@agent-native/core 0.12.9 → 0.12.11

package/dist/agent/production-agent.js

@@ -297,9 +297,13 @@ export function createPlanModeActionRegistry(actions) {
 }
 const MAX_RETRIES = 3;
 const RETRY_BASE_DELAY_MS = 2000;
+const TOOL_INPUT_ACTIVITY_INTERVAL_MS = 1500;
 function generateRunId() {
     return `run-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
+function toolInputActivityLabel(toolName) {
+    return toolName ? `Preparing ${toolName} action` : "Preparing action input";
+}
 /** Check if an error is transient and should be retried */
 function isContextTooLongError(err) {
     if (!(err instanceof Error))
@@ -429,6 +433,69 @@ export function buildUserContentWithAttachments(opts) {
     });
     return userContent;
 }
+export function structuredHistoryToEngineMessages(history) {
+    if (!Array.isArray(history))
+        return null;
+    const messages = [];
+    for (const message of history) {
+        if (!message ||
+            (message.role !== "user" && message.role !== "assistant") ||
+            !Array.isArray(message.content)) {
+            continue;
+        }
+        const content = [];
+        for (const part of message.content) {
+            if (!part || typeof part !== "object")
+                continue;
+            if (part.type === "text" && typeof part.text === "string") {
+                if (part.text.length > 0) {
+                    content.push({ type: "text", text: part.text });
+                }
+                continue;
+            }
+            if (part.type === "tool-call" && message.role === "assistant") {
+                const id = typeof part.id === "string"
+                    ? part.id
+                    : typeof part.toolCallId === "string"
+                        ? part.toolCallId
+                        : "";
+                const name = typeof part.name === "string"
+                    ? part.name
+                    : typeof part.toolName === "string"
+                        ? part.toolName
+                        : "";
+                if (!id || !name)
+                    continue;
+                content.push({
+                    type: "tool-call",
+                    id,
+                    name,
+                    input: part.input ?? part.args ?? {},
+                });
+                continue;
+            }
+            if (part.type === "tool-result" && message.role === "user") {
+                if (typeof part.toolCallId !== "string" ||
+                    typeof part.content !== "string") {
+                    continue;
+                }
+                content.push({
+                    type: "tool-result",
+                    toolCallId: part.toolCallId,
+                    ...(typeof part.toolName === "string"
+                        ? { toolName: part.toolName }
+                        : {}),
+                    content: part.content,
+                    ...(part.isError ? { isError: true } : {}),
+                });
+            }
+        }
+        if (content.length > 0) {
+            messages.push({ role: message.role, content });
+        }
+    }
+    return messages.length > 0 ? messages : null;
+}
 /** Build enriched message with file/skill/mention references */
 function enrichMessage(message, references) {
     if (references.length === 0)
@@ -487,6 +554,52 @@ export function appendAgentLoopContinuation(messages, reason) {
         ],
     });
 }
+function textFromEngineMessage(message) {
+    return message.content
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n");
+}
+function isInternalContinuationTurn(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "user")
+            continue;
+        return textFromEngineMessage(message).startsWith(AGENT_INTERNAL_CONTINUE_PROMPT);
+    }
+    return false;
+}
+function seedReadOnlyToolResultsFromHistory(messages, actions) {
+    const cache = new Map();
+    if (!isInternalContinuationTurn(messages))
+        return cache;
+    const pendingToolCalls = new Map();
+    for (const message of messages) {
+        if (message.role === "assistant") {
+            for (const part of message.content) {
+                if (part.type !== "tool-call")
+                    continue;
+                const entry = actions[part.name];
+                if (entry?.readOnly !== true)
+                    continue;
+                pendingToolCalls.set(part.id, {
+                    name: part.name,
+                    input: part.input,
+                });
+            }
+            continue;
+        }
+        for (const part of message.content) {
+            if (part.type !== "tool-result")
+                continue;
+            const call = pendingToolCalls.get(part.toolCallId);
+            if (!call)
+                continue;
+            cache.set(toolCallCacheKey(call.name, call.input), part.content);
+        }
+    }
+    return cache;
+}
 /**
  * Convert ActionEntry registry to EngineTool array.
  */
@@ -531,6 +644,22 @@ function stringifyToolInput(input) {
         return String(input);
     }
 }
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    const obj = value;
+    return `{${Object.keys(obj)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`)
+        .join(",")}}`;
+}
+function toolCallCacheKey(toolName, input) {
+    return `${toolName}:${stableStringify(normalizeToolCallInputForHistory(input))}`;
+}
 function normalizeToolCallInputForHistory(input) {
     if (input && typeof input === "object" && !Array.isArray(input)) {
         return input;
@@ -564,6 +693,8 @@ export async function runAgentLoop(opts) {
         runCtx.toolCalls = toolCallHistory;
         runCtx.toolResults = toolResultHistory;
     }
+    const readOnlyToolResultCache = seedReadOnlyToolResultsFromHistory(messages, actions);
+    const duplicateReadOnlyToolCalls = new Map();
     let finalGuardRetries = 0;
     let iterations = 0;
     while (true) {
@@ -590,6 +721,21 @@ export async function runAgentLoop(opts) {
                 };
                 const eventStream = engine.stream(streamOpts);
                 let thinkingBuffer = "";
+                const toolInputNames = new Map();
+                let lastToolInputActivityAt = 0;
+                const sendToolInputActivity = (toolName, force = false) => {
+                    const now = Date.now();
+                    if (!force &&
+                        now - lastToolInputActivityAt < TOOL_INPUT_ACTIVITY_INTERVAL_MS) {
+                        return;
+                    }
+                    lastToolInputActivityAt = now;
+                    send({
+                        type: "activity",
+                        label: toolInputActivityLabel(toolName),
+                        ...(toolName ? { tool: toolName } : {}),
+                    });
+                };
                 for await (const event of eventStream) {
                     if (event.type === "text-delta") {
                         send({ type: "text", text: event.text });
@@ -600,6 +746,17 @@ export async function runAgentLoop(opts) {
                         // we accumulate them. In a future iteration, we can surface
                         // them as a collapsible "reasoning" section in the UI.
                     }
+                    else if (event.type === "tool-input-start") {
+                        if (event.id && event.name) {
+                            toolInputNames.set(event.id, event.name);
+                        }
+                        sendToolInputActivity(event.name, true);
+                    }
+                    else if (event.type === "tool-input-delta") {
+                        const toolName = event.name ??
+                            (event.id ? toolInputNames.get(event.id) : undefined);
+                        sendToolInputActivity(toolName);
+                    }
                     else if (event.type === "tool-call") {
                         // The authoritative tool-call blocks arrive in assistant-content.
                     }
@@ -734,6 +891,36 @@ export async function runAgentLoop(opts) {
                     isError: true,
                 };
             }
+            const cacheKey = actionEntry.readOnly === true
+                ? toolCallCacheKey(toolCall.name, toolCall.input)
+                : null;
+            if (cacheKey && readOnlyToolResultCache.has(cacheKey)) {
+                const repeats = (duplicateReadOnlyToolCalls.get(cacheKey) ?? 0) + 1;
+                duplicateReadOnlyToolCalls.set(cacheKey, repeats);
+                const previousResult = readOnlyToolResultCache.get(cacheKey) ?? "";
+                const result = `Skipped duplicate read-only call to ${toolCall.name}: identical input already ran in this turn. ` +
+                    `Use the previous result already in the conversation instead of calling this tool again.\n\n` +
+                    `Previous result:\n${previousResult}`;
+                send({
+                    type: "tool_start",
+                    tool: toolCall.name,
+                    input: toolCall.input,
+                });
+                send({ type: "tool_done", tool: toolCall.name, result });
+                recordToolResult(result, false);
+                if (repeats >= 3) {
+                    requestedActionStop ??= {
+                        message: "I stopped because the agent kept asking for the same read-only context it already had. Please send the request again if you want me to retry from a fresh turn.",
+                        errorCode: "duplicate_read_only_tool",
+                    };
+                }
+                return {
+                    type: "tool-result",
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    content: result,
+                };
+            }
             send({
                 type: "tool_start",
                 tool: toolCall.name,
@@ -823,6 +1010,15 @@ export async function runAgentLoop(opts) {
             }
             send({ type: "tool_done", tool: toolCall.name, result });
             recordToolResult(result, isError);
+            if (!isError) {
+                if (cacheKey) {
+                    readOnlyToolResultCache.set(cacheKey, result);
+                }
+                else {
+                    readOnlyToolResultCache.clear();
+                    duplicateReadOnlyToolCalls.clear();
+                }
+            }
             return {
                 type: "tool-result",
                 toolCallId: toolCall.id,
@@ -913,7 +1109,7 @@ export function createProductionAgentHandler(options) {
             setResponseStatus(event, 400);
             return { error: "Invalid request body" };
         }
-        const { message, history = [], references = [], threadId, attachments, model: requestModel, engine: requestEngine, effort: requestEffort, } = body;
+        const { message, history = [], structuredHistory, references = [], threadId, attachments, model: requestModel, engine: requestEngine, effort: requestEffort, } = body;
         const requestMode = body.mode === "plan" ? "plan" : "act";
         const hasMessageText = typeof message === "string" && message.trim().length > 0;
         const hasAttachments = Array.isArray(attachments) && attachments.length > 0;
@@ -1210,13 +1406,15 @@ export function createProductionAgentHandler(options) {
             text: enrichedMessage + screenContext + filesContext + planModeAgentNote,
             attachments,
         });
-        const messages = [
-            ...history
+        const historyMessages = structuredHistoryToEngineMessages(structuredHistory) ??
+            history
                 .filter((m) => m.content.trim())
                 .map((m) => ({
                 role: m.role,
                 content: [{ type: "text", text: m.content }],
-            })),
+            }));
+        const messages = [
+            ...historyMessages,
             { role: "user", content: userContent },
         ];
         // If there's already an active run for this thread, reject with 409 so