scootcli 0.14.0__tar.gz → 0.14.2__tar.gz

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

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

{scootcli-0.14.0 → 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.0"
+__version__ = "0.14.2"
 

{scootcli-0.14.0 → scootcli-0.14.2}/src/scootcli/cli.py

@@ -139,11 +139,15 @@ def _cmd_models(pool: ProviderPool, as_json: bool, vision_only: bool = False,
     for m in models:
         by_provider.setdefault(m.provider, []).append(m)
     default = pool.default_name
+    cap = None if provider else 8  # a specific --provider shows all; the full grid caps per provider
     for name in sorted(by_provider):
         tag = "  (default)" if name == default else ""
         print(color(f"{name}{tag}", "bold"))
-        for m in sorted(by_provider[name], key=lambda x: x.name):
+        rows = sorted(by_provider[name], key=lambda x: x.name)
+        for m in (rows if cap is None else rows[:cap]):
             print(f"  {color(m.id, 'cyan')}")
+        if cap is not None and len(rows) > cap:
+            print(color(f"  … +{len(rows) - cap} more · scoot models --provider {name}", "gray"))
     return 0
 
 

{scootcli-0.14.0 → scootcli-0.14.2}/src/scootcli/commands/model.py

@@ -10,11 +10,26 @@ explicit ``--model`` flag or ``SCOOT_MODEL`` still overrides it for that run.
 from __future__ import annotations
 
 from .. import preferences
+from ..providers import registry
 from ..providers.base import qualify, split_model_id
 from ..rendering import color
 from . import register
 from .base import SlashCommand
 
+_PER_PROVIDER = 8  # models shown per provider in the summary; the rest are behind `/model <provider>`
+
+
+def _print_provider(head: str, models: list, active: str, cap: "int | None") -> None:
+    """Print one provider's models, active first, capped unless ``cap`` is None."""
+    ordered = ([m for m in models if m == active] + [m for m in models if m != active])
+    shown = ordered if cap is None else ordered[:cap]
+    print(color(f"  {head}", "bold"))
+    for mid in shown:
+        mark = color(" ← active", "green") if mid == active else ""
+        print("    " + color(mid, "cyan") + mark)
+    if cap is not None and len(ordered) > cap:
+        print(color(f"    … +{len(ordered) - cap} more · /model {head} to list them", "gray"))
+
 _USAGE = "/model <provider/model> · /model default · /model auto (pick per task) · add 'everywhere' for all folders · /model forget"
 
 
@@ -55,17 +70,29 @@ def _run(session, args: str):
     arg = " ".join(words)
     available = session.available_models()
 
+    def _grouped():
+        groups = {}
+        for mid in available:
+            head, _ = split_model_id(mid)
+            groups.setdefault(head or "?", []).append(mid)
+        return groups
+
+    # `/model <provider>` (a bare known provider name) lists just that provider, uncapped, so a long
+    # list stays scoped to one screen-friendly provider instead of flooding the terminal.
+    if arg and not everywhere and "/" not in arg and registry.get(arg) is not None:
+        models = _grouped().get(arg, [])
+        if not models:
+            print(color(f"no models listed for '{arg}' (is its key set? try /auth).", "yellow"))
+        else:
+            print(color(f"{arg}  ({len(models)} models)", "bold"))
+            _print_provider(arg, models, session.active_model, cap=None)
+        return
+
     if not arg:
         print(color(f"models  (preference: {session.model} → active: {session.active_model})", "bold"))
         print(color(f"  {_saved_line(session)}", "gray"))
-        current = ""
-        for mid in available:
-            head, _ = split_model_id(mid)
-            if head != current:
-                current = head
-                print(color(f"  {head}", "bold"))
-            mark = color(" ← active", "green") if mid == session.active_model else ""
-            print("    " + color(mid, "cyan") + mark)
+        for head, models in _grouped().items():
+            _print_provider(head, models, session.active_model, cap=_PER_PROVIDER)
         errors = getattr(getattr(session, "provider", None), "list_errors", None) or {}
         for name, err in sorted(errors.items()):
             print(color(f"  {name}: unavailable ({err})", "yellow"))

{scootcli-0.14.0 → 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.0 → 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.0 → 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.0 → scootcli-0.14.2/src/scootcli.egg-info}/PKG-INFO

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

{scootcli-0.14.0 → scootcli-0.14.2}/tests/test_preferences.py

@@ -264,3 +264,33 @@ def test_status_names_the_models_origin(tmp_path, capsys):
     session = _model_session(root)
     status_cmd._run(session, "")
     assert "(from saved for this folder)" in capsys.readouterr().out
+
+
+def test_model_list_caps_per_provider_and_shows_active(tmp_path, capsys):
+    _fresh_config_dir()
+    from scootcli.commands import model as model_cmd
+
+    session = _model_session(tmp_path)
+    session._available = [f"openai/m{i:02d}" for i in range(12)] + ["ollama/llama3.2"]
+    session.model = "openai/m11"
+    session.active_model = "openai/m11"
+    model_cmd._run(session, "")
+    out = capsys.readouterr().out
+    assert "openai/m11 ← active" in out            # the active model is shown first, even past the cap
+    assert out.index("openai/m11") < out.index("openai/m00")
+    assert "+4 more" in out and "/model openai to list them" in out
+    assert "ollama/llama3.2" in out                # short providers list fully
+
+
+def test_model_provider_filter_lists_one_provider_uncapped(tmp_path, capsys):
+    _fresh_config_dir()
+    from scootcli.commands import model as model_cmd
+
+    session = _model_session(tmp_path)
+    session._available = [f"openai/m{i:02d}" for i in range(12)] + ["ollama/llama3.2"]
+    session.active_model = "openai/m00"
+    model_cmd._run(session, "openai")
+    out = capsys.readouterr().out
+    assert out.count("openai/m") == 12             # every openai model, no cap
+    assert "ollama/llama3.2" not in out            # scoped to the one provider
+    assert "more ·" not in out                     # nothing truncated

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

@@ -236,3 +236,72 @@ def test_xai_and_groq_are_registered_openai_chat_rows(monkeypatch, tmp_path):
     # A per-provider base-url override still works.
     monkeypatch.setenv("SCOOT_GROQ_BASE_URL", "https://proxy.example/v1")
     assert registry.base_url_for(registry.get("groq")) == "https://proxy.example/v1"
+
+
+def test_cli_models_caps_per_provider_unless_filtered(capsys):
+    from scootcli.cli import _cmd_models
+    from scootcli.providers import ModelInfo
+
+    class _Pool:
+        default_name = "openai"
+        list_errors: dict = {}
+
+        def list_models(self, provider=None):
+            ms = [ModelInfo(id=f"openai/m{i:02d}", provider="openai", name=f"m{i:02d}") for i in range(12)]
+            return [m for m in ms if provider is None or m.provider == provider]
+
+    _cmd_models(_Pool(), as_json=False)
+    out = capsys.readouterr().out
+    assert "+4 more" in out and "scoot models --provider openai" in out
+    _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 {}