@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/services/kimchiModels.js

@@ -1,176 +0,0 @@
-import { createHash } from "crypto";
-
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
-
-export const KIMCHI_API = "https://llm.kimchi.dev";
-export const KIMCHI_USER_AGENT = "kimchi/0.1.40";
-
-const FETCH_TIMEOUT_MS = 20_000;
-const CACHE_TTL_MS = 5 * 60 * 1000;
-const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
-
-/** @type {Map<string, { expiresAt: number, models: object[], rawModels: object[] }>} */
-const catalogCache = new Map();
-/** @type {Map<string, object>} */
-const metadataByModelId = new Map();
-
-function normalizeKimchiEndpoint(endpoint) {
-  const raw = typeof endpoint === "string" ? endpoint.trim() : "";
-  return (raw || KIMCHI_API).replace(/\/+$/, "");
-}
-
-export function buildKimchiModelsUrl(endpoint) {
-  return `${normalizeKimchiEndpoint(endpoint)}/v1/models/metadata?include_in_cli=true`;
-}
-
-function readToken(credentials) {
-  return (
-    credentials?.accessToken
-    || credentials?.apiKey
-    || credentials?.providerSpecificData?.apiKey
-    || null
-  );
-}
-
-function cacheKey(credentials, endpoint) {
-  const psd = credentials?.providerSpecificData || {};
-  const seed = psd.userId || psd.username || credentials?.refreshToken || readToken(credentials) || "anonymous";
-  return createHash("sha256")
-    .update(`kimchi:${normalizeKimchiEndpoint(endpoint)}:${seed}`)
-    .digest("hex");
-}
-
-function toModelKind(inputModalities) {
-  return Array.isArray(inputModalities) && inputModalities.includes("image")
-    ? "imageToText"
-    : "llm";
-}
-
-export function normalizeKimchiModel(item) {
-  if (!item || typeof item !== "object") return null;
-  const id = item.slug || item.id || item.model || item.name;
-  if (typeof id !== "string" || id.trim() === "") return null;
-
-  const inputModalities = Array.isArray(item.input_modalities)
-    ? item.input_modalities.filter((value) => value === "text" || value === "image")
-    : [];
-  const limits = item.limits && typeof item.limits === "object" ? item.limits : {};
-  const contextLength = Number(limits.context_window || item.contextLength || item.context_length) || undefined;
-  const maxOutputTokens = Number(limits.max_output_tokens || item.maxOutputTokens || item.max_output_tokens) || undefined;
-  const upstreamProvider = typeof item.provider === "string" ? item.provider : "";
-  const reasoning = item.reasoning === true;
-  const kind = toModelKind(inputModalities);
-
-  const model = {
-    ...item,
-    id: id.trim(),
-    name: String(item.display_name || item.displayName || item.name || id).trim(),
-    provider: upstreamProvider,
-    upstreamProvider,
-    reasoning,
-    inputModalities,
-    kind,
-    type: kind,
-    capabilities: {
-      vision: inputModalities.includes("image"),
-      reasoning,
-      ...(contextLength ? { contextWindow: contextLength } : {}),
-      ...(maxOutputTokens ? { maxOutput: maxOutputTokens } : {}),
-      ...(upstreamProvider ? { upstreamProvider } : {}),
-    },
-    ...(contextLength ? { contextLength } : {}),
-    ...(maxOutputTokens ? { maxOutputTokens } : {}),
-  };
-
-  if (upstreamProvider === "anthropic") {
-    model.compat = { supportsReasoningEffort: false, cacheControlFormat: "anthropic" };
-  }
-
-  return model;
-}
-
-function rememberModels(models) {
-  for (const model of models || []) {
-    if (!model?.id) continue;
-    metadataByModelId.set(model.id, model);
-    metadataByModelId.set(model.id.toLowerCase(), model);
-  }
-}
-
-export function getCachedKimchiModelMetadata(modelId) {
-  if (typeof modelId !== "string" || modelId.trim() === "") return null;
-  const raw = modelId.includes("/") ? modelId.split("/").pop() : modelId;
-  return metadataByModelId.get(raw) || metadataByModelId.get(raw.toLowerCase()) || null;
-}
-
-async function fetchKimchiCatalogRaw(token, endpoint, options = {}) {
-  const url = buildKimchiModelsUrl(endpoint);
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(new Error("Kimchi models fetch timeout")), FETCH_TIMEOUT_MS);
-  const signal = options.signal
-    ? AbortSignal.any([options.signal, controller.signal])
-    : controller.signal;
-
-  try {
-    const response = await proxyAwareFetch(url, {
-      method: "GET",
-      headers: {
-        "Accept": "application/json",
-        "Authorization": `Bearer ${token}`,
-        "User-Agent": KIMCHI_USER_AGENT,
-      },
-      cache: "no-store",
-      signal,
-    }, options.proxyOptions || null);
-
-    if (!response.ok) {
-      const error = new Error(`Kimchi models ${response.status}: ${response.statusText}`);
-      error.status = response.status;
-      error.retryable = RETRYABLE_STATUSES.has(response.status);
-      throw error;
-    }
-
-    const data = await response.json();
-    return Array.isArray(data?.models) ? data.models : [];
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-export async function resolveKimchiModels(credentials, options = {}) {
-  const token = readToken(credentials);
-  if (!token) return null;
-
-  const endpoint = credentials?.providerSpecificData?.kimchiEndpoint || options.endpoint || KIMCHI_API;
-  const key = cacheKey(credentials, endpoint);
-  const now = Date.now();
-  if (!options.forceRefresh) {
-    const cached = catalogCache.get(key);
-    if (cached && cached.expiresAt > now) return cached;
-  }
-
-  let rawModels;
-  try {
-    rawModels = await fetchKimchiCatalogRaw(token, endpoint, options);
-  } catch (error) {
-    options.log?.warn?.("KIMCHI_MODELS", error.message);
-    return null;
-  }
-
-  const models = rawModels.map(normalizeKimchiModel).filter(Boolean);
-  if (models.length === 0) return null;
-
-  rememberModels(models);
-  const entry = {
-    expiresAt: Date.now() + CACHE_TTL_MS,
-    models,
-    rawModels,
-  };
-  catalogCache.set(key, entry);
-  return entry;
-}
-
-export function clearKimchiCatalog() {
-  catalogCache.clear();
-  metadataByModelId.clear();
-}

package/open-sse/services/kiroModels.js

@@ -1,332 +0,0 @@
-/**
- * Kiro model catalog fetcher.
- *
- * Calls AWS CodeWhisperer's `ListAvailableModels` endpoint to get the live
- * catalog for an authenticated Kiro account, then expands each upstream model
- * into 9router-shaped variants:
- *
- *   {upstream}                          - base model
- *   {upstream}-thinking                 - same model, thinking on at request time
- *   {upstream}-agentic                  - same model, chunked-write prompt prepended
- *   {upstream}-thinking-agentic         - both
- *
- * The `-thinking` and `-agentic` suffixes do not exist on the Kiro upstream
- * API. They are 9router fictions and the `openai-to-kiro` translator strips
- * them before the request leaves this process.
- *
- * The runtime UA is built to match what Kiro IDE itself sends, because the
- * upstream rejects requests with malformed `User-Agent` headers (returns 400
- * "format of value 'os/win/10 lang/js ...' is invalid").
- */
-
-import { v4 as uuidv4 } from "uuid";
-import { createHash } from "crypto";
-import { refreshKiroToken } from "./tokenRefresh.js";
-
-const KIRO_RUNTIME_SDK_VERSION = "1.0.0";
-const KIRO_AGENT_OS = "windows";
-const KIRO_AGENT_OS_VERSION = "10.0.26200";
-const KIRO_NODE_VERSION = "22.21.1";
-const KIRO_VERSION = "0.10.32";
-
-const DEFAULT_REGION = "us-east-1";
-const FETCH_TIMEOUT_MS = 30_000;
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes per credential
-
-/** @type {Map<string, { expiresAt: number, models: any[] }>} */
-const catalogCache = new Map();
-
-/**
- * Strip the `-agentic` and/or `-thinking` suffixes from a synthetic id, if
- * any. Used only for display naming when a Kiro upstream id happens to look
- * synthetic (defensive).
- */
-function stripSyntheticSuffixes(id) {
-  let out = id;
-  if (out.endsWith("-agentic")) out = out.slice(0, -"-agentic".length);
-  if (out.endsWith("-thinking")) out = out.slice(0, -"-thinking".length);
-  return out;
-}
-
-/**
- * Extract region from a profileArn like
- *   arn:aws:codewhisperer:us-east-1:123456789012:profile/ABC
- */
-function regionFromProfileArn(profileArn) {
-  if (!profileArn || typeof profileArn !== "string") return DEFAULT_REGION;
-  const parts = profileArn.split(":");
-  if (parts.length >= 4 && parts[3]) return parts[3];
-  return DEFAULT_REGION;
-}
-
-/**
- * Build the per-account fingerprint headers Kiro upstream validates.
- * Keyed off whatever stable identifier we have for this credential, so the
- * same account always presents the same machineId.
- */
-function buildKiroFingerprintHeaders(credentials) {
-  const seed =
-    credentials?.providerSpecificData?.clientId
-    || credentials?.refreshToken
-    || credentials?.providerSpecificData?.profileArn
-    || credentials?.accessToken
-    || "kiro-anonymous";
-  const machineId = createHash("sha256").update(String(seed)).digest("hex");
-
-  const userAgent =
-    `aws-sdk-js/${KIRO_RUNTIME_SDK_VERSION} ua/2.1 ` +
-    `os/${KIRO_AGENT_OS}#${KIRO_AGENT_OS_VERSION} ` +
-    `lang/js md/nodejs#${KIRO_NODE_VERSION} ` +
-    `api/codewhispererruntime#${KIRO_RUNTIME_SDK_VERSION} m/N,E ` +
-    `KiroIDE-${KIRO_VERSION}-${machineId}`;
-  const amzUserAgent = `aws-sdk-js/${KIRO_RUNTIME_SDK_VERSION} KiroIDE-${KIRO_VERSION}-${machineId}`;
-
-  return {
-    "User-Agent": userAgent,
-    "x-amz-user-agent": amzUserAgent,
-    "x-amzn-kiro-agent-mode": "vibe",
-    "x-amzn-codewhisperer-optout": "true",
-    "amz-sdk-request": "attempt=1; max=1",
-    "amz-sdk-invocation-id": uuidv4(),
-    "Accept": "application/json"
-  };
-}
-
-/**
- * Build the synthetic 9router variant set for a single upstream Kiro model.
- *
- * Returns objects shaped for `PROVIDER_MODELS` (`{ id, name }`) so they can
- * be slotted directly into the existing model registry.
- *
- * The `auto` model is special: Kiro picks the underlying model server-side,
- * so the chunked-write `-agentic` prompt is not meaningful (the prompt
- * targets coding-agent file writes). Match CLIProxyAPIPlus and skip
- * `-agentic` / `-thinking-agentic` for `auto`.
- */
-function buildVariants(upstream, displayName) {
-  const safeUpstream = stripSyntheticSuffixes(upstream);
-  const display = displayName || `Kiro ${safeUpstream}`;
-  const isAuto = safeUpstream === "auto";
-
-  const variants = [
-    {
-      id: safeUpstream,
-      name: display,
-      capabilities: { thinking: false, agentic: false }
-    },
-    {
-      id: `${safeUpstream}-thinking`,
-      name: `${display} (Thinking)`,
-      capabilities: { thinking: true, agentic: false }
-    }
-  ];
-
-  if (!isAuto) {
-    variants.push({
-      id: `${safeUpstream}-agentic`,
-      name: `${display} (Agentic)`,
-      capabilities: { thinking: false, agentic: true }
-    });
-    variants.push({
-      id: `${safeUpstream}-thinking-agentic`,
-      name: `${display} (Thinking + Agentic)`,
-      capabilities: { thinking: true, agentic: true }
-    });
-  }
-
-  return variants;
-}
-
-/**
- * Format the human-friendly display name for a Kiro model, including the
- * rate multiplier when it is something other than 1.0x.
- */
-function formatDisplayName(modelName, modelId, rateMultiplier) {
-  const base = (modelName || modelId || "Kiro").trim();
-  const rate = Number(rateMultiplier);
-  if (!Number.isFinite(rate) || Math.abs(rate - 1.0) < 1e-9 || rate <= 0) {
-    return `Kiro ${base}`;
-  }
-  // Locale-independent decimal formatting.
-  const rateStr = rate.toFixed(1).replace(",", ".");
-  return `Kiro ${base} (${rateStr}x credit)`;
-}
-
-/**
- * Fetch the raw model catalog from Kiro. Returns the array under `.models`
- * from the API response, or throws on network/HTTP error.
- */
-async function fetchKiroCatalogRaw(credentials, signal) {
-  const profileArn = credentials?.providerSpecificData?.profileArn || "";
-  const region = regionFromProfileArn(profileArn);
-  const params = new URLSearchParams();
-  params.set("origin", "AI_EDITOR");
-  if (profileArn) params.set("profileArn", profileArn);
-  const url = `https://q.${region}.amazonaws.com/ListAvailableModels?${params.toString()}`;
-
-  const headers = {
-    ...buildKiroFingerprintHeaders(credentials),
-    "Authorization": `Bearer ${credentials?.accessToken || ""}`
-  };
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort("timeout"), FETCH_TIMEOUT_MS);
-  // Forward outer cancellation if any.
-  if (signal && typeof signal.addEventListener === "function") {
-    signal.addEventListener("abort", () => controller.abort(signal.reason));
-  }
-
-  let response;
-  try {
-    response = await fetch(url, {
-      method: "GET",
-      headers,
-      signal: controller.signal
-    });
-  } finally {
-    clearTimeout(timer);
-  }
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    const err = new Error(`Kiro ListAvailableModels ${response.status}: ${text || response.statusText}`);
-    err.status = response.status;
-    err.body = text;
-    throw err;
-  }
-
-  const data = await response.json();
-  const models = Array.isArray(data?.models) ? data.models : [];
-  return models;
-}
-
-/**
- * Build a stable cache key for a Kiro credential. Uses the most stable id we
- * have available so different login sessions for the same account share a
- * cache entry.
- */
-function cacheKey(credentials) {
-  const psd = credentials?.providerSpecificData || {};
-  const seed =
-    psd.profileArn
-    || psd.clientId
-    || credentials?.refreshToken
-    || credentials?.accessToken
-    || "anonymous";
-  return createHash("sha256").update(`kiro:${seed}`).digest("hex");
-}
-
-/**
- * Resolve the live Kiro model catalog for a credential and expand each entry
- * into 9router variants (`-thinking`, `-agentic`, `-thinking-agentic`).
- *
- * On any error (network, 4xx, 5xx), returns `null` so callers can fall back
- * to the static catalog without taking down the dashboard or `/v1/models`.
- *
- * @param {object} credentials Connection record (accessToken, refreshToken,
- *   providerSpecificData {profileArn, authMethod, clientId, clientSecret, region})
- * @param {object} [options]
- * @param {boolean} [options.forceRefresh] Bypass the per-credential cache.
- * @param {object}  [options.log] Logger.
- * @param {function} [options.onCredentialsRefreshed] Persist refreshed token
- *   back to your credential store. Called with `{ accessToken, refreshToken,
- *   expiresIn }` whenever a 401 triggers a token refresh.
- * @returns {Promise<{ models: object[], rawModels: object[] } | null>}
- */
-export async function resolveKiroModels(credentials, options = {}) {
-  if (!credentials || !credentials.accessToken) {
-    options.log?.debug?.("KIRO_MODELS", "No accessToken; skipping live fetch");
-    return null;
-  }
-
-  const key = cacheKey(credentials);
-  const now = Date.now();
-  if (!options.forceRefresh) {
-    const cached = catalogCache.get(key);
-    if (cached && cached.expiresAt > now) {
-      return { models: cached.models, rawModels: cached.rawModels };
-    }
-  }
-
-  let raw;
-  try {
-    raw = await fetchKiroCatalogRaw(credentials, options.signal);
-  } catch (err) {
-    if (err && err.status === 401 && credentials.refreshToken) {
-      options.log?.info?.("KIRO_MODELS", "Got 401 from Kiro; refreshing token");
-      const refreshed = await refreshKiroToken(
-        credentials.refreshToken,
-        credentials.providerSpecificData,
-        options.log
-      );
-      if (refreshed?.accessToken) {
-        const next = { ...credentials, ...refreshed };
-        if (typeof options.onCredentialsRefreshed === "function") {
-          try { await options.onCredentialsRefreshed(refreshed); } catch (e) {
-            options.log?.warn?.("KIRO_MODELS", `onCredentialsRefreshed failed: ${e?.message || e}`);
-          }
-        }
-        try {
-          raw = await fetchKiroCatalogRaw(next, options.signal);
-          // Update the in-memory credential reference too so retry logic uses
-          // the fresh token consistently.
-          credentials.accessToken = next.accessToken;
-          if (next.refreshToken) credentials.refreshToken = next.refreshToken;
-        } catch (err2) {
-          options.log?.warn?.("KIRO_MODELS", `Retry after refresh failed: ${err2?.message || err2}`);
-          return null;
-        }
-      } else {
-        options.log?.warn?.("KIRO_MODELS", "Token refresh did not return accessToken");
-        return null;
-      }
-    } else {
-      options.log?.warn?.("KIRO_MODELS", `ListAvailableModels failed: ${err?.message || err}`);
-      return null;
-    }
-  }
-
-  const expanded = [];
-  for (const m of raw) {
-    if (!m || typeof m !== "object") continue;
-    const upstreamId = m.modelId || m.id;
-    if (!upstreamId) continue;
-    const display = formatDisplayName(m.modelName, upstreamId, m.rateMultiplier);
-    const ctx = Number(m?.tokenLimits?.maxInputTokens) || 200_000;
-    for (const v of buildVariants(upstreamId, display)) {
-      expanded.push({
-        ...v,
-        // Carry over context window + raw upstream metadata so the caller
-        // (e.g. the dashboard models endpoint) can render it.
-        contextLength: ctx,
-        rateMultiplier: Number.isFinite(Number(m.rateMultiplier)) ? Number(m.rateMultiplier) : 1.0,
-        upstreamModelId: upstreamId,
-        description: m.description || ""
-      });
-    }
-  }
-
-  catalogCache.set(key, {
-    expiresAt: now + CACHE_TTL_MS,
-    models: expanded,
-    rawModels: raw
-  });
-
-  return { models: expanded, rawModels: raw };
-}
-
-/**
- * Drop any cached catalog for this credential. Call this after rotating /
- * importing tokens so the next fetch is fresh.
- */
-export function invalidateKiroModelCache(credentials) {
-  if (!credentials) return;
-  catalogCache.delete(cacheKey(credentials));
-}
-
-/**
- * Drop the entire in-memory cache. Mostly for tests / manual debug.
- */
-export function clearKiroModelCache() {
-  catalogCache.clear();
-}

