@fudrouter/fsrouter 0.6.64 → 0.6.66

package/open-sse/config/kiroConstants.js

@@ -0,0 +1,268 @@
+/**
+ * Kiro-specific constants and helpers.
+ *
+ * Mirrors the behaviour of `internal/translator/kiro/common/constants.go` and
+ * `internal/translator/kiro/claude/kiro_claude_request.go` from the
+ * CLIProxyAPIPlus reference implementation, scoped down to what 9router needs:
+ *
+ *   - `-agentic` model suffix detection + chunked-write system prompt
+ *   - reasoning / thinking trigger detection (Anthropic-Beta header,
+ *     Claude `thinking`, OpenAI `reasoning_effort`, AMP/Cursor magic tag)
+ *   - the `<thinking_mode>enabled</thinking_mode>` system-prompt injection
+ *     that turns Kiro reasoning on
+ *
+ * Kiro upstream does not advertise `-agentic` model IDs; they are a 9router
+ * fiction. The suffix is stripped before the request leaves this process.
+ */
+
+export const KIRO_AGENTIC_SUFFIX = "-agentic";
+export const KIRO_THINKING_SUFFIX = "-thinking";
+
+export const KIRO_THINKING_BUDGET_DEFAULT = 16000;
+
+export const KIRO_AGENTIC_SYSTEM_PROMPT = `
+# CRITICAL: CHUNKED WRITE PROTOCOL (MANDATORY)
+
+You MUST follow these rules for ALL file operations. Violation causes server timeouts and task failure.
+
+## ABSOLUTE LIMITS
+- **MAXIMUM 350 LINES** per single write/edit operation - NO EXCEPTIONS
+- **RECOMMENDED 300 LINES** or less for optimal performance
+- **NEVER** write entire files in one operation if >300 lines
+
+## MANDATORY CHUNKED WRITE STRATEGY
+
+### For NEW FILES (>300 lines total):
+1. FIRST: Write initial chunk (first 250-300 lines) using write_to_file/fsWrite
+2. THEN: Append remaining content in 250-300 line chunks using file append operations
+3. REPEAT: Continue appending until complete
+
+### For EDITING EXISTING FILES:
+1. Use surgical edits (apply_diff/targeted edits) - change ONLY what's needed
+2. NEVER rewrite entire files - use incremental modifications
+3. Split large refactors into multiple small, focused edits
+
+### For LARGE CODE GENERATION:
+1. Generate in logical sections (imports, types, functions separately)
+2. Write each section as a separate operation
+3. Use append operations for subsequent sections
+
+## EXAMPLES OF CORRECT BEHAVIOR
+
+CORRECT: Writing a 600-line file
+- Operation 1: Write lines 1-300 (initial file creation)
+- Operation 2: Append lines 301-600
+
+CORRECT: Editing multiple functions
+- Operation 1: Edit function A
+- Operation 2: Edit function B
+- Operation 3: Edit function C
+
+WRONG: Writing 500 lines in single operation -> TIMEOUT
+WRONG: Rewriting entire file to change 5 lines -> TIMEOUT
+WRONG: Generating massive code blocks without chunking -> TIMEOUT
+
+## WHY THIS MATTERS
+- Server has 2-3 minute timeout for operations
+- Large writes exceed timeout and FAIL completely
+- Chunked writes are FASTER and more RELIABLE
+- Failed writes waste time and require retry
+
+REMEMBER: When in doubt, write LESS per operation. Multiple small operations > one large operation.
+`.trim();
+
+/**
+ * Detect whether an inbound request is asking for reasoning / thinking output.
+ *
+ * Sources of intent (any one is enough):
+ *   - HTTP header `Anthropic-Beta: ...interleaved-thinking...`
+ *   - JSON `thinking.type === "enabled"` (Claude Messages API)
+ *   - JSON `reasoning_effort` in {low, medium, high, auto} (OpenAI o1/o3)
+ *   - JSON `reasoning.effort` in {low, medium, high, auto} (OpenAI Responses)
+ *   - System prompt contains `<thinking_mode>enabled</thinking_mode>` or
+ *     `<thinking_mode>interleaved</thinking_mode>` (AMP / Cursor)
+ *   - Model name contains `thinking` or `-reason`
+ *
+ * @param {object} body OpenAI-shaped request body (post-translation)
+ * @param {object} [headers] Original inbound HTTP headers (case-insensitive)
+ * @param {string} [model] Model id the caller asked for (post-strip ok)
+ * @returns {boolean}
+ */
+export function isThinkingEnabled(body, headers, model) {
+  if (headers) {
+    const beta = pickHeader(headers, "anthropic-beta");
+    if (typeof beta === "string" && beta.toLowerCase().includes("interleaved-thinking")) {
+      return true;
+    }
+  }
+
+  if (body && typeof body === "object") {
+    const thinking = body.thinking;
+    if (thinking && typeof thinking === "object" && thinking.type === "enabled") {
+      const budget = Number(thinking.budget_tokens);
+      if (!Number.isFinite(budget) || budget > 0) {
+        return true;
+      }
+    }
+
+    const effort = body.reasoning_effort
+      ?? (body.reasoning && typeof body.reasoning === "object" ? body.reasoning.effort : null);
+    if (typeof effort === "string") {
+      const v = effort.toLowerCase();
+      if (v && v !== "none" && (v === "low" || v === "medium" || v === "high" || v === "auto")) {
+        return true;
+      }
+    }
+
+    if (containsThinkingModeTag(body)) {
+      return true;
+    }
+  }
+
+  if (typeof model === "string" && model) {
+    const m = model.toLowerCase();
+    if (m.includes("thinking") || m.includes("-reason")) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Detect whether a model id refers to a 9router synthetic agentic variant.
+ * Agentic variants share the same upstream model as the base; the only
+ * difference is the chunked-write system prompt this module injects.
+ *
+ * @param {string} model
+ * @returns {boolean}
+ */
+export function isAgenticModel(model) {
+  return typeof model === "string" && model.endsWith(KIRO_AGENTIC_SUFFIX);
+}
+
+/**
+ * Strip the `-agentic` suffix from a model id, leaving the upstream-real id.
+ *
+ * @param {string} model
+ * @returns {string}
+ */
+export function stripAgenticSuffix(model) {
+  if (!isAgenticModel(model)) return model;
+  return model.slice(0, -KIRO_AGENTIC_SUFFIX.length);
+}
+
+/**
+ * Detect whether a model id is a 9router synthetic thinking variant
+ * (e.g. `claude-sonnet-4.5-thinking`). Same upstream model as the base; the
+ * only difference is `<thinking_mode>enabled</thinking_mode>` injection.
+ *
+ * Note: real Kiro thinking-capable variants exist (e.g. `kimi-k2-thinking` in
+ * other providers), but for the `kr/` namespace there is no `-thinking`
+ * model on Kiro upstream. Treat the suffix as a synthetic alias.
+ *
+ * @param {string} model Model id with `-agentic` already stripped
+ * @returns {boolean}
+ */
+export function isThinkingModel(model) {
+  return typeof model === "string" && model.endsWith(KIRO_THINKING_SUFFIX);
+}
+
+/**
+ * Strip the `-thinking` suffix from a model id.
+ *
+ * @param {string} model
+ * @returns {string}
+ */
+export function stripThinkingSuffix(model) {
+  if (!isThinkingModel(model)) return model;
+  return model.slice(0, -KIRO_THINKING_SUFFIX.length);
+}
+
+/**
+ * Resolve a 9router model id to the real upstream Kiro model id, plus flags
+ * describing which behaviours the suffixes implied.
+ *
+ *   resolveKiroModel("claude-sonnet-4.5-thinking-agentic")
+ *     => { upstream: "claude-sonnet-4.5", agentic: true, thinking: true }
+ *   resolveKiroModel("claude-sonnet-4.5-thinking")
+ *     => { upstream: "claude-sonnet-4.5", agentic: false, thinking: true }
+ *   resolveKiroModel("claude-sonnet-4.5-agentic")
+ *     => { upstream: "claude-sonnet-4.5", agentic: true, thinking: false }
+ *   resolveKiroModel("claude-sonnet-4.5")
+ *     => { upstream: "claude-sonnet-4.5", agentic: false, thinking: false }
+ *
+ * @param {string} model
+ * @returns {{ upstream: string, agentic: boolean, thinking: boolean }}
+ */
+export function resolveKiroModel(model) {
+  let upstream = model;
+  let agentic = false;
+  let thinking = false;
+  if (isAgenticModel(upstream)) {
+    agentic = true;
+    upstream = stripAgenticSuffix(upstream);
+  }
+  if (isThinkingModel(upstream)) {
+    thinking = true;
+    upstream = stripThinkingSuffix(upstream);
+  }
+  return { upstream, agentic, thinking };
+}
+
+/**
+ * Build the magic system-prompt prefix that turns Kiro reasoning on.
+ * Same shape as CLIProxyAPIPlus.
+ *
+ * @param {number} [budget=KIRO_THINKING_BUDGET_DEFAULT]
+ */
+export function buildThinkingSystemPrefix(budget = KIRO_THINKING_BUDGET_DEFAULT) {
+  const safeBudget = Math.max(1, Math.min(32000, Number(budget) || KIRO_THINKING_BUDGET_DEFAULT));
+  return `<thinking_mode>enabled</thinking_mode>\n<max_thinking_length>${safeBudget}</max_thinking_length>`;
+}
+
+function pickHeader(headers, name) {
+  if (!headers) return undefined;
+  if (typeof headers.get === "function") {
+    return headers.get(name);
+  }
+  const lower = name.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === lower) {
+      return headers[key];
+    }
+  }
+  return undefined;
+}
+
+function containsThinkingModeTag(body) {
+  const messages = Array.isArray(body?.messages) ? body.messages : [];
+  for (const msg of messages) {
+    if (!msg) continue;
+    if (msg.role !== "system" && msg.role !== "user") continue;
+    const content = msg.content;
+    if (typeof content === "string") {
+      if (containsTagInText(content)) return true;
+    } else if (Array.isArray(content)) {
+      for (const part of content) {
+        const text = part?.text;
+        if (typeof text === "string" && containsTagInText(text)) return true;
+      }
+    }
+  }
+  if (typeof body?.system === "string" && containsTagInText(body.system)) return true;
+  return false;
+}
+
+function containsTagInText(text) {
+  if (!text) return false;
+  if (!text.includes("<thinking_mode>")) return false;
+  return text.includes("<thinking_mode>enabled</thinking_mode>")
+    || text.includes("<thinking_mode>interleaved</thinking_mode>");
+}
+
+// Added from 9router - missing exports
+export function resolveDefaultProfileArn(authMethod) {
+  const social = authMethod === "google" || authMethod === "github";
+  return social ? KIRO_DEFAULT_PROFILE_ARNS.social : KIRO_DEFAULT_PROFILE_ARNS["builder-id"];
+}

