Meet the model where it writes: a palette either way round, a row separator it can type, several conversions in one call, and a date unit that defaults

.gitignore

@@ -1,4 +1,6 @@
 __pycache__/
+.pytest_cache/
+.ruff_cache/
 *.py[cod]
 .env
 .DS_Store

distinct_skills/handlers.py

@@ -312,7 +312,8 @@ def csv_table(arguments: Mapping[str, object], skill: SkillDefinition) -> dict[s
         raise SkillInputError(
             "text needs a header line and at least one row, each on its own line. "
             "Put a real line break between rows, like "
-            "\"name|qty|aisle\\nflour|500 g|baking\""
+            "\"name|qty|aisle\\nflour|500 g|baking\". "
+            "If you cannot write a line break, separate the rows with ' // ' instead."
         )
     if len(lines) > MAX_TABLE_ROWS + 1:
         raise SkillInputError(f"text must contain at most {MAX_TABLE_ROWS} rows")
@@ -371,6 +372,37 @@ def csv_table(arguments: Mapping[str, object], skill: SkillDefinition) -> dict[s
 # --------------------------------------------------------------------------
 
 
+#: A colour value, with or without the hash a model forgets.
+_HEX = re.compile(r"#?[0-9A-Fa-f]{3,8}")
+
+
+def _read_colour_line(line: str) -> tuple[str, str, str]:
+    """One palette line as ``(name, #hex, problem)``, however it was written.
+
+    "#121212: background" is the same palette entry as "background: #121212",
+    and refusing it lost a whole stylesheet three calls running. So whichever
+    half is a colour is the colour and the other half is the name, the hash is
+    added when it was left off, and a line with no colour in it at all is the
+    only one that comes back as a problem.
+    """
+
+    left, separator, right = line.partition(":")
+    if not separator:
+        left, _, right = line.partition(" ")
+    parts = [part.strip() for part in (left, right) if part.strip()]
+    if not parts:
+        return "", "", f"{line!r}: nothing to read"
+
+    value = next((part for part in parts if _HEX.fullmatch(part)), "")
+    if not value:
+        return "", "", f"{line!r}: no #hex colour in this line"
+    name = next((part for part in parts if part != value), "")
+    name = re.sub(r"[\s_]+", "-", name.lower()).strip("-")
+    if name and not re.fullmatch(r"[a-z][a-z0-9-]{0,30}", name):
+        return "", "", f"{name!r}: not a usable colour name"
+    return name, value if value.startswith("#") else f"#{value}", ""
+
+
 def unescape_line_breaks(text: str) -> str:
     """Treat a literal backslash-n as the line break the caller meant.
 
@@ -392,7 +424,17 @@ def unescape_line_breaks(text: str) -> str:
 
     if "\n" in text or "\r" in text:
         return text
-    return text.replace("\\r\\n", "\n").replace("\\n", "\n")
+    unescaped = text.replace("\\r\\n", "\n").replace("\\n", "\n")
+    if "\n" in unescaped:
+        return unescaped
+    # STILL ONE LINE. A model held to a JSON grammar has to emit a two-
+    # character escape to get a line break, and some of them simply will not.
+    # " // " is offered in the refusal message as the way out, cannot appear in
+    # a well-formed row of a pipe-separated table, and is only ever consulted
+    # for a text that has no line breaks at all -- which is a text this tool
+    # was about to refuse outright. So it can rescue a table and cannot damage
+    # one.
+    return unescaped.replace(" // ", "\n") if " // " in unescaped else unescaped
 
 
 def fit_row(cells: list[str], width: int, number: int) -> tuple[list[str], str]:
@@ -518,7 +560,8 @@ def _rows_from_text(arguments: Mapping[str, object]) -> tuple[list[list[str]], l
         raise SkillInputError(
             "text needs a header line and at least one row, each on its own line. "
             "Put a real line break between rows, like "
-            "\"name|qty|aisle\\nflour|500 g|baking\""
+            "\"name|qty|aisle\\nflour|500 g|baking\". "
+            "If you cannot write a line break, separate the rows with ' // ' instead."
         )
     rows = [[cell.strip() for cell in line.split(separator)] for line in lines]
     width = len(rows[0])
@@ -1016,25 +1059,22 @@ def theme_css(arguments: Mapping[str, object], skill: SkillDefinition) -> dict[s
     # table rows: adjust, never silently.
     variables = []
     skipped: list[str] = []
+    unnamed = 0
     for line in colors_text.splitlines():
         line = line.strip()
         if not line:
             continue
-        key, _, value = line.partition(":")
-        key = re.sub(r"[\s_]+", "-", key.strip().lower()).strip("-")
-        value = value.strip()
-        if not re.fullmatch(r"#[0-9A-Fa-f]{3,8}", value) and re.fullmatch(
-            r"[0-9A-Fa-f]{6}|[0-9A-Fa-f]{3}", value
-        ):
-            # A hex value with the hash left off is the commonest near-miss and
-            # is unambiguous, so it is completed rather than discarded.
-            value = f"#{value}"
-        if not re.fullmatch(r"[a-z][a-z0-9-]{0,30}", key):
-            skipped.append(f"{key or line!r}: not a usable colour name")
-            continue
-        if not re.fullmatch(r"#[0-9A-Fa-f]{3,8}", value):
-            skipped.append(f"{key}: {value!r} is not a #hex value")
+        key, value, note = _read_colour_line(line)
+        if note:
+            skipped.append(note)
             continue
+        if not key:
+            # A bare hex with no name at all. Naming it positionally invents a
+            # token name and nothing else, which is disclosed below, and is a
+            # better outcome than a stylesheet nobody gets.
+            unnamed += 1
+            key = f"colour-{unnamed}"
+            skipped.append(f"{value} had no name and was called --{key}")
         variables.append(f"  --{key}: {value};")
     if not variables:
         raise SkillInputError(

distinct_tools/local.py

@@ -521,28 +521,63 @@ CONVERT_UNITS_SPEC = ToolSpec(
         "Both units must measure the same kind of thing; converting kilograms to metres "
         "is refused rather than guessed. "
         "Do not use it for plain arithmetic (use calculate) or for date arithmetic "
-        "(use calculate_date). One call gives the exact answer, so do not repeat it."
+        "(use calculate_date). One call gives the exact answer, so do not repeat it. "
+        "To convert several quantities, put them all in `conversions` in ONE call "
+        "rather than calling this tool once per quantity."
     ),
     required_hosts=frozenset(),
     input_schema={
         "type": "object",
         "additionalProperties": False,
-        "required": ["value", "from_unit", "to_unit"],
         "properties": {
             "value": {"type": "number", "description": "The quantity to convert."},
             "from_unit": {"type": "string", "enum": list(_ALL_UNITS)},
             "to_unit": {"type": "string", "enum": list(_ALL_UNITS)},
+            "conversions": {
+                "type": "array",
+                "description": "Several conversions at once, instead of value/from_unit/to_unit.",
+                "items": {
+                    "type": "object",
+                    "additionalProperties": False,
+                    "required": ["value", "from_unit", "to_unit"],
+                    "properties": {
+                        "value": {"type": "number"},
+                        "from_unit": {"type": "string", "enum": list(_ALL_UNITS)},
+                        "to_unit": {"type": "string", "enum": list(_ALL_UNITS)},
+                    },
+                },
+            },
         },
     },
 )
 
+#: How many conversions one call may carry. Generous for any real request and
+#: still a bound, because a list is a way to ask for arbitrary work in one go.
+MAX_CONVERSIONS = 24
+
 
 def convert_units_handler(
     arguments: Mapping[str, object], context: ToolContext
 ) -> dict[str, object]:
-    """Convert between units of the same dimension, exactly where possible."""
+    """Convert between units of the same dimension, exactly where possible.
+
+    SIX CONVERSIONS ASKED FOR AT ONCE WERE SIX CALLS, AND THE MODEL STOPPED
+    AFTER THREE.
 
-    _reject_unknown(arguments, frozenset({"value", "from_unit", "to_unit"}))
+    "Convert these six quantities" is one request, and making it six calls put
+    the burden of remembering how many were left on the part of the system
+    least able to carry it. A benchmark workload failed that way every time:
+    three conversions done correctly, the other three simply never attempted,
+    and an answer confidently presenting half the list. Accepting the list in
+    one call moves the counting to code, which can count.
+
+    The single form is untouched, so nothing that worked before changes.
+    """
+
+    _reject_unknown(arguments, frozenset({"value", "from_unit", "to_unit", "conversions"}))
+    listed = arguments.get("conversions")
+    if listed is not None:
+        return _convert_many(listed, context)
     raw = arguments.get("value")
     if isinstance(raw, bool) or not isinstance(raw, int | float):
         raise ToolInputError("value must be a number")
@@ -600,6 +635,37 @@ def convert_units_handler(
     }
 
 
+def _convert_many(listed: object, context: ToolContext) -> dict[str, object]:
+    """Every conversion in the list, or a refusal naming the one that failed.
+
+    One bad entry does not lose the others: each carries its own answer or its
+    own reason, in the order they were asked for, so a model reading the result
+    can fix the one it got wrong rather than starting again.
+    """
+
+    if not isinstance(listed, list | tuple) or not listed:
+        raise ToolInputError("conversions must be a non-empty list")
+    if len(listed) > MAX_CONVERSIONS:
+        raise ToolInputError(f"conversions may contain at most {MAX_CONVERSIONS} entries")
+    results: list[dict[str, object]] = []
+    for index, entry in enumerate(listed, start=1):
+        if not isinstance(entry, Mapping):
+            results.append({"position": index, "error": "each conversion must be an object"})
+            continue
+        try:
+            answer = convert_units_handler(dict(entry), context)
+        except ToolInputError as exc:
+            results.append({"position": index, "error": str(exc)})
+            continue
+        answer["position"] = index
+        results.append(answer)
+    return {
+        "conversions": results,
+        "converted": sum(1 for item in results if "result" in item),
+        "refused": sum(1 for item in results if "error" in item),
+    }
+
+
 # --------------------------------------------------------------------------
 # calculate_date
 # --------------------------------------------------------------------------
@@ -696,7 +762,18 @@ def calculate_date_handler(
         raise ToolInputError("amount must be a whole number for operation='add'")
     if not -400_000 <= amount <= 400_000:
         raise ToolInputError("amount must be between -400000 and 400000")
-    unit = _require_choice(arguments, "unit", _DATE_UNITS)
+    # AN OPTIONAL ARGUMENT THAT IS REQUIRED IN PRACTICE IS A TRAP.
+    #
+    # ``unit`` is not in the schema's ``required`` list, so a model reading the
+    # schema leaves it out -- and then "add 45 to this date" was refused with
+    # "unit must be a string", which reads like the model sent the wrong type
+    # rather than nothing at all. Days is what "add 45" means to everybody, so
+    # it is the default, and the answer says which unit it used either way.
+    unit = (
+        _require_choice(arguments, "unit", _DATE_UNITS)
+        if arguments.get("unit") is not None
+        else "days"
+    )
     try:
         result = date + _datetime.timedelta(days=amount * _DATE_UNITS[unit])
     except (OverflowError, ValueError) as exc:

tests/test_ragged_rows_still_make_a_table.py

@@ -154,7 +154,31 @@ def test_a_colour_that_cannot_be_read_is_skipped_and_named() -> None:
     sheet, skipped = _theme("primary: #1a1a2e\naccent: rgb(20,20,30)")
     assert "--primary: #1a1a2e;" in sheet
     assert "--accent" not in sheet
-    assert skipped and "accent" in skipped[0]
+    assert skipped and "rgb" in skipped[0]
+
+
+def test_a_palette_written_hex_first_is_read_the_right_way_round() -> None:
+    """"#121212: background" lost a whole stylesheet, three calls running."""
+
+    sheet, skipped = _theme("#121212: background\n#3e8e56: accent")
+    assert "--background: #121212;" in sheet
+    assert "--accent: #3e8e56;" in sheet
+    assert skipped == []
+
+
+def test_a_palette_written_without_a_colon_is_still_read() -> None:
+    sheet, _skipped = _theme("background #121212\naccent #3e8e56")
+    assert "--background: #121212;" in sheet
+    assert "--accent: #3e8e56;" in sheet
+
+
+def test_a_bare_hex_gets_a_positional_name_and_the_naming_is_disclosed() -> None:
+    """Naming an unnamed thing is not inventing data, but it is still declared."""
+
+    sheet, skipped = _theme("#121212\n#3e8e56")
+    assert "--colour-1: #121212;" in sheet
+    assert "--colour-2: #3e8e56;" in sheet
+    assert len(skipped) == 2 and "had no name" in skipped[0]
 
 
 def test_a_palette_with_nothing_usable_is_still_refused() -> None:
@@ -212,3 +236,130 @@ def test_the_spreadsheet_accepts_the_same_one_line_form() -> None:
 
     result = spreadsheet_xlsx({"text": "a|b\\n1|2\\n3|4"}, None)
     assert result["artifact"]["size_bytes"] > 0
+
+
+def test_rows_can_be_separated_the_way_the_refusal_offers() -> None:
+    """A model held to a JSON grammar sometimes will not emit a line break."""
+
+    text, adjusted = _csv("name|qty|aisle // flour|500 g|baking // salt|10 g|baking")
+    assert "flour,500 g,baking" in text
+    assert "salt,10 g,baking" in text
+    assert adjusted == []
+
+
+def test_the_offered_separator_is_only_consulted_when_there_are_no_line_breaks() -> None:
+    """It can rescue a table this tool was about to refuse; it cannot damage one."""
+
+    from distinct_skills.handlers import unescape_line_breaks
+
+    assert unescape_line_breaks("a // b\nc // d") == "a // b\nc // d"
+
+
+def test_the_refusal_names_that_way_out() -> None:
+    from distinct_skills.handlers import csv_table
+
+    with pytest.raises(SkillInputError, match=r"' // '"):
+        csv_table({"text": "one line, no rows"}, None)
+
+
+# -- an optional argument that was required in practice ----------------------
+
+
+def test_adding_to_a_date_without_naming_a_unit_means_days() -> None:
+    """"unit must be a string" read as a wrong type when nothing had been sent."""
+
+    from distinct_tools.local import calculate_date_handler
+
+    answer = calculate_date_handler(
+        {"operation": "add", "date": "2026-03-03", "amount": 45}, None
+    )
+    assert answer["result"] == "2026-04-17"
+    assert answer["unit"] == "days"
+
+
+def test_a_unit_that_is_given_is_still_honoured() -> None:
+    from distinct_tools.local import calculate_date_handler
+
+    answer = calculate_date_handler(
+        {"operation": "add", "date": "2026-03-03", "amount": 2, "unit": "weeks"}, None
+    )
+    assert answer["result"] == "2026-03-17"
+
+
+def test_a_unit_that_is_not_a_unit_is_still_refused() -> None:
+    from distinct_tools.core import ToolInputError
+    from distinct_tools.local import calculate_date_handler
+
+    with pytest.raises(ToolInputError):
+        calculate_date_handler(
+            {"operation": "add", "date": "2026-03-03", "amount": 2, "unit": "fortnights"}, None
+        )
+
+
+# -- several things asked for at once ----------------------------------------
+
+
+def _convert(arguments):
+    from distinct_tools.local import convert_units_handler
+
+    return convert_units_handler(arguments, None)
+
+
+def test_six_conversions_are_one_call_and_all_six_are_done() -> None:
+    """The model did three and stopped. Counting is code's job, not the model's."""
+
+    answer = _convert(
+        {
+            "conversions": [
+                {"value": n, "from_unit": "lb", "to_unit": "kg"} for n in range(1, 7)
+            ]
+        }
+    )
+    assert answer["converted"] == 6
+    assert answer["refused"] == 0
+    assert [item["position"] for item in answer["conversions"]] == [1, 2, 3, 4, 5, 6]
+
+
+def test_one_bad_entry_does_not_lose_the_others() -> None:
+    answer = _convert(
+        {
+            "conversions": [
+                {"value": 140, "from_unit": "lb", "to_unit": "kg"},
+                {"value": 3, "from_unit": "kg", "to_unit": "m"},
+                {"value": 5, "from_unit": "mi", "to_unit": "km"},
+            ]
+        }
+    )
+    assert answer["converted"] == 2
+    assert answer["refused"] == 1
+    assert "different things" in answer["conversions"][1]["error"]
+
+
+def test_the_single_form_is_untouched() -> None:
+    """Nothing that worked before changes."""
+
+    answer = _convert({"value": 140, "from_unit": "lb", "to_unit": "kg"})
+    assert answer["result"] == "63.5029318"
+    assert "conversions" not in answer
+
+
+def test_an_empty_list_is_refused_rather_than_answered_with_nothing() -> None:
+    from distinct_tools.core import ToolInputError
+
+    with pytest.raises(ToolInputError):
+        _convert({"conversions": []})
+
+
+def test_a_list_longer_than_the_ceiling_is_refused() -> None:
+    from distinct_tools.core import ToolInputError
+    from distinct_tools.local import MAX_CONVERSIONS
+
+    with pytest.raises(ToolInputError):
+        _convert(
+            {
+                "conversions": [
+                    {"value": 1, "from_unit": "lb", "to_unit": "kg"}
+                ]
+                * (MAX_CONVERSIONS + 1)
+            }
+        )