@ljoukov/llm 3.0.6 → 3.0.8

package/dist/index.cjs

@@ -71,6 +71,7 @@ __export(index_exports, {
   createReadFilesTool: () => createReadFilesTool,
   createReplaceTool: () => createReplaceTool,
   createRgSearchTool: () => createRgSearchTool,
+  createToolLoopSteeringChannel: () => createToolLoopSteeringChannel,
   createWriteFileTool: () => createWriteFileTool,
   customTool: () => customTool,
   encodeChatGptAuthJson: () => encodeChatGptAuthJson,
@@ -102,8 +103,10 @@ __export(index_exports, {
   runAgentLoop: () => runAgentLoop,
   runToolLoop: () => runToolLoop,
   sanitisePartForLogging: () => sanitisePartForLogging,
+  streamAgentLoop: () => streamAgentLoop,
   streamJson: () => streamJson,
   streamText: () => streamText,
+  streamToolLoop: () => streamToolLoop,
   stripCodexCitationMarkers: () => stripCodexCitationMarkers,
   toGeminiJsonSchema: () => toGeminiJsonSchema,
   tool: () => tool
@@ -4908,6 +4911,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";
 }
@@ -5026,451 +5125,817 @@ 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 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;
-      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 markFirstModelEvent = () => {
-        if (firstModelEventAtMs === void 0) {
-          firstModelEventAtMs = Date.now();
-        }
+      const reasoning = {
+        effort: toOpenAiReasoningEffort(reasoningEffort),
+        summary: "detailed"
       };
-      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":
-                emitEvent({
-                  type: "delta",
-                  channel: "thought",
-                  text: typeof event.delta === "string" ? event.delta : ""
-                });
-                break;
-              case "response.refusal.delta":
-                emitEvent({ type: "blocked" });
-                break;
-              default:
-                break;
+      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();
+          },
+          providerInfo.model,
+          {
+            onSettled: (metrics) => {
+              schedulerMetrics = metrics;
             }
           }
-          return await stream.finalResponse();
-        },
-        providerInfo.model,
-        {
-          onSettled: (metrics) => {
-            schedulerMetrics = metrics;
+        );
+        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;
         }
-      );
-      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 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) {
-        finalText = responseText;
-        finalThoughts = reasoningSummary;
-        const stepCompletedAtMs2 = Date.now();
-        const timing2 = buildStepTiming({
+        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: stepCompletedAtMs2,
+          stepCompletedAtMs,
           modelCompletedAtMs,
           firstModelEventAtMs,
           schedulerMetrics,
-          toolExecutionMs: 0,
-          waitToolMs: 0
+          toolExecutionMs,
+          waitToolMs
         });
         steps.push({
           step: steps.length + 1,
           modelVersion,
           text: responseText || void 0,
           thoughts: reasoningSummary || void 0,
-          toolCalls: [],
+          toolCalls: stepToolCalls,
           usage: usageTokens,
           costUsd: stepCostUsd,
-          timing: timing2
+          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-${(0, import_node_crypto.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 = [];
-      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;
+            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 });
         }
-        if (entry.call.kind === "custom") {
-          toolOutputs.push({
-            type: "custom_tool_call_output",
-            call_id: entry.call.call_id,
-            output: mergeToolOutput(outputPayload)
+        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
           });
-        } else {
-          toolOutputs.push({
-            type: "function_call_output",
-            call_id: entry.call.call_id,
-            output: mergeToolOutput(outputPayload)
+          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;
         }
-      }
-      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: stepToolCalls,
-        usage: usageTokens,
-        costUsd: stepCostUsd,
-        timing
-      });
-      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-${(0, import_node_crypto.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;
-      const markFirstModelEvent = () => {
-        if (firstModelEventAtMs === void 0) {
-          firstModelEventAtMs = Date.now();
+        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 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) {
-            markFirstModelEvent();
-            request.onEvent?.({ type: "delta", channel: "thought", text: delta.thoughtDelta });
+        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) {
-            markFirstModelEvent();
-            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 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();
-      const responseToolCalls = response.toolCalls ?? [];
-      if (responseToolCalls.length === 0) {
-        finalText = responseText;
-        finalThoughts = reasoningSummaryText;
-        const stepCompletedAtMs2 = Date.now();
-        const timing2 = buildStepTiming({
+        const stepCompletedAtMs = Date.now();
+        const timing = buildStepTiming({
           stepStartedAtMs,
-          stepCompletedAtMs: stepCompletedAtMs2,
+          stepCompletedAtMs,
           modelCompletedAtMs,
           firstModelEventAtMs,
-          toolExecutionMs: 0,
-          waitToolMs: 0
+          toolExecutionMs,
+          waitToolMs
         });
         steps.push({
           step: steps.length + 1,
           modelVersion,
           text: responseText || void 0,
           thoughts: reasoningSummaryText || void 0,
-          toolCalls: [],
+          toolCalls,
           usage: usageTokens,
           costUsd: stepCostUsd,
-          timing: timing2
+          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;
             }
-          );
-        })
-      );
-      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;
+          }
+        );
+        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" });
         }
-        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 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
           });
