@rowan-agent/agent 0.16.2 → 0.18.0

package/dist/index.js

@@ -945,7 +945,7 @@ function createRuntimeCoreTools(input = {}) {
 import { mkdir as mkdir2, chmod as chmod2, writeFile as writeFile2 } from "fs/promises";
 import { randomUUID } from "crypto";
 import { join as join5 } from "path";
-import { createModelStream } from "@rowan-agent/models";
+import { createModelStream, isValidToolProgress } from "@rowan-agent/models";
 
 // src/utils.ts
 function createId(prefix) {
@@ -961,6 +961,49 @@ function createTimestamp(date = /* @__PURE__ */ new Date()) {
   const mm = String(abs % 60).padStart(2, "0");
   return `${iso}${sign}${hh}:${mm}`;
 }
+function combineSignals(signalA, signalB) {
+  if (!signalA && !signalB) return new AbortController().signal;
+  if (!signalA) return signalB;
+  if (!signalB) return signalA;
+  if (typeof AbortSignal.any === "function") {
+    return AbortSignal.any([signalA, signalB]);
+  }
+  if (signalA.aborted) return signalA;
+  if (signalB.aborted) return signalB;
+  const controller = new AbortController();
+  const onAbort = (ev) => {
+    const target = ev.target;
+    controller.abort(target.reason);
+  };
+  signalA.addEventListener("abort", onAbort, { once: true });
+  signalB.addEventListener("abort", onAbort, { once: true });
+  return controller.signal;
+}
+function withAbort(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    const error = signal.reason instanceof Error ? signal.reason : new DOMException(typeof signal.reason === "string" ? signal.reason : "Tool execution aborted.", "AbortError");
+    return Promise.reject(error);
+  }
+  return new Promise((resolve9, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      const error = signal.reason instanceof Error ? signal.reason : new DOMException(typeof signal.reason === "string" ? signal.reason : "Tool execution aborted.", "AbortError");
+      reject(error);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (val) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve9(val);
+      },
+      (err) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(err);
+      }
+    );
+  });
+}
 
 // src/loop/state.ts
 function snapshotMessage(message) {
@@ -991,12 +1034,18 @@ function contentBlocksToMessageContent(blocks) {
     if (block.type === "thinking") {
       return { type: "thinking", thinking: block.thinking, ...block.signature ? { signature: block.signature } : {} };
     }
-    let input = block.args;
-    try {
-      input = JSON.parse(block.args);
-    } catch {
+    if (block.type === "image") {
+      return { type: "image", data: block.data, mimeType: block.mimeType };
+    }
+    if (block.type === "tool_call") {
+      let input = block.args;
+      try {
+        input = JSON.parse(block.args);
+      } catch {
+      }
+      return { type: "tool_use", id: block.id, name: block.name, input };
     }
-    return { type: "tool_use", id: block.id, name: block.name, input };
+    return { type: "text", text: JSON.stringify(block) };
   });
 }
 
@@ -1009,6 +1058,296 @@ function validateMaxAttempts(value) {
   return value;
 }
 
