swayrouter 1.0.0

package/src/services/capacityAdapter.js

@@ -0,0 +1,140 @@
+import { getCapabilitiesForModel } from "../providers/capabilities.js";
+
+const CAPABILITY_KEYS = ["vision", "pdf", "audioInput", "videoInput"];
+const HARD_CAPS = new Set(CAPABILITY_KEYS);
+const DEFAULT_FALLBACK_MODEL = "oc/mimo-v2.5-free";
+
+function normalizeCapEntry(entry) {
+  if (Array.isArray(entry)) {
+    return { enabled: true, roundRobin: false, models: entry.map((e) => e?.model || e).filter(Boolean) };
+  }
+  if (entry && typeof entry === "object") {
+    return {
+      enabled: entry.enabled !== false,
+      roundRobin: !!entry.roundRobin,
+      models: Array.isArray(entry.models) ? entry.models.filter(Boolean) : [],
+    };
+  }
+  return { enabled: false, roundRobin: false, models: [] };
+}
+
+export function getCapacityAdapterConfig(cap, settings) {
+  const entry = normalizeCapEntry(settings?.capacityAdapter?.[cap]);
+  if (entry.enabled && entry.models.length === 0) {
+    return { ...entry, models: [DEFAULT_FALLBACK_MODEL] };
+  }
+  return entry;
+}
+
+export function getCapacityAdapterModels(settings) {
+  const seen = new Set();
+  const models = [];
+  for (const cap of CAPABILITY_KEYS) {
+    const { enabled, models: pool } = getCapacityAdapterConfig(cap, settings);
+    if (!enabled) continue;
+    for (const m of pool) {
+      if (!seen.has(m)) {
+        seen.add(m);
+        models.push(m);
+      }
+    }
+  }
+  return models;
+}
+
+export function getCapacityAdapterStrategy(cap, settings) {
+  const { enabled, roundRobin } = getCapacityAdapterConfig(cap, settings);
+  return enabled && roundRobin ? "round-robin" : "fallback";
+}
+
+export function getActiveAdapterStrategy(requiredCapabilities, settings) {
+  const hard = [...(requiredCapabilities || [])].filter((c) => HARD_CAPS.has(c));
+  for (const cap of hard) {
+    const { enabled, models } = getCapacityAdapterConfig(cap, settings);
+    if (!enabled || models.length === 0) continue;
+    return getCapacityAdapterStrategy(cap, settings);
+  }
+  return "fallback";
+}
+
+function modelSatisfies(modelStr, requiredHard) {
+  const slash = modelStr.indexOf("/");
+  const provider = slash > 0 ? modelStr.slice(0, slash) : "";
+  const model = slash > 0 ? modelStr.slice(slash + 1) : modelStr;
+  const caps = getCapabilitiesForModel(provider, model);
+  return requiredHard.every((c) => caps[c] === true);
+}
+
+export function augmentModelsWithCapacityAdapter(models, requiredCapabilities, settings) {
+  const hard = [...(requiredCapabilities || [])].filter((c) => HARD_CAPS.has(c));
+  if (hard.length === 0 || !Array.isArray(models) || models.length === 0) return models;
+  if (models.some((m) => modelSatisfies(m, hard))) return models;
+
+  const pool = getCapacityAdapterModels(settings).filter((m) => !models.includes(m) && modelSatisfies(m, hard));
+  if (pool.length === 0) return models;
+  return [...pool, ...models];
+}
+
+const CHARS_PER_TOKEN = 4;
+const HEAD_KEEP = 6;
+
+function blockLength(content) {
+  if (typeof content === "string") return content.length;
+  if (Array.isArray(content)) {
+    return content.reduce((sum, b) => sum + (typeof b?.text === "string" ? b.text.length : 50), 0);
+  }
+  return 0;
+}
+
+export function stripHistoryForContext(body, contextWindow) {
+  const key = Array.isArray(body.messages) ? "messages"
+    : Array.isArray(body.input) ? "input"
+    : Array.isArray(body.contents) ? "contents"
+    : null;
+  if (!key) return body;
+  const arr = body[key];
+  if (!arr || arr.length === 0) return body;
+
+  const isSystem = (r) => r === "system" || r === "developer";
+  const systemMsgs = arr.filter((m) => isSystem(m?.role));
+  const rest = arr.filter((m) => !isSystem(m?.role));
+  if (rest.length === 0) return body;
+
+  const isAssistant = (r) => r === "assistant" || r === "model";
+  let i = rest.length - 1;
+  while (i >= 0 && !isAssistant(rest[i]?.role)) i--;
+  const tail = rest.slice(i + 1);
+  const older = rest.slice(0, i + 1);
+  if (older.length === 0) return body;
+
+  const contentOf = (m) => m.content ?? m.parts;
+
+  const budgetChars = (contextWindow || 200000) * 0.8 * CHARS_PER_TOKEN;
+
+  const headKept = older.slice(0, HEAD_KEEP);
+  let total = systemMsgs.concat(headKept, tail).reduce((s, m) => s + blockLength(contentOf(m)), 0);
+
+  let head = headKept;
+  while (total > budgetChars && head.length > 0) {
+    const dropped = head.pop();
+    total -= blockLength(contentOf(dropped));
+  }
+
+  if (head.length === older.length) return body;
+  return { ...body, [key]: [...systemMsgs, ...head, ...tail] };
+}
+
+export function withCapacityAdapterStripping(handleSingleModel, adapterModels) {
+  const adapterSet = new Set(adapterModels);
+  if (adapterSet.size === 0) return handleSingleModel;
+  return (body, modelStr, ...rest) => {
+    if (adapterSet.has(modelStr)) {
+      const slash = modelStr.indexOf("/");
+      const provider = slash > 0 ? modelStr.slice(0, slash) : "";
+      const model = slash > 0 ? modelStr.slice(slash + 1) : modelStr;
+      const { contextWindow } = getCapabilitiesForModel(provider, model);
+      body = stripHistoryForContext(body, contextWindow);
+    }
+    return handleSingleModel(body, modelStr, ...rest);
+  };
+}

