swayrouter 1.0.0

package/src/services/kiroModels.js

@@ -0,0 +1,246 @@
+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;
+
+const catalogCache = new Map();
+
+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;
+}
+
+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;
+}
+
+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"
+  };
+}
+
+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;
+}
+
+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}`;
+  }
+
+  const rateStr = rate.toFixed(1).replace(",", ".");
+  return `Kiro ${base} (${rateStr}x credit)`;
+}
+
+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);
+
+  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;
+}
+
+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");
+}
+
+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);
+
+          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,
+
+        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 };
+}
+
+export function invalidateKiroModelCache(credentials) {
+  if (!credentials) return;
+  catalogCache.delete(cacheKey(credentials));
+}
+
+export function clearKiroModelCache() {
+  catalogCache.clear();
+}

package/src/services/model.js

@@ -0,0 +1,83 @@
+import REGISTRY from "../providers/registry/index.js";
+
+const ALIAS_TO_PROVIDER_ID = {};
+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;
+}
+
+const BUILTIN_MODEL_ALIASES = {
+  "grok-build": "gcli/grok-build",
+};
+
+export function resolveProviderAlias(aliasOrId) {
+  return ALIAS_TO_PROVIDER_ID[aliasOrId] || aliasOrId;
+}
+
+export function parseModel(modelStr) {
+  if (!modelStr) {
+    return { provider: null, model: null, isAlias: false, providerAlias: null };
+  }
+
+  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 };
+  }
+
+  return {
+    provider: null,
+    model: modelStr,
+    isAlias: true,
+    providerAlias: null,
+  };
+}
+
+function resolveBuiltinModelAlias(alias) {
+  const resolved = BUILTIN_MODEL_ALIASES[alias];
+  if (!resolved) return null;
+
+  const firstSlash = resolved.indexOf("/");
+  return {
+    provider: resolveProviderAlias(resolved.slice(0, firstSlash)),
+    model: resolved.slice(firstSlash + 1),
+  };
+}
+
+export async function getModelInfoCore(modelStr) {
+  const parsed = parseModel(modelStr);
+
+  if (!parsed.isAlias) {
+    return {
+      provider: parsed.provider,
+      model: parsed.model,
+    };
+  }
+
+  const resolved = resolveBuiltinModelAlias(parsed.model);
+  if (resolved) {
+    return resolved;
+  }
+
+  return {
+    provider: inferProviderFromModelName(parsed.model),
+    model: parsed.model,
+  };
+}
+
+const MODEL_PREFIX_PROVIDERS = [
+  [/^claude-/, "anthropic"],
+  [/^gemini-/, "gemini"],
+  [/^gpt-/, "openai"],
+  [/^o[134]/, "openai"],
+  [/^deepseek-/, "openrouter"],
+];
+
+function inferProviderFromModelName(modelName) {
+  if (!modelName) return "openai";
+  const m = modelName.toLowerCase();
+  return MODEL_PREFIX_PROVIDERS.find(([re]) => re.test(m))?.[1] || "openai";
+}

package/src/services/oauthCredentialManager.js

@@ -0,0 +1,153 @@
+import {
+  getRefreshLeadMs,
+  isUnrecoverableRefreshError,
+  refreshTokenByProvider,
+} from "./tokenRefresh.js";
+import { PROVIDER_OAUTH } from "../providers/index.js";
+
+export const CODEX_MAX_REFRESH_AGE_MS = PROVIDER_OAUTH["codex"]?.maxRefreshAgeMs;
+
+const refreshLocks = new Map();
+
+function parseTimeMs(value) {
+  if (value === undefined || value === null || value === "") return null;
+  if (typeof value === "number") {
+    return value < 1e12 ? value * 1000 : value;
+  }
+
+  const parsed = new Date(value).getTime();
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function toExpiresAt(expiresIn, nowMs = Date.now()) {
+  if (!expiresIn) return null;
+  return new Date(nowMs + expiresIn * 1000).toISOString();
+}
+
+export function getCredentialExpiryMs(credentials) {
+  return parseTimeMs(credentials?.expiresAt ?? credentials?.tokenExpiresAt);
+}
+
+export function getCredentialLastRefreshMs(credentials) {
+  return parseTimeMs(
+    credentials?.lastRefreshAt ??
+    credentials?.lastRefresh ??
+    credentials?.providerSpecificData?.lastRefreshAt
+  );
+}
+
+export function isCodexRefreshStale(credentials, nowMs = Date.now(), maxAgeMs = CODEX_MAX_REFRESH_AGE_MS) {
+  const lastRefreshMs = getCredentialLastRefreshMs(credentials);
+  return !lastRefreshMs || nowMs - lastRefreshMs >= maxAgeMs;
+}
+
+export function shouldRefreshCredentials(provider, credentials, nowMs = Date.now()) {
+  if (!credentials) return false;
+
+  const expiresAtMs = getCredentialExpiryMs(credentials);
+  if (expiresAtMs !== null && expiresAtMs - nowMs < getRefreshLeadMs(provider)) {
+    return true;
+  }
+
+  const maxAgeMs = PROVIDER_OAUTH[provider]?.maxRefreshAgeMs;
+  if (maxAgeMs && credentials.refreshToken && isCodexRefreshStale(credentials, nowMs, maxAgeMs)) {
+    return true;
+  }
+
+  return false;
+}
+
+export function mergeProviderSpecificData(existing, next) {
+  if (!next || typeof next !== "object") return existing;
+  return {
+    ...(existing || {}),
+    ...next,
+  };
+}
+
+export function mergeRefreshedCredentials(provider, currentCredentials, refreshedCredentials, nowMs = Date.now()) {
+  if (!refreshedCredentials) return null;
+  if (isUnrecoverableRefreshError(refreshedCredentials)) return refreshedCredentials;
+
+  const next = {};
+  const nowIso = new Date(nowMs).toISOString();
+
+  if (refreshedCredentials.accessToken) next.accessToken = refreshedCredentials.accessToken;
+  if (refreshedCredentials.apiKey) next.apiKey = refreshedCredentials.apiKey;
+  if (refreshedCredentials.token) next.token = refreshedCredentials.token;
+
+  const refreshToken = refreshedCredentials.refreshToken ?? currentCredentials?.refreshToken;
+  if (refreshToken) next.refreshToken = refreshToken;
+
+  const idToken = refreshedCredentials.idToken ?? currentCredentials?.idToken;
+  if (idToken) next.idToken = idToken;
+
+  if (refreshedCredentials.expiresIn) {
+    next.expiresIn = refreshedCredentials.expiresIn;
+    next.expiresAt = toExpiresAt(refreshedCredentials.expiresIn, nowMs);
+  } else if (refreshedCredentials.expiresAt) {
+    next.expiresAt = refreshedCredentials.expiresAt;
+  }
+
+  if (refreshedCredentials.projectId) next.projectId = refreshedCredentials.projectId;
+
+  if (refreshedCredentials.providerSpecificData) {
+    next.providerSpecificData = mergeProviderSpecificData(
+      currentCredentials?.providerSpecificData,
+      refreshedCredentials.providerSpecificData
+    );
+  }
+
+  if (refreshedCredentials.copilotToken) next.copilotToken = refreshedCredentials.copilotToken;
+  if (refreshedCredentials.copilotTokenExpiresAt) {
+    next.copilotTokenExpiresAt = refreshedCredentials.copilotTokenExpiresAt;
+  }
+
+  if (
+    PROVIDER_OAUTH[provider]?.trackRefreshAt ||
+    next.accessToken ||
+    next.apiKey ||
+    next.token ||
+    next.refreshToken ||
+    next.copilotToken
+  ) {
+    next.lastRefreshAt = refreshedCredentials.lastRefreshAt || nowIso;
+  }
+
+  return next;
+}
+
+function getRefreshLockKey(provider, credentials) {
+  const stableId =
+    credentials?.connectionId ||
+    credentials?.id ||
+    credentials?.email ||
+    credentials?.name ||
+    credentials?.refreshToken?.slice?.(-16) ||
+    "default";
+  return `${provider}:${stableId}`;
+}
+
+export async function withCredentialRefreshLock(provider, credentials, refreshFn) {
+  const key = getRefreshLockKey(provider, credentials);
+  const existing = refreshLocks.get(key);
+  if (existing) return existing;
+
+  const pending = Promise.resolve()
+    .then(refreshFn)
+    .finally(() => {
+      refreshLocks.delete(key);
+    });
+
+  refreshLocks.set(key, pending);
+  return pending;
+}
+
+export async function refreshProviderCredentials(provider, credentials, log) {
+  if (!credentials) return null;
+
+  return withCredentialRefreshLock(provider, credentials, async () => {
+    const refreshed = await refreshTokenByProvider(provider, credentials, log);
+    return mergeRefreshedCredentials(provider, credentials, refreshed);
+  });
+}