-          toolOutputs.push({
-            type: "custom_tool_call_output",
-            call_id: entry.ids.callId,
-            output: mergeToolOutput(outputPayload)
+        }
+        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
           });
-        } else {
-          toolOutputs.push({
-            type: "function_call",
-            id: entry.ids.itemId,
-            call_id: entry.ids.callId,
-            name: entry.toolName,
-            arguments: entry.call.arguments,
-            status: "completed"
+          steps.push({
+            step: steps.length + 1,
+            modelVersion,
+            text: responseText || void 0,
+            thoughts: void 0,
+            toolCalls: [],
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            timing: timing2
           });
-          toolOutputs.push({
-            type: "function_call_output",
-            call_id: entry.ids.callId,
-            output: mergeToolOutput(outputPayload)
+          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
           });
         }
+        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));
+        }
       }
-      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,
-        usage: usageTokens,
-        costUsd: stepCostUsd,
-        timing
-      });
-      input = input.concat(toolOutputs);
-    }
-    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."
-      );
+      throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
     }
-    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 stepStartedAtMs = Date.now();
+      let firstModelEventAtMs;
       let schedulerMetrics;
-      const response = await runFireworksCall(
+      const markFirstModelEvent = () => {
+        if (firstModelEventAtMs === void 0) {
+          firstModelEventAtMs = Date.now();
+        }
+      };
+      const config = {
+        maxOutputTokens: 32e3,
+        tools: geminiTools,
+        toolConfig: {
+          functionCallingConfig: {
+            mode: import_genai2.FunctionCallingConfigMode.VALIDATED
+          }
+        },
+        thinkingConfig: resolveGeminiThinkingConfig(request.model)
+      };
+      const onEvent = request.onEvent;
+      const response = await runGeminiCall(
         async (client) => {
-          return await client.chat.completions.create(
-            {
-              model: providerInfo.model,
-              messages,
-              tools: fireworksTools,
-              tool_choice: "auto",
-              parallel_tool_calls: true
-            },
-            { signal: request.signal }
-          );
+          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
+          };
         },
-        providerInfo.model,
+        request.model,
         {
           onSettled: (metrics) => {
             schedulerMetrics = metrics;
@@ -5478,41 +5943,24 @@ async function runToolLoop(request) {
         }
       );
       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 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
-        });
-      }
-      const responseToolCalls = extractFireworksToolCalls(message);
-      if (responseToolCalls.length === 0) {
-        finalText = responseText;
-        finalThoughts = "";
+      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
@@ -5520,22 +5968,65 @@ async function runToolLoop(request) {
         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,
           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 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 stepToolCalls = [];
-      const callInputs = responseToolCalls.map((call, index) => {
+      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(
@@ -5550,44 +6041,51 @@ 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 });
+        toolCalls.push({ ...result, callId: entry.call.id });
         const callDurationMs = toToolResultDuration(result);
         toolExecutionMs += callDurationMs;
         if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
           waitToolMs += callDurationMs;
         }
-        assistantToolCalls.push({
-          id: entry.call.id,
-          type: "function",
-          function: {
+        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
@@ -5595,251 +6093,82 @@ async function runToolLoop(request) {
       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,
         timing
       });
-      messages.push({
-        role: "assistant",
-        ...responseText.length > 0 ? { content: responseText } : {},
-        tool_calls: assistantToolCalls
-      });
-      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 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: import_genai2.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 (response.functionCalls.length === 0) {
-      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
-      });
-      steps.push({
-        step: steps.length + 1,
-        modelVersion,
-        text: finalText || void 0,
-        thoughts: finalThoughts || void 0,
-        toolCalls: [],
-        usage: usageTokens,
-        costUsd: stepCostUsd,
-        timing: timing2
-      });
-      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 };
-          }
-        );
-      })
-    );
-    let toolExecutionMs = 0;
-    let waitToolMs = 0;
-    for (const { entry, result, outputPayload } of callResults) {
-      toolCalls.push({ ...result, callId: entry.call.id });
-      const callDurationMs = toToolResultDuration(result);
-      toolExecutionMs += callDurationMs;
-      if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
-        waitToolMs += callDurationMs;
-      }
-      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;
     }
