vforclaude2 0.3.87

package/open-sse/handlers/chatCore.js

@@ -0,0 +1,213 @@
+import { detectFormat, getTargetFormat } from "../services/provider.js";
+import { translateRequest } from "../translator/index.js";
+import { FORMATS } from "../translator/formats.js";
+import { COLORS } from "../utils/stream.js";
+import { createStreamController } from "../utils/streamHandler.js";
+import { refreshWithRetry } from "../services/tokenRefresh.js";
+import { createRequestLogger } from "../utils/requestLogger.js";
+import { getModelTargetFormat, PROVIDER_ID_TO_ALIAS } from "../config/providerModels.js";
+import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
+import { HTTP_STATUS } from "../config/runtimeConfig.js";
+import { handleBypassRequest } from "../utils/bypassHandler.js";
+import { trackPendingRequest, appendRequestLog, saveRequestDetail } from "@/lib/usageDb.js";
+import { getExecutor } from "../executors/index.js";
+import { buildRequestDetail, extractRequestConfig } from "./chatCore/requestDetail.js";
+import { handleForcedSSEToJson } from "./chatCore/sseToJsonHandler.js";
+import { handleNonStreamingResponse } from "./chatCore/nonStreamingHandler.js";
+import { handleStreamingResponse, buildOnStreamComplete } from "./chatCore/streamingHandler.js";
+
+/**
+ * Core chat handler - shared between SSE and Worker
+ * @param {object} options.body - Request body
+ * @param {object} options.modelInfo - { provider, model }
+ * @param {object} options.credentials - Provider credentials
+ * @param {string} options.sourceFormatOverride - Override detected source format (e.g. "openai-responses")
+ */
+export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, sourceFormatOverride }) {
+  const { provider, model } = modelInfo;
+  const requestStartTime = Date.now();
+
+  const sourceFormat = sourceFormatOverride || detectFormat(body);
+
+  // Check for bypass patterns (warmup, skip, cc naming)
+  const bypassResponse = handleBypassRequest(body, model, userAgent, ccFilterNaming);
+  if (bypassResponse) return bypassResponse;
+
+  const alias = PROVIDER_ID_TO_ALIAS[provider] || provider;
+  const modelTargetFormat = getModelTargetFormat(alias, model);
+  const targetFormat = modelTargetFormat || getTargetFormat(provider);
+
+  const clientRequestedStreaming = body.stream === true || sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI || sourceFormat === FORMATS.GEMINI_CLI;
+  const providerRequiresStreaming = provider === "openai" || provider === "codex";
+  let stream = providerRequiresStreaming ? true : (body.stream !== false);
+
+  // Check client Accept header preference for non-streaming requests
+  // This fixes AI SDK compatibility where clients send Accept: application/json
+  const acceptHeader = clientRawRequest?.headers?.accept || "";
+  const clientPrefersJson = acceptHeader.includes("application/json");
+  const clientPrefersSSE = acceptHeader.includes("text/event-stream");
+  if (clientPrefersJson && !clientPrefersSSE && body.stream !== true) {
+    stream = false;
+  }
+
+  const reqLogger = await createRequestLogger(sourceFormat, targetFormat, model);
+  if (clientRawRequest) reqLogger.logClientRawRequest(clientRawRequest.endpoint, clientRawRequest.body, clientRawRequest.headers);
+  reqLogger.logRawRequest(body);
+  log?.debug?.("FORMAT", `${sourceFormat} → ${targetFormat} | stream=${stream}`);
+
+  let translatedBody = translateRequest(sourceFormat, targetFormat, model, body, stream, credentials, provider, reqLogger);
+  if (!translatedBody) {
+    trackPendingRequest(model, provider, connectionId, false, true);
+    return createErrorResult(HTTP_STATUS.BAD_REQUEST, `Failed to translate request for ${sourceFormat} → ${targetFormat}`);
+  }
+  const toolNameMap = translatedBody._toolNameMap;
+  delete translatedBody._toolNameMap;
+  translatedBody.model = model;
+
+  const executor = getExecutor(provider);
+  trackPendingRequest(model, provider, connectionId, true);
+  appendRequestLog({ model, provider, connectionId, status: "PENDING" }).catch(() => {});
+
+  const msgCount = translatedBody.messages?.length || translatedBody.input?.length || translatedBody.contents?.length || translatedBody.request?.contents?.length || 0;
+  log?.debug?.("REQUEST", `${provider.toUpperCase()} | ${model} | ${msgCount} msgs`);
+
+  const streamController = createStreamController({
+    onDisconnect: (reason) => {
+      trackPendingRequest(model, provider, connectionId, false);
+      if (onDisconnect) onDisconnect(reason);
+    },
+    onError: () => trackPendingRequest(model, provider, connectionId, false),
+    log, provider, model
+  });
+
+  const proxyOptions = {
+    connectionProxyEnabled: credentials?.providerSpecificData?.connectionProxyEnabled === true,
+    connectionProxyUrl: credentials?.providerSpecificData?.connectionProxyUrl || "",
+    connectionNoProxy: credentials?.providerSpecificData?.connectionNoProxy || "",
+  };
+
+  if (proxyOptions.connectionProxyEnabled && proxyOptions.connectionProxyUrl) {
+    let maskedProxyUrl = proxyOptions.connectionProxyUrl;
+    try {
+      const parsed = new URL(proxyOptions.connectionProxyUrl);
+      const host = parsed.hostname || "";
+      const port = parsed.port ? `:${parsed.port}` : "";
+      const protocol = parsed.protocol || "http:";
+      maskedProxyUrl = `${protocol}//${host}${port}`;
+    } catch {
+      // Keep raw if URL parsing fails
+    }
+
+    const poolId = credentials?.providerSpecificData?.connectionProxyPoolId || "none";
+    const connectionName = credentials?.connectionName || credentials?.connectionId || "unknown";
+    log?.info?.("PROXY", `${provider.toUpperCase()} | ${model} | conn=${connectionName} | pool=${poolId} | url=${maskedProxyUrl}`);
+  }
+
+  if (proxyOptions.connectionProxyEnabled && proxyOptions.connectionNoProxy) {
+    const connectionName = credentials?.connectionName || credentials?.connectionId || "unknown";
+    log?.debug?.("PROXY", `${provider.toUpperCase()} | ${model} | conn=${connectionName} | no_proxy=${proxyOptions.connectionNoProxy}`);
+  }
+
+  // Execute request
+  let providerResponse, providerUrl, providerHeaders, finalBody;
+  try {
+    const result = await executor.execute({ model, body: translatedBody, stream, credentials, signal: streamController.signal, log, proxyOptions });
+    providerResponse = result.response;
+    providerUrl = result.url;
+    providerHeaders = result.headers;
+    finalBody = result.transformedBody;
+    reqLogger.logTargetRequest(providerUrl, providerHeaders, finalBody);
+  } catch (error) {
+    trackPendingRequest(model, provider, connectionId, false, true);
+    appendRequestLog({ model, provider, connectionId, status: `FAILED ${error.name === "AbortError" ? 499 : HTTP_STATUS.BAD_GATEWAY}` }).catch(() => {});
+    saveRequestDetail(buildRequestDetail({
+      provider, model, connectionId,
+      latency: { ttft: 0, total: Date.now() - requestStartTime },
+      tokens: { prompt_tokens: 0, completion_tokens: 0 },
+      request: extractRequestConfig(body, stream),
+      providerRequest: translatedBody || null,
+      response: { error: error.message || String(error), status: error.name === "AbortError" ? 499 : 502, thinking: null },
+      status: "error"
+    })).catch(() => {});
+
+    if (error.name === "AbortError") {
+      streamController.handleError(error);
+      return createErrorResult(499, "Request aborted");
+    }
+    const errMsg = formatProviderError(error, provider, model, HTTP_STATUS.BAD_GATEWAY);
+    console.log(`${COLORS.red}[ERROR] ${errMsg}${COLORS.reset}`);
+    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, errMsg);
+  }
+
+  // Handle 401/403 - try token refresh
+  if (providerResponse.status === HTTP_STATUS.UNAUTHORIZED || providerResponse.status === HTTP_STATUS.FORBIDDEN) {
+    try {
+      const newCredentials = await refreshWithRetry(() => executor.refreshCredentials(credentials, log), 3, log);
+      if (newCredentials?.accessToken || newCredentials?.copilotToken) {
+        log?.info?.("TOKEN", `${provider.toUpperCase()} | refreshed`);
+        Object.assign(credentials, newCredentials);
+        if (onCredentialsRefreshed) {
+          try { await onCredentialsRefreshed(newCredentials); } catch (e) { log?.warn?.("TOKEN", `onCredentialsRefreshed failed: ${e.message}`); }
+        }
+        try {
+          const retryResult = await executor.execute({ model, body: translatedBody, stream, credentials, signal: streamController.signal, log, proxyOptions });
+          if (retryResult.response.ok) { providerResponse = retryResult.response; providerUrl = retryResult.url; }
+        } catch { log?.warn?.("TOKEN", `${provider.toUpperCase()} | retry after refresh failed`); }
+      } else {
+        log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh failed`);
+      }
+    } catch (e) {
+      log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh threw: ${e.message}`);
+    }
+  }
+
+  // Provider returned error
+  if (!providerResponse.ok) {
+    trackPendingRequest(model, provider, connectionId, false, true);
+    const { statusCode, message, retryAfterMs } = await parseUpstreamError(providerResponse, provider);
+    appendRequestLog({ model, provider, connectionId, status: `FAILED ${statusCode}` }).catch(() => {});
+    saveRequestDetail(buildRequestDetail({
+      provider, model, connectionId,
+      latency: { ttft: 0, total: Date.now() - requestStartTime },
+      tokens: { prompt_tokens: 0, completion_tokens: 0 },
+      request: extractRequestConfig(body, stream),
+      providerRequest: finalBody || translatedBody || null,
+      response: { error: message, status: statusCode, thinking: null },
+      status: "error"
+    })).catch(() => {});
+
+    const errMsg = formatProviderError(new Error(message), provider, model, statusCode);
+    console.log(`${COLORS.red}[ERROR] ${errMsg}${COLORS.reset}`);
+    if (retryAfterMs && provider === "antigravity") {
+      log?.debug?.("RETRY", `Antigravity quota reset in ${Math.ceil(retryAfterMs / 1000)}s`);
+    }
+    reqLogger.logError(new Error(message), finalBody || translatedBody);
+    return createErrorResult(statusCode, errMsg, retryAfterMs);
+  }
+
+  const sharedCtx = { provider, model, body, stream, translatedBody, finalBody, requestStartTime, connectionId, apiKey, clientRawRequest, onRequestSuccess };
+  const appendLog = (extra) => appendRequestLog({ model, provider, connectionId, ...extra }).catch(() => {});
+  const trackDone = () => trackPendingRequest(model, provider, connectionId, false);
+
+  // Provider forced streaming but client wants JSON
+  if (!clientRequestedStreaming && providerRequiresStreaming) {
+    const result = await handleForcedSSEToJson({ ...sharedCtx, providerResponse, sourceFormat, trackDone, appendLog });
+    if (result) { streamController.handleComplete(); return result; }
+  }
+
+  // True non-streaming response
+  if (!stream) {
+    const result = await handleNonStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat, reqLogger, trackDone, appendLog });
+    streamController.handleComplete();
+    return result;
+  }
+
+  // Streaming response
+  const { onStreamComplete } = buildOnStreamComplete({ ...sharedCtx });
+  return handleStreamingResponse({ ...sharedCtx, providerResponse, sourceFormat, targetFormat, userAgent, reqLogger, toolNameMap, streamController, onStreamComplete });
+}
+
+export function isTokenExpiringSoon(expiresAt, bufferMs = 5 * 60 * 1000) {
+  if (!expiresAt) return false;
+  return new Date(expiresAt).getTime() - Date.now() < bufferMs;
+}

