@ljoukov/llm 3.0.3 → 3.0.4

package/dist/index.js

@@ -1582,6 +1582,66 @@ function parseEventBlock(raw) {
   }
 }
 
+// src/utils/modelConcurrency.ts
+var MIN_MODEL_CONCURRENCY_CAP = 1;
+var MAX_MODEL_CONCURRENCY_CAP = 64;
+var DEFAULT_MODEL_CONCURRENCY_CAP = 3;
+function parsePositiveInteger(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const normalized = raw.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  if (!/^-?\d+$/u.test(normalized)) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(normalized, 10);
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  return parsed;
+}
+function clampModelConcurrencyCap(value) {
+  if (!Number.isFinite(value)) {
+    return DEFAULT_MODEL_CONCURRENCY_CAP;
+  }
+  const rounded = Math.floor(value);
+  if (rounded < MIN_MODEL_CONCURRENCY_CAP) {
+    return MIN_MODEL_CONCURRENCY_CAP;
+  }
+  if (rounded > MAX_MODEL_CONCURRENCY_CAP) {
+    return MAX_MODEL_CONCURRENCY_CAP;
+  }
+  return rounded;
+}
+function normalizeModelIdForEnv(modelId) {
+  return modelId.trim().replace(/[^A-Za-z0-9]+/gu, "_").replace(/^_+|_+$/gu, "").toUpperCase();
+}
+function resolveModelConcurrencyCap(options) {
+  const env = options.env ?? process.env;
+  const providerPrefix = options.providerEnvPrefix;
+  const defaultCap = clampModelConcurrencyCap(options.defaultCap ?? DEFAULT_MODEL_CONCURRENCY_CAP);
+  const normalizedModelId = options.modelId ? normalizeModelIdForEnv(options.modelId) : "";
+  const candidateKeys = [
+    ...normalizedModelId ? [
+      `${providerPrefix}_MAX_PARALLEL_REQUESTS_MODEL_${normalizedModelId}`,
+      `LLM_MAX_PARALLEL_REQUESTS_MODEL_${normalizedModelId}`
+    ] : [],
+    `${providerPrefix}_MAX_PARALLEL_REQUESTS_PER_MODEL`,
+    "LLM_MAX_PARALLEL_REQUESTS_PER_MODEL"
+  ];
+  for (const key of candidateKeys) {
+    const parsed = parsePositiveInteger(env[key]);
+    if (parsed === void 0) {
+      continue;
+    }
+    return clampModelConcurrencyCap(parsed);
+  }
+  return defaultCap;
+}
+
 // src/utils/scheduler.ts
 function sleep(ms) {
   return new Promise((resolve) => {
@@ -1597,13 +1657,72 @@ function toError(value) {
   }
   return new Error("Unknown error");
 }
+function getStatusCode(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const maybe = error;
+  const candidates = [maybe.status, maybe.statusCode];
+  for (const candidate of candidates) {
+    if (typeof candidate === "number") {
+      return candidate;
+    }
+    if (typeof candidate === "string") {
+      const parsed = Number.parseInt(candidate, 10);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+  if (typeof maybe.code === "number") {
+    return maybe.code;
+  }
+  return void 0;
+}
+function getErrorText(error) {
+  if (error instanceof Error) {
+    return error.message.toLowerCase();
+  }
+  if (typeof error === "string") {
+    return error.toLowerCase();
+  }
+  if (error && typeof error === "object") {
+    const maybe = error;
+    const code = typeof maybe.code === "string" ? maybe.code : "";
+    const message = typeof maybe.message === "string" ? maybe.message : "";
+    return `${code} ${message}`.trim().toLowerCase();
+  }
+  return "";
+}
+function defaultIsOverloadError(error) {
+  const status = getStatusCode(error);
+  if (status === 429 || status === 503 || status === 529) {
+    return true;
+  }
+  const text = getErrorText(error);
+  if (!text) {
+    return false;
+  }
+  return text.includes("rate limit") || text.includes("too many requests") || text.includes("resource exhausted") || text.includes("resource_exhausted") || text.includes("overload");
+}
 function createCallScheduler(options = {}) {
   const maxParallelRequests = Math.max(1, Math.floor(options.maxParallelRequests ?? 3));
+  const initialParallelRequests = Math.min(
+    maxParallelRequests,
+    Math.max(1, Math.floor(options.initialParallelRequests ?? Math.min(3, maxParallelRequests)))
+  );
+  const increaseAfterConsecutiveSuccesses = Math.max(
+    1,
+    Math.floor(options.increaseAfterConsecutiveSuccesses ?? 8)
+  );
   const minIntervalBetweenStartMs = Math.max(0, Math.floor(options.minIntervalBetweenStartMs ?? 0));
   const startJitterMs = Math.max(0, Math.floor(options.startJitterMs ?? 0));
   const retryPolicy = options.retry;
+  const isOverloadError2 = options.isOverloadError ?? defaultIsOverloadError;
   let activeCount = 0;
   let lastStartTime = 0;
+  let currentParallelLimit = initialParallelRequests;
+  let consecutiveSuccesses = 0;
   let startSpacingChain = Promise.resolve();
   const queue = [];
   async function applyStartSpacing() {
@@ -1634,6 +1753,10 @@ function createCallScheduler(options = {}) {
       await applyStartSpacing();
       return await fn();
     } catch (error) {
+      if (isOverloadError2(error)) {
+        consecutiveSuccesses = 0;
+        currentParallelLimit = Math.max(1, Math.ceil(currentParallelLimit / 2));
+      }
       const err = toError(error);
       if (!retryPolicy || attempt >= retryPolicy.maxAttempts) {
         throw err;
@@ -1653,7 +1776,7 @@ function createCallScheduler(options = {}) {
     }
   }
   function drainQueue() {
-    while (activeCount < maxParallelRequests && queue.length > 0) {
+    while (activeCount < currentParallelLimit && queue.length > 0) {
       const task = queue.shift();
       if (!task) {
         continue;
@@ -1667,6 +1790,11 @@ function createCallScheduler(options = {}) {
       const job = async () => {
         try {
           const result = await attemptWithRetries(fn, 1);
+          consecutiveSuccesses += 1;
+          if (currentParallelLimit < maxParallelRequests && consecutiveSuccesses >= increaseAfterConsecutiveSuccesses) {
+            currentParallelLimit += 1;
+            consecutiveSuccesses = 0;
+          }
           resolve(result);
         } catch (error) {
           reject(toError(error));
@@ -1756,13 +1884,28 @@ function getFireworksClient() {
 }
 
 // src/fireworks/calls.ts
-var scheduler = createCallScheduler({
-  maxParallelRequests: 3,
-  minIntervalBetweenStartMs: 200,
-  startJitterMs: 200
-});
-async function runFireworksCall(fn) {
-  return scheduler.run(async () => fn(getFireworksClient()));
+var DEFAULT_SCHEDULER_KEY = "__default__";
+var schedulerByModel = /* @__PURE__ */ new Map();
+function getSchedulerForModel(modelId) {
+  const normalizedModelId = modelId?.trim();
+  const schedulerKey = normalizedModelId && normalizedModelId.length > 0 ? normalizedModelId : DEFAULT_SCHEDULER_KEY;
+  const existing = schedulerByModel.get(schedulerKey);
+  if (existing) {
+    return existing;
+  }
+  const created = createCallScheduler({
+    maxParallelRequests: resolveModelConcurrencyCap({
+      providerEnvPrefix: "FIREWORKS",
+      modelId: normalizedModelId
+    }),
+    minIntervalBetweenStartMs: 200,
+    startJitterMs: 200
+  });
+  schedulerByModel.set(schedulerKey, created);
+  return created;
+}
+async function runFireworksCall(fn, modelId) {
+  return getSchedulerForModel(modelId).run(async () => fn(getFireworksClient()));
 }
 
 // src/fireworks/models.ts
@@ -2098,6 +2241,18 @@ function shouldRetry(error) {
   }
   return false;
 }
+function isOverloadError(error) {
+  const status = getStatus(error);
+  if (status === 429 || status === 503 || status === 529) {
+    return true;
+  }
+  const reason = getErrorReason(error);
+  if (reason && RATE_LIMIT_REASONS.has(reason)) {
+    return true;
+  }
+  const message = getErrorMessage(error).toLowerCase();
+  return message.includes("rate limit") || message.includes("too many requests") || message.includes("resource exhausted") || message.includes("resource_exhausted");
+}
 function retryDelayMs(attempt) {
   const baseRetryDelayMs = 500;
   const maxRetryDelayMs = 4e3;
@@ -2105,23 +2260,39 @@ function retryDelayMs(attempt) {
   const jitter = Math.floor(Math.random() * 200);
   return base + jitter;
 }
-var scheduler2 = createCallScheduler({
-  maxParallelRequests: 3,
-  minIntervalBetweenStartMs: 200,
-  startJitterMs: 200,
-  retry: {
-    maxAttempts: 3,
-    getDelayMs: (attempt, error) => {
-      if (!shouldRetry(error)) {
-        return null;
+var DEFAULT_SCHEDULER_KEY2 = "__default__";
+var schedulerByModel2 = /* @__PURE__ */ new Map();
+function getSchedulerForModel2(modelId) {
+  const normalizedModelId = modelId?.trim();
+  const schedulerKey = normalizedModelId && normalizedModelId.length > 0 ? normalizedModelId : DEFAULT_SCHEDULER_KEY2;
+  const existing = schedulerByModel2.get(schedulerKey);
+  if (existing) {
+    return existing;
+  }
+  const created = createCallScheduler({
+    maxParallelRequests: resolveModelConcurrencyCap({
+      providerEnvPrefix: "GOOGLE",
+      modelId: normalizedModelId
+    }),
+    minIntervalBetweenStartMs: 200,
+    startJitterMs: 200,
+    isOverloadError,
+    retry: {
+      maxAttempts: 3,
+      getDelayMs: (attempt, error) => {
+        if (!shouldRetry(error)) {
+          return null;
+        }
+        const hintedDelay = getRetryAfterMs(error);
+        return hintedDelay ?? retryDelayMs(attempt);
       }
-      const hintedDelay = getRetryAfterMs(error);
-      return hintedDelay ?? retryDelayMs(attempt);
     }
-  }
-});
-async function runGeminiCall(fn) {
-  return scheduler2.run(async () => fn(await getGeminiClient()));
+  });
+  schedulerByModel2.set(schedulerKey, created);
+  return created;
+}
+async function runGeminiCall(fn, modelId) {
+  return getSchedulerForModel2(modelId).run(async () => fn(await getGeminiClient()));
 }
 
 // src/openai/client.ts
@@ -2282,13 +2453,28 @@ function getOpenAiClient() {
 
 // src/openai/calls.ts
 var DEFAULT_OPENAI_REASONING_EFFORT = "medium";
-var scheduler3 = createCallScheduler({
-  maxParallelRequests: 3,
-  minIntervalBetweenStartMs: 200,
-  startJitterMs: 200
-});
-async function runOpenAiCall(fn) {
-  return scheduler3.run(async () => fn(getOpenAiClient()));
+var DEFAULT_SCHEDULER_KEY3 = "__default__";
+var schedulerByModel3 = /* @__PURE__ */ new Map();
+function getSchedulerForModel3(modelId) {
+  const normalizedModelId = modelId?.trim();
+  const schedulerKey = normalizedModelId && normalizedModelId.length > 0 ? normalizedModelId : DEFAULT_SCHEDULER_KEY3;
+  const existing = schedulerByModel3.get(schedulerKey);
+  if (existing) {
+    return existing;
+  }
+  const created = createCallScheduler({
+    maxParallelRequests: resolveModelConcurrencyCap({
+      providerEnvPrefix: "OPENAI",
+      modelId: normalizedModelId
+    }),
+    minIntervalBetweenStartMs: 200,
+    startJitterMs: 200
+  });
+  schedulerByModel3.set(schedulerKey, created);
+  return created;
+}
+async function runOpenAiCall(fn, modelId) {
+  return getSchedulerForModel3(modelId).run(async () => fn(getOpenAiClient()));
 }
 
 // src/openai/models.ts
@@ -4050,7 +4236,7 @@ async function runTextCall(params) {
           }
         }
       }
-    });
+    }, modelForProvider);
   } else if (provider === "chatgpt") {
     const chatGptInput = toChatGptInput(contents);
     const reasoningEffort = resolveOpenAiReasoningEffort(
@@ -4145,7 +4331,7 @@ async function runTextCall(params) {
         pushDelta("response", textOutput);
       }
       latestUsage = extractFireworksUsageTokens(response.usage);
-    });
+    }, modelForProvider);
   } else {
     const geminiContents = contents.map(convertLlmContentToGeminiContent);
     const config = {
@@ -4213,7 +4399,7 @@ async function runTextCall(params) {
         }
       }
       grounding = latestGrounding;
-    });
+    }, modelForProvider);
   }
   const mergedParts = mergeConsecutiveTextParts(responseParts);
   const content = mergedParts.length > 0 ? { role: responseRole ?? "assistant", parts: mergedParts } : void 0;
@@ -4640,7 +4826,7 @@ async function runToolLoop(request) {
           }
         }
         return await stream.finalResponse();
-      });
+      }, providerInfo.model);
       modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
       emitEvent({ type: "model", modelVersion });
       if (finalResponse.error) {
@@ -4916,7 +5102,7 @@ async function runToolLoop(request) {
           },
           { signal: request.signal }
         );
-      });
+      }, providerInfo.model);
       const modelVersion = typeof response.model === "string" ? response.model : request.model;
       request.onEvent?.({ type: "model", modelVersion });
       const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