-    const stepCompletedAtMs = Date.now();
-    const timing = buildStepTiming({
-      stepStartedAtMs,
-      stepCompletedAtMs,
-      modelCompletedAtMs,
-      firstModelEventAtMs,
-      schedulerMetrics,
-      toolExecutionMs,
-      waitToolMs
-    });
-    steps.push({
-      step: steps.length + 1,
-      modelVersion,
-      text: response.responseText.trim() || void 0,
-      thoughts: response.thoughtsText.trim() || void 0,
-      toolCalls,
-      usage: usageTokens,
-      costUsd: stepCostUsd,
-      timing
-    });
-    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 = import_zod3.z.enum(["pass", "fail"]);
 async function gradeGeneratedImage(params) {
@@ -6092,65 +6421,106 @@ var import_node_crypto3 = require("crypto");
 // src/agent/subagents.ts
 var import_node_crypto2 = require("crypto");
 var import_zod4 = require("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 = import_zod4.z.object({
-  text: import_zod4.z.string().optional(),
-  image_url: import_zod4.z.string().optional(),
-  name: import_zod4.z.string().optional(),
-  path: import_zod4.z.string().optional(),
-  type: import_zod4.z.string().optional()
+  text: import_zod4.z.string().nullish(),
+  image_url: import_zod4.z.string().nullish(),
+  name: import_zod4.z.string().nullish(),
+  path: import_zod4.z.string().nullish(),
+  type: import_zod4.z.string().nullish()
 }).passthrough();
 var spawnAgentInputSchema = import_zod4.z.object({
-  prompt: import_zod4.z.string().optional().describe("Initial prompt for the subagent."),
-  message: import_zod4.z.string().optional().describe("Codex-style alias for prompt."),
-  items: import_zod4.z.array(subagentInputItemSchema).optional().describe("Optional Codex-style input items."),
-  agent_type: import_zod4.z.string().optional().describe("Codex-style agent type hint."),
-  instructions: import_zod4.z.string().optional().describe("Optional extra instructions for this subagent instance."),
-  model: import_zod4.z.string().optional().describe("Optional model override. Must be one of this package's supported text model ids."),
-  max_steps: import_zod4.z.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: import_zod4.z.string().nullish().describe("Alias for message. Initial plain-text task for the new agent."),
+  message: import_zod4.z.string().nullish().describe("Initial plain-text task for the new agent. Use either message or items."),
+  items: import_zod4.z.array(subagentInputItemSchema).nullish().describe(
+    "Structured input items. Use this to pass explicit mentions (for example app:// connector paths)."
+  ),
+  agent_type: import_zod4.z.string().nullish().describe(SPAWN_AGENT_TYPE_DESCRIPTION),
+  fork_context: import_zod4.z.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: import_zod4.z.string().nullish().describe("Optional extra instructions for this subagent instance."),
+  model: import_zod4.z.string().nullish().describe("Optional model override. Must be one of this package's supported text model ids."),
+  max_steps: import_zod4.z.number().int().min(1).max(MAX_SUBAGENT_MAX_STEPS).nullish().describe("Optional max step budget for each subagent run.")
 });
 var sendInputSchema = import_zod4.z.object({
-  agent_id: import_zod4.z.string().optional().describe("Target subagent id."),
-  id: import_zod4.z.string().optional().describe("Codex-style alias for agent_id."),
-  input: import_zod4.z.string().optional().describe("New user input queued for the subagent."),
-  message: import_zod4.z.string().optional().describe("Codex-style alias for input."),
-  items: import_zod4.z.array(subagentInputItemSchema).optional().describe("Optional Codex-style input items."),
-  interrupt: import_zod4.z.boolean().optional().describe("If true and currently running, aborts active run before queuing input.")
+  agent_id: import_zod4.z.string().nullish().describe("Target subagent id."),
+  id: import_zod4.z.string().nullish().describe("Agent id to message (from spawn_agent)."),
+  input: import_zod4.z.string().nullish().describe("New user input queued for the subagent."),
+  message: import_zod4.z.string().nullish().describe("Legacy plain-text message to send to the agent. Use either message or items."),
+  items: import_zod4.z.array(subagentInputItemSchema).nullish().describe(
+    "Structured input items. Use this to pass explicit mentions (for example app:// connector paths)."
+  ),
+  interrupt: import_zod4.z.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 = import_zod4.z.object({
-  agent_id: import_zod4.z.string().optional().describe("Target subagent id."),
-  id: import_zod4.z.string().optional().describe("Codex-style alias for agent_id.")
+  agent_id: import_zod4.z.string().nullish().describe("Target subagent id."),
+  id: import_zod4.z.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 = import_zod4.z.object({
-  agent_id: import_zod4.z.string().optional().describe("Target subagent id."),
-  id: import_zod4.z.string().optional().describe("Codex-style alias for agent_id."),
-  ids: import_zod4.z.array(import_zod4.z.string().min(1)).optional().describe("Codex-style list of agent ids."),
-  timeout_ms: import_zod4.z.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: import_zod4.z.string().nullish().describe("Target subagent id."),
+  id: import_zod4.z.string().nullish().describe("Codex-style alias for agent_id."),
+  ids: import_zod4.z.array(import_zod4.z.string().min(1)).nullish().describe("Agent ids to wait on. Pass multiple ids to wait for whichever finishes first."),
+  timeout_ms: import_zod4.z.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 = import_zod4.z.object({
-  agent_id: import_zod4.z.string().optional().describe("Target subagent id."),
-  id: import_zod4.z.string().optional().describe("Codex-style alias for agent_id.")
+  agent_id: import_zod4.z.string().nullish().describe("Target subagent id."),
+  id: import_zod4.z.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."
 });
@@ -6158,6 +6528,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",
@@ -6178,10 +6549,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(
@@ -6198,6 +6575,7 @@ function resolveSubagentToolConfig(selection, currentDepth) {
     enabled,
     maxAgents,
     maxDepth,
+    minWaitTimeoutMs,
     defaultWaitTimeoutMs,
     maxWaitTimeoutMs,
     promptPattern,
@@ -6211,9 +6589,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}.`
@@ -6235,9 +6615,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) {
@@ -6260,24 +6641,36 @@ function createSubagentToolController(options) {
         }
         const id = `agent_${(0, import_node_crypto2.randomBytes)(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",
@@ -6287,41 +6680,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);
@@ -6330,10 +6732,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);
@@ -6352,41 +6755,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);
@@ -6398,7 +6802,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}.` },
@@ -6413,7 +6817,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);
@@ -6428,7 +6832,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;
 }
@@ -6447,17 +6851,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);
+  }
+  if (!hasText && !hasItems) {
+    throw new Error(params.missingError);
+  }
+  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 messageValue = message?.trim();
-  if (messageValue) {
-    return messageValue;
+  const itemText = resolveInputItemsText(params.items);
+  if (!itemText) {
+    throw new Error(params.emptyItemsError);
   }
-  const itemText = resolveInputItemsText(items);
-  return itemText ?? "";
+  return itemText;
 }
 function resolveInputItemsText(items) {
   if (!items || items.length === 0) {
@@ -6473,9 +6893,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) {
@@ -6587,6 +7026,7 @@ function startRun(agent, options) {
         "run_completed",
         `Subagent ${agent.id} completed run ${agent.turns}.`
       );
+      emitBackgroundNotification(agent, options);
     } catch (error) {
       if (agent.status === "closed") {
         return;
@@ -6598,6 +7038,7 @@ 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;
@@ -6609,30 +7050,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;
@@ -6670,6 +7097,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,
@@ -6695,6 +7124,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_${(0, import_node_crypto2.randomBytes)(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));
@@ -7433,29 +7939,33 @@ var DEFAULT_MAX_LINE_LENGTH = 500;
 var DEFAULT_GREP_MAX_SCANNED_FILES = 2e4;
 var DEFAULT_TAB_WIDTH = 4;
 var codexReadFileInputSchema = import_zod6.z.object({
-  file_path: import_zod6.z.string().min(1).describe("Absolute path to the file"),
-  offset: import_zod6.z.number().int().min(1).optional().describe("The line number to start reading from. Must be 1 or greater."),
-  limit: import_zod6.z.number().int().min(1).optional().describe("The maximum number of lines to return."),
-  mode: import_zod6.z.enum(["slice", "indentation"]).optional().describe('Optional mode selector: "slice" (default) or "indentation".'),
+  file_path: import_zod6.z.string().min(1).describe(
+    "Path to the file (relative to cwd, or absolute. In sandbox mode, / maps to the sandbox root)."
+  ),
+  offset: import_zod6.z.number().int().min(1).nullish().describe("The line number to start reading from. Must be 1 or greater."),
+  limit: import_zod6.z.number().int().min(1).nullish().describe("The maximum number of lines to return."),
+  mode: import_zod6.z.enum(["slice", "indentation"]).nullish().describe('Optional mode selector: "slice" (default) or "indentation".'),
   indentation: import_zod6.z.object({
-    anchor_line: import_zod6.z.number().int().min(1).optional(),
-    max_levels: import_zod6.z.number().int().min(0).optional(),
-    include_siblings: import_zod6.z.boolean().optional(),
-    include_header: import_zod6.z.boolean().optional(),
-    max_lines: import_zod6.z.number().int().min(1).optional()
-  }).optional()
+    anchor_line: import_zod6.z.number().int().min(1).nullish(),
+    max_levels: import_zod6.z.number().int().min(0).nullish(),
+    include_siblings: import_zod6.z.boolean().nullish(),
+    include_header: import_zod6.z.boolean().nullish(),
+    max_lines: import_zod6.z.number().int().min(1).nullish()
+  }).nullish()
 });
 var codexListDirInputSchema = import_zod6.z.object({
-  dir_path: import_zod6.z.string().min(1).describe("Absolute path to the directory to list."),
-  offset: import_zod6.z.number().int().min(1).optional().describe("The entry number to start listing from. Must be 1 or greater."),
-  limit: import_zod6.z.number().int().min(1).optional().describe("The maximum number of entries to return."),
-  depth: import_zod6.z.number().int().min(1).optional().describe("The maximum directory depth to traverse. Must be 1 or greater.")
+  dir_path: import_zod6.z.string().min(1).describe(
+    "Path to the directory to list (relative to cwd, or absolute. In sandbox mode, / maps to the sandbox root)."
+  ),
+  offset: import_zod6.z.number().int().min(1).nullish().describe("The entry number to start listing from. Must be 1 or greater."),
+  limit: import_zod6.z.number().int().min(1).nullish().describe("The maximum number of entries to return."),
+  depth: import_zod6.z.number().int().min(1).nullish().describe("The maximum directory depth to traverse. Must be 1 or greater.")
 });
 var codexGrepFilesInputSchema = import_zod6.z.object({
   pattern: import_zod6.z.string().min(1).describe("Regular expression pattern to search for."),
-  include: import_zod6.z.string().optional().describe('Optional glob limiting searched files (for example "*.rs").'),
-  path: import_zod6.z.string().optional().describe("Directory or file path to search. Defaults to cwd."),
-  limit: import_zod6.z.number().int().min(1).optional().describe("Maximum number of file paths to return (defaults to 100).")
+  include: import_zod6.z.string().nullish().describe('Optional glob limiting searched files (for example "*.rs").'),
+  path: import_zod6.z.string().nullish().describe("Directory or file path to search. Defaults to cwd."),
+  limit: import_zod6.z.number().int().min(1).nullish().describe("Maximum number of file paths to return (defaults to 100).")
 });
 var applyPatchInputSchema = import_zod6.z.object({
   input: import_zod6.z.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
@@ -7690,9 +8200,6 @@ function createGlobTool(options = {}) {
 }
 async function readFileCodex(input, options) {
   const runtime = resolveRuntime(options);
-  if (!import_node_path5.default.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,
@@ -7735,15 +8242,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 (!import_node_path5.default.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,
@@ -7771,7 +8275,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));
   }
@@ -8157,10 +8661,17 @@ function mapApplyPatchAction(action) {
 }
 function resolvePathWithPolicy(inputPath, cwd, allowOutsideCwd) {
   const absolutePath = import_node_path5.default.isAbsolute(inputPath) ? import_node_path5.default.resolve(inputPath) : import_node_path5.default.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 (import_node_path5.default.isAbsolute(inputPath)) {
+    const sandboxRelativePath = inputPath.replace(/^[/\\]+/, "");
+    const sandboxRootedPath = import_node_path5.default.resolve(cwd, sandboxRelativePath);
+    if (isPathInsideCwd2(sandboxRootedPath, cwd)) {
+      return sandboxRootedPath;
+    }
+  }
+  throw new Error(`path "${inputPath}" resolves outside cwd "${cwd}"`);
 }
 function isPathInsideCwd2(candidatePath, cwd) {
   const relative = import_node_path5.default.relative(cwd, candidatePath);
@@ -8176,6 +8687,16 @@ function toDisplayPath2(absolutePath, cwd) {
   }
   return absolutePath;
 }
+function toSandboxDisplayPath(absolutePath, cwd) {
+  const relative = import_node_path5.default.relative(cwd, absolutePath);
+  if (relative === "") {
+    return "/";
+  }
+  if (!relative.startsWith("..") && !import_node_path5.default.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");
@@ -8520,6 +9041,65 @@ async function runAgentLoop(request) {
     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 {
     tools: customTools,
@@ -8534,6 +9114,8 @@ async function runAgentLoopInternal(request, context) {
   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);
@@ -8546,7 +9128,8 @@ async function runAgentLoopInternal(request, context) {
     customTools: customTools ?? {},
     filesystemSelection,
     subagentSelection,
-    toolLoopRequest,
+    toolLoopRequest: toolLoopRequestWithSteering,
+    steering: steeringChannel,
     resolvedSubagentConfig
   });
   const mergedTools = mergeToolSets(
@@ -8559,7 +9142,7 @@ async function runAgentLoopInternal(request, context) {
     );
   }
   const instructions = buildLoopInstructions(
-    toolLoopRequest.instructions,
+    toolLoopRequestWithSteering.instructions,
     resolvedSubagentConfig,
     context.depth
   );
@@ -8578,7 +9161,7 @@ async function runAgentLoopInternal(request, context) {
     filesystemToolsEnabled: Object.keys(filesystemTools).length > 0,
     subagentToolsEnabled: resolvedSubagentConfig.enabled
   });
-  const sourceOnEvent = toolLoopRequest.onEvent;
+  const sourceOnEvent = toolLoopRequestWithSteering.onEvent;
   const includeLlmStreamEvents = telemetrySession?.includeLlmStreamEvents === true;
   const wrappedOnEvent = sourceOnEvent || includeLlmStreamEvents ? (event) => {
     sourceOnEvent?.(event);
@@ -8588,7 +9171,7 @@ async function runAgentLoopInternal(request, context) {
   } : void 0;
   try {
     const result = await runToolLoop({
-      ...toolLoopRequest,
+      ...toolLoopRequestWithSteering,
       ...instructions ? { instructions } : {},
       ...wrappedOnEvent ? { onEvent: wrappedOnEvent } : {},
       tools: mergedTools
@@ -8656,6 +9239,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 : {};
@@ -8724,6 +9311,15 @@ 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;
@@ -8894,6 +9490,7 @@ function createAgentTelemetryEmitter(params) {
   createReadFilesTool,
   createReplaceTool,
   createRgSearchTool,
+  createToolLoopSteeringChannel,
   createWriteFileTool,
   customTool,
   encodeChatGptAuthJson,
@@ -8925,8 +9522,10 @@ function createAgentTelemetryEmitter(params) {
   runAgentLoop,
   runToolLoop,
   sanitisePartForLogging,
+  streamAgentLoop,
   streamJson,
   streamText,
+  streamToolLoop,
   stripCodexCitationMarkers,
   toGeminiJsonSchema,
   tool