@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/services/taskAwareRouter.js

@@ -0,0 +1,227 @@
+const TASK_PATTERNS = {
+  coding: {
+    patterns: [
+      "write code",
+      "write a function",
+      "implement",
+      "debug",
+      "fix this",
+      "fix the",
+      "refactor",
+      "unit test",
+      "write test",
+      "write a script",
+      "code review",
+      "complete this function",
+      "add a feature",
+      "javascript",
+      "typescript",
+      "python",
+      "sql query",
+      "api endpoint"
+    ],
+    userPatterns: [
+      "```",
+      "def ",
+      "function ",
+      "class ",
+      "import ",
+      "const ",
+      "let ",
+      "var ",
+      "SELECT ",
+      "INSERT ",
+      "<html",
+      "<div"
+    ]
+  },
+  creative: {
+    patterns: [
+      "write a story",
+      "write a poem",
+      "write a song",
+      "creative writing",
+      "write a blog",
+      "write an article",
+      "write a script",
+      "write an essay",
+      "imagine",
+      "roleplay",
+      "brainstorm",
+      "creative"
+    ]
+  },
+  analysis: {
+    patterns: [
+      "analyze",
+      "analyse",
+      "analysis",
+      "compare",
+      "evaluate",
+      "assess",
+      "explain",
+      "reasoning",
+      "pros and cons",
+      "advantages and disadvantages",
+      "what are the implications",
+      "in-depth",
+      "comprehensive"
+    ]
+  },
+  vision: {
+    patterns: [
+      "look at this image",
+      "in this image",
+      "what do you see",
+      "describe this image",
+      "analyze this image",
+      "read this screenshot"
+    ],
+    userPatterns: ["image_url", "data:image"]
+  },
+  summarization: {
+    patterns: [
+      "summarize",
+      "summary",
+      "tldr",
+      "tl;dr",
+      "brief overview",
+      "key points",
+      "main points",
+      "what did",
+      "highlights from"
+    ]
+  },
+  background: {
+    patterns: [
+      "generate a title",
+      "generate title",
+      "create a title",
+      "name this",
+      "short description",
+      "brief description",
+      "one-line summary",
+      "conversation title"
+    ]
+  },
+  chat: {
+    patterns: []
+  }
+};
+const DEFAULT_TASK_MODEL_MAP = {
+  coding: "deepseek/deepseek-chat",
+  // DeepSeek V3.2 — best coding OSS
+  creative: "",
+  // No override — use requested model
+  analysis: "gemini/gemini-2.5-pro",
+  // Best long-context reasoning
+  vision: "openai/gpt-4o",
+  // Best vision baseline
+  summarization: "gemini/gemini-2.5-flash",
+  // Fast + cheap for summarization
+  background: "gemini/gemini-2.5-flash-lite",
+  // Cheapest for utility tasks
+  chat: ""
+  // No override — use requested model
+};
+let _config = {
+  enabled: false,
+  // User must explicitly enable
+  taskModelMap: { ...DEFAULT_TASK_MODEL_MAP },
+  detectionEnabled: true,
+  stats: { detected: 0, routed: 0 }
+};
+function setTaskRoutingConfig(config) {
+  _config = {
+    ..._config,
+    ...config,
+    stats: _config.stats
+    // preserve stats across config changes
+  };
+}
+function getTaskRoutingConfig() {
+  return {
+    ..._config,
+    taskModelMap: { ..._config.taskModelMap },
+    stats: { ..._config.stats }
+  };
+}
+function resetTaskRoutingStats() {
+  _config.stats = { detected: 0, routed: 0 };
+}
+function getDefaultTaskModelMap() {
+  return { ...DEFAULT_TASK_MODEL_MAP };
+}
+function extractText(content) {
+  if (typeof content === "string") return content.toLowerCase();
+  if (Array.isArray(content)) {
+    return content.map(
+      (part) => typeof part === "string" ? part.toLowerCase() : part?.text?.toLowerCase() || ""
+    ).join(" ");
+  }
+  return "";
+}
+function hasImages(messages) {
+  for (const msg of messages) {
+    if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part?.type === "image_url" || part?.type === "image") return true;
+      }
+    }
+  }
+  return false;
+}
+function detectTaskType(body) {
+  if (!body || typeof body !== "object") return "chat";
+  const messages = Array.isArray(body.messages) ? body.messages : Array.isArray(body.input) ? body.input : [];
+  if (messages.length === 0) return "chat";
+  if (hasImages(messages)) return "vision";
+  const systemMsg = messages.find((m) => m.role === "system" || m.role === "developer");
+  const systemText = systemMsg ? extractText(systemMsg.content) : "";
+  const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+  const userText = lastUserMsg ? extractText(lastUserMsg.content) : "";
+  const priorityOrder = [
+    "background",
+    "coding",
+    "vision",
+    "summarization",
+    "analysis",
+    "creative"
+  ];
+  for (const taskType of priorityOrder) {
+    const { patterns, userPatterns } = TASK_PATTERNS[taskType];
+    if (patterns.some((p) => systemText.includes(p.toLowerCase()))) {
+      return taskType;
+    }
+    if (patterns.some((p) => userText.includes(p.toLowerCase()))) {
+      return taskType;
+    }
+    if (userPatterns?.some((p) => userText.includes(p.toLowerCase()))) {
+      return taskType;
+    }
+  }
+  return "chat";
+}
+function applyTaskAwareRouting(originalModel, body) {
+  if (!_config.enabled || !_config.detectionEnabled) {
+    return { model: originalModel, taskType: "chat", wasRouted: false };
+  }
+  const taskType = detectTaskType(body);
+  _config.stats.detected++;
+  const preferred = _config.taskModelMap[taskType];
+  if (!preferred || preferred === "") {
+    return { model: originalModel, taskType, wasRouted: false };
+  }
+  if (taskType !== "background" && taskType !== "summarization") {
+  }
+  _config.stats.routed++;
+  return { model: preferred, taskType, wasRouted: true };
+}
+export {
+  applyTaskAwareRouting,
+  detectTaskType,
+  getDefaultTaskModelMap,
+  getTaskRoutingConfig,
+  resetTaskRoutingStats,
+  setTaskRoutingConfig
+};