+// src/loop/partial-json.ts
+var COMPLETE_NUMBER_REGEX = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+function escapeRawControlChars(s) {
+  let result = "";
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    const code = ch.charCodeAt(0);
+    if (code === 10) result += "\\n";
+    else if (code === 13) result += "\\r";
+    else if (code === 9) result += "\\t";
+    else if (code < 32) result += "\\u" + code.toString(16).padStart(4, "0");
+    else result += ch;
+  }
+  return result;
+}
+function cleanOpenString(raw) {
+  let s = raw;
+  let backslashes = 0;
+  while (s.length - 1 - backslashes >= 0 && s[s.length - 1 - backslashes] === "\\") {
+    backslashes++;
+  }
+  if (backslashes % 2 === 1) {
+    s = s.slice(0, -1);
+  } else {
+    s = s.replace(/(^|[^\\])(?:\\\\)*\\u[0-9a-fA-F]{0,3}$/, (match) => {
+      const uIndex = match.lastIndexOf("\\u");
+      return match.slice(0, uIndex);
+    });
+  }
+  return escapeRawControlChars(s) + '"';
+}
+function repairPartialJson(input) {
+  const stack = [];
+  let i = 0;
+  let hasTopLevelValue = false;
+  let topLevelSafeEnd = 0;
+  function finishWithSafeEnd(safeEnd) {
+    let result = input.slice(0, safeEnd);
+    for (let j = stack.length - 1; j >= 0; j--) {
+      result += stack[j].kind === "object" ? "}" : "]";
+    }
+    return result;
+  }
+  function closeStackWithPrefix(prefix) {
+    let result = prefix;
+    for (let j = stack.length - 1; j >= 0; j--) {
+      result += stack[j].kind === "object" ? "}" : "]";
+    }
+    return result;
+  }
+  function popContainer(endIndex) {
+    stack.pop();
+    const parent = stack[stack.length - 1];
+    if (parent) {
+      parent.safeEnd = endIndex;
+      parent.state = "after_value";
+    } else {
+      hasTopLevelValue = true;
+      topLevelSafeEnd = endIndex;
+    }
+  }
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      i++;
+      continue;
+    }
+    const current = stack[stack.length - 1];
+    if (!current) {
+      if (hasTopLevelValue) break;
+      if (ch === "{") {
+        stack.push({ kind: "object", safeEnd: i + 1, state: "expect_key" });
+        i++;
+      } else if (ch === "[") {
+        stack.push({ kind: "array", safeEnd: i + 1, state: "expect_value" });
+        i++;
+      } else if (ch === '"') {
+        const strStart = i;
+        i++;
+        let closed = false;
+        while (i < input.length) {
+          if (input[i] === "\\") {
+            i += 2;
+          } else if (input[i] === '"') {
+            i++;
+            closed = true;
+            break;
+          } else {
+            i++;
+          }
+        }
+        if (closed) {
+          hasTopLevelValue = true;
+          topLevelSafeEnd = i;
+        } else {
+          return cleanOpenString(input.slice(strStart));
+        }
+      } else {
+        const tokStart = i;
+        while (i < input.length && !/[\s,}\]]/.test(input[i])) {
+          i++;
+        }
+        const tok = input.slice(tokStart, i);
+        if (tok === "true" || tok === "false" || tok === "null" || COMPLETE_NUMBER_REGEX.test(tok)) {
+          hasTopLevelValue = true;
+          topLevelSafeEnd = i;
+        } else {
+          return void 0;
+        }
+      }
+      continue;
+    }
+    if (current.kind === "object") {
+      if (current.state === "expect_key") {
+        if (ch === "}") {
+          i++;
+          popContainer(i);
+        } else if (ch === '"') {
+          i++;
+          let closed = false;
+          while (i < input.length) {
+            if (input[i] === "\\") {
+              i += 2;
+            } else if (input[i] === '"') {
+              i++;
+              closed = true;
+              break;
+            } else {
+              i++;
+            }
+          }
+          if (closed) {
+            current.state = "expect_colon";
+          } else {
+            return finishWithSafeEnd(current.safeEnd);
+          }
+        } else {
+          return finishWithSafeEnd(current.safeEnd);
+        }
+      } else if (current.state === "expect_colon") {
+        if (ch === ":") {
+          current.state = "expect_value";
+          i++;
+        } else {
+          return finishWithSafeEnd(current.safeEnd);
+        }
+      } else if (current.state === "expect_value") {
+        if (ch === '"') {
+          const valStart = i;
+          i++;
+          let closed = false;
+          while (i < input.length) {
+            if (input[i] === "\\") {
+              i += 2;
+            } else if (input[i] === '"') {
+              i++;
+              closed = true;
+              break;
+            } else {
+              i++;
+            }
+          }
+          if (closed) {
+            current.safeEnd = i;
+            current.state = "after_value";
+          } else {
+            const prefix = input.slice(0, valStart);
+            const repairedStr = cleanOpenString(input.slice(valStart));
+            return closeStackWithPrefix(prefix + repairedStr);
+          }
+        } else if (ch === "{") {
+          stack.push({ kind: "object", safeEnd: i + 1, state: "expect_key" });
+          i++;
+        } else if (ch === "[") {
+          stack.push({ kind: "array", safeEnd: i + 1, state: "expect_value" });
+          i++;
+        } else if (ch === "}" || ch === "]") {
+          return finishWithSafeEnd(current.safeEnd);
+        } else {
+          const tokStart = i;
+          while (i < input.length && !/[\s,}\]]/.test(input[i])) {
+            i++;
+          }
+          const tok = input.slice(tokStart, i);
+          if (tok === "true" || tok === "false" || tok === "null" || COMPLETE_NUMBER_REGEX.test(tok)) {
+            current.safeEnd = i;
+            current.state = "after_value";
+          } else {
+            return finishWithSafeEnd(current.safeEnd);
+          }
+        }
+      } else if (current.state === "after_value") {
+        if (ch === ",") {
+          current.state = "expect_key";
+          i++;
+        } else if (ch === "}") {
+          i++;
+          popContainer(i);
+        } else {
+          return finishWithSafeEnd(current.safeEnd);
+        }
+      }
+    } else {
+      if (current.state === "expect_value") {
+        if (ch === "]") {
+          i++;
+          popContainer(i);
+        } else if (ch === '"') {
+          const valStart = i;
+          i++;
+          let closed = false;
+          while (i < input.length) {
+            if (input[i] === "\\") {
+              i += 2;
+            } else if (input[i] === '"') {
+              i++;
+              closed = true;
+              break;
+            } else {
+              i++;
+            }
+          }
+          if (closed) {
+            current.safeEnd = i;
+            current.state = "after_value";
+          } else {
+            const prefix = input.slice(0, valStart);
+            const repairedStr = cleanOpenString(input.slice(valStart));
+            return closeStackWithPrefix(prefix + repairedStr);
+          }
+        } else if (ch === "{") {
+          stack.push({ kind: "object", safeEnd: i + 1, state: "expect_key" });
+          i++;
+        } else if (ch === "[") {
+          stack.push({ kind: "array", safeEnd: i + 1, state: "expect_value" });
+          i++;
+        } else if (ch === "}") {
+          return finishWithSafeEnd(current.safeEnd);
+        } else {
+          const tokStart = i;
+          while (i < input.length && !/[\s,}\]]/.test(input[i])) {
+            i++;
+          }
+          const tok = input.slice(tokStart, i);
+          if (tok === "true" || tok === "false" || tok === "null" || COMPLETE_NUMBER_REGEX.test(tok)) {
+            current.safeEnd = i;
+            current.state = "after_value";
+          } else {
+            return finishWithSafeEnd(current.safeEnd);
+          }
+        }
+      } else if (current.state === "after_value") {
+        if (ch === ",") {
+          current.state = "expect_value";
+          i++;
+        } else if (ch === "]") {
+          i++;
+          popContainer(i);
+        } else {
+          return finishWithSafeEnd(current.safeEnd);
+        }
+      }
+    }
+  }
+  if (stack.length > 0) {
+    const current = stack[stack.length - 1];
+    return finishWithSafeEnd(current.safeEnd);
+  }
+  if (hasTopLevelValue) {
+    return input.slice(0, topLevelSafeEnd);
+  }
+  return void 0;
+}
+function parsePartialJson(input) {
+  if (typeof input !== "string") return void 0;
+  if (!input.trim()) return void 0;
+  const source = input.trimStart();
+  try {
+    return JSON.parse(source);
+  } catch {
+  }
+  const repaired = repairPartialJson(source);
+  if (repaired === void 0) return void 0;
+  try {
+    return JSON.parse(repaired);
+  } catch {
+    return void 0;
+  }
+}
+
 // src/loop/errors.ts
 var EmptyResponseError = class extends Error {
   code = "empty_response";
@@ -1039,14 +1378,50 @@ var LoopGuard = {
 // src/loop/stream-collector.ts
 var MAX_STREAMED_OUTPUT_CHARACTERS = 1024 * 1024;
 async function invokeModel(input) {
-  const events = input.config.stream(input.request, { signal: input.config.signal });
+  const callContext = input.callContext ?? {
+    signal: input.config.signal ?? new AbortController().signal,
+    run: {
+      id: input.config.execution.runId,
+      agentId: input.config.execution.agentId,
+      scope: input.config.execution.scope ?? [],
+      cwd: input.config.execution.cwd ?? input.config.context.cwd ?? ""
+    },
+    interact: async (request) => {
+      const handler = input.config.runtime?.interact ?? input.config.interact;
+      if (!handler) {
+        throw new Error("Run interactions are not supported in this runtime.");
+      }
+      return handler(request);
+    },
+    tools: {
+      list: () => {
+        return input.config.context.tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters,
+          ...t._meta !== void 0 ? { _meta: t._meta } : {}
+        }));
+      },
+      call: async (_name, _args, _options) => {
+        throw new Error("Tool calling is not available in standalone stream collector without callContext.");
+      },
+      report: (update) => {
+        input.config.onToolReport?.({
+          runId: input.config.execution.runId,
+          update
+        });
+      }
+    }
+  };
+  const events = input.config.stream(input.request, callContext);
   const result = await collectStreamResult({
     config: input.config,
     message: input.message,
     events,
     metadataPhase: input.phaseId,
     output: input.output,
-    onThinkingDelta: input.onThinkingDelta
+    onThinkingDelta: input.onThinkingDelta,
+    onToolCallDelta: input.onToolCallDelta
   });
   const response = result.doneResponse ?? {
     content: result.text,
@@ -1077,6 +1452,8 @@ async function collectStreamResult(input) {
   let streamedOutputCharacters = 0;
   const toolCallsWithDeltas = /* @__PURE__ */ new Set();
   const thinkingOffsets = /* @__PURE__ */ new Map();
+  const toolNames = /* @__PURE__ */ new Map();
+  const toolArguments = /* @__PURE__ */ new Map();
   for await (const event of input.events) {
     if (event.type === "text_delta") {
       streamedOutputCharacters += event.text.length;
@@ -1127,6 +1504,26 @@ async function collectStreamResult(input) {
       }
       lastPartial = event.partial;
     }
+    if (event.type === "tool_call_start") {
+      toolNames.set(event.id, event.name);
+    }
+    if (event.type === "tool_call_delta") {
+      const accumulated = (toolArguments.get(event.id) ?? "") + event.arguments;
+      toolArguments.set(event.id, accumulated);
+      const toolName = toolNames.get(event.id) ?? event.partial.contentBlocks.find((b) => b.type === "tool_call" && b.id === event.id)?.name ?? "";
+      if (toolName && !toolNames.has(event.id)) {
+        toolNames.set(event.id, toolName);
+      }
+      if (persistAssistant && activeMessageId) {
+        input.onToolCallDelta?.({
+          messageId: activeMessageId,
+          providerToolCallId: event.id,
+          toolName,
+          arguments: accumulated,
+          args: parsePartialJson(accumulated)
+        });
+      }
+    }
     if (event.type === "thinking_delta") {
       if (persistAssistant && !activeMessageId) {
         activeMessageId = input.message.reserve("assistant", {
@@ -1239,16 +1636,17 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
   let outputPayload = phaseIn?.state?.payload;
   let nextPhase;
   let outputMessage;
-  let settingsProvider;
   return {
-    on: (eventType, handler) => {
-      assertActive();
-      hooks?.on(eventType, handler);
-      trackCleanup?.(() => hooks?.off(eventType, handler));
-    },
-    off: (eventType, handler) => {
-      assertActive();
-      hooks?.off(eventType, handler);
+    hooks: {
+      on: (eventType, handler) => {
+        assertActive();
+        hooks?.on(eventType, handler);
+        trackCleanup?.(() => hooks?.off(eventType, handler));
+      },
+      off: (eventType, handler) => {
+        assertActive();
+        hooks?.off(eventType, handler);
+      }
     },
     config: {
       get: async (scope) => {
@@ -1298,9 +1696,28 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
             return store?.delete(key);
           }
         };
+      },
+      global: () => {
+        assertActive();
+        const store = options?.state?.global();
+        return {
+          get: async (key) => {
+            assertActive();
+            return store?.get(key);
+          },
+          set: async (key, value) => {
+            assertActive();
+            assertJsonValue(value);
+            return store?.set(key, value);
+          },
+          delete: async (key) => {
+            assertActive();
+            return store?.delete(key);
+          }
+        };
       }
     },
-    tool: {
+    tools: {
       register: (tool) => {
         assertActive();
         options?.registerTool?.(tool);
@@ -1329,14 +1746,16 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
         };
       }
     },
-    registerProvider: (config) => {
-      assertActive();
-      options?.registerProvider?.(config);
-      trackCleanup?.(() => options?.unregisterProvider?.(config.id));
-    },
-    unregisterProvider: (name) => {
-      assertActive();
-      options?.unregisterProvider?.(name);
+    providers: {
+      register: (config) => {
+        assertActive();
+        options?.registerProvider?.(config);
+        trackCleanup?.(() => options?.unregisterProvider?.(config.id));
+      },
+      unregister: (id) => {
+        assertActive();
+        options?.unregisterProvider?.(id);
+      }
     },
     manifest: options?.manifest,
     utils: {
@@ -1358,7 +1777,7 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
     }, off: () => {
     }, emit: () => {
     }, has: () => false, count: () => 0 },
-    phase: {
+    phases: {
       register: async (registration) => {
         assertActive();
         await options?.registerPhase?.(registration);
@@ -1379,19 +1798,37 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
         nextPhase = id;
       },
       getNextPhase: () => nextPhase,
-      getMessage: () => outputMessage,
-      settings: {
-        register: (provider) => {
-          assertActive();
-          if (typeof provider !== "function") {
-            throw new Error("Phase Settings registration requires a provider function.");
+      getMessage: () => outputMessage
+    },
+    ui: {
+      contribute: (contribution) => {
+        assertActive();
+        if (!contribution || typeof contribution !== "object") {
+          throw new TypeError("UI contribution must be an object.");
+        }
+        if (contribution.slot !== "settings" && contribution.slot !== "model-picker") {
+          throw new TypeError(`Unsupported UI contribution slot: "${contribution.slot}".`);
+        }
+        if (typeof contribution.id !== "string" || contribution.id.trim() === "") {
+          throw new TypeError("UI contribution requires a non-empty id.");
+        }
+        if (contribution.slot === "settings") {
+          if (typeof contribution.title !== "string") {
+            throw new TypeError("Settings UI contribution requires a title.");
           }
-          if (settingsProvider) {
-            throw new Error("A Phase may register only one Settings provider.");
+          if (!contribution.settings || typeof contribution.settings !== "object") {
+            throw new TypeError("Settings UI contribution requires a settings definition.");
+          }
+        }
+        if (contribution.slot === "model-picker") {
+          if (typeof contribution.provider !== "string" || contribution.provider.trim() === "") {
+            throw new TypeError("Model-picker UI contribution requires a provider.");
           }
-          settingsProvider = provider;
-          options?.registerSettings?.(provider);
         }
+        const dispose = options?.contributeUi ? options.contributeUi(contribution) : () => {
+        };
+        trackCleanup?.(dispose);
+        return dispose;
       }
     }
   };
@@ -1400,8 +1837,8 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
 // src/harness/phases/interactions.ts
 var RunInteractionCancelledError = class extends Error {
   code = "run_interaction_cancelled";
-  constructor() {
-    super("Run interaction work was cancelled.");
+  constructor(message = "Run interaction work was cancelled.") {
+    super(message);
     this.name = "RunInteractionCancelledError";
   }
 };
@@ -1872,17 +2309,6 @@ async function loadPhase(targetPath) {
   }
   return phase;
 }
-async function loadPhaseSettings(phase, context) {
-  if (!phase.factory) return void 0;
-  let provider;
-  const api = createExtensionAPI(void 0, {
-    registerSettings: (candidate) => {
-      provider = candidate;
-    }
-  });
-  await phase.factory(api);
-  return provider ? provider(context) : void 0;
-}
 async function loadPhaseSkills(baseDir) {
   const entries = await readdir2(baseDir, { withFileTypes: true });
   const skills = [];
@@ -2324,9 +2750,11 @@ function extractToolResults(transcript) {
     }
     for (const part of msg.content) {
       if (part.type !== "tool_result") continue;
-      const result = parseToolResult(part.content);
-      if (result) {
-        results.push(result);
+      if (typeof part.content === "string") {
+        const result = parseToolResult(part.content);
+        if (result) {
+          results.push(result);
+        }
       }
     }
   }
@@ -3069,9 +3497,8 @@ async function runPhaseLoop(config, state, registry) {
   }
   throw new Error("Phase machine exited without a stop or abort transition.");
 }
-var DEFAULT_MAX_RETRIES = 3;
-var DEFAULT_BASE_DELAY_MS = 1e3;
-var DEFAULT_MAX_DELAY_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 10;
+var DEFAULT_RETRY_DELAY_MS = 5e3;
 function isRetryableError(error) {
   if (!(error instanceof Error)) return false;
   const message = error.message.toLowerCase();
@@ -3082,21 +3509,36 @@ function isRetryableError(error) {
   if (message.includes("service unavailable") || message.includes("503")) return true;
   if (message.includes("gateway timeout") || message.includes("504")) return true;
   if (message.includes("econnreset") || message.includes("econnrefused")) return true;
+  if (message.includes("socket connection was closed") || message.includes("socket hang up")) return true;
+  if (message.includes("fetch failed") || message.includes("etimedout")) return true;
+  if (message.includes("network") || message.includes("connection reset")) return true;
   if ("code" in error) {
     const code = error.code;
     if (code === "invalid_model_schema" || code === "empty_response") return true;
   }
   return false;
 }
-function getRetryDelay(attempt, baseMs, maxMs) {
-  const exponential = baseMs * Math.pow(2, attempt);
-  const jitter = exponential * (0.5 + Math.random() * 0.5);
-  return Math.min(jitter, maxMs);
+function sleepAbortable(delayMs, signal) {
+  return new Promise((resolve9) => {
+    if (signal?.aborted) {
+      resolve9();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve9();
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve9();
+    }, delayMs);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 }
 async function withRetry(fn, options = {}) {
   const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
-  const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
-  const maxDelayMs = options.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
   let lastError;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
@@ -3109,9 +3551,9 @@ async function withRetry(fn, options = {}) {
       if (options.signal?.aborted) {
         throw error;
       }
-      const delayMs = getRetryDelay(attempt, baseDelayMs, maxDelayMs);
-      options.onRetry?.(attempt, error, delayMs);
-      await new Promise((resolve9) => setTimeout(resolve9, delayMs));
+      const retryAttempt = attempt + 1;
+      options.onRetry?.(retryAttempt, error, retryDelayMs, maxRetries);
+      await sleepAbortable(retryDelayMs, options.signal);
       if (options.signal?.aborted) {
         throw lastError;
       }
@@ -3161,10 +3603,10 @@ async function executePhase(ctx) {
     });
     await phase.factory(api);
     return {
-      message: api.phase.getMessage() ?? `${phase.name} phase completed.`,
-      route: api.phase.getNextPhase() || "stop",
+      message: api.phases.getMessage() ?? `${phase.name} phase completed.`,
+      route: api.phases.getNextPhase() || "stop",
       phase: phase.name,
-      payload: api.phase.getPayload()
+      payload: api.phases.getPayload()
     };
   }
   return executePhaseWithModel(ctx);
@@ -3176,7 +3618,8 @@ async function executeToolCall(input) {
       config: input.config,
       toolCall: input.toolCall,
       contentBlocks: input.contentBlocks,
-      driver: input.driver
+      driver: input.driver,
+      options: input.options
     });
   } else {
     const toolContext = {
@@ -3189,7 +3632,7 @@ async function executeToolCall(input) {
       toolContext,
       beforeToolCall: input.config.beforeToolCall,
       afterToolCall: input.config.afterToolCall,
-      signal: input.config.signal
+      signal: combineSignals(input.config.signal, input.options?.signal)
     });
   }
   return {
@@ -3221,6 +3664,28 @@ async function executeToolCalls(input) {
 }
 function createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry) {
   const interaction = createRunInteractionDriver(state, phase.name, config.signal);
+  const executePhaseTool = async (phaseContext, toolCall, options) => {
+    return runTurn(async () => {
+      await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
+      const tools = phaseContext.tools.filter((tool) => tool.name !== PhaseRouteTool);
+      const result = await executeToolCall({
+        config: {
+          ...config,
+          context: {
+            ...config.context,
+            tools,
+            skills: phaseContext.skills
+          }
+        },
+        tools,
+        toolCall,
+        driver: interaction,
+        options
+      });
+      await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
+      return result;
+    });
+  };
   return {
     interaction,
     messages: messageManager,
@@ -3264,6 +3729,51 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
           }));
         }
       }
+      const scope = config.execution.scope ?? [];
+      const cwd = config.execution.cwd ?? config.context.cwd ?? "";
+      const callContext = {
+        signal: config.signal ?? new AbortController().signal,
+        run: {
+          id: config.execution.runId,
+          agentId: config.execution.agentId,
+          scope,
+          cwd
+        },
+        interact: async (interactionReq) => {
+          const handler = config.runtime?.interact ?? config.interact;
+          if (!handler) {
+            throw new Error("Run interactions are not supported in this runtime.");
+          }
+          return handler(interactionReq);
+        },
+        tools: {
+          list: () => {
+            const tools = phaseContext.tools.filter((tool) => tool.name !== PhaseRouteTool);
+            return tools.map((t) => ({
+              name: t.name,
+              description: t.description,
+              parameters: t.parameters,
+              ...t._meta !== void 0 ? { _meta: t._meta } : {}
+            }));
+          },
+          call: async (name, args, options2) => {
+            const toolCallId = createId("call");
+            const toolCall = {
+              id: toolCallId,
+              name,
+              args
+            };
+            const res = await executePhaseTool(phaseContext, toolCall, options2);
+            return res.ok ? { ok: true, content: res.content } : { ok: false, error: res.error ?? "Tool execution failed", ...res.content !== void 0 ? { content: res.content } : {} };
+          },
+          report: (update) => {
+            config.onToolReport?.({
+              runId: config.execution.runId,
+              update
+            });
+          }
+        }
+      };
       const result = await runTurn(
         () => withRetry(
           () => invokeModel({
@@ -3272,12 +3782,21 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
             request,
             phaseId: phase.name,
             output: options.output,
-            onThinkingDelta: config.onThinkingDelta
+            onThinkingDelta: config.onThinkingDelta,
+            onToolCallDelta: config.onToolCallDelta,
+            callContext
           }),
           {
             signal: config.signal,
-            onRetry: () => {
+            retryDelayMs: config.retryDelayMs,
+            onRetry: (attempt, error, delayMs, maxRetries) => {
               state.metrics.retryCount++;
+              config.onModelRetry?.({
+                attempt,
+                maxRetries,
+                delayMs,
+                error: error instanceof Error ? error.message : String(error)
+              });
             }
           }
         )
@@ -3288,27 +3807,7 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
     async reportStatus(status) {
       await config.onPhaseStatus?.(phase.name, status);
     },
-    async executeTool(phaseContext, toolCall) {
-      return runTurn(async () => {
-        await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
-        const tools = phaseContext.tools.filter((tool) => tool.name !== PhaseRouteTool);
-        const result = await executeToolCall({
-          config: {
-            ...config,
-            context: {
-              ...config.context,
-              tools,
-              skills: phaseContext.skills
-            }
-          },
-          tools,
-          toolCall,
-          driver: interaction
-        });
-        await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
-        return result;
-      });
-    },
+    executeTool: executePhaseTool,
     async executeTools(phaseContext, toolCalls, contentBlocks) {
       return runTurn(async () => {
         const tools = phaseContext.tools.filter((tool) => tool.name !== PhaseRouteTool);
@@ -3571,10 +4070,14 @@ async function executeOnce(input) {
     onParallelPhaseOutput: input.onParallelPhaseOutput,
     onMessageDelta: input.onMessageDelta,
     onThinkingDelta: input.onThinkingDelta,
+    onToolCallDelta: input.onToolCallDelta,
+    onModelRetry: input.onModelRetry,
+    retryDelayMs: input.retryDelayMs,
     onOutcome: input.onOutcome,
     onModelTranscript: input.onModelTranscript,
     onPhaseEntered: input.onPhaseEntered,
     onPhaseStatus: input.onPhaseStatus,
+    onToolReport: input.onToolReport,
     runtime: input.runtime,
     waitForInput: async (nextState, request) => {
       if (!nextState || !request) throw new Error("Input boundary did not include execution state.");
@@ -3665,6 +4168,46 @@ function isContinuation(value) {
   return value.previousResults.every((result) => isRecord2(result) && typeof result.name === "string" && (result.output === void 0 || isJsonValue(result.output))) && (value.pendingInstruction === void 0 || typeof value.pendingInstruction === "string") && (value.previousPhaseMessageId === void 0 || typeof value.previousPhaseMessageId === "string");
 }
 
+// src/runtime/tool-call-merge.ts
+function isValidPresentationOutput(output) {
+  if (typeof output !== "object" || output === null || Array.isArray(output)) return false;
+  const o = output;
+  if (o.title !== void 0 && typeof o.title !== "string") return false;
+  if (o.locations !== void 0) {
+    if (!Array.isArray(o.locations)) return false;
+    for (const loc of o.locations) {
+      if (typeof loc !== "object" || loc === null || typeof loc.path !== "string") return false;
+      if (loc.line !== void 0 && typeof loc.line !== "number") return false;
+    }
+  }
+  if (o.content !== void 0) {
+    if (!Array.isArray(o.content)) return false;
+    for (const c of o.content) {
+      if (typeof c !== "object" || c === null || typeof c.type !== "string") return false;
+    }
+  }
+  if (o._meta !== void 0) {
+    if (typeof o._meta !== "object" || o._meta === null || Array.isArray(o._meta)) return false;
+  }
+  return true;
+}
+function mergeToolCall(target, patch) {
+  if (patch.title !== void 0) target.title = patch.title;
+  if (patch.kind !== void 0) target.kind = patch.kind;
+  if (patch.status !== void 0) target.status = patch.status;
+  if (patch.locations !== void 0) target.locations = structuredClone(patch.locations);
+  if (patch.content !== void 0) target.content = structuredClone(patch.content);
+  if (patch.rawInput !== void 0) target.rawInput = structuredClone(patch.rawInput);
+  if (patch.rawOutput !== void 0) target.rawOutput = structuredClone(patch.rawOutput);
+  if (patch._meta !== void 0) {
+    target._meta = {
+      ...target._meta ?? {},
+      ...structuredClone(patch._meta)
+    };
+  }
+  return target;
+}
+
 // src/runtime/contracts.ts
 var THINKING_LEVELS = [
   "off",
@@ -3675,23 +4218,8 @@ var THINKING_LEVELS = [
   "xhigh",
   "max"
 ];
-function thinkingLevelFromMetadata(metadata) {
-  const record = isRecord3(metadata) ? metadata : void 0;
-  const mori = record?.mori;
-  if (!isRecord3(mori)) return void 0;
-  const level = mori.thinkingLevel;
-  return typeof level === "string" && THINKING_LEVELS.includes(level) ? level : void 0;
-}
-function thinkingLevelFromMessages(messages) {
-  for (let index = messages.length - 1; index >= 0; index -= 1) {
-    const message = messages[index];
-    if (message?.role !== "user") continue;
-    const metadata = message.metadata;
-    const kind = isRecord3(metadata) && typeof metadata.kind === "string" ? metadata.kind : void 0;
-    if (kind === "phase_prompt" || kind === "phase_input") continue;
-    return thinkingLevelFromMetadata(metadata);
-  }
-  return void 0;
+function thinkingLevelFromUserInput(input) {
+  return typeof input === "string" ? void 0 : input.thinkingLevel;
 }
 var METADATA_LIMIT = 64 * 1024;
 var IDENTITY_LIMIT = 256;
@@ -3747,8 +4275,13 @@ function isAssistantContent(value) {
 }
 function normalizeUserInput(input) {
   const normalized = typeof input === "string" ? { content: input } : input;
-  if (!isRecord3(normalized) || !hasOnlyKeys(normalized, ["content", "metadata"]) || !isUserContent(normalized.content)) throw new TypeError("input must contain only valid UserContent");
+  if (!isRecord3(normalized) || !hasOnlyKeys(normalized, ["content", "metadata", "thinkingLevel"]) || !isUserContent(normalized.content)) {
+    throw new TypeError("input must contain only valid UserContent");
+  }
   if (normalized.metadata !== void 0) assertMetadata(normalized.metadata, "input.metadata");
+  if (normalized.thinkingLevel !== void 0 && !THINKING_LEVELS.includes(normalized.thinkingLevel)) {
+    throw new TypeError("input.thinkingLevel must be a valid ThinkingLevel");
+  }
   assertJsonValue(normalized, "input");
   return normalized;
 }
@@ -3756,9 +4289,16 @@ function isAssistantMessage(value) {
   return isRecord3(value) && hasOnlyKeys(value, ["id", "agentId", "runId", "messageRevision", "role", "content", "metadata", "sequenceWithinRun", "createdAt", "interrupted"]) && typeof value.id === "string" && typeof value.agentId === "string" && typeof value.runId === "string" && value.role === "assistant" && (value.messageRevision === void 0 || Number.isInteger(value.messageRevision) && value.messageRevision >= 0) && Number.isInteger(value.sequenceWithinRun) && value.sequenceWithinRun >= 0 && typeof value.createdAt === "string" && isAssistantContent(value.content) && (value.metadata === void 0 || isMetadata(value.metadata)) && (value.interrupted === void 0 || typeof value.interrupted === "boolean");
 }
 function isToolResult(value) {
-  if (!isRecord3(value) || !isJsonValue(value.content) || typeof value.ok !== "boolean") return false;
+  if (!isRecord3(value)) return false;
+  if (value.structuredContent !== void 0 && !isJsonValue(value.structuredContent)) return false;
+  if (Array.isArray(value.content)) {
+    if (value.isError !== void 0 && typeof value.isError !== "boolean") return false;
+    return true;
+  }
+  if (!isJsonValue(value.content) || typeof value.ok !== "boolean") return false;
+  const keys = Object.keys(value).filter((k) => k !== "structuredContent").sort();
   const expected = value.ok ? ["content", "ok"] : ["content", "error", "ok"];
-  if (JSON.stringify(Object.keys(value).sort()) !== JSON.stringify(expected)) return false;
+  if (JSON.stringify(keys) !== JSON.stringify(expected)) return false;
   return value.ok || typeof value.error === "string";
 }
 function assertAgentConfiguration(config) {
@@ -3931,17 +4471,20 @@ function encodeIdempotencyScope(storeIncarnation, scope) {
   if (typeof storeIncarnation !== "string" || storeIncarnation.length === 0) throw new TypeError("storeIncarnation must be non-empty");
   return canonicalJson([storeIncarnation, ...scope]);
 }
-function canonicalStartRunRequest(input, metadata, phasePayload, pinnedConfigToken, entryPhases) {
+function canonicalStartRunRequest(input, metadata, phasePayload, pinnedConfigToken, entryPhases, scope, cwd) {
   const normalized = normalizeUserInput(input);
   if (metadata !== void 0) assertUtf8ByteLimit(canonicalJson(metadata), METADATA_JSON_BYTES, "run.metadata");
   if (phasePayload !== void 0) assertUtf8ByteLimit(canonicalJson(phasePayload), MESSAGE_CONTENT_JSON_BYTES, "run.phasePayload");
   if (entryPhases !== void 0) assertUtf8ByteLimit(canonicalJson(entryPhases), MESSAGE_CONTENT_JSON_BYTES, "run.entryPhases");
+  if (cwd !== void 0 && typeof cwd !== "string") throw new TypeError("run.cwd must be a string");
   return canonicalJson({
     input: normalized,
     ...metadata === void 0 ? {} : { metadata },
     ...phasePayload === void 0 ? {} : { phasePayload },
     ...entryPhases === void 0 ? {} : { entryPhases },
-    ...pinnedConfigToken === void 0 ? {} : { pinnedConfigToken }
+    ...pinnedConfigToken === void 0 ? {} : { pinnedConfigToken },
+    ...scope === void 0 ? {} : { scope },
+    ...cwd === void 0 ? {} : { cwd }
   });
 }
 
@@ -4483,7 +5026,8 @@ function projectToolMessage(message, toolInteractionTexts) {
     id: message.id,
     role: message.role,
     content: message.content.map((part) => {
-      const rawResult = jsonText(part.result.content);
+      const isError = "isError" in part.result ? Boolean(part.result.isError) : !part.result.ok;
+      const rawResult = Array.isArray(part.result.content) ? part.result.content.map((block) => block?.type === "text" ? block.text : JSON.stringify(block)).join("\n\n") : jsonText(part.result.content);
       const interactionTexts = toolInteractionTexts.get(String(part.toolCallId));
       let content = rawResult;
       if (interactionTexts && interactionTexts.length > 0) {
@@ -4496,7 +5040,7 @@ ${rawResult}`;
         type: "tool_result",
         toolUseId: part.providerToolCallId ?? String(part.toolCallId),
         content,
-        ...part.result.ok ? {} : { isError: true }
+        ...isError ? { isError: true } : {}
       };
     }),
     createdAt: message.createdAt,
@@ -4528,12 +5072,16 @@ function projectAssistantContent(content) {
   });
 }
 function projectToolContent(content) {
-  return content.map((part) => ({
-    type: "tool_result",
-    toolUseId: part.providerToolCallId ?? part.toolCallId,
-    content: jsonText(part.result.content),
-    ...part.result.ok ? {} : { isError: true }
-  }));
+  return content.map((part) => {
+    const isError = "isError" in part.result ? Boolean(part.result.isError) : !part.result.ok;
+    const textContent = Array.isArray(part.result.content) ? part.result.content.map((block) => block?.type === "text" ? block.text : JSON.stringify(block)).join("\n\n") : jsonText(part.result.content);
+    return {
+      type: "tool_result",
+      toolUseId: part.providerToolCallId ?? part.toolCallId,
+      content: textContent,
+      ...isError ? { isError: true } : {}
+    };
+  });
 }
 function inertRunInteraction(signal) {
   const controller = signal ? void 0 : new AbortController();
@@ -4562,15 +5110,18 @@ function projectTool(tool, agentId, runId) {
     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);
-      return { toolCallId: context.toolCallId, toolName: tool.name, ...result };
+      const ok = "ok" in result && typeof result.ok === "boolean" ? result.ok : !result.isError;
+      return { toolCallId: context.toolCallId, toolName: tool.name, ok, ...result };
     }
   };
 }
@@ -4665,20 +5216,38 @@ function resolveDefinitionContext(snapshot, assembled) {
     systemPrompt: [snapshot.definition.prompt, buildContextDescription(contexts)].filter((section) => section.length > 0).join("\n\n"),
     tools,
     skills,
-    phases: { phases, entryPhaseId }
+    phases: { phases, entryPhaseId },
+    ...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: result.ok,
+    ok,
     content: result.content,
-    ...!result.ok ? { error: result.error } : {}
+    ...!ok && error ? { error } : {},
+    ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {},
+    ...result.isError !== void 0 ? { isError: result.isError } : {}
   };
 }
 function fromLoopResult(result) {
-  return result.ok ? { ok: true, content: result.content } : { ok: false, content: result.content, error: result.error ?? "Extension hook rejected the Tool 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/transient-run-events.ts
@@ -4709,6 +5278,34 @@ var TransientRunEventSubscription = class {
         ...previous,
         text: previous.text + event.text
       };
+    } else if (
+      // `arguments` accumulates, so the latest delta of a call replaces the one before.
+      previous?.kind === "tool_call_delta" && event.kind === "tool_call_delta" && previous.executionId === event.executionId && previous.providerToolCallId === event.providerToolCallId
+    ) {
+      this.queue[this.queue.length - 1] = event;
+    } else if (event.kind === "tool_state_changed") {
+      const toolCallId = event.toolCall.toolCallId;
+      let index = -1;
+      for (let i = this.queue.length - 1; i >= 0; i -= 1) {
+        const existing = this.queue[i];
+        if (existing && existing.kind === "tool_state_changed" && existing.runId === event.runId && existing.toolCall.toolCallId === toolCallId) {
+          index = i;
+          break;
+        }
+      }
+      if (index !== -1) {
+        const existing = this.queue[index];
+        const mergedCall = { ...existing.toolCall };
+        mergeToolCall(mergedCall, event.toolCall);
+        this.queue[index] = {
+          ...existing,
+          transition: { from: existing.transition.from, to: event.transition.to },
+          toolCall: mergedCall
+        };
+      } else {
+        if (this.queue.length >= MAX_BUFFERED_EVENTS) this.queue.shift();
+        this.queue.push(event);
+      }
     } else {
       if (this.queue.length >= MAX_BUFFERED_EVENTS) this.queue.shift();
       this.queue.push(event);
@@ -4724,7 +5321,7 @@ var TransientRunEventSubscription = class {
     else {
       for (let index = this.queue.length - 1; index >= 0; index -= 1) {
         const event = this.queue[index];
-        if (event?.executionId === executionId && !(preserveCompletedPhaseStatus && event.kind === "phase_status" && event.status.state === "completed")) {
+        if (event && "executionId" in event && event.executionId === executionId && !(preserveCompletedPhaseStatus && event.kind === "phase_status" && event.status.state === "completed")) {
           this.queue.splice(index, 1);
         }
       }
@@ -4734,14 +5331,14 @@ var TransientRunEventSubscription = class {
   clearMessage(messageId) {
     for (let index = this.queue.length - 1; index >= 0; index -= 1) {
       const event = this.queue[index];
-      if ((event?.kind === "message_delta" || event?.kind === "thinking_delta") && event.messageId === messageId) this.queue.splice(index, 1);
+      if ((event?.kind === "message_delta" || event?.kind === "thinking_delta" || event?.kind === "tool_call_delta") && event.messageId === messageId) this.queue.splice(index, 1);
     }
     this.notify();
   }
   clearTool(toolCallId) {
     for (let index = this.queue.length - 1; index >= 0; index -= 1) {
       const event = this.queue[index];
-      if (event?.kind === "tool_progress" && event.toolCallId === toolCallId) this.queue.splice(index, 1);
+      if (event?.kind === "tool_state_changed" && event.toolCall.toolCallId === toolCallId) this.queue.splice(index, 1);
     }
     this.notify();
   }
@@ -4885,6 +5482,7 @@ var HooksManager = class {
 var InMemoryExtensionHost = class {
   configs = /* @__PURE__ */ new Map();
   agentState = /* @__PURE__ */ new Map();
+  globalState = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   constructor(options = {}) {
     if (options.configs) {
@@ -4911,8 +5509,18 @@ var InMemoryExtensionHost = class {
         this.agentState.set(agentId, agentMap);
       }
     }
+    if (options.globalState) {
+      for (const [extId, stateMap] of Object.entries(options.globalState)) {
+        const map = /* @__PURE__ */ new Map();
+        for (const [key, val] of Object.entries(stateMap)) {
+          assertJsonValue(val);
+          map.set(key, structuredClone(val));
+        }
+        this.globalState.set(extId, map);
+      }
+    }
   }
-  setConfig(extensionId, config, scope = { kind: "global" }) {
+  setConfig(extensionId, config, scope = []) {
     const scopeKey = scopeToKey(scope);
     if (!this.configs.has(scopeKey)) {
       this.configs.set(scopeKey, /* @__PURE__ */ new Map());
@@ -4926,19 +5534,18 @@ var InMemoryExtensionHost = class {
     }
     this.notifyConfigChanged(extensionId, scope);
   }
-  getConfig(extensionId, scope = { kind: "global" }) {
+  getConfig(extensionId, scope = []) {
+    let merged = null;
     const globalConfig = this.configs.get("global")?.get(extensionId);
-    let merged = globalConfig ? { ...globalConfig } : null;
-    if (scope.kind === "team" || scope.kind === "project") {
-      const teamConfig = this.configs.get(`team:${scope.teamId}`)?.get(extensionId);
-      if (teamConfig) {
-        merged = { ...merged ?? {}, ...teamConfig };
-      }
+    if (globalConfig) {
+      merged = { ...globalConfig };
     }
-    if (scope.kind === "project") {
-      const projectConfig = this.configs.get(`project:${scope.teamId}:${scope.projectId}`)?.get(extensionId);
-      if (projectConfig) {
-        merged = { ...merged ?? {}, ...projectConfig };
+    for (let i = 1; i <= scope.length; i++) {
+      const subScope = scope.slice(0, i);
+      const key = scopeToKey(subScope);
+      const layerConfig = this.configs.get(key)?.get(extensionId);
+      if (layerConfig) {
+        merged = { ...merged ?? {}, ...layerConfig };
       }
     }
     return merged ? structuredClone(merged) : null;
@@ -4947,7 +5554,7 @@ var InMemoryExtensionHost = class {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
   }
-  notifyConfigChanged(extensionId, scope = { kind: "global" }) {
+  notifyConfigChanged(extensionId, scope = []) {
     for (const listener of this.listeners) {
       try {
         listener(extensionId, scope);
@@ -4976,29 +5583,26 @@ var InMemoryExtensionHost = class {
   deleteAgentState(extensionId, agentId, key) {
     this.agentState.get(agentId)?.get(extensionId)?.delete(key);
   }
-};
-function scopeToKey(scope) {
-  switch (scope.kind) {
-    case "global":
-      return "global";
-    case "team":
-      return `team:${scope.teamId}`;
-    case "project":
-      return `project:${scope.teamId}:${scope.projectId}`;
+  getGlobalState(extensionId, key) {
+    const val = this.globalState.get(extensionId)?.get(key);
+    return val !== void 0 ? structuredClone(val) : void 0;
   }
-}
-function resolveScopeFromMetadata(metadata) {
-  if (metadata) {
-    const teamId = typeof metadata.teamId === "string" ? metadata.teamId : void 0;
-    const projectId = typeof metadata.projectId === "string" ? metadata.projectId : void 0;
-    if (teamId && projectId) {
-      return { kind: "project", teamId, projectId };
-    }
-    if (teamId) {
-      return { kind: "team", teamId };
+  setGlobalState(extensionId, key, value) {
+    assertJsonValue(value);
+    let extMap = this.globalState.get(extensionId);
+    if (!extMap) {
+      extMap = /* @__PURE__ */ new Map();
+      this.globalState.set(extensionId, extMap);
     }
+    extMap.set(key, structuredClone(value));
+  }
+  deleteGlobalState(extensionId, key) {
+    this.globalState.get(extensionId)?.delete(key);
   }
-  return { kind: "global" };
+};
+function scopeToKey(scope) {
+  if (scope.length === 0) return "global";
+  return scope.map((layer) => `${layer.kind}:${layer.id}`).join("/");
 }
 
 // src/extensions/runner.ts
@@ -5112,8 +5716,9 @@ async function execCommand(command, args, cwd, options) {
   });
 }
 function applyProviderRegistration(config) {
-  if (config.streamSimple) {
-    registerApiProvider({ protocol: config.protocol, stream: config.streamSimple });
+  unregisterProviderModels(config.id);
+  if (config.stream) {
+    registerApiProvider({ protocol: config.protocol, stream: config.stream });
   }
   for (const modelConfig of config.models) {
     registerModel({
@@ -5123,12 +5728,13 @@ function applyProviderRegistration(config) {
       provider: config.id,
       baseUrl: config.baseUrl,
       apiKey: config.apiKey,
-      reasoning: modelConfig.reasoning,
+      reasoning: modelConfig.reasoning ?? false,
       ...modelConfig.thinkingLevel !== void 0 ? { thinkingLevel: modelConfig.thinkingLevel } : {},
-      input: modelConfig.input,
-      cost: modelConfig.cost,
-      contextWindow: modelConfig.contextWindow,
-      maxTokens: modelConfig.maxTokens,
+      ...modelConfig.thinkingLevels !== void 0 ? { thinkingLevels: modelConfig.thinkingLevels } : {},
+      input: modelConfig.input ?? ["text"],
+      cost: modelConfig.cost ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: modelConfig.contextWindow ?? 128e3,
+      maxTokens: modelConfig.maxTokens ?? 4096,
       ...config.headers || modelConfig.headers ? { headers: { ...config.headers, ...modelConfig.headers } } : {},
       ...config.timeoutMs !== void 0 ? { timeoutMs: config.timeoutMs } : {},
       ...config.maxRetries !== void 0 ? { maxRetries: config.maxRetries } : {},
@@ -5164,6 +5770,8 @@ var ExtensionRunner = class {
   errorListeners = /* @__PURE__ */ new Set();
   // Capability change listeners
   capabilityListeners = /* @__PURE__ */ new Set();
+  // UI contribution change listeners
+  uiContributionListeners = /* @__PURE__ */ new Set();
   /** Current agent context — set by the agent before each phase */
   currentContext;
   constructor(options) {
@@ -5267,6 +5875,7 @@ var ExtensionRunner = class {
         tools: /* @__PURE__ */ new Map(),
         phases: /* @__PURE__ */ new Set(),
         capabilities: /* @__PURE__ */ new Map(),
+        uiContributions: /* @__PURE__ */ new Map(),
         cleanup: [],
         runtime: createExtensionRuntime()
       };
@@ -5279,6 +5888,9 @@ var ExtensionRunner = class {
         if (extension.capabilities.size > 0) {
           this.notifyCapabilitiesChanged();
         }
+        if (extension.uiContributions.size > 0) {
+          this.notifyUiContributionsChanged();
+        }
       } catch (error) {
         await this.rollbackExtension(extension);
         const message = error instanceof Error ? error.message : String(error);
@@ -5407,9 +6019,30 @@ var ExtensionRunner = class {
     this.capabilityListeners.add(listener);
     return () => this.capabilityListeners.delete(listener);
   }
-  // ---------------------------------------------------------------------------
-  // Phase management
-  // ---------------------------------------------------------------------------
+  /** Get all contributed UI elements across all extensions. */
+  getUiContributions() {
+    const result = [];
+    for (const ext of this.extensions) {
+      for (const contrib of ext.uiContributions.values()) {
+        result.push(contrib);
+      }
+    }
+    return Object.freeze(result);
+  }
+  /**
+   * Subscribe to UI contribution changes (contributions added, removed, or extensions disposed).
+   * Returns an unsubscribe function.
+   */
+  onUiContributionsChanged(listener) {
+    this.uiContributionListeners.add(listener);
+    return () => this.uiContributionListeners.delete(listener);
+  }
+  triggerUiAction(event) {
+    this.events.emit("ui.action", event);
+  }
+  // ---------------------------------------------------------------------------
+  // Phase management
+  // ---------------------------------------------------------------------------
   getPhase(name) {
     const reg = this.getRegisteredPhase(name);
     if (!reg) return void 0;
@@ -5524,7 +6157,7 @@ var ExtensionRunner = class {
     }
   }
   async emitBeforeToolCall(tool, args, context) {
-    const scope = context?.scope ?? resolveScopeFromMetadata(context?.metadata);
+    const scope = context?.scope ?? [];
     const turn = context?.turn ?? {};
     const result = await this.emitHook("before_tool_call", {
       type: "before_tool_call",
@@ -5541,7 +6174,7 @@ var ExtensionRunner = class {
     return result ?? { allow: true };
   }
   async emitAfterToolCall(tool, result, context) {
-    const scope = context?.scope ?? resolveScopeFromMetadata(context?.metadata);
+    const scope = context?.scope ?? [];
     const turn = context?.turn ?? {};
     const hookResult = await this.emitHook("after_tool_call", {
       type: "after_tool_call",
@@ -5621,12 +6254,13 @@ var ExtensionRunner = class {
       registerTool: (tool) => this.registerTool(extension, tool),
       unregisterTool: (toolName) => this.unregisterTool(extension, toolName),
       contributeCapability: (contribution) => this.contributeCapability(extension, contribution),
+      contributeUi: (contribution) => this.contributeUi(extension, contribution),
       context: extContext,
       manifest,
       trackCleanup: (cleanup) => extension.cleanup.push(cleanup),
       config: {
         get: async (scope) => {
-          const effectiveScope = scope ?? { kind: "global" };
+          const effectiveScope = scope ?? [];
           const res = await runner.host.getConfig(extension.id, effectiveScope);
           return res ?? null;
         },
@@ -5655,6 +6289,11 @@ var ExtensionRunner = class {
           get: async (key) => runner.host.getAgentState(extension.id, agentId, key),
           set: async (key, value) => runner.host.setAgentState(extension.id, agentId, key, value),
           delete: async (key) => runner.host.deleteAgentState(extension.id, agentId, key)
+        }),
+        global: () => ({
+          get: async (key) => runner.host.getGlobalState(extension.id, key),
+          set: async (key, value) => runner.host.setGlobalState(extension.id, key, value),
+          delete: async (key) => runner.host.deleteGlobalState(extension.id, key)
         })
       }
     }, extension.runtime, this.events);
@@ -5725,6 +6364,44 @@ var ExtensionRunner = class {
       }
     }
   }
+  contributeUi(extension, contribution) {
+    const key = `${contribution.slot}:${contribution.id}`;
+    const entry = {
+      ...contribution
+    };
+    extension.uiContributions.set(key, entry);
+    if (this.extensions.includes(extension)) {
+      this.notifyUiContributionsChanged();
+    }
+    let disposed = false;
+    const dispose = () => {
+      if (disposed) return;
+      disposed = true;
+      if (extension.uiContributions.get(key) === entry) {
+        extension.uiContributions.delete(key);
+        if (this.extensions.includes(extension)) {
+          this.notifyUiContributionsChanged();
+        }
+      }
+    };
+    extension.cleanup.push(dispose);
+    return dispose;
+  }
+  notifyUiContributionsChanged() {
+    const contributions = this.getUiContributions();
+    for (const listener of this.uiContributionListeners) {
+      try {
+        listener(contributions);
+      } catch (error) {
+        this.emitError({
+          extensionPath: "<runtime>",
+          event: "ui_contributions_changed",
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    }
+  }
   async registerPhase(extension, registration) {
     if (typeof registration === "string") {
       if (registration.length === 0) {
@@ -5813,6 +6490,8 @@ var ExtensionRunner = class {
     for (const name of extension.phases) this.phases.delete(name);
     const hadCapabilities = extension.capabilities.size > 0;
     extension.capabilities.clear();
+    const hadUiContributions = extension.uiContributions.size > 0;
+    extension.uiContributions.clear();
     for (const cleanup of [...extension.cleanup].reverse()) {
       await Promise.resolve().then(() => cleanup()).catch(() => void 0);
     }
@@ -5823,6 +6502,9 @@ var ExtensionRunner = class {
     if (hadCapabilities) {
       this.notifyCapabilitiesChanged();
     }
+    if (hadUiContributions) {
+      this.notifyUiContributionsChanged();
+    }
   }
 };
 function createExtensionRunner(options) {
@@ -6515,11 +7197,11 @@ function adaptExtensionTool(input) {
     parameters: definition.parameters,
     ...definition.promptSnippet ? { promptSnippet: definition.promptSnippet } : {},
     ...definition.promptGuidelines ? { promptGuidelines: definition.promptGuidelines } : {},
-    execute: async (args, context, signal) => {
-      const result = await definition.execute(args, context, signal);
-      const content = JSON.parse(JSON.stringify(result.content));
-      return result.isError ? { ok: false, content, error: "Extension Tool failed." } : { ok: true, content };
-    }
+    ...definition.kind ? { kind: definition.kind } : {},
+    ...definition.annotations ? { annotations: definition.annotations } : {},
+    ...definition._meta !== void 0 ? { _meta: definition._meta } : {},
+    ...definition.present ? { present: definition.present } : {},
+    execute: async (args, context, signal) => definition.execute(args, context, signal)
   };
 }
 
@@ -6587,12 +7269,53 @@ async function spillLargeToolResult(result, archiveDir, toolName) {
   await writeFile2(path, serialized, { encoding: "utf8", mode: 384 });
   await chmod2(path, 384).catch(() => void 0);
   const preview = new TextDecoder().decode(bytes.subarray(0, MAX_INLINE_TOOL_RESULT_BYTES));
-  return {
-    ...result,
-    content: `${preview}
+  const truncatedText = `${preview}
 [truncated]
 
-[Full result: ${path}, offset 0]`
+[Full result: ${path}, offset 0]`;
+  if (Array.isArray(result.content)) {
+    return {
+      ...result,
+      content: [{ type: "text", text: truncatedText }]
+    };
+  }
+  if (result.ok) {
+    return {
+      ok: true,
+      content: truncatedText,
+      ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
+    };
+  }
+  return {
+    ok: false,
+    content: truncatedText,
+    error: result.error ?? "Tool execution failed.",
+    ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
+  };
+}
+async function presentToolCall(tool, call) {
+  if (!tool.present) return void 0;
+  try {
+    const res = await tool.present(call);
+    if (!res) return void 0;
+    if (!isValidPresentationOutput(res)) {
+      console.warn(`Tool "${tool.name}" present() returned invalid shape for status "${call.status}":`, res);
+      return void 0;
+    }
+    return res;
+  } catch (err) {
+    console.warn(`Tool "${tool.name}" present() threw for status "${call.status}":`, err);
+    return void 0;
+  }
+}
+async function presentToolPending(tool, args) {
+  const pres = await presentToolCall(tool, { status: "pending", args });
+  return {
+    title: pres?.title ?? tool.annotations?.title ?? tool.name,
+    kind: tool.kind ?? "other",
+    ...pres?.locations !== void 0 ? { locations: pres.locations } : {},
+    ...pres?.content !== void 0 ? { content: pres.content } : {},
+    ...pres?._meta !== void 0 ? { _meta: pres._meta } : {}
   };
 }
 var AgentRuntime = class _AgentRuntime {
@@ -6611,9 +7334,11 @@ var AgentRuntime = class _AgentRuntime {
   host;
   resources;
   startedRuns = /* @__PURE__ */ new Set();
+  liveInteractions = /* @__PURE__ */ new Map();
   heartbeat;
   pumping = false;
   closed = false;
+  retryDelayMs;
   constructor(options, owned, resources) {
     this.host = options.host;
     this.owned = owned;
@@ -6621,6 +7346,7 @@ var AgentRuntime = class _AgentRuntime {
     this.storeIncarnation = String(owned.lease.token).split(":")[0];
     this.concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
     this.resources = resources;
+    this.retryDelayMs = options.retryDelayMs;
   }
   static async init(options) {
     if (!options.store) throw new TypeError("AgentRuntime requires a DurableStore");
@@ -6644,6 +7370,13 @@ var AgentRuntime = class _AgentRuntime {
     }
   }
   async handleRunEnd(runId, agentId, outcome) {
+    const runLive = this.liveInteractions.get(runId);
+    if (runLive) {
+      for (const live of runLive.values()) {
+        live.reject(new RunInteractionCancelledError("Run ended."));
+      }
+      this.liveInteractions.delete(runId);
+    }
     if (this.startedRuns.has(runId)) {
       this.startedRuns.delete(runId);
       try {
@@ -6787,6 +7520,8 @@ var AgentRuntime = class _AgentRuntime {
       agentId,
       input,
       ...options.metadata === void 0 ? {} : { metadata: options.metadata },
+      ...options.scope === void 0 ? {} : { scope: options.scope },
+      ...options.cwd === void 0 ? {} : { cwd: options.cwd },
       ...phasePayload === void 0 ? {} : { phasePayload },
       ...options.entryPhases === void 0 ? {} : { entryPhases: options.entryPhases },
       ...pinnedConfigToken === agent.currentConfigToken ? {} : { pinnedConfigToken },
@@ -6875,12 +7610,72 @@ var AgentRuntime = class _AgentRuntime {
     this.assertOpen();
     return this.resources.extensionRunner.onCapabilitiesChanged(listener);
   }
+  listUiContributions() {
+    this.assertOpen();
+    return this.resources.extensionRunner.getUiContributions();
+  }
+  onUiContributionsChanged(listener) {
+    this.assertOpen();
+    return this.resources.extensionRunner.onUiContributionsChanged(listener);
+  }
+  triggerUiAction(event) {
+    this.assertOpen();
+    this.resources.extensionRunner.triggerUiAction(event);
+  }
+  liveInteract(runId, request, signal) {
+    if (signal.aborted) {
+      return Promise.reject(signal.reason ?? new Error("Run aborted"));
+    }
+    const interactionId = request.id ?? createId("interaction");
+    const interaction = {
+      id: interactionId,
+      phase: "default",
+      kind: request.kind,
+      prompt: request.prompt,
+      payload: request.payload,
+      toolCallId: request.toolCallId,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending",
+      result: request.result
+    };
+    let runLive = this.liveInteractions.get(runId);
+    if (!runLive) {
+      runLive = /* @__PURE__ */ new Map();
+      this.liveInteractions.set(runId, runLive);
+    }
+    return new Promise((resolve9, reject) => {
+      const onAbort = () => {
+        runLive?.delete(interactionId);
+        if (runLive && runLive.size === 0) this.liveInteractions.delete(runId);
+        signal.removeEventListener("abort", onAbort);
+        reject(signal.reason ?? new Error("Run aborted"));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+      runLive.set(interactionId, {
+        interaction,
+        resolve: (val) => {
+          signal.removeEventListener("abort", onAbort);
+          resolve9(val);
+        },
+        reject: (err) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(err);
+        }
+      });
+    });
+  }
   async close() {
     if (this.closed) return;
     this.closed = true;
     if (this.heartbeat) clearInterval(this.heartbeat);
     for (const execution of this.executions.values()) execution.controller.abort();
     this.executions.clear();
+    for (const runLive of this.liveInteractions.values()) {
+      for (const live of runLive.values()) {
+        live.reject(new RunInteractionCancelledError("Runtime closed."));
+      }
+    }
+    this.liveInteractions.clear();
     this.transientEvents.close();
     for (const subscription of this.consumers.values()) subscription.controller.abort();
     await this.resources.closeExtensions();
@@ -6888,7 +7683,15 @@ var AgentRuntime = class _AgentRuntime {
   }
   async snapshot(runId) {
     this.assertOpen();
-    return this.owned.snapshotRun(runId);
+    const snap = await this.owned.snapshotRun(runId);
+    const runLive = this.liveInteractions.get(runId);
+    if (runLive && runLive.size > 0 && snap.state === "running") {
+      return {
+        ...snap,
+        interactions: [...runLive.values()].map((l) => l.interaction)
+      };
+    }
+    return snap;
   }
   async history(agentId) {
     this.assertOpen();
@@ -6896,6 +7699,20 @@ var AgentRuntime = class _AgentRuntime {
   }
   async respondInteraction(runId, input) {
     this.assertOpen();
+    const runLive = this.liveInteractions.get(runId);
+    const live = runLive?.get(input.interactionId);
+    if (live) {
+      runLive.delete(input.interactionId);
+      if (runLive.size === 0) this.liveInteractions.delete(runId);
+      if (input.cancel) {
+        live.reject(new RunInteractionCancelledError("Run interaction cancelled."));
+      } else if (input.input !== void 0) {
+        live.resolve(input.input);
+      } else {
+        live.reject(new TypeError("respondInteraction requires input or cancel: true"));
+      }
+      return;
+    }
     const snapshot = await this.owned.snapshotRun(runId);
     if (snapshot.state !== "input_required" || !snapshot.interactions.some((interaction) => interaction.id === input.interactionId)) {
       throw new RuntimeError("input_request_conflict", { runId, interactionId: input.interactionId, reason: "not_found" });
@@ -6905,6 +7722,13 @@ var AgentRuntime = class _AgentRuntime {
   }
   async cancel(runId, reason) {
     this.assertOpen();
+    const runLive = this.liveInteractions.get(runId);
+    if (runLive) {
+      for (const live of runLive.values()) {
+        live.reject(new RunInteractionCancelledError(reason ?? "Agent run stopped."));
+      }
+      this.liveInteractions.delete(runId);
+    }
     const done = this.executionDone.get(runId);
     if (done) {
       this.cancellationRequested.add(runId);
@@ -6963,6 +7787,7 @@ var AgentRuntime = class _AgentRuntime {
   async execute(run) {
     let claim;
     let executionRevision = run.revision;
+    let toolQueue = Promise.resolve();
     try {
       const agent = await this.requireAgent(run.agentId);
       let token = run.pinnedConfigToken ?? agent.currentConfigToken;
@@ -7050,7 +7875,7 @@ var AgentRuntime = class _AgentRuntime {
       const assembly = assembleRegisteredExtensions(config, this.resources.extensionRunner, {
         toolArchiveDir: this.archiveDirFor(run.agentId)
       });
-      let toolQueue = Promise.resolve();
+      toolQueue = Promise.resolve();
       const model = "stream" in config && config.stream ? config.model : { provider: config.model.provider, id: config.model.id };
       const stream = "stream" in config && config.stream ? config.stream : createModelStream(config.model);
       const phaseRegistry = normalizePhaseRegistry(assembly.context.phases);
@@ -7089,10 +7914,12 @@ var AgentRuntime = class _AgentRuntime {
           executionId: claim.execution.executionId,
           input: typeof run.input === "string" ? run.input : run.input.content,
           ...agent.metadata === void 0 ? {} : { agentMetadata: agent.metadata },
-          ...run.metadata === void 0 ? {} : { runMetadata: run.metadata }
+          ...run.metadata === void 0 ? {} : { runMetadata: run.metadata },
+          ...run.scope === void 0 ? {} : { scope: run.scope },
+          ...run.cwd === void 0 ? {} : { cwd: run.cwd }
         },
         model,
-        thinkingLevel: thinkingLevelFromMessages(context.messages),
+        thinkingLevel: thinkingLevelFromUserInput(run.input),
         stream,
         maxAttempts: config.maxAttempts,
         checkpoint: claim.run.checkpoint,
@@ -7101,9 +7928,9 @@ var AgentRuntime = class _AgentRuntime {
         interactionAnswers: claim.run.interactionAnswers,
         signal: controller.signal,
         beforePhase: assembly.beforePhase,
-        afterPhase: async (phaseId, output) => {
-          const extAfter = assembly.afterPhase ? await assembly.afterPhase(phaseId, output) : {};
-          const effectiveOutput = extAfter.output ?? output;
+        afterPhase: async (phaseId, output2) => {
+          const extAfter = assembly.afterPhase ? await assembly.afterPhase(phaseId, output2) : {};
+          const effectiveOutput = extAfter.output ?? output2;
           if (!extAfter.abort && (phaseId === COMPACT_PHASE_ID || isCompactionOutcome(effectiveOutput.payload))) {
             const active = this.executions.get(run.id);
             if (active?.executionId === claim.execution.executionId && !this.cancellationRequested.has(run.id) && !controller.signal.aborted) {
@@ -7155,7 +7982,7 @@ var AgentRuntime = class _AgentRuntime {
             const active = this.executions.get(run.id);
             if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
             const projected = projectAssistantMessage(message, run.agentId, run.id, 0);
-            const committed = await this.owned.commitPhaseOutput({
+            const committed2 = await this.owned.commitPhaseOutput({
               runId: run.id,
               execution: claim.execution,
               expectedRevision: executionRevision,
@@ -7172,7 +7999,7 @@ var AgentRuntime = class _AgentRuntime {
                 }
               }
             });
-            executionRevision = committed.revision;
+            executionRevision = committed2.revision;
           });
           toolQueue = task.then(() => void 0, () => void 0);
           return task;
@@ -7204,9 +8031,65 @@ var AgentRuntime = class _AgentRuntime {
             text: event.text
           });
         },
+        onToolCallDelta: (event) => {
+          const active = this.executions.get(run.id);
+          if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
+          this.transientEvents.publish({
+            kind: "tool_call_delta",
+            durability: "transient",
+            runId: run.id,
+            executionId: claim.execution.executionId,
+            messageId: event.messageId,
+            providerToolCallId: event.providerToolCallId,
+            toolName: event.toolName,
+            arguments: event.arguments,
+            args: event.args
+          });
+        },
+        onModelRetry: (event) => {
+          const active = this.executions.get(run.id);
+          if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
+          this.transientEvents.publish({
+            kind: "model_retry",
+            durability: "transient",
+            runId: run.id,
+            executionId: claim.execution.executionId,
+            attempt: event.attempt,
+            maxRetries: event.maxRetries,
+            delayMs: event.delayMs,
+            error: event.error
+          });
+        },
+        onToolReport: (event) => {
+          const active = this.executions.get(run.id);
+          if (this.closed || controller.signal.aborted || active?.executionId !== claim.execution.executionId) return;
+          this.transientEvents.publish({
+            kind: "tool_state_changed",
+            durability: "transient",
+            runId: event.runId,
+            executionId: claim.execution.executionId,
+            transition: { from: null, to: event.update.status ?? "in_progress" },
+            toolCall: event.update,
+            external: true
+          });
+          const task = toolQueue.then(async () => {
+            const active2 = this.executions.get(run.id);
+            if (this.closed || controller.signal.aborted || active2?.executionId !== claim.execution.executionId) return;
+            const recorded = await this.owned.recordToolCall({
+              runId: run.id,
+              execution: claim.execution,
+              update: event.update,
+              external: true
+            });
+            executionRevision = recorded.runRevision;
+          });
+          toolQueue = task.then(() => void 0, () => void 0);
+        },
+        retryDelayMs: this.retryDelayMs,
         onContext: assembly.setContext,
         runtime: {
-          tools: ({ toolCall, contentBlocks, driver }) => {
+          interact: (request) => this.liveInteract(run.id, request, controller.signal),
+          tools: ({ toolCall, contentBlocks, driver, options }) => {
             const task = toolQueue.then(async () => {
               const execution = await this.executeToolBatch({
                 run,
@@ -7218,6 +8101,7 @@ var AgentRuntime = class _AgentRuntime {
                 contentBlocks,
                 signal: controller.signal,
                 driver,
+                options,
                 onRevision: (rev) => {
                   executionRevision = rev;
                 }
@@ -7228,7 +8112,7 @@ var AgentRuntime = class _AgentRuntime {
             toolQueue = task.then(() => void 0, () => void 0);
             return task;
           },
-          toolsBatch: ({ toolCalls, contentBlocks, driver }) => {
+          toolsBatch: ({ toolCalls, contentBlocks, driver, options }) => {
             const task = toolQueue.then(async () => {
               const execution = await this.executeToolBatch({
                 run,
@@ -7240,6 +8124,7 @@ var AgentRuntime = class _AgentRuntime {
                 contentBlocks,
                 signal: controller.signal,
                 driver,
+                options,
                 onRevision: (rev) => {
                   executionRevision = rev;
                 }
@@ -7263,14 +8148,15 @@ var AgentRuntime = class _AgentRuntime {
           result = await executeModel(executionContext);
         }
       }
+      await toolQueue;
       if (this.cancellationRequested.has(run.id) || controller.signal.aborted) {
-        const output = latestAssistant(run, result.messages, executionContext.messages.length, true);
+        const output2 = latestAssistant(run, result.messages, executionContext.messages.length, true);
         const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
         await this.owned.cancelRun({
           runId: run.id,
           expectedRevision: executionRevision,
           reason,
-          ...output && hasVisibleAssistantText(output) ? { output } : {}
+          ...output2 && hasVisibleAssistantText(output2) ? { output: output2 } : {}
         });
         this.transientEvents.clear(run.id, claim.execution.executionId);
         await this.handleRunEnd(run.id, run.agentId, {
@@ -7289,12 +8175,12 @@ var AgentRuntime = class _AgentRuntime {
           pendingToolCallIds = result.interactions.map(({ toolCallId }) => toolCallId);
         }
         const isToolCallInteraction = result.interactions?.some((i) => i.toolCallId !== void 0);
-        const output = isToolCallInteraction ? void 0 : latestAssistant(
+        const output2 = isToolCallInteraction ? void 0 : latestAssistant(
           run,
           result.messages,
           executionContext.messages.length
         );
-        const prompt = isToolCallInteraction ? void 0 : output ?? (result.interactions[0]?.prompt ? promptMessage(run, result.interactions[0].prompt, result.messages.length) : void 0);
+        const prompt = isToolCallInteraction ? void 0 : output2 ?? (result.interactions[0]?.prompt ? promptMessage(run, result.interactions[0].prompt, result.messages.length) : void 0);
         await this.owned.commitInputRequired({
           runId: run.id,
           execution: claim.execution,
@@ -7310,24 +8196,32 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       if (result.type === "completed") {
-        const output = latestAssistant(run, result.messages, executionContext.messages.length);
-        await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, outcome: durableOutcome(result.outcome), ...output ? { output } : {} });
+        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 } : {} });
         this.transientEvents.clear(run.id, claim.execution.executionId, true);
         await this.handleRunEnd(run.id, run.agentId, result.outcome);
         return;
       }
+      const output = latestAssistant(run, result.messages, executionContext.messages.length);
       const failure = { code: "execution_failed", message: result.error instanceof Error ? result.error.message : "Execution failed." };
-      await this.owned.commitOutcome({ runId: run.id, execution: claim.execution, expectedRevision: executionRevision, failure });
+      const committed = await this.owned.commitOutcome({
+        runId: run.id,
+        execution: claim.execution,
+        expectedRevision: executionRevision,
+        failure,
+        ...output ? { output } : {}
+      });
       this.transientEvents.clear(run.id, claim.execution.executionId);
       await this.handleRunEnd(run.id, run.agentId, {
         id: createId("out"),
         status: "failed",
         message: failure.message,
-        error: failure
+        error: committed.failure ?? failure
       });
     } catch (error) {
       if (!claim && error instanceof RuntimeError && ["run_state_conflict", "runtime_ownership_lost", "run_not_found"].includes(error.code)) return;
       if (claim) {
+        await toolQueue;
         if (this.cancellationRequested.has(run.id)) {
           const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
           await this.owned.cancelRun({
@@ -7343,7 +8237,7 @@ var AgentRuntime = class _AgentRuntime {
           return;
         }
         const failureMessage = error instanceof Error ? error.message : "Execution failed.";
-        await this.owned.commitOutcome({
+        const committed = await this.owned.commitOutcome({
           runId: run.id,
           execution: claim.execution,
           expectedRevision: executionRevision,
@@ -7353,12 +8247,13 @@ var AgentRuntime = class _AgentRuntime {
             runId: run.id,
             reason: commitError instanceof Error ? commitError.message : "Run failure could not be committed."
           }).catch(() => void 0);
+          return void 0;
         });
         await this.handleRunEnd(run.id, run.agentId, {
           id: createId("out"),
           status: "failed",
           message: failureMessage,
-          error: { code: "execution_failed", message: failureMessage }
+          error: committed?.failure ?? { code: "execution_failed", message: failureMessage }
         });
         return;
       }
@@ -7382,7 +8277,8 @@ var AgentRuntime = class _AgentRuntime {
     return { result: batch.results[0], revision: batch.revision };
   }
   async executeToolBatch(input) {
-    const scope = resolveScopeFromMetadata(input.run.metadata);
+    const scope = input.run.scope ?? [];
+    const cwd = input.run.cwd;
     const turn = typeof input.run.input === "object" && input.run.input !== null && !Array.isArray(input.run.input) ? input.run.input : {};
     const checkpoint = input.driver?.checkpoint();
     const isSuspensionResume = checkpoint && typeof checkpoint === "object" && checkpoint.kind === "tool_call_suspension";
@@ -7410,7 +8306,9 @@ var AgentRuntime = class _AgentRuntime {
           ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
           ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
           toolCallId,
+          providerToolCallId: toolCall.id,
           scope,
+          ...cwd ? { cwd } : {},
           turn,
           interaction: createRunInteractionDriver({
             currentPhase: "default",
@@ -7438,6 +8336,12 @@ var AgentRuntime = class _AgentRuntime {
         }
       }
       if (!hasInteraction) {
+        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;
+          })
+        );
         const reserved = await this.owned.reserveToolCalls({
           runId: input.run.id,
           execution: input.execution,
@@ -7448,7 +8352,8 @@ var AgentRuntime = class _AgentRuntime {
             toolCallId: toolCallIds[i],
             providerToolCallId: tc.id,
             name: tc.name,
-            args: toJsonValue(tc.args)
+            args: toJsonValue(tc.args),
+            ...startPresentations[i] ?? {}
           }))
         });
         setRevision(reserved.run.revision);
@@ -7472,7 +8377,9 @@ var AgentRuntime = class _AgentRuntime {
               expectedRevision: revision,
               toolCallId,
               state: "failed",
-              result: { ok: false, content: null, error: `Tool ${toolCall.name} is not available.` }
+              result: { ok: false, content: null, error: `Tool ${toolCall.name} is not available.` },
+              title: toolCall.name,
+              kind: "other"
             });
             setRevision(failed.run.revision);
             results2.push(protocolFailure(`Tool ${toolCall.name} is not available.`));
@@ -7486,116 +8393,64 @@ var AgentRuntime = class _AgentRuntime {
               expectedRevision: revision,
               toolCallId,
               state: "failed",
-              result: { ok: false, content: null, error: decision.reason }
+              result: { ok: false, content: null, error: decision.reason },
+              title: durableTool.annotations?.title ?? durableTool.name,
+              kind: durableTool.kind ?? "other"
             });
             setRevision(failed.run.revision);
             results2.push(protocolFailure(decision.reason));
             continue;
           }
-          let progressActive = false;
-          const context = {
-            agentId: input.run.agentId,
-            runId: input.run.id,
-            ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
-            ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
-            toolCallId,
-            scope,
-            turn,
-            interaction: createToolInteractionDriver(input.driver, {
-              toolCallId,
-              toolCallIds,
-              toolCalls: input.toolCalls,
-              pendingIndex: i,
-              completedResults: results2
-            }),
-            reportProgress: (progress) => {
-              const active = this.executions.get(input.run.id);
-              if (!progressActive || this.closed || input.signal.aborted || active?.executionId !== input.execution.executionId || !isJsonValue(progress)) return;
-              let copy;
-              try {
-                if (JSON.stringify(progress).length > 64 * 1024) return;
-                copy = structuredClone(progress);
-              } catch {
-                return;
-              }
-              this.transientEvents.publish({
-                kind: "tool_progress",
-                durability: "transient",
-                runId: input.run.id,
-                executionId: input.execution.executionId,
-                toolCallId,
-                progress: copy
-              });
-            }
+          const currentToolState = {
+            ...startPresentations[i] ?? {
+              title: durableTool.annotations?.title ?? durableTool.name,
+              kind: durableTool.kind ?? "other"
+            },
+            rawInput: toJsonValue(toolCall.args)
           };
+          const inProgressPres = await presentToolCall(durableTool, {
+            status: "in_progress",
+            args: toJsonValue(toolCall.args)
+          });
+          if (inProgressPres) mergeToolCall(currentToolState, inProgressPres);
           const started = await this.owned.startToolCall({
             runId: input.run.id,
             execution: input.execution,
             expectedRevision: revision,
-            toolCallId
+            toolCallId,
+            title: currentToolState.title ?? durableTool.annotations?.title ?? durableTool.name,
+            kind: currentToolState.kind ?? durableTool.kind ?? "other",
+            ...currentToolState.locations !== void 0 ? { locations: currentToolState.locations } : {},
+            ...currentToolState.content !== void 0 ? { content: currentToolState.content } : {},
+            ...currentToolState._meta !== void 0 ? { _meta: currentToolState._meta } : {}
           });
           setRevision(started.run.revision);
-          progressActive = true;
-          try {
-            let result = await durableTool.execute(toJsonValue(toolCall.args), context, input.signal);
-            assertToolExecutionResult(result);
-            if (input.toolConfig.afterToolCall) {
-              result = await input.toolConfig.afterToolCall({
-                tool: durableTool,
-                result,
-                context,
-                signal: input.signal
-              });
-            }
-            assertToolExecutionResult(result);
-            result = await spillLargeToolResult(
-              result,
-              this.archiveDirFor(input.run.agentId),
-              toolCall.name
-            );
-            const committed = await this.owned.commitToolResult({
-              runId: input.run.id,
-              execution: input.execution,
-              expectedRevision: revision,
-              toolCallId,
-              state: result.ok ? "completed" : "failed",
-              result
-            });
-            setRevision(committed.run.revision);
-            const projectedResult = await this.foldToolInteractionRecords(result, toolCallId, input.run.agentId);
-            results2.push({
-              toolCallId: providerToolCallId,
-              toolName: toolCall.name,
-              ...projectedResult
-            });
-          } catch (error) {
-            if (error instanceof RunInteractionBoundary) {
-              const suspended = await this.owned.suspendToolCall({
-                runId: input.run.id,
-                execution: input.execution,
-                expectedRevision: revision,
-                toolCallId
-              });
-              setRevision(suspended.run.revision);
-              throw error;
-            }
-            if (error instanceof RunInteractionCancelledError) throw error;
-            const reason = error instanceof Error ? error.message : "Tool execution outcome is indeterminate.";
-            const indeterminate = await this.owned.commitToolResult({
-              runId: input.run.id,
-              execution: input.execution,
-              expectedRevision: revision,
-              toolCallId,
-              state: "indeterminate",
-              reason,
-              result: { ok: false, content: null, error: reason }
-            });
-            setRevision(indeterminate.run.revision);
-            results2.push(protocolFailure(reason));
-          } finally {
-            progressActive = false;
-            this.transientEvents.clearTool(input.run.id, toolCallId);
-          }
+          const toolResult2 = await this.executeAndCommitTool({
+            runId: input.run.id,
+            agentId: input.run.agentId,
+            agentMetadata: input.agentMetadata,
+            runMetadata: input.run.metadata,
+            execution: input.execution,
+            revision,
+            setRevision,
+            toolCall,
+            durableTool,
+            toolCallId,
+            providerToolCallId,
+            scope,
+            cwd,
+            turn,
+            driver: input.driver,
+            toolCalls: input.toolCalls,
+            toolCallIds,
+            pendingIndex: i,
+            completedResults: results2,
+            signal: input.signal,
+            afterToolCall: input.toolConfig.afterToolCall,
+            currentToolState,
+            options: input.options
+          });
+          results2.push(toolResult2);
         }
         return { results: results2, revision };
       }
@@ -7615,7 +8470,7 @@ var AgentRuntime = class _AgentRuntime {
         error
       });
       if (!durableTool) {
-        const reserved2 = await this.owned.reserveToolCalls({
+        const reserved = await this.owned.reserveToolCalls({
           runId: input.run.id,
           execution: input.execution,
           expectedRevision: revision,
@@ -7628,60 +8483,70 @@ var AgentRuntime = class _AgentRuntime {
             args: toJsonValue(toolCall.args)
           }]
         });
-        setRevision(reserved2.run.revision);
+        setRevision(reserved.run.revision);
         const failed = await this.owned.commitToolResult({
           runId: input.run.id,
           execution: input.execution,
           expectedRevision: revision,
           toolCallId,
           state: "failed",
-          result: { ok: false, content: null, error: `Tool ${toolCall.name} is not available.` }
+          result: { ok: false, content: null, error: `Tool ${toolCall.name} is not available.` },
+          title: toolCall.name,
+          kind: "other"
         });
         setRevision(failed.run.revision);
         results.push(protocolFailure(`Tool ${toolCall.name} is not available.`));
         continue;
       }
-      let progressActive = false;
-      const resumedStart = suspension && index === suspension.pendingIndex ? await this.owned.startToolCall({
-        runId: input.run.id,
-        execution: input.execution,
-        expectedRevision: revision,
-        toolCallId
-      }) : void 0;
+      const pendingPres = await presentToolPending(durableTool, toJsonValue(toolCall.args));
+      const currentToolState = {
+        ...pendingPres,
+        rawInput: toJsonValue(toolCall.args)
+      };
+      const resumedStart = suspension && index === suspension.pendingIndex ? await (async () => {
+        const inProgressPres = await presentToolCall(durableTool, {
+          status: "in_progress",
+          args: toJsonValue(toolCall.args)
+        });
+        if (inProgressPres) mergeToolCall(currentToolState, inProgressPres);
+        return this.owned.startToolCall({
+          runId: input.run.id,
+          execution: input.execution,
+          expectedRevision: revision,
+          toolCallId,
+          title: currentToolState.title ?? durableTool.annotations?.title ?? durableTool.name,
+          kind: currentToolState.kind ?? durableTool.kind ?? "other",
+          ...currentToolState.locations !== void 0 ? { locations: currentToolState.locations } : {},
+          ...currentToolState.content !== void 0 ? { content: currentToolState.content } : {},
+          ...currentToolState._meta !== void 0 ? { _meta: currentToolState._meta } : {}
+        });
+      })() : void 0;
       if (resumedStart) setRevision(resumedStart.run.revision);
+      const baseDriver = input.driver ?? createRunInteractionDriver({
+        currentPhase: "default",
+        attempt: 0,
+        status: "running",
+        metrics: { iterations: 0, phaseTransitions: [], compactionCount: 0, retryCount: 0, startedAt: (/* @__PURE__ */ new Date()).toISOString(), startedAtMs: Date.now() }
+      }, "default", input.signal);
+      const interactionDriver = createToolInteractionDriver(baseDriver, {
+        toolCallId,
+        ...suspension?.toolCallIds === void 0 ? {} : { toolCallIds: suspension.toolCallIds },
+        toolCalls: input.toolCalls,
+        pendingIndex: index,
+        completedResults: results
+      });
       const context = {
         agentId: input.run.agentId,
         runId: input.run.id,
         ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
         ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
         toolCallId,
+        providerToolCallId,
         scope,
+        ...cwd ? { cwd } : {},
         turn,
-        interaction: createToolInteractionDriver(input.driver, {
-          toolCallId,
-          ...suspension?.toolCallIds === void 0 ? {} : { toolCallIds: suspension.toolCallIds },
-          toolCalls: input.toolCalls,
-          pendingIndex: index,
-          completedResults: results
-        }),
-        reportProgress: (progress) => {
-          const active = this.executions.get(input.run.id);
-          if (!progressActive || this.closed || input.signal.aborted || active?.executionId !== input.execution.executionId || !isJsonValue(progress)) return;
-          let copy;
-          try {
-            if (JSON.stringify(progress).length > 64 * 1024) return;
-            copy = structuredClone(progress);
-          } catch {
-            return;
-          }
-          this.transientEvents.publish({
-            kind: "tool_progress",
-            durability: "transient",
-            runId: input.run.id,
-            executionId: input.execution.executionId,
-            toolCallId,
-            progress: copy
-          });
+        interaction: interactionDriver,
+        reportProgress: () => {
         }
       };
       const answer = suspension && index === suspension.pendingIndex ? suspension.interactionIds?.map((id) => input.driver?.answers().get(id)).find((value) => value !== void 0) : void 0;
@@ -7698,31 +8563,43 @@ var AgentRuntime = class _AgentRuntime {
             if (!input.driver) {
               throw new Error("Tool call requested interaction but no interaction driver is active.");
             }
-            context.interaction.request(decision.interaction);
-            if (!(suspension && index === suspension.pendingIndex)) {
-              const reserved2 = await this.owned.reserveToolCalls({
+            interactionDriver.request(decision.interaction);
+            if (!resumedStart) {
+              const reserved = await this.owned.reserveToolCalls({
                 runId: input.run.id,
                 execution: input.execution,
                 expectedRevision: revision,
                 requestMessageId: createId("msg"),
                 contentBlocks: input.contentBlocks,
-                calls: [{ toolCallId, providerToolCallId, name: toolCall.name, args: toJsonValue(toolCall.args) }]
+                calls: [{
+                  toolCallId,
+                  providerToolCallId,
+                  name: toolCall.name,
+                  args: toJsonValue(toolCall.args),
+                  ...pendingPres
+                }]
               });
-              setRevision(reserved2.run.revision);
+              setRevision(reserved.run.revision);
             }
-            context.interaction.suspend();
+            interactionDriver.suspend();
           }
           if ("allow" in decision && !decision.allow) {
-            if (!(suspension && index === suspension.pendingIndex)) {
-              const reserved2 = await this.owned.reserveToolCalls({
+            if (!resumedStart) {
+              const reserved = await this.owned.reserveToolCalls({
                 runId: input.run.id,
                 execution: input.execution,
                 expectedRevision: revision,
                 requestMessageId: createId("msg"),
                 contentBlocks: input.contentBlocks,
-                calls: [{ toolCallId, providerToolCallId, name: toolCall.name, args: toJsonValue(toolCall.args) }]
+                calls: [{
+                  toolCallId,
+                  providerToolCallId,
+                  name: toolCall.name,
+                  args: toJsonValue(toolCall.args),
+                  ...pendingPres
+                }]
               });
-              setRevision(reserved2.run.revision);
+              setRevision(reserved.run.revision);
             }
             const failed = await this.owned.commitToolResult({
               runId: input.run.id,
@@ -7730,9 +8607,27 @@ var AgentRuntime = class _AgentRuntime {
               expectedRevision: revision,
               toolCallId,
               state: "failed",
-              result: { ok: false, content: null, error: decision.reason }
+              result: { ok: false, content: null, error: decision.reason },
+              title: currentToolState.title ?? durableTool.annotations?.title ?? durableTool.name,
+              kind: currentToolState.kind ?? durableTool.kind ?? "other",
+              locations: currentToolState.locations,
+              content: currentToolState.content,
+              _meta: currentToolState._meta
             });
             setRevision(failed.run.revision);
+            if (input.options?.onUpdate) {
+              try {
+                input.options.onUpdate(createMergedToolCall(
+                  toolCallId,
+                  "failed",
+                  currentToolState,
+                  durableTool.annotations?.title ?? durableTool.name,
+                  durableTool.kind ?? "other"
+                ));
+              } catch (err) {
+                console.warn(`Error in tool call onUpdate callback:`, err);
+              }
+            }
             results.push(protocolFailure(decision.reason));
             continue;
           }
@@ -7742,16 +8637,22 @@ var AgentRuntime = class _AgentRuntime {
           throw error;
         }
         const reason = error instanceof Error ? error.message : "Tool policy rejected the call.";
-        if (!(suspension && index === suspension.pendingIndex)) {
-          const reserved2 = await this.owned.reserveToolCalls({
+        if (!resumedStart) {
+          const reserved = await this.owned.reserveToolCalls({
             runId: input.run.id,
             execution: input.execution,
             expectedRevision: revision,
             requestMessageId: createId("msg"),
             contentBlocks: input.contentBlocks,
-            calls: [{ toolCallId, providerToolCallId, name: toolCall.name, args: toJsonValue(toolCall.args) }]
+            calls: [{
+              toolCallId,
+              providerToolCallId,
+              name: toolCall.name,
+              args: toJsonValue(toolCall.args),
+              ...pendingPres
+            }]
           });
-          setRevision(reserved2.run.revision);
+          setRevision(reserved.run.revision);
         }
         const failed = await this.owned.commitToolResult({
           runId: input.run.id,
@@ -7759,94 +8660,316 @@ var AgentRuntime = class _AgentRuntime {
           expectedRevision: revision,
           toolCallId,
           state: "failed",
-          result: { ok: false, content: null, error: reason }
+          result: { ok: false, content: null, error: reason },
+          title: currentToolState.title ?? durableTool.annotations?.title ?? durableTool.name,
+          kind: currentToolState.kind ?? durableTool.kind ?? "other",
+          locations: currentToolState.locations,
+          content: currentToolState.content,
+          _meta: currentToolState._meta
         });
         setRevision(failed.run.revision);
+        if (input.options?.onUpdate) {
+          try {
+            input.options.onUpdate(createMergedToolCall(
+              toolCallId,
+              "failed",
+              currentToolState,
+              durableTool.annotations?.title ?? durableTool.name,
+              durableTool.kind ?? "other"
+            ));
+          } catch (err) {
+            console.warn(`Error in tool call onUpdate callback:`, err);
+          }
+        }
         results.push(protocolFailure(reason));
         continue;
       }
-      const reserved = resumedStart ?? await (async () => {
-        const committed = await this.owned.reserveToolCalls({
+      if (!resumedStart) {
+        const reserved = await this.owned.reserveToolCalls({
           runId: input.run.id,
           execution: input.execution,
           expectedRevision: revision,
           requestMessageId: createId("msg"),
           contentBlocks: input.contentBlocks,
-          calls: [{ toolCallId, providerToolCallId, name: toolCall.name, args: toJsonValue(toolCall.args) }]
+          calls: [{
+            toolCallId,
+            providerToolCallId,
+            name: toolCall.name,
+            args: toJsonValue(toolCall.args),
+            ...pendingPres
+          }]
         });
-        setRevision(committed.run.revision);
-        return this.owned.startToolCall({
-          runId: input.run.id,
-          execution: input.execution,
-          expectedRevision: revision,
-          toolCallId
+        setRevision(reserved.run.revision);
+        const inProgressPres = await presentToolCall(durableTool, {
+          status: "in_progress",
+          args: toJsonValue(toolCall.args)
         });
-      })();
-      if (reserved) setRevision(reserved.run.revision);
-      progressActive = true;
-      try {
-        let result = await durableTool.execute(toJsonValue(toolCall.args), context, input.signal);
-        assertToolExecutionResult(result);
-        if (input.toolConfig.afterToolCall) {
-          result = await input.toolConfig.afterToolCall({
-            tool: durableTool,
-            result,
-            context,
-            signal: input.signal
-          });
-        }
-        assertToolExecutionResult(result);
-        result = await spillLargeToolResult(
-          result,
-          this.archiveDirFor(input.run.agentId),
-          toolCall.name
-        );
-        const committed = await this.owned.commitToolResult({
+        if (inProgressPres) mergeToolCall(currentToolState, inProgressPres);
+        const started = await this.owned.startToolCall({
           runId: input.run.id,
           execution: input.execution,
           expectedRevision: revision,
           toolCallId,
-          state: result.ok ? "completed" : "failed",
-          result
+          title: currentToolState.title ?? durableTool.annotations?.title ?? durableTool.name,
+          kind: currentToolState.kind ?? durableTool.kind ?? "other",
+          ...currentToolState.locations !== void 0 ? { locations: currentToolState.locations } : {},
+          ...currentToolState.content !== void 0 ? { content: currentToolState.content } : {},
+          ...currentToolState._meta !== void 0 ? { _meta: currentToolState._meta } : {}
         });
-        setRevision(committed.run.revision);
-        const projectedResult = await this.foldToolInteractionRecords(result, toolCallId, input.run.agentId);
-        results.push({
-          toolCallId: providerToolCallId,
-          toolName: toolCall.name,
-          ...projectedResult
-        });
-      } catch (error) {
-        if (error instanceof RunInteractionBoundary) {
-          const suspended = await this.owned.suspendToolCall({
-            runId: input.run.id,
-            execution: input.execution,
-            expectedRevision: revision,
-            toolCallId
-          });
-          setRevision(suspended.run.revision);
-          throw error;
+        setRevision(started.run.revision);
+      }
+      const toolResult2 = await this.executeAndCommitTool({
+        runId: input.run.id,
+        agentId: input.run.agentId,
+        agentMetadata: input.agentMetadata,
+        runMetadata: input.run.metadata,
+        execution: input.execution,
+        revision,
+        setRevision,
+        toolCall,
+        durableTool,
+        toolCallId,
+        providerToolCallId,
+        scope,
+        cwd,
+        turn,
+        driver: input.driver,
+        toolCalls: input.toolCalls,
+        toolCallIds: suspension?.toolCallIds,
+        pendingIndex: index,
+        completedResults: results,
+        signal: input.signal,
+        afterToolCall: input.toolConfig.afterToolCall,
+        currentToolState,
+        options: input.options
+      });
+      results.push(toolResult2);
+    }
+    input.driver?.clearCheckpoint();
+    return { results, revision };
+  }
+  async executeAndCommitTool(input) {
+    let progressActive = true;
+    let progressQueue = Promise.resolve();
+    const notifyUpdate = (toolCall, progress) => {
+      if (input.options?.onUpdate) {
+        try {
+          input.options.onUpdate(toolCall, progress);
+        } catch (err) {
+          console.warn(`Error in tool call onUpdate callback:`, err);
         }
-        if (error instanceof RunInteractionCancelledError) throw error;
-        const reason = error instanceof Error ? error.message : "Tool execution outcome is indeterminate.";
-        const indeterminate = await this.owned.commitToolResult({
-          runId: input.run.id,
+      }
+    };
+    const startToolCall = createMergedToolCall(
+      input.toolCallId,
+      "in_progress",
+      input.currentToolState,
+      input.durableTool.annotations?.title ?? input.durableTool.name,
+      input.durableTool.kind ?? "other"
+    );
+    notifyUpdate(startToolCall);
+    const effectiveSignal = combineSignals(input.signal, input.options?.signal);
+    const baseDriver = input.driver ?? createRunInteractionDriver({
+      currentPhase: "default",
+      attempt: 0,
+      status: "running",
+      metrics: { iterations: 0, phaseTransitions: [], compactionCount: 0, retryCount: 0, startedAt: (/* @__PURE__ */ new Date()).toISOString(), startedAtMs: Date.now() }
+    }, "default", effectiveSignal);
+    const interactionDriver = createToolInteractionDriver(baseDriver, {
+      toolCallId: input.toolCallId,
+      ...input.toolCallIds === void 0 ? {} : { toolCallIds: input.toolCallIds },
+      toolCalls: input.toolCalls,
+      pendingIndex: input.pendingIndex,
+      completedResults: input.completedResults
+    });
+    const context = {
+      agentId: input.agentId,
+      runId: input.runId,
+      ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
+      ...input.runMetadata === void 0 ? {} : { runMetadata: input.runMetadata },
+      toolCallId: input.toolCallId,
+      providerToolCallId: input.providerToolCallId,
+      scope: input.scope,
+      ...input.cwd ? { cwd: input.cwd } : {},
+      turn: input.turn,
+      interaction: interactionDriver,
+      reportProgress: (progress) => {
+        const active = this.executions.get(input.runId);
+        if (!progressActive || this.closed || effectiveSignal.aborted || active?.executionId !== input.execution.executionId) return;
+        if (!isValidToolProgress(progress)) {
+          console.warn(`Invalid progress report for tool "${input.durableTool.name}": expected valid ToolProgress shape with finite numbers.`);
+          return;
+        }
+        let copy;
+        try {
+          if (JSON.stringify(progress).length > 64 * 1024) return;
+          copy = structuredClone(progress);
+        } catch {
+          return;
+        }
+        progressQueue = progressQueue.then(async () => {
+          if (!progressActive || this.closed || effectiveSignal.aborted) return;
+          const pres = await presentToolCall(input.durableTool, {
+            status: "in_progress",
+            args: toJsonValue(input.toolCall.args),
+            progress: copy
+          });
+          if (pres) {
+            mergeToolCall(input.currentToolState, pres);
+            const progressToolCall = createMergedToolCall(
+              input.toolCallId,
+              "in_progress",
+              input.currentToolState,
+              input.durableTool.annotations?.title ?? input.durableTool.name,
+              input.durableTool.kind ?? "other"
+            );
+            this.transientEvents.publish({
+              kind: "tool_state_changed",
+              durability: "transient",
+              runId: input.runId,
+              executionId: input.execution.executionId,
+              transition: { from: "in_progress", to: "in_progress" },
+              toolCall: progressToolCall
+            });
+            notifyUpdate(progressToolCall, copy);
+          }
+        }).catch((err) => {
+          console.warn(`Error handling progress report for tool "${input.durableTool.name}":`, err);
+        });
+      }
+    };
+    try {
+      if (input.options?.signal?.aborted) {
+        const error = input.options.signal.reason instanceof Error ? input.options.signal.reason : new DOMException(
+          typeof input.options.signal.reason === "string" ? input.options.signal.reason : "Tool execution aborted.",
+          "AbortError"
+        );
+        throw error;
+      }
+      let result = await withAbort(
+        input.durableTool.execute(toJsonValue(input.toolCall.args), context, effectiveSignal),
+        input.options?.signal
+      );
+      assertToolExecutionResult(result);
+      if (input.afterToolCall) {
+        result = await input.afterToolCall({
+          tool: input.durableTool,
+          result,
+          context,
+          signal: effectiveSignal
+        });
+      }
+      assertToolExecutionResult(result);
+      result = await spillLargeToolResult(
+        result,
+        this.archiveDirFor(input.agentId),
+        input.toolCall.name
+      );
+      await progressQueue.catch(() => {
+      });
+      const finalState = result.ok ? "completed" : "failed";
+      const completionPres = await presentToolCall(input.durableTool, {
+        status: finalState,
+        args: toJsonValue(input.toolCall.args),
+        result
+      });
+      if (completionPres) {
+        mergeToolCall(input.currentToolState, completionPres);
+      }
+      const rawOutput = "structuredContent" in result && result.structuredContent !== void 0 ? toJsonValue(result.structuredContent) : toJsonValue(result.content);
+      if (input.currentToolState.rawOutput === void 0) {
+        input.currentToolState.rawOutput = rawOutput;
+      }
+      const committed = await this.owned.commitToolResult({
+        runId: input.runId,
+        execution: input.execution,
+        expectedRevision: input.revision,
+        toolCallId: input.toolCallId,
+        state: finalState,
+        result,
+        title: input.currentToolState.title ?? input.durableTool.annotations?.title ?? input.durableTool.name,
+        kind: input.currentToolState.kind ?? input.durableTool.kind ?? "other",
+        locations: input.currentToolState.locations,
+        content: input.currentToolState.content,
+        rawOutput: input.currentToolState.rawOutput,
+        _meta: input.currentToolState._meta
+      });
+      input.setRevision(committed.run.revision);
+      const finalToolCall = createMergedToolCall(
+        input.toolCallId,
+        finalState,
+        input.currentToolState,
+        input.durableTool.annotations?.title ?? input.durableTool.name,
+        input.durableTool.kind ?? "other"
+      );
+      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
+      };
+    } catch (error) {
+      if (error instanceof RunInteractionBoundary) {
+        const suspended = await this.owned.suspendToolCall({
+          runId: input.runId,
           execution: input.execution,
-          expectedRevision: revision,
-          toolCallId,
-          state: "indeterminate",
-          reason,
-          result: { ok: false, content: null, error: reason }
+          expectedRevision: input.revision,
+          toolCallId: input.toolCallId
         });
-        setRevision(indeterminate.run.revision);
-        results.push(protocolFailure(reason));
-      } finally {
-        progressActive = false;
-        this.transientEvents.clearTool(input.run.id, toolCallId);
+        input.setRevision(suspended.run.revision);
+        throw error;
       }
+      if (error instanceof RunInteractionCancelledError) throw error;
+      const isPerCallAbort = Boolean(input.options?.signal?.aborted && !input.signal.aborted);
+      const reason = error instanceof Error ? error.message : isPerCallAbort ? "Tool execution aborted." : "Tool execution outcome is indeterminate.";
+      await progressQueue.catch(() => {
+      });
+      const failurePres = await presentToolCall(input.durableTool, {
+        status: "failed",
+        args: toJsonValue(input.toolCall.args),
+        result: { ok: false, content: null, error: reason }
+      });
+      if (failurePres) {
+        mergeToolCall(input.currentToolState, failurePres);
+      }
+      const commitState = isPerCallAbort ? "failed" : "indeterminate";
+      const committed = await this.owned.commitToolResult({
+        runId: input.runId,
+        execution: input.execution,
+        expectedRevision: input.revision,
+        toolCallId: input.toolCallId,
+        state: commitState,
+        ...isPerCallAbort ? {} : { reason },
+        result: { ok: false, content: null, error: reason },
+        title: input.currentToolState.title ?? input.durableTool.annotations?.title ?? input.durableTool.name,
+        kind: input.currentToolState.kind ?? input.durableTool.kind ?? "other",
+        locations: input.currentToolState.locations,
+        content: input.currentToolState.content,
+        _meta: input.currentToolState._meta
+      });
+      input.setRevision(committed.run.revision);
+      const finalToolCall = createMergedToolCall(
+        input.toolCallId,
+        "failed",
+        input.currentToolState,
+        input.durableTool.annotations?.title ?? input.durableTool.name,
+        input.durableTool.kind ?? "other"
+      );
+      notifyUpdate(finalToolCall);
+      return {
+        toolCallId: input.providerToolCallId,
+        toolName: input.toolCall.name,
+        ok: false,
+        content: null,
+        error: reason
+      };
+    } finally {
+      progressActive = false;
+      this.transientEvents.clearTool(input.runId, input.toolCallId);
     }
-    input.driver?.clearCheckpoint();
-    return { results, revision };
   }
   async foldToolInteractionRecords(result, toolCallId, agentId) {
     const interactionMessages = (await this.owned.history(agentId)).filter(
@@ -7855,11 +8978,27 @@ var AgentRuntime = class _AgentRuntime {
     if (interactionMessages.length === 0) return result;
     const interactionText = interactionMessages.filter((message) => message.role === "interaction").map(renderInteractionText).join("\n\n");
     const content = typeof result.content === "string" ? result.content : JSON.stringify(result.content) ?? "null";
-    return {
-      ...result,
-      content: content === "null" || content.length === 0 ? interactionText : `${interactionText}
+    const appendedText = content === "null" || content.length === 0 ? interactionText : `${interactionText}
 
-${content}`
+${content}`;
+    if (Array.isArray(result.content)) {
+      return {
+        ...result,
+        content: [{ type: "text", text: appendedText }]
+      };
+    }
+    if (result.ok) {
+      return {
+        ok: true,
+        content: appendedText,
+        ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
+      };
+    }
+    return {
+      ok: false,
+      content: appendedText,
+      error: result.error ?? "Tool execution failed.",
+      ...result.structuredContent !== void 0 ? { structuredContent: result.structuredContent } : {}
     };
   }
   async requireAgent(agentId) {
@@ -7947,8 +9086,8 @@ ${content}`
           if (event.runId !== runId) continue;
           if (event.kind === "message_committed") {
             subscription.clearMessage(event.message.id);
-          } else if (event.kind === "tool_state_changed" && ["completed", "failed", "indeterminate"].includes(event.transition.to)) {
-            subscription.clearTool(event.toolCall.id);
+          } else if (event.kind === "tool_state_changed" && ["completed", "failed"].includes(event.transition.to)) {
+            subscription.clearTool(event.toolCall.toolCallId);
           }
           if (event.kind === "run_state_changed" && ["completed", "failed", "cancelled"].includes(event.to)) {
             while (true) {
@@ -8146,6 +9285,19 @@ function toJsonValue(value) {
   assertJsonValue(value, "tool arguments");
   return value;
 }
+function createMergedToolCall(toolCallId, status, current, fallbackTitle, fallbackKind = "other") {
+  return {
+    toolCallId,
+    title: current.title ?? fallbackTitle,
+    kind: current.kind ?? fallbackKind,
+    status,
+    ...current.locations !== void 0 ? { locations: current.locations } : {},
+    ...current.content !== void 0 ? { content: current.content } : {},
+    ...current.rawInput !== void 0 ? { rawInput: current.rawInput } : {},
+    ...current.rawOutput !== void 0 ? { rawOutput: current.rawOutput } : {},
+    ...current._meta !== void 0 ? { _meta: current._meta } : {}
+  };
+}
 function deferred2() {
   let resolve9;
   let reject;
@@ -8158,6 +9310,24 @@ function deferred2() {
 
 // src/runtime/durable-store.ts
 import { createHash } from "crypto";
+function defaultToolCallContent(result) {
+  if ("content" in result && Array.isArray(result.content)) {
+    return result.content.map((block) => {
+      if (typeof block === "object" && block !== null && "type" in block && (block.type === "content" || block.type === "diff" || block.type === "terminal")) {
+        return block;
+      }
+      return {
+        type: "content",
+        content: block
+      };
+    });
+  }
+  const content = result.content;
+  if (typeof content === "string") {
+    return [{ type: "content", content: { type: "text", text: content } }];
+  }
+  return [{ type: "content", content: { type: "text", text: JSON.stringify(content ?? null) } }];
+}
 var InMemoryStore = class _InMemoryStore {
   incarnation;
   agents = /* @__PURE__ */ new Map();
@@ -8276,7 +9446,7 @@ var InMemoryStore = class _InMemoryStore {
       }
     }
     for (const message of state.messages) store.messages.set(message.id, clone(message));
-    for (const toolCall of state.toolCalls ?? []) store.toolCalls.set(toolCall.id, clone(toolCall));
+    for (const toolCall of state.toolCalls ?? []) store.toolCalls.set(toolCall.id ?? toolCall.toolCallId, clone(toolCall));
     store.events.push(...clone(state.events));
     for (const [key, receipt] of state.idempotency) store.idempotency.set(key, clone(receipt));
     for (const [key, receipt] of state.operationReceipts) {
@@ -8341,10 +9511,10 @@ var InMemoryStore = class _InMemoryStore {
     this.ownerEpoch = Math.max(this.ownerEpoch, ownerEpoch);
     for (const run of this.runs.values()) {
       if (run.state !== "running" || run.execution?.ownerEpoch !== ownerEpoch) continue;
-      const activeToolCalls = [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.state === "pending" || toolCall.state === "running"));
+      const activeToolCalls = [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.status === "pending" || toolCall.status === "in_progress" || toolCall.state === "pending" || toolCall.state === "in_progress"));
       const indeterminateToolCallIds = [];
       for (const toolCall of activeToolCalls) {
-        if (toolCall.state === "running") indeterminateToolCallIds.push(toolCall.id);
+        if (toolCall.status === "in_progress" || toolCall.state === "in_progress") indeterminateToolCallIds.push(toolCall.id);
         this.interruptToolCall(run, toolCall, message);
       }
       const failure = indeterminateToolCallIds.length > 0 ? { code: "tool_indeterminate", message, toolCallIds: indeterminateToolCallIds } : { code: "runtime_interrupted", message, ownerEpoch };
@@ -8604,7 +9774,7 @@ var InMemoryStore = class _InMemoryStore {
       run.invalidatedBy = { messageId: original.id, messageRevision: actualRevision + 1 };
       if (run.state === "running" || run.state === "queued" || run.state === "input_required") {
         if (run.state === "running") {
-          const openToolCalls = [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.state === "pending" || toolCall.state === "running"));
+          const openToolCalls = [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.status === "pending" || toolCall.status === "in_progress" || toolCall.state === "pending" || toolCall.state === "in_progress"));
           for (const toolCall of openToolCalls) this.interruptToolCall(run, toolCall, "Run superseded by Message revision.");
         } else {
           delete run.openInteractions;
@@ -8700,7 +9870,7 @@ var InMemoryStore = class _InMemoryStore {
     if (input.phasePayload !== void 0) assertJsonValue(input.phasePayload, "run.phasePayload");
     if (input.entryPhases !== void 0) assertEntryPhases(input.entryPhases, "run.entryPhases");
     const scope = createIdempotencyScope("start_run", input.agentId, input.idempotencyKey);
-    const payload = canonicalStartRunRequest(normalizedInput, input.metadata, input.phasePayload, input.pinnedConfigToken, input.entryPhases);
+    const payload = canonicalStartRunRequest(normalizedInput, input.metadata, input.phasePayload, input.pinnedConfigToken, input.entryPhases, input.scope, input.cwd);
     const replay = this.replay(scope, payload);
     if (replay) return clone(replay);
     const waitingRun = isControlMetadata(input.metadata) ? void 0 : [...this.runs.values()].find((candidate) => candidate.agentId === input.agentId && candidate.state === "input_required");
@@ -8756,6 +9926,8 @@ var InMemoryStore = class _InMemoryStore {
       state: "queued",
       input: clone(normalizedInput),
       ...input.metadata ? { metadata: clone(input.metadata) } : {},
+      ...input.scope !== void 0 ? { scope: clone(input.scope) } : {},
+      ...input.cwd !== void 0 ? { cwd: input.cwd } : {},
       ...input.phasePayload === void 0 ? {} : { phasePayload: clone(input.phasePayload) },
       ...input.entryPhases === void 0 ? {} : { entryPhases: clone(input.entryPhases) },
       ...input.pinnedConfigToken === void 0 ? {} : { pinnedConfigToken: input.pinnedConfigToken },
@@ -9031,19 +10203,30 @@ var InMemoryStore = class _InMemoryStore {
     this.assertExecution(run, input.execution, input.expectedRevision);
     if (this.messages.has(input.requestMessageId)) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
     const timestamp = createTimestamp();
-    const toolCalls = input.calls.map((call) => ({
-      id: call.toolCallId ?? createId("tool"),
-      providerToolCallId: call.providerToolCallId,
-      agentId: run.agentId,
-      runId: run.id,
-      executionId: input.execution.executionId,
-      requestMessageId: input.requestMessageId,
-      name: call.name,
-      args: clone(call.args),
-      state: "pending",
-      createdAt: timestamp,
-      updatedAt: timestamp
-    }));
+    const toolCalls = input.calls.map((call) => {
+      const toolCallId = call.providerToolCallId || (call.toolCallId ?? createId("tool"));
+      return {
+        id: call.toolCallId ?? createId("tool"),
+        toolCallId,
+        ...call.providerToolCallId ? { providerToolCallId: call.providerToolCallId } : {},
+        agentId: run.agentId,
+        runId: run.id,
+        executionId: input.execution.executionId,
+        requestMessageId: input.requestMessageId,
+        name: call.name,
+        title: call.title ?? call.name,
+        kind: call.kind ?? "other",
+        status: "pending",
+        state: "pending",
+        ...call.content ? { content: clone(call.content) } : {},
+        ...call.locations ? { locations: clone(call.locations) } : {},
+        rawInput: clone(call.args),
+        ...call._meta ? { _meta: clone(call._meta) } : {},
+        args: clone(call.args),
+        createdAt: timestamp,
+        updatedAt: timestamp
+      };
+    });
     for (const toolCall of toolCalls) {
       if (this.toolCalls.has(toolCall.id)) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
     }
@@ -9079,15 +10262,27 @@ var InMemoryStore = class _InMemoryStore {
     const run = this.requireRun(input.runId);
     this.assertExecution(run, input.execution, input.expectedRevision);
     const toolCall = this.requireToolCall(input.toolCallId, run);
-    if (toolCall.state !== "pending") throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
-    toolCall.state = "running";
+    if (toolCall.status !== "pending" && toolCall.state !== "pending") throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
+    const from = toolCall.status ?? "pending";
+    toolCall.status = "in_progress";
+    toolCall.state = "in_progress";
     toolCall.executionId = input.execution.executionId;
+    if (input.title !== void 0) toolCall.title = input.title;
+    if (input.kind !== void 0) toolCall.kind = input.kind;
+    if (input.locations !== void 0) toolCall.locations = clone(input.locations);
+    if (input.content !== void 0) toolCall.content = clone(input.content);
+    if (input._meta !== void 0) {
+      toolCall._meta = {
+        ...toolCall._meta ?? {},
+        ...clone(input._meta)
+      };
+    }
     toolCall.updatedAt = createTimestamp();
     this.storeToolCall(toolCall);
     run.revision += 1;
     run.updatedAt = toolCall.updatedAt;
     this.touchRun(run);
-    this.appendToolTransition(run, { from: "pending", to: "running" }, toolCall);
+    this.appendToolTransition(run, { from, to: "in_progress" }, toolCall);
     const result = { run: clone(run), toolCall: clone(toolCall) };
     this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
@@ -9101,16 +10296,18 @@ var InMemoryStore = class _InMemoryStore {
     const run = this.requireRun(input.runId);
     this.assertExecution(run, input.execution, input.expectedRevision);
     const toolCall = this.requireToolCall(input.toolCallId, run);
-    if (toolCall.state !== "running" || toolCall.executionId !== input.execution.executionId) {
+    if (toolCall.status !== "in_progress" && toolCall.state !== "in_progress" || toolCall.executionId !== input.execution.executionId) {
       throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
     }
+    const from = toolCall.status ?? "in_progress";
+    toolCall.status = "pending";
     toolCall.state = "pending";
     toolCall.updatedAt = createTimestamp();
     this.storeToolCall(toolCall);
     run.revision += 1;
     run.updatedAt = toolCall.updatedAt;
     this.touchRun(run);
-    this.appendToolTransition(run, { from: "running", to: "pending" }, toolCall);
+    this.appendToolTransition(run, { from, to: "pending" }, toolCall);
     const result = { run: clone(run), toolCall: clone(toolCall) };
     this.writeOperationReceipt(operationKey, operationPayload, result, run.id);
     return result;
@@ -9119,8 +10316,9 @@ var InMemoryStore = class _InMemoryStore {
     this.assertOwner(lease);
     assertToolExecutionResult(input.result);
     assertToolValue(input.result, "tool.result");
-    if (input.state === "completed" && !input.result.ok) throw new TypeError("completed ToolCall requires a successful result");
-    if (input.state !== "completed" && input.result.ok) throw new TypeError(`${input.state} ToolCall requires a failed result`);
+    const isCompleted = "ok" in input.result ? input.result.ok : !input.result.isError;
+    if (input.state === "completed" && !isCompleted) throw new TypeError("completed ToolCall requires a successful result");
+    if (input.state !== "completed" && isCompleted) throw new TypeError(`${input.state} ToolCall requires a failed result`);
     if (input.state === "indeterminate" && (!input.reason || input.reason.trim().length === 0)) throw new TypeError("indeterminate ToolCall requires a reason");
     const operationKey = `tool_commit:${input.toolCallId}`;
     const operationPayload = canonicalJson([input.runId, input.expectedRevision, input.execution.executionId, input.state, input.result, input.reason ?? null]);
@@ -9130,10 +10328,9 @@ var InMemoryStore = class _InMemoryStore {
     this.assertExecution(run, input.execution, input.expectedRevision);
     const toolCall = this.requireToolCall(input.toolCallId, run);
     if (toolCall.executionId !== input.execution.executionId) throw new RuntimeError("runtime_ownership_lost", { reason: "epoch_advanced", expectedEpoch: input.execution.ownerEpoch, actualEpoch: this.ownerEpoch });
-    const from = toolCall.state;
-    if (from === "pending" && input.state !== "failed") throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
-    if (from !== "pending" && from !== "running") throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
-    const durableResult = { toolCallId: toolCall.id, toolName: toolCall.name, ...clone(input.result) };
+    const fromStatus = toolCall.status ?? (toolCall.state === "in_progress" ? "in_progress" : toolCall.state);
+    const toStatus = input.state === "completed" ? "completed" : "failed";
+    const durableResult = { toolCallId: toolCall.id, toolName: toolCall.name ?? toolCall.title, ...clone(input.result) };
     const resultMessageId = createId("msg");
     const message = {
       id: resultMessageId,
@@ -9145,7 +10342,21 @@ var InMemoryStore = class _InMemoryStore {
       createdAt: createTimestamp()
     };
     this.storeMessage(message);
-    toolCall.state = input.state;
+    toolCall.status = toStatus;
+    toolCall.state = toStatus;
+    if (input.title !== void 0) toolCall.title = input.title;
+    if (input.kind !== void 0) toolCall.kind = input.kind;
+    if (input.locations !== void 0) toolCall.locations = clone(input.locations);
+    if (input.content !== void 0) toolCall.content = clone(input.content);
+    else if (toolCall.content === void 0) toolCall.content = defaultToolCallContent(input.result);
+    if (input.rawOutput !== void 0) toolCall.rawOutput = clone(input.rawOutput);
+    else if (toolCall.rawOutput === void 0) toolCall.rawOutput = "structuredContent" in input.result && input.result.structuredContent !== void 0 ? clone(input.result.structuredContent) : clone(input.result.content);
+    if (input._meta !== void 0) {
+      toolCall._meta = {
+        ...toolCall._meta ?? {},
+        ...clone(input._meta)
+      };
+    }
     toolCall.result = durableResult;
     toolCall.resultMessageId = resultMessageId;
     if (input.state === "indeterminate") toolCall.reason = input.reason;
@@ -9155,13 +10366,13 @@ var InMemoryStore = class _InMemoryStore {
     run.revision += 1;
     run.updatedAt = message.createdAt;
     this.touchRun(run);
-    this.appendToolTransition(run, { from, to: input.state }, toolCall);
+    this.appendToolTransition(run, { from: fromStatus, to: toStatus }, toolCall);
     this.appendMessage(run, message);
     if (input.state === "indeterminate") {
-      const openToolCalls = [...this.toolCalls.values()].filter((candidate) => candidate.runId === run.id && candidate.executionId === input.execution.executionId && candidate.id !== toolCall.id && (candidate.state === "pending" || candidate.state === "running"));
+      const openToolCalls = [...this.toolCalls.values()].filter((candidate) => candidate.runId === run.id && candidate.executionId === input.execution.executionId && candidate.id !== toolCall.id && (candidate.status === "pending" || candidate.status === "in_progress" || candidate.state === "pending" || candidate.state === "in_progress"));
       const indeterminateToolCallIds = [toolCall.id];
       for (const candidate of openToolCalls) {
-        if (candidate.state === "running") indeterminateToolCallIds.push(candidate.id);
+        if (candidate.status === "in_progress" || candidate.state === "in_progress") indeterminateToolCallIds.push(candidate.id);
         this.interruptToolCall(run, candidate, input.reason);
       }
       const failure = {
@@ -9203,7 +10414,11 @@ var InMemoryStore = class _InMemoryStore {
     }
     run.state = nextState;
     if (input.outcome) run.outcome = clone(input.outcome);
-    if (input.failure) run.failure = clone(input.failure);
+    let failure = input.failure ? clone(input.failure) : void 0;
+    if (nextState === "failed" && failure) {
+      failure = this.withdrawUserInputIfNoOutput(run, failure, output);
+      run.failure = failure;
+    }
     this.dropClaimReceipt(run.execution);
     delete run.execution;
     delete run.openInteractions;
@@ -9211,7 +10426,7 @@ var InMemoryStore = class _InMemoryStore {
     run.revision += 1;
     run.updatedAt = createTimestamp();
     this.touchRun(run);
-    this.appendTransition(run, "running", nextState, { outcome: input.outcome, failure: input.failure, output });
+    this.appendTransition(run, "running", nextState, { outcome: input.outcome, failure, output });
     this.dropRunOperationReceipts(run.id);
     const result = clone(run);
     return result;
@@ -9236,14 +10451,14 @@ var InMemoryStore = class _InMemoryStore {
       return result2;
     }
     const from = run.state;
-    const activeToolCalls = run.execution ? [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.state === "pending" || toolCall.state === "running")) : run.state === "input_required" && run.checkpoint?.data && typeof run.checkpoint.data === "object" && !Array.isArray(run.checkpoint.data) ? (() => {
+    const activeToolCalls = run.execution ? [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.status === "pending" || toolCall.status === "in_progress" || toolCall.state === "pending" || toolCall.state === "in_progress")) : run.state === "input_required" && run.checkpoint?.data && typeof run.checkpoint.data === "object" && !Array.isArray(run.checkpoint.data) ? (() => {
       const interactionState = run.checkpoint.data.runInteractions;
       const interactionCheckpoint = interactionState && typeof interactionState === "object" && !Array.isArray(interactionState) ? interactionState.checkpoint : void 0;
       const ids = interactionCheckpoint && typeof interactionCheckpoint === "object" && !Array.isArray(interactionCheckpoint) ? interactionCheckpoint.toolCallIds : void 0;
       const allowed = new Set(Array.isArray(ids) ? ids : []);
-      return [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.state === "pending" && allowed.has(toolCall.id));
+      return [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && (toolCall.status === "pending" || toolCall.state === "pending") && allowed.has(toolCall.id));
     })() : [];
-    const indeterminateToolCallIds = activeToolCalls.filter((toolCall) => toolCall.state === "running").map((toolCall) => toolCall.id);
+    const indeterminateToolCallIds = activeToolCalls.filter((toolCall) => toolCall.status === "in_progress" || toolCall.state === "in_progress").map((toolCall) => toolCall.id);
     for (const toolCall of activeToolCalls) this.interruptToolCall(run, toolCall, input.reason ?? "The Run was cancelled.");
     if (input.output && (typeof input.output.content === "string" ? input.output.content.length > 0 : input.output.content.length > 0)) {
       const output = { ...clone(input.output), sequenceWithinRun: this.nextMessageSequence(run.id) };
@@ -9290,6 +10505,74 @@ var InMemoryStore = class _InMemoryStore {
     const result = clone(run);
     return result;
   }
+  recordToolCall(lease, input) {
+    this.assertOwner(lease);
+    const run = this.requireRun(input.runId);
+    if (input.execution) {
+      if (run.state !== "running" || !run.execution || run.execution.executionId !== input.execution.executionId || run.execution.ownerEpoch !== input.execution.ownerEpoch) {
+        throw new RuntimeError("runtime_ownership_lost", {
+          reason: "epoch_advanced",
+          expectedEpoch: input.execution.ownerEpoch,
+          actualEpoch: this.ownerEpoch
+        });
+      }
+    }
+    const toolCallId = input.update.toolCallId;
+    const existing = this.toolCalls.get(toolCallId);
+    const fromStatus = existing ? existing.status : null;
+    const toStatus = input.update.status ?? (existing ? existing.status : "in_progress");
+    const timestamp = createTimestamp();
+    let stored;
+    if (existing) {
+      mergeToolCall(existing, input.update);
+      existing.status = toStatus;
+      existing.state = toStatus;
+      if (input.external !== void 0) existing.external = input.external;
+      existing.updatedAt = timestamp;
+      stored = existing;
+    } else {
+      stored = {
+        id: toolCallId,
+        toolCallId,
+        providerToolCallId: toolCallId,
+        agentId: run.agentId,
+        runId: run.id,
+        executionId: input.execution?.executionId,
+        title: "title" in input.update && input.update.title ? input.update.title : "external_tool",
+        kind: "kind" in input.update && input.update.kind ? input.update.kind : "other",
+        status: toStatus,
+        state: toStatus,
+        external: input.external ?? false,
+        createdAt: timestamp,
+        updatedAt: timestamp
+      };
+      mergeToolCall(stored, input.update);
+      this.toolCalls.set(stored.id, stored);
+    }
+    this.storeToolCall(stored);
+    run.revision += 1;
+    run.updatedAt = timestamp;
+    this.touchRun(run);
+    const acpToolCall = {
+      toolCallId: stored.toolCallId,
+      title: stored.title,
+      kind: stored.kind,
+      status: stored.status,
+      ...stored.content !== void 0 ? { content: clone(stored.content) } : {},
+      ...stored.locations !== void 0 ? { locations: clone(stored.locations) } : {},
+      ...stored.rawInput !== void 0 ? { rawInput: clone(stored.rawInput) } : {},
+      ...stored.rawOutput !== void 0 ? { rawOutput: clone(stored.rawOutput) } : {},
+      ...stored._meta !== void 0 ? { _meta: clone(stored._meta) } : {}
+    };
+    const event = this.baseEvent(run, {
+      kind: "tool_state_changed",
+      transition: { from: fromStatus, to: toStatus },
+      toolCall: acpToolCall,
+      ...input.external ? { external: true } : {}
+    });
+    this.appendEvent(event);
+    return event;
+  }
   snapshotRun(lease, runId) {
     this.assertOwner(lease);
     const run = this.requireRun(runId);
@@ -9300,6 +10583,8 @@ var InMemoryStore = class _InMemoryStore {
       revision: run.revision,
       input: clone(run.input),
       ...run.metadata ? { metadata: clone(run.metadata) } : {},
+      ...run.scope !== void 0 ? { scope: clone(run.scope) } : {},
+      ...run.cwd !== void 0 ? { cwd: run.cwd } : {},
       ...run.phasePayload === void 0 ? {} : { phasePayload: clone(run.phasePayload) },
       ...run.entryPhases === void 0 ? {} : { entryPhases: clone(run.entryPhases) },
       messageCount: this.messagesForRun(run.id).length,
@@ -9386,7 +10671,7 @@ var InMemoryStore = class _InMemoryStore {
       if (run.state === "running") blockedRunIds.add(run.id);
     }
     for (const tool of this.toolCalls.values()) {
-      if (tool.state === "pending" || tool.state === "running" || tool.state === "indeterminate") {
+      if (tool.status === "pending" || tool.status === "in_progress" || tool.state === "pending" || tool.state === "in_progress") {
         blockedRunIds.add(tool.runId);
       }
     }
@@ -9527,13 +10812,13 @@ var InMemoryStore = class _InMemoryStore {
   }
   assertNoOpenTools(run, allowedPendingToolCallIds = []) {
     const allowed = new Set(allowedPendingToolCallIds);
-    if ([...this.toolCalls.values()].some((toolCall) => toolCall.runId === run.id && (toolCall.state === "running" || toolCall.state === "pending" && !allowed.has(toolCall.id)))) {
+    if ([...this.toolCalls.values()].some((toolCall) => toolCall.runId === run.id && (toolCall.status === "in_progress" || toolCall.state === "in_progress" || (toolCall.status === "pending" || toolCall.state === "pending") && !allowed.has(toolCall.id)))) {
       throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
     }
   }
   interruptToolCall(run, toolCall, reason) {
     const result = { ok: false, content: null, error: reason };
-    const durableResult = { toolCallId: toolCall.id, toolName: toolCall.name, ...result };
+    const durableResult = { toolCallId: toolCall.id, toolName: toolCall.name ?? toolCall.title, ...result };
     const message = {
       id: createId("msg"),
       agentId: run.agentId,
@@ -9543,13 +10828,14 @@ var InMemoryStore = class _InMemoryStore {
       sequenceWithinRun: this.nextMessageSequence(run.id),
       createdAt: createTimestamp()
     };
-    const from = toolCall.state;
-    const to = from === "running" ? "indeterminate" : "failed";
+    const from = toolCall.status ?? toolCall.state ?? "in_progress";
+    const to = "failed";
     this.storeMessage(message);
     toolCall.state = to;
+    toolCall.status = to;
     toolCall.result = durableResult;
     toolCall.resultMessageId = message.id;
-    if (to === "indeterminate") toolCall.reason = reason;
+    toolCall.reason = reason;
     toolCall.updatedAt = message.createdAt;
     this.storeToolCall(toolCall);
     run.revision += 1;
@@ -9586,6 +10872,28 @@ var InMemoryStore = class _InMemoryStore {
   messagesForRun(runId) {
     return [...this.messages.values()].filter((message) => message.runId === runId).sort((a, b) => a.sequenceWithinRun - b.sequenceWithinRun);
   }
+  withdrawUserInputIfNoOutput(run, failure, output) {
+    const runMessages = this.messagesForRun(run.id);
+    const hasAssistantMessage = runMessages.some((m) => m.role === "assistant") || output !== void 0;
+    const hasToolMessage = runMessages.some((m) => m.role === "tool");
+    const hasToolCalls = [...this.toolCalls.values()].some((tc) => tc.runId === run.id);
+    if (hasAssistantMessage || hasToolMessage || hasToolCalls) {
+      return failure;
+    }
+    const userInputMessage = runMessages.find((m) => m.role === "user");
+    if (!userInputMessage) {
+      return failure;
+    }
+    this.messages.delete(userInputMessage.id);
+    this.recorder?.onMessageDelete(userInputMessage.id);
+    return {
+      ...failure,
+      withdrawnInput: {
+        messageId: userInputMessage.id,
+        content: clone(userInputMessage.content)
+      }
+    };
+  }
   history(lease, agentId) {
     this.assertOwner(lease);
     this.requireAgent(agentId);
@@ -9678,18 +10986,34 @@ ${record.summary}`,
       to,
       ...to === "input_required" ? { interactions: clone(options?.interactions ?? []), answers: clone(options?.answers ?? {}) } : {},
       ...to === "completed" && options?.outcome ? { outcome: options.outcome, ...options.output ? { output: options.output } : {} } : {},
-      ...to === "failed" && options?.failure ? { failure: options.failure } : {},
+      ...to === "failed" && options?.failure ? {
+        failure: options.failure,
+        ...options.failure.withdrawnInput ? { withdrawnInput: options.failure.withdrawnInput } : {}
+      } : {},
       ...to === "cancelled" && options?.reason ? { reason: options.reason } : {}
     };
     this.touchRun(run);
     this.appendEvent(transition);
   }
   appendToolTransition(run, transition, toolCall) {
-    this.appendEvent(this.baseEvent(run, {
+    const acpToolCall = {
+      toolCallId: toolCall.toolCallId ?? toolCall.id,
+      title: toolCall.title ?? toolCall.name ?? toolCall.toolCallId,
+      kind: toolCall.kind ?? "other",
+      status: toolCall.status ?? toolCall.state,
+      ...toolCall.content ? { content: clone(toolCall.content) } : {},
+      ...toolCall.locations ? { locations: clone(toolCall.locations) } : {},
+      ...toolCall.rawInput !== void 0 ? { rawInput: clone(toolCall.rawInput) } : {},
+      ...toolCall.rawOutput !== void 0 ? { rawOutput: clone(toolCall.rawOutput) } : {},
+      ...toolCall._meta ? { _meta: clone(toolCall._meta) } : {}
+    };
+    this.appendEvent({
+      ...this.baseEvent(run),
       kind: "tool_state_changed",
       transition,
-      toolCall: clone(toolCall)
-    }));
+      toolCall: acpToolCall,
+      ...toolCall.external ? { external: true } : {}
+    });
   }
   baseEvent(run, extra) {
     this.eventSequence += 1;
@@ -9791,6 +11115,9 @@ var MemoryOwnedStore = class {
   async cancelRun(input) {
     return this.store.cancelRun(this.lease, input);
   }
+  async recordToolCall(input) {
+    return this.store.recordToolCall(this.lease, input);
+  }
   async snapshotRun(runId) {
     return this.store.snapshotRun(this.lease, runId);
   }
@@ -9934,19 +11261,19 @@ function requestMessageContent(toolCalls, contentBlocks) {
   const toolUse = (toolCall) => ({
     type: "tool_use",
     toolCallId: toolCall.id,
-    providerToolCallId: toolCall.providerToolCallId,
-    name: toolCall.name,
-    input: clone(toolCall.args)
+    ...toolCall.providerToolCallId !== void 0 ? { providerToolCallId: toolCall.providerToolCallId } : {},
+    name: toolCall.name ?? toolCall.title ?? "tool",
+    input: clone(toolCall.args !== void 0 ? toolCall.args : toolCall.rawInput !== void 0 ? toolCall.rawInput : {})
   });
   if (!contentBlocks) return toolCalls.map(toolUse);
-  const reserved = new Map(toolCalls.map((toolCall) => [toolCall.providerToolCallId, toolCall]));
+  const reserved = new Map(toolCalls.map((toolCall) => [toolCall.providerToolCallId ?? toolCall.id, toolCall]));
   const parts = [];
   for (const block of contentBlocks) {
     if (block.type === "text") {
       parts.push({ type: "text", text: block.text });
     } else if (block.type === "thinking") {
       parts.push({ type: "thinking", thinking: block.thinking, ...block.signature ? { signature: block.signature } : {} });
-    } else {
+    } else if (block.type === "tool_call") {
       const toolCall = reserved.get(block.id);
       if (!toolCall) continue;
       reserved.delete(block.id);
@@ -10343,6 +11670,9 @@ var SqliteStore = class {
   async cancelRun(lease, input) {
     return this.invoke(lease, (store, current) => store.cancelRun(current, input));
   }
+  async recordToolCall(lease, input) {
+    return this.invoke(lease, (store, current) => store.recordToolCall(current, input));
+  }
   async snapshotRun(lease, runId) {
     return this.invoke(lease, (store, current) => store.snapshotRun(current, runId), false);
   }
@@ -10643,7 +11973,9 @@ var SqliteStore = class {
   }
   getStmtInsertEvent() {
     return this.stmtInsertEvent ??= this.database.prepare(
-      "INSERT INTO run_events (id, run_id, payload_json, created_at) VALUES (?, ?, ?, ?)"
+      `INSERT INTO run_events (id, run_id, payload_json, created_at)
+       VALUES (?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET payload_json = excluded.payload_json`
     );
   }
   getStmtDeleteEvent() {
@@ -10726,7 +12058,7 @@ var SqliteStore = class {
         toolCall.id,
         toolCall.runId,
         toolCall.executionId,
-        toolCall.state,
+        toolCall.status ?? toolCall.state ?? "in_progress",
         JSON.stringify(toolCall)
       );
     }
@@ -11114,6 +12446,9 @@ var SqliteOwnedStore = class {
   cancelRun(input) {
     return this.store.cancelRun(this.lease, input);
   }
+  recordToolCall(input) {
+    return this.store.recordToolCall(this.lease, input);
+  }
   snapshotRun(runId) {
     return this.store.snapshotRun(this.lease, runId);
   }
@@ -11199,10 +12534,10 @@ export {
   isRuntimeError,
   loadExtensionsFromPath as loadExtensions,
   loadPhase,
-  loadPhaseSettings,
   loadPhases,
   loadSkill,
   loadSkills,
+  mergeToolCall,
   parseAgentDefinition,
   parseFrontmatter,
   resolveConfigurationSnapshot