@ljoukov/llm 7.0.18 → 7.0.20

package/dist/index.js

@@ -575,6 +575,10 @@ function resolveOpenAiImagePriceResolution(imageSize) {
 import os2 from "os";
 import { TextDecoder as TextDecoder2 } from "util";
 
+// src/utils/env.ts
+import fs from "fs";
+import path from "path";
+
 // src/utils/runtimeSingleton.ts
 var runtimeSingletonStoreKey = /* @__PURE__ */ Symbol.for("@ljoukov/llm.runtimeSingletonStore");
 function getRuntimeSingletonStore() {
@@ -603,16 +607,7 @@ function getRuntimeSingleton(key, create) {
   return createdValue;
 }
 
-// src/openai/chatgpt-auth.ts
-import { Buffer as Buffer2 } from "buffer";
-import fs2 from "fs";
-import os from "os";
-import path2 from "path";
-import { z } from "zod";
-
 // src/utils/env.ts
-import fs from "fs";
-import path from "path";
 var envState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.envState"), () => ({
   envLoaded: false
 }));
@@ -674,6 +669,11 @@ function parseEnvLine(line) {
 }
 
 // src/openai/chatgpt-auth.ts
+import { Buffer as Buffer2 } from "buffer";
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+import { z } from "zod";
 var CHATGPT_AUTH_TOKEN_PROVIDER_URL_ENV = "CHATGPT_AUTH_TOKEN_PROVIDER_URL";
 var CHATGPT_AUTH_TOKEN_PROVIDER_STORE_ENV = "CHATGPT_AUTH_TOKEN_PROVIDER_STORE";
 var CHATGPT_AUTH_API_KEY_ENV = "CHATGPT_AUTH_API_KEY";
