@ljoukov/llm 4.1.0 → 5.0.0

package/dist/index.js

@@ -2533,7 +2533,7 @@ async function runGeminiCall(fn, modelId, runOptions) {
 
 // src/openai/client.ts
 import OpenAI2 from "openai";
-import { Agent as Agent2, fetch as undiciFetch2 } from "undici";
+import { Agent as Agent2 } from "undici";
 var openAiClientState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.openAiClientState"), () => ({
   cachedApiKey: null,
   cachedClient: null,
@@ -2562,7 +2562,7 @@ function getOpenAiFetch() {
     headersTimeout: timeoutMs
   });
   openAiClientState.cachedFetch = ((input, init) => {
-    return undiciFetch2(input, {
+    return fetch(input, {
       ...init ?? {},
       dispatcher
     });
@@ -3259,7 +3259,7 @@ import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 import { Buffer as Buffer4, File as NodeFile } from "buffer";
 import { createHash } from "crypto";
 import { createReadStream, createWriteStream, openAsBlob } from "fs";
-import { mkdir as mkdir2, mkdtemp, stat, unlink, writeFile as writeFile2 } from "fs/promises";
+import { copyFile, mkdir as mkdir2, mkdtemp, readFile, stat, unlink, writeFile as writeFile2 } from "fs/promises";
 import os3 from "os";
 import path4 from "path";
 import { Readable } from "stream";
@@ -3272,6 +3272,9 @@ var OPENAI_UPLOAD_PART_MAX_BYTES = 64 * 1024 * 1024;
 var GEMINI_FILE_POLL_INTERVAL_MS = 1e3;
 var GEMINI_FILE_POLL_TIMEOUT_MS = 6e4;
 var FILES_TEMP_ROOT = path4.join(os3.tmpdir(), "ljoukov-llm-files");
+var FILES_CACHE_ROOT = path4.join(FILES_TEMP_ROOT, "cache");
+var FILES_CACHE_CONTENT_ROOT = path4.join(FILES_CACHE_ROOT, "content");
+var FILES_CACHE_METADATA_ROOT = path4.join(FILES_CACHE_ROOT, "metadata");
 var filesState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.filesState"), () => ({
   metadataById: /* @__PURE__ */ new Map(),
   openAiUploadCacheByKey: /* @__PURE__ */ new Map(),
@@ -3417,6 +3420,12 @@ function toStoredFile(file) {
 function buildCacheKey(filename, mimeType, sha256Hex) {
   return `${sha256Hex}\0${filename}\0${mimeType}`;
 }
+function buildCachedContentPath(sha256Hex) {
+  return path4.join(FILES_CACHE_CONTENT_ROOT, sha256Hex);
+}
+function buildCachedMetadataPath(fileId) {
+  return path4.join(FILES_CACHE_METADATA_ROOT, `${fileId}.json`);
+}
 function isFresh(file) {
   if (!file.expires_at) {
     return true;
@@ -3437,6 +3446,82 @@ function recordMetadata(metadata) {
   }
   return metadata;
 }
+async function ensureFilesCacheReady() {
+  await mkdir2(FILES_CACHE_CONTENT_ROOT, { recursive: true });
+  await mkdir2(FILES_CACHE_METADATA_ROOT, { recursive: true });
+}
+async function cacheBufferLocally(bytes, sha256Hex) {
+  await ensureFilesCacheReady();
+  const localPath = buildCachedContentPath(sha256Hex);
+  try {
+    await writeFile2(localPath, bytes, { flag: "wx" });
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST") {
+      throw error;
+    }
+  }
+  return localPath;
+}
+async function cacheFileLocally(filePath, sha256Hex) {
+  await ensureFilesCacheReady();
+  const localPath = buildCachedContentPath(sha256Hex);
+  try {
+    await copyFile(filePath, localPath);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST") {
+      throw error;
+    }
+  }
+  return localPath;
+}
+async function persistMetadataToDisk(metadata) {
+  await ensureFilesCacheReady();
+  const payload = {
+    file: metadata.file,
+    filename: metadata.filename,
+    bytes: metadata.bytes,
+    mimeType: metadata.mimeType,
+    sha256Hex: metadata.sha256Hex,
+    localPath: metadata.localPath
+  };
+  await writeFile2(
+    buildCachedMetadataPath(metadata.file.id),
+    `${JSON.stringify(payload, null, 2)}
+`
+  );
+}
+async function loadPersistedMetadata(fileId) {
+  try {
+    const payload = JSON.parse(
+      await readFile(buildCachedMetadataPath(fileId), "utf8")
+    );
+    if (!payload || typeof payload !== "object" || !payload.file) {
+      return void 0;
+    }
+    if (payload.localPath) {
+      try {
+        const localStats = await stat(payload.localPath);
+        if (!localStats.isFile()) {
+          return void 0;
+        }
+      } catch {
+        return void 0;
+      }
+    }
+    return recordMetadata({
+      file: payload.file,
+      filename: payload.filename,
+      bytes: payload.bytes,
+      mimeType: payload.mimeType,
+      sha256Hex: payload.sha256Hex,
+      localPath: payload.localPath
+    });
+  } catch {
+    return void 0;
+  }
+}
 async function uploadOpenAiFileFromBytes(params) {
   const cacheKey = buildCacheKey(params.filename, params.mimeType, params.sha256Hex);
   const cached = filesState.openAiUploadCacheByKey.get(cacheKey);
@@ -3585,17 +3670,23 @@ async function retrieveOpenAiFile(fileId) {
   if (cached && isFresh(cached.file)) {
     return cached;
   }
+  const persisted = await loadPersistedMetadata(fileId);
+  if (persisted && isFresh(persisted.file)) {
+    return persisted;
+  }
   const client = getOpenAiClient();
   const retrieved = await client.files.retrieve(fileId);
   const file = toStoredFile(retrieved);
-  return recordMetadata({
+  const metadata = recordMetadata({
     file,
     filename: file.filename,
     bytes: file.bytes,
-    mimeType: cached?.mimeType ?? resolveMimeType(file.filename, void 0),
-    sha256Hex: cached?.sha256Hex,
-    localPath: cached?.localPath
+    mimeType: cached?.mimeType ?? persisted?.mimeType ?? resolveMimeType(file.filename, void 0),
+    sha256Hex: cached?.sha256Hex ?? persisted?.sha256Hex,
+    localPath: cached?.localPath ?? persisted?.localPath
   });
+  await persistMetadataToDisk(metadata);
+  return metadata;
 }
 function buildGeminiMirrorName(sha256Hex) {
   return `files/${sha256Hex.slice(0, 40)}`;
@@ -3707,6 +3798,7 @@ async function materializeOpenAiFile(fileId) {
       sha256Hex,
       localPath
     });
+    await persistMetadataToDisk(updated);
     return {
       file: updated.file,
       filename: updated.filename,
@@ -3870,7 +3962,13 @@ async function filesCreate(params) {
       sha256Hex: sha256Hex2,
       bytes: info.size
     });
-    return uploaded2.file;
+    const localPath2 = await cacheFileLocally(filePath, sha256Hex2);
+    const cached2 = recordMetadata({
+      ...uploaded2,
+      localPath: localPath2
+    });
+    await persistMetadataToDisk(cached2);
+    return cached2.file;
   }
   const filename = normaliseFilename(params.filename);
   const bytes = toBuffer(params.data);
@@ -3884,7 +3982,13 @@ async function filesCreate(params) {
     expiresAfterSeconds,
     sha256Hex
   });
-  return uploaded.file;
+  const localPath = await cacheBufferLocally(bytes, sha256Hex);
+  const cached = recordMetadata({
+    ...uploaded,
+    localPath
+  });
+  await persistMetadataToDisk(cached);
+  return cached.file;
 }
 async function filesRetrieve(fileId) {
   return (await retrieveOpenAiFile(fileId)).file;
@@ -3917,6 +4021,10 @@ async function filesDelete(fileId) {
   const response = await getOpenAiClient().files.delete(fileId);
   filesState.metadataById.delete(fileId);
   filesState.materializedById.delete(fileId);
+  try {
+    await unlink(buildCachedMetadataPath(fileId));
+  } catch {
+  }
   return {
     id: response.id,
     deleted: response.deleted,
@@ -3945,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"),
@@ -4396,8 +4569,7 @@ function toGeminiPart(part) {
         return {
           fileData: {
             fileUri: buildCanonicalGeminiFileUri(part.file_id),
-            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream",
-            displayName: part.filename ?? void 0
+            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
           }
         };
       }
@@ -4415,8 +4587,7 @@ function toGeminiPart(part) {
       return {
         fileData: {
           fileUri: part.image_url,
-          mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream",
-          displayName: part.filename ?? void 0
+          mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
         }
       };
     }
@@ -4425,8 +4596,7 @@ function toGeminiPart(part) {
         return {
           fileData: {
             fileUri: buildCanonicalGeminiFileUri(part.file_id),
-            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream",
-            displayName: part.filename ?? void 0
+            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
           }
         };
       }
@@ -4452,8 +4622,7 @@ function toGeminiPart(part) {
         return {
           fileData: {
             fileUri: part.file_url,
-            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream",
-            displayName: part.filename ?? void 0
+            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
           }
         };
       }
@@ -4685,7 +4854,7 @@ async function prepareOpenAiPromptContentItem(item) {
       mimeType,
       filename
     });
-    return { type: "input_file", file_id: uploaded.fileId, filename: uploaded.filename };
+    return { type: "input_file", file_id: uploaded.fileId };
   }
   if (typeof item.file_url === "string" && item.file_url.trim().toLowerCase().startsWith("data:")) {
     const parsed = parseDataUrlPayload(item.file_url);
@@ -4700,7 +4869,7 @@ async function prepareOpenAiPromptContentItem(item) {
         guessInlineDataFilename(parsed.mimeType)
       )
     });
-    return { type: "input_file", file_id: uploaded.fileId, filename: uploaded.filename };
+    return { type: "input_file", file_id: uploaded.fileId };
   }
   return item;
 }
@@ -4765,21 +4934,16 @@ async function prepareGeminiPromptContents(contents) {
     for (const part of content.parts ?? []) {
       const canonicalFileId = parseCanonicalGeminiFileId(part.fileData?.fileUri);
       if (canonicalFileId) {
-        const metadata = await getCanonicalFileMetadata(canonicalFileId);
+        await getCanonicalFileMetadata(canonicalFileId);
         if (backend === "api") {
           const mirrored = await ensureGeminiFileMirror(canonicalFileId);
-          const mirroredPart = createPartFromUri(mirrored.uri, mirrored.mimeType);
-          if (metadata.filename && mirroredPart.fileData) {
-            mirroredPart.fileData.displayName = metadata.filename;
-          }
-          parts.push(mirroredPart);
+          parts.push(createPartFromUri(mirrored.uri, mirrored.mimeType));
         } else {
           const mirrored = await ensureVertexFileMirror(canonicalFileId);
           parts.push({
             fileData: {
               fileUri: mirrored.fileUri,
-              mimeType: mirrored.mimeType,
-              displayName: metadata.filename
+              mimeType: mirrored.mimeType
             }
           });
         }
@@ -4798,18 +4962,13 @@ async function prepareGeminiPromptContents(contents) {
         });
         if (backend === "api") {
           const mirrored = await ensureGeminiFileMirror(stored.fileId);
-          const mirroredPart = createPartFromUri(mirrored.uri, mirrored.mimeType);
-          if (filename && mirroredPart.fileData) {
-            mirroredPart.fileData.displayName = filename;
-          }
-          parts.push(mirroredPart);
+          parts.push(createPartFromUri(mirrored.uri, mirrored.mimeType));
         } else {
           const mirrored = await ensureVertexFileMirror(stored.fileId);
           parts.push({
             fileData: {
               fileUri: mirrored.fileUri,
-              mimeType: mirrored.mimeType,
-              displayName: filename
+              mimeType: mirrored.mimeType
             }
           });
         }
@@ -5330,7 +5489,7 @@ function toOpenAiInput(contents) {
             ...part.file_id ? { file_id: part.file_id } : {},
             ...part.file_data ? { file_data: part.file_data } : {},
             ...part.file_url ? { file_url: part.file_url } : {},
-            ...part.filename ? { filename: part.filename } : {}
+            ...!part.file_id && part.filename ? { filename: part.filename } : {}
           });
           break;
         default:
@@ -5415,7 +5574,7 @@ function toChatGptInput(contents) {
             ...part.file_id ? { file_id: part.file_id } : {},
             ...part.file_data ? { file_data: part.file_data } : {},
             ...part.file_url ? { file_url: part.file_url } : {},
-            ...part.filename ? { filename: part.filename } : {}
+            ...!part.file_id && part.filename ? { filename: part.filename } : {}
           });
           break;
         default:
@@ -5545,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;
@@ -6022,8 +6240,7 @@ function buildGeminiToolOutputMediaPart(item) {
       return {
         fileData: {
           fileUri: buildCanonicalGeminiFileUri(item.file_id),
-          mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream",
-          displayName: item.filename ?? void 0
+          mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream"
         }
       };
     }
@@ -6042,8 +6259,7 @@ function buildGeminiToolOutputMediaPart(item) {
     return {
       fileData: {
         fileUri: item.image_url,
-        mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream",
-        displayName: item.filename ?? void 0
+        mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream"
       }
     };
   }
@@ -6052,8 +6268,7 @@ function buildGeminiToolOutputMediaPart(item) {
       return {
         fileData: {
           fileUri: buildCanonicalGeminiFileUri(item.file_id),
-          mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream",
-          displayName: item.filename ?? void 0
+          mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream"
         }
       };
     }
@@ -6076,12 +6291,7 @@ function buildGeminiToolOutputMediaPart(item) {
       return part;
     }
     if (typeof item.file_url === "string" && item.file_url.trim().length > 0 && inferredMimeType) {
-      const part = createPartFromUri(item.file_url, inferredMimeType);
-      const displayName = item.filename?.trim();
-      if (displayName && part.fileData) {
-        part.fileData.displayName = displayName;
-      }
-      return part;
+      return createPartFromUri(item.file_url, inferredMimeType);
     }
   }
   return null;
@@ -6962,6 +7172,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;
@@ -6972,7 +7186,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) {
@@ -7042,7 +7256,7 @@ async function runTextCall(params) {
               }
               case "response.refusal.delta": {
                 blocked = true;
-                queue.push({ type: "blocked" });
+                pushEvent({ type: "blocked" });
                 break;
               }
               default:
@@ -7051,7 +7265,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);
@@ -7115,11 +7329,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 : "";
@@ -7157,11 +7371,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
@@ -7203,11 +7417,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,
@@ -7220,7 +7434,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;
@@ -7257,7 +7471,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,
@@ -7311,18 +7525,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 {
@@ -7331,8 +7603,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;
@@ -7358,9 +7633,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;
@@ -7379,135 +7671,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) {
@@ -9123,7 +9435,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 = [
     {
@@ -9134,7 +9449,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")
     },
     {
@@ -9143,12 +9458,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));
@@ -9168,6 +9484,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") {
@@ -9225,6 +9554,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;
@@ -9239,70 +9571,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 {
@@ -11953,7 +12333,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 () => {
@@ -12039,7 +12419,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();
@@ -12102,15 +12482,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);
@@ -12348,7 +12728,7 @@ function countToolCalls(result) {
   }
   return count;
 }
-function sumUsageValue(current, next) {
+function sumUsageValue2(current, next) {
   if (typeof next !== "number" || !Number.isFinite(next)) {
     return current;
   }
@@ -12366,20 +12746,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;
@@ -12413,60 +12790,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) {
@@ -13159,6 +13482,7 @@ export {
   applyPatch,
   configureGemini,
   configureModelConcurrency,
+  configureTelemetry,
   convertGooglePartsToLlmParts,
   createApplyPatchTool,
   createCodexApplyPatchTool,
@@ -13207,6 +13531,7 @@ export {
   parseJsonFromLlmText,
   refreshChatGptOauthToken,
   resetModelConcurrencyConfig,
+  resetTelemetry,
   resolveFilesystemToolProfile,
   resolveFireworksModelId,
   runAgentLoop,