@ljoukov/llm 4.0.7 → 4.0.8

package/dist/index.cjs

@@ -441,6 +441,34 @@ function estimateCallCostUsd({
 var import_node_os2 = __toESM(require("os"), 1);
 var import_node_util = require("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
 var import_node_buffer = require("buffer");
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -451,14 +479,16 @@ var import_zod = require("zod");
 // src/utils/env.ts
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
-var envLoaded = false;
+var envState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.envState"), () => ({
+  envLoaded: false
+}));
 function loadLocalEnv() {
-  if (envLoaded) {
+  if (envState.envLoaded) {
     return;
   }
   const envPath = import_node_path.default.join(process.cwd(), ".env.local");
   loadEnvFromFile(envPath, { override: false });
-  envLoaded = true;
+  envState.envLoaded = true;
 }
 function loadEnvFromFile(filePath, { override = false } = {}) {
   let content;
@@ -544,8 +574,10 @@ var ExchangeResponseSchema = import_zod.z.object({
   expires_in: import_zod.z.union([import_zod.z.number(), import_zod.z.string()]),
   id_token: import_zod.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";
@@ -646,13 +678,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({
@@ -660,31 +692,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;
@@ -1416,8 +1448,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();
@@ -1443,7 +1477,7 @@ async function streamChatGptCodexResponse(options) {
       }
     };
   };
-  if (mode === "off" || chatGptResponsesWebSocketDisabled) {
+  if (mode === "off" || chatGptCodexState.chatGptResponsesWebSocketDisabled) {
     return fallbackStreamFactory();
   }
   const websocketHeaders = buildChatGptCodexHeaders({
@@ -1462,7 +1496,7 @@ async function streamChatGptCodexResponse(options) {
     }),
     createFallbackStream: fallbackStreamFactory,
     onWebSocketFallback: () => {
-      chatGptResponsesWebSocketDisabled = true;
+      chatGptCodexState.chatGptResponsesWebSocketDisabled = true;
     }
   });
 }
@@ -1492,14 +1526,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(
@@ -1537,8 +1571,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;
       }
@@ -1774,7 +1808,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;
@@ -1848,14 +1887,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;
@@ -2089,32 +2128,37 @@ var import_openai = __toESM(require("openai"), 1);
 var import_undici = require("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;
@@ -2124,46 +2168,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 import_undici.Agent({
     bodyTimeout: timeoutMs,
     headersTimeout: timeoutMs
   });
-  cachedFetch = ((input, init) => {
+  fireworksClientState.cachedFetch = ((input, init) => {
     return (0, import_undici.fetch)(input, {
       ...init ?? {},
       dispatcher
     });
   });
-  return cachedFetch;
+  return fireworksClientState.cachedFetch;
 }
 function getFireworksClient() {
-  if (cachedClient) {
-    return cachedClient;
+  if (fireworksClientState.cachedClient) {
+    return fireworksClientState.cachedClient;
   }
-  cachedClient = new import_openai.default({
+  fireworksClientState.cachedClient = new import_openai.default({
     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;
   }
@@ -2175,7 +2224,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) {
@@ -2222,7 +2271,10 @@ var ServiceAccountSchema = import_zod2.z.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 {
@@ -2233,16 +2285,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) {
@@ -2294,8 +2346,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;
@@ -2306,14 +2360,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;
   }
@@ -2321,15 +2375,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);
@@ -2341,7 +2395,7 @@ async function getGeminiClient() {
       });
     });
   }
-  return clientPromise;
+  return geminiClientState.clientPromise;
 }
 
 // src/google/calls.ts
@@ -2537,11 +2591,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;
   }
@@ -2564,7 +2620,7 @@ function getSchedulerForModel2(modelId) {
       }
     }
   });
-  schedulerByModel2.set(schedulerKey, created);
+  googleCallState.schedulerByModel.set(schedulerKey, created);
   return created;
 }
 async function runGeminiCall(fn, modelId, runOptions) {
@@ -2574,53 +2630,55 @@ async function runGeminiCall(fn, modelId, runOptions) {
 // src/openai/client.ts
 var import_openai2 = __toESM(require("openai"), 1);
 var import_undici2 = require("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 import_undici2.Agent({
     bodyTimeout: timeoutMs,
     headersTimeout: timeoutMs
   });
-  cachedFetch2 = ((input, init) => {
+  openAiClientState.cachedFetch = ((input, init) => {
     return (0, import_undici2.fetch)(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 {
@@ -2673,7 +2731,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;
@@ -2692,15 +2750,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;
@@ -2708,33 +2766,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 import_openai2.default({
+  openAiClientState.cachedClient = new import_openai2.default({
     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;
   }
@@ -2746,7 +2806,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) {
@@ -3232,7 +3292,10 @@ var AgentLoggingSessionImpl = class {
     }
   }
 };
-var loggingSessionStorage = new import_node_async_hooks.AsyncLocalStorage();
+var loggingSessionStorage = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.agentLogging.sessionStorage"),
+  () => new import_node_async_hooks.AsyncLocalStorage()
+);
 function createAgentLoggingSession(config) {
   return new AgentLoggingSessionImpl(config);
 }
@@ -3247,7 +3310,10 @@ function getCurrentAgentLoggingSession() {
 }
 
 // src/llm.ts
-var toolCallContextStorage = new import_node_async_hooks2.AsyncLocalStorage();
+var toolCallContextStorage = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.toolCallContextStorage"),
+  () => new import_node_async_hooks2.AsyncLocalStorage()
+);
 function getCurrentToolCallContext() {
   return toolCallContextStorage.getStore() ?? null;
 }
@@ -5915,7 +5981,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;