package/open-sse/handlers/embeddingsCore.js

@@ -0,0 +1,302 @@
+import { getModelTargetFormat, PROVIDER_ID_TO_ALIAS } from "../config/providerModels.js";
+import { createErrorResult, parseUpstreamError, formatProviderError } from "../utils/error.js";
+import { HTTP_STATUS } from "../config/runtimeConfig.js";
+import { getExecutor } from "../executors/index.js";
+import { refreshWithRetry } from "../services/tokenRefresh.js";
+
+// Google AI (Gemini) provider aliases / identifiers
+const GEMINI_PROVIDERS = new Set(["gemini", "google_ai_studio"]);
+
+/**
+ * Check whether a provider targets the Google AI (Gemini) embeddings API.
+ * @param {string} provider
+ */
+function isGeminiProvider(provider) {
+  return GEMINI_PROVIDERS.has(provider);
+}
+
+/**
+ * Build the embeddings request body for the target provider.
+ *
+ * - OpenAI / openai-compatible / openrouter: standard { model, input } format.
+ * - Google AI (Gemini): different format per API spec.
+ *   - Single input  → embedContent  body: { model, content: { parts: [{ text }] } }
+ *   - Batch input   → batchEmbedContents body: { requests: [{ model, content: { parts: [{ text }] } }] }
+ */
+function buildEmbeddingsBody(provider, model, input, encodingFormat) {
+  if (isGeminiProvider(provider)) {
+    // Normalize model name: Gemini API expects "models/<model>" prefix
+    const geminiModel = model.startsWith("models/") ? model : `models/${model}`;
+
+    if (Array.isArray(input)) {
+      // Batch request
+      return {
+        requests: input.map((text) => ({
+          model: geminiModel,
+          content: { parts: [{ text: String(text) }] }
+        }))
+      };
+    } else {
+      // Single request
+      return {
+        model: geminiModel,
+        content: { parts: [{ text: String(input) }] }
+      };
+    }
+  }
+
+  // Default: OpenAI format
+  const body = { model, input };
+  if (encodingFormat) {
+    body.encoding_format = encodingFormat;
+  }
+  return body;
+}
+
+/**
+ * Build the URL for the embeddings endpoint based on the provider.
+ * @param {string} provider
+ * @param {string} model
+ * @param {object} credentials
+ * @param {string|string[]} input - used to select single vs batch endpoint for Gemini
+ */
+function buildEmbeddingsUrl(provider, model, credentials, input) {
+  if (isGeminiProvider(provider)) {
+    const apiKey = credentials.apiKey || credentials.accessToken;
+    // Normalize model name for URL path
+    const modelPath = model.startsWith("models/") ? model : `models/${model}`;
+
+    if (Array.isArray(input)) {
+      // batchEmbedContents for array input (keeps response format consistent even for length=1)
+      return `https://generativelanguage.googleapis.com/v1beta/${modelPath}:batchEmbedContents?key=${encodeURIComponent(apiKey)}`;
+    }
+    return `https://generativelanguage.googleapis.com/v1beta/${modelPath}:embedContent?key=${encodeURIComponent(apiKey)}`;
+  }
+
+  switch (provider) {
+    case "openai":
+      return "https://api.openai.com/v1/embeddings";
+    case "openrouter":
+      return "https://openrouter.ai/api/v1/embeddings";
+    default:
+      // openai-compatible providers: use their baseUrl + /embeddings
+      if (provider?.startsWith?.("openai-compatible-")) {
+        const baseUrl = credentials?.providerSpecificData?.baseUrl || "https://api.openai.com/v1";
+        return `${baseUrl.replace(/\/$/, "")}/embeddings`;
+      }
+      // For other providers, attempt to use their base URL pattern with /embeddings path
+      return null;
+  }
+}
+
+/**
+ * Build headers for the embeddings request.
+ */
+function buildEmbeddingsHeaders(provider, credentials) {
+  const headers = { "Content-Type": "application/json" };
+
+  if (isGeminiProvider(provider)) {
+    // Gemini API uses API key as query param — no Authorization header needed
+    return headers;
+  }
+
+  switch (provider) {
+    case "openai":
+    case "openrouter":
+      headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
+      if (provider === "openrouter") {
+        headers["HTTP-Referer"] = "https://endpoint-proxy.local";
+        headers["X-Title"] = "Endpoint Proxy";
+      }
+      break;
+    default:
+      headers["Authorization"] = `Bearer ${credentials.apiKey || credentials.accessToken}`;
+  }
+
+  return headers;
+}
+
+/**
+ * Normalize the embeddings response to OpenAI format.
+ *
+ * Gemini single response:
+ *   { embedding: { values: [0.1, 0.2, ...] } }
+ *
+ * Gemini batch response:
+ *   { embeddings: [{ values: [...] }, ...] }
+ *
+ * Target OpenAI format:
+ *   { object: "list", data: [{ object: "embedding", index: 0, embedding: [...] }], model, usage: {...} }
+ */
+function normalizeEmbeddingsResponse(responseBody, model, provider) {
+  // Already in OpenAI format
+  if (responseBody.object === "list" && Array.isArray(responseBody.data)) {
+    return responseBody;
+  }
+
+  if (isGeminiProvider(provider)) {
+    let embeddingItems = [];
+
+    if (Array.isArray(responseBody.embeddings)) {
+      // Batch response
+      embeddingItems = responseBody.embeddings.map((emb, idx) => ({
+        object: "embedding",
+        index: idx,
+        embedding: emb.values || []
+      }));
+    } else if (responseBody.embedding?.values) {
+      // Single response
+      embeddingItems = [{
+        object: "embedding",
+        index: 0,
+        embedding: responseBody.embedding.values
+      }];
+    }
+
+    return {
+      object: "list",
+      data: embeddingItems,
+      model,
+      usage: {
+        prompt_tokens: 0,
+        total_tokens: 0
+      }
+    };
+  }
+
+  // Try to handle alternate formats gracefully
+  return responseBody;
+}
+
+/**
+ * Core embeddings handler — shared between Worker and SSE server.
+ *
+ * @param {object} options
+ * @param {object} options.body - Parsed request body { model, input, encoding_format }
+ * @param {object} options.modelInfo - { provider, model }
+ * @param {object} options.credentials - Provider credentials
+ * @param {object} [options.log] - Logger
+ * @param {function} [options.onCredentialsRefreshed] - Called when creds are refreshed
+ * @param {function} [options.onRequestSuccess] - Called on success (clear error state)
+ * @returns {Promise<{ success: boolean, response: Response, status?: number, error?: string }>}
+ */
+export async function handleEmbeddingsCore({
+  body,
+  modelInfo,
+  credentials,
+  log,
+  onCredentialsRefreshed,
+  onRequestSuccess
+}) {
+  const { provider, model } = modelInfo;
+
+  // Validate input
+  const input = body.input;
+  if (!input) {
+    return createErrorResult(HTTP_STATUS.BAD_REQUEST, "Missing required field: input");
+  }
+  if (typeof input !== "string" && !Array.isArray(input)) {
+    return createErrorResult(HTTP_STATUS.BAD_REQUEST, "input must be a string or array of strings");
+  }
+
+  const encodingFormat = body.encoding_format || "float";
+
+  // Determine embeddings URL
+  const url = buildEmbeddingsUrl(provider, model, credentials, input);
+  if (!url) {
+    return createErrorResult(
+      HTTP_STATUS.BAD_REQUEST,
+      `Provider '${provider}' does not support embeddings. Use openai, openrouter, gemini, or an openai-compatible provider.`
+    );
+  }
+
+  const headers = buildEmbeddingsHeaders(provider, credentials);
+  const requestBody = buildEmbeddingsBody(provider, model, input, encodingFormat);
+
+  log?.debug?.("EMBEDDINGS", `${provider.toUpperCase()} | ${model} | input_type=${Array.isArray(input) ? `array[${input.length}]` : "string"}`);
+
+  let providerResponse;
+  try {
+    providerResponse = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody)
+    });
+  } catch (error) {
+    const errMsg = formatProviderError(error, provider, model, HTTP_STATUS.BAD_GATEWAY);
+    log?.debug?.("EMBEDDINGS", `Fetch error: ${errMsg}`);
+    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, errMsg);
+  }
+
+  // Handle 401/403 — try token refresh
+  if (
+    providerResponse.status === HTTP_STATUS.UNAUTHORIZED ||
+    providerResponse.status === HTTP_STATUS.FORBIDDEN
+  ) {
+    const executor = getExecutor(provider);
+    const newCredentials = await refreshWithRetry(
+      () => executor.refreshCredentials(credentials, log),
+      3,
+      log
+    );
+
+    if (newCredentials?.accessToken || newCredentials?.apiKey) {
+      log?.info?.("TOKEN", `${provider.toUpperCase()} | refreshed for embeddings`);
+      Object.assign(credentials, newCredentials);
+      if (onCredentialsRefreshed && newCredentials) {
+        await onCredentialsRefreshed(newCredentials);
+      }
+
+      // Retry with refreshed credentials
+      try {
+        const retryHeaders = buildEmbeddingsHeaders(provider, credentials);
+        // Rebuild URL for Gemini since API key is embedded in query param
+        const retryUrl = isGeminiProvider(provider)
+          ? buildEmbeddingsUrl(provider, model, credentials, input)
+          : url;
+
+        providerResponse = await fetch(retryUrl, {
+          method: "POST",
+          headers: retryHeaders,
+          body: JSON.stringify(requestBody)
+        });
+      } catch (retryError) {
+        log?.warn?.("TOKEN", `${provider.toUpperCase()} | retry after refresh failed`);
+      }
+    } else {
+      log?.warn?.("TOKEN", `${provider.toUpperCase()} | refresh failed`);
+    }
+  }
+
+  if (!providerResponse.ok) {
+    const { statusCode, message } = await parseUpstreamError(providerResponse, provider);
+    const errMsg = formatProviderError(new Error(message), provider, model, statusCode);
+    log?.debug?.("EMBEDDINGS", `Provider error: ${errMsg}`);
+    return createErrorResult(statusCode, errMsg);
+  }
+
+  let responseBody;
+  try {
+    responseBody = await providerResponse.json();
+  } catch (parseError) {
+    return createErrorResult(HTTP_STATUS.BAD_GATEWAY, `Invalid JSON response from ${provider}`);
+  }
+
+  if (onRequestSuccess) {
+    await onRequestSuccess();
+  }
+
+  const normalized = normalizeEmbeddingsResponse(responseBody, model, provider);
+
+  log?.debug?.("EMBEDDINGS", `Success | usage=${JSON.stringify(normalized.usage || {})}`);
+
+  return {
+    success: true,
+    response: new Response(JSON.stringify(normalized), {
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*"
+      }
+    })
+  };
+}

