@ljoukov/llm 3.0.3 → 3.0.6

package/dist/index.cjs

@@ -51,6 +51,7 @@ __export(index_exports, {
   appendMarkdownSourcesSection: () => appendMarkdownSourcesSection,
   applyPatch: () => applyPatch,
   configureGemini: () => configureGemini,
+  configureModelConcurrency: () => configureModelConcurrency,
   convertGooglePartsToLlmParts: () => convertGooglePartsToLlmParts,
   createApplyPatchTool: () => createApplyPatchTool,
   createCodexApplyPatchTool: () => createCodexApplyPatchTool,
@@ -95,6 +96,7 @@ __export(index_exports, {
   loadLocalEnv: () => loadLocalEnv,
   parseJsonFromLlmText: () => parseJsonFromLlmText,
   refreshChatGptOauthToken: () => refreshChatGptOauthToken,
+  resetModelConcurrencyConfig: () => resetModelConcurrencyConfig,
   resolveFilesystemToolProfile: () => resolveFilesystemToolProfile,
   resolveFireworksModelId: () => resolveFireworksModelId,
   runAgentLoop: () => runAgentLoop,
@@ -1689,6 +1691,123 @@ 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;
+var DEFAULT_OPENAI_MODEL_CONCURRENCY_CAP = 12;
+var DEFAULT_GOOGLE_MODEL_CONCURRENCY_CAP = 4;
+var DEFAULT_GOOGLE_PREVIEW_MODEL_CONCURRENCY_CAP = 2;
+var DEFAULT_FIREWORKS_MODEL_CONCURRENCY_CAP = 6;
+var MODEL_CONCURRENCY_PROVIDERS = [
+  "openai",
+  "google",
+  "fireworks"
+];
+var configuredModelConcurrency = normalizeModelConcurrencyConfig({});
+function clampModelConcurrencyCap(value) {
+  if (!Number.isFinite(value)) {
+    return DEFAULT_MODEL_CONCURRENCY_CAP;
+  }
+  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 normalizeModelIdForConfig(modelId) {
+  return modelId.trim().toLowerCase();
+}
+function normalizeCap(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return clampModelConcurrencyCap(value);
+}
+function normalizeModelCapMap(caps) {
+  const normalized = /* @__PURE__ */ new Map();
+  if (!caps) {
+    return normalized;
+  }
+  for (const [modelId, cap] of Object.entries(caps)) {
+    const modelKey = normalizeModelIdForConfig(modelId);
+    if (!modelKey) {
+      continue;
+    }
+    const normalizedCap = normalizeCap(cap);
+    if (normalizedCap === void 0) {
+      continue;
+    }
+    normalized.set(modelKey, normalizedCap);
+  }
+  return normalized;
+}
+function normalizeModelConcurrencyConfig(config) {
+  const providerCaps = {};
+  const providerModelCaps = {
+    openai: /* @__PURE__ */ new Map(),
+    google: /* @__PURE__ */ new Map(),
+    fireworks: /* @__PURE__ */ new Map()
+  };
+  for (const provider of MODEL_CONCURRENCY_PROVIDERS) {
+    const providerCap = normalizeCap(config.providerCaps?.[provider]);
+    if (providerCap !== void 0) {
+      providerCaps[provider] = providerCap;
+    }
+    providerModelCaps[provider] = new Map(
+      normalizeModelCapMap(config.providerModelCaps?.[provider])
+    );
+  }
+  return {
+    globalCap: normalizeCap(config.globalCap),
+    providerCaps,
+    modelCaps: normalizeModelCapMap(config.modelCaps),
+    providerModelCaps
+  };
+}
+function resolveDefaultProviderCap(provider, modelId) {
+  if (provider === "openai") {
+    return DEFAULT_OPENAI_MODEL_CONCURRENCY_CAP;
+  }
+  if (provider === "google") {
+    return modelId?.includes("preview") ? DEFAULT_GOOGLE_PREVIEW_MODEL_CONCURRENCY_CAP : DEFAULT_GOOGLE_MODEL_CONCURRENCY_CAP;
+  }
+  return DEFAULT_FIREWORKS_MODEL_CONCURRENCY_CAP;
+}
+function configureModelConcurrency(config = {}) {
+  configuredModelConcurrency = normalizeModelConcurrencyConfig(config);
+}
+function resetModelConcurrencyConfig() {
+  configuredModelConcurrency = normalizeModelConcurrencyConfig({});
+}
+function resolveModelConcurrencyCap(options) {
+  const modelId = options.modelId ? normalizeModelIdForConfig(options.modelId) : void 0;
+  const config = options.config ? normalizeModelConcurrencyConfig(options.config) : configuredModelConcurrency;
+  const providerModelCap = modelId ? config.providerModelCaps[options.provider].get(modelId) : void 0;
+  if (providerModelCap !== void 0) {
+    return providerModelCap;
+  }
+  const modelCap = modelId ? config.modelCaps.get(modelId) : void 0;
+  if (modelCap !== void 0) {
+    return modelCap;
+  }
+  const providerCap = config.providerCaps[options.provider];
+  if (providerCap !== void 0) {
+    return providerCap;
+  }
+  if (config.globalCap !== void 0) {
+    return config.globalCap;
+  }
+  const defaultCap = normalizeCap(options.defaultCap);
+  if (defaultCap !== void 0) {
+    return defaultCap;
+  }
+  return resolveDefaultProviderCap(options.provider, modelId);
+}
+
 // src/utils/scheduler.ts
 function sleep(ms) {
   return new Promise((resolve) => {
@@ -1704,13 +1823,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() {
@@ -1736,11 +1914,23 @@ function createCallScheduler(options = {}) {
       release?.();
     }
   }
-  async function attemptWithRetries(fn, attempt) {
+  async function attemptWithRetries(fn, attempt, state) {
     try {
+      const spacingStartedAtMs = Date.now();
       await applyStartSpacing();
+      const callStartedAtMs = Date.now();
+      state.schedulerDelayMs += Math.max(0, callStartedAtMs - spacingStartedAtMs);
+      if (state.startedAtMs === void 0) {
+        state.startedAtMs = callStartedAtMs;
+      }
+      state.attempts = Math.max(state.attempts, attempt);
       return await fn();
     } catch (error) {
+      if (isOverloadError2(error)) {
+        state.overloadCount += 1;
+        consecutiveSuccesses = 0;
+        currentParallelLimit = Math.max(1, Math.ceil(currentParallelLimit / 2));
+      }
       const err = toError(error);
       if (!retryPolicy || attempt >= retryPolicy.maxAttempts) {
         throw err;
@@ -1754,13 +1944,14 @@ function createCallScheduler(options = {}) {
       }
       const normalizedDelay = Math.max(0, delay);
       if (normalizedDelay > 0) {
+        state.retryDelayMs += normalizedDelay;
         await sleep(normalizedDelay);
       }
-      return attemptWithRetries(fn, attempt + 1);
+      return attemptWithRetries(fn, attempt + 1, state);
     }
   }
   function drainQueue() {
-    while (activeCount < maxParallelRequests && queue.length > 0) {
+    while (activeCount < currentParallelLimit && queue.length > 0) {
       const task = queue.shift();
       if (!task) {
         continue;
@@ -1769,15 +1960,49 @@ function createCallScheduler(options = {}) {
       void task();
     }
   }
-  function run(fn) {
+  function run(fn, runOptions = {}) {
     return new Promise((resolve, reject) => {
+      const enqueuedAtMs = Date.now();
       const job = async () => {
+        const dequeuedAtMs = Date.now();
+        const state = {
+          enqueuedAtMs,
+          dequeuedAtMs,
+          schedulerDelayMs: 0,
+          retryDelayMs: 0,
+          attempts: 0,
+          overloadCount: 0
+        };
         try {
-          const result = await attemptWithRetries(fn, 1);
+          const result = await attemptWithRetries(fn, 1, state);
+          state.completedAtMs = Date.now();
+          consecutiveSuccesses += 1;
+          if (currentParallelLimit < maxParallelRequests && consecutiveSuccesses >= increaseAfterConsecutiveSuccesses) {
+            currentParallelLimit += 1;
+            consecutiveSuccesses = 0;
+          }
           resolve(result);
         } catch (error) {
+          state.completedAtMs = Date.now();
           reject(toError(error));
         } finally {
+          const startedAtMs = state.startedAtMs ?? state.dequeuedAtMs;
+          const completedAtMs = state.completedAtMs ?? Date.now();
+          const metrics = {
+            enqueuedAtMs: state.enqueuedAtMs,
+            dequeuedAtMs: state.dequeuedAtMs,
+            startedAtMs,
+            completedAtMs,
+            queueWaitMs: Math.max(0, state.dequeuedAtMs - state.enqueuedAtMs),
+            schedulerDelayMs: Math.max(0, state.schedulerDelayMs),
+            retryDelayMs: Math.max(0, state.retryDelayMs),
+            attempts: Math.max(1, state.attempts),
+            overloadCount: Math.max(0, state.overloadCount)
+          };
+          try {
+            runOptions.onSettled?.(metrics);
+          } catch {
+          }
           activeCount -= 1;
           queueMicrotask(drainQueue);
         }
@@ -1863,13 +2088,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({
+      provider: "fireworks",
+      modelId: normalizedModelId
+    }),
+    minIntervalBetweenStartMs: 200,
+    startJitterMs: 200
+  });
+  schedulerByModel.set(schedulerKey, created);
+  return created;
+}
+async function runFireworksCall(fn, modelId, runOptions) {
+  return getSchedulerForModel(modelId).run(async () => fn(getFireworksClient()), runOptions);
 }
 
 // src/fireworks/models.ts
@@ -2205,6 +2445,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;
@@ -2212,23 +2464,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({
+      provider: "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, runOptions) {
+  return getSchedulerForModel2(modelId).run(async () => fn(await getGeminiClient()), runOptions);
 }
 
 // src/openai/client.ts
@@ -2389,13 +2657,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({
+      provider: "openai",
+      modelId: normalizedModelId
+    }),
+    minIntervalBetweenStartMs: 200,
+    startJitterMs: 200
+  });
+  schedulerByModel3.set(schedulerKey, created);
+  return created;
+}
+async function runOpenAiCall(fn, modelId, runOptions) {
+  return getSchedulerForModel3(modelId).run(async () => fn(getOpenAiClient()), runOptions);
 }
 
 // src/openai/models.ts
@@ -2849,9 +3132,9 @@ function isRetryableChatGptTransportError(error) {
     return false;
   }
   const message = error.message.toLowerCase();
-  return message === "terminated" || message.includes("socket hang up") || message.includes("fetch failed") || message.includes("network");
+  return message === "terminated" || message.includes("socket hang up") || message.includes("fetch failed") || message.includes("network") || message.includes("responses websocket");
 }
-async function collectChatGptCodexResponseWithRetry(options, maxAttempts = 2) {
+async function collectChatGptCodexResponseWithRetry(options, maxAttempts = 3) {
   let attempt = 1;
   while (true) {
     try {
@@ -3756,77 +4039,153 @@ function buildToolErrorOutput(message, issues) {
   }
   return output;
 }
+var SUBAGENT_WAIT_TOOL_NAME = "wait";
+function toIsoTimestamp(ms) {
+  return new Date(ms).toISOString();
+}
+function toToolResultDuration(result) {
+  return typeof result.durationMs === "number" && Number.isFinite(result.durationMs) ? Math.max(0, result.durationMs) : 0;
+}
+function schedulerMetricsOrDefault(metrics) {
+  if (!metrics) {
+    return {
+      queueWaitMs: 0,
+      schedulerDelayMs: 0,
+      providerRetryDelayMs: 0,
+      providerAttempts: 1
+    };
+  }
+  return {
+    queueWaitMs: Math.max(0, metrics.queueWaitMs),
+    schedulerDelayMs: Math.max(0, metrics.schedulerDelayMs),
+    providerRetryDelayMs: Math.max(0, metrics.retryDelayMs),
+    providerAttempts: Math.max(1, metrics.attempts),
+    modelCallStartedAtMs: metrics.startedAtMs
+  };
+}
+function buildStepTiming(params) {
+  const scheduler = schedulerMetricsOrDefault(params.schedulerMetrics);
+  const modelCallStartedAtMs = scheduler.modelCallStartedAtMs ?? params.stepStartedAtMs;
+  const firstModelEventAtMs = params.firstModelEventAtMs;
+  const effectiveFirstEventAtMs = firstModelEventAtMs !== void 0 ? Math.max(modelCallStartedAtMs, firstModelEventAtMs) : params.modelCompletedAtMs;
+  const connectionSetupMs = Math.max(0, effectiveFirstEventAtMs - modelCallStartedAtMs);
+  const activeGenerationMs = Math.max(0, params.modelCompletedAtMs - effectiveFirstEventAtMs);
+  return {
+    startedAt: toIsoTimestamp(params.stepStartedAtMs),
+    completedAt: toIsoTimestamp(params.stepCompletedAtMs),
+    totalMs: Math.max(0, params.stepCompletedAtMs - params.stepStartedAtMs),
+    queueWaitMs: scheduler.queueWaitMs,
+    connectionSetupMs,
+    activeGenerationMs,
+    toolExecutionMs: Math.max(0, params.toolExecutionMs),
+    waitToolMs: Math.max(0, params.waitToolMs),
+    schedulerDelayMs: scheduler.schedulerDelayMs,
+    providerRetryDelayMs: scheduler.providerRetryDelayMs,
+    providerAttempts: scheduler.providerAttempts
+  };
+}
+function extractSpawnStartupMetrics(outputPayload) {
+  if (!outputPayload || typeof outputPayload !== "object") {
+    return void 0;
+  }
+  const outputRecord = outputPayload;
+  const notification = typeof outputRecord.notification === "string" ? outputRecord.notification : "";
+  if (notification !== "spawned") {
+    return void 0;
+  }
+  const agent = outputRecord.agent;
+  if (!agent || typeof agent !== "object") {
+    return void 0;
+  }
+  const agentRecord = agent;
+  const startupLatencyMs = agentRecord.spawn_startup_latency_ms;
+  if (typeof startupLatencyMs !== "number" || !Number.isFinite(startupLatencyMs)) {
+    return void 0;
+  }
+  return {
+    spawnStartupLatencyMs: Math.max(0, startupLatencyMs)
+  };
+}
 async function executeToolCall(params) {
   const { callKind, toolName, tool: tool2, rawInput, parseError } = params;
-  if (!tool2) {
-    const message = `Unknown tool: ${toolName}`;
+  const startedAtMs = Date.now();
+  const finalize = (base, outputPayload, metrics) => {
+    const completedAtMs = Date.now();
     return {
-      result: { toolName, input: rawInput, output: { error: message }, error: message },
-      outputPayload: buildToolErrorOutput(message)
+      result: {
+        ...base,
+        startedAt: toIsoTimestamp(startedAtMs),
+        completedAt: toIsoTimestamp(completedAtMs),
+        durationMs: Math.max(0, completedAtMs - startedAtMs),
+        ...metrics ? { metrics } : {}
+      },
+      outputPayload
     };
+  };
+  if (!tool2) {
+    const message = `Unknown tool: ${toolName}`;
+    const outputPayload = buildToolErrorOutput(message);
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
+      outputPayload
+    );
   }
   if (callKind === "custom") {
     if (!isCustomTool(tool2)) {
       const message = `Tool ${toolName} was called as custom_tool_call but is declared as function.`;
       const outputPayload = buildToolErrorOutput(message);
-      return {
-        result: { toolName, input: rawInput, output: outputPayload, error: message },
+      return finalize(
+        { toolName, input: rawInput, output: outputPayload, error: message },
         outputPayload
-      };
+      );
     }
     const input = typeof rawInput === "string" ? rawInput : String(rawInput ?? "");
     try {
       const output = await tool2.execute(input);
-      return {
-        result: { toolName, input, output },
-        outputPayload: output
-      };
+      const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(output) : void 0;
+      return finalize({ toolName, input, output }, output, metrics);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
-      return {
-        result: { toolName, input, output: outputPayload, error: message },
-        outputPayload
-      };
+      return finalize({ toolName, input, output: outputPayload, error: message }, outputPayload);
     }
   }
   if (isCustomTool(tool2)) {
     const message = `Tool ${toolName} was called as function_call but is declared as custom.`;
     const outputPayload = buildToolErrorOutput(message);
-    return {
-      result: { toolName, input: rawInput, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
   if (parseError) {
     const message = `Invalid JSON for tool ${toolName}: ${parseError}`;
-    return {
-      result: { toolName, input: rawInput, output: { error: message }, error: message },
-      outputPayload: buildToolErrorOutput(message)
-    };
+    const outputPayload = buildToolErrorOutput(message);
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
+      outputPayload
+    );
   }
   const parsed = tool2.inputSchema.safeParse(rawInput);
   if (!parsed.success) {
     const message = `Invalid tool arguments for ${toolName}: ${formatZodIssues(parsed.error.issues)}`;
     const outputPayload = buildToolErrorOutput(message, parsed.error.issues);
-    return {
-      result: { toolName, input: rawInput, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
   try {
     const output = await tool2.execute(parsed.data);
-    return {
-      result: { toolName, input: parsed.data, output },
-      outputPayload: output
-    };
+    const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(output) : void 0;
+    return finalize({ toolName, input: parsed.data, output }, output, metrics);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
-    return {
-      result: { toolName, input: parsed.data, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: parsed.data, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
 }
 function buildToolLogId(turn, toolIndex) {
@@ -4157,7 +4516,7 @@ async function runTextCall(params) {
           }
         }
       }
-    });
+    }, modelForProvider);
   } else if (provider === "chatgpt") {
     const chatGptInput = toChatGptInput(contents);
     const reasoningEffort = resolveOpenAiReasoningEffort(
@@ -4252,7 +4611,7 @@ async function runTextCall(params) {
         pushDelta("response", textOutput);
       }
       latestUsage = extractFireworksUsageTokens(response.usage);
-    });
+    }, modelForProvider);
   } else {
     const geminiContents = contents.map(convertLlmContentToGeminiContent);
     const config = {
@@ -4320,7 +4679,7 @@ async function runTextCall(params) {
         }
       }
       grounding = latestGrounding;
-    });
+    }, modelForProvider);
   }
   const mergedParts = mergeConsecutiveTextParts(responseParts);
   const content = mergedParts.length > 0 ? { role: responseRole ?? "assistant", parts: mergedParts } : void 0;
@@ -4691,6 +5050,9 @@ async function runToolLoop(request) {
     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) {
@@ -4709,45 +5071,59 @@ async function runToolLoop(request) {
       const emitEvent = (ev) => {
         onEvent?.(ev);
       };
-      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) {
-          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;
+      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":
+                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();
-      });
+      );
       modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
       emitEvent({ type: "model", modelVersion });
       if (finalResponse.error) {
@@ -4757,6 +5133,7 @@ async function runToolLoop(request) {
       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,
@@ -4771,6 +5148,16 @@ async function runToolLoop(request) {
       if (responseToolCalls.length === 0) {
         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,
@@ -4778,7 +5165,8 @@ async function runToolLoop(request) {
           thoughts: reasoningSummary || void 0,
           toolCalls: [],
           usage: usageTokens,
-          costUsd: stepCostUsd
+          costUsd: stepCostUsd,
+          timing: timing2
         });
         return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
       }
@@ -4823,8 +5211,15 @@ async function runToolLoop(request) {
         })
       );
       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 (entry.call.kind === "custom") {
           toolOutputs.push({
             type: "custom_tool_call_output",
@@ -4839,6 +5234,16 @@ async function runToolLoop(request) {
           });
         }
       }
+      const stepCompletedAtMs = Date.now();
+      const timing = buildStepTiming({
+        stepStartedAtMs,
+        stepCompletedAtMs,
+        modelCompletedAtMs,
+        firstModelEventAtMs,
+        schedulerMetrics,
+        toolExecutionMs,
+        waitToolMs
+      });
       steps.push({
         step: steps.length + 1,
         modelVersion,
@@ -4846,7 +5251,8 @@ async function runToolLoop(request) {
         thoughts: reasoningSummary || void 0,
         toolCalls: stepToolCalls,
         usage: usageTokens,
-        costUsd: stepCostUsd
+        costUsd: stepCostUsd,
+        timing
       });
       previousResponseId = finalResponse.id;
       input = toolOutputs;
@@ -4867,6 +5273,13 @@ async function runToolLoop(request) {
     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 response = await collectChatGptCodexResponseWithRetry({
         sessionId: conversationId,
         request: {
@@ -4889,13 +5302,16 @@ async function runToolLoop(request) {
         signal: request.signal,
         onDelta: (delta) => {
           if (delta.thoughtDelta) {
+            markFirstModelEvent();
             request.onEvent?.({ type: "delta", channel: "thought", text: delta.thoughtDelta });
           }
           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({
@@ -4910,6 +5326,15 @@ async function runToolLoop(request) {
       if (responseToolCalls.length === 0) {
         finalText = responseText;
         finalThoughts = reasoningSummaryText;
+        const stepCompletedAtMs2 = Date.now();
+        const timing2 = buildStepTiming({
+          stepStartedAtMs,
+          stepCompletedAtMs: stepCompletedAtMs2,
+          modelCompletedAtMs,
+          firstModelEventAtMs,
+          toolExecutionMs: 0,
+          waitToolMs: 0
+        });
         steps.push({
           step: steps.length + 1,
           modelVersion,
@@ -4917,7 +5342,8 @@ async function runToolLoop(request) {
           thoughts: reasoningSummaryText || void 0,
           toolCalls: [],
           usage: usageTokens,
-          costUsd: stepCostUsd
+          costUsd: stepCostUsd,
+          timing: timing2
         });
         return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
       }
@@ -4957,8 +5383,15 @@ async function runToolLoop(request) {
           );
         })
       );
+      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 (entry.call.kind === "custom") {
           toolOutputs.push({
             type: "custom_tool_call",
@@ -4989,6 +5422,15 @@ async function runToolLoop(request) {
           });
         }
       }
+      const stepCompletedAtMs = Date.now();
+      const timing = buildStepTiming({
+        stepStartedAtMs,
+        stepCompletedAtMs,
+        modelCompletedAtMs,
+        firstModelEventAtMs,
+        toolExecutionMs,
+        waitToolMs
+      });
       steps.push({
         step: steps.length + 1,
         modelVersion,
@@ -4996,7 +5438,8 @@ async function runToolLoop(request) {
         thoughts: reasoningSummaryText || void 0,
         toolCalls,
         usage: usageTokens,
-        costUsd: stepCostUsd
+        costUsd: stepCostUsd,
+        timing
       });
       input = input.concat(toolOutputs);
     }
@@ -5012,18 +5455,29 @@ async function runToolLoop(request) {
     const messages = toFireworksMessages(contents);
     for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
       const turn = stepIndex + 1;
-      const response = await runFireworksCall(async (client) => {
-        return await client.chat.completions.create(
-          {
-            model: providerInfo.model,
-            messages,
-            tools: fireworksTools,
-            tool_choice: "auto",
-            parallel_tool_calls: true
-          },
-          { signal: request.signal }
-        );
-      });
+      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;
+          }
+        }
+      );
+      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;
@@ -5054,6 +5508,15 @@ async function runToolLoop(request) {
       if (responseToolCalls.length === 0) {
         finalText = responseText;
         finalThoughts = "";
+        const stepCompletedAtMs2 = Date.now();
+        const timing2 = buildStepTiming({
+          stepStartedAtMs,
+          stepCompletedAtMs: stepCompletedAtMs2,
+          modelCompletedAtMs,
+          schedulerMetrics,
+          toolExecutionMs: 0,
+          waitToolMs: 0
+        });
         steps.push({
           step: steps.length + 1,
           modelVersion,
@@ -5061,7 +5524,8 @@ async function runToolLoop(request) {
           thoughts: void 0,
           toolCalls: [],
           usage: usageTokens,
-          costUsd: stepCostUsd
+          costUsd: stepCostUsd,
+          timing: timing2
         });
         return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
       }
@@ -5096,8 +5560,15 @@ async function runToolLoop(request) {
       );
       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;
+        }
         assistantToolCalls.push({
           id: entry.call.id,
           type: "function",
@@ -5112,6 +5583,15 @@ async function runToolLoop(request) {
           content: mergeToolOutput(outputPayload)
         });
       }
+      const stepCompletedAtMs = Date.now();
+      const timing = buildStepTiming({
+        stepStartedAtMs,
+        stepCompletedAtMs,
+        modelCompletedAtMs,
+        schedulerMetrics,
+        toolExecutionMs,
+        waitToolMs
+      });
       steps.push({
         step: steps.length + 1,
         modelVersion,
@@ -5119,7 +5599,8 @@ async function runToolLoop(request) {
         thoughts: void 0,
         toolCalls: stepToolCalls,
         usage: usageTokens,
-        costUsd: stepCostUsd
+        costUsd: stepCostUsd,
+        timing
       });
       messages.push({
         role: "assistant",
@@ -5135,6 +5616,14 @@ async function runToolLoop(request) {
   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,
@@ -5146,81 +5635,91 @@ async function runToolLoop(request) {
       thinkingConfig: resolveGeminiThinkingConfig(request.model)
     };
     const onEvent = request.onEvent;
-    const response = await runGeminiCall(async (client) => {
-      const stream = await client.models.generateContentStream({
-        model: request.model,
-        contents: geminiContents,
-        config
-      });
-      let responseText = "";
-      let thoughtsText = "";
-      const modelParts = [];
-      const functionCalls = [];
-      const seenFunctionCallIds = /* @__PURE__ */ new Set();
-      const seenFunctionCallKeys = /* @__PURE__ */ new Set();
-      let latestUsageMetadata;
-      let resolvedModelVersion;
-      for await (const chunk of stream) {
-        if (chunk.modelVersion) {
-          resolvedModelVersion = chunk.modelVersion;
-          onEvent?.({ type: "model", modelVersion: chunk.modelVersion });
-        }
-        if (chunk.usageMetadata) {
-          latestUsageMetadata = chunk.usageMetadata;
-        }
-        const candidates = chunk.candidates;
-        if (!candidates || candidates.length === 0) {
-          continue;
-        }
-        const primary = candidates[0];
-        const parts = primary?.content?.parts;
-        if (!parts || parts.length === 0) {
-          continue;
-        }
-        for (const part of parts) {
-          modelParts.push(part);
-          const call = part.functionCall;
-          if (call) {
-            const id = typeof call.id === "string" ? call.id : "";
-            const shouldAdd = (() => {
-              if (id.length > 0) {
-                if (seenFunctionCallIds.has(id)) {
+    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;
                 }
-                seenFunctionCallIds.add(id);
+                seenFunctionCallKeys.add(key);
                 return true;
+              })();
+              if (shouldAdd) {
+                functionCalls.push(call);
               }
-              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 });
+            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;
+        }
       }
-      return {
-        responseText,
-        thoughtsText,
-        functionCalls,
-        modelParts,
-        usageMetadata: latestUsageMetadata,
-        modelVersion: resolvedModelVersion ?? request.model
-      };
-    });
+    );
+    const modelCompletedAtMs = Date.now();
     const usageTokens = extractGeminiUsageTokens(response.usageMetadata);
     const modelVersion = response.modelVersion ?? request.model;
     const stepCostUsd = estimateCallCostUsd({
@@ -5232,6 +5731,16 @@ async function runToolLoop(request) {
     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,
@@ -5239,7 +5748,8 @@ async function runToolLoop(request) {
         thoughts: finalThoughts || void 0,
         toolCalls: [],
         usage: usageTokens,
-        costUsd: stepCostUsd
+        costUsd: stepCostUsd,
+        timing: timing2
       });
       return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
     }
@@ -5289,8 +5799,15 @@ async function runToolLoop(request) {
         );
       })
     );
+    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: {
@@ -5300,6 +5817,16 @@ async function runToolLoop(request) {
         }
       });
     }
+    const stepCompletedAtMs = Date.now();
+    const timing = buildStepTiming({
+      stepStartedAtMs,
+      stepCompletedAtMs,
+      modelCompletedAtMs,
+      firstModelEventAtMs,
+      schedulerMetrics,
+      toolExecutionMs,
+      waitToolMs
+    });
     steps.push({
       step: steps.length + 1,
       modelVersion,
@@ -5307,7 +5834,8 @@ async function runToolLoop(request) {
       thoughts: response.thoughtsText.trim() || void 0,
       toolCalls,
       usage: usageTokens,
-      costUsd: stepCostUsd
+      costUsd: stepCostUsd,
+      timing
     });
     geminiContents.push({ role: "user", parts: responseParts });
   }
@@ -5558,13 +6086,648 @@ function appendMarkdownSourcesSection(value, sources) {
 ${lines}`;
 }
 
+// src/agent.ts
+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 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 = 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()
+}).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."
+});
+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.")
+}).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.")
+}).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."
+  }
+);
+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.")
+}).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_${(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 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();
+  const runStartedAtMs = Date.now();
+  agent.abortController = abortController;
+  if (agent.firstRunStartedAtMs === void 0) {
+    agent.firstRunStartedAtMs = runStartedAtMs;
+  }
+  agent.lastRunStartedAtMs = runStartedAtMs;
+  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 {
+      const runCompletedAtMs = Date.now();
+      agent.lastRunCompletedAtMs = runCompletedAtMs;
+      agent.lastRunDurationMs = Math.max(0, runCompletedAtMs - runStartedAtMs);
+      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.firstRunStartedAtMs ? {
+      first_run_started_at: new Date(agent.firstRunStartedAtMs).toISOString(),
+      spawn_startup_latency_ms: Math.max(0, agent.firstRunStartedAtMs - agent.createdAtMs)
+    } : {},
+    ...agent.lastRunStartedAtMs ? { last_run_started_at: new Date(agent.lastRunStartedAtMs).toISOString() } : {},
+    ...agent.lastRunCompletedAtMs ? { last_run_completed_at: new Date(agent.lastRunCompletedAtMs).toISOString() } : {},
+    ...typeof agent.lastRunDurationMs === "number" ? { last_run_duration_ms: Math.max(0, agent.lastRunDurationMs) } : {},
+    ...agent.lastError ? { last_error: agent.lastError } : {},
+    ...agent.lastResult ? {
+      last_result: {
+        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
 var import_node_path5 = __toESM(require("path"), 1);
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/tools/applyPatch.ts
 var import_node_path4 = __toESM(require("path"), 1);
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/tools/filesystem.ts
 var import_node_fs3 = require("fs");
@@ -5860,8 +7023,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 = import_zod4.z.object({
-  input: import_zod4.z.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
+var applyPatchToolInputSchema = import_zod5.z.object({
+  input: import_zod5.z.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
 });
 function createApplyPatchTool(options = {}) {
   return tool({
@@ -6269,100 +7432,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 = import_zod5.z.object({
-  file_path: import_zod5.z.string().min(1).describe("Absolute path to the file"),
-  offset: import_zod5.z.number().int().min(1).optional().describe("The line number to start reading from. Must be 1 or greater."),
-  limit: import_zod5.z.number().int().min(1).optional().describe("The maximum number of lines to return."),
-  mode: import_zod5.z.enum(["slice", "indentation"]).optional().describe('Optional mode selector: "slice" (default) or "indentation".'),
-  indentation: import_zod5.z.object({
-    anchor_line: import_zod5.z.number().int().min(1).optional(),
-    max_levels: import_zod5.z.number().int().min(0).optional(),
-    include_siblings: import_zod5.z.boolean().optional(),
-    include_header: import_zod5.z.boolean().optional(),
-    max_lines: import_zod5.z.number().int().min(1).optional()
+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".'),
+  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()
 });
-var codexListDirInputSchema = import_zod5.z.object({
-  dir_path: import_zod5.z.string().min(1).describe("Absolute path to the directory to list."),
-  offset: import_zod5.z.number().int().min(1).optional().describe("The entry number to start listing from. Must be 1 or greater."),
-  limit: import_zod5.z.number().int().min(1).optional().describe("The maximum number of entries to return."),
-  depth: import_zod5.z.number().int().min(1).optional().describe("The maximum directory depth to traverse. Must be 1 or greater.")
+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.")
 });
-var codexGrepFilesInputSchema = import_zod5.z.object({
-  pattern: import_zod5.z.string().min(1).describe("Regular expression pattern to search for."),
-  include: import_zod5.z.string().optional().describe('Optional glob limiting searched files (for example "*.rs").'),
-  path: import_zod5.z.string().optional().describe("Directory or file path to search. Defaults to cwd."),
-  limit: import_zod5.z.number().int().min(1).optional().describe("Maximum number of file paths to return (defaults to 100).")
+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).")
 });
-var applyPatchInputSchema = import_zod5.z.object({
-  input: import_zod5.z.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
+var applyPatchInputSchema = import_zod6.z.object({
+  input: import_zod6.z.string().min(1).describe(CODEX_APPLY_PATCH_INPUT_DESCRIPTION)
 });
-var geminiReadFileInputSchema = import_zod5.z.object({
-  file_path: import_zod5.z.string().min(1),
-  offset: import_zod5.z.number().int().min(0).nullish(),
-  limit: import_zod5.z.number().int().min(1).nullish()
+var geminiReadFileInputSchema = import_zod6.z.object({
+  file_path: import_zod6.z.string().min(1),
+  offset: import_zod6.z.number().int().min(0).nullish(),
+  limit: import_zod6.z.number().int().min(1).nullish()
 });
-var geminiReadFilesInputSchema = import_zod5.z.object({
-  paths: import_zod5.z.array(import_zod5.z.string().min(1)).min(1),
-  line_offset: import_zod5.z.number().int().min(0).nullish(),
-  line_limit: import_zod5.z.number().int().min(1).nullish(),
-  char_offset: import_zod5.z.number().int().min(0).nullish(),
-  char_limit: import_zod5.z.number().int().min(1).nullish(),
-  include_line_numbers: import_zod5.z.boolean().nullish()
+var geminiReadFilesInputSchema = import_zod6.z.object({
+  paths: import_zod6.z.array(import_zod6.z.string().min(1)).min(1),
+  line_offset: import_zod6.z.number().int().min(0).nullish(),
+  line_limit: import_zod6.z.number().int().min(1).nullish(),
+  char_offset: import_zod6.z.number().int().min(0).nullish(),
+  char_limit: import_zod6.z.number().int().min(1).nullish(),
+  include_line_numbers: import_zod6.z.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: import_zod5.z.ZodIssueCode.custom,
+      code: import_zod6.z.ZodIssueCode.custom,
       message: "Use either line_* or char_* window arguments, not both."
     });
   }
 });
-var geminiWriteFileInputSchema = import_zod5.z.object({
-  file_path: import_zod5.z.string().min(1),
-  content: import_zod5.z.string()
+var geminiWriteFileInputSchema = import_zod6.z.object({
+  file_path: import_zod6.z.string().min(1),
+  content: import_zod6.z.string()
 });
-var geminiReplaceInputSchema = import_zod5.z.object({
-  file_path: import_zod5.z.string().min(1),
-  instruction: import_zod5.z.string().min(1),
-  old_string: import_zod5.z.string(),
-  new_string: import_zod5.z.string(),
-  expected_replacements: import_zod5.z.number().int().min(1).nullish()
+var geminiReplaceInputSchema = import_zod6.z.object({
+  file_path: import_zod6.z.string().min(1),
+  instruction: import_zod6.z.string().min(1),
+  old_string: import_zod6.z.string(),
+  new_string: import_zod6.z.string(),
+  expected_replacements: import_zod6.z.number().int().min(1).nullish()
 });
-var geminiListDirectoryInputSchema = import_zod5.z.object({
-  dir_path: import_zod5.z.string().min(1),
-  ignore: import_zod5.z.array(import_zod5.z.string()).nullish(),
-  file_filtering_options: import_zod5.z.object({
-    respect_git_ignore: import_zod5.z.boolean().nullish(),
-    respect_gemini_ignore: import_zod5.z.boolean().nullish()
+var geminiListDirectoryInputSchema = import_zod6.z.object({
+  dir_path: import_zod6.z.string().min(1),
+  ignore: import_zod6.z.array(import_zod6.z.string()).nullish(),
+  file_filtering_options: import_zod6.z.object({
+    respect_git_ignore: import_zod6.z.boolean().nullish(),
+    respect_gemini_ignore: import_zod6.z.boolean().nullish()
   }).nullish()
 });
-var geminiRgSearchInputSchema = import_zod5.z.object({
-  pattern: import_zod5.z.string().min(1),
-  path: import_zod5.z.string().nullish(),
-  glob: import_zod5.z.string().nullish(),
-  case_sensitive: import_zod5.z.boolean().nullish(),
-  exclude_pattern: import_zod5.z.string().nullish(),
-  names_only: import_zod5.z.boolean().nullish(),
-  max_matches_per_file: import_zod5.z.number().int().min(1).nullish(),
-  max_results: import_zod5.z.number().int().min(1).nullish()
+var geminiRgSearchInputSchema = import_zod6.z.object({
+  pattern: import_zod6.z.string().min(1),
+  path: import_zod6.z.string().nullish(),
+  glob: import_zod6.z.string().nullish(),
+  case_sensitive: import_zod6.z.boolean().nullish(),
+  exclude_pattern: import_zod6.z.string().nullish(),
+  names_only: import_zod6.z.boolean().nullish(),
+  max_matches_per_file: import_zod6.z.number().int().min(1).nullish(),
+  max_results: import_zod6.z.number().int().min(1).nullish()
 });
-var geminiGrepSearchInputSchema = import_zod5.z.object({
-  pattern: import_zod5.z.string().min(1),
-  dir_path: import_zod5.z.string().nullish(),
-  include: import_zod5.z.string().nullish(),
-  exclude_pattern: import_zod5.z.string().nullish(),
-  names_only: import_zod5.z.boolean().nullish(),
-  max_matches_per_file: import_zod5.z.number().int().min(1).nullish(),
-  total_max_matches: import_zod5.z.number().int().min(1).nullish()
+var geminiGrepSearchInputSchema = import_zod6.z.object({
+  pattern: import_zod6.z.string().min(1),
+  dir_path: import_zod6.z.string().nullish(),
+  include: import_zod6.z.string().nullish(),
+  exclude_pattern: import_zod6.z.string().nullish(),
+  names_only: import_zod6.z.boolean().nullish(),
+  max_matches_per_file: import_zod6.z.number().int().min(1).nullish(),
+  total_max_matches: import_zod6.z.number().int().min(1).nullish()
 });
-var geminiGlobInputSchema = import_zod5.z.object({
-  pattern: import_zod5.z.string().min(1),
-  dir_path: import_zod5.z.string().nullish(),
-  case_sensitive: import_zod5.z.boolean().nullish(),
-  respect_git_ignore: import_zod5.z.boolean().nullish(),
-  respect_gemini_ignore: import_zod5.z.boolean().nullish()
+var geminiGlobInputSchema = import_zod6.z.object({
+  pattern: import_zod6.z.string().min(1),
+  dir_path: import_zod6.z.string().nullish(),
+  case_sensitive: import_zod6.z.boolean().nullish(),
+  respect_git_ignore: import_zod6.z.boolean().nullish(),
+  respect_gemini_ignore: import_zod6.z.boolean().nullish()
 });
 function resolveFilesystemToolProfile(model, profile = "auto") {
   if (profile !== "auto") {
@@ -7350,19 +8513,107 @@ function isNoEntError(error) {
 
 // src/agent.ts
 async function runAgentLoop(request) {
-  const { tools: customTools, filesystemTool, filesystem_tool, ...toolLoopRequest } = request;
+  const telemetry = createAgentTelemetrySession(request.telemetry);
+  try {
+    return await runAgentLoopInternal(request, { depth: 0, telemetry });
+  } finally {
+    await telemetry?.flush();
+  }
+}
+async function runAgentLoopInternal(request, context) {
+  const {
+    tools: customTools,
+    filesystemTool,
+    filesystem_tool,
+    subagentTool,
+    subagent_tool,
+    subagents,
+    telemetry,
+    ...toolLoopRequest
+  } = request;
+  const telemetrySession = context.telemetry ?? createAgentTelemetrySession(telemetry);
+  const runId = randomRunId();
+  const startedAtMs = Date.now();
   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({
+    runId,
+    model: request.model,
+    depth: context.depth,
+    telemetry: telemetrySession,
+    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
+  );
+  const emitTelemetry = createAgentTelemetryEmitter({
+    session: telemetrySession,
+    runId,
+    parentRunId: context.parentRunId,
+    depth: context.depth,
+    model: request.model
+  });
+  emitTelemetry({
+    type: "agent.run.started",
+    inputMode: typeof request.input === "string" ? "string" : "messages",
+    customToolCount: Object.keys(customTools ?? {}).length,
+    mergedToolCount: Object.keys(mergedTools).length,
+    filesystemToolsEnabled: Object.keys(filesystemTools).length > 0,
+    subagentToolsEnabled: resolvedSubagentConfig.enabled
   });
+  const sourceOnEvent = toolLoopRequest.onEvent;
+  const includeLlmStreamEvents = telemetrySession?.includeLlmStreamEvents === true;
+  const wrappedOnEvent = sourceOnEvent || includeLlmStreamEvents ? (event) => {
+    sourceOnEvent?.(event);
+    if (includeLlmStreamEvents) {
+      emitTelemetry({ type: "agent.run.stream", event });
+    }
+  } : void 0;
+  try {
+    const result = await runToolLoop({
+      ...toolLoopRequest,
+      ...instructions ? { instructions } : {},
+      ...wrappedOnEvent ? { onEvent: wrappedOnEvent } : {},
+      tools: mergedTools
+    });
+    emitTelemetry({
+      type: "agent.run.completed",
+      success: true,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      stepCount: result.steps.length,
+      toolCallCount: countToolCalls(result),
+      totalCostUsd: result.totalCostUsd,
+      usage: summarizeResultUsage(result)
+    });
+    return result;
+  } catch (error) {
+    emitTelemetry({
+      type: "agent.run.completed",
+      success: false,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      error: toErrorMessage2(error)
+    });
+    throw error;
+  } finally {
+    await subagentController?.closeAll();
+  }
 }
 function resolveFilesystemTools(model, selection) {
   if (selection === void 0 || selection === false) {
@@ -7390,13 +8641,216 @@ 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,
+          parentRunId: params.runId,
+          telemetry: params.telemetry
+        }
+      );
+    }
+  });
+}
+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;
+}
+function randomRunId() {
+  return (0, import_node_crypto3.randomBytes)(8).toString("hex");
+}
+function toIsoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toErrorMessage2(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Unknown error";
+}
+function countToolCalls(result) {
+  let count = 0;
+  for (const step of result.steps) {
+    count += step.toolCalls.length;
+  }
+  return count;
+}
+function sumUsageValue(current, next) {
+  if (typeof next !== "number" || !Number.isFinite(next)) {
+    return current;
+  }
+  const normalizedNext = Math.max(0, next);
+  if (typeof current !== "number" || !Number.isFinite(current)) {
+    return normalizedNext;
+  }
+  return Math.max(0, current) + normalizedNext;
+}
+function summarizeResultUsage(result) {
+  let summary;
+  for (const step of result.steps) {
+    const usage = step.usage;
+    if (!usage) {
+      continue;
+    }
+    summary = {
+      promptTokens: sumUsageValue(summary?.promptTokens, usage.promptTokens),
+      cachedTokens: sumUsageValue(summary?.cachedTokens, usage.cachedTokens),
+      responseTokens: sumUsageValue(summary?.responseTokens, usage.responseTokens),
+      responseImageTokens: sumUsageValue(summary?.responseImageTokens, usage.responseImageTokens),
+      thinkingTokens: sumUsageValue(summary?.thinkingTokens, usage.thinkingTokens),
+      totalTokens: sumUsageValue(summary?.totalTokens, usage.totalTokens),
+      toolUsePromptTokens: sumUsageValue(summary?.toolUsePromptTokens, usage.toolUsePromptTokens)
+    };
+  }
+  return summary;
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function isAgentTelemetrySink(value) {
+  return typeof value === "object" && value !== null && typeof value.emit === "function";
+}
+function resolveTelemetrySelection(telemetry) {
+  if (!telemetry) {
+    return void 0;
+  }
+  if (isAgentTelemetrySink(telemetry)) {
+    return { sink: telemetry };
+  }
+  if (isAgentTelemetrySink(telemetry.sink)) {
+    return telemetry;
+  }
+  throw new Error("Invalid runAgentLoop telemetry config: expected a sink with emit(event).");
+}
+function createAgentTelemetrySession(telemetry) {
+  const config = resolveTelemetrySelection(telemetry);
+  if (!config) {
+    return void 0;
+  }
+  const pending = /* @__PURE__ */ new Set();
+  const trackPromise = (promise) => {
+    pending.add(promise);
+    promise.finally(() => {
+      pending.delete(promise);
+    });
+  };
+  const emit = (event) => {
+    try {
+      const output = config.sink.emit(event);
+      if (isPromiseLike(output)) {
+        const task = Promise.resolve(output).then(() => void 0).catch(() => void 0);
+        trackPromise(task);
+      }
+    } catch {
+    }
+  };
+  const flush = async () => {
+    while (pending.size > 0) {
+      await Promise.allSettled([...pending]);
+    }
+    if (typeof config.sink.flush === "function") {
+      try {
+        await config.sink.flush();
+      } catch {
+      }
+    }
+  };
+  return {
+    includeLlmStreamEvents: config.includeLlmStreamEvents === true,
+    emit,
+    flush
+  };
+}
+function createAgentTelemetryEmitter(params) {
+  return (event) => {
+    if (!params.session) {
+      return;
+    }
+    params.session.emit({
+      ...event,
+      timestamp: toIsoNow(),
+      runId: params.runId,
+      ...params.parentRunId ? { parentRunId: params.parentRunId } : {},
+      depth: params.depth,
+      model: params.model
+    });
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CHATGPT_MODEL_IDS,
@@ -7420,6 +8874,7 @@ function mergeToolSets(base, extra) {
   appendMarkdownSourcesSection,
   applyPatch,
   configureGemini,
+  configureModelConcurrency,
   convertGooglePartsToLlmParts,
   createApplyPatchTool,
   createCodexApplyPatchTool,
@@ -7464,6 +8919,7 @@ function mergeToolSets(base, extra) {
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
+  resetModelConcurrencyConfig,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,