tsugite-cli 0.17.0__tar.gz → 0.17.2__tar.gz

{tsugite_cli-0.17.0 → tsugite_cli-0.17.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.17.0
+Version: 0.17.2
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE

{tsugite_cli-0.17.0 → tsugite_cli-0.17.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.17.0"
+version = "0.17.2"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"

tsugite_cli-0.17.2/tsugite/builtin_agents/job_verifier.md

@@ -0,0 +1,71 @@
+---
+name: job_verifier
+description: Reasoning-blind verifier — judges a Job's worker output against its acceptance criteria, inspecting workspace file artifacts before deciding. Returns strict JSON. Spawned fresh per round with no parent context.
+extends: none
+max_turns: 10
+tools: [read_file, run]
+---
+
+# Job Verifier
+
+You are a reasoning-blind verifier. You receive a list of acceptance criteria
+and a work-output blob (the worker's structured summary, optionally with a
+`git diff`). You run in the same working directory the worker ran in, so the
+files it produced are directly inspectable.
+
+You do not see the worker's reasoning. You do not see the parent chat. Claims
+are not evidence: judge each criterion against the visible artifacts, or by
+inspecting the workspace yourself.
+
+## Task
+
+{{ user_prompt }}
+
+## How to verify
+
+- Read the worker's `## Summary`, `## Output` (if present), `## Acceptance
+  criteria`, and `## Artifacts` sections.
+- When the deliverable is inline text (poem, snippet, written answer), it
+  lives in `## Output`. Judge ACs about the content (length, format, contains
+  word X, syllable count, etc.) against the verbatim Output text.
+- When a criterion concerns a file's existence, contents, or structure, read
+  the actual file before deciding: `read_file(path=...)` resolves against your
+  working directory; use `run` for listings or diffs. Only fail such a
+  criterion after inspection confirms the miss or the file is genuinely
+  absent/unreadable - never just because the worker's summary doesn't inline
+  the contents.
+- If a PR URL or commit SHA is provided, you may inspect it via `run` (e.g.
+  `git show <sha>`, `gh pr view <url>`) when that materially affects the
+  verdict.
+- Do not run long-running commands or perform setup; you have a turn budget.
+- Be skeptical, not pedantic. A criterion like "tests pass" is met if the
+  worker reports a passing test run; you don't need to re-run unless evidence
+  is contradictory.
+
+## Tool use
+
+To inspect, reply with a single ```python code block calling a tool:
+
+```python
+read_file(path="docs/page.md")
+```
+
+The result comes back as an observation; keep inspecting or emit the verdict.
+Never mix the final verdict into a tool-call turn.
+
+## Output contract
+
+When you have enough evidence, reply with ONLY a strictly-valid JSON object as
+plain text - no code block, no markdown fences, no prose before or after:
+
+```
+{
+  "ac_results": [
+    {"ac_text": "<verbatim AC>", "pass": true|false, "reason": "<one sentence>"}
+  ],
+  "overall_pass": true|false
+}
+```
+
+Include one entry per acceptance criterion, in the given order. `overall_pass`
+is `true` only if every `ac_results[i].pass` is `true`.

{tsugite_cli-0.17.0 → tsugite_cli-0.17.2}/tsugite/cli/daemon.py

@@ -716,20 +716,36 @@ token_app = typer.Typer(help="Manage API authentication tokens")
 daemon_app.add_typer(token_app, name="token")
 
 
-def _get_tokens_path() -> Path:
+def _get_tokens_path(config_path: Optional[Path] = None) -> Path:
+    """Resolve the daemon's token storage from its config so the CLI writes
+    where the daemon reads. Previously the CLI always used the XDG default,
+    so a daemon with a custom `state_dir` never saw CLI-created tokens.
+    Falls back to the default state dir when no daemon config exists yet.
+    """
     from tsugite_daemon.auth import TOKENS_FILENAME
+    from tsugite_daemon.config import load_daemon_config
+
+    try:
+        state_dir = load_daemon_config(config_path).state_dir
+    except ValueError:
+        state_dir = get_xdg_data_path("daemon")
+    return state_dir / TOKENS_FILENAME
+
 
-    return get_xdg_data_path("daemon") / TOKENS_FILENAME
+_TOKEN_CONFIG_OPTION = typer.Option(
+    None, "--config", "-c", help="Daemon config to resolve state_dir from (default: ~/.config/tsugite/daemon.yaml)"
+)
 
 
 @token_app.command("create")
 def token_create(
     name: str = typer.Option("", "--name", "-n", help="Name for the token (for identification)"),
+    config: Optional[Path] = _TOKEN_CONFIG_OPTION,
 ):
     """Create a new admin API token."""
     from tsugite_daemon.auth import TokenStore
 
-    store = TokenStore(_get_tokens_path())
+    store = TokenStore(_get_tokens_path(config))
     t, raw = store.create_admin_token(name=name)
     print(raw)
     err = Console(stderr=True)
@@ -740,11 +756,11 @@ def token_create(
 
 
 @token_app.command("list")
-def token_list():
+def token_list(config: Optional[Path] = _TOKEN_CONFIG_OPTION):
     """List all admin API tokens."""
     from tsugite_daemon.auth import TokenStore
 
-    store = TokenStore(_get_tokens_path())
+    store = TokenStore(_get_tokens_path(config))
     tokens = store.list_admin_tokens()
     if not tokens:
         console.print("[dim]No tokens configured.[/dim]")
@@ -757,11 +773,12 @@ def token_list():
 @token_app.command("revoke")
 def token_revoke(
     name_or_prefix: str = typer.Argument(help="Token name or prefix to revoke"),
+    config: Optional[Path] = _TOKEN_CONFIG_OPTION,
 ):
     """Revoke an admin API token."""
     from tsugite_daemon.auth import TokenStore
 
-    store = TokenStore(_get_tokens_path())
+    store = TokenStore(_get_tokens_path(config))
     if store.revoke_admin_token(name_or_prefix):
         console.print(f"[green]Token '{name_or_prefix}' revoked.[/green]")
     else:

tsugite_cli-0.17.2/tsugite/core/record_store.py

@@ -0,0 +1,316 @@
+"""Shared base for the daemon's record stores.
+
+One copy of the locking, persistence, and guarded state-machine logic that
+JobStore and TerminalSessionStore both need - the two had already started to
+drift (one locked its read accessors, the other didn't).
+
+Persistence is a per-collection table in ``<dir>/daemon.db`` (SQLite, WAL,
+write-through): each mutation upserts or deletes exactly the affected row, so
+nothing is lost on a crash and a large store isn't re-serialized wholesale per
+save. The legacy per-store ``*.json`` file remains the constructor argument:
+it is read once as a migration source when the db collection is empty, and
+left untouched afterwards as a backup.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import sqlite3
+import threading
+from dataclasses import asdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+DAEMON_DB_FILENAME = "daemon.db"
+
+_BUSY_TIMEOUT_MS = 5000
+_COLLECTION_NAME_RE = re.compile(r"^[a-z_][a-z0-9_]*$")
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class SqliteCollectionStorage:
+    """One collection (table) of ``id -> JSON document`` rows in a shared SQLite db.
+
+    Rows are opaque JSON documents rather than per-field columns so dataclass
+    schema growth never needs a db migration; queries stay in the stores'
+    in-memory dicts. The connection is NOT internally synchronized - callers
+    serialize access with their own lock (every store method already runs
+    under one).
+    """
+
+    def __init__(self, db_path: Path, collection: str):
+        if not _COLLECTION_NAME_RE.match(collection):
+            raise ValueError(f"Invalid collection name: {collection!r}")
+        # Reject non-paths outright: a test's MagicMock would otherwise
+        # materialize junk directories/db files named after the mock's repr in
+        # the CWD (Path(mock) "works" via the mock's auto-generated __fspath__).
+        if not isinstance(db_path, (str, Path)):
+            raise TypeError(f"db_path must be a Path, got {type(db_path).__name__}")
+        db_path = Path(db_path)
+        self._collection = collection
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(str(db_path), check_same_thread=False, isolation_level=None)
+        self._conn.execute("PRAGMA journal_mode=WAL")
+        self._conn.execute(f"PRAGMA busy_timeout={_BUSY_TIMEOUT_MS}")
+        self._conn.execute("PRAGMA synchronous=NORMAL")
+        self._conn.execute(f'CREATE TABLE IF NOT EXISTS "{collection}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)')
+        # Tracks which collections have completed their one-time legacy-JSON
+        # import. Row-count can't stand in for this: a collection legitimately
+        # emptied at runtime must NOT re-import the stale legacy file on the
+        # next start.
+        self._conn.execute('CREATE TABLE IF NOT EXISTS "_migrated" (collection TEXT PRIMARY KEY, at TEXT NOT NULL)')
+        # Owner-only, like tokens.json was: the db holds session content and
+        # auth token hashes. SQLite propagates the mode to -wal/-shm siblings.
+        try:
+            os.chmod(db_path, 0o600)
+        except OSError:
+            pass
+
+    @classmethod
+    def for_state_file(cls, legacy_path: Path, collection: str) -> "SqliteCollectionStorage":
+        """Storage for a store whose legacy JSON lived at ``legacy_path``:
+        the shared daemon.db sits next to it."""
+        return cls(legacy_path.parent / DAEMON_DB_FILENAME, collection)
+
+    def load_or_migrate(self, legacy_path: Path, collection_key: str) -> tuple[list[dict], bool]:
+        """Entries from the db, falling back to a one-time legacy JSON import.
+
+        The import runs at most once per collection (tracked in the _migrated
+        table), so a collection emptied at runtime stays empty across restarts
+        instead of resurrecting the stale legacy file.
+
+        Returns (entries, migrating). When migrating is True the caller must
+        persist its parsed records back (replace_all / _save) so the import
+        becomes durable; the legacy file is left untouched as a backup.
+        """
+        entries = self.load_all()
+        if entries or self._is_migrated():
+            self._mark_migrated()  # stamp dbs created before the marker existed
+            return entries, False
+        entries = load_legacy_json_entries(legacy_path, collection_key)
+        if entries:
+            logger.info(
+                "Migrating %d %s record(s) from %s into daemon.db (legacy file kept as backup)",
+                len(entries),
+                collection_key,
+                legacy_path.name,
+            )
+        self._mark_migrated()
+        return entries, bool(entries)
+
+    def _is_migrated(self) -> bool:
+        row = self._conn.execute('SELECT 1 FROM "_migrated" WHERE collection = ?', (self._collection,)).fetchone()
+        return row is not None
+
+    def _mark_migrated(self) -> None:
+        self._conn.execute(
+            'INSERT OR IGNORE INTO "_migrated" (collection, at) VALUES (?, ?)',
+            (self._collection, datetime.now(timezone.utc).isoformat()),
+        )
+
+    def exists_any(self) -> bool:
+        """True when the collection has at least one row (no full scan)."""
+        return self._conn.execute(f'SELECT 1 FROM "{self._collection}" LIMIT 1').fetchone() is not None
+
+    def get(self, record_id: str) -> dict | None:
+        row = self._conn.execute(f'SELECT data FROM "{self._collection}" WHERE id = ?', (record_id,)).fetchone()
+        if row is None:
+            return None
+        try:
+            return json.loads(row[0])
+        except json.JSONDecodeError as e:
+            logger.error("Corrupt %s row %s: %s", self._collection, record_id, e)
+            return None
+
+    def load_all(self) -> list[dict]:
+        rows = self._conn.execute(f'SELECT data FROM "{self._collection}"').fetchall()
+        entries = []
+        for (data,) in rows:
+            try:
+                entries.append(json.loads(data))
+            except json.JSONDecodeError as e:
+                logger.error("Skipping corrupt %s row: %s", self._collection, e)
+        return entries
+
+    def upsert(self, record_id: str, entry: dict) -> None:
+        # default=str: a stray non-JSON value in a record field must degrade to
+        # its string form, not crash the mutation that carries it.
+        self._conn.execute(
+            f'INSERT INTO "{self._collection}" (id, data) VALUES (?, ?) '
+            "ON CONFLICT(id) DO UPDATE SET data = excluded.data",
+            (record_id, json.dumps(entry, default=str)),
+        )
+
+    def delete(self, record_id: str) -> None:
+        self._conn.execute(f'DELETE FROM "{self._collection}" WHERE id = ?', (record_id,))
+
+    def replace_all(self, entries: dict[str, dict]) -> None:
+        """Atomically make the collection equal to ``entries``."""
+        self._conn.execute("BEGIN IMMEDIATE")
+        try:
+            self._conn.execute(f'DELETE FROM "{self._collection}"')
+            self._conn.executemany(
+                f'INSERT INTO "{self._collection}" (id, data) VALUES (?, ?)',
+                [(rid, json.dumps(entry, default=str)) for rid, entry in entries.items()],
+            )
+            self._conn.execute("COMMIT")
+        except Exception:
+            self._conn.execute("ROLLBACK")
+            raise
+
+    def close(self) -> None:
+        self._conn.close()
+
+
+def load_legacy_json_entries(path: Path, collection_key: str) -> list[dict]:
+    """Entries from a legacy whole-file JSON store, tolerating the list shape
+    (``{key: [...]}``), the dict shape (``{key: {id: {...}}}``), and the bare
+    top-level array some stores used (tokens.json, push_subscriptions.json).
+    Returns [] when the file is absent or unreadable."""
+    if not path.exists():
+        return []
+    try:
+        data = json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError) as e:
+        logger.error("Failed to load legacy %s from %s: %s", collection_key, path, e)
+        return []
+    raw = data.get(collection_key, []) if isinstance(data, dict) else data
+    if isinstance(raw, dict):
+        return list(raw.values())
+    if isinstance(raw, list):
+        return [e for e in raw if isinstance(e, dict)]
+    return []
+
+
+class RecordStore:
+    """In-memory dict of dataclass records + write-through SQLite persistence.
+
+    Records must have: id, state, updated_at, resolved_at, parent_session_id.
+    Subclasses define the class attributes below and may override `_load_entry`
+    (per-entry migrations) and `_after_load` (post-load reconciliation; return
+    True to persist the result).
+    """
+
+    record_cls: type
+    collection_key: str  # table name / legacy top-level JSON key, e.g. "jobs"
+    record_label: str  # for error messages, e.g. "job"
+    valid_transitions: dict[str, frozenset[str]]
+    terminal_states: frozenset[str]
+    transition_error_cls: type[ValueError] = ValueError
+
+    def __init__(self, path: Path):
+        self._path = path  # legacy JSON location; migration source only
+        self._storage = SqliteCollectionStorage.for_state_file(path, self.collection_key)
+        self._records: dict = {}
+        self._lock = threading.Lock()
+        self._load()
+
+    def _persist(self, record) -> None:
+        """Write-through one record's row. Caller holds the lock."""
+        self._storage.upsert(record.id, asdict(record))
+
+    def add(self, record):
+        with self._lock:
+            if record.id in self._records:
+                raise ValueError(f"{self.record_cls.__name__} already exists: {record.id}")
+            self._records[record.id] = record
+            self._persist(record)
+        return record
+
+    def get(self, record_id: str):
+        with self._lock:
+            return self._records.get(record_id)
+
+    def list_all(self) -> list:
+        with self._lock:
+            return list(self._records.values())
+
+    def list_active(self) -> list:
+        with self._lock:
+            return [r for r in self._records.values() if r.state not in self.terminal_states]
+
+    def list_for_parent(self, parent_session_id: str) -> list:
+        with self._lock:
+            return [r for r in self._records.values() if r.parent_session_id == parent_session_id]
+
+    def update_state(self, record_id: str, new_state: str):
+        with self._lock:
+            record = self._records.get(record_id)
+            if record is None:
+                raise KeyError(f"Unknown {self.record_label}: {record_id}")
+            allowed = self.valid_transitions.get(record.state, frozenset())
+            if new_state not in allowed:
+                raise self.transition_error_cls(
+                    f"Invalid {self.record_cls.__name__} state transition: "
+                    f"{record.state} -> {new_state} ({self.record_label} {record_id})"
+                )
+            record.state = new_state
+            record.updated_at = now_iso()
+            if new_state in self.terminal_states and not record.resolved_at:
+                record.resolved_at = record.updated_at
+            self._on_state_updated(record)
+            self._persist(record)
+            return record
+
+    def _on_state_updated(self, record) -> None:
+        """Hook called (under the lock) after a state transition, before persist.
+        Hooks that drop other records must go through `_delete_record` so the
+        deletion is durable."""
+
+    def _delete_record(self, record_id: str) -> None:
+        """Remove a record from memory AND storage. Caller holds the lock."""
+        self._records.pop(record_id, None)
+        self._storage.delete(record_id)
+
+    def update(self, record_id: str, **fields):
+        with self._lock:
+            record = self._records.get(record_id)
+            if record is None:
+                raise KeyError(f"Unknown {self.record_label}: {record_id}")
+            for key, value in fields.items():
+                if not hasattr(record, key):
+                    raise ValueError(f"Unknown {self.record_cls.__name__} field: {key}")
+                setattr(record, key, self._coerce_update_value(key, value))
+            record.updated_at = now_iso()
+            self._persist(record)
+            return record
+
+    def _coerce_update_value(self, key: str, value):
+        """Hook for per-field validation/coercion in update()."""
+        return value
+
+    def _load_entry(self, entry: dict):
+        """Build a record from a raw persisted entry; return None to drop it.
+        Subclasses apply schema migrations here."""
+        try:
+            return self.record_cls(**entry)
+        except TypeError as e:
+            logger.error("Skipping malformed %s record: %s (%s)", self.record_cls.__name__, entry.get("id"), e)
+            return None
+
+    def _after_load(self) -> bool:
+        """Post-load reconciliation hook. Return True to persist the result."""
+        return False
+
+    def _load(self) -> None:
+        entries, migrating = self._storage.load_or_migrate(self._path, self.collection_key)
+        for entry in entries:
+            record = self._load_entry(entry)
+            if record is not None:
+                self._records[record.id] = record
+        if self._after_load() or migrating:
+            self._storage.replace_all({r.id: asdict(r) for r in self._records.values()})
+
+
+# Deprecated alias - external plugins may still import the old name.
+JsonRecordStore = RecordStore
+
+__all__ = ["RecordStore", "JsonRecordStore", "SqliteCollectionStorage", "load_legacy_json_entries", "now_iso"]

{tsugite_cli-0.17.0 → tsugite_cli-0.17.2}/tsugite/providers/anthropic.py

@@ -35,27 +35,30 @@ _EFFORT_TO_BUDGET = {
 # Auto-generated by scripts/update_model_registry.py — do not edit manually
 # fmt: off
 _ANTHROPIC_MODELS: dict[str, ModelInfo] = {
-    "anthropic/claude-3-7-sonnet-20250219": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True),
+    "anthropic/claude-3-5-sonnet-20240620": ModelInfo(max_input_tokens=200_000, max_output_tokens=8_192, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True),
+    "anthropic/claude-3-5-sonnet-20241022": ModelInfo(max_input_tokens=200_000, max_output_tokens=8_192, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True),
+    "anthropic/claude-3-7-sonnet-20250219": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
     "anthropic/claude-3-haiku-20240307": ModelInfo(max_input_tokens=200_000, max_output_tokens=4_096, input_cost_per_million=0.25, output_cost_per_million=1.25, supports_vision=True),
     "anthropic/claude-3-opus-20240229": ModelInfo(max_input_tokens=200_000, max_output_tokens=4_096, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True),
-    "anthropic/claude-4-opus-20250514": ModelInfo(max_input_tokens=200_000, max_output_tokens=32_000, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True),
-    "anthropic/claude-4-sonnet-20250514": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True),
-    "anthropic/claude-haiku-4-5": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=1.0, output_cost_per_million=5.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-haiku-4-5-20251001": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=1.0, output_cost_per_million=5.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-1": ModelInfo(max_input_tokens=200_000, max_output_tokens=32_000, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-1-20250805": ModelInfo(max_input_tokens=200_000, max_output_tokens=32_000, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-20250514": ModelInfo(max_input_tokens=200_000, max_output_tokens=32_000, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-5": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-5-20251101": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-6": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-6-20260205": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-7": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-7-20260416": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-opus-4-8": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-sonnet-4-20250514": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-sonnet-4-5": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-sonnet-4-5-20250929": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
-    "anthropic/claude-sonnet-4-6": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supported_effort_levels=["low", "medium", "high", "max"]),
+    "anthropic/claude-3-sonnet-20240229": ModelInfo(max_input_tokens=200_000, max_output_tokens=4_096, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True),
+    "anthropic/claude-fable-5": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=10.0, output_cost_per_million=50.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"], thinking_style="adaptive"),
+    "anthropic/claude-haiku-4-5": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=1.0, output_cost_per_million=5.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-haiku-4-5-20251001": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=1.0, output_cost_per_million=5.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-opus-4-0": ModelInfo(max_input_tokens=200_000, max_output_tokens=32_000, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-opus-4-1": ModelInfo(max_input_tokens=200_000, max_output_tokens=32_000, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-opus-4-1-20250805": ModelInfo(max_input_tokens=200_000, max_output_tokens=32_000, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-opus-4-20250514": ModelInfo(max_input_tokens=200_000, max_output_tokens=32_000, input_cost_per_million=15.0, output_cost_per_million=75.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-opus-4-5": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-opus-4-5-20251101": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-opus-4-6": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-opus-4-7": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"], thinking_style="adaptive"),
+    "anthropic/claude-opus-4-8": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=5.0, output_cost_per_million=25.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"], thinking_style="adaptive"),
+    "anthropic/claude-sonnet-4-0": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-sonnet-4-20250514": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-sonnet-4-5": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-sonnet-4-5-20250929": ModelInfo(max_input_tokens=200_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-sonnet-4-6": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=64_000, input_cost_per_million=3.0, output_cost_per_million=15.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "max"], thinking_style="budget_tokens"),
+    "anthropic/claude-sonnet-5": ModelInfo(max_input_tokens=1_000_000, max_output_tokens=128_000, input_cost_per_million=2.0, output_cost_per_million=10.0, supports_vision=True, supports_reasoning=True, supported_effort_levels=["low", "medium", "high", "xhigh", "max"], thinking_style="adaptive"),
 }
 # fmt: on
 # --- END GENERATED MODELS (anthropic) --- #
@@ -114,20 +117,37 @@ class AnthropicProvider:
         if system:
             body["system"] = system
 
+        # The adaptive-thinking generation (Opus 4.7+, Sonnet 5, Fable 5)
+        # rejects budget_tokens thinking AND sampling params with 400; effort
+        # rides output_config there instead. Unknown models fall back to the
+        # budget_tokens path (pre-adaptive behavior).
+        info = self.get_model_info(model)
+        adaptive = info is not None and info.thinking_style == "adaptive"
+
         for key in ("temperature", "top_p", "top_k", "stop_sequences", "metadata"):
-            if key in kwargs:
-                body[key] = kwargs[key]
+            if key not in kwargs:
+                continue
+            if adaptive and key in ("temperature", "top_p", "top_k"):
+                logger.warning(
+                    "Model %s rejects sampling param %s (adaptive-thinking generation); dropping", model, key
+                )
+                continue
+            body[key] = kwargs[key]
 
         effort = kwargs.get("reasoning_effort")
         if effort:
-            budget = _EFFORT_TO_BUDGET.get(effort)
-            if budget is None:
-                logger.warning("Unknown reasoning_effort=%r for Anthropic; dropping", effort)
+            if adaptive:
+                body["thinking"] = {"type": "adaptive"}
+                body["output_config"] = {"effort": effort}
             else:
-                # Extended thinking requires max_tokens > budget_tokens.
-                if body["max_tokens"] <= budget:
-                    body["max_tokens"] = budget + 1024
-                body["thinking"] = {"type": "enabled", "budget_tokens": budget}
+                budget = _EFFORT_TO_BUDGET.get(effort)
+                if budget is None:
+                    logger.warning("Unknown reasoning_effort=%r for Anthropic; dropping", effort)
+                else:
+                    # Extended thinking requires max_tokens > budget_tokens.
+                    if body["max_tokens"] <= budget:
+                        body["max_tokens"] = budget + 1024
+                    body["thinking"] = {"type": "enabled", "budget_tokens": budget}
 
         url = f"{self.api_base}/v1/messages"
         headers = self._build_headers()

{tsugite_cli-0.17.0 → tsugite_cli-0.17.2}/tsugite/providers/base.py

@@ -49,6 +49,11 @@ class ModelInfo:
     supports_reasoning: bool = False
     supports_streaming: bool = True
     supported_effort_levels: list[str] | None = None
+    # How the model exposes reasoning control: "budget_tokens" (extended
+    # thinking via thinking budgets) or "adaptive" (native effort parameter;
+    # budget_tokens and sampling params are rejected with 400). None when the
+    # model has neither or the style is unknown.
+    thinking_style: str | None = None
 
 
 @runtime_checkable