package/src/services/cliModelMapping.js

@@ -0,0 +1,84 @@
+const CLIENT_TOOL_IDS = Object.freeze({
+  claude: "claude",
+  "claude-code": "claude",
+  claude_code: "claude",
+  codex: "codex",
+  opencode: "opencode",
+  cline: "cline",
+  cursor: "cursor",
+  "github-copilot": "copilot",
+  copilot: "copilot",
+  hermes: "hermes",
+  aider: "aider",
+});
+
+const CLAUDE_FAMILIES = new Set(["opus", "sonnet", "haiku", "fable", "mythos"]);
+
+function clean(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function normalizeEntry(entry) {
+  if (!entry || typeof entry !== "object") return null;
+  const sourceModel = clean(entry.sourceModel ?? entry.source_model);
+  const targetModel = clean(entry.targetModel ?? entry.target_model);
+  if (!sourceModel || !targetModel) return null;
+  return { sourceModel, targetModel, enabled: entry.enabled !== false };
+}
+
+export function normalizeCliModelMappings(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const result = {};
+  for (const [toolId, snapshot] of Object.entries(value)) {
+    if (!snapshot || typeof snapshot !== "object") continue;
+    const entries = Array.isArray(snapshot.entries)
+      ? snapshot.entries.map(normalizeEntry).filter(Boolean)
+      : [];
+    result[toolId] = { enabled: snapshot.enabled !== false, entries };
+  }
+  return result;
+}
+
+export function clientToolId(clientId) {
+  return CLIENT_TOOL_IDS[clean(clientId).toLowerCase()] || clean(clientId).toLowerCase();
+}
+
+function familyFor(model) {
+  const lower = clean(model).toLowerCase();
+  for (const family of CLAUDE_FAMILIES) {
+    if (lower.includes(family)) return family;
+  }
+  return null;
+}
+
+function matchesClaudeFamily(sourceModel, requestedModel) {
+  const source = clean(sourceModel).toLowerCase();
+  const requested = clean(requestedModel).toLowerCase();
+  if (!source || !requested) return false;
+  if (source === requested) return true;
+  const sourceFamily = familyFor(source);
+  const requestedFamily = familyFor(requested);
+  return Boolean(sourceFamily && sourceFamily === requestedFamily);
+}
+
+export function resolveCliModelMapping(clientId, sourceModel, mappings) {
+  const source = clean(sourceModel);
+  if (!source) return sourceModel;
+  const toolId = clientToolId(clientId);
+  const all = normalizeCliModelMappings(mappings);
+  const snapshot = all[toolId];
+  if (!snapshot?.enabled) return sourceModel;
+
+  const exact = snapshot.entries.find((entry) => entry.enabled && entry.sourceModel === source);
+  if (exact) return exact.targetModel;
+
+  if (toolId === "claude") {
+    const family = snapshot.entries.find(
+      (entry) => entry.enabled && matchesClaudeFamily(entry.sourceModel, source),
+    );
+    if (family) return family.targetModel;
+  }
+  return sourceModel;
+}
+
+export { CLIENT_TOOL_IDS, CLAUDE_FAMILIES };

package/src/services/clinepassModels.js

@@ -0,0 +1,60 @@
+import { buildClineHeaders } from "../shared/clineAuth.js";
+
+const CLINEPASS_MODELS_ENDPOINT = "https://api.cline.bot/api/v1/models";
+const FETCH_TIMEOUT_MS = 5000;
+
+function buildModelListHeaders(token, isApiKey) {
+  if (isApiKey) {
+    return {
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`,
+    };
+  }
+  return buildClineHeaders(token, { Accept: "application/json" });
+}
+
+export async function resolveClinepassModels(credentials) {
+  const isApiKey = Boolean(credentials?.apiKey);
+  const token = isApiKey ? credentials.apiKey : credentials?.accessToken;
+  if (!token) return null;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+
+  try {
+    const response = await fetch(CLINEPASS_MODELS_ENDPOINT, {
+      method: "GET",
+      headers: buildModelListHeaders(token, isApiKey),
+      signal: controller.signal,
+    });
+    if (!response.ok) return null;
+
+    const json = await response.json();
+    const rawList = Array.isArray(json)
+      ? json
+      : Array.isArray(json?.data)
+        ? json.data
+        : Array.isArray(json?.models)
+          ? json.models
+          : Array.isArray(json?.data?.models)
+            ? json.data.models
+            : [];
+    if (!rawList.length) return null;
+
+    const models = rawList
+      .filter((model) => typeof model?.id === "string" && model.id.length > 0)
+      .filter((model) => !model.id.includes("/free/"))
+      .map((model) => ({
+        ...model,
+        id: model.id,
+        name: model.name || model.id,
+        capabilities: model.capabilities || model.caps,
+      }));
+
+    return models.length ? { models } : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/services/codebuddyModels.js

@@ -0,0 +1,250 @@
+import {
+  refreshCodebuddyToken,
+  refreshCodebuddyIntlToken,
+} from "./tokenRefresh/providers.js";
+
+const CODEBUDDY_CONFIG = {
+  "codebuddy-cn": {
+    baseUrl: "https://copilot.tencent.com",
+    domain: "copilot.tencent.com",
+    userAgent: "CLI/2.108.1 CodeBuddy/2.108.1",
+  },
+  "codebuddy-intl": {
+    baseUrl: "https://www.codebuddy.ai",
+    domain: "www.codebuddy.ai",
+    userAgent: "CLI/2.108.1 CodeBuddy/2.108.1",
+  },
+};
+
+const MODEL_CATALOG_PATH = "/v3/config";
+
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+function asString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function decodeBase64Url(value) {
+  try {
+    const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+    return Buffer.from(padded, "base64").toString("utf8");
+  } catch {
+    return "";
+  }
+}
+
+export function decodeCodeBuddyJwtPayload(token) {
+  const parts = asString(token).split(".");
+  if (parts.length < 2) return {};
+  try {
+    return asObject(JSON.parse(decodeBase64Url(parts[1])));
+  } catch {
+    return {};
+  }
+}
+
+function getIdentity(token) {
+  const payload = decodeCodeBuddyJwtPayload(token);
+  return {
+    userId: asString(payload.sub || payload.userId || payload.user_id),
+    tenantId: asString(payload.tenantId || payload.tenant_id),
+    enterpriseId: asString(payload.enterpriseId || payload.enterprise_id),
+  };
+}
+
+export function buildCodeBuddyModelHeaders(provider, accessToken) {
+  const config = CODEBUDDY_CONFIG[provider];
+  if (!config) throw new Error(`Unsupported CodeBuddy provider: ${provider}`);
+
+  const identity = getIdentity(accessToken);
+  const headers = {
+    Accept: "application/json, text/plain, */*",
+    "Content-Type": "application/json",
+    "X-Requested-With": "XMLHttpRequest",
+    Authorization: `Bearer ${accessToken}`,
+    "User-Agent": config.userAgent,
+    "X-Agent-Intent": "cli",
+    "X-IDE-Type": "CLI",
+    "X-IDE-Name": "CLI",
+    "X-IDE-Version": "2.108.1",
+    "X-Product-Version": "4.10.35413651",
+    "X-Env-ID": "production",
+    "X-Domain": config.domain,
+    "X-Product": "SaaS",
+  };
+
+  if (identity.userId) headers["X-User-Id"] = identity.userId;
+  if (identity.tenantId) headers["X-Tenant-Id"] = identity.tenantId;
+  if (identity.enterpriseId) headers["X-Enterprise-Id"] = identity.enterpriseId;
+  return headers;
+}
+
+function modelId(value) {
+  if (typeof value === "string") return value.trim();
+  const item = asObject(value);
+  return asString(item.id || item.model || item.modelId || item.name);
+}
+
+function isChatModel(model) {
+  const item = asObject(model);
+  const descriptor = [
+    modelId(item),
+    item.name,
+    item.type,
+    item.kind,
+    item.category,
+    ...(Array.isArray(item.tags) ? item.tags : []),
+  ]
+    .map(asString)
+    .join(" ")
+    .toLowerCase();
+
+  return !/image|video/.test(descriptor);
+}
+
+function normalizeThinkingLevels(model, capabilities) {
+  const reasoning = asObject(model.reasoning);
+  const raw = reasoning.supportedEfforts
+    || reasoning.supportedLevels
+    || model.supportedReasoningEfforts
+    || model.reasoningEfforts
+    || [];
+  const values = (Array.isArray(raw) ? raw : [raw])
+    .map((value) => asString(value).toLowerCase())
+    .filter(Boolean);
+
+  if (!capabilities.reasoning && values.length === 0) return undefined;
+  const levels = [...new Set(values)];
+  if (capabilities.thinkingCanDisable !== false && !levels.includes("none")) {
+    levels.unshift("none");
+  }
+  return levels.length ? levels : undefined;
+}
+
+function normalizeModel(model) {
+  const item = asObject(model);
+  const id = modelId(item);
+  if (!id) return null;
+
+  const reasoning = asObject(item.reasoning);
+  const supportedEfforts = reasoning.supportedEfforts
+    || reasoning.supportedLevels
+    || item.supportedReasoningEfforts
+    || item.reasoningEfforts;
+  const hasReasoningMetadata = Boolean(
+    reasoning && Object.keys(reasoning).length > 0
+  );
+  const capabilities = {
+    vision: item.supportsImages === true || item.supportsVision === true,
+    tools: item.supportsToolCall !== false && item.supportsTools !== false,
+    reasoning: item.supportsReasoning === true
+      || hasReasoningMetadata
+      || (Array.isArray(supportedEfforts) && supportedEfforts.length > 0),
+    thinkingFormat: "openai",
+    ...(typeof reasoning.canDisableThinking === "boolean"
+      ? { thinkingCanDisable: reasoning.canDisableThinking }
+      : {}),
+    ...(Number(item.maxInputTokens) > 0 ? { contextWindow: Number(item.maxInputTokens) } : {}),
+    ...(Number(item.maxOutputTokens) > 0 ? { maxOutput: Number(item.maxOutputTokens) } : {}),
+  };
+
+  const thinkingLevels = normalizeThinkingLevels(item, capabilities);
+  return {
+    id,
+    name: asString(item.displayName || item.name || id) || id,
+    ...(asString(item.description) ? { description: asString(item.description) } : {}),
+    ...(thinkingLevels ? { thinkingLevels } : {}),
+    capabilities,
+  };
+}
+
+export function parseCodeBuddyConfig(payload) {
+  const root = asObject(payload?.data || payload);
+  const catalog = Array.isArray(root.models) ? root.models : [];
+  const selected = catalog.filter(isChatModel);
+
+  return selected.map(normalizeModel).filter(Boolean);
+}
+
+function refreshForProvider(provider, refreshToken, log) {
+  return provider === "codebuddy-cn"
+    ? refreshCodebuddyToken(refreshToken, log)
+    : refreshCodebuddyIntlToken(refreshToken, log);
+}
+
+export async function resolveCodeBuddyModels(credentials, options = {}) {
+  const provider = asString(credentials?.provider);
+  const config = CODEBUDDY_CONFIG[provider];
+  if (!config) return { error: "Unsupported CodeBuddy provider", status: 400 };
+
+  let accessToken = asString(credentials?.accessToken);
+  let refreshToken = asString(credentials?.refreshToken);
+  const log = options.log;
+
+  async function persistRefresh(refreshed) {
+    if (!refreshed?.accessToken) return false;
+    accessToken = refreshed.accessToken;
+    refreshToken = refreshed.refreshToken || refreshToken;
+    if (typeof options.onCredentialsRefreshed === "function") {
+      await options.onCredentialsRefreshed(refreshed);
+    }
+    return true;
+  }
+
+  if (!accessToken && refreshToken) {
+    let refreshed = null;
+    try {
+      refreshed = await refreshForProvider(provider, refreshToken, log);
+    } catch (error) {
+      log?.warn?.("CODEBUDDY_MODELS", "CodeBuddy refresh token exchange failed", {
+        provider,
+        error: error?.message || String(error),
+      });
+    }
+    if (refreshed?.accessToken) await persistRefresh(refreshed);
+  }
+  if (!accessToken) return { error: "No valid token found", status: 401 };
+
+  const url = `${config.baseUrl}${MODEL_CATALOG_PATH}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: buildCodeBuddyModelHeaders(provider, accessToken),
+      ...(options.signal ? { signal: options.signal } : {}),
+    });
+
+    if ((response.status === 401 || response.status === 403) && refreshToken) {
+      const refreshed = await refreshForProvider(provider, refreshToken, log);
+      if (refreshed?.accessToken && await persistRefresh(refreshed)) {
+        response = await fetch(url, {
+          method: "GET",
+          headers: buildCodeBuddyModelHeaders(provider, accessToken),
+          ...(options.signal ? { signal: options.signal } : {}),
+        });
+      }
+    }
+
+    if (!response.ok) {
+      return {
+        models: [],
+        status: response.status,
+        warning: `CodeBuddy model catalog returned ${response.status}.`,
+      };
+    }
+
+    const models = parseCodeBuddyConfig(await response.json());
+    return models.length
+      ? { models }
+      : { models: [], warning: "CodeBuddy returned no CLI models." };
+  } catch (error) {
+    log?.warn?.("CODEBUDDY_MODELS", "CodeBuddy model catalog request failed", {
+      provider,
+      error: error?.message || String(error),
+    });
+    return { models: [], warning: "CodeBuddy model catalog is unavailable." };
+  }
+}