@ljoukov/llm 4.1.1 → 5.0.2

package/dist/index.js

@@ -4053,6 +4053,71 @@ var files = {
   content: filesContent
 };
 
+// src/telemetry.ts
+var telemetryState = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.telemetryState"),
+  () => ({
+    configuredTelemetry: void 0
+  })
+);
+function configureTelemetry(telemetry = void 0) {
+  telemetryState.configuredTelemetry = telemetry === void 0 || telemetry === false ? void 0 : telemetry;
+}
+function resetTelemetry() {
+  telemetryState.configuredTelemetry = void 0;
+}
+function isPromiseLike2(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function resolveTelemetrySelection(telemetry) {
+  if (telemetry === false) {
+    return void 0;
+  }
+  if (telemetry !== void 0) {
+    return telemetry;
+  }
+  return telemetryState.configuredTelemetry;
+}
+function createTelemetrySession(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 (isPromiseLike2(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 {
+    includeStreamEvents: config.includeStreamEvents === true,
+    emit,
+    flush
+  };
+}
+
 // src/llm.ts
 var toolCallContextStorage = getRuntimeSingleton(
   /* @__PURE__ */ Symbol.for("@ljoukov/llm.toolCallContextStorage"),
@@ -5639,6 +5704,65 @@ function mergeTokenUpdates(current, next) {
     toolUsePromptTokens: next.toolUsePromptTokens ?? current.toolUsePromptTokens
   };
 }
+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 sumUsageTokens(current, next) {
+  if (!next) {
+    return current;
+  }
+  return {
+    promptTokens: sumUsageValue(current?.promptTokens, next.promptTokens),
+    cachedTokens: sumUsageValue(current?.cachedTokens, next.cachedTokens),
+    responseTokens: sumUsageValue(current?.responseTokens, next.responseTokens),
+    responseImageTokens: sumUsageValue(current?.responseImageTokens, next.responseImageTokens),
+    thinkingTokens: sumUsageValue(current?.thinkingTokens, next.thinkingTokens),
+    totalTokens: sumUsageValue(current?.totalTokens, next.totalTokens),
+    toolUsePromptTokens: sumUsageValue(current?.toolUsePromptTokens, next.toolUsePromptTokens)
+  };
+}
+function countInlineImagesInContent(content) {
+  if (!content) {
+    return 0;
+  }
+  let count = 0;
+  for (const part of content.parts) {
+    if (part.type === "inlineData" && isInlineImageMime(part.mimeType)) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function createLlmTelemetryEmitter(params) {
+  const session = createTelemetrySession(params.telemetry);
+  const callId = randomBytes(8).toString("hex");
+  return {
+    includeStreamEvents: session?.includeStreamEvents === true,
+    emit: (event) => {
+      if (!session) {
+        return;
+      }
+      session.emit({
+        ...event,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        callId,
+        operation: params.operation,
+        provider: params.provider,
+        model: params.model
+      });
+    },
+    flush: async () => {
+      await session?.flush();
+    }
+  };
+}
 function toMaybeNumber(value) {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value;
@@ -5859,6 +5983,23 @@ function toOpenAiToolOutput(value) {
   }
   return mergeToolOutput(value);
 }
+function toChatGptToolOutput(value) {
+  const toolOutput = toOpenAiToolOutput(value);
+  if (typeof toolOutput === "string") {
+    return toolOutput;
+  }
+  return toolOutput.map((item) => {
+    if (item.type !== "input_image") {
+      return item;
+    }
+    return {
+      type: "input_image",
+      ...item.file_id ? { file_id: item.file_id } : {},
+      ...item.image_url ? { image_url: item.image_url } : {},
+      ...item.detail ? { detail: item.detail } : {}
+    };
+  });
+}
 function toGeminiToolOutputItems(value) {
   if (isLlmToolOutputContentItem(value)) {
     return [value];
@@ -7048,6 +7189,10 @@ async function runTextCall(params) {
   let responseRole;
   let latestUsage;
   let responseImages = 0;
+  const pushEvent = (event) => {
+    queue.push(event);
+    params.onEvent?.(event);
+  };
   const pushDelta = (channel, text) => {
     if (!text) {
       return;
@@ -7058,7 +7203,7 @@ async function runTextCall(params) {
     } else {
       callLogger?.appendResponseDelta(text);
     }
-    queue.push({ type: "delta", channel, text });
+    pushEvent({ type: "delta", channel, text });
   };
   const pushInline = (data, mimeType) => {
     if (!data) {
@@ -7128,7 +7273,7 @@ async function runTextCall(params) {
               }
               case "response.refusal.delta": {
                 blocked = true;
-                queue.push({ type: "blocked" });
+                pushEvent({ type: "blocked" });
                 break;
               }
               default:
@@ -7137,7 +7282,7 @@ async function runTextCall(params) {
           }
           const finalResponse = await stream.finalResponse();
           modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
-          queue.push({ type: "model", modelVersion });
+          pushEvent({ type: "model", modelVersion });
           if (finalResponse.error) {
             const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
             throw new Error(message);
@@ -7201,11 +7346,11 @@ async function runTextCall(params) {
         });
         blocked = blocked || result2.blocked;
         if (blocked) {
-          queue.push({ type: "blocked" });
+          pushEvent({ type: "blocked" });
         }
         if (result2.model) {
           modelVersion = providerInfo.serviceTier ? request.model : `chatgpt-${result2.model}`;
-          queue.push({ type: "model", modelVersion });
+          pushEvent({ type: "model", modelVersion });
         }
         latestUsage = extractChatGptUsageTokens(result2.usage);
         const fallbackText = typeof result2.text === "string" ? result2.text : "";
@@ -7243,11 +7388,11 @@ async function runTextCall(params) {
             { signal }
           );
           modelVersion = typeof response.model === "string" ? response.model : request.model;
-          queue.push({ type: "model", modelVersion });
+          pushEvent({ type: "model", modelVersion });
           const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
           if (choice?.finish_reason === "content_filter") {
             blocked = true;
-            queue.push({ type: "blocked" });
+            pushEvent({ type: "blocked" });
           }
           const textOutput = extractFireworksMessageText(
             choice?.message
@@ -7289,11 +7434,11 @@ async function runTextCall(params) {
           for await (const chunk of stream) {
             if (chunk.modelVersion) {
               modelVersion = chunk.modelVersion;
-              queue.push({ type: "model", modelVersion });
+              pushEvent({ type: "model", modelVersion });
             }
             if (chunk.promptFeedback?.blockReason) {
               blocked = true;
-              queue.push({ type: "blocked" });
+              pushEvent({ type: "blocked" });
             }
             latestUsage = mergeTokenUpdates(
               latestUsage,
@@ -7306,7 +7451,7 @@ async function runTextCall(params) {
             const primary = candidates[0];
             if (primary && isModerationFinish(primary.finishReason)) {
               blocked = true;
-              queue.push({ type: "blocked" });
+              pushEvent({ type: "blocked" });
             }
             for (const candidate of candidates) {
               const candidateContent = candidate.content;
@@ -7343,7 +7488,7 @@ async function runTextCall(params) {
         imageSize: request.imageSize
       });
       if (latestUsage) {
-        queue.push({ type: "usage", usage: latestUsage, costUsd, modelVersion });
+        pushEvent({ type: "usage", usage: latestUsage, costUsd, modelVersion });
       }
       callLogger?.complete({
         responseText: text,
@@ -7397,18 +7542,76 @@ async function runTextCall(params) {
   });
   return result;
 }
-function streamText(request) {
+function startTextStream(request, operation) {
   const queue = createAsyncQueue();
   const abortController = new AbortController();
+  const provider = resolveProvider(request.model).provider;
+  const telemetry = createLlmTelemetryEmitter({
+    telemetry: request.telemetry,
+    operation,
+    provider,
+    model: request.model
+  });
+  const startedAtMs = Date.now();
+  telemetry.emit({
+    type: "llm.call.started",
+    inputMode: typeof request.input === "string" ? "string" : "messages",
+    toolCount: request.tools?.length ?? 0,
+    responseModalities: request.responseModalities
+  });
   const result = (async () => {
+    let uploadMetrics = emptyFileUploadMetrics();
     try {
-      const output = await runTextCall({ request, queue, abortController });
+      let output;
+      await collectFileUploadMetrics(async () => {
+        try {
+          output = await runTextCall({
+            request,
+            queue,
+            abortController,
+            onEvent: telemetry.includeStreamEvents ? (event) => {
+              telemetry.emit({ type: "llm.call.stream", event });
+            } : void 0
+          });
+        } finally {
+          uploadMetrics = getCurrentFileUploadMetrics();
+        }
+      });
+      if (!output) {
+        throw new Error("LLM text call returned no result.");
+      }
+      telemetry.emit({
+        type: "llm.call.completed",
+        success: true,
+        durationMs: Math.max(0, Date.now() - startedAtMs),
+        modelVersion: output.modelVersion,
+        blocked: output.blocked,
+        usage: output.usage,
+        costUsd: output.costUsd,
+        outputTextChars: output.text.length,
+        thoughtChars: output.thoughts.length,
+        responseImages: countInlineImagesInContent(output.content),
+        uploadCount: uploadMetrics.count,
+        uploadBytes: uploadMetrics.totalBytes,
+        uploadLatencyMs: uploadMetrics.totalLatencyMs
+      });
       queue.close();
       return output;
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
+      telemetry.emit({
+        type: "llm.call.completed",
+        success: false,
+        durationMs: Math.max(0, Date.now() - startedAtMs),
+        uploadCount: uploadMetrics.count,
+        uploadBytes: uploadMetrics.totalBytes,
+        uploadLatencyMs: uploadMetrics.totalLatencyMs,
+        error: err.message
+      });
       queue.fail(err);
       throw err;
+    } finally {
+      await telemetry.flush();
     }
   })();
   return {
@@ -7417,8 +7620,11 @@ function streamText(request) {
     abort: () => abortController.abort()
   };
 }
+function streamText(request) {
+  return startTextStream(request, "streamText");
+}
 async function generateText(request) {
-  const call = streamText(request);
+  const call = startTextStream(request, "generateText");
   for await (const _event of call.events) {
   }
   return await call.result;
@@ -7444,9 +7650,26 @@ function buildJsonSchemaConfig(request) {
   } : void 0;
   return { providerInfo, responseJsonSchema, openAiTextFormat };
 }
-function streamJson(request) {
+function startJsonStream(request, operation) {
   const queue = createAsyncQueue();
   const abortController = new AbortController();
+  const provider = resolveProvider(request.model).provider;
+  const telemetry = createLlmTelemetryEmitter({
+    telemetry: request.telemetry,
+    operation,
+    provider,
+    model: request.model
+  });
+  const startedAtMs = Date.now();
+  const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
+  const streamMode = request.streamMode ?? "partial";
+  telemetry.emit({
+    type: "llm.call.started",
+    inputMode: typeof request.input === "string" ? "string" : "messages",
+    toolCount: request.tools?.length ?? 0,
+    maxAttempts,
+    streamMode
+  });
   const resolveAbortSignal = () => {
     if (!request.signal) {
       return abortController.signal;
@@ -7465,135 +7688,155 @@ function streamJson(request) {
     return abortController.signal;
   };
   const result = (async () => {
-    const signal = resolveAbortSignal();
-    const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
-    const { providerInfo, responseJsonSchema, openAiTextFormat } = buildJsonSchemaConfig(request);
-    const streamMode = request.streamMode ?? "partial";
-    const failures = [];
-    let openAiTextFormatForAttempt = openAiTextFormat;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-      let rawText = "";
-      let lastPartial = "";
-      try {
-        const call = streamText({
-          model: request.model,
-          input: request.input,
-          instructions: request.instructions,
-          tools: request.tools,
-          responseMimeType: request.responseMimeType ?? "application/json",
-          responseJsonSchema,
-          thinkingLevel: request.thinkingLevel,
-          ...openAiTextFormatForAttempt ? { openAiTextFormat: openAiTextFormatForAttempt } : {},
-          signal
-        });
+    let uploadMetrics = emptyFileUploadMetrics();
+    let attemptsUsed = 0;
+    try {
+      let output;
+      await collectFileUploadMetrics(async () => {
         try {
-          for await (const event of call.events) {
-            queue.push(event);
-            if (event.type === "delta" && event.channel === "response") {
-              rawText += event.text;
-              if (streamMode === "partial") {
-                const partial = parsePartialJsonFromLlmText(rawText);
-                if (partial !== null) {
-                  const serialized = JSON.stringify(partial);
-                  if (serialized !== lastPartial) {
-                    lastPartial = serialized;
-                    queue.push({
-                      type: "json",
-                      stage: "partial",
-                      value: partial
-                    });
+          const signal = resolveAbortSignal();
+          const { providerInfo, responseJsonSchema, openAiTextFormat } = buildJsonSchemaConfig(request);
+          const failures = [];
+          let openAiTextFormatForAttempt = openAiTextFormat;
+          for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            attemptsUsed = attempt;
+            let rawText = "";
+            let lastPartial = "";
+            try {
+              const call = streamText({
+                model: request.model,
+                input: request.input,
+                instructions: request.instructions,
+                tools: request.tools,
+                responseMimeType: request.responseMimeType ?? "application/json",
+                responseJsonSchema,
+                thinkingLevel: request.thinkingLevel,
+                ...openAiTextFormatForAttempt ? { openAiTextFormat: openAiTextFormatForAttempt } : {},
+                telemetry: false,
+                signal
+              });
+              try {
+                for await (const event of call.events) {
+                  queue.push(event);
+                  if (telemetry.includeStreamEvents) {
+                    telemetry.emit({ type: "llm.call.stream", event });
+                  }
+                  if (event.type === "delta" && event.channel === "response") {
+                    rawText += event.text;
+                    if (streamMode === "partial") {
+                      const partial = parsePartialJsonFromLlmText(rawText);
+                      if (partial !== null) {
+                        const serialized = JSON.stringify(partial);
+                        if (serialized !== lastPartial) {
+                          lastPartial = serialized;
+                          queue.push({
+                            type: "json",
+                            stage: "partial",
+                            value: partial
+                          });
+                        }
+                      }
+                    }
                   }
                 }
+              } catch (streamError) {
+                await call.result.catch(() => void 0);
+                throw streamError;
+              }
+              const result2 = await call.result;
+              rawText = rawText || result2.text;
+              const cleanedText = normalizeJsonText(rawText);
+              const repairedText = escapeNewlinesInStrings(cleanedText);
+              const payload = JSON.parse(repairedText);
+              const normalized = typeof request.normalizeJson === "function" ? request.normalizeJson(payload) : payload;
+              const parsed = request.schema.parse(normalized);
+              queue.push({ type: "json", stage: "final", value: parsed });
+              output = { value: parsed, rawText, result: result2 };
+              return;
+            } catch (error) {
+              const handled = error instanceof Error ? error : new Error(String(error));
+              failures.push({ attempt, rawText, error: handled });
+              if (providerInfo.provider === "chatgpt" && openAiTextFormatForAttempt) {
+                openAiTextFormatForAttempt = void 0;
+              }
+              if (attempt >= maxAttempts) {
+                throw new LlmJsonCallError(
+                  `LLM JSON call failed after ${attempt} attempt(s)`,
+                  failures
+                );
               }
             }
           }
-        } catch (streamError) {
-          await call.result.catch(() => void 0);
-          throw streamError;
-        }
-        const result2 = await call.result;
-        rawText = rawText || result2.text;
-        const cleanedText = normalizeJsonText(rawText);
-        const repairedText = escapeNewlinesInStrings(cleanedText);
-        const payload = JSON.parse(repairedText);
-        const normalized = typeof request.normalizeJson === "function" ? request.normalizeJson(payload) : payload;
-        const parsed = request.schema.parse(normalized);
-        queue.push({ type: "json", stage: "final", value: parsed });
-        queue.close();
-        return { value: parsed, rawText, result: result2 };
-      } catch (error) {
-        const handled = error instanceof Error ? error : new Error(String(error));
-        failures.push({ attempt, rawText, error: handled });
-        if (providerInfo.provider === "chatgpt" && openAiTextFormatForAttempt) {
-          openAiTextFormatForAttempt = void 0;
-        }
-        if (attempt >= maxAttempts) {
-          throw new LlmJsonCallError(`LLM JSON call failed after ${attempt} attempt(s)`, failures);
+          throw new LlmJsonCallError("LLM JSON call failed", failures);
+        } finally {
+          uploadMetrics = getCurrentFileUploadMetrics();
         }
-      }
+      });
+      if (!output) {
+        throw new Error("LLM JSON call returned no result.");
+      }
+      telemetry.emit({
+        type: "llm.call.completed",
+        success: true,
+        durationMs: Math.max(0, Date.now() - startedAtMs),
+        modelVersion: output.result.modelVersion,
+        blocked: output.result.blocked,
+        usage: output.result.usage,
+        costUsd: output.result.costUsd,
+        rawTextChars: output.rawText.length,
+        attempts: attemptsUsed,
+        uploadCount: uploadMetrics.count,
+        uploadBytes: uploadMetrics.totalBytes,
+        uploadLatencyMs: uploadMetrics.totalLatencyMs
+      });
+      queue.close();
+      return output;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      telemetry.emit({
+        type: "llm.call.completed",
+        success: false,
+        durationMs: Math.max(0, Date.now() - startedAtMs),
+        attempts: attemptsUsed > 0 ? attemptsUsed : void 0,
+        uploadCount: uploadMetrics.count,
+        uploadBytes: uploadMetrics.totalBytes,
+        uploadLatencyMs: uploadMetrics.totalLatencyMs,
+        error: err.message
+      });
+      queue.fail(err);
+      throw err;
+    } finally {
+      await telemetry.flush();
     }
-    throw new LlmJsonCallError("LLM JSON call failed", failures);
-  })().catch((error) => {
-    const err = error instanceof Error ? error : new Error(String(error));
-    queue.fail(err);
-    throw err;
-  });
+  })();
   return {
     events: queue.iterable,
     result,
     abort: () => abortController.abort()
   };
 }
+function streamJson(request) {
+  return startJsonStream(request, "streamJson");
+}
 async function generateJson(request) {
-  const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 2));
-  const { providerInfo, responseJsonSchema, openAiTextFormat } = buildJsonSchemaConfig(request);
-  let openAiTextFormatForAttempt = openAiTextFormat;
-  const failures = [];
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    let rawText = "";
-    try {
-      const call = streamText({
-        model: request.model,
-        input: request.input,
-        instructions: request.instructions,
-        tools: request.tools,
-        responseMimeType: request.responseMimeType ?? "application/json",
-        responseJsonSchema,
-        thinkingLevel: request.thinkingLevel,
-        ...openAiTextFormatForAttempt ? { openAiTextFormat: openAiTextFormatForAttempt } : {},
-        signal: request.signal
-      });
-      try {
-        for await (const event of call.events) {
-          request.onEvent?.(event);
-          if (event.type === "delta" && event.channel === "response") {
-            rawText += event.text;
-          }
-        }
-      } catch (streamError) {
-        await call.result.catch(() => void 0);
-        throw streamError;
-      }
-      const result = await call.result;
-      rawText = rawText || result.text;
-      const cleanedText = normalizeJsonText(rawText);
-      const repairedText = escapeNewlinesInStrings(cleanedText);
-      const payload = JSON.parse(repairedText);
-      const normalized = typeof request.normalizeJson === "function" ? request.normalizeJson(payload) : payload;
-      const parsed = request.schema.parse(normalized);
-      return { value: parsed, rawText, result };
-    } catch (error) {
-      const handled = error instanceof Error ? error : new Error(String(error));
-      failures.push({ attempt, rawText, error: handled });
-      if (providerInfo.provider === "chatgpt" && openAiTextFormatForAttempt) {
-        openAiTextFormatForAttempt = void 0;
-      }
-      if (attempt >= maxAttempts) {
-        throw new LlmJsonCallError(`LLM JSON call failed after ${attempt} attempt(s)`, failures);
+  const call = startJsonStream(
+    {
+      ...request,
+      streamMode: "final"
+    },
+    "generateJson"
+  );
+  try {
+    for await (const event of call.events) {
+      if (event.type !== "json") {
+        request.onEvent?.(event);
       }
     }
+  } catch (streamError) {
+    await call.result.catch(() => void 0);
+    throw streamError;
   }
-  throw new LlmJsonCallError("LLM JSON call failed", failures);
+  return await call.result;
 }
 var DEFAULT_TOOL_LOOP_MAX_STEPS = 8;
 function resolveToolLoopContents(input) {
@@ -8441,7 +8684,7 @@ async function runToolLoop(request) {
               toolOutputs.push({
                 type: "custom_tool_call_output",
                 call_id: entry.ids.callId,
-                output: toOpenAiToolOutput(outputPayload)
+                output: toChatGptToolOutput(outputPayload)
               });
             } else {
               toolOutputs.push({
@@ -8455,7 +8698,7 @@ async function runToolLoop(request) {
               toolOutputs.push({
                 type: "function_call_output",
                 call_id: entry.ids.callId,
-                output: toOpenAiToolOutput(outputPayload)
+                output: toChatGptToolOutput(outputPayload)
               });
             }
           }
@@ -9209,7 +9452,10 @@ function streamToolLoop(request) {
     abort: () => abortController.abort()
   };
 }
-var IMAGE_GRADE_SCHEMA = z3.enum(["pass", "fail"]);
+var IMAGE_GRADE_VALUE_SCHEMA = z3.enum(["pass", "fail"]);
+var IMAGE_GRADE_SCHEMA = z3.object({
+  grade: IMAGE_GRADE_VALUE_SCHEMA
+});
 async function gradeGeneratedImage(params) {
   const parts = [
     {
@@ -9220,7 +9466,7 @@ async function gradeGeneratedImage(params) {
         "Image prompt to grade:",
         params.imagePrompt,
         "",
-        'Respond with the JSON string "pass" or "fail".'
+        'Respond with JSON like {"grade":"pass"} or {"grade":"fail"}.'
       ].join("\\n")
     },
     {
@@ -9229,12 +9475,13 @@ async function gradeGeneratedImage(params) {
       mimeType: params.image.mimeType ?? "image/png"
     }
   ];
-  const { value } = await generateJson({
+  const { value, result } = await generateJson({
     model: params.model,
     input: [{ role: "user", content: parts }],
-    schema: IMAGE_GRADE_SCHEMA
+    schema: IMAGE_GRADE_SCHEMA,
+    telemetry: false
   });
-  return value;
+  return { grade: value.grade, result };
 }
 async function generateImages(request) {
   const maxAttempts = Math.max(1, Math.floor(request.maxAttempts ?? 4));
@@ -9254,6 +9501,19 @@ async function generateImages(request) {
   if (!gradingPrompt) {
     throw new Error("imageGradingPrompt must be a non-empty string");
   }
+  const telemetry = createLlmTelemetryEmitter({
+    telemetry: request.telemetry,
+    operation: "generateImages",
+    provider: resolveProvider(request.model).provider,
+    model: request.model
+  });
+  const startedAtMs = Date.now();
+  telemetry.emit({
+    type: "llm.call.started",
+    imagePromptCount: promptList.length,
+    styleImageCount: request.styleImages?.length ?? 0,
+    maxAttempts
+  });
   const addText = (parts, text) => {
     const lastPart = parts[parts.length - 1];
     if (lastPart !== void 0 && lastPart.type === "text") {
@@ -9311,6 +9571,9 @@ async function generateImages(request) {
   const inputMessages = [{ role: "user", content: buildInitialPromptParts() }];
   const orderedEntries = [...promptEntries];
   const resolvedImages = /* @__PURE__ */ new Map();
+  let totalCostUsd = 0;
+  let totalUsage;
+  let attemptsUsed = 0;
   const removeResolvedEntries = (resolved) => {
     if (resolved.size === 0) {
       return;
@@ -9325,70 +9588,118 @@ async function generateImages(request) {
       }
     }
   };
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    const result = await generateText({
-      model: request.model,
-      input: inputMessages,
-      responseModalities: ["IMAGE", "TEXT"],
-      imageAspectRatio: request.imageAspectRatio,
-      imageSize: request.imageSize ?? "2K"
-    });
-    if (result.blocked || !result.content) {
-      continue;
-    }
-    const images = extractImages(result.content);
-    if (images.length > 0 && promptEntries.length > 0) {
-      const assignedCount = Math.min(images.length, promptEntries.length);
-      const pendingAssignments = promptEntries.slice(0, assignedCount);
-      const assignedImages = images.slice(0, assignedCount);
-      const gradeResults = await Promise.all(
-        pendingAssignments.map(
-          (entry, index) => gradeGeneratedImage({
-            gradingPrompt,
-            imagePrompt: entry.prompt,
-            image: (() => {
-              const image = assignedImages[index];
-              if (!image) {
-                throw new Error("Image generation returned fewer images than expected.");
+  let uploadMetrics = emptyFileUploadMetrics();
+  try {
+    await collectFileUploadMetrics(async () => {
+      try {
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+          attemptsUsed = attempt;
+          const result = await generateText({
+            model: request.model,
+            input: inputMessages,
+            responseModalities: ["IMAGE", "TEXT"],
+            imageAspectRatio: request.imageAspectRatio,
+            imageSize: request.imageSize ?? "2K",
+            telemetry: false
+          });
+          totalCostUsd += result.costUsd;
+          totalUsage = sumUsageTokens(totalUsage, result.usage);
+          if (result.blocked || !result.content) {
+            continue;
+          }
+          const images = extractImages(result.content);
+          if (images.length > 0 && promptEntries.length > 0) {
+            const assignedCount = Math.min(images.length, promptEntries.length);
+            const pendingAssignments = promptEntries.slice(0, assignedCount);
+            const assignedImages = images.slice(0, assignedCount);
+            const gradeResults = await Promise.all(
+              pendingAssignments.map(
+                (entry, index) => gradeGeneratedImage({
+                  gradingPrompt,
+                  imagePrompt: entry.prompt,
+                  image: (() => {
+                    const image = assignedImages[index];
+                    if (!image) {
+                      throw new Error("Image generation returned fewer images than expected.");
+                    }
+                    return image;
+                  })(),
+                  model: "gpt-5.2"
+                })
+              )
+            );
+            const passedEntries = /* @__PURE__ */ new Set();
+            for (let i = 0; i < gradeResults.length; i += 1) {
+              const gradeResult = gradeResults[i];
+              const entry = pendingAssignments[i];
+              const image = assignedImages[i];
+              if (!gradeResult || !entry || !image) {
+                continue;
               }
-              return image;
-            })(),
-            model: "gpt-5.2"
-          })
-        )
-      );
-      const passedEntries = /* @__PURE__ */ new Set();
-      for (let i = 0; i < gradeResults.length; i += 1) {
-        const grade = gradeResults[i];
-        const entry = pendingAssignments[i];
-        const image = assignedImages[i];
-        if (!grade || !entry || !image) {
-          continue;
-        }
-        if (grade === "pass") {
-          resolvedImages.set(entry.index, image);
-          passedEntries.add(entry.index);
+              totalCostUsd += gradeResult.result.costUsd;
+              totalUsage = sumUsageTokens(totalUsage, gradeResult.result.usage);
+              if (gradeResult.grade === "pass") {
+                resolvedImages.set(entry.index, image);
+                passedEntries.add(entry.index);
+              }
+            }
+            removeResolvedEntries(passedEntries);
+          }
+          if (promptEntries.length === 0) {
+            break;
+          }
+          inputMessages.push({
+            role: "assistant",
+            content: result.content.parts
+          });
+          inputMessages.push({
+            role: "user",
+            content: buildContinuationPromptParts(promptEntries)
+          });
         }
+      } finally {
+        uploadMetrics = getCurrentFileUploadMetrics();
       }
-      removeResolvedEntries(passedEntries);
-    }
-    if (promptEntries.length === 0) {
-      break;
-    }
-    inputMessages.push({
-      role: "assistant",
-      content: result.content.parts
     });
-    inputMessages.push({ role: "user", content: buildContinuationPromptParts(promptEntries) });
-  }
-  const orderedImages = [];
-  for (const entry of orderedEntries) {
-    const image = resolvedImages.get(entry.index);
-    if (image) {
-      orderedImages.push(image);
+    const orderedImages = [];
+    for (const entry of orderedEntries) {
+      const image = resolvedImages.get(entry.index);
+      if (image) {
+        orderedImages.push(image);
+      }
     }
+    const outputImages = orderedImages.slice(0, numImages);
+    telemetry.emit({
+      type: "llm.call.completed",
+      success: true,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      usage: totalUsage,
+      costUsd: totalCostUsd,
+      imageCount: outputImages.length,
+      attempts: attemptsUsed,
+      uploadCount: uploadMetrics.count,
+      uploadBytes: uploadMetrics.totalBytes,
+      uploadLatencyMs: uploadMetrics.totalLatencyMs
+    });
+    return outputImages;
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    telemetry.emit({
+      type: "llm.call.completed",
+      success: false,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      usage: totalUsage,
+      costUsd: totalCostUsd,
+      attempts: attemptsUsed > 0 ? attemptsUsed : void 0,
+      uploadCount: uploadMetrics.count,
+      uploadBytes: uploadMetrics.totalBytes,
+      uploadLatencyMs: uploadMetrics.totalLatencyMs,
+      error: err.message
+    });
+    throw err;
+  } finally {
+    await telemetry.flush();
   }
-  return orderedImages.slice(0, numImages);
 }
 async function generateImageInBatches(request) {
   const {
@@ -12039,7 +12350,7 @@ function isNoEntError(error) {
 
 // src/agent.ts
 async function runAgentLoop(request) {
-  const telemetry = createAgentTelemetrySession(request.telemetry);
+  const telemetry = createTelemetrySession(request.telemetry);
   const logging = createRootAgentLoggingSession(request);
   try {
     return await runWithAgentLoggingSession(logging, async () => {
@@ -12125,7 +12436,7 @@ async function runAgentLoopInternal(request, context) {
     logging: _logging,
     ...toolLoopRequest
   } = request;
-  const telemetrySession = context.telemetry ?? createAgentTelemetrySession(telemetry);
+  const telemetrySession = context.telemetry ?? createTelemetrySession(telemetry);
   const loggingSession = context.logging;
   const runId = randomRunId();
   const startedAtMs = Date.now();
@@ -12188,15 +12499,15 @@ async function runAgentLoopInternal(request, context) {
     ].join(" ")
   );
   const sourceOnEvent = toolLoopRequestWithSteering.onEvent;
-  const includeLlmStreamEvents = telemetrySession?.includeLlmStreamEvents === true;
+  const includeStreamEvents = telemetrySession?.includeStreamEvents === true;
   const streamEventLogger = loggingSession ? createAgentStreamEventLogger({
     append: (line) => {
       loggingSession.logLine(`[agent:${runId}] ${line}`);
     }
   }) : void 0;
-  const wrappedOnEvent = sourceOnEvent || includeLlmStreamEvents ? (event) => {
+  const wrappedOnEvent = sourceOnEvent || includeStreamEvents ? (event) => {
     sourceOnEvent?.(event);
-    if (includeLlmStreamEvents) {
+    if (includeStreamEvents) {
       emitTelemetry({ type: "agent.run.stream", event });
     }
     streamEventLogger?.appendEvent(event);
@@ -12434,7 +12745,7 @@ function countToolCalls(result) {
   }
   return count;
 }
-function sumUsageValue(current, next) {
+function sumUsageValue2(current, next) {
   if (typeof next !== "number" || !Number.isFinite(next)) {
     return current;
   }
@@ -12452,20 +12763,17 @@ function summarizeResultUsage(result) {
       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)
+      promptTokens: sumUsageValue2(summary?.promptTokens, usage.promptTokens),
+      cachedTokens: sumUsageValue2(summary?.cachedTokens, usage.cachedTokens),
+      responseTokens: sumUsageValue2(summary?.responseTokens, usage.responseTokens),
+      responseImageTokens: sumUsageValue2(summary?.responseImageTokens, usage.responseImageTokens),
+      thinkingTokens: sumUsageValue2(summary?.thinkingTokens, usage.thinkingTokens),
+      totalTokens: sumUsageValue2(summary?.totalTokens, usage.totalTokens),
+      toolUsePromptTokens: sumUsageValue2(summary?.toolUsePromptTokens, usage.toolUsePromptTokens)
     };
   }
   return summary;
 }
-function isPromiseLike2(value) {
-  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
-}
 function resolveAgentLoggingSelection(value) {
   if (value === false) {
     return void 0;
@@ -12499,60 +12807,6 @@ function createRootAgentLoggingSession(request) {
     mirrorToConsole: selected.mirrorToConsole !== false
   });
 }
-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 (isPromiseLike2(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) {
@@ -13245,6 +13499,7 @@ export {
   applyPatch,
   configureGemini,
   configureModelConcurrency,
+  configureTelemetry,
   convertGooglePartsToLlmParts,
   createApplyPatchTool,
   createCodexApplyPatchTool,
@@ -13293,6 +13548,7 @@ export {
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
   resetModelConcurrencyConfig,
+  resetTelemetry,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,