swayrouter 1.0.0

package/src/config/appConstants.js

@@ -0,0 +1,153 @@
+import { platform, arch, hostname } from "os";
+import { PROVIDERS, PROVIDER_OAUTH } from "./providers.js";
+import { ANTIGRAVITY_IDE_USER_AGENT } from "../providers/shared.js";
+import { createRequire } from "module";
+
+export const GEMINI_CLI_VERSION = PROVIDERS["gemini-cli"]?.cliVersion;
+export const GEMINI_CLI_API_CLIENT = PROVIDERS["gemini-cli"]?.apiClient;
+
+function geminiCLIArch() {
+  const a = arch();
+  if (a === "ia32") return "x86";
+  return a;
+}
+
+export function geminiCLIUserAgent(model = "unknown") {
+  return `GeminiCLI/${GEMINI_CLI_VERSION}/${model || "unknown"} (${platform()}; ${geminiCLIArch()}; terminal)`;
+}
+
+const _ghCopilot = PROVIDERS.github?.copilot || {};
+export const GITHUB_COPILOT = {
+  VSCODE_VERSION: _ghCopilot.vscodeVersion,
+  COPILOT_CHAT_VERSION: _ghCopilot.chatVersion,
+  USER_AGENT: _ghCopilot.userAgent,
+  API_VERSION: _ghCopilot.apiVersion,
+};
+
+export const IDE_TYPE = {
+  UNSPECIFIED: 0,
+  JETSKI: 10,
+  ANTIGRAVITY: 9,
+  PLUGINS: 7
+};
+
+export const PLATFORM = {
+  UNSPECIFIED: 0,
+  DARWIN_AMD64: 1,
+  DARWIN_ARM64: 2,
+  LINUX_AMD64: 3,
+  LINUX_ARM64: 4,
+  WINDOWS_AMD64: 5
+};
+
+export const PLUGIN_TYPE = {
+  UNSPECIFIED: 0,
+  CLOUD_CODE: 1,
+  GEMINI: 2
+};
+
+export function getPlatformEnum() {
+  const os = platform();
+  const architecture = arch();
+  if (os === "darwin") return architecture === "arm64" ? PLATFORM.DARWIN_ARM64 : PLATFORM.DARWIN_AMD64;
+  if (os === "linux") return architecture === "arm64" ? PLATFORM.LINUX_ARM64 : PLATFORM.LINUX_AMD64;
+  if (os === "win32") return PLATFORM.WINDOWS_AMD64;
+  return PLATFORM.UNSPECIFIED;
+}
+
+export function getPlatformUserAgent() {
+  return ANTIGRAVITY_IDE_USER_AGENT;
+}
+
+export const CLIENT_METADATA = {
+  ideType: IDE_TYPE.ANTIGRAVITY,
+  platform: getPlatformEnum(),
+  pluginType: PLUGIN_TYPE.GEMINI
+};
+
+export const INTERNAL_REQUEST_HEADER = { name: "x-request-source", value: "local" };
+
+export const ANTIGRAVITY_HEADERS = {
+  "User-Agent": ANTIGRAVITY_IDE_USER_AGENT
+};
+
+export const CLOUD_CODE_API = {
+  "gemini-cli": {
+    loadCodeAssist: "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
+    onboardUser: "https://cloudcode-pa.googleapis.com/v1internal:onboardUser",
+  },
+
+  antigravity: {
+    loadCodeAssist: "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist",
+    onboardUser: "https://cloudcode-pa.googleapis.com/v1internal:onboardUser",
+  },
+};
+
+export const LOAD_CODE_ASSIST_HEADERS = {
+  "Content-Type": "application/json",
+  "User-Agent": "google-api-nodejs-client/9.15.1",
+  "X-Goog-Api-Client": "google-cloud-sdk vscode_cloudshelleditor/0.1",
+  "Client-Metadata": JSON.stringify({ ideType: IDE_TYPE.ANTIGRAVITY, platform: getPlatformEnum(), pluginType: PLUGIN_TYPE.GEMINI }),
+};
+
+export const ANTIGRAVITY_LOAD_CODE_ASSIST_HEADERS = {
+  "Content-Type": "application/json",
+  "User-Agent": ANTIGRAVITY_IDE_USER_AGENT,
+};
+
+export const LOAD_CODE_ASSIST_METADATA = {
+  ideType: IDE_TYPE.ANTIGRAVITY,
+  platform: getPlatformEnum(),
+  pluginType: PLUGIN_TYPE.GEMINI,
+};
+
+export const REFRESH_LEAD_MS = Object.fromEntries(
+  Object.entries(PROVIDER_OAUTH).filter(([, o]) => o.refreshLeadMs).map(([id, o]) => [id, o.refreshLeadMs])
+);
+
+export const OAUTH_ENDPOINTS = {
+  google:    { token: "https://oauth2.googleapis.com/token", auth: "https://accounts.google.com/o/oauth2/auth" },
+  openai:    { token: PROVIDER_OAUTH["codex"]?.tokenUrl, auth: PROVIDER_OAUTH["codex"]?.authorizeUrl },
+  anthropic: { token: PROVIDER_OAUTH["claude"]?.tokenUrl, auth: "https://api.anthropic.com/v1/oauth/authorize" },
+  github:    { token: PROVIDER_OAUTH["github"]?.tokenUrl, auth: PROVIDER_OAUTH["github"]?.authorizeUrl, deviceCode: PROVIDER_OAUTH["github"]?.deviceCodeUrl },
+};
+
+let _appVersion;
+function getAppPackageVersion() {
+  if (_appVersion) return _appVersion;
+  try {
+    const require = createRequire(import.meta.url);
+    _appVersion = require("../../package.json").version || "0.0.0";
+  } catch {
+    _appVersion = process.env.npm_package_version || "0.0.0";
+  }
+  return _appVersion;
+}
+
+export function buildKimiHeaders(deviceId) {
+  const osName = platform();
+  const architecture = arch();
+  let deviceModel = `${osName} ${architecture}`;
+  if (osName === "darwin") deviceModel = `macOS ${architecture}`;
+  else if (osName === "win32") deviceModel = `Windows ${architecture}`;
+  else if (osName === "linux") deviceModel = `Linux ${architecture}`;
+
+  let deviceName = "unknown";
+  try {
+    deviceName = hostname() || "unknown";
+  } catch {
+    deviceName = "unknown";
+  }
+
+  const resolvedId = (typeof deviceId === "string" && deviceId.trim())
+    ? deviceId.trim()
+    : `kimi-${Date.now()}`;
+
+  return {
+    "X-Msh-Platform": "swayrouter",
+    "X-Msh-Version": getAppPackageVersion(),
+    "X-Msh-Device-Name": deviceName,
+    "X-Msh-Device-Model": deviceModel,
+    "X-Msh-Device-Id": resolvedId,
+  };
+}