package/open-sse/config/mediaConfig.js

@@ -0,0 +1,27 @@
+// Central config for remote-media fetching security limits.
+
+// Max bytes accepted from a remote image fetch (reject larger to prevent memory DoS).
+export const MAX_IMAGE_BYTES = 10 * 1024 * 1024; // 10MB
+
+// Fetch timeout for remote media.
+export const FETCH_TIMEOUT_MS = 10000;
+
+// Magic-byte signatures -> mime. Each entry: { sig:[bytes], offset, mime }.
+// offset>0 for containers where the signature is not at byte 0 (e.g. webp).
+export const IMAGE_SIGNATURES = [
+  { sig: [0x89, 0x50, 0x4e, 0x47], offset: 0, mime: "image/png" },
+  { sig: [0xff, 0xd8, 0xff], offset: 0, mime: "image/jpeg" },
+  { sig: [0x47, 0x49, 0x46, 0x38], offset: 0, mime: "image/gif" },
+  { sig: [0x52, 0x49, 0x46, 0x46], offset: 0, mime: "image/webp", verifyWebp: true },
+  { sig: [0x42, 0x4d], offset: 0, mime: "image/bmp" },
+];
+
+// Hostnames/IPs that must never be fetched (SSRF guard for loopback + cloud metadata).
+export const BLOCKED_HOSTS = new Set([
+  "localhost",
+  "127.0.0.1",
+  "0.0.0.0",
+  "::1",
+  "169.254.169.254", // AWS/GCP/Azure IMDS
+  "metadata.google.internal",
+]);

