scootcli 0.14.1__tar.gz → 0.14.2__tar.gz

{scootcli-0.14.1/src/scootcli.egg-info → scootcli-0.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.14.1
+Version: 0.14.2
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT

{scootcli-0.14.1 → scootcli-0.14.2}/src/scootcli/__init__.py

@@ -1,4 +1,4 @@
 """scoot: a tiny coding agent that goes where you point it."""
 
-__version__ = "0.14.1"
+__version__ = "0.14.2"
 

{scootcli-0.14.1 → scootcli-0.14.2}/src/scootcli/providers/base.py

@@ -363,6 +363,41 @@ class BaseProvider:
             time.sleep(0.05)
 
 
+def valid_tool_arguments(raw) -> str:
+    """A tool call's ``arguments`` as a JSON *object* string, safe to replay to a provider that
+    validates them. A missing, empty, or malformed value (a stream truncated mid-JSON on a length turn)
+    becomes ``"{}"``, so one bad tool call cannot poison the session on every later request. The call
+    is never dropped, so it still pairs with its matching ``tool`` result and history stays valid.
+    """
+    if isinstance(raw, dict):
+        try:
+            return json.dumps(raw)
+        except (TypeError, ValueError):
+            return "{}"
+    if not raw or not isinstance(raw, str):
+        return "{}"
+    try:
+        parsed = json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        return "{}"
+    return raw if isinstance(parsed, dict) else "{}"
+
+
+def sanitized_tool_calls(calls) -> list:
+    """Copy ``calls`` with each ``function.arguments`` replaced by a valid JSON-object string."""
+    out = []
+    for c in calls or []:
+        if not isinstance(c, dict):
+            out.append(c)
+            continue
+        c = dict(c)
+        fn = dict(c.get("function") or {})
+        fn["arguments"] = valid_tool_arguments(fn.get("arguments"))
+        c["function"] = fn
+        out.append(c)
+    return out
+
+
 def iter_sse_json(lines: Iterator[str], status_holder: dict, leftovers: List[str]) -> Iterator[dict]:
     """Walk raw SSE lines: yield each ``data:`` JSON object, record the status sentinel, collect
     anything that is not SSE (an error body) into ``leftovers``."""

{scootcli-0.14.1 → scootcli-0.14.2}/src/scootcli/providers/openai_chat.py

@@ -18,17 +18,23 @@ from .base import (
     finish_stream,
     iter_sse_json,
     normalize_usage,
+    sanitized_tool_calls,
 )
 
 _PRIVATE_KEYS = ("provider_items",)
 
 
 def strip_private(messages: List[dict]) -> List[dict]:
-    """Drop scoot-private keys the API would reject."""
+    """Prepare messages for the wire: drop scoot-private keys the API would reject, and rewrite any
+    tool-call arguments that are not valid JSON objects (a truncated length-turn leaves a malformed
+    string that a validating provider would reject on every later request). Copies, never mutates."""
     out = []
     for m in messages:
-        if any(k in m for k in _PRIVATE_KEYS):
+        calls = m.get("tool_calls")
+        if any(k in m for k in _PRIVATE_KEYS) or calls:
             m = {k: v for k, v in m.items() if k not in _PRIVATE_KEYS}
+            if calls:
+                m["tool_calls"] = sanitized_tool_calls(calls)
         out.append(m)
     return out
 

{scootcli-0.14.1 → scootcli-0.14.2}/src/scootcli/providers/openai_responses.py

@@ -31,6 +31,7 @@ from .base import (
     iter_sse_json,
     normalize_usage,
     raise_for_status,
+    valid_tool_arguments,
 )
 
 # Models that accept the ``reasoning`` parameter (others reject it with a 400).
@@ -68,9 +69,9 @@ def _content_parts(content, role: str) -> object:
 
 
 def _arguments(raw) -> str:
-    if isinstance(raw, str):
-        return raw
-    return json.dumps(raw or {})
+    # A valid JSON-object string, so a truncated/malformed tool call replayed to the Responses API
+    # cannot get the session stuck (mirrors the Chat wire and Anthropic's dict fallback).
+    return valid_tool_arguments(raw)
 
 
 def translate_messages(messages: List[dict], qualified_model: str) -> Tuple[str, List[dict]]:

{scootcli-0.14.1 → scootcli-0.14.2/src/scootcli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.14.1
+Version: 0.14.2
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT

{scootcli-0.14.1 → scootcli-0.14.2}/tests/test_providers.py

@@ -256,3 +256,52 @@ def test_cli_models_caps_per_provider_unless_filtered(capsys):
     _cmd_models(_Pool(), as_json=False, provider="openai")
     out = capsys.readouterr().out
     assert "more ·" not in out                      # a single --provider shows all
+
+
+# ── outbound tool-argument sanitizing: a malformed/truncated call cannot stick a session ──
+def test_valid_tool_arguments_normalizes_to_a_json_object():
+    import json as _json
+    from scootcli.providers.base import valid_tool_arguments
+
+    assert valid_tool_arguments('{"path": "a.txt"}') == '{"path": "a.txt"}'   # valid: unchanged
+    assert valid_tool_arguments("") == "{}"                                    # empty
+    assert valid_tool_arguments(None) == "{}"
+    assert valid_tool_arguments('{"path": "a') == "{}"                         # truncated mid-JSON
+    assert valid_tool_arguments("[1, 2]") == "{}"                              # JSON but not an object
+    assert _json.loads(valid_tool_arguments({"x": 1})) == {"x": 1}            # dict -> json string
+
+
+def test_chat_wire_sanitizes_tool_args_and_keeps_pairing():
+    import json as _json
+    from scootcli.providers.openai_chat import strip_private
+
+    def call(cid, args):
+        return {"id": cid, "type": "function", "function": {"name": "write_file", "arguments": args}}
+
+    messages = [
+        {"role": "user", "content": "go"},
+        {"role": "assistant", "content": "", "tool_calls": [
+            call("c1", '{"ok": true}'), call("c2", ""), call("c3", '{"path": "x')]},
+        {"role": "tool", "tool_call_id": "c1", "content": "ok"},
+        {"role": "tool", "tool_call_id": "c2", "content": "ok"},
+        {"role": "tool", "tool_call_id": "c3", "content": "ok"},
+    ]
+    out = strip_private(messages)
+    calls = out[1]["tool_calls"]
+    assert len(calls) == 3                                    # no call dropped
+    assert [c["id"] for c in calls] == ["c1", "c2", "c3"]
+    for c in calls:
+        _json.loads(c["function"]["arguments"])              # every one is now valid JSON
+    assert [m.get("tool_call_id") for m in out if m["role"] == "tool"] == ["c1", "c2", "c3"]  # pairing kept
+    assert messages[1]["tool_calls"][1]["function"]["arguments"] == ""  # original history untouched (copied)
+
+
+def test_responses_wire_sanitizes_reconstructed_tool_args():
+    import json as _json
+    from scootcli.providers.openai_responses import translate_messages
+
+    messages = [{"role": "assistant", "content": "", "tool_calls": [
+        {"id": "c1", "type": "function", "function": {"name": "read_file", "arguments": '{"path": "a'}}]}]
+    _instr, items = translate_messages(messages, "openai/gpt-5.3-codex")
+    fc = [it for it in items if it.get("type") == "function_call"]
+    assert len(fc) == 1 and _json.loads(fc[0]["arguments"]) == {}   # truncated args replayed as {}