u-foo 3.0.0 → 3.0.2

package/src/code/nativeRunner.js

@@ -5,6 +5,7 @@ const {
   resolveKimiUpstreamCredentials,
 } = require("../agents/providers/credentials/kimi");
 const { runToolCall } = require("./dispatch");
+const { runTaskRunTool } = require("./tools/taskRun");
 const { appendUsageRecord } = require("./usageStore");
 const {
   persistToolResultToContext,
@@ -34,6 +35,19 @@ const {
   getPendingUserInteraction,
 } = require("./context/userInteraction");
 const { checkWriteAllowed } = require("./runtime/workspaceLease");
+const {
+  createToolCallLedger,
+  declareCalls,
+  markExecuting,
+  deferCall,
+  resolveCall,
+  snapshotLedger,
+  runProviderTurnGate,
+  withFaultPoint,
+  checkFaultPoint,
+  materializeResolvedToolResults,
+  materializeAnswerToolResult,
+} = require("./protocol");
 const { stableStringify } = require("./context/stableJson");
 const { getReadToolDescription } = require("../agents/prompts/native/toolDescriptions/read");
 const { getWriteToolDescription } = require("../agents/prompts/native/toolDescriptions/write");
@@ -47,9 +61,11 @@ const CORE_TOOL_NAMES = new Set([
   "bash",
   "artifact_read",
   "plan_graph",
+  "task_run",
   "ask_user",
 ]);
 const EXECUTABLE_GRAPH_TOOLS = new Set(["read", "write", "edit", "bash", "artifact_read"]);
+const CONTROL_PLANE_TOOLS = new Set(["plan_graph", "task_run"]);
 const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
 const DEFAULT_KIMI_BASE_URL = "https://api.kimi.com/coding/v1";
@@ -65,11 +81,9 @@ const DEFAULT_NATIVE_TIMEOUT_MS = 43200000; // 12 hours
 // via UFOO_UCODE_MAX_TOKENS (positive integer).
 const DEFAULT_OPENAI_MAX_TOKENS = 131072;
 const DEFAULT_ANTHROPIC_MAX_TOKENS = 64000;
-// Extended thinking is on by default for the anthropic transport; the budget
-// stays well below the 64K max_tokens cap as the Messages API requires.
-// UFOO_UCODE_THINKING_BUDGET_TOKENS overrides; 0 or a non-numeric value
-// disables thinking (the payload then omits the field entirely).
-const DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS = 10000;
+// Extended thinking defaults live in thinkingLevels.js (medium = 10k).
+// UFOO_UCODE_THINKING=off|low|medium|high|max selects a preset; numeric
+// UFOO_UCODE_THINKING_BUDGET_TOKENS still overrides. 0 disables thinking.
 // Prompt caching is GA on the current Messages API: cache_control blocks need
 // no anthropic-beta header. Kept as a constant so the marker shape stays in
 // one place (system block + last history message, 2 of the 4 allowed
@@ -103,14 +117,40 @@ function resolveMaxTokens(fallback) {
   return normalizePositiveInt(process.env.UFOO_UCODE_MAX_TOKENS, fallback);
 }
 
-function resolveThinkingBudgetTokens() {
-  const raw = process.env.UFOO_UCODE_THINKING_BUDGET_TOKENS;
-  if (raw === undefined || raw === null || String(raw).trim() === "") {
-    return DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS;
+function resolveThinkingBudgetTokens(options = {}) {
+  const { resolveThinkingFromEnvAndConfig } = require("./thinkingLevels");
+  const { loadGlobalUcodeConfig } = require("../config");
+  let configLevel = String(options.configLevel || "").trim();
+  if (!configLevel) {
+    try {
+      configLevel = String((loadGlobalUcodeConfig() || {}).ucodeThinking || "").trim();
+    } catch {
+      configLevel = "";
+    }
   }
-  const parsed = Number.parseInt(String(raw), 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) return 0;
-  return Math.floor(parsed);
+  const resolved = resolveThinkingFromEnvAndConfig({
+    env: options.env || process.env,
+    configLevel,
+  });
+  return resolved.budgetTokens;
+}
+
+function resolveReasoningEffort(options = {}) {
+  const { resolveThinkingFromEnvAndConfig } = require("./thinkingLevels");
+  const { loadGlobalUcodeConfig } = require("../config");
+  let configLevel = String(options.configLevel || "").trim();
+  if (!configLevel) {
+    try {
+      configLevel = String((loadGlobalUcodeConfig() || {}).ucodeThinking || "").trim();
+    } catch {
+      configLevel = "";
+    }
+  }
+  const resolved = resolveThinkingFromEnvAndConfig({
+    env: options.env || process.env,
+    configLevel,
+  });
+  return resolved.reasoningEffort || "";
 }
 
 function toUsageInt(value) {
@@ -433,12 +473,13 @@ function buildCoreToolSpecs() {
       function: {
         name: "plan_graph",
         description: [
-          "Manage the persistent Plan Graph and asynchronous TaskRuns.",
-          "Use create, patch, inspect, or cancel_graph for graph operations, and control for TaskRun lifecycle.",
-          "`control.start_task` starts a `task_loop` asynchronously and returns immediately.",
+          "Manage the persistent Plan Graph and graph-bound TaskRuns.",
+          "TaskRuns are orthogonal to Plan Mode; for a standalone TaskRun without a plan, use `task_run` instead.",
+          "Use create, patch, inspect, or cancel_graph for graph operations, and control for graph-bound TaskRun lifecycle.",
+          "`control.start_task` starts a graph `task_loop` asynchronously and returns immediately.",
           "Use `inline_llm` for work handled by the current graph owner,",
           "`expand` for tasks that must be lowered into child nodes,",
-          "and `task_loop` for asynchronous work in an independent TaskLoop.",
+          "and `task_loop` for asynchronous work in an independent TaskLoop attached to a plan node.",
           "Do not call `plan_graph` together with data-plane tools in the same assistant turn.",
         ].join(" "),
         parameters: {
@@ -504,6 +545,63 @@ function buildCoreToolSpecs() {
         },
       },
     },
+    {
+      type: "function",
+      function: {
+        name: "task_run",
+        description: [
+          "Start, inspect, cancel, fail, or complete a TaskRun.",
+          "TaskRuns are orthogonal to Plan Mode and do not require a plan_graph.",
+          "Use operation=start with an objective for a standalone single-point TaskRun; it returns immediately.",
+          "On complex multi-goal work, decompose into concrete objectives and start one or more TaskRuns.",
+          "Use plan_graph control.start_task only when the TaskRun is attached to a plan_graph task_loop node.",
+          "Do not call `task_run` together with data-plane tools in the same assistant turn.",
+        ].join(" "),
+        parameters: {
+          type: "object",
+          properties: {
+            operation: {
+              type: "string",
+              enum: ["start", "cancel", "fail", "complete", "inspect"],
+              description: [
+                "start creates a standalone TaskRun from objective;",
+                "cancel/fail/complete/inspect address an existing taskRunId",
+                "(cancel/fail may also use nodeId for graph-bound runs).",
+              ].join(" "),
+            },
+            objective: {
+              type: "string",
+              description: "Required for start: concrete TaskRun objective.",
+            },
+            title: {
+              type: "string",
+              description: "Optional short title for start.",
+            },
+            taskRunId: {
+              type: "string",
+              description: "TaskRun id for cancel, fail, complete, or inspect.",
+            },
+            nodeId: {
+              type: "string",
+              description: "Optional graph node id for cancel/fail of a graph-bound TaskRun.",
+            },
+            reason: {
+              type: "string",
+              description: "Optional reason for cancel or fail.",
+            },
+            result: {
+              type: "object",
+              description: "Optional result payload for complete (TaskLoop owner).",
+            },
+            commandId: {
+              type: "string",
+              description: "Optional idempotency key for explicit replay.",
+            },
+          },
+          required: ["operation"],
+        },
+      },
+    },
     {
       type: "function",
       function: {
@@ -759,6 +857,51 @@ function runCoreTool({
     };
   }
 
+  if (normalizedTool === "task_run") {
+    const state = executionState && typeof executionState === "object"
+      ? executionState
+      : emptyExecutionState();
+    const result = runTaskRunTool(safeArgs, {
+      executionState: state,
+      runTool: ({ node, args: nestedArgs, tool: nestedTool, stepId }) => {
+        const nested = runCoreTool({
+          tool: nestedTool,
+          args: nestedArgs,
+          workspaceRoot,
+          onToolEvent,
+          sessionId,
+          onArtifactPersisted,
+          executionState: state,
+          origin: {
+            kind: "task_run",
+            taskRunId: String(safeArgs.taskRunId || ""),
+            nodeId: stepId || (node && node.id) || "",
+            attempt: Number(node && node.attempt) || 0,
+          },
+        });
+        return nested;
+      },
+    });
+    const ok = result.ok !== false && result.status !== "rejected";
+    emitToolEvent(onToolEvent, {
+      tool: "task_run",
+      phase: ok ? "end" : "error",
+      args: safeArgs,
+      result,
+      error: ok
+        ? ""
+        : (Array.isArray(result.errors)
+          ? result.errors.map((e) => e.message || e.code).join("; ")
+          : (result.error || "task_run rejected")),
+      origin,
+    });
+    return {
+      ...result,
+      ok,
+      executionState: result.executionState || state,
+    };
+  }
+
   if (normalizedTool === "ask_user") {
     const state = executionState && typeof executionState === "object"
       ? executionState
@@ -957,6 +1100,12 @@ async function runOpenAiLikeTurn({
     // Kimi k3 rejects any temperature other than 1.
     temperature: normalizeProvider(provider) === "kimi" ? 1 : 0,
   };
+  const reasoningEffort = resolveReasoningEffort();
+  if (reasoningEffort) {
+    // OpenAI-compatible gateways that support reasoning models accept this;
+    // unknown fields are typically ignored by plain chat models.
+    payload.reasoning_effort = reasoningEffort;
+  }
 
   const headers = {
     "content-type": "application/json",
@@ -1460,140 +1609,76 @@ async function runAnthropicTurn({
   });
 }
 
-// Transport descriptors: everything the shared native loop needs that differs
-// between the OpenAI chat-completions and Anthropic messages protocols —
-// request URL resolution, initial message shaping, turn execution, and
-// assistant/tool-result message formatting.
+const {
+  createOpenAiChatTransport,
+  createAnthropicMessagesTransport,
+} = require("./providers");
+
+// Transport descriptors: wire-format only. Plan Mode / leases / policy live in the loop.
 const TRANSPORTS = {
-  "openai-chat": {
+  "openai-chat": createOpenAiChatTransport({
     resolveUrl: resolveCompletionUrl,
-    prepareMessages({ messages, systemPrompt, prompt }) {
-      const systemText = String(systemPrompt || "").trim();
-      const hasSystem = messages.some((entry) => String(entry.role || "").trim() === "system");
-      if (systemText && !hasSystem) {
-        messages.unshift({ role: "system", content: systemText });
-      }
-      messages.push({ role: "user", content: String(prompt || "") });
-    },
     runTurn: runOpenAiLikeTurn,
-    getToolCalls(turnResult) {
-      return Array.isArray(turnResult.toolCalls)
-        ? turnResult.toolCalls.filter((call) => call && call.function && typeof call.function === "object")
-        : [];
-    },
-    appendFinalAssistantMessage({ messages, turnResult }) {
-      const text = String(turnResult.text || "").trim();
-      if (text) {
-        messages.push({
-          role: "assistant",
-          content: text,
-        });
-      }
-    },
-    prepareToolCalls({ messages, toolCalls }) {
-      const assistantToolCalls = [];
-      for (const call of toolCalls) {
-        const callId = String(call.id || `call_${randomUUID()}`);
-        const name = normalizeToolName(call.function.name || "");
-        const args = normalizeToolCallArgs(call.function.arguments || "");
-
-        assistantToolCalls.push({
-          id: callId,
-          type: "function",
-          function: {
-            name: name || String(call.function.name || ""),
-            arguments: toJsonString(args),
-          },
-        });
-      }
+    normalizeToolName,
+    normalizeToolCallArgs,
+    toJsonString,
+    clipText,
+  }),
+  "anthropic-messages": createAnthropicMessagesTransport({
+    resolveUrl: resolveAnthropicMessagesUrl,
+    runTurn: runAnthropicTurn,
+    toJsonString,
+    clipText,
+  }),
+};
 
-      if (assistantToolCalls.length === 0) return null;
+function pendingToolCallId(pending = null) {
+  if (!pending || !pending.source) return "";
+  return String(pending.source.id || "").trim();
+}
 
-      messages.push({
-        role: "assistant",
-        content: null,
-        tool_calls: assistantToolCalls,
-      });
+function shadowDeclarePendingCalls(ledger, pendingCalls = []) {
+  const entries = (Array.isArray(pendingCalls) ? pendingCalls : []).map((pending) => ({
+    callId: pendingToolCallId(pending) || `call_${randomUUID()}`,
+    name: String(pending && pending.name || "").trim().toLowerCase(),
+    args: pending && pending.args != null ? pending.args : {},
+  }));
+  // Keep source ids aligned when we had to synthesize.
+  for (let i = 0; i < entries.length; i += 1) {
+    const pending = pendingCalls[i];
+    if (pending && pending.source && !pending.source.id) {
+      pending.source.id = entries[i].callId;
+    }
+  }
+  return declareCalls(ledger, entries);
+}
 
-      return assistantToolCalls.map((toolCall) => ({
-        name: toolCall.function.name,
-        args: normalizeToolCallArgs(toolCall.function.arguments),
-        source: toolCall,
-      }));
-    },
-    appendToolResult({ messages, call, toolResult }) {
-      messages.push({
-        role: "tool",
-        tool_call_id: call.source.id,
-        content: clipText(toJsonString(toolResult), 12000),
-      });
-    },
-  },
-  "anthropic-messages": {
-    resolveUrl: resolveAnthropicMessagesUrl,
-    prepareMessages({ messages, prompt }) {
-      messages.push({
-        role: "user",
-        content: String(prompt || ""),
-      });
-    },
-    runTurn: runAnthropicTurn,
-    getToolCalls(turnResult) {
-      return Array.isArray(turnResult.toolCalls) ? turnResult.toolCalls : [];
-    },
-    appendFinalAssistantMessage({ messages, turnResult }) {
-      const assistantContent = Array.isArray(turnResult.assistantContent)
-        ? turnResult.assistantContent
-        : [];
-      if (assistantContent.length > 0) {
-        messages.push({
-          role: "assistant",
-          content: assistantContent,
-        });
-      } else if (String(turnResult.text || "").trim()) {
-        messages.push({
-          role: "assistant",
-          content: [
-            {
-              type: "text",
-              text: String(turnResult.text || ""),
-            },
-          ],
-        });
-      }
-    },
-    prepareToolCalls({ messages, turnResult, toolCalls }) {
-      const assistantContent = Array.isArray(turnResult.assistantContent)
-        ? turnResult.assistantContent
-        : [];
-
-      messages.push({
-        role: "assistant",
-        content: assistantContent,
-      });
+function shadowResolvePending(ledger, pending, toolResult) {
+  if (!ledger) return;
+  const callId = pendingToolCallId(pending);
+  if (!callId) return;
+  resolveCall(ledger, callId, {
+    result: toolResult,
+    isError: Boolean(!toolResult || toolResult.ok === false),
+  });
+}
 
-      return toolCalls.map((call) => ({
-        name: call.name,
-        args: call.args,
-        source: call,
-      }));
-    },
-    appendToolResult({ collected, call, toolResult }) {
-      collected.push({
-        type: "tool_result",
-        tool_use_id: String(call.source.id || ""),
-        content: clipText(toJsonString(toolResult), 12000),
-        is_error: Boolean(!toolResult || toolResult.ok === false),
-      });
-    },
-    flushToolResults({ messages, collected }) {
-      messages.push({
-        role: "user",
-        content: collected,
-      });
-    },
-  },
-};
+function pendingByIdMap(pendingCalls = []) {
+  const map = Object.create(null);
+  for (const pending of pendingCalls) {
+    const id = pendingToolCallId(pending);
+    if (id) map[id] = pending;
+  }
+  return map;
+}
+
+function flushLedgerToolResults(ledger, transport, messages, pendingCalls) {
+  return materializeResolvedToolResults(ledger, {
+    transport,
+    messages,
+    pendingById: pendingByIdMap(pendingCalls),
+  });
+}
 
 async function runNativeLoop({
   transport,
@@ -1644,6 +1729,14 @@ async function runNativeLoop({
   ensurePendingUserPrompts(executionState);
   const toolBudget = resolveNativeToolBudget();
   const usage = createUsageTotals();
+  // Shadow Tool Call Ledger (R1). Observes declare/defer/resolve; does not
+  // materialize Provider messages yet. STRICT via UFOO_UCODE_PROTOCOL_STRICT=1.
+  let activeLedger = null;
+  let lastProtocolLedger = null;
+
+  if (resume) {
+    await withFaultPoint("before_provider_resume", () => {});
+  }
 
   function injectPendingUserReminders() {
     const nudges = drainUserPrompts(executionState);
@@ -1661,6 +1754,10 @@ async function runNativeLoop({
 
     injectPendingUserReminders();
 
+    if (activeLedger) {
+      runProviderTurnGate(activeLedger);
+    }
+
     const turnResult = await transport.runTurn({
       url: requestUrl,
       apiKey,
@@ -1730,6 +1827,7 @@ async function runNativeLoop({
         messages,
         usage,
         executionState,
+        protocolLedger: lastProtocolLedger || snapshotLedger(activeLedger),
       };
     }
 
@@ -1742,61 +1840,55 @@ async function runNativeLoop({
         messages,
         usage,
         executionState,
+        protocolLedger: lastProtocolLedger || snapshotLedger(activeLedger),
       };
     }
 
+    activeLedger = createToolCallLedger({ provider, sessionId });
+    shadowDeclarePendingCalls(activeLedger, pendingCalls);
+    lastProtocolLedger = snapshotLedger(activeLedger);
+    await withFaultPoint("after_prepare_tool_calls", () => {});
+    await withFaultPoint("before_tool_exec", () => {});
+
     const callNames = pendingCalls.map((call) => String(call.name || "").trim().toLowerCase());
-    const hasPlanGraph = callNames.includes("plan_graph");
+    const hasControlPlane = callNames.some((name) => CONTROL_PLANE_TOOLS.has(name));
     const hasAskUser = callNames.includes("ask_user");
     const hasDataTool = callNames.some((name) => EXECUTABLE_GRAPH_TOOLS.has(name));
-    if (hasPlanGraph && hasDataTool) {
+    if (hasControlPlane && hasDataTool) {
       // prepareToolCalls already appended the assistant tool_calls / tool_use
-      // message; every declared call must get a contiguous tool result.
-      const collectedResults = [];
+      // message; every declared call must get a contiguous tool result via ledger.
+      const rejected = {
+        ok: false,
+        status: "rejected",
+        error: "Do not mix plan_graph/task_run with data-plane tools in the same turn",
+        code: "MIXED_PLAN_AND_DATA_TOOLS",
+      };
       for (const pending of pendingCalls) {
-        transport.appendToolResult({
-          messages,
-          collected: collectedResults,
-          call: pending,
-          toolResult: {
-            ok: false,
-            status: "rejected",
-            error: "Do not mix plan_graph with data-plane tools in the same turn",
-            code: "MIXED_PLAN_AND_DATA_TOOLS",
-          },
-        });
+        shadowResolvePending(activeLedger, pending, rejected);
         toolCallsExecuted += 1;
         toolErrors += 1;
       }
-      if (typeof transport.flushToolResults === "function") {
-        transport.flushToolResults({ messages, collected: collectedResults });
-      }
+      flushLedgerToolResults(activeLedger, transport, messages, pendingCalls);
+      lastProtocolLedger = snapshotLedger(activeLedger);
       continue;
     }
     if (hasAskUser && pendingCalls.length > 1) {
-      const collectedResults = [];
+      const rejected = {
+        ok: false,
+        status: "rejected",
+        error: "ask_user must be the only tool call in the turn",
+        code: "ASK_USER_MUST_BE_ALONE",
+      };
       for (const pending of pendingCalls) {
-        transport.appendToolResult({
-          messages,
-          collected: collectedResults,
-          call: pending,
-          toolResult: {
-            ok: false,
-            status: "rejected",
-            error: "ask_user must be the only tool call in the turn",
-            code: "ASK_USER_MUST_BE_ALONE",
-          },
-        });
+        shadowResolvePending(activeLedger, pending, rejected);
         toolCallsExecuted += 1;
         toolErrors += 1;
       }
-      if (typeof transport.flushToolResults === "function") {
-        transport.flushToolResults({ messages, collected: collectedResults });
-      }
+      flushLedgerToolResults(activeLedger, transport, messages, pendingCalls);
+      lastProtocolLedger = snapshotLedger(activeLedger);
       continue;
     }
 
-    const collectedResults = [];
     let deferredAskUser = null;
     for (const pending of pendingCalls) {
       const pendingName = String(pending.name || "").trim().toLowerCase();
@@ -1814,12 +1906,7 @@ async function runNativeLoop({
         };
         toolCallsExecuted += 1;
         toolErrors += 1;
-        transport.appendToolResult({
-          messages,
-          collected: collectedResults,
-          call: pending,
-          toolResult: blocked,
-        });
+        shadowResolvePending(activeLedger, pending, blocked);
         continue;
       }
       if (planModeBlocksDirectTool(pendingName, executionState)) {
@@ -1833,12 +1920,7 @@ async function runNativeLoop({
         };
         toolCallsExecuted += 1;
         toolErrors += 1;
-        transport.appendToolResult({
-          messages,
-          collected: collectedResults,
-          call: pending,
-          toolResult: blocked,
-        });
+        shadowResolvePending(activeLedger, pending, blocked);
         continue;
       }
       const leaseCheck = checkWriteAllowed(executionState, {
@@ -1858,12 +1940,7 @@ async function runNativeLoop({
         };
         toolCallsExecuted += 1;
         toolErrors += 1;
-        transport.appendToolResult({
-          messages,
-          collected: collectedResults,
-          call: pending,
-          toolResult: blocked,
-        });
+        shadowResolvePending(activeLedger, pending, blocked);
         continue;
       }
 
@@ -1882,6 +1959,7 @@ async function runNativeLoop({
         }
         : null;
 
+      markExecuting(activeLedger, pendingToolCallId(pending));
       const toolResult = runCoreTool({
         tool: pending.name,
         args: pending.args,
@@ -1911,6 +1989,7 @@ async function runNativeLoop({
             transport: provider === "anthropic" ? "anthropic-messages" : "openai-chat",
           };
         }
+        deferCall(activeLedger, pendingToolCallId(pending), { reason: "ask_user" });
         deferredAskUser = { call: pending, interactionId: toolResult.interactionId || "" };
         continue;
       }
@@ -1923,17 +2002,11 @@ async function runNativeLoop({
         lastTool: pending.name,
         lastError: toolResult && toolResult.error ? String(toolResult.error) : "",
       });
-      transport.appendToolResult({
-        messages,
-        collected: collectedResults,
-        call: pending,
-        toolResult,
-      });
+      shadowResolvePending(activeLedger, pending, toolResult);
     }
 
-    if (typeof transport.flushToolResults === "function") {
-      transport.flushToolResults({ messages, collected: collectedResults });
-    }
+    flushLedgerToolResults(activeLedger, transport, messages, pendingCalls);
+    lastProtocolLedger = snapshotLedger(activeLedger);
 
     if (deferredAskUser) {
       return {
@@ -1945,6 +2018,7 @@ async function runNativeLoop({
         executionState,
         waitingUserInteraction: true,
         interactionId: deferredAskUser.interactionId || "",
+        protocolLedger: lastProtocolLedger,
       };
     }
 
@@ -1959,33 +2033,30 @@ async function runNativeLoop({
         executionState,
         waitingUserInteraction: true,
         interactionId: (getPendingUserInteraction(executionState) || {}).id || "",
+        protocolLedger: lastProtocolLedger,
       };
     }
   }
 }
 
-function appendAnswerToolResult(messages = [], resume = null, answer = {}) {
-  const call = resume && resume.call ? resume.call : null;
-  if (!call || !call.source) return { ok: false, error: "missing deferred tool call" };
-  const transportName = String(resume.transport || "openai-chat");
-  const content = clipText(toJsonString(answer), 12000);
-  if (transportName === "anthropic-messages") {
-    messages.push({
-      role: "user",
-      content: [{
-        type: "tool_result",
-        tool_use_id: String(call.source.id || resume.toolCallId || ""),
-        content,
-        is_error: false,
-      }],
-    });
-  } else {
-    messages.push({
-      role: "tool",
-      tool_call_id: String(call.source.id || resume.toolCallId || ""),
-      content,
-    });
+function appendAnswerToolResult(messages = [], resume = null, answer = {}, options = {}) {
+  const materialized = materializeAnswerToolResult(messages, resume, answer);
+  if (!materialized.ok) return materialized;
+  const ledger = options && options.ledger ? options.ledger : null;
+  if (ledger) {
+    const call = resume && resume.call ? resume.call : null;
+    const callId = String(
+      (call && call.source && call.source.id) || (resume && resume.toolCallId) || ""
+    ).trim();
+    if (callId) {
+      resolveCall(ledger, callId, {
+        result: answer,
+        isError: false,
+        allowFromDeferred: true,
+      });
+    }
   }
+  checkFaultPoint("after_answer_commit");
   return { ok: true };
 }
 
@@ -2118,6 +2189,7 @@ async function runNativeAgentTask({
       streamed: Boolean(runResult.streamed) && typeof onStreamDelta === "function",
       waitingUserInteraction: Boolean(runResult.waitingUserInteraction),
       interactionId: runResult.interactionId || "",
+      protocolLedger: runResult.protocolLedger || null,
     };
   } catch (err) {
     const message = err && err.message ? err.message : "native runner failed";
@@ -2142,6 +2214,8 @@ module.exports = {
   resolveCompletionUrl,
   resolveAnthropicMessagesUrl,
   resolveTransport,
+  resolveThinkingBudgetTokens,
+  resolveReasoningEffort,
   buildCoreToolSpecs,
   buildAnthropicToolSpecs,
 };