@stage-labs/metro 0.1.0-beta.15 → 0.1.0-beta.151

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

@@ -0,0 +1,353 @@
+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 { errMsg, 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 { beginLogin as beginGeminiLogin, exchangeCode as exchangeGeminiCode, GeminiAuthError, userEmail } from './gemini-auth.js';
+import { onboard, parseGeminiProject } from './gemini-setup.js';
+import { currentGeminiTokens, freshGeminiState, listGeminiModels, type GeminiDeps } from './gemini.js';
+import { openrouterCredits, openrouterModels, openrouterZdrModels } from './openrouter.js';
+import { anthropicModels, bedrockModels } from './provider-models.js';
+import { syncAvailableModelsQuietly, type SetupDeps } from '../claude/setup.js';
+import { lastServed } from './served.js';
+import { geminiUsage, noteUsage, openrouterUsage, usageOf, usageSeen } from './usage.js';
+import type { CodexTokens } from './codex-auth.js';
+import { GatewayError } from './forward.js';
+import {
+  applyModelUpdate,
+  ModelConfigError,
+  parseModelConfig,
+  publicModelConfig,
+  readModelConfig,
+  setCodexAuth,
+  setGeminiAuth,
+  writeModelConfig,
+  type ModelConfig,
+} from './model-config.js';
+
+const PATH = '/api/model';
+const CODEX = '/api/model/codex/';
+const GEMINI = '/api/model/gemini/';
+const OPENROUTER = '/api/model/openrouter/';
+const ANTHROPIC = '/api/model/anthropic/';
+const BEDROCK = '/api/model/bedrock/';
+const BUNDLE = '/api/model/bundle';
+const RESTORE = '/api/model/restore';
+const RESTORE_MAX = 64 * 1024;
+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;
+  geminiAuthBase?: string;
+  geminiTokenBase?: string;
+  geminiUserBase?: string;
+  geminiBase?: string;
+  openrouterBase?: string;
+  anthropicBase?: string;
+  bedrockControlBase?: string;
+  setup?: SetupDeps;
+}
+
+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(),
+  usage: usageSeen(),
+});
+
+const CREDITS_TTL_MS = 5 * 60_000;
+
+async function refreshCredits(cfg: ModelConfig, deps: ModelApiDeps, now = Date.now()): Promise<void> {
+  const key = cfg.openrouter.apiKey;
+  if (key === '') return;
+  const seen = usageOf('openrouter');
+  if (seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS) return;
+  try {
+    const credits = await openrouterCredits(key, deps.openrouterBase, deps.fetchImpl);
+    noteUsage('openrouter', openrouterUsage(credits.total, credits.spent, new Date(now)));
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'model-api: could not read the OpenRouter credits');
+  }
+}
+
+const geminiApiState = freshGeminiState();
+
+const geminiDeps = (deps: ModelApiDeps, store: Store): GeminiDeps => ({
+  base: deps.geminiBase,
+  tokenBase: deps.geminiTokenBase,
+  fetchImpl: deps.fetchImpl,
+  save: (t) => {
+    store.write(setGeminiAuth(store.read(), t));
+  },
+});
+
+async function geminiModels(deps: ModelApiDeps, store: Store): Promise<Awaited<ReturnType<typeof listGeminiModels>>> {
+  const cfg = store.read();
+  if (cfg.gemini.auth === null) throw new ApiError('Gemini is not connected: sign in with Google first', 400);
+  const tokens = await currentGeminiTokens(cfg, geminiDeps(deps, store), geminiApiState);
+  return listGeminiModels(tokens, geminiDeps(deps, store));
+}
+
+async function refreshGeminiQuota(deps: ModelApiDeps, store: Store, now = Date.now()): Promise<void> {
+  if (store.read().gemini.auth === null) return;
+  const seen = usageOf('gemini');
+  if (seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS) return;
+  try {
+    const usage = geminiUsage(await geminiModels(deps, store), new Date(now));
+    if (usage !== null) noteUsage('gemini', usage);
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'model-api: could not read the Gemini quota');
+  }
+}
+
+async function settingsWithUsage(cfg: ModelConfig, deps: ModelApiDeps, store: Store): Promise<Record<string, unknown>> {
+  await refreshCredits(cfg, deps);
+  await refreshGeminiQuota(deps, store);
+  return settingsBody(cfg);
+}
+
+function asApiError(err: unknown): never {
+  if (err instanceof ModelConfigError || err instanceof CodexAuthError || err instanceof GeminiAuthError) throw new ApiError(err.message, 400);
+  if (err instanceof GatewayError) throw new ApiError(err.message, err.status >= 400 && err.status < 500 ? 400 : 502);
+  throw err;
+}
+
+async function update(req: IncomingMessage, store: Store, deps: ModelApiDeps): 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);
+  syncAvailableModelsQuietly(deps.setup ?? {}, 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 };
+    },
+  },
+};
+
+function projectOf(body: unknown): string | null {
+  try {
+    return parseGeminiProject(isRecord(body) ? body.project : null);
+  } catch (err) {
+    return asApiError(err);
+  }
+}
+
+async function connectGemini(req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<unknown> {
+  const body = await readJsonBody(req, BODY_MAX);
+  const code = isRecord(body) && typeof body.code === 'string' ? body.code : '';
+  const state = isRecord(body) && typeof body.state === 'string' ? body.state : '';
+  const project = projectOf(body);
+  const tokens = await exchangeGeminiCode(code, state, deps.geminiTokenBase, deps.fetchImpl).catch(asApiError);
+  const email = await userEmail(tokens, deps.geminiUserBase, deps.fetchImpl);
+  const onboarded = await onboard(tokens, project, deps.geminiBase, deps.fetchImpl).catch(asApiError);
+  const cfg = setGeminiAuth(store.read(), { ...tokens, email, project: onboarded.project, tier: onboarded.tier });
+  store.write(cfg);
+  log.info({ tier: onboarded.tier }, 'model-api: Gemini connected');
+  return settingsBody(cfg);
+}
+
+const GEMINI_ROUTES: Record<string, Route> = {
+  login: {
+    method: 'POST',
+    run: (_req, deps) => Promise.resolve(beginGeminiLogin(deps.geminiAuthBase)),
+  },
+  code: { method: 'POST', run: connectGemini },
+  logout: {
+    method: 'POST',
+    run: (_req, _deps, store) => {
+      const cfg = setGeminiAuth(store.read(), null);
+      store.write(cfg);
+      log.info('model-api: Gemini disconnected');
+      return Promise.resolve(settingsBody(cfg));
+    },
+  },
+  models: {
+    method: 'GET',
+    run: async (_req, deps, store) => ({ models: (await geminiModels(deps, store).catch(asApiError)).map((m) => m.id) }),
+  },
+};
+
+const OPENROUTER_ROUTES: Record<string, Route> = {
+  models: {
+    method: 'GET',
+    run: async (_req, deps) => ({ models: await openrouterModels(deps.openrouterBase, deps.fetchImpl).catch(asApiError) }),
+  },
+  zdr: {
+    method: 'GET',
+    run: async (_req, deps) => ({ models: await openrouterZdrModels(deps.openrouterBase, deps.fetchImpl).catch(asApiError) }),
+  },
+};
+
+const ANTHROPIC_ROUTES: Record<string, Route> = {
+  models: {
+    method: 'GET',
+    run: async (_req, deps, store) => ({ models: await anthropicModels(store.read().anthropic, deps.anthropicBase, deps.fetchImpl).catch(asApiError) }),
+  },
+};
+
+const BEDROCK_ROUTES: Record<string, Route> = {
+  models: {
+    method: 'GET',
+    run: async (_req, deps, store) => ({ models: await bedrockModels(store.read().bedrock, deps.bedrockControlBase, 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;
+};
+
+async function restore(req: IncomingMessage, store: Store, deps: ModelApiDeps): Promise<unknown> {
+  const body = await readJsonBody(req, RESTORE_MAX);
+  if (!isRecord(body)) throw new ApiError('body must be a JSON object', 400);
+  const next = parseModelConfig(body);
+  store.write(next);
+  syncAvailableModelsQuietly(deps.setup ?? {}, next);
+  log.info({ provider: next.provider }, 'model-api: model setup restored from a file');
+  return settingsBody(next);
+}
+
+function bundleRoute(path: string, method: string | undefined): Route | number {
+  if (path === BUNDLE) return method === 'GET' ? { method: 'GET', run: (_req, _deps, store) => Promise.resolve(store.read()) } : 405;
+  return method === 'POST' ? { method: 'POST', run: (req, deps, store) => restore(req, store, deps) } : 405;
+}
+
+function settingsRoute(method: string | undefined): Route | number {
+  if (method === 'GET') return { method: 'GET', run: (_req, deps, store) => settingsWithUsage(store.read(), deps, store) };
+  if (method === 'PUT') return { method: 'POST', run: (req, deps, store) => update(req, store, deps) };
+  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 === BUNDLE || path === RESTORE || path.startsWith(CODEX) || path.startsWith(GEMINI) || path.startsWith(OPENROUTER) || path.startsWith(ANTHROPIC) || path.startsWith(BEDROCK);
+
+function routeFor(path: string, method: string | undefined): Route | number {
+  if (path === PATH) return settingsRoute(method);
+  if (path === BUNDLE || path === RESTORE) return bundleRoute(path, method);
+  if (path.startsWith(OPENROUTER)) return named(OPENROUTER_ROUTES, path.slice(OPENROUTER.length), method);
+  if (path.startsWith(ANTHROPIC)) return named(ANTHROPIC_ROUTES, path.slice(ANTHROPIC.length), method);
+  if (path.startsWith(BEDROCK)) return named(BEDROCK_ROUTES, path.slice(BEDROCK.length), method);
+  if (path.startsWith(GEMINI)) return named(GEMINI_ROUTES, path.slice(GEMINI.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,232 @@
+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';
+import { tokensFromDisk as geminiTokensFromDisk, type GeminiTokens } from './gemini-auth.js';
+
+export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex', 'gemini'] 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;
+  zdr: boolean;
+}
+
+export interface CodexSettings {
+  model: string;
+  auth: CodexTokens | null;
+}
+
+export interface GeminiSettings {
+  model: string;
+  auth: GeminiTokens | null;
+}
+
+export interface ModelConfig {
+  version: 1;
+  provider: Provider;
+  anthropic: AnthropicSettings;
+  bedrock: BedrockSettings;
+  openrouter: OpenRouterSettings;
+  codex: CodexSettings;
+  gemini: GeminiSettings;
+}
+
+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|gemini):(.+)$/;
+const SMALL_RE = /haiku/i;
+
+const empty = (): ModelConfig => ({
+  version: 1,
+  provider: 'anthropic',
+  anthropic: { apiKey: '', model: '' },
+  bedrock: { region: '', apiKey: '', model: '' },
+  openrouter: { apiKey: '', model: '', zdr: false },
+  codex: { model: '', auth: null },
+  gemini: { 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),
+  };
+}
+
+export function parseModelConfig(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 : {};
+  const gemini = isRecord(raw.gemini) ? raw.gemini : {};
+  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), zdr: openrouter.zdr === true },
+    codex: { model: text(codex.model), auth: tokensFromDisk(codex.auth) },
+    gemini: { model: text(gemini.model), auth: geminiTokensFromDisk(gemini.auth) },
+  };
+}
+
+export function readModelConfig(dir = agentsDir()): ModelConfig {
+  return parseModelConfig(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 flag(patch: Record<string, unknown>, key: string, current: boolean, what: string): boolean {
+  if (!(key in patch)) return current;
+  const value = patch[key];
+  if (typeof value !== 'boolean') throw new ModelConfigError(`${what} must be true or false`);
+  return value;
+}
+
+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 : {};
+  const gemini = isRecord(patch.gemini) ? patch.gemini : {};
+  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'),
+      zdr: flag(openrouter, 'zdr', cfg.openrouter.zdr, 'OpenRouter zero data retention'),
+    },
+    codex: { model: field(codex, 'model', cfg.codex.model, 'Codex model'), auth: cfg.codex.auth },
+    gemini: { model: field(gemini, 'model', cfg.gemini.model, 'Gemini model'), auth: cfg.gemini.auth },
+  };
+}
+
+export const setCodexAuth = (cfg: ModelConfig, auth: CodexTokens | null): ModelConfig => ({ ...cfg, codex: { ...cfg.codex, auth } });
+
+export const setGeminiAuth = (cfg: ModelConfig, auth: GeminiTokens | null): ModelConfig => ({ ...cfg, gemini: { ...cfg.gemini, 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.'],
+  ],
+  gemini: [
+    [(cfg) => cfg.gemini.auth === null, 'Gemini is not connected: sign in with Google on the Model page.'],
+    [(cfg) => cfg.gemini.model === '', 'Gemini 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;
+  const gemini = cfg.gemini.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 !== '', zdr: cfg.openrouter.zdr },
+    codex: { model: cfg.codex.model, signedIn: auth !== null, account: auth?.email ?? null, plan: auth?.plan ?? null },
+    gemini: { model: cfg.gemini.model, signedIn: gemini !== null, account: gemini?.email ?? null, plan: gemini?.tier ?? null },
+  };
+}
+
+export const isSmallModel = (requested: string): boolean => SMALL_RE.test(requested);
+
+const DEFAULTS: Record<Provider, (requested: string, cfg: ModelConfig) => string> = {
+  openrouter: (requested, cfg) => (requested.includes('/') ? requested : cfg.openrouter.model),
+  bedrock: (requested, cfg) => (cfg.bedrock.model === '' ? requested : cfg.bedrock.model),
+  codex: (requested, cfg) => (requested.startsWith('gpt-') ? requested : cfg.codex.model),
+  gemini: (requested, cfg) => (requested.startsWith('gemini-') ? requested : cfg.gemini.model),
+  anthropic: (requested, cfg) => (cfg.anthropic.model === '' || isSmallModel(requested) ? requested : cfg.anthropic.model),
+};
+
+function defaultModelFor(provider: Provider, requested: string, cfg: ModelConfig): string {
+  return DEFAULTS[provider](requested, cfg);
+}
+
+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,90 @@
+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;
+  created: 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 released(raw: unknown): number | null {
+  return typeof raw === 'number' && Number.isFinite(raw) && raw > 0 ? raw : 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),
+    created: released(entry.created),
+  };
+}
+
+export function newestFirst(a: OpenRouterModel, b: OpenRouterModel): number {
+  const when = (b.created ?? 0) - (a.created ?? 0);
+  return when !== 0 ? when : a.id.localeCompare(b.id);
+}
+
+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)
+    .sort(newestFirst)
+    .slice(0, MODELS_MAX);
+}
+
+export interface OpenRouterCredits {
+  total: number;
+  spent: number;
+}
+
+export async function openrouterCredits(
+  apiKey: string,
+  base = OPENROUTER_BASE,
+  fetchImpl: typeof fetch = fetch,
+): Promise<OpenRouterCredits> {
+  const res = await fetchImpl(`${base}/v1/credits`, {
+    headers: { accept: 'application/json', authorization: `Bearer ${apiKey}` },
+    redirect: 'manual',
+  });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not report the credits (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = isRecord(body) && isRecord(body.data) ? body.data : {};
+  const total = Number(data.total_credits);
+  const spent = Number(data.total_usage);
+  if (!Number.isFinite(total) || !Number.isFinite(spent)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no credit figures');
+  return { total, spent };
+}
+
+export async function openrouterZdrModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<string[]> {
+  const res = await fetchImpl(`${base}/v1/endpoints/zdr`, { headers: { accept: 'application/json' }, redirect: 'manual' });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its zero data retention endpoints (${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 endpoint list');
+  const ids = new Set<string>();
+  for (const entry of data) if (isRecord(entry) && str(entry.model_id) !== '') ids.add(str(entry.model_id));
+  return [...ids].sort();
+}