tether-sdk 0.2.6__tar.gz → 0.2.7__tar.gz

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/AGENTS.md

@@ -62,7 +62,7 @@ Reviewers and the Team Leader cite the failing line when they reject a change.
   ```text
   [obs_3 folded: `web fetch https://...` (3,420 chars) | use `mem recall obs_3` to expand]
   ```
-- Exception: the latest read of each of the last 8 files (`edit view <p>`, `bash cat/head/tail/sed -n <p>`; paths normalized against the workspace) is not folded until `<p>` is edited (`edit write|replace`, or any other bash command naming it: `sed -i`, `tee`, redirects, `python -c`) or re-read. The 2,400-char head+tail elision still applies, and under `max_context_tokens` pressure it is folded like any other (oldest first). The `mem recall` hint is shown only when `mem` is enabled (else "re-run the command").
+- Exception: the latest read of each of the last 8 files (`edit view <p>`, `bash cat/head/tail/sed -n <p>`; paths normalized against the workspace) is not folded until `<p>` is edited (`edit write|replace`, or any other bash command naming it: `sed -i`, `tee`, redirects, `python -c`) or re-read. The head+tail elision still applies (an observation may use up to a third of `max_context_tokens`, at least 2,400 chars), and under `max_context_tokens` pressure it is folded like any other (oldest first). The `mem recall` hint is shown only when `mem` is enabled (else "re-run the command").
 - History is replayed as structured `tool_calls` + `tool` results (providers with `structured_history = True`; textual `act('...')` form only as fallback), with `stdin` replayed as a real 400-char prefix, never a `<N chars>` placeholder. A call and its result are trimmed together.
 
 ### Rule 6: Deterministic Security Envelope (Never Trust the LLM for Safety)

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tether-sdk
-Version: 0.2.6
+Version: 0.2.7
 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.6 → tether_sdk-0.2.7}/bench/README.md

@@ -9,6 +9,14 @@ Nine tasks in `tasks/<name>/` (workspace in `ws/`, goal in `goal.txt`, hidden te
 scores 0), `qa`, `content`, `review` (graded by constraint counts and keyword checks, so they are
 a smoke test for quality, not a judge).
 
+**Polyglot-Python** is the score we answer to. `--tasks polyglot` runs the 34 Python exercises of Aider's
+[polyglot-benchmark](https://github.com/Aider-AI/polyglot-benchmark) (cloned once into
+`~/.cache/tether-bench/polyglot-benchmark`, or set `POLYGLOT_DIR`); `--tasks polyglot-fast` runs a 12-exercise
+subset that mixes passes, partials and failures. Each task is graded by the exercise's own tests (the test file is
+restored before grading, so editing it cannot pass), `--poly-verify` adds a `--verify` gate on those tests. Then
+`python3 bench/report.py <out>` prints pass rate and mean score with a failure breakdown that keeps provider outages
+(`outage`, `timeout`) apart from harness outcomes (`max_steps`, `stalled`, `wrong_answer`, `worker_error`).
+
 Three runners, so a gap can be attributed:
 
 | runner | what it is |

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/bench/grade.py

@@ -176,10 +176,55 @@ def _codereview(_task, _ws, result):
     return {"score": round(sum(hit.values()) / len(hit), 3), "pass": all(hit[k] for k in must), "detail": {"missed": [k for k, v in hit.items() if not v], "items": _steps(t)}}
 
 
+# Fast set (12): easy passes, partials and hard failures from the 0.2.6 baseline; tether's weak spots.
+POLY_FAST = ("affine-cipher bottle-song list-ops paasio dot-dsl food-chain forth go-counting poker pov react "
+             "rest-api").split()
+
+
+def poly_dir(ex=""):
+    """Aider polyglot-benchmark Python exercises (cloned once, never vendored)."""
+    root = os.environ.get("POLYGLOT_DIR") or os.path.expanduser("~/.cache/tether-bench/polyglot-benchmark")
+    if not os.path.isdir(root):
+        subprocess.run(["git", "clone", "--depth", "1", "https://github.com/Aider-AI/polyglot-benchmark", root], check=True)
+    return os.path.join(root, "python", "exercises", "practice", ex)
+
+
+def poly_goal(ex):
+    d = poly_dir(ex)
+    docs = "\n\n".join(open(os.path.join(d, ".docs", f)).read() for f in ("instructions.md", "instructions.append.md")
+                        if os.path.exists(os.path.join(d, ".docs", f)))
+    sol = ex.replace("-", "_") + ".py"
+    return (f"Implement `{sol}` in the current directory so that `python3 -m unittest discover -p '*_test.py'` passes. "
+            f"Do not edit the test file.\n\n{docs}")
+
+
+def _poly(task, ws, _result):
+    ex = task.removeprefix("poly-")
+    tmp = tempfile.mkdtemp(prefix="g_")
+    try:
+        shutil.copytree(ws, tmp, dirs_exist_ok=True)
+        test = ex.replace("-", "_") + "_test.py"
+        shutil.copy(os.path.join(poly_dir(ex), test), os.path.join(tmp, test))  # restore: editing tests cannot pass
+        try:
+            p = subprocess.run([sys.executable, "-m", "unittest", "-v", test[:-3]], cwd=tmp, capture_output=True, text=True, timeout=90)
+        except subprocess.TimeoutExpired:
+            return {"score": 0.0, "pass": False, "detail": {"error": "tests timed out"}}
+        out = p.stderr + p.stdout
+        ok = len(re.findall(r"\.\.\. ok$", out, re.M))
+        bad = len(re.findall(r"\.\.\. (FAIL|ERROR)$", out, re.M))
+        total = ok + bad
+        return {"score": round(ok / total, 3) if total else 0.0, "pass": p.returncode == 0 and total > 0, "detail": {"ok": ok, "total": total}}
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
 def grade(task, ws, result):
-    fn = {"qa": _qa, "content": _content, "review": _review, "focus": _focus, "plan": _plan, "codereview": _codereview}.get(task, _code)
+    orig = task
+    if task.startswith("poly-"):
+        task = "poly"
+    fn = {"poly": _poly, "qa": _qa, "content": _content, "review": _review, "focus": _focus, "plan": _plan, "codereview": _codereview}.get(task, _code)
     try:
-        return fn(task, ws, result)
+        return fn(orig, ws, result)
     except Exception as e:  # grader bug must never look like a model result
         return {"score": 0.0, "pass": False, "detail": {"grader_error": repr(e)}}
 

tether_sdk-0.2.7/bench/report.py

@@ -0,0 +1,48 @@
+"""Failure breakdown for a results dir: `python3 bench/report.py <out> [<out> ...]`.
+
+Splits every run into pass, model-side outcomes (wrong answer, ran out of steps, stalled) and
+failures that say nothing about the harness's logic (provider outage, killed by timeout), so a
+score never hides infrastructure noise and infrastructure never hides a harness bug.
+"""
+import collections
+import json
+import os
+import re
+import sys
+
+OUTAGE = re.compile(r"unavailable after|429|503|Not Found|ConnectError|TimeoutError")
+
+
+def outcome(r):
+    if r["pass"]:
+        return "pass"
+    try:
+        j = json.loads(open(r["dir"] + "/stdout.txt").read())
+    except (OSError, ValueError):
+        return "timeout" if r.get("run_status") == "timeout" else "no_output"
+    f = j.get("failure") or {}
+    kind, msg = f.get("kind"), f.get("message", "")
+    if kind == "worker_error":
+        return "outage" if OUTAGE.search(msg) else "worker_error"
+    return kind or ("wrong_answer" if j.get("status") == "COMPLETED" else "timeout")
+
+
+def main(dirs):
+    rows = []
+    for d in dirs:
+        rows += [json.loads(line) for line in open(os.path.join(d, "results.jsonl"))]
+    groups = collections.defaultdict(list)
+    for r in rows:
+        groups[(r["runner"], r["model"])].append(r)
+    for (runner, model), rs in sorted(groups.items()):
+        c = collections.Counter(outcome(r) for r in rs)
+        valid = [r for r in rs if outcome(r) not in ("outage", "timeout", "no_output")]
+        mean = lambda l: round(sum(x["score"] for x in l) / len(l), 3) if l else 0.0  # noqa: E731
+        wall = round(sum(r["wall_s"] for r in rs) / len(rs))
+        print(f"{runner} {model}: {len(rs)} runs, pass {c['pass']} ({c['pass'] / len(rs):.0%}), mean {mean(rs)}, "
+              f"mean over valid runs {mean(valid)}, {wall}s/run")
+        print("   " + ", ".join(f"{k} {v}" for k, v in c.most_common()))
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/bench/run.py

@@ -25,6 +25,17 @@ TASK_CFG = {  # tether tools / step cap / wall timeout
 }
 
 
+POLY_VERIFY = False
+
+
+def cfg(task):
+    return ("edit,bash", 30, 600) if task.startswith("poly-") else TASK_CFG[task]
+
+
+def poly_tasks():
+    return ",".join("poly-" + e for e in sorted(os.listdir(grade.poly_dir())))
+
+
 def group(model):
     return "nvidia" if model.startswith("openai/") else "ollama" if model.startswith("ollama/") else "claude" if model.startswith(("claude", "cc/")) else "nvidia"
 
@@ -40,7 +51,7 @@ def flags(tether_bin):
 
 
 def build_cmd(runner, model, task, goal, ws, rd, tether_bin, params=()):
-    tools, steps, _ = TASK_CFG[task]
+    tools, steps, _ = cfg(task)
     if runner == "tether":
         h = flags(tether_bin)
         cmd = [tether_bin, "run", "--model", model, "--max-steps", str(steps), "--db", f"{rd}/t.db"]
@@ -50,6 +61,8 @@ def build_cmd(runner, model, task, goal, ws, rd, tether_bin, params=()):
             cmd += ["--tools", tools]
         for item in params:
             cmd += ["--param", item]
+        if task.startswith("poly-") and POLY_VERIFY:
+            cmd += ["--verify", "python3 -m unittest discover -p '*_test.py'"]
         return cmd + [goal]
     if runner == "naive":
         base, key = ("http://localhost:11435/v1", "") if model.startswith("ollama/") else ("https://integrate.api.nvidia.com/v1", "NVIDIA_API_KEY")
@@ -99,8 +112,13 @@ async def one(sem, rec, args, results):
     async with sem[group(model)]:
         shutil.rmtree(rd, ignore_errors=True)
         os.makedirs(rd)
-        shutil.copytree(f"{HERE}/tasks/{task}/ws", ws)
-        goal = open(f"{HERE}/tasks/{task}/goal.txt").read().strip()
+        if task.startswith("poly-"):
+            ex = task[5:]
+            shutil.copytree(grade.poly_dir(ex), ws, ignore=shutil.ignore_patterns(".meta", ".docs"))
+            goal = grade.poly_goal(ex)
+        else:
+            shutil.copytree(f"{HERE}/tasks/{task}/ws", ws)
+            goal = open(f"{HERE}/tasks/{task}/goal.txt").read().strip()
         cmd = build_cmd(runner, model, task, goal, ws, rd, args.tether_bin, args.param)
         env = dict(os.environ, OLLAMA_HOST="http://localhost:11435", PYTHONDONTWRITEBYTECODE="1")
         if model.startswith("openai/"):  # old tether has no providers.yaml: route openai/ to NVIDIA's OpenAI-compatible API
@@ -109,7 +127,7 @@ async def one(sem, rec, args, results):
         p = await asyncio.create_subprocess_exec(*cmd, cwd=ws, env=env, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE, start_new_session=True)
         status = "ok"
         try:
-            out, err = await asyncio.wait_for(p.communicate(), TASK_CFG[task][2])
+            out, err = await asyncio.wait_for(p.communicate(), cfg(task)[2])
         except asyncio.TimeoutError:
             os.killpg(p.pid, signal.SIGKILL)
             out, err = await p.communicate()
@@ -161,7 +179,14 @@ async def main():
     ap.add_argument("--par", default="nvidia=4,ollama=1,claude=3")
     ap.add_argument("--force", action="store_true")
     ap.add_argument("--redo-infra", action="store_true", help="rerun cells that failed on provider errors")
+    ap.add_argument("--poly-verify", action="store_true", help="verify gate on the exercise tests: gate runs at `done`")
     args = ap.parse_args()
+    global POLY_VERIFY
+    POLY_VERIFY = args.poly_verify
+    if args.tasks == "polyglot":
+        args.tasks = poly_tasks()
+    elif args.tasks == "polyglot-fast":
+        args.tasks = ",".join("poly-" + e for e in grade.POLY_FAST)
     os.makedirs(args.out, exist_ok=True)
     sem = {k: asyncio.Semaphore(int(v)) for k, v in (x.split("=") for x in args.par.split(","))}
     recs = [(r, m, t, k) for r in args.runners.split(",") for m in args.models.split(",") for t in args.tasks.split(",") for k in range(args.trials)

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/docs/architecture.md

@@ -53,12 +53,12 @@ In *"MemGPT: Towards LLMs as Operating Systems"*, Packer et al. (2023) introduce
 
 Tether implements a deterministic three-tier memory hierarchy backed by `.tether/tether.db` (SQLite WAL + FTS5):
 
-1. **Head + Tail L1 Active Elision**: Even within the active $K=2$ turn window, if a command emits an oversized output (`> 2,400 chars`), `ContextAssembler` keeps the first 900 chars (headers/command summary) + last 900 chars (stack trace/exit status) and elides the middle with a pointer to `mem recall <obs_id>`.
+1. **Head + Tail L1 Active Elision**: Even within the active $K=2$ turn window, if a command emits an oversized output (more than a third of `max_context_tokens` in chars, at least 2,400), `ContextAssembler` keeps the first 60% of the cap (headers/command summary) + the last 40% (stack trace/exit status) and elides the middle with a pointer to `mem recall <obs_id>`.
 2. **Ephemeral $K$-Turn Folding**: Once an observation ages past $K=2$ steps, it is folded into a single-line tombstone:
    ```text
    [obs_1 folded: `web fetch https://...` (3,420 chars) | use `mem recall obs_1` or `mem search <query>`]
    ```
-   Exception (#69): the latest read of each of the last 8 files (`edit view <p>`, `bash cat/head/tail/sed -n <p>`; paths normalized against the workspace) is not folded until `<p>` is edited (`edit write|replace`, or any other bash command naming it: `sed -i`, `tee`, redirects, `python -c`) or re-read. The 2,400-char head+tail elision still applies, and the hard context budget remains #81. The `mem recall` hint is shown only when `mem` is enabled (else "re-run the command").
+   Exception (#69): the latest read of each of the last 8 files (`edit view <p>`, `bash cat/head/tail/sed -n <p>`; paths normalized against the workspace) is not folded until `<p>` is edited (`edit write|replace`, or any other bash command naming it: `sed -i`, `tee`, redirects, `python -c`) or re-read. The head+tail elision still applies (an observation may use up to a third of `max_context_tokens`, at least 2,400 chars), and the hard context budget remains #81. The `mem recall` hint is shown only when `mem` is enabled (else "re-run the command").
 3. **Sub-Millisecond SQLite FTS5 BM25 RAG**: Every raw observation and final deliverable is automatically chunked (~150 tokens per paragraph/section) and indexed into an FTS5 virtual table (`chunks_fts`) so the agent (or a parent agent) can retrieve exact passages via `mem search` or `agent query`.
 
 ---

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/docs/reference/context-and-store.md

@@ -22,7 +22,7 @@ When the provider sets `structured_history = True` (Ollama, OpenAI-compatible, A
 
 Raw tool outputs stay in the prompt for $K=2$ turns, then fold into a one-line tombstone (see [Built-in Tools](../tutorial/built-in-tools.md#mem-pinned-scratchpad-bm25-observation-recall)). For small models this has consequences ([#27](https://github.com/igormcsouza/tether/issues/27)), seen in the [course-builder example](https://github.com/igormcsouza/tether/tree/main/examples/course):
 
-- **Fix (#69).** Folding exception: the latest read of each of the last 8 files (`edit view <p>`, `bash cat/head/tail/sed -n <p>`; paths normalized against the workspace) is not folded until `<p>` is edited (`edit write|replace`, or any other bash command naming it: `sed -i`, `tee`, redirects, `python -c`) or re-read. The 2,400-char head+tail elision still applies, and the hard context budget remains #81. The `mem recall` hint is shown only when `mem` is enabled (else "re-run the command"). (`ContextAssembler(mem_enabled=..., workspace_root=...)`, `MAX_LIVE_READS`).
+- **Fix (#69).** Folding exception: the latest read of each of the last 8 files (`edit view <p>`, `bash cat/head/tail/sed -n <p>`; paths normalized against the workspace) is not folded until `<p>` is edited (`edit write|replace`, or any other bash command naming it: `sed -i`, `tee`, redirects, `python -c`) or re-read. The head+tail elision still applies (an observation may use up to a third of `max_context_tokens`, at least 2,400 chars), and the hard context budget remains #81. The `mem recall` hint is shown only when `mem` is enabled (else "re-run the command"). (`ContextAssembler(mem_enabled=..., workspace_root=...)`, `MAX_LIVE_READS`).
 - **Re-viewing files loops, then invents data.** The model runs `edit view`, the output folds two turns later, it views again, and eventually writes from memory.
 - **What worked: one compact joined view, used right before the write, that ends with the exact next call.** The `course-source <module>` tool returns a module's plan and chosen videos in one output and finishes with `NOW WRITE THIS MODULE: act("edit write part-N.md", ...)`, so the data is still in the prompt when the write happens.
 - **Write long outputs in small pieces.** One big write dropped a whole section. The writer skill writes one `part-N.md` per module with `edit write`, then a `course-build` tool concatenates them into `course.md`.

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/docs/reference/providers.md

@@ -48,7 +48,7 @@ Every entry, of any kind, may set optional positive integers: `context_tokens` (
 
 ### Timeout and retry
 
-Every entry may set `timeout` (positive seconds). It applies to the HTTP kinds (`openai`, `ollama`, `anthropic`; defaults 120 / 120 / 180 s) and to `command` (default 300 s). The HTTP providers retry automatically, at most 2 times with 1 s then 2 s backoff, on timeouts, network errors and HTTP 429/500/502/503/504. A 401/403 is never retried: it raises `ProviderError` naming the provider and the credential variable (`openai: HTTP 401: `NVIDIA_API_KEY` is missing or rejected; set it to a valid key`; the value is never printed), and a declared `api_key_env` that is unset or empty fails the session before any request with the same message. Other 4xx responses are never retried. When retries run out the call raises `ProviderError`, so the session fails with a readable `Worker error: ProviderError: openai model `gpt-4o` unavailable after 3 attempts (timeout 120s, last error: ReadTimeout)`. The retry is invisible to the prompt (0 tokens, no prefix change).
+Every entry may set `timeout` (positive seconds). It applies to the HTTP kinds (`openai`, `ollama`, `anthropic`; defaults 120 / 120 / 180 s) and to `command` (default 300 s). The HTTP providers retry automatically, at most 2 times with 1 s then 2 s backoff, on timeouts, network errors and HTTP 429/500/502/503/504. A 401/403 is never retried: it raises `ProviderError` naming the provider and the credential variable (`openai: HTTP 401: `NVIDIA_API_KEY` is missing or rejected; set it to a valid key`; the value is never printed), and a declared `api_key_env` that is unset or empty fails the session before any request with the same message. Other 4xx responses are never retried. An HTTP 500 whose body names a rejected tool call (Ollama: `invalid tool call arguments`, a cut-off tool-call JSON) is not retried either, since the same request fails the same way; `ollama`, `openai` and `anthropic` turn it into a one-line hint to the model (a no-action reply), so the session continues instead of failing. The match is the text `tool call` in a 500 body, for any server. When retries run out the call raises `ProviderError`, so the session fails with a readable `Worker error: ProviderError: openai model `gpt-4o` unavailable after 3 attempts (timeout 120s, last error: ReadTimeout)`. The retry is invisible to the prompt (0 tokens, no prefix change).
 
 ### Kinds
 

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/docs/release-notes.md

@@ -1,5 +1,18 @@
 # Release Notes
 
+## v0.2.7 (2026-10-24)
+
+Found by running Tether on the Polyglot-Python benchmark (34 Aider polyglot Python exercises) and reading why runs failed instead of guessing: sessions that ended mid-task on a server error, and models that re-read one file until the step cap. Closes #138, #141.
+
+### Benchmark
+
+- `bench/run.py --tasks polyglot|polyglot-fast` runs the Polyglot-Python exercises, graded by each exercise's own tests; `bench/report.py` prints pass rate, mean score and a failure breakdown that keeps provider outages apart from harness outcomes. On the 12-exercise fast set (2 trials), the observation-cap fix below moved `qwen3.5:9b` from mean 0.64 to 0.80 and cut re-reads of one file from 32% to 19% of steps; `nemotron-3.5-lightning` went from 10 to 12 passes of 24.
+
+### Fixes
+
+- Context: one active observation may now use up to a third of the context budget (`max_context_tokens * 4 / 3` chars, at least 2,400) before head+tail elision, instead of a fixed 2,400 chars. Before, a 6-12 KB test file or a 100-line slice of one was always cut to head+tail, so the model asked for another slice, got that cut too, and re-read the same file 10+ times: on the Polyglot-Python fast set 24 of 48 runs ended at the step cap, 45% of their steps were reads and only 19% were edits. The hard budget still folds older observations first, so the prompt cannot overflow; `ContextAssembler(active_char_cap=...)` still sets a fixed cap.
+- Providers: when a server (Ollama, vLLM, llama.cpp behind `openai`, `anthropic`) answers HTTP 500 because it rejected the model's own tool call (`invalid tool call arguments for "act": unexpected end of JSON input`), the call is no longer retried and no longer ends the session as `worker_error` (#138). The model gets one line (`Your last call was rejected: the tool-call JSON was invalid or cut off. Send a shorter call, e.g. write long files in smaller pieces.`) through the existing no-action reminder and carries on, bounded by `max_steps`. Before, 13 of 34 Polyglot-Python runs on `qwen3.5:9b` died this way, mid-task and often with most tests passing. `ModelResponse` gains an optional `hint`. 0 static prompt tokens.
+
 ## v0.2.6 (2026-10-23)
 
 Found by using tether as its own SWE agent and by the v0.2.5 post-release check: a sandbox that refused harmless commands, sessions that only read, and a `query` that could not say why it found nothing. Closes #77, #93, #125, #127.

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/e2e/test_faults.py

@@ -26,6 +26,18 @@ def test_persistent_5xx_fails_loudly_with_exit_5(tether: Tether, chaos) -> None:
     assert "unavailable after 3 attempts" in r["failure"]["message"]
 
 
+def test_rejected_tool_call_reaches_the_model_instead_of_ending_the_session(
+    tether: Tether, chaos
+) -> None:
+    """#138: a 500 naming an invalid tool call is model feedback, not a provider outage."""
+    chaos.fault("status", code=500, error='invalid tool call arguments for "act": unexpected end')
+    chaos.script(("done", "ok"))
+    r = tether.run("go", "--max-steps", "6")
+    assert (r["rc"], r["status"]) == (0, "COMPLETED"), r
+    assert len(chaos.requests) == 2, "the rejected call must not be retried"
+    assert "cut off" in "\n".join(t["content"] or "" for t in tether.turns(r["id"]))
+
+
 def test_trickling_response_hits_the_per_attempt_deadline(tmp_path: Path, chaos) -> None:
     """#88: bytes keep arriving so httpx's read timeout never fires; the deadline must."""
     chaos.fault("trickle", times=3, seconds=60)

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tests/test_context.py

@@ -245,7 +245,7 @@ def test_tombstone_hint_follows_mem_availability(tmp_path: Path) -> None:
     # active (not yet folded) head+tail elision marker follows the same rule
     store = SQLiteStore(db_path=tmp_path / "c.db")
     rec = store.create_session("g")
-    obs = store.add_observation(rec.id, step=1, cmd="bash ls", raw_output="x" * 5000)
+    obs = store.add_observation(rec.id, step=1, cmd="bash ls", raw_output="x" * 20000)
     store.add_turn(rec.id, step=1, role="tool", content="", obs_id=obs.id)
     msgs = ContextAssembler(mem_enabled=False).assemble(
         system_prompt="S",
@@ -320,3 +320,26 @@ def test_mem_recall_results_are_not_folded_again(tmp_path: Path) -> None:
     # Folding a recall's own output sent GLM-5.3 on a 10-step `mem recall obs_N` chain (#86).
     text = _text(tmp_path, ["bash ls", "mem recall obs_1", "bash echo a", "bash echo b"])
     assert _live(text, 2) and "obs_1 folded" in text and "obs_3 folded" in text
+
+
+def test_active_observation_cap_follows_the_context_budget(tmp_path: Path) -> None:
+    """A 9 KB test file is shown whole on the default budget, head+tail on a tiny one."""
+    store = SQLiteStore(db_path=tmp_path / "c.db")
+    rec = store.create_session("g")
+    obs = store.add_observation(rec.id, step=1, cmd="bash cat t.py", raw_output="x" * 9000)
+    store.add_turn(rec.id, step=1, role="tool", content="", obs_id=obs.id)
+
+    def shown(**kw: int) -> str:
+        msgs = ContextAssembler(**kw).assemble(
+            system_prompt="S",
+            goal="g",
+            turns=store.get_turns(rec.id),
+            observations={obs.id: obs},
+            pins={},
+            current_step=1,
+        )
+        return str(msgs)
+
+    assert "elided" not in shown()
+    assert "elided" in shown(max_context_tokens=2048)
+    assert ContextAssembler(max_context_tokens=100).active_char_cap == 2400

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tests/test_harness.py

@@ -718,3 +718,16 @@ def test_awk_is_quiet_unless_it_writes(cmd: str, quiet: bool) -> None:
 )
 def test_comparison_operators_are_not_redirects(cmd: str, quiet: bool) -> None:
     assert is_quiet(cmd) is quiet
+
+
+async def test_provider_hint_reaches_the_model_and_the_session_continues(tmp_path: Path) -> None:
+    provider = FakeScriptedProvider(
+        [
+            ModelResponse(content="", hint="Your last call was cut off."),
+            ModelResponse(content="", action=ActionCall(cmd="done", stdin="ok")),
+        ]
+    )
+    harness = Harness(provider=provider, db_path=tmp_path / "t.db", max_steps=5)
+    rec = await harness.run("go")
+    assert rec.status == "COMPLETED"
+    assert any("Your last call was cut off." in str(m) for m in provider.recorded_calls[-1])

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tests/test_params.py

@@ -125,3 +125,33 @@ async def test_cli_param_flag(tmp_path: Path, capsys: pytest.CaptureFixture[str]
     assert stored == {"temperature": 0, "think": False}
     assert await _async_main([*argv, "--param", "oops", "g"]) == 1
     assert "KEY=VALUE" in capsys.readouterr().err
+
+
+async def test_ollama_rejected_tool_call_is_model_feedback_not_an_outage() -> None:
+    calls = 0
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        nonlocal calls
+        calls += 1
+        return httpx.Response(
+            500, text='{"error":"invalid tool call arguments for \\"act\\": unexpected end"}'
+        )
+
+    prov = OllamaProvider("m", client=httpx.AsyncClient(transport=httpx.MockTransport(handler)))
+    resp = await prov.generate([{"role": "user", "content": "x"}], [])
+    assert calls == 1  # the same request would fail the same way
+    assert resp.action is None and "cut off" in resp.hint
+
+
+@pytest.mark.parametrize("make", [OpenAIProvider, AnthropicProvider])
+async def test_other_http_providers_also_turn_a_rejected_tool_call_into_feedback(make: Any) -> None:
+    calls = 0
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        nonlocal calls
+        calls += 1
+        return httpx.Response(500, text="invalid tool call arguments")
+
+    prov = make("m", client=httpx.AsyncClient(transport=httpx.MockTransport(handler)))
+    resp = await prov.generate([{"role": "user", "content": "x"}], [])
+    assert calls == 1 and resp.action is None and "cut off" in resp.hint

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/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.6"
+    assert tether.__version__ == "0.2.7"
     for symbol in tether.__all__:
         assert hasattr(tether, symbol)

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tether/__init__.py

@@ -32,7 +32,7 @@ from tether.store import (
     ToolOffender,
 )
 
-__version__ = "0.2.6"
+__version__ = "0.2.7"
 
 __all__ = [
     "ActionCall",

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tether/context.py

@@ -159,7 +159,7 @@ class ContextAssembler:
         *,
         fold_after_turns: int = 2,
         fold_char_threshold: int = 200,
-        active_char_cap: int = 2400,
+        active_char_cap: int | None = None,
         max_context_tokens: int = 8192,
         structured: bool = False,
         mem_enabled: bool = True,
@@ -167,7 +167,11 @@ class ContextAssembler:
     ) -> None:
         self.fold_after_turns = fold_after_turns
         self.fold_char_threshold = fold_char_threshold
-        self.active_char_cap = active_char_cap
+        # One observation may use a third of the context (4 chars/token); the budget still folds
+        # older ones first, so a 12 KB test file is seen whole instead of head+tail, then re-read.
+        self.active_char_cap = (
+            max(2400, max_context_tokens * 4 // 3) if active_char_cap is None else active_char_cap
+        )
         self.max_context_tokens = max_context_tokens
         # True: replay past actions as tool_calls + tool results (provider adapters translate);
         # False: textual fallback for providers without tool messages.

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tether/harness.py

@@ -761,7 +761,8 @@ class Harness:
                         session_id=session_id,
                         step=step,
                         role="user",
-                        content=(
+                        content=resp.hint
+                        or (
                             "System reminder: Use `act(cmd, stdin)` to execute a tool command, "
                             'or call `act("done", stdin="<final deliverable>")` to finish.'
                         ),
@@ -1027,8 +1028,8 @@ class Harness:
                     nudged = False
                     stalls = 0
 
-                # One-shot nudge after QUIET_NUDGE_STEPS quiet steps following a change
                 out = dispatch.output
+                # One-shot nudge after QUIET_NUDGE_STEPS quiet steps following a change
                 if changed and not nudged and quiet_run >= QUIET_NUDGE_STEPS:
                     out += (
                         f"\n[NUDGE] No file changes for {QUIET_NUDGE_STEPS} steps. If the task is "

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tether/providers/anthropic.py

@@ -14,6 +14,7 @@ from tether.providers.base import (
     extract_fallback_action,
     limiter_for,
     post_with_retry,
+    rejected_call,
 )
 
 
@@ -156,6 +157,8 @@ class AnthropicProvider:
             limiter=self._limiter,
             json=payload,
         )
+        if rejected := rejected_call(resp):
+            return rejected
         resp.raise_for_status()
         data = resp.json()
 

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tether/providers/base.py

@@ -35,6 +35,7 @@ class ModelResponse:
     action: ActionCall | None = None
     prompt_tokens: int = 0
     completion_tokens: int = 0
+    hint: str = ""  # shown to the model instead of the generic reminder when it sent no usable call
 
 
 ProviderResponse = ModelResponse
@@ -69,6 +70,21 @@ def auth_message(
 
 
 RETRY_STATUS = frozenset({429, 500, 502, 503, 504})
+# A server that rejects the model's own tool call (cut-off JSON) answers the same way every time.
+MODEL_FAULT = "tool call"
+REJECTED_CALL_HINT = (
+    "Your last call was rejected: the tool-call JSON was invalid or cut off. "
+    "Send a shorter call, e.g. write long files in smaller pieces."
+)
+
+
+def rejected_call(resp: httpx.Response) -> ModelResponse | None:
+    """Turn a server's 500 about the model's own bad tool call into feedback for the model."""
+    if resp.status_code == 500 and MODEL_FAULT in resp.text:
+        return ModelResponse(content="", hint=REJECTED_CALL_HINT)
+    return None
+
+
 _TRANSIENT = (httpx.TimeoutException, httpx.NetworkError, TimeoutError)
 
 
@@ -167,7 +183,7 @@ async def post_with_retry(
             continue
         if resp.status_code in (401, 403):
             raise ProviderError(auth_message(provider, key_env, resp.status_code, resp.text))
-        if resp.status_code not in RETRY_STATUS:
+        if resp.status_code not in RETRY_STATUS or rejected_call(resp):
             return resp
         last = f"HTTP {resp.status_code}: {resp.text[:120]!r}"
         if resp.status_code == 429:  # rate limits reset per minute: wait longer, honor Retry-After

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tether/providers/ollama.py

@@ -15,6 +15,7 @@ from tether.providers.base import (
     extract_fallback_action,
     limiter_for,
     post_with_retry,
+    rejected_call,
 )
 
 # Request-level keys of /api/chat; everything else in `params` is a sampling option.
@@ -133,6 +134,8 @@ class OllamaProvider:
                 self.model_name = fallback
                 payload["model"] = fallback
                 resp = await self._chat(client, payload)
+        if rejected := rejected_call(resp):
+            return rejected
         resp.raise_for_status()
         data = resp.json()
 

{tether_sdk-0.2.6 → tether_sdk-0.2.7}/tether/providers/openai.py

@@ -15,6 +15,7 @@ from tether.providers.base import (
     extract_fallback_action,
     limiter_for,
     post_with_retry,
+    rejected_call,
 )
 
 
@@ -95,6 +96,8 @@ class OpenAIProvider:
             limiter=self._limiter,
             json=payload,
         )
+        if rejected := rejected_call(resp):
+            return rejected
         resp.raise_for_status()
         data = resp.json()