@khanglvm/llm-router 1.1.1 → 1.3.0

package/src/runtime/handler/provider-call.js

@@ -17,6 +17,11 @@ import { resolveUpstreamTimeoutMs } from "./request.js";
 import { parseJsonSafely } from "./utils.js";
 import { buildTimeoutSignal } from "../../shared/timeout-signal.js";
 import { isSubscriptionProvider, makeSubscriptionProviderCall } from "../subscription-provider.js";
+import {
+  convertCodexResponseToOpenAIChatCompletion,
+  extractCodexFinalResponse,
+  handleCodexStreamToOpenAI
+} from "../codex-response-transformer.js";
 
 async function toProviderError(response) {
   const raw = await response.text();
@@ -65,6 +70,120 @@ export async function buildFailureResponse(result) {
   }, fallbackStatus);
 }
 
+async function adaptProviderResponse({
+  response,
+  stream,
+  translate,
+  sourceFormat,
+  targetFormat,
+  fallbackModel
+}) {
+  if (stream) {
+    if (!translate) {
+      return {
+        ok: true,
+        status: 200,
+        retryable: false,
+        response: passthroughResponseWithCors(response, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        })
+      };
+    }
+
+    if (sourceFormat === FORMATS.CLAUDE && targetFormat === FORMATS.OPENAI) {
+      return {
+        ok: true,
+        status: 200,
+        retryable: false,
+        response: handleOpenAIStreamToClaude(response)
+      };
+    }
+
+    if (sourceFormat === FORMATS.OPENAI && targetFormat === FORMATS.CLAUDE) {
+      return {
+        ok: true,
+        status: 200,
+        retryable: false,
+        response: handleClaudeStreamToOpenAI(response)
+      };
+    }
+
+    return {
+      ok: false,
+      status: 501,
+      retryable: false,
+      errorKind: "not_supported_error",
+      response: jsonResponse({
+        type: "error",
+        error: {
+          type: "not_supported_error",
+          message: `Streaming translation from ${targetFormat} to ${sourceFormat} is not implemented.`
+        }
+      }, 501)
+    };
+  }
+
+  if (!translate) {
+    return {
+      ok: true,
+      status: 200,
+      retryable: false,
+      response: passthroughResponseWithCors(response)
+    };
+  }
+
+  const raw = await response.text();
+  const parsed = parseJsonSafely(raw);
+  if (!parsed) {
+    return {
+      ok: false,
+      status: 502,
+      retryable: true,
+      response: jsonResponse({
+        type: "error",
+        error: {
+          type: "api_error",
+          message: "Provider returned invalid JSON."
+        }
+      }, 502)
+    };
+  }
+
+  if (sourceFormat === FORMATS.CLAUDE && targetFormat === FORMATS.OPENAI) {
+    return {
+      ok: true,
+      status: 200,
+      retryable: false,
+      response: jsonResponse(convertOpenAINonStreamToClaude(parsed, fallbackModel))
+    };
+  }
+
+  if (sourceFormat === FORMATS.OPENAI && targetFormat === FORMATS.CLAUDE) {
+    return {
+      ok: true,
+      status: 200,
+      retryable: false,
+      response: jsonResponse(claudeToOpenAINonStreamResponse(parsed))
+    };
+  }
+
+  return {
+    ok: false,
+    status: 501,
+    retryable: false,
+    errorKind: "not_supported_error",
+    response: jsonResponse({
+      type: "error",
+      error: {
+        type: "not_supported_error",
+        message: `Non-stream translation from ${targetFormat} to ${sourceFormat} is not implemented.`
+      }
+    }, 501)
+  };
+}
+
 export async function makeProviderCall({
   body,
   sourceFormat,
@@ -115,12 +234,100 @@ export async function makeProviderCall({
   });
 
   if (isSubscriptionProvider(provider)) {
-    return makeSubscriptionProviderCall({
+    const subscriptionType = String(provider?.subscriptionType || provider?.subscription_type || "").trim().toLowerCase();
+    const subscriptionResult = await makeSubscriptionProviderCall({
       provider,
       body: providerBody,
-      stream,
+      // ChatGPT Codex backend expects stream=true; non-stream responses are reconstructed from SSE.
+      stream: subscriptionType === "chatgpt-codex" ? true : Boolean(stream),
       env
     });
+
+    if (!subscriptionResult?.ok) {
+      return subscriptionResult;
+    }
+
+    if (!(subscriptionResult.response instanceof Response)) {
+      return {
+        ok: false,
+        status: 502,
+        retryable: true,
+        response: jsonResponse({
+          type: "error",
+          error: {
+            type: "api_error",
+            message: "Subscription provider returned an invalid response."
+          }
+        }, 502)
+      };
+    }
+
+    const fallbackModel = candidate?.backend || providerBody?.model || "unknown";
+    if (subscriptionType !== "chatgpt-codex") {
+      return adaptProviderResponse({
+        response: subscriptionResult.response,
+        stream,
+        translate,
+        sourceFormat,
+        targetFormat,
+        fallbackModel
+      });
+    }
+
+    if (stream) {
+      const openAIStreamResponse = handleCodexStreamToOpenAI(subscriptionResult.response, {
+        fallbackModel
+      });
+      if (sourceFormat === FORMATS.CLAUDE) {
+        return {
+          ok: true,
+          status: 200,
+          retryable: false,
+          response: handleOpenAIStreamToClaude(openAIStreamResponse)
+        };
+      }
+      return {
+        ok: true,
+        status: 200,
+        retryable: false,
+        response: openAIStreamResponse
+      };
+    }
+
+    const parsedSubscriptionResponse = await extractCodexFinalResponse(subscriptionResult.response);
+    if (!parsedSubscriptionResponse) {
+      return {
+        ok: false,
+        status: 502,
+        retryable: true,
+        response: jsonResponse({
+          type: "error",
+          error: {
+            type: "api_error",
+            message: "Subscription provider stream did not contain a completed response payload."
+          }
+        }, 502)
+      };
+    }
+
+    const openAINonStreamResponse = convertCodexResponseToOpenAIChatCompletion(parsedSubscriptionResponse, {
+      fallbackModel
+    });
+    if (sourceFormat === FORMATS.CLAUDE) {
+      return {
+        ok: true,
+        status: 200,
+        retryable: false,
+        response: jsonResponse(convertOpenAINonStreamToClaude(openAINonStreamResponse, fallbackModel))
+      };
+    }
+
+    return {
+      ok: true,
+      status: 200,
+      retryable: false,
+      response: jsonResponse(openAINonStreamResponse)
+    };
   }
 
   const providerUrl = resolveProviderUrl(provider, targetFormat);
@@ -192,108 +399,12 @@ export async function makeProviderCall({
     };
   }
 
-  if (stream) {
-    if (!translate) {
-      return {
-        ok: true,
-        status: 200,
-        retryable: false,
-        response: passthroughResponseWithCors(response, {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        })
-      };
-    }
-
-    if (sourceFormat === FORMATS.CLAUDE && targetFormat === FORMATS.OPENAI) {
-      return {
-        ok: true,
-        status: 200,
-        retryable: false,
-        response: handleOpenAIStreamToClaude(response)
-      };
-    }
-
-    if (sourceFormat === FORMATS.OPENAI && targetFormat === FORMATS.CLAUDE) {
-      return {
-        ok: true,
-        status: 200,
-        retryable: false,
-        response: handleClaudeStreamToOpenAI(response)
-      };
-    }
-
-    return {
-      ok: false,
-      status: 501,
-      retryable: false,
-      errorKind: "not_supported_error",
-      response: jsonResponse({
-        type: "error",
-        error: {
-          type: "not_supported_error",
-          message: `Streaming translation from ${targetFormat} to ${sourceFormat} is not implemented.`
-        }
-      }, 501)
-    };
-  }
-
-  if (!translate) {
-    return {
-      ok: true,
-      status: 200,
-      retryable: false,
-      response: passthroughResponseWithCors(response)
-    };
-  }
-
-  const raw = await response.text();
-  const parsed = parseJsonSafely(raw);
-  if (!parsed) {
-    return {
-      ok: false,
-      status: 502,
-      retryable: true,
-      response: jsonResponse({
-        type: "error",
-        error: {
-          type: "api_error",
-          message: "Provider returned invalid JSON."
-        }
-      }, 502)
-    };
-  }
-
-  if (sourceFormat === FORMATS.CLAUDE && targetFormat === FORMATS.OPENAI) {
-    return {
-      ok: true,
-      status: 200,
-      retryable: false,
-      response: jsonResponse(convertOpenAINonStreamToClaude(parsed, candidate.backend))
-    };
-  }
-
-  if (sourceFormat === FORMATS.OPENAI && targetFormat === FORMATS.CLAUDE) {
-    return {
-      ok: true,
-      status: 200,
-      retryable: false,
-      response: jsonResponse(claudeToOpenAINonStreamResponse(parsed))
-    };
-  }
-
-  return {
-    ok: false,
-    status: 501,
-    retryable: false,
-    errorKind: "not_supported_error",
-    response: jsonResponse({
-      type: "error",
-      error: {
-        type: "not_supported_error",
-        message: `Non-stream translation from ${targetFormat} to ${sourceFormat} is not implemented.`
-      }
-    }, 501)
-  };
+  return adaptProviderResponse({
+    response,
+    stream,
+    translate,
+    sourceFormat,
+    targetFormat,
+    fallbackModel: candidate.backend
+  });
 }