atom-agent 1.2.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 {
@@ -450,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);
@@ -468,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
@@ -546,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;
@@ -631,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;
@@ -753,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/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);
+}