agent-foundry-runtime 0.4.0__py3-none-any.whl

agent_foundry/config.py

@@ -0,0 +1,190 @@
+"""Config management: ~/.config/agent-foundry/config.toml."""
+from __future__ import annotations
+
+import dataclasses
+import os
+import sys
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+CONFIG_PATH = Path.home() / ".config" / "agent-foundry" / "config.toml"
+LOG_DB_PATH = Path.home() / ".config" / "agent-foundry" / "executions.db"
+INDEX_CACHE_TTL_DEFAULT = 60  # seconds
+SCHEMA_VERSION = 1  # bumped on any config-shape change; reject mismatches on load
+
+DEFAULT_CONFIG = """# Agent Foundry configuration
+# Edit this file to tune the orchestrator.
+
+[core]
+skills_dir = "~/.claude/skills/agent-foundry"
+index_path = "~/.config/agent-foundry/skills-index.json"
+default_llm = "claude-3-7-sonnet-20250219"
+token_budget = 100000
+daemon_port = 8765
+index_cache_ttl_seconds = 60
+harness_type = "claude-code"
+executor_timeout_seconds = 120
+executor_max_tokens = 0
+executor_retries = 2
+
+[planner]
+# Score added per matched trigger pattern (regex).
+pattern_match_weight = 0.3
+# Score added if skill name or description appears in the prompt.
+name_in_prompt_boost = 0.2
+# Larger value = weaker cost penalty in the ranker.
+cost_penalty_divisor = 5000.0
+# Default top-N returned by /plan.
+max_results = 5
+# Semantic fallback (optional; requires the `semantic` extra).
+semantic_enabled = false
+semantic_model = "all-MiniLM-L6-v2"
+semantic_weight = 0.35
+rerank_enabled = false
+rerank_top_k = 10
+
+# System prompt for the generic-reasoning fallback skill.
+# Edit to override the built-in default.
+# fallback_system_prompt = "You are a helpful assistant..."
+"""
+
+
+@dataclass(frozen=True)
+class PlannerConfig:
+    """Tunable planner weights. Frozen — construct a new instance to change."""
+    pattern_match_weight: float = 0.3
+    name_in_prompt_boost: float = 0.2
+    cost_penalty_divisor: float = 5000.0
+    max_results: int = 5
+    semantic_enabled: bool = False
+    semantic_model: str = "all-MiniLM-L6-v2"
+    semantic_weight: float = 0.35
+    rerank_enabled: bool = False
+    rerank_top_k: int = 10
+
+
+@dataclass(frozen=True)
+class CoreConfig:
+    """Runtime config. Frozen — construct a new instance to change."""
+    skills_dir: str = "~/.claude/skills/agent-foundry"
+    index_path: str = "~/.config/agent-foundry/skills-index.json"
+    default_llm: str = "claude-3-7-sonnet-20250219"
+    token_budget: int = 100000
+    daemon_port: int = 8765
+    index_cache_ttl_seconds: int = 60
+    harness_type: str = "claude-code"
+    executor_timeout_seconds: int = 120
+    executor_max_tokens: int = 0
+    executor_retries: int = 2
+
+
+@dataclass(frozen=True)
+class Config:
+    """Top-level config. Frozen; one instance per load.
+
+    The runtime should treat the loaded Config as immutable. To change a value
+    (e.g. after a `/plan --max N` call), construct a new Config with the change
+    applied. Tests that want to override behavior should patch the fields they
+    care about via dataclasses.replace.
+    """
+    core: CoreConfig = field(default_factory=CoreConfig)
+    planner: PlannerConfig = field(default_factory=PlannerConfig)
+    fallback_system_prompt: str | None = None
+    config_path: Path = CONFIG_PATH
+    schema_version: int = SCHEMA_VERSION
+
+    @classmethod
+    def load(cls, path: Path | None = None) -> "Config":
+        """Load config from path (default: ~/.config/agent-foundry/config.toml).
+
+        Missing file or sections fall back to defaults. The returned Config
+        is frozen; use `dataclasses.replace(cfg, core=...)` to derive a new
+        instance with overrides (e.g. CLI flags).
+        """
+        p = Path(path) if path else CONFIG_PATH
+        cfg = cls()
+        if not p.exists():
+            return dataclasses.replace(cfg, config_path=p)
+
+        try:
+            with open(p, "rb") as f:
+                data = tomllib.load(f)
+        except Exception as exc:
+            print(f"WARN: failed to parse {p}: {exc}", file=sys.stderr)
+            return dataclasses.replace(cfg, config_path=p)
+
+        # Schema version check: warn on mismatch (older files load with defaults
+        # applied; future bumps may refuse).
+        on_disk_version = data.get("schema_version", 0)
+        if on_disk_version and on_disk_version != SCHEMA_VERSION:
+            print(
+                f"WARN: {p} has schema_version={on_disk_version}, "
+                f"running version={SCHEMA_VERSION}. Some keys may be ignored.",
+                file=sys.stderr,
+            )
+
+        core_overrides = {
+            k: data["core"][k]
+            for k in cfg.core.__dataclass_fields__
+            if k in data.get("core", {})
+        }
+        planner_overrides = {
+            k: data["planner"][k]
+            for k in cfg.planner.__dataclass_fields__
+            if k in data.get("planner", {})
+        }
+        return dataclasses.replace(
+            cfg,
+            core=dataclasses.replace(cfg.core, **core_overrides),
+            planner=dataclasses.replace(cfg.planner, **planner_overrides),
+            fallback_system_prompt=data.get("fallback_system_prompt"),
+            config_path=p,
+        )
+
+    def save(self, path: Path | None = None) -> Path:
+        """Write current config to disk (overwrites)."""
+        p = Path(path) if path else self.config_path
+        p.parent.mkdir(parents=True, exist_ok=True)
+
+        # Render manually (preserves section comments)
+        lines: list[str] = []
+        lines.append("# Agent Foundry configuration")
+        lines.append("# Generated by `agent-foundry init`. Edit to tune.")
+        lines.append("")
+        lines.append(f"schema_version = {SCHEMA_VERSION}")
+        lines.append("")
+        lines.append("[core]")
+        for k, v in vars(self.core).items():
+            v_str = f'"{v}"' if isinstance(v, str) else str(v)
+            lines.append(f"{k} = {v_str}")
+        lines.append("")
+        lines.append("[planner]")
+        for k, v in vars(self.planner).items():
+            v_str = f'"{v}"' if isinstance(v, str) else str(v)
+            lines.append(f"{k} = {v_str}")
+        lines.append("")
+        if self.fallback_system_prompt is not None:
+            # toml multiline
+            lines.append("# Optional override for the generic-reasoning fallback prompt.")
+            escaped = self.fallback_system_prompt.replace("\\", "\\\\").replace('"', '\\"')
+            lines.append(f'fallback_system_prompt = "{escaped}"')
+            lines.append("")
+        else:
+            lines.append("# Uncomment to override the fallback prompt:")
+            lines.append('# fallback_system_prompt = "You are a helpful assistant..."')
+            lines.append("")
+
+        p.write_text("\n".join(lines))
+        return p
+
+
+def init_config(force: bool = False) -> Config:
+    """Create config dir + default config file. Returns loaded config."""
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    if not CONFIG_PATH.exists() or force:
+        cfg = Config()
+        cfg.save()
+    return Config.load()