package/open-sse/handlers/responsesHandler.js

@@ -0,0 +1,103 @@
+/**
+ * Responses API Handler for Workers
+ * Converts Chat Completions to Codex Responses API format
+ */
+
+import { handleChatCore } from "./chatCore.js";
+import { convertResponsesApiFormat } from "../translator/helpers/responsesApiHelper.js";
+import { createResponsesApiTransformStream } from "../transformer/responsesTransformer.js";
+import { convertResponsesStreamToJson } from "../transformer/streamToJsonConverter.js";
+
+/**
+ * Handle /v1/responses request
+ * @param {object} options
+ * @param {object} options.body - Request body (Responses API format)
+ * @param {object} options.modelInfo - { provider, model }
+ * @param {object} options.credentials - Provider credentials
+ * @param {object} options.log - Logger instance (optional)
+ * @param {function} options.onCredentialsRefreshed - Callback when credentials are refreshed
+ * @param {function} options.onRequestSuccess - Callback when request succeeds
+ * @param {function} options.onDisconnect - Callback when client disconnects
+ * @param {string} options.connectionId - Connection ID for usage tracking
+ * @returns {Promise<{success: boolean, response?: Response, status?: number, error?: string}>}
+ */
+export async function handleResponsesCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, connectionId }) {
+  // Convert Responses API format to Chat Completions format
+  const convertedBody = convertResponsesApiFormat(body);
+
+  // Preserve client's stream preference (matches OpenClaw behavior)
+  // Default to false if omitted: Boolean(undefined) = false
+  const clientRequestedStreaming = convertedBody.stream === true;
+  if (convertedBody.stream === undefined) {
+    convertedBody.stream = false;
+  }
+
+  // Call chat core handler — force sourceFormat so streaming path knows this is a Responses API client
+  const result = await handleChatCore({
+    body: convertedBody,
+    modelInfo,
+    credentials,
+    log,
+    onCredentialsRefreshed,
+    onRequestSuccess,
+    onDisconnect,
+    connectionId,
+    sourceFormatOverride: "openai-responses"
+  });
+
+  if (!result.success || !result.response) {
+    return result;
+  }
+
+  const response = result.response;
+  const contentType = response.headers.get("Content-Type") || "";
+
+  // Case 1: Client wants non-streaming, but got SSE (provider forced it, e.g., Codex)
+  if (!clientRequestedStreaming && contentType.includes("text/event-stream")) {
+    try {
+      const jsonResponse = await convertResponsesStreamToJson(response.body);
+
+      return {
+        success: true,
+        response: new Response(JSON.stringify(jsonResponse), {
+          status: 200,
+          headers: {
+            "Content-Type": "application/json",
+            "Cache-Control": "no-cache",
+            "Access-Control-Allow-Origin": "*"
+          }
+        })
+      };
+    } catch (error) {
+      console.error("[Responses API] Stream-to-JSON conversion failed:", error);
+      return {
+        success: false,
+        status: 500,
+        error: "Failed to convert streaming response to JSON"
+      };
+    }
+  }
+
+  // Case 2: Client wants streaming, got SSE - transform it
+  if (clientRequestedStreaming && contentType.includes("text/event-stream")) {
+    const transformStream = createResponsesApiTransformStream(null);
+    const transformedBody = response.body.pipeThrough(transformStream);
+
+    return {
+      success: true,
+      response: new Response(transformedBody, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        }
+      })
+    };
+  }
+
+  // Case 3: Non-SSE response (error or non-streaming from provider) - return as-is
+  return result;
+}
+

