coderouter-cli 2.11.0__py3-none-any.whl → 2.11.1__py3-none-any.whl

coderouter/translation/tool_repair.py

@@ -90,12 +90,28 @@ from __future__ import annotations
 
 import contextlib
 import json
+import logging
 import re
 import uuid
+from array import array
 from typing import Any
 
 __all__ = ["deduplicate_tool_calls", "repair_tool_calls_in_text"]
 
+# Plain stdlib logger (same idiom as coderouter/translation/anthropic.py).
+# This module is deliberately import-free of the rest of the package:
+# benchmarks/tool-repair/run_offline.py loads it straight from its source
+# path, with no `coderouter` package on sys.path.
+logger = logging.getLogger(__name__)
+
+# Hard ceiling on the text handed to the bare-JSON brace scanners. The
+# scanners themselves are linear, but every candidate they emit still costs a
+# JSON parse attempt plus a prose-cue check, and an assistant message this
+# large is never a tool call anyway. Above the limit the bare-JSON step is
+# skipped outright; the fenced / XML / R4a / R4c paths are regex-driven and
+# linear, so they keep running.
+_MAX_BARE_SCAN_CHARS = 262_144
+
 
 # ------------------------------------------------------------------
 # R2: shape detection + normalisation (with key aliases)
@@ -528,6 +544,139 @@ def _in_spans(pos: int, spans: list[tuple[int, int]]) -> bool:
     return any(start <= pos < end for start, end in spans)
 
 
