tether-sdk 0.2.1__tar.gz → 0.2.2__tar.gz

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/AGENTS.md

@@ -70,7 +70,7 @@ Tether implements the architectural principles from *"LLM-Native Applications as
 ```text
 tether/
 ├── __init__.py          # Public SDK exports: Harness, Pipeline, Session, Skill, SandboxPolicy, tool
-├── cli.py               # Headless-capable CLI: `tether run|pipeline|status|read|query|send|list|wait|stats|retro|events|mcp` (`--json` + documented exit codes)
+├── cli.py               # Headless-capable CLI: `tether run|pipeline|status|read|query|send|list|wait|stats|retro|events|misses|mcp` (`--json` + documented exit codes)
 ├── harness.py           # Control Plane: bounded agent loop, pipelines, SQLite inbox, worker spawn
 ├── pipeline.py          # Workflow Plane: declarative multi-stage YAML pipelines & model routing
 ├── api.py               # Agent-facing JSON session view, exit codes, events (`--json`)
@@ -155,6 +155,7 @@ tether/
   - `ANTHROPIC_API_KEY`, `ANTHROPIC_BASE_URL` (default `https://api.anthropic.com`)
 
 ---
+- **Context config (#54):** `max_context_tokens` / `fold_observations_after` resolve as explicit argument (`--context-tokens` / `--fold-after`, MCP `context_tokens` / `fold_after`) > `providers.yaml` entry keys `context_tokens` / `fold_after` > defaults 8192 / 2.
 
 ## 4. Development Workflow & Commands
 

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tether-sdk
-Version: 0.2.1
+Version: 0.2.2
 Summary: General-purpose, headless-first LLM-Native micro-harness for small language models
 Project-URL: Homepage, https://github.com/igormcsouza/tether
 Project-URL: Repository, https://github.com/igormcsouza/tether

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/docs/reference/agent-interface.md

@@ -42,7 +42,7 @@ Optional: `pip install "tether-sdk[mcp]"` (installs the official `mcp` SDK; core
 
 | Tool | Arguments |
 |------|-----------|
-| `tether_run` | `goal`, `model`, `skill`, `tools`, `verify[]`, `max_steps`, `sandbox`, `no_network`, `output_schema`, `wait` (default true) |
+| `tether_run` | `goal`, `model`, `skill`, `tools`, `verify[]`, `max_steps`, `context_tokens`, `fold_after`, `sandbox`, `no_network`, `output_schema`, `wait` (default true) |
 | `tether_status` | `id` |
 | `tether_wait` | `ids[]`, `timeout` |
 | `tether_read` | `id`, `mode` = `full` \| `digest` \| `steps` |

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/docs/reference/providers.md

@@ -34,12 +34,18 @@ claude-cli:
   reply: result
   usage: {prompt: [usage.input_tokens, usage.cache_creation_input_tokens, usage.cache_read_input_tokens], completion: usage.output_tokens}
   timeout: 180
+  context_tokens: 32000
+  fold_after: 8
 ```
 
 ```bash
 tether run --model claude-cli/sonnet "fix the failing test"
 ```
 
+### Context budget
+
+Every entry, of any kind, may set two optional positive integers: `context_tokens` (the context budget, default 8192) and `fold_after` (how many recent turns keep full observations, default 2). The `--context-tokens` / `--fold-after` flags and the Harness arguments override them.
+
 ### Kinds
 
 | `kind` | Fields |
@@ -55,11 +61,25 @@ tether run --model claude-cli/sonnet "fix the failing test"
 
 A `command` entry wraps any program that takes a prompt and prints JSON.
 
-- **Placeholders**: `{model}`, `{system}` and `{conversation}` are substituted in `argv` items and in the `stdin` template. If `stdin` is omitted it defaults to `{conversation}`.
+- **Placeholders**: `{model}`, `{system}`, `{conversation}` and `{schema}` (the act JSON schema, compact) are substituted in `argv` items and in the `stdin` template. If `stdin` is omitted it defaults to `{conversation}`.
 - **No shell**: `argv` is executed directly, never through a shell.
 - **Reply**: `reply` is a dotted path into the JSON the command prints (`result` in the example).
 - **Usage**: `usage.prompt` is a path or a list of paths (their values are summed); `usage.completion` is a path. Both are optional.
-- **Protocol**: the model must answer with a single JSON `{"cmd", "stdin"}` object. The `{system}` placeholder already contains that instruction.
+- **Constrained output**: use `{schema}` to make the CLI constrain its reply to the act schema, for example `argv: [claude, -p, --json-schema, "{schema}", --output-format, json]`. The reply may then be an object with `cmd` and optional `stdin` instead of a string; if the `reply` path gives no string or object, a top-level `structured_output` object is used.
+
+  Measured cost (v0.2.2, one small task): with `claude -p`, `--json-schema` adds about 2k prompt tokens to every call (the CLI wraps the schema in a hidden tool), so the same 5-step task used ~26k prompt tokens instead of ~7k. Use it when a model's plain replies are not being understood, not as a default.
+- **Protocol**: the model should answer with a single JSON `{"cmd", "stdin"}` object. The `{system}` placeholder already contains that instruction.
+- **Dialects**: when the reply is not that JSON, Tether tries table-driven extractors in order, first match wins: `<tool_call>` JSON, raw JSON containing `"cmd"`, `<parameter name="cmd">X</parameter>` with optional `<parameter name="stdin">Y</parameter>` (inside any wrapper such as `<invoke>`), and text `act(...)`.
+- **`dialects:`** (optional): a list of mappings, each with a `regex` (compiled with `re.DOTALL`) that defines the named group `cmd` and optionally `stdin`. Custom dialects are tried after the built-in ones. Python users can also call `tether.register_dialect(fn)` with a `(str) -> ActionCall | None` function.
+
+```yaml
+mycli:
+  kind: command
+  argv: [mycli, "{conversation}"]
+  reply: result
+  dialects:
+    - regex: 'RUN\[(?P<cmd>.*?)\]WITH\[(?P<stdin>.*?)\]'
+```
 
 ### Rules
 

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/docs/release-notes.md

@@ -1,5 +1,19 @@
 # Release Notes
 
+## v0.2.2 (2026-10-19)
+
+Dogfooding fixes: Tether implemented most of this release itself through the CLI and a `claude -p` provider.
+
+### Features
+
+- `{schema}` placeholder for `command` providers (#51): constrain output to the act schema (e.g. `claude -p --json-schema '{schema}'`); replies may be structured objects with `cmd`/`stdin`.
+- `tether misses [session_id] [--model M] [--limit N] [--json]` (#53): list unparsed model replies (nudges) as fixture-ready JSONL; paste lines into `tests/fixtures/dialects.jsonl` after filling `expected`.
+
+### Fixes
+
+- The context budget and observation fold window are now configurable (#54): `--context-tokens` / `--fold-after` on `tether run` and `tether pipeline`, `context_tokens` / `fold_after` on `tether_run`, and per-provider keys in `providers.yaml`.
+- Tool-call dialect extraction is now table-driven (#52): built-in extractors for `<tool_call>` JSON, raw JSON, `<parameter name="cmd">` blocks and text `act(...)`, extendable with `tether.register_dialect` or a `dialects:` key on `command` entries in `providers.yaml`.
+
 ## v0.2.1 (2026-10-19)
 
 Add model backends without code.

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/docs/troubleshooting.md

@@ -10,6 +10,7 @@ Symptom, cause, fix. Most entries come from building the [course-builder example
 | Files contain a literal `\n` | Model sent escaped newlines in stdin | Fixed in v0.1.2 for `edit write`, `edit replace` and `done` |
 | Tool with multi-word argument fails (`unexpected keyword argument`, wrong value) | Unquoted words were not joined | Fixed in v0.1.2. See [argument parsing](tutorial/sdk-and-custom-tools.md#argument-parsing-v012) |
 | `Error: unknown command` for a tool defined in `tools.py` | The tool is not in the skill `tools:` list ([#24](https://github.com/igormcsouza/tether/issues/24)) | Add its name to `tools:`. See [Skills](tutorial/skills.md#tools-py-and-the-tools-list) |
+| Model answers are not understood (many nudges in `tether stats`) | The reply format is not parsed into an action | Run `tether misses`, then add a dialect: paste the lines into `tests/fixtures/dialects.jsonl` or add a `dialects:` regex to `providers.yaml` |
 | Gate with inline `awk`/`sed` is blocked as "absolute path outside workspace" | Fixed in v0.1.4 ([#31](https://github.com/igormcsouza/tether/issues/31)); older versions saw a program starting with `/` as a path | Upgrade, or move the logic into a script (`python3 checks.py ...`). See [Security and Sandbox](tutorial/security-and-sandbox.md#example-awksed-programs-that-start-with) |
 | `Ollama model … not found; installed: …` | The model name is not pulled; Tether no longer substitutes another one ([#21](https://github.com/igormcsouza/tether/issues/21)) | `ollama pull <model>`, fix the name, or set `TETHER_OLLAMA_FALLBACK=1` to opt in to a substitute |
 | `tether mcp` prints "MCP support is not installed" | The optional extra is missing | `pip install "tether-sdk[mcp]"`. See [Use Tether Inside Your Harness](tutorial/agent-interface.md) |

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/docs/tutorial/cli-and-headless.md

@@ -76,10 +76,22 @@ tether query "$SESSION_ID" "write-ahead log checkpointing" --top 3
 tether list
 ```
 
+## Context budget and fold window
+
+By default Tether keeps an 8192-token context budget and folds observations older than 2 turns. Tune both per run with `--context-tokens N` and `--fold-after N` (on `tether run` and `tether pipeline`), or per model in `providers.yaml` with `context_tokens` / `fold_after`. Flags override the provider entry, which overrides the defaults.
+
+```bash
+tether run --context-tokens 32000 --fold-after 8 "refactor the parser"
+```
+
 ## Scripting: `--json` and exit codes
 
 `run`, `pipeline`, `status`, `list`, `read`, `wait`, `send` and `stats` accept `--json`. Exit codes: `0` completed, `1` usage error, `2` waiting for input, `3` gate failed, `4` max steps, `5` worker error. A failure reason goes to stderr, never stdout. `--result-file <path>` writes the deliverable to a file, `--output-schema <schema.json>` rejects a `done` whose JSON does not match, and `tether events <id> --follow` streams turns as JSONL. Details: [Agent Interface reference](../reference/agent-interface.md).
 
+### When a model's replies are not understood
+
+If a model keeps answering in a format Tether cannot parse into an action (many nudges in `tether stats`), run `tether misses [session_id] [--model M] [--limit N] [--json]`. It lists the unparsed replies; with `--json` each line is fixture-ready. Paste lines into `tests/fixtures/dialects.jsonl` after filling `expected`, or add a `dialects:` regex to `providers.yaml`.
+
 ## Live Inbox Injection & Auto-Resume (`tether send`)
 
 Every session has a persistent SQLite `inbox` queue:

tether_sdk-0.2.2/tests/fixtures/dialects.jsonl

@@ -0,0 +1,6 @@
+{"reply": "<tool_call>{\"name\": \"act\", \"arguments\": {\"cmd\": \"ls -la\"}}</tool_call>", "cmd": "ls -la", "stdin": null}
+{"reply": "Sure: {\"cmd\": \"echo hi\"}", "cmd": "echo hi", "stdin": null}
+{"reply": "act(\"done\", stdin=\"x\")", "cmd": "done", "stdin": "x"}
+{"reply": "<invoke name=\"act\">\n<parameter name=\"cmd\">  pytest -q  </parameter>\n</invoke>", "cmd": "pytest -q", "stdin": null}
+{"reply": "<invoke name=\"act\">\n<parameter name=\"cmd\">edit write a.txt</parameter>\n<parameter name=\"stdin\">line1\nline2\n</parameter>\n</invoke>", "cmd": "edit write a.txt", "stdin": "line1\nline2\n"}
+{"reply": "I will think about this and answer in plain prose.", "cmd": null, "stdin": null}

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/tests/providers/test_declarative.py

@@ -15,6 +15,7 @@ from tether.providers import (
 )
 from tether.providers.base import ModelResponse
 from tether.providers.declarative import (
+    ACT_SCHEMA,
     CommandProvider,
     build_declared,
     load_declared,
@@ -300,3 +301,100 @@ def test_command_validation_errors(
     _write(monkeypatch, tmp_path, f"cli:\n  kind: command\n  {body}")
     with pytest.raises(ValueError, match=f"providers.yaml: entry `cli`.*{message}"):
         load_declared()
+
+
+def test_command_custom_dialect_end_to_end() -> None:
+    from tether.providers.declarative import _build_dialects
+
+    text = "RUN[ls -la]WITH[body]"
+    code = f"import json; print(json.dumps({{'r': {text!r}}}))"
+    dialects = _build_dialects([{"regex": r"RUN\[(?P<cmd>.*?)\]WITH\[(?P<stdin>.*?)\]"}])
+    resp = _run(CommandProvider("m", argv=_script(code), reply="r", dialects=dialects))
+    assert resp.action is not None
+    assert resp.action.cmd == "ls -la"
+    assert resp.action.stdin == "body"
+
+
+def test_command_custom_dialect_no_match_and_empty_cmd() -> None:
+    from tether.providers.declarative import _build_dialects
+
+    dialects = _build_dialects([{"regex": r"RUN\[(?P<cmd>.*?)\]"}])
+    assert dialects[0]("nothing here") is None
+    assert dialects[0]("RUN[   ]") is None
+    call = dialects[0]("RUN[ pwd ]")
+    assert call is not None
+    assert call.cmd == "pwd"
+    assert call.stdin is None
+
+
+@pytest.mark.parametrize(
+    ("dialects", "message"),
+    [
+        ("dialects: nope", "invalid `dialects`"),
+        ("dialects: [1]", "`regex` required"),
+        ("dialects: [{foo: bar}]", "`regex` required"),
+        ("dialects: [{regex: '('}]", "invalid `dialects` regex"),
+        ("dialects: [{regex: 'abc'}]", "named group `cmd`"),
+    ],
+)
+def test_command_dialects_validation_errors(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, dialects: str, message: str
+) -> None:
+    _write(
+        monkeypatch,
+        tmp_path,
+        f"cli:\n  kind: command\n  argv: [echo]\n  reply: r\n  {dialects}\n",
+    )
+    with pytest.raises(ValueError, match=f"providers.yaml: entry `cli`.*{message}"):
+        load_declared()
+
+
+_SCHEMA = json.dumps(ACT_SCHEMA, separators=(",", ":"))
+
+
+def test_schema_placeholder_in_argv_and_stdin() -> None:
+    code = (
+        "import sys,json;"
+        "s = sys.argv[1] + '|' + sys.stdin.read();"
+        "print(json.dumps({'r': json.dumps({'cmd': 'a', 'stdin': s})}))"
+    )
+    provider = CommandProvider("m", argv=_script(code, "{schema}"), reply="r", stdin="in:{schema}")
+    resp = _run(provider)
+    assert resp.action is not None
+    assert resp.action.stdin == f"{_SCHEMA}|in:{_SCHEMA}"
+
+
+def test_reply_dict_with_cmd_and_stdin() -> None:
+    code = "import json;print(json.dumps({'r': {'cmd': 'ls', 'stdin': 'x'}}))"
+    resp = _run(CommandProvider("m", argv=_script(code), reply="r"))
+    assert resp.action is not None
+    assert (resp.action.cmd, resp.action.stdin) == ("ls", "x")
+    assert json.loads(resp.content) == {"cmd": "ls", "stdin": "x"}
+
+
+def test_reply_dict_with_cmd_no_stdin() -> None:
+    code = "import json;print(json.dumps({'r': {'cmd': 'ls', 'stdin': None}}))"
+    resp = _run(CommandProvider("m", argv=_script(code), reply="r"))
+    assert resp.action is not None
+    assert resp.action.stdin is None
+
+
+def test_structured_output_fallback() -> None:
+    code = "import json;print(json.dumps({'result': '', 'structured_output': {'cmd': 'pwd'}}))"
+    resp = _run(CommandProvider("m", argv=_script(code), reply="missing"))
+    assert resp.action is not None
+    assert resp.action.cmd == "pwd"
+
+
+def test_reply_dict_without_cmd_falls_back() -> None:
+    code = "import json;print(json.dumps({'r': {'foo': 1}}))"
+    resp = _run(CommandProvider("m", argv=_script(code), reply="r"))
+    assert resp.content == ""
+    assert resp.action is None
+
+
+def test_reply_string_still_works() -> None:
+    code = "import json;print(json.dumps({'r': json.dumps({'cmd': 'ls'})}))"
+    resp = _run(CommandProvider("m", argv=_script(code), reply="r"))
+    assert resp.action is not None
+    assert resp.action.cmd == "ls"

tether_sdk-0.2.2/tests/providers/test_dialects.py

@@ -0,0 +1,79 @@
+"""Table-driven tests for tool-call dialect extractors."""
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tether.providers import base
+from tether.providers.base import ActionCall, extract_fallback_action, register_dialect
+
+FIXTURE = Path(__file__).parent.parent / "fixtures" / "dialects.jsonl"
+ROWS = [json.loads(line) for line in FIXTURE.read_text().splitlines() if line.strip()]
+
+
+@pytest.mark.parametrize("row", ROWS, ids=[str(i) for i in range(len(ROWS))])
+def test_dialect_fixture_rows(row: dict) -> None:
+    call = extract_fallback_action(row["reply"])
+    if row["cmd"] is None:
+        assert call is None
+    else:
+        assert call is not None
+        assert call.cmd == row["cmd"]
+        assert call.stdin == row["stdin"]
+
+
+def test_fixture_covers_required_forms() -> None:
+    assert len(ROWS) >= 6
+    assert any(r["cmd"] is None for r in ROWS)
+
+
+def test_empty_text_returns_none() -> None:
+    assert extract_fallback_action("") is None
+
+
+def test_parameter_tags_empty_cmd_is_none() -> None:
+    text = '<parameter name="cmd">   </parameter>'
+    assert extract_fallback_action(text) is None
+
+
+def test_register_dialect_appends_and_is_used() -> None:
+    def custom(text: str) -> ActionCall | None:
+        if text.startswith("RUN:"):
+            return ActionCall(cmd=text[4:].strip(), stdin=None)
+        return None
+
+    before = list(base.DIALECTS)
+    try:
+        assert register_dialect(custom) is custom
+        assert base.DIALECTS[-1] is custom
+        call = extract_fallback_action("RUN: ls")
+        assert call is not None
+        assert call.cmd == "ls"
+    finally:
+        base.DIALECTS.remove(custom)
+    assert base.DIALECTS == before
+    assert extract_fallback_action("RUN: ls") is None
+
+
+def test_extra_extractors_tried_after_builtins() -> None:
+    def custom(text: str) -> ActionCall | None:
+        return ActionCall(cmd="extra", stdin=None) if "zzz" in text else None
+
+    call = extract_fallback_action("zzz", extra=[custom])
+    assert call is not None
+    assert call.cmd == "extra"
+    assert extract_fallback_action("zzz") is None
+    builtin = extract_fallback_action('{"cmd": "ls"} zzz', extra=[custom])
+    assert builtin is not None
+    assert builtin.cmd == "ls"
+
+
+def test_tool_call_block_with_non_object_payload_is_ignored() -> None:
+    assert extract_fallback_action("<tool_call>[1, 2]</tool_call>") is None
+
+
+def test_act_ast_rejects_non_call_expression() -> None:
+    from tether.providers.base import _act_from_ast
+
+    assert _act_from_ast(") or (1") is None

tether_sdk-0.2.2/tests/test_context_config.py

@@ -0,0 +1,101 @@
+"""Configurable context budget and fold window (#54)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tether import ActionCall, Harness, ModelResponse, register_provider
+from tether.cli import _async_main
+from tether.providers.declarative import load_declared
+
+
+def _yaml(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, text: str) -> None:
+    p = tmp_path / "p.yaml"
+    p.write_text(text, encoding="utf-8")
+    monkeypatch.setenv("TETHER_PROVIDERS", str(p))
+
+
+ENTRY = "decl:\n  kind: openai\n  base_url: http://x\n  api_key_env: K\n"
+
+
+def test_precedence(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    db = tmp_path / "t.db"
+    monkeypatch.setenv("TETHER_PROVIDERS", str(tmp_path / "none.yaml"))
+    h = Harness(model="decl/m", db_path=db)
+    assert (h.max_context_tokens, h.fold_observations_after) == (8192, 2)
+    _yaml(monkeypatch, tmp_path, ENTRY + "  context_tokens: 32000\n  fold_after: 8\n")
+    h = Harness(model="decl/m", db_path=db)
+    assert (h.max_context_tokens, h.fold_observations_after) == (32000, 8)
+    h = Harness(model="decl/m", db_path=db, max_context_tokens=100, fold_observations_after=5)
+    assert (h.max_context_tokens, h.fold_observations_after) == (100, 5)
+    _yaml(monkeypatch, tmp_path, "decl:\n  kind: nope\n")
+    h = Harness(model="decl/m", db_path=db)
+    assert h.max_context_tokens == 8192
+
+
+@pytest.mark.parametrize("key", ["context_tokens", "fold_after"])
+@pytest.mark.parametrize("bad", ["0", "-1", "true", "'8'", "1.5"])
+def test_validation(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, key: str, bad: str) -> None:
+    _yaml(monkeypatch, tmp_path, ENTRY + f"  {key}: {bad}\n")
+    with pytest.raises(ValueError, match=f"entry `decl` has invalid `{key}` "):
+        load_declared()
+
+
+class _P:
+    model_name = "x"
+
+    async def generate(self, messages: Any, tools: Any) -> ModelResponse:
+        return ModelResponse(
+            content="",
+            action=ActionCall(cmd="done", stdin="ok"),
+            prompt_tokens=1,
+            completion_tokens=1,
+        )
+
+
+async def test_cli_flags(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    seen: list[Harness] = []
+
+    class Rec(Harness):
+        def __init__(self, *a: Any, **kw: Any) -> None:
+            super().__init__(*a, **kw)
+            seen.append(self)
+
+    monkeypatch.setattr("tether.cli.Harness", Rec)
+    register_provider("ctxcfg", lambda name: _P())
+    db = str(tmp_path / "t.db")
+    flags = ["--context-tokens", "123", "--fold-after", "7", "--db", db, "--model", "ctxcfg/m"]
+    assert await _async_main(["run", "--json", *flags, "g"]) == 0
+    assert json.loads(capsys.readouterr().out)["status"] == "COMPLETED"
+    await _async_main(["pipeline", *flags, str(tmp_path / "missing.yaml"), "g"])
+    assert len(seen) == 2
+    assert all((h.max_context_tokens, h.fold_observations_after) == (123, 7) for h in seen)
+
+
+async def test_mcp_args(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    import mcp
+
+    from tether.mcp import build_server
+
+    seen: list[Harness] = []
+
+    class Rec(Harness):
+        def __init__(self, *a: Any, **kw: Any) -> None:
+            super().__init__(*a, **kw)
+            seen.append(self)
+
+    monkeypatch.setattr("tether.mcp.Harness", Rec)
+    register_provider("ctxmcp", lambda name: _P())
+    async with mcp.Client(build_server(tmp_path / "t.db", tmp_path)) as c:
+        res = await c.call_tool(
+            "tether_run",
+            {"goal": "g", "model": "ctxmcp/m", "context_tokens": 50, "fold_after": 4},
+        )
+        assert not res.is_error
+    assert (seen[0].max_context_tokens, seen[0].fold_observations_after) == (50, 4)

tether_sdk-0.2.2/tests/test_misses.py

@@ -0,0 +1,108 @@
+"""`tether misses`: unparsed model replies as fixture-ready JSONL (#53)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from tether import ActionCall, ModelResponse, register_provider
+from tether.cli import _async_main
+from tether.store import SQLiteStore
+
+
+class Prose:
+    model_name = "x"
+
+    def __init__(self, text: str) -> None:
+        self.text = text
+        self.i = 0
+
+    async def generate(self, messages: Any, tools: Any) -> ModelResponse:
+        self.i += 1
+        return ModelResponse(
+            content=f"{self.text} #{self.i}", action=None, prompt_tokens=1, completion_tokens=1
+        )
+
+
+class Done:
+    model_name = "x"
+
+    async def generate(self, messages: Any, tools: Any) -> ModelResponse:
+        return ModelResponse(
+            content="",
+            action=ActionCall(cmd="done", stdin="ok"),
+            prompt_tokens=1,
+            completion_tokens=1,
+        )
+
+
+async def _run(capsys: pytest.CaptureFixture[str], argv: list[str]) -> tuple[int, str, str]:
+    code = await _async_main(argv)
+    cap = capsys.readouterr()
+    return code, cap.out, cap.err
+
+
+async def _session(capsys: pytest.CaptureFixture[str], db: str, prefix: str, provider: Any) -> str:
+    register_provider(prefix, lambda name: provider)
+    argv = ["run", "--json", "--model", f"{prefix}/m", "--db", db, "--max-steps", "3", "g"]
+    _, out, _ = await _run(capsys, argv)
+    return str(json.loads(out)["id"])
+
+
+async def test_misses_outputs_and_filters(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    db = str(tmp_path / "t.db")
+    s1 = await _session(capsys, db, "miss-a", Prose("a" * 500))
+    s2 = await _session(capsys, db, "miss-b", Prose("b"))
+
+    code, out, _ = await _run(capsys, ["misses", "--db", db])
+    assert code == 0
+    assert f"[{s1} step" in out and "miss-a/m]" in out
+    assert "a" * 300 in out and "a" * 301 not in out
+
+    code, out, _ = await _run(capsys, ["misses", "--json", "--db", db])
+    rows = [json.loads(line) for line in out.splitlines()]
+    assert code == 0 and len(rows) >= 2
+    assert {r["session"] for r in rows} == {s1, s2}
+    assert all(r["expected"] is None and r["reply"] and "step" in r for r in rows)
+    assert any(len(r["reply"]) > 300 for r in rows)
+
+    _, out, _ = await _run(capsys, ["misses", "--json", "--limit", "1", "--db", db])
+    assert len(out.splitlines()) == 1
+
+    _, out, _ = await _run(capsys, ["misses", "--json", "--model", "miss-b/m", "--db", db])
+    assert {json.loads(x)["session"] for x in out.splitlines()} == {s2}
+
+    _, out, _ = await _run(capsys, ["misses", s1, "--json", "--db", db])
+    assert {json.loads(x)["session"] for x in out.splitlines()} == {s1}
+
+    code, _, err = await _run(capsys, ["misses", "ses_nope", "--db", db])
+    assert code == 1 and "session `ses_nope` not found." in err
+
+
+async def test_misses_empty(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    db = str(tmp_path / "t.db")
+    await _session(capsys, db, "miss-ok", Done())
+    code, out, _ = await _run(capsys, ["misses", "--db", db])
+    assert code == 0 and out.strip() == "No unparsed replies."
+    code, out, _ = await _run(capsys, ["misses", "--json", "--db", db])
+    assert code == 0 and out == ""
+
+
+async def test_store_list_nudges(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    db = str(tmp_path / "t.db")
+    s1 = await _session(capsys, db, "miss-c", Prose("c"))
+    store = SQLiteStore(db_path=db)
+    rows = store.list_nudges()
+    assert len(rows) >= 2
+    assert all(t.event_type == "nudge" and s.id == s1 for s, t in rows)
+    ids = [t.id for _, t in rows]
+    assert ids == sorted(ids, reverse=True)
+    assert len(store.list_nudges(limit=1)) == 1
+    assert store.list_nudges(session_id="nope") == []
+    assert store.list_nudges(model="other/m") == []
+    assert len(store.list_nudges(session_id=s1, model="miss-c/m")) == len(rows)

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/tests/test_tether.py

@@ -7,6 +7,6 @@ import tether
 
 def test_version_and_public_exports() -> None:
     """Verify package __version__ and public SDK symbols."""
-    assert tether.__version__ == "0.2.1"
+    assert tether.__version__ == "0.2.2"
     for symbol in tether.__all__:
         assert hasattr(tether, symbol)

{tether_sdk-0.2.1 → tether_sdk-0.2.2}/tether/__init__.py

@@ -17,6 +17,7 @@ from tether.providers import (
     ModelResponse,
     ProviderResponse,
     extract_fallback_action,
+    register_dialect,
     register_provider,
 )
 from tether.sandbox import SandboxPolicy, SandboxViolationError
@@ -30,7 +31,7 @@ from tether.store import (
     ToolOffender,
 )
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 __all__ = [
     "ActionCall",
@@ -55,6 +56,7 @@ __all__ = [
     "extract_fallback_action",
     "load_pipeline",
     "parse_pipeline_yaml",
+    "register_dialect",
     "register_provider",
     "tool",
 ]