@ljoukov/llm 3.0.0 → 3.0.2

package/dist/index.js

@@ -136,7 +136,7 @@ function getGeminiProPricing(modelId) {
   if (modelId.includes("gemini-2.5-pro")) {
     return GEMINI_2_5_PRO_PRICING;
   }
-  if (modelId.includes("gemini-3-pro")) {
+  if (modelId.includes("gemini-3-pro") || modelId.includes("gemini-3.1-pro")) {
     return GEMINI_3_PRO_PREVIEW_PRICING;
   }
   return void 0;
@@ -336,8 +336,6 @@ function parseEnvLine(line) {
 // src/openai/chatgpt-auth.ts
 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_SERVER_URL_ENV = "CHATGPT_AUTH_SERVER_URL";
-var CHATGPT_AUTH_SERVER_STORE_ENV = "CHATGPT_AUTH_SERVER_STORE";
 var CHATGPT_AUTH_API_KEY_ENV = "CHATGPT_AUTH_API_KEY";
 var CHATGPT_AUTH_TOKEN_PROVIDER_API_KEY_ENV = "CHATGPT_AUTH_TOKEN_PROVIDER_API_KEY";
 var CHATGPT_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
@@ -469,7 +467,7 @@ async function refreshChatGptOauthToken(refreshToken, fallback) {
 }
 async function getChatGptAuthProfile() {
   loadLocalEnv();
-  const tokenProviderUrl = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_URL_ENV] ?? process.env[CHATGPT_AUTH_SERVER_URL_ENV];
+  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)) {
@@ -480,7 +478,7 @@ async function getChatGptAuthProfile() {
     }
     refreshPromise = (async () => {
       try {
-        const store = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_STORE_ENV] ?? process.env[CHATGPT_AUTH_SERVER_STORE_ENV];
+        const store = process.env[CHATGPT_AUTH_TOKEN_PROVIDER_STORE_ENV];
         const profile = await fetchChatGptAuthProfileFromTokenProvider({
           baseUrl: tokenProviderUrl,
           apiKey: tokenProviderKey,
@@ -683,22 +681,588 @@ function extractChatGptAccountId(token) {
   return typeof namespaced === "string" && namespaced.length > 0 ? namespaced : void 0;
 }
 
+// src/openai/responses-websocket.ts
+import WebSocket from "ws";
+var OPENAI_BETA_RESPONSES_WEBSOCKETS_V2 = "responses_websockets=2026-02-06";
+var ResponsesWebSocketHttpError = class extends Error {
+  status;
+  body;
+  headers;
+  constructor(options) {
+    super(options.message);
+    this.name = "ResponsesWebSocketHttpError";
+    this.status = options.status;
+    this.body = options.body;
+    this.headers = options.headers;
+  }
+};
+function resolveResponsesWebSocketMode(raw, fallback = "auto") {
+  const value = raw?.trim().toLowerCase();
+  if (value === "auto" || value === "off" || value === "only") {
+    return value;
+  }
+  return fallback;
+}
+function mergeOpenAiBetaHeader(existing, required) {
+  const parts = /* @__PURE__ */ new Set();
+  for (const part of (existing ?? "").split(",")) {
+    const trimmed = part.trim();
+    if (trimmed.length > 0) {
+      parts.add(trimmed);
+    }
+  }
+  const normalizedRequired = required.trim();
+  if (normalizedRequired.length > 0) {
+    parts.add(normalizedRequired);
+  }
+  return Array.from(parts).join(", ");
+}
+function toWebSocketUrl(httpOrHttpsUrl) {
+  const parsed = new URL(httpOrHttpsUrl);
+  if (parsed.protocol === "https:") {
+    parsed.protocol = "wss:";
+  } else if (parsed.protocol === "http:") {
+    parsed.protocol = "ws:";
+  } else if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+    throw new Error(`Unsupported websocket URL protocol: ${parsed.protocol}`);
+  }
+  return parsed.toString();
+}
+function isResponsesWebSocketUnsupportedError(error) {
+  if (error instanceof ResponsesWebSocketHttpError) {
+    return [400, 404, 405, 406, 426, 501].includes(error.status);
+  }
+  const message = error instanceof Error ? error.message.toLowerCase() : "";
+  return message.includes("unexpected server response: 426");
+}
+function createAdaptiveResponsesStream(options) {
+  let resolved = null;
+  let websocketSelected = false;
+  let fallbackSelected = false;
+  const activateFallback = (error) => {
+    options.onWebSocketFallback?.(error);
+    fallbackSelected = true;
+    websocketSelected = false;
+    const fallback = options.createFallbackStream();
+    resolved = Promise.resolve(fallback);
+    return fallback;
+  };
+  const getStream = async () => {
+    if (resolved) {
+      return await resolved;
+    }
+    resolved = (async () => {
+      if (options.mode === "off") {
+        fallbackSelected = true;
+        return options.createFallbackStream();
+      }
+      try {
+        const stream = await options.createWebSocketStream();
+        websocketSelected = true;
+        return stream;
+      } catch (error) {
+        if (options.mode === "only") {
+          throw error;
+        }
+        return activateFallback(error);
+      }
+    })();
+    return await resolved;
+  };
+  return {
+    async *[Symbol.asyncIterator]() {
+      const stream = await getStream();
+      let yielded = 0;
+      try {
+        for await (const event of stream) {
+          yielded += 1;
+          yield event;
+        }
+      } catch (error) {
+        if (options.mode !== "only" && websocketSelected && !fallbackSelected && yielded === 0) {
+          const fallback = activateFallback(error);
+          for await (const event of fallback) {
+            yield event;
+          }
+          return;
+        }
+        throw error;
+      }
+    },
+    async finalResponse() {
+      const stream = await getStream();
+      try {
+        return await stream.finalResponse();
+      } catch (error) {
+        if (options.mode === "only" || !websocketSelected || fallbackSelected) {
+          throw error;
+        }
+        const fallback = activateFallback(error);
+        return await fallback.finalResponse();
+      }
+    },
+    close() {
+      void getStream().then((stream) => stream.close()).catch(() => {
+      });
+    }
+  };
+}
+async function createResponsesWebSocketStream(options) {
+  const completionTypes = new Set(
+    options.completionEventTypes ?? ["response.completed", "response.failed", "response.done"]
+  );
+  const { socket, responseHeaders } = await connectWebSocket({
+    url: options.url,
+    headers: options.headers,
+    signal: options.signal
+  });
+  const queue = createAsyncQueue();
+  let settled = false;
+  let finalResponse = null;
+  let latestResponse = null;
+  let idleTimer = null;
+  let resolveFinal = null;
+  let rejectFinal = null;
+  const finalPromise = new Promise((resolve, reject) => {
+    resolveFinal = resolve;
+    rejectFinal = reject;
+  });
+  void finalPromise.catch(() => {
+  });
+  const clearIdleTimer = () => {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+  };
+  const closeSocket = () => {
+    try {
+      if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
+        socket.close();
+      }
+    } catch {
+    }
+  };
+  const complete = (response) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    clearIdleTimer();
+    finalResponse = response;
+    resolveFinal?.(response);
+    queue.close();
+    closeSocket();
+  };
+  const fail = (error) => {
+    if (settled) {
+      return;
+    }
+    settled = true;
+    clearIdleTimer();
+    rejectFinal?.(error);
+    queue.fail(error);
+    closeSocket();
+  };
+  const restartIdleTimer = () => {
+    clearIdleTimer();
+    const idleTimeoutMs = options.idleTimeoutMs;
+    if (!idleTimeoutMs || idleTimeoutMs <= 0 || settled) {
+      return;
+    }
+    idleTimer = setTimeout(() => {
+      fail(new Error(`Responses WebSocket idle timeout after ${idleTimeoutMs}ms.`));
+    }, idleTimeoutMs);
+  };
+  const onAbort = () => {
+    const error = createAbortError(options.signal?.reason);
+    fail(error);
+  };
+  if (options.signal) {
+    if (options.signal.aborted) {
+      socket.close();
+      throw createAbortError(options.signal.reason);
+    }
+    options.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  const cleanup = () => {
+    clearIdleTimer();
+    socket.removeAllListeners();
+    if (options.signal) {
+      options.signal.removeEventListener("abort", onAbort);
+    }
+  };
+  socket.on("message", (raw) => {
+    restartIdleTimer();
+    const parsed = parseWebSocketPayload(raw);
+    if (!parsed) {
+      return;
+    }
+    const error = mapWebSocketErrorEvent(parsed);
+    if (error) {
+      fail(error);
+      return;
+    }
+    const event = parsed;
+    if (isObjectWithResponse(event)) {
+      latestResponse = event.response;
+    }
+    queue.push(event);
+    const type = typeof event.type === "string" ? event.type : "";
+    if (completionTypes.has(type)) {
+      const completedResponse = normalizeFinalResponse(
+        type,
+        event.response,
+        latestResponse,
+        responseHeaders
+      );
+      complete(completedResponse);
+    }
+  });
+  socket.on("error", (error) => {
+    fail(new Error(`Responses WebSocket error: ${error.message}`));
+  });
+  socket.on("close", (_code, _reason) => {
+    if (settled) {
+      cleanup();
+      return;
+    }
+    fail(new Error("Responses WebSocket closed before completion."));
+    cleanup();
+  });
+  restartIdleTimer();
+  const payload = serializeRequestPayload(options.request);
+  await new Promise((resolve, reject) => {
+    socket.send(payload, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  }).catch((error) => {
+    fail(new Error(`Failed to send Responses WebSocket request: ${errorToMessage(error)}`));
+    throw error instanceof Error ? error : new Error(errorToMessage(error));
+  });
+  return {
+    async *[Symbol.asyncIterator]() {
+      try {
+        for await (const event of queue.iterable) {
+          yield event;
+        }
+      } finally {
+        if (!settled) {
+          closeSocket();
+        }
+      }
+    },
+    async finalResponse() {
+      return await finalPromise;
+    },
+    close() {
+      if (settled) {
+        return;
+      }
+      const response = finalResponse ?? latestResponse ?? { status: "cancelled" };
+      complete(response);
+      cleanup();
+    }
+  };
+}
+async function connectWebSocket(options) {
+  return await new Promise((resolve, reject) => {
+    const socket = new WebSocket(options.url, {
+      headers: options.headers,
+      handshakeTimeout: 3e4
+    });
+    let settled = false;
+    let responseBody = "";
+    const rejectOnce = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      try {
+        socket.terminate();
+      } catch {
+      }
+      reject(error);
+    };
+    const resolveOnce = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup(false);
+      resolve(result);
+    };
+    const onAbort = () => {
+      rejectOnce(createAbortError(options.signal?.reason));
+    };
+    const cleanup = (removeAbortListener = true) => {
+      socket.removeListener("open", onOpen);
+      socket.removeListener("error", onError);
+      socket.removeListener("unexpected-response", onUnexpectedResponse);
+      if (removeAbortListener && options.signal) {
+        options.signal.removeEventListener("abort", onAbort);
+      }
+    };
+    const onOpen = () => {
+      const headers = normalizeUpgradeHeaders(socket);
+      resolveOnce({ socket, responseHeaders: headers });
+    };
+    const onError = (error) => {
+      rejectOnce(new Error(`Responses WebSocket connection failed: ${error.message}`));
+    };
+    const onUnexpectedResponse = (_request, response) => {
+      if (typeof response.setEncoding === "function") {
+        response.setEncoding("utf8");
+      }
+      response.on("data", (chunk) => {
+        responseBody += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      });
+      response.on("end", () => {
+        const status = Number(response.statusCode ?? 0);
+        const headers = {};
+        const rawHeaders = response.headers ?? {};
+        for (const [key, value] of Object.entries(rawHeaders)) {
+          if (typeof value === "string") {
+            headers[key] = value;
+          } else if (Array.isArray(value)) {
+            headers[key] = value.join(", ");
+          }
+        }
+        rejectOnce(
+          new ResponsesWebSocketHttpError({
+            status: Number.isFinite(status) && status > 0 ? status : 500,
+            message: `Responses WebSocket upgrade failed${status ? ` (${status})` : ""}.`,
+            body: responseBody || void 0,
+            headers
+          })
+        );
+      });
+      response.on("error", (error) => {
+        rejectOnce(
+          new ResponsesWebSocketHttpError({
+            status: Number(response.statusCode ?? 500),
+            message: `Responses WebSocket upgrade failed: ${error.message}`,
+            body: responseBody || void 0
+          })
+        );
+      });
+    };
+    socket.once("open", onOpen);
+    socket.once("error", onError);
+    socket.once("unexpected-response", onUnexpectedResponse);
+    if (options.signal) {
+      if (options.signal.aborted) {
+        onAbort();
+        return;
+      }
+      options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function normalizeUpgradeHeaders(socket) {
+  const maybeUpgradeResponse = socket._req?.res;
+  const raw = maybeUpgradeResponse?.headers ?? {};
+  const normalized = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (typeof value === "string") {
+      normalized[key.toLowerCase()] = value;
+    } else if (Array.isArray(value)) {
+      normalized[key.toLowerCase()] = value.join(", ");
+    }
+  }
+  return normalized;
+}
+function parseWebSocketPayload(raw) {
+  const text = toUtf8(raw);
+  if (!text) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function toUtf8(raw) {
+  if (typeof raw === "string") {
+    return raw;
+  }
+  if (raw instanceof ArrayBuffer) {
+    return Buffer.from(raw).toString("utf8");
+  }
+  if (Array.isArray(raw)) {
+    const chunks = raw.map((chunk) => {
+      if (typeof chunk === "string") {
+        return Buffer.from(chunk, "utf8");
+      }
+      return Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    });
+    return Buffer.concat(chunks).toString("utf8");
+  }
+  return Buffer.isBuffer(raw) ? raw.toString("utf8") : Buffer.from(raw).toString("utf8");
+}
+function mapWebSocketErrorEvent(payload) {
+  if (payload.type !== "error") {
+    return null;
+  }
+  const status = resolveNumericStatus(payload.status) ?? resolveNumericStatus(payload.status_code);
+  if (!status || status < 400) {
+    const message = errorToMessage(payload.error) || "Responses WebSocket returned an error event.";
+    return new Error(message);
+  }
+  const headers = mapErrorHeaders(payload.headers);
+  const body = payload.error && typeof payload.error === "object" ? JSON.stringify({ error: payload.error }, null, 2) : void 0;
+  return new ResponsesWebSocketHttpError({
+    status,
+    message: `Responses WebSocket returned status ${status}.`,
+    body,
+    headers
+  });
+}
+function mapErrorHeaders(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const headers = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean") {
+      headers[key.toLowerCase()] = String(entry);
+    }
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function resolveNumericStatus(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.floor(value);
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return Math.floor(parsed);
+    }
+  }
+  return null;
+}
+function normalizeFinalResponse(eventType, eventResponse, latestResponse, responseHeaders) {
+  const response = eventResponse && typeof eventResponse === "object" ? { ...eventResponse } : latestResponse ? { ...latestResponse } : {};
+  if (typeof response.status !== "string") {
+    if (eventType === "response.failed") {
+      response.status = "failed";
+    } else if (eventType === "response.done") {
+      response.status = "completed";
+    } else if (eventType === "response.completed") {
+      response.status = "completed";
+    }
+  }
+  const upgradeModel = responseHeaders["openai-model"];
+  if (typeof response.model !== "string" && upgradeModel) {
+    response.model = upgradeModel;
+  }
+  return response;
+}
+function serializeRequestPayload(request) {
+  if (!request || typeof request !== "object" || Array.isArray(request)) {
+    throw new Error("Responses WebSocket request must be a JSON object.");
+  }
+  const body = request;
+  const payload = typeof body.type === "string" ? body : { type: "response.create", ...body };
+  return JSON.stringify(payload);
+}
+function isObjectWithResponse(event) {
+  return Boolean(event.response && typeof event.response === "object");
+}
+function errorToMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function createAbortError(reason) {
+  const error = new Error(
+    reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "Request aborted."
+  );
+  error.name = "AbortError";
+  return error;
+}
+
 // 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;
 async function streamChatGptCodexResponse(options) {
   const { access, accountId } = await getChatGptAuthProfile();
-  const headers = {
-    Authorization: `Bearer ${access}`,
-    "chatgpt-account-id": accountId,
-    "OpenAI-Beta": "responses=experimental",
-    originator: "llm",
-    "User-Agent": buildUserAgent(),
-    Accept: "text/event-stream",
-    "Content-Type": "application/json"
+  const mode = resolveChatGptResponsesWebSocketMode();
+  const fallbackStreamFactory = () => {
+    const streamPromise = streamChatGptCodexResponseSse({
+      request: options.request,
+      access,
+      accountId,
+      sessionId: options.sessionId,
+      signal: options.signal
+    });
+    return {
+      async *[Symbol.asyncIterator]() {
+        const stream = await streamPromise;
+        for await (const event of stream) {
+          yield event;
+        }
+      },
+      async finalResponse() {
+        return {};
+      },
+      close() {
+      }
+    };
   };
-  if (options.sessionId) {
-    headers.session_id = options.sessionId;
+  if (mode === "off" || chatGptResponsesWebSocketDisabled) {
+    return fallbackStreamFactory();
   }
+  const websocketHeaders = buildChatGptCodexHeaders({
+    access,
+    accountId,
+    sessionId: options.sessionId,
+    useWebSocket: true
+  });
+  return createAdaptiveResponsesStream({
+    mode,
+    createWebSocketStream: async () => await createResponsesWebSocketStream({
+      url: toWebSocketUrl(CHATGPT_CODEX_ENDPOINT),
+      headers: websocketHeaders,
+      request: options.request,
+      signal: options.signal
+    }),
+    createFallbackStream: fallbackStreamFactory,
+    onWebSocketFallback: () => {
+      chatGptResponsesWebSocketDisabled = true;
+    }
+  });
+}
+async function streamChatGptCodexResponseSse(options) {
+  const headers = buildChatGptCodexHeaders({
+    access: options.access,
+    accountId: options.accountId,
+    sessionId: options.sessionId,
+    useWebSocket: false
+  });
+  headers.Accept = "text/event-stream";
+  headers["Content-Type"] = "application/json";
   const response = await fetch(CHATGPT_CODEX_ENDPOINT, {
     method: "POST",
     headers,
@@ -715,20 +1279,67 @@ async function streamChatGptCodexResponse(options) {
   }
   return parseEventStream(body);
 }
+function resolveChatGptResponsesWebSocketMode() {
+  if (cachedResponsesWebSocketMode) {
+    return cachedResponsesWebSocketMode;
+  }
+  cachedResponsesWebSocketMode = resolveResponsesWebSocketMode(
+    process.env.CHATGPT_RESPONSES_WEBSOCKET_MODE ?? process.env.OPENAI_RESPONSES_WEBSOCKET_MODE,
+    "auto"
+  );
+  return cachedResponsesWebSocketMode;
+}
+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.sessionId) {
+    headers.session_id = options.sessionId;
+  }
+  return headers;
+}
 async function collectChatGptCodexResponse(options) {
-  let stream;
-  try {
-    stream = await streamChatGptCodexResponse(options);
-  } catch (error) {
-    if (shouldRetryWithoutReasoningSummary(options.request, error)) {
-      stream = await streamChatGptCodexResponse({
+  let requestForAttempt = options.request;
+  let retriedWithoutReasoningSummary = false;
+  let retriedViaSseFallback = false;
+  while (true) {
+    let sawAnyDelta = false;
+    try {
+      const stream = await streamChatGptCodexResponse({
         ...options,
-        request: removeReasoningSummary(options.request)
+        request: requestForAttempt
       });
-    } else {
+      return await collectChatGptCodexStream({
+        stream,
+        onDelta: (delta) => {
+          sawAnyDelta = true;
+          options.onDelta?.(delta);
+        }
+      });
+    } catch (error) {
+      if (!sawAnyDelta && !retriedViaSseFallback && shouldRetryViaSseFallback(error) && !chatGptResponsesWebSocketDisabled) {
+        chatGptResponsesWebSocketDisabled = true;
+        retriedViaSseFallback = true;
+        continue;
+      }
+      if (!retriedWithoutReasoningSummary && shouldRetryWithoutReasoningSummary(requestForAttempt, error)) {
+        requestForAttempt = removeReasoningSummary(requestForAttempt);
+        retriedWithoutReasoningSummary = true;
+        continue;
+      }
       throw error;
     }
   }
+}
+async function collectChatGptCodexStream(options) {
   const toolCalls = /* @__PURE__ */ new Map();
   const toolCallOrder = [];
   const webSearchCalls = /* @__PURE__ */ new Map();
@@ -741,7 +1352,7 @@ async function collectChatGptCodexResponse(options) {
   let model;
   let status;
   let blocked = false;
-  for await (const event of stream) {
+  for await (const event of options.stream) {
     const type = typeof event.type === "string" ? event.type : void 0;
     if (type === "response.output_text.delta") {
       const delta = typeof event.delta === "string" ? event.delta : "";
@@ -865,6 +1476,16 @@ function shouldRetryWithoutReasoningSummary(request, error) {
   const message = error.message.toLowerCase();
   return message.includes("unsupported parameter") && message.includes("reasoning.summary");
 }
+function shouldRetryViaSseFallback(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  if (error.name === "AbortError") {
+    return false;
+  }
+  const message = error.message.toLowerCase();
+  return message.includes("responses websocket");
+}
 function removeReasoningSummary(request) {
   const reasoning = request.reasoning;
   if (!reasoning?.summary) {
@@ -1112,14 +1733,16 @@ async function runFireworksCall(fn) {
 }
 
 // src/fireworks/models.ts
-var FIREWORKS_MODEL_IDS = ["kimi-k2.5", "glm-5", "minimax-m2.1"];
+var FIREWORKS_MODEL_IDS = ["kimi-k2.5", "glm-5", "minimax-m2.1", "gpt-oss-120b"];
 var FIREWORKS_DEFAULT_KIMI_MODEL = "kimi-k2.5";
 var FIREWORKS_DEFAULT_GLM_MODEL = "glm-5";
 var FIREWORKS_DEFAULT_MINIMAX_MODEL = "minimax-m2.1";
+var FIREWORKS_DEFAULT_GPT_OSS_120B_MODEL = "gpt-oss-120b";
 var FIREWORKS_CANONICAL_MODEL_IDS = {
   "kimi-k2.5": "accounts/fireworks/models/kimi-k2p5",
   "glm-5": "accounts/fireworks/models/glm-5",
-  "minimax-m2.1": "accounts/fireworks/models/minimax-m2p1"
+  "minimax-m2.1": "accounts/fireworks/models/minimax-m2p1",
+  "gpt-oss-120b": "accounts/fireworks/models/gpt-oss-120b"
 };
 function isFireworksModelId(value) {
   return FIREWORKS_MODEL_IDS.includes(value.trim());
@@ -1200,6 +1823,7 @@ function getGoogleAuthOptions(scopes) {
 // src/google/client.ts
 var GEMINI_MODEL_IDS = [
   "gemini-3-pro-preview",
+  "gemini-3.1-pro-preview",
   "gemini-3-flash-preview",
   "gemini-2.5-pro",
   "gemini-flash-latest",
@@ -1466,6 +2090,8 @@ var cachedApiKey2 = null;
 var cachedClient2 = null;
 var cachedFetch2 = null;
 var cachedTimeoutMs2 = null;
+var openAiResponsesWebSocketMode = null;
+var openAiResponsesWebSocketDisabled = false;
 var DEFAULT_OPENAI_TIMEOUT_MS = 15 * 6e4;
 function resolveOpenAiTimeoutMs() {
   if (cachedTimeoutMs2 !== null) {
@@ -1493,6 +2119,97 @@ function getOpenAiFetch() {
   });
   return cachedFetch2;
 }
+function resolveOpenAiBaseUrl() {
+  loadLocalEnv();
+  return process.env.OPENAI_BASE_URL?.trim() || "https://api.openai.com/v1";
+}
+function resolveOpenAiResponsesWebSocketMode() {
+  if (openAiResponsesWebSocketMode) {
+    return openAiResponsesWebSocketMode;
+  }
+  loadLocalEnv();
+  openAiResponsesWebSocketMode = resolveResponsesWebSocketMode(
+    process.env.OPENAI_RESPONSES_WEBSOCKET_MODE,
+    "auto"
+  );
+  return openAiResponsesWebSocketMode;
+}
+function wrapFallbackStream(stream) {
+  return {
+    async *[Symbol.asyncIterator]() {
+      for await (const event of stream) {
+        yield event;
+      }
+    },
+    async finalResponse() {
+      return await stream.finalResponse();
+    },
+    close() {
+      const maybeClose = stream;
+      if (typeof maybeClose.close === "function") {
+        maybeClose.close();
+      }
+    }
+  };
+}
+function buildOpenAiResponsesEndpointUrl() {
+  const base = resolveOpenAiBaseUrl();
+  const normalized = base.endsWith("/") ? base : `${base}/`;
+  return new URL("responses", normalized).toString();
+}
+function buildOpenAiResponsesWebSocketHeaders(apiKey) {
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "OpenAI-Beta": mergeOpenAiBetaHeader(
+      process.env.OPENAI_BETA,
+      OPENAI_BETA_RESPONSES_WEBSOCKETS_V2
+    )
+  };
+  const organization = process.env.OPENAI_ORGANIZATION?.trim();
+  if (organization) {
+    headers["OpenAI-Organization"] = organization;
+  }
+  const project = process.env.OPENAI_PROJECT?.trim();
+  if (project) {
+    headers["OpenAI-Project"] = project;
+  }
+  return headers;
+}
+function installResponsesWebSocketTransport(client, apiKey) {
+  const responsesApi = client.responses;
+  const streamMethod = responsesApi?.stream;
+  if (typeof streamMethod !== "function") {
+    return;
+  }
+  const originalStream = streamMethod.bind(client.responses);
+  responsesApi.stream = (request, options) => {
+    const mode = resolveOpenAiResponsesWebSocketMode();
+    const fallbackStreamFactory = () => wrapFallbackStream(originalStream(request, options));
+    if (mode === "off" || openAiResponsesWebSocketDisabled) {
+      return fallbackStreamFactory();
+    }
+    const signal = options && typeof options === "object" ? options.signal ?? void 0 : void 0;
+    const websocketUrl = toWebSocketUrl(buildOpenAiResponsesEndpointUrl());
+    const headers = buildOpenAiResponsesWebSocketHeaders(apiKey);
+    const timeoutMs = resolveOpenAiTimeoutMs();
+    return createAdaptiveResponsesStream({
+      mode,
+      createWebSocketStream: async () => await createResponsesWebSocketStream({
+        url: websocketUrl,
+        headers,
+        request,
+        signal,
+        idleTimeoutMs: timeoutMs
+      }),
+      createFallbackStream: fallbackStreamFactory,
+      onWebSocketFallback: (error) => {
+        if (isResponsesWebSocketUnsupportedError(error)) {
+          openAiResponsesWebSocketDisabled = true;
+        }
+      }
+    });
+  };
+}
 function getOpenAiApiKey() {
   if (cachedApiKey2 !== null) {
     return cachedApiKey2;
@@ -1510,6 +2227,7 @@ function getOpenAiClient() {
   if (cachedClient2) {
     return cachedClient2;
   }
+  loadLocalEnv();
   const apiKey = getOpenAiApiKey();
   const timeoutMs = resolveOpenAiTimeoutMs();
   cachedClient2 = new OpenAI2({
@@ -1517,6 +2235,7 @@ function getOpenAiClient() {
     fetch: getOpenAiFetch(),
     timeout: timeoutMs
   });
+  installResponsesWebSocketTransport(cachedClient2, apiKey);
   return cachedClient2;
 }
 
@@ -3090,6 +3809,7 @@ function extractFireworksToolCalls(message) {
 function resolveGeminiThinkingConfig(modelId) {
   switch (modelId) {
     case "gemini-3-pro-preview":
+    case "gemini-3.1-pro-preview":
       return { includeThoughts: true };
     case "gemini-3-flash-preview":
       return { includeThoughts: true, thinkingBudget: 16384 };
@@ -6489,6 +7209,7 @@ export {
   CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_LARK_GRAMMAR,
   FIREWORKS_DEFAULT_GLM_MODEL,
+  FIREWORKS_DEFAULT_GPT_OSS_120B_MODEL,
   FIREWORKS_DEFAULT_KIMI_MODEL,
   FIREWORKS_DEFAULT_MINIMAX_MODEL,
   FIREWORKS_MODEL_IDS,