@@ -1581,19 +1581,21 @@ function createAbortError(reason) {
 
 // src/openai/chatgpt-codex.ts
 var CHATGPT_CODEX_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
+var CHATGPT_CODEX_ENDPOINT_ENV = "CHATGPT_CODEX_ENDPOINT";
+var CHATGPT_CODEX_PROXY_URL_ENV = "CHATGPT_CODEX_PROXY_URL";
+var CHATGPT_CODEX_PROXY_API_KEY_ENV = "CHATGPT_CODEX_PROXY_API_KEY";
 var CHATGPT_RESPONSES_EXPERIMENTAL_HEADER = "responses=experimental";
 var chatGptCodexState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.chatGptCodexState"), () => ({
   cachedResponsesWebSocketMode: null,
   chatGptResponsesWebSocketDisabled: false
 }));
 async function streamChatGptCodexResponse(options) {
-  const { access, accountId } = await getChatGptAuthProfile();
+  const endpointConfig = await resolveChatGptCodexEndpointConfig();
   const mode = resolveChatGptResponsesWebSocketMode();
   const fallbackStreamFactory = () => {
     const streamPromise = streamChatGptCodexResponseSse({
       request: options.request,
-      access,
-      accountId,
+      endpointConfig,
       sessionId: options.sessionId,
       signal: options.signal
     });
@@ -1615,15 +1617,14 @@ async function streamChatGptCodexResponse(options) {
     return fallbackStreamFactory();
   }
   const websocketHeaders = buildChatGptCodexHeaders({
-    access,
-    accountId,
+    endpointConfig,
     sessionId: options.sessionId,
     useWebSocket: true
   });
   return createAdaptiveResponsesStream({
     mode,
     createWebSocketStream: async () => await createResponsesWebSocketStream({
-      url: toWebSocketUrl(CHATGPT_CODEX_ENDPOINT),
+      url: toWebSocketUrl(endpointConfig.url),
       headers: websocketHeaders,
       request: options.request,
       signal: options.signal
@@ -1636,14 +1637,13 @@ async function streamChatGptCodexResponse(options) {
 }
 async function streamChatGptCodexResponseSse(options) {
   const headers = buildChatGptCodexHeaders({
-    access: options.access,
-    accountId: options.accountId,
+    endpointConfig: options.endpointConfig,
     sessionId: options.sessionId,
     useWebSocket: false
   });
   headers.Accept = "text/event-stream";
   headers["Content-Type"] = "application/json";
-  const response = await fetch(CHATGPT_CODEX_ENDPOINT, {
+  const response = await fetch(options.endpointConfig.url, {
     method: "POST",
     headers,
     body: JSON.stringify(options.request),
@@ -1663,24 +1663,77 @@ function resolveChatGptResponsesWebSocketMode() {
   if (chatGptCodexState.cachedResponsesWebSocketMode) {
     return chatGptCodexState.cachedResponsesWebSocketMode;
   }
+  const explicitMode = process.env.CHATGPT_RESPONSES_WEBSOCKET_MODE ?? process.env.OPENAI_RESPONSES_WEBSOCKET_MODE;
+  const defaultMode = resolveChatGptCodexProxyConfig() ? "off" : "auto";
   chatGptCodexState.cachedResponsesWebSocketMode = resolveResponsesWebSocketMode(
-    process.env.CHATGPT_RESPONSES_WEBSOCKET_MODE ?? process.env.OPENAI_RESPONSES_WEBSOCKET_MODE,
-    "auto"
+    explicitMode,
+    defaultMode
   );
   return chatGptCodexState.cachedResponsesWebSocketMode;
 }
+async function resolveChatGptCodexEndpointConfig() {
+  const proxy = resolveChatGptCodexProxyConfig();
+  if (proxy) {
+    return proxy;
+  }
+  const { access, accountId } = await getChatGptAuthProfile();
+  return {
+    kind: "direct",
+    url: resolveChatGptCodexEndpoint(),
+    access,
+    accountId
+  };
+}
+function resolveChatGptCodexEndpoint() {
+  loadLocalEnv();
+  return process.env[CHATGPT_CODEX_ENDPOINT_ENV]?.trim() || CHATGPT_CODEX_ENDPOINT;
+}
+function resolveChatGptCodexProxyConfig() {
+  loadLocalEnv();
+  const rawUrl = process.env[CHATGPT_CODEX_PROXY_URL_ENV]?.trim();
+  if (!rawUrl) {
+    return null;
+  }
+  const apiKey = process.env[CHATGPT_CODEX_PROXY_API_KEY_ENV]?.trim();
+  if (!apiKey) {
+    throw new Error(
+      `${CHATGPT_CODEX_PROXY_API_KEY_ENV} must be provided when ${CHATGPT_CODEX_PROXY_URL_ENV} is set.`
+    );
+  }
+  return {
+    kind: "proxy",
+    url: normalizeChatGptCodexProxyUrl(rawUrl),
+    apiKey
+  };
+}
+function normalizeChatGptCodexProxyUrl(rawUrl) {
+  try {
+    const url = new URL(rawUrl);
+    if (url.pathname === "" || url.pathname === "/") {
+      url.pathname = "/api/codex/responses";
+    }
+    return url.toString();
+  } catch {
+    return rawUrl;
+  }
+}
 function buildChatGptCodexHeaders(options) {
   const openAiBeta = options.useWebSocket ? mergeOpenAiBetaHeader(
     CHATGPT_RESPONSES_EXPERIMENTAL_HEADER,
     OPENAI_BETA_RESPONSES_WEBSOCKETS_V2
   ) : CHATGPT_RESPONSES_EXPERIMENTAL_HEADER;
   const headers = {
-    Authorization: `Bearer ${options.access}`,
-    "chatgpt-account-id": options.accountId,
     "OpenAI-Beta": openAiBeta,
     originator: "llm",
     "User-Agent": buildUserAgent()
   };
+  if (options.endpointConfig.kind === "proxy") {
+    headers.Authorization = `Bearer ${options.endpointConfig.apiKey}`;
+    headers["x-codex-proxy-auth"] = options.endpointConfig.apiKey;
+  } else {
+    headers.Authorization = `Bearer ${options.endpointConfig.access}`;
+    headers["chatgpt-account-id"] = options.endpointConfig.accountId;
+  }
   if (options.sessionId) {
     headers.session_id = options.sessionId;
   }