@fudrouter/fsrouter 0.6.63 → 0.6.64

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

@@ -1,265 +0,0 @@
-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

@@ -1,43 +0,0 @@
-// 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

@@ -1,7 +0,0 @@
-// 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

@@ -1,27 +0,0 @@
-// 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

@@ -1,8 +0,0 @@
-// 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

@@ -1,16 +0,0 @@
-// 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

@@ -1,85 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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
-};