@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/executors/blackbox-web.js

@@ -0,0 +1,578 @@
+import {
+  BaseExecutor,
+  mergeAbortSignals,
+  mergeUpstreamExtraHeaders
+} from "./base.ts";
+import { FETCH_TIMEOUT_MS } from "../config/constants.ts";
+import { normalizeSessionCookieHeader } from '../../dist/lib/providers/webCookieAuth.js';
+import { prepareToolMessages, buildToolAwareResult } from "../translator/webTools.ts";
+const BLACKBOX_CHAT_API = "https://app.blackbox.ai/api/chat";
+const BLACKBOX_DEFAULT_COOKIE = "next-auth.session-token";
+const BLACKBOX_USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
+const SESSION_CACHE_TTL_MS = 5 * 6e4;
+function resolveBlackboxValidatedToken() {
+  const explicit = (process.env.BLACKBOX_WEB_VALIDATED_TOKEN || "").trim();
+  if (explicit) return explicit;
+  return crypto.randomUUID();
+}
+function isBlackboxValidatedTokenError(responseText) {
+  const lower = (responseText || "").toLowerCase();
+  return lower.includes("invalid validated token") || lower.includes("invalid validated") || lower.includes("validation token") || lower.includes("invalid token");
+}
+const MAX_SESSIONS = 100;
+const sessionCache = /* @__PURE__ */ new Map();
+function extractMessageText(content) {
+  if (typeof content === "string") {
+    return content.trim();
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.map((part) => {
+    if (!part || typeof part !== "object") return "";
+    const item = part;
+    if (item.type === "text" && typeof item.text === "string") {
+      return item.text;
+    }
+    if (item.type === "input_text" && typeof item.text === "string") {
+      return item.text;
+    }
+    return "";
+  }).filter((part) => part.trim().length > 0).join("\n").trim();
+}
+function parseOpenAIMessages(messages, chatId) {
+  const systemParts = [];
+  const parsed = [];
+  for (const message of messages) {
+    const role = String(message.role || "user");
+    const content = extractMessageText(message.content);
+    if (!content) continue;
+    if (role === "system" || role === "developer") {
+      systemParts.push(content);
+      continue;
+    }
+    if (role === "assistant" || role === "user") {
+      parsed.push({
+        id: role === "user" ? chatId : crypto.randomUUID(),
+        role,
+        content
+      });
+    }
+  }
+  if (systemParts.length > 0) {
+    const prefix = `System instructions:
+${systemParts.join("\n\n")}`;
+    const firstUserIndex = parsed.findIndex((message) => message.role === "user");
+    if (firstUserIndex >= 0) {
+      parsed[firstUserIndex] = {
+        ...parsed[firstUserIndex],
+        content: `${prefix}
+
+${parsed[firstUserIndex].content}`
+      };
+    } else {
+      parsed.unshift({
+        id: chatId,
+        role: "user",
+        content: prefix
+      });
+    }
+  }
+  return parsed;
+}
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil((text || "").length / 4));
+}
+function sseChunk(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+async function readTextResponse(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+      }
+      const { value, done } = await reader.read();
+      if (done) break;
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+    return text;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function buildStreamingResponse(responseText, model, id, created) {
+  const encoder = new TextEncoder();
+  return new ReadableStream(
+    {
+      start(controller) {
+        controller.enqueue(
+          encoder.encode(
+            sseChunk({
+              id,
+              object: "chat.completion.chunk",
+              created,
+              model,
+              system_fingerprint: null,
+              choices: [
+                {
+                  index: 0,
+                  delta: { role: "assistant" },
+                  finish_reason: null,
+                  logprobs: null
+                }
+              ]
+            })
+          )
+        );
+        if (responseText) {
+          controller.enqueue(
+            encoder.encode(
+              sseChunk({
+                id,
+                object: "chat.completion.chunk",
+                created,
+                model,
+                system_fingerprint: null,
+                choices: [
+                  {
+                    index: 0,
+                    delta: { content: responseText },
+                    finish_reason: null,
+                    logprobs: null
+                  }
+                ]
+              })
+            )
+          );
+        }
+        controller.enqueue(
+          encoder.encode(
+            sseChunk({
+              id,
+              object: "chat.completion.chunk",
+              created,
+              model,
+              system_fingerprint: null,
+              choices: [{ index: 0, delta: {}, finish_reason: "stop", logprobs: null }]
+            })
+          )
+        );
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      }
+    },
+    { highWaterMark: 16384 }
+  );
+}
+function buildNonStreamingResponse(responseText, model, id, created) {
+  const completionTokens = estimateTokens(responseText);
+  return new Response(
+    JSON.stringify({
+      id,
+      object: "chat.completion",
+      created,
+      model,
+      system_fingerprint: null,
+      choices: [
+        {
+          index: 0,
+          message: { role: "assistant", content: responseText },
+          finish_reason: "stop",
+          logprobs: null
+        }
+      ],
+      usage: {
+        prompt_tokens: completionTokens,
+        completion_tokens: completionTokens,
+        total_tokens: completionTokens * 2
+      }
+    }),
+    {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    }
+  );
+}
+function normalizeBlackboxCookieHeader(apiKey) {
+  return normalizeSessionCookieHeader(apiKey, BLACKBOX_DEFAULT_COOKIE);
+}
+class BlackboxWebExecutor extends BaseExecutor {
+  constructor() {
+    super("blackbox-web", { id: "blackbox-web", baseUrl: BLACKBOX_CHAT_API });
+  }
+  async execute({
+    model,
+    body,
+    stream,
+    credentials,
+    signal,
+    log,
+    upstreamExtraHeaders
+  }) {
+    const bodyObj = body || {};
+    const messages = bodyObj.messages;
+    if (!messages || !Array.isArray(messages) || messages.length === 0) {
+      const errorResponse = new Response(
+        JSON.stringify({
+          error: {
+            message: "Missing or empty messages array",
+            type: "invalid_request"
+          }
+        }),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+      return {
+        response: errorResponse,
+        url: BLACKBOX_CHAT_API,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    const { hasTools, requestedTools, effectiveMessages } = prepareToolMessages(
+      bodyObj,
+      messages
+    );
+    const chatId = crypto.randomUUID().slice(0, 7);
+    const parsedMessages = parseOpenAIMessages(effectiveMessages, chatId);
+    if (parsedMessages.length === 0) {
+      const errorResponse = new Response(
+        JSON.stringify({
+          error: {
+            message: "Empty query after processing messages",
+            type: "invalid_request"
+          }
+        }),
+        { status: 400, headers: { "Content-Type": "application/json" } }
+      );
+      return {
+        response: errorResponse,
+        url: BLACKBOX_CHAT_API,
+        headers: {},
+        transformedBody: body
+      };
+    }
+    const cookieHeader = normalizeBlackboxCookieHeader(credentials.apiKey || "");
+    const baseHeaders = {
+      Accept: "application/json",
+      Cookie: cookieHeader,
+      Origin: "https://app.blackbox.ai",
+      "User-Agent": BLACKBOX_USER_AGENT
+    };
+    let sessionData = null;
+    let subscriptionCache = null;
+    let teamAccount = "";
+    const cacheKey = cookieHeader;
+    const cached = sessionCache.get(cacheKey);
+    if (cached && Date.now() - cached.fetchedAt < SESSION_CACHE_TTL_MS) {
+      sessionData = cached.sessionData;
+      subscriptionCache = cached.subscriptionCache;
+      teamAccount = cached.teamAccount;
+      log?.debug?.("BLACKBOX-WEB", `Session cache hit (${teamAccount || "no email"})`);
+    } else {
+      const sideSignal = signal ? mergeAbortSignals(signal, AbortSignal.timeout(1e4)) : AbortSignal.timeout(1e4);
+      try {
+        const sessionRes = await fetch("https://app.blackbox.ai/api/auth/session", {
+          method: "GET",
+          headers: { ...baseHeaders, Accept: "application/json" },
+          signal: sideSignal
+        });
+        sessionData = sessionRes.ok ? await sessionRes.json() : null;
+        const email = sessionData?.user?.email;
+        teamAccount = email || "";
+        log?.debug?.("BLACKBOX-WEB", `Session email: ${email ?? "none"}`);
+        if (email) {
+          const subRes = await fetch("https://app.blackbox.ai/api/check-subscription", {
+            method: "POST",
+            headers: { ...baseHeaders, "Content-Type": "application/json" },
+            body: JSON.stringify({ email }),
+            signal: sideSignal
+          });
+          const rawSub = subRes.ok ? await subRes.json() : null;
+          if (rawSub) {
+            subscriptionCache = {
+              status: rawSub.hasActiveSubscription ? "PREMIUM" : "FREE",
+              customerId: rawSub.customerId ?? null,
+              expiryTimestamp: rawSub.expiryTimestamp ?? null,
+              lastChecked: Date.now(),
+              isTrialSubscription: rawSub.isTrialSubscription ?? false,
+              hasPaymentVerificationFailure: false,
+              verificationFailureTimestamp: null,
+              requiresAuthentication: false,
+              isTeam: rawSub.isTeam ?? false,
+              numSeats: rawSub.numSeats ?? 1,
+              provider: rawSub.provider ?? null,
+              previouslySubscribed: rawSub.previouslySubscribed ?? false,
+              activeInsuffientCredits: rawSub.activeInsuffientCredits ?? false
+            };
+            log?.debug?.("BLACKBOX-WEB", `Subscription: ${subscriptionCache.status}`);
+          }
+        }
+        sessionCache.set(cacheKey, {
+          sessionData,
+          subscriptionCache,
+          teamAccount,
+          fetchedAt: Date.now()
+        });
+        while (sessionCache.size > MAX_SESSIONS) {
+          const oldestKey = sessionCache.keys().next().value;
+          if (oldestKey !== void 0) sessionCache.delete(oldestKey);
+          else break;
+        }
+      } catch (diagErr) {
+        log?.debug?.("BLACKBOX-WEB", `Session/subscription fetch failed (non-fatal): ${diagErr}`);
+      }
+    }
+    const headers = {
+      ...baseHeaders,
+      Accept: "text/plain, */*",
+      "Content-Type": "application/json",
+      Referer: `https://app.blackbox.ai/chat/${chatId}`
+    };
+    mergeUpstreamExtraHeaders(headers, upstreamExtraHeaders);
+    const transformedBody = {
+      messages: parsedMessages,
+      id: chatId,
+      previewToken: null,
+      userId: credentials.providerSpecificData?.userId ?? null,
+      codeModelMode: true,
+      trendingAgentMode: {},
+      isMicMode: false,
+      userSystemPrompt: null,
+      maxTokens: Number(body.max_tokens) || 1024,
+      playgroundTopP: null,
+      playgroundTemperature: null,
+      isChromeExt: false,
+      githubToken: "",
+      clickedAnswer2: false,
+      clickedAnswer3: false,
+      clickedForceWebSearch: false,
+      visitFromDelta: false,
+      isMemoryEnabled: false,
+      mobileClient: false,
+      userSelectedModel: model || null,
+      userSelectedAgent: "VscodeAgent",
+      // Issue #2252: prefer operator-supplied BLACKBOX_WEB_VALIDATED_TOKEN over
+      // a random UUID — Blackbox's `/api/chat` rejects mismatched tokens with 403.
+      validated: resolveBlackboxValidatedToken(),
+      imageGenerationMode: false,
+      imageGenMode: "autoMode",
+      webSearchModePrompt: false,
+      deepSearchMode: false,
+      promptSelection: "",
+      domains: null,
+      vscodeClient: false,
+      codeInterpreterMode: false,
+      customProfile: {
+        name: "",
+        occupation: "",
+        traits: [],
+        additionalInfo: "",
+        enableNewChats: false
+      },
+      webSearchModeOption: {
+        autoMode: true,
+        webMode: false,
+        offlineMode: false
+      },
+      session: sessionData,
+      isPremium: subscriptionCache ? subscriptionCache.status === "PREMIUM" : credentials.providerSpecificData?.isPremium ?? true,
+      teamAccount,
+      subscriptionCache,
+      beastMode: false,
+      reasoningMode: false,
+      designerMode: false,
+      workspaceId: "",
+      asyncMode: false,
+      integrations: {},
+      isTaskPersistent: false,
+      selectedElement: null
+    };
+    const timeoutSignal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+    const combinedSignal = signal ? mergeAbortSignals(signal, timeoutSignal) : timeoutSignal;
+    let upstreamResponse;
+    try {
+      upstreamResponse = await fetch(BLACKBOX_CHAT_API, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(transformedBody),
+        signal: combinedSignal
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log?.error?.("BLACKBOX-WEB", `Fetch failed: ${message}`);
+      const errorResponse = new Response(
+        JSON.stringify({
+          error: {
+            message: `Blackbox Web connection failed: ${message}`,
+            type: "upstream_error"
+          }
+        }),
+        { status: 502, headers: { "Content-Type": "application/json" } }
+      );
+      return {
+        response: errorResponse,
+        url: BLACKBOX_CHAT_API,
+        headers,
+        transformedBody
+      };
+    }
+    if (!upstreamResponse.ok) {
+      const status = upstreamResponse.status;
+      let message = `Blackbox Web returned HTTP ${status}`;
+      const errorBody = await upstreamResponse.text().catch(() => "");
+      if (status === 403 && isBlackboxValidatedTokenError(errorBody)) {
+        message = "Blackbox Web rejected the request with an invalid `validated` token. If you have a valid frontend token (the `tk` value from app.blackbox.ai's Next.js bundle), set BLACKBOX_WEB_VALIDATED_TOKEN in your environment and restart.";
+      } else if (status === 401 || status === 403) {
+        message = "Blackbox Web auth failed \u2014 your app.blackbox.ai session cookie may be missing or expired.";
+      } else if (status === 429) {
+        message = "Blackbox Web rate limited the session. Wait a moment and retry.";
+      }
+      const errorResponse = new Response(
+        JSON.stringify({
+          error: {
+            message,
+            type: "upstream_error",
+            code: `HTTP_${status}`
+          }
+        }),
+        { status, headers: { "Content-Type": "application/json" } }
+      );
+      return {
+        response: errorResponse,
+        url: BLACKBOX_CHAT_API,
+        headers,
+        transformedBody
+      };
+    }
+    if (!upstreamResponse.body) {
+      const errorResponse = new Response(
+        JSON.stringify({
+          error: {
+            message: "Blackbox Web returned an empty response body",
+            type: "upstream_error"
+          }
+        }),
+        { status: 502, headers: { "Content-Type": "application/json" } }
+      );
+      return {
+        response: errorResponse,
+        url: BLACKBOX_CHAT_API,
+        headers,
+        transformedBody
+      };
+    }
+    const responseText = (await readTextResponse(upstreamResponse.body, signal)).trim();
+    log?.debug?.("BLACKBOX-WEB", `Response (first 300 chars): ${responseText.slice(0, 300)}`);
+    log?.debug?.("BLACKBOX-WEB", `userSelectedModel sent: ${transformedBody.userSelectedModel}`);
+    log?.debug?.("BLACKBOX-WEB", `isPremium sent: ${transformedBody.isPremium}`);
+    const lowerText = responseText.toLowerCase();
+    const isSubscriptionError = /not upgraded|upgrade to a premium plan|upgrade.required/i.test(responseText) || lowerText.includes("please upgrade");
+    const isAuthError = /please login|login required|authentication required/i.test(responseText) && !isSubscriptionError;
+    const isRateLimit = /rate limit|too many requests/i.test(responseText) && !isSubscriptionError;
+    if (isSubscriptionError) {
+      log?.warn?.("BLACKBOX-WEB", "Blackbox returned subscription error in response body");
+      const errorResponse = new Response(
+        JSON.stringify({
+          error: {
+            message: "Blackbox reports your account lacks a premium subscription. If you have a paid plan, re-paste your session cookie from app.blackbox.ai.",
+            type: "upstream_error",
+            code: "BLACKBOX_SUBSCRIPTION_REQUIRED"
+          }
+        }),
+        { status: 402, headers: { "Content-Type": "application/json" } }
+      );
+      return { response: errorResponse, url: BLACKBOX_CHAT_API, headers, transformedBody };
+    }
+    if (isAuthError) {
+      log?.warn?.("BLACKBOX-WEB", "Blackbox returned auth error in response body");
+      const errorResponse = new Response(
+        JSON.stringify({
+          error: {
+            message: "Blackbox session is not authenticated \u2014 re-paste next-auth.session-token from app.blackbox.ai",
+            type: "upstream_error",
+            code: "BLACKBOX_AUTH_REQUIRED"
+          }
+        }),
+        { status: 401, headers: { "Content-Type": "application/json" } }
+      );
+      return { response: errorResponse, url: BLACKBOX_CHAT_API, headers, transformedBody };
+    }
+    if (isRateLimit) {
+      log?.warn?.("BLACKBOX-WEB", "Blackbox returned rate-limit error in response body");
+      const errorResponse = new Response(
+        JSON.stringify({
+          error: {
+            message: "Blackbox Web rate limited the session. Wait a moment and retry.",
+            type: "upstream_error",
+            code: "BLACKBOX_RATE_LIMIT"
+          }
+        }),
+        { status: 429, headers: { "Content-Type": "application/json" } }
+      );
+      return { response: errorResponse, url: BLACKBOX_CHAT_API, headers, transformedBody };
+    }
+    const id = `chatcmpl-blackbox-${crypto.randomUUID().slice(0, 12)}`;
+    const created = Math.floor(Date.now() / 1e3);
+    if (hasTools) {
+      const { content, toolCalls, finishReason } = buildToolAwareResult(
+        responseText,
+        requestedTools,
+        "bbx"
+      );
+      if (toolCalls) {
+        const toolResponse = new Response(
+          JSON.stringify({
+            id,
+            object: "chat.completion",
+            created,
+            model,
+            choices: [
+              {
+                index: 0,
+                message: { role: "assistant", content: null, tool_calls: toolCalls },
+                finish_reason: finishReason
+              }
+            ]
+          }),
+          { status: 200, headers: { "Content-Type": "application/json" } }
+        );
+        return { response: toolResponse, url: BLACKBOX_CHAT_API, headers, transformedBody };
+      }
+      const finalResponse2 = stream ? new Response(buildStreamingResponse(content, model, id, created), {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "X-Accel-Buffering": "no"
+        }
+      }) : buildNonStreamingResponse(content, model, id, created);
+      return { response: finalResponse2, url: BLACKBOX_CHAT_API, headers, transformedBody };
+    }
+    const finalResponse = stream ? new Response(buildStreamingResponse(responseText, model, id, created), {
+      status: 200,
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "X-Accel-Buffering": "no"
+      }
+    }) : buildNonStreamingResponse(responseText, model, id, created);
+    return {
+      response: finalResponse,
+      url: BLACKBOX_CHAT_API,
+      headers,
+      transformedBody
+    };
+  }
+}
+export {
+  BlackboxWebExecutor,
+  normalizeBlackboxCookieHeader,
+  resolveBlackboxValidatedToken
+};