package/open-sse/config/mediaServiceKinds.js

@@ -0,0 +1,71 @@
+/**
+ * Media serviceKinds — derived from the backend registries.
+ *
+ * The dashboard's `/dashboard/media-providers/[kind]` pages list a provider
+ * under a media kind when the provider supports it. Historically this relied on
+ * a hand-maintained `serviceKinds` array on every provider in providers.ts,
+ * which had drifted badly: ~48 providers were wired into the audio/video/music/
+ * image/embedding registries (backend works) but declared no `serviceKinds`, so
+ * they never appeared in the UI.
+ *
+ * This module makes the registries the single source of truth: a provider that
+ * appears as a key in a media registry supports that kind, full stop. The UI
+ * derives membership from here instead of duplicating it by hand, so adding a
+ * provider to a registry automatically surfaces it — no second edit, no drift.
+ *
+ * Kinds without a backing registry (imageToText, webSearch, webFetch, llm) are
+ * still declared explicitly via `serviceKinds` on the provider entry; callers
+ * union the two sources.
+ */
+import { AUDIO_TRANSCRIPTION_PROVIDERS, AUDIO_SPEECH_PROVIDERS } from "./audioRegistry.js";
+import { VIDEO_PROVIDERS } from "./videoRegistry.js";
+import { MUSIC_PROVIDERS } from "./musicRegistry.js";
+import { IMAGE_PROVIDERS } from "./imageRegistry.js";
+import { EMBEDDING_PROVIDERS } from "./embeddingRegistry.js";
+import { OCR_PROVIDERS } from "./ocrRegistry.js";
+import { SEARCH_PROVIDERS } from "./searchRegistry.js";
+import { MODERATION_PROVIDERS } from "./moderationRegistry.js";
+import { RERANK_PROVIDERS } from "./rerankRegistry.js";
+
+/** Media kinds whose provider membership is defined by a backend registry. */
+export const MEDIA_KIND_REGISTRIES = {
+  stt: AUDIO_TRANSCRIPTION_PROVIDERS,
+  tts: AUDIO_SPEECH_PROVIDERS,
+  video: VIDEO_PROVIDERS,
+  music: MUSIC_PROVIDERS,
+  image: IMAGE_PROVIDERS,
+  embedding: EMBEDDING_PROVIDERS,
+  ocr: OCR_PROVIDERS,
+  search: SEARCH_PROVIDERS,
+  moderation: MODERATION_PROVIDERS,
+  rerank: RERANK_PROVIDERS,
+};
+
+export const REGISTRY_MEDIA_KINDS = Object.freeze(
+  Object.keys(MEDIA_KIND_REGISTRIES)
+);
+
+/**
+ * Media serviceKinds a provider supports, derived from the backend registries.
+ * Returns the kinds (e.g. `["tts","video","music"]`) for which `providerId`
+ * appears as a registry key. Empty array if the provider serves no media.
+ */
+export function getRegistryMediaKinds(providerId) {
+  const kinds = [];
+  for (const kind of REGISTRY_MEDIA_KINDS) {
+    if (Object.prototype.hasOwnProperty.call(MEDIA_KIND_REGISTRIES[kind], providerId)) {
+      kinds.push(kind);
+    }
+  }
+  return kinds;
+}
+
+/**
+ * Full set of serviceKinds for a provider: the explicitly declared ones (llm,
+ * web*, imageToText) unioned with the media kinds derived from the registries.
+ */
+export function resolveProviderServiceKinds(providerId, declared) {
+  const set = new Set(declared ?? []);
+  for (const kind of getRegistryMediaKinds(providerId)) set.add(kind);
+  return [...set];
+}