package/src/config/defaultThinkingSignature.js

@@ -0,0 +1,7 @@
+export const DEFAULT_THINKING_CLAUDE_SIGNATURE = "EpwGCkYIChgCKkCzVUuRrg7CcglSUWEef4rH6o35g9UYS8ZPe0/VomQTBsFx6sttYNj5l8GqgW6ejuHyYqpFToxIbZl0bw17l5dJEgzCnqDO0Z8fRlMrNgsaDLS1cnCjC53KBqE0CCIwAADQdo1eO+7qPAmo8J4WR3JPmr92S97kmvr5K1iPMiOpkZNj8mEXW8uzBoOJs/9ZKoMFiqHJ3UObwaJDqFOW70E9oCwDoc6jesaWVAEdN5vWfKMpIkjFJjECdjIdkxyJNJ8Ib8yXVal3qwE7uThoPRqSZDdHB5mmwPEjWE/90cSYCbtX2YsJki1265CabBb8/QEkODXg4kgRrL+c8e8rRXz/dr1RswvaPuzEdGKHRNi9UooNUeOK4/ebx1KkP9YZttyohN9GWqlts36kOoW0Cfie/ABDgF9g534BPth/sstxDM6d79QlRmh6NxizyTF74DXJI34u0M4tTRchqE5pAq85SgdJaa+dix1yJPMji8m6nZkwJbscJb9rdc2MKyKWjz8QL2+rTSSuZ2F1k1qSsW0xNcI7qLcI12Vncfn/VqY6YOIZy/saZBR0ezXvN6g+UYbuIdyVg7AyIFZt3nbrO7/kmOEb2VKzygwklHGEIJHfFgMpH3JSrAzbZIowVHOF7VaJ+KXRFDCFin7hHTOiOsdg+1ij1mML9Z/x/9CP4b7OUcaQm1llDZPSHc6rZMNL3DdB+fW5YfmNgKU35S+7AMtA10nVILzDAk1UV4T2K9Do09JlI6rjOs9UuULlIN2Z0eE8YTlANR6uQcw7lMcdfqYE8tke4rDKc2dDiaS5vVe45VewICNpdXGN11yw8QqH7p27CR1HtN30e0tHXOR3bIwWk/Yb6O5fTaKG6Ri8e5ZCPvdD9HqepVi188nM0iTjJqL58F3ni04ECIhcbyaQWnuTes1Kw4CMwiZDLQkk8Hgz7HkUOf1btQTF/0nhD7ry0n0hAEg2PaDM3V6TjOjf4hEldRmeqERcQF1PfgKb6ZM12rlIIfUqKACczWJSzTV158+47HX36o0cgux6nFlv/DE+sEiRVxgB";
+
+export const DEFAULT_THINKING_AG_SIGNATURE = "EuwGCukGAXLI2nxwZIq54WWSoL/YN0P3TsDZ7zRnLi8g0S4aVr2HUGxvaHKySuY6HAVzcE0GPGjXrytLIldxthSvfxgUlJh6Qa9Z+Oj5QZBlYdg6HaJ6yuY5R7waE6rdwBsRf7Ft2j3DJ9rMi9qhWFqApewYtPhls3VHtuvND3l8Rm09+lbAXQs6KKWEWrxNLKTBkfpMgXhRERc/TQRMZu1twAablm6/Zk1tsYRvfWKLsNbeKF+CCojJdXJKvnR/8Ouuoa+Y2Ti20hcW7aZIIjZDFYPU//k6Ybmhg69J/imbFai2ckhfLaisqdDkdoIiBJScTOUvYqP6AE9d4MsydSC+UlhIMk4hoP76R8vUSCZRMkjOaDXstf/QoVZKbt94wyRZgAJ1G0BqI8L5ow86kLpA4wJEtxsRGymOE4bKUvApveBakYDNM9APkf+LbtbzWSseGjoZcSlycF9iN8Q2XNYKRrHbv3Lr5Y8JjdH/5y/6SHkNehTEZugaeGnSPSyCTWto1kQgHpxdWmhkLfJGNUGLmue7Mesj4TSms4J33mRpYVhNB/J333FCqIP0hr/E7BkkjEn7yZ4X7SQlh+xKPurapsnHRwiKmtsilmEFrnTE9iQr+pMr6M29qqFNv1tr5yumbaJw8JW9sB15tNsRv+dW6BjNanbsKz7HCgKUBc8tGy+7YuhXzAfViyRefcjK7eZW0Fbyt7AbybJTKz78W8NH7ye6LAwzOebXpeZ4D43fNIt8bKh26qgduSQv/7o+pAflkuqHZ99YWgHQ8h8OkZFi3eOiSYjsjhdZ/czWOdoPI/OnqIldzMPF5YlrKBLFX8VhRKVmqgsmWf5PHGulHhMkVlS+XG2UIseGy69ARa93D78Gsa+1n1kJr7EEB7Rh+27vUMxVYLdz1yMSvE5nalTAlg/ZeG8+XQ0cHuAI3KbQpHW2Q++RdXfm5JzD5WdJZUU+Zn8t8UUn85BH4RxZLeE0qJikgSsKoYVBc6YhiMjhPgkR95ReimY4Z0xCJdRo1gjexOFeODZMpQF6Yxnoic7IrdgsFA3iePTbFnPp3IAM1fAThWhXJUn3QInUOTd5o1qmTmn6REbL15g/JQNl+dqUoPkhleeb2V3kjqp1okmO3wMZbPknR3S1LZNmlS72/iBQUm+n2b/RCn4PjmM2";
+
+export const DEFAULT_THINKING_VERTEX_SIGNATURE = "CloBjz1rX5+yg1ILh/Ag+suum5k1f/9m/hI0XDQ33lsQIYnOHLn9KZwN0C7E4jgep5MzZvz5Se1Z1xxYrA1+Iz0Il4tabBhaDfMKNa5dGdEA3KnikfjfIpMlPaAKaQGPPWtf2hodPdBgguiZqDn+Qz2LwGEqHVJ16LVBUpeSx7UnYBLSwio8cyNy0jPijOh5QXKLTeHVdO2tKKcCCrtG2JCW3dOSrW2qA8eyAg40iQUnMNECjbcjkqB1+zrab7jX9ILwg7L9OgqYAQGPPWtfT4nzaPzSkXePAa920abYxPs3fg/RHDlg8PUVFLa+ko6qOjt7nXJTMxN0cpCwUCFX7eHHcMnA6vApyA/rXvJiAABkHZ3HilAktXRtxr/thHU0H8/4H5gT3kzoQcq9aMznrKomd3ct0mFi0ioSKnOEfoY1Mrfj00p/ZWm0tT7Wrjcm3BQXZ+T9Vrb94k+6CjtcEBrGCq8BAY89a1/vTMczqwB1NP3HCCuBdnds2vDXkj6XAYaXjsjmik8tGqwMKHz8R9RAWsx6SO6pkGEpXXpRzAaUx6c+aofsL/z1xOcN7ArCAa6uEeQKEgNngZuCP05p4+9P95epVmgOjFa4KfsPnyg+NKUkEFmpPSDrIRyMT+xERlclVcCI98/u7i8a9+vTbgzl8TRFYryClNH37K1ye5i6kqSGDUcMyiEasjke5BxbUh3i6wqMAgGPPWtfk+A+iY38QAldu117FEkTIkzbYOIt67lk9c6Ou3Y3Ct8TFHFw5QwGfSFc0YWjeTFHdm9UdV5jPK35p6VfhiRSva3w2+JLIHb4jvv5HutZPOJ3yQTt/+hUDj80oMNMbwnxNZvCEdzKS+D9vwmTACAm5H0ZetBSH2gPJXnhhuQo9AegS3wIWVR2a5k643Vx9r4u4pOvij4476lxKswIHvqsjL4jnTzRCvd44G6dn7vD0ENGb1K/i+dMRQMcOBaOxPN0ynk9bKxXWRDbZ+Rhakfr+y74z+6eYCdRPVqO9I7s+riilFuRIfaQ+U6/vuVKGIWEVKCfZZi0z6H5Xgz1xmse0u0AsittDlIKxwEBjz1rX783A0vehvUeabRia+/pX46IsN5efTAxFEBUeUce3jLuXIghkMV2b8KNhUs2G0aZldDDewRQbkluQabBMDT82N5I7reJP0VZgLIKccCL5DoGv1J7YWM2npLMIgZ6aP8aSlT3PFFJ0IXbUZUrzduczmIm6nzAJf9zxmq1aIFYw8YrgW8RjUdy0UvUmRoBEShSGUrvsyaRTl7J//KJW5utIPunFMu53GPWLidCFHzM1QA3Cj1+4zv5UXajP/V92RQayWbzCvYBAY89a1+yzoVSWukUGH7kX71Tg9dx7HA7OyKYwnYaqekG98zJfcUM/3KoiiiotW5t4xYu//ksEl36bSWvUHsRnxGByg+3WYdnZqKg0AtdRB/EXbI5PsjvS5ko96bkjSuFkY3TjHGwAM2B94K6/t6OTE/NBbxCsY9sT4d+1sbFv/iyfmfCnfvJaSzGmC9CDWKy4iqQ/vBNWps9j1JXk0p5uPAYC2BaMkxl5xoTVZqI3zAuRtQF5JLmPPy+PdqOgFxMKcLGNhwp7dbhIFLF68vCYQ9CL0NnK2d3CFk1UFVYxsi1TsolR1xahe/Rxt5HZDz/z65nevrQ";
+
+export const DEFAULT_THINKING_GEMINI_CLI_SIGNATURE = "CiQBjz1rX/AlslZWMe5RgBt4Tv9j4+YNZTTez+JH2/+5oAlICygKXgGPPWtf7/Sux9eLYap/bmYAdPqFThLXj+l7o0DLu/hdgU98MA9ZrlRDNHXx+T0tuY8AcnjPZbiDyOq2bE11Fjhsk6p5axqayaapC/Pt9GczcgIQf1z15WTxCeKWAPYKYQGPPWtfDYj0nlNFNoTlU39RC91Z16xFKJ2MLEmkm+NvimsoOJ6be3g2BssNPtJ/9BKDXRA5cVs17tBeeW72lH8TMB5999udtxHM2SiUsnWsrHlfVuGSCpNQQ+5REw8HNvEKkgEBjz1rXzBNWrqZGbjun55K+vgYPBhJO2qZ67uRWXUA5/qcU12U/mbi5XoA3swoxYE8LEXfZvFFC9WG/W28QNCA0Qd4Trk/WkWiAwZmB8a84Fs14rkv3wqyxwFavPkJorqurAfd2XzGiFy0sB0ITCOPYi1HzDGV5WfXk6b9k+jT66/RuzGa8EcSOWo/QtC3Bkhgowo4AY89a1/f/tw8A02zjIoK7JVDAbf8W4UfmbApJJhwXIiGtu1M0JItObx7g2reYqT+HHL2Q/R4VDc=";

