Initial commit

src/sse/handlers/chat.js

@@ -0,0 +1,134 @@
+import { getProviderCredentials, markAccountUnavailable, clearAccountError } from "../services/auth.js";
+import { getModelInfo, getComboModels } from "../services/model.js";
+import { handleChatCore } from "open-sse/handlers/chatCore.js";
+import { errorResponse } from "open-sse/utils/error.js";
+import { checkFallbackError } from "open-sse/services/accountFallback.js";
+import { handleComboChat } from "open-sse/services/combo.js";
+import * as log from "../utils/logger.js";
+import { updateProviderCredentials, checkAndRefreshToken } from "../services/tokenRefresh.js";
+
+/**
+ * Handle chat completion request
+ * Supports: OpenAI, Claude, Gemini, OpenAI Responses API formats
+ * Format detection and translation handled by translator
+ */
+export async function handleChat(request, clientRawRequest = null) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    log.warn("CHAT", "Invalid JSON body");
+    return errorResponse(400, "Invalid JSON body");
+  }
+  
+  // Build clientRawRequest for logging (if not provided)
+  if (!clientRawRequest) {
+    const url = new URL(request.url);
+    clientRawRequest = {
+      endpoint: url.pathname,
+      body,
+      headers: Object.fromEntries(request.headers.entries())
+    };
+  }
+
+  // Count messages (support both messages[] and input[] formats)
+  const msgCount = body.messages?.length || body.input?.length || 0;
+  const toolCount = body.tools?.length || 0;
+  log.request("POST", `${body.model} | ${msgCount} msgs${toolCount ? ` | ${toolCount} tools` : ""}`);
+
+  const modelStr = body.model;
+  if (!modelStr) {
+    log.warn("CHAT", "Missing model");
+    return errorResponse(400, "Missing model");
+  }
+
+  // Check if model is a combo (has multiple models with fallback)
+  const comboModels = await getComboModels(modelStr);
+  if (comboModels) {
+    log.info("CHAT", `Combo "${modelStr}" with ${comboModels.length} models`);
+    return handleComboChat({
+      body,
+      models: comboModels,
+      handleSingleModel: (b, m) => handleSingleModelChat(b, m, clientRawRequest),
+      log
+    });
+  }
+
+  // Single model request
+  return handleSingleModelChat(body, modelStr, clientRawRequest);
+}
+
+/**
+ * Handle single model chat request
+ */
+async function handleSingleModelChat(body, modelStr, clientRawRequest = null) {
+  const modelInfo = await getModelInfo(modelStr);
+  if (!modelInfo.provider) {
+    log.warn("CHAT", "Invalid model format", { model: modelStr });
+    return errorResponse(400, "Invalid model format");
+  }
+
+  const { provider, model } = modelInfo;
+
+  // Try with available accounts (fallback on errors)
+  let excludeConnectionId = null;
+  let lastError = null;
+
+  while (true) {
+    const credentials = await getProviderCredentials(provider, excludeConnectionId);
+    if (!credentials) {
+      if (!excludeConnectionId) {
+        return errorResponse(400, `No credentials for provider: ${provider}`);
+      }
+      log.warn("CHAT", "No more accounts available", { provider });
+      return new Response(
+        JSON.stringify({ error: lastError || "All accounts unavailable" }),
+        { status: 503, headers: { "Content-Type": "application/json" } }
+      );
+    }
+
+    log.debug("CHAT", `Using account ${credentials.connectionId} for ${provider}`);
+
+    const refreshedCredentials = await checkAndRefreshToken(provider, credentials);
+    
+    // Use shared chatCore
+    const result = await handleChatCore({
+      body: { ...body, model: `${provider}/${model}` },
+      modelInfo: { provider, model },
+      credentials: refreshedCredentials,
+      log,
+      clientRawRequest,
+      onCredentialsRefreshed: async (newCreds) => {
+        await updateProviderCredentials(credentials.connectionId, {
+          accessToken: newCreds.accessToken,
+          refreshToken: newCreds.refreshToken,
+          providerSpecificData: newCreds.providerSpecificData,
+          testStatus: "active"
+        });
+      },
+      onRequestSuccess: async () => {
+        // Clear error status only if currently has error (optimization)
+        await clearAccountError(credentials.connectionId, credentials);
+      }
+    });
+    
+    if (result.success) return result.response;
+
+    // Check if should fallback to next account
+    const { shouldFallback, cooldownMs } = checkFallbackError(result.status, result.error);
+    
+    if (shouldFallback) {
+      log.warn("CHAT", "Account unavailable, trying next", {
+        provider,
+        connectionId: credentials.connectionId,
+        status: result.status
+      });
+      await markAccountUnavailable(credentials.connectionId, cooldownMs, result.error?.slice(0, 100), result.status, provider);
+      excludeConnectionId = credentials.connectionId;
+      lastError = result.error;
+      continue;
+    }
+
+    return result.response;
+  }
+}