@fudrouter/fsrouter 0.6.64 → 0.6.65

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

@@ -0,0 +1,133 @@
+import { BaseExecutor } from "./base.ts";
+import { makeExecutorErrorResult as makeErrorResult, normalizeCookie } from "../utils/error.js";
+const BASE_URL = "https://www.poe.com";
+const GQL_URL = `${BASE_URL}/api/gql_POST`;
+const USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36";
+const MODEL_MAP = {
+  "gpt-4o": "GPT-4o",
+  "gpt-4-turbo": "GPT-4-Turbo",
+  "claude-3.5-sonnet": "Claude-3.5-Sonnet",
+  "claude-3-opus": "Claude-3-Opus",
+  "gemini-2.0-flash": "Gemini-2.0-Flash",
+  "llama-3-70b": "Llama-3-70B",
+  "mixtral-8x22b": "Mixtral-8x22B",
+  "poe-default": "Assistant"
+};
+function extractPbCookie(raw) {
+  const match = raw.match(/p-b=([^;]+)/);
+  return match ? match[1] : raw;
+}
+class PoeWebExecutor extends BaseExecutor {
+  constructor() {
+    super("poe-web", { id: "poe-web", baseUrl: "https://www.poe.com" });
+  }
+  async execute(input) {
+    const { body, credentials, signal, stream: wantStream } = input;
+    const bodyObj = body || {};
+    const rawCookie = normalizeCookie(String(credentials?.apiKey ?? "").trim());
+    const pbCookie = extractPbCookie(rawCookie);
+    const messages = bodyObj.messages || [];
+    const requestedModel = bodyObj.model || "poe-default";
+    const botName = MODEL_MAP[requestedModel] || requestedModel;
+    const lastUserMsg = messages.filter((m) => m.role === "user").pop();
+    const prompt = lastUserMsg?.content || "";
+    const gqlBody = {
+      operationName: "ChatViewQuery",
+      query: `query ChatViewQuery($bot: String!, $query: String!) {
+        chatWithBot(bot: $bot, query: $query) {
+          messageId
+          text
+          state
+        }
+      }`,
+      variables: { bot: botName, query: prompt }
+    };
+    const reqHeaders = {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENT,
+      Accept: "application/json",
+      Referer: `${BASE_URL}/`,
+      Origin: BASE_URL,
+      Cookie: `p-b=${pbCookie}`
+    };
+    let upstream;
+    try {
+      upstream = await fetch(GQL_URL, {
+        method: "POST",
+        headers: reqHeaders,
+        body: JSON.stringify(gqlBody),
+        signal
+      });
+    } catch (err) {
+      return makeErrorResult(
+        502,
+        `Poe fetch failed: ${err instanceof Error ? err.message : "unknown"}`,
+        body,
+        GQL_URL
+      );
+    }
+    if (!upstream.ok) {
+      const errText = await upstream.text().catch(() => "");
+      return makeErrorResult(upstream.status, `Poe error: ${errText}`, body, GQL_URL);
+    }
+    const data = await upstream.json();
+    const inner = data.data ?? {};
+    const chatData = inner.chatWithBot ?? {};
+    const text = chatData.text || "";
+    if (!wantStream) {
+      return {
+        response: new Response(
+          JSON.stringify({
+            id: `chatcmpl-poe-${Date.now()}`,
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1e3),
+            model: requestedModel,
+            choices: [
+              {
+                index: 0,
+                message: { role: "assistant", content: text },
+                finish_reason: "stop"
+              }
+            ]
+          }),
+          { headers: { "Content-Type": "application/json" } }
+        ),
+        url: GQL_URL,
+        headers: reqHeaders,
+        transformedBody: gqlBody
+      };
+    }
+    const encoder = new TextEncoder();
+    const chunk = {
+      id: `chatcmpl-poe-${Date.now()}`,
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1e3),
+      model: requestedModel,
+      choices: [{ index: 0, delta: { content: text }, finish_reason: null }]
+    };
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
+
+`));
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      }
+    });
+    return {
+      response: new Response(stream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      }),
+      url: GQL_URL,
+      headers: reqHeaders,
+      transformedBody: gqlBody
+    };
+  }
+}
+export {
+  PoeWebExecutor
+};

package/open-sse/executors/pollinations.js

@@ -0,0 +1,95 @@
+import { BaseExecutor } from "./base.ts";
+import { PROVIDERS } from "../config/constants.ts";
+import { DEFAULT_POOL_CONFIG } from "../services/sessionPool/types.ts";
+class PollinationsExecutor extends BaseExecutor {
+  constructor() {
+    super("pollinations", PROVIDERS["pollinations"] || { format: "openai" });
+    this.poolConfig = DEFAULT_POOL_CONFIG;
+  }
+  buildUrl(_model, _stream, urlIndex = 0, _credentials = null) {
+    const baseUrls = this.getBaseUrls();
+    return baseUrls[urlIndex] || baseUrls[0] || "https://gen.pollinations.ai/v1/chat/completions";
+  }
+  buildHeaders(credentials, stream = true) {
+    const key = credentials?.apiKey || credentials?.accessToken;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (key) {
+      headers.Authorization = `Bearer ${key}`;
+    }
+    if (stream) {
+      headers["Accept"] = "text/event-stream";
+    }
+    return headers;
+  }
+  transformRequest(model, body, stream, _credentials) {
+    if (typeof body === "object" && body !== null) {
+      body.model = model;
+      body.stream = stream;
+      const responseFormatType = body.response_format?.type;
+      if (responseFormatType === "json_object" || responseFormatType === "json_schema") {
+        body.jsonMode = true;
+      }
+    }
+    return body;
+  }
+  async execute(input) {
+    const isAnonymous = !input.credentials?.apiKey && !input.credentials?.accessToken;
+    if (!isAnonymous) {
+      return super.execute(input);
+    }
+    const pool = this.getPool();
+    let session;
+    try {
+      session = pool ? await pool.acquireBlocking(1e4) : null;
+    } catch {
+      session = null;
+    }
+    if (session) {
+      const fpHeaders = session.buildHeaders();
+      input.upstreamExtraHeaders = {
+        ...fpHeaders,
+        ...input.upstreamExtraHeaders
+      };
+    }
+    try {
+      const result = await super.execute(input);
+      if (session && pool) {
+        const status = result.response.status;
+        if (status === 429) {
+          pool.reportCooldown(session);
+        } else if (status >= 500) {
+          pool.reportDead(session);
+        } else {
+          pool.reportSuccess(session);
+        }
+      }
+      return result;
+    } catch (err) {
+      if (session && pool) {
+        pool.reportCooldown(session);
+      }
+      if (err?.status === 401 || err?.statusCode === 401) {
+        const premiumModels = ["claude", "claude-fast", "claude-large", "gemini", "gemini-fast", "midijourney", "midijourney-large"];
+        const model = input.model || "";
+        if (premiumModels.includes(model)) {
+          const enhanced = new Error(
+            `Pollinations model "${model}" requires an API key. Free keyless models: openai, openai-fast, openai-large, qwen-coder, mistral, deepseek, grok, gemini-flash-lite-3.1, perplexity-fast, perplexity-reasoning. Get a Pollinations API key at https://enter.pollinations.ai and add it in Settings \u2192 API Keys.`
+          );
+          enhanced.status = 401;
+          enhanced.type = "authentication_error";
+          throw enhanced;
+        }
+      }
+      throw err;
+    } finally {
+      session?.release();
+    }
+  }
+}
+var pollinations_default = PollinationsExecutor;
+export {
+  PollinationsExecutor,
+  pollinations_default as default
+};

package/open-sse/executors/puter.js

@@ -0,0 +1,31 @@
+import { BaseExecutor } from "./base.ts";
+import { PROVIDERS } from "../config/constants.ts";
+class PuterExecutor extends BaseExecutor {
+  constructor() {
+    super("puter", PROVIDERS["puter"] || { format: "openai" });
+  }
+  buildUrl(_model, _stream, _urlIndex = 0, _credentials = null) {
+    return "https://api.puter.com/puterai/openai/v1/chat/completions";
+  }
+  buildHeaders(credentials, stream = true) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const key = credentials?.apiKey || credentials?.accessToken;
+    if (key) {
+      headers["Authorization"] = `Bearer ${key}`;
+    }
+    if (stream) {
+      headers["Accept"] = "text/event-stream";
+    }
+    return headers;
+  }
+  transformRequest(model, body, _stream, _credentials) {
+    return body;
+  }
+}
+var puter_default = PuterExecutor;
+export {
+  PuterExecutor,
+  puter_default as default
+};