@jacobbd/relay-ai 0.7.5 → 0.8.0

package/dist/{chunk-HEMJFOXG.js → chunk-5DDQJSTU.js}

@@ -2,7 +2,7 @@
 import {
   getTemplateById,
   init_provider_templates
-} from "./chunk-HXGZ4CTV.js";
+} from "./chunk-Q2FTCICO.js";
 
 // src/constants.ts
 import { homedir } from "os";
@@ -11,7 +11,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@jacobbd/relay-ai",
-  version: "0.7.5",
+  version: "0.8.0",
   publishConfig: {
     access: "public"
   },
@@ -610,6 +610,44 @@ function injectClaudeIdentity(body, providerData, seed) {
   return { sessionId, userId };
 }
 
+// src/cline-pass.ts
+var CLINE_PASS_HOST = "https://api.cline.bot";
+var CLINE_PASS_SDK_BASE_URL = `${CLINE_PASS_HOST}/api/v1`;
+var CLINE_PASS_CATALOG_URL = `${CLINE_PASS_HOST}/api/v1/ai/cline/recommended-models`;
+var CLINE_PASS_VALIDATION_URL = `${CLINE_PASS_HOST}/api/v1/users/me`;
+var CLINE_PASS_REGISTER_URL = `${CLINE_PASS_HOST}/api/v1/auth/register`;
+var CLINE_PASS_REFRESH_URL = `${CLINE_PASS_HOST}/api/v1/auth/refresh`;
+var CLINE_PASS_LEGACY_DEFAULT_CONTEXT_WINDOW = 131072;
+var CLINE_PASS_WORKOS_PREFIX = "workos:";
+function isClinePassOAuth(providerId, authType) {
+  return providerId === "cline-pass" && authType === "oauth";
+}
+function formatClineRuntimeCredential(providerId, authType, key) {
+  if (!isClinePassOAuth(providerId, authType)) return key;
+  return key.toLowerCase().startsWith(CLINE_PASS_WORKOS_PREFIX) ? key : `${CLINE_PASS_WORKOS_PREFIX}${key}`;
+}
+function createClinePassOAuthFetch(initialRuntimeCredential, refreshToken, onTokenRefreshed, fetchImpl = globalThis.fetch) {
+  let currentRuntimeCredential = initialRuntimeCredential;
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const send = (runtimeCredential) => {
+      const headers = new Headers(request.headers);
+      headers.set("Authorization", `Bearer ${runtimeCredential}`);
+      return fetchImpl(request.clone(), { headers });
+    };
+    const response = await send(currentRuntimeCredential);
+    if (response.status !== 401) return response;
+    const refreshedRawToken = await refreshToken().catch(() => null);
+    const refreshedRuntimeCredential = refreshedRawToken ? formatClineRuntimeCredential("cline-pass", "oauth", refreshedRawToken) : null;
+    if (!refreshedRawToken || !refreshedRuntimeCredential || refreshedRuntimeCredential === currentRuntimeCredential) {
+      return response;
+    }
+    currentRuntimeCredential = refreshedRuntimeCredential;
+    onTokenRefreshed?.(refreshedRawToken);
+    return send(currentRuntimeCredential);
+  };
+}
+
 // src/provider-factory.ts
 var RESPONSES_ONLY_PREFIXES = [
   "gpt-5-codex",
@@ -744,11 +782,19 @@ async function createLanguageModel(spec) {
   let model;
   if (npm === "@ai-sdk/openai-compatible") {
     const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible");
+    const runtimeApiKey = formatClineRuntimeCredential(spec.providerId, spec.authType, apiKey);
     const options = {
       name: spec.providerId ?? "openai-compatible",
       baseURL: baseURL ?? "",
-      ...apiKey.trim() ? { apiKey } : {},
-      ...spec.headers ? { headers: spec.headers } : {}
+      ...runtimeApiKey.trim() ? { apiKey: runtimeApiKey } : {},
+      ...spec.headers ? { headers: spec.headers } : {},
+      ...isClinePassOAuth(spec.providerId, spec.authType) && spec.refreshToken ? {
+        fetch: createClinePassOAuthFetch(
+          runtimeApiKey,
+          spec.refreshToken,
+          spec.onTokenRefreshed
+        )
+      } : {}
     };
     model = createOpenAICompatible({
       ...options
@@ -1502,9 +1548,9 @@ function modelSelectOption(model, hint) {
     hint: defaultHint && ctxSuffix ? `${defaultHint} \xB7 ${ctxSuffix}` : defaultHint || ctxSuffix
   };
 }
-function fmtContextWindow(contextWindow) {
-  if (!contextWindow) return "";
-  const k = contextWindow >= 1e3 ? `${Math.round(contextWindow / 1e3)}k` : String(contextWindow);
+function fmtContextWindow(contextWindow2) {
+  if (!contextWindow2) return "";
+  const k = contextWindow2 >= 1e3 ? `${Math.round(contextWindow2 / 1e3)}k` : String(contextWindow2);
   return pc.dim(`${k} ctx`);
 }
 function navOption(value, label, hint = "") {
@@ -2146,9 +2192,9 @@ var ONE_M_CONTEXT_SUFFIX = "[1m]";
 function stripOneMContextSuffix(modelId) {
   return modelId.replace(/\[1m\]$/i, "");
 }
-function claudeCodeClientModelId(modelId, contextWindow) {
+function claudeCodeClientModelId(modelId, contextWindow2) {
   const bare = stripOneMContextSuffix(modelId);
-  const window = resolveContextWindow(bare, contextWindow);
+  const window = resolveContextWindow(bare, contextWindow2);
   if (window > DEFAULT_CONTEXT_WINDOW) {
     return `${bare}${ONE_M_CONTEXT_SUFFIX}`;
   }
@@ -2509,16 +2555,16 @@ function readOpencodeAuthFile(env = process.env) {
   } catch {
     return { path, entries: {}, permissionWarning: authFilePermissionWarning(path) };
   }
-  const entries = {};
+  const entries2 = {};
   if (parsed && typeof parsed === "object") {
     for (const [providerId, value] of Object.entries(parsed)) {
       const entry = decodeAuthEntry(value);
-      if (entry) entries[providerId] = entry;
+      if (entry) entries2[providerId] = entry;
     }
   }
   return {
     path,
-    entries,
+    entries: entries2,
     permissionWarning: authFilePermissionWarning(path)
   };
 }
@@ -2570,7 +2616,7 @@ function accessTokenIsExpiring(token, skewMs = OAUTH_REFRESH_SKEW_MS) {
     return false;
   }
 }
-var NATIVE_OAUTH_PROVIDER_IDS = ["xai", "xai-oauth", "openai", "openai-oauth", "github-copilot", "claude-code", "antigravity"];
+var NATIVE_OAUTH_PROVIDER_IDS = ["xai", "xai-oauth", "openai", "openai-oauth", "github-copilot", "claude-code", "antigravity", "cline-pass"];
 function supportsNativeOAuth(providerId) {
   return NATIVE_OAUTH_PROVIDER_IDS.includes(providerId);
 }
@@ -2981,21 +3027,165 @@ async function fetchClaudeCodeModels(accessToken) {
     throw new Error(`Claude Code model discovery failed (HTTP ${res.status}): ${await res.text().catch(() => "")}`);
   }
   const body = await res.json();
-  const entries = (body.data ?? []).filter((m) => typeof m.id === "string" && m.id.length > 0).map((m) => ({
+  const entries2 = (body.data ?? []).filter((m) => typeof m.id === "string" && m.id.length > 0).map((m) => ({
     id: m.id,
     displayName: typeof m.display_name === "string" ? m.display_name : m.id,
     maxInputTokens: typeof m.max_input_tokens === "number" ? m.max_input_tokens : void 0,
     maxTokens: typeof m.max_tokens === "number" ? m.max_tokens : void 0
   }));
-  if (entries.length === 0) {
+  if (entries2.length === 0) {
     throw new Error("Claude Code model discovery returned no models");
   }
-  return entries;
+  return entries2;
 }
 function guiCallbackRedirectUri(host) {
   return `http://${host}/oauth/callback`;
 }
 
+// src/oauth/cline-pass.ts
+var WORKOS_CLIENT_ID = "client_01K3A541FN8TA3EPPHTD2325AR";
+var WORKOS_DEVICE_URL = "https://api.workos.com/user_management/authorize/device";
+var WORKOS_TOKEN_URL = "https://api.workos.com/user_management/authenticate";
+var DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+var DEFAULT_INTERVAL_MS = 5e3;
+var SLOW_DOWN_INCREMENT_MS = 1e3;
+var DEFAULT_EXPIRES_MS = 10 * 60 * 1e3;
+function formHeaders() {
+  return {
+    Accept: "application/json",
+    "Content-Type": "application/x-www-form-urlencoded"
+  };
+}
+function jsonHeaders() {
+  return {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+}
+function expiresInFromIso(expiresAt) {
+  if (typeof expiresAt !== "string") throw new Error("ClinePass response is missing a valid expiresAt");
+  const timestamp = Date.parse(expiresAt);
+  if (!Number.isFinite(timestamp)) throw new Error("ClinePass response is missing a valid expiresAt");
+  return Math.max(1, Math.floor((timestamp - Date.now()) / 1e3));
+}
+function toOAuthResult(data) {
+  if (typeof data.accessToken !== "string" || !data.accessToken) {
+    throw new Error("ClinePass response is missing accessToken");
+  }
+  const userInfo = data.userInfo && typeof data.userInfo === "object" && !Array.isArray(data.userInfo) ? data.userInfo : void 0;
+  const accountId = typeof userInfo?.clineUserId === "string" ? userInfo.clineUserId : void 0;
+  return {
+    tokens: {
+      access_token: data.accessToken,
+      ...typeof data.refreshToken === "string" ? { refresh_token: data.refreshToken } : {},
+      expires_in: expiresInFromIso(data.expiresAt),
+      ...userInfo ? { providerData: userInfo } : {}
+    },
+    ...accountId ? { accountId } : {},
+    ...userInfo ? { providerData: userInfo } : {}
+  };
+}
+async function readError(response) {
+  const text4 = await response.text().catch(() => "");
+  if (!text4) return `HTTP ${response.status}`;
+  try {
+    const parsed = JSON.parse(text4);
+    const detail = typeof parsed.error === "string" ? parsed.error : typeof parsed.message === "string" ? parsed.message : "";
+    return detail || `HTTP ${response.status}`;
+  } catch {
+    return text4.slice(0, 120);
+  }
+}
+async function requestClinePassDeviceCode() {
+  const response = await fetch(WORKOS_DEVICE_URL, {
+    method: "POST",
+    headers: formHeaders(),
+    body: new URLSearchParams({ client_id: WORKOS_CLIENT_ID }).toString()
+  });
+  if (!response.ok) throw new Error(`ClinePass device code request failed (${response.status})`);
+  const json = await response.json();
+  if (!json.device_code || !json.user_code || !json.verification_uri) {
+    throw new Error("ClinePass device code response is missing required fields");
+  }
+  return json;
+}
+async function registerClinePassTokens(accessToken, refreshToken) {
+  const response = await fetch(CLINE_PASS_REGISTER_URL, {
+    method: "POST",
+    headers: jsonHeaders(),
+    body: JSON.stringify({ accessToken, refreshToken })
+  });
+  if (!response.ok) throw new Error(`ClinePass registration failed (${response.status})`);
+  const body = await response.json();
+  if (body.success !== true || !body.data) {
+    const detail = typeof body.error === "string" ? body.error : typeof body.message === "string" ? body.message : "unsuccessful response";
+    throw new Error(`ClinePass registration failed: ${detail}`);
+  }
+  return toOAuthResult(body.data);
+}
+async function pollClinePassDeviceCode(device, opts) {
+  const sleep3 = opts?.sleep ?? sleepMs;
+  const now = opts?.now ?? (() => Date.now());
+  const deadline = now() + positiveSecondsToMs(device.expires_in, DEFAULT_EXPIRES_MS);
+  let intervalMs = Math.max(positiveSecondsToMs(device.interval, DEFAULT_INTERVAL_MS), 1e3);
+  while (now() < deadline) {
+    const response = await fetch(WORKOS_TOKEN_URL, {
+      method: "POST",
+      headers: formHeaders(),
+      body: new URLSearchParams({
+        grant_type: DEVICE_GRANT_TYPE,
+        client_id: WORKOS_CLIENT_ID,
+        device_code: device.device_code
+      }).toString()
+    });
+    if (response.ok) {
+      const workos = await response.json();
+      if (!workos.access_token || !workos.refresh_token) {
+        throw new Error("ClinePass WorkOS response is missing required tokens");
+      }
+      return registerClinePassTokens(workos.access_token, workos.refresh_token);
+    }
+    const body = await response.json().catch(() => ({}));
+    const remaining = Math.max(0, deadline - now());
+    if (body.error === "authorization_pending") {
+      await sleep3(Math.min(intervalMs, remaining));
+      continue;
+    }
+    if (body.error === "slow_down") {
+      intervalMs += SLOW_DOWN_INCREMENT_MS;
+      await sleep3(Math.min(intervalMs, remaining));
+      continue;
+    }
+    throw new Error(`ClinePass device authorization failed${body.error ? `: ${body.error}` : ""}`);
+  }
+  throw new Error("ClinePass device authorization timed out");
+}
+async function runClinePassDeviceCodeFlow(onDeviceCode, opts) {
+  const device = await requestClinePassDeviceCode();
+  onDeviceCode({
+    url: device.verification_uri_complete ?? device.verification_uri,
+    userCode: device.user_code
+  });
+  return pollClinePassDeviceCode(device, opts);
+}
+async function refreshClinePassAccessToken(refreshToken) {
+  const response = await fetch(CLINE_PASS_REFRESH_URL, {
+    method: "POST",
+    headers: jsonHeaders(),
+    body: JSON.stringify({ refreshToken, grantType: "refresh_token" })
+  });
+  if (!response.ok) {
+    const detail = await readError(response);
+    throw new Error(`ClinePass token refresh failed (${response.status}): ${detail}`);
+  }
+  const body = await response.json();
+  if (body.success !== true || !body.data) {
+    const detail = typeof body.error === "string" ? body.error : typeof body.message === "string" ? body.message : "unsuccessful response";
+    throw new Error(`ClinePass token refresh failed: ${detail}`);
+  }
+  return toOAuthResult(body.data).tokens;
+}
+
 // src/oauth/refresh.ts
 function oauthCredentialShouldRefresh(cred, providerId) {
   if (oauthCredentialNeedsRefresh(cred)) return true;
@@ -3017,10 +3207,13 @@ async function refreshStoredOAuthCredential(providerId, cred) {
     tokens = await refreshClaudeCodeToken(cred.refresh);
   } else if (providerId === "antigravity") {
     tokens = await refreshAntigravityToken(cred.refresh);
+  } else if (providerId === "cline-pass") {
+    tokens = await refreshClinePassAccessToken(cred.refresh);
   } else {
     throw new Error(`OAuth refresh not implemented for provider "${providerId}"`);
   }
-  return tokensToStoredCredential(tokens, cred.refresh, cred.accountId, cred.providerData);
+  const accountId = providerId === "cline-pass" && typeof tokens.providerData?.clineUserId === "string" ? tokens.providerData.clineUserId : cred.accountId;
+  return tokensToStoredCredential(tokens, cred.refresh, accountId, cred.providerData);
 }
 
 // src/secrets-file.ts
@@ -3102,7 +3295,7 @@ function applyClaudeCodeThirdPartyCompat(env) {
   env["ENABLE_TOOL_SEARCH"] = "true";
   env["CLAUDE_CODE_SIMPLE_SYSTEM_PROMPT"] = "0";
 }
-function buildChildEnv(baseUrl, model, apiKey, proxyPort, contextWindow, enableGatewayDiscovery) {
+function buildChildEnv(baseUrl, model, apiKey, proxyPort, contextWindow2, enableGatewayDiscovery) {
   const env = { ...process.env };
   for (const name of CONFLICTING_ENV_VARS) {
     delete env[name];
@@ -3113,8 +3306,8 @@ function buildChildEnv(baseUrl, model, apiKey, proxyPort, contextWindow, enableG
   env["ANTHROPIC_BASE_URL"] = proxyPort ? `http://127.0.0.1:${proxyPort}` : baseUrl;
   env["ANTHROPIC_API_KEY"] = apiKey;
   const bareModel = stripOneMContextSuffix(model);
-  env["ANTHROPIC_MODEL"] = claudeCodeClientModelId(model, contextWindow);
-  env["CLAUDE_CODE_MAX_CONTEXT_TOKENS"] = String(resolveContextWindow(bareModel, contextWindow));
+  env["ANTHROPIC_MODEL"] = claudeCodeClientModelId(model, contextWindow2);
+  env["CLAUDE_CODE_MAX_CONTEXT_TOKENS"] = String(resolveContextWindow(bareModel, contextWindow2));
   if (enableGatewayDiscovery) {
     env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1";
   }
@@ -3311,6 +3504,18 @@ async function resolveProviderCredential(providerId, authRef, diag) {
   }
   return readProviderSecret(parsed.account, diag);
 }
+async function forceRefreshProviderCredential(providerId, authRef, diag) {
+  const namespaced = readEnvCredential(relayAiKeyEnvVar(providerId));
+  if (namespaced) return namespaced;
+  const parsed = parseAuthRef(authRef);
+  if (!parsed || parsed.kind !== "keyring") {
+    return resolveProviderCredential(providerId, authRef, diag);
+  }
+  const oauthProviderId = oauthProviderIdFromAccount(parsed.account);
+  const raw = await readKeyringAccount(parsed.account, diag);
+  if (!raw || !oauthProviderId) return decodeProviderSecret(raw);
+  return refreshOAuthKeyringAccount(parsed.account, oauthProviderId, raw, diag, true);
+}
 async function resolveProviderOAuthAccountId(authRef, diag) {
   const parsed = parseAuthRef(authRef);
   if (!parsed || parsed.kind !== "keyring" || !oauthProviderIdFromAccount(parsed.account)) return void 0;
@@ -3359,12 +3564,12 @@ function decodeProviderSecret(raw) {
   }
   return trimmed;
 }
-async function refreshOAuthKeyringAccount(account, providerId, raw, diag) {
+async function refreshOAuthKeyringAccount(account, providerId, raw, diag, force = false) {
   const existing = oauthRefreshInflight.get(account);
   if (existing) return existing;
   const work = (async () => {
     const cred = parseStoredOAuthCredential(raw);
-    if (!cred || !oauthCredentialShouldRefresh(cred, providerId)) {
+    if (!cred || !force && !oauthCredentialShouldRefresh(cred, providerId)) {
       return decodeProviderSecret(raw);
     }
     try {
@@ -4180,6 +4385,16 @@ function getAntigravityDebugLogPath(tracePrefix) {
   const surface = tracePrefix === "antigravity" ? "app" : tracePrefix;
   return join8(ensureLogsDir(), `antigravity-${surface}-debug.log`);
 }
+function prepareProviderTraceLog() {
+  const path = getProviderDebugLogPath();
+  resetTraceLog(path);
+  try {
+    writeFileSync5(path, "", { mode: FILE_MODE5 });
+    chmodSync5(path, FILE_MODE5);
+  } catch {
+  }
+  return path;
+}
 function makeTraceLogger(logPath) {
   resetTraceLog(logPath);
   return (message) => writeSecureLogLine(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${message}`);
@@ -4315,11 +4530,245 @@ function maskGatewayModelId(aliasId) {
   return `anthropic-${reverseSegment(providerSlug)}__${reverseSegment(modelSuffix)}`;
 }
 
+// src/subagent-route-registry.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_TTL_MS = 5 * 6e4;
+var DEFAULT_MAX_ENTRIES = 1024;
+var ROUTE_MARKER_PATTERN = /(?:\n\n)?<relay-ai-subagent-route token="([0-9a-f-]{36})"\s*\/>/gi;
+function firstHeader(value) {
+  const first = Array.isArray(value) ? value[0] : value;
+  return typeof first === "string" && first.trim() ? first.trim() : void 0;
+}
+function extractClaudeSessionId(headers, body) {
+  const headerSession = firstHeader(headers["x-claude-code-session-id"]);
+  if (headerSession) return headerSession;
+  const userId = body?.metadata?.user_id;
+  if (typeof userId !== "string") return void 0;
+  try {
+    const parsed = JSON.parse(userId);
+    return typeof parsed.session_id === "string" && parsed.session_id.trim() ? parsed.session_id.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function appendSubagentRouteMarker(prompt, token) {
+  return `${prompt}
+
+<relay-ai-subagent-route token="${token}"/>`;
+}
+function findMarkersInUserMessages(body) {
+  if (!Array.isArray(body.messages)) return void 0;
+  const tokens = [];
+  const messages = [...body.messages];
+  for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+    const message = body.messages[messageIndex];
+    if (!message || message.role !== "user") continue;
+    if (typeof message.content === "string") {
+      const matches = [...message.content.matchAll(ROUTE_MARKER_PATTERN)];
+      if (matches.length === 0) continue;
+      tokens.push(...matches.flatMap((match) => match[1] ? [match[1]] : []));
+      messages[messageIndex] = {
+        ...message,
+        content: message.content.replace(ROUTE_MARKER_PATTERN, "").trimEnd()
+      };
+      continue;
+    }
+    if (!Array.isArray(message.content)) continue;
+    const content = [...message.content];
+    for (let partIndex = 0; partIndex < message.content.length; partIndex++) {
+      const part = message.content[partIndex];
+      if (!part || part.type !== "text" || typeof part.text !== "string") continue;
+      const matches = [...part.text.matchAll(ROUTE_MARKER_PATTERN)];
+      if (matches.length === 0) continue;
+      tokens.push(...matches.flatMap((match) => match[1] ? [match[1]] : []));
+      content[partIndex] = {
+        ...part,
+        text: part.text.replace(ROUTE_MARKER_PATTERN, "").trimEnd()
+      };
+    }
+    messages[messageIndex] = { ...message, content };
+  }
+  return tokens.length > 0 ? { tokens, body: { ...body, messages } } : void 0;
+}
+var SubagentRouteRegistry = class {
+  entries = /* @__PURE__ */ new Map();
+  ttlMs;
+  maxEntries;
+  now;
+  constructor(options = {}) {
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+    this.maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.now = options.now ?? Date.now;
+  }
+  register(sessionId, modelId) {
+    this.cleanup();
+    while (this.entries.size >= this.maxEntries) {
+      const oldest = this.entries.keys().next().value;
+      if (!oldest) break;
+      this.entries.delete(oldest);
+    }
+    const token = randomUUID2();
+    this.entries.set(token, { sessionId, modelId, createdAt: this.now() });
+    return token;
+  }
+  consume(headers, body) {
+    this.cleanup();
+    if (!firstHeader(headers["x-claude-code-agent-id"])) return void 0;
+    const sessionId = extractClaudeSessionId(headers, body);
+    if (!sessionId) return void 0;
+    const marked = findMarkersInUserMessages(body);
+    if (!marked) return void 0;
+    const token = [...marked.tokens].reverse().find((candidate) => this.entries.get(candidate)?.sessionId === sessionId);
+    if (!token) return void 0;
+    const entry = this.entries.get(token);
+    this.entries.delete(token);
+    return { modelId: entry.modelId, body: marked.body };
+  }
+  cleanup() {
+    const cutoff = this.now() - this.ttlMs;
+    for (const [token, entry] of this.entries) {
+      if (entry.createdAt < cutoff) this.entries.delete(token);
+    }
+  }
+};
+
+// src/subagent-model-routing.ts
+var CLAUDE_MODEL_FAMILIES = ["sonnet", "opus", "haiku", "fable"];
+var CLAUDE_MODEL_FAMILY_SET = new Set(CLAUDE_MODEL_FAMILIES);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function claudeModelFamily(modelId) {
+  const normalized = modelId.toLowerCase();
+  if (!normalized.startsWith("claude-")) return void 0;
+  return CLAUDE_MODEL_FAMILIES.find((family) => normalized.includes(family));
+}
+function isClaudeAgentTool(tool4) {
+  if (tool4.name !== "Agent" || !isRecord(tool4.input_schema)) return false;
+  const properties = tool4.input_schema.properties;
+  if (!isRecord(properties)) return false;
+  return ["description", "prompt", "subagent_type"].every((name) => isRecord(properties[name]));
+}
+var UnavailableSubagentModelError = class extends Error {
+  constructor(selector, routing) {
+    const visible = routing.models.slice(0, MAX_MODEL_CATALOG).map((model) => model.id);
+    const omitted = routing.models.length - visible.length;
+    const suffix = omitted > 0 ? `, and ${omitted} more` : "";
+    super(
+      `Subagent model "${selector}" is unavailable in this Relay AI session. Available model ids: ${visible.join(", ")}${suffix}.`
+    );
+    this.selector = selector;
+    this.name = "UnavailableSubagentModelError";
+  }
+  selector;
+  statusCode = 400;
+};
+function normalizeClaudeAgentInput(input, routing) {
+  const source = isRecord(input) ? input : {};
+  const normalized = { ...source };
+  if (source.subagent_type === "fork") {
+    return { input: normalized, decision: { kind: "fork" } };
+  }
+  const rawModel = source.model;
+  if (rawModel == null) {
+    normalized.model = routing.parentModelId;
+    return {
+      input: normalized,
+      decision: { kind: "inherit", resolvedModelId: routing.parentModelId }
+    };
+  }
+  if (typeof rawModel !== "string") {
+    throw new UnavailableSubagentModelError(String(rawModel), routing);
+  }
+  const selector = rawModel.trim();
+  if (selector === "" || selector === "inherit") {
+    normalized.model = routing.parentModelId;
+    return {
+      input: normalized,
+      decision: { kind: "inherit", resolvedModelId: routing.parentModelId }
+    };
+  }
+  const exposed = routing.models.find((model) => model.id === selector);
+  if (exposed) {
+    normalized.model = exposed.id;
+    return {
+      input: normalized,
+      decision: { kind: "explicit", resolvedModelId: exposed.id }
+    };
+  }
+  const compatible = routing.models.find((model) => model.compatibilityIds.includes(selector));
+  if (compatible) {
+    normalized.model = compatible.id;
+    return {
+      input: normalized,
+      decision: {
+        kind: "compatibility",
+        requestedModelId: selector,
+        resolvedModelId: compatible.id
+      }
+    };
+  }
+  if (CLAUDE_MODEL_FAMILY_SET.has(selector)) {
+    const family = selector;
+    const nativeModel = routing.models.find((model) => model.family === family);
+    const resolvedModelId = nativeModel?.id ?? routing.parentModelId;
+    normalized.model = resolvedModelId;
+    return {
+      input: normalized,
+      decision: nativeModel ? { kind: "family", requestedModelId: family, resolvedModelId } : { kind: "family-fallback", requestedModelId: family, resolvedModelId }
+    };
+  }
+  throw new UnavailableSubagentModelError(selector, routing);
+}
+function prepareClaudeAgentInput(input, routing) {
+  const normalized = normalizeClaudeAgentInput(input, routing);
+  const decision = normalized.decision;
+  if (decision.kind === "fork") return normalized;
+  if (!routing.registerSubagentRoute) return normalized;
+  const prompt = normalized.input.prompt;
+  if (typeof prompt !== "string") return normalized;
+  const token = routing.registerSubagentRoute(decision.resolvedModelId);
+  const clientInput = { ...normalized.input };
+  const target = routing.models.find((model) => model.id === decision.resolvedModelId);
+  if (target?.family) clientInput.model = target.family;
+  else delete clientInput.model;
+  clientInput.prompt = appendSubagentRouteMarker(prompt, token);
+  return { input: clientInput, decision };
+}
+function augmentClaudeAgentTool(tool4, routing) {
+  const inputSchema = isRecord(tool4.input_schema) ? tool4.input_schema : {};
+  const properties = isRecord(inputSchema.properties) ? inputSchema.properties : {};
+  const originalModel = isRecord(properties.model) ? properties.model : {};
+  const smallCatalog = routing.models.length <= MAX_MODEL_CATALOG;
+  const modelProperty = {
+    ...originalModel,
+    type: "string"
+  };
+  if (smallCatalog) {
+    const originalEnum = Array.isArray(originalModel.enum) ? originalModel.enum.filter((value) => typeof value === "string") : CLAUDE_MODEL_FAMILIES;
+    modelProperty.enum = [.../* @__PURE__ */ new Set([...originalEnum, ...routing.models.map((model) => model.id)])];
+  } else {
+    delete modelProperty.enum;
+  }
+  const guidance = smallCatalog ? `Relay AI subagent model routing (default: ${routing.parentModelId}). ` + routing.models.map((model) => `${model.displayName}: ${model.id}`).join("; ") : `Relay AI subagent model routing (default: ${routing.parentModelId}). Other explicit model values must be exact ids from the current session catalog.`;
+  return {
+    ...tool4,
+    description: [tool4.description?.trim(), guidance].filter(Boolean).join("\n\n"),
+    input_schema: {
+      ...inputSchema,
+      properties: {
+        ...properties,
+        model: modelProperty
+      }
+    }
+  };
+}
+
 // src/server/models.ts
 var CREATED_AT_ISO = "2025-01-01T00:00:00Z";
 var CREATED_AT_UNIX = 1735689600;
-function formatAnthropicModelEntry(id, displayName, contextWindow, options) {
-  const maxInput = resolveContextWindow(id, contextWindow);
+function formatAnthropicModelEntry(id, displayName, contextWindow2, options) {
+  const maxInput = resolveContextWindow(id, contextWindow2);
   return {
     id,
     type: "model",
@@ -4330,17 +4779,17 @@ function formatAnthropicModelEntry(id, displayName, contextWindow, options) {
     ...options?.supportsOneM !== void 0 ? { supports_1m: options.supportsOneM } : {}
   };
 }
-function formatAnthropicModelList(entries) {
+function formatAnthropicModelList(entries2) {
   return {
-    data: entries.map((entry) => formatAnthropicModelEntry(
+    data: entries2.map((entry) => formatAnthropicModelEntry(
       entry.id,
       entry.name,
       entry.contextWindow,
       { supportsOneM: entry.supportsOneM }
     )),
     has_more: false,
-    first_id: entries[0]?.id ?? null,
-    last_id: entries.at(-1)?.id ?? null
+    first_id: entries2[0]?.id ?? null,
+    last_id: entries2.at(-1)?.id ?? null
   };
 }
 function gatewayProviderLabel(model) {
@@ -4368,6 +4817,52 @@ function exposedGatewayAliasId(model, opts) {
   const exposed = opts?.maskGatewayIds ? maskGatewayModelId(alias) : alias;
   return singleOneM ? `${stripOneMContextSuffix(exposed)}[1m]` : exposed;
 }
+function gatewayModelIdentity(model, models, opts) {
+  const collisions = openAiIdCollisions(models);
+  const ids = [];
+  const modelIndex = models.indexOf(model);
+  const firstBareIndex = models.findIndex((candidate) => candidate.id === model.id);
+  if (modelIndex === firstBareIndex || modelIndex < 0) ids.push(model.id);
+  const scopedId = openAiExposedId(model, collisions);
+  if (scopedId !== model.id) ids.push(scopedId);
+  const publicId = exposedGatewayAliasId(model, opts);
+  if (publicId !== model.id) ids.push(publicId);
+  const singleOneM = usesSingleOneMEntry(model, opts);
+  if (singleOneM) {
+    const bareModel = { ...model, id: stripOneMContextSuffix(model.id) };
+    const rawBareAlias = gatewayAliasId(bareModel);
+    const exposedBareAlias = opts?.maskGatewayIds ? maskGatewayModelId(rawBareAlias) : rawBareAlias;
+    ids.push(
+      stripOneMContextSuffix(model.id),
+      rawBareAlias,
+      `${rawBareAlias}[1m]`,
+      exposedBareAlias,
+      `${exposedBareAlias}[1m]`
+    );
+  }
+  if (opts?.maskGatewayIds) {
+    const rawAlias = gatewayAliasId(singleOneM ? { ...model, id: stripOneMContextSuffix(model.id) } : model);
+    if (rawAlias !== publicId) ids.push(rawAlias);
+  }
+  return {
+    publicId,
+    compatibilityIds: [...new Set(ids)]
+  };
+}
+function buildServerSubagentModelRouting(models, parentModel, opts) {
+  const identities = models.map((model) => gatewayModelIdentity(model, models, opts));
+  const parentIndex = models.indexOf(parentModel);
+  const parentModelId = parentIndex >= 0 ? identities[parentIndex].publicId : exposedGatewayAliasId(parentModel, opts);
+  return {
+    parentModelId,
+    models: models.map((model, index) => ({
+      id: identities[index].publicId,
+      compatibilityIds: identities[index].compatibilityIds,
+      displayName: gatewayDisplayName(model, opts),
+      family: model.modelFormat === "anthropic" ? claudeModelFamily(model.upstreamModelId ?? model.id) : void 0
+    }))
+  };
+}
 function gatewayDisplayName(model, opts) {
   const name = opts?.maskGatewayIds ? `${model.name} (${gatewayProviderLabel(model)})` : model.name;
   return usesSingleOneMEntry(model, opts) && !/\b1m$/i.test(name) ? `${name} 1M` : name;
@@ -4387,31 +4882,10 @@ function usesSingleOneMEntry(model, opts) {
 }
 function createGatewayModelCatalog(models, opts) {
   const byId = /* @__PURE__ */ new Map();
-  const collisions = openAiIdCollisions(models);
   for (const model of models) {
-    if (!byId.has(model.id)) byId.set(model.id, model);
-    const scopedId = openAiExposedId(model, collisions);
-    if (scopedId !== model.id) byId.set(scopedId, model);
-    const alias = exposedGatewayAliasId(model, opts);
-    if (alias !== model.id) byId.set(alias, model);
-    const singleOneM = usesSingleOneMEntry(model, opts);
-    if (singleOneM) {
-      const bareModel = { ...model, id: stripOneMContextSuffix(model.id) };
-      const rawBareAlias = gatewayAliasId(bareModel);
-      const exposedBareAlias = opts?.maskGatewayIds ? maskGatewayModelId(rawBareAlias) : rawBareAlias;
-      for (const compatibleId of [
-        stripOneMContextSuffix(model.id),
-        rawBareAlias,
-        `${rawBareAlias}[1m]`,
-        exposedBareAlias,
-        `${exposedBareAlias}[1m]`
-      ]) {
-        byId.set(compatibleId, model);
-      }
-    }
-    if (opts?.maskGatewayIds) {
-      const rawAlias = gatewayAliasId(singleOneM ? { ...model, id: stripOneMContextSuffix(model.id) } : model);
-      if (rawAlias !== alias) byId.set(rawAlias, model);
+    const identity = gatewayModelIdentity(model, models, opts);
+    for (const compatibleId of identity.compatibilityIds) {
+      byId.set(compatibleId, model);
     }
   }
   return {
@@ -4611,10 +5085,10 @@ async function relayAnthropicMessages(res, messagesUrl, body, apiKey, clientWant
 }
 
 // src/antigravity/anthropic-to-cloudcode.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/antigravity/request-adapter.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import { tool, jsonSchema } from "ai";
 
 // src/proxy-shared.ts
@@ -4724,6 +5198,43 @@ function serializeToolResultContent(content) {
 }
 
 // src/antigravity/request-adapter.ts
+var UNSUPPORTED_VOICE_MESSAGE = "Voice transcription isn\u2019t supported by Relay AI yet. Please type your message. Your coding session remains active.";
+var OMITTED_VOICE_TEXT = "[Voice recording omitted because transcription is not supported by Relay AI.]";
+function isSupportedImage(part) {
+  return part.inlineData?.mimeType.toLowerCase().startsWith("image/") ?? false;
+}
+function isUnsupportedInlineData(part) {
+  return !!part.inlineData && !isSupportedImage(part);
+}
+function sanitizeUnsupportedInlineData(ccReq) {
+  const contents = ccReq.request?.contents ?? [];
+  let latestUserIndex = -1;
+  for (let i = contents.length - 1; i >= 0; i--) {
+    if (contents[i].role === "user") {
+      latestUserIndex = i;
+      break;
+    }
+  }
+  let latestUserTurnHasUnsupportedMedia = false;
+  const sanitizedContents = contents.map((message, index) => ({
+    ...message,
+    parts: message.parts.map((part) => {
+      if (!isUnsupportedInlineData(part)) return part;
+      if (index === latestUserIndex) latestUserTurnHasUnsupportedMedia = true;
+      return { text: OMITTED_VOICE_TEXT };
+    })
+  }));
+  return {
+    request: {
+      ...ccReq,
+      request: {
+        ...ccReq.request,
+        contents: sanitizedContents
+      }
+    },
+    latestUserTurnHasUnsupportedMedia
+  };
+}
 function tracePartChars(part) {
   if (typeof part.text === "string") return part.text.length;
   if (part.type !== "tool-result") return void 0;
@@ -4883,13 +5394,17 @@ function translateRequest(ccReq, options = {}) {
           }
         }
       } else if (part.inlineData) {
-        contentParts.push({
-          type: "image",
-          image: part.inlineData.data,
-          mimeType: part.inlineData.mimeType
-        });
+        if (isSupportedImage(part)) {
+          contentParts.push({
+            type: "image",
+            image: part.inlineData.data,
+            mimeType: part.inlineData.mimeType
+          });
+        } else {
+          contentParts.push({ type: "text", text: OMITTED_VOICE_TEXT });
+        }
       } else if (part.functionCall) {
-        const id = "call_" + randomUUID2().replace(/-/g, "");
+        const id = "call_" + randomUUID3().replace(/-/g, "");
         const name = part.functionCall.name;
         if (!nameToIdList.has(name)) nameToIdList.set(name, []);
         nameToIdList.get(name).push(id);
@@ -4902,7 +5417,7 @@ function translateRequest(ccReq, options = {}) {
       } else if (part.functionResponse) {
         const name = part.functionResponse.name;
         const idList = nameToIdList.get(name) || [];
-        const id = idList.shift() || "call_" + randomUUID2().replace(/-/g, "");
+        const id = idList.shift() || "call_" + randomUUID3().replace(/-/g, "");
         toolResults.push({
           type: "tool-result",
           toolCallId: id,
@@ -5111,7 +5626,7 @@ function anthropicToCloudCode(body, realModelId, projectId) {
   }
   return {
     project: projectId,
-    requestId: randomUUID3(),
+    requestId: randomUUID4(),
     model: realModelId,
     userAgent: ANTIGRAVITY_USER_AGENT2,
     requestType: "agent",
@@ -5121,7 +5636,7 @@ function anthropicToCloudCode(body, realModelId, projectId) {
 }
 
 // src/antigravity/cloudcode-to-anthropic.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function writeEvent(res, event, data) {
   res.write(`event: ${event}
 data: ${JSON.stringify(data)}
@@ -5211,7 +5726,7 @@ function closeBlock(res, state) {
 }
 async function streamCloudCodeToAnthropic(res, upstreamRes, model, log7) {
   const state = {
-    messageId: `msg_${randomUUID4().replace(/-/g, "").slice(0, 24)}`,
+    messageId: `msg_${randomUUID5().replace(/-/g, "").slice(0, 24)}`,
     model,
     blockIdx: 0,
     textBlockOpen: false,
@@ -5300,7 +5815,7 @@ async function streamCloudCodeToAnthropic(res, upstreamRes, model, log7) {
             closeBlock(res, state);
           }
           for (const tc of state.toolCalls) {
-            const rawToolId = `toolu_${randomUUID4().replace(/-/g, "").slice(0, 16)}`;
+            const rawToolId = `toolu_${randomUUID5().replace(/-/g, "").slice(0, 16)}`;
             const toolId = encodeToolUseId(rawToolId, tc.signature);
             writeEvent(res, "content_block_start", {
               type: "content_block_start",
@@ -5351,7 +5866,7 @@ async function streamCloudCodeToAnthropic(res, upstreamRes, model, log7) {
 }
 async function collectCloudCodeToAnthropic(upstreamRes, model, log7) {
   const text4 = await upstreamRes.text();
-  const messageId = `msg_${randomUUID4().replace(/-/g, "").slice(0, 24)}`;
+  const messageId = `msg_${randomUUID5().replace(/-/g, "").slice(0, 24)}`;
   const content = [];
   let stopReason = "end_turn";
   let inputTokens = 0;
@@ -5380,7 +5895,7 @@ async function collectCloudCodeToAnthropic(upstreamRes, model, log7) {
         else content.push({ type: "text", text: part.text });
       } else if (part.functionCall && typeof part.functionCall === "object") {
         const fc = part.functionCall;
-        const rawToolId = `toolu_${randomUUID4().replace(/-/g, "").slice(0, 16)}`;
+        const rawToolId = `toolu_${randomUUID5().replace(/-/g, "").slice(0, 16)}`;
         content.push({
           type: "tool_use",
           id: encodeToolUseId(rawToolId, signature ?? pendingThoughtSignature),
@@ -5413,7 +5928,7 @@ async function collectCloudCodeToAnthropic(upstreamRes, model, log7) {
 }
 
 // src/proxy.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // src/sdk-adapter.ts
 import { streamText, generateText, tool as tool2, jsonSchema as jsonSchema2 } from "ai";
@@ -5746,6 +6261,17 @@ function translateRequest2(body, npm, options) {
   if (options?.maxTools !== void 0 && upstreamTools.length > options.maxTools) {
     upstreamTools = upstreamTools.slice(0, options.maxTools);
   }
+  let responseSubagentRouting;
+  if (options?.subagentRouting) {
+    const agentIndex = upstreamTools.findIndex((toolDefinition) => isClaudeAgentTool(toolDefinition));
+    if (agentIndex >= 0) {
+      upstreamTools = upstreamTools.map((toolDefinition, index) => index === agentIndex ? augmentClaudeAgentTool(
+        toolDefinition,
+        options.subagentRouting
+      ) : toolDefinition);
+      responseSubagentRouting = options.subagentRouting;
+    }
+  }
   const effort = anthropicEffortFromRequest(body) ?? options?.defaultEffort;
   let providerOptions = deepMergeProviderOptions(
     thinkingProviderOptions(npm),
@@ -5763,16 +6289,22 @@ function translateRequest2(body, npm, options) {
     toolChoice: translateToolChoice(body.tool_choice),
     maxOutputTokens: options?.openAiOAuth ? void 0 : body.max_tokens,
     temperature: body.temperature,
-    providerOptions
+    providerOptions,
+    subagentRouting: responseSubagentRouting
   };
 }
-async function writeAnthropicStream(fullStream, modelId, write, log7, estimatedInputTokens = 0) {
+function logSubagentDecision(log7, decision) {
+  if (!log7 || decision.kind === "fork" || decision.kind === "explicit") return;
+  log7(() => decision.kind === "family-fallback" ? `sdk Agent model "${decision.requestedModelId}" unavailable; using parent ${decision.resolvedModelId}` : `sdk Agent model ${decision.kind}: ${"requestedModelId" in decision ? `${decision.requestedModelId} -> ` : ""}${decision.resolvedModelId}`);
+}
+async function writeAnthropicStream(fullStream, modelId, write, log7, estimatedInputTokens = 0, subagentRouting) {
   const messageId = "msg_" + Date.now();
   let blockIndex = -1;
   let started = false;
   let openType = null;
   let pendingThinkingSig;
   const idToBlock = /* @__PURE__ */ new Map();
+  const bufferedAgentCalls = /* @__PURE__ */ new Map();
   let finishReason = "end_turn";
   let usage = { input_tokens: estimatedInputTokens, output_tokens: 0 };
   const emit = (event, data) => write(sseChunk(event, data));
@@ -5855,9 +6387,13 @@ async function writeAnthropicStream(fullStream, modelId, write, log7, estimatedI
           input: {}
         });
         idToBlock.set(part.id ?? "", blockIndex);
+        if (subagentRouting && part.toolName === "Agent") {
+          bufferedAgentCalls.set(part.id ?? "", { blockIndex });
+        }
         break;
       }
       case "tool-input-delta":
+        if (bufferedAgentCalls.has(part.id ?? "")) break;
         emit("content_block_delta", {
           type: "content_block_delta",
           index: idToBlock.get(part.id ?? "") ?? blockIndex,
@@ -5868,11 +6404,53 @@ async function writeAnthropicStream(fullStream, modelId, write, log7, estimatedI
         break;
       case "tool-call": {
         finishReason = "tool_use";
-        if (!idToBlock.has(part.toolCallId ?? "") && openType !== "tool") {
+        const toolCallId = part.toolCallId ?? "";
+        if (subagentRouting && part.toolName === "Agent") {
+          try {
+            const normalized = prepareClaudeAgentInput(part.input, subagentRouting);
+            logSubagentDecision(log7, normalized.decision);
+            const buffered = bufferedAgentCalls.get(toolCallId);
+            if (!buffered && !idToBlock.has(toolCallId)) {
+              const sig = grabRoundTripSignature(part);
+              openBlock("tool", {
+                type: "tool_use",
+                id: encodeToolUseId(toolCallId, sig),
+                name: part.toolName,
+                input: {}
+              });
+              idToBlock.set(toolCallId, blockIndex);
+            }
+            emit("content_block_delta", {
+              type: "content_block_delta",
+              index: buffered?.blockIndex ?? idToBlock.get(toolCallId) ?? blockIndex,
+              delta: {
+                type: "input_json_delta",
+                partial_json: JSON.stringify(stripNullInputs(normalized.input))
+              }
+            });
+            bufferedAgentCalls.delete(toolCallId);
+          } catch (error) {
+            if (error instanceof UnavailableSubagentModelError) {
+              bufferedAgentCalls.delete(toolCallId);
+              closeOpen();
+              emit("error", {
+                type: "error",
+                error: {
+                  type: anthropicErrorType(error.statusCode),
+                  message: error.message
+                }
+              });
+              return;
+            }
+            throw error;
+          }
+          break;
+        }
+        if (!idToBlock.has(toolCallId) && openType !== "tool") {
           const sig = grabRoundTripSignature(part);
           openBlock("tool", {
             type: "tool_use",
-            id: encodeToolUseId(part.toolCallId ?? "", sig),
+            id: encodeToolUseId(toolCallId, sig),
             name: part.toolName,
             input: {}
           });
@@ -5900,6 +6478,7 @@ async function writeAnthropicStream(fullStream, modelId, write, log7, estimatedI
         const errMsg = e?.message || (typeof part.error === "string" ? part.error : JSON.stringify(e?.data ?? part.error));
         const errorType = anthropicErrorType(upstreamHttpStatus(part.error, errMsg));
         log7?.(() => `sdk stream error (${errorType}): ${errMsg}`);
+        bufferedAgentCalls.clear();
         closeOpen();
         emit("error", { type: "error", error: { type: errorType, message: errMsg } });
         return;
@@ -5914,7 +6493,8 @@ async function writeAnthropicStream(fullStream, modelId, write, log7, estimatedI
   emit("message_stop", { type: "message_stop" });
 }
 async function streamAnthropicResponse(model, params, modelId, write, log7, estimatedInputTokens = 0) {
-  const result = streamText({ model, ...params, onError: () => {
+  const { subagentRouting, ...providerParams } = params;
+  const result = streamText({ model, ...providerParams, onError: () => {
   } });
   Promise.resolve(result.text).catch(() => {
   });
@@ -5931,22 +6511,24 @@ async function streamAnthropicResponse(model, params, modelId, write, log7, esti
     modelId,
     write,
     log7,
-    estimatedInputTokens
+    estimatedInputTokens,
+    subagentRouting
   );
 }
 async function generateAnthropicResponse(model, params, modelId, options) {
+  const { subagentRouting, ...providerParams } = params;
   let text4;
   let toolCalls;
   let finishReason;
   let usage;
   if (options?.forceStream) {
-    const r = streamText({ model, ...params, onError: () => {
+    const r = streamText({ model, ...providerParams, onError: () => {
     } });
     Promise.resolve(r.toolResults).catch(() => {
     });
     [text4, toolCalls, finishReason, usage] = await Promise.all([r.text, r.toolCalls, r.finishReason, r.usage]);
   } else {
-    const r = await generateText({ model, ...params });
+    const r = await generateText({ model, ...providerParams });
     ({ text: text4, toolCalls, finishReason, usage } = r);
   }
   return {
@@ -5956,12 +6538,20 @@ async function generateAnthropicResponse(model, params, modelId, options) {
     model: modelId,
     content: [
       ...text4 ? [{ type: "text", text: text4 }] : [],
-      ...toolCalls.map((tc) => ({
-        type: "tool_use",
-        id: encodeToolUseId(tc.toolCallId, grabRoundTripSignature(tc)),
-        name: tc.toolName,
-        input: stripNullInputs(tc.input)
-      }))
+      ...toolCalls.map((tc) => {
+        let input = tc.input;
+        if (subagentRouting && tc.toolName === "Agent") {
+          const normalized = prepareClaudeAgentInput(tc.input, subagentRouting);
+          logSubagentDecision(options?.log, normalized.decision);
+          input = normalized.input;
+        }
+        return {
+          type: "tool_use",
+          id: encodeToolUseId(tc.toolCallId, grabRoundTripSignature(tc)),
+          name: tc.toolName,
+          input: stripNullInputs(input)
+        };
+      })
     ],
     stop_reason: finishReason === "tool-calls" ? "tool_use" : "end_turn",
     usage: { input_tokens: usage?.inputTokens ?? 0, output_tokens: usage?.outputTokens ?? 0 }
@@ -6008,6 +6598,21 @@ function aliasModelId(realId, providerId) {
   const sanitized = providerId.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return `anthropic-${sanitized}__${realId}`;
 }
+function buildProxySubagentModelRouting(routes, parentRoute) {
+  const publicId = (route) => route.gatewayAliasId ?? route.aliasId;
+  return {
+    parentModelId: publicId(parentRoute),
+    models: routes.map((route) => ({
+      id: publicId(route),
+      compatibilityIds: [.../* @__PURE__ */ new Set([
+        ...routeLookupIds(route.aliasId),
+        ...route.gatewayAliasId ? routeLookupIds(route.gatewayAliasId) : []
+      ])],
+      displayName: route.displayName,
+      family: route.modelFormat === "anthropic" ? claudeModelFamily(route.realModelId) : void 0
+    }))
+  };
+}
 function lookupRoute(byAlias, id) {
   for (const key of routeLookupIds(id)) {
     const route = byAlias.get(key);
@@ -6016,13 +6621,14 @@ function lookupRoute(byAlias, id) {
   return void 0;
 }
 function startProxyCatalog(routes, defaultAliasId, debug = false) {
-  const proxyToken = randomUUID5();
+  const proxyToken = randomUUID6();
   silenceSdkWarnings();
   if (routes.length === 0) {
     return Promise.reject(new Error("Proxy catalog requires at least one route"));
   }
   const byAlias = new Map(routes.map((r) => [r.aliasId, r]));
   const defaultRoute = byAlias.get(defaultAliasId) ?? routes[0];
+  const subagentRouteRegistry = new SubagentRouteRegistry();
   const plog = makeProxyLog(debug);
   const onRejection = (reason) => {
     plog(() => `Unhandled Rejection: ${reason instanceof Error ? reason.stack || reason.message : String(reason)}`);
@@ -6076,9 +6682,12 @@ function startProxyCatalog(routes, defaultAliasId, debug = false) {
         anthropicError(res, 400, "Invalid JSON body");
         return;
       }
+      const correlatedSubagent = subagentRouteRegistry.consume(req.headers, anthropicBody);
+      if (correlatedSubagent) anthropicBody = correlatedSubagent.body;
       const originalModel = anthropicBody.model;
       const clientWantsStream = Boolean(anthropicBody.stream);
-      const route = lookupRoute(byAlias, originalModel) ?? defaultRoute;
+      const correlatedRoute = correlatedSubagent ? routes.find((candidate) => (candidate.gatewayAliasId ?? candidate.aliasId) === correlatedSubagent.modelId) : void 0;
+      const route = correlatedRoute ?? lookupRoute(byAlias, originalModel) ?? defaultRoute;
       const apiKey = route.apiKey;
       const upstreamUrl = route.upstreamUrl;
       plog(
@@ -6134,10 +6743,16 @@ function startProxyCatalog(routes, defaultAliasId, debug = false) {
       }
       if (usesSdkAdapter) {
         const openAiOAuth = route.npm === "@ai-sdk/openai" && route.authType === "oauth";
+        const subagentRouting = buildProxySubagentModelRouting(routes, route);
+        const sessionId = extractClaudeSessionId(req.headers, anthropicBody);
+        if (sessionId) {
+          subagentRouting.registerSubagentRoute = (modelId) => subagentRouteRegistry.register(sessionId, modelId);
+        }
         const params = translateRequest2(anthropicBody, route.npm, {
           openAiOAuth,
           maxTools: maxToolsForNpm(route.npm),
           onDebug: (msg) => plog(() => msg),
+          subagentRouting,
           reasoningMetadata: {
             providerId: route.providerId,
             apiBaseUrl: route.baseURL,
@@ -6161,6 +6776,10 @@ function startProxyCatalog(routes, defaultAliasId, debug = false) {
             oauthAccountId: route.oauthAccountId,
             providerData: route.providerData,
             headers: route.headers,
+            refreshToken: route.refreshToken,
+            onTokenRefreshed: (refreshed) => {
+              route.apiKey = refreshed;
+            },
             useResponsesLite: route.useResponsesLite,
             preferWebSockets: route.preferWebSockets,
             onDebug: (msg) => plog(() => msg)
@@ -6185,7 +6804,7 @@ function startProxyCatalog(routes, defaultAliasId, debug = false) {
               model,
               params,
               originalModel,
-              { forceStream: openAiOAuth }
+              { forceStream: openAiOAuth, log: plog }
             );
             sendJson(res, 200, anthropicResponse);
           }
@@ -6281,9 +6900,9 @@ data: ${JSON.stringify({ type: "error", error: { type: errorType, message } })}
     });
   });
 }
-function startProxy(completionsUrl, modelId, debug = false, contextWindow, sdk, apiKey) {
+function startProxy(completionsUrl, modelId, debug = false, contextWindow2, sdk, apiKey) {
   const bareModelId = stripOneMContextSuffix(modelId);
-  const clientModelId = claudeCodeClientModelId(modelId, contextWindow);
+  const clientModelId = claudeCodeClientModelId(modelId, contextWindow2);
   return startProxyCatalog([{
     aliasId: clientModelId,
     realModelId: sdk?.upstreamModelId ?? bareModelId,
@@ -6291,13 +6910,15 @@ function startProxy(completionsUrl, modelId, debug = false, contextWindow, sdk,
     upstreamUrl: completionsUrl,
     apiKey: apiKey ?? "",
     modelFormat: sdk?.modelFormat ?? "openai",
-    contextWindow,
+    contextWindow: contextWindow2,
     npm: sdk?.npm,
     baseURL: sdk?.baseURL,
     providerId: sdk?.providerId,
     authType: sdk?.authType,
     oauthAccountId: sdk?.oauthAccountId,
     providerData: sdk?.providerData,
+    refreshToken: sdk?.refreshToken,
+    headers: sdk?.headers,
     supportedParameters: sdk?.supportedParameters,
     reasoning: sdk?.reasoning,
     interleavedReasoningField: sdk?.interleavedReasoningField,
@@ -6306,54 +6927,6 @@ function startProxy(completionsUrl, modelId, debug = false, contextWindow, sdk,
   }], clientModelId, debug);
 }
 
-// src/catalog.ts
-function localModelToRoute(lp, model) {
-  if (model.modelFormat === "anthropic" && !model.baseUrl) return null;
-  if (model.modelFormat === "openai" && !isSdkMigratedNpm(model.npm) && !model.completionsUrl) return null;
-  const upstreamUrl = model.modelFormat === "cloud-code" ? model.baseUrl ?? ANTIGRAVITY_BASE_URLS[0] : model.modelFormat === "anthropic" ? model.baseUrl : model.completionsUrl;
-  return {
-    aliasId: claudeCodeClientModelId(aliasModelId(model.id, lp.id), model.contextWindow),
-    realModelId: model.upstreamModelId,
-    displayName: `${model.name || model.id} (${lp.name})`,
-    upstreamUrl: upstreamUrl ?? "",
-    apiKey: lp.apiKey,
-    modelFormat: model.modelFormat,
-    contextWindow: model.contextWindow,
-    npm: model.npm,
-    baseURL: model.apiBaseUrl,
-    providerId: lp.id,
-    authType: lp.authType,
-    oauthAccountId: lp.oauthAccountId,
-    providerData: lp.providerData,
-    headers: lp.headers,
-    supportedParameters: model.supportedParameters,
-    reasoning: model.reasoning,
-    interleavedReasoningField: model.interleavedReasoningField,
-    useResponsesLite: model.useResponsesLite,
-    preferWebSockets: model.preferWebSockets
-  };
-}
-function makeRouteResolver(localProviders) {
-  return (providerId, modelId) => {
-    const provider = localProviders?.find((lp) => lp.id === providerId);
-    const model = provider?.models.find((m) => m.id === modelId);
-    return provider && model ? localModelToRoute(provider, model) ?? void 0 : void 0;
-  };
-}
-function buildCatalogRoutes(startingRoute, favorites, resolveRoute, max = MAX_MODEL_CATALOG) {
-  const droppedFavorites = [];
-  const tail = favorites.map((fav) => {
-    const route = resolveRoute(fav.providerId, fav.modelId);
-    if (!route) droppedFavorites.push(fav);
-    return route;
-  }).filter((route) => route !== void 0);
-  const routes = [
-    startingRoute,
-    ...tail.filter((route) => route.aliasId !== startingRoute.aliasId)
-  ].slice(0, max);
-  return { routes, droppedFavorites };
-}
-
 // src/data/model-incompatible.json
 var model_incompatible_default = {
   schema_version: "1",
@@ -7161,6 +7734,61 @@ function listCredentialSkippedProviders(raw, authEntries, importedIds, alreadyRe
   return skipped;
 }
 
+// src/provider-runtime.ts
+function providerRefreshToken(providerId, authType, authRef) {
+  if (authType !== "oauth" || !providerId) return void 0;
+  return () => forceRefreshProviderCredential(providerId, authRef ?? oauthAuthRef(providerId));
+}
+
+// src/catalog.ts
+function localModelToRoute(lp, model) {
+  if (model.modelFormat === "anthropic" && !model.baseUrl) return null;
+  if (model.modelFormat === "openai" && !isSdkMigratedNpm(model.npm) && !model.completionsUrl) return null;
+  const upstreamUrl = model.modelFormat === "cloud-code" ? model.baseUrl ?? ANTIGRAVITY_BASE_URLS[0] : model.modelFormat === "anthropic" ? model.baseUrl : model.completionsUrl;
+  return {
+    aliasId: claudeCodeClientModelId(aliasModelId(model.id, lp.id), model.contextWindow),
+    realModelId: model.upstreamModelId,
+    displayName: `${model.name || model.id} (${lp.name})`,
+    upstreamUrl: upstreamUrl ?? "",
+    apiKey: lp.apiKey,
+    modelFormat: model.modelFormat,
+    contextWindow: model.contextWindow,
+    npm: model.npm,
+    baseURL: model.apiBaseUrl,
+    providerId: lp.id,
+    authType: lp.authType,
+    oauthAccountId: lp.oauthAccountId,
+    providerData: lp.providerData,
+    refreshToken: providerRefreshToken(lp.id, lp.authType, lp.authRef),
+    headers: lp.headers,
+    supportedParameters: model.supportedParameters,
+    reasoning: model.reasoning,
+    interleavedReasoningField: model.interleavedReasoningField,
+    useResponsesLite: model.useResponsesLite,
+    preferWebSockets: model.preferWebSockets
+  };
+}
+function makeRouteResolver(localProviders) {
+  return (providerId, modelId) => {
+    const provider = localProviders?.find((lp) => lp.id === providerId);
+    const model = provider?.models.find((m) => m.id === modelId);
+    return provider && model ? localModelToRoute(provider, model) ?? void 0 : void 0;
+  };
+}
+function buildCatalogRoutes(startingRoute, favorites, resolveRoute, max = MAX_MODEL_CATALOG) {
+  const droppedFavorites = [];
+  const tail = favorites.map((fav) => {
+    const route = resolveRoute(fav.providerId, fav.modelId);
+    if (!route) droppedFavorites.push(fav);
+    return route;
+  }).filter((route) => route !== void 0);
+  const routes = [
+    startingRoute,
+    ...tail.filter((route) => route.aliasId !== startingRoute.aliasId)
+  ].slice(0, max);
+  return { routes, droppedFavorites };
+}
+
 // src/registry/materialize.ts
 init_provider_templates();
 function cachedModelToLocal(cached, provider) {
@@ -7207,7 +7835,12 @@ function cachedModelToLocal(cached, provider) {
     cost: cached.cost,
     isFree: isFreeStatus(freeStatus),
     freeStatus,
-    contextWindow: cached.contextWindow ?? resolveContextWindow(id),
+    // ClinePass's public catalog does not currently report per-model context
+    // limits. Preserve that unknown state for the picker instead of displaying
+    // a heuristic as if it were provider metadata. Launch-time callers still
+    // resolve their required safety fallback when they build the child env or
+    // proxy catalog.
+    contextWindow: provider.id === "cline-pass" && cached.contextWindow === CLINE_PASS_LEGACY_DEFAULT_CONTEXT_WINDOW && cached.contextWindowSource !== "provider" ? void 0 : cached.contextWindow ?? (provider.id === "cline-pass" ? void 0 : resolveContextWindow(id)),
     supportedParameters: cached.supportedParameters,
     reasoning: cached.reasoning ?? modelsDev?.reasoning,
     interleavedReasoningField: cached.interleavedReasoningField ?? modelsDev?.interleaved?.field,
@@ -7244,6 +7877,7 @@ function materializeOne(provider, resolveCredential, agent) {
     id: provider.id,
     name: provider.name,
     apiKey,
+    authRef: provider.authRef,
     authType: provider.authType,
     headers: provider.api.headers,
     models
@@ -7287,14 +7921,14 @@ function normalizeCopilotModels(rows, tier) {
     const lowerId = id.toLowerCase();
     const isFree = tier !== "paid" || copilotModelIsIncluded(row);
     const family = lowerId.split(/[-/:]/)[0] ?? lowerId;
-    const contextWindow = numericValue(row["context_length"]) ?? numericValue(row["contextWindow"]) ?? numericValue(row["context_window"]) ?? resolveContextWindow(id);
+    const contextWindow2 = numericValue(row["context_length"]) ?? numericValue(row["contextWindow"]) ?? numericValue(row["context_window"]) ?? resolveContextWindow(id);
     models.push({
       id,
       name: `${id} [Copilot]`,
       upstreamModelId: id,
       family,
       brand: deriveBrand(family),
-      contextWindow,
+      contextWindow: contextWindow2,
       isFree,
       freeStatus: isFree ? "verified_free" : "unknown",
       modelFormat: "openai",
@@ -7452,9 +8086,9 @@ function formatRegistryAuthLabel(provider) {
 }
 async function resolveProvidersForDisplay() {
   const reg = loadRegistry();
-  const entries = [];
+  const entries2 = [];
   for (const provider of reg.providers) {
-    entries.push({
+    entries2.push({
       id: provider.id,
       name: provider.name,
       modelCount: provider.modelsCache?.models.length ?? 0,
@@ -7463,7 +8097,7 @@ async function resolveProvidersForDisplay() {
       inRegistry: true
     });
   }
-  return entries.sort((a, b) => a.name.localeCompare(b.name));
+  return entries2.sort((a, b) => a.name.localeCompare(b.name));
 }
 function localProvidersToServerModels(localProviders) {
   return localProviders.flatMap(
@@ -7926,6 +8560,14 @@ function injectRelayModels(fixture, routes, templateKey) {
         }]
       }
     ];
+    for (const entry of Object.values(result.models)) {
+      const mimeTypes = entry.supportedMimeTypes;
+      if (!mimeTypes || typeof mimeTypes !== "object" || Array.isArray(mimeTypes)) continue;
+      entry.supportedMimeTypes = Object.fromEntries(
+        Object.entries(mimeTypes).filter(([mime]) => !mime.toLowerCase().includes("audio/"))
+      );
+    }
+    result.audioTranscriptionModelIds = [];
     return result;
   }
   if (!result.agentModelSorts?.[0]?.groups?.[0]) {
@@ -7952,7 +8594,7 @@ function buildAntigravityRoutes(resolvedFavorites, maxRoutes = MAX_MODEL_CATALOG
     const npm = favModel.npm || "@ai-sdk/openai-compatible";
     const upstreamModelId2 = favModel.upstreamModelId || modelId;
     const baseURL = favModel.apiBaseUrl || favModel.completionsUrl || void 0;
-    const contextWindow = favModel.contextWindow;
+    const contextWindow2 = favModel.contextWindow;
     const modelFormat = favModel.modelFormat;
     routes.push({
       catalogId,
@@ -7967,8 +8609,10 @@ function buildAntigravityRoutes(resolvedFavorites, maxRoutes = MAX_MODEL_CATALOG
       ...fav.authType ? { authType: fav.authType } : {},
       ...fav.oauthAccountId ? { oauthAccountId: fav.oauthAccountId } : {},
       ...fav.providerData ? { providerData: fav.providerData } : {},
+      ...fav.headers ? { headers: fav.headers } : {},
+      ...fav.refreshToken ? { refreshToken: fav.refreshToken } : {},
       baseURL,
-      contextWindow
+      contextWindow: contextWindow2
     });
   }
   return applyUniqueAntigravityRouteLabels(routes);
@@ -8184,8 +8828,8 @@ function contextFloorForTarget(target) {
   if (target === "server") return 0;
   return MIN_CONTEXT_WINDOW;
 }
-function meetsContextFloor(target, contextWindow) {
-  return contextWindow === void 0 || contextWindow >= contextFloorForTarget(target);
+function meetsContextFloor(target, contextWindow2) {
+  return contextWindow2 === void 0 || contextWindow2 >= contextFloorForTarget(target);
 }
 function isTargetCompatibleModel(ctx) {
   const blacklistAgent = blacklistAgentForTarget(ctx.target);
@@ -8361,14 +9005,14 @@ function parseModelList(body, npm) {
       // daily Neuron allowance, so free access is a provider rule, not a price.
       freeAccess: isFreeFromProps === true
     });
-    const contextWindow = contextWindowFromProps ?? row.context_length ?? row.contextWindow ?? row.context_window ?? resolveContextWindow(id);
+    const contextWindow2 = contextWindowFromProps ?? row.context_length ?? row.contextWindow ?? row.context_window ?? resolveContextWindow(id);
     models.push({
       id,
       name: normalizeGoogleDisplayName(row.name, id),
       upstreamModelId: upstreamModelId2,
       family,
       brand: deriveBrand(family),
-      contextWindow,
+      contextWindow: contextWindow2,
       cost,
       isFree: isFreeStatus(freeStatus),
       freeStatus,
@@ -8770,6 +9414,125 @@ async function addCustomEndpointProvider(input) {
   return { added: true, provider: entry, modelCount: fetched.models.length };
 }
 
+// src/registry/fetch-cline-pass-models.ts
+var REQUEST_TIMEOUT_MS = 1e4;
+function trace(message) {
+  if (process.env.RELAY_AI_TRACE !== "1") return;
+  writeSecureLogLine(
+    getProviderDebugLogPath(),
+    `${(/* @__PURE__ */ new Date()).toISOString()} ${message}`
+  );
+}
+async function responseBodyPreview(response) {
+  try {
+    const clone = typeof response.clone === "function" ? response.clone() : response;
+    if (typeof clone.text !== "function") return "";
+    return (await clone.text()).slice(0, 500).trim();
+  } catch {
+    return "";
+  }
+}
+function entries(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => Boolean(entry && typeof entry === "object"));
+}
+function positiveNumber(value) {
+  const number = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : void 0;
+  return typeof number === "number" && Number.isFinite(number) && number > 0 ? number : void 0;
+}
+function contextWindow(entry) {
+  return [
+    entry.context_window,
+    entry.contextWindow,
+    entry.context_length,
+    entry.max_input_tokens,
+    entry.limit?.context
+  ].map(positiveNumber).find((value) => value !== void 0);
+}
+function toCachedModel(entry, isFree) {
+  const id = typeof entry.id === "string" ? entry.id.trim() : "";
+  if (!id) return null;
+  const name = typeof entry.name === "string" && entry.name.trim() ? entry.name.trim() : id;
+  const reportedContextWindow = contextWindow(entry);
+  const cost = isFree ? { input: 0, output: 0 } : void 0;
+  const freeStatus = classifyFreeStatus({ model: { cost, isFree } });
+  const family = id.split("/").pop()?.split(/[-:]/)[0] ?? id;
+  return {
+    id,
+    name,
+    upstreamModelId: id,
+    family,
+    brand: deriveBrand(family),
+    contextWindow: reportedContextWindow,
+    contextWindowSource: reportedContextWindow === void 0 ? void 0 : "provider",
+    cost,
+    isFree: isFreeStatus(freeStatus),
+    freeStatus,
+    modelFormat: "openai",
+    npm: "@ai-sdk/openai-compatible"
+  };
+}
+function parseClinePassModels(payload) {
+  if (!payload || typeof payload !== "object") return [];
+  const body = payload;
+  const byId = /* @__PURE__ */ new Map();
+  for (const entry of entries(body.clinePass)) {
+    const model = toCachedModel(entry, false);
+    if (model) byId.set(model.id, model);
+  }
+  for (const entry of entries(body.free)) {
+    const model = toCachedModel(entry, true);
+    if (model && !byId.has(model.id)) byId.set(model.id, model);
+  }
+  return [...byId.values()];
+}
+async function fetchJson(url, headers) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  trace(`ClinePass GET ${url} authorization=${headers?.Authorization ? "present" : "absent"}`);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json", ...headers },
+      redirect: "manual",
+      signal: controller.signal
+    });
+    trace(`ClinePass response status=${response.status} url=${url}`);
+    return response;
+  } catch (err) {
+    trace(`ClinePass request failed url=${url} error=${err instanceof Error ? err.message : String(err)}`);
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchClinePassModels() {
+  const response = await fetchJson(CLINE_PASS_CATALOG_URL);
+  if (!response.ok) {
+    const body = await responseBodyPreview(response);
+    if (body) trace(`ClinePass catalog body=${body}`);
+    throw new Error(`ClinePass catalog returned HTTP ${response.status}.`);
+  }
+  const payload = await response.json().catch(() => null);
+  const models = parseClinePassModels(payload);
+  trace(`ClinePass catalog parsed models=${models.length}`);
+  if (models.length === 0) throw new Error("ClinePass catalog returned no usable models.");
+  return models;
+}
+async function validateClinePassApiKey(apiKey) {
+  const response = await fetchJson(CLINE_PASS_VALIDATION_URL, {
+    Authorization: `Bearer ${apiKey.trim()}`
+  });
+  const body = await responseBodyPreview(response);
+  if (body) trace(`ClinePass validation body=${body}`);
+  if (response.status === 401 || response.status === 403) {
+    throw new Error("API key was rejected.");
+  }
+  if (!response.ok) {
+    throw new Error(`ClinePass API key validation returned HTTP ${response.status}.`);
+  }
+}
+
 // src/registry/model-source.ts
 init_provider_templates();
 
@@ -8939,8 +9702,8 @@ async function refreshZenGoProvider(provider) {
   });
 }
 async function refreshClaudeCodeOAuthModels(accessToken) {
-  const entries = await fetchClaudeCodeModels(accessToken);
-  const models = entries.map((entry) => ({
+  const entries2 = await fetchClaudeCodeModels(accessToken);
+  const models = entries2.map((entry) => ({
     id: entry.id,
     name: entry.displayName,
     upstreamModelId: entry.id,
@@ -9121,7 +9884,7 @@ async function fetchJsonWithAuth(url, accessToken, timeoutMs, extraHeaders = {})
 async function refreshOpenAiOAuthModels(accessToken) {
   const TIMEOUT_MS = 1e4;
   const seedById = new Map(buildOpenAiOAuthModels().map((m) => [m.id, m]));
-  const toModels = (entries) => entries.map((entry) => buildDynamicOAuthModel(entry, seedById));
+  const toModels = (entries2) => entries2.map((entry) => buildDynamicOAuthModel(entry, seedById));
   const claudeVersion = getInstalledClaudeVersion();
   const codexResult = await fetchJsonWithAuth(
     `https://chatgpt.com/backend-api/codex/models?client_version=${claudeVersion}`,
@@ -9152,9 +9915,9 @@ async function refreshXaiOAuthModels(accessToken) {
   const seedById = new Map(seed.map((m) => [m.id, m]));
   const result = await fetchJsonWithAuth("https://api.x.ai/v1/models", accessToken, 8e3);
   if (result.body) {
-    const entries = (result.body.data ?? []).filter((m) => !!m.id);
-    if (entries.length > 0) {
-      const live = entries.map(({ id, context_length }) => {
+    const entries2 = (result.body.data ?? []).filter((m) => !!m.id);
+    if (entries2.length > 0) {
+      const live = entries2.map(({ id, context_length }) => {
         const cached = seedById.get(id);
         if (cached) return cached;
         const prefix = id.split("-")[0] ?? id;
@@ -9261,6 +10024,19 @@ async function refreshProviderModels(providerId, apiKey, registry = loadRegistry
     let oauthFallbackReason;
     if (source === "zen-go-api") {
       models = await refreshZenGoProvider(provider);
+    } else if (source === "cline-recommended") {
+      try {
+        models = await fetchClinePassModels();
+        baseUrl = provider.api.url ?? "https://api.cline.bot/api/v1";
+      } catch (err) {
+        if (cachedModelCount(provider) > 0) {
+          return skipWithCachedModels(
+            provider,
+            `ClinePass catalog refresh failed: ${err instanceof Error ? err.message : String(err)} Kept the existing cached model list; try again later.`
+          );
+        }
+        throw err;
+      }
     } else if (provider.authType === "oauth" && (["openai", "xai", "xai-oauth", "github-copilot", "claude-code", "antigravity"].includes(provider.templateId ?? provider.id) || provider.id === "openai-oauth" || provider.id === "xai-oauth")) {
       if (!apiKey) {
         return {
@@ -9921,8 +10697,9 @@ async function startServer(options) {
   silenceSdkWarnings();
   const languageModelCache = /* @__PURE__ */ new Map();
   const plog = makeServerLog(options.debugLogPath);
+  const subagentRouteRegistry = new SubagentRouteRegistry();
   const server = createServer2((req, res) => {
-    void routeRequest(req, res, options, languageModelCache, plog);
+    void routeRequest(req, res, options, languageModelCache, plog, subagentRouteRegistry);
   });
   await new Promise((resolve, reject) => {
     server.once("error", reject);
@@ -9945,7 +10722,7 @@ async function startServer(options) {
     })
   };
 }
-async function routeRequest(req, res, options, modelCache, plog) {
+async function routeRequest(req, res, options, modelCache, plog, subagentRouteRegistry) {
   try {
     const pathname = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`).pathname;
     plog(`${req.method} ${pathname}`);
@@ -9970,7 +10747,7 @@ async function routeRequest(req, res, options, modelCache, plog) {
       return;
     }
     if (req.method === "POST" && pathname === "/anthropic/v1/messages") {
-      await handleAnthropicMessages(req, res, options, modelCache, plog);
+      await handleAnthropicMessages(req, res, options, modelCache, plog, subagentRouteRegistry);
       return;
     }
     if (req.method === "POST" && pathname === "/openai/v1/chat/completions") {
@@ -9982,13 +10759,16 @@ async function routeRequest(req, res, options, modelCache, plog) {
     sendJson(res, 500, { error: { message: err instanceof Error ? err.message : String(err) } });
   }
 }
-async function handleAnthropicMessages(req, res, options, modelCache, plog) {
-  const body = await readJson(req);
+async function handleAnthropicMessages(req, res, options, modelCache, plog, subagentRouteRegistry) {
+  let body = await readJson(req);
   if (!body) {
     sendJson(res, 400, { error: { message: "Invalid JSON body" } });
     return;
   }
-  const model = lookupModel(res, options.catalog, body.model);
+  const correlatedSubagent = subagentRouteRegistry.consume(req.headers, body);
+  if (correlatedSubagent) body = correlatedSubagent.body;
+  const requestedModelId = correlatedSubagent?.modelId ?? body.model;
+  const model = lookupModel(res, options.catalog, requestedModelId);
   if (!model) {
     plog(`model not found: ${body.model}`);
     return;
@@ -10041,16 +10821,34 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
       return;
     }
     const apiKey = model.apiKey ?? options.apiKey;
-    const languageModel = await getOrInitLanguageModel(modelCache, model, model.npm, model.apiBaseUrl, apiKey, options.vertex);
+    const languageModel = await getOrInitLanguageModel(
+      modelCache,
+      model,
+      model.npm,
+      model.apiBaseUrl,
+      apiKey,
+      options.vertex,
+      providerRefreshToken(model.providerId, model.authType)
+    );
     const npmMaxTools = maxToolsForNpm(model.npm);
     const toolCount = Array.isArray(body.tools) ? body.tools.length : 0;
     if (npmMaxTools !== void 0 && toolCount > npmMaxTools) {
       plog(`tools truncated: ${toolCount} \u2192 ${npmMaxTools} (provider limit)`);
     }
+    const subagentRouting = buildServerSubagentModelRouting(
+      options.catalog.list(),
+      model,
+      options.gateway
+    );
+    const sessionId = extractClaudeSessionId(req.headers, body);
+    if (sessionId) {
+      subagentRouting.registerSubagentRoute = (modelId) => subagentRouteRegistry.register(sessionId, modelId);
+    }
     const params = translateRequest2(body, model.npm, {
       defaultEffort: anthropicEffortFromRequest(body) ? void 0 : model.defaultEffort,
       openAiOAuth: model.npm === "@ai-sdk/openai" && model.authType === "oauth",
       onDebug: plog,
+      subagentRouting,
       reasoningMetadata: {
         providerId: model.providerId,
         apiBaseUrl: model.apiBaseUrl,
@@ -10076,12 +10874,17 @@ async function handleAnthropicMessages(req, res, options, modelCache, plog) {
           params,
           responseModelId,
           (chunk) => res.write(chunk),
-          void 0,
+          plog,
           estimateAnthropicInputTokens(body)
         );
         res.end();
       } else {
-        const anthropicResponse = await generateAnthropicResponse(languageModel, params, responseModelId);
+        const anthropicResponse = await generateAnthropicResponse(
+          languageModel,
+          params,
+          responseModelId,
+          { log: plog }
+        );
         sendJson(res, 200, anthropicResponse);
       }
     } catch (err) {
@@ -10142,7 +10945,15 @@ async function handleOpenAIChatCompletions(req, res, options, modelCache, plog)
   }
   const apiKey = model.apiKey ?? options.apiKey;
   const baseURL = model.modelFormat === "anthropic" ? model.baseUrl : model.apiBaseUrl;
-  const languageModel = await getOrInitLanguageModel(modelCache, model, npm, baseURL, apiKey, options.vertex);
+  const languageModel = await getOrInitLanguageModel(
+    modelCache,
+    model,
+    npm,
+    baseURL,
+    apiKey,
+    options.vertex,
+    providerRefreshToken(model.providerId, model.authType)
+  );
   const params = translateOpenAiRequest(body);
   const clientWantsStream = Boolean(body.stream);
   const responseModelId = getResponseModelId(body.model, model, options);
@@ -10189,7 +11000,7 @@ function backendFor(options, model) {
   if (model.sourceBackend === "go") return options.backends.go;
   throw new Error(`Provider ${model.sourceBackend} is not a cloud backend \u2014 model must set baseUrl/completionsUrl`);
 }
-async function getOrInitLanguageModel(modelCache, model, npm, baseURL, apiKey, vertex) {
+async function getOrInitLanguageModel(modelCache, model, npm, baseURL, apiKey, vertex, refreshToken) {
   const cacheKey = [
     model.providerId ?? model.sourceBackend,
     model.id,
@@ -10209,6 +11020,10 @@ async function getOrInitLanguageModel(modelCache, model, npm, baseURL, apiKey, v
       oauthAccountId: model.oauthAccountId,
       vertex,
       headers: model.headers,
+      refreshToken,
+      onTokenRefreshed: (refreshed) => {
+        model.apiKey = refreshed;
+      },
       useResponsesLite: model.useResponsesLite,
       preferWebSockets: model.preferWebSockets
     });
@@ -11152,7 +11967,24 @@ async function addProviderFromTemplate(template, apiKey, opts) {
       hint: `Remove it first with: relay-ai providers remove ${template.id}`
     };
   }
-  const fetched = await fetchTemplateModels(template, trimmedKey, opts?.baseUrl);
+  let fetched;
+  if (template.modelSource === "cline-recommended") {
+    try {
+      await validateClinePassApiKey(trimmedKey);
+      fetched = {
+        models: await fetchClinePassModels(),
+        baseUrl: template.defaultBaseUrl ?? ""
+      };
+    } catch (err) {
+      return {
+        added: false,
+        error: err instanceof Error ? err.message : String(err),
+        hint: template.signupUrl ? `Verify your key at ${template.signupUrl}` : void 0
+      };
+    }
+  } else {
+    fetched = await fetchTemplateModels(template, trimmedKey, opts?.baseUrl);
+  }
   if (fetched.error || fetched.models.length === 0) {
     return {
       added: false,
@@ -11194,7 +12026,8 @@ async function addProviderFromTemplate(template, apiKey, opts) {
     authType: template.authType,
     api: {
       npm: template.npm,
-      url: fetched.baseUrl
+      url: fetched.baseUrl,
+      ...template.headers ? { headers: template.headers } : {}
     },
     addedAt: existing?.addedAt ?? now,
     refreshedAt: now,
@@ -11210,6 +12043,9 @@ async function addProviderFromTemplate(template, apiKey, opts) {
     registry.providers.push(entry);
   }
   saveRegistry(registry);
+  if (existing?.authRef && existing.authRef !== authRef) {
+    await deleteProviderCredential(existing.authRef);
+  }
   enrichPricingAsync();
   return { added: true, provider: entry, modelCount: pricedModels.length };
 }
@@ -11227,7 +12063,8 @@ var PROVIDER_DISPLAY = {
   "openai-oauth": OPENAI_DISPLAY,
   "github-copilot": "GitHub Copilot",
   "claude-code": "Claude Code (Anthropic subscription)",
-  antigravity: "Antigravity (Google Cloud Code Assist)"
+  antigravity: "Antigravity (Google Cloud Code Assist)",
+  "cline-pass": "ClinePass"
 };
 function openBrowser(url) {
   open3(url).catch(() => {
@@ -11261,6 +12098,17 @@ async function runNativeDeviceCode(providerId) {
       spinner3.stop(pc6.green("Signed in to GitHub Copilot"));
       return tokensToStoredCredential(tokens2);
     }
+    if (providerId === "cline-pass") {
+      const result = await runClinePassDeviceCodeFlow(({ url, userCode }) => {
+        spinner3.stop("");
+        p5.log.info(`Visit: ${pc6.cyan(url)}`);
+        p5.log.info(`Enter code: ${pc6.bold(userCode)}`);
+        openBrowser(url);
+        spinner3.start("Waiting for authorization...");
+      });
+      spinner3.stop(pc6.green("Signed in to ClinePass"));
+      return tokensToStoredCredential(result.tokens, void 0, result.accountId, result.providerData);
+    }
     const { tokens, accountId } = await runOpenAiDeviceCodeFlow(({ url, userCode }) => {
       spinner3.stop("");
       p5.log.info(`Visit: ${pc6.cyan(url)}`);
@@ -11354,6 +12202,7 @@ async function upsertOAuthProvider(providerId, cred) {
   const authRef = oauthAuthRef(registryId);
   const template = getTemplateById(templateId) ?? getTemplateById(registryId);
   let entry = registry.providers.find((pr) => pr.id === registryId);
+  const previousAuthRef = entry?.authRef;
   if (!entry) {
     if (!template) {
       throw new Error(`Provider "${providerId}" is not in your registry and has no template`);
@@ -11380,6 +12229,9 @@ async function upsertOAuthProvider(providerId, cred) {
   if (idx >= 0) registry.providers[idx] = entry;
   else registry.providers.push(entry);
   saveRegistry(registry);
+  if (previousAuthRef && previousAuthRef !== authRef) {
+    await deleteProviderCredential(previousAuthRef);
+  }
   return entry;
 }
 async function authenticateProvider(providerId, options = {}) {
@@ -11425,11 +12277,13 @@ ${pc6.bold("Usage:")}
   relay-ai providers auth xai-oauth
   relay-ai providers auth openai-oauth
   relay-ai providers auth github-copilot
+  relay-ai providers auth cline-pass
 
 ${pc6.bold("Device code (works on SSH/VPS):")}
   xai-oauth        SuperGrok / X Premium (device code at x.ai/device)
   openai-oauth     ChatGPT Plus/Pro (device code at auth.openai.com/codex/device)
   github-copilot   GitHub Copilot Free or paid (device code at github.com/login/device)
+  cline-pass       ClinePass account (device code at app.cline.bot)
 
 ${pc6.dim("OpenCode CLI configs: use")} relay-ai providers import${pc6.dim(" (optional one-time migration).")}`;
 }
@@ -12025,6 +12879,8 @@ export {
   ANTIGRAVITY_BASE_URLS,
   buildAntigravityAuthUrl,
   completeAntigravityExchange,
+  requestClinePassDeviceCode,
+  pollClinePassDeviceCode,
   detectConflicts,
   resolveApiKey,
   buildChildEnv,
@@ -12062,6 +12918,7 @@ export {
   getUiDebugLogPath,
   getServerDebugLogPath,
   getAntigravityDebugLogPath,
+  prepareProviderTraceLog,
   makeTraceLogger,
   writeSecureLogLine,
   printTraceLog,
@@ -12093,6 +12950,8 @@ export {
   splitToolUseId,
   encodeToolUseId,
   serializeToolResultContent,
+  UNSUPPORTED_VOICE_MESSAGE,
+  sanitizeUnsupportedInlineData,
   summarizeSdkRequestForTrace,
   translateRequest,
   formatUpstreamErrorTrace,
@@ -12101,6 +12960,7 @@ export {
   aliasModelId,
   startProxyCatalog,
   startProxy,
+  providerRefreshToken,
   makeRouteResolver,
   buildCatalogRoutes,
   hostFromHeader,
@@ -12162,4 +13022,4 @@ export {
   supportsClaudeTransparentMode,
   buildHttpProxyRoutes
 };
-//# sourceMappingURL=chunk-HEMJFOXG.js.map
+//# sourceMappingURL=chunk-5DDQJSTU.js.map