@ljoukov/llm 3.0.4 → 3.0.6

package/dist/index.js

@@ -1586,23 +1586,16 @@ function parseEventBlock(raw) {
 var MIN_MODEL_CONCURRENCY_CAP = 1;
 var MAX_MODEL_CONCURRENCY_CAP = 64;
 var DEFAULT_MODEL_CONCURRENCY_CAP = 3;
-function parsePositiveInteger(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  const normalized = raw.trim();
-  if (!normalized) {
-    return void 0;
-  }
-  if (!/^-?\d+$/u.test(normalized)) {
-    return void 0;
-  }
-  const parsed = Number.parseInt(normalized, 10);
-  if (!Number.isFinite(parsed)) {
-    return void 0;
-  }
-  return parsed;
-}
+var DEFAULT_OPENAI_MODEL_CONCURRENCY_CAP = 12;
+var DEFAULT_GOOGLE_MODEL_CONCURRENCY_CAP = 4;
+var DEFAULT_GOOGLE_PREVIEW_MODEL_CONCURRENCY_CAP = 2;
+var DEFAULT_FIREWORKS_MODEL_CONCURRENCY_CAP = 6;
+var MODEL_CONCURRENCY_PROVIDERS = [
+  "openai",
+  "google",
+  "fireworks"
+];
+var configuredModelConcurrency = normalizeModelConcurrencyConfig({});
 function clampModelConcurrencyCap(value) {
   if (!Number.isFinite(value)) {
     return DEFAULT_MODEL_CONCURRENCY_CAP;
@@ -1616,30 +1609,94 @@ function clampModelConcurrencyCap(value) {
   }
   return rounded;
 }
-function normalizeModelIdForEnv(modelId) {
-  return modelId.trim().replace(/[^A-Za-z0-9]+/gu, "_").replace(/^_+|_+$/gu, "").toUpperCase();
+function normalizeModelIdForConfig(modelId) {
+  return modelId.trim().toLowerCase();
 }
-function resolveModelConcurrencyCap(options) {
-  const env = options.env ?? process.env;
-  const providerPrefix = options.providerEnvPrefix;
-  const defaultCap = clampModelConcurrencyCap(options.defaultCap ?? DEFAULT_MODEL_CONCURRENCY_CAP);
-  const normalizedModelId = options.modelId ? normalizeModelIdForEnv(options.modelId) : "";
-  const candidateKeys = [
-    ...normalizedModelId ? [
-      `${providerPrefix}_MAX_PARALLEL_REQUESTS_MODEL_${normalizedModelId}`,
-      `LLM_MAX_PARALLEL_REQUESTS_MODEL_${normalizedModelId}`
-    ] : [],
-    `${providerPrefix}_MAX_PARALLEL_REQUESTS_PER_MODEL`,
-    "LLM_MAX_PARALLEL_REQUESTS_PER_MODEL"
-  ];
-  for (const key of candidateKeys) {
-    const parsed = parsePositiveInteger(env[key]);
-    if (parsed === void 0) {
+function normalizeCap(value) {
+  if (value === void 0 || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return clampModelConcurrencyCap(value);
+}
+function normalizeModelCapMap(caps) {
+  const normalized = /* @__PURE__ */ new Map();
+  if (!caps) {
+    return normalized;
+  }
+  for (const [modelId, cap] of Object.entries(caps)) {
+    const modelKey = normalizeModelIdForConfig(modelId);
+    if (!modelKey) {
       continue;
     }
-    return clampModelConcurrencyCap(parsed);
+    const normalizedCap = normalizeCap(cap);
+    if (normalizedCap === void 0) {
+      continue;
+    }
+    normalized.set(modelKey, normalizedCap);
+  }
+  return normalized;
+}
+function normalizeModelConcurrencyConfig(config) {
+  const providerCaps = {};
+  const providerModelCaps = {
+    openai: /* @__PURE__ */ new Map(),
+    google: /* @__PURE__ */ new Map(),
+    fireworks: /* @__PURE__ */ new Map()
+  };
+  for (const provider of MODEL_CONCURRENCY_PROVIDERS) {
+    const providerCap = normalizeCap(config.providerCaps?.[provider]);
+    if (providerCap !== void 0) {
+      providerCaps[provider] = providerCap;
+    }
+    providerModelCaps[provider] = new Map(
+      normalizeModelCapMap(config.providerModelCaps?.[provider])
+    );
   }
-  return defaultCap;
+  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
@@ -1748,12 +1805,20 @@ function createCallScheduler(options = {}) {
       release?.();
     }
   }
-  async function attemptWithRetries(fn, attempt) {
+  async function attemptWithRetries(fn, attempt, state) {
     try {
+      const spacingStartedAtMs = Date.now();
       await applyStartSpacing();
+      const callStartedAtMs = Date.now();
+      state.schedulerDelayMs += Math.max(0, callStartedAtMs - spacingStartedAtMs);
+      if (state.startedAtMs === void 0) {
+        state.startedAtMs = callStartedAtMs;
+      }
+      state.attempts = Math.max(state.attempts, attempt);
       return await fn();
     } catch (error) {
       if (isOverloadError2(error)) {
+        state.overloadCount += 1;
         consecutiveSuccesses = 0;
         currentParallelLimit = Math.max(1, Math.ceil(currentParallelLimit / 2));
       }
@@ -1770,9 +1835,10 @@ function createCallScheduler(options = {}) {
       }
       const normalizedDelay = Math.max(0, delay);
       if (normalizedDelay > 0) {
+        state.retryDelayMs += normalizedDelay;
         await sleep(normalizedDelay);
       }
-      return attemptWithRetries(fn, attempt + 1);
+      return attemptWithRetries(fn, attempt + 1, state);
     }
   }
   function drainQueue() {
@@ -1785,11 +1851,22 @@ function createCallScheduler(options = {}) {
       void task();
     }
   }
-  function run(fn) {
+  function run(fn, runOptions = {}) {
     return new Promise((resolve, reject) => {
+      const enqueuedAtMs = Date.now();
       const job = async () => {
+        const dequeuedAtMs = Date.now();
+        const state = {
+          enqueuedAtMs,
+          dequeuedAtMs,
+          schedulerDelayMs: 0,
+          retryDelayMs: 0,
+          attempts: 0,
+          overloadCount: 0
+        };
         try {
-          const result = await attemptWithRetries(fn, 1);
+          const result = await attemptWithRetries(fn, 1, state);
+          state.completedAtMs = Date.now();
           consecutiveSuccesses += 1;
           if (currentParallelLimit < maxParallelRequests && consecutiveSuccesses >= increaseAfterConsecutiveSuccesses) {
             currentParallelLimit += 1;
@@ -1797,8 +1874,26 @@ function createCallScheduler(options = {}) {
           }
           resolve(result);
         } catch (error) {
+          state.completedAtMs = Date.now();
           reject(toError(error));
         } finally {
+          const startedAtMs = state.startedAtMs ?? state.dequeuedAtMs;
+          const completedAtMs = state.completedAtMs ?? Date.now();
+          const metrics = {
+            enqueuedAtMs: state.enqueuedAtMs,
+            dequeuedAtMs: state.dequeuedAtMs,
+            startedAtMs,
+            completedAtMs,
+            queueWaitMs: Math.max(0, state.dequeuedAtMs - state.enqueuedAtMs),
+            schedulerDelayMs: Math.max(0, state.schedulerDelayMs),
+            retryDelayMs: Math.max(0, state.retryDelayMs),
+            attempts: Math.max(1, state.attempts),
+            overloadCount: Math.max(0, state.overloadCount)
+          };
+          try {
+            runOptions.onSettled?.(metrics);
+          } catch {
+          }
           activeCount -= 1;
           queueMicrotask(drainQueue);
         }
@@ -1895,7 +1990,7 @@ function getSchedulerForModel(modelId) {
   }
   const created = createCallScheduler({
     maxParallelRequests: resolveModelConcurrencyCap({
-      providerEnvPrefix: "FIREWORKS",
+      provider: "fireworks",
       modelId: normalizedModelId
     }),
     minIntervalBetweenStartMs: 200,
@@ -1904,8 +1999,8 @@ function getSchedulerForModel(modelId) {
   schedulerByModel.set(schedulerKey, created);
   return created;
 }
-async function runFireworksCall(fn, modelId) {
-  return getSchedulerForModel(modelId).run(async () => fn(getFireworksClient()));
+async function runFireworksCall(fn, modelId, runOptions) {
+  return getSchedulerForModel(modelId).run(async () => fn(getFireworksClient()), runOptions);
 }
 
 // src/fireworks/models.ts
@@ -2271,7 +2366,7 @@ function getSchedulerForModel2(modelId) {
   }
   const created = createCallScheduler({
     maxParallelRequests: resolveModelConcurrencyCap({
-      providerEnvPrefix: "GOOGLE",
+      provider: "google",
       modelId: normalizedModelId
     }),
     minIntervalBetweenStartMs: 200,
@@ -2291,8 +2386,8 @@ function getSchedulerForModel2(modelId) {
   schedulerByModel2.set(schedulerKey, created);
   return created;
 }
-async function runGeminiCall(fn, modelId) {
-  return getSchedulerForModel2(modelId).run(async () => fn(await getGeminiClient()));
+async function runGeminiCall(fn, modelId, runOptions) {
+  return getSchedulerForModel2(modelId).run(async () => fn(await getGeminiClient()), runOptions);
 }
 
 // src/openai/client.ts
@@ -2464,7 +2559,7 @@ function getSchedulerForModel3(modelId) {
   }
   const created = createCallScheduler({
     maxParallelRequests: resolveModelConcurrencyCap({
-      providerEnvPrefix: "OPENAI",
+      provider: "openai",
       modelId: normalizedModelId
     }),
     minIntervalBetweenStartMs: 200,
@@ -2473,8 +2568,8 @@ function getSchedulerForModel3(modelId) {
   schedulerByModel3.set(schedulerKey, created);
   return created;
 }
-async function runOpenAiCall(fn, modelId) {
-  return getSchedulerForModel3(modelId).run(async () => fn(getOpenAiClient()));
+async function runOpenAiCall(fn, modelId, runOptions) {
+  return getSchedulerForModel3(modelId).run(async () => fn(getOpenAiClient()), runOptions);
 }
 
 // src/openai/models.ts
@@ -2928,9 +3023,9 @@ function isRetryableChatGptTransportError(error) {
     return false;
   }
   const message = error.message.toLowerCase();
-  return message === "terminated" || message.includes("socket hang up") || message.includes("fetch failed") || message.includes("network");
+  return message === "terminated" || message.includes("socket hang up") || message.includes("fetch failed") || message.includes("network") || message.includes("responses websocket");
 }
-async function collectChatGptCodexResponseWithRetry(options, maxAttempts = 2) {
+async function collectChatGptCodexResponseWithRetry(options, maxAttempts = 3) {
   let attempt = 1;
   while (true) {
     try {
@@ -3835,77 +3930,153 @@ function buildToolErrorOutput(message, issues) {
   }
   return output;
 }
+var SUBAGENT_WAIT_TOOL_NAME = "wait";
+function toIsoTimestamp(ms) {
+  return new Date(ms).toISOString();
+}
+function toToolResultDuration(result) {
+  return typeof result.durationMs === "number" && Number.isFinite(result.durationMs) ? Math.max(0, result.durationMs) : 0;
+}
+function schedulerMetricsOrDefault(metrics) {
+  if (!metrics) {
+    return {
+      queueWaitMs: 0,
+      schedulerDelayMs: 0,
+      providerRetryDelayMs: 0,
+      providerAttempts: 1
+    };
+  }
+  return {
+    queueWaitMs: Math.max(0, metrics.queueWaitMs),
+    schedulerDelayMs: Math.max(0, metrics.schedulerDelayMs),
+    providerRetryDelayMs: Math.max(0, metrics.retryDelayMs),
+    providerAttempts: Math.max(1, metrics.attempts),
+    modelCallStartedAtMs: metrics.startedAtMs
+  };
+}
+function buildStepTiming(params) {
+  const scheduler = schedulerMetricsOrDefault(params.schedulerMetrics);
+  const modelCallStartedAtMs = scheduler.modelCallStartedAtMs ?? params.stepStartedAtMs;
+  const firstModelEventAtMs = params.firstModelEventAtMs;
+  const effectiveFirstEventAtMs = firstModelEventAtMs !== void 0 ? Math.max(modelCallStartedAtMs, firstModelEventAtMs) : params.modelCompletedAtMs;
+  const connectionSetupMs = Math.max(0, effectiveFirstEventAtMs - modelCallStartedAtMs);
+  const activeGenerationMs = Math.max(0, params.modelCompletedAtMs - effectiveFirstEventAtMs);
+  return {
+    startedAt: toIsoTimestamp(params.stepStartedAtMs),
+    completedAt: toIsoTimestamp(params.stepCompletedAtMs),
+    totalMs: Math.max(0, params.stepCompletedAtMs - params.stepStartedAtMs),
+    queueWaitMs: scheduler.queueWaitMs,
+    connectionSetupMs,
+    activeGenerationMs,
+    toolExecutionMs: Math.max(0, params.toolExecutionMs),
+    waitToolMs: Math.max(0, params.waitToolMs),
+    schedulerDelayMs: scheduler.schedulerDelayMs,
+    providerRetryDelayMs: scheduler.providerRetryDelayMs,
+    providerAttempts: scheduler.providerAttempts
+  };
+}
+function extractSpawnStartupMetrics(outputPayload) {
+  if (!outputPayload || typeof outputPayload !== "object") {
+    return void 0;
+  }
+  const outputRecord = outputPayload;
+  const notification = typeof outputRecord.notification === "string" ? outputRecord.notification : "";
+  if (notification !== "spawned") {
+    return void 0;
+  }
+  const agent = outputRecord.agent;
+  if (!agent || typeof agent !== "object") {
+    return void 0;
+  }
+  const agentRecord = agent;
+  const startupLatencyMs = agentRecord.spawn_startup_latency_ms;
+  if (typeof startupLatencyMs !== "number" || !Number.isFinite(startupLatencyMs)) {
+    return void 0;
+  }
+  return {
+    spawnStartupLatencyMs: Math.max(0, startupLatencyMs)
+  };
+}
 async function executeToolCall(params) {
   const { callKind, toolName, tool: tool2, rawInput, parseError } = params;
-  if (!tool2) {
-    const message = `Unknown tool: ${toolName}`;
+  const startedAtMs = Date.now();
+  const finalize = (base, outputPayload, metrics) => {
+    const completedAtMs = Date.now();
     return {
-      result: { toolName, input: rawInput, output: { error: message }, error: message },
-      outputPayload: buildToolErrorOutput(message)
+      result: {
+        ...base,
+        startedAt: toIsoTimestamp(startedAtMs),
+        completedAt: toIsoTimestamp(completedAtMs),
+        durationMs: Math.max(0, completedAtMs - startedAtMs),
+        ...metrics ? { metrics } : {}
+      },
+      outputPayload
     };
+  };
+  if (!tool2) {
+    const message = `Unknown tool: ${toolName}`;
+    const outputPayload = buildToolErrorOutput(message);
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
+      outputPayload
+    );
   }
   if (callKind === "custom") {
     if (!isCustomTool(tool2)) {
       const message = `Tool ${toolName} was called as custom_tool_call but is declared as function.`;
       const outputPayload = buildToolErrorOutput(message);
-      return {
-        result: { toolName, input: rawInput, output: outputPayload, error: message },
+      return finalize(
+        { toolName, input: rawInput, output: outputPayload, error: message },
         outputPayload
-      };
+      );
     }
     const input = typeof rawInput === "string" ? rawInput : String(rawInput ?? "");
     try {
       const output = await tool2.execute(input);
-      return {
-        result: { toolName, input, output },
-        outputPayload: output
-      };
+      const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(output) : void 0;
+      return finalize({ toolName, input, output }, output, metrics);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
-      return {
-        result: { toolName, input, output: outputPayload, error: message },
-        outputPayload
-      };
+      return finalize({ toolName, input, output: outputPayload, error: message }, outputPayload);
     }
   }
   if (isCustomTool(tool2)) {
     const message = `Tool ${toolName} was called as function_call but is declared as custom.`;
     const outputPayload = buildToolErrorOutput(message);
-    return {
-      result: { toolName, input: rawInput, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
   if (parseError) {
     const message = `Invalid JSON for tool ${toolName}: ${parseError}`;
-    return {
-      result: { toolName, input: rawInput, output: { error: message }, error: message },
-      outputPayload: buildToolErrorOutput(message)
-    };
+    const outputPayload = buildToolErrorOutput(message);
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
+      outputPayload
+    );
   }
   const parsed = tool2.inputSchema.safeParse(rawInput);
   if (!parsed.success) {
     const message = `Invalid tool arguments for ${toolName}: ${formatZodIssues(parsed.error.issues)}`;
     const outputPayload = buildToolErrorOutput(message, parsed.error.issues);
-    return {
-      result: { toolName, input: rawInput, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: rawInput, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
   try {
     const output = await tool2.execute(parsed.data);
-    return {
-      result: { toolName, input: parsed.data, output },
-      outputPayload: output
-    };
+    const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(output) : void 0;
+    return finalize({ toolName, input: parsed.data, output }, output, metrics);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
-    return {
-      result: { toolName, input: parsed.data, output: outputPayload, error: message },
+    return finalize(
+      { toolName, input: parsed.data, output: outputPayload, error: message },
       outputPayload
-    };
+    );
   }
 }
 function buildToolLogId(turn, toolIndex) {
@@ -4770,6 +4941,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) {
@@ -4788,45 +4962,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();
-      }, providerInfo.model);
+      );
       modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
       emitEvent({ type: "model", modelVersion });
       if (finalResponse.error) {
@@ -4836,6 +5024,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,
@@ -4850,6 +5039,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,
@@ -4857,7 +5056,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 };
       }
@@ -4902,8 +5102,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",
@@ -4918,6 +5125,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,
@@ -4925,7 +5142,8 @@ async function runToolLoop(request) {
         thoughts: reasoningSummary || void 0,
         toolCalls: stepToolCalls,
         usage: usageTokens,
-        costUsd: stepCostUsd
+        costUsd: stepCostUsd,
+        timing
       });
       previousResponseId = finalResponse.id;
       input = toolOutputs;
@@ -4946,6 +5164,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: {
@@ -4968,13 +5193,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({
@@ -4989,6 +5217,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,
@@ -4996,7 +5233,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 };
       }
@@ -5036,8 +5274,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",
@@ -5068,6 +5313,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,
@@ -5075,7 +5329,8 @@ async function runToolLoop(request) {
         thoughts: reasoningSummaryText || void 0,
         toolCalls,
         usage: usageTokens,
-        costUsd: stepCostUsd
+        costUsd: stepCostUsd,
+        timing
       });
       input = input.concat(toolOutputs);
     }
@@ -5091,18 +5346,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 }
-        );
-      }, providerInfo.model);
+      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;
@@ -5133,6 +5399,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,
@@ -5140,7 +5415,8 @@ async function runToolLoop(request) {
           thoughts: void 0,
           toolCalls: [],
           usage: usageTokens,
-          costUsd: stepCostUsd
+          costUsd: stepCostUsd,
+          timing: timing2
         });
         return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
       }
@@ -5175,8 +5451,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",
@@ -5191,6 +5474,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,
@@ -5198,7 +5490,8 @@ async function runToolLoop(request) {
         thoughts: void 0,
         toolCalls: stepToolCalls,
         usage: usageTokens,
-        costUsd: stepCostUsd
+        costUsd: stepCostUsd,
+        timing
       });
       messages.push({
         role: "assistant",
@@ -5214,6 +5507,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,
@@ -5225,81 +5526,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
-      };
-    }, request.model);
+    );
+    const modelCompletedAtMs = Date.now();
     const usageTokens = extractGeminiUsageTokens(response.usageMetadata);
     const modelVersion = response.modelVersion ?? request.model;
     const stepCostUsd = estimateCallCostUsd({
@@ -5311,6 +5622,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,
@@ -5318,7 +5639,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 };
     }
@@ -5368,8 +5690,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: {
@@ -5379,6 +5708,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,
@@ -5386,7 +5725,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 });
   }
@@ -5637,6 +5977,9 @@ function appendMarkdownSourcesSection(value, sources) {
 ${lines}`;
 }
 
+// src/agent.ts
+import { randomBytes as randomBytes3 } from "crypto";
+
 // src/agent/subagents.ts
 import { randomBytes as randomBytes2 } from "crypto";
 import { z as z4 } from "zod";
@@ -6098,7 +6441,12 @@ function startRun(agent, options) {
   }
   const input = [...agent.history, { role: "user", content: nextInput }];
   const abortController = new AbortController();
+  const runStartedAtMs = Date.now();
   agent.abortController = abortController;
+  if (agent.firstRunStartedAtMs === void 0) {
+    agent.firstRunStartedAtMs = runStartedAtMs;
+  }
+  agent.lastRunStartedAtMs = runStartedAtMs;
   agent.lastError = void 0;
   setLifecycle(
     agent,
@@ -6142,6 +6490,9 @@ function startRun(agent, options) {
       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;
     }
@@ -6217,6 +6568,13 @@ function buildSnapshot(agent) {
     turns: agent.turns,
     created_at: new Date(agent.createdAtMs).toISOString(),
     updated_at: new Date(agent.updatedAtMs).toISOString(),
+    ...agent.firstRunStartedAtMs ? {
+      first_run_started_at: new Date(agent.firstRunStartedAtMs).toISOString(),
+      spawn_startup_latency_ms: Math.max(0, agent.firstRunStartedAtMs - agent.createdAtMs)
+    } : {},
+    ...agent.lastRunStartedAtMs ? { last_run_started_at: new Date(agent.lastRunStartedAtMs).toISOString() } : {},
+    ...agent.lastRunCompletedAtMs ? { last_run_completed_at: new Date(agent.lastRunCompletedAtMs).toISOString() } : {},
+    ...typeof agent.lastRunDurationMs === "number" ? { last_run_duration_ms: Math.max(0, agent.lastRunDurationMs) } : {},
     ...agent.lastError ? { last_error: agent.lastError } : {},
     ...agent.lastResult ? {
       last_result: {
@@ -8046,7 +8404,12 @@ function isNoEntError(error) {
 
 // src/agent.ts
 async function runAgentLoop(request) {
-  return await runAgentLoopInternal(request, { depth: 0 });
+  const telemetry = createAgentTelemetrySession(request.telemetry);
+  try {
+    return await runAgentLoopInternal(request, { depth: 0, telemetry });
+  } finally {
+    await telemetry?.flush();
+  }
 }
 async function runAgentLoopInternal(request, context) {
   const {
@@ -8056,15 +8419,21 @@ async function runAgentLoopInternal(request, context) {
     subagentTool,
     subagent_tool,
     subagents,
+    telemetry,
     ...toolLoopRequest
   } = request;
+  const telemetrySession = context.telemetry ?? createAgentTelemetrySession(telemetry);
+  const runId = randomRunId();
+  const startedAtMs = Date.now();
   const filesystemSelection = filesystemTool ?? filesystem_tool;
   const subagentSelection = subagentTool ?? subagent_tool ?? subagents;
   const filesystemTools = resolveFilesystemTools(request.model, filesystemSelection);
   const resolvedSubagentConfig = resolveSubagentToolConfig(subagentSelection, context.depth);
   const subagentController = createSubagentController({
+    runId,
     model: request.model,
     depth: context.depth,
+    telemetry: telemetrySession,
     customTools: customTools ?? {},
     filesystemSelection,
     subagentSelection,
@@ -8085,12 +8454,54 @@ async function runAgentLoopInternal(request, context) {
     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 {
-    return await runToolLoop({
+    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();
   }
@@ -8153,7 +8564,11 @@ function createSubagentController(params) {
           openAiReasoningEffort: params.toolLoopRequest.openAiReasoningEffort,
           signal: subagentRequest.signal
         },
-        { depth: params.depth + 1 }
+        {
+          depth: params.depth + 1,
+          parentRunId: params.runId,
+          telemetry: params.telemetry
+        }
       );
     }
   });
@@ -8204,6 +8619,129 @@ function trimToUndefined2(value) {
   const trimmed = value?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
 }
+function randomRunId() {
+  return randomBytes3(8).toString("hex");
+}
+function toIsoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toErrorMessage2(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Unknown error";
+}
+function countToolCalls(result) {
+  let count = 0;
+  for (const step of result.steps) {
+    count += step.toolCalls.length;
+  }
+  return count;
+}
+function sumUsageValue(current, next) {
+  if (typeof next !== "number" || !Number.isFinite(next)) {
+    return current;
+  }
+  const normalizedNext = Math.max(0, next);
+  if (typeof current !== "number" || !Number.isFinite(current)) {
+    return normalizedNext;
+  }
+  return Math.max(0, current) + normalizedNext;
+}
+function summarizeResultUsage(result) {
+  let summary;
+  for (const step of result.steps) {
+    const usage = step.usage;
+    if (!usage) {
+      continue;
+    }
+    summary = {
+      promptTokens: sumUsageValue(summary?.promptTokens, usage.promptTokens),
+      cachedTokens: sumUsageValue(summary?.cachedTokens, usage.cachedTokens),
+      responseTokens: sumUsageValue(summary?.responseTokens, usage.responseTokens),
+      responseImageTokens: sumUsageValue(summary?.responseImageTokens, usage.responseImageTokens),
+      thinkingTokens: sumUsageValue(summary?.thinkingTokens, usage.thinkingTokens),
+      totalTokens: sumUsageValue(summary?.totalTokens, usage.totalTokens),
+      toolUsePromptTokens: sumUsageValue(summary?.toolUsePromptTokens, usage.toolUsePromptTokens)
+    };
+  }
+  return summary;
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function isAgentTelemetrySink(value) {
+  return typeof value === "object" && value !== null && typeof value.emit === "function";
+}
+function resolveTelemetrySelection(telemetry) {
+  if (!telemetry) {
+    return void 0;
+  }
+  if (isAgentTelemetrySink(telemetry)) {
+    return { sink: telemetry };
+  }
+  if (isAgentTelemetrySink(telemetry.sink)) {
+    return telemetry;
+  }
+  throw new Error("Invalid runAgentLoop telemetry config: expected a sink with emit(event).");
+}
+function createAgentTelemetrySession(telemetry) {
+  const config = resolveTelemetrySelection(telemetry);
+  if (!config) {
+    return void 0;
+  }
+  const pending = /* @__PURE__ */ new Set();
+  const trackPromise = (promise) => {
+    pending.add(promise);
+    promise.finally(() => {
+      pending.delete(promise);
+    });
+  };
+  const emit = (event) => {
+    try {
+      const output = config.sink.emit(event);
+      if (isPromiseLike(output)) {
+        const task = Promise.resolve(output).then(() => void 0).catch(() => void 0);
+        trackPromise(task);
+      }
+    } catch {
+    }
+  };
+  const flush = async () => {
+    while (pending.size > 0) {
+      await Promise.allSettled([...pending]);
+    }
+    if (typeof config.sink.flush === "function") {
+      try {
+        await config.sink.flush();
+      } catch {
+      }
+    }
+  };
+  return {
+    includeLlmStreamEvents: config.includeLlmStreamEvents === true,
+    emit,
+    flush
+  };
+}
+function createAgentTelemetryEmitter(params) {
+  return (event) => {
+    if (!params.session) {
+      return;
+    }
+    params.session.emit({
+      ...event,
+      timestamp: toIsoNow(),
+      runId: params.runId,
+      ...params.parentRunId ? { parentRunId: params.parentRunId } : {},
+      depth: params.depth,
+      model: params.model
+    });
+  };
+}
 export {
   CHATGPT_MODEL_IDS,
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
@@ -8226,6 +8764,7 @@ export {
   appendMarkdownSourcesSection,
   applyPatch,
   configureGemini,
+  configureModelConcurrency,
   convertGooglePartsToLlmParts,
   createApplyPatchTool,
   createCodexApplyPatchTool,
@@ -8270,6 +8809,7 @@ export {
   loadLocalEnv,
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
+  resetModelConcurrencyConfig,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,