@@ -5113,7 +5299,7 @@ async function runToolLoop(request) {
         usageMetadata: latestUsageMetadata,
         modelVersion: resolvedModelVersion ?? request.model
       };
-    });
+    }, request.model);
     const usageTokens = extractGeminiUsageTokens(response.usageMetadata);
     const modelVersion = response.modelVersion ?? request.model;
     const stepCostUsd = estimateCallCostUsd({
@@ -5451,13 +5637,630 @@ function appendMarkdownSourcesSection(value, sources) {
 ${lines}`;
 }
 
+// src/agent/subagents.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { z as z4 } from "zod";
+var DEFAULT_SUBAGENT_MAX_AGENTS = 4;
+var DEFAULT_SUBAGENT_MAX_DEPTH = 2;
+var DEFAULT_SUBAGENT_WAIT_TIMEOUT_MS = 1500;
+var DEFAULT_SUBAGENT_MAX_WAIT_TIMEOUT_MS = 9e4;
+var 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 SUBAGENT_CONTROL_TOOL_NAMES = ["send_input", "resume_agent", "wait", "close_agent"];
+var subagentInputItemSchema = z4.object({
+  text: z4.string().optional(),
+  image_url: z4.string().optional(),
+  name: z4.string().optional(),
+  path: z4.string().optional(),
+  type: z4.string().optional()
+}).passthrough();
+var spawnAgentInputSchema = z4.object({
+  prompt: z4.string().optional().describe("Initial prompt for the subagent."),
+  message: z4.string().optional().describe("Codex-style alias for prompt."),
+  items: z4.array(subagentInputItemSchema).optional().describe("Optional Codex-style input items."),
+  agent_type: z4.string().optional().describe("Codex-style agent type hint."),
+  instructions: z4.string().optional().describe("Optional extra instructions for this subagent instance."),
+  model: z4.string().optional().describe("Optional model override. Must be one of this package's supported text model ids."),
+  max_steps: z4.number().int().min(1).max(MAX_SUBAGENT_MAX_STEPS).optional().describe("Optional max step budget for each subagent run.")
+}).refine((value) => Boolean(resolvePromptValue(value.prompt, value.message, value.items)), {
+  message: "Either prompt, message, or items must contain non-empty input."
+});
+var sendInputSchema = z4.object({
+  agent_id: z4.string().optional().describe("Target subagent id."),
+  id: z4.string().optional().describe("Codex-style alias for agent_id."),
+  input: z4.string().optional().describe("New user input queued for the subagent."),
+  message: z4.string().optional().describe("Codex-style alias for input."),
+  items: z4.array(subagentInputItemSchema).optional().describe("Optional Codex-style input items."),
+  interrupt: z4.boolean().optional().describe("If true and currently running, aborts active run before queuing input.")
+}).refine((value) => Boolean(resolveAgentIdValue(value.agent_id, value.id)), {
+  message: "agent_id (or id) is required."
+}).refine((value) => Boolean(resolvePromptValue(value.input, value.message, value.items)), {
+  message: "input (or message/items) is required."
+});
+var resumeAgentSchema = z4.object({
+  agent_id: z4.string().optional().describe("Target subagent id."),
+  id: z4.string().optional().describe("Codex-style alias for agent_id.")
+}).refine((value) => Boolean(resolveAgentIdValue(value.agent_id, value.id)), {
+  message: "agent_id (or id) is required."
+});
+var waitSchema = z4.object({
+  agent_id: z4.string().optional().describe("Target subagent id."),
+  id: z4.string().optional().describe("Codex-style alias for agent_id."),
+  ids: z4.array(z4.string().min(1)).optional().describe("Codex-style list of agent ids."),
+  timeout_ms: z4.number().int().min(1).optional().describe("Optional wait timeout in milliseconds.")
+}).refine(
+  (value) => Boolean(resolveAgentIdValue(value.agent_id, value.id)) || Array.isArray(value.ids) && value.ids.length > 0,
+  {
+    message: "agent_id/id or ids is required."
+  }
+);
+var closeSchema = z4.object({
+  agent_id: z4.string().optional().describe("Target subagent id."),
+  id: z4.string().optional().describe("Codex-style alias for agent_id.")
+}).refine((value) => Boolean(resolveAgentIdValue(value.agent_id, value.id)), {
+  message: "agent_id (or id) is required."
+});
+function resolveSubagentToolConfig(selection, currentDepth) {
+  const defaults = {
+    maxAgents: DEFAULT_SUBAGENT_MAX_AGENTS,
+    maxDepth: DEFAULT_SUBAGENT_MAX_DEPTH,
+    defaultWaitTimeoutMs: DEFAULT_SUBAGENT_WAIT_TIMEOUT_MS,
+    maxWaitTimeoutMs: DEFAULT_SUBAGENT_MAX_WAIT_TIMEOUT_MS,
+    promptPattern: "codex",
+    inheritTools: true,
+    inheritFilesystemTool: true
+  };
+  if (selection === void 0 || selection === false) {
+    return {
+      enabled: false,
+      ...defaults
+    };
+  }
+  const config = selection === true ? {} : selection;
+  const maxAgents = normalizeInteger(
+    config.maxAgents,
+    defaults.maxAgents,
+    1,
+    MAX_SUBAGENT_MAX_AGENTS
+  );
+  const maxDepth = normalizeInteger(config.maxDepth, defaults.maxDepth, 1, MAX_SUBAGENT_MAX_DEPTH);
+  const defaultWaitTimeoutMs = normalizeInteger(
+    config.defaultWaitTimeoutMs,
+    defaults.defaultWaitTimeoutMs,
+    1,
+    MAX_SUBAGENT_WAIT_TIMEOUT_MS
+  );
+  const maxWaitTimeoutMs = normalizeInteger(
+    config.maxWaitTimeoutMs,
+    defaults.maxWaitTimeoutMs,
+    defaultWaitTimeoutMs,
+    MAX_SUBAGENT_WAIT_TIMEOUT_MS
+  );
+  const promptPattern = config.promptPattern ?? defaults.promptPattern;
+  const instructions = trimToUndefined(config.instructions);
+  const maxSteps = normalizeOptionalInteger(config.maxSteps, 1, MAX_SUBAGENT_MAX_STEPS);
+  const enabled = config.enabled !== false && currentDepth < maxDepth;
+  return {
+    enabled,
+    maxAgents,
+    maxDepth,
+    defaultWaitTimeoutMs,
+    maxWaitTimeoutMs,
+    promptPattern,
+    ...instructions ? { instructions } : {},
+    ...config.model ? { model: config.model } : {},
+    ...maxSteps ? { maxSteps } : {},
+    inheritTools: config.inheritTools !== false,
+    inheritFilesystemTool: config.inheritFilesystemTool !== false
+  };
+}
+function buildCodexSubagentOrchestratorInstructions(params) {
+  return [
+    "Subagent orchestration tools are available: spawn_agent, send_input, resume_agent, wait, close_agent.",
+    "Use this control pattern:",
+    "1. spawn_agent with a focused prompt.",
+    "2. wait on that agent_id until it is no longer running.",
+    "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}.`
+  ].join("\n");
+}
+function buildCodexSubagentWorkerInstructions(params) {
+  return [
+    `You are a delegated subagent at depth ${params.depth}/${params.maxDepth}.`,
+    "Focus on the delegated task, use available tools when needed, and return concise actionable output.",
+    "If blocked, report the blocker explicitly."
+  ].join("\n");
+}
+function createSubagentToolController(options) {
+  if (!options.config.enabled) {
+    return {
+      tools: {},
+      closeAll: async () => {
+      }
+    };
+  }
+  const agents = /* @__PURE__ */ new Map();
+  const tools = {
+    spawn_agent: tool({
+      description: "Spawns a subagent asynchronously. Returns immediately with agent status and id.",
+      inputSchema: spawnAgentInputSchema,
+      execute: async (input) => {
+        if (countActiveAgents(agents) >= options.config.maxAgents) {
+          throw new Error(
+            `Subagent limit reached (${options.config.maxAgents}). Close existing agents before spawning new ones.`
+          );
+        }
+        const childDepth = options.parentDepth + 1;
+        if (childDepth > options.config.maxDepth) {
+          throw new Error(
+            `Subagent depth limit reached (${options.config.maxDepth}). Cannot spawn at depth ${childDepth}.`
+          );
+        }
+        let model = options.config.model ?? options.parentModel;
+        if (input.model) {
+          if (!isLlmTextModelId(input.model)) {
+            throw new Error(`Unsupported subagent model id: ${input.model}`);
+          }
+          model = input.model;
+        }
+        const id = `agent_${randomBytes2(6).toString("hex")}`;
+        const now = Date.now();
+        const initialPrompt = resolvePromptValue(input.prompt, input.message, input.items);
+        if (!initialPrompt) {
+          throw new Error("spawn_agent requires prompt/message/items with non-empty text.");
+        }
+        const agent = {
+          id,
+          depth: childDepth,
+          model,
+          status: "idle",
+          createdAtMs: now,
+          updatedAtMs: now,
+          pendingInputs: [initialPrompt],
+          history: [],
+          ...options.buildChildInstructions ? {
+            instructions: trimToUndefined(
+              options.buildChildInstructions(input.instructions, childDepth)
+            )
+          } : input.instructions ? { instructions: trimToUndefined(input.instructions) } : {},
+          ...input.max_steps ? { maxSteps: input.max_steps } : options.config.maxSteps ? { maxSteps: options.config.maxSteps } : {},
+          turns: 0,
+          notification: "spawned",
+          notificationMessage: `Spawned subagent ${id}.`,
+          version: 1,
+          waiters: /* @__PURE__ */ new Set()
+        };
+        agents.set(id, agent);
+        startRun(agent, options);
+        return buildToolResponse(agent, {
+          notification: "spawned",
+          message: `Spawned subagent ${id}.`
+        });
+      }
+    }),
+    send_input: tool({
+      description: "Queues new input for an existing subagent.",
+      inputSchema: sendInputSchema,
+      execute: async (input) => {
+        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.");
+        }
+        if (agent.status === "closed") {
+          throw new Error(`Subagent ${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);
+        }
+        agent.pendingInputs.push(nextInput);
+        setNotification(agent, "input_queued", `Queued input for ${agent.id}.`);
+        return buildToolResponse(agent);
+      }
+    }),
+    resume_agent: tool({
+      description: "Resumes a subagent run when queued input is available.",
+      inputSchema: resumeAgentSchema,
+      execute: async (input) => {
+        const agentId = resolveAgentIdValue(input.agent_id, input.id);
+        if (!agentId) {
+          throw new Error("resume_agent requires agent_id or id.");
+        }
+        const agent = requireAgent(agents, agentId);
+        if (agent.status === "closed") {
+          setNotification(agent, "already_closed", `Subagent ${agent.id} is already closed.`);
+          return buildToolResponse(agent, {
+            notification: "already_closed",
+            message: `Subagent ${agent.id} is already closed.`
+          });
+        }
+        const outcome = startRun(agent, options);
+        if (outcome === "started") {
+          return buildToolResponse(agent, {
+            notification: "run_started",
+            message: `Started subagent ${agent.id}.`
+          });
+        }
+        if (outcome === "already_running") {
+          setNotification(agent, "already_running", `Subagent ${agent.id} is already running.`);
+          return buildToolResponse(agent);
+        }
+        setNotification(agent, "no_pending_input", `Subagent ${agent.id} has no queued input.`);
+        return buildToolResponse(agent);
+      }
+    }),
+    wait: tool({
+      description: "Waits for a running subagent to change state or until timeout. Returns current 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.");
+        }
+        const timeoutMs = normalizeInteger(
+          input.timeout_ms,
+          options.config.defaultWaitTimeoutMs,
+          1,
+          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 });
+          }
+        }
+        return buildToolResponse(agent, void 0, { timed_out: false, timeout_ms: timeoutMs });
+      }
+    }),
+    close_agent: tool({
+      description: "Closes a subagent and aborts its current run if it is still running.",
+      inputSchema: closeSchema,
+      execute: async (input) => {
+        const agentId = resolveAgentIdValue(input.agent_id, input.id);
+        if (!agentId) {
+          throw new Error("close_agent requires agent_id or id.");
+        }
+        const agent = requireAgent(agents, agentId);
+        if (agent.status === "closed") {
+          setNotification(agent, "already_closed", `Subagent ${agent.id} is already closed.`);
+          return buildToolResponse(agent, void 0, { cancelled: false });
+        }
+        const cancelled = closeSubagent(agent, `Closed ${agent.id}.`);
+        return buildToolResponse(
+          agent,
+          { notification: "closed", message: `Closed ${agent.id}.` },
+          { cancelled }
+        );
+      }
+    })
+  };
+  return {
+    tools,
+    closeAll: async () => {
+      const running = [];
+      for (const agent of agents.values()) {
+        if (agent.status !== "closed") {
+          closeSubagent(agent, `Parent agent loop closed ${agent.id}.`);
+        }
+        if (agent.runningPromise) {
+          running.push(agent.runningPromise);
+        }
+      }
+      if (running.length > 0) {
+        await Promise.race([Promise.allSettled(running), sleep2(2e3)]);
+      }
+    }
+  };
+}
+function requireAgent(agents, id) {
+  const agent = agents.get(id);
+  if (!agent) {
+    throw new Error(`Unknown subagent id: ${id}`);
+  }
+  return agent;
+}
+function resolveAgentIdValue(agentId, idAlias) {
+  const preferred = agentId?.trim();
+  if (preferred) {
+    return preferred;
+  }
+  const alias = idAlias?.trim();
+  return alias ?? "";
+}
+function resolveAgentIdList(agentId, idAlias, ids) {
+  if (Array.isArray(ids) && ids.length > 0) {
+    return [...new Set(ids.map((value) => value.trim()).filter(Boolean))];
+  }
+  const single = resolveAgentIdValue(agentId, idAlias);
+  return single ? [single] : [];
+}
+function resolvePromptValue(prompt, message, items) {
+  const promptValue = prompt?.trim();
+  if (promptValue) {
+    return promptValue;
+  }
+  const messageValue = message?.trim();
+  if (messageValue) {
+    return messageValue;
+  }
+  const itemText = resolveInputItemsText(items);
+  return itemText ?? "";
+}
+function resolveInputItemsText(items) {
+  if (!items || items.length === 0) {
+    return void 0;
+  }
+  const lines = [];
+  for (const item of items) {
+    if (typeof item.text === "string" && item.text.trim().length > 0) {
+      lines.push(item.text.trim());
+      continue;
+    }
+    const itemType = typeof item.type === "string" ? item.type.trim() : "";
+    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 (lines.length === 0) {
+    return void 0;
+  }
+  return lines.join("\n");
+}
+function countActiveAgents(agents) {
+  let count = 0;
+  for (const agent of agents.values()) {
+    if (agent.status !== "closed") {
+      count += 1;
+    }
+  }
+  return count;
+}
+async function waitForAnyAgentStatus(agents, ids, timeoutMs) {
+  const requested = ids.map((id) => requireAgent(agents, id));
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    const status = {};
+    for (const agent of requested) {
+      if (agent.status !== "running") {
+        status[agent.id] = buildSnapshot(agent);
+      }
+    }
+    if (Object.keys(status).length > 0) {
+      return status;
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      return {};
+    }
+    await Promise.race(
+      requested.map(async (agent) => {
+        const changed = await waitForVersionChange(agent, agent.version, remaining);
+        if (!changed) {
+          return;
+        }
+      })
+    );
+  }
+}
+function setNotification(agent, notification, message) {
+  agent.notification = notification;
+  agent.notificationMessage = message;
+  agent.updatedAtMs = Date.now();
+  agent.version += 1;
+  notifyWaiters(agent);
+}
+function setLifecycle(agent, status, notification, message) {
+  agent.status = status;
+  setNotification(agent, notification, message);
+}
+function notifyWaiters(agent) {
+  if (agent.waiters.size === 0) {
+    return;
+  }
+  const waiters = [...agent.waiters];
+  agent.waiters.clear();
+  for (const notify of waiters) {
+    notify();
+  }
+}
+function startRun(agent, options) {
+  if (agent.runningPromise) {
+    return "already_running";
+  }
+  const nextInput = agent.pendingInputs.shift();
+  if (!nextInput) {
+    return "no_pending_input";
+  }
+  const input = [...agent.history, { role: "user", content: nextInput }];
+  const abortController = new AbortController();
+  agent.abortController = abortController;
+  agent.lastError = void 0;
+  setLifecycle(
+    agent,
+    "running",
+    "run_started",
+    `Subagent ${agent.id} started run ${agent.turns + 1}.`
+  );
+  const runPromise = (async () => {
+    try {
+      const result = await options.runSubagent({
+        agentId: agent.id,
+        depth: agent.depth,
+        model: agent.model,
+        input,
+        instructions: agent.instructions,
+        maxSteps: agent.maxSteps,
+        signal: abortController.signal
+      });
+      if (agent.status === "closed") {
+        return;
+      }
+      agent.lastResult = result;
+      agent.lastError = void 0;
+      agent.turns += 1;
+      agent.history = [...input, { role: "assistant", content: result.text }];
+      setLifecycle(
+        agent,
+        "idle",
+        "run_completed",
+        `Subagent ${agent.id} completed run ${agent.turns}.`
+      );
+    } catch (error) {
+      if (agent.status === "closed") {
+        return;
+      }
+      if (abortController.signal.aborted) {
+        setLifecycle(agent, "idle", "input_queued", `Subagent ${agent.id} run interrupted.`);
+        return;
+      }
+      const message = toErrorMessage(error);
+      agent.lastError = message;
+      setLifecycle(agent, "failed", "run_failed", `Subagent ${agent.id} failed: ${message}`);
+    } finally {
+      agent.runningPromise = void 0;
+      agent.abortController = void 0;
+    }
+  })();
+  agent.runningPromise = runPromise;
+  return "started";
+}
+function closeSubagent(agent, message) {
+  const cancelled = Boolean(agent.runningPromise);
+  agent.pendingInputs = [];
+  if (agent.abortController) {
+    agent.abortController.abort("close_agent");
+  }
+  setLifecycle(agent, "closed", "closed", message);
+  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;
+  }
+  return await new Promise((resolve) => {
+    const waiter = () => {
+      cleanup();
+      resolve(true);
+    };
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve(false);
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      agent.waiters.delete(waiter);
+    };
+    agent.waiters.add(waiter);
+  });
+}
+function buildToolResponse(agent, override, extra = {}) {
+  const notification = override?.notification ?? agent.notification;
+  const message = override?.message ?? agent.notificationMessage;
+  const snapshot = buildSnapshot(agent);
+  return {
+    agent_id: snapshot.agent_id,
+    notification,
+    message,
+    status: snapshot.status,
+    agent: snapshot,
+    tool_availability: snapshot.status === "closed" ? [] : [...SUBAGENT_CONTROL_TOOL_NAMES],
+    ...extra
+  };
+}
+function buildSnapshot(agent) {
+  return {
+    agent_id: agent.id,
+    status: agent.status,
+    depth: agent.depth,
+    model: agent.model,
+    pending_inputs: agent.pendingInputs.length,
+    turns: agent.turns,
+    created_at: new Date(agent.createdAtMs).toISOString(),
+    updated_at: new Date(agent.updatedAtMs).toISOString(),
+    ...agent.lastError ? { last_error: agent.lastError } : {},
+    ...agent.lastResult ? {
+      last_result: {
+        text: agent.lastResult.text,
+        thoughts: agent.lastResult.thoughts,
+        step_count: agent.lastResult.steps.length,
+        total_cost_usd: agent.lastResult.totalCostUsd
+      }
+    } : {}
+  };
+}
+function normalizeInteger(value, fallback, min, max) {
+  const parsed = Number.isFinite(value) ? Math.floor(value) : fallback;
+  return Math.max(min, Math.min(max, parsed));
+}
+function normalizeOptionalInteger(value, min, max) {
+  if (!Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.max(min, Math.min(max, Math.floor(value)));
+}
+function trimToUndefined(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function toErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function sleep2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
 // src/tools/filesystemTools.ts
 import path5 from "path";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // src/tools/applyPatch.ts
 import path4 from "path";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/tools/filesystem.ts
 import { promises as fs3 } from "fs";
@@ -5753,8 +6556,8 @@ var CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION = [
   "- You must prefix new lines with `+` even when creating a new file",
   "- File references can only be relative, NEVER ABSOLUTE."
 ].join("\n");
-var applyPatchToolInputSchema = z4.object({
-  input: z4.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
+var applyPatchToolInputSchema = z5.object({
+  input: z5.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
 });
 function createApplyPatchTool(options = {}) {
   return tool({
@@ -6162,100 +6965,100 @@ var MAX_GREP_LIMIT = 2e3;
 var DEFAULT_MAX_LINE_LENGTH = 500;
 var DEFAULT_GREP_MAX_SCANNED_FILES = 2e4;
 var DEFAULT_TAB_WIDTH = 4;
-var codexReadFileInputSchema = z5.object({
-  file_path: z5.string().min(1).describe("Absolute path to the file"),
-  offset: z5.number().int().min(1).optional().describe("The line number to start reading from. Must be 1 or greater."),
-  limit: z5.number().int().min(1).optional().describe("The maximum number of lines to return."),
-  mode: z5.enum(["slice", "indentation"]).optional().describe('Optional mode selector: "slice" (default) or "indentation".'),
-  indentation: z5.object({
-    anchor_line: z5.number().int().min(1).optional(),
-    max_levels: z5.number().int().min(0).optional(),
-    include_siblings: z5.boolean().optional(),
-    include_header: z5.boolean().optional(),
-    max_lines: z5.number().int().min(1).optional()
+var codexReadFileInputSchema = z6.object({
+  file_path: z6.string().min(1).describe("Absolute path to the file"),
+  offset: z6.number().int().min(1).optional().describe("The line number to start reading from. Must be 1 or greater."),
+  limit: z6.number().int().min(1).optional().describe("The maximum number of lines to return."),
+  mode: z6.enum(["slice", "indentation"]).optional().describe('Optional mode selector: "slice" (default) or "indentation".'),
+  indentation: z6.object({
+    anchor_line: z6.number().int().min(1).optional(),
+    max_levels: z6.number().int().min(0).optional(),
+    include_siblings: z6.boolean().optional(),
+    include_header: z6.boolean().optional(),
+    max_lines: z6.number().int().min(1).optional()
   }).optional()
 });
-var codexListDirInputSchema = z5.object({
-  dir_path: z5.string().min(1).describe("Absolute path to the directory to list."),
-  offset: z5.number().int().min(1).optional().describe("The entry number to start listing from. Must be 1 or greater."),
-  limit: z5.number().int().min(1).optional().describe("The maximum number of entries to return."),
-  depth: z5.number().int().min(1).optional().describe("The maximum directory depth to traverse. Must be 1 or greater.")
+var codexListDirInputSchema = z6.object({
+  dir_path: z6.string().min(1).describe("Absolute path to the directory to list."),
+  offset: z6.number().int().min(1).optional().describe("The entry number to start listing from. Must be 1 or greater."),
+  limit: z6.number().int().min(1).optional().describe("The maximum number of entries to return."),
+  depth: z6.number().int().min(1).optional().describe("The maximum directory depth to traverse. Must be 1 or greater.")
 });
-var codexGrepFilesInputSchema = z5.object({
-  pattern: z5.string().min(1).describe("Regular expression pattern to search for."),
-  include: z5.string().optional().describe('Optional glob limiting searched files (for example "*.rs").'),
-  path: z5.string().optional().describe("Directory or file path to search. Defaults to cwd."),
-  limit: z5.number().int().min(1).optional().describe("Maximum number of file paths to return (defaults to 100).")
+var codexGrepFilesInputSchema = z6.object({
+  pattern: z6.string().min(1).describe("Regular expression pattern to search for."),
+  include: z6.string().optional().describe('Optional glob limiting searched files (for example "*.rs").'),
+  path: z6.string().optional().describe("Directory or file path to search. Defaults to cwd."),
+  limit: z6.number().int().min(1).optional().describe("Maximum number of file paths to return (defaults to 100).")
 });
-var applyPatchInputSchema = z5.object({
-  input: z5.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
+var applyPatchInputSchema = z6.object({
+  input: z6.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
 });
-var geminiReadFileInputSchema = z5.object({
-  file_path: z5.string().min(1),
-  offset: z5.number().int().min(0).nullish(),
-  limit: z5.number().int().min(1).nullish()
+var geminiReadFileInputSchema = z6.object({
+  file_path: z6.string().min(1),
+  offset: z6.number().int().min(0).nullish(),
+  limit: z6.number().int().min(1).nullish()
 });
-var geminiReadFilesInputSchema = z5.object({
-  paths: z5.array(z5.string().min(1)).min(1),
-  line_offset: z5.number().int().min(0).nullish(),
-  line_limit: z5.number().int().min(1).nullish(),
-  char_offset: z5.number().int().min(0).nullish(),
-  char_limit: z5.number().int().min(1).nullish(),
-  include_line_numbers: z5.boolean().nullish()
+var geminiReadFilesInputSchema = z6.object({
+  paths: z6.array(z6.string().min(1)).min(1),
+  line_offset: z6.number().int().min(0).nullish(),
+  line_limit: z6.number().int().min(1).nullish(),
+  char_offset: z6.number().int().min(0).nullish(),
+  char_limit: z6.number().int().min(1).nullish(),
+  include_line_numbers: z6.boolean().nullish()
 }).superRefine((value, context) => {
   const hasLineWindow = value.line_offset !== void 0 || value.line_limit !== void 0;
   const hasCharWindow = value.char_offset !== void 0 || value.char_limit !== void 0;
   if (hasLineWindow && hasCharWindow) {
     context.addIssue({
-      code: z5.ZodIssueCode.custom,
+      code: z6.ZodIssueCode.custom,
       message: "Use either line_* or char_* window arguments, not both."
     });
   }
 });
-var geminiWriteFileInputSchema = z5.object({
-  file_path: z5.string().min(1),
-  content: z5.string()
+var geminiWriteFileInputSchema = z6.object({
+  file_path: z6.string().min(1),
+  content: z6.string()
 });
-var geminiReplaceInputSchema = z5.object({
-  file_path: z5.string().min(1),
-  instruction: z5.string().min(1),
-  old_string: z5.string(),
-  new_string: z5.string(),
-  expected_replacements: z5.number().int().min(1).nullish()
+var geminiReplaceInputSchema = z6.object({
+  file_path: z6.string().min(1),
+  instruction: z6.string().min(1),
+  old_string: z6.string(),
+  new_string: z6.string(),
+  expected_replacements: z6.number().int().min(1).nullish()
 });
-var geminiListDirectoryInputSchema = z5.object({
-  dir_path: z5.string().min(1),
-  ignore: z5.array(z5.string()).nullish(),
-  file_filtering_options: z5.object({
-    respect_git_ignore: z5.boolean().nullish(),
-    respect_gemini_ignore: z5.boolean().nullish()
+var geminiListDirectoryInputSchema = z6.object({
+  dir_path: z6.string().min(1),
+  ignore: z6.array(z6.string()).nullish(),
+  file_filtering_options: z6.object({
+    respect_git_ignore: z6.boolean().nullish(),
+    respect_gemini_ignore: z6.boolean().nullish()
   }).nullish()
 });
-var geminiRgSearchInputSchema = z5.object({
-  pattern: z5.string().min(1),
-  path: z5.string().nullish(),
-  glob: z5.string().nullish(),
-  case_sensitive: z5.boolean().nullish(),
-  exclude_pattern: z5.string().nullish(),
-  names_only: z5.boolean().nullish(),
-  max_matches_per_file: z5.number().int().min(1).nullish(),
-  max_results: z5.number().int().min(1).nullish()
+var geminiRgSearchInputSchema = z6.object({
+  pattern: z6.string().min(1),
+  path: z6.string().nullish(),
+  glob: z6.string().nullish(),
+  case_sensitive: z6.boolean().nullish(),
+  exclude_pattern: z6.string().nullish(),
+  names_only: z6.boolean().nullish(),
+  max_matches_per_file: z6.number().int().min(1).nullish(),
+  max_results: z6.number().int().min(1).nullish()
 });
-var geminiGrepSearchInputSchema = z5.object({
-  pattern: z5.string().min(1),
-  dir_path: z5.string().nullish(),
-  include: z5.string().nullish(),
-  exclude_pattern: z5.string().nullish(),
-  names_only: z5.boolean().nullish(),
-  max_matches_per_file: z5.number().int().min(1).nullish(),
-  total_max_matches: z5.number().int().min(1).nullish()
+var geminiGrepSearchInputSchema = z6.object({
+  pattern: z6.string().min(1),
+  dir_path: z6.string().nullish(),
+  include: z6.string().nullish(),
+  exclude_pattern: z6.string().nullish(),
+  names_only: z6.boolean().nullish(),
+  max_matches_per_file: z6.number().int().min(1).nullish(),
+  total_max_matches: z6.number().int().min(1).nullish()
 });
-var geminiGlobInputSchema = z5.object({
-  pattern: z5.string().min(1),
-  dir_path: z5.string().nullish(),
-  case_sensitive: z5.boolean().nullish(),
-  respect_git_ignore: z5.boolean().nullish(),
-  respect_gemini_ignore: z5.boolean().nullish()
+var geminiGlobInputSchema = z6.object({
+  pattern: z6.string().min(1),
+  dir_path: z6.string().nullish(),
+  case_sensitive: z6.boolean().nullish(),
+  respect_git_ignore: z6.boolean().nullish(),
+  respect_gemini_ignore: z6.boolean().nullish()
 });
 function resolveFilesystemToolProfile(model, profile = "auto") {
   if (profile !== "auto") {
@@ -7243,19 +8046,54 @@ function isNoEntError(error) {
 
 // src/agent.ts
 async function runAgentLoop(request) {
-  const { tools: customTools, filesystemTool, filesystem_tool, ...toolLoopRequest } = request;
+  return await runAgentLoopInternal(request, { depth: 0 });
+}
+async function runAgentLoopInternal(request, context) {
+  const {
+    tools: customTools,
+    filesystemTool,
+    filesystem_tool,
+    subagentTool,
+    subagent_tool,
+    subagents,
+    ...toolLoopRequest
+  } = request;
   const filesystemSelection = filesystemTool ?? filesystem_tool;
+  const subagentSelection = subagentTool ?? subagent_tool ?? subagents;
   const filesystemTools = resolveFilesystemTools(request.model, filesystemSelection);
-  const mergedTools = mergeToolSets(filesystemTools, customTools ?? {});
+  const resolvedSubagentConfig = resolveSubagentToolConfig(subagentSelection, context.depth);
+  const subagentController = createSubagentController({
+    model: request.model,
+    depth: context.depth,
+    customTools: customTools ?? {},
+    filesystemSelection,
+    subagentSelection,
+    toolLoopRequest,
+    resolvedSubagentConfig
+  });
+  const mergedTools = mergeToolSets(
+    mergeToolSets(filesystemTools, subagentController?.tools ?? {}),
+    customTools ?? {}
+  );
   if (Object.keys(mergedTools).length === 0) {
     throw new Error(
-      "runAgentLoop requires at least one tool. Provide `tools` or enable `filesystemTool`."
+      "runAgentLoop requires at least one tool. Provide `tools`, enable `filesystemTool`, or enable `subagentTool`."
     );
   }
-  return runToolLoop({
-    ...toolLoopRequest,
-    tools: mergedTools
-  });
+  const instructions = buildLoopInstructions(
+    toolLoopRequest.instructions,
+    resolvedSubagentConfig,
+    context.depth
+  );
+  try {
+    return await runToolLoop({
+      ...toolLoopRequest,
+      ...instructions ? { instructions } : {},
+      tools: mergedTools
+    });
+  } finally {
+    await subagentController?.closeAll();
+  }
 }
 function resolveFilesystemTools(model, selection) {
   if (selection === void 0 || selection === false) {
@@ -7283,13 +8121,89 @@ function mergeToolSets(base, extra) {
   for (const [toolName, toolSpec] of Object.entries(extra)) {
     if (Object.hasOwn(merged, toolName)) {
       throw new Error(
-        `Duplicate tool name "${toolName}" in runAgentLoop. Rename the custom tool or disable that filesystem tool.`
+        `Duplicate tool name "${toolName}" in runAgentLoop. Rename one of the conflicting tools or disable an overlapping built-in tool.`
       );
     }
     merged[toolName] = toolSpec;
   }
   return merged;
 }
+function createSubagentController(params) {
+  if (!params.resolvedSubagentConfig.enabled) {
+    return null;
+  }
+  return createSubagentToolController({
+    config: params.resolvedSubagentConfig,
+    parentDepth: params.depth,
+    parentModel: params.resolvedSubagentConfig.model ?? params.model,
+    buildChildInstructions: (spawnInstructions, childDepth) => buildChildInstructions(spawnInstructions, params.resolvedSubagentConfig, childDepth),
+    runSubagent: async (subagentRequest) => {
+      const childCustomTools = params.resolvedSubagentConfig.inheritTools ? params.customTools : {};
+      const childFilesystemSelection = params.resolvedSubagentConfig.inheritFilesystemTool ? params.filesystemSelection : false;
+      return await runAgentLoopInternal(
+        {
+          model: subagentRequest.model,
+          input: subagentRequest.input,
+          instructions: subagentRequest.instructions,
+          tools: childCustomTools,
+          filesystemTool: childFilesystemSelection,
+          subagentTool: params.subagentSelection,
+          modelTools: params.toolLoopRequest.modelTools,
+          maxSteps: subagentRequest.maxSteps,
+          openAiReasoningEffort: params.toolLoopRequest.openAiReasoningEffort,
+          signal: subagentRequest.signal
+        },
+        { depth: params.depth + 1 }
+      );
+    }
+  });
+}
+function buildLoopInstructions(baseInstructions, config, depth) {
+  if (!config.enabled) {
+    return trimToUndefined2(baseInstructions);
+  }
+  const blocks = [];
+  const base = trimToUndefined2(baseInstructions);
+  if (base) {
+    blocks.push(base);
+  }
+  if (config.promptPattern === "codex") {
+    blocks.push(
+      buildCodexSubagentOrchestratorInstructions({
+        currentDepth: depth,
+        maxDepth: config.maxDepth,
+        maxAgents: config.maxAgents
+      })
+    );
+  }
+  if (config.instructions) {
+    blocks.push(config.instructions);
+  }
+  return blocks.length > 0 ? blocks.join("\n\n") : void 0;
+}
+function buildChildInstructions(spawnInstructions, config, childDepth) {
+  const blocks = [];
+  if (config.promptPattern === "codex") {
+    blocks.push(
+      buildCodexSubagentWorkerInstructions({
+        depth: childDepth,
+        maxDepth: config.maxDepth
+      })
+    );
+  }
+  if (config.instructions) {
+    blocks.push(config.instructions);
+  }
+  const perSpawn = trimToUndefined2(spawnInstructions);
+  if (perSpawn) {
+    blocks.push(perSpawn);
+  }
+  return blocks.length > 0 ? blocks.join("\n\n") : void 0;
+}
+function trimToUndefined2(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
 export {
   CHATGPT_MODEL_IDS,
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,