package/src/config/errorConfig.js

@@ -0,0 +1,117 @@
+export const ERROR_TYPES = {
+  400: { type: "invalid_request_error", code: "bad_request" },
+  401: { type: "authentication_error", code: "invalid_api_key" },
+  402: { type: "billing_error", code: "payment_required" },
+  403: { type: "permission_error", code: "insufficient_quota" },
+  404: { type: "invalid_request_error", code: "model_not_found" },
+  406: { type: "invalid_request_error", code: "model_not_supported" },
+  429: { type: "rate_limit_error", code: "rate_limit_exceeded" },
+  500: { type: "server_error", code: "internal_server_error" },
+  502: { type: "server_error", code: "bad_gateway" },
+  503: { type: "server_error", code: "service_unavailable" },
+  504: { type: "server_error", code: "gateway_timeout" }
+};
+
+export const DEFAULT_ERROR_MESSAGES = {
+  400: "Bad request",
+  401: "Invalid API key provided",
+  402: "Payment required",
+  403: "You exceeded your current quota",
+  404: "Model not found",
+  406: "Model not supported",
+  429: "Rate limit exceeded",
+  500: "Internal server error",
+  502: "Bad gateway - upstream provider error",
+  503: "Service temporarily unavailable",
+  504: "Gateway timeout"
+};
+
+export const BACKOFF_CONFIG = {
+  base: 2000,
+  max: 5 * 60 * 1000,
+  maxLevel: 15
+};
+
+export const TRANSIENT_COOLDOWN_MS = 30 * 1000;
+
+export const MAX_RATE_LIMIT_COOLDOWN_MS = 30 * 60 * 1000;
+
+const COOLDOWN = {
+  long: 2 * 60 * 1000,
+  short: 5 * 1000,
+};
+
+export const ERROR_TIERS = {
+  T1: "T1",
+  T2: "T2",
+  T3: "T3",
+};
+
+const T1_BACKOFF_BASE = 30 * 1000;
+const T1_BACKOFF_CAP = 5 * 60 * 1000;
+
+const T3_DEPRIORITIZE_MS = 10 * 60 * 1000;
+
+const JITTER_FRACTION = 0.25;
+
+export const ERROR_RULES = [
+
+  { text: "no credentials",           cooldownMs: COOLDOWN.long },
+  { text: "request not allowed",      cooldownMs: COOLDOWN.short },
+  { text: "improperly formed request", cooldownMs: COOLDOWN.long },
+  { text: "rate limit",               backoff: true },
+  { text: "too many requests",        backoff: true },
+  { text: "quota exceeded",           backoff: true },
+  { text: "capacity",                 backoff: true },
+  { text: "overloaded",               backoff: true },
+
+  { status: 401, cooldownMs: COOLDOWN.long },
+  { status: 402, cooldownMs: COOLDOWN.long },
+  { status: 403, cooldownMs: COOLDOWN.long },
+  { status: 404, cooldownMs: COOLDOWN.long },
+  { status: 429, backoff: true },
+];
+
+export const COOLDOWN_MS = {
+  unauthorized: COOLDOWN.long,
+  paymentRequired: COOLDOWN.long,
+  notFound: COOLDOWN.long,
+  transient: TRANSIENT_COOLDOWN_MS,
+  requestNotAllowed: COOLDOWN.short,
+};
+
+export function classifyError(status, errorText, retryCount = 0, opts = {}) {
+  const lowerError = errorText
+    ? (typeof errorText === "string" ? errorText : JSON.stringify(errorText)).toLowerCase()
+    : "";
+  const rng = typeof opts.rng === "function" ? opts.rng : null;
+
+  const t1Texts = ["rate limit", "too many requests", "quota exceeded", "capacity", "overloaded"];
+  if (t1Texts.some((t) => lowerError.includes(t)) || Number(status) === 429) {
+    const exp = T1_BACKOFF_BASE * Math.pow(2, retryCount);
+    const base = Math.min(exp, T1_BACKOFF_CAP);
+    const jitter = rng ? Math.floor(rng() * base * JITTER_FRACTION) : 0;
+    return { tier: ERROR_TIERS.T1, action: "cooldown", cooldownMs: base + jitter };
+  }
+
+  const t3Texts = ["no credentials", "request not allowed", "improperly formed request"];
+  const t3ByText = t3Texts.some((t) => lowerError.includes(t));
+  const t3ByStatus = [401, 402, 403, 404, 406].includes(Number(status));
+  if (t3ByStatus || t3ByText) {
+    const jitter = rng ? Math.floor(rng() * COOLDOWN.long * JITTER_FRACTION) : 0;
+    return {
+      tier: ERROR_TIERS.T3,
+      action: "deprioritize",
+      cooldownMs: COOLDOWN.long + jitter,
+      deprioitizeUntil: Date.now() + COOLDOWN.long + jitter + T3_DEPRIORITIZE_MS,
+    };
+  }
+
+  const jitter = rng ? Math.floor(rng() * COOLDOWN.short * JITTER_FRACTION) : 0;
+  return { tier: ERROR_TIERS.T2, action: "retry-same", cooldownMs: COOLDOWN.short + jitter };
+}
+
+export function isDeprioitized(deprioitizeUntil) {
+  if (!deprioitizeUntil) return false;
+  return deprioitizeUntil > Date.now();
+}

