@stage-labs/metro 0.1.0-beta.307 → 0.1.0-beta.309

package/runtime/node_modules/@metro-labs/daemon/src/gateway/delivered.ts

@@ -0,0 +1,82 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { isProvider, LOCAL_PREFIX, type Account, type CodexAccess, type Connection, type Fallback, type Provider, type RouteSource } from './model-config.js';
+
+export interface DeliveredRoute {
+  primary: Fallback | null;
+  fallbacks: Fallback[];
+}
+
+export interface Delivered {
+  route: DeliveredRoute | null;
+  source: RouteSource | null;
+  connections: Connection[];
+}
+
+const MAX_FALLBACKS = 8;
+const MAX_CONNECTIONS = 20;
+
+const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
+const maybe = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
+
+function refOf(raw: unknown): Fallback | null {
+  if (!isRecord(raw)) return null;
+  const ref = { connection: text(raw.connection), model: text(raw.model) };
+  return ref.connection === '' ? null : ref;
+}
+
+function routeOf(raw: unknown): DeliveredRoute | null {
+  if (!isRecord(raw)) return null;
+  const fallbacks = Array.isArray(raw.fallbacks) ? raw.fallbacks.flatMap((f: unknown) => refOf(f) ?? []) : [];
+  return { primary: refOf(raw.primary), fallbacks: fallbacks.filter((f) => f.model !== '').slice(0, MAX_FALLBACKS) };
+}
+
+function accountOf(raw: unknown): Account {
+  const account = isRecord(raw) ? raw : {};
+  const method = account.method === 'chatgpt' || account.method === 'code' ? account.method : null;
+  return { email: maybe(account.email), plan: maybe(account.plan), method };
+}
+
+const numberOf = (value: unknown): number => (typeof value === 'number' && Number.isFinite(value) ? value : 0);
+
+function codexOf(raw: Record<string, unknown>): CodexAccess | null {
+  const accessToken = text(raw.accessToken);
+  if (accessToken === '' || (raw.method !== 'chatgpt' && raw.method !== 'code')) return null;
+  return { method: raw.method, accessToken, expiresAt: numberOf(raw.expiresAt), accountId: maybe(raw.accountId) };
+}
+
+function credentialOf(provider: Provider, raw: unknown): { apiKey: string; codex: CodexAccess | null } {
+  if (!isRecord(raw)) return { apiKey: '', codex: null };
+  return provider === 'codex' ? { apiKey: '', codex: codexOf(raw) } : { apiKey: text(raw.apiKey), codex: null };
+}
+
+export function deliveredConnection(raw: unknown): Connection | null {
+  if (!isRecord(raw) || !isProvider(raw.provider)) return null;
+  const id = text(raw.id);
+  if (id === '' || id.startsWith(LOCAL_PREFIX)) return null;
+  const { apiKey, codex } = credentialOf(raw.provider, raw.credential);
+  return {
+    id,
+    provider: raw.provider,
+    label: text(raw.label) === '' ? raw.provider : text(raw.label),
+    model: text(raw.model),
+    apiKey,
+    region: text(raw.region),
+    zdr: raw.zdr === true,
+    revision: numberOf(raw.revision),
+    codex,
+    claude: null,
+    account: accountOf(raw.account),
+    signedOut: codex === null && apiKey === '',
+  };
+}
+
+export function deliveredOf(raw: Record<string, unknown>): Delivered | null {
+  if (!Array.isArray(raw.connections) || (raw.route !== null && !isRecord(raw.route))) return null;
+  const source = raw.source === 'agent' || raw.source === 'organization' ? raw.source : null;
+  const connections = raw.connections.flatMap((c: unknown) => deliveredConnection(c) ?? []).slice(0, MAX_CONNECTIONS);
+  return { route: routeOf(raw.route), source, connections };
+}
+
+export function refreshedConnection(raw: Record<string, unknown>): Connection | null {
+  return deliveredConnection(isRecord(raw.connection) ? raw.connection : raw);
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/effective.ts

@@ -0,0 +1,47 @@
+import { log } from '@metro-labs/core/log';
+import { agentsDir } from '../agents/files.js';
+import { claudeLoginsIn, isV2, readModelFile, type ClaudeLogin } from './claude-store.js';
+import type { Delivered } from './delivered.js';
+import { emptySetup, LOCAL_PREFIX, loginConnection, primaryRoute, runnerModel, SESSION_LOGIN, sessionConnection, type Connection, type ModelSetup } from './model-config.js';
+import { v2Setup } from './model-v2.js';
+import { deliveredSetup, type OrgModels } from './org-models.js';
+
+function localOf(id: string, logins: ClaudeLogin[]): Connection | null {
+  if (id === SESSION_LOGIN) return sessionConnection();
+  if (!id.startsWith(LOCAL_PREFIX)) return null;
+  const login = id.slice(LOCAL_PREFIX.length);
+  return loginConnection(login, logins.find((l) => l.id === login));
+}
+
+export function setupOf(delivered: Delivered | null, logins: ClaudeLogin[]): ModelSetup {
+  const route = delivered?.route ?? null;
+  if (delivered === null || route === null) return { ...emptySetup(), source: delivered?.source ?? null };
+  const named = [...(route.primary === null ? [] : [route.primary]), ...route.fallbacks].map((r) => r.connection);
+  const locals = [...new Set(named)].flatMap((id) => localOf(id, logins) ?? []);
+  return { primary: route.primary, fallbacks: route.fallbacks, connections: [...delivered.connections, ...locals], source: delivered.source };
+}
+
+export function effectiveSetup(dir = agentsDir(), delivered: Delivered | null = deliveredSetup()): ModelSetup {
+  const raw = readModelFile(dir);
+  return isV2(raw) ? v2Setup(raw) : setupOf(delivered, claudeLoginsIn(raw));
+}
+
+export function modelViewText(setup: ModelSetup): string | null {
+  const primary = primaryRoute(setup);
+  if (primary === null) return null;
+  const connections = [{ id: primary.connection.id, provider: primary.connection.provider, model: primary.model }];
+  return `${JSON.stringify({ version: 2, route: primary.connection.id, connections }, null, 2)}\n`;
+}
+
+export function watchModelChanges(models: Pick<OrgModels, 'onChange'>, switchModel: (model: string | null) => boolean, setup: () => ModelSetup = effectiveSetup): () => void {
+  let last = runnerModel(setup());
+  const changed = (): void => {
+    const now = runnerModel(setup());
+    if (now === last) return;
+    const was = last;
+    last = now;
+    if (switchModel(now)) log.info({ was, now }, 'org-models: the model changed, so the Agent SDK session switches to it live, with no restart');
+    else log.info({ was, now }, 'org-models: the model changed while no Agent SDK session listens; its next start loads it');
+  };
+  return models.onChange(changed);
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/fallback.ts

@@ -1,7 +1,7 @@
 import { log } from '@metro-labs/core/log';
 import { lastServed } from './served.js';
 import { PER_MINUTE, usageOf, type UsageWindow } from './usage.js';
-import { bareModel, connectionOf, isSmallModel, notReady, routedConnection, routeLabel, type Connection, type Fallback, type ModelConfig, type Route } from './model-config.js';
+import { bareModel, connectionOf, isSmallModel, notReady, primaryRoute, routeLabel, type Connection, type Fallback, type ModelSetup, type Route } from './model-config.js';
 
 export const USAGE_LIMIT = 0.95;
 const COOLDOWN_MS = 60_000;
@@ -36,7 +36,6 @@ function scopeOf(label: string): string | null {
 function applies(window: UsageWindow, route: Route, now: number): boolean {
   if (window.used === null || window.label === PER_MINUTE) return false;
   if (window.resetAt !== null && Date.parse(window.resetAt) <= now) return false;
-  if (route.connection.provider === 'gemini') return window.label === route.model;
   const scope = scopeOf(window.label);
   return scope === null || route.model.toLowerCase().split(/[^a-z0-9]+/).includes(scope);
 }
@@ -59,16 +58,16 @@ function fallbackModel(requested: string, conn: Connection, model: string): stri
   return conn.provider === 'anthropic' && isSmallModel(bare) ? bare : model;
 }
 
-function fallbackRoute(cfg: ModelConfig, fallback: Fallback, requested: string): Route | null {
-  const conn = connectionOf(cfg, fallback.connection);
-  if (conn === null || notReady(cfg, conn) !== null) return null;
+function fallbackRoute(setup: ModelSetup, fallback: Fallback, requested: string): Route | null {
+  const conn = connectionOf(setup, fallback.connection);
+  if (conn === null || notReady({ connection: conn, model: fallback.model }) !== null) return null;
   return { connection: conn, model: fallbackModel(requested, conn, fallback.model) };
 }
 
 const unique = (routes: Route[]): Route[] => routes.filter((route, at) => routes.findIndex((other) => keyOf(other) === keyOf(route)) === at);
 
-export const chainOf = (primary: Route, cfg: ModelConfig, requested: string): Route[] =>
-  unique([primary, ...(cfg.fallbacks ?? []).flatMap((f) => fallbackRoute(cfg, f, requested) ?? [])]);
+export const chainOf = (primary: Route, setup: ModelSetup, requested: string): Route[] =>
+  unique([primary, ...setup.fallbacks.flatMap((f) => fallbackRoute(setup, f, requested) ?? [])]);
 
 export function routesToTry(chain: Route[], now = Date.now()): Route[] {
   const open = chain.filter((route) => holdOf(route, now) === null);
@@ -120,28 +119,28 @@ export interface ChainRow {
   active: boolean;
 }
 
-function primaryOf(cfg: ModelConfig): Route | null {
-  const conn = routedConnection(cfg);
-  if (conn === null) return null;
+function primaryOf(setup: ModelSetup): Route | null {
+  const primary = primaryRoute(setup);
+  if (primary === null) return null;
   const served = lastServed();
-  const model = conn.model !== '' ? conn.model : served?.connection === conn.id ? served.model : '';
-  return { connection: conn, model };
+  const model = primary.model !== '' ? primary.model : served?.connection === primary.connection.id ? served.model : '';
+  return { connection: primary.connection, model };
 }
 
-function rowOf(cfg: ModelConfig, route: Route, now: number): Omit<ChainRow, 'active'> {
-  const reason = notReady(cfg, route.connection);
+function rowOf(route: Route, now: number): Omit<ChainRow, 'active'> {
+  const reason = notReady(route);
   const used = windowsFor(route, now).reduce<number | null>((most, w) => Math.max(most ?? 0, w.used ?? 0), null);
   return { connection: route.connection.id, model: route.model, used, hold: reason === null ? holdOf(route, now) : { reason, until: null } };
 }
 
-export function chainStatus(cfg: ModelConfig, now = Date.now()): ChainRow[] {
-  const primary = primaryOf(cfg);
+export function chainStatus(setup: ModelSetup, now = Date.now()): ChainRow[] {
+  const primary = primaryOf(setup);
   if (primary === null) return [];
-  const listed = (cfg.fallbacks ?? []).flatMap((f) => {
-    const conn = connectionOf(cfg, f.connection);
+  const listed = setup.fallbacks.flatMap((f) => {
+    const conn = connectionOf(setup, f.connection);
     return conn === null ? [] : [{ connection: conn, model: f.model }];
   });
-  const rows = unique([primary, ...listed]).map((route) => rowOf(cfg, route, now));
+  const rows = unique([primary, ...listed]).map((route) => rowOf(route, now));
   const active = Math.max(0, rows.findIndex((row) => row.hold === null));
   return rows.map((row, at) => ({ ...row, active: at === active }));
 }

package/runtime/node_modules/@metro-labs/daemon/src/gateway/forward.ts

@@ -28,7 +28,6 @@ const HOP_BY_HOP = new Set([
   'upgrade',
   'accept-encoding',
   'x-metro-key',
-  'x-metro-runner',
 ]);
 const RESPONSE_DROP = new Set(['content-length', 'content-encoding', 'transfer-encoding', 'connection', 'keep-alive']);
 

package/runtime/node_modules/@metro-labs/daemon/src/gateway/gateway.ts

@@ -2,9 +2,7 @@ import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'node:
 import { errMsg, log } from '@metro-labs/core/log';
 import { cameThroughProxy } from '@metro-labs/http/api-http';
 import { agentIdForKey } from '../agents/keys.js';
-import { sdkAllowed, sdkConnectionAllowed, SDK_NEEDS_KEY } from '../claude/runner.js';
 import {
-  assertBedrockReady,
   bedrockBase,
   bedrockCount,
   bedrockMessages,
@@ -38,21 +36,17 @@ import {
   withEffort,
   withThinkingFor,
 } from './effort.js';
-import { notReady, PASSTHROUGH_ID, readModelConfig, resolveRoute, routeLabel, setCodexAuth, setGeminiAuth, writeModelConfig, type Connection, type ModelConfig, type Route } from './model-config.js';
-import { codexMessages, sharedCodexState } from './codex.js';
-import { geminiMessages, sharedGeminiState } from './gemini.js';
+import { notReady, resolveRoute, routeLabel, sessionConnection, type Connection, type ModelSetup, type Route } from './model-config.js';
+import { codexMessages, type CodexDeps } from './codex.js';
 import { countTokens } from './subscription.js';
-import type { GeminiDeps } from './gemini.js';
-import type { CodexDeps } from './codex.js';
-import type { GeminiTokens } from './gemini-auth.js';
 import { OPENROUTER_BASE } from './openrouter.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import { forgetServed, noteServed } from './served.js';
 import { forgetUsage, noteUsageHeaders, UsageScanner } from './usage.js';
 import { fitToolSearch } from './tool-search.js';
 import { ANTHROPIC_API, refreshLoginModels } from './provider-models.js';
-import type { CodexTokens } from './codex-auth.js';
 import { forgetClaudeTokens, withClaudeLogin, type ClaudeLoginDeps } from './claude-logins.js';
+import { orgModels } from './org-models.js';
 
 const GATEWAY_PREFIX = '/gateway';
 const MESSAGES = '/v1/messages';
@@ -61,13 +55,12 @@ const MODELS = '/v1/models';
 const HELLO = '/api/hello';
 
 export interface GatewayDeps {
-  config: () => ModelConfig;
+  setup: () => ModelSetup;
   identify?: (key: string) => boolean;
   anthropicBase?: string;
   bedrockBase?: string;
   openrouterBase?: string;
   codex?: Partial<CodexDeps>;
-  gemini?: Partial<GeminiDeps>;
   claudeLogins?: ClaudeLoginDeps;
 }
 
@@ -80,52 +73,35 @@ export function resetGatewayState(): void {
   learned.fields.clear();
   learned.dropBetas = false;
   forgetLearnedThinking();
-  sharedCodexState.clear();
-  sharedGeminiState.clear();
   forgetClaudeTokens();
 }
 
-const saveCodexTokens = (id: string, tokens: CodexTokens): void => {
-  writeModelConfig(setCodexAuth(readModelConfig(), id, tokens));
-};
-
-const saveGeminiTokens = (id: string, tokens: GeminiTokens): void => {
-  writeModelConfig(setGeminiAuth(readModelConfig(), id, tokens));
-};
+const refreshCodex = (conn: Connection): Promise<Connection | null> => orgModels()?.refresh(conn) ?? Promise.resolve(null);
 
 const keyOf = (req: IncomingMessage): string => {
   const raw = req.headers['x-metro-key'];
   return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
 };
 
-const fromSdkRunner = (req: IncomingMessage): boolean => {
-  const raw = req.headers['x-metro-runner'];
-  return (Array.isArray(raw) ? raw[0] : raw)?.trim() === 'sdk';
-};
-
 const defaultIdentify = (key: string): boolean => key !== '' && agentIdForKey(key) !== undefined;
 
-function modelsBody(cfg: ModelConfig): Record<string, unknown> {
-  const data = cfg.connections
-    .filter((c) => c.provider !== 'anthropic' && c.model !== '')
-    .map((c) => ({ id: `${c.provider}:${c.model}`, display_name: `${c.label} · ${c.model}`, description: 'Through metro' }));
-  return { data, has_more: false, first_id: data[0]?.id ?? null, last_id: data.at(-1)?.id ?? null };
+function routesOf(setup: ModelSetup): Route[] {
+  return [...(setup.primary === null ? [] : [setup.primary]), ...setup.fallbacks].flatMap((ref) => {
+    const conn = setup.connections.find((c) => c.id === ref.connection);
+    const model = ref.model === '' ? (conn?.model ?? '') : ref.model;
+    return conn === undefined || model === '' ? [] : [{ connection: conn, model }];
+  });
 }
 
-const PASSTHROUGH: Connection = {
-  id: PASSTHROUGH_ID,
-  provider: 'anthropic',
-  label: 'Claude Code login',
-  model: '',
-  apiKey: '',
-  region: '',
-  zdr: false,
-  codex: null,
-  gemini: null,
-  claude: null,
-};
+function modelsBody(setup: ModelSetup): Record<string, unknown> {
+  const listed = routesOf(setup)
+    .filter((r) => r.connection.provider !== 'anthropic')
+    .map((r) => ({ id: routeLabel(r), display_name: `${r.connection.label} · ${r.model}`, description: 'Through metro' }));
+  const data = listed.filter((m, at) => listed.findIndex((o) => o.id === m.id) === at);
+  return { data, has_more: false, first_id: data[0]?.id ?? null, last_id: data.at(-1)?.id ?? null };
+}
 
-const passthrough = (body: Record<string, unknown>): Route => ({ connection: PASSTHROUGH, model: requestedModel(body) });
+const passthrough = (body: Record<string, unknown>): Route => ({ connection: sessionConnection(), model: requestedModel(body) });
 
 function requestedModel(body: Record<string, unknown>): string {
   const model = body.model;
@@ -181,7 +157,7 @@ function listLoginModels(headers: IncomingHttpHeaders, anthropicBase: string): v
 function sendAnthropic(req: IncomingMessage, conn: Connection, anthropicBase: string, attempt: (base: Record<string, string>) => Promise<Response>, deps: GatewayDeps): Promise<Response> {
   if (conn.apiKey !== '') return attempt(anthropicHeaders(req, conn.apiKey));
   if (conn.claude === null) return attempt(forwardedHeaders(req));
-  return withClaudeLogin(conn.claude.id, deps.claudeLogins ?? {}, (token) => {
+  return withClaudeLogin(conn.claude, deps.claudeLogins ?? {}, (token) => {
     listLoginModels({ authorization: `Bearer ${token}` }, anthropicBase);
     return attempt(loginHeaders(req, token));
   });
@@ -190,7 +166,7 @@ function sendAnthropic(req: IncomingMessage, conn: Connection, anthropicBase: st
 async function refusedLogin(conn: Connection, upstream: Response): Promise<void> {
   if (conn.apiKey !== '' || conn.claude === null || upstream.status !== 401) return;
   await upstream.body?.cancel();
-  throw new GatewayError(403, 'permission_error', `Anthropic refused the Claude login of ${conn.label}: sign in again on the Model page`);
+  throw new GatewayError(403, 'permission_error', `Anthropic refused the Claude login ${conn.label}: sign in again on the Model page`);
 }
 
 async function toAnthropic(
@@ -210,7 +186,7 @@ async function toAnthropic(
     throw new GatewayError(
       403,
       'permission_error',
-      'Claude Code on this machine has no Anthropic login of its own; choose Bedrock, OpenRouter, Codex or Gemini on the Model page, or sign in on the Claude tab',
+      "Claude Code on this machine has no Anthropic login of its own; route this agent to a model on the organization's Models page, or sign in a Claude login on the Model page",
     );
   const watch = watchUpstream(res);
   if (passthrough) listLoginModels(req.headers, anthropicBase);
@@ -229,17 +205,8 @@ async function toAnthropic(
   await pipeResponse(upstream, res, watch, passthrough ? { scanner } : { ownCredential: true, scanner });
 }
 
-async function toOpenRouter(
-  req: IncomingMessage,
-  res: ServerResponse,
-  body: Record<string, unknown>,
-  route: Route,
-  cfg: ModelConfig,
-  deps: GatewayDeps,
-): Promise<void> {
+async function toOpenRouter(req: IncomingMessage, res: ServerResponse, body: Record<string, unknown>, route: Route, deps: GatewayDeps): Promise<void> {
   const conn = route.connection;
-  const reason = notReady(cfg, conn);
-  if (reason !== null) throw new GatewayError(400, 'invalid_request_error', reason);
   const headers: Record<string, string> = {
     'content-type': 'application/json',
     accept: req.headers.accept ?? 'application/json',
@@ -276,11 +243,9 @@ function noteRefusal(connection: string, model: string, upstream: Response): voi
   if (!upstream.ok) log.warn({ connection, model, status: upstream.status }, 'gateway: the provider refused the request');
 }
 
-async function toSubscription(req: IncomingMessage, res: ServerResponse, path: string, body: Record<string, unknown>, route: Route, deps: GatewayDeps): Promise<void> {
-  const conn = route.connection;
+async function toCodex(req: IncomingMessage, res: ServerResponse, path: string, body: Record<string, unknown>, route: Route, deps: GatewayDeps): Promise<void> {
   if (path === COUNT) countTokens(res, body);
-  else if (conn.provider === 'gemini') await geminiMessages(req, res, body, route.model, conn, { save: saveGeminiTokens, ...deps.gemini }, sharedGeminiState, watchUpstream(res));
-  else await codexMessages(req, res, body, route.model, conn, { save: saveCodexTokens, ...deps.codex }, sharedCodexState, watchUpstream(res));
+  else await codexMessages(req, res, body, route.model, route.connection, { refresh: refreshCodex, ...deps.codex }, watchUpstream(res));
 }
 
 function shapedFor(req: IncomingMessage, sent: Record<string, unknown>): Record<string, unknown> {
@@ -296,22 +261,17 @@ interface Request {
   parsed: Record<string, unknown>;
   sent: Record<string, unknown>;
   body: Record<string, unknown>;
-  cfg: ModelConfig;
-}
-
-function checkSdkRoute(req: IncomingMessage, route: Route, deps: GatewayDeps): void {
-  if (fromSdkRunner(req) && (!sdkAllowed(undefined, deps.config()) || !sdkConnectionAllowed(route.connection)))
-    throw new GatewayError(403, 'permission_error', SDK_NEEDS_KEY);
+  setup: ModelSetup;
 }
 
 async function attempt(req: IncomingMessage, res: ServerResponse, ask: Request, route: Route, deps: GatewayDeps): Promise<void> {
   const { path, body } = ask;
   const conn = route.connection;
-  checkSdkRoute(req, route, deps);
   log.info({ route: routeLabel(route), connection: conn.label, path }, 'gateway: routing');
+  const reason = notReady(route);
+  if (reason !== null) throw new GatewayError(400, 'invalid_request_error', reason);
   if (path === MESSAGES) noteServed({ connection: conn.id, provider: conn.provider, model: route.model, at: new Date().toISOString() });
   if (conn.provider === 'bedrock') {
-    assertBedrockReady(conn);
     const up = { settings: conn, base: deps.bedrockBase ?? bedrockBase(conn.region), learned, watch: watchUpstream(res) };
     if (path === COUNT) await bedrockCount(req, res, body, route.model, up);
     else await bedrockMessages(req, res, body, route.model, up);
@@ -319,25 +279,25 @@ async function attempt(req: IncomingMessage, res: ServerResponse, ask: Request,
   }
   if (conn.provider === 'openrouter') {
     if (path === COUNT) throw new GatewayError(404, 'not_found_error', 'OpenRouter does not count tokens');
-    await toOpenRouter(req, res, body, route, ask.cfg, deps);
+    await toOpenRouter(req, res, body, route, deps);
     return;
   }
-  if (conn.provider === 'codex' || conn.provider === 'gemini') {
-    await toSubscription(req, res, path, body, route, deps);
+  if (conn.provider === 'codex') {
+    await toCodex(req, res, path, body, route, deps);
     return;
   }
   await toAnthropic(req, res, bytesOf(ask.raw, ask.parsed, ask.sent), ask.sent, body, route, deps);
 }
 
 async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
-  const cfg = deps.config();
+  const setup = deps.setup();
   const raw = await readBody(req);
   const parsed = parseJson(raw);
   const sent = fitToolSearch(req, parsed);
   const requested = requestedModel(sent);
-  const primary = resolveRoute(requested, cfg) ?? passthrough(sent);
-  const ask: Request = { path, raw, parsed, sent, body: shapedFor(req, sent), cfg };
-  const routes = routesToTry(chainOf(primary, cfg, requested));
+  const primary = resolveRoute(requested, setup) ?? passthrough(sent);
+  const ask: Request = { path, raw, parsed, sent, body: shapedFor(req, sent), setup };
+  const routes = routesToTry(chainOf(primary, setup, requested));
   for (const [at, route] of routes.entries()) {
     const next = routes[at + 1];
     if (path === MESSAGES) noteChoice(primary, route);
@@ -369,7 +329,7 @@ function failed(res: ServerResponse, err: unknown): void {
 function answer(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): void {
   if (req.method === 'GET' && path === MODELS) {
     res.writeHead(200, { 'content-type': 'application/json' });
-    res.end(JSON.stringify(modelsBody(deps.config())));
+    res.end(JSON.stringify(modelsBody(deps.setup())));
     return;
   }
   if (req.method === 'POST' && (path === MESSAGES || path === COUNT)) {
@@ -391,6 +351,6 @@ export function handleGatewayRequest(req: IncomingMessage, res: ServerResponse,
   }
   if (cameThroughProxy(req)) sendError(res, 401, 'authentication_error', 'metro gateway: the agent key works only on this machine, not through its public address');
   else if ((deps.identify ?? defaultIdentify)(keyOf(req))) answer(req, res, path, deps);
-  else sendError(res, 401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start Claude Code with metro claude');
+  else sendError(res, 401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start the agent with metro agent');
   return true;
 }