@fudrouter/fsrouter 0.6.62 → 0.6.63

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

@@ -0,0 +1,265 @@
+import { register } from "../index.js";
+import { FORMATS } from "../formats.js";
+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
+function sanitizeToolArgs(toolName, argsJson) {
+  try {
+    const args = JSON.parse(argsJson);
+    const name = toolName.startsWith(CLAUDE_OAUTH_TOOL_PREFIX)
+      ? toolName.slice(CLAUDE_OAUTH_TOOL_PREFIX.length)
+      : toolName;
+    if (name === "Read") sanitizeReadArgs(args);
+    return JSON.stringify(args);
+  } catch {
+    return argsJson;
+  }
+}
+
+function sanitizeReadArgs(args) {
+  if (typeof args.limit === "string" && /^\d+$/.test(args.limit)) args.limit = Number(args.limit);
+  if (typeof args.offset === "string" && /^-?\d+$/.test(args.offset)) args.offset = Number(args.offset);
+
+  if (typeof args.limit === "number") {
+    if (args.limit > 2000) args.limit = 2000;
+    if (args.limit < 1) delete args.limit;
+  }
+  if (typeof args.offset === "number" && args.offset < 0) args.offset = 0;
+
+  if ("pages" in args && !isValidPdfPagesArg(args.file_path, args.pages)) {
+    delete args.pages;
+  }
+}
+
+function isValidPdfPagesArg(filePath, pages) {
+  return typeof filePath === "string" &&
+    filePath.toLowerCase().endsWith(".pdf") &&
+    typeof pages === "string" &&
+    /^\d+(?:-\d+)?$/.test(pages);
+}
+
+// Helper: stop thinking block if started
+function stopThinkingBlock(state, results) {
+  if (!state.thinkingBlockStarted) return;
+  results.push({
+    type: "content_block_stop",
+    index: state.thinkingBlockIndex
+  });
+  state.thinkingBlockStarted = false;
+}
+
+// Helper: stop text block if started
+function stopTextBlock(state, results) {
+  if (!state.textBlockStarted || state.textBlockClosed) return;
+  state.textBlockClosed = true;
+  results.push({
+    type: "content_block_stop",
+    index: state.textBlockIndex
+  });
+  state.textBlockStarted = false;
+}
+
+// Convert OpenAI stream chunk to Claude format
+export function openaiToClaudeResponse(chunk, state) {
+  if (!chunk || !chunk.choices?.[0]) return null;
+
+  const results = [];
+  const choice = chunk.choices[0];
+  const delta = choice.delta;
+
+  // Track usage from OpenAI chunk if available
+  if (chunk.usage && typeof chunk.usage === "object") {
+    const promptTokens = typeof chunk.usage.prompt_tokens === "number" ? chunk.usage.prompt_tokens : 0;
+    const outputTokens = typeof chunk.usage.completion_tokens === "number" ? chunk.usage.completion_tokens : 0;
+
+    // Extract cache tokens from prompt_tokens_details
+    const cachedTokens = chunk.usage.prompt_tokens_details?.cached_tokens;
+    const cacheCreationTokens = chunk.usage.prompt_tokens_details?.cache_creation_tokens;
+    const cacheReadTokens = typeof cachedTokens === "number" ? cachedTokens : 0;
+    const cacheCreateTokens = typeof cacheCreationTokens === "number" ? cacheCreationTokens : 0;
+
+    // input_tokens = prompt_tokens - cached_tokens - cache_creation_tokens
+    // Because OpenAI's prompt_tokens includes all prompt-side tokens
+    const inputTokens = promptTokens - cacheReadTokens - cacheCreateTokens;
+
+    state.usage = {
+      input_tokens: inputTokens,
+      output_tokens: outputTokens
+    };
+
+    // Add cache_read_input_tokens if present
+    if (cacheReadTokens > 0) {
+      state.usage.cache_read_input_tokens = cacheReadTokens;
+    }
+
+    // Add cache_creation_input_tokens if present
+    if (cacheCreateTokens > 0) {
+      state.usage.cache_creation_input_tokens = cacheCreateTokens;
+    }
+
+    // Note: completion_tokens_details.reasoning_tokens is already included in output_tokens
+    // No need to add separately as Claude expects total output_tokens
+  }
+
+  // First chunk - ALWAYS send message_start first
+  if (!state.messageStartSent) {
+    state.messageStartSent = true;
+    state.messageId = chunk.id?.replace("chatcmpl-", "") || `msg_${Date.now()}`;
+    if (!state.messageId || state.messageId === "chat" || state.messageId.length < 8) {
+      state.messageId = chunk.extend_fields?.requestId ||
+        chunk.extend_fields?.traceId ||
+        `msg_${Date.now()}`;
+    }
+    state.model = chunk.model || MODEL_FALLBACK;
+    state.nextBlockIndex = 0;
+    results.push({
+      type: "message_start",
+      message: {
+        id: state.messageId,
+        type: "message",
+        role: ROLE.ASSISTANT,
+        model: state.model,
+        content: [],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 }
+      }
+    });
+  }
+
+  // Handle reasoning (thinking) across vendor shapes - GLM/DeepSeek/Qwen/MiniMax/etc.
+  const reasoningContent = extractReasoningText(delta);
+  if (reasoningContent) {
+    stopTextBlock(state, results);
+
+    if (!state.thinkingBlockStarted) {
+      state.thinkingBlockIndex = state.nextBlockIndex++;
+      state.thinkingBlockStarted = true;
+      results.push({
+        type: "content_block_start",
+        index: state.thinkingBlockIndex,
+        content_block: { type: CLAUDE_BLOCK.THINKING, thinking: "" }
+      });
+    }
+
+    results.push({
+      type: "content_block_delta",
+      index: state.thinkingBlockIndex,
+      delta: { type: "thinking_delta", thinking: reasoningContent }
+    });
+  }
+
+  // Handle regular content
+  if (delta?.content) {
+    stopThinkingBlock(state, results);
+
+    if (!state.textBlockStarted) {
+      state.textBlockIndex = state.nextBlockIndex++;
+      state.textBlockStarted = true;
+      state.textBlockClosed = false;
+      results.push({
+        type: "content_block_start",
+        index: state.textBlockIndex,
+        content_block: { type: CLAUDE_BLOCK.TEXT, text: "" }
+      });
+    }
+
+    results.push({
+      type: "content_block_delta",
+      index: state.textBlockIndex,
+      delta: { type: "text_delta", text: delta.content }
+    });
+  }
+
+  // Tool calls
+  if (delta?.tool_calls) {
+    for (const tc of delta.tool_calls) {
+      const idx = tc.index ?? 0;
+
+      // 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);
+
+        const toolBlockIndex = state.nextBlockIndex++;
+        state.toolCalls.set(idx, { id: tc.id, name: tc.function?.name || "", blockIndex: toolBlockIndex });
+
+        // Strip prefix from tool name for response
+        let toolName = tc.function?.name || "";
+        if (toolName.startsWith(CLAUDE_OAUTH_TOOL_PREFIX)) {
+          toolName = toolName.slice(CLAUDE_OAUTH_TOOL_PREFIX.length);
+        }
+
+        results.push({
+          type: "content_block_start",
+          index: toolBlockIndex,
+          content_block: {
+            type: CLAUDE_BLOCK.TOOL_USE,
+            id: tc.id,
+            name: toolName,
+            input: {}
+          }
+        });
+      }
+
+      if (tc.function?.arguments) {
+        const toolInfo = state.toolCalls.get(idx);
+        if (toolInfo) {
+          // Buffer args instead of streaming — sanitize at finish to fix bad params
+          if (!state.toolArgBuffers) state.toolArgBuffers = new Map();
+          state.toolArgBuffers.set(idx, (state.toolArgBuffers.get(idx) || "") + tc.function.arguments);
+        }
+      }
+    }
+  }
+
+  // Finish
+  if (choice.finish_reason) {
+    stopThinkingBlock(state, results);
+    stopTextBlock(state, results);
+
+    for (const [idx, toolInfo] of state.toolCalls) {
+      // Emit buffered + sanitized args as single delta before stop
+      const buffered = state.toolArgBuffers?.get(idx);
+      if (buffered) {
+        const sanitized = sanitizeToolArgs(toolInfo.name, buffered);
+        results.push({
+          type: "content_block_delta",
+          index: toolInfo.blockIndex,
+          delta: { type: "input_json_delta", partial_json: sanitized }
+        });
+      }
+      results.push({
+        type: "content_block_stop",
+        index: toolInfo.blockIndex
+      });
+    }
+
+    // Mark finish for later usage injection in stream.js
+    state.finishReason = choice.finish_reason;
+
+    // Use tracked usage (will be estimated in stream.js if not valid)
+    const finalUsage = state.usage || { input_tokens: 0, output_tokens: 0 };
+    results.push({
+      type: "message_delta",
+      delta: { stop_reason: convertFinishReason(choice.finish_reason) },
+      usage: finalUsage
+    });
+    results.push({ type: "message_stop" });
+  }
+
+  return results.length > 0 ? results : null;
+}
+
+const convertFinishReason = (reason) => fromOpenAIFinish(reason, "claude");
+
+// Register
+register(FORMATS.OPENAI, FORMATS.CLAUDE, null, openaiToClaudeResponse);