package/open-sse/services/taskAwareRouting.js

@@ -0,0 +1,332 @@
+import { createHash } from "node:crypto";
+import { getResolvedModelCapabilities } from "./modelCapabilities.ts";
+const TASK_LEVEL_WEIGHT = {
+  light: 1,
+  standard: 2,
+  heavy: 3,
+  critical: 4
+};
+const TASK_TARGET_POWER = {
+  light: 35,
+  standard: 65,
+  heavy: 95,
+  critical: 120
+};
+const LIGHT_TASK_RE = /\b(hi|hello|thanks|thank you|ping|format|rewrite|grammar|translate|summari[sz]e|short|quick|one[- ]?liner|explain briefly)\b/i;
+const HEAVY_TASK_RE = /\b(debug|root cause|architecture|architectural|refactor|migrate|implementation|implement|design|analy[sz]e|investigate|compare|benchmark|whitebox|codebase|end[- ]?to[- ]?end|e2e)\b/i;
+const CRITICAL_TASK_RE = /\b(critical|security|vulnerability|exploit|rce|remote code execution|supply chain|account takeover|auth bypass|privilege escalation|tenant|cross[- ]tenant|sandbox escape|ssrf|deserialization|prod incident|data exfiltration|bug bounty)\b/i;
+const comboConversationAffinity = /* @__PURE__ */ new Map();
+const CONVERSATION_AFFINITY_TTL_MS = 60 * 60 * 1e3;
+const MAX_CONVERSATION_AFFINITY_ENTRIES = 1e3;
+function isTaskRoutingStrategy(strategy) {
+  return ["smart", "task", "task-aware", "task_aware", "auto"].includes(
+    String(strategy ?? "").toLowerCase()
+  );
+}
+function taskWeight(level) {
+  return TASK_LEVEL_WEIGHT[level];
+}
+function collectText(value, out = []) {
+  if (value == null) return out;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    out.push(String(value));
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectText(item, out);
+    return out;
+  }
+  if (typeof value !== "object") return out;
+  const rec = value;
+  if (typeof rec["text"] === "string") out.push(rec["text"]);
+  if (typeof rec["input_text"] === "string") out.push(rec["input_text"]);
+  if (typeof rec["output_text"] === "string") out.push(rec["output_text"]);
+  if (typeof rec["content"] === "string") out.push(rec["content"]);
+  else if (Array.isArray(rec["content"])) collectText(rec["content"], out);
+  if (Array.isArray(rec["parts"])) collectText(rec["parts"], out);
+  if (typeof rec["query"] === "string") out.push(rec["query"]);
+  if (typeof rec["url"] === "string") out.push(rec["url"]);
+  return out;
+}
+function estimatePromptChars(body) {
+  const contents = body["contents"] ?? body["request"]?.["contents"];
+  const parts = [
+    body["system"],
+    body["instructions"],
+    body["messages"],
+    body["input"],
+    contents,
+    body["query"],
+    body["url"]
+  ];
+  return collectText(parts).join("\n").length;
+}
+function countMessages(body) {
+  const contents = body["contents"] ?? body["request"]?.["contents"];
+  return (Array.isArray(body["messages"]) ? body["messages"].length : 0) + (Array.isArray(body["input"]) ? body["input"].length : 0) + (Array.isArray(body["contents"]) ? body["contents"].length : 0) + (Array.isArray(contents) ? contents.length : 0);
+}
+function maxRequestedOutput(body) {
+  const genConf = body["generationConfig"];
+  const candidates = [
+    body["max_tokens"],
+    body["max_output_tokens"],
+    body["max_completion_tokens"],
+    genConf?.["maxOutputTokens"]
+  ].map((v) => Number.parseInt(String(v ?? ""), 10)).filter((v) => Number.isFinite(v));
+  return candidates.length > 0 ? Math.max(...candidates) : 0;
+}
+function getTaskText(body) {
+  const contents = body?.["contents"] ?? body?.["request"]?.["contents"];
+  return collectText([
+    body?.["system"],
+    body?.["instructions"],
+    body?.["messages"],
+    body?.["input"],
+    contents,
+    body?.["query"],
+    body?.["url"]
+  ]).join("\n");
+}
+function normalizeEffort(body) {
+  const reasoning = body?.["reasoning"];
+  return String(body?.["reasoning_effort"] ?? reasoning?.["effort"] ?? "").toLowerCase();
+}
+function getTaskSignals(body) {
+  const promptChars = estimatePromptChars(body);
+  const messageCount = countMessages(body);
+  const toolCount = Array.isArray(body?.["tools"]) ? body["tools"].length : 0;
+  const outputTokens = maxRequestedOutput(body);
+  const effort = normalizeEffort(body);
+  const text = getTaskText(body);
+  return {
+    promptChars,
+    messageCount,
+    toolCount,
+    outputTokens,
+    effort,
+    hasExplicitReasoning: Boolean(
+      effort && effort !== "none" && effort !== "off" && effort !== "disabled"
+    ),
+    lightKeyword: LIGHT_TASK_RE.test(text),
+    heavyKeyword: HEAVY_TASK_RE.test(text),
+    criticalKeyword: CRITICAL_TASK_RE.test(text)
+  };
+}
+function classifyTask(body) {
+  const s = getTaskSignals(body ?? {});
+  const reasons = [];
+  const add = (condition, reason) => {
+    if (condition) reasons.push(reason);
+    return condition;
+  };
+  const effortIsHigh = /^(high|xhigh|max|maximum|hard|deep)$/.test(s.effort);
+  const effortIsLight = !s.hasExplicitReasoning || /^(low|minimal|none|off|disabled)$/.test(s.effort);
+  const critical = add(s.promptChars >= 1e5, "huge-context") || add(s.outputTokens >= 32768, "huge-output") || add(s.toolCount >= 8 && s.promptChars >= 16e3, "many-tools-large-context") || add(
+    s.criticalKeyword && (effortIsHigh || s.toolCount >= 3 || s.promptChars >= 8e3),
+    "critical-domain"
+  );
+  if (critical) {
+    return { level: "critical", weight: taskWeight("critical"), ...s, reasons };
+  }
+  const heavySignalCount = [
+    add(s.promptChars >= 5e4, "large-context"),
+    add(s.promptChars >= 24e3, "medium-large-context"),
+    add(s.messageCount >= 16, "long-conversation"),
+    add(s.toolCount >= 4, "many-tools"),
+    add(s.outputTokens >= 8192, "large-output"),
+    add(effortIsHigh, "high-reasoning-effort"),
+    add(s.criticalKeyword, "security-sensitive"),
+    add(s.heavyKeyword && s.promptChars >= 4e3, "complex-task")
+  ].filter(Boolean).length;
+  if (heavySignalCount >= 2 || s.promptChars >= 5e4 || effortIsHigh) {
+    return { level: "heavy", weight: taskWeight("heavy"), ...s, reasons };
+  }
+  const light = s.promptChars <= 2e3 && s.messageCount <= 3 && s.toolCount === 0 && s.outputTokens <= 1500 && effortIsLight && !s.criticalKeyword && !s.heavyKeyword;
+  if (light || s.lightKeyword && s.promptChars <= 4e3 && s.toolCount === 0 && effortIsLight && !s.criticalKeyword) {
+    return {
+      level: "light",
+      weight: taskWeight("light"),
+      ...s,
+      reasons: reasons.length > 0 ? reasons : ["small-simple-request"]
+    };
+  }
+  return {
+    level: "standard",
+    weight: taskWeight("standard"),
+    ...s,
+    reasons: reasons.length > 0 ? reasons : ["default"]
+  };
+}
+function modelPowerScore(modelStr) {
+  const id = `${modelStr ?? ""}`.toLowerCase();
+  const caps = getResolvedModelCapabilities(modelStr);
+  let score = 35;
+  if (caps.reasoning) score += 18;
+  if (caps.supportsVision === true) score += 3;
+  if (caps.toolCalling) score += 3;
+  const ctx = caps.contextWindow ?? 0;
+  if (ctx >= 1e6) score += 22;
+  else if (ctx >= 4e5) score += 15;
+  else if (ctx >= 2e5) score += 9;
+  else if (ctx > 0 && ctx <= 32e3) score -= 10;
+  const maxOut = caps.maxOutputTokens ?? 0;
+  if (maxOut >= 128e3) score += 12;
+  else if (maxOut >= 64e3) score += 8;
+  else if (maxOut > 0 && maxOut <= 8192) score -= 8;
+  if (/\b(opus|mythos|gpt-5|o3|o4|pro|max|ultra|deepseek-v4-pro|sonnet-4|glm-5|kimi-k2\.7|minimax-m3|reasoner)\b/i.test(
+    id
+  ))
+    score += 28;
+  if (/\b(coder|code|coding)\b/i.test(id)) score += 8;
+  if (/\b(haiku|flash|mini|lite|small|nano|instant|fast|turbo|3\.5|8b|7b)\b/i.test(id)) score -= 24;
+  return Math.max(0, Math.min(150, score));
+}
+const HARD_CAP_CHECKS = /* @__PURE__ */ new Set(["vision"]);
+function scoreModelForTask(modelStr, task = classifyTask({}), required = /* @__PURE__ */ new Set()) {
+  const caps = getResolvedModelCapabilities(modelStr);
+  const target = TASK_TARGET_POWER[task.level];
+  const power = modelPowerScore(modelStr);
+  let score = 100 - Math.abs(power - target);
+  for (const cap of required) {
+    if (!HARD_CAP_CHECKS.has(cap)) continue;
+    if (cap === "vision" && caps.supportsVision !== true) score -= 1e4;
+  }
+  if ((required.has("reasoning") || task.weight >= TASK_LEVEL_WEIGHT.heavy) && !caps.reasoning)
+    score -= 120;
+  if (required.has("search") && !caps.toolCalling) score -= 30;
+  const estimatedPromptTokens = Math.ceil((task.promptChars ?? 0) / 4);
+  const ctxLimit = caps.contextWindow ?? 0;
+  if (ctxLimit > 0 && estimatedPromptTokens > ctxLimit * 0.85) score -= 200;
+  const maxOut = caps.maxOutputTokens ?? 0;
+  if (maxOut > 0 && task.outputTokens > 0 && task.outputTokens > maxOut) score -= 80;
+  if (task.level === "light" && power > 95) score -= 35;
+  if (task.level === "standard" && power > 125) score -= 10;
+  if (task.level === "heavy" && power < 65) score -= 60;
+  if (task.level === "critical" && power < 85) score -= 100;
+  return score;
+}
+function reorderByTaskWeight(targets, task = classifyTask({}), required = /* @__PURE__ */ new Set()) {
+  if (!Array.isArray(targets) || targets.length <= 1) return targets;
+  const reordered = targets.map((t, i) => ({ t, i, score: scoreModelForTask(t.modelStr, task, required) })).sort((a, b) => b.score - a.score || a.i - b.i).map((x) => x.t);
+  return reordered.every((t, i) => t === targets[i]) ? targets : reordered;
+}
+function normalizeFingerprintText(value) {
+  return String(value ?? "").replace(/\s+/g, " ").trim().slice(0, 12e3);
+}
+function firstRoleText(items, roles, contentKey = "content") {
+  if (!Array.isArray(items)) return "";
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const rec = item;
+    if (!roles.has(String(rec["role"] ?? ""))) continue;
+    const raw = contentKey === "parts" ? rec["parts"] : rec["content"];
+    const text = normalizeFingerprintText(collectText(raw).join("\n"));
+    if (text) return text;
+  }
+  return "";
+}
+function allRoleText(items, roles, contentKey = "content") {
+  if (!Array.isArray(items)) return "";
+  return normalizeFingerprintText(
+    items.filter(
+      (item) => !!item && typeof item === "object" && roles.has(String(item["role"] ?? ""))
+    ).map(
+      (item) => collectText(contentKey === "parts" ? item["parts"] : item["content"]).join("\n")
+    ).filter(Boolean).join("\n")
+  );
+}
+function hashConversationSeed(seed) {
+  const normalized = normalizeFingerprintText(seed);
+  if (!normalized) return null;
+  return createHash("sha1").update(normalized).digest("hex").slice(0, 24);
+}
+function getConversationCacheKey(body) {
+  if (!body || typeof body !== "object") return null;
+  const meta = body["metadata"];
+  const explicitCandidates = [
+    body["conversation_id"],
+    body["conversationId"],
+    body["thread_id"],
+    body["threadId"],
+    body["session_id"],
+    body["sessionId"],
+    meta?.["conversation_id"],
+    meta?.["conversationId"],
+    meta?.["thread_id"],
+    meta?.["threadId"],
+    meta?.["session_id"],
+    meta?.["sessionId"]
+  ];
+  const explicit = explicitCandidates.find((v) => v != null && String(v).trim());
+  if (explicit != null) return hashConversationSeed(`explicit:${String(explicit).trim()}`);
+  const systemRoles = /* @__PURE__ */ new Set(["system", "developer"]);
+  const userRoles = /* @__PURE__ */ new Set(["user"]);
+  const contents = body["contents"] ?? body["request"]?.["contents"];
+  const seedParts = [
+    collectText(body["system"]).join("\n"),
+    collectText(body["instructions"]).join("\n"),
+    allRoleText(body["messages"] ?? [], systemRoles),
+    allRoleText(body["input"] ?? [], systemRoles),
+    allRoleText(contents ?? [], systemRoles, "parts"),
+    firstRoleText(body["messages"] ?? [], userRoles),
+    typeof body["input"] === "string" ? body["input"] : firstRoleText(body["input"] ?? [], userRoles),
+    firstRoleText(contents ?? [], userRoles, "parts"),
+    body["query"],
+    body["url"]
+  ].filter(Boolean);
+  return hashConversationSeed(seedParts.join("\n"));
+}
+function pruneConversationAffinity(now = Date.now()) {
+  for (const [key, value] of comboConversationAffinity) {
+    if (!value || now - value.lastUsed > CONVERSATION_AFFINITY_TTL_MS) {
+      comboConversationAffinity.delete(key);
+    }
+  }
+  while (comboConversationAffinity.size > MAX_CONVERSATION_AFFINITY_ENTRIES) {
+    const oldestKey = comboConversationAffinity.keys().next().value;
+    if (oldestKey === void 0) break;
+    comboConversationAffinity.delete(oldestKey);
+  }
+}
+function getOrSetConversationAffinityIndex(rotationKey, conversationCacheKey, currentIndex) {
+  const now = Date.now();
+  pruneConversationAffinity(now);
+  const affinityKey = `${rotationKey}:${conversationCacheKey}`;
+  const existing = comboConversationAffinity.get(affinityKey);
+  if (existing) {
+    const pinnedIndex = existing.index;
+    comboConversationAffinity.delete(affinityKey);
+    comboConversationAffinity.set(affinityKey, { index: pinnedIndex, lastUsed: now });
+    return pinnedIndex;
+  }
+  comboConversationAffinity.set(affinityKey, { index: currentIndex, lastUsed: now });
+  return currentIndex;
+}
+function clearConversationAffinity(comboName) {
+  if (comboName) {
+    const prefix = `${comboName}:`;
+    for (const key of comboConversationAffinity.keys()) {
+      if (key.startsWith(prefix)) comboConversationAffinity.delete(key);
+    }
+  } else {
+    comboConversationAffinity.clear();
+  }
+}
+export {
+  CRITICAL_TASK_RE,
+  HEAVY_TASK_RE,
+  LIGHT_TASK_RE,
+  TASK_LEVEL_WEIGHT,
+  TASK_TARGET_POWER,
+  classifyTask,
+  clearConversationAffinity,
+  comboConversationAffinity,
+  getConversationCacheKey,
+  getOrSetConversationAffinityIndex,
+  getTaskSignals,
+  isTaskRoutingStrategy,
+  modelPowerScore,
+  pruneConversationAffinity,
+  reorderByTaskWeight,
+  scoreModelForTask
+};