+# ------------------------------------------------------------------
+# Brace scanning (bare-JSON candidate discovery)
+#
+# Both scanners below answer the same question for every ``{`` in the text:
+# "does a *fresh* scan started right here reach a balanced close?".  The
+# obvious implementation re-scans to end-of-text once per ``{``, which is
+# O(k*n) for k unclosed braces — a 48 KB assistant message full of stray
+# braces took ~20 s, and because ``to_anthropic_response`` is called from the
+# request path that stalled the whole server.
+#
+# Instead we precompute, in ONE right-to-left sweep, a table that answers
+# "starting at offset j outside any string, where is the first ``}`` that is
+# still at brace depth 0?".  The closing brace of a ``{`` at offset q is then
+# simply ``table[q + 1]``, so the driver below is a plain left-to-right walk
+# and the whole scan is linear in the length of the text.
+#
+# The table is defined by a right-to-left recurrence over the scanner's state
+# machine (outside a string / inside a string / previous char was a
+# backslash).  Only the "outside a string" row needs random access — the ``{``
+# case has to jump over the nested object it just resolved — so the
+# in-string rows are carried as rolling scalars instead of arrays.
+# ------------------------------------------------------------------
+
+
+def _scan_object_spans(text: str, close_table: array[int]) -> list[tuple[int, int, str]]:
+    """Walk ``text`` left to right emitting balanced ``{...}`` spans.
+
+    ``close_table`` comes from :func:`_strict_close_table` or
+    :func:`_lenient_close_table` and supplies, for each offset, the index of
+    the first depth-0 ``}`` at or after it (``-1`` when there is none). The
+    driver is shared; the flavour lives entirely in the table.
+
+    Returns (start, end_exclusive, substring) triples. See the two callers'
+    docstrings for the (deliberate, load-bearing) return-value contract.
+    """
+    out: list[tuple[int, int, str]] = []
+    n = len(text)
+    i = 0
+    while i < n:
+        start = text.find("{", i)
+        if start < 0:
+            break
+        close = close_table[start + 1]
+        if close < 0:
+            # Never closes — drop this `{` and resume at the next one. The
+            # restart deliberately begins from a clean "outside a string"
+            # state (see the contract note in the callers).
+            i = start + 1
+            continue
+        out.append((start, close + 1, text[start : close + 1]))
+        i = close + 1
+    return out
+
+
+def _strict_close_table(text: str) -> array[int]:
+    """Depth-0 close-brace lookup table with *strict* JSON string rules.
+
+    ``table[j]`` is the offset of the first ``}`` that a scanner starting at
+    ``j`` — outside any string literal, at brace depth 0 — would reach while
+    still at depth 0, or ``-1`` if it runs off the end. Only ``"`` opens a
+    string; ``\\`` escapes the next character inside one.
+
+    Built in a single right-to-left sweep, so building plus scanning is
+    O(len(text)) regardless of how many unbalanced braces the text contains.
+    """
+    n = len(text)
+    outside = array("i", [-1]) * (n + 1)
+    in_str = -1  # answer when the scan *enters* offset j+1 inside a "..."
+    escaped = -1  # ... inside a "..." with the previous char a backslash
+    for j in range(n - 1, -1, -1):
+        c = text[j]
+        nxt_outside = outside[j + 1]
+        nxt_in_str = in_str
+        nxt_escaped = escaped
+        # Escaped char: consumed verbatim, then we are back inside the string.
+        escaped = nxt_in_str
+        # Inside a string literal.
+        if c == "\\":
+            in_str = nxt_escaped
+        elif c == '"':
+            in_str = nxt_outside
+        else:
+            in_str = nxt_in_str
+        # Outside any string literal.
+        if c == '"':
+            outside[j] = nxt_in_str
+        elif c == "{":
+            inner = nxt_outside  # close of the nested object opening at j
+            outside[j] = -1 if inner < 0 else outside[inner + 1]
+        elif c == "}":
+            outside[j] = j
+        else:
+            outside[j] = nxt_outside
+    return outside
+
+
+def _lenient_close_table(text: str) -> array[int]:
+    """Depth-0 close-brace lookup table tolerating single-quoted strings.
+
+    Same contract as :func:`_strict_close_table`, but BOTH ``'`` and ``"``
+    open a string literal (and only the matching quote closes it), which is
+    what the lenient pass needs to survive Python-repr / single-quoted
+    malformed objects. Five scanner states instead of three; again only the
+    "outside a string" row needs to be materialised as an array.
+    """
+    n = len(text)
+    outside = array("i", [-1]) * (n + 1)
+    in_sq = in_dq = esc_sq = esc_dq = -1
+    for j in range(n - 1, -1, -1):
+        c = text[j]
+        nxt_outside = outside[j + 1]
+        nxt_in_sq, nxt_in_dq = in_sq, in_dq
+        nxt_esc_sq, nxt_esc_dq = esc_sq, esc_dq
+        esc_sq, esc_dq = nxt_in_sq, nxt_in_dq
+        if c == "\\":
+            in_sq, in_dq = nxt_esc_sq, nxt_esc_dq
+        else:
+            in_sq = nxt_outside if c == "'" else nxt_in_sq
+            in_dq = nxt_outside if c == '"' else nxt_in_dq
+        if c == "'":
+            outside[j] = nxt_in_sq
+        elif c == '"':
+            outside[j] = nxt_in_dq
+        elif c == "{":
+            inner = nxt_outside
+            outside[j] = -1 if inner < 0 else outside[inner + 1]
+        elif c == "}":
+            outside[j] = j
+        else:
+            outside[j] = nxt_outside
+    return outside
+
+
 def _find_balanced_json_objects(text: str) -> list[tuple[int, int, str]]:
     """Find top-level `{...}` JSON substrings by a brace-counter scan.
 
@@ -539,45 +688,27 @@ def _find_balanced_json_objects(text: str) -> list[tuple[int, int, str]]:
     brace balancing. Single-quoted / unquoted malformed objects are found by
     :func:`_find_candidate_object_spans` instead, which brace-balances without
     assuming JSON string syntax.
+
+    Return-value contract (load-bearing — downstream recall depends on all
+    three; do NOT "simplify" this into a single global stack pass):
+
+    1. **Top-level objects only.** Once a ``{`` closes, the scan resumes after
+       its ``}``, so objects nested inside a *closed* object are not returned.
+       ``'{"a": {"b": 1}}'`` yields the outer object alone.
+    2. **Nested objects surface when the outer never closes.** An unbalanced
+       ``{`` is dropped and the scan restarts at the next ``{``, so
+       ``'{"a": {"b":1}'`` yields ``[(6, 13, '{"b":1}')]`` — the inner
+       object is still repairable even though the outer one is broken.
+    3. **Every restart begins with a fresh string state.** The scan between
+       candidates does not track quotes, so a stray/unbalanced quote before a
+       ``{`` cannot swallow it. This is what keeps prose apostrophes
+       (``"I'll call the tool now."``) and quoted braces (``'{ "z{}" '`` ->
+       ``[(4, 6, '{}')]``) from hiding a real call. A single global pass that
+       carried string state across candidates loses both.
     """
