@botbotgo/agent-harness 0.0.416 → 0.0.419

package/dist/runtime/adapter/model/model-providers.js

@@ -8,6 +8,7 @@ import { initChatModel } from "langchain";
 import { salvageToolArgs, tryParseJson } from "../../parsing/output-parsing.js";
 import { normalizeModelFacingToolSchema } from "../tool/resolved-tool.js";
 import { normalizeOpenAICompatibleInit } from "../compat/openai-compatible.js";
+import { recordPromptedJsonToolCall } from "./prompted-json-tool-call-capture.js";
 const NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION = [
     "Available tools are listed below.",
     "If you need a tool, respond with only one JSON object.",
@@ -17,6 +18,13 @@ const NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION = [
     "If the conversation already contains TOOL_RESULT for the requested work, answer from that result instead of repeating the same tool call.",
     "If no tool is needed, answer normally.",
 ].join("\n");
+const FORCED_NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION = [
+    "Available tools are listed below.",
+    "You must call exactly one available tool now.",
+    'Return only one JSON object with this exact shape: {"name":"tool_name","arguments":{"key":"value"}}',
+    "Do not add markdown, prose, explanations, analysis, or code fences.",
+    "Do not answer normally on this turn.",
+].join("\n");
 const PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER = [
     "Final tool-call rule:",
     "If the correct next step is a tool call, return exactly one JSON object and no prose.",
@@ -192,17 +200,51 @@ function canonicalToolName(value) {
         .replace(/[^a-z0-9]+/g, "_")
         .replace(/^_+|_+$/g, "");
 }
+function readToolCallId(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const typed = value;
+    return typeof typed.id === "string"
+        ? typed.id
+        : typeof typed.tool_call_id === "string"
+            ? typed.tool_call_id
+            : undefined;
+}
+function buildToolResultNameLookup(messages) {
+    const namesByToolCallId = new Map();
+    for (const message of messages) {
+        if (mapMessageRole(message) !== "ASSISTANT") {
+            continue;
+        }
+        for (const toolCall of readToolCalls(message)) {
+            if (typeof toolCall !== "object" || toolCall === null) {
+                continue;
+            }
+            const id = readToolCallId(toolCall);
+            const name = typeof toolCall.name === "string"
+                ? toolCall.name
+                : "";
+            if (id && name) {
+                namesByToolCallId.set(id, name);
+            }
+        }
+    }
+    return namesByToolCallId;
+}
 function hasPriorToolResultForToolName(input, toolName) {
     if (!toolName) {
         return false;
     }
     const expectedName = canonicalToolName(toolName);
     if (Array.isArray(input)) {
+        const namesByToolCallId = buildToolResultNameLookup(input);
         return input.some((message) => {
             if (mapMessageRole(message) !== "TOOL") {
                 return false;
             }
-            const observedName = readToolMessageMetadata(message).name;
+            const metadata = readToolMessageMetadata(message);
+            const observedName = metadata.name ?? (metadata.toolCallId ? namesByToolCallId.get(metadata.toolCallId) : undefined);
             return typeof observedName === "string" && canonicalToolName(observedName) === expectedName;
         });
     }
@@ -258,11 +300,31 @@ function readBoundToolName(tool) {
         ? tool.name.trim()
         : "";
 }
+function readBoundToolDescription(tool) {
+    return typeof tool === "object" && tool !== null && typeof tool.description === "string"
+        ? tool.description.trim()
+        : "";
+}
+function summarizeSchemaKeys(schema) {
+    const normalized = normalizeModelFacingToolSchema(schema);
+    const properties = typeof normalized.properties === "object" && normalized.properties !== null
+        ? Object.keys(normalized.properties)
+        : [];
+    const required = Array.isArray(normalized.required)
+        ? normalized.required.filter((item) => typeof item === "string")
+        : [];
+    if (properties.length === 0) {
+        return "{}";
+    }
+    return `{${properties.map((key) => required.includes(key) ? `${key}:required` : `${key}:optional`).join(", ")}}`;
+}
 function isTodoPlanningToolName(name) {
     return name === "write_todos"
         || name === "read_todos"
         || name === "tool_call_write_todos"
-        || name === "tool_call_read_todos";
+        || name === "tool_call_read_todos"
+        || name === "call_write_todos"
+        || name === "call_read_todos";
 }
 function hasPriorNonPlanningToolResult(input, tools) {
     const toolNames = tools
@@ -270,19 +332,46 @@ function hasPriorNonPlanningToolResult(input, tools) {
         .filter((name) => name && !isTodoPlanningToolName(name));
     return toolNames.some((name) => hasPriorToolResultForToolName(input, name));
 }
-function shouldLimitToolsToPlanning(input) {
+function hasPriorPlanningToolResult(input) {
+    return hasPriorToolResultForToolName(input, "write_todos")
+        || hasPriorToolResultForToolName(input, "tool_call_write_todos")
+        || hasPriorToolResultForToolName(input, "call_write_todos")
+        || hasPriorToolResultForToolName(input, "read_todos")
+        || hasPriorToolResultForToolName(input, "tool_call_read_todos")
+        || hasPriorToolResultForToolName(input, "call_read_todos");
+}
+function shouldLimitToolsToPlanning(input, boundTools) {
     const text = stringifyNodeLlamaCppInput(input);
     return text.includes("required visible planning contract")
         && !hasPriorToolResultForToolName(input, "write_todos")
-        && !hasPriorToolResultForToolName(input, "tool_call_write_todos");
+        && !hasPriorToolResultForToolName(input, "tool_call_write_todos")
+        && !hasPriorToolResultForToolName(input, "call_write_todos")
+        && !hasPriorNonPlanningToolResult(input, boundTools);
 }
 function selectPlanningToolsForTurn(input, boundTools) {
-    if (!shouldLimitToolsToPlanning(input)) {
+    if (!shouldLimitToolsToPlanning(input, boundTools)) {
         return boundTools;
     }
     const planningTools = boundTools.filter((tool) => isTodoPlanningToolName(readBoundToolName(tool)));
     return planningTools.length > 0 ? planningTools : boundTools;
 }
+function shouldLimitToolsToNonPlanningEvidence(input, boundTools) {
+    const text = stringifyNodeLlamaCppInput(input);
+    const hasNonPlanningEvidenceInstruction = /non[-\s]?planning (?:evidence )?tool call|non[-\s]?TODO evidence tool|Do not call write_todos|Do not call write_todos or read_todos/i.test(text);
+    return (hasPriorPlanningToolResult(input) || hasNonPlanningEvidenceInstruction)
+        && !hasPriorNonPlanningToolResult(input, boundTools);
+}
+function selectNonPlanningToolsForTurn(boundTools) {
+    const nonPlanningTools = boundTools.filter((tool) => {
+        const name = readBoundToolName(tool);
+        return name.length > 0 && !isTodoPlanningToolName(name);
+    });
+    return nonPlanningTools.length > 0 ? nonPlanningTools : boundTools;
+}
+function isAllowedPromptedJsonToolCall(toolName, effectiveBoundTools) {
+    const allowedToolNames = new Set(effectiveBoundTools.map((tool) => readBoundToolName(tool)).filter(Boolean));
+    return allowedToolNames.has(toolName);
+}
 function normalizeReadFileToolContent(name, content) {
     if (name !== "read_file") {
         return content;
@@ -547,37 +636,6 @@ function normalizeParsedToolCall(payload) {
         : salvageToolArgs(argsCandidate) ?? {};
     return { name, args };
 }
-function extractFallbackTodoContentsFromText(text) {
-    const normalized = text.trim();
-    if (!normalized) {
-        return [];
-    }
-    const candidates = normalized
-        .split(/\r?\n/)
-        .map((line) => line
-        .replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+|\[[ x~!-]\]\s+)/i, "")
-        .replace(/^\s*(?:todo|step|task)\s*\d*\s*[:.-]\s*/i, "")
-        .trim())
-        .filter((line) => line.length >= 12
-        && !/^(?:status|summary|findings|blockers|next actions)\s*[:：]?$/i.test(line)
-        && !/\b(?:plan|todo|steps?)\s*[:：]\s*$/i.test(line)
-        && !isLowSignalPlanningLine(line));
-    const seen = new Set();
-    return candidates.filter((line) => {
-        const key = line.toLowerCase();
-        if (seen.has(key)) {
-            return false;
-        }
-        seen.add(key);
-        return true;
-    }).slice(0, 6);
-}
-function isLowSignalPlanningLine(value) {
-    const normalized = value.trim().toLowerCase();
-    return (normalized.length < 12
-        || /^#+\s*/.test(normalized)
-        || /^(?:ok|okay|sure|understood|got it|plan|todo|steps?)\.?$/.test(normalized));
-}
 function buildFallbackTodoContents() {
     return [
         "Identify the concrete evidence tool required for this request",
@@ -586,20 +644,14 @@ function buildFallbackTodoContents() {
         "Return the final answer grounded in tool output",
     ];
 }
-function isGenericFallbackTodoContent(value) {
-    return /^(?:gather concrete evidence|inspect the most relevant runtime signals|analyze (?:the )?evidence|produce the final rca)/i.test(value.trim());
-}
 function buildFallbackPlanningToolCall(input, planningTools, rawText) {
-    const toolName = planningTools.map((tool) => readBoundToolName(tool)).find((name) => name === "write_todos" || name === "tool_call_write_todos");
+    void input;
+    void rawText;
+    const toolName = planningTools.map((tool) => readBoundToolName(tool)).find((name) => name === "write_todos" || name === "tool_call_write_todos" || name === "call_write_todos");
     if (!toolName) {
         return null;
     }
-    const modelPlannedItems = extractFallbackTodoContentsFromText(rawText);
-    const hasUsefulModelPlan = modelPlannedItems.length >= 2 && !modelPlannedItems.every(isGenericFallbackTodoContent);
-    const fallbackItems = hasUsefulModelPlan
-        ? modelPlannedItems
-        : buildFallbackTodoContents();
-    const todos = fallbackItems.map((content, index) => ({
+    const todos = buildFallbackTodoContents().map((content, index) => ({
         content,
         status: index === 0 ? "in_progress" : "pending",
     }));
@@ -618,7 +670,7 @@ function buildFallbackTodoCompletionToolCall(input, tools) {
     if (/TODO completed:|\[x\]/i.test(prompt)) {
         return null;
     }
-    const planningToolName = tools.map((tool) => readBoundToolName(tool)).find((name) => name === "write_todos" || name === "tool_call_write_todos");
+    const planningToolName = tools.map((tool) => readBoundToolName(tool)).find((name) => name === "write_todos" || name === "tool_call_write_todos" || name === "call_write_todos");
     if (!planningToolName) {
         return null;
     }
@@ -683,29 +735,99 @@ function formatBoundToolInstruction(tool) {
         `Arguments JSON schema: ${JSON.stringify(schema)}`,
     ].filter(Boolean).join("\n");
 }
+function formatCompactBoundToolInstruction(tool) {
+    const name = readBoundToolName(tool);
+    if (!name) {
+        return null;
+    }
+    const description = readBoundToolDescription(tool).split(/\n/u)[0]?.trim() ?? "";
+    return [
+        `Tool: ${name}`,
+        description ? `Description: ${description}` : "",
+        `Arguments keys: ${summarizeSchemaKeys(tool)}`,
+    ].filter(Boolean).join("\n");
+}
 function withPromptedJsonToolPrompt(input, tools, options = {}) {
     const toolInstructions = tools.map((tool) => formatBoundToolInstruction(tool)).filter((value) => Boolean(value));
+    const compactToolInstructions = tools.map((tool) => formatCompactBoundToolInstruction(tool)).filter((value) => Boolean(value));
     if (toolInstructions.length === 0) {
         return stringifyNodeLlamaCppInput(input);
     }
-    const forcedPlanningInstruction = options.forcePlanningToolCall
+    const forcedToolInstruction = options.forceToolCall === "planning"
         ? [
             "Required planning tool call:",
             "You must call write_todos now before any domain tool or final answer.",
             "Return exactly one JSON object for write_todos with concrete todo items and statuses.",
             "Do not write prose, markdown, analysis, or a plain-text plan.",
         ].join("\n")
-        : "";
-    const systemContent = `${NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION}\n\n${toolInstructions.join("\n\n")}`;
+        : options.forceToolCall === "nonPlanningEvidence"
+            ? [
+                "Required evidence tool call:",
+                "A todo board already exists. Your next action must be exactly one non-planning tool call chosen from the available tool descriptions and schemas.",
+                "Do not call write_todos or read_todos now.",
+                "Do not write prose, markdown, analysis, or a plain-text plan.",
+            ].join("\n")
+            : "";
+    const baseToolInstruction = options.forceToolCall
+        ? FORCED_NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION
+        : NODE_LLAMA_CPP_TOOL_CALL_INSTRUCTION;
+    const systemContent = [
+        baseToolInstruction,
+        forcedToolInstruction,
+        (options.forceToolCall ? compactToolInstructions : toolInstructions).join("\n\n"),
+        forcedToolInstruction,
+    ].filter(Boolean).join("\n\n");
     const prompt = stringifyNodeLlamaCppInput(input);
     return [
         options.suppressThinking ? NO_THINK_CONTROL_TOKEN : "",
         systemContent,
-        forcedPlanningInstruction,
+        forcedToolInstruction,
         prompt,
         PROMPTED_JSON_FINAL_TOOL_CALL_REMINDER,
     ].filter(Boolean).join("\n\n");
 }
+function debugPromptedJsonTurn(input) {
+    if (process.env.AGENT_HARNESS_PROMPTED_JSON_DEBUG !== "1") {
+        return;
+    }
+    const promptText = typeof input.prompt === "string" ? input.prompt : stringifyNodeLlamaCppInput(input.prompt);
+    console.error(JSON.stringify({
+        type: "prompted-json-turn",
+        forcePlanningToolCall: input.forcePlanningToolCall,
+        forceNonPlanningEvidenceToolCall: input.forceNonPlanningEvidenceToolCall,
+        effectiveToolNames: input.effectiveToolNames,
+        inputSummary: summarizePromptedJsonInput(input.rawInput),
+        promptHead: promptText.slice(0, 2000),
+    }));
+}
+function debugPromptedJsonResult(input) {
+    if (process.env.AGENT_HARNESS_PROMPTED_JSON_DEBUG !== "1") {
+        return;
+    }
+    console.error(JSON.stringify({
+        type: "prompted-json-result",
+        forcePlanningToolCall: input.forcePlanningToolCall,
+        forceNonPlanningEvidenceToolCall: input.forceNonPlanningEvidenceToolCall,
+        parsedToolName: input.parsedToolName ?? null,
+        textHead: input.text.slice(0, 2000),
+    }));
+}
+function summarizePromptedJsonInput(input) {
+    const messages = typeof input === "object" && input !== null && Array.isArray(input.messages)
+        ? input.messages
+        : Array.isArray(input)
+            ? input
+            : [];
+    return messages.slice(-8).map((message) => ({
+        role: mapMessageRole(message),
+        type: readMessageType(message),
+        name: readToolMessageMetadata(message).name,
+        toolCallNames: readToolCalls(message).map((toolCall) => typeof toolCall === "object" && toolCall !== null && typeof toolCall.name === "string"
+            ? toolCall.name
+            : ""),
+        contentHead: readPromptContent(message).slice(0, 120),
+    }));
+}
 function createPromptedJsonToolBindableModel(model, boundTools = [], options = {}) {
     return new Proxy(model, {
         has(target, prop) {
@@ -720,8 +842,13 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
             }
             if (prop === "invoke") {
                 return async (input, config) => {
-                    const effectiveBoundTools = selectPlanningToolsForTurn(input, boundTools);
-                    const forcePlanningToolCall = shouldLimitToolsToPlanning(input);
+                    const forcePlanningToolCall = shouldLimitToolsToPlanning(input, boundTools);
+                    const forceNonPlanningEvidenceToolCall = !forcePlanningToolCall && shouldLimitToolsToNonPlanningEvidence(input, boundTools);
+                    const effectiveBoundTools = forcePlanningToolCall
+                        ? selectPlanningToolsForTurn(input, boundTools)
+                        : forceNonPlanningEvidenceToolCall
+                            ? selectNonPlanningToolsForTurn(boundTools)
+                            : boundTools;
                     if (options.settleCompletedToolResults === true
                         && !forcePlanningToolCall
                         && effectiveBoundTools.length > 0
@@ -731,14 +858,35 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                             content: readLatestToolResultContent(input) ?? "",
                         });
                     }
-                    const rawResult = await target.invoke(effectiveBoundTools.length > 0
-                        ? withPromptedJsonToolPrompt(input, effectiveBoundTools, { ...options, forcePlanningToolCall })
-                        : input, config);
+                    const promptedInput = effectiveBoundTools.length > 0
+                        ? withPromptedJsonToolPrompt(input, effectiveBoundTools, {
+                            ...options,
+                            forceToolCall: forcePlanningToolCall
+                                ? "planning"
+                                : forceNonPlanningEvidenceToolCall
+                                    ? "nonPlanningEvidence"
+                                    : undefined,
+                        })
+                        : input;
+                    debugPromptedJsonTurn({
+                        forcePlanningToolCall,
+                        forceNonPlanningEvidenceToolCall,
+                        effectiveToolNames: effectiveBoundTools.map(readBoundToolName).filter(Boolean),
+                        rawInput: input,
+                        prompt: promptedInput,
+                    });
+                    const rawResult = await target.invoke(promptedInput, config);
                     if (effectiveBoundTools.length === 0) {
                         return rawResult;
                     }
                     const text = readModelText(rawResult);
                     const parsedToolCall = normalizeParsedToolCall(extractToolCallPayload(text));
+                    debugPromptedJsonResult({
+                        forcePlanningToolCall,
+                        forceNonPlanningEvidenceToolCall,
+                        text,
+                        parsedToolName: parsedToolCall?.name,
+                    });
                     if (!parsedToolCall) {
                         if (forcePlanningToolCall) {
                             const fallbackToolCall = buildFallbackPlanningToolCall(input, effectiveBoundTools, text);
@@ -746,7 +894,7 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                                 return fallbackToolCall;
                             }
                         }
-                        else {
+                        else if (!forceNonPlanningEvidenceToolCall) {
                             const fallbackCompletionToolCall = buildFallbackTodoCompletionToolCall(input, effectiveBoundTools);
                             if (fallbackCompletionToolCall) {
                                 return fallbackCompletionToolCall;
@@ -754,12 +902,20 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
                         }
                         return rawResult;
                     }
+                    if (!isAllowedPromptedJsonToolCall(parsedToolCall.name, effectiveBoundTools)) {
+                        return new AIMessage({ content: "" });
+                    }
                     const effectiveParsedToolCall = forcePlanningToolCall
                         ? normalizeInitialTodoPlanToolCall(parsedToolCall)
                         : parsedToolCall;
-                    if (hasPriorToolResultForToolName(input, effectiveParsedToolCall.name) || hasAnyPriorToolResult(input)) {
+                    if (parsedToolCallCompletesTodoPlan(effectiveParsedToolCall) && !hasPriorNonPlanningToolResult(input, effectiveBoundTools)) {
                         return rawResult;
                     }
+                    recordPromptedJsonToolCall({
+                        name: effectiveParsedToolCall.name,
+                        args: effectiveParsedToolCall.args,
+                        rawArgsInput: text,
+                    });
                     return new AIMessage({
                         content: "",
                         tool_calls: [{
@@ -810,6 +966,41 @@ function createPromptedJsonToolBindableModel(model, boundTools = [], options = {
         },
     });
 }
+function createPromptedJsonPlanningToolBindableModel(model, boundTools = [], options = {}) {
+    return new Proxy(model, {
+        has(target, prop) {
+            if (prop === "bindTools" || prop === "invoke" || prop === "stream" || prop === "streamEvents" || prop === "withConfig") {
+                return true;
+            }
+            return prop in target;
+        },
+        get(target, prop, receiver) {
+            if (prop === "bindTools") {
+                return (tools) => createPromptedJsonPlanningToolBindableModel(target, tools, options);
+            }
+            if (prop === "invoke") {
+                return async (input, config) => {
+                    if (shouldLimitToolsToPlanning(input, boundTools)) {
+                        const prompted = createPromptedJsonToolBindableModel(target, boundTools, options);
+                        return prompted.invoke(input, config);
+                    }
+                    const nativeModel = typeof target.bindTools === "function"
+                        ? target.bindTools(boundTools)
+                        : target;
+                    if (typeof nativeModel.invoke === "function") {
+                        return nativeModel.invoke(input, config);
+                    }
+                    return target.invoke(input, config);
+                };
+            }
+            if (prop === "withConfig" && typeof target.withConfig === "function") {
+                return (config) => createPromptedJsonPlanningToolBindableModel(target.withConfig(config), boundTools, options);
+            }
+            const member = Reflect.get(target, prop, receiver);
+            return typeof member === "function" ? member.bind(target) : member;
+        },
+    });
+}
 function inferNodeLlamaCppModelPath(model) {
     const modelPath = typeof model.init?.modelPath === "string" ? model.init.modelPath.trim() : "";
     if (modelPath) {
@@ -846,6 +1037,12 @@ export async function createResolvedModel(model, modelResolver) {
                 suppressThinking: init.think === false,
             });
         }
+        if (toolCallingMode === "prompted-json-planning") {
+            return createPromptedJsonPlanningToolBindableModel(resolved, [], {
+                settleCompletedToolResults: true,
+                suppressThinking: init.think === false,
+            });
+        }
         return createProviderToolMessageCompatModel(resolved);
     }
     if (model.provider === "openai-compatible") {
@@ -860,6 +1057,12 @@ export async function createResolvedModel(model, modelResolver) {
                 suppressThinking: true,
             });
         }
+        if (toolCallingMode === "prompted-json-planning") {
+            return createPromptedJsonPlanningToolBindableModel(resolved, [], {
+                settleCompletedToolResults: true,
+                suppressThinking: true,
+            });
+        }
         return createProviderToolMessageCompatModel(resolved);
     }
     if (model.provider === "openai") {

package/dist/runtime/adapter/model/prompted-json-tool-call-capture.d.ts

@@ -0,0 +1,9 @@
+export type CapturedPromptedJsonToolCall = {
+    id?: string;
+    name: string;
+    args: Record<string, unknown>;
+    rawArgsInput?: unknown;
+};
+export declare function recordPromptedJsonToolCall(toolCall: CapturedPromptedJsonToolCall): void;
+export declare function capturePromptedJsonToolCalls<T>(producer: () => Promise<T>): Promise<T>;
+export declare function readCapturedPromptedJsonToolCalls(value: unknown): CapturedPromptedJsonToolCall[];

package/dist/runtime/adapter/model/prompted-json-tool-call-capture.js

@@ -0,0 +1,40 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const CAPTURED_TOOL_CALLS_KEY = "__harnessPromptedJsonToolCalls";
+const storage = new AsyncLocalStorage();
+export function recordPromptedJsonToolCall(toolCall) {
+    const active = storage.getStore();
+    if (!active) {
+        return;
+    }
+    active.push(toolCall);
+}
+export async function capturePromptedJsonToolCalls(producer) {
+    const captured = [];
+    const result = await storage.run(captured, producer);
+    if (typeof result === "object"
+        && result !== null
+        && captured.length > 0
+        && !Object.prototype.hasOwnProperty.call(result, CAPTURED_TOOL_CALLS_KEY)) {
+        Object.defineProperty(result, CAPTURED_TOOL_CALLS_KEY, {
+            configurable: true,
+            enumerable: false,
+            value: [...captured],
+        });
+    }
+    return result;
+}
+export function readCapturedPromptedJsonToolCalls(value) {
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+    const captured = value[CAPTURED_TOOL_CALLS_KEY];
+    if (!Array.isArray(captured)) {
+        return [];
+    }
+    return captured.filter((item) => typeof item === "object"
+        && item !== null
+        && typeof item.name === "string"
+        && typeof item.args === "object"
+        && item.args !== null
+        && !Array.isArray(item.args));
+}

package/dist/runtime/adapter/runtime-adapter-support.js

@@ -27,24 +27,70 @@ function findTodosArray(value, depth = 0) {
     }
     return [];
 }
+function stripWrappingQuotes(value) {
+    const trimmed = value.trim().replace(/,$/, "").trim();
+    if (trimmed.length >= 2) {
+        const first = trimmed[0];
+        const last = trimmed[trimmed.length - 1];
+        if ((first === "\"" && last === "\"") || (first === "'" && last === "'")) {
+            return trimmed.slice(1, -1).trim();
+        }
+    }
+    return trimmed;
+}
+function normalizeTodoContentValue(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "";
+    }
+    if (/^\*{1,2}\s*(?:call\s+)?(?:write|read)[ _-]?todos\s*\*{1,2}$/iu.test(trimmed)) {
+        return "";
+    }
+    const contentField = /^["']?(content|description|title|name|text)["']?\s*:\s*(.+)$/iu.exec(trimmed);
+    if (contentField) {
+        const normalized = stripWrappingQuotes(contentField[2]);
+        return normalized && normalized !== "null" && normalized !== "undefined" ? normalized : "";
+    }
+    if (/^["']?(status|id|ownerAgentId|startedAt|endedAt|result|metadata)["']?\s*:/u.test(trimmed)) {
+        return "";
+    }
+    return stripWrappingQuotes(trimmed);
+}
+function readTodoContent(todo) {
+    const candidates = [todo.content, todo.description, todo.title, todo.name, todo.text];
+    for (const candidate of candidates) {
+        if (typeof candidate !== "string") {
+            continue;
+        }
+        const normalized = normalizeTodoContentValue(candidate);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return "";
+}
+function normalizeTodoStatus(value) {
+    if (typeof value !== "string") {
+        return "pending";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "pending"
+        || normalized === "in_progress"
+        || normalized === "completed"
+        || normalized === "failed"
+        || normalized === "cancelled") {
+        return normalized;
+    }
+    return "pending";
+}
 export function summarizeBuiltinWriteTodosArgs(args) {
     const todos = findTodosArray(args);
     const items = todos.flatMap((todo) => {
         if (!isRecord(todo)) {
             return [];
         }
-        const content = typeof todo.content === "string" && todo.content.trim().length > 0
-            ? todo.content.trim()
-            : typeof todo.description === "string" && todo.description.trim().length > 0
-                ? todo.description.trim()
-                : typeof todo.title === "string" && todo.title.trim().length > 0
-                    ? todo.title.trim()
-                    : typeof todo.name === "string" && todo.name.trim().length > 0
-                        ? todo.name.trim()
-                        : typeof todo.text === "string" && todo.text.trim().length > 0
-                            ? todo.text.trim()
-                            : "";
-        const status = typeof todo.status === "string" && todo.status.trim().length > 0 ? todo.status.trim() : "pending";
+        const content = readTodoContent(todo);
+        const status = normalizeTodoStatus(todo.status);
         const metadata = isRecord(todo.metadata) ? todo.metadata : undefined;
         return content ? [{
                 ...((typeof todo.id === "string" && todo.id.trim().length > 0)

package/dist/runtime/adapter/runtime-shell.js

@@ -3,6 +3,7 @@ import { appendToolRecoveryInstruction, extractVisibleOutput, isToolCallRecovery
 import { readStreamDelta } from "../parsing/stream-event-parsing.js";
 import { computeRemainingTimeoutMs, isRetryableProviderError, resolveProviderRetryPolicy } from "./resilience.js";
 import { isDeepAgentBinding, isLangChainBinding, withUpdatedBindingExecutionParams, } from "../support/compiled-binding.js";
+import { capturePromptedJsonToolCalls } from "./model/prompted-json-tool-call-capture.js";
 export class RuntimeOperationTimeoutError extends Error {
     operation;
     timeoutMs;
@@ -153,13 +154,13 @@ export function applyToolRecoveryInstruction(binding, instruction) {
 }
 export async function callRuntimeWithToolParseRecovery(input) {
     try {
-        return await input.callRuntime(input.binding, input.request);
+        return await capturePromptedJsonToolCalls(() => input.callRuntime(input.binding, input.request));
     }
     catch (error) {
         const recoveryInstruction = resolveToolCallRecoveryInstruction(error);
         if (input.resumePayload !== undefined || !recoveryInstruction || !isToolCallRecoveryFailure(error)) {
             throw error;
         }
-        return input.callRuntime(applyToolRecoveryInstruction(input.binding, recoveryInstruction), appendToolRecoveryInstruction(input.request, recoveryInstruction));
+        return capturePromptedJsonToolCalls(() => input.callRuntime(applyToolRecoveryInstruction(input.binding, recoveryInstruction), appendToolRecoveryInstruction(input.request, recoveryInstruction)));
     }
 }