agent_foundry/daemon.py

@@ -0,0 +1,220 @@
+"""FastAPI daemon: /health, /index, /plan, /execute, /loop, /events (SSE), /site-data."""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import time
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, StreamingResponse
+
+# Repo + generated web assets (used by the live-update SSE endpoint for local dev).
+_REPO = Path(__file__).resolve().parent.parent
+_WEB = _REPO / "web"
+
+
+def _site_signature() -> str:
+    """A cheap fingerprint of the skill/agent sources so the SSE loop can detect edits."""
+    parts = []
+    for base in ("skills", "agents"):
+        d = _REPO / base
+        if not d.exists():
+            continue
+        for f in sorted(d.rglob("*.md")):
+            try:
+                parts.append(f"{f.relative_to(_REPO)}:{int(f.stat().st_mtime)}")
+            except OSError:
+                continue
+    return "|".join(parts)
+
+from .config import Config, LOG_DB_PATH
+from .executor import execute as executor_run
+from .indexer import (
+    build_index,
+    get_index_cached,
+    invalidate_cache,
+    write_index,
+)
+from .logging_db import (
+    count_executions,
+    log_execution,
+    set_feedback,
+    learn,
+    list_instincts,
+    approve_instinct,
+    get_stats as db_stats,
+    engram_lookup,
+    get_skill_weights,
+    get_loop_session,
+)
+from .loop import resume_loop, run_loop
+from .models import (
+    ExecuteRequest,
+    FeedbackRequest,
+    IndexResponse,
+    LearnResponse,
+    LoopRequest,
+    LoopResumeRequest,
+    PlanRequest,
+)
+
+
+def create_app(cfg: Config | None = None) -> FastAPI:
+    cfg = cfg or Config.load()
+    app = FastAPI(title="Agent Foundry", version="0.2.0")
+    db_path = LOG_DB_PATH
+
+    # Dev-only: allow the statically served site (different origin) to reach the
+    # SSE + site-data endpoints for instant live updates.
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["GET"],
+        allow_headers=["*"],
+    )
+
+    @app.get("/health")
+    def health():
+        return {"status": "ok", "skills_indexed": 0}
+
+    @app.get("/site-data")
+    def site_data():
+        """Serve the generated data.json consumed by the reactive store (store.js)."""
+        f = _WEB / "data.json"
+        if not f.exists():
+            raise HTTPException(status_code=404, detail="data.json not generated yet — run scripts/gen-site-data.py")
+        return JSONResponse(json.loads(f.read_text(encoding="utf-8")))
+
+    @app.get("/events")
+    async def events():
+        """Server-Sent Events: emit a 'changed' event when skill/agent sources change."""
+        async def stream():
+            last = _site_signature()
+            yield "event: changed\ndata: init\n\n"
+            beat = 0
+            while True:
+                await asyncio.sleep(1.0)
+                sig = _site_signature()
+                if sig != last:
+                    last = sig
+                    yield "event: changed\ndata: update\n\n"
+                else:
+                    beat += 1
+                    if beat >= 15:  # heartbeat keeps the connection alive
+                        beat = 0
+                        yield ": keep-alive\n\n"
+        return StreamingResponse(stream(), media_type="text/event-stream")
+
+    @app.post("/index", response_model=IndexResponse)
+    def do_index():
+        skills_dir = Path(cfg.core.skills_dir).expanduser()
+        if not skills_dir.exists():
+            raise HTTPException(status_code=400, detail=f"skills_dir does not exist: {skills_dir}")
+
+        t0 = time.time()
+        idx = build_index(skills_dir)
+        out = Path(cfg.core.index_path).expanduser()
+        write_index(idx, out)
+        invalidate_cache(out)
+
+        # Refresh /health cache lazily
+        return IndexResponse(
+            total_skills=len(idx.skills),
+            took_ms=(time.time() - t0) * 1000.0,
+        )
+
+    @app.post("/plan")
+    def do_plan(req: PlanRequest):
+        idx = get_index_cached(Path(cfg.core.index_path).expanduser(),
+                                ttl_seconds=cfg.core.index_cache_ttl_seconds)
+        if idx is None:
+            raise HTTPException(status_code=409,
+                                detail="No index. POST /index first.")
+        # Engram fast-path: if we have a high-confidence cached routing for this
+        # prompt's N-gram fingerprint, use it directly. Falls through to planner
+        # otherwise.
+        rerank = cfg.core.default_llm if cfg.planner.rerank_enabled else None
+        eg = engram_lookup(db_path, req.prompt, min_confidence=0.6)
+        if eg:
+            from .planner import plan as planner_run
+            full = planner_run(req, idx, cfg.planner, weights=get_skill_weights(db_path),
+                               rerank_model=rerank)
+            return {**full.model_dump(), "engram_cache_hit": eg}
+        from .planner import plan as planner_run
+        return planner_run(req, idx, cfg.planner, weights=get_skill_weights(db_path),
+                           rerank_model=rerank)
+
+    @app.get("/engram")
+    def do_engram_lookup(prompt: str):
+        """Engram-style O(1) instinct lookup for a prompt."""
+        hit = engram_lookup(db_path, prompt, min_confidence=0.5)
+        return {"hit": hit}
+
+    @app.post("/execute")
+    def do_execute(req: ExecuteRequest):
+        idx = get_index_cached(Path(cfg.core.index_path).expanduser(),
+                                ttl_seconds=cfg.core.index_cache_ttl_seconds)
+        if idx is None:
+            raise HTTPException(status_code=409,
+                                detail="No index. POST /index first.")
+        return executor_run(req, model=cfg.core.default_llm,
+                            skill_paths=idx.skill_paths,
+                            db_path=db_path,
+                            skill_hashes={s.id: s.sha256 for s in idx.skills},
+                            timeout_seconds=cfg.core.executor_timeout_seconds,
+                            max_tokens=cfg.core.executor_max_tokens,
+                            retries=cfg.core.executor_retries)
+
+    @app.post("/loop")
+    def do_loop(req: LoopRequest):
+        # Resolve model override if any
+        model_override = req.model
+        # run_loop uses cfg.core.default_llm unless model_override provided
+        return run_loop(req, cfg=cfg, db_path=db_path, model_override=model_override)
+
+    @app.post("/loop/resume")
+    def do_loop_resume(req: LoopResumeRequest):
+        return resume_loop(req, cfg=cfg, db_path=db_path, model_override=req.model)
+
+    @app.get("/loop/{session_id}")
+    def get_loop(session_id: int):
+        session = get_loop_session(db_path, session_id)
+        if session is None:
+            raise HTTPException(status_code=404, detail="Loop session not found")
+        return session
+
+    @app.get("/stats")
+    def stats():
+        return {"executions": count_executions(db_path)}
+
+    @app.post("/feedback")
+    def do_feedback(req: FeedbackRequest):
+        ok = set_feedback(db_path, req.execution_id, req.feedback)
+        if not ok:
+            raise HTTPException(status_code=404, detail="Execution not found or invalid feedback")
+        return {"ok": True}
+
+    @app.post("/learn")
+    def do_learn():
+        result = learn(db_path)
+        return LearnResponse(
+            new_instincts=result["new_instincts"],
+            updated_instincts=result["updated_instincts"],
+            patterns_found=result["patterns_found"],
+        )
+
+    @app.get("/instincts")
+    def get_instincts(approved: bool = False):
+        return {"instincts": list_instincts(db_path, approved_only=approved)}
+
+    @app.post("/instincts/{instinct_id}/approve")
+    def approve(instinct_id: int):
+        ok = approve_instinct(db_path, instinct_id)
+        if not ok:
+            raise HTTPException(status_code=404, detail="Instinct not found")
+        return {"ok": True}
+
+    return app