-    out: list[tuple[int, int, str]] = []
-    n = len(text)
-    i = 0
-    while i < n:
-        if text[i] != "{":
-            i += 1
-            continue
-        # Scan forward to find a balanced close.
-        depth = 0
-        j = i
-        in_str = False
-        escape = False
-        while j < n:
-            c = text[j]
-            if escape:
-                escape = False
-            elif in_str:
-                if c == "\\":
-                    escape = True
-                elif c == '"':
-                    in_str = False
-            else:
-                if c == '"':
-                    in_str = True
-                elif c == "{":
-                    depth += 1
-                elif c == "}":
-                    depth -= 1
-                    if depth == 0:
-                        out.append((i, j + 1, text[i : j + 1]))
-                        i = j + 1
-                        break
-            j += 1
-        else:
-            # Ran off the end without closing — skip this `{` and move on.
-            i += 1
-            continue
-    return out
+    if "{" not in text:
+        return []
+    return _scan_object_spans(text, _strict_close_table(text))
 
 
 def _find_candidate_object_spans(text: str) -> list[tuple[int, int, str]]:
@@ -587,43 +718,17 @@ def _find_candidate_object_spans(text: str) -> list[tuple[int, int, str]]:
     respecting BOTH ``'`` and ``"`` string delimiters, so it can locate
     Python-repr / single-quoted malformed objects for the lenient parser.
     Returns (start, end_exclusive, substring).