package/open-sse/config/models.js

@@ -0,0 +1,13 @@
+// Model metadata registry
+// Only define models that differ from DEFAULT_MODEL_INFO
+// Custom entries are merged over default
+const DEFAULT_MODEL_INFO = {
+  type: ["chat"],
+  contextWindow: 200000,
+};
+
+export const MODEL_INFO = {};
+
+export function getModelInfo(modelId) {
+  return { ...DEFAULT_MODEL_INFO, ...MODEL_INFO[modelId] };
+}

package/open-sse/config/moderationRegistry.js

@@ -0,0 +1,71 @@
+/**
+ * Moderation Provider Registry
+ *
+ * Defines providers that support the /v1/moderations endpoint.
+ * Follows OpenAI's moderation API format.
+ */
+
+export const MODERATION_PROVIDERS = {
+  openai: {
+    id: "openai",
+    baseUrl: "https://api.openai.com/v1/moderations",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [
+      { id: "omni-moderation-latest", name: "Omni Moderation Latest" },
+      { id: "text-moderation-latest", name: "Text Moderation Latest" },
+    ],
+  },
+  mistral: {
+    id: "mistral",
+    baseUrl: "https://api.mistral.ai/v1/moderations",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [{ id: "mistral-moderation-latest", name: "Mistral Moderation" }],
+  },
+};
+
+/**
+ * Get moderation provider config by ID.
+ */
+export function getModerationProvider(providerId) {
+  return MODERATION_PROVIDERS[providerId] || null;
+}
+
+/**
+ * Parse a moderation model string.
+ */
+export function parseModerationModel(modelStr) {
+  if (!modelStr) return { provider: null, model: null };
+
+  for (const providerId of Object.keys(MODERATION_PROVIDERS)) {
+    if (modelStr.startsWith(providerId + "/")) {
+      return { provider: providerId, model: modelStr.slice(providerId.length + 1) };
+    }
+  }
+
+  for (const [providerId, config] of Object.entries(MODERATION_PROVIDERS)) {
+    if (config.models.some((m) => m.id === modelStr)) {
+      return { provider: providerId, model: modelStr };
+    }
+  }
+
+  return { provider: null, model: modelStr };
+}
+
+/**
+ * Get all moderation models as a flat list.
+ */
+export function getAllModerationModels() {
+  const models = [];
+  for (const [providerId, config] of Object.entries(MODERATION_PROVIDERS)) {
+    for (const model of config.models) {
+      models.push({
+        id: `${providerId}/${model.id}`,
+        name: model.name,
+        provider: providerId,
+      });
+    }
+  }
+  return models;
+}