package/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/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/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/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/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/open-sse/utils/agentGoalPolicy.js

@@ -0,0 +1,85 @@
+const DEFAULT_AGENT_GOAL_READINESS_MAX_TIMEOUT_MS = 6e5;
+const GOAL_COMMAND_RE = /(^|[\s"'`])\/goal(?=$|[\s"'`:;,.!?])/i;
+const MAX_VISITED_NODES = 5e3;
+const MAX_STRING_CHARS = 256e3;
+function readHeader(headers, name) {
+  if (!headers) return null;
+  if (typeof headers.get === "function") {
+    return headers.get(name);
+  }
+  const lower = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== lower) continue;
+    if (Array.isArray(value)) return value.join(",");
+    return typeof value === "string" ? value : null;
+  }
+  return null;
+}
+function parseBoolean(value, fallback) {
+  if (value == null || value.trim() === "") return fallback;
+  const normalized = value.trim().toLowerCase();
+  if (["true", "1", "yes", "on"].includes(normalized)) return true;
+  if (["false", "0", "no", "off"].includes(normalized)) return false;
+  return fallback;
+}
+function readPositiveMs(env, name, fallback) {
+  const raw = env[name];
+  if (raw == null || raw.trim() === "") return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+function hasGoalCommandText(value) {
+  const sample = value.length > MAX_STRING_CHARS ? value.slice(0, MAX_STRING_CHARS) : value;
+  return GOAL_COMMAND_RE.test(sample);
+}
+function isAgentGoalRequestBody(body) {
+  const seen = /* @__PURE__ */ new Set();
+  let visited = 0;
+  const visit = (value, depth) => {
+    if (visited++ > MAX_VISITED_NODES || depth > 10) return false;
+    if (typeof value === "string") return hasGoalCommandText(value);
+    if (!value || typeof value !== "object") return false;
+    if (seen.has(value)) return false;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (visit(item, depth + 1)) return true;
+      }
+      return false;
+    }
+    for (const [key, child] of Object.entries(value)) {
+      if (key === "metadata" || key === "usage") continue;
+      if (visit(child, depth + 1)) return true;
+    }
+    return false;
+  };
+  return visit(body, 0);
+}
+function resolveAgentGoalPolicy(body, headers = null, env = process.env) {
+  const policyEnabled = parseBoolean(env.OMNIROUTE_AGENT_GOAL_POLICY_ENABLED, true);
+  if (!policyEnabled) {
+    return {
+      detected: false,
+      readinessMaxTimeoutMs: DEFAULT_AGENT_GOAL_READINESS_MAX_TIMEOUT_MS,
+      streamRecoveryEnabled: false
+    };
+  }
+  const forcedByHeader = parseBoolean(readHeader(headers, "x-omniroute-agent-goal"), false);
+  const detected = forcedByHeader || isAgentGoalRequestBody(body);
+  const readinessMaxTimeoutMs = readPositiveMs(
+    env,
+    "OMNIROUTE_AGENT_GOAL_READINESS_MAX_TIMEOUT_MS",
+    DEFAULT_AGENT_GOAL_READINESS_MAX_TIMEOUT_MS
+  );
+  const streamRecoveryEnabled = detected && parseBoolean(env.OMNIROUTE_AGENT_GOAL_STREAM_RECOVERY, true);
+  return {
+    detected,
+    readinessMaxTimeoutMs,
+    streamRecoveryEnabled
+  };
+}
+export {
+  DEFAULT_AGENT_GOAL_READINESS_MAX_TIMEOUT_MS,
+  isAgentGoalRequestBody,
+  resolveAgentGoalPolicy
+};