package/src/config/grokCli.js

@@ -0,0 +1,9 @@
+export const GROK_CLI_VERSION = "0.2.99";
+export const GROK_CLI_MODEL = "grok-build";
+export const GROK_CLI_BASE_URL = "https://cli-chat-proxy.grok.com/v1";
+export const GROK_CLI_CLIENT_IDENTIFIER = "grok-shell";
+export const GROK_CLI_USER_AGENT = `grok-shell/${GROK_CLI_VERSION} (linux; x86_64)`;
+
+export function supportsGrokCliReasoningEffort(model) {
+  return /^grok-4(?:\.\d+)?(?:$|-)/.test(String(model || ""));
+}

package/src/config/kiroConstants.js

@@ -0,0 +1,235 @@
+import { extractThinking, parseSuffix } from "../translator/concerns/thinkingUnified.js";
+import { effortToBudget } from "../translator/concerns/thinking.js";
+
+export const KIRO_AGENTIC_SUFFIX = "-agentic";
+export const KIRO_THINKING_SUFFIX = "-thinking";
+export const KIRO_TOOL_NAME_MAX_LENGTH = 64;
+export const KIRO_TOOL_DESCRIPTION_MAX_LENGTH = 10237;
+export const KIRO_TOOL_ID_MAX_LENGTH = 64;
+export const KIRO_CODEWHISPERER_TARGET =
+  "AmazonCodeWhispererStreamingService.GenerateAssistantResponse";
+export const KIRO_ENDPOINT_FALLBACK_STATUSES = new Set([401, 403, 404]);
+
+export const KIRO_DEFAULT_PROFILE_ARNS = {
+  "builder-id": "arn:aws:codewhisperer:us-east-1:638616132270:profile/AAAACCCCXXXX",
+  social: "arn:aws:codewhisperer:us-east-1:699475941385:profile/EHGA3GRVQMUK",
+};
+
+export const KIRO_DEFAULT_PROFILE_ARN = KIRO_DEFAULT_PROFILE_ARNS["builder-id"];
+
+export function resolveDefaultProfileArn(authMethod) {
+  const social = authMethod === "google" || authMethod === "github";
+  return social ? KIRO_DEFAULT_PROFILE_ARNS.social : KIRO_DEFAULT_PROFILE_ARNS["builder-id"];
+}
+
+export const KIRO_THINKING_BUDGET_DEFAULT = 16000;
+
+export function resolveKiroModelIntent(model) {
+  const { cleanModel, override } = parseSuffix(model);
+  return {
+    model: cleanModel,
+    ...resolveKiroModel(cleanModel),
+    thinkingOverride: override,
+  };
+}
+
+export function applyKiroThinkingOverride(body, override) {
+  if (!override) return body;
+
+  const next = { ...body };
+  if (override.mode === "budget") {
+    delete next.output_config;
+    delete next.reasoning_effort;
+    delete next.reasoning;
+    next.thinking = { type: "enabled", budget_tokens: override.budget };
+    return next;
+  }
+
+  next.output_config = {
+    ...(body.output_config || {}),
+    effort: override.mode === "level" ? override.level : override.mode,
+  };
+  return next;
+}
+
+export function resolveKiroThinkingBudget(body, headers, model) {
+  const cfg = extractThinking(body);
+  if (cfg) {
+    if (cfg.mode === "none") return null;
+    if (cfg.mode === "level" && cfg.level === "disabled") return null;
+    if (cfg.mode === "budget") return cfg.budget;
+    if (cfg.mode === "level") return effortToBudget(cfg.level) ?? KIRO_THINKING_BUDGET_DEFAULT;
+    return KIRO_THINKING_BUDGET_DEFAULT;
+  }
+
+  if (headers) {
+    const beta = pickHeader(headers, "anthropic-beta");
+    if (typeof beta === "string" && beta.toLowerCase().includes("interleaved-thinking")) {
+      return KIRO_THINKING_BUDGET_DEFAULT;
+    }
+  }
+
+  if (containsThinkingModeTag(body)) return KIRO_THINKING_BUDGET_DEFAULT;
+
+  if (typeof model === "string" && model) {
+    const m = model.toLowerCase();
+    if (m.includes("thinking") || m.includes("-reason")) return KIRO_THINKING_BUDGET_DEFAULT;
+  }
+
+  return null;
+}
+
+export function extractKiroEffortLevel(body) {
+  const effort =
+    body?.output_config?.effort ??
+    body?.reasoning_effort ??
+    (typeof body?.reasoning === "object" ? body.reasoning?.effort : null);
+  if (typeof effort !== "string") return null;
+  const normalized = effort.toLowerCase();
+  if (normalized === "none" || normalized === "off" || normalized === "disabled") return null;
+  if (normalized === "xhigh" || normalized === "max") return "high";
+  if (["low", "medium", "high"].includes(normalized)) return normalized;
+  return null;
+}
+
+function extractKiroGptEffortLevel(body) {
+  const effort =
+    body?.output_config?.effort ??
+    body?.reasoning_effort ??
+    (typeof body?.reasoning === "object" ? body.reasoning?.effort : null);
+  if (typeof effort !== "string") return null;
+  const normalized = effort.toLowerCase();
+  if (normalized === "max") return "xhigh";
+
+  if (["low", "medium", "high", "xhigh"].includes(normalized)) {
+    return normalized;
+  }
+  return null;
+}
+
+export function buildKiroAdditionalModelRequestFields(body, effortPath = "output_config") {
+  const effort = effortPath === "reasoning"
+    ? extractKiroGptEffortLevel(body)
+    : extractKiroEffortLevel(body);
+  if (!effort) return undefined;
+  if (effortPath === "reasoning") {
+
+    return { reasoning: { effort } };
+  }
+
+  return {
+    thinking: { type: "adaptive", display: "summarized" },
+    output_config: { effort },
+  };
+}
+
+export function resolveKiroEffortPath(model) {
+  if (typeof model !== "string") return null;
+  const normalized = model.toLowerCase().replace(/-/g, ".");
+  if (/(?:^|[/.])gpt[/.]5[/.]6(?:[/.]|$)/.test(normalized)) {
+    return "reasoning";
+  }
+  if (!normalized.includes("claude")) return null;
+  const match = normalized.match(/(?:^|[/.])claude(?:[/.][a-z]+)*[/.](\d+)(?:[/.](\d+))?(?:[/.]|$)/);
+  if (!match) return null;
+  const [, majorText, minorText] = match;
+  const major = Number(majorText);
+  const minor = minorText === undefined ? null : Number(minorText);
+  const dateSuffixMinor = minor !== null && minor >= 1000;
+
+  return major < 4 || (major === 4 && (minor === null || minor <= 5 || dateSuffixMinor))
+    ? null
+    : "output_config";
+}
+
+export function supportsKiroAdditionalModelRequestFields(model) {
+  return resolveKiroEffortPath(model) !== null;
+}
+
+export function usesKiroNativeGptEffort(body, model) {
+  return resolveKiroEffortPath(model) === "reasoning"
+    && extractKiroGptEffortLevel(body) !== null;
+}
+
+export function buildKiroAdditionalModelRequestFieldsForModel(body, model) {
+  const effortPath = resolveKiroEffortPath(model);
+  if (!effortPath) return undefined;
+  return buildKiroAdditionalModelRequestFields(body, effortPath);
+}
+
+export function isThinkingEnabled(body, headers, model) {
+  return resolveKiroThinkingBudget(body, headers, model) !== null;
+}
+
+export function isAgenticModel(model) {
+  return typeof model === "string" && model.endsWith(KIRO_AGENTIC_SUFFIX);
+}
+
+export function stripAgenticSuffix(model) {
+  if (!isAgenticModel(model)) return model;
+  return model.slice(0, -KIRO_AGENTIC_SUFFIX.length);
+}
+
+export function isThinkingModel(model) {
+  return typeof model === "string" && model.endsWith(KIRO_THINKING_SUFFIX);
+}
+
+export function stripThinkingSuffix(model) {
+  if (!isThinkingModel(model)) return model;
+  return model.slice(0, -KIRO_THINKING_SUFFIX.length);
+}
+
+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 };
+}
+
+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>");
+}

