atom-agent 1.1.0 → 1.3.0

package/dist/adapters.js

@@ -6,12 +6,68 @@
 // Normalized output matches zen ChatResult:
 //   {content, tool_calls:[{id,function:{name,arguments}}], usage?}
 // so runAgenticLoop/retry/rollback/status code is untouched.
-import { TOOL_DEFINITIONS } from "./tools.js";
+import { allToolDefinitions } from "./tools.js";
 import { getProvider, modelsUrlForProvider, } from "./providers.js";
 export const ANTHROPIC_VERSION = "2023-06-01";
 export const ANTHROPIC_MAX_TOKENS = 4096;
+// ---- Reasoning-effort mappings (one /effort knob, three wire shapes) ----
+//
+// OpenAI-chat kind sends `reasoning_effort` verbatim (no mapping needed).
+// Anthropic takes a thinking budget in tokens: minimum 1024, and it must
+// stay under max_tokens for the turn (budgets count toward max_tokens).
+// Gemini takes a thinkingLevel enum (minimal/low/medium/high): our Max maps
+// to high, the deepest level the API offers.
+// Minimum thinking budget Anthropic accepts (see extended-thinking docs).
+export const ANTHROPIC_MIN_THINKING_BUDGET = 1024;
+export const ANTHROPIC_EFFORT_BUDGETS = {
+    low: 1024,
+    medium: 2048,
+    high: 3072,
+    max: 3500,
+};
+// Budget for an effort level under a max_tokens cap, or undefined when the
+// knob must be omitted (Auto/unknown effort, or a cap too small to fit the
+// 1024 minimum — e.g. a tiny compaction cap). Oversized wants shrink to
+// cap - 1 instead of 400ing.
+export function anthropicThinkingFor(effort, maxTokens) {
+    if (!effort)
+        return undefined;
+    const want = ANTHROPIC_EFFORT_BUDGETS[effort];
+    if (want === undefined)
+        return undefined;
+    if (typeof maxTokens !== "number" || !Number.isFinite(maxTokens))
+        return want;
+    const max = Math.floor(maxTokens);
+    if (want < max)
+        return want;
+    const shrunk = max - 1;
+    return shrunk >= ANTHROPIC_MIN_THINKING_BUDGET ? shrunk : undefined;
+}
+const GEMINI_EFFORT_LEVELS = {
+    low: "low",
+    medium: "medium",
+    high: "high",
+    // The API's deepest level is high — Max rides it.
+    max: "high",
+};
+// thinkingLevel for an effort level, or undefined when the knob must be
+// omitted (Auto/unknown effort).
+export function geminiThinkingLevelFor(effort) {
+    if (!effort)
+        return undefined;
+    return GEMINI_EFFORT_LEVELS[effort];
+}
+// Server-authoritative unsupported detection: a 400 that names the effort
+// knob means this model/deployment has no such control, and the caller
+// retries once without it. Deliberately narrow (knob names only) so
+// unrelated 400s keep failing loudly instead of silently dropping effort.
+export function isEffortRejection(errorText) {
+    return /reasoning_effort|reasoning effort|thinking_level|budget_tokens|\bthinking\b/i.test(errorText);
+}
 function toolDefs() {
-    return TOOL_DEFINITIONS;
+    // Builtins plus extension-registered custom tools, so non-OpenAI kinds
+    // see the same model-visible surface as the OpenAI-chat path.
+    return allToolDefinitions();
 }
 function parseArgsObject(raw) {
     try {
@@ -318,6 +374,24 @@ async function collectSSEText(res) {
     const body = res.body;
     const decoder = new TextDecoder();
     let rawText = "";
+    // Data-silence tracking (mirrors zen.readSSEMessage): queue comments and
+    // keep-alives carry bytes but no model output, so only chunks containing a
+    // `data:` line start refresh the clock. The tail window catches a marker
+    // split across chunk boundaries.
+    let lastDataAt = Date.now();
+    let tail = "";
+    const noteChunk = (chunkText) => {
+        const joined = tail + chunkText;
+        if (/(?:^|\n)data:/.test(joined))
+            lastDataAt = Date.now();
+        tail = joined.slice(-8);
+    };
+    const throwIfDataStalled = () => {
+        const budget = sseStallTimeoutMs();
+        if (Date.now() - lastDataAt > budget) {
+            throw new Error(`Truncated stream from model (stall: no output for ${budget}ms — queued or stalled upstream; resend to retry).`);
+        }
+    };
     if (body == null)
         return { rawText, events: [] };
     try {
@@ -346,10 +420,12 @@ async function collectSSEText(res) {
                     if (chunk.done)
                         break;
                     const v = chunk.value;
-                    rawText +=
-                        typeof v === "string"
-                            ? v
-                            : decoder.decode(v, { stream: true });
+                    const textPart = typeof v === "string"
+                        ? v
+                        : decoder.decode(v, { stream: true });
+                    rawText += textPart;
+                    noteChunk(textPart);
+                    throwIfDataStalled();
                 }
             }
             finally {
@@ -369,10 +445,12 @@ async function collectSSEText(res) {
                     if (step.done)
                         break;
                     const v = step.value;
-                    rawText +=
-                        typeof v === "string"
-                            ? v
-                            : decoder.decode(v, { stream: true });
+                    const textPart = typeof v === "string"
+                        ? v
+                        : decoder.decode(v, { stream: true });
+                    rawText += textPart;
+                    noteChunk(textPart);
+                    throwIfDataStalled();
                 }
             }
             finally {
@@ -428,16 +506,9 @@ function finiteCount(value) {
         ? Math.floor(value)
         : undefined;
 }
-function openAIUsage(prompt, completion, cache) {
+function openAIUsage(prompt, completion, cache, opts) {
     const out = {};
     const p = finiteCount(prompt);
-    if (p !== undefined)
-        out.prompt_tokens = p;
-    const c = finiteCount(completion);
-    if (c !== undefined)
-        out.completion_tokens = c;
-    if (p !== undefined && c !== undefined)
-        out.total_tokens = p + c;
     // Provider-reported cache counters ride alongside (Anthropic
     // cache_read/_creation, Gemini cachedContentTokenCount) — present-only.
     const read = finiteCount(cache?.read);
@@ -446,6 +517,22 @@ function openAIUsage(prompt, completion, cache) {
     const write = finiteCount(cache?.write);
     if (write !== undefined)
         out.cacheWriteTokens = write;
+    // Anthropic's input_tokens EXCLUDES cache_read/_creation (they are separate
+    // counters for the same context), while OpenAI/Gemini prompt counts already
+    // include cached tokens. With foldCacheIntoPrompt, prompt_tokens is
+    // normalized to total input-side tokens so load (P%), spend (NK), and the
+    // auto-compact trigger all see the real context. Detail fields above stay
+    // provider-faithful regardless.
+    const folded = opts?.foldCacheIntoPrompt === true
+        ? [p, read, write].reduce((acc, v) => (v === undefined ? acc : (acc ?? 0) + v), undefined)
+        : p;
+    if (folded !== undefined)
+        out.prompt_tokens = folded;
+    const c = finiteCount(completion);
+    if (c !== undefined)
+        out.completion_tokens = c;
+    if (folded !== undefined && c !== undefined)
+        out.total_tokens = folded + c;
     return out.prompt_tokens !== undefined ||
         out.completion_tokens !== undefined ||
         out.total_tokens !== undefined
@@ -524,10 +611,12 @@ export async function readAnthropicSSEMessage(res, opts) {
             const msg = o["message"];
             const u = msg?.["usage"];
             if (u) {
+                // Anthropic input_tokens excludes cache_read/_creation — fold them
+                // into prompt_tokens so the value is total input-side tokens.
                 const hit = openAIUsage(u["input_tokens"], u["output_tokens"], {
                     read: u["cache_read_input_tokens"],
                     write: u["cache_creation_input_tokens"],
-                });
+                }, { foldCacheIntoPrompt: true });
                 const merged = mergeUsage(usage, hit, { recomputeTotal: true });
                 if (merged !== undefined)
                     usage = merged;
@@ -609,10 +698,11 @@ export async function readAnthropicSSEMessage(res, opts) {
             const inputSrc = u?.["input_tokens"] !== undefined ? u["input_tokens"] : o["input_tokens"];
             const outputSrc = u?.["output_tokens"] !== undefined ? u["output_tokens"] : o["output_tokens"];
             if (u !== undefined || o["input_tokens"] !== undefined || o["output_tokens"] !== undefined) {
+                // Same Anthropic-exclusive-cache fold as message_start above.
                 const hit = openAIUsage(inputSrc, outputSrc, {
                     read: u?.["cache_read_input_tokens"] ?? o["cache_read_input_tokens"],
                     write: u?.["cache_creation_input_tokens"] ?? o["cache_creation_input_tokens"],
-                });
+                }, { foldCacheIntoPrompt: true });
                 const merged = mergeUsage(usage, hit, { recomputeTotal: true });
                 if (merged !== undefined)
                     usage = merged;
@@ -731,10 +821,11 @@ export function parseAnthropicJson(data) {
     };
     const u = o["usage"];
     if (u) {
+        // Same Anthropic-exclusive-cache fold as the SSE path above.
         const hit = openAIUsage(u["input_tokens"], u["output_tokens"], {
             read: u["cache_read_input_tokens"],
             write: u["cache_creation_input_tokens"],
-        });
+        }, { foldCacheIntoPrompt: true });
         if (hit)
             result.usage = hit;
     }

package/dist/agent/gates.js

@@ -19,6 +19,15 @@ export function todoCompletionGate(finalText, ctx) {
             finalText: `${finalText}${finalText ? "\n" : ""}(blocked: ${open.length} open todo(s) — resolve with todo_update/todowrite before ending the turn:\n${items})`,
         };
     }
+    // Guard cycles are bounded (like the verification gate): a model that
+    // keeps answering without resolving todos ends with a blocked statement
+    // instead of looping forever. Normal flows resolve within a round or two.
+    if ((ctx.todoRounds ?? 0) >= MAX_TODO_ROUNDS) {
+        return {
+            action: "end",
+            finalText: `${finalText}${finalText ? "\n" : ""}(blocked: ${open.length} open todo(s) remain after ${MAX_TODO_ROUNDS} guard rounds — resolve with todo_update/todowrite before ending the turn:\n${items})`,
+        };
+    }
     return {
         action: "continue",
         assistantText: finalText,
@@ -30,11 +39,15 @@ export function todoCompletionGate(finalText, ctx) {
 // report — the system prompt forbids unverified finishes, so the runtime
 // must not terminate while just labeling): the attempt is recorded and a
 // verification follow-up re-enters the loop, exactly like the todo guard.
-// Two bounded exits: spent step budget, or MAX_VERIFY_ROUNDS nag cycles
+// Two bounded exits: an explicit step budget spent, or MAX_VERIFY_ROUNDS nag
 // without a passing run — both end with an explicit labeled statement naming
 // what is unverified and why the loop stopped. Turns with no code writes
 // (questions, docs, explanations, read-only work) are unaffected.
 export const MAX_VERIFY_ROUNDS = 3;
+// Todo-guard continues before the turn ends blocked: a model that keeps
+// answering final text without resolving open todos is sent back at most
+// this many times. Mirrors MAX_VERIFY_ROUNDS so no gate can spin forever.
+export const MAX_TODO_ROUNDS = 3;
 // Source-code extensions whose writes require a passing verification run.
 // Curated heuristic boundary (not a parser): docs, configs, data, and
 // extensionless files never arm the gate, so a README edit finishes clean.

package/dist/agent/goal-evaluator.js

@@ -0,0 +1,69 @@
+// Goal evaluator fallback (ticket 04): one bounded, read-only judge call
+// for a goal turn that ends with no disposition report. Follows the
+// compaction summary-POST precedent (requestCompactSummary in src/compact.ts):
+// same provider/model, tools disabled, capped output, single attempt, throws
+// on failure (the loop turns that into a pause, never a crash).
+//
+// Split of responsibilities: the loop owns WHEN (report-less turn end) and
+// WHAT NEXT (consumed verdicts flow through the model-report path); this
+// module owns the request shape, the judge prompt, and the transport. App
+// builds the full request from its live provider/key/model refs; unit tests
+// inject a fake GoalJudgeRunner through AgenticOpts without fetch mocks.
+import { chatCompletionForProvider } from "../zen.js";
+import { parseGoalJudgeVerdict } from "../goal.js";
+// Output cap for the judge POST: a verdict is a few dozen tokens of JSON —
+// 256 leaves headroom for a short reason without letting the judge write prose.
+export const GOAL_JUDGE_MAX_TOKENS = 256;
+// The judge instruction: goal text plus the demand for one strict
+// machine-readable verdict. No tools are offered, so there is nothing to
+// call — the transcript above is the only evidence.
+export function buildGoalJudgeInstruction(goal) {
+    return (`You are judging whether a coding-goal turn advanced. Goal: "${goal}".\n` +
+        `The recent transcript turns are above. Decide the turn outcome and answer ` +
+        `with a single JSON object only (no prose, no code fences):\n` +
+        `{"status": "continue", "next": "<concrete next action>"} — work remains; name the next action.\n` +
+        `{"status": "complete", "reason": "<why the goal is done>"} — the goal is fully achieved.\n` +
+        `{"status": "blocked", "reason": "<what blocks progress>"} — a genuine blocker, not mere remaining work.\n` +
+        `Rules: no tools are available for this request — judge from the transcript only, ` +
+        `answer with the JSON object only.`);
+}
+export function buildGoalJudgeMessages(systemContent, goal, turns) {
+    const system = typeof systemContent === "string" && systemContent.length > 0
+        ? systemContent
+        : "You are a concise engineering judge.";
+    return [
+        { role: "system", content: system },
+        ...turns.map((m) => ({ ...m })),
+        { role: "user", content: buildGoalJudgeInstruction(goal) },
+    ];
+}
+// Judge POST: SAME provider/model via the existing chat path but TOOLS
+// DISABLED (no `tools` key in the POST body) and output capped
+// (max_tokens/maxOutputTokens per kind — see zen.ts/adapters.ts). Single
+// attempt, no retry — bounded by construction. Returns the parsed verdict,
+// or null when the judge output is anything but a clear verdict (tolerant
+// parsing lives in parseGoalJudgeVerdict). Transport failures and empty
+// replies throw with history untouched (the loop pauses on them).
+export async function requestGoalVerdict(req) {
+    const messages = buildGoalJudgeMessages(req.systemContent, req.goal, req.turns);
+    const res = await chatCompletionForProvider(req.provider, req.apiKey, req.model, messages, {
+        baseURL: req.baseURL,
+        endpointOverride: req.endpointOverride,
+        disableTools: true,
+        maxOutputTokens: req.maxOutputTokens ?? GOAL_JUDGE_MAX_TOKENS,
+        ...(req.signal ? { signal: req.signal } : {}),
+    });
+    // Totals keep accumulating: forward real judge usage when present.
+    if (res.usage !== undefined) {
+        try {
+            req.onUsage?.(res.usage);
+        }
+        catch {
+            // observer errors never break the judge
+        }
+    }
+    const text = (res.content ?? "").trim();
+    if (!text)
+        throw new Error("Empty reply from model (unexpected payload).");
+    return parseGoalJudgeVerdict(text);
+}

package/dist/agent/loop-guard.js

@@ -1,20 +1,18 @@
 // Loop-guard: repetition/runaway detection + error-streak recovery for the
 // agentic loop. Pure state machines, no I/O, never throw.
 //
-// Why this exists: maxSteps (30 tool rounds) is the ultimate backstop, but
-// a model stuck calling `read <same path>` 30 times burns 30 POSTs before it
-// trips. The guard spots the pattern early (consecutive identical signatures)
-// and the loop nudges the model toward a different approach with a bounded
-// follow-up — then stops hard if the pattern survives the nudges. Error
-// streaks get the same treatment: ending on 3+ unaddressed `Error:` results
-// is almost always premature, so the loop asks for a fix-forward attempt
-// before accepting final text.
+// Why this exists: turns are uncapped by default, so a model stuck calling
+// `read <same path>` forever burns POSTs without end. The guard spots the
+// pattern early (consecutive identical signatures) and the loop nudges the
+// model toward a different approach with a bounded follow-up — then stops
+// hard if the pattern survives the nudges. Error streaks get the same
+// treatment: ending on 3+ unaddressed `Error:` results is almost always
+// premature, so the loop asks for a fix-forward attempt before accepting
+// final text.
 //
-// Defaults preserve the pinned maxSteps contract: repetition intervention is
-// OPT-IN (maxRepeatedCalls set by the caller; unset = track-only for stats),
-// because the existing suites pin "always same call → 31 POSTs → stopped
-// notice". Error-streak recovery defaults to 3 (single errors still end
-// normally — the model may be reporting a blocker).
+// Repetition intervention is OPT-IN (maxRepeatedCalls set by the caller;
+// unset = track-only for stats). Error-streak recovery defaults to 3
+// (single errors still end normally — the model may be reporting a blocker).
 //
 // All thresholds clamp to sane minima; every method is safe to call with any
 // input.