agent_foundry/eval.py

@@ -0,0 +1,93 @@
+"""Paired skill evaluation: same task with and without a skill.
+
+Task file format (JSON array):
+  [{"id": "t1", "prompt": "...", "skill": "api-design", "verify": "grep -qi ok"}]
+
+`verify` is an optional shell command. It receives the model output on stdin
+and passes when the exit code is 0. Without a verifier the run is recorded as
+unscored.
+"""
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from .config import Config, LOG_DB_PATH
+from .executor import execute
+from .indexer import GENERIC_REASONING_ID, get_index_cached
+from .models import ExecuteRequest
+
+
+def _verify(command: str, output: str) -> bool | None:
+    if not command:
+        return None
+    try:
+        proc = subprocess.run(
+            command, shell=True, input=output, text=True,
+            capture_output=True, timeout=60,
+        )
+        return proc.returncode == 0
+    except Exception:
+        return False
+
+
+def run_eval(tasks_path: Path, *, cfg: Config, model: str | None = None,
+             db_path: Path | None = None) -> dict[str, Any]:
+    idx = get_index_cached(Path(cfg.core.index_path).expanduser(),
+                           ttl_seconds=cfg.core.index_cache_ttl_seconds)
+    if idx is None:
+        raise RuntimeError("No skill index. Run `agent-foundry index` first.")
+    tasks = json.loads(Path(tasks_path).read_text(encoding="utf-8"))
+    if not isinstance(tasks, list) or not tasks:
+        raise ValueError("task file must be a non-empty JSON array")
+
+    model_name = model or cfg.core.default_llm
+    hashes = {s.id: s.sha256 for s in idx.skills}
+    results = []
+    for task in tasks:
+        prompt = str(task["prompt"])
+        skill_id = str(task.get("skill") or GENERIC_REASONING_ID)
+        verify = str(task.get("verify") or "")
+
+        with_resp = execute(
+            ExecuteRequest(skill_id=skill_id, prompt=prompt, force=True),
+            model=model_name, skill_paths=idx.skill_paths,
+            db_path=db_path, skill_hashes=hashes,
+            timeout_seconds=cfg.core.executor_timeout_seconds,
+            max_tokens=cfg.core.executor_max_tokens,
+            retries=cfg.core.executor_retries,
+        )
+        no_resp = execute(
+            ExecuteRequest(skill_id=GENERIC_REASONING_ID, prompt=prompt, force=True),
+            model=model_name, skill_paths=idx.skill_paths,
+            db_path=db_path, skill_hashes=hashes,
+            timeout_seconds=cfg.core.executor_timeout_seconds,
+            max_tokens=cfg.core.executor_max_tokens,
+            retries=cfg.core.executor_retries,
+        )
+
+        with_pass = _verify(verify, with_resp.output) if with_resp.success else False
+        no_pass = _verify(verify, no_resp.output) if no_resp.success else False
+        results.append({
+            "id": task.get("id", prompt[:40]),
+            "skill": skill_id,
+            "with_skill_pass": with_pass,
+            "no_skill_pass": no_pass,
+            "with_skill_cost_usd": with_resp.cost_usd,
+            "no_skill_cost_usd": no_resp.cost_usd,
+        })
+
+    scored = [r for r in results if r["with_skill_pass"] is not None]
+    with_rate = (sum(1 for r in scored if r["with_skill_pass"]) / len(scored)) if scored else 0.0
+    no_rate = (sum(1 for r in scored if r["no_skill_pass"]) / len(scored)) if scored else 0.0
+    return {
+        "tasks": results,
+        "scored": len(scored),
+        "with_skill_pass_rate": round(with_rate, 3),
+        "no_skill_pass_rate": round(no_rate, 3),
+        "skill_lift": round(with_rate - no_rate, 3),
+        "total_cost_usd": round(sum(r["with_skill_cost_usd"] + r["no_skill_cost_usd"]
+                                   for r in results), 4),
+    }