package/src/config/mediaConfig.js

@@ -0,0 +1,20 @@
+export const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+export const FETCH_TIMEOUT_MS = 10000;
+
+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" },
+];
+
+export const BLOCKED_HOSTS = new Set([
+  "localhost",
+  "127.0.0.1",
+  "0.0.0.0",
+  "::1",
+  "169.254.169.254",
+  "metadata.google.internal",
+]);

package/src/config/ollamaModels.js

@@ -0,0 +1,18 @@
+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" }
+    }
+  ]
+};

package/src/config/providerModels.js

@@ -0,0 +1,109 @@
+import { PROVIDERS } from "./providers.js";
+import REGISTRY from "../providers/registry/index.js";
+
+import { PROVIDER_MODELS } from "../providers/index.js";
+import { modelQuotaFamily, modelStrip, modelTargetFormat, normalizeModelId } from "../providers/models/schema.js";
+import { CODEX_REVIEW_SUFFIX } from "../providers/models/helpers.js";
+export { PROVIDER_MODELS };
+
+export function getProviderModels(aliasOrId) {
+  return PROVIDER_MODELS[aliasOrId] || [];
+}
+
+export function getDefaultModel(aliasOrId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  return models?.[0]?.id || null;
+}
+
+const DOT_VERSION_PROVIDERS = new Set(["kr", "kiro"]);
+
+function findModel(models, modelId, aliasOrId) {
+  if (!models) return undefined;
+
+  const candidates = typeof modelId === "string"
+    ? [
+        modelId,
+        modelId.replace(/^clinepass\//, "cline-pass/"),
+        modelId.replace(/^cline-pass\//, "clinepass/"),
+        modelId.replace(/^(?:clinepass|cline-pass)\//, ""),
+        ...(aliasOrId === "clinepass" && !/^(?:clinepass|cline-pass)\//.test(modelId)
+          ? [`cline-pass/${modelId}`, `clinepass/${modelId}`]
+          : []),
+      ]
+    : [modelId];
+  const found = models.find((m) => candidates.includes(m.id));
+  if (found) return found;
+
+  if (!DOT_VERSION_PROVIDERS.has(aliasOrId)) return undefined;
+  const normalizedCandidates = candidates.map((candidate) => normalizeModelId(candidate));
+  return models.find((m) => normalizedCandidates.includes(m.id));
+}
+
+export function isValidModel(aliasOrId, modelId, passthroughProviders = new Set()) {
+  if (passthroughProviders.has(aliasOrId)) return true;
+  const models = PROVIDER_MODELS[aliasOrId];
+  if (!models) return false;
+  return !!findModel(models, modelId, aliasOrId);
+}
+
+export function findModelName(aliasOrId, modelId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  if (!models) return modelId;
+  const found = findModel(models, modelId, aliasOrId);
+  return found?.name || modelId;
+}
+
+export function getModelTargetFormat(aliasOrId, modelId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  if (!models) return null;
+  return modelTargetFormat(findModel(models, modelId, aliasOrId));
+}
+
+export function getModelType(aliasOrId, modelId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  if (!models) return null;
+  const found = findModel(models, modelId, aliasOrId);
+  return found?.kind || found?.type || null;
+}
+
+export function getModelUpstreamId(aliasOrId, modelId) {
+
+  const sufMatch = typeof modelId === "string" ? modelId.match(/\([^()]+\)\s*$/) : null;
+  const suffix = sufMatch ? sufMatch[0] : "";
+  const baseId = suffix ? modelId.slice(0, sufMatch.index).trim() : modelId;
+  const models = PROVIDER_MODELS[aliasOrId];
+  const found = findModel(models, baseId, aliasOrId);
+  const resolvedId = found?.upstreamModelId || found?.id;
+  if (resolvedId) {
+    const presetMatch = resolvedId.match(/\([^()]+\)\s*$/);
+    const presetSuffix = presetMatch?.[0] || "";
+    const resolvedBase = presetSuffix ? resolvedId.slice(0, presetMatch.index).trim() : resolvedId;
+    return resolvedBase + (suffix || presetSuffix);
+  }
+  if (aliasOrId === "cx" && typeof baseId === "string" && baseId.endsWith(CODEX_REVIEW_SUFFIX)) {
+    return baseId.slice(0, -CODEX_REVIEW_SUFFIX.length) + suffix;
+  }
+  return baseId + suffix;
+}
+
+export function getModelQuotaFamily(aliasOrId, modelId) {
+  const models = PROVIDER_MODELS[aliasOrId];
+  return modelQuotaFamily(findModel(models, modelId, aliasOrId));
+}
+
+export const OAUTH_ALIASES = Object.fromEntries(
+  REGISTRY.filter(r => r.alias && r.alias !== r.id).map(r => [r.id, r.alias])
+);
+
+export const PROVIDER_ID_TO_ALIAS = Object.fromEntries(
+  Object.keys(PROVIDERS).map(id => [id, OAUTH_ALIASES[id] || id])
+);
+
+export function getModelsByProviderId(providerId) {
+  const alias = PROVIDER_ID_TO_ALIAS[providerId] || providerId;
+  return PROVIDER_MODELS[alias] || [];
+}
+
+export function getModelStrip(alias, modelId) {
+  return modelStrip(findModel(PROVIDER_MODELS[alias], modelId, alias));
+}