+
+    The same three-point return-value contract documented on
+    :func:`_find_balanced_json_objects` applies here: top-level objects only,
+    nested objects surface when the outer never closes, and every restart
+    begins from a fresh string state. Point 3 matters most on this flavour —
+    ``'`` opens a string here, so carrying state across candidates would let
+    an ordinary prose apostrophe swallow every following object.
     """
-    out: list[tuple[int, int, str]] = []
-    n = len(text)
-    i = 0
-    while i < n:
-        if text[i] != "{":
-            i += 1
-            continue
-        depth = 0
-        j = i
-        quote: str | None = None
-        escape = False
-        while j < n:
-            c = text[j]
-            if escape:
-                escape = False
-            elif quote is not None:
-                if c == "\\":
-                    escape = True
-                elif c == quote:
-                    quote = None
-            else:
-                if c == '"' or c == "'":
-                    quote = c
-                elif c == "{":
-                    depth += 1
-                elif c == "}":
-                    depth -= 1
-                    if depth == 0:
-                        out.append((i, j + 1, text[i : j + 1]))
-                        i = j + 1
-                        break
-            j += 1
-        else:
-            i += 1
-            continue
-    return out
+    if "{" not in text:
+        return []
+    return _scan_object_spans(text, _lenient_close_table(text))
 
 
 # ------------------------------------------------------------------
@@ -1405,12 +1510,24 @@ def repair_tool_calls_in_text(
     #    Skip anything inside a protected code fence or introduced by a prose
     #    example cue. Walk back-to-front so slicing removals don't shift the
     #    indices of earlier matches.
+    #    Oversized inputs skip this step entirely (see _MAX_BARE_SCAN_CHARS):
+    #    the per-candidate JSON parsing / cue checking is the expensive part
+    #    and a message that large is not a tool call. Steps 1/2/2b/2c above
+    #    are regex-driven and linear, so they are NOT skipped.
     protected = _protected_code_spans(cleaned)
     spans_to_remove: list[tuple[int, int]] = []
     repaired_from_bare: list[dict[str, Any]] = []
 
+    strict_spans: list[tuple[int, int, str]] = []
+    lenient_spans: list[tuple[int, int, str]] = []
+    if len(cleaned) > _MAX_BARE_SCAN_CHARS:
+        logger.warning("tool-repair-input-too-large", extra={"chars": len(cleaned)})
+    else:
+        strict_spans = _find_balanced_json_objects(cleaned)
+        lenient_spans = _find_candidate_object_spans(cleaned)
+
     # First pass: strict-JSON balanced objects.
-    for start, end, substr in _find_balanced_json_objects(cleaned):
+    for start, end, substr in strict_spans:
         if _in_spans(start, protected):
             continue
         if _preceded_by_prose_cue(cleaned, start):
@@ -1436,7 +1553,7 @@ def repair_tool_calls_in_text(
 
     # Second pass: lenient objects (single-quoted / unquoted / trailing comma /
     # double-brace) that strict parsing missed. Skip spans already claimed.
-    for start, end, substr in _find_candidate_object_spans(cleaned):
+    for start, end, substr in lenient_spans:
         if _in_spans(start, spans_to_remove):
             continue
         if _in_spans(start, protected):

{coderouter_cli-2.11.0.dist-info → coderouter_cli-2.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.11.0
+Version: 2.11.1
 Summary: Local-first, free-first, fallback-built-in LLM router. Claude Code / OpenAI compatible.
 Project-URL: Homepage, https://github.com/zephel01/CodeRouter
 Project-URL: Repository, https://github.com/zephel01/CodeRouter

{coderouter_cli-2.11.0.dist-info → coderouter_cli-2.11.1.dist-info}/RECORD

@@ -1,16 +1,16 @@
 coderouter/__init__.py,sha256=ghdjPrLtnRzY8fyQ4CJZI1UJKADyNTLtA3G7se8H7Ns,696
 coderouter/__main__.py,sha256=-LCgxJnvgUV240HjQKv7ly-mn2NuKHpC4nCpvTHjeSU,130
-coderouter/cli.py,sha256=rEo-G9fyIBXnRWmVCHxWBlfzII2CWMcFvhRJW5h2oBU,34650
+coderouter/cli.py,sha256=2g-0HILLM16mNnkFUOR6lWXy5f6Y0LipCjo_YH4--j0,36896
 coderouter/cli_stats.py,sha256=CCjzc1G4hTRHZ2gG1XhxhDpUkJnnl3NXbcbp1T18jpg,29894
 coderouter/cost.py,sha256=32h6uzb4nxh2eA5d2Hn3kD9yJbtis6CFDAbeIy5KRkM,7431
-coderouter/doctor.py,sha256=x0OqWUMGPzYaX2poWSH2UA90sEr4Z69-gVYLXYQFCFU,85483
-coderouter/doctor_apply.py,sha256=r_J6xbu5-HivofPNriw4_vjNYs_VRs7GsGTS0oMEX10,24209
+coderouter/doctor.py,sha256=wmPunlvqm2s7x3VGLjexqHPLD2oejwE3Mu04V8y-xn4,89869
+coderouter/doctor_apply.py,sha256=UqRvzRqENHWqsL3OCsuSotNdxCMw5rP2LnCWMBLmZow,28033
 coderouter/env_security.py,sha256=FEBZnXfJ0xE39kmMMn39zk0W_DRRnmcB_REmP9f4xWo,14796
 coderouter/errors.py,sha256=Xmq67lheyw8iv3Ox39jh2c4tvNI5RcUR4QkoxVDN6l4,1130
-coderouter/gguf_introspect.py,sha256=KeE00CfbYRa4gSTrzuwC6zVuHi20IzLC4nUQa98BEXI,10387
+coderouter/gguf_introspect.py,sha256=Scu0JjUfLHj7T7TL0HQIm1AZcGYrXsjkaMMSN9HkTro,16121
 coderouter/hardware.py,sha256=gn3_9qbVcGRR81yKMn1lJE_8-YDRau0LxIH_M-f7pxE,8356
 coderouter/language_tax.py,sha256=LTbE3tIfoJuV2O3T0NixRKhzq_dEOTUuPEerJv2q9uk,9360
-coderouter/launcher_devices.py,sha256=_5R7dA8tHEhwLn9VkXccLEXPJREfpHu90nYd6-cm8Xs,28180
+coderouter/launcher_devices.py,sha256=Jd2hVJMsQZ0x6YFc_2ROvEc2L10b6dh77Y-gvP_Po8M,29039
 coderouter/launcher_speculative.py,sha256=h0RTGsD1Y56sJVywDJwybrT75_Ta3GF1Jz_B1d42aPg,12931
 coderouter/launcher_swap.py,sha256=tMW5ZElDdf9T1VQGsUkvfLiSCdj_oXN_UtkV7DE8ySY,24175
 coderouter/logging.py,sha256=5rfi4_R4aoeeUYDc642dgs61wA0aBX7wvubyB-k3Uyo,58074
@@ -19,15 +19,15 @@ coderouter/token_estimation.py,sha256=iz22vZEEW2P7uKLB2pYvPNpIbZGbgXRO5MtfkS_-9S
 coderouter/token_estimation_accurate.py,sha256=GTfzrBVnvAGjeVzmzAeUdOYZvWZKLAxcxPpFiJGlzjk,4609
 coderouter/vscode_init.py,sha256=ATQ1FzeQRAXfBBNcPwpEHRP4l4Yjn4hYgE-TjkcVvck,20034
 coderouter/adapters/__init__.py,sha256=7dIDSZ-FE_0iSqLSDc_lK1idRdLTKcM2hP9tCJipgPI,463
-coderouter/adapters/anthropic_native.py,sha256=CT9Hitun-c3z83YHT2zZXgwZpY3_t6eRnOfAmNud2aw,23610
+coderouter/adapters/anthropic_native.py,sha256=-FGTQFlFL5Z2IZms4NUGPcNkIN-fVvQrCY8e8nxW17s,24777
 coderouter/adapters/base.py,sha256=ykKMaiIVVGr23oFFXilK2iP_YhI8-CtsEiJyFXaC9bE,10396
 coderouter/adapters/openai_compat.py,sha256=wcrd_UpV7N6ISpUyKvdFPGU-YjCrX5oMqGpjAFEeWfg,20356
 coderouter/adapters/registry.py,sha256=XNc1wmFv_oZlqKS0rA693TRDdbq1sZ-OIcofXOVOtq0,3680
 coderouter/config/__init__.py,sha256=FODEn74fN-qZnt4INPSHswqhOlEgpL6-_onxsitSx8g,274
 coderouter/config/capability_registry.py,sha256=RZgzHF54dXy0CCDocRCz2ee21qXGbbgTSKTkRI9iLL4,16936
 coderouter/config/env_file.py,sha256=CoMK27fuAXm-NtoLzXb8yN2E-wDFjHQuFwiIlmgTBQw,10356
-coderouter/config/loader.py,sha256=FUEe8m4Tnmj_aul0vSctD8vKvNW-oLRoMRbTpSKqSmc,4077
-coderouter/config/schemas.py,sha256=nPwaG4uIdhqoOs74nay4fPTNvEHxpsx7RhqFTZzBX-E,127468
+coderouter/config/loader.py,sha256=jUoHAbEyjK6Y0HDqhjXHO4tfncMPuzsjfWJokrPb2x8,6876
+coderouter/config/schemas.py,sha256=8MZMW3Iask-ZvkWV2b77UYszqMgJ4ETc6gEU80Ekx9g,131685
 coderouter/data/__init__.py,sha256=uNyfD9jaCvTWsBAWtaw1Fr25OSxzv3psGMfBjT1z0Cc,328
 coderouter/data/model-capabilities.yaml,sha256=S9jt6SC6-3s2-icZ_n-a14iEMnc2yB1C2R6q-N_tZWQ,19309
 coderouter/guards/__init__.py,sha256=5qliYBqygvVPneej7nx0uSjxDKsz7t8VzvrDgVBJlvU,1170
@@ -36,7 +36,7 @@ coderouter/guards/backend_health.py,sha256=GLUVQ5BhU6i8Cxz_FrgIMs5AZ-YSKAW8veFWg
 coderouter/guards/context_budget.py,sha256=6u08JqBdRQkDz9NIQ-aISXo3w3L804oYFg027s04IwY,17202
 coderouter/guards/continuous_probe.py,sha256=WIfS-apVMWXGv7bPBxxkJssePa95I4fT0mi4PNqK5iE,12181
 coderouter/guards/drift_actions.py,sha256=A6pY5CR480Ct5rCVyjlBvjPFVc93eu_r5qcUpK9mWKc,3602
-coderouter/guards/drift_detection.py,sha256=vlepNw_GjvmpHZHTkMS5JM7XKxHaRxzjj_GfopRa1M0,13489
+coderouter/guards/drift_detection.py,sha256=lW45EZDGRleDUTstw_CHlfUiwLUrlDHX8g7ncuOYNEw,13962
 coderouter/guards/memory_budget.py,sha256=_bRtusk4AwrU781wVXW32OFU7zD2FXxOwTb7yGqPJqA,8278
 coderouter/guards/memory_pressure.py,sha256=9Xm-b7rv9Td5kPNmAFoL3sNmaOR5zT8NLdn6erWcuyY,8719
 coderouter/guards/self_healing.py,sha256=Qene73S1kqMJn8HYzHO-WT8hhWxKbo2v_JtXtEgpCp8,14434
@@ -45,7 +45,7 @@ coderouter/ingress/__init__.py,sha256=WQsCH2CGJCAhy0mS6GSEdeYZRkkQu2OHDsP4CJWTLu
 coderouter/ingress/anthropic_routes.py,sha256=1ThXzx8VgxRV7UCi3NF5ey7kbr0ADPKTXyQuYS5gK1w,27063
 coderouter/ingress/app.py,sha256=6e_qNlYZIyjLKhY20t0ZNL-x5Fv8R8oaIH_HCdxa9Ic,20921
 coderouter/ingress/dashboard_routes.py,sha256=1SqNNrVTfQiZcx5n2MvjAzWirittX0e61tCt-MKp4Ag,25617
-coderouter/ingress/launcher_routes.py,sha256=CGD_Uq8jz1qwFPQD-HXfHdB7-nD1rvPaHkpXzmTzB1w,133287
+coderouter/ingress/launcher_routes.py,sha256=g-0Mee1vpY10b82jI51-2fTeR8hxutMCaLYBcicwM_k,133287
 coderouter/ingress/metrics_routes.py,sha256=M22dwOGn24P05Ge4W3c7d7mYytSGWjIR-pPSPOAiHJY,3965
 coderouter/ingress/openai_routes.py,sha256=TrugsQNJfNPgKKLzfT1aXzrs4emWYGE4XebEBuaZoWk,12505
 coderouter/metrics/__init__.py,sha256=7Es351DPS7yLM0yVF_F0eesmiD83n7Zzhie44chht38,1465
@@ -60,7 +60,7 @@ coderouter/routing/adaptive.py,sha256=G2o377twGSjbUh65wiIFx6klnpFGjsD_nI3oDvcBwh
 coderouter/routing/auto_router.py,sha256=y4v0c8u5F9f98Vmhx1vRcKPiOgAvpzbFqr6TIh058h0,13341
 coderouter/routing/budget.py,sha256=PblmVKJGs_BwNa9uDHAA8hmZ4XIVKv38mHAeU0V3OMs,8451
 coderouter/routing/capability.py,sha256=rRQhzTgQYFTFDNYcSLKvq3xjdw6B1w7T-3jS7PTMI14,27864
-coderouter/routing/fallback.py,sha256=DDH3kvnWqXOD28ENWi7kgpaBQOJo6_LRIj1a43ZWXP0,155655
+coderouter/routing/fallback.py,sha256=fqwjz5hTNsQDEf45nYcVTwGJwz2mFxQ5ZmZwdvFSKsI,156394
 coderouter/state/__init__.py,sha256=XoGcPmmBQSiZWML2S0juSveQ78xfhtdeCliNnVyzu7E,1088
 coderouter/state/audit_log.py,sha256=n7vuDsTfd5iuNUJhlRQPakJ2tMSsT9EfgPCzs1GEaac,10941
 coderouter/state/replay.py,sha256=Z_YHKroTKZdrL8qObFxcoLOAQWWXZvXFdLfxzvBhEJg,11230
@@ -68,11 +68,11 @@ coderouter/state/request_log.py,sha256=mNxQJ9IDGpUtT5rZbCo_-CTyhxmvig7C2Gfvdn9rc
 coderouter/state/store.py,sha256=h-rsMJq8GILsOfCP94nI40cuHaj4Vqycsm9UNN77REI,7445
 coderouter/state/suggest_rules.py,sha256=FvdhEvao5NvdKp9zs8AkcoFKHY4yqqXY2HekvSjpDFA,16670
 coderouter/translation/__init__.py,sha256=PYXN7XVEwpG1uC8RLy6fvnGbzEZhhrEuUapH8IYOtG8,1788
-coderouter/translation/anthropic.py,sha256=uEScq-icLn6ZXFWaxsKROv7feaq3zD0ZogjbTJ3Y7gQ,12578
-coderouter/translation/convert.py,sha256=VV4kpu4dvLmGBmJfQnCLY5ryy_AnQcV2NuwjqRtaR8Q,52633
-coderouter/translation/tool_repair.py,sha256=DGOKArM53yfVbIfiAveoul1vGq9NEKmjagf43Qh4IkM,57630
-coderouter_cli-2.11.0.dist-info/METADATA,sha256=KIJ1syHgU0_eFQlBpZvaasysCEzQE5LLsITNQYP9x3o,16897
-coderouter_cli-2.11.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-coderouter_cli-2.11.0.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
-coderouter_cli-2.11.0.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
-coderouter_cli-2.11.0.dist-info/RECORD,,
+coderouter/translation/anthropic.py,sha256=ZQQGS9itN_3o7IKD68lKr5gR_Kem32Jsd7OcGjJzv8Q,13468
+coderouter/translation/convert.py,sha256=VrstDAMsUpcQ1VgMTn_-ETp1OjGX8v0ZGhCkcd4icyU,53037
+coderouter/translation/tool_repair.py,sha256=1p8rmdyyscGX2g0DDOYitMnLv-nKfR1SLuLaRB4z7GM,64244
+coderouter_cli-2.11.1.dist-info/METADATA,sha256=s5AYjjcq3k-9rNEZ4cNAf5arPT4FkS8bMuqVlNpBOc0,16897
+coderouter_cli-2.11.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+coderouter_cli-2.11.1.dist-info/entry_points.txt,sha256=-dnLfD1YZ2WjH2zSdNCvlO65wYltM9bsHt9Fhg3yGss,51
+coderouter_cli-2.11.1.dist-info/licenses/LICENSE,sha256=wkEzoR86jFw33jvfOHjULqmkGEfxTFMgMaJnpR8mPRw,1065
+coderouter_cli-2.11.1.dist-info/RECORD,,