package/open-sse/config/musicRegistry.js

@@ -0,0 +1,99 @@
+/**
+ * Music Generation Provider Registry
+ *
+ * Defines providers that support the /v1/music/generations endpoint.
+ * Currently supports local providers (ComfyUI with audio models).
+ */
+
+import { parseModelFromRegistry, getAllModelsFromRegistry } from "./registryUtils.js";
+
+export const MUSIC_PROVIDERS = {
+  vertex: {
+    id: "vertex",
+    baseUrl: "https://us-central1-aiplatform.googleapis.com/v1",
+    authType: "apikey",
+    authHeader: "bearer",
+    format: "vertex-lyria",
+    models: [{ id: "lyria-002", name: "Lyria 2 (Vertex)" }],
+  },
+
+  kie: {
+    id: "kie",
+    baseUrl: "https://api.kie.ai",
+    statusUrl: "https://api.kie.ai/api/v1/jobs/recordInfo",
+    authType: "apikey",
+    authHeader: "bearer",
+    format: "kie-music",
+    models: [
+      { id: "suno-v4.0", name: "Suno V4.0" },
+      { id: "suno-v3.5", name: "Suno V3.5" },
+    ],
+  },
+
+  suno: {
+    id: "suno",
+    baseUrl: "https://studio-api.suno.ai/api/generate/v2/",
+    statusUrl: "https://studio-api.suno.ai/api/feed/",
+    authType: "cookie",
+    authHeader: "cookie",
+    format: "suno-music",
+    models: [
+      { id: "chirp-v3-5", name: "Chirp V3.5" },
+      { id: "chirp-v4", name: "Chirp V4" },
+    ],
+  },
+  udio: {
+    id: "udio",
+    baseUrl: "https://www.udio.com/api/generate-proxy",
+    statusUrl: "https://www.udio.com/api/songs",
+    authType: "cookie",
+    authHeader: "cookie",
+    format: "udio-music",
+    models: [{ id: "udio-default", name: "Udio Default" }],
+  },
+  minimax: {
+    id: "minimax",
+    baseUrl: "https://api.minimax.io/v1/music_generation",
+    statusUrl: "https://api.minimax.io/v1/query/music_generation",
+    authType: "apikey",
+    authHeader: "bearer",
+    format: "minimax-music",
+    models: [
+      { id: "music-2.6", name: "Music 2.6" },
+      { id: "music-2.6-free", name: "Music 2.6 Free" },
+      { id: "music-cover", name: "Music Cover" },
+    ],
+  },
+  comfyui: {
+    id: "comfyui",
+    baseUrl: "http://localhost:8188",
+    authType: "none",
+    authHeader: "none",
+    format: "comfyui",
+    models: [
+      { id: "stable-audio-open", name: "Stable Audio Open" },
+      { id: "musicgen-medium", name: "MusicGen Medium" },
+    ],
+  },
+};
+
+/**
+ * Get music provider config by ID
+ */
+export function getMusicProvider(providerId) {
+  return MUSIC_PROVIDERS[providerId] || null;
+}
+
+/**
+ * Parse music model string (format: "provider/model" or just "model")
+ */
+export function parseMusicModel(modelStr) {
+  return parseModelFromRegistry(modelStr, MUSIC_PROVIDERS);
+}
+
+/**
+ * Get all music models as a flat list
+ */
+export function getAllMusicModels() {
+  return getAllModelsFromRegistry(MUSIC_PROVIDERS);
+}