package/open-sse/utils/aiSdkCompat.js

@@ -0,0 +1,75 @@
+function normalizeResolveStreamFlagOptions(optionsOrUserAgent) {
+  if (optionsOrUserAgent && typeof optionsOrUserAgent === "object" && !Array.isArray(optionsOrUserAgent)) {
+    return optionsOrUserAgent;
+  }
+  return { userAgent: optionsOrUserAgent };
+}
+function normalizeStreamDefaultMode(value) {
+  return value === "json" ? "json" : "legacy";
+}
+function clientWantsJsonResponse(acceptHeader) {
+  if (typeof acceptHeader !== "string") return false;
+  const normalized = acceptHeader.toLowerCase();
+  return normalized.includes("application/json") && !normalized.includes("text/event-stream");
+}
+function acceptHeaderForcesStream(acceptHeader, bodyStream) {
+  if (bodyStream !== void 0) return false;
+  if (typeof acceptHeader !== "string") return false;
+  const normalized = acceptHeader.toLowerCase();
+  return normalized.includes("text/event-stream") && !normalized.includes("application/json");
+}
+function resolveStreamFlag(bodyStream, acceptHeader, sourceFormat, optionsOrUserAgent) {
+  const options = normalizeResolveStreamFlagOptions(optionsOrUserAgent);
+  if (options.providerRequiresStreaming) return true;
+  if (bodyStream === true) return true;
+  if (bodyStream === false) return false;
+  const streamDefaultMode = normalizeStreamDefaultMode(options.streamDefaultMode);
+  const acceptsEventStream = typeof acceptHeader === "string" && /text\/event-stream/i.test(acceptHeader);
+  if (sourceFormat === "claude" || sourceFormat === "openai-responses") {
+    if (acceptsEventStream) return true;
+    return false;
+  }
+  if (isKnownJsonOnlyClient(options.userAgent) && !acceptsEventStream) {
+    return false;
+  }
+  if (streamDefaultMode === "json" && !acceptsEventStream) {
+    return false;
+  }
+  if (typeof acceptHeader === "string" && /application\/json/i.test(acceptHeader)) {
+    return false;
+  }
+  return !clientWantsJsonResponse(acceptHeader);
+}
+function isKnownJsonOnlyClient(userAgent) {
+  if (typeof userAgent !== "string") return false;
+  return /nextcloud\s+openai\/localai\s+integration/i.test(userAgent);
+}
+function resolveExplicitStreamAlias(body) {
+  if (!body || typeof body !== "object") return void 0;
+  const b = body;
+  if (b.streaming === true) return true;
+  if (b.streaming === false) return false;
+  if (b.non_stream === true) return false;
+  if (b.disable_stream === true) return false;
+  if (b.disable_streaming === true) return false;
+  return void 0;
+}
+function hasExplicitNoStreamParam(body) {
+  return resolveExplicitStreamAlias(body) === false;
+}
+function stripMarkdownCodeFence(text) {
+  if (typeof text !== "string") return text;
+  const codeBlockRegex = /^```(?:json|javascript|typescript|js|ts)?\s*\n?([\s\S]*?)\n?```\s*$/i;
+  const match = text.trim().match(codeBlockRegex);
+  return match ? match[1].trim() : text;
+}
+export {
+  acceptHeaderForcesStream,
+  clientWantsJsonResponse,
+  hasExplicitNoStreamParam,
+  isKnownJsonOnlyClient,
+  normalizeStreamDefaultMode,
+  resolveExplicitStreamAlias,
+  resolveStreamFlag,
+  stripMarkdownCodeFence
+};