@fudrouter/fsrouter 0.6.63 → 0.6.64

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

@@ -1,325 +0,0 @@
-import { BaseExecutor } from "./base.ts";
-import { makeExecutorErrorResult as makeErrorResult, sanitizeErrorMessage } from "../utils/error.js";
-import { extractKimiJwt } from '../../../dist/lib/providers/webCookieAuth.js';
-const BASE_URL = "https://www.kimi.com";
-const CHAT_URL = `${BASE_URL}/apiv2/kimi.gateway.chat.v1.ChatService/Chat`;
-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";
-function resolveModelConfig(modelId) {
-  if (modelId === "k2d6-thinking") return { scenario: "SCENARIO_K2D5", thinking: true };
-  return { scenario: "SCENARIO_K2D5", thinking: false };
-}
-function frameConnectMessage(json) {
-  const payload = new TextEncoder().encode(json);
-  const framed = new Uint8Array(5 + payload.length);
-  framed[0] = 0;
-  const len = payload.length;
-  framed[1] = len >>> 24 & 255;
-  framed[2] = len >>> 16 & 255;
-  framed[3] = len >>> 8 & 255;
-  framed[4] = len & 255;
-  framed.set(payload, 5);
-  return framed;
-}
-const MAX_FRAME_LEN = 8 * 1024 * 1024;
-function decodeConnectFrame(buf, byteOffset) {
-  if (byteOffset + 5 > buf.length) return { consumed: 0, frame: null };
-  const flags = buf[byteOffset];
-  const len = buf[byteOffset + 1] << 24 | buf[byteOffset + 2] << 16 | buf[byteOffset + 3] << 8 | buf[byteOffset + 4];
-  const msgLen = len < 0 ? len + 4294967296 : len;
-  if (msgLen > MAX_FRAME_LEN) return { consumed: -1, frame: null };
-  if (byteOffset + 5 + msgLen > buf.length) return { consumed: 0, frame: null };
-  const payload = buf.subarray(byteOffset + 5, byteOffset + 5 + msgLen);
-  let message = null;
-  if (msgLen > 0) {
-    try {
-      message = JSON.parse(new TextDecoder().decode(payload));
-    } catch {
-      message = null;
-    }
-  }
-  return { consumed: 5 + msgLen, frame: { flags, message } };
-}
-function extractDelta(msg) {
-  if (!msg) return null;
-  const op = String(msg.op ?? "");
-  const mask = String(msg.mask ?? "");
-  const block = msg.block ?? {};
-  if (op === "append") {
-    if (mask === "block.text.content") {
-      const text = String((block.text ?? {}).content ?? "");
-      return text ? { kind: "text", text } : null;
-    }
-    if (mask === "block.think.content") {
-      const text = String((block.think ?? {}).content ?? "");
-      return text ? { kind: "think", text } : null;
-    }
-    return null;
-  }
-  if (op === "set") {
-    if (mask === "block.text") {
-      const text = String((block.text ?? {}).content ?? "");
-      return text ? { kind: "text", text } : null;
-    }
-    if (mask === "block.think") {
-      const text = String((block.think ?? {}).content ?? "");
-      return text ? { kind: "think", text } : null;
-    }
-  }
-  return null;
-}
-function isEndOfStream(msg) {
-  if (!msg) return false;
-  const message = msg.message ?? null;
-  if (message && String(message.status ?? "") === "MESSAGE_STATUS_COMPLETED" && String(message.role ?? "") === "assistant") {
-    return true;
-  }
-  return false;
-}
-function foldMessages(messages) {
-  let system = "";
-  let user = "";
-  for (const m of messages) {
-    const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content ?? "");
-    if (m.role === "system") {
-      system += (system ? "\n\n" : "") + text;
-    } else if (m.role === "user") {
-      user = user ? `${user}
-
-${text}` : text;
-    } else if (m.role === "assistant") {
-      user = user ? `${user}
-
-Assistant: ${text}` : `Assistant: ${text}`;
-    }
-  }
-  return system ? `${system}
-
-${user}` : user;
-}
-class KimiWebExecutor extends BaseExecutor {
-  constructor() {
-    super("kimi-web", { id: "kimi-web", baseUrl: BASE_URL });
-  }
-  buildKimiHeaders(jwt) {
-    const headers = {
-      "Content-Type": "application/connect+json",
-      Accept: "*/*",
-      "User-Agent": USER_AGENT,
-      Origin: BASE_URL,
-      Referer: `${BASE_URL}/`,
-      "connect-protocol-version": "1"
-    };
-    if (jwt) {
-      headers["Authorization"] = `Bearer ${jwt}`;
-      headers["Cookie"] = `kimi-auth=${jwt}`;
-    }
-    return headers;
-  }
-  buildRequestBody(prompt, wantThinking, scenario) {
-    return JSON.stringify({
-      scenario,
-      tools: [{ type: "TOOL_TYPE_SEARCH", search: {} }, { type: "TOOL_TYPE_CRON_JOB" }],
-      message: {
-        role: "user",
-        blocks: [{ message_id: "", text: { content: prompt } }],
-        scenario
-      },
-      options: { thinking: wantThinking, enable_plugin: true }
-    });
-  }
-  async execute(input) {
-    const { body, credentials, signal, stream: wantStream } = input;
-    const bodyObj = body || {};
-    const rawCredential = String(credentials?.apiKey ?? "").trim();
-    const jwt = extractKimiJwt(rawCredential);
-    if (!jwt) {
-      return makeErrorResult(
-        400,
-        "Missing Kimi session \u2014 paste the full Cookie header from www.kimi.com (must contain kimi-auth=<JWT>) or just the JWT itself.",
-        body,
-        CHAT_URL
-      );
-    }
-    const messages = bodyObj.messages || [];
-    const modelId = bodyObj.model || "kimi-default";
-    const modelConfig = resolveModelConfig(modelId);
-    const wantThinking = bodyObj.reasoning_effort === "none" ? false : modelConfig.thinking;
-    const prompt = foldMessages(messages);
-    const reqBody = this.buildRequestBody(prompt, wantThinking, modelConfig.scenario);
-    const reqHeaders = this.buildKimiHeaders(jwt);
-    const framedBody = frameConnectMessage(reqBody);
-    let upstream;
-    try {
-      upstream = await fetch(CHAT_URL, {
-        method: "POST",
-        headers: reqHeaders,
-        body: new Uint8Array(framedBody),
-        signal
-      });
-    } catch (err) {
-      return makeErrorResult(
-        502,
-        `Kimi fetch failed: ${err instanceof Error ? err.message : "unknown"}`,
-        body,
-        CHAT_URL
-      );
-    }
-    if (!upstream.ok) {
-      const errText = await upstream.text().catch(() => "");
-      return makeErrorResult(upstream.status, `Kimi error: ${sanitizeErrorMessage(errText)}`, body, CHAT_URL);
-    }
-    const encoder = new TextEncoder();
-    const id = `chatcmpl-kimi-${Date.now()}`;
-    const created = Math.floor(Date.now() / 1e3);
-    const emitChunk = (controller, delta, finish = null) => {
-      const chunk = {
-        id,
-        object: "chat.completion.chunk",
-        created,
-        model: modelId,
-        choices: [{ index: 0, delta, finish_reason: finish }]
-      };
-      controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}
-
-`));
-    };
-    const sourceStream = upstream.body ?? new ReadableStream({ start: (c) => c.close() });
-    if (wantStream) {
-      const outStream = new ReadableStream({
-        async start(controller) {
-          const reader2 = sourceStream.getReader();
-          let buffer2 = new Uint8Array(0);
-          let emittedRole = false;
-          try {
-            while (true) {
-              const { done, value } = await reader2.read();
-              if (done) break;
-              if (value) {
-                const merged = new Uint8Array(buffer2.length + value.length);
-                merged.set(buffer2, 0);
-                merged.set(value, buffer2.length);
-                buffer2 = merged;
-                let offset = 0;
-                while (offset < buffer2.length) {
-                  const { consumed, frame } = decodeConnectFrame(buffer2, offset);
-                  if (consumed === -1) {
-                    controller.error(new Error("Kimi Connect frame exceeded MAX_FRAME_LEN"));
-                    return;
-                  }
-                  if (consumed === 0) break;
-                  offset += consumed;
-                  if (!frame?.message) continue;
-                  const delta = extractDelta(frame.message);
-                  if (delta) {
-                    if (!emittedRole) {
-                      emittedRole = true;
-                      emitChunk(controller, { role: "assistant", content: "" });
-                    }
-                    if (delta.kind === "think") {
-                      emitChunk(controller, { reasoning_content: delta.text });
-                    } else {
-                      emitChunk(controller, { content: delta.text });
-                    }
-                  }
-                  if (isEndOfStream(frame.message)) {
-                    emitChunk(controller, {}, "stop");
-                    controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-                    controller.close();
-                    return;
-                  }
-                }
-                buffer2 = buffer2.subarray(offset);
-              }
-            }
-            if (!emittedRole) {
-              emitChunk(controller, { role: "assistant", content: "" });
-            }
-            emitChunk(controller, {}, "stop");
-            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-            controller.close();
-          } catch (err) {
-            if (!signal?.aborted) {
-              try {
-                controller.error(err);
-              } catch {
-              }
-            }
-          }
-        }
-      });
-      return {
-        response: new Response(outStream, {
-          headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive"
-          }
-        }),
-        url: CHAT_URL,
-        headers: reqHeaders,
-        transformedBody: JSON.parse(reqBody)
-      };
-    }
-    let answer = "";
-    let reasoning = "";
-    const reader = sourceStream.getReader();
-    let buffer = new Uint8Array(0);
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        if (!value) continue;
-        const merged = new Uint8Array(buffer.length + value.length);
-        merged.set(buffer, 0);
-        merged.set(value, buffer.length);
-        buffer = merged;
-        let offset = 0;
-        while (offset < buffer.length) {
-          const { consumed, frame } = decodeConnectFrame(buffer, offset);
-          if (consumed === -1) break;
-          if (consumed === 0) break;
-          offset += consumed;
-          if (!frame?.message) continue;
-          const delta = extractDelta(frame.message);
-          if (delta) {
-            if (delta.kind === "think") reasoning += delta.text;
-            else answer += delta.text;
-          }
-          if (isEndOfStream(frame.message)) {
-            offset = buffer.length;
-            break;
-          }
-        }
-        buffer = buffer.subarray(offset);
-      }
-    } catch {
-    }
-    const message = { role: "assistant", content: answer };
-    if (reasoning) message.reasoning_content = reasoning;
-    const completion = {
-      id,
-      object: "chat.completion",
-      created,
-      model: modelId,
-      choices: [{ index: 0, message, finish_reason: "stop" }]
-    };
-    return {
-      response: new Response(JSON.stringify(completion), {
-        headers: { "Content-Type": "application/json" }
-      }),
-      url: CHAT_URL,
-      headers: reqHeaders,
-      transformedBody: JSON.parse(reqBody)
-    };
-  }
-}
-export {
-  KimiWebExecutor,
-  decodeConnectFrame,
-  extractDelta,
-  extractKimiJwt,
-  foldMessages,
-  frameConnectMessage,
-  isEndOfStream,
-  resolveModelConfig
-};

package/open-sse/executors/kimi.js

@@ -1,97 +0,0 @@
-import { DefaultExecutor } from "./default.ts";
-import { applyProviderRequestDefaults } from "../services/providerRequestDefaults.ts";
-import { NON_ANTHROPIC_THINKING_PLACEHOLDER } from "../translator/helpers/claudeHelper.ts";
-function hasActiveKimiThinking(body) {
-  const thinking = body.thinking;
-  if (thinking && typeof thinking === "object" && !Array.isArray(thinking)) {
-    const thinkingRecord = thinking;
-    return thinkingRecord.type === "enabled" || thinkingRecord.type === "adaptive";
-  }
-  return false;
-}
-function hasNonEmptyReasoningContent(message) {
-  return typeof message.reasoning_content === "string" && message.reasoning_content.trim().length > 0;
-}
-function isToolUseBlock(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value) && value.type === "tool_use";
-}
-function isThinkingBlock(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value) && (value.type === "thinking" || value.type === "redacted_thinking");
-}
-function hasAssistantToolCalls(message) {
-  if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) return true;
-  return Array.isArray(message.content) && message.content.some(isToolUseBlock);
-}
-function isClaudeProtocolBody(body) {
-  if (Array.isArray(body.system)) return true;
-  if (!Array.isArray(body.messages)) return false;
-  return body.messages.some((message) => {
-    const msg = asRecord(message);
-    if (!msg || !Array.isArray(msg.content)) return false;
-    return msg.content.some((part) => {
-      const block = asRecord(part);
-      return block?.type === "text" || block?.type === "tool_use" || block?.type === "tool_result";
-    });
-  });
-}
-function disableKimiPreservedThinking(body) {
-  if (!isClaudeProtocolBody(body)) return body;
-  const thinking = asRecord(body.thinking) ?? { type: "enabled" };
-  if (thinking.keep === null) return body;
-  return {
-    ...body,
-    thinking: {
-      ...thinking,
-      keep: null
-    }
-  };
-}
-function ensureKimiThinkingContent(message) {
-  const reasoningContent = hasNonEmptyReasoningContent(message) ? String(message.reasoning_content) : NON_ANTHROPIC_THINKING_PLACEHOLDER;
-  let nextMessage = hasNonEmptyReasoningContent(message) ? message : { ...message, reasoning_content: reasoningContent };
-  if (!Array.isArray(nextMessage.content)) return nextMessage;
-  const firstToolUseIndex = nextMessage.content.findIndex(isToolUseBlock);
-  if (firstToolUseIndex < 0 || nextMessage.content.some(isThinkingBlock)) return nextMessage;
-  const content = [...nextMessage.content];
-  content.splice(firstToolUseIndex, 0, {
-    type: "thinking",
-    thinking: reasoningContent
-  });
-  return { ...nextMessage, content };
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function applyKimiRequestDefaults(body, defaults) {
-  const withDefaults = applyProviderRequestDefaults(body, defaults);
-  const record = asRecord(withDefaults);
-  if (!record || !Array.isArray(record.messages)) {
-    return withDefaults;
-  }
-  const kimiBody = disableKimiPreservedThinking(record);
-  if (!hasActiveKimiThinking(kimiBody)) return kimiBody;
-  let modified = false;
-  const sourceMessages = Array.isArray(kimiBody.messages) ? kimiBody.messages : record.messages;
-  const messages = sourceMessages.map((message) => {
-    const msg = asRecord(message);
-    if (!msg || msg.role !== "assistant" || !hasAssistantToolCalls(msg)) return message;
-    const nextMessage = ensureKimiThinkingContent(msg);
-    if (nextMessage !== msg) modified = true;
-    return nextMessage;
-  });
-  return modified ? { ...kimiBody, messages } : kimiBody;
-}
-class KimiExecutor extends DefaultExecutor {
-  constructor(provider = "kimi-coding") {
-    super(provider);
-  }
-  transformRequest(model, body, stream, credentials) {
-    const cleanedBody = super.transformRequest(model, body, stream, credentials);
-    return applyKimiRequestDefaults(cleanedBody);
-  }
-}
-var kimi_default = KimiExecutor;
-export {
-  KimiExecutor,
-  kimi_default as default
-};