package/open-sse/config/ocrRegistry.js

@@ -0,0 +1,61 @@
+/**
+ * OCR Provider Registry
+ *
+ * Defines providers that support the /v1/ocr endpoint.
+ * Follows Mistral's OCR API format.
+ */
+
+export const OCR_PROVIDERS = {
+  mistral: {
+    id: "mistral",
+    baseUrl: "https://api.mistral.ai/v1/ocr",
+    authType: "apikey",
+    authHeader: "bearer",
+    models: [{ id: "mistral-ocr-latest", name: "Mistral OCR" }],
+  },
+};
+
+/**
+ * Get OCR provider config by ID.
+ */
+export function getOcrProvider(providerId) {
+  return OCR_PROVIDERS[providerId] || null;
+}
+
+/**
+ * Parse an OCR model string.
+ */
+export function parseOcrModel(modelStr) {
+  if (!modelStr) return { provider: null, model: null };
+
+  for (const providerId of Object.keys(OCR_PROVIDERS)) {
+    if (modelStr.startsWith(providerId + "/")) {
+      return { provider: providerId, model: modelStr.slice(providerId.length + 1) };
+    }
+  }
+
+  for (const [providerId, config] of Object.entries(OCR_PROVIDERS)) {
+    if (config.models.some((m) => m.id === modelStr)) {
+      return { provider: providerId, model: modelStr };
+    }
+  }
+
+  return { provider: null, model: modelStr };
+}
+
+/**
+ * Get all OCR models as a flat list.
+ */
+export function getAllOcrModels() {
+  const models = [];
+  for (const [providerId, config] of Object.entries(OCR_PROVIDERS)) {
+    for (const model of config.models) {
+      models.push({
+        id: `${providerId}/${model.id}`,
+        name: model.name,
+        provider: providerId,
+      });
+    }
+  }
+  return models;
+}

package/open-sse/config/ollamaModels.js

@@ -0,0 +1,19 @@
+export const ollamaModels = {
+  models: [
+    {
+      name: "llama3.2",
+      modified_at: "2025-12-26T00:00:00Z",
+      size: 2000000000,
+      digest: "abc123def456",
+      details: { format: "gguf", family: "llama", parameter_size: "3B", quantization_level: "Q4_K_M" }
+    },
+    {
+      name: "qwen2.5",
+      modified_at: "2025-12-26T00:00:00Z",
+      size: 4000000000,
+      digest: "def456abc123",
+      details: { format: "gguf", family: "qwen", parameter_size: "7B", quantization_level: "Q4_K_M" }
+    }
+  ]
+};
+