@stage-labs/metro 0.1.0-beta.9 → 0.1.0-beta.91

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

@@ -0,0 +1,208 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { errMsg, log } from '@metro-labs/core/log';
+import { agentIdForKey } from '../agents/keys.js';
+import {
+  assertBedrockReady,
+  bedrockBase,
+  bedrockCount,
+  bedrockMessages,
+  freshAdaptations,
+  type Adaptations,
+} from './bedrock.js';
+import { anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
+import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, writeModelConfig, type ModelConfig, type Route } from './model-config.js';
+import { codexCount, codexMessages, freshCodexState, type CodexDeps } from './codex.js';
+import { OPENROUTER_BASE } from './openrouter.js';
+import { forgetServed, noteServed } from './served.js';
+import type { CodexTokens } from './codex-auth.js';
+
+export const GATEWAY_PREFIX = '/gateway';
+export const ANTHROPIC_BASE = 'https://api.anthropic.com';
+const MESSAGES = '/v1/messages';
+const COUNT = '/v1/messages/count_tokens';
+const MODELS = '/v1/models';
+const HELLO = '/api/hello';
+
+export interface GatewayDeps {
+  config: () => ModelConfig;
+  identify?: (key: string) => boolean;
+  anthropicBase?: string;
+  bedrockBase?: string;
+  openrouterBase?: string;
+  codex?: Partial<CodexDeps>;
+}
+
+const learned: Adaptations = freshAdaptations();
+const codexState = freshCodexState();
+
+export function resetGatewayState(): void {
+  forgetServed();
+  learned.fields.clear();
+  learned.dropBetas = false;
+  Object.assign(codexState, freshCodexState());
+}
+
+const saveCodexTokens = (tokens: CodexTokens): void => {
+  writeModelConfig(setCodexAuth(readModelConfig(), tokens));
+};
+
+const keyOf = (req: IncomingMessage): string => {
+  const raw = req.headers['x-metro-key'];
+  return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
+};
+
+const defaultIdentify = (key: string): boolean => key !== '' && agentIdForKey(key) !== undefined;
+
+function modelsBody(cfg: ModelConfig): Record<string, unknown> {
+  const data: Record<string, string>[] = [];
+  if (cfg.bedrock.model !== '')
+    data.push({ id: `bedrock:${cfg.bedrock.model}`, display_name: `Bedrock · ${cfg.bedrock.model}`, description: 'Through metro, billed to Amazon Bedrock' });
+  if (cfg.openrouter.model !== '')
+    data.push({ id: `openrouter:${cfg.openrouter.model}`, display_name: `OpenRouter · ${cfg.openrouter.model}`, description: 'Through metro, billed to OpenRouter' });
+  if (cfg.codex.model !== '')
+    data.push({ id: `codex:${cfg.codex.model}`, display_name: `Codex · ${cfg.codex.model}`, description: 'Through metro, on your ChatGPT subscription' });
+  return { data, has_more: false, first_id: data[0]?.id ?? null, last_id: data.at(-1)?.id ?? null };
+}
+
+function requestedModel(body: Record<string, unknown>): string {
+  const model = body.model;
+  if (typeof model !== 'string' || model === '') throw new GatewayError(400, 'invalid_request_error', 'model is required');
+  return model;
+}
+
+const standsInFor = (req: IncomingMessage): boolean => {
+  const metroKey = req.headers['x-metro-key'];
+  return typeof metroKey === 'string' && metroKey !== '' && req.headers.authorization === `Bearer ${metroKey}`;
+};
+
+async function toAnthropic(
+  req: IncomingMessage,
+  res: ServerResponse,
+  raw: Buffer,
+  body: Record<string, unknown>,
+  route: Route,
+  deps: GatewayDeps,
+): Promise<void> {
+  const explicit = typeof body.model === 'string' && body.model !== route.model;
+  const payload = explicit ? Buffer.from(JSON.stringify({ ...body, model: route.model })) : raw;
+  const url = `${deps.anthropicBase ?? ANTHROPIC_BASE}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
+  const key = deps.config().anthropic.apiKey;
+  if (key === '' && standsInFor(req))
+    throw new GatewayError(
+      403,
+      'permission_error',
+      'Claude Code on this machine has no Anthropic login of its own; choose Bedrock, OpenRouter or Codex on the Model page, or sign in on the Claude tab',
+    );
+  const watch = watchUpstream(res);
+  const upstream = await fetch(url, {
+    method: 'POST',
+    headers: key === '' ? forwardedHeaders(req) : anthropicHeaders(req, key),
+    body: new Uint8Array(payload),
+    signal: watch.signal,
+    redirect: 'manual',
+  });
+  await pipeResponse(upstream, res, watch, key === '' ? {} : { ownCredential: true });
+}
+
+async function toOpenRouter(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  route: Route,
+  cfg: ModelConfig,
+  deps: GatewayDeps,
+): Promise<void> {
+  const reason = notReady(cfg, 'openrouter');
+  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',
+    authorization: `Bearer ${cfg.openrouter.apiKey}`,
+    'anthropic-version': typeof req.headers['anthropic-version'] === 'string' ? req.headers['anthropic-version'] : '2023-06-01',
+    'http-referer': 'https://metro.box',
+    'x-title': 'metro',
+  };
+  const beta = req.headers['anthropic-beta'];
+  if (typeof beta === 'string' && beta !== '') headers['anthropic-beta'] = beta;
+  const watch = watchUpstream(res);
+  const upstream = await fetch(`${deps.openrouterBase ?? OPENROUTER_BASE}${MESSAGES}`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ ...body, model: route.model }),
+    signal: watch.signal,
+    redirect: 'manual',
+  });
+  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true });
+}
+
+async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
+  const cfg = deps.config();
+  const raw = await readBody(req);
+  const body = parseJson(raw);
+  const route = resolveRoute(requestedModel(body), cfg);
+  log.info({ route: routeLabel(route), path }, 'gateway: routing');
+  if (path === MESSAGES) noteServed({ provider: route.provider, model: route.model, at: new Date().toISOString() });
+  if (route.provider === 'bedrock') {
+    assertBedrockReady(cfg.bedrock);
+    const up = { settings: cfg.bedrock, base: deps.bedrockBase ?? bedrockBase(cfg.bedrock.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);
+    return;
+  }
+  if (route.provider === 'openrouter') {
+    if (path === COUNT) throw new GatewayError(404, 'not_found_error', 'OpenRouter does not count tokens');
+    await toOpenRouter(req, res, body, route, cfg, deps);
+    return;
+  }
+  if (route.provider === 'codex') {
+    if (path === COUNT) {
+      codexCount(res, body);
+      return;
+    }
+    const codexDeps: CodexDeps = { save: saveCodexTokens, ...deps.codex };
+    await codexMessages(req, res, body, route.model, cfg, codexDeps, codexState, watchUpstream(res));
+    return;
+  }
+  await toAnthropic(req, res, raw, body, route, deps);
+}
+
+function failed(res: ServerResponse, err: unknown): void {
+  if (res.headersSent) {
+    res.end();
+    return;
+  }
+  if (err instanceof GatewayError) {
+    sendError(res, err.status, err.kind, err.message);
+    return;
+  }
+  log.warn({ err: errMsg(err) }, 'gateway: request failed');
+  sendError(res, 502, 'api_error', `metro gateway: ${errMsg(err)}`);
+}
+
+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())));
+    return;
+  }
+  if (req.method === 'POST' && (path === MESSAGES || path === COUNT)) {
+    dispatch(req, res, path, deps).catch((err: unknown) => {
+      failed(res, err);
+    });
+    return;
+  }
+  sendError(res, 404, 'not_found_error', 'not found');
+}
+
+export function handleGatewayRequest(req: IncomingMessage, res: ServerResponse, deps: GatewayDeps): boolean {
+  const full = req.url ?? '';
+  if (full !== GATEWAY_PREFIX && !full.startsWith(`${GATEWAY_PREFIX}/`)) return false;
+  const path = (full.split('?')[0] ?? '').slice(GATEWAY_PREFIX.length);
+  if (req.method === 'HEAD' && path === HELLO) {
+    res.writeHead(200).end();
+    return true;
+  }
+  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');
+  return true;
+}

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

@@ -0,0 +1,195 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson } from '@metro-labs/http/api-http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from './codex-auth.js';
+import { beginDeviceLogin, pollDeviceLogin } from './codex-device.js';
+import { codexModels, currentTokens, freshCodexState } from './codex.js';
+import { openrouterModels } from './openrouter.js';
+import { lastServed } from './served.js';
+import type { CodexTokens } from './codex-auth.js';
+import { GatewayError } from './forward.js';
+import {
+  applyModelUpdate,
+  ModelConfigError,
+  publicModelConfig,
+  readModelConfig,
+  setCodexAuth,
+  writeModelConfig,
+  type ModelConfig,
+} from './model-config.js';
+
+const PATH = '/api/model';
+const CODEX = '/api/model/codex/';
+const OPENROUTER = '/api/model/openrouter/';
+const BODY_MAX = 16 * 1024;
+const DEVICE_PREFIX = 'device/';
+const DEVICE_ID_RE = /^[A-Za-z0-9_-]{16,64}$/;
+
+export interface ModelApiDeps {
+  authorize: (subject: string) => void;
+  read?: () => ModelConfig;
+  write?: (cfg: ModelConfig) => void;
+  issuer?: string;
+  fetchImpl?: typeof fetch;
+  codexHome?: string;
+  codexBase?: string;
+  openrouterBase?: string;
+}
+
+interface Store {
+  read: () => ModelConfig;
+  write: (cfg: ModelConfig) => void;
+}
+
+type Handler = (req: IncomingMessage, deps: ModelApiDeps, store: Store) => Promise<unknown>;
+
+interface Route {
+  method: 'GET' | 'POST';
+  run: Handler;
+}
+
+const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({ ...publicModelConfig(cfg), lastServed: lastServed() });
+
+function asApiError(err: unknown): never {
+  if (err instanceof ModelConfigError || err instanceof CodexAuthError) throw new ApiError(err.message, 400);
+  if (err instanceof GatewayError) throw new ApiError(err.message, 502);
+  throw err;
+}
+
+async function update(req: IncomingMessage, store: Store): Promise<unknown> {
+  const patch = await readJsonBody(req, BODY_MAX);
+  let next: ModelConfig;
+  try {
+    next = applyModelUpdate(store.read(), patch);
+  } catch (err) {
+    asApiError(err);
+  }
+  store.write(next);
+  log.info({ provider: next.provider }, 'model-api: route updated');
+  return settingsBody(next);
+}
+
+function saveCodex(store: Store, cfg: ModelConfig, note: string): unknown {
+  store.write(cfg);
+  log.info({ signedIn: cfg.codex.auth !== null, plan: cfg.codex.auth?.plan ?? null }, note);
+  return settingsBody(cfg);
+}
+
+const modelApiState = freshCodexState();
+
+async function pollDevice(id: string, deps: ModelApiDeps, store: Store): Promise<unknown> {
+  const result = await pollDeviceLogin(id, deps.fetchImpl).catch(asApiError);
+  if (result.status !== 'done') return result;
+  return { status: 'done', settings: saveCodex(store, setCodexAuth(store.read(), result.tokens), 'model-api: Codex connected by device code') };
+}
+
+const CODEX_ROUTES: Record<string, Route> = {
+  device: {
+    method: 'POST',
+    run: async (_req, deps) => {
+      const login = await beginDeviceLogin(deps.issuer, deps.fetchImpl).catch(asApiError);
+      return { id: login.id, user_code: login.userCode, verify_url: login.verifyUrl, interval: login.interval };
+    },
+  },
+  login: {
+    method: 'POST',
+    run: (_req, deps) => Promise.resolve({ url: beginLogin(deps.issuer).url }),
+  },
+  callback: {
+    method: 'POST',
+    run: async (req, deps, store) => {
+      const body = await readJsonBody(req, BODY_MAX);
+      const raw = isRecord(body) && typeof body.url === 'string' ? body.url : '';
+      const tokens = await finishLogin(raw, deps.issuer, deps.fetchImpl).catch(asApiError);
+      return saveCodex(store, setCodexAuth(store.read(), tokens), 'model-api: Codex connected');
+    },
+  },
+  logout: {
+    method: 'POST',
+    run: (_req, _deps, store) => Promise.resolve(saveCodex(store, setCodexAuth(store.read(), null), 'model-api: Codex disconnected')),
+  },
+  import: {
+    method: 'POST',
+    run: (_req, deps, store) => {
+      let tokens;
+      try {
+        tokens = readCodexCliAuth(deps.codexHome);
+      } catch (err) {
+        asApiError(err);
+      }
+      return Promise.resolve(saveCodex(store, setCodexAuth(store.read(), tokens), 'model-api: Codex CLI login imported'));
+    },
+  },
+  models: {
+    method: 'GET',
+    run: async (_req, deps, store) => {
+      const cfg = store.read();
+      if (cfg.codex.auth === null) throw new ApiError('Codex is not connected: sign in with ChatGPT first', 400);
+      const codexDeps = { issuer: deps.issuer, fetchImpl: deps.fetchImpl, base: deps.codexBase, save: (t: CodexTokens) => { store.write(setCodexAuth(store.read(), t)); } };
+      const auth = await currentTokens(cfg, codexDeps, modelApiState).catch(asApiError);
+      const models = await codexModels(auth, codexDeps).catch(asApiError);
+      return { models };
+    },
+  },
+};
+
+const OPENROUTER_ROUTES: Record<string, Route> = {
+  models: {
+    method: 'GET',
+    run: async (_req, deps) => ({ models: await openrouterModels(deps.openrouterBase, deps.fetchImpl).catch(asApiError) }),
+  },
+};
+
+const named = (table: Record<string, Route>, name: string, method: string | undefined): Route | number => {
+  const route = table[name];
+  if (route === undefined) return 404;
+  return route.method === method ? route : 405;
+};
+
+function settingsRoute(method: string | undefined): Route | number {
+  if (method === 'GET') return { method: 'GET', run: (_req, _deps, store) => Promise.resolve(settingsBody(store.read())) };
+  if (method === 'PUT') return { method: 'POST', run: (req, _deps, store) => update(req, store) };
+  return 405;
+}
+
+function codexRoute(rest: string, method: string | undefined): Route | number {
+  if (rest in CODEX_ROUTES) return named(CODEX_ROUTES, rest, method);
+  const id = rest.startsWith(DEVICE_PREFIX) ? rest.slice(DEVICE_PREFIX.length) : '';
+  if (!DEVICE_ID_RE.test(id)) return 404;
+  return method === 'GET' ? { method: 'GET', run: (_req, deps, store) => pollDevice(id, deps, store) } : 405;
+}
+
+const mine = (path: string): boolean => path === PATH || path.startsWith(CODEX) || path.startsWith(OPENROUTER);
+
+function routeFor(path: string, method: string | undefined): Route | number {
+  if (path === PATH) return settingsRoute(method);
+  if (path.startsWith(OPENROUTER)) return named(OPENROUTER_ROUTES, path.slice(OPENROUTER.length), method);
+  return codexRoute(path.slice(CODEX.length), method);
+}
+
+export function handleModelRequest(req: IncomingMessage, res: ServerResponse, deps: ModelApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (!mine(path)) return false;
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, cors(req)).end();
+    return true;
+  }
+  const route = routeFor(path, req.method);
+  if (typeof route === 'number') {
+    sendJson(req, res, route, { error: route === 404 ? 'not found' : 'method not allowed' });
+    return true;
+  }
+  const store: Store = { read: deps.read ?? readModelConfig, write: deps.write ?? writeModelConfig };
+  apiSession(req)
+    .then(async (session) => {
+      if (!session) throw new ApiError('unauthorized', 401);
+      deps.authorize(session.subject);
+      sendJson(req, res, 200, await route.run(req, deps, store));
+    })
+    .catch((err: unknown) => {
+      apiFailure(req, res, err, 'model-api');
+    });
+  return true;
+}

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

@@ -0,0 +1,198 @@
+import { join } from 'node:path';
+import { readJson, writeSecure } from '@metro-labs/core/secure-fs';
+import { agentsDir } from '../agents/files.js';
+import { isRecord } from '@metro-labs/core/is-record';
+import type { CodexTokens } from './codex-auth.js';
+
+export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex'] as const;
+export type Provider = (typeof PROVIDERS)[number];
+
+export interface AnthropicSettings {
+  apiKey: string;
+  model: string;
+}
+
+export interface BedrockSettings {
+  region: string;
+  apiKey: string;
+  model: string;
+}
+
+export interface OpenRouterSettings {
+  apiKey: string;
+  model: string;
+}
+
+export interface CodexSettings {
+  model: string;
+  auth: CodexTokens | null;
+}
+
+export interface ModelConfig {
+  version: 1;
+  provider: Provider;
+  anthropic: AnthropicSettings;
+  bedrock: BedrockSettings;
+  openrouter: OpenRouterSettings;
+  codex: CodexSettings;
+}
+
+export interface Route {
+  provider: Provider;
+  model: string;
+}
+
+export class ModelConfigError extends Error {}
+
+export const MODEL_FILE = 'model.json';
+const MAX_FIELD = 512;
+const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex):(.+)$/;
+const SMALL_RE = /haiku/i;
+
+const empty = (): ModelConfig => ({
+  version: 1,
+  provider: 'anthropic',
+  anthropic: { apiKey: '', model: '' },
+  bedrock: { region: '', apiKey: '', model: '' },
+  openrouter: { apiKey: '', model: '' },
+  codex: { model: '', auth: null },
+});
+
+const isProvider = (value: unknown): value is Provider =>
+  typeof value === 'string' && (PROVIDERS as readonly string[]).includes(value);
+
+const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
+const maybe = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
+
+function tokensFromDisk(raw: unknown): CodexTokens | null {
+  if (!isRecord(raw)) return null;
+  const accessToken = text(raw.accessToken);
+  const refreshToken = text(raw.refreshToken);
+  const accountId = text(raw.accountId);
+  if (accessToken === '' || refreshToken === '' || accountId === '') return null;
+  return {
+    accessToken,
+    refreshToken,
+    idToken: text(raw.idToken),
+    accountId,
+    email: maybe(raw.email),
+    plan: maybe(raw.plan),
+    savedAt: text(raw.savedAt) === '' ? new Date(0).toISOString() : text(raw.savedAt),
+  };
+}
+
+function fromDisk(raw: unknown): ModelConfig {
+  const base = empty();
+  if (!isRecord(raw)) return base;
+  const anthropic = isRecord(raw.anthropic) ? raw.anthropic : {};
+  const bedrock = isRecord(raw.bedrock) ? raw.bedrock : {};
+  const openrouter = isRecord(raw.openrouter) ? raw.openrouter : {};
+  const codex = isRecord(raw.codex) ? raw.codex : {};
+  return {
+    version: 1,
+    provider: isProvider(raw.provider) ? raw.provider : 'anthropic',
+    anthropic: { apiKey: text(anthropic.apiKey), model: text(anthropic.model) },
+    bedrock: { region: text(bedrock.region), apiKey: text(bedrock.apiKey), model: text(bedrock.model) },
+    openrouter: { apiKey: text(openrouter.apiKey), model: text(openrouter.model) },
+    codex: { model: text(codex.model), auth: tokensFromDisk(codex.auth) },
+  };
+}
+
+export function readModelConfig(dir = agentsDir()): ModelConfig {
+  return fromDisk(readJson<unknown>(join(dir, MODEL_FILE), null, { warn: 'model-config: model.json is unreadable, so every request goes to Anthropic until it is fixed' }));
+}
+
+export function writeModelConfig(cfg: ModelConfig, dir = agentsDir()): void {
+  writeSecure(join(dir, MODEL_FILE), JSON.stringify(cfg, null, 2));
+}
+
+function field(patch: Record<string, unknown>, key: string, current: string, what: string): string {
+  if (!(key in patch)) return current;
+  const value = patch[key];
+  if (typeof value !== 'string') throw new ModelConfigError(`${what} must be a string`);
+  if (value.length > MAX_FIELD) throw new ModelConfigError(`${what} is too long`);
+  return value.trim();
+}
+
+export function applyModelUpdate(cfg: ModelConfig, patch: unknown): ModelConfig {
+  if (!isRecord(patch)) throw new ModelConfigError('body must be a JSON object');
+  const provider = 'provider' in patch ? patch.provider : cfg.provider;
+  if (!isProvider(provider)) throw new ModelConfigError(`provider must be one of ${PROVIDERS.join(', ')}`);
+  const anthropic = isRecord(patch.anthropic) ? patch.anthropic : {};
+  const bedrock = isRecord(patch.bedrock) ? patch.bedrock : {};
+  const openrouter = isRecord(patch.openrouter) ? patch.openrouter : {};
+  const codex = isRecord(patch.codex) ? patch.codex : {};
+  return {
+    version: 1,
+    provider,
+    anthropic: {
+      apiKey: field(anthropic, 'apiKey', cfg.anthropic.apiKey, 'Anthropic API key'),
+      model: field(anthropic, 'model', cfg.anthropic.model, 'Anthropic model'),
+    },
+    bedrock: {
+      region: field(bedrock, 'region', cfg.bedrock.region, 'Bedrock region'),
+      apiKey: field(bedrock, 'apiKey', cfg.bedrock.apiKey, 'Bedrock API key'),
+      model: field(bedrock, 'model', cfg.bedrock.model, 'Bedrock model'),
+    },
+    openrouter: {
+      apiKey: field(openrouter, 'apiKey', cfg.openrouter.apiKey, 'OpenRouter API key'),
+      model: field(openrouter, 'model', cfg.openrouter.model, 'OpenRouter model'),
+    },
+    codex: { model: field(codex, 'model', cfg.codex.model, 'Codex model'), auth: cfg.codex.auth },
+  };
+}
+
+export const setCodexAuth = (cfg: ModelConfig, auth: CodexTokens | null): ModelConfig => ({ ...cfg, codex: { ...cfg.codex, auth } });
+
+const CHECKS: Record<Provider, [(cfg: ModelConfig) => boolean, string][]> = {
+  anthropic: [],
+  bedrock: [
+    [(cfg) => cfg.bedrock.apiKey === '', 'Bedrock needs an API key: add it on the Model page.'],
+    [(cfg) => cfg.bedrock.region === '', 'Bedrock needs a region: add it on the Model page.'],
+  ],
+  openrouter: [
+    [(cfg) => cfg.openrouter.apiKey === '', 'OpenRouter needs an API key: add it on the Model page.'],
+    [(cfg) => cfg.openrouter.model === '', 'OpenRouter needs a model id: choose one on the Model page.'],
+  ],
+  codex: [
+    [(cfg) => cfg.codex.auth === null, 'Codex is not connected: sign in with ChatGPT on the Model page.'],
+    [(cfg) => cfg.codex.model === '', 'Codex needs a model id: choose one on the Model page.'],
+  ],
+};
+
+export function notReady(cfg: ModelConfig, provider: Provider = cfg.provider): string | null {
+  return CHECKS[provider].find(([missing]) => missing(cfg))?.[1] ?? null;
+}
+
+export function publicModelConfig(cfg: ModelConfig): Record<string, unknown> {
+  const auth = cfg.codex.auth;
+  return {
+    provider: cfg.provider,
+    ready: notReady(cfg) === null,
+    reason: notReady(cfg),
+    anthropic: { model: cfg.anthropic.model, hasKey: cfg.anthropic.apiKey !== '' },
+    bedrock: { region: cfg.bedrock.region, model: cfg.bedrock.model, hasKey: cfg.bedrock.apiKey !== '' },
+    openrouter: { model: cfg.openrouter.model, hasKey: cfg.openrouter.apiKey !== '' },
+    codex: { model: cfg.codex.model, signedIn: auth !== null, account: auth?.email ?? null, plan: auth?.plan ?? null },
+  };
+}
+
+export const isSmallModel = (requested: string): boolean => SMALL_RE.test(requested);
+
+function defaultModelFor(provider: Provider, requested: string, cfg: ModelConfig): string {
+  if (provider === 'openrouter') return requested.includes('/') ? requested : cfg.openrouter.model;
+  if (provider === 'bedrock') return cfg.bedrock.model === '' ? requested : cfg.bedrock.model;
+  if (provider === 'codex') return requested.startsWith('gpt-') ? requested : cfg.codex.model;
+  return cfg.anthropic.model === '' || isSmallModel(requested) ? requested : cfg.anthropic.model;
+}
+
+export function resolveRoute(requested: string, cfg: ModelConfig): Route {
+  const explicit = PREFIX_RE.exec(requested);
+  if (explicit !== null && isProvider(explicit[1]))
+    return { provider: explicit[1], model: (explicit[2] ?? '').trim() };
+  return { provider: cfg.provider, model: defaultModelFor(cfg.provider, requested, cfg) };
+}
+
+export function routeLabel(route: Route): string {
+  return route.provider === 'anthropic' ? route.model : `${route.provider}:${route.model}`;
+}

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

@@ -0,0 +1,40 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { GatewayError } from './forward.js';
+
+export const OPENROUTER_BASE = 'https://openrouter.ai/api';
+const MODELS_MAX = 2000;
+
+export interface OpenRouterModel {
+  id: string;
+  name: string;
+  prompt: number | null;
+  completion: number | null;
+}
+
+const str = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+function price(raw: unknown): number | null {
+  const value = typeof raw === 'string' ? Number(raw) : typeof raw === 'number' ? raw : Number.NaN;
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function modelOf(entry: unknown): OpenRouterModel | null {
+  if (!isRecord(entry)) return null;
+  const id = str(entry.id);
+  if (id === '') return null;
+  const pricing = isRecord(entry.pricing) ? entry.pricing : {};
+  return { id, name: str(entry.name) || id, prompt: price(pricing.prompt), completion: price(pricing.completion) };
+}
+
+export async function openrouterModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<OpenRouterModel[]> {
+  const res = await fetchImpl(`${base}/v1/models`, { headers: { accept: 'application/json' }, redirect: 'manual' });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its models (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = typeof body === 'object' && body !== null ? (body as { data?: unknown }).data : undefined;
+  if (!Array.isArray(data)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no model list');
+  return data
+    .map(modelOf)
+    .filter((model): model is OpenRouterModel => model !== null)
+    .slice(0, MODELS_MAX)
+    .sort((a, b) => a.id.localeCompare(b.id));
+}

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

@@ -0,0 +1,17 @@
+export interface Served {
+  provider: string;
+  model: string;
+  at: string;
+}
+
+let last: Served | null = null;
+
+export const noteServed = (served: Served): void => {
+  last = served;
+};
+
+export const lastServed = (): Served | null => last;
+
+export const forgetServed = (): void => {
+  last = null;
+};