package/open-sse/index.js

@@ -0,0 +1,74 @@
+// Patch global fetch with proxy support (must be first)
+import "./utils/proxyFetch.js";
+
+// Config
+export { PROVIDERS } from "./config/providers.js";
+export { OAUTH_ENDPOINTS, CLAUDE_SYSTEM_PROMPT } from "./config/appConstants.js";
+export { CACHE_TTL, DEFAULT_MAX_TOKENS, COOLDOWN_MS, BACKOFF_CONFIG } from "./config/runtimeConfig.js";
+export { 
+  PROVIDER_MODELS, 
+  getProviderModels,
+  getDefaultModel, 
+  isValidModel,
+  findModelName,
+  getModelTargetFormat,
+  PROVIDER_ID_TO_ALIAS,
+  getModelsByProviderId
+} from "./config/providerModels.js";
+
+// Translator
+export { FORMATS } from "./translator/formats.js";
+export { 
+  register, 
+  translateRequest, 
+  translateResponse, 
+  needsTranslation, 
+  initState, 
+  initTranslators 
+} from "./translator/index.js";
+
+// Services
+export { 
+  detectFormat, 
+  getProviderConfig, 
+  buildProviderUrl, 
+  buildProviderHeaders, 
+  getTargetFormat 
+} from "./services/provider.js";
+
+export { parseModel, resolveModelAliasFromMap, getModelInfoCore } from "./services/model.js";
+
+export {
+  checkFallbackError,
+  isAccountUnavailable,
+  getUnavailableUntil,
+  filterAvailableAccounts
+} from "./services/accountFallback.js";
+
+export {
+  TOKEN_EXPIRY_BUFFER_MS,
+  refreshAccessToken,
+  refreshClaudeOAuthToken,
+  refreshGoogleToken,
+  refreshQwenToken,
+  refreshCodexToken,
+  refreshIflowToken,
+  refreshGitHubToken,
+  refreshCopilotToken,
+  getAccessToken,
+  refreshTokenByProvider
+} from "./services/tokenRefresh.js";
+
+// Handlers
+export { handleChatCore, isTokenExpiringSoon } from "./handlers/chatCore.js";
+export { createStreamController, pipeWithDisconnect, createDisconnectAwareStream } from "./utils/streamHandler.js";
+
+// Executors
+export { getExecutor, hasSpecializedExecutor } from "./executors/index.js";
+
+// Utils
+export { errorResponse, formatProviderError } from "./utils/error.js";
+export { 
+  createSSETransformStreamWithLogger, 
+  createPassthroughStreamWithLogger 
+} from "./utils/stream.js";