package/open-sse/services/model.js

@@ -1,136 +0,0 @@
-import REGISTRY from "../providers/registry/index.js";
-
-// Alias→id derived from registry single-source: id→id, alias→id, aliases[]→id.
-// Media-only providers without a registry transport entry keep explicit aliases here.
-const MEDIA_ONLY_ALIASES = {
-  el: "elevenlabs",
-  jina: "jina-ai",
-  "jina-ai": "jina-ai",
-  polly: "aws-polly",
-  "aws-polly": "aws-polly",
-};
-
-const ALIAS_TO_PROVIDER_ID = { ...MEDIA_ONLY_ALIASES };
-for (const entry of REGISTRY) {
-  ALIAS_TO_PROVIDER_ID[entry.id] = entry.id;
-  if (entry.alias) ALIAS_TO_PROVIDER_ID[entry.alias] = entry.id;
-  for (const a of entry.aliases || []) ALIAS_TO_PROVIDER_ID[a] = entry.id;
-}
-
-/**
- * Resolve provider alias to provider ID
- */
-export function resolveProviderAlias(aliasOrId) {
-  return ALIAS_TO_PROVIDER_ID[aliasOrId] || aliasOrId;
-}
-
-/**
- * Parse model string: "alias/model" or "provider/model" or just alias
- */
-export function parseModel(modelStr) {
-  if (!modelStr) {
-    return { provider: null, model: null, isAlias: false, providerAlias: null };
-  }
-
-  // Check if standard format: provider/model or alias/model
-  if (modelStr.includes("/")) {
-    const firstSlash = modelStr.indexOf("/");
-    const providerOrAlias = modelStr.slice(0, firstSlash);
-    const model = modelStr.slice(firstSlash + 1);
-    const provider = resolveProviderAlias(providerOrAlias);
-    return { provider, model, isAlias: false, providerAlias: providerOrAlias };
-  }
-
-  // Alias format (model alias, not provider alias)
-  return {
-    provider: null,
-    model: modelStr,
-    isAlias: true,
-    providerAlias: null,
-  };
-}
-
-/**
- * Resolve model alias from aliases object
- * Format: { "alias": "provider/model" }
- */
-export function resolveModelAliasFromMap(alias, aliases) {
-  if (!aliases) return null;
-
-  // Check if alias exists
-  const resolved = aliases[alias];
-  if (!resolved) return null;
-
-  // Resolved value is "provider/model" format
-  if (typeof resolved === "string" && resolved.includes("/")) {
-    const firstSlash = resolved.indexOf("/");
-    const providerOrAlias = resolved.slice(0, firstSlash);
-    return {
-      provider: resolveProviderAlias(providerOrAlias),
-      model: resolved.slice(firstSlash + 1),
-    };
-  }
-
-  // Or object { provider, model }
-  if (typeof resolved === "object" && resolved.provider && resolved.model) {
-    return {
-      provider: resolveProviderAlias(resolved.provider),
-      model: resolved.model,
-    };
-  }
-
-  return null;
-}
-
-/**
- * Get full model info (parse or resolve)
- * @param {string} modelStr - Model string
- * @param {object|function} aliasesOrGetter - Aliases object or async function to get aliases
- */
-export async function getModelInfoCore(modelStr, aliasesOrGetter) {
-  const parsed = parseModel(modelStr);
-
-  if (!parsed.isAlias) {
-    return {
-      provider: parsed.provider,
-      model: parsed.model,
-    };
-  }
-
-  // Get aliases (from object or function)
-  const aliases =
-    typeof aliasesOrGetter === "function"
-      ? await aliasesOrGetter()
-      : aliasesOrGetter;
-
-  // Resolve alias
-  const resolved = resolveModelAliasFromMap(parsed.model, aliases);
-  if (resolved) {
-    return resolved;
-  }
-
-  // Fallback: infer provider from model name prefix
-  return {
-    provider: inferProviderFromModelName(parsed.model),
-    model: parsed.model,
-  };
-}
-
-// Config-driven prefix → provider inference (first match wins, fallback "openai").
-const MODEL_PREFIX_PROVIDERS = [
-  [/^claude-/, "anthropic"],
-  [/^gemini-/, "gemini"],
-  [/^gpt-/, "openai"],
-  [/^o[134]/, "openai"],
-  [/^deepseek-/, "openrouter"],
-];
-
-/**
- * Infer provider from model name prefix
- * Used as fallback when no provider prefix or alias is given
- */
-function inferProviderFromModelName(modelName) {
-  if (!modelName) return "openai";
-  const m = modelName.toLowerCase();
-  return MODEL_PREFIX_PROVIDERS.find(([re]) => re.test(m))?.[1] || "openai";
-}

package/open-sse/services/modelCapabilities.js

@@ -1,5 +0,0 @@
-export {
-  getResolvedModelCapabilities,
-  supportsReasoning,
-  supportsToolCalling,
-} from "../../lib/modelCapabilities.js";