@ljoukov/llm 4.0.6 → 4.0.8

package/dist/index.js

@@ -329,6 +329,34 @@ function estimateCallCostUsd({
 import os2 from "os";
 import { TextDecoder } from "util";
 
+// src/utils/runtimeSingleton.ts
+var runtimeSingletonStoreKey = /* @__PURE__ */ Symbol.for("@ljoukov/llm.runtimeSingletonStore");
+function getRuntimeSingletonStore() {
+  const globalObject = globalThis;
+  const existingStore = globalObject[runtimeSingletonStoreKey];
+  if (existingStore) {
+    return existingStore;
+  }
+  const store = /* @__PURE__ */ new Map();
+  Object.defineProperty(globalObject, runtimeSingletonStoreKey, {
+    value: store,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return store;
+}
+function getRuntimeSingleton(key, create) {
+  const store = getRuntimeSingletonStore();
+  const existingValue = store.get(key);
+  if (existingValue !== void 0) {
+    return existingValue;
+  }
+  const createdValue = create();
+  store.set(key, createdValue);
+  return createdValue;
+}
+
 // src/openai/chatgpt-auth.ts
 import { Buffer as Buffer2 } from "buffer";
 import fs2 from "fs";
@@ -339,14 +367,16 @@ import { z } from "zod";
 // src/utils/env.ts
 import fs from "fs";
 import path from "path";
-var envLoaded = false;
+var envState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.envState"), () => ({
+  envLoaded: false
+}));
 function loadLocalEnv() {
-  if (envLoaded) {
+  if (envState.envLoaded) {
     return;
   }
   const envPath = path.join(process.cwd(), ".env.local");
   loadEnvFromFile(envPath, { override: false });
-  envLoaded = true;
+  envState.envLoaded = true;
 }
 function loadEnvFromFile(filePath, { override = false } = {}) {
   let content;
@@ -432,8 +462,10 @@ var ExchangeResponseSchema = z.object({
   expires_in: z.union([z.number(), z.string()]),
   id_token: z.string().optional()
 });
-var cachedProfile = null;
-var refreshPromise = null;
+var chatGptAuthState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.chatGptAuthState"), () => ({
+  cachedProfile: null,
+  refreshPromise: null
+}));
 async function fetchChatGptAuthProfileFromTokenProvider(options) {
   const base = options.baseUrl.replace(/\/+$/u, "");
   const store = options.store?.trim() ? options.store.trim() : "kv";
@@ -534,13 +566,13 @@ async function getChatGptAuthProfile() {
   const tokenProviderUrl = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_URL_ENV];
   const tokenProviderKey = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_API_KEY_ENV] ?? process.env[CHATGPT_AUTH_API_KEY_ENV];
   if (tokenProviderUrl && tokenProviderUrl.trim().length > 0 && tokenProviderKey && tokenProviderKey.trim().length > 0) {
-    if (cachedProfile && !isExpired(cachedProfile)) {
-      return cachedProfile;
+    if (chatGptAuthState.cachedProfile && !isExpired(chatGptAuthState.cachedProfile)) {
+      return chatGptAuthState.cachedProfile;
     }
-    if (refreshPromise) {
-      return refreshPromise;
+    if (chatGptAuthState.refreshPromise) {
+      return chatGptAuthState.refreshPromise;
     }
-    refreshPromise = (async () => {
+    chatGptAuthState.refreshPromise = (async () => {
       try {
         const store = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_STORE_ENV];
         const profile = await fetchChatGptAuthProfileFromTokenProvider({
@@ -548,31 +580,31 @@ async function getChatGptAuthProfile() {
           apiKey: tokenProviderKey,
           store: store ?? void 0
         });
-        cachedProfile = profile;
+        chatGptAuthState.cachedProfile = profile;
         return profile;
       } finally {
-        refreshPromise = null;
+        chatGptAuthState.refreshPromise = null;
       }
     })();
-    return refreshPromise;
+    return chatGptAuthState.refreshPromise;
   }
-  if (cachedProfile && !isExpired(cachedProfile)) {
-    return cachedProfile;
+  if (chatGptAuthState.cachedProfile && !isExpired(chatGptAuthState.cachedProfile)) {
+    return chatGptAuthState.cachedProfile;
   }
-  if (refreshPromise) {
-    return refreshPromise;
+  if (chatGptAuthState.refreshPromise) {
+    return chatGptAuthState.refreshPromise;
   }
-  refreshPromise = (async () => {
+  chatGptAuthState.refreshPromise = (async () => {
     try {
-      const baseProfile = cachedProfile ?? loadAuthProfileFromCodexStore();
+      const baseProfile = chatGptAuthState.cachedProfile ?? loadAuthProfileFromCodexStore();
       const profile = isExpired(baseProfile) ? await refreshAndPersistCodexProfile(baseProfile) : baseProfile;
-      cachedProfile = profile;
+      chatGptAuthState.cachedProfile = profile;
       return profile;
     } finally {
-      refreshPromise = null;
+      chatGptAuthState.refreshPromise = null;
     }
   })();
-  return refreshPromise;
+  return chatGptAuthState.refreshPromise;
 }
 function resolveCodexHome() {
   const codexHome = process.env.CODEX_HOME;
@@ -1304,8 +1336,10 @@ function createAbortError(reason) {
 // src/openai/chatgpt-codex.ts
 var CHATGPT_CODEX_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
 var CHATGPT_RESPONSES_EXPERIMENTAL_HEADER = "responses=experimental";
-var cachedResponsesWebSocketMode = null;
-var chatGptResponsesWebSocketDisabled = false;
+var chatGptCodexState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.chatGptCodexState"), () => ({
+  cachedResponsesWebSocketMode: null,
+  chatGptResponsesWebSocketDisabled: false
+}));
 async function streamChatGptCodexResponse(options) {
   const { access, accountId } = await getChatGptAuthProfile();
   const mode = resolveChatGptResponsesWebSocketMode();
@@ -1331,7 +1365,7 @@ async function streamChatGptCodexResponse(options) {
       }
     };
   };
-  if (mode === "off" || chatGptResponsesWebSocketDisabled) {
+  if (mode === "off" || chatGptCodexState.chatGptResponsesWebSocketDisabled) {
     return fallbackStreamFactory();
   }
   const websocketHeaders = buildChatGptCodexHeaders({
@@ -1350,7 +1384,7 @@ async function streamChatGptCodexResponse(options) {
     }),
     createFallbackStream: fallbackStreamFactory,
     onWebSocketFallback: () => {
-      chatGptResponsesWebSocketDisabled = true;
+      chatGptCodexState.chatGptResponsesWebSocketDisabled = true;
     }
   });
 }
@@ -1380,14 +1414,14 @@ async function streamChatGptCodexResponseSse(options) {
   return parseEventStream(body);
 }
 function resolveChatGptResponsesWebSocketMode() {
-  if (cachedResponsesWebSocketMode) {
-    return cachedResponsesWebSocketMode;
+  if (chatGptCodexState.cachedResponsesWebSocketMode) {
+    return chatGptCodexState.cachedResponsesWebSocketMode;
   }
-  cachedResponsesWebSocketMode = resolveResponsesWebSocketMode(
+  chatGptCodexState.cachedResponsesWebSocketMode = resolveResponsesWebSocketMode(
     process.env.CHATGPT_RESPONSES_WEBSOCKET_MODE ?? process.env.OPENAI_RESPONSES_WEBSOCKET_MODE,
     "auto"
   );
-  return cachedResponsesWebSocketMode;
+  return chatGptCodexState.cachedResponsesWebSocketMode;
 }
 function buildChatGptCodexHeaders(options) {
   const openAiBeta = options.useWebSocket ? mergeOpenAiBetaHeader(
@@ -1425,8 +1459,8 @@ async function collectChatGptCodexResponse(options) {
         }
       });
     } catch (error) {
-      if (!sawAnyDelta && !retriedViaSseFallback && shouldRetryViaSseFallback(error) && !chatGptResponsesWebSocketDisabled) {
-        chatGptResponsesWebSocketDisabled = true;
+      if (!sawAnyDelta && !retriedViaSseFallback && shouldRetryViaSseFallback(error) && !chatGptCodexState.chatGptResponsesWebSocketDisabled) {
+        chatGptCodexState.chatGptResponsesWebSocketDisabled = true;
         retriedViaSseFallback = true;
         continue;
       }
@@ -1662,7 +1696,12 @@ var MODEL_CONCURRENCY_PROVIDERS = [
   "google",
   "fireworks"
 ];
-var configuredModelConcurrency = normalizeModelConcurrencyConfig({});
+var modelConcurrencyState = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.modelConcurrencyState"),
+  () => ({
+    configuredModelConcurrency: normalizeModelConcurrencyConfig({})
+  })
+);
 function clampModelConcurrencyCap(value) {
   if (!Number.isFinite(value)) {
     return DEFAULT_MODEL_CONCURRENCY_CAP;
@@ -1736,14 +1775,14 @@ function resolveDefaultProviderCap(provider, modelId) {
   return DEFAULT_FIREWORKS_MODEL_CONCURRENCY_CAP;
 }
 function configureModelConcurrency(config = {}) {
-  configuredModelConcurrency = normalizeModelConcurrencyConfig(config);
+  modelConcurrencyState.configuredModelConcurrency = normalizeModelConcurrencyConfig(config);
 }
 function resetModelConcurrencyConfig() {
-  configuredModelConcurrency = normalizeModelConcurrencyConfig({});
+  modelConcurrencyState.configuredModelConcurrency = normalizeModelConcurrencyConfig({});
 }
 function resolveModelConcurrencyCap(options) {
   const modelId = options.modelId ? normalizeModelIdForConfig(options.modelId) : void 0;
-  const config = options.config ? normalizeModelConcurrencyConfig(options.config) : configuredModelConcurrency;
+  const config = options.config ? normalizeModelConcurrencyConfig(options.config) : modelConcurrencyState.configuredModelConcurrency;
   const providerModelCap = modelId ? config.providerModelCaps[options.provider].get(modelId) : void 0;
   if (providerModelCap !== void 0) {
     return providerModelCap;
@@ -1977,32 +2016,37 @@ import OpenAI from "openai";
 import { Agent, fetch as undiciFetch } from "undici";
 var DEFAULT_FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
 var DEFAULT_FIREWORKS_TIMEOUT_MS = 15 * 6e4;
-var cachedClient = null;
-var cachedFetch = null;
-var cachedBaseUrl = null;
-var cachedApiKey = null;
-var cachedTimeoutMs = null;
+var fireworksClientState = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.fireworksClientState"),
+  () => ({
+    cachedClient: null,
+    cachedFetch: null,
+    cachedBaseUrl: null,
+    cachedApiKey: null,
+    cachedTimeoutMs: null
+  })
+);
 function resolveTimeoutMs() {
-  if (cachedTimeoutMs !== null) {
-    return cachedTimeoutMs;
+  if (fireworksClientState.cachedTimeoutMs !== null) {
+    return fireworksClientState.cachedTimeoutMs;
   }
   const raw = process.env.FIREWORKS_TIMEOUT_MS;
   const parsed = raw ? Number(raw) : Number.NaN;
-  cachedTimeoutMs = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_FIREWORKS_TIMEOUT_MS;
-  return cachedTimeoutMs;
+  fireworksClientState.cachedTimeoutMs = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_FIREWORKS_TIMEOUT_MS;
+  return fireworksClientState.cachedTimeoutMs;
 }
 function resolveBaseUrl() {
-  if (cachedBaseUrl !== null) {
-    return cachedBaseUrl;
+  if (fireworksClientState.cachedBaseUrl !== null) {
+    return fireworksClientState.cachedBaseUrl;
   }
   loadLocalEnv();
   const raw = process.env.FIREWORKS_BASE_URL?.trim();
-  cachedBaseUrl = raw && raw.length > 0 ? raw : DEFAULT_FIREWORKS_BASE_URL;
-  return cachedBaseUrl;
+  fireworksClientState.cachedBaseUrl = raw && raw.length > 0 ? raw : DEFAULT_FIREWORKS_BASE_URL;
+  return fireworksClientState.cachedBaseUrl;
 }
 function resolveApiKey() {
-  if (cachedApiKey !== null) {
-    return cachedApiKey;
+  if (fireworksClientState.cachedApiKey !== null) {
+    return fireworksClientState.cachedApiKey;
   }
   loadLocalEnv();
   const raw = process.env.FIREWORKS_TOKEN ?? process.env.FIREWORKS_API_KEY;
@@ -2012,46 +2056,51 @@ function resolveApiKey() {
       "FIREWORKS_TOKEN (or FIREWORKS_API_KEY) must be provided to access Fireworks APIs."
     );
   }
-  cachedApiKey = token;
-  return cachedApiKey;
+  fireworksClientState.cachedApiKey = token;
+  return fireworksClientState.cachedApiKey;
 }
 function getFireworksFetch() {
-  if (cachedFetch) {
-    return cachedFetch;
+  if (fireworksClientState.cachedFetch) {
+    return fireworksClientState.cachedFetch;
   }
   const timeoutMs = resolveTimeoutMs();
   const dispatcher = new Agent({
     bodyTimeout: timeoutMs,
     headersTimeout: timeoutMs
   });
-  cachedFetch = ((input, init) => {
+  fireworksClientState.cachedFetch = ((input, init) => {
     return undiciFetch(input, {
       ...init ?? {},
       dispatcher
     });
   });
-  return cachedFetch;
+  return fireworksClientState.cachedFetch;
 }
 function getFireworksClient() {
-  if (cachedClient) {
-    return cachedClient;
+  if (fireworksClientState.cachedClient) {
+    return fireworksClientState.cachedClient;
   }
-  cachedClient = new OpenAI({
+  fireworksClientState.cachedClient = new OpenAI({
     apiKey: resolveApiKey(),
     baseURL: resolveBaseUrl(),
     timeout: resolveTimeoutMs(),
     fetch: getFireworksFetch()
   });
-  return cachedClient;
+  return fireworksClientState.cachedClient;
 }
 
 // src/fireworks/calls.ts
 var DEFAULT_SCHEDULER_KEY = "__default__";
-var schedulerByModel = /* @__PURE__ */ new Map();
+var fireworksCallState = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.fireworksCallState"),
+  () => ({
+    schedulerByModel: /* @__PURE__ */ new Map()
+  })
+);
 function getSchedulerForModel(modelId) {
   const normalizedModelId = modelId?.trim();
   const schedulerKey = normalizedModelId && normalizedModelId.length > 0 ? normalizedModelId : DEFAULT_SCHEDULER_KEY;
-  const existing = schedulerByModel.get(schedulerKey);
+  const existing = fireworksCallState.schedulerByModel.get(schedulerKey);
   if (existing) {
     return existing;
   }
@@ -2063,7 +2112,7 @@ function getSchedulerForModel(modelId) {
     minIntervalBetweenStartMs: 200,
     startJitterMs: 200
   });
-  schedulerByModel.set(schedulerKey, created);
+  fireworksCallState.schedulerByModel.set(schedulerKey, created);
   return created;
 }
 async function runFireworksCall(fn, modelId, runOptions) {
@@ -2110,7 +2159,10 @@ var ServiceAccountSchema = z2.object({
   privateKey: private_key.replace(/\\n/g, "\n"),
   tokenUri: token_uri
 }));
-var cachedServiceAccount = null;
+var googleAuthState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.googleAuthState"), () => ({
+  cachedServiceAccount: null,
+  authClientCache: /* @__PURE__ */ new Map()
+}));
 function parseGoogleServiceAccount(input) {
   let parsed;
   try {
@@ -2121,16 +2173,16 @@ function parseGoogleServiceAccount(input) {
   return ServiceAccountSchema.parse(parsed);
 }
 function getGoogleServiceAccount() {
-  if (cachedServiceAccount) {
-    return cachedServiceAccount;
+  if (googleAuthState.cachedServiceAccount) {
+    return googleAuthState.cachedServiceAccount;
   }
   loadLocalEnv();
   const raw = process.env.GOOGLE_SERVICE_ACCOUNT_JSON;
   if (!raw || raw.trim().length === 0) {
     throw new Error("GOOGLE_SERVICE_ACCOUNT_JSON must be provided for Google APIs access.");
   }
-  cachedServiceAccount = parseGoogleServiceAccount(raw);
-  return cachedServiceAccount;
+  googleAuthState.cachedServiceAccount = parseGoogleServiceAccount(raw);
+  return googleAuthState.cachedServiceAccount;
 }
 function normaliseScopes(scopes) {
   if (!scopes) {
@@ -2182,8 +2234,10 @@ function isGeminiImageModelId(value) {
 }
 var CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
 var DEFAULT_VERTEX_LOCATION = "global";
-var geminiConfiguration = {};
-var clientPromise;
+var geminiClientState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.geminiClientState"), () => ({
+  geminiConfiguration: {},
+  clientPromise: void 0
+}));
 function normaliseConfigValue(value) {
   if (value === void 0 || value === null) {
     return void 0;
@@ -2194,14 +2248,14 @@ function normaliseConfigValue(value) {
 function configureGemini(options = {}) {
   const nextProjectId = normaliseConfigValue(options.projectId);
   const nextLocation = normaliseConfigValue(options.location);
-  geminiConfiguration = {
-    projectId: nextProjectId !== void 0 ? nextProjectId : geminiConfiguration.projectId,
-    location: nextLocation !== void 0 ? nextLocation : geminiConfiguration.location
+  geminiClientState.geminiConfiguration = {
+    projectId: nextProjectId !== void 0 ? nextProjectId : geminiClientState.geminiConfiguration.projectId,
+    location: nextLocation !== void 0 ? nextLocation : geminiClientState.geminiConfiguration.location
   };
-  clientPromise = void 0;
+  geminiClientState.clientPromise = void 0;
 }
 function resolveProjectId() {
-  const override = geminiConfiguration.projectId;
+  const override = geminiClientState.geminiConfiguration.projectId;
   if (override) {
     return override;
   }
@@ -2209,15 +2263,15 @@ function resolveProjectId() {
   return serviceAccount.projectId;
 }
 function resolveLocation() {
-  const override = geminiConfiguration.location;
+  const override = geminiClientState.geminiConfiguration.location;
   if (override) {
     return override;
   }
   return DEFAULT_VERTEX_LOCATION;
 }
 async function getGeminiClient() {
-  if (!clientPromise) {
-    clientPromise = Promise.resolve().then(() => {
+  if (!geminiClientState.clientPromise) {
+    geminiClientState.clientPromise = Promise.resolve().then(() => {
       const projectId = resolveProjectId();
       const location = resolveLocation();
       const googleAuthOptions = getGoogleAuthOptions(CLOUD_PLATFORM_SCOPE);
@@ -2229,7 +2283,7 @@ async function getGeminiClient() {
       });
     });
   }
-  return clientPromise;
+  return geminiClientState.clientPromise;
 }
 
 // src/google/calls.ts
@@ -2425,11 +2479,13 @@ function retryDelayMs(attempt) {
   return base + jitter;
 }
 var DEFAULT_SCHEDULER_KEY2 = "__default__";
-var schedulerByModel2 = /* @__PURE__ */ new Map();
+var googleCallState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.googleCallState"), () => ({
+  schedulerByModel: /* @__PURE__ */ new Map()
+}));
 function getSchedulerForModel2(modelId) {
   const normalizedModelId = modelId?.trim();
   const schedulerKey = normalizedModelId && normalizedModelId.length > 0 ? normalizedModelId : DEFAULT_SCHEDULER_KEY2;
-  const existing = schedulerByModel2.get(schedulerKey);
+  const existing = googleCallState.schedulerByModel.get(schedulerKey);
   if (existing) {
     return existing;
   }
@@ -2452,7 +2508,7 @@ function getSchedulerForModel2(modelId) {
       }
     }
   });
-  schedulerByModel2.set(schedulerKey, created);
+  googleCallState.schedulerByModel.set(schedulerKey, created);
   return created;
 }
 async function runGeminiCall(fn, modelId, runOptions) {
@@ -2462,53 +2518,55 @@ async function runGeminiCall(fn, modelId, runOptions) {
 // src/openai/client.ts
 import OpenAI2 from "openai";
 import { Agent as Agent2, fetch as undiciFetch2 } from "undici";
-var cachedApiKey2 = null;
-var cachedClient2 = null;
-var cachedFetch2 = null;
-var cachedTimeoutMs2 = null;
-var openAiResponsesWebSocketMode = null;
-var openAiResponsesWebSocketDisabled = false;
+var openAiClientState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.openAiClientState"), () => ({
+  cachedApiKey: null,
+  cachedClient: null,
+  cachedFetch: null,
+  cachedTimeoutMs: null,
+  openAiResponsesWebSocketMode: null,
+  openAiResponsesWebSocketDisabled: false
+}));
 var DEFAULT_OPENAI_TIMEOUT_MS = 15 * 6e4;
 function resolveOpenAiTimeoutMs() {
-  if (cachedTimeoutMs2 !== null) {
-    return cachedTimeoutMs2;
+  if (openAiClientState.cachedTimeoutMs !== null) {
+    return openAiClientState.cachedTimeoutMs;
   }
   const raw = process.env.OPENAI_STREAM_TIMEOUT_MS ?? process.env.OPENAI_TIMEOUT_MS;
   const parsed = raw ? Number(raw) : Number.NaN;
-  cachedTimeoutMs2 = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_OPENAI_TIMEOUT_MS;
-  return cachedTimeoutMs2;
+  openAiClientState.cachedTimeoutMs = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_OPENAI_TIMEOUT_MS;
+  return openAiClientState.cachedTimeoutMs;
 }
 function getOpenAiFetch() {
-  if (cachedFetch2) {
-    return cachedFetch2;
+  if (openAiClientState.cachedFetch) {
+    return openAiClientState.cachedFetch;
   }
   const timeoutMs = resolveOpenAiTimeoutMs();
   const dispatcher = new Agent2({
     bodyTimeout: timeoutMs,
     headersTimeout: timeoutMs
   });
-  cachedFetch2 = ((input, init) => {
+  openAiClientState.cachedFetch = ((input, init) => {
     return undiciFetch2(input, {
       ...init ?? {},
       dispatcher
     });
   });
-  return cachedFetch2;
+  return openAiClientState.cachedFetch;
 }
 function resolveOpenAiBaseUrl() {
   loadLocalEnv();
   return process.env.OPENAI_BASE_URL?.trim() || "https://api.openai.com/v1";
 }
 function resolveOpenAiResponsesWebSocketMode() {
-  if (openAiResponsesWebSocketMode) {
-    return openAiResponsesWebSocketMode;
+  if (openAiClientState.openAiResponsesWebSocketMode) {
+    return openAiClientState.openAiResponsesWebSocketMode;
   }
   loadLocalEnv();
-  openAiResponsesWebSocketMode = resolveResponsesWebSocketMode(
+  openAiClientState.openAiResponsesWebSocketMode = resolveResponsesWebSocketMode(
     process.env.OPENAI_RESPONSES_WEBSOCKET_MODE,
     "auto"
   );
-  return openAiResponsesWebSocketMode;
+  return openAiClientState.openAiResponsesWebSocketMode;
 }
 function wrapFallbackStream(stream) {
   return {
@@ -2561,7 +2619,7 @@ function installResponsesWebSocketTransport(client, apiKey) {
   responsesApi.stream = (request, options) => {
     const mode = resolveOpenAiResponsesWebSocketMode();
     const fallbackStreamFactory = () => wrapFallbackStream(originalStream(request, options));
-    if (mode === "off" || openAiResponsesWebSocketDisabled) {
+    if (mode === "off" || openAiClientState.openAiResponsesWebSocketDisabled) {
       return fallbackStreamFactory();
     }
     const signal = options && typeof options === "object" ? options.signal ?? void 0 : void 0;
@@ -2580,15 +2638,15 @@ function installResponsesWebSocketTransport(client, apiKey) {
       createFallbackStream: fallbackStreamFactory,
       onWebSocketFallback: (error) => {
         if (isResponsesWebSocketUnsupportedError(error)) {
-          openAiResponsesWebSocketDisabled = true;
+          openAiClientState.openAiResponsesWebSocketDisabled = true;
         }
       }
     });
   };
 }
 function getOpenAiApiKey() {
-  if (cachedApiKey2 !== null) {
-    return cachedApiKey2;
+  if (openAiClientState.cachedApiKey !== null) {
+    return openAiClientState.cachedApiKey;
   }
   loadLocalEnv();
   const raw = process.env.OPENAI_API_KEY;
@@ -2596,33 +2654,35 @@ function getOpenAiApiKey() {
   if (!value) {
     throw new Error("OPENAI_API_KEY must be provided to access OpenAI APIs.");
   }
-  cachedApiKey2 = value;
-  return cachedApiKey2;
+  openAiClientState.cachedApiKey = value;
+  return openAiClientState.cachedApiKey;
 }
 function getOpenAiClient() {
-  if (cachedClient2) {
-    return cachedClient2;
+  if (openAiClientState.cachedClient) {
+    return openAiClientState.cachedClient;
   }
   loadLocalEnv();
   const apiKey = getOpenAiApiKey();
   const timeoutMs = resolveOpenAiTimeoutMs();
-  cachedClient2 = new OpenAI2({
+  openAiClientState.cachedClient = new OpenAI2({
     apiKey,
     fetch: getOpenAiFetch(),
     timeout: timeoutMs
   });
-  installResponsesWebSocketTransport(cachedClient2, apiKey);
-  return cachedClient2;
+  installResponsesWebSocketTransport(openAiClientState.cachedClient, apiKey);
+  return openAiClientState.cachedClient;
 }
 
 // src/openai/calls.ts
 var DEFAULT_OPENAI_REASONING_EFFORT = "medium";
 var DEFAULT_SCHEDULER_KEY3 = "__default__";
-var schedulerByModel3 = /* @__PURE__ */ new Map();
+var openAiCallState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.openAiCallState"), () => ({
+  schedulerByModel: /* @__PURE__ */ new Map()
+}));
 function getSchedulerForModel3(modelId) {
   const normalizedModelId = modelId?.trim();
   const schedulerKey = normalizedModelId && normalizedModelId.length > 0 ? normalizedModelId : DEFAULT_SCHEDULER_KEY3;
-  const existing = schedulerByModel3.get(schedulerKey);
+  const existing = openAiCallState.schedulerByModel.get(schedulerKey);
   if (existing) {
     return existing;
   }
@@ -2634,7 +2694,7 @@ function getSchedulerForModel3(modelId) {
     minIntervalBetweenStartMs: 200,
     startJitterMs: 200
   });
-  schedulerByModel3.set(schedulerKey, created);
+  openAiCallState.schedulerByModel.set(schedulerKey, created);
   return created;
 }
 async function runOpenAiCall(fn, modelId, runOptions) {
@@ -2706,6 +2766,9 @@ function ensureTrailingNewline(value) {
   return value.endsWith("\n") ? value : `${value}
 `;
 }
+function hasNonEmptyText(value) {
+  return typeof value === "string" && value.length > 0;
+}
 function redactDataUrlPayload(value) {
   if (!value.toLowerCase().startsWith("data:")) {
     return value;
@@ -2954,6 +3017,25 @@ var AgentLoggingSessionImpl = class {
     }
     this.enqueueLineWrite(timestamped);
   }
+  async writeAttachments(baseDir, attachments) {
+    const usedNames = /* @__PURE__ */ new Set();
+    for (const attachment of attachments ?? []) {
+      let filename = normalisePathSegment(attachment.filename);
+      if (!filename.includes(".")) {
+        filename = `${filename}.bin`;
+      }
+      const ext = path3.extname(filename);
+      const base = ext.length > 0 ? filename.slice(0, -ext.length) : filename;
+      let candidate = filename;
+      let duplicateIndex = 2;
+      while (usedNames.has(candidate)) {
+        candidate = `${base}-${duplicateIndex.toString()}${ext}`;
+        duplicateIndex += 1;
+      }
+      usedNames.add(candidate);
+      await writeFile(path3.join(baseDir, candidate), attachment.bytes);
+    }
+  }
   startLlmCall(input) {
     const callNumber = this.callCounter + 1;
     this.callCounter = callNumber;
@@ -2966,6 +3048,9 @@ var AgentLoggingSessionImpl = class {
     );
     const responsePath = path3.join(baseDir, "response.txt");
     const thoughtsPath = path3.join(baseDir, "thoughts.txt");
+    const toolCallPath = path3.join(baseDir, "tool_call.txt");
+    const toolCallResponsePath = path3.join(baseDir, "tool_call_response.txt");
+    const errorPath = path3.join(baseDir, "error.txt");
     const responseMetadataPath = path3.join(baseDir, "response.metadata.json");
     let chain = this.ensureReady.then(async () => {
       await mkdir(baseDir, { recursive: true });
@@ -2987,22 +3072,13 @@ var AgentLoggingSessionImpl = class {
 `,
         "utf8"
       );
-      const usedNames = /* @__PURE__ */ new Set();
-      for (const attachment of input.attachments ?? []) {
-        let filename = normalisePathSegment(attachment.filename);
-        if (!filename.includes(".")) {
-          filename = `${filename}.bin`;
-        }
-        const ext = path3.extname(filename);
-        const base = ext.length > 0 ? filename.slice(0, -ext.length) : filename;
-        let candidate = filename;
-        let duplicateIndex = 2;
-        while (usedNames.has(candidate)) {
-          candidate = `${base}-${duplicateIndex.toString()}${ext}`;
-          duplicateIndex += 1;
-        }
-        usedNames.add(candidate);
-        await writeFile(path3.join(baseDir, candidate), attachment.bytes);
+      await this.writeAttachments(baseDir, input.attachments);
+      if (hasNonEmptyText(input.toolCallResponseText)) {
+        await writeFile(
+          toolCallResponsePath,
+          ensureTrailingNewline(input.toolCallResponseText),
+          "utf8"
+        );
       }
     }).catch(() => void 0);
     this.track(chain);
@@ -3030,18 +3106,25 @@ var AgentLoggingSessionImpl = class {
           await appendFile(responsePath, text, "utf8");
         });
       },
-      complete: (metadata) => {
+      complete: (options) => {
         if (closed) {
           return;
         }
         closed = true;
         enqueue(async () => {
+          if (hasNonEmptyText(options?.responseText)) {
+            await writeFile(responsePath, options.responseText, "utf8");
+          }
+          if (hasNonEmptyText(options?.toolCallText)) {
+            await writeFile(toolCallPath, ensureTrailingNewline(options.toolCallText), "utf8");
+          }
+          await this.writeAttachments(baseDir, options?.attachments);
           const payload = {
             capturedAt: toIsoNow(),
             status: "completed"
           };
-          if (metadata) {
-            const sanitised = sanitiseLogValue(metadata);
+          if (options?.metadata) {
+            const sanitised = sanitiseLogValue(options.metadata);
             if (sanitised && typeof sanitised === "object" && !Array.isArray(sanitised)) {
               Object.assign(payload, sanitised);
             } else if (sanitised !== void 0) {
@@ -3052,19 +3135,27 @@ var AgentLoggingSessionImpl = class {
 `, "utf8");
         });
       },
-      fail: (error, metadata) => {
+      fail: (error, options) => {
         if (closed) {
           return;
         }
         closed = true;
         enqueue(async () => {
+          if (hasNonEmptyText(options?.responseText)) {
+            await writeFile(responsePath, options.responseText, "utf8");
+          }
+          if (hasNonEmptyText(options?.toolCallText)) {
+            await writeFile(toolCallPath, ensureTrailingNewline(options.toolCallText), "utf8");
+          }
+          await this.writeAttachments(baseDir, options?.attachments);
+          await writeFile(errorPath, ensureTrailingNewline(toErrorMessage(error)), "utf8");
           const payload = {
             capturedAt: toIsoNow(),
             status: "failed",
             error: toErrorMessage(error)
           };
-          if (metadata) {
-            const sanitised = sanitiseLogValue(metadata);
+          if (options?.metadata) {
+            const sanitised = sanitiseLogValue(options.metadata);
             if (sanitised && typeof sanitised === "object" && !Array.isArray(sanitised)) {
               Object.assign(payload, sanitised);
             } else if (sanitised !== void 0) {
@@ -3089,7 +3180,10 @@ var AgentLoggingSessionImpl = class {
     }
   }
 };
-var loggingSessionStorage = new AsyncLocalStorage();
+var loggingSessionStorage = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.agentLogging.sessionStorage"),
+  () => new AsyncLocalStorage()
+);
 function createAgentLoggingSession(config) {
   return new AgentLoggingSessionImpl(config);
 }
@@ -3104,7 +3198,10 @@ function getCurrentAgentLoggingSession() {
 }
 
 // src/llm.ts
-var toolCallContextStorage = new AsyncLocalStorage2();
+var toolCallContextStorage = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.toolCallContextStorage"),
+  () => new AsyncLocalStorage2()
+);
 function getCurrentToolCallContext() {
   return toolCallContextStorage.getStore() ?? null;
 }
@@ -4907,7 +5004,10 @@ function resolveAttachmentExtension(mimeType) {
     }
   }
 }
-function decodeDataUrlAttachment(value, basename) {
+function buildLoggedAttachmentFilename(prefix, index, mimeType) {
+  return `${prefix}-${index.toString()}.${resolveAttachmentExtension(mimeType)}`;
+}
+function decodeDataUrlAttachment(value, options) {
   const trimmed = value.trim();
   if (!trimmed.toLowerCase().startsWith("data:")) {
     return null;
@@ -4923,7 +5023,7 @@ function decodeDataUrlAttachment(value, basename) {
   try {
     const bytes = isBase64 ? Buffer4.from(payload, "base64") : Buffer4.from(decodeURIComponent(payload), "utf8");
     return {
-      filename: `${basename}.${resolveAttachmentExtension(mimeType)}`,
+      filename: buildLoggedAttachmentFilename(options.prefix, options.index, mimeType),
       bytes
     };
   } catch {
@@ -4932,10 +5032,10 @@ function decodeDataUrlAttachment(value, basename) {
 }
 function collectPayloadAttachments(value, options) {
   if (typeof value === "string") {
-    const attachment = decodeDataUrlAttachment(
-      value,
-      `${options.prefix}-${options.counter.toString()}`
-    );
+    const attachment = decodeDataUrlAttachment(value, {
+      prefix: options.prefix,
+      index: options.counter
+    });
     if (attachment) {
       options.attachments.push(attachment);
       options.counter += 1;
@@ -4960,7 +5060,7 @@ function collectPayloadAttachments(value, options) {
   if (typeof record.data === "string" && mimeType) {
     try {
       options.attachments.push({
-        filename: `${options.prefix}-${options.counter.toString()}.${resolveAttachmentExtension(mimeType)}`,
+        filename: buildLoggedAttachmentFilename(options.prefix, options.counter, mimeType),
         bytes: decodeInlineDataBuffer(record.data)
       });
       options.counter += 1;
@@ -4980,27 +5080,166 @@ function serialiseRequestPayloadForLogging(value) {
 `;
   }
 }
+function serialiseLogArtifactText(value) {
+  if (value === null || value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    if (value.length === 0) {
+      return void 0;
+    }
+    return value.endsWith("\n") ? value : `${value}
+`;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return void 0;
+  }
+  if (isPlainRecord(value) && Object.keys(value).length === 0) {
+    return void 0;
+  }
+  try {
+    return `${JSON.stringify(sanitiseLogValue(value), null, 2)}
+`;
+  } catch {
+    return `${String(value)}
+`;
+  }
+}
+function collectLoggedAttachmentsFromLlmParts(parts, prefix) {
+  const attachments = [];
+  let index = 1;
+  for (const part of parts) {
+    if (part.type !== "inlineData") {
+      continue;
+    }
+    attachments.push({
+      filename: buildLoggedAttachmentFilename(prefix, index, part.mimeType),
+      bytes: decodeInlineDataBuffer(part.data)
+    });
+    index += 1;
+  }
+  return attachments;
+}
+function collectLoggedAttachmentsFromGeminiParts(parts, prefix) {
+  return collectLoggedAttachmentsFromLlmParts(convertGooglePartsToLlmParts(parts), prefix);
+}
+function extractToolCallResponseTextFromOpenAiInput(input) {
+  if (!Array.isArray(input)) {
+    return void 0;
+  }
+  const responses = input.filter((item) => isPlainRecord(item)).flatMap((item) => {
+    const type = typeof item.type === "string" ? item.type : "";
+    if (type !== "function_call_output" && type !== "custom_tool_call_output") {
+      return [];
+    }
+    return [
+      {
+        type,
+        callId: typeof item.call_id === "string" ? item.call_id : void 0,
+        output: "output" in item ? sanitiseLogValue(item.output) : void 0
+      }
+    ];
+  });
+  return serialiseLogArtifactText(responses);
+}
+function extractToolCallResponseTextFromFireworksMessages(messages) {
+  if (!Array.isArray(messages)) {
+    return void 0;
+  }
+  const responses = messages.filter((message) => isPlainRecord(message)).flatMap((message) => {
+    if (message.role !== "tool") {
+      return [];
+    }
+    return [
+      {
+        toolCallId: typeof message.tool_call_id === "string" ? message.tool_call_id : void 0,
+        content: sanitiseLogValue(message.content)
+      }
+    ];
+  });
+  return serialiseLogArtifactText(responses);
+}
+function extractToolCallResponseTextFromGeminiContents(contents) {
+  if (!Array.isArray(contents)) {
+    return void 0;
+  }
+  const responses = [];
+  for (const content of contents) {
+    if (!content || typeof content !== "object") {
+      continue;
+    }
+    const parts = content.parts;
+    if (!Array.isArray(parts)) {
+      continue;
+    }
+    for (const part of parts) {
+      if (!part || typeof part !== "object") {
+        continue;
+      }
+      const functionResponse = part.functionResponse;
+      if (functionResponse) {
+        responses.push(sanitiseLogValue(functionResponse));
+      }
+    }
+  }
+  return serialiseLogArtifactText(responses);
+}
+function serialiseOpenAiStyleToolCallsForLogging(calls) {
+  return serialiseLogArtifactText(
+    calls.map((call) => {
+      if (call.kind === "custom") {
+        return {
+          kind: call.kind,
+          name: call.name,
+          callId: call.callId,
+          itemId: call.itemId,
+          input: call.input
+        };
+      }
+      const { value, error } = parseOpenAiToolArguments(call.arguments);
+      return {
+        kind: call.kind,
+        name: call.name,
+        callId: call.callId,
+        itemId: call.itemId,
+        arguments: value,
+        ...error ? { parseError: error, rawArguments: call.arguments } : {}
+      };
+    })
+  );
+}
+function serialiseGeminiToolCallsForLogging(calls) {
+  return serialiseLogArtifactText(
+    calls.map((call) => ({
+      name: call.name ?? "unknown",
+      callId: typeof call.id === "string" ? call.id : void 0,
+      arguments: sanitiseLogValue(call.args ?? {})
+    }))
+  );
+}
 function startLlmCallLoggerFromContents(options) {
   const session = getCurrentAgentLoggingSession();
   if (!session) {
     return void 0;
   }
   const attachments = [];
+  let attachmentIndex = 1;
   const sections = [];
   for (const [messageIndex, message] of options.contents.entries()) {
     sections.push(`### message_${(messageIndex + 1).toString()} role=${message.role}`);
-    for (const [partIndex, part] of message.parts.entries()) {
+    for (const part of message.parts) {
       if (part.type === "text") {
         const channel = part.thought === true ? "thought" : "response";
         sections.push(`[text:${channel}]`);
         sections.push(part.text);
         continue;
       }
-      const filename = `message-${(messageIndex + 1).toString()}-part-${(partIndex + 1).toString()}.${resolveAttachmentExtension(part.mimeType)}`;
+      const filename = buildLoggedAttachmentFilename("input", attachmentIndex, part.mimeType);
       attachments.push({
         filename,
         bytes: decodeInlineDataBuffer(part.data)
       });
+      attachmentIndex += 1;
       sections.push(
         `[inlineData] file=${filename} mime=${part.mimeType ?? "application/octet-stream"} bytes=${attachments[attachments.length - 1]?.bytes.byteLength ?? 0}`
       );
@@ -5044,11 +5283,18 @@ function startLlmCallLoggerFromPayload(options) {
   }
   const attachments = [];
   collectPayloadAttachments(options.requestPayload, {
-    prefix: `step-${options.step.toString()}`,
+    prefix: "input",
     attachments,
     seen: /* @__PURE__ */ new WeakSet(),
     counter: 1
   });
+  const toolCallResponseText = options.provider === "openai" || options.provider === "chatgpt" ? extractToolCallResponseTextFromOpenAiInput(
+    options.requestPayload.input
+  ) : options.provider === "fireworks" ? extractToolCallResponseTextFromFireworksMessages(
+    options.requestPayload.messages
+  ) : extractToolCallResponseTextFromGeminiContents(
+    options.requestPayload.contents
+  );
   return session.startLlmCall({
     provider: options.provider,
     modelId: options.modelId,
@@ -5057,7 +5303,8 @@ function startLlmCallLoggerFromPayload(options) {
       step: options.step,
       ...getCurrentToolCallContext() ? { toolContext: getCurrentToolCallContext() } : {}
     },
-    attachments
+    attachments,
+    toolCallResponseText
   });
 }
 async function runTextCall(params) {
@@ -5362,6 +5609,7 @@ async function runTextCall(params) {
     const mergedParts = mergeConsecutiveTextParts(responseParts);
     const content = mergedParts.length > 0 ? { role: responseRole ?? "assistant", parts: mergedParts } : void 0;
     const { text, thoughts } = extractTextByChannel(content);
+    const outputAttachments = collectLoggedAttachmentsFromLlmParts(mergedParts, "output");
     const costUsd = estimateCallCostUsd({
       modelId: modelVersion,
       tokens: latestUsage,
@@ -5372,16 +5620,20 @@ async function runTextCall(params) {
       queue.push({ type: "usage", usage: latestUsage, costUsd, modelVersion });
     }
     callLogger?.complete({
-      provider,
-      model: request.model,
-      modelVersion,
-      blocked,
-      costUsd,
-      usage: latestUsage,
-      grounding: grounding ? sanitiseLogValue(grounding) : void 0,
-      responseChars: text.length,
-      thoughtChars: thoughts.length,
-      responseImages
+      responseText: text,
+      attachments: outputAttachments,
+      metadata: {
+        provider,
+        model: request.model,
+        modelVersion,
+        blocked,
+        costUsd,
+        usage: latestUsage,
+        grounding: grounding ? sanitiseLogValue(grounding) : void 0,
+        responseChars: text.length,
+        thoughtChars: thoughts.length,
+        responseImages
+      }
     });
     return {
       provider,
@@ -5396,14 +5648,21 @@ async function runTextCall(params) {
       grounding
     };
   } catch (error) {
+    const partialParts = mergeConsecutiveTextParts(responseParts);
+    const partialContent = partialParts.length > 0 ? { role: responseRole ?? "assistant", parts: partialParts } : void 0;
+    const { text: partialText } = extractTextByChannel(partialContent);
     callLogger?.fail(error, {
-      provider,
-      model: request.model,
-      modelVersion,
-      blocked,
-      usage: latestUsage,
-      partialResponseParts: responseParts.length,
-      responseImages
+      responseText: partialText,
+      attachments: collectLoggedAttachmentsFromLlmParts(partialParts, "output"),
+      metadata: {
+        provider,
+        model: request.model,
+        modelVersion,
+        blocked,
+        usage: latestUsage,
+        partialResponseParts: responseParts.length,
+        responseImages
+      }
     });
     throw error;
   }
@@ -5610,7 +5869,10 @@ var DEFAULT_TOOL_LOOP_MAX_STEPS = 8;
 function resolveToolLoopContents(input) {
   return resolveTextContents(input);
 }
-var toolLoopSteeringInternals = /* @__PURE__ */ new WeakMap();
+var toolLoopSteeringInternals = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.toolLoopSteeringInternals"),
+  () => /* @__PURE__ */ new WeakMap()
+);
 function createToolLoopSteeringChannel() {
   const pending = [];
   let closed = false;
@@ -5870,6 +6132,9 @@ async function runToolLoop(request) {
         let usageTokens;
         let thoughtDeltaEmitted = false;
         let blocked = false;
+        let responseText = "";
+        let reasoningSummary = "";
+        let stepToolCallText;
         const stepRequestPayload = {
           model: providerInfo.model,
           input,
@@ -5962,8 +6227,8 @@ async function runToolLoop(request) {
             throw new Error(message);
           }
           usageTokens = extractOpenAiUsageTokens(finalResponse.usage);
-          const responseText = extractOpenAiResponseParts(finalResponse).parts.filter((p) => p.type === "text" && p.thought !== true).map((p) => p.text).join("").trim();
-          const reasoningSummary = extractOpenAiReasoningSummary(finalResponse).trim();
+          responseText = extractOpenAiResponseParts(finalResponse).parts.filter((p) => p.type === "text" && p.thought !== true).map((p) => p.text).join("").trim();
+          reasoningSummary = extractOpenAiReasoningSummary(finalResponse).trim();
           if (!thoughtDeltaEmitted && reasoningSummary.length > 0) {
             stepCallLogger?.appendThoughtDelta(reasoningSummary);
             emitEvent({ type: "delta", channel: "thought", text: reasoningSummary });
@@ -5979,6 +6244,23 @@ async function runToolLoop(request) {
             emitEvent({ type: "usage", usage: usageTokens, costUsd: stepCostUsd, modelVersion });
           }
           const responseToolCalls = extractOpenAiToolCalls(finalResponse.output);
+          stepToolCallText = serialiseOpenAiStyleToolCallsForLogging(
+            responseToolCalls.map(
+              (call) => call.kind === "custom" ? {
+                kind: call.kind,
+                name: call.name,
+                input: call.input,
+                callId: call.call_id,
+                itemId: call.id
+              } : {
+                kind: call.kind,
+                name: call.name,
+                arguments: call.arguments,
+                callId: call.call_id,
+                itemId: call.id
+              }
+            )
+          );
           const stepToolCalls = [];
           if (responseToolCalls.length === 0) {
             const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
@@ -6006,17 +6288,20 @@ async function runToolLoop(request) {
               timing: timing2
             });
             stepCallLogger?.complete({
-              provider: "openai",
-              model: request.model,
-              modelVersion,
-              step: turn,
-              usage: usageTokens,
-              costUsd: stepCostUsd,
-              blocked,
-              responseChars: responseText.length,
-              thoughtChars: reasoningSummary.length,
-              toolCalls: 0,
-              finalStep: steeringItems2.length === 0
+              responseText,
+              metadata: {
+                provider: "openai",
+                model: request.model,
+                modelVersion,
+                step: turn,
+                usage: usageTokens,
+                costUsd: stepCostUsd,
+                blocked,
+                responseChars: responseText.length,
+                thoughtChars: reasoningSummary.length,
+                toolCalls: 0,
+                finalStep: steeringItems2.length === 0
+              }
             });
             if (steeringItems2.length === 0) {
               return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
@@ -6139,28 +6424,36 @@ async function runToolLoop(request) {
           const steeringInput = steeringInternal?.drainPendingContents() ?? [];
           const steeringItems = steeringInput.length > 0 ? toOpenAiInput(steeringInput) : [];
           stepCallLogger?.complete({
-            provider: "openai",
-            model: request.model,
-            modelVersion,
-            step: turn,
-            usage: usageTokens,
-            costUsd: stepCostUsd,
-            blocked,
-            responseChars: responseText.length,
-            thoughtChars: reasoningSummary.length,
-            toolCalls: stepToolCalls.length,
-            finalStep: false
+            responseText,
+            toolCallText: stepToolCallText,
+            metadata: {
+              provider: "openai",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              blocked,
+              responseChars: responseText.length,
+              thoughtChars: reasoningSummary.length,
+              toolCalls: stepToolCalls.length,
+              finalStep: false
+            }
           });
           previousResponseId = finalResponse.id;
           input = steeringItems.length > 0 ? toolOutputs.concat(steeringItems) : toolOutputs;
         } catch (error) {
           stepCallLogger?.fail(error, {
-            provider: "openai",
-            model: request.model,
-            modelVersion,
-            step: turn,
-            usage: usageTokens,
-            blocked
+            responseText,
+            toolCallText: stepToolCallText,
+            metadata: {
+              provider: "openai",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              blocked
+            }
           });
           throw error;
         }
@@ -6186,6 +6479,7 @@ async function runToolLoop(request) {
         let usageTokens;
         let responseText = "";
         let reasoningSummaryText = "";
+        let stepToolCallText;
         const markFirstModelEvent = () => {
           if (firstModelEventAtMs === void 0) {
             firstModelEventAtMs = Date.now();
@@ -6254,6 +6548,23 @@ async function runToolLoop(request) {
             stepCallLogger?.appendResponseDelta(responseText);
           }
           const responseToolCalls = response.toolCalls ?? [];
+          stepToolCallText = serialiseOpenAiStyleToolCallsForLogging(
+            responseToolCalls.map(
+              (call) => call.kind === "custom" ? {
+                kind: call.kind,
+                name: call.name,
+                input: call.input,
+                callId: call.callId,
+                itemId: call.id
+              } : {
+                kind: call.kind,
+                name: call.name,
+                arguments: call.arguments,
+                callId: call.callId,
+                itemId: call.id
+              }
+            )
+          );
           if (responseToolCalls.length === 0) {
             const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
             const steeringItems2 = steeringInput2.length > 0 ? toChatGptInput(steeringInput2).input : [];
@@ -6279,16 +6590,19 @@ async function runToolLoop(request) {
               timing: timing2
             });
             stepCallLogger?.complete({
-              provider: "chatgpt",
-              model: request.model,
-              modelVersion,
-              step: turn,
-              usage: usageTokens,
-              costUsd: stepCostUsd,
-              responseChars: responseText.length,
-              thoughtChars: reasoningSummaryText.length,
-              toolCalls: 0,
-              finalStep: steeringItems2.length === 0
+              responseText,
+              metadata: {
+                provider: "chatgpt",
+                model: request.model,
+                modelVersion,
+                step: turn,
+                usage: usageTokens,
+                costUsd: stepCostUsd,
+                responseChars: responseText.length,
+                thoughtChars: reasoningSummaryText.length,
+                toolCalls: 0,
+                finalStep: steeringItems2.length === 0
+              }
             });
             if (steeringItems2.length === 0) {
               return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
@@ -6421,25 +6735,33 @@ async function runToolLoop(request) {
           const steeringInput = steeringInternal?.drainPendingContents() ?? [];
           const steeringItems = steeringInput.length > 0 ? toChatGptInput(steeringInput).input : [];
           stepCallLogger?.complete({
-            provider: "chatgpt",
-            model: request.model,
-            modelVersion,
-            step: turn,
-            usage: usageTokens,
-            costUsd: stepCostUsd,
-            responseChars: responseText.length,
-            thoughtChars: reasoningSummaryText.length,
-            toolCalls: toolCalls.length,
-            finalStep: false
+            responseText,
+            toolCallText: stepToolCallText,
+            metadata: {
+              provider: "chatgpt",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              responseChars: responseText.length,
+              thoughtChars: reasoningSummaryText.length,
+              toolCalls: toolCalls.length,
+              finalStep: false
+            }
           });
           input = steeringItems.length > 0 ? input.concat(toolOutputs, steeringItems) : input.concat(toolOutputs);
         } catch (error) {
           stepCallLogger?.fail(error, {
-            provider: "chatgpt",
-            model: request.model,
-            modelVersion,
-            step: turn,
-            usage: usageTokens
+            responseText,
+            toolCallText: stepToolCallText,
+            metadata: {
+              provider: "chatgpt",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens
+            }
           });
           throw error;
         }
@@ -6462,6 +6784,7 @@ async function runToolLoop(request) {
         let usageTokens;
         let responseText = "";
         let blocked = false;
+        let stepToolCallText;
         const stepRequestPayload = {
           model: providerInfo.model,
           messages,
@@ -6526,6 +6849,14 @@ async function runToolLoop(request) {
             });
           }
           const responseToolCalls = extractFireworksToolCalls(message);
+          stepToolCallText = serialiseOpenAiStyleToolCallsForLogging(
+            responseToolCalls.map((call) => ({
+              kind: "function",
+              name: call.name,
+              arguments: call.arguments,
+              callId: call.id
+            }))
+          );
           if (responseToolCalls.length === 0) {
             const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
             const steeringMessages = steeringInput2.length > 0 ? toFireworksMessages(steeringInput2) : [];
@@ -6551,17 +6882,20 @@ async function runToolLoop(request) {
               timing: timing2
             });
             stepCallLogger?.complete({
-              provider: "fireworks",
-              model: request.model,
-              modelVersion,
-              step: turn,
-              usage: usageTokens,
-              costUsd: stepCostUsd,
-              blocked,
-              responseChars: responseText.length,
-              thoughtChars: 0,
-              toolCalls: 0,
-              finalStep: steeringMessages.length === 0
+              responseText,
+              metadata: {
+                provider: "fireworks",
+                model: request.model,
+                modelVersion,
+                step: turn,
+                usage: usageTokens,
+                costUsd: stepCostUsd,
+                blocked,
+                responseChars: responseText.length,
+                thoughtChars: 0,
+                toolCalls: 0,
+                finalStep: steeringMessages.length === 0
+              }
             });
             if (steeringMessages.length === 0) {
               return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
@@ -6673,17 +7007,21 @@ async function runToolLoop(request) {
             timing
           });
           stepCallLogger?.complete({
-            provider: "fireworks",
-            model: request.model,
-            modelVersion,
-            step: turn,
-            usage: usageTokens,
-            costUsd: stepCostUsd,
-            blocked,
-            responseChars: responseText.length,
-            thoughtChars: 0,
-            toolCalls: stepToolCalls.length,
-            finalStep: false
+            responseText,
+            toolCallText: stepToolCallText,
+            metadata: {
+              provider: "fireworks",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              blocked,
+              responseChars: responseText.length,
+              thoughtChars: 0,
+              toolCalls: stepToolCalls.length,
+              finalStep: false
+            }
           });
           messages.push({
             role: "assistant",
@@ -6697,12 +7035,16 @@ async function runToolLoop(request) {
           }
         } catch (error) {
           stepCallLogger?.fail(error, {
-            provider: "fireworks",
-            model: request.model,
-            modelVersion,
-            step: turn,
-            usage: usageTokens,
-            blocked
+            responseText,
+            toolCallText: stepToolCallText,
+            metadata: {
+              provider: "fireworks",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              blocked
+            }
           });
           throw error;
         }
@@ -6722,6 +7064,7 @@ async function runToolLoop(request) {
       let usageTokens;
       let responseText = "";
       let thoughtsText = "";
+      let stepToolCallText;
       const markFirstModelEvent = () => {
         if (firstModelEventAtMs === void 0) {
           firstModelEventAtMs = Date.now();
@@ -6842,12 +7185,17 @@ async function runToolLoop(request) {
         modelVersion = response.modelVersion ?? request.model;
         responseText = response.responseText.trim();
         thoughtsText = response.thoughtsText.trim();
+        const responseOutputAttachments = collectLoggedAttachmentsFromGeminiParts(
+          response.modelParts,
+          "output"
+        );
         const stepCostUsd = estimateCallCostUsd({
           modelId: modelVersion,
           tokens: usageTokens,
           responseImages: 0
         });
         totalCostUsd += stepCostUsd;
+        stepToolCallText = serialiseGeminiToolCallsForLogging(response.functionCalls);
         if (response.functionCalls.length === 0) {
           const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
           finalText = responseText;
@@ -6873,16 +7221,20 @@ async function runToolLoop(request) {
             timing: timing2
           });
           stepCallLogger?.complete({
-            provider: "gemini",
-            model: request.model,
-            modelVersion,
-            step: turn,
-            usage: usageTokens,
-            costUsd: stepCostUsd,
-            responseChars: responseText.length,
-            thoughtChars: thoughtsText.length,
-            toolCalls: 0,
-            finalStep: steeringInput2.length === 0
+            responseText,
+            attachments: responseOutputAttachments,
+            metadata: {
+              provider: "gemini",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              responseChars: responseText.length,
+              thoughtChars: thoughtsText.length,
+              toolCalls: 0,
+              finalStep: steeringInput2.length === 0
+            }
           });
           if (steeringInput2.length === 0) {
             return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
@@ -7009,16 +7361,21 @@ async function runToolLoop(request) {
           timing
         });
         stepCallLogger?.complete({
-          provider: "gemini",
-          model: request.model,
-          modelVersion,
-          step: turn,
-          usage: usageTokens,
-          costUsd: stepCostUsd,
-          responseChars: responseText.length,
-          thoughtChars: thoughtsText.length,
-          toolCalls: toolCalls.length,
-          finalStep: false
+          responseText,
+          attachments: responseOutputAttachments,
+          toolCallText: stepToolCallText,
+          metadata: {
+            provider: "gemini",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            responseChars: responseText.length,
+            thoughtChars: thoughtsText.length,
+            toolCalls: toolCalls.length,
+            finalStep: false
+          }
         });
         geminiContents.push({ role: "user", parts: responseParts });
         const steeringInput = steeringInternal?.drainPendingContents() ?? [];
@@ -7027,13 +7384,17 @@ async function runToolLoop(request) {
         }
       } catch (error) {
         stepCallLogger?.fail(error, {
-          provider: "gemini",
-          model: request.model,
-          modelVersion,
-          step: turn,
-          usage: usageTokens,
-          responseChars: responseText.length,
-          thoughtChars: thoughtsText.length
+          responseText,
+          toolCallText: stepToolCallText,
+          metadata: {
+            provider: "gemini",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens,
+            responseChars: responseText.length,
+            thoughtChars: thoughtsText.length
+          }
         });
         throw error;
       }