@rowan-agent/agent 0.30.0 → 0.32.0

package/dist/runtime.js

@@ -29,7 +29,7 @@ function snapshotMessages(messages) {
   return messages.map(snapshotMessage);
 }
 
-// src/types.ts
+// src/loop/messages.ts
 function createMessage(role, content, metadata) {
   return {
     id: createId("msg"),
@@ -47,9 +47,6 @@ function contentBlocksToMessageContent(blocks) {
     if (block.type === "thinking") {
       return { type: "thinking", thinking: block.thinking, ...block.signature ? { signature: block.signature } : {} };
     }
-    if (block.type === "image") {
-      return { type: "image", data: block.data, mimeType: block.mimeType };
-    }
     if (block.type === "tool_call") {
       let input = block.args;
       try {
@@ -419,11 +416,7 @@ async function invokeModel(input) {
   });
   const response = result.doneResponse ?? {
     content: result.text,
-    toolCalls: result.toolCalls.map((tc) => ({
-      id: tc.id,
-      name: tc.name,
-      arguments: tc.args
-    })),
+    toolCalls: result.toolCalls,
     stopReason: result.stopReason
   };
   return {
@@ -578,11 +571,7 @@ async function collectStreamResult(input) {
     throw new EmptyResponseError();
   }
   if (doneResponse) {
-    const toolCalls2 = (doneResponse.toolCalls ?? []).map((tc) => ({
-      id: tc.id,
-      name: tc.name,
-      args: tc.arguments
-    }));
+    const toolCalls2 = doneResponse.toolCalls ?? [];
     return {
       text: doneResponse.content,
       contentBlocks: lastPartial?.contentBlocks ?? [],
@@ -599,7 +588,7 @@ async function collectStreamResult(input) {
       parsedArgs = JSON.parse(b.args);
     } catch {
     }
-    return { id: b.id, name: b.name, args: parsedArgs };
+    return { id: b.id, name: b.name, arguments: parsedArgs };
   });
   return { text, contentBlocks, toolCalls, stopReason };
 }
@@ -1424,9 +1413,7 @@ function createRouteTool(availablePhases) {
       instruction: Type2.Optional(Type2.String({ description: "Overall instruction, passed as context" }))
     }),
     // No-op: this tool is intercepted by phases, never executed via tool execution
-    execute: async (_, context) => ({
-      toolCallId: context.toolCallId,
-      toolName: PhaseRouteTool,
+    execute: async () => ({
       ok: true,
       content: ""
     })
@@ -1436,16 +1423,17 @@ function extractRouteCall(toolCalls) {
   const routeCalls = toolCalls.filter((t) => t.name === PhaseRouteTool);
   if (routeCalls.length !== 1) return void 0;
   const routeCall = routeCalls[0];
+  const callArgs = routeCall.arguments !== void 0 ? routeCall.arguments : routeCall.args;
   let args;
-  if (typeof routeCall.args === "string") {
+  if (typeof callArgs === "string") {
     try {
-      const parsed = JSON.parse(routeCall.args);
+      const parsed = JSON.parse(callArgs);
       args = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
     } catch {
       return { decision: [{ phase: "" }] };
     }
   } else {
-    args = routeCall.args !== null && typeof routeCall.args === "object" ? routeCall.args : {};
+    args = callArgs !== null && typeof callArgs === "object" ? callArgs : {};
   }
   const decisionRaw = args.decision;
   let decision = [];
@@ -1526,21 +1514,24 @@ async function runInternalModelLoop(context, execution, phase, options) {
   };
   for (let attempt = 0; attempt < maxRounds && result.toolCalls.length > 0; attempt += 1) {
     if (!result.toolCalls.some((call) => isAllowedTool(call.name))) break;
-    const normalizedCalls = result.toolCalls.map((call) => ({
-      ...call,
-      args: typeof call.args === "string" ? (() => {
-        try {
-          return JSON.parse(call.args);
-        } catch {
-          return call.args;
-        }
-      })() : call.args
-    }));
+    const normalizedCalls = result.toolCalls.map((call) => {
+      const callArgs = call.arguments;
+      return {
+        ...call,
+        arguments: typeof callArgs === "string" ? (() => {
+          try {
+            return JSON.parse(callArgs);
+          } catch {
+            return callArgs;
+          }
+        })() : callArgs
+      };
+    });
     const toolUseParts = normalizedCalls.map((call) => ({
       type: "tool_use",
       id: call.id,
       name: call.name,
-      input: call.args
+      input: call.arguments
     }));
     const assistantContent = result.contentBlocks.length > 0 ? contentBlocksToMessageContent(result.contentBlocks) : result.text ? [{ type: "text", text: result.text }, ...toolUseParts] : toolUseParts;
     working.messages.push(createMessage("assistant", assistantContent, {
@@ -1774,20 +1765,12 @@ function resolveCoreToolPath(context, path = ".") {
   };
 }
 function toolResult(input) {
-  return {
-    toolCallId: input.context.toolCallId,
-    toolName: input.toolName,
-    ok: input.ok,
-    content: input.content,
-    ...input.error ? { error: input.error } : {}
-  };
+  return input.ok ? { ok: true, content: input.content } : { ok: false, content: input.content, error: input.error ?? "Tool execution failed" };
 }
 async function executeRuntimeToolCall(input) {
   const tool = input.tools.find((candidate) => candidate.name === input.toolCall.name);
   if (!tool) {
     const result = toolResult({
-      context: input.toolContext,
-      toolName: input.toolCall.name,
       ok: false,
       content: null,
       error: `Unknown tool: ${input.toolCall.name}`
@@ -1797,11 +1780,10 @@ async function executeRuntimeToolCall(input) {
   }
   let args;
   try {
-    args = validatorFor(tool.parameters).Parse(input.toolCall.args);
+    const rawArgs = input.toolCall.arguments;
+    args = validatorFor(tool.parameters).Parse(rawArgs);
   } catch (error) {
     const result = toolResult({
-      context: input.toolContext,
-      toolName: tool.name,
       ok: false,
       content: null,
       error: error instanceof Error ? error.message : String(error)
@@ -1810,12 +1792,14 @@ async function executeRuntimeToolCall(input) {
     return result;
   }
   let decision;
+  const effectiveSignal = input.signal ?? new AbortController().signal;
   if (input.beforeToolCall) {
     await input.observe?.({ type: "approval_requested", tool, args });
     decision = await input.beforeToolCall({
       tool,
       args,
-      toolCallId: input.toolCall.id
+      context: input.toolContext,
+      signal: effectiveSignal
     });
     if (decision && "allow" in decision) {
       await input.observe?.({
@@ -1828,8 +1812,6 @@ async function executeRuntimeToolCall(input) {
   }
   if (decision && "interaction" in decision) {
     const result = toolResult({
-      context: input.toolContext,
-      toolName: tool.name,
       ok: false,
       content: null,
       error: `Tool interaction required: ${decision.interaction.prompt}`
@@ -1839,8 +1821,6 @@ async function executeRuntimeToolCall(input) {
   }
   if (decision && "allow" in decision && !decision.allow) {
     const result = toolResult({
-      context: input.toolContext,
-      toolName: tool.name,
       ok: false,
       content: null,
       error: decision.reason
@@ -1850,14 +1830,25 @@ async function executeRuntimeToolCall(input) {
   }
   await input.observe?.({ type: "tool_start", tool, args });
   try {
-    let result = await tool.execute(args, input.toolContext, input.signal);
+    let result = await tool.execute(args, input.toolContext, effectiveSignal);
+    if (!("ok" in result)) {
+      result = { ok: !result.isError, ...result };
+    }
     if (input.afterToolCall) {
       await input.observe?.({
         type: "result_review_requested",
         tool,
         result
       });
-      result = await input.afterToolCall({ tool, result });
+      result = await input.afterToolCall({
+        tool,
+        result,
+        context: input.toolContext,
+        signal: effectiveSignal
+      });
+      if (!("ok" in result)) {
+        result = { ok: !result.isError, ...result };
+      }
       await input.observe?.({
         type: "result_review_result",
         tool,
@@ -1868,8 +1859,6 @@ async function executeRuntimeToolCall(input) {
     return result;
   } catch (error) {
     const result = toolResult({
-      context: input.toolContext,
-      toolName: tool.name,
       ok: false,
       content: null,
       error: error instanceof Error ? error.message : "Tool execution failed."
@@ -1952,8 +1941,6 @@ function createReadTool(context) {
       const limitError = parsed.limit === void 0 ? void 0 : positiveInteger(parsed.limit, "limit");
       if (offsetError || limitError) {
         return toolResult({
-          context: toolContext,
-          toolName: "read",
           ok: false,
           content: null,
           error: offsetError ?? limitError
@@ -1964,8 +1951,6 @@ function createReadTool(context) {
       const invalidLimit = positiveNumber(maxBytes, "maxBytes");
       if (invalidLimit) {
         return toolResult({
-          context: toolContext,
-          toolName: "read",
           ok: false,
           content: null,
           error: invalidLimit
@@ -1976,8 +1961,6 @@ function createReadTool(context) {
         fileStat = await stat(resolved.absolutePath);
       } catch (error) {
         return toolResult({
-          context: toolContext,
-          toolName: "read",
           ok: false,
           content: null,
           error: error instanceof Error ? error.message : String(error)
@@ -1985,8 +1968,6 @@ function createReadTool(context) {
       }
       if (!fileStat.isFile()) {
         return toolResult({
-          context: toolContext,
-          toolName: "read",
           ok: false,
           content: null,
           error: `Not a file: ${resolved.relativePath}`
@@ -1997,8 +1978,6 @@ function createReadTool(context) {
         bytes = await readFile2(resolved.absolutePath);
       } catch (error) {
         return toolResult({
-          context: toolContext,
-          toolName: "read",
           ok: false,
           content: null,
           error: error instanceof Error ? error.message : String(error)
@@ -2039,8 +2018,6 @@ function createReadTool(context) {
 Showing lines ${requestedOffset}-${selectedLineEnd} of ${sourceLines.length}. Use offset=${selectedLineEnd + 1} to continue.`;
       }
       return toolResult({
-        context: toolContext,
-        toolName: "read",
         ok: true,
         content
       });
@@ -2060,8 +2037,6 @@ function createWriteTool(context) {
       await mkdir(dirname4(resolved.absolutePath), { recursive: true });
       await writeFile(resolved.absolutePath, parsed.content, "utf8");
       return toolResult({
-        context: toolContext,
-        toolName: "write",
         ok: true,
         content: `Successfully wrote ${parsed.content.length} bytes to ${resolved.relativePath}.`
       });
@@ -2118,8 +2093,6 @@ function createEditTool(context) {
         replacements = result.replacements;
       } catch (error) {
         return toolResult({
-          context: toolContext,
-          toolName: "edit",
           ok: false,
           content: null,
           error: error instanceof Error ? error.message : String(error)
@@ -2127,8 +2100,6 @@ function createEditTool(context) {
       }
       await writeFile(resolved.absolutePath, next, "utf8");
       return toolResult({
-        context: toolContext,
-        toolName: "edit",
         ok: true,
         content: `Successfully replaced ${replacements} block(s) in ${resolved.relativePath}.`
       });
@@ -2150,8 +2121,6 @@ function createBashTool(context) {
       const invalidOutputLimit = positiveNumber(maxOutputBytes, "maxOutputBytes");
       if (invalidTimeout || invalidOutputLimit) {
         return toolResult({
-          context: toolContext,
-          toolName: "bash",
           ok: false,
           content: null,
           error: invalidTimeout ?? invalidOutputLimit
@@ -2193,8 +2162,6 @@ function createBashTool(context) {
 
 [Full result: ${archivePath}, offset 0]`;
         return toolResult({
-          context: toolContext,
-          toolName: "bash",
           ok,
           content,
           ...ok ? {} : {
@@ -2318,7 +2285,7 @@ function buildModelRequest(input, options) {
   const modelTools = input.tools.map((t) => ({
     name: t.name,
     description: t.description,
-    parameters: t.parameters
+    parameters: t.parameters ?? {}
   }));
   return {
     model: options?.model ?? { provider: "", id: "" },
@@ -2336,12 +2303,18 @@ function parseToolResult(content) {
   try {
     const parsed = JSON.parse(content);
     if (typeof parsed.toolCallId === "string" && typeof parsed.toolName === "string" && typeof parsed.ok === "boolean") {
-      return {
+      const base = {
         toolCallId: parsed.toolCallId,
         toolName: parsed.toolName,
-        ok: parsed.ok,
-        content: parsed.content,
-        ...parsed.error ? { error: parsed.error } : {}
+        content: parsed.content ?? null
+      };
+      if (parsed.ok) {
+        return { ...base, ok: true };
+      }
+      return {
+        ...base,
+        ok: false,
+        error: typeof parsed.error === "string" ? parsed.error : "Tool execution failed."
       };
     }
   } catch {
@@ -2383,17 +2356,12 @@ var createOutcome = {
   default(output, transcript) {
     const toolResults = transcript ? extractToolResults(transcript) : [];
     const message = output.message || output.routeReason || `${output.phase ?? "Unknown"} phase completed.`;
-    const outcome = {
+    return {
       id: createId("out"),
-      message
+      message,
+      ...output.payload !== void 0 ? { payload: output.payload } : {},
+      ...toolResults.length > 0 ? { toolResults } : {}
     };
-    if (output.payload !== void 0) {
-      outcome.payload = output.payload;
-    }
-    if (toolResults.length > 0) {
-      outcome.toolResults = toolResults;
-    }
-    return outcome;
   },
   phase(output, transcript) {
     return {
@@ -2638,7 +2606,7 @@ function createToolResultContent(result) {
     {
       type: "tool_result",
       toolUseId: result.toolCallId,
-      content: JSON.stringify(result),
+      content: typeof result.content === "string" ? result.content : JSON.stringify(result),
       isError: !result.ok
     }
   ];
@@ -2959,7 +2927,7 @@ async function runPhaseLoop(config, state, registry) {
         previousPhaseInputMsgId = void 0;
         if (extBefore.skip.route === "stop") {
           return completeRun(config, state, {
-            id: "skip",
+            id: createId("out"),
             message: extBefore.skip.message || "Skipped."
           });
         }
@@ -3209,6 +3177,25 @@ async function executePhase(ctx) {
   }
   return executePhaseWithModel(ctx);
 }
+function inertRunInteraction(signal) {
+  const controller = signal ? void 0 : new AbortController();
+  const state = {
+    currentPhase: "default",
+    attempt: 0,
+    status: "running",
+    metrics: { iterations: 0, phaseTransitions: [], compactionCount: 0, retryCount: 0, startedAt: (/* @__PURE__ */ new Date()).toISOString(), startedAtMs: Date.now() }
+  };
+  const driver = createRunInteractionDriver(state, "default", signal ?? controller.signal);
+  return {
+    ...driver,
+    request: () => {
+      throw new Error("Run interactions require an active interaction driver.");
+    },
+    suspend: () => {
+      throw new Error("Run interactions require an active interaction driver.");
+    }
+  };
+}
 async function executeToolCall(input) {
   let result;
   if (input.config.runtime?.tools) {
@@ -3222,14 +3209,20 @@ async function executeToolCall(input) {
       ...input.phase !== void 0 ? { phase: input.phase } : {}
     });
   } else {
-    const toolContext = {
-      skills: input.config.context.skills,
-      toolCallId: input.toolCall.id
+    const toolInvocationContext = {
+      agentId: input.config.execution.agentId,
+      runId: input.config.execution.runId,
+      toolCallId: input.toolCall.id,
+      providerToolCallId: input.toolCall.id,
+      reportProgress: () => {
+      },
+      interaction: input.driver ?? inertRunInteraction(input.config.signal),
+      ...input.phase !== void 0 ? { phase: input.phase } : {}
     };
     result = await executeRuntimeToolCall({
       tools: input.tools,
       toolCall: input.toolCall,
-      toolContext,
+      toolContext: toolInvocationContext,
       beforeToolCall: input.config.beforeToolCall,
       afterToolCall: input.config.afterToolCall,
       signal: combineSignals(input.config.signal, input.options?.signal)
@@ -3273,7 +3266,7 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
   const interaction = createRunInteractionDriver(state, phase.name, config.signal);
   const executePhaseTool = async (phaseContext, toolCall, options, providerInitiated = false) => {
     return runTurn(async () => {
-      await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
+      await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.arguments);
       const tools = phaseContext.tools.filter((tool) => tool.name !== PhaseRouteTool);
       const result = await executeToolCall({
         config: {
@@ -3320,7 +3313,8 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
           request.tools = phaseContext.tools.map((t) => ({
             name: t.name,
             description: t.description,
-            parameters: t.parameters
+            parameters: t.parameters,
+            ...t._meta !== void 0 ? { _meta: t._meta } : {}
           }));
         }
       }
@@ -3347,7 +3341,7 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
             return tools.map((t) => ({
               name: t.name,
               description: t.description,
-              parameters: t.parameters,
+              parameters: t.parameters ?? {},
               ...t._meta !== void 0 ? { _meta: t._meta } : {}
             }));
           },
@@ -3356,10 +3350,11 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
             const toolCall = {
               id: toolCallId,
               name,
-              args
+              arguments: args
             };
             const res = await executePhaseTool(phaseContext, toolCall, options2, true);
-            return res.ok ? { ok: true, content: res.content } : { ok: false, error: res.error ?? "Tool execution failed", ...res.content !== void 0 ? { content: res.content } : {} };
+            const { toolCallId: _id, toolName: _name, ...result2 } = res;
+            return result2;
           }
         }
       };
@@ -3403,7 +3398,7 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
       return runTurn(async () => {
         const tools = phaseContext.tools.filter((tool) => tool.name !== PhaseRouteTool);
         for (const toolCall of toolCalls) {
-          await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
+          await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.arguments);
         }
         const results = await executeToolCalls({
           config: {
@@ -3938,16 +3933,8 @@ function assertToolExecutionResult(value) {
 var CORE_TOOL_NAMES = /* @__PURE__ */ new Set(["read", "edit", "write", "bash"]);
 function createRuntimeCoreTools(input = {}) {
   return createCoreTools(input).map((tool) => ({
-    name: tool.name,
-    core: true,
-    description: tool.description,
-    parameters: tool.parameters,
-    ...tool.promptSnippet ? { promptSnippet: tool.promptSnippet } : {},
-    ...tool.promptGuidelines ? { promptGuidelines: tool.promptGuidelines } : {},
-    execute: async (args, context, signal) => {
-      const result = await tool.execute(args, { skills: [], toolCallId: context.toolCallId }, signal);
-      return result.ok ? { ok: true, content: result.content } : { ok: false, content: result.content, error: result.error ?? "Tool failed." };
-    }
+    ...tool,
+    core: true
   }));
 }
 
@@ -4608,7 +4595,7 @@ function projectModelContext(input) {
   return {
     systemPrompt: input.context.systemPrompt,
     messages: projectedMessages,
-    tools: input.context.tools.map((tool) => projectTool(tool, input.agentId, input.runId)),
+    tools: [...input.context.tools],
     skills: [...input.context.skills],
     ...input.context.phases ? { phases: input.context.phases } : {}
   };
@@ -4713,48 +4700,6 @@ function projectToolContent(content) {
     };
   });
 }
-function inertRunInteraction(signal) {
-  const controller = signal ? void 0 : new AbortController();
-  const state = {
-    currentPhase: "default",
-    attempt: 0,
-    status: "running",
-    metrics: { iterations: 0, phaseTransitions: [], compactionCount: 0, retryCount: 0, startedAt: (/* @__PURE__ */ new Date()).toISOString(), startedAtMs: Date.now() }
-  };
-  const driver = createRunInteractionDriver(state, "default", signal ?? controller.signal);
-  return {
-    ...driver,
-    request: () => {
-      throw new Error("Run interactions require an active interaction driver.");
-    },
-    suspend: () => {
-      throw new Error("Run interactions require an active interaction driver.");
-    }
-  };
-}
-function projectTool(tool, agentId, runId) {
-  return {
-    name: tool.name,
-    ...tool.core ? { core: true } : {},
-    description: tool.description,
-    parameters: tool.parameters,
-    ...tool.promptSnippet ? { promptSnippet: tool.promptSnippet } : {},
-    ...tool.promptGuidelines ? { promptGuidelines: [...tool.promptGuidelines] } : {},
-    ...tool._meta !== void 0 ? { _meta: tool._meta } : {},
-    execute: async (args, context, signal) => {
-      const result = await tool.execute(args, {
-        agentId,
-        runId,
-        toolCallId: context.toolCallId,
-        providerToolCallId: context.toolCallId,
-        reportProgress: () => void 0,
-        interaction: context.interaction ?? inertRunInteraction(signal)
-      }, signal ?? new AbortController().signal);
-      const ok = "ok" in result && typeof result.ok === "boolean" ? result.ok : !result.isError;
-      return { toolCallId: context.toolCallId, toolName: tool.name, ok, ...result };
-    }
-  };
-}
 function jsonText(value) {
   return typeof value === "string" ? value : JSON.stringify(value) ?? "null";
 }
@@ -4779,8 +4724,7 @@ function assembleRegisteredExtensions(snapshot, runner, options = {}) {
     afterPhase: (phaseId, output) => runner.emitAfterPhase(phaseId, output),
     beforePrompt: (phaseId, input) => runner.emitBeforePrompt(phaseId, input),
     beforeToolCall: async (input) => {
-      const tool = projectTool(input.tool, input.context.agentId, input.context.runId);
-      const decision = await runner.emitBeforeToolCall(tool, input.args, {
+      const decision = await runner.emitBeforeToolCall(input.tool, input.args, {
         runId: input.context.runId,
         agentId: input.context.agentId,
         toolCallId: input.context.toolCallId,
@@ -4797,10 +4741,9 @@ function assembleRegisteredExtensions(snapshot, runner, options = {}) {
       return decision.allow ? { allow: true } : { allow: false, reason: decision.reason ?? "Extension hook rejected the Tool." };
     },
     afterToolCall: async (input) => {
-      const tool = projectTool(input.tool, input.context.agentId, input.context.runId);
-      const result = await runner.emitAfterToolCall(
-        tool,
-        toLoopResult(input.result, input.context.toolCallId, input.tool.name),
+      return runner.emitAfterToolCall(
+        input.tool,
+        input.result,
         {
           runId: input.context.runId,
           agentId: input.context.agentId,
@@ -4811,7 +4754,6 @@ function assembleRegisteredExtensions(snapshot, runner, options = {}) {
           ...input.context.phase === void 0 ? {} : { phase: input.context.phase }
         }
       );
-      return fromLoopResult(result);
     },
     setContext: (context2) => {
       runner.currentContext = context2;
@@ -4853,35 +4795,6 @@ function resolveDefinitionContext(snapshot, assembled, runner, scope) {
     ...snapshot.cwd ? { cwd: snapshot.cwd } : {}
   };
 }
-function toLoopResult(result, toolCallId, toolName) {
-  const ok = "ok" in result && typeof result.ok === "boolean" ? result.ok : !result.isError;
-  const error = "error" in result && typeof result.error === "string" ? result.error : void 0;
-  return {
-    toolCallId,
-    toolName,
-    ok,
-    content: result.content,
-    ...!ok && error ? { error } : {},
-    ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {},
-    ...result.isError !== void 0 ? { isError: result.isError } : {}
-  };
-}
-function fromLoopResult(result) {
-  if (Array.isArray(result.content)) {
-    return {
-      content: result.content,
-      ...result.ok !== void 0 ? { ok: result.ok } : {},
-      ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {},
-      ...result.isError !== void 0 ? { isError: result.isError } : !result.ok ? { isError: true } : {},
-      ...result.error !== void 0 ? { error: result.error } : {}
-    };
-  }
-  return {
-    ...result.ok ? { ok: true } : { ok: false, error: result.error ?? "Extension hook rejected the Tool result." },
-    content: result.content,
-    ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
-  };
-}
 
 // src/runtime/session-files.ts
 import { appendFileSync, chmodSync, existsSync as existsSync3, mkdirSync, readFileSync } from "fs";
@@ -7535,6 +7448,11 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
         if (!agentsDelegate) throw new Error("AgentRuntime is not available in this extension context.");
         return agentsDelegate.listRuns({ agentId, ...filter });
       },
+      run: async (runId) => {
+        assertActive();
+        if (!agentsDelegate) throw new Error("AgentRuntime is not available in this extension context.");
+        return agentsDelegate.snapshot(runId);
+      },
       runPhase: async (agentId, runOpt) => {
         assertActive();
         if (!agentsDelegate) throw new Error("AgentRuntime is not available in this extension context.");
@@ -10538,7 +10456,7 @@ var AgentRuntime = class _AgentRuntime {
                               options.onUpdate(createMergedToolCall(
                                 toolCallId2,
                                 "failed",
-                                { rawInput: toJsonValue(toolCall.args) },
+                                { rawInput: toolCallArgs(toolCall) },
                                 toolCall.name,
                                 "other"
                               ));
@@ -10549,8 +10467,6 @@ var AgentRuntime = class _AgentRuntime {
                         }
                         if (!controller.signal.aborted && isCancel) {
                           return {
-                            toolCallId: toolCall.id,
-                            toolName: toolCall.name,
                             ok: false,
                             content: null,
                             error: reason
@@ -10681,7 +10597,7 @@ var AgentRuntime = class _AgentRuntime {
       }
       if (result.type === "completed") {
         const output2 = latestAssistant(run, result.messages, executionContext.messages.length);
-        await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, outcome: durableOutcome(result.outcome), ...output2 ? { output: output2 } : {} });
+        await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, outcome: result.outcome, ...output2 ? { output: output2 } : {} });
         this.transientEvents.clear(run.id, claim.execution.executionId, true);
         await this.handleRunEnd(run.id, run.agentId, result.outcome);
         return;
@@ -10808,7 +10724,7 @@ var AgentRuntime = class _AgentRuntime {
         try {
           const decision = await input.toolConfig.beforeToolCall({
             tool: durableTool,
-            args: toJsonValue(toolCall.args),
+            args: toolCallArgs(toolCall),
             context,
             signal: input.signal
           });
@@ -10825,7 +10741,7 @@ var AgentRuntime = class _AgentRuntime {
         const startPresentations = await Promise.all(
           input.toolCalls.map(async (tc) => {
             const t = input.toolConfig.tools.find((c) => c.name === tc.name);
-            return t ? presentToolPending(t, toJsonValue(tc.args)) : void 0;
+            return t ? presentToolPending(t, toolCallArgs(tc)) : void 0;
           })
         );
         const reserved = await this.owned.reserveToolCalls({
@@ -10840,7 +10756,7 @@ var AgentRuntime = class _AgentRuntime {
             toolCallId: toolCallIds[i],
             providerToolCallId: tc.id,
             name: tc.name,
-            args: toJsonValue(tc.args),
+            args: toolCallArgs(tc),
             ...startPresentations[i] ?? {}
           }))
         });
@@ -10852,8 +10768,6 @@ var AgentRuntime = class _AgentRuntime {
           const providerToolCallId = toolCall.id;
           const toolCallId = toolCallIds[i];
           const protocolFailure = (error) => ({
-            toolCallId: providerToolCallId,
-            toolName: toolCall.name,
             ok: false,
             content: null,
             error
@@ -10894,11 +10808,11 @@ var AgentRuntime = class _AgentRuntime {
               title: durableTool.annotations?.title ?? durableTool.name,
               kind: durableTool.kind ?? "other"
             },
-            rawInput: toJsonValue(toolCall.args)
+            rawInput: toolCallArgs(toolCall)
           };
           const inProgressPres = await presentToolCall(durableTool, {
             status: "in_progress",
-            args: toJsonValue(toolCall.args)
+            args: toolCallArgs(toolCall)
           });
           if (inProgressPres) mergeToolCall(currentToolState, inProgressPres);
           const started = await this.owned.startToolCall({
@@ -10958,8 +10872,6 @@ var AgentRuntime = class _AgentRuntime {
       const isReserved = Boolean(active?.reservedToolCalls.has(toolCallId));
       const isStarted = Boolean(active?.startedToolCalls.has(toolCallId));
       const protocolFailure = (error) => ({
-        toolCallId: providerToolCallId,
-        toolName: toolCall.name,
         ok: false,
         content: null,
         error
@@ -10978,7 +10890,7 @@ var AgentRuntime = class _AgentRuntime {
               toolCallId,
               providerToolCallId,
               name: toolCall.name,
-              args: toJsonValue(toolCall.args)
+              args: toolCallArgs(toolCall)
             }]
           });
           setRevision(reserved.run.revision);
@@ -10998,15 +10910,15 @@ var AgentRuntime = class _AgentRuntime {
         results.push(protocolFailure(`Tool ${toolCall.name} is not available.`));
         continue;
       }
-      const pendingPres = await presentToolPending(durableTool, toJsonValue(toolCall.args));
+      const pendingPres = await presentToolPending(durableTool, toolCallArgs(toolCall));
       const currentToolState = {
         ...pendingPres,
-        rawInput: toJsonValue(toolCall.args)
+        rawInput: toolCallArgs(toolCall)
       };
       const resumedStart = suspension && index === suspension.pendingIndex ? await (async () => {
         const inProgressPres = await presentToolCall(durableTool, {
           status: "in_progress",
-          args: toJsonValue(toolCall.args)
+          args: toolCallArgs(toolCall)
         });
         if (inProgressPres) mergeToolCall(currentToolState, inProgressPres);
         return this.owned.startToolCall({
@@ -11055,7 +10967,7 @@ var AgentRuntime = class _AgentRuntime {
         if (input.toolConfig.beforeToolCall) {
           const decision = await input.toolConfig.beforeToolCall({
             tool: durableTool,
-            args: toJsonValue(toolCall.args),
+            args: toolCallArgs(toolCall),
             context,
             signal: input.signal,
             answer
@@ -11078,7 +10990,7 @@ var AgentRuntime = class _AgentRuntime {
                   toolCallId,
                   providerToolCallId,
                   name: toolCall.name,
-                  args: toJsonValue(toolCall.args),
+                  args: toolCallArgs(toolCall),
                   ...pendingPres
                 }]
               });
@@ -11101,7 +11013,7 @@ var AgentRuntime = class _AgentRuntime {
                   toolCallId,
                   providerToolCallId,
                   name: toolCall.name,
-                  args: toJsonValue(toolCall.args),
+                  args: toolCallArgs(toolCall),
                   ...pendingPres
                 }]
               });
@@ -11157,7 +11069,7 @@ var AgentRuntime = class _AgentRuntime {
               toolCallId,
               providerToolCallId,
               name: toolCall.name,
-              args: toJsonValue(toolCall.args),
+              args: toolCallArgs(toolCall),
               ...pendingPres
             }]
           });
@@ -11208,7 +11120,7 @@ var AgentRuntime = class _AgentRuntime {
               toolCallId,
               providerToolCallId,
               name: toolCall.name,
-              args: toJsonValue(toolCall.args),
+              args: toolCallArgs(toolCall),
               ...pendingPres
             }]
           });
@@ -11217,7 +11129,7 @@ var AgentRuntime = class _AgentRuntime {
         }
         const inProgressPres = await presentToolCall(durableTool, {
           status: "in_progress",
-          args: toJsonValue(toolCall.args)
+          args: toolCallArgs(toolCall)
         });
         if (inProgressPres) mergeToolCall(currentToolState, inProgressPres);
         const started = await this.owned.startToolCall({
@@ -11330,7 +11242,7 @@ var AgentRuntime = class _AgentRuntime {
           if (!progressActive || this.closed || effectiveSignal.aborted) return;
           const pres = await presentToolCall(input.durableTool, {
             status: "in_progress",
-            args: toJsonValue(input.toolCall.args),
+            args: toolCallArgs(input.toolCall),
             progress: copy
           });
           if (pres) {
@@ -11366,9 +11278,12 @@ var AgentRuntime = class _AgentRuntime {
         throw error;
       }
       let result = await withAbort(
-        input.durableTool.execute(toJsonValue(input.toolCall.args), context, effectiveSignal),
+        input.durableTool.execute(toolCallArgs(input.toolCall), context, effectiveSignal),
         input.options?.signal
       );
+      if (!("ok" in result)) {
+        result = { ok: !result.isError, ...result };
+      }
       assertToolExecutionResult(result);
       if (input.afterToolCall) {
         result = await input.afterToolCall({
@@ -11377,6 +11292,9 @@ var AgentRuntime = class _AgentRuntime {
           context,
           signal: effectiveSignal
         });
+        if (!("ok" in result)) {
+          result = { ok: !result.isError, ...result };
+        }
       }
       assertToolExecutionResult(result);
       result = await spillLargeToolResult(
@@ -11386,10 +11304,10 @@ var AgentRuntime = class _AgentRuntime {
       );
       await progressQueue.catch(() => {
       });
-      const finalState = result.ok ? "completed" : "failed";
+      const finalState = ("ok" in result ? result.ok : !result.isError) ? "completed" : "failed";
       const completionPres = await presentToolCall(input.durableTool, {
         status: finalState,
-        args: toJsonValue(input.toolCall.args),
+        args: toolCallArgs(input.toolCall),
         result
       });
       if (completionPres) {
@@ -11423,13 +11341,7 @@ var AgentRuntime = class _AgentRuntime {
       );
       notifyUpdate(finalToolCall);
       const projectedResult = await this.foldToolInteractionRecords(result, input.toolCallId, input.agentId);
-      const ok = "ok" in projectedResult && typeof projectedResult.ok === "boolean" ? projectedResult.ok : !projectedResult.isError;
-      return {
-        toolCallId: input.providerToolCallId,
-        toolName: input.toolCall.name,
-        ...projectedResult,
-        ok
-      };
+      return projectedResult;
     } catch (error) {
       if (error instanceof RunInteractionBoundary) {
         if (!input.providerInitiated) {
@@ -11450,7 +11362,7 @@ var AgentRuntime = class _AgentRuntime {
       });
       const failurePres = await presentToolCall(input.durableTool, {
         status: "failed",
-        args: toJsonValue(input.toolCall.args),
+        args: toolCallArgs(input.toolCall),
         result: { ok: false, content: null, error: reason }
       });
       if (failurePres) {
@@ -11481,8 +11393,6 @@ var AgentRuntime = class _AgentRuntime {
       );
       notifyUpdate(finalToolCall);
       return {
-        toolCallId: input.providerToolCallId,
-        toolName: input.toolCall.name,
         ok: false,
         content: null,
         error: reason
@@ -11691,14 +11601,6 @@ function latestAssistant(run, messages, historyLength, interrupted = false) {
 function hasVisibleAssistantText(message) {
   return typeof message.content === "string" ? message.content.length > 0 : message.content.some((part) => part.type === "text" && part.text.length > 0);
 }
-function durableOutcome(outcome) {
-  return {
-    id: outcome.id,
-    message: outcome.message,
-    ...outcome.payload === void 0 ? {} : { payload: outcome.payload },
-    ...outcome.toolResults === void 0 ? {} : { toolResults: outcome.toolResults }
-  };
-}
 function boundaryFromSnapshot(snapshot) {
   switch (snapshot.state) {
     case "input_required":
@@ -11814,6 +11716,9 @@ function toJsonValue(value) {
   assertJsonValue(value, "tool arguments");
   return value;
 }
+function toolCallArgs(toolCall) {
+  return toJsonValue(toolCall.arguments);
+}
 function createMergedToolCall(toolCallId, status, current, fallbackTitle, fallbackKind = "other") {
   return {
     toolCallId,