n9router 0.4.44 → 0.4.45

package/app/open-sse/translator/response/openai-to-claude.js

@@ -1,7 +1,13 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
-
-// Prefix for Claude OAuth tool names (must match request translator)
+import { ROLE, CLAUDE_BLOCK, MODEL_FALLBACK } from "../schema/index.js";
+import { fromOpenAIFinish } from "../concerns/finishReason.js";
+import { extractReasoningText } from "../concerns/reasoning.js";
+
+// Legacy "proxy_" prefix used by older request translators. Response strips it
+// defensively so tool names from such turns resolve back (e.g. proxy_Read → Read
+// for arg sanitization). Current request translator emits no prefix ("") — strip
+// is then a no-op. Kept intentionally; do NOT couple to request's empty prefix.
 const CLAUDE_OAUTH_TOOL_PREFIX = "proxy_";
 
 // Sanitize tool call arguments to fix bad params from non-Anthropic models
@@ -112,14 +118,14 @@ export function openaiToClaudeResponse(chunk, state) {
         chunk.extend_fields?.traceId ||
         `msg_${Date.now()}`;
     }
-    state.model = chunk.model || "unknown";
+    state.model = chunk.model || MODEL_FALLBACK;
     state.nextBlockIndex = 0;
     results.push({
       type: "message_start",
       message: {
         id: state.messageId,
         type: "message",
-        role: "assistant",
+        role: ROLE.ASSISTANT,
         model: state.model,
         content: [],
         stop_reason: null,
@@ -129,8 +135,8 @@ export function openaiToClaudeResponse(chunk, state) {
     });
   }
 
-  // Handle reasoning_content (thinking) - GLM, DeepSeek, etc.
-  const reasoningContent = delta?.reasoning_content || delta?.reasoning;
+  // Handle reasoning (thinking) across vendor shapes - GLM/DeepSeek/Qwen/MiniMax/etc.
+  const reasoningContent = extractReasoningText(delta);
   if (reasoningContent) {
     stopTextBlock(state, results);
 
@@ -140,7 +146,7 @@ export function openaiToClaudeResponse(chunk, state) {
       results.push({
         type: "content_block_start",
         index: state.thinkingBlockIndex,
-        content_block: { type: "thinking", thinking: "" }
+        content_block: { type: CLAUDE_BLOCK.THINKING, thinking: "" }
       });
     }
 
@@ -162,7 +168,7 @@ export function openaiToClaudeResponse(chunk, state) {
       results.push({
         type: "content_block_start",
         index: state.textBlockIndex,
-        content_block: { type: "text", text: "" }
+        content_block: { type: CLAUDE_BLOCK.TEXT, text: "" }
       });
     }
 
@@ -178,7 +184,8 @@ export function openaiToClaudeResponse(chunk, state) {
     for (const tc of delta.tool_calls) {
       const idx = tc.index ?? 0;
 
-      if (tc.id) {
+      // GLM/fireworks repeats id+null-name on every arg chunk; open block once per idx
+      if (tc.id && !state.toolCalls.has(idx)) {
         stopThinkingBlock(state, results);
         stopTextBlock(state, results);
 
@@ -195,7 +202,7 @@ export function openaiToClaudeResponse(chunk, state) {
           type: "content_block_start",
           index: toolBlockIndex,
           content_block: {
-            type: "tool_use",
+            type: CLAUDE_BLOCK.TOOL_USE,
             id: tc.id,
             name: toolName,
             input: {}
@@ -252,15 +259,7 @@ export function openaiToClaudeResponse(chunk, state) {
   return results.length > 0 ? results : null;
 }
 
-// Convert OpenAI finish_reason to Claude stop_reason
-function convertFinishReason(reason) {
-  switch (reason) {
-    case "stop": return "end_turn";
-    case "length": return "max_tokens";
-    case "tool_calls": return "tool_use";
-    default: return "end_turn";
-  }
-}
+const convertFinishReason = (reason) => fromOpenAIFinish(reason, "claude");
 
 // Register
 register(FORMATS.OPENAI, FORMATS.CLAUDE, null, openaiToClaudeResponse);

package/app/open-sse/translator/schema/blocks.js

@@ -0,0 +1,43 @@
+// Content-block "type" discriminators — fixed per format. Pure data (no logic).
+
+// OpenAI chat content blocks + tool_call wrapper.
+export const OPENAI_BLOCK = {
+  TEXT: "text",
+  IMAGE_URL: "image_url",
+  IMAGE: "image",
+  INPUT_AUDIO: "input_audio",
+  AUDIO_URL: "audio_url",
+  FILE: "file",
+  FUNCTION: "function",
+};
+
+// Claude content blocks.
+export const CLAUDE_BLOCK = {
+  TEXT: "text",
+  IMAGE: "image",
+  DOCUMENT: "document",
+  TOOL_USE: "tool_use",
+  TOOL_RESULT: "tool_result",
+  THINKING: "thinking",
+  REDACTED_THINKING: "redacted_thinking",
+};
+
+// OpenAI Responses API item types.
+export const RESPONSES_ITEM = {
+  MESSAGE: "message",
+  FUNCTION_CALL: "function_call",
+  FUNCTION_CALL_OUTPUT: "function_call_output",
+  REASONING: "reasoning",
+  OUTPUT_TEXT: "output_text",
+  INPUT_TEXT: "input_text",
+  INPUT_IMAGE: "input_image",
+  SUMMARY_TEXT: "summary_text",
+};
+
+// Valid OpenAI block types (used by filterToOpenAIFormat).
+export const VALID_OPENAI_CONTENT_TYPES = [
+  OPENAI_BLOCK.TEXT, OPENAI_BLOCK.IMAGE_URL, OPENAI_BLOCK.IMAGE, OPENAI_BLOCK.INPUT_AUDIO, OPENAI_BLOCK.AUDIO_URL, OPENAI_BLOCK.FILE,
+];
+export const VALID_OPENAI_MESSAGE_TYPES = [
+  OPENAI_BLOCK.TEXT, OPENAI_BLOCK.IMAGE_URL, OPENAI_BLOCK.IMAGE, "tool_calls", CLAUDE_BLOCK.TOOL_RESULT,
+];

package/app/open-sse/translator/schema/defaults.js

@@ -0,0 +1,7 @@
+// Shared translator default values (magic strings used across multiple translators).
+
+// Fallback model id when upstream chunk omits one.
+export const MODEL_FALLBACK = "unknown";
+
+// Default image mime when source omits it (base64 blobs without a declared type).
+export const DEFAULT_IMAGE_MIME = "image/png";

package/app/open-sse/translator/schema/finishReasons.js

@@ -0,0 +1,27 @@
+// Finish/stop reason enums. Pure data — mapping LOGIC lives in concerns/finishReason.js.
+
+// OpenAI finish_reason values (the hub format; shared across all response translators).
+export const OPENAI_FINISH = {
+  STOP: "stop",
+  LENGTH: "length",
+  TOOL_CALLS: "tool_calls",
+  CONTENT_FILTER: "content_filter",
+};
+
+// Claude stop_reason values.
+export const CLAUDE_STOP = {
+  END_TURN: "end_turn",
+  MAX_TOKENS: "max_tokens",
+  TOOL_USE: "tool_use",
+  STOP_SEQUENCE: "stop_sequence",
+};
+
+// Gemini finishReason values.
+export const GEMINI_FINISH = {
+  STOP: "STOP",
+  MAX_TOKENS: "MAX_TOKENS",
+  SAFETY: "SAFETY",
+  RECITATION: "RECITATION",
+  BLOCKLIST: "BLOCKLIST",
+  PROHIBITED_CONTENT: "PROHIBITED_CONTENT",
+};

package/app/open-sse/translator/schema/index.js

@@ -0,0 +1,8 @@
+// Translator schema barrel — pure data enums (roles, blocks). No logic here.
+export { ROLE, GEMINI_ROLE } from "./roles.js";
+export {
+  OPENAI_BLOCK, CLAUDE_BLOCK, RESPONSES_ITEM,
+  VALID_OPENAI_CONTENT_TYPES, VALID_OPENAI_MESSAGE_TYPES,
+} from "./blocks.js";
+export { OPENAI_FINISH, CLAUDE_STOP, GEMINI_FINISH } from "./finishReasons.js";
+export { MODEL_FALLBACK, DEFAULT_IMAGE_MIME } from "./defaults.js";

package/app/open-sse/translator/schema/roles.js

@@ -0,0 +1,16 @@
+// Role enums — fixed per format. Pure data (no logic).
+// OpenAI chat / Claude share these; mapping between them stays in translators.
+
+export const ROLE = {
+  USER: "user",
+  ASSISTANT: "assistant",
+  TOOL: "tool",
+  SYSTEM: "system",
+  DEVELOPER: "developer",
+};
+
+// Gemini / Antigravity use "model" instead of "assistant".
+export const GEMINI_ROLE = {
+  USER: "user",
+  MODEL: "model",
+};

package/app/open-sse/utils/bypassHandler.js

@@ -247,9 +247,24 @@ function mergeChunksToResponse(chunks, sourceFormat) {
 
       if (messageStart?.message) {
         finalChunk = messageStart.message;
-        // Merge usage if available
-        if (messageDelta?.usage) {
-          finalChunk.usage = messageDelta.usage;
+        // message_start.usage has input + cache; message_delta.usage has the
+        // final output_tokens. Merge so cache survives (delta omits it).
+        const startUsage = messageStart.message.usage;
+        const deltaUsage = messageDelta?.usage;
+        if (startUsage || deltaUsage) {
+          finalChunk.usage = {
+            ...(startUsage || {}),
+            ...(deltaUsage || {}),
+            ...(startUsage?.cache_read_input_tokens !== undefined
+              ? { cache_read_input_tokens: startUsage.cache_read_input_tokens }
+              : {}),
+            ...(startUsage?.cache_creation_input_tokens !== undefined
+              ? { cache_creation_input_tokens: startUsage.cache_creation_input_tokens }
+              : {}),
+            ...(startUsage?.input_tokens !== undefined
+              ? { input_tokens: startUsage.input_tokens }
+              : {})
+          };
         }
       }
     }

package/app/open-sse/utils/claudeCloaking.js

@@ -13,11 +13,18 @@ function generateBillingHeader(payload) {
   return `x-anthropic-billing-header: cc_version=${CLAUDE_VERSION}.${buildHash}; cc_entrypoint=${CC_ENTRYPOINT}; cch=${cch};`;
 }
 
+// Derive a deterministic UUID-v4-shaped string from a seed (stable per account)
+function deriveUuid(seed) {
+  const h = createHash("sha256").update(seed).digest("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-${((parseInt(h[16], 16) & 0x3) | 0x8).toString(16)}${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+
 // Generate fake user ID in Claude Code 2.1.92+ JSON format:
 // {"device_id":"<64hex>","account_uuid":"<uuid>","session_id":"<uuid>"}
-function generateFakeUserID(sessionId) {
-  const deviceId = randomBytes(32).toString("hex");
-  const accountUuid = randomUUID();
+// device_id/account_uuid derive from apiKey (stable per account), session_id per-conversation
+function generateFakeUserID(sessionId, apiKey) {
+  const deviceId = apiKey ? createHash("sha256").update(`device:${apiKey}`).digest("hex") : randomBytes(32).toString("hex");
+  const accountUuid = apiKey ? deriveUuid(`account:${apiKey}`) : randomUUID();
   const sessionUuid = sessionId || randomUUID();
   return `{"device_id":"${deviceId}","account_uuid":"${accountUuid}","session_id":"${sessionUuid}"}`;
 }
@@ -40,8 +47,11 @@ export function cloakClaudeTools(body) {
   const clientToolNames = new Set();
   const clientDeclarations = [];
 
-  // All client tools get renamed with suffix
+  // All client tools get renamed with suffix.
+  // Built-in server tools (web_search_20250305, etc.) carry a `type` and require
+  // an exact reserved `name` — never suffix those or Claude rejects the request.
   for (const tool of tools) {
+    if (tool.type) { clientDeclarations.push(tool); continue; }
     const suffixed = suffix(tool.name);
     toolNameMap.set(suffixed, tool.name);
     clientToolNames.add(tool.name);
@@ -148,7 +158,7 @@ export function applyCloaking(body, apiKey, sessionId) {
   // Inject fake user ID into metadata (session_id must match X-Claude-Code-Session-Id)
   const existingUserId = result.metadata?.user_id;
   if (!existingUserId) {
-    result.metadata = { ...result.metadata, user_id: generateFakeUserID(sessionId) };
+    result.metadata = { ...result.metadata, user_id: generateFakeUserID(sessionId, apiKey) };
   }
 
   return result;

package/app/open-sse/utils/claudeSignature.js

@@ -0,0 +1,41 @@
+// Claude thinking signature validation (ported from CLIProxyAPI internal/signature).
+// E-form: single-layer base64, decoded[0] == 0x12 (Claude marker).
+// R-form: double-layer base64, outer decoded[0] == 'E', inner decoded[0] == 0x12.
+// Cache prefix "...#sig" stripped before validation.
+
+const MAX_CLAUDE_SIGNATURE_LEN = 32 * 1024 * 1024;
+const CLAUDE_SIGNATURE_MARKER = 0x12;
+
+function stripCachePrefix(rawSignature) {
+  const sig = (rawSignature || "").trim();
+  if (!sig) return "";
+  const idx = sig.indexOf("#");
+  return idx >= 0 ? sig.slice(idx + 1).trim() : sig;
+}
+
+export function hasClaudeSignaturePrefix(rawSignature) {
+  const sig = stripCachePrefix(rawSignature);
+  return sig.length > 0 && (sig[0] === "E" || sig[0] === "R");
+}
+
+// Strict-ish: validates base64 layers + Claude marker byte.
+export function isValidClaudeSignature(rawSignature) {
+  const sig = stripCachePrefix(rawSignature);
+  if (!sig || sig.length > MAX_CLAUDE_SIGNATURE_LEN) return false;
+
+  try {
+    if (sig[0] === "E") {
+      const decoded = Buffer.from(sig, "base64");
+      return decoded.length > 0 && decoded[0] === CLAUDE_SIGNATURE_MARKER;
+    }
+    if (sig[0] === "R") {
+      const outer = Buffer.from(sig, "base64");
+      if (!outer.length || outer[0] !== 0x45) return false; // 'E'
+      const inner = Buffer.from(outer.toString(), "base64");
+      return inner.length > 0 && inner[0] === CLAUDE_SIGNATURE_MARKER;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}

package/app/open-sse/utils/reasoningContentInjector.js

@@ -1,15 +1,12 @@
 // Some thinking-mode providers (DeepSeek, Kimi, MiniMax, ...) require reasoning_content
 // to be echoed back on assistant messages. Clients in OpenAI format don't send it,
 // so we inject a non-empty placeholder to satisfy upstream validation.
+import { PROVIDERS } from "../config/providers.js";
 
 const PLACEHOLDER = " ";
 
-// Provider-level rules: keyed by executor.provider
-const PROVIDER_RULES = {
-  deepseek: { scope: "all" },
-  minimax: { scope: "all" },
-  "minimax-cn": { scope: "all" }
-};
+// Provider-level rules derive from registry transport.reasoningInject (single source)
+const providerRuleFor = (provider) => PROVIDERS[provider]?.reasoningInject;
 
 // Model-level rules: matched by predicate against model id
 const MODEL_RULES = [
@@ -71,7 +68,7 @@ function applyDeepSeekV4ProAlias({ provider, model, body }) {
 }
 
 export function injectReasoningContent({ provider, model, body }) {
-  const providerRule = PROVIDER_RULES[provider];
+  const providerRule = providerRuleFor(provider);
   const modelRule = MODEL_RULES.find(r => r.match(model));
   const rule = providerRule || modelRule;
   const nextBody = applyDeepSeekV4ProAlias({ provider, model, body });

package/app/open-sse/utils/responsesStreamHelpers.js

@@ -5,6 +5,7 @@ import { formatSSE } from "./streamHelpers.js";
 // Responses API events that signal the stream has reached a terminal state
 const OPENAI_RESPONSES_TERMINAL_EVENTS = new Set([
   "response.completed",
+  "response.done",
   "response.failed",
   "error"
 ]);

package/app/open-sse/utils/sessionManager.js

@@ -79,4 +79,153 @@ export function generateBinaryStyleId() {
  */
 export function clearSessionStore() {
     runtimeSessionStore.clear();
+    assistantSessionStore.clear();
 }
+
+// Conversation-stable session store: Key = hash(scope+assistant text), Value = { sessionId, lastUsed }
+const assistantSessionStore = new Map();
+const ASSISTANT_MIN_LEN = 50;
+const ASSISTANT_CAP_LEN = 50;
+const MAX_ASSISTANT_SESSIONS = 5000;
+
+// Client headers/body fields that carry an upstream session id (priority order)
+const SESSION_HEADER_KEYS = ["x-session-id", "session-id", "session_id", "x-amp-thread-id", "x-client-request-id"];
+const CLAUDE_CODE_SESSION_RE = /_session_([a-f0-9-]+)$/;
+
+function sha16(text) {
+    return crypto.createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+
+// Normalize a session id candidate (trim, length cap)
+function normalizeSessionId(value) {
+    if (typeof value !== "string") return null;
+    const v = value.trim();
+    if (!v || v.length > 256) return null;
+    return v;
+}
+
+// Extract Claude Code session id from metadata.user_id (_session_{uuid} | JSON {session_id})
+function extractClaudeCodeSession(userId) {
+    if (typeof userId !== "string" || !userId) return null;
+    const m = userId.match(CLAUDE_CODE_SESSION_RE);
+    if (m) return m[1];
+    if (userId[0] === "{") {
+        try { return normalizeSessionId(JSON.parse(userId)?.session_id); } catch { /* noop */ }
+    }
+    return null;
+}
+
+// Lowercase-key lookup for raw client headers
+function headerValue(headers, key) {
+    if (!headers || typeof headers !== "object") return null;
+    return normalizeSessionId(headers[key] ?? headers[key.toLowerCase()]);
+}
+
+// Read client-provided session id from headers/body (no generation)
+// Antigravity envelope carries session in request.sessionId; requestId embeds conversation uuid
+const ANTIGRAVITY_CONV_RE = /^[a-z]+\/([0-9a-f-]{36})\//i;
+function extractAntigravitySession(body) {
+    const sid = body?.request?.sessionId;
+    if (sid != null && sid !== "") return normalizeSessionId(String(sid));
+    const m = typeof body?.requestId === "string" ? body.requestId.match(ANTIGRAVITY_CONV_RE) : null;
+    return m ? normalizeSessionId(m[1]) : null;
+}
+
+function extractClientSessionId(headers, body) {
+    const claude = extractClaudeCodeSession(body?.metadata?.user_id);
+    if (claude) return `claude:${claude}`;
+    const antigravity = extractAntigravitySession(body);
+    if (antigravity) return `antigravity:${antigravity}`;
+    for (const key of SESSION_HEADER_KEYS) {
+        const v = headerValue(headers, key);
+        if (v) return v;
+    }
+    const fromBody =
+        normalizeSessionId(body?.prompt_cache_key) ||
+        normalizeSessionId(body?.session_id) ||
+        normalizeSessionId(body?.conversation_id) ||
+        normalizeSessionId(body?.metadata?.user_id);
+    return fromBody || null;
+}
+
+// Accumulate assistant text from OpenAI/Responses-style input/messages (cap-limited)
+function accumulateAssistantText(body) {
+    const items = Array.isArray(body?.input) ? body.input
+        : Array.isArray(body?.messages) ? body.messages : null;
+    if (!items) return "";
+    let text = "";
+    for (const item of items) {
+        if (item?.role !== "assistant") continue;
+        if (typeof item.content === "string") text += item.content;
+        else if (Array.isArray(item.content)) {
+            for (const c of item.content) text += c?.text || c?.output || "";
+        }
+        if (text.length >= ASSISTANT_CAP_LEN) break;
+    }
+    return text;
+}
+
+// Stable session id keyed on accumulated assistant text (avoids collision on identical first user prompt)
+function assistantTextSessionId(scope, body) {
+    const text = accumulateAssistantText(body);
+    if (text.length < ASSISTANT_MIN_LEN) return null;
+    const hash = sha16(`${scope}:${text.slice(0, ASSISTANT_CAP_LEN)}`);
+    const existing = assistantSessionStore.get(hash);
+    if (existing) {
+        existing.lastUsed = Date.now();
+        return existing.sessionId;
+    }
+    if (assistantSessionStore.size >= MAX_ASSISTANT_SESSIONS) {
+        assistantSessionStore.delete(assistantSessionStore.keys().next().value);
+    }
+    const sessionId = generateBinaryStyleId();
+    assistantSessionStore.set(hash, { sessionId, lastUsed: Date.now() });
+    return sessionId;
+}
+
+/**
+ * Resolve a conversation-stable session id (generalizes Codex resolveCacheSessionId).
+ * Priority: client session → accumulated-assistant-text hash → workspaceId → per-connection.
+ *
+ * @param {object} opts
+ * @param {object} [opts.headers] - Raw client request headers (lowercase keys)
+ * @param {object} [opts.body] - Parsed request body
+ * @param {string} [opts.connectionId] - Connection identifier (fallback scope)
+ * @param {string} [opts.workspaceId] - Provider workspace id (account-wide fallback)
+ * @param {string} [opts.scope] - Provider scope to isolate cache keys across providers
+ * @returns {string} A stable session id
+ */
+export function resolveSessionId({ headers, body, connectionId, workspaceId, scope = "" } = {}) {
+    const client = extractClientSessionId(headers, body);
+    if (client) return client;
+    const fromAssistant = assistantTextSessionId(`${scope}:${connectionId || ""}`, body);
+    if (fromAssistant) return fromAssistant;
+    const ws = normalizeSessionId(workspaceId);
+    if (ws) return ws;
+    return deriveSessionId(connectionId);
+}
+
+// Capture session id from request body + credentials (envelope still intact here)
+export function captureSessionId(body, credentials, connectionId, scope = "") {
+    return resolveSessionId({ headers: credentials?.rawHeaders, body, connectionId, scope });
+}
+
+// Convert any session id to Antigravity numeric format "-<int64>" (matches real AG / CLIProxyAPI).
+// Already-numeric ids (native AG sessionId) pass through unchanged.
+export function toNumericSessionId(sessionId) {
+    const v = normalizeSessionId(sessionId);
+    if (!v) return null;
+    if (/^-?\d+$/.test(v)) return v;
+    const h = crypto.createHash("sha256").update(v).digest();
+    const n = h.readBigUInt64BE(0) & 0x7fffffffffffffffn;
+    return `-${n.toString()}`;
+}
+
+// Cleanup expired assistant-session entries
+const assistantCleanup = setInterval(() => {
+    const now = Date.now();
+    for (const [key, entry] of assistantSessionStore) {
+        if (now - entry.lastUsed > MEMORY_CONFIG.sessionTtlMs) assistantSessionStore.delete(key);
+    }
+}, MEMORY_CONFIG.sessionCleanupIntervalMs);
+if (assistantCleanup.unref) assistantCleanup.unref();

package/app/open-sse/utils/sse.js

@@ -0,0 +1,14 @@
+export function sseChunk(data) {
+  return `data: ${JSON.stringify(data)}\n\n`;
+}
+
+// Build OpenAI chat.completion.chunk SSE frame. Key order: id, object, created, model, choices.
+export function chatChunkSse({ id, created, model, delta, finishReason = null }) {
+  return sseChunk({
+    id,
+    object: "chat.completion.chunk",
+    created,
+    model,
+    choices: [{ index: 0, delta, finish_reason: finishReason }],
+  });
+}

package/app/open-sse/utils/sseConstants.js

@@ -0,0 +1,23 @@
+// Shared SSE primitives (no imports → safe for executors + stream.js)
+export const SSE_DONE = "data: [DONE]\n\n";
+
+export const SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "Connection": "keep-alive"
+};
+
+// Variant for web-cookie executors behind nginx (disable proxy buffering)
+export const SSE_HEADERS_NO_BUFFER = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "X-Accel-Buffering": "no"
+};
+
+// Variant for client-facing SSE responses (adds permissive CORS)
+export const SSE_HEADERS_CORS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  "Connection": "keep-alive",
+  "Access-Control-Allow-Origin": "*"
+};