agent_foundry/executor.py

@@ -0,0 +1,159 @@
+"""Executor: run a skill (prompt + body) via LiteLLM."""
+from __future__ import annotations
+
+import hashlib
+import time
+from pathlib import Path
+from typing import Any
+
+from .indexer import GENERIC_REASONING_ID, GENERIC_REASONING_SYSTEM_PROMPT
+from .models import (
+    ExecuteRequest,
+    ExecuteResponse,
+    TokenEstimate,
+)
+
+
+# API response cap. Full output is always stored in the log DB.
+OUTPUT_MAX_CHARS = 8000
+
+
+def estimate_prompt_tokens(prompt: str) -> int:
+    return max(1, len(prompt) // 4)
+
+
+def find_skill_path(skill_paths: dict[str, str], skill_id: str) -> str | None:
+    return skill_paths.get(skill_id)
+
+
+def _verify_integrity(path: Path, expected_sha256: str | None) -> None:
+    """Refuse a skill file whose bytes changed since indexing."""
+    if not expected_sha256:
+        return
+    actual = hashlib.sha256(path.read_bytes()).hexdigest()
+    if actual != expected_sha256:
+        raise ValueError(
+            f"skill integrity check failed for {path.name}: "
+            f"expected {expected_sha256[:12]}, got {actual[:12]}. Re-run `agent-foundry index`."
+        )
+
+
+def build_messages(skill_id: str, prompt: str, skill_paths: dict[str, str],
+                   fallback_prompt: str | None = None,
+                   expected_sha256: str | None = None) -> tuple[list[dict], bool]:
+    """Return (messages, is_fallback). Raises ValueError on integrity mismatch."""
+    path = find_skill_path(skill_paths, skill_id)
+    if skill_id == GENERIC_REASONING_ID or not path or path.startswith("__virtual__:"):
+        system = fallback_prompt or GENERIC_REASONING_SYSTEM_PROMPT
+        return ([{"role": "system", "content": system},
+                 {"role": "user", "content": prompt}], True)
+
+    file_path = Path(path)
+    _verify_integrity(file_path, expected_sha256)
+    try:
+        system = file_path.read_text(encoding="utf-8")
+    except Exception as e:
+        return ([{"role": "system", "content": f"(failed to load skill: {e})"},
+                 {"role": "user", "content": prompt}], False)
+    return ([{"role": "system", "content": system},
+             {"role": "user", "content": prompt}], False)
+
+
+def complete(messages: list[dict], *, model: str, timeout_seconds: int = 120,
+             max_tokens: int = 0, retries: int = 2) -> tuple[str, int, float]:
+    """Run one completion. Returns (full_text, tokens_used, cost_usd)."""
+    import litellm
+
+    kwargs: dict[str, Any] = {
+        "model": model,
+        "messages": messages,
+        "timeout": timeout_seconds,
+        "num_retries": retries,
+    }
+    if max_tokens and max_tokens > 0:
+        kwargs["max_tokens"] = max_tokens
+
+    resp = litellm.completion(**kwargs)
+
+    try:
+        text = resp.choices[0].message.content or ""
+    except Exception:
+        text = ""
+    if not isinstance(text, str):
+        text = str(text)
+
+    usage: dict[str, Any] = {}
+    try:
+        usage = resp.usage.model_dump() if hasattr(resp.usage, "model_dump") else dict(resp.usage or {})
+    except Exception:
+        pass
+    tokens_used = int(usage.get("total_tokens") or 0)
+    if tokens_used == 0:
+        pt = int(usage.get("prompt_tokens") or 0)
+        ct = int(usage.get("completion_tokens") or 0)
+        tokens_used = pt + ct
+
+    cost_usd = 0.0
+    try:
+        cost_usd = float(litellm.completion_cost(completion_response=resp) or 0.0)
+    except Exception:
+        pass
+    return text, tokens_used, cost_usd
+
+
+def execute(request: ExecuteRequest, *, model: str, skill_paths: dict[str, str],
+            db_path: Path | None = None, planner_score: float | None = None,
+            fallback_prompt: str | None = None,
+            skill_hashes: dict[str, str] | None = None,
+            timeout_seconds: int = 120, max_tokens: int = 0,
+            retries: int = 2) -> ExecuteResponse:
+    """Run the skill via LiteLLM. Optionally log to SQLite."""
+    t0 = time.time()
+    was_fallback = False
+    try:
+        was_fallback = request.skill_id == GENERIC_REASONING_ID
+        messages, was_fallback = build_messages(
+            request.skill_id, request.prompt, skill_paths,
+            fallback_prompt=fallback_prompt,
+            expected_sha256=(skill_hashes or {}).get(request.skill_id),
+        )
+        text, tokens_used, cost_usd = complete(
+            messages, model=model, timeout_seconds=timeout_seconds,
+            max_tokens=max_tokens, retries=retries,
+        )
+    except Exception as exc:
+        err = str(exc)
+        dur = time.time() - t0
+        if db_path is not None:
+            from .logging_db import log_execution
+            log_execution(db_path, skill_id=request.skill_id, prompt=request.prompt,
+                          output="", tokens_used=0, duration_seconds=dur,
+                          success=False, error=err[:1000],
+                          planner_score=planner_score, was_fallback=was_fallback)
+        return ExecuteResponse(
+            skill_id=request.skill_id,
+            output="",
+            tokens_used=0,
+            duration_seconds=dur,
+            success=False,
+            error=err[:1000],
+            was_fallback=was_fallback,
+        )
+
+    dur = time.time() - t0
+    if db_path is not None:
+        from .logging_db import log_execution
+        log_execution(db_path, skill_id=request.skill_id, prompt=request.prompt,
+                      output=text, tokens_used=tokens_used,
+                      duration_seconds=dur, success=True,
+                      planner_score=planner_score, was_fallback=was_fallback)
+
+    return ExecuteResponse(
+        skill_id=request.skill_id,
+        output=text[:OUTPUT_MAX_CHARS],
+        tokens_used=tokens_used,
+        duration_seconds=dur,
+        success=True,
+        was_fallback=was_fallback,
+        cost_usd=cost_usd,
+    )