@ljoukov/llm 3.0.4 → 3.0.8

package/dist/index.js

@@ -1586,23 +1586,16 @@ function parseEventBlock(raw) {
 var MIN_MODEL_CONCURRENCY_CAP = 1;
 var MAX_MODEL_CONCURRENCY_CAP = 64;
 var DEFAULT_MODEL_CONCURRENCY_CAP = 3;
-function parsePositiveInteger(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  const normalized = raw.trim();
-  if (!normalized) {
-    return void 0;
-  }
-  if (!/^-?\d+$/u.test(normalized)) {
-    return void 0;
-  }
-  const parsed = Number.parseInt(normalized, 10);
-  if (!Number.isFinite(parsed)) {
-    return void 0;
-  }
-  return parsed;
-}
+var DEFAULT_OPENAI_MODEL_CONCURRENCY_CAP = 12;
+var DEFAULT_GOOGLE_MODEL_CONCURRENCY_CAP = 4;
+var DEFAULT_GOOGLE_PREVIEW_MODEL_CONCURRENCY_CAP = 2;
+var DEFAULT_FIREWORKS_MODEL_CONCURRENCY_CAP = 6;
+var MODEL_CONCURRENCY_PROVIDERS = [
+  "openai",
+  "google",
+  "fireworks"
+];
+var configuredModelConcurrency = normalizeModelConcurrencyConfig({});
 function clampModelConcurrencyCap(value) {
   if (!Number.isFinite(value)) {
     return DEFAULT_MODEL_CONCURRENCY_CAP;
@@ -1616,30 +1609,94 @@ function clampModelConcurrencyCap(value) {
   }
   return rounded;
 }
-function normalizeModelIdForEnv(modelId) {
-  return modelId.trim().replace(/[^A-Za-z0-9]+/gu, "_").replace(/^_+|_+$/gu, "").toUpperCase();
+function normalizeModelIdForConfig(modelId) {
+  return modelId.trim().toLowerCase();
 }
-function resolveModelConcurrencyCap(options) {
-  const env = options.env ?? process.env;
-  const providerPrefix = options.providerEnvPrefix;
-  const defaultCap = clampModelConcurrencyCap(options.defaultCap ?? DEFAULT_MODEL_CONCURRENCY_CAP);
-  const normalizedModelId = options.modelId ? normalizeModelIdForEnv(options.modelId) : "";
-  const candidateKeys = [
-    ...normalizedModelId ? [
-      `${providerPrefix}_MAX_PARALLEL_REQUESTS_MODEL_${normalizedModelId}`,
-      `LLM_MAX_PARALLEL_REQUESTS_MODEL_${normalizedModelId}`
-    ] : [],
-    `${providerPrefix}_MAX_PARALLEL_REQUESTS_PER_MODEL`,
-    "LLM_MAX_PARALLEL_REQUESTS_PER_MODEL"
-  ];
-  for (const key of candidateKeys) {
-    const parsed = parsePositiveInteger(env[key]);
-    if (parsed === void 0) {
+function normalizeCap(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return clampModelConcurrencyCap(value);
+}
+function normalizeModelCapMap(caps) {
+  const normalized = /* @__PURE__ */ new Map();
+  if (!caps) {
+    return normalized;
+  }
+  for (const [modelId, cap] of Object.entries(caps)) {
+    const modelKey = normalizeModelIdForConfig(modelId);
+    if (!modelKey) {
       continue;
     }
-    return clampModelConcurrencyCap(parsed);
+    const normalizedCap = normalizeCap(cap);
+    if (normalizedCap === void 0) {
+      continue;
+    }
+    normalized.set(modelKey, normalizedCap);
+  }
+  return normalized;
+}
+function normalizeModelConcurrencyConfig(config) {
+  const providerCaps = {};
+  const providerModelCaps = {
+    openai: /* @__PURE__ */ new Map(),
+    google: /* @__PURE__ */ new Map(),
+    fireworks: /* @__PURE__ */ new Map()
+  };
+  for (const provider of MODEL_CONCURRENCY_PROVIDERS) {
+    const providerCap = normalizeCap(config.providerCaps?.[provider]);
+    if (providerCap !== void 0) {
+      providerCaps[provider] = providerCap;
+    }
+    providerModelCaps[provider] = new Map(
+      normalizeModelCapMap(config.providerModelCaps?.[provider])
+    );
+  }
+  return {
+    globalCap: normalizeCap(config.globalCap),
+    providerCaps,
+    modelCaps: normalizeModelCapMap(config.modelCaps),
+    providerModelCaps
+  };
+}
+function resolveDefaultProviderCap(provider, modelId) {
+  if (provider === "openai") {
+    return DEFAULT_OPENAI_MODEL_CONCURRENCY_CAP;
+  }
+  if (provider === "google") {
+    return modelId?.includes("preview") ? DEFAULT_GOOGLE_PREVIEW_MODEL_CONCURRENCY_CAP : DEFAULT_GOOGLE_MODEL_CONCURRENCY_CAP;
+  }
+  return DEFAULT_FIREWORKS_MODEL_CONCURRENCY_CAP;
+}
+function configureModelConcurrency(config = {}) {
+  configuredModelConcurrency = normalizeModelConcurrencyConfig(config);
+}
+function resetModelConcurrencyConfig() {
+  configuredModelConcurrency = normalizeModelConcurrencyConfig({});
+}
+function resolveModelConcurrencyCap(options) {
+  const modelId = options.modelId ? normalizeModelIdForConfig(options.modelId) : void 0;
+  const config = options.config ? normalizeModelConcurrencyConfig(options.config) : configuredModelConcurrency;
+  const providerModelCap = modelId ? config.providerModelCaps[options.provider].get(modelId) : void 0;
+  if (providerModelCap !== void 0) {
+    return providerModelCap;
+  }
+  const modelCap = modelId ? config.modelCaps.get(modelId) : void 0;
+  if (modelCap !== void 0) {
+    return modelCap;
   }
-  return defaultCap;
+  const providerCap = config.providerCaps[options.provider];
+  if (providerCap !== void 0) {
+    return providerCap;
+  }
+  if (config.globalCap !== void 0) {
+    return config.globalCap;
+  }
+  const defaultCap = normalizeCap(options.defaultCap);
+  if (defaultCap !== void 0) {
+    return defaultCap;
+  }
+  return resolveDefaultProviderCap(options.provider, modelId);
 }
 
 // src/utils/scheduler.ts
@@ -1748,12 +1805,20 @@ function createCallScheduler(options = {}) {
       release?.();
     }
   }
-  async function attemptWithRetries(fn, attempt) {
+  async function attemptWithRetries(fn, attempt, state) {
     try {
+      const spacingStartedAtMs = Date.now();
       await applyStartSpacing();
+      const callStartedAtMs = Date.now();
+      state.schedulerDelayMs += Math.max(0, callStartedAtMs - spacingStartedAtMs);
+      if (state.startedAtMs === void 0) {
+        state.startedAtMs = callStartedAtMs;
+      }
+      state.attempts = Math.max(state.attempts, attempt);
       return await fn();
     } catch (error) {
       if (isOverloadError2(error)) {
+        state.overloadCount += 1;
         consecutiveSuccesses = 0;
         currentParallelLimit = Math.max(1, Math.ceil(currentParallelLimit / 2));
       }
@@ -1770,9 +1835,10 @@ function createCallScheduler(options = {}) {
       }
       const normalizedDelay = Math.max(0, delay);
       if (normalizedDelay > 0) {
+        state.retryDelayMs += normalizedDelay;
         await sleep(normalizedDelay);
       }
-      return attemptWithRetries(fn, attempt + 1);
+      return attemptWithRetries(fn, attempt + 1, state);
     }
   }
   function drainQueue() {
@@ -1785,11 +1851,22 @@ function createCallScheduler(options = {}) {
       void task();
     }
   }
-  function run(fn) {
+  function run(fn, runOptions = {}) {
     return new Promise((resolve, reject) => {
+      const enqueuedAtMs = Date.now();
       const job = async () => {
+        const dequeuedAtMs = Date.now();
+        const state = {
+          enqueuedAtMs,
+          dequeuedAtMs,
+          schedulerDelayMs: 0,
+          retryDelayMs: 0,
+          attempts: 0,
+          overloadCount: 0
+        };
         try {
-          const result = await attemptWithRetries(fn, 1);
+          const result = await attemptWithRetries(fn, 1, state);
+          state.completedAtMs = Date.now();
           consecutiveSuccesses += 1;
           if (currentParallelLimit < maxParallelRequests && consecutiveSuccesses >= increaseAfterConsecutiveSuccesses) {
             currentParallelLimit += 1;
@@ -1797,8 +1874,26 @@ function createCallScheduler(options = {}) {
           }
           resolve(result);
         } catch (error) {
+          state.completedAtMs = Date.now();
           reject(toError(error));
         } finally {
+          const startedAtMs = state.startedAtMs ?? state.dequeuedAtMs;
+          const completedAtMs = state.completedAtMs ?? Date.now();
+          const metrics = {
+            enqueuedAtMs: state.enqueuedAtMs,
+            dequeuedAtMs: state.dequeuedAtMs,
+            startedAtMs,
+            completedAtMs,
+            queueWaitMs: Math.max(0, state.dequeuedAtMs - state.enqueuedAtMs),
+            schedulerDelayMs: Math.max(0, state.schedulerDelayMs),
+            retryDelayMs: Math.max(0, state.retryDelayMs),
+            attempts: Math.max(1, state.attempts),
+            overloadCount: Math.max(0, state.overloadCount)
+          };
+          try {
+            runOptions.onSettled?.(metrics);
+          } catch {
+          }
           activeCount -= 1;
           queueMicrotask(drainQueue);
         }
@@ -1895,7 +1990,7 @@ function getSchedulerForModel(modelId) {
   }
   const created = createCallScheduler({
     maxParallelRequests: resolveModelConcurrencyCap({
-      providerEnvPrefix: "FIREWORKS",
+      provider: "fireworks",
       modelId: normalizedModelId
     }),
     minIntervalBetweenStartMs: 200,
@@ -1904,8 +1999,8 @@ function getSchedulerForModel(modelId) {
   schedulerByModel.set(schedulerKey, created);
   return created;
 }
-async function runFireworksCall(fn, modelId) {
-  return getSchedulerForModel(modelId).run(async () => fn(getFireworksClient()));
+async function runFireworksCall(fn, modelId, runOptions) {
+  return getSchedulerForModel(modelId).run(async () => fn(getFireworksClient()), runOptions);
 }
 
 // src/fireworks/models.ts
@@ -2271,7 +2366,7 @@ function getSchedulerForModel2(modelId) {
   }
   const created = createCallScheduler({
     maxParallelRequests: resolveModelConcurrencyCap({
-      providerEnvPrefix: "GOOGLE",
+      provider: "google",
       modelId: normalizedModelId
     }),
     minIntervalBetweenStartMs: 200,
@@ -2291,8 +2386,8 @@ function getSchedulerForModel2(modelId) {
   schedulerByModel2.set(schedulerKey, created);
   return created;
 }
-async function runGeminiCall(fn, modelId) {
-  return getSchedulerForModel2(modelId).run(async () => fn(await getGeminiClient()));
+async function runGeminiCall(fn, modelId, runOptions) {
+  return getSchedulerForModel2(modelId).run(async () => fn(await getGeminiClient()), runOptions);
 }
 
 // src/openai/client.ts
@@ -2464,7 +2559,7 @@ function getSchedulerForModel3(modelId) {
   }
   const created = createCallScheduler({
     maxParallelRequests: resolveModelConcurrencyCap({
-      providerEnvPrefix: "OPENAI",
+      provider: "openai",
       modelId: normalizedModelId
     }),
     minIntervalBetweenStartMs: 200,
@@ -2473,8 +2568,8 @@ function getSchedulerForModel3(modelId) {
   schedulerByModel3.set(schedulerKey, created);
   return created;
 }
-async function runOpenAiCall(fn, modelId) {
-  return getSchedulerForModel3(modelId).run(async () => fn(getOpenAiClient()));
+async function runOpenAiCall(fn, modelId, runOptions) {
+  return getSchedulerForModel3(modelId).run(async () => fn(getOpenAiClient()), runOptions);
 }
 
 // src/openai/models.ts
@@ -2928,9 +3023,9 @@ function isRetryableChatGptTransportError(error) {
     return false;
   }
   const message = error.message.toLowerCase();
-  return message === "terminated" || message.includes("socket hang up") || message.includes("fetch failed") || message.includes("network");
+  return message === "terminated" || message.includes("socket hang up") || message.includes("fetch failed") || message.includes("network") || message.includes("responses websocket");
 }
-async function collectChatGptCodexResponseWithRetry(options, maxAttempts = 2) {
+async function collectChatGptCodexResponseWithRetry(options, maxAttempts = 3) {
   let attempt = 1;
   while (true) {
     try {
@@ -3835,77 +3930,153 @@ function buildToolErrorOutput(message, issues) {
   }
   return output;
 }
+var SUBAGENT_WAIT_TOOL_NAME = "wait";
+function toIsoTimestamp(ms) {
+  return new Date(ms).toISOString();
+}
+function toToolResultDuration(result) {
+  return typeof result.durationMs === "number" && Number.isFinite(result.durationMs) ? Math.max(0, result.durationMs) : 0;
+}
+function schedulerMetricsOrDefault(metrics) {
+  if (!metrics) {
+    return {
+      queueWaitMs: 0,
+      schedulerDelayMs: 0,
+      providerRetryDelayMs: 0,
+      providerAttempts: 1
+    };
+  }
+  return {
+    queueWaitMs: Math.max(0, metrics.queueWaitMs),
+    schedulerDelayMs: Math.max(0, metrics.schedulerDelayMs),
+    providerRetryDelayMs: Math.max(0, metrics.retryDelayMs),
+    providerAttempts: Math.max(1, metrics.attempts),
+    modelCallStartedAtMs: metrics.startedAtMs
+  };
+}
+function buildStepTiming(params) {
+  const scheduler = schedulerMetricsOrDefault(params.schedulerMetrics);
+  const modelCallStartedAtMs = scheduler.modelCallStartedAtMs ?? params.stepStartedAtMs;
+  const firstModelEventAtMs = params.firstModelEventAtMs;
+  const effectiveFirstEventAtMs = firstModelEventAtMs !== void 0 ? Math.max(modelCallStartedAtMs, firstModelEventAtMs) : params.modelCompletedAtMs;
+  const connectionSetupMs = Math.max(0, effectiveFirstEventAtMs - modelCallStartedAtMs);
+  const activeGenerationMs = Math.max(0, params.modelCompletedAtMs - effectiveFirstEventAtMs);
+  return {
+    startedAt: toIsoTimestamp(params.stepStartedAtMs),
+    completedAt: toIsoTimestamp(params.stepCompletedAtMs),
+    totalMs: Math.max(0, params.stepCompletedAtMs - params.stepStartedAtMs),
+    queueWaitMs: scheduler.queueWaitMs,
+    connectionSetupMs,
+    activeGenerationMs,
+    toolExecutionMs: Math.max(0, params.toolExecutionMs),
+    waitToolMs: Math.max(0, params.waitToolMs),
+    schedulerDelayMs: scheduler.schedulerDelayMs,
+    providerRetryDelayMs: scheduler.providerRetryDelayMs,
+    providerAttempts: scheduler.providerAttempts
+  };
+}
+function extractSpawnStartupMetrics(outputPayload) {
+  if (!outputPayload || typeof outputPayload !== "object") {
+    return void 0;
+  }
+  const outputRecord = outputPayload;
+  const notification = typeof outputRecord.notification === "string" ? outputRecord.notification : "";
+  if (notification !== "spawned") {
+    return void 0;
+  }
+  const agent = outputRecord.agent;
+  if (!agent || typeof agent !== "object") {
+    return void 0;
+  }
+  const agentRecord = agent;
+  const startupLatencyMs = agentRecord.spawn_startup_latency_ms;
+  if (typeof startupLatencyMs !== "number" || !Number.isFinite(startupLatencyMs)) {
+    return void 0;
+  }
+  return {
+    spawnStartupLatencyMs: Math.max(0, startupLatencyMs)
+  };
+}
 async function executeToolCall(params) {
   const { callKind, toolName, tool: tool2, rawInput, parseError } = params;
-  if (!tool2) {
-    const message = `Unknown tool: ${toolName}`;
+  const startedAtMs = Date.now();
+  const finalize = (base, outputPayload, metrics) => {
+    const completedAtMs = Date.now();
     return {
-      result: { toolName, input: rawInput, output: { error: message }, error: message },
-      outputPayload: buildToolErrorOutput(message)
+      result: {
+        ...base,
+        startedAt: toIsoTimestamp(startedAtMs),
+        completedAt: toIsoTimestamp(completedAtMs),
+        durationMs: Math.max(0, completedAtMs - startedAtMs),
+        ...metrics ? { metrics } : {}
+      },
+      outputPayload
     };
+  };
+  if (!tool2) {
+    const message = `Unknown tool: ${toolName}`;
+    const outputPayload = buildToolErrorOutput(message);
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
+      outputPayload
+    );
   }
   if (callKind === "custom") {
     if (!isCustomTool(tool2)) {
       const message = `Tool ${toolName} was called as custom_tool_call but is declared as function.`;
       const outputPayload = buildToolErrorOutput(message);
-      return {
-        result: { toolName, input: rawInput, output: outputPayload, error: message },
+      return finalize(
+        { toolName, input: rawInput, output: outputPayload, error: message },
         outputPayload
-      };
+      );
     }
     const input = typeof rawInput === "string" ? rawInput : String(rawInput ?? "");
     try {
       const output = await tool2.execute(input);
-      return {
-        result: { toolName, input, output },
-        outputPayload: output
-      };
+      const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(output) : void 0;
+      return finalize({ toolName, input, output }, output, metrics);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
-      return {
-        result: { toolName, input, output: outputPayload, error: message },
-        outputPayload
-      };
+      return finalize({ toolName, input, output: outputPayload, error: message }, outputPayload);
     }
   }
   if (isCustomTool(tool2)) {
     const message = `Tool ${toolName} was called as function_call but is declared as custom.`;
     const outputPayload = buildToolErrorOutput(message);
-    return {
-      result: { toolName, input: rawInput, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
   if (parseError) {
     const message = `Invalid JSON for tool ${toolName}: ${parseError}`;
-    return {
-      result: { toolName, input: rawInput, output: { error: message }, error: message },
-      outputPayload: buildToolErrorOutput(message)
-    };
+    const outputPayload = buildToolErrorOutput(message);
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
+      outputPayload
+    );
   }
   const parsed = tool2.inputSchema.safeParse(rawInput);
   if (!parsed.success) {
     const message = `Invalid tool arguments for ${toolName}: ${formatZodIssues(parsed.error.issues)}`;
     const outputPayload = buildToolErrorOutput(message, parsed.error.issues);
-    return {
-      result: { toolName, input: rawInput, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
   try {
     const output = await tool2.execute(parsed.data);
-    return {
-      result: { toolName, input: parsed.data, output },
-      outputPayload: output
-    };
+    const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(output) : void 0;
+    return finalize({ toolName, input: parsed.data, output }, output, metrics);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
-    return {
-      result: { toolName, input: parsed.data, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: parsed.data, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
 }
 function buildToolLogId(turn, toolIndex) {
@@ -4628,6 +4799,102 @@ var DEFAULT_TOOL_LOOP_MAX_STEPS = 8;
 function resolveToolLoopContents(input) {
   return resolveTextContents(input);
 }
+var toolLoopSteeringInternals = /* @__PURE__ */ new WeakMap();
+function createToolLoopSteeringChannel() {
+  const pending = [];
+  let closed = false;
+  const channel = {
+    append: (input) => {
+      if (closed) {
+        return { accepted: false, queuedCount: pending.length };
+      }
+      const normalized = normalizeToolLoopSteeringInput(input);
+      if (normalized.length === 0) {
+        return { accepted: false, queuedCount: pending.length };
+      }
+      pending.push(...normalized);
+      return { accepted: true, queuedCount: pending.length };
+    },
+    steer: (input) => channel.append(input),
+    pendingCount: () => pending.length,
+    close: () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      pending.length = 0;
+    }
+  };
+  const internalState = {
+    drainPendingContents: () => {
+      if (pending.length === 0) {
+        return [];
+      }
+      return pending.splice(0, pending.length);
+    },
+    close: channel.close
+  };
+  toolLoopSteeringInternals.set(channel, internalState);
+  return channel;
+}
+function resolveToolLoopSteeringInternal(steering) {
+  if (!steering) {
+    return void 0;
+  }
+  const internal = toolLoopSteeringInternals.get(steering);
+  if (!internal) {
+    throw new Error(
+      "Invalid tool loop steering channel. Use createToolLoopSteeringChannel() to construct one."
+    );
+  }
+  return internal;
+}
+function normalizeToolLoopSteeringInput(input) {
+  const messages = typeof input === "string" ? [{ role: "user", content: input }] : Array.isArray(input) ? input : [input];
+  const normalized = [];
+  for (const message of messages) {
+    const role = message.role ?? "user";
+    if (role !== "user") {
+      throw new Error("Tool loop steering only accepts role='user' messages.");
+    }
+    if (typeof message.content === "string") {
+      if (message.content.length === 0) {
+        continue;
+      }
+      normalized.push({
+        role: "user",
+        parts: [{ type: "text", text: message.content }]
+      });
+      continue;
+    }
+    if (!Array.isArray(message.content) || message.content.length === 0) {
+      continue;
+    }
+    const parts = [];
+    for (const part of message.content) {
+      if (part.type === "text") {
+        parts.push({ type: "text", text: part.text });
+      } else {
+        parts.push({ type: "inlineData", data: part.data, mimeType: part.mimeType });
+      }
+    }
+    if (parts.length > 0) {
+      normalized.push({ role: "user", parts });
+    }
+  }
+  return normalized;
+}
+function toChatGptAssistantMessage(text) {
+  if (!text) {
+    return void 0;
+  }
+  return {
+    type: "message",
+    role: "assistant",
+    status: "completed",
+    content: [{ type: "output_text", text }]
+  };
+}
 function isCustomTool(toolDef) {
   return toolDef.type === "custom";
 }
@@ -4746,411 +5013,908 @@ async function runToolLoop(request) {
   }
   const maxSteps = Math.max(1, Math.floor(request.maxSteps ?? DEFAULT_TOOL_LOOP_MAX_STEPS));
   const providerInfo = resolveProvider(request.model);
+  const steeringInternal = resolveToolLoopSteeringInternal(request.steering);
   const steps = [];
   let totalCostUsd = 0;
   let finalText = "";
   let finalThoughts = "";
-  if (providerInfo.provider === "openai") {
-    const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
-    const openAiNativeTools = toOpenAiTools(request.modelTools);
-    const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
-    const reasoningEffort = resolveOpenAiReasoningEffort(
-      providerInfo.model,
-      request.openAiReasoningEffort
-    );
-    const textConfig = {
-      format: { type: "text" },
-      verbosity: resolveOpenAiVerbosity(providerInfo.model)
-    };
-    const reasoning = {
-      effort: toOpenAiReasoningEffort(reasoningEffort),
-      summary: "detailed"
-    };
-    let previousResponseId;
-    let input = toOpenAiInput(contents);
-    for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
-      const turn = stepIndex + 1;
-      const abortController = new AbortController();
-      if (request.signal) {
-        if (request.signal.aborted) {
-          abortController.abort(request.signal.reason);
-        } else {
-          request.signal.addEventListener(
-            "abort",
-            () => abortController.abort(request.signal?.reason),
-            { once: true }
-          );
-        }
-      }
-      const onEvent = request.onEvent;
-      let modelVersion = request.model;
-      let usageTokens;
-      const emitEvent = (ev) => {
-        onEvent?.(ev);
+  try {
+    if (providerInfo.provider === "openai") {
+      const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
+      const openAiNativeTools = toOpenAiTools(request.modelTools);
+      const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
+      const reasoningEffort = resolveOpenAiReasoningEffort(
+        providerInfo.model,
+        request.openAiReasoningEffort
+      );
+      const textConfig = {
+        format: { type: "text" },
+        verbosity: resolveOpenAiVerbosity(providerInfo.model)
       };
-      const finalResponse = await runOpenAiCall(async (client) => {
-        const stream = client.responses.stream(
-          {
-            model: providerInfo.model,
-            input,
-            ...previousResponseId ? { previous_response_id: previousResponseId } : {},
-            ...openAiTools.length > 0 ? { tools: openAiTools } : {},
-            ...openAiTools.length > 0 ? { parallel_tool_calls: true } : {},
-            reasoning,
-            text: textConfig,
-            include: ["reasoning.encrypted_content"]
+      const reasoning = {
+        effort: toOpenAiReasoningEffort(reasoningEffort),
+        summary: "detailed"
+      };
+      let previousResponseId;
+      let input = toOpenAiInput(contents);
+      for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+        const turn = stepIndex + 1;
+        const stepStartedAtMs = Date.now();
+        let firstModelEventAtMs;
+        let schedulerMetrics;
+        const abortController = new AbortController();
+        if (request.signal) {
+          if (request.signal.aborted) {
+            abortController.abort(request.signal.reason);
+          } else {
+            request.signal.addEventListener(
+              "abort",
+              () => abortController.abort(request.signal?.reason),
+              { once: true }
+            );
+          }
+        }
+        const onEvent = request.onEvent;
+        let modelVersion = request.model;
+        let usageTokens;
+        let thoughtDeltaEmitted = false;
+        const emitEvent = (ev) => {
+          onEvent?.(ev);
+        };
+        const markFirstModelEvent = () => {
+          if (firstModelEventAtMs === void 0) {
+            firstModelEventAtMs = Date.now();
+          }
+        };
+        const finalResponse = await runOpenAiCall(
+          async (client) => {
+            const stream = client.responses.stream(
+              {
+                model: providerInfo.model,
+                input,
+                ...previousResponseId ? { previous_response_id: previousResponseId } : {},
+                ...openAiTools.length > 0 ? { tools: openAiTools } : {},
+                ...openAiTools.length > 0 ? { parallel_tool_calls: true } : {},
+                reasoning,
+                text: textConfig,
+                include: ["reasoning.encrypted_content"]
+              },
+              { signal: abortController.signal }
+            );
+            for await (const event of stream) {
+              markFirstModelEvent();
+              switch (event.type) {
+                case "response.output_text.delta":
+                  emitEvent({
+                    type: "delta",
+                    channel: "response",
+                    text: typeof event.delta === "string" ? event.delta : ""
+                  });
+                  break;
+                case "response.reasoning_summary_text.delta":
+                  thoughtDeltaEmitted = true;
+                  emitEvent({
+                    type: "delta",
+                    channel: "thought",
+                    text: typeof event.delta === "string" ? event.delta : ""
+                  });
+                  break;
+                case "response.refusal.delta":
+                  emitEvent({ type: "blocked" });
+                  break;
+                default:
+                  break;
+              }
+            }
+            return await stream.finalResponse();
           },
-          { signal: abortController.signal }
+          providerInfo.model,
+          {
+            onSettled: (metrics) => {
+              schedulerMetrics = metrics;
+            }
+          }
         );
-        for await (const event of stream) {
-          switch (event.type) {
-            case "response.output_text.delta":
-              emitEvent({
-                type: "delta",
-                channel: "response",
-                text: typeof event.delta === "string" ? event.delta : ""
-              });
-              break;
-            case "response.reasoning_summary_text.delta":
-              emitEvent({
-                type: "delta",
-                channel: "thought",
-                text: typeof event.delta === "string" ? event.delta : ""
-              });
-              break;
-            case "response.refusal.delta":
-              emitEvent({ type: "blocked" });
-              break;
-            default:
-              break;
+        modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
+        emitEvent({ type: "model", modelVersion });
+        if (finalResponse.error) {
+          const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
+          throw new Error(message);
+        }
+        usageTokens = extractOpenAiUsageTokens(finalResponse.usage);
+        const responseText = extractOpenAiResponseParts(finalResponse).parts.filter((p) => p.type === "text" && p.thought !== true).map((p) => p.text).join("").trim();
+        const reasoningSummary = extractOpenAiReasoningSummary(finalResponse).trim();
+        if (!thoughtDeltaEmitted && reasoningSummary.length > 0) {
+          emitEvent({ type: "delta", channel: "thought", text: reasoningSummary });
+        }
+        const modelCompletedAtMs = Date.now();
+        const stepCostUsd = estimateCallCostUsd({
+          modelId: modelVersion,
+          tokens: usageTokens,
+          responseImages: 0
+        });
+        totalCostUsd += stepCostUsd;
+        if (usageTokens) {
+          emitEvent({ type: "usage", usage: usageTokens, costUsd: stepCostUsd, modelVersion });
+        }
+        const responseToolCalls = extractOpenAiToolCalls(finalResponse.output);
+        const stepToolCalls = [];
+        if (responseToolCalls.length === 0) {
+          const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
+          const steeringItems2 = steeringInput2.length > 0 ? toOpenAiInput(steeringInput2) : [];
+          finalText = responseText;
+          finalThoughts = reasoningSummary;
+          const stepCompletedAtMs2 = Date.now();
+          const timing2 = buildStepTiming({
+            stepStartedAtMs,
+            stepCompletedAtMs: stepCompletedAtMs2,
+            modelCompletedAtMs,
+            firstModelEventAtMs,
+            schedulerMetrics,
+            toolExecutionMs: 0,
+            waitToolMs: 0
+          });
+          steps.push({
+            step: steps.length + 1,
+            modelVersion,
+            text: responseText || void 0,
+            thoughts: reasoningSummary || void 0,
+            toolCalls: [],
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            timing: timing2
+          });
+          if (steeringItems2.length === 0) {
+            return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
           }
+          previousResponseId = finalResponse.id;
+          input = steeringItems2;
+          continue;
         }
-        return await stream.finalResponse();
-      }, providerInfo.model);
-      modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
-      emitEvent({ type: "model", modelVersion });
-      if (finalResponse.error) {
-        const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
-        throw new Error(message);
-      }
-      usageTokens = extractOpenAiUsageTokens(finalResponse.usage);
-      const responseText = extractOpenAiResponseParts(finalResponse).parts.filter((p) => p.type === "text" && p.thought !== true).map((p) => p.text).join("").trim();
-      const reasoningSummary = extractOpenAiReasoningSummary(finalResponse).trim();
-      const stepCostUsd = estimateCallCostUsd({
-        modelId: modelVersion,
-        tokens: usageTokens,
-        responseImages: 0
-      });
-      totalCostUsd += stepCostUsd;
-      if (usageTokens) {
-        emitEvent({ type: "usage", usage: usageTokens, costUsd: stepCostUsd, modelVersion });
-      }
-      const responseToolCalls = extractOpenAiToolCalls(finalResponse.output);
-      const stepToolCalls = [];
-      if (responseToolCalls.length === 0) {
-        finalText = responseText;
-        finalThoughts = reasoningSummary;
+        const callInputs = responseToolCalls.map((call, index) => {
+          const toolIndex = index + 1;
+          const toolId = buildToolLogId(turn, toolIndex);
+          const toolName = call.name;
+          if (call.kind === "custom") {
+            return {
+              call,
+              toolName,
+              value: call.input,
+              parseError: void 0,
+              toolId,
+              turn,
+              toolIndex
+            };
+          }
+          const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
+          return { call, toolName, value, parseError, toolId, turn, toolIndex };
+        });
+        for (const entry of callInputs) {
+          emitEvent({
+            type: "tool_call",
+            phase: "started",
+            turn: entry.turn,
+            toolIndex: entry.toolIndex,
+            toolName: entry.toolName,
+            toolId: entry.toolId,
+            callKind: entry.call.kind,
+            callId: entry.call.call_id,
+            input: entry.value
+          });
+        }
+        const callResults = await Promise.all(
+          callInputs.map(async (entry) => {
+            return await toolCallContextStorage.run(
+              {
+                toolName: entry.toolName,
+                toolId: entry.toolId,
+                turn: entry.turn,
+                toolIndex: entry.toolIndex
+              },
+              async () => {
+                const { result, outputPayload } = await executeToolCall({
+                  callKind: entry.call.kind,
+                  toolName: entry.toolName,
+                  tool: request.tools[entry.toolName],
+                  rawInput: entry.value,
+                  parseError: entry.parseError
+                });
+                return { entry, result, outputPayload };
+              }
+            );
+          })
+        );
+        const toolOutputs = [];
+        let toolExecutionMs = 0;
+        let waitToolMs = 0;
+        for (const { entry, result, outputPayload } of callResults) {
+          stepToolCalls.push({ ...result, callId: entry.call.call_id });
+          const callDurationMs = toToolResultDuration(result);
+          toolExecutionMs += callDurationMs;
+          if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
+            waitToolMs += callDurationMs;
+          }
+          emitEvent({
+            type: "tool_call",
+            phase: "completed",
+            turn: entry.turn,
+            toolIndex: entry.toolIndex,
+            toolName: entry.toolName,
+            toolId: entry.toolId,
+            callKind: entry.call.kind,
+            callId: entry.call.call_id,
+            input: entry.value,
+            output: result.output,
+            error: result.error,
+            durationMs: result.durationMs
+          });
+          if (entry.call.kind === "custom") {
+            toolOutputs.push({
+              type: "custom_tool_call_output",
+              call_id: entry.call.call_id,
+              output: mergeToolOutput(outputPayload)
+            });
+          } else {
+            toolOutputs.push({
+              type: "function_call_output",
+              call_id: entry.call.call_id,
+              output: mergeToolOutput(outputPayload)
+            });
+          }
+        }
+        const stepCompletedAtMs = Date.now();
+        const timing = buildStepTiming({
+          stepStartedAtMs,
+          stepCompletedAtMs,
+          modelCompletedAtMs,
+          firstModelEventAtMs,
+          schedulerMetrics,
+          toolExecutionMs,
+          waitToolMs
+        });
         steps.push({
           step: steps.length + 1,
           modelVersion,
           text: responseText || void 0,
           thoughts: reasoningSummary || void 0,
-          toolCalls: [],
+          toolCalls: stepToolCalls,
           usage: usageTokens,
-          costUsd: stepCostUsd
+          costUsd: stepCostUsd,
+          timing
         });
-        return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
-      }
-      const callInputs = responseToolCalls.map((call, index) => {
-        const toolIndex = index + 1;
-        const toolId = buildToolLogId(turn, toolIndex);
-        const toolName = call.name;
-        if (call.kind === "custom") {
-          return {
-            call,
-            toolName,
-            value: call.input,
-            parseError: void 0,
-            toolId,
-            turn,
-            toolIndex
-          };
-        }
-        const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
-        return { call, toolName, value, parseError, toolId, turn, toolIndex };
-      });
-      const callResults = await Promise.all(
-        callInputs.map(async (entry) => {
-          return await toolCallContextStorage.run(
-            {
-              toolName: entry.toolName,
-              toolId: entry.toolId,
-              turn: entry.turn,
-              toolIndex: entry.toolIndex
+        const steeringInput = steeringInternal?.drainPendingContents() ?? [];
+        const steeringItems = steeringInput.length > 0 ? toOpenAiInput(steeringInput) : [];
+        previousResponseId = finalResponse.id;
+        input = steeringItems.length > 0 ? toolOutputs.concat(steeringItems) : toolOutputs;
+      }
+      throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
+    }
+    if (providerInfo.provider === "chatgpt") {
+      const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
+      const openAiNativeTools = toOpenAiTools(request.modelTools);
+      const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
+      const reasoningEffort = resolveOpenAiReasoningEffort(
+        request.model,
+        request.openAiReasoningEffort
+      );
+      const toolLoopInput = toChatGptInput(contents);
+      const conversationId = `tool-loop-${randomBytes(8).toString("hex")}`;
+      const promptCacheKey = conversationId;
+      let input = [...toolLoopInput.input];
+      for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+        const turn = stepIndex + 1;
+        const stepStartedAtMs = Date.now();
+        let firstModelEventAtMs;
+        let thoughtDeltaEmitted = false;
+        const markFirstModelEvent = () => {
+          if (firstModelEventAtMs === void 0) {
+            firstModelEventAtMs = Date.now();
+          }
+        };
+        const response = await collectChatGptCodexResponseWithRetry({
+          sessionId: conversationId,
+          request: {
+            model: providerInfo.model,
+            store: false,
+            stream: true,
+            instructions: toolLoopInput.instructions ?? "You are a helpful assistant.",
+            input,
+            prompt_cache_key: promptCacheKey,
+            include: ["reasoning.encrypted_content"],
+            tools: openAiTools,
+            tool_choice: "auto",
+            parallel_tool_calls: true,
+            reasoning: {
+              effort: toOpenAiReasoningEffort(reasoningEffort),
+              summary: "detailed"
             },
-            async () => {
-              const { result, outputPayload } = await executeToolCall({
-                callKind: entry.call.kind,
-                toolName: entry.toolName,
-                tool: request.tools[entry.toolName],
-                rawInput: entry.value,
-                parseError: entry.parseError
-              });
-              return { entry, result, outputPayload };
+            text: { verbosity: resolveOpenAiVerbosity(request.model) }
+          },
+          signal: request.signal,
+          onDelta: (delta) => {
+            if (delta.thoughtDelta) {
+              markFirstModelEvent();
+              thoughtDeltaEmitted = true;
+              request.onEvent?.({ type: "delta", channel: "thought", text: delta.thoughtDelta });
             }
-          );
-        })
-      );
-      const toolOutputs = [];
-      for (const { entry, result, outputPayload } of callResults) {
-        stepToolCalls.push({ ...result, callId: entry.call.call_id });
-        if (entry.call.kind === "custom") {
-          toolOutputs.push({
-            type: "custom_tool_call_output",
-            call_id: entry.call.call_id,
-            output: mergeToolOutput(outputPayload)
-          });
-        } else {
-          toolOutputs.push({
-            type: "function_call_output",
-            call_id: entry.call.call_id,
-            output: mergeToolOutput(outputPayload)
+            if (delta.textDelta) {
+              markFirstModelEvent();
+              request.onEvent?.({ type: "delta", channel: "response", text: delta.textDelta });
+            }
+          }
+        });
+        const modelCompletedAtMs = Date.now();
+        const modelVersion = response.model ? `chatgpt-${response.model}` : request.model;
+        const usageTokens = extractChatGptUsageTokens(response.usage);
+        const stepCostUsd = estimateCallCostUsd({
+          modelId: modelVersion,
+          tokens: usageTokens,
+          responseImages: 0
+        });
+        totalCostUsd += stepCostUsd;
+        const responseText = (response.text ?? "").trim();
+        const reasoningSummaryText = (response.reasoningSummaryText ?? "").trim();
+        if (!thoughtDeltaEmitted && reasoningSummaryText.length > 0) {
+          request.onEvent?.({ type: "delta", channel: "thought", text: reasoningSummaryText });
+        }
+        const responseToolCalls = response.toolCalls ?? [];
+        if (responseToolCalls.length === 0) {
+          const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
+          const steeringItems2 = steeringInput2.length > 0 ? toChatGptInput(steeringInput2).input : [];
+          finalText = responseText;
+          finalThoughts = reasoningSummaryText;
+          const stepCompletedAtMs2 = Date.now();
+          const timing2 = buildStepTiming({
+            stepStartedAtMs,
+            stepCompletedAtMs: stepCompletedAtMs2,
+            modelCompletedAtMs,
+            firstModelEventAtMs,
+            toolExecutionMs: 0,
+            waitToolMs: 0
           });
+          steps.push({
+            step: steps.length + 1,
+            modelVersion,
+            text: responseText || void 0,
+            thoughts: reasoningSummaryText || void 0,
+            toolCalls: [],
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            timing: timing2
+          });
+          if (steeringItems2.length === 0) {
+            return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+          }
+          const assistantItem = toChatGptAssistantMessage(responseText);
+          input = assistantItem ? input.concat(assistantItem, steeringItems2) : input.concat(steeringItems2);
+          continue;
         }
-      }
-      steps.push({
-        step: steps.length + 1,
-        modelVersion,
-        text: responseText || void 0,
-        thoughts: reasoningSummary || void 0,
-        toolCalls: stepToolCalls,
-        usage: usageTokens,
-        costUsd: stepCostUsd
-      });
-      previousResponseId = finalResponse.id;
-      input = toolOutputs;
-    }
-    throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
-  }
-  if (providerInfo.provider === "chatgpt") {
-    const openAiAgentTools = buildOpenAiToolsFromToolSet(request.tools);
-    const openAiNativeTools = toOpenAiTools(request.modelTools);
-    const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
-    const reasoningEffort = resolveOpenAiReasoningEffort(
-      request.model,
-      request.openAiReasoningEffort
-    );
-    const toolLoopInput = toChatGptInput(contents);
-    const conversationId = `tool-loop-${randomBytes(8).toString("hex")}`;
-    const promptCacheKey = conversationId;
-    let input = [...toolLoopInput.input];
-    for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
-      const turn = stepIndex + 1;
-      const response = await collectChatGptCodexResponseWithRetry({
-        sessionId: conversationId,
-        request: {
-          model: providerInfo.model,
-          store: false,
-          stream: true,
-          instructions: toolLoopInput.instructions ?? "You are a helpful assistant.",
-          input,
-          prompt_cache_key: promptCacheKey,
-          include: ["reasoning.encrypted_content"],
-          tools: openAiTools,
-          tool_choice: "auto",
-          parallel_tool_calls: true,
-          reasoning: {
-            effort: toOpenAiReasoningEffort(reasoningEffort),
-            summary: "detailed"
-          },
-          text: { verbosity: resolveOpenAiVerbosity(request.model) }
-        },
-        signal: request.signal,
-        onDelta: (delta) => {
-          if (delta.thoughtDelta) {
-            request.onEvent?.({ type: "delta", channel: "thought", text: delta.thoughtDelta });
+        const toolCalls = [];
+        const toolOutputs = [];
+        const callInputs = responseToolCalls.map((call, index) => {
+          const toolIndex = index + 1;
+          const toolId = buildToolLogId(turn, toolIndex);
+          const toolName = call.name;
+          const { value, error: parseError } = call.kind === "custom" ? { value: call.input, error: void 0 } : parseOpenAiToolArguments(call.arguments);
+          const ids = normalizeChatGptToolIds({
+            callKind: call.kind,
+            callId: call.callId,
+            itemId: call.id
+          });
+          return { call, toolName, value, parseError, ids, toolId, turn, toolIndex };
+        });
+        for (const entry of callInputs) {
+          request.onEvent?.({
+            type: "tool_call",
+            phase: "started",
+            turn: entry.turn,
+            toolIndex: entry.toolIndex,
+            toolName: entry.toolName,
+            toolId: entry.toolId,
+            callKind: entry.call.kind,
+            callId: entry.ids.callId,
+            input: entry.value
+          });
+        }
+        const callResults = await Promise.all(
+          callInputs.map(async (entry) => {
+            return await toolCallContextStorage.run(
+              {
+                toolName: entry.toolName,
+                toolId: entry.toolId,
+                turn: entry.turn,
+                toolIndex: entry.toolIndex
+              },
+              async () => {
+                const { result, outputPayload } = await executeToolCall({
+                  callKind: entry.call.kind,
+                  toolName: entry.toolName,
+                  tool: request.tools[entry.toolName],
+                  rawInput: entry.value,
+                  parseError: entry.parseError
+                });
+                return { entry, result, outputPayload };
+              }
+            );
+          })
+        );
+        let toolExecutionMs = 0;
+        let waitToolMs = 0;
+        for (const { entry, result, outputPayload } of callResults) {
+          toolCalls.push({ ...result, callId: entry.ids.callId });
+          const callDurationMs = toToolResultDuration(result);
+          toolExecutionMs += callDurationMs;
+          if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
+            waitToolMs += callDurationMs;
           }
-          if (delta.textDelta) {
-            request.onEvent?.({ type: "delta", channel: "response", text: delta.textDelta });
+          request.onEvent?.({
+            type: "tool_call",
+            phase: "completed",
+            turn: entry.turn,
+            toolIndex: entry.toolIndex,
+            toolName: entry.toolName,
+            toolId: entry.toolId,
+            callKind: entry.call.kind,
+            callId: entry.ids.callId,
+            input: entry.value,
+            output: result.output,
+            error: result.error,
+            durationMs: result.durationMs
+          });
+          if (entry.call.kind === "custom") {
+            toolOutputs.push({
+              type: "custom_tool_call",
+              id: entry.ids.itemId,
+              call_id: entry.ids.callId,
+              name: entry.toolName,
+              input: entry.call.input,
+              status: "completed"
+            });
+            toolOutputs.push({
+              type: "custom_tool_call_output",
+              call_id: entry.ids.callId,
+              output: mergeToolOutput(outputPayload)
+            });
+          } else {
+            toolOutputs.push({
+              type: "function_call",
+              id: entry.ids.itemId,
+              call_id: entry.ids.callId,
+              name: entry.toolName,
+              arguments: entry.call.arguments,
+              status: "completed"
+            });
+            toolOutputs.push({
+              type: "function_call_output",
+              call_id: entry.ids.callId,
+              output: mergeToolOutput(outputPayload)
+            });
           }
         }
-      });
-      const modelVersion = response.model ? `chatgpt-${response.model}` : request.model;
-      const usageTokens = extractChatGptUsageTokens(response.usage);
-      const stepCostUsd = estimateCallCostUsd({
-        modelId: modelVersion,
-        tokens: usageTokens,
-        responseImages: 0
-      });
-      totalCostUsd += stepCostUsd;
-      const responseText = (response.text ?? "").trim();
-      const reasoningSummaryText = (response.reasoningSummaryText ?? "").trim();
-      const responseToolCalls = response.toolCalls ?? [];
-      if (responseToolCalls.length === 0) {
-        finalText = responseText;
-        finalThoughts = reasoningSummaryText;
+        const stepCompletedAtMs = Date.now();
+        const timing = buildStepTiming({
+          stepStartedAtMs,
+          stepCompletedAtMs,
+          modelCompletedAtMs,
+          firstModelEventAtMs,
+          toolExecutionMs,
+          waitToolMs
+        });
         steps.push({
           step: steps.length + 1,
           modelVersion,
           text: responseText || void 0,
           thoughts: reasoningSummaryText || void 0,
-          toolCalls: [],
+          toolCalls,
           usage: usageTokens,
-          costUsd: stepCostUsd
+          costUsd: stepCostUsd,
+          timing
         });
-        return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+        const steeringInput = steeringInternal?.drainPendingContents() ?? [];
+        const steeringItems = steeringInput.length > 0 ? toChatGptInput(steeringInput).input : [];
+        input = steeringItems.length > 0 ? input.concat(toolOutputs, steeringItems) : input.concat(toolOutputs);
       }
-      const toolCalls = [];
-      const toolOutputs = [];
-      const callInputs = responseToolCalls.map((call, index) => {
-        const toolIndex = index + 1;
-        const toolId = buildToolLogId(turn, toolIndex);
-        const toolName = call.name;
-        const { value, error: parseError } = call.kind === "custom" ? { value: call.input, error: void 0 } : parseOpenAiToolArguments(call.arguments);
-        const ids = normalizeChatGptToolIds({
-          callKind: call.kind,
-          callId: call.callId,
-          itemId: call.id
-        });
-        return { call, toolName, value, parseError, ids, toolId, turn, toolIndex };
-      });
-      const callResults = await Promise.all(
-        callInputs.map(async (entry) => {
-          return await toolCallContextStorage.run(
-            {
-              toolName: entry.toolName,
-              toolId: entry.toolId,
-              turn: entry.turn,
-              toolIndex: entry.toolIndex
-            },
-            async () => {
-              const { result, outputPayload } = await executeToolCall({
-                callKind: entry.call.kind,
-                toolName: entry.toolName,
-                tool: request.tools[entry.toolName],
-                rawInput: entry.value,
-                parseError: entry.parseError
-              });
-              return { entry, result, outputPayload };
+      throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
+    }
+    if (providerInfo.provider === "fireworks") {
+      if (request.modelTools && request.modelTools.length > 0) {
+        throw new Error(
+          "Fireworks provider does not support provider-native modelTools in runToolLoop."
+        );
+      }
+      const fireworksTools = buildFireworksToolsFromToolSet(request.tools);
+      const messages = toFireworksMessages(contents);
+      for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+        const turn = stepIndex + 1;
+        const stepStartedAtMs = Date.now();
+        let schedulerMetrics;
+        const response = await runFireworksCall(
+          async (client) => {
+            return await client.chat.completions.create(
+              {
+                model: providerInfo.model,
+                messages,
+                tools: fireworksTools,
+                tool_choice: "auto",
+                parallel_tool_calls: true
+              },
+              { signal: request.signal }
+            );
+          },
+          providerInfo.model,
+          {
+            onSettled: (metrics) => {
+              schedulerMetrics = metrics;
             }
-          );
-        })
-      );
-      for (const { entry, result, outputPayload } of callResults) {
-        toolCalls.push({ ...result, callId: entry.ids.callId });
-        if (entry.call.kind === "custom") {
-          toolOutputs.push({
-            type: "custom_tool_call",
-            id: entry.ids.itemId,
-            call_id: entry.ids.callId,
-            name: entry.toolName,
-            input: entry.call.input,
-            status: "completed"
+          }
+        );
+        const modelCompletedAtMs = Date.now();
+        const modelVersion = typeof response.model === "string" ? response.model : request.model;
+        request.onEvent?.({ type: "model", modelVersion });
+        const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
+        if (choice?.finish_reason === "content_filter") {
+          request.onEvent?.({ type: "blocked" });
+        }
+        const message = choice?.message;
+        const responseText = extractFireworksMessageText(message).trim();
+        if (responseText.length > 0) {
+          request.onEvent?.({ type: "delta", channel: "response", text: responseText });
+        }
+        const usageTokens = extractFireworksUsageTokens(response.usage);
+        const stepCostUsd = estimateCallCostUsd({
+          modelId: modelVersion,
+          tokens: usageTokens,
+          responseImages: 0
+        });
+        totalCostUsd += stepCostUsd;
+        if (usageTokens) {
+          request.onEvent?.({
+            type: "usage",
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            modelVersion
+          });
+        }
+        const responseToolCalls = extractFireworksToolCalls(message);
+        if (responseToolCalls.length === 0) {
+          const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
+          const steeringMessages = steeringInput2.length > 0 ? toFireworksMessages(steeringInput2) : [];
+          finalText = responseText;
+          finalThoughts = "";
+          const stepCompletedAtMs2 = Date.now();
+          const timing2 = buildStepTiming({
+            stepStartedAtMs,
+            stepCompletedAtMs: stepCompletedAtMs2,
+            modelCompletedAtMs,
+            schedulerMetrics,
+            toolExecutionMs: 0,
+            waitToolMs: 0
           });
-          toolOutputs.push({
-            type: "custom_tool_call_output",
-            call_id: entry.ids.callId,
-            output: mergeToolOutput(outputPayload)
+          steps.push({
+            step: steps.length + 1,
+            modelVersion,
+            text: responseText || void 0,
+            thoughts: void 0,
+            toolCalls: [],
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            timing: timing2
           });
-        } else {
-          toolOutputs.push({
-            type: "function_call",
-            id: entry.ids.itemId,
-            call_id: entry.ids.callId,
-            name: entry.toolName,
-            arguments: entry.call.arguments,
-            status: "completed"
+          if (steeringMessages.length === 0) {
+            return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+          }
+          if (responseText.length > 0) {
+            messages.push({ role: "assistant", content: responseText });
+          }
+          messages.push(...steeringMessages);
+          continue;
+        }
+        const stepToolCalls = [];
+        const callInputs = responseToolCalls.map((call, index) => {
+          const toolIndex = index + 1;
+          const toolId = buildToolLogId(turn, toolIndex);
+          const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
+          return { call, toolName: call.name, value, parseError, toolId, turn, toolIndex };
+        });
+        for (const entry of callInputs) {
+          request.onEvent?.({
+            type: "tool_call",
+            phase: "started",
+            turn: entry.turn,
+            toolIndex: entry.toolIndex,
+            toolName: entry.toolName,
+            toolId: entry.toolId,
+            callKind: "function",
+            callId: entry.call.id,
+            input: entry.value
           });
-          toolOutputs.push({
-            type: "function_call_output",
-            call_id: entry.ids.callId,
-            output: mergeToolOutput(outputPayload)
+        }
+        const callResults = await Promise.all(
+          callInputs.map(async (entry) => {
+            return await toolCallContextStorage.run(
+              {
+                toolName: entry.toolName,
+                toolId: entry.toolId,
+                turn: entry.turn,
+                toolIndex: entry.toolIndex
+              },
+              async () => {
+                const { result, outputPayload } = await executeToolCall({
+                  callKind: "function",
+                  toolName: entry.toolName,
+                  tool: request.tools[entry.toolName],
+                  rawInput: entry.value,
+                  parseError: entry.parseError
+                });
+                return { entry, result, outputPayload };
+              }
+            );
+          })
+        );
+        const assistantToolCalls = [];
+        const toolMessages = [];
+        let toolExecutionMs = 0;
+        let waitToolMs = 0;
+        for (const { entry, result, outputPayload } of callResults) {
+          stepToolCalls.push({ ...result, callId: entry.call.id });
+          const callDurationMs = toToolResultDuration(result);
+          toolExecutionMs += callDurationMs;
+          if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
+            waitToolMs += callDurationMs;
+          }
+          request.onEvent?.({
+            type: "tool_call",
+            phase: "completed",
+            turn: entry.turn,
+            toolIndex: entry.toolIndex,
+            toolName: entry.toolName,
+            toolId: entry.toolId,
+            callKind: "function",
+            callId: entry.call.id,
+            input: entry.value,
+            output: result.output,
+            error: result.error,
+            durationMs: result.durationMs
+          });
+          assistantToolCalls.push({
+            id: entry.call.id,
+            type: "function",
+            function: {
+              name: entry.toolName,
+              arguments: entry.call.arguments
+            }
           });
+          toolMessages.push({
+            role: "tool",
+            tool_call_id: entry.call.id,
+            content: mergeToolOutput(outputPayload)
+          });
+        }
+        const stepCompletedAtMs = Date.now();
+        const timing = buildStepTiming({
+          stepStartedAtMs,
+          stepCompletedAtMs,
+          modelCompletedAtMs,
+          schedulerMetrics,
+          toolExecutionMs,
+          waitToolMs
+        });
+        steps.push({
+          step: steps.length + 1,
+          modelVersion,
+          text: responseText || void 0,
+          thoughts: void 0,
+          toolCalls: stepToolCalls,
+          usage: usageTokens,
+          costUsd: stepCostUsd,
+          timing
+        });
+        messages.push({
+          role: "assistant",
+          ...responseText.length > 0 ? { content: responseText } : {},
+          tool_calls: assistantToolCalls
+        });
+        messages.push(...toolMessages);
+        const steeringInput = steeringInternal?.drainPendingContents() ?? [];
+        if (steeringInput.length > 0) {
+          messages.push(...toFireworksMessages(steeringInput));
         }
       }
-      steps.push({
-        step: steps.length + 1,
-        modelVersion,
-        text: responseText || void 0,
-        thoughts: reasoningSummaryText || void 0,
-        toolCalls,
-        usage: usageTokens,
-        costUsd: stepCostUsd
-      });
-      input = input.concat(toolOutputs);
+      throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
     }
-    throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
-  }
-  if (providerInfo.provider === "fireworks") {
-    if (request.modelTools && request.modelTools.length > 0) {
-      throw new Error(
-        "Fireworks provider does not support provider-native modelTools in runToolLoop."
-      );
-    }
-    const fireworksTools = buildFireworksToolsFromToolSet(request.tools);
-    const messages = toFireworksMessages(contents);
+    const geminiFunctionTools = buildGeminiFunctionDeclarations(request.tools);
+    const geminiNativeTools = toGeminiTools(request.modelTools);
+    const geminiTools = geminiNativeTools ? geminiNativeTools.concat(geminiFunctionTools) : geminiFunctionTools;
+    const geminiContents = contents.map(convertLlmContentToGeminiContent);
     for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
-      const turn = stepIndex + 1;
-      const response = await runFireworksCall(async (client) => {
-        return await client.chat.completions.create(
-          {
-            model: providerInfo.model,
-            messages,
-            tools: fireworksTools,
-            tool_choice: "auto",
-            parallel_tool_calls: true
-          },
-          { signal: request.signal }
-        );
-      }, providerInfo.model);
-      const modelVersion = typeof response.model === "string" ? response.model : request.model;
-      request.onEvent?.({ type: "model", modelVersion });
-      const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
-      if (choice?.finish_reason === "content_filter") {
-        request.onEvent?.({ type: "blocked" });
-      }
-      const message = choice?.message;
-      const responseText = extractFireworksMessageText(message).trim();
-      if (responseText.length > 0) {
-        request.onEvent?.({ type: "delta", channel: "response", text: responseText });
-      }
-      const usageTokens = extractFireworksUsageTokens(response.usage);
+      const stepStartedAtMs = Date.now();
+      let firstModelEventAtMs;
+      let schedulerMetrics;
+      const markFirstModelEvent = () => {
+        if (firstModelEventAtMs === void 0) {
+          firstModelEventAtMs = Date.now();
+        }
+      };
+      const config = {
+        maxOutputTokens: 32e3,
+        tools: geminiTools,
+        toolConfig: {
+          functionCallingConfig: {
+            mode: FunctionCallingConfigMode.VALIDATED
+          }
+        },
+        thinkingConfig: resolveGeminiThinkingConfig(request.model)
+      };
+      const onEvent = request.onEvent;
+      const response = await runGeminiCall(
+        async (client) => {
+          const stream = await client.models.generateContentStream({
+            model: request.model,
+            contents: geminiContents,
+            config
+          });
+          let responseText = "";
+          let thoughtsText = "";
+          const modelParts = [];
+          const functionCalls = [];
+          const seenFunctionCallIds = /* @__PURE__ */ new Set();
+          const seenFunctionCallKeys = /* @__PURE__ */ new Set();
+          let latestUsageMetadata;
+          let resolvedModelVersion;
+          for await (const chunk of stream) {
+            markFirstModelEvent();
+            if (chunk.modelVersion) {
+              resolvedModelVersion = chunk.modelVersion;
+              onEvent?.({ type: "model", modelVersion: chunk.modelVersion });
+            }
+            if (chunk.usageMetadata) {
+              latestUsageMetadata = chunk.usageMetadata;
+            }
+            const candidates = chunk.candidates;
+            if (!candidates || candidates.length === 0) {
+              continue;
+            }
+            const primary = candidates[0];
+            const parts = primary?.content?.parts;
+            if (!parts || parts.length === 0) {
+              continue;
+            }
+            for (const part of parts) {
+              modelParts.push(part);
+              const call = part.functionCall;
+              if (call) {
+                const id = typeof call.id === "string" ? call.id : "";
+                const shouldAdd = (() => {
+                  if (id.length > 0) {
+                    if (seenFunctionCallIds.has(id)) {
+                      return false;
+                    }
+                    seenFunctionCallIds.add(id);
+                    return true;
+                  }
+                  const key = JSON.stringify({ name: call.name ?? "", args: call.args ?? null });
+                  if (seenFunctionCallKeys.has(key)) {
+                    return false;
+                  }
+                  seenFunctionCallKeys.add(key);
+                  return true;
+                })();
+                if (shouldAdd) {
+                  functionCalls.push(call);
+                }
+              }
+              if (typeof part.text === "string" && part.text.length > 0) {
+                if (part.thought) {
+                  thoughtsText += part.text;
+                  onEvent?.({ type: "delta", channel: "thought", text: part.text });
+                } else {
+                  responseText += part.text;
+                  onEvent?.({ type: "delta", channel: "response", text: part.text });
+                }
+              }
+            }
+          }
+          return {
+            responseText,
+            thoughtsText,
+            functionCalls,
+            modelParts,
+            usageMetadata: latestUsageMetadata,
+            modelVersion: resolvedModelVersion ?? request.model
+          };
+        },
+        request.model,
+        {
+          onSettled: (metrics) => {
+            schedulerMetrics = metrics;
+          }
+        }
+      );
+      const modelCompletedAtMs = Date.now();
+      const usageTokens = extractGeminiUsageTokens(response.usageMetadata);
+      const modelVersion = response.modelVersion ?? request.model;
       const stepCostUsd = estimateCallCostUsd({
         modelId: modelVersion,
         tokens: usageTokens,
         responseImages: 0
       });
       totalCostUsd += stepCostUsd;
-      if (usageTokens) {
-        request.onEvent?.({
-          type: "usage",
-          usage: usageTokens,
-          costUsd: stepCostUsd,
-          modelVersion
+      if (response.functionCalls.length === 0) {
+        const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
+        finalText = response.responseText.trim();
+        finalThoughts = response.thoughtsText.trim();
+        const stepCompletedAtMs2 = Date.now();
+        const timing2 = buildStepTiming({
+          stepStartedAtMs,
+          stepCompletedAtMs: stepCompletedAtMs2,
+          modelCompletedAtMs,
+          firstModelEventAtMs,
+          schedulerMetrics,
+          toolExecutionMs: 0,
+          waitToolMs: 0
         });
-      }
-      const responseToolCalls = extractFireworksToolCalls(message);
-      if (responseToolCalls.length === 0) {
-        finalText = responseText;
-        finalThoughts = "";
         steps.push({
           step: steps.length + 1,
           modelVersion,
-          text: responseText || void 0,
-          thoughts: void 0,
+          text: finalText || void 0,
+          thoughts: finalThoughts || void 0,
           toolCalls: [],
           usage: usageTokens,
-          costUsd: stepCostUsd
+          costUsd: stepCostUsd,
+          timing: timing2
         });
-        return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+        if (steeringInput2.length === 0) {
+          return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+        }
+        const modelPartsForHistory2 = response.modelParts.filter(
+          (part) => !(typeof part.text === "string" && part.thought === true)
+        );
+        if (modelPartsForHistory2.length > 0) {
+          geminiContents.push({ role: "model", parts: modelPartsForHistory2 });
+        } else if (response.responseText.length > 0) {
+          geminiContents.push({ role: "model", parts: [{ text: response.responseText }] });
+        }
+        geminiContents.push(...steeringInput2.map(convertLlmContentToGeminiContent));
+        continue;
       }
-      const stepToolCalls = [];
-      const callInputs = responseToolCalls.map((call, index) => {
+      const toolCalls = [];
+      const modelPartsForHistory = response.modelParts.filter(
+        (part) => !(typeof part.text === "string" && part.thought === true)
+      );
+      if (modelPartsForHistory.length > 0) {
+        geminiContents.push({ role: "model", parts: modelPartsForHistory });
+      } else {
+        const parts = [];
+        if (response.responseText) {
+          parts.push({ text: response.responseText });
+        }
+        for (const call of response.functionCalls) {
+          parts.push({ functionCall: call });
+        }
+        geminiContents.push({ role: "model", parts });
+      }
+      const responseParts = [];
+      const callInputs = response.functionCalls.map((call, index) => {
+        const turn = stepIndex + 1;
         const toolIndex = index + 1;
         const toolId = buildToolLogId(turn, toolIndex);
-        const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
-        return { call, toolName: call.name, value, parseError, toolId, turn, toolIndex };
+        const toolName = call.name ?? "unknown";
+        const rawInput = call.args ?? {};
+        return { call, toolName, rawInput, toolId, turn, toolIndex };
       });
+      for (const entry of callInputs) {
+        onEvent?.({
+          type: "tool_call",
+          phase: "started",
+          turn: entry.turn,
+          toolIndex: entry.toolIndex,
+          toolName: entry.toolName,
+          toolId: entry.toolId,
+          callKind: "function",
+          callId: entry.call.id,
+          input: entry.rawInput
+        });
+      }
       const callResults = await Promise.all(
         callInputs.map(async (entry) => {
           return await toolCallContextStorage.run(
@@ -5165,232 +5929,134 @@ async function runToolLoop(request) {
                 callKind: "function",
                 toolName: entry.toolName,
                 tool: request.tools[entry.toolName],
-                rawInput: entry.value,
-                parseError: entry.parseError
+                rawInput: entry.rawInput
               });
               return { entry, result, outputPayload };
             }
           );
         })
       );
-      const assistantToolCalls = [];
-      const toolMessages = [];
+      let toolExecutionMs = 0;
+      let waitToolMs = 0;
       for (const { entry, result, outputPayload } of callResults) {
-        stepToolCalls.push({ ...result, callId: entry.call.id });
-        assistantToolCalls.push({
-          id: entry.call.id,
-          type: "function",
-          function: {
+        toolCalls.push({ ...result, callId: entry.call.id });
+        const callDurationMs = toToolResultDuration(result);
+        toolExecutionMs += callDurationMs;
+        if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
+          waitToolMs += callDurationMs;
+        }
+        onEvent?.({
+          type: "tool_call",
+          phase: "completed",
+          turn: entry.turn,
+          toolIndex: entry.toolIndex,
+          toolName: entry.toolName,
+          toolId: entry.toolId,
+          callKind: "function",
+          callId: entry.call.id,
+          input: entry.rawInput,
+          output: result.output,
+          error: result.error,
+          durationMs: result.durationMs
+        });
+        const responsePayload = isPlainRecord(outputPayload) ? outputPayload : { output: outputPayload };
+        responseParts.push({
+          functionResponse: {
             name: entry.toolName,
-            arguments: entry.call.arguments
+            response: responsePayload,
+            ...entry.call.id ? { id: entry.call.id } : {}
           }
         });
-        toolMessages.push({
-          role: "tool",
-          tool_call_id: entry.call.id,
-          content: mergeToolOutput(outputPayload)
-        });
       }
+      const stepCompletedAtMs = Date.now();
+      const timing = buildStepTiming({
+        stepStartedAtMs,
+        stepCompletedAtMs,
+        modelCompletedAtMs,
+        firstModelEventAtMs,
+        schedulerMetrics,
+        toolExecutionMs,
+        waitToolMs
+      });
       steps.push({
         step: steps.length + 1,
         modelVersion,
-        text: responseText || void 0,
-        thoughts: void 0,
-        toolCalls: stepToolCalls,
+        text: response.responseText.trim() || void 0,
+        thoughts: response.thoughtsText.trim() || void 0,
+        toolCalls,
         usage: usageTokens,
-        costUsd: stepCostUsd
-      });
-      messages.push({
-        role: "assistant",
-        ...responseText.length > 0 ? { content: responseText } : {},
-        tool_calls: assistantToolCalls
+        costUsd: stepCostUsd,
+        timing
       });
-      messages.push(...toolMessages);
+      geminiContents.push({ role: "user", parts: responseParts });
+      const steeringInput = steeringInternal?.drainPendingContents() ?? [];
+      if (steeringInput.length > 0) {
+        geminiContents.push(...steeringInput.map(convertLlmContentToGeminiContent));
+      }
     }
     throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
+  } finally {
+    steeringInternal?.close();
   }
-  const geminiFunctionTools = buildGeminiFunctionDeclarations(request.tools);
-  const geminiNativeTools = toGeminiTools(request.modelTools);
-  const geminiTools = geminiNativeTools ? geminiNativeTools.concat(geminiFunctionTools) : geminiFunctionTools;
-  const geminiContents = contents.map(convertLlmContentToGeminiContent);
-  for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
-    const config = {
-      maxOutputTokens: 32e3,
-      tools: geminiTools,
-      toolConfig: {
-        functionCallingConfig: {
-          mode: FunctionCallingConfigMode.VALIDATED
-        }
-      },
-      thinkingConfig: resolveGeminiThinkingConfig(request.model)
-    };
-    const onEvent = request.onEvent;
-    const response = await runGeminiCall(async (client) => {
-      const stream = await client.models.generateContentStream({
-        model: request.model,
-        contents: geminiContents,
-        config
-      });
-      let responseText = "";
-      let thoughtsText = "";
-      const modelParts = [];
-      const functionCalls = [];
-      const seenFunctionCallIds = /* @__PURE__ */ new Set();
-      const seenFunctionCallKeys = /* @__PURE__ */ new Set();
-      let latestUsageMetadata;
-      let resolvedModelVersion;
-      for await (const chunk of stream) {
-        if (chunk.modelVersion) {
-          resolvedModelVersion = chunk.modelVersion;
-          onEvent?.({ type: "model", modelVersion: chunk.modelVersion });
-        }
-        if (chunk.usageMetadata) {
-          latestUsageMetadata = chunk.usageMetadata;
-        }
-        const candidates = chunk.candidates;
-        if (!candidates || candidates.length === 0) {
-          continue;
-        }
-        const primary = candidates[0];
-        const parts = primary?.content?.parts;
-        if (!parts || parts.length === 0) {
-          continue;
-        }
-        for (const part of parts) {
-          modelParts.push(part);
-          const call = part.functionCall;
-          if (call) {
-            const id = typeof call.id === "string" ? call.id : "";
-            const shouldAdd = (() => {
-              if (id.length > 0) {
-                if (seenFunctionCallIds.has(id)) {
-                  return false;
-                }
-                seenFunctionCallIds.add(id);
-                return true;
-              }
-              const key = JSON.stringify({ name: call.name ?? "", args: call.args ?? null });
-              if (seenFunctionCallKeys.has(key)) {
-                return false;
-              }
-              seenFunctionCallKeys.add(key);
-              return true;
-            })();
-            if (shouldAdd) {
-              functionCalls.push(call);
-            }
-          }
-          if (typeof part.text === "string" && part.text.length > 0) {
-            if (part.thought) {
-              thoughtsText += part.text;
-              onEvent?.({ type: "delta", channel: "thought", text: part.text });
-            } else {
-              responseText += part.text;
-              onEvent?.({ type: "delta", channel: "response", text: part.text });
-            }
-          }
-        }
-      }
-      return {
-        responseText,
-        thoughtsText,
-        functionCalls,
-        modelParts,
-        usageMetadata: latestUsageMetadata,
-        modelVersion: resolvedModelVersion ?? request.model
-      };
-    }, request.model);
-    const usageTokens = extractGeminiUsageTokens(response.usageMetadata);
-    const modelVersion = response.modelVersion ?? request.model;
-    const stepCostUsd = estimateCallCostUsd({
-      modelId: modelVersion,
-      tokens: usageTokens,
-      responseImages: 0
-    });
-    totalCostUsd += stepCostUsd;
-    if (response.functionCalls.length === 0) {
-      finalText = response.responseText.trim();
-      finalThoughts = response.thoughtsText.trim();
-      steps.push({
-        step: steps.length + 1,
-        modelVersion,
-        text: finalText || void 0,
-        thoughts: finalThoughts || void 0,
-        toolCalls: [],
-        usage: usageTokens,
-        costUsd: stepCostUsd
-      });
-      return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+}
+function mergeAbortSignals(first, second) {
+  if (!first) {
+    return second;
+  }
+  if (!second) {
+    return first;
+  }
+  const controller = new AbortController();
+  const abortFrom = (signal) => {
+    if (!controller.signal.aborted) {
+      controller.abort(signal.reason);
     }
-    const toolCalls = [];
-    const modelPartsForHistory = response.modelParts.filter(
-      (part) => !(typeof part.text === "string" && part.thought === true)
-    );
-    if (modelPartsForHistory.length > 0) {
-      geminiContents.push({ role: "model", parts: modelPartsForHistory });
-    } else {
-      const parts = [];
-      if (response.responseText) {
-        parts.push({ text: response.responseText });
-      }
-      for (const call of response.functionCalls) {
-        parts.push({ functionCall: call });
-      }
-      geminiContents.push({ role: "model", parts });
-    }
-    const responseParts = [];
-    const callInputs = response.functionCalls.map((call, index) => {
-      const turn = stepIndex + 1;
-      const toolIndex = index + 1;
-      const toolId = buildToolLogId(turn, toolIndex);
-      const toolName = call.name ?? "unknown";
-      const rawInput = call.args ?? {};
-      return { call, toolName, rawInput, toolId, turn, toolIndex };
-    });
-    const callResults = await Promise.all(
-      callInputs.map(async (entry) => {
-        return await toolCallContextStorage.run(
-          {
-            toolName: entry.toolName,
-            toolId: entry.toolId,
-            turn: entry.turn,
-            toolIndex: entry.toolIndex
-          },
-          async () => {
-            const { result, outputPayload } = await executeToolCall({
-              callKind: "function",
-              toolName: entry.toolName,
-              tool: request.tools[entry.toolName],
-              rawInput: entry.rawInput
-            });
-            return { entry, result, outputPayload };
-          }
-        );
-      })
-    );
-    for (const { entry, result, outputPayload } of callResults) {
-      toolCalls.push({ ...result, callId: entry.call.id });
-      const responsePayload = isPlainRecord(outputPayload) ? outputPayload : { output: outputPayload };
-      responseParts.push({
-        functionResponse: {
-          name: entry.toolName,
-          response: responsePayload,
-          ...entry.call.id ? { id: entry.call.id } : {}
+  };
+  if (first.aborted) {
+    abortFrom(first);
+  } else {
+    first.addEventListener("abort", () => abortFrom(first), { once: true });
+  }
+  if (second.aborted) {
+    abortFrom(second);
+  } else {
+    second.addEventListener("abort", () => abortFrom(second), { once: true });
+  }
+  return controller.signal;
+}
+function streamToolLoop(request) {
+  const queue = createAsyncQueue();
+  const abortController = new AbortController();
+  const steering = request.steering ?? createToolLoopSteeringChannel();
+  const signal = mergeAbortSignals(request.signal, abortController.signal);
+  const sourceOnEvent = request.onEvent;
+  const result = (async () => {
+    try {
+      const output = await runToolLoop({
+        ...request,
+        steering,
+        ...signal ? { signal } : {},
+        onEvent: (event) => {
+          sourceOnEvent?.(event);
+          queue.push(event);
         }
       });
+      queue.close();
+      return output;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      queue.fail(err);
+      throw err;
     }
-    steps.push({
-      step: steps.length + 1,
-      modelVersion,
-      text: response.responseText.trim() || void 0,
-      thoughts: response.thoughtsText.trim() || void 0,
-      toolCalls,
-      usage: usageTokens,
-      costUsd: stepCostUsd
-    });
-    geminiContents.push({ role: "user", parts: responseParts });
-  }
-  throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
+  })();
+  return {
+    events: queue.iterable,
+    result,
+    append: steering.append,
+    steer: steering.steer,
+    pendingSteeringCount: steering.pendingCount,
+    abort: () => abortController.abort()
+  };
 }
 var IMAGE_GRADE_SCHEMA = z3.enum(["pass", "fail"]);
 async function gradeGeneratedImage(params) {
@@ -5637,68 +6303,112 @@ function appendMarkdownSourcesSection(value, sources) {
 ${lines}`;
 }
 
+// src/agent.ts
+import { randomBytes as randomBytes3 } from "crypto";
+
 // src/agent/subagents.ts
 import { randomBytes as randomBytes2 } from "crypto";
 import { z as z4 } from "zod";
-var DEFAULT_SUBAGENT_MAX_AGENTS = 4;
-var DEFAULT_SUBAGENT_MAX_DEPTH = 2;
-var DEFAULT_SUBAGENT_WAIT_TIMEOUT_MS = 1500;
-var DEFAULT_SUBAGENT_MAX_WAIT_TIMEOUT_MS = 9e4;
+var DEFAULT_SUBAGENT_MAX_AGENTS = 6;
+var DEFAULT_SUBAGENT_MAX_DEPTH = 1;
+var DEFAULT_SUBAGENT_MIN_WAIT_TIMEOUT_MS = 1e4;
+var DEFAULT_SUBAGENT_WAIT_TIMEOUT_MS = 3e4;
+var DEFAULT_SUBAGENT_MAX_WAIT_TIMEOUT_MS = 36e5;
 var MAX_SUBAGENT_MAX_AGENTS = 64;
 var MAX_SUBAGENT_MAX_DEPTH = 12;
 var MAX_SUBAGENT_MAX_STEPS = 64;
-var MAX_SUBAGENT_WAIT_TIMEOUT_MS = 6e5;
+var MAX_SUBAGENT_WAIT_TIMEOUT_MS = 36e5;
 var SUBAGENT_CONTROL_TOOL_NAMES = ["send_input", "resume_agent", "wait", "close_agent"];
+var DEFAULT_AGENT_TYPE = "default";
+var BUILT_IN_AGENT_TYPES = ["default", "researcher", "worker", "reviewer"];
+var RESEARCHER_ROLE_DESCRIPTION = `Use \`researcher\` for focused discovery and fact-finding work.
+Researchers are fast and authoritative.
+They should be used for specific, well-scoped research questions.
+Rules:
+- Do not repeat searches they have already completed.
+- Trust researcher findings unless there is a clear contradiction.
+- Run researchers in parallel when useful.
+- Reuse existing researchers for related follow-up questions.`;
+var WORKER_ROLE_DESCRIPTION = `Use for execution and production work across domains.
+Typical tasks:
+- Build part of a deliverable
+- Implement requested changes
+- Produce concrete outputs (documents, plans, analyses, artifacts)
+Rules:
+- Explicitly assign **ownership** of the task (scope / responsibility).
+- Always tell workers they are **not alone in the workspace**, and they should ignore edits made by others without touching them unless asked.`;
+var REVIEWER_ROLE_DESCRIPTION = `Use \`reviewer\` to evaluate completed work and provide feedback.
+Reviewers focus on quality, correctness, risk, and clarity.
+Rules:
+- Review critically and prioritize issues by severity.
+- Call out gaps, assumptions, and edge cases explicitly.
+- Provide actionable, concrete feedback to improve the result.
+- Do not redo the entire task unless explicitly requested; evaluate first.`;
+var BUILT_IN_AGENT_TYPE_DESCRIPTIONS = {
+  default: "Default agent.",
+  researcher: RESEARCHER_ROLE_DESCRIPTION,
+  worker: WORKER_ROLE_DESCRIPTION,
+  reviewer: REVIEWER_ROLE_DESCRIPTION
+};
+var BUILT_IN_AGENT_TYPE_INSTRUCTIONS = {
+  default: void 0,
+  researcher: RESEARCHER_ROLE_DESCRIPTION,
+  worker: WORKER_ROLE_DESCRIPTION,
+  reviewer: REVIEWER_ROLE_DESCRIPTION
+};
+var SUBAGENT_NOTIFICATION_OPEN_TAG = "<subagent_notification>";
+var SUBAGENT_NOTIFICATION_CLOSE_TAG = "</subagent_notification>";
+var SPAWN_AGENT_TYPE_DESCRIPTION = buildSpawnAgentTypeDescription();
 var subagentInputItemSchema = z4.object({
-  text: z4.string().optional(),
-  image_url: z4.string().optional(),
-  name: z4.string().optional(),
-  path: z4.string().optional(),
-  type: z4.string().optional()
+  text: z4.string().nullish(),
+  image_url: z4.string().nullish(),
+  name: z4.string().nullish(),
+  path: z4.string().nullish(),
+  type: z4.string().nullish()
 }).passthrough();
 var spawnAgentInputSchema = z4.object({
-  prompt: z4.string().optional().describe("Initial prompt for the subagent."),
-  message: z4.string().optional().describe("Codex-style alias for prompt."),
-  items: z4.array(subagentInputItemSchema).optional().describe("Optional Codex-style input items."),
-  agent_type: z4.string().optional().describe("Codex-style agent type hint."),
-  instructions: z4.string().optional().describe("Optional extra instructions for this subagent instance."),
-  model: z4.string().optional().describe("Optional model override. Must be one of this package's supported text model ids."),
-  max_steps: z4.number().int().min(1).max(MAX_SUBAGENT_MAX_STEPS).optional().describe("Optional max step budget for each subagent run.")
-}).refine((value) => Boolean(resolvePromptValue(value.prompt, value.message, value.items)), {
-  message: "Either prompt, message, or items must contain non-empty input."
+  prompt: z4.string().nullish().describe("Alias for message. Initial plain-text task for the new agent."),
+  message: z4.string().nullish().describe("Initial plain-text task for the new agent. Use either message or items."),
+  items: z4.array(subagentInputItemSchema).nullish().describe(
+    "Structured input items. Use this to pass explicit mentions (for example app:// connector paths)."
+  ),
+  agent_type: z4.string().nullish().describe(SPAWN_AGENT_TYPE_DESCRIPTION),
+  fork_context: z4.boolean().nullish().describe(
+    "When true, fork the current thread history into the new agent before sending the initial prompt. This must be used when you want the new agent to have exactly the same context as you."
+  ),
+  instructions: z4.string().nullish().describe("Optional extra instructions for this subagent instance."),
+  model: z4.string().nullish().describe("Optional model override. Must be one of this package's supported text model ids."),
+  max_steps: z4.number().int().min(1).max(MAX_SUBAGENT_MAX_STEPS).nullish().describe("Optional max step budget for each subagent run.")
 });
 var sendInputSchema = z4.object({
-  agent_id: z4.string().optional().describe("Target subagent id."),
-  id: z4.string().optional().describe("Codex-style alias for agent_id."),
-  input: z4.string().optional().describe("New user input queued for the subagent."),
-  message: z4.string().optional().describe("Codex-style alias for input."),
-  items: z4.array(subagentInputItemSchema).optional().describe("Optional Codex-style input items."),
-  interrupt: z4.boolean().optional().describe("If true and currently running, aborts active run before queuing input.")
+  agent_id: z4.string().nullish().describe("Target subagent id."),
+  id: z4.string().nullish().describe("Agent id to message (from spawn_agent)."),
+  input: z4.string().nullish().describe("New user input queued for the subagent."),
+  message: z4.string().nullish().describe("Legacy plain-text message to send to the agent. Use either message or items."),
+  items: z4.array(subagentInputItemSchema).nullish().describe(
+    "Structured input items. Use this to pass explicit mentions (for example app:// connector paths)."
+  ),
+  interrupt: z4.boolean().nullish().describe("If true and currently running, aborts active run before queuing input.")
 }).refine((value) => Boolean(resolveAgentIdValue(value.agent_id, value.id)), {
   message: "agent_id (or id) is required."
-}).refine((value) => Boolean(resolvePromptValue(value.input, value.message, value.items)), {
-  message: "input (or message/items) is required."
 });
 var resumeAgentSchema = z4.object({
-  agent_id: z4.string().optional().describe("Target subagent id."),
-  id: z4.string().optional().describe("Codex-style alias for agent_id.")
+  agent_id: z4.string().nullish().describe("Target subagent id."),
+  id: z4.string().nullish().describe("Agent id to resume.")
 }).refine((value) => Boolean(resolveAgentIdValue(value.agent_id, value.id)), {
   message: "agent_id (or id) is required."
 });
 var waitSchema = z4.object({
-  agent_id: z4.string().optional().describe("Target subagent id."),
-  id: z4.string().optional().describe("Codex-style alias for agent_id."),
-  ids: z4.array(z4.string().min(1)).optional().describe("Codex-style list of agent ids."),
-  timeout_ms: z4.number().int().min(1).optional().describe("Optional wait timeout in milliseconds.")
-}).refine(
-  (value) => Boolean(resolveAgentIdValue(value.agent_id, value.id)) || Array.isArray(value.ids) && value.ids.length > 0,
-  {
-    message: "agent_id/id or ids is required."
-  }
-);
+  agent_id: z4.string().nullish().describe("Target subagent id."),
+  id: z4.string().nullish().describe("Codex-style alias for agent_id."),
+  ids: z4.array(z4.string().min(1)).nullish().describe("Agent ids to wait on. Pass multiple ids to wait for whichever finishes first."),
+  timeout_ms: z4.number().int().nullish().describe(
+    "Optional timeout in milliseconds. Defaults to 30000, min 10000, max 3600000. Prefer longer waits (minutes) to avoid busy polling."
+  )
+});
 var closeSchema = z4.object({
-  agent_id: z4.string().optional().describe("Target subagent id."),
-  id: z4.string().optional().describe("Codex-style alias for agent_id.")
+  agent_id: z4.string().nullish().describe("Target subagent id."),
+  id: z4.string().nullish().describe("Agent id to close (from spawn_agent).")
 }).refine((value) => Boolean(resolveAgentIdValue(value.agent_id, value.id)), {
   message: "agent_id (or id) is required."
 });
@@ -5706,6 +6416,7 @@ function resolveSubagentToolConfig(selection, currentDepth) {
   const defaults = {
     maxAgents: DEFAULT_SUBAGENT_MAX_AGENTS,
     maxDepth: DEFAULT_SUBAGENT_MAX_DEPTH,
+    minWaitTimeoutMs: DEFAULT_SUBAGENT_MIN_WAIT_TIMEOUT_MS,
     defaultWaitTimeoutMs: DEFAULT_SUBAGENT_WAIT_TIMEOUT_MS,
     maxWaitTimeoutMs: DEFAULT_SUBAGENT_MAX_WAIT_TIMEOUT_MS,
     promptPattern: "codex",
@@ -5726,10 +6437,16 @@ function resolveSubagentToolConfig(selection, currentDepth) {
     MAX_SUBAGENT_MAX_AGENTS
   );
   const maxDepth = normalizeInteger(config.maxDepth, defaults.maxDepth, 1, MAX_SUBAGENT_MAX_DEPTH);
+  const minWaitTimeoutMs = normalizeInteger(
+    config.minWaitTimeoutMs,
+    defaults.minWaitTimeoutMs,
+    1,
+    MAX_SUBAGENT_WAIT_TIMEOUT_MS
+  );
   const defaultWaitTimeoutMs = normalizeInteger(
     config.defaultWaitTimeoutMs,
     defaults.defaultWaitTimeoutMs,
-    1,
+    minWaitTimeoutMs,
     MAX_SUBAGENT_WAIT_TIMEOUT_MS
   );
   const maxWaitTimeoutMs = normalizeInteger(
@@ -5746,6 +6463,7 @@ function resolveSubagentToolConfig(selection, currentDepth) {
     enabled,
     maxAgents,
     maxDepth,
+    minWaitTimeoutMs,
     defaultWaitTimeoutMs,
     maxWaitTimeoutMs,
     promptPattern,
@@ -5759,9 +6477,11 @@ function resolveSubagentToolConfig(selection, currentDepth) {
 function buildCodexSubagentOrchestratorInstructions(params) {
   return [
     "Subagent orchestration tools are available: spawn_agent, send_input, resume_agent, wait, close_agent.",
+    "Background updates may appear as <subagent_notification>{...}</subagent_notification>; treat them as status updates, not new user intent.",
+    "Available spawn_agent agent_type values: default, researcher, worker, reviewer.",
     "Use this control pattern:",
     "1. spawn_agent with a focused prompt.",
-    "2. wait on that agent_id until it is no longer running.",
+    "2. wait with ids=[agent_id] until the agent reaches a non-running state. Prefer long waits (minutes).",
     "3. For follow-up turns, send_input then resume_agent.",
     "4. close_agent when delegation is complete.",
     `Limits: max active subagents ${params.maxAgents}, max depth ${params.maxDepth}, current depth ${params.currentDepth}.`
@@ -5783,9 +6503,10 @@ function createSubagentToolController(options) {
     };
   }
   const agents = /* @__PURE__ */ new Map();
+  const roleNicknameCounts = /* @__PURE__ */ new Map();
   const tools = {
     spawn_agent: tool({
-      description: "Spawns a subagent asynchronously. Returns immediately with agent status and id.",
+      description: "Spawn a sub-agent for a well-scoped task. Returns the agent id (and user-facing nickname when available) to use to communicate with this agent.",
       inputSchema: spawnAgentInputSchema,
       execute: async (input) => {
         if (countActiveAgents(agents) >= options.config.maxAgents) {
@@ -5808,24 +6529,36 @@ function createSubagentToolController(options) {
         }
         const id = `agent_${randomBytes2(6).toString("hex")}`;
         const now = Date.now();
-        const initialPrompt = resolvePromptValue(input.prompt, input.message, input.items);
-        if (!initialPrompt) {
-          throw new Error("spawn_agent requires prompt/message/items with non-empty text.");
-        }
+        const { roleName, roleInstructions } = resolveAgentType(input.agent_type);
+        const nickname = reserveAgentNickname(roleName, roleNicknameCounts);
+        const perSpawnInstructions = joinInstructionBlocks(
+          roleInstructions,
+          trimToUndefined(input.instructions)
+        );
+        const initialPrompt = resolveCollabInputText({
+          textCandidates: [{ value: input.prompt }, { value: input.message }],
+          items: input.items,
+          bothError: "Provide either prompt/message or items, but not both.",
+          missingError: "Provide one of: prompt/message or items.",
+          emptyTextError: "Empty message can't be sent to an agent.",
+          emptyItemsError: "Items can't be empty."
+        });
         const agent = {
           id,
           depth: childDepth,
           model,
+          ...nickname ? { nickname } : {},
+          agentRole: roleName,
           status: "idle",
           createdAtMs: now,
           updatedAtMs: now,
           pendingInputs: [initialPrompt],
-          history: [],
+          history: input.fork_context && options.forkContextMessages ? [...options.forkContextMessages] : [],
           ...options.buildChildInstructions ? {
             instructions: trimToUndefined(
-              options.buildChildInstructions(input.instructions, childDepth)
+              options.buildChildInstructions(perSpawnInstructions, childDepth)
             )
-          } : input.instructions ? { instructions: trimToUndefined(input.instructions) } : {},
+          } : perSpawnInstructions ? { instructions: perSpawnInstructions } : {},
           ...input.max_steps ? { maxSteps: input.max_steps } : options.config.maxSteps ? { maxSteps: options.config.maxSteps } : {},
           turns: 0,
           notification: "spawned",
@@ -5835,41 +6568,50 @@ function createSubagentToolController(options) {
         };
         agents.set(id, agent);
         startRun(agent, options);
-        return buildToolResponse(agent, {
-          notification: "spawned",
-          message: `Spawned subagent ${id}.`
-        });
+        return buildToolResponse(
+          agent,
+          {
+            notification: "spawned",
+            message: `Spawned subagent ${id}.`
+          },
+          { nickname: agent.nickname }
+        );
       }
     }),
     send_input: tool({
-      description: "Queues new input for an existing subagent.",
+      description: "Send a message to an existing agent. Use interrupt=true to redirect work immediately.",
       inputSchema: sendInputSchema,
       execute: async (input) => {
+        const submissionId = randomSubmissionId();
         const agentId = resolveAgentIdValue(input.agent_id, input.id);
         if (!agentId) {
           throw new Error("send_input requires agent_id or id.");
         }
         const agent = requireAgent(agents, agentId);
-        const nextInput = resolvePromptValue(input.input, input.message, input.items);
-        if (!nextInput) {
-          throw new Error("send_input requires input/message/items with non-empty text.");
-        }
+        const nextInput = resolveCollabInputText({
+          textCandidates: [{ value: input.input }, { value: input.message }],
+          items: input.items,
+          bothError: "Provide either input/message or items, but not both.",
+          missingError: "Provide one of: input/message or items.",
+          emptyTextError: "Empty message can't be sent to an agent.",
+          emptyItemsError: "Items can't be empty."
+        });
         if (agent.status === "closed") {
-          throw new Error(`Subagent ${agent.id} is closed.`);
+          throw new Error(`agent with id ${agent.id} is closed`);
         }
         if (input.interrupt && agent.abortController) {
           agent.abortController.abort("send_input_interrupt");
           agent.pendingInputs.unshift(nextInput);
           setNotification(agent, "input_queued", `Interrupted ${agent.id} and queued new input.`);
-          return buildToolResponse(agent);
+          return buildToolResponse(agent, void 0, { submission_id: submissionId });
         }
         agent.pendingInputs.push(nextInput);
         setNotification(agent, "input_queued", `Queued input for ${agent.id}.`);
-        return buildToolResponse(agent);
+        return buildToolResponse(agent, void 0, { submission_id: submissionId });
       }
     }),
     resume_agent: tool({
-      description: "Resumes a subagent run when queued input is available.",
+      description: "Resume a previously closed agent by id so it can receive send_input and wait calls.",
       inputSchema: resumeAgentSchema,
       execute: async (input) => {
         const agentId = resolveAgentIdValue(input.agent_id, input.id);
@@ -5878,10 +6620,11 @@ function createSubagentToolController(options) {
         }
         const agent = requireAgent(agents, agentId);
         if (agent.status === "closed") {
-          setNotification(agent, "already_closed", `Subagent ${agent.id} is already closed.`);
+          agent.status = "idle";
+          setNotification(agent, "resumed", `Resumed subagent ${agent.id}.`);
           return buildToolResponse(agent, {
-            notification: "already_closed",
-            message: `Subagent ${agent.id} is already closed.`
+            notification: "resumed",
+            message: `Resumed subagent ${agent.id}.`
           });
         }
         const outcome = startRun(agent, options);
@@ -5900,41 +6643,42 @@ function createSubagentToolController(options) {
       }
     }),
     wait: tool({
-      description: "Waits for a running subagent to change state or until timeout. Returns current status.",
+      description: "Wait for agents to reach a final status. Completed statuses may include the agent's final message. Returns empty status when timed out. Once the agent reaches a final status, a notification message will be received containing the same completed status.",
       inputSchema: waitSchema,
       execute: async (input) => {
-        const usesIdsArray = Array.isArray(input.ids) && input.ids.length > 0;
         const ids = resolveAgentIdList(input.agent_id, input.id, input.ids);
         if (ids.length === 0) {
-          throw new Error("wait requires agent_id/id or ids.");
+          throw new Error("ids must be non-empty");
+        }
+        if (typeof input.timeout_ms === "number" && input.timeout_ms <= 0) {
+          throw new Error("timeout_ms must be greater than zero");
         }
         const timeoutMs = normalizeInteger(
           input.timeout_ms,
           options.config.defaultWaitTimeoutMs,
-          1,
+          options.config.minWaitTimeoutMs,
           options.config.maxWaitTimeoutMs
         );
-        if (usesIdsArray) {
-          const status = await waitForAnyAgentStatus(agents, ids, timeoutMs);
-          return { status, timed_out: Object.keys(status).length === 0, timeout_ms: timeoutMs };
-        }
-        const agent = requireAgent(agents, ids[0]);
-        if (agent.status === "running") {
-          const completed = await waitUntilNotRunning(agent, timeoutMs);
-          if (!completed) {
-            setNotification(
-              agent,
-              "timeout",
-              `Timed out after ${timeoutMs}ms while waiting for ${agent.id}.`
-            );
-            return buildToolResponse(agent, void 0, { timed_out: true, timeout_ms: timeoutMs });
-          }
+        const status = await waitForAnyAgentStatus(agents, ids, timeoutMs);
+        const timedOut = Object.keys(status).length === 0;
+        if (timedOut && ids.length === 1) {
+          const agent = requireAgent(agents, ids[0]);
+          setNotification(
+            agent,
+            "timeout",
+            `Timed out after ${timeoutMs}ms while waiting for ${agent.id}.`
+          );
         }
-        return buildToolResponse(agent, void 0, { timed_out: false, timeout_ms: timeoutMs });
+        return {
+          status,
+          status_summary: summarizeAgentStatuses(status),
+          timed_out: timedOut,
+          timeout_ms: timeoutMs
+        };
       }
     }),
     close_agent: tool({
-      description: "Closes a subagent and aborts its current run if it is still running.",
+      description: "Close an agent when it is no longer needed and return its last known status.",
       inputSchema: closeSchema,
       execute: async (input) => {
         const agentId = resolveAgentIdValue(input.agent_id, input.id);
@@ -5946,7 +6690,7 @@ function createSubagentToolController(options) {
           setNotification(agent, "already_closed", `Subagent ${agent.id} is already closed.`);
           return buildToolResponse(agent, void 0, { cancelled: false });
         }
-        const cancelled = closeSubagent(agent, `Closed ${agent.id}.`);
+        const cancelled = closeSubagent(agent, `Closed ${agent.id}.`, options);
         return buildToolResponse(
           agent,
           { notification: "closed", message: `Closed ${agent.id}.` },
@@ -5961,7 +6705,7 @@ function createSubagentToolController(options) {
       const running = [];
       for (const agent of agents.values()) {
         if (agent.status !== "closed") {
-          closeSubagent(agent, `Parent agent loop closed ${agent.id}.`);
+          closeSubagent(agent, `Parent agent loop closed ${agent.id}.`, options);
         }
         if (agent.runningPromise) {
           running.push(agent.runningPromise);
@@ -5976,7 +6720,7 @@ function createSubagentToolController(options) {
 function requireAgent(agents, id) {
   const agent = agents.get(id);
   if (!agent) {
-    throw new Error(`Unknown subagent id: ${id}`);
+    throw new Error(`agent with id ${id} not found`);
   }
   return agent;
 }
@@ -5995,17 +6739,33 @@ function resolveAgentIdList(agentId, idAlias, ids) {
   const single = resolveAgentIdValue(agentId, idAlias);
   return single ? [single] : [];
 }
-function resolvePromptValue(prompt, message, items) {
-  const promptValue = prompt?.trim();
-  if (promptValue) {
-    return promptValue;
+function resolveCollabInputText(params) {
+  const textCandidate = params.textCandidates.find(
+    (candidate) => candidate.value !== void 0 && candidate.value !== null
+  );
+  const hasText = Boolean(textCandidate);
+  const hasItems = params.items !== void 0 && params.items !== null;
+  if (hasText && hasItems) {
+    throw new Error(params.bothError);
   }
-  const messageValue = message?.trim();
-  if (messageValue) {
-    return messageValue;
+  if (!hasText && !hasItems) {
+    throw new Error(params.missingError);
   }
-  const itemText = resolveInputItemsText(items);
-  return itemText ?? "";
+  if (hasText) {
+    const value = textCandidate?.value?.trim();
+    if (!value) {
+      throw new Error(params.emptyTextError);
+    }
+    return value;
+  }
+  if (!params.items || params.items.length === 0) {
+    throw new Error(params.emptyItemsError);
+  }
+  const itemText = resolveInputItemsText(params.items);
+  if (!itemText) {
+    throw new Error(params.emptyItemsError);
+  }
+  return itemText;
 }
 function resolveInputItemsText(items) {
   if (!items || items.length === 0) {
@@ -6021,9 +6781,28 @@ function resolveInputItemsText(items) {
     const name = typeof item.name === "string" ? item.name.trim() : "";
     const path6 = typeof item.path === "string" ? item.path.trim() : "";
     const imageUrl = typeof item.image_url === "string" ? item.image_url.trim() : "";
-    const compact = [itemType, name, path6 || imageUrl].filter(Boolean).join(" ");
-    if (compact) {
-      lines.push(compact);
+    if (itemType === "image") {
+      lines.push("[image]");
+      continue;
+    }
+    if (itemType === "local_image" && path6) {
+      lines.push(`[local_image:${path6}]`);
+      continue;
+    }
+    if (itemType === "skill" && name && path6) {
+      lines.push(`[skill:$${name}](${path6})`);
+      continue;
+    }
+    if (itemType === "mention" && name && path6) {
+      lines.push(`[mention:$${name}](${path6})`);
+      continue;
+    }
+    if (path6 || imageUrl) {
+      lines.push(`[${itemType || "input"}:${path6 || imageUrl}]`);
+      continue;
+    }
+    if (name) {
+      lines.push(`[${itemType || "input"}:${name}]`);
     }
   }
   if (lines.length === 0) {
@@ -6098,7 +6877,12 @@ function startRun(agent, options) {
   }
   const input = [...agent.history, { role: "user", content: nextInput }];
   const abortController = new AbortController();
+  const runStartedAtMs = Date.now();
   agent.abortController = abortController;
+  if (agent.firstRunStartedAtMs === void 0) {
+    agent.firstRunStartedAtMs = runStartedAtMs;
+  }
+  agent.lastRunStartedAtMs = runStartedAtMs;
   agent.lastError = void 0;
   setLifecycle(
     agent,
@@ -6130,6 +6914,7 @@ function startRun(agent, options) {
         "run_completed",
         `Subagent ${agent.id} completed run ${agent.turns}.`
       );
+      emitBackgroundNotification(agent, options);
     } catch (error) {
       if (agent.status === "closed") {
         return;
@@ -6141,7 +6926,11 @@ function startRun(agent, options) {
       const message = toErrorMessage(error);
       agent.lastError = message;
       setLifecycle(agent, "failed", "run_failed", `Subagent ${agent.id} failed: ${message}`);
+      emitBackgroundNotification(agent, options);
     } finally {
+      const runCompletedAtMs = Date.now();
+      agent.lastRunCompletedAtMs = runCompletedAtMs;
+      agent.lastRunDurationMs = Math.max(0, runCompletedAtMs - runStartedAtMs);
       agent.runningPromise = void 0;
       agent.abortController = void 0;
     }
@@ -6149,30 +6938,16 @@ function startRun(agent, options) {
   agent.runningPromise = runPromise;
   return "started";
 }
-function closeSubagent(agent, message) {
+function closeSubagent(agent, message, options) {
   const cancelled = Boolean(agent.runningPromise);
   agent.pendingInputs = [];
   if (agent.abortController) {
     agent.abortController.abort("close_agent");
   }
   setLifecycle(agent, "closed", "closed", message);
+  emitBackgroundNotification(agent, options);
   return cancelled;
 }
-async function waitUntilNotRunning(agent, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (agent.status === "running") {
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) {
-      return false;
-    }
-    const currentVersion = agent.version;
-    const changed = await waitForVersionChange(agent, currentVersion, remaining);
-    if (!changed) {
-      return false;
-    }
-  }
-  return true;
-}
 async function waitForVersionChange(agent, version, timeoutMs) {
   if (agent.version !== version) {
     return true;
@@ -6210,6 +6985,8 @@ function buildToolResponse(agent, override, extra = {}) {
 function buildSnapshot(agent) {
   return {
     agent_id: agent.id,
+    ...agent.nickname ? { nickname: agent.nickname } : {},
+    agent_role: agent.agentRole,
     status: agent.status,
     depth: agent.depth,
     model: agent.model,
@@ -6217,6 +6994,13 @@ function buildSnapshot(agent) {
     turns: agent.turns,
     created_at: new Date(agent.createdAtMs).toISOString(),
     updated_at: new Date(agent.updatedAtMs).toISOString(),
+    ...agent.firstRunStartedAtMs ? {
+      first_run_started_at: new Date(agent.firstRunStartedAtMs).toISOString(),
+      spawn_startup_latency_ms: Math.max(0, agent.firstRunStartedAtMs - agent.createdAtMs)
+    } : {},
+    ...agent.lastRunStartedAtMs ? { last_run_started_at: new Date(agent.lastRunStartedAtMs).toISOString() } : {},
+    ...agent.lastRunCompletedAtMs ? { last_run_completed_at: new Date(agent.lastRunCompletedAtMs).toISOString() } : {},
+    ...typeof agent.lastRunDurationMs === "number" ? { last_run_duration_ms: Math.max(0, agent.lastRunDurationMs) } : {},
     ...agent.lastError ? { last_error: agent.lastError } : {},
     ...agent.lastResult ? {
       last_result: {
@@ -6228,6 +7012,83 @@ function buildSnapshot(agent) {
     } : {}
   };
 }
+function emitBackgroundNotification(agent, options) {
+  if (!options?.onBackgroundMessage) {
+    return;
+  }
+  if (!isBackgroundNotification(agent.notification)) {
+    return;
+  }
+  const payload = {
+    agent_id: agent.id,
+    status: buildSnapshot(agent)
+  };
+  const body = JSON.stringify(payload);
+  try {
+    options.onBackgroundMessage(
+      `${SUBAGENT_NOTIFICATION_OPEN_TAG}${body}${SUBAGENT_NOTIFICATION_CLOSE_TAG}`
+    );
+  } catch {
+  }
+}
+function isBackgroundNotification(notification) {
+  return notification === "run_completed" || notification === "run_failed" || notification === "closed";
+}
+function summarizeAgentStatuses(status) {
+  const summary = {};
+  for (const [agentId, snapshot] of Object.entries(status)) {
+    const value = snapshot.status;
+    summary[agentId] = typeof value === "string" ? value : "unknown";
+  }
+  return summary;
+}
+function buildSpawnAgentTypeDescription() {
+  const sections = BUILT_IN_AGENT_TYPES.map((name) => {
+    const description = BUILT_IN_AGENT_TYPE_DESCRIPTIONS[name];
+    return `${name}: {
+${description}
+}`;
+  });
+  return [
+    `Optional type name for the new agent. If omitted, \`${DEFAULT_AGENT_TYPE}\` is used.`,
+    "Available roles:",
+    ...sections
+  ].join("\n");
+}
+function resolveAgentType(agentType) {
+  const requestedRoleName = trimToUndefined(agentType) ?? DEFAULT_AGENT_TYPE;
+  const roleName = requestedRoleName;
+  const description = BUILT_IN_AGENT_TYPE_DESCRIPTIONS[roleName];
+  if (!description) {
+    throw new Error(`unknown agent_type '${requestedRoleName}'`);
+  }
+  return {
+    roleName,
+    roleInstructions: BUILT_IN_AGENT_TYPE_INSTRUCTIONS[roleName]
+  };
+}
+function reserveAgentNickname(roleName, counts) {
+  const prefixByRole = {
+    default: "Agent",
+    researcher: "Researcher",
+    worker: "Worker",
+    reviewer: "Reviewer"
+  };
+  const prefix = prefixByRole[roleName] ?? "Agent";
+  const next = (counts.get(prefix) ?? 0) + 1;
+  counts.set(prefix, next);
+  return `${prefix}_${next}`;
+}
+function joinInstructionBlocks(...blocks) {
+  const parts = blocks.map(trimToUndefined).filter((value) => Boolean(value));
+  if (parts.length === 0) {
+    return void 0;
+  }
+  return parts.join("\n\n");
+}
+function randomSubmissionId() {
+  return `sub_${randomBytes2(6).toString("hex")}`;
+}
 function normalizeInteger(value, fallback, min, max) {
   const parsed = Number.isFinite(value) ? Math.floor(value) : fallback;
   return Math.max(min, Math.min(max, parsed));
@@ -6966,29 +7827,33 @@ var DEFAULT_MAX_LINE_LENGTH = 500;
 var DEFAULT_GREP_MAX_SCANNED_FILES = 2e4;
 var DEFAULT_TAB_WIDTH = 4;
 var codexReadFileInputSchema = z6.object({
-  file_path: z6.string().min(1).describe("Absolute path to the file"),
-  offset: z6.number().int().min(1).optional().describe("The line number to start reading from. Must be 1 or greater."),
-  limit: z6.number().int().min(1).optional().describe("The maximum number of lines to return."),
-  mode: z6.enum(["slice", "indentation"]).optional().describe('Optional mode selector: "slice" (default) or "indentation".'),
+  file_path: z6.string().min(1).describe(
+    "Path to the file (relative to cwd, or absolute. In sandbox mode, / maps to the sandbox root)."
+  ),
+  offset: z6.number().int().min(1).nullish().describe("The line number to start reading from. Must be 1 or greater."),
+  limit: z6.number().int().min(1).nullish().describe("The maximum number of lines to return."),
+  mode: z6.enum(["slice", "indentation"]).nullish().describe('Optional mode selector: "slice" (default) or "indentation".'),
   indentation: z6.object({
-    anchor_line: z6.number().int().min(1).optional(),
-    max_levels: z6.number().int().min(0).optional(),
-    include_siblings: z6.boolean().optional(),
-    include_header: z6.boolean().optional(),
-    max_lines: z6.number().int().min(1).optional()
-  }).optional()
+    anchor_line: z6.number().int().min(1).nullish(),
+    max_levels: z6.number().int().min(0).nullish(),
+    include_siblings: z6.boolean().nullish(),
+    include_header: z6.boolean().nullish(),
+    max_lines: z6.number().int().min(1).nullish()
+  }).nullish()
 });
 var codexListDirInputSchema = z6.object({
-  dir_path: z6.string().min(1).describe("Absolute path to the directory to list."),
-  offset: z6.number().int().min(1).optional().describe("The entry number to start listing from. Must be 1 or greater."),
-  limit: z6.number().int().min(1).optional().describe("The maximum number of entries to return."),
-  depth: z6.number().int().min(1).optional().describe("The maximum directory depth to traverse. Must be 1 or greater.")
+  dir_path: z6.string().min(1).describe(
+    "Path to the directory to list (relative to cwd, or absolute. In sandbox mode, / maps to the sandbox root)."
+  ),
+  offset: z6.number().int().min(1).nullish().describe("The entry number to start listing from. Must be 1 or greater."),
+  limit: z6.number().int().min(1).nullish().describe("The maximum number of entries to return."),
+  depth: z6.number().int().min(1).nullish().describe("The maximum directory depth to traverse. Must be 1 or greater.")
 });
 var codexGrepFilesInputSchema = z6.object({
   pattern: z6.string().min(1).describe("Regular expression pattern to search for."),
-  include: z6.string().optional().describe('Optional glob limiting searched files (for example "*.rs").'),
-  path: z6.string().optional().describe("Directory or file path to search. Defaults to cwd."),
-  limit: z6.number().int().min(1).optional().describe("Maximum number of file paths to return (defaults to 100).")
+  include: z6.string().nullish().describe('Optional glob limiting searched files (for example "*.rs").'),
+  path: z6.string().nullish().describe("Directory or file path to search. Defaults to cwd."),
+  limit: z6.number().int().min(1).nullish().describe("Maximum number of file paths to return (defaults to 100).")
 });
 var applyPatchInputSchema = z6.object({
   input: z6.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
@@ -7223,9 +8088,6 @@ function createGlobTool(options = {}) {
 }
 async function readFileCodex(input, options) {
   const runtime = resolveRuntime(options);
-  if (!path5.isAbsolute(input.file_path)) {
-    throw new Error("file_path must be an absolute path");
-  }
   const filePath = resolvePathWithPolicy(input.file_path, runtime.cwd, runtime.allowOutsideCwd);
   await runAccessHook2(runtime, {
     cwd: runtime.cwd,
@@ -7268,15 +8130,12 @@ async function readFileCodex(input, options) {
     maxLevels: indentation.max_levels ?? 0,
     includeSiblings: indentation.include_siblings ?? false,
     includeHeader: indentation.include_header ?? true,
-    maxLines: indentation.max_lines
+    maxLines: indentation.max_lines ?? void 0
   });
   return selected.map((record) => `L${record.number}: ${record.display}`).join("\n");
 }
 async function listDirectoryCodex(input, options) {
   const runtime = resolveRuntime(options);
-  if (!path5.isAbsolute(input.dir_path)) {
-    throw new Error("dir_path must be an absolute path");
-  }
   const dirPath = resolvePathWithPolicy(input.dir_path, runtime.cwd, runtime.allowOutsideCwd);
   await runAccessHook2(runtime, {
     cwd: runtime.cwd,
@@ -7304,7 +8163,7 @@ async function listDirectoryCodex(input, options) {
   const remaining = entries.length - startIndex;
   const cappedLimit = Math.min(limit, remaining);
   const selected = entries.slice(startIndex, startIndex + cappedLimit);
-  const output = [`Absolute path: ${dirPath}`];
+  const output = [`Absolute path: ${toSandboxDisplayPath(dirPath, runtime.cwd)}`];
   for (const entry of selected) {
     output.push(formatListEntry(entry));
   }
@@ -7690,10 +8549,17 @@ function mapApplyPatchAction(action) {
 }
 function resolvePathWithPolicy(inputPath, cwd, allowOutsideCwd) {
   const absolutePath = path5.isAbsolute(inputPath) ? path5.resolve(inputPath) : path5.resolve(cwd, inputPath);
-  if (!allowOutsideCwd && !isPathInsideCwd2(absolutePath, cwd)) {
-    throw new Error(`path "${inputPath}" resolves outside cwd "${cwd}"`);
+  if (allowOutsideCwd || isPathInsideCwd2(absolutePath, cwd)) {
+    return absolutePath;
   }
-  return absolutePath;
+  if (path5.isAbsolute(inputPath)) {
+    const sandboxRelativePath = inputPath.replace(/^[/\\]+/, "");
+    const sandboxRootedPath = path5.resolve(cwd, sandboxRelativePath);
+    if (isPathInsideCwd2(sandboxRootedPath, cwd)) {
+      return sandboxRootedPath;
+    }
+  }
+  throw new Error(`path "${inputPath}" resolves outside cwd "${cwd}"`);
 }
 function isPathInsideCwd2(candidatePath, cwd) {
   const relative = path5.relative(cwd, candidatePath);
@@ -7709,6 +8575,16 @@ function toDisplayPath2(absolutePath, cwd) {
   }
   return absolutePath;
 }
+function toSandboxDisplayPath(absolutePath, cwd) {
+  const relative = path5.relative(cwd, absolutePath);
+  if (relative === "") {
+    return "/";
+  }
+  if (!relative.startsWith("..") && !path5.isAbsolute(relative)) {
+    return `/${normalizeSlashes(relative)}`;
+  }
+  return normalizeSlashes(absolutePath);
+}
 function splitLines(content) {
   const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
   const lines = normalized.split("\n");
@@ -8046,7 +8922,71 @@ function isNoEntError(error) {
 
 // src/agent.ts
 async function runAgentLoop(request) {
-  return await runAgentLoopInternal(request, { depth: 0 });
+  const telemetry = createAgentTelemetrySession(request.telemetry);
+  try {
+    return await runAgentLoopInternal(request, { depth: 0, telemetry });
+  } finally {
+    await telemetry?.flush();
+  }
+}
+function mergeAbortSignals2(first, second) {
+  if (!first) {
+    return second;
+  }
+  if (!second) {
+    return first;
+  }
+  const controller = new AbortController();
+  const abortFrom = (signal) => {
+    if (!controller.signal.aborted) {
+      controller.abort(signal.reason);
+    }
+  };
+  if (first.aborted) {
+    abortFrom(first);
+  } else {
+    first.addEventListener("abort", () => abortFrom(first), { once: true });
+  }
+  if (second.aborted) {
+    abortFrom(second);
+  } else {
+    second.addEventListener("abort", () => abortFrom(second), { once: true });
+  }
+  return controller.signal;
+}
+function streamAgentLoop(request) {
+  const queue = createAsyncQueue();
+  const abortController = new AbortController();
+  const steering = request.steering ?? createToolLoopSteeringChannel();
+  const signal = mergeAbortSignals2(request.signal, abortController.signal);
+  const sourceOnEvent = request.onEvent;
+  const result = (async () => {
+    try {
+      const output = await runAgentLoop({
+        ...request,
+        steering,
+        ...signal ? { signal } : {},
+        onEvent: (event) => {
+          sourceOnEvent?.(event);
+          queue.push(event);
+        }
+      });
+      queue.close();
+      return output;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      queue.fail(err);
+      throw err;
+    }
+  })();
+  return {
+    events: queue.iterable,
+    result,
+    append: steering.append,
+    steer: steering.steer,
+    pendingSteeringCount: steering.pendingCount,
+    abort: () => abortController.abort()
+  };
 }
 async function runAgentLoopInternal(request, context) {
   const {
@@ -8056,19 +8996,28 @@ async function runAgentLoopInternal(request, context) {
     subagentTool,
     subagent_tool,
     subagents,
+    telemetry,
     ...toolLoopRequest
   } = request;
+  const telemetrySession = context.telemetry ?? createAgentTelemetrySession(telemetry);
+  const runId = randomRunId();
+  const startedAtMs = Date.now();
+  const steeringChannel = toolLoopRequest.steering ?? createToolLoopSteeringChannel();
+  const toolLoopRequestWithSteering = toolLoopRequest.steering === steeringChannel ? toolLoopRequest : { ...toolLoopRequest, steering: steeringChannel };
   const filesystemSelection = filesystemTool ?? filesystem_tool;
   const subagentSelection = subagentTool ?? subagent_tool ?? subagents;
   const filesystemTools = resolveFilesystemTools(request.model, filesystemSelection);
   const resolvedSubagentConfig = resolveSubagentToolConfig(subagentSelection, context.depth);
   const subagentController = createSubagentController({
+    runId,
     model: request.model,
     depth: context.depth,
+    telemetry: telemetrySession,
     customTools: customTools ?? {},
     filesystemSelection,
     subagentSelection,
-    toolLoopRequest,
+    toolLoopRequest: toolLoopRequestWithSteering,
+    steering: steeringChannel,
     resolvedSubagentConfig
   });
   const mergedTools = mergeToolSets(
@@ -8081,16 +9030,58 @@ async function runAgentLoopInternal(request, context) {
     );
   }
   const instructions = buildLoopInstructions(
-    toolLoopRequest.instructions,
+    toolLoopRequestWithSteering.instructions,
     resolvedSubagentConfig,
     context.depth
   );
+  const emitTelemetry = createAgentTelemetryEmitter({
+    session: telemetrySession,
+    runId,
+    parentRunId: context.parentRunId,
+    depth: context.depth,
+    model: request.model
+  });
+  emitTelemetry({
+    type: "agent.run.started",
+    inputMode: typeof request.input === "string" ? "string" : "messages",
+    customToolCount: Object.keys(customTools ?? {}).length,
+    mergedToolCount: Object.keys(mergedTools).length,
+    filesystemToolsEnabled: Object.keys(filesystemTools).length > 0,
+    subagentToolsEnabled: resolvedSubagentConfig.enabled
+  });
+  const sourceOnEvent = toolLoopRequestWithSteering.onEvent;
+  const includeLlmStreamEvents = telemetrySession?.includeLlmStreamEvents === true;
+  const wrappedOnEvent = sourceOnEvent || includeLlmStreamEvents ? (event) => {
+    sourceOnEvent?.(event);
+    if (includeLlmStreamEvents) {
+      emitTelemetry({ type: "agent.run.stream", event });
+    }
+  } : void 0;
   try {
-    return await runToolLoop({
-      ...toolLoopRequest,
+    const result = await runToolLoop({
+      ...toolLoopRequestWithSteering,
       ...instructions ? { instructions } : {},
+      ...wrappedOnEvent ? { onEvent: wrappedOnEvent } : {},
       tools: mergedTools
     });
+    emitTelemetry({
+      type: "agent.run.completed",
+      success: true,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      stepCount: result.steps.length,
+      toolCallCount: countToolCalls(result),
+      totalCostUsd: result.totalCostUsd,
+      usage: summarizeResultUsage(result)
+    });
+    return result;
+  } catch (error) {
+    emitTelemetry({
+      type: "agent.run.completed",
+      success: false,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      error: toErrorMessage2(error)
+    });
+    throw error;
   } finally {
     await subagentController?.closeAll();
   }
@@ -8136,6 +9127,10 @@ function createSubagentController(params) {
     config: params.resolvedSubagentConfig,
     parentDepth: params.depth,
     parentModel: params.resolvedSubagentConfig.model ?? params.model,
+    forkContextMessages: normalizeForkContextMessages(params.toolLoopRequest.input),
+    onBackgroundMessage: (message) => {
+      params.steering?.append({ role: "user", content: message });
+    },
     buildChildInstructions: (spawnInstructions, childDepth) => buildChildInstructions(spawnInstructions, params.resolvedSubagentConfig, childDepth),
     runSubagent: async (subagentRequest) => {
       const childCustomTools = params.resolvedSubagentConfig.inheritTools ? params.customTools : {};
@@ -8153,7 +9148,11 @@ function createSubagentController(params) {
           openAiReasoningEffort: params.toolLoopRequest.openAiReasoningEffort,
           signal: subagentRequest.signal
         },
-        { depth: params.depth + 1 }
+        {
+          depth: params.depth + 1,
+          parentRunId: params.runId,
+          telemetry: params.telemetry
+        }
       );
     }
   });
@@ -8200,10 +9199,142 @@ function buildChildInstructions(spawnInstructions, config, childDepth) {
   }
   return blocks.length > 0 ? blocks.join("\n\n") : void 0;
 }
+function normalizeForkContextMessages(input) {
+  if (typeof input === "string") {
+    return [{ role: "user", content: input }];
+  }
+  return input.map((message) => ({
+    role: message.role,
+    content: Array.isArray(message.content) ? [...message.content] : message.content
+  }));
+}
 function trimToUndefined2(value) {
   const trimmed = value?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
 }
+function randomRunId() {
+  return randomBytes3(8).toString("hex");
+}
+function toIsoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toErrorMessage2(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Unknown error";
+}
+function countToolCalls(result) {
+  let count = 0;
+  for (const step of result.steps) {
+    count += step.toolCalls.length;
+  }
+  return count;
+}
+function sumUsageValue(current, next) {
+  if (typeof next !== "number" || !Number.isFinite(next)) {
+    return current;
+  }
+  const normalizedNext = Math.max(0, next);
+  if (typeof current !== "number" || !Number.isFinite(current)) {
+    return normalizedNext;
+  }
+  return Math.max(0, current) + normalizedNext;
+}
+function summarizeResultUsage(result) {
+  let summary;
+  for (const step of result.steps) {
+    const usage = step.usage;
+    if (!usage) {
+      continue;
+    }
+    summary = {
+      promptTokens: sumUsageValue(summary?.promptTokens, usage.promptTokens),
+      cachedTokens: sumUsageValue(summary?.cachedTokens, usage.cachedTokens),
+      responseTokens: sumUsageValue(summary?.responseTokens, usage.responseTokens),
+      responseImageTokens: sumUsageValue(summary?.responseImageTokens, usage.responseImageTokens),
+      thinkingTokens: sumUsageValue(summary?.thinkingTokens, usage.thinkingTokens),
+      totalTokens: sumUsageValue(summary?.totalTokens, usage.totalTokens),
+      toolUsePromptTokens: sumUsageValue(summary?.toolUsePromptTokens, usage.toolUsePromptTokens)
+    };
+  }
+  return summary;
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function isAgentTelemetrySink(value) {
+  return typeof value === "object" && value !== null && typeof value.emit === "function";
+}
+function resolveTelemetrySelection(telemetry) {
+  if (!telemetry) {
+    return void 0;
+  }
+  if (isAgentTelemetrySink(telemetry)) {
+    return { sink: telemetry };
+  }
+  if (isAgentTelemetrySink(telemetry.sink)) {
+    return telemetry;
+  }
+  throw new Error("Invalid runAgentLoop telemetry config: expected a sink with emit(event).");
+}
+function createAgentTelemetrySession(telemetry) {
+  const config = resolveTelemetrySelection(telemetry);
+  if (!config) {
+    return void 0;
+  }
+  const pending = /* @__PURE__ */ new Set();
+  const trackPromise = (promise) => {
+    pending.add(promise);
+    promise.finally(() => {
+      pending.delete(promise);
+    });
+  };
+  const emit = (event) => {
+    try {
+      const output = config.sink.emit(event);
+      if (isPromiseLike(output)) {
+        const task = Promise.resolve(output).then(() => void 0).catch(() => void 0);
+        trackPromise(task);
+      }
+    } catch {
+    }
+  };
+  const flush = async () => {
+    while (pending.size > 0) {
+      await Promise.allSettled([...pending]);
+    }
+    if (typeof config.sink.flush === "function") {
+      try {
+        await config.sink.flush();
+      } catch {
+      }
+    }
+  };
+  return {
+    includeLlmStreamEvents: config.includeLlmStreamEvents === true,
+    emit,
+    flush
+  };
+}
+function createAgentTelemetryEmitter(params) {
+  return (event) => {
+    if (!params.session) {
+      return;
+    }
+    params.session.emit({
+      ...event,
+      timestamp: toIsoNow(),
+      runId: params.runId,
+      ...params.parentRunId ? { parentRunId: params.parentRunId } : {},
+      depth: params.depth,
+      model: params.model
+    });
+  };
+}
 export {
   CHATGPT_MODEL_IDS,
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
@@ -8226,6 +9357,7 @@ export {
   appendMarkdownSourcesSection,
   applyPatch,
   configureGemini,
+  configureModelConcurrency,
   convertGooglePartsToLlmParts,
   createApplyPatchTool,
   createCodexApplyPatchTool,
@@ -8245,6 +9377,7 @@ export {
   createReadFilesTool,
   createReplaceTool,
   createRgSearchTool,
+  createToolLoopSteeringChannel,
   createWriteFileTool,
   customTool,
   encodeChatGptAuthJson,
@@ -8270,13 +9403,16 @@ export {
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
+  resetModelConcurrencyConfig,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,
   runToolLoop,
   sanitisePartForLogging,
+  streamAgentLoop,
   streamJson,
   streamText,
+  streamToolLoop,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
   tool