atom-agent 1.4.0 → 1.5.0

package/dist/adapters.js

@@ -6,7 +6,7 @@
 // Normalized output matches zen ChatResult:
 //   {content, tool_calls:[{id,function:{name,arguments}}], usage?}
 // so runAgenticLoop/retry/rollback/status code is untouched.
-import { allToolDefinitions } from "./tools.js";
+import { chatToolDefinitions } from "./tools.js";
 import { getProvider, modelsUrlForProvider, } from "./providers.js";
 export const ANTHROPIC_VERSION = "2023-06-01";
 export const ANTHROPIC_MAX_TOKENS = 4096;
@@ -64,10 +64,13 @@ export function geminiThinkingLevelFor(effort) {
 export function isEffortRejection(errorText) {
     return /reasoning_effort|reasoning effort|thinking_level|budget_tokens|\bthinking\b/i.test(errorText);
 }
-function toolDefs() {
+function toolDefs(includeUpdateGoal = true) {
     // Builtins plus extension-registered custom tools, so non-OpenAI kinds
     // see the same model-visible surface as the OpenAI-chat path.
-    return allToolDefinitions();
+    // includeUpdateGoal:false hides update_goal when the turn has no live
+    // goal (same contract as chatToolDefinitions — default keeps every
+    // existing caller byte-identical).
+    return chatToolDefinitions(includeUpdateGoal);
 }
 function parseArgsObject(raw) {
     try {
@@ -81,11 +84,16 @@ function parseArgsObject(raw) {
     }
 }
 import { ephemeralBreakpoint, assemblePrefix } from "./prompt-cache.js";
+import { hasMediaRefs, resolveMediaRefs, stripMedia, } from "./media.js";
 export function buildAnthropicBody(history, model, opts) {
     const systems = [];
     const messages = [];
     // Group consecutive tool messages into one user message with
     // multiple tool_result blocks (Anthropic convention).
+    // Media lowering (see src/media.ts): histories without descriptors take
+    // the string path byte-identically; descriptor-bearing user/tool content
+    // expands to text + base64 image blocks (strip mode: prose markers).
+    const strip = opts?.stripMedia === true;
     let pendingToolResults = [];
     function flushTools() {
         if (pendingToolResults.length === 0)
@@ -95,20 +103,64 @@ export function buildAnthropicBody(history, model, opts) {
     }
     for (const m of history) {
         if (m.role === "system") {
-            systems.push(m.content);
+            systems.push(strip ? stripMedia(m.content) : m.content);
             continue;
         }
         if (m.role === "tool") {
+            if (!hasMediaRefs(m.content)) {
+                pendingToolResults.push({
+                    type: "tool_result",
+                    tool_use_id: m.tool_call_id,
+                    content: strip ? stripMedia(m.content) : m.content,
+                });
+                continue;
+            }
+            if (strip) {
+                pendingToolResults.push({
+                    type: "tool_result",
+                    tool_use_id: m.tool_call_id,
+                    content: stripMedia(m.content),
+                });
+                continue;
+            }
+            const { text, media } = resolveMediaRefs(m.content);
+            const blocks = [{ type: "text", text }];
+            for (const part of media) {
+                if (!part.ok)
+                    continue; // placeholder already inline in text
+                blocks.push({
+                    type: "image",
+                    source: { type: "base64", media_type: part.mime, data: part.base64 },
+                });
+            }
             pendingToolResults.push({
                 type: "tool_result",
                 tool_use_id: m.tool_call_id,
-                content: m.content,
+                content: blocks,
             });
             continue;
         }
         flushTools();
         if (m.role === "user") {
-            messages.push({ role: "user", content: m.content });
+            if (!hasMediaRefs(m.content)) {
+                messages.push({ role: "user", content: strip ? stripMedia(m.content) : m.content });
+            }
+            else if (strip) {
+                messages.push({ role: "user", content: stripMedia(m.content) });
+            }
+            else {
+                const { text, media } = resolveMediaRefs(m.content);
+                const blocks = [{ type: "text", text }];
+                for (const part of media) {
+                    if (!part.ok)
+                        continue;
+                    blocks.push({
+                        type: "image",
+                        source: { type: "base64", media_type: part.mime, data: part.base64 },
+                    });
+                }
+                messages.push({ role: "user", content: blocks });
+            }
         }
         else {
             // assistant: text + tool_use blocks
@@ -140,7 +192,7 @@ export function buildAnthropicBody(history, model, opts) {
     // Compaction path (includeTools:false) omits `tools` + `tool_choice`
     // entirely — asserted in tests as "no `tools` key".
     if (includeTools) {
-        const defs = toolDefs().map((t) => ({
+        const defs = toolDefs(opts?.includeUpdateGoal !== false).map((t) => ({
             name: t.function.name,
             description: t.function.description,
             input_schema: t.function.parameters,
@@ -222,10 +274,15 @@ export function geminiHeaders(apiKey) {
     };
 }
 export function buildGeminiBody(history, _model, opts) {
+    // Media lowering (see src/media.ts): histories without descriptors take
+    // the legacy path byte-identically. Tool-result images ride as inline_data
+    // user parts after their functionResponse (function responses stay text);
+    // user-message images ride inline. Strip mode: prose markers only.
+    const strip = opts?.stripMedia === true;
     const systems = [];
     for (const m of history) {
         if (m.role === "system")
-            systems.push(m.content);
+            systems.push(strip ? stripMedia(m.content) : m.content);
     }
     // tool_call_id -> function name (tool messages carry only the id).
     const nameById = new Map();
@@ -239,27 +296,83 @@ export function buildGeminiBody(history, _model, opts) {
     }
     const contents = [];
     let pendingResponses = [];
+    // Images resolved out of tool results (flushed as user inline_data parts
+    // right after their functionResponse group).
+    let pendingToolImages = [];
     function flushResponses() {
-        if (pendingResponses.length === 0)
+        if (pendingResponses.length === 0 && pendingToolImages.length === 0)
             return;
-        contents.push({ role: "user", parts: pendingResponses });
-        pendingResponses = [];
+        if (pendingResponses.length > 0) {
+            contents.push({ role: "user", parts: pendingResponses });
+            pendingResponses = [];
+        }
+        if (pendingToolImages.length > 0) {
+            const parts = [
+                {
+                    text: `Image(s) from tool result: ${pendingToolImages.map((i) => i.name).join(", ")}`,
+                },
+            ];
+            for (const img of pendingToolImages) {
+                parts.push({ inline_data: { mime_type: img.mime, data: img.data } });
+            }
+            pendingToolImages = [];
+            contents.push({ role: "user", parts });
+        }
     }
     for (const m of history) {
         if (m.role === "system")
             continue;
         if (m.role === "tool") {
+            if (!hasMediaRefs(m.content)) {
+                pendingResponses.push({
+                    functionResponse: {
+                        name: nameById.get(m.tool_call_id) ?? "unknown",
+                        response: { result: strip ? stripMedia(m.content) : m.content },
+                    },
+                });
+                continue;
+            }
+            if (strip) {
+                pendingResponses.push({
+                    functionResponse: {
+                        name: nameById.get(m.tool_call_id) ?? "unknown",
+                        response: { result: stripMedia(m.content) },
+                    },
+                });
+                continue;
+            }
+            const { text, media } = resolveMediaRefs(m.content);
             pendingResponses.push({
                 functionResponse: {
                     name: nameById.get(m.tool_call_id) ?? "unknown",
-                    response: { result: m.content },
+                    response: { result: text },
                 },
             });
+            for (const part of media) {
+                if (!part.ok)
+                    continue;
+                pendingToolImages.push({ mime: part.mime, data: part.base64, name: part.name });
+            }
             continue;
         }
         flushResponses();
         if (m.role === "user") {
-            contents.push({ role: "user", parts: [{ text: m.content }] });
+            if (!hasMediaRefs(m.content)) {
+                contents.push({ role: "user", parts: [{ text: strip ? stripMedia(m.content) : m.content }] });
+            }
+            else if (strip) {
+                contents.push({ role: "user", parts: [{ text: stripMedia(m.content) }] });
+            }
+            else {
+                const { text, media } = resolveMediaRefs(m.content);
+                const parts = [{ text }];
+                for (const part of media) {
+                    if (!part.ok)
+                        continue;
+                    parts.push({ inline_data: { mime_type: part.mime, data: part.base64 } });
+                }
+                contents.push({ role: "user", parts });
+            }
         }
         else {
             const am = m;
@@ -290,7 +403,7 @@ export function buildGeminiBody(history, _model, opts) {
     if (includeTools) {
         body.tools = [
             {
-                functionDeclarations: toolDefs().map((t) => ({
+                functionDeclarations: toolDefs(opts?.includeUpdateGoal !== false).map((t) => ({
                     name: t.function.name,
                     description: t.function.description,
                     parameters: stripGeminiSchemaKeys(t.function.parameters),

package/dist/agent/goal-evaluator.js

@@ -51,6 +51,9 @@ export async function requestGoalVerdict(req) {
         endpointOverride: req.endpointOverride,
         disableTools: true,
         maxOutputTokens: req.maxOutputTokens ?? GOAL_JUDGE_MAX_TOKENS,
+        // The judge needs prose, not pixels — same strip contract as the
+        // compaction summary POST.
+        stripMedia: true,
         ...(req.signal ? { signal: req.signal } : {}),
     });
     // Totals keep accumulating: forward real judge usage when present.