@stage-labs/metro 0.1.0-beta.70 → 0.1.0-beta.71

package/dist/bedrock.js

@@ -1,63 +1,10 @@
-import { spawn } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { claudeArgs } from './claude.js';
+import { claudeArgs, runClaude } from './claude.js';
 import { bedrockConfigFromEnv, startBedrockProxy } from './bedrock-proxy.js';
-export const PROVIDER_FLAGS = [
-    'CLAUDE_CODE_USE_BEDROCK',
-    'CLAUDE_CODE_USE_MANTLE',
-    'CLAUDE_CODE_USE_VERTEX',
-    'CLAUDE_CODE_USE_FOUNDRY',
-    'CLAUDE_CODE_USE_ANTHROPIC_AWS',
-    'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
-    'CLAUDE_CODE_USE_GATEWAY',
-];
-const CONFLICTING = [
-    ...PROVIDER_FLAGS,
-    'ANTHROPIC_BASE_URL',
-    'ANTHROPIC_API_KEY',
-    'ANTHROPIC_AUTH_TOKEN',
-];
+import { settingsConflicts, settingsFiles } from './claude-settings.js';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+export { PROVIDER_FLAGS, settingsConflicts, settingsFiles };
 const SCRUBBED = [...PROVIDER_FLAGS, 'ANTHROPIC_API_KEY', 'AWS_BEARER_TOKEN_BEDROCK'];
-export function settingsFiles(cwd = process.cwd(), env = process.env) {
-    const explicit = env.CLAUDE_CONFIG_DIR?.trim() ?? '';
-    const configDir = explicit === '' ? join(homedir(), '.claude') : explicit;
-    return [
-        ...new Set([
-            join(configDir, 'settings.json'),
-            join(cwd, '.claude', 'settings.json'),
-            join(cwd, '.claude', 'settings.local.json'),
-        ]),
-    ];
-}
-function envBlock(file) {
-    if (!existsSync(file))
-        return {};
-    try {
-        const parsed = JSON.parse(readFileSync(file, 'utf8'));
-        const block = parsed.env;
-        return typeof block === 'object' && block !== null
-            ? block
-            : {};
-    }
-    catch {
-        return {};
-    }
-}
-export function settingsConflicts(files) {
-    const out = [];
-    for (const file of files) {
-        const block = envBlock(file);
-        for (const key of CONFLICTING) {
-            const value = block[key];
-            if (typeof value === 'string' && value.trim() !== '')
-                out.push(`${file}: ${key}`);
-        }
-    }
-    return out;
-}
 export function firstPartyModelId(bedrockId) {
     return bedrockId.replace(/^(?:[a-z-]+\.)?anthropic\./, '').replace(/-v\d+:\d+$/, '');
 }
@@ -71,22 +18,6 @@ export function claudeEnv(base, port, token, pinned = null) {
         ANTHROPIC_AUTH_TOKEN: token,
     };
 }
-function runClaude(args, env) {
-    return new Promise((resolve, reject) => {
-        const leaveToChild = () => undefined;
-        process.on('SIGINT', leaveToChild);
-        process.on('SIGTERM', leaveToChild);
-        const child = spawn('claude', args, { stdio: 'inherit', env });
-        child.on('error', (err) => {
-            reject(new Error(err.code === 'ENOENT'
-                ? 'the `claude` command is not on PATH — install Claude Code first'
-                : err.message));
-        });
-        child.on('exit', (code) => {
-            resolve(code ?? 1);
-        });
-    });
-}
 export async function bedrock(argv) {
     const cfg = bedrockConfigFromEnv();
     const conflicts = settingsConflicts(settingsFiles());

package/dist/claude-settings.js

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+const CONFLICTING = [...PROVIDER_FLAGS, 'ANTHROPIC_BASE_URL', 'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
+export function settingsFiles(cwd = process.cwd(), env = process.env) {
+    const explicit = env.CLAUDE_CONFIG_DIR?.trim() ?? '';
+    const configDir = explicit === '' ? join(homedir(), '.claude') : explicit;
+    return [
+        ...new Set([
+            join(configDir, 'settings.json'),
+            join(cwd, '.claude', 'settings.json'),
+            join(cwd, '.claude', 'settings.local.json'),
+        ]),
+    ];
+}
+function envBlock(file) {
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        const block = parsed.env;
+        return typeof block === 'object' && block !== null ? block : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function settingsConflicts(files) {
+    const out = [];
+    for (const file of files) {
+        const block = envBlock(file);
+        for (const key of CONFLICTING) {
+            const value = block[key];
+            if (typeof value === 'string' && value.trim() !== '')
+                out.push(`${file}: ${key}`);
+        }
+    }
+    return out;
+}

package/dist/claude.js

@@ -1,15 +1,107 @@
-import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
+import { settingsConflicts, settingsFiles } from './claude-settings.js';
+import { localAgents, pickLocalAgent } from './local.js';
+import { PROVIDER_FLAGS } from './provider-flags.js';
+import { localPort, localUrl } from './runtime.js';
 const CHANNEL_FLAGS = ['--dangerously-load-development-channels', 'server:metro'];
+const KEY_HEADER = 'x-metro-key';
+const PROBE_MS = 3_000;
 export const claudeArgs = (extra) => [
     ...CHANNEL_FLAGS,
     ...extra,
 ];
-export function launchClaude(extra) {
-    const leaveToChild = () => undefined;
-    process.on('SIGINT', leaveToChild);
-    process.on('SIGTERM', leaveToChild);
-    const res = spawnSync('claude', claudeArgs(extra), { stdio: 'inherit' });
-    if (res.error !== undefined)
-        throw new Error('the `claude` command is not on PATH — install Claude Code first');
-    return Promise.resolve(res.status ?? 1);
+const set = (env, name) => (env[name] ?? '').trim() !== '';
+export function pinnedBy(env) {
+    if (set(env, 'ANTHROPIC_BASE_URL'))
+        return 'ANTHROPIC_BASE_URL';
+    return PROVIDER_FLAGS.find((flag) => set(env, flag)) ?? null;
+}
+export function gatewayEnv(base, agentKey, port) {
+    if (agentKey === null || pinnedBy(base) !== null)
+        return base;
+    const own = (base.ANTHROPIC_CUSTOM_HEADERS ?? '').trim();
+    const mine = `${KEY_HEADER}: ${agentKey}`;
+    return {
+        ...base,
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}/gateway`,
+        ANTHROPIC_CUSTOM_HEADERS: own === '' ? mine : `${own}\n${mine}`,
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+    };
+}
+export function servingDaemon(body) {
+    if (typeof body !== 'object' || body === null)
+        return false;
+    const mode = body;
+    return mode.mode === 'local' && mode.stopped !== true;
+}
+async function daemonServing(base = localUrl()) {
+    try {
+        const res = await fetch(`${base}/api/mode`, { signal: AbortSignal.timeout(PROBE_MS) });
+        return res.ok && servingDaemon(await res.json());
+    }
+    catch {
+        return false;
+    }
+}
+export function agentKey(agents, wanted) {
+    if (agents.length === 0)
+        return { skip: 'no agent lives on this machine yet, so Claude Code talks to Anthropic directly' };
+    try {
+        return { key: pickLocalAgent(agents, wanted).key };
+    }
+    catch {
+        return {
+            skip: wanted === undefined || wanted === ''
+                ? 'several agents live here; set METRO_AGENT=<name> to route through the daemon, Claude Code talks to Anthropic directly for now'
+                : `no agent named '${wanted}' lives here, so Claude Code talks to Anthropic directly`,
+        };
+    }
+}
+function localAgentList() {
+    try {
+        return localAgents();
+    }
+    catch {
+        return [];
+    }
+}
+async function verdict() {
+    const pinned = pinnedBy(process.env);
+    if (pinned !== null)
+        return { skip: `${pinned} is set, so Claude Code keeps talking to it` };
+    const conflicts = settingsConflicts(settingsFiles());
+    if (conflicts.length > 0)
+        return { skip: `a settings file pins the provider (${conflicts.join(', ')}), so Claude Code keeps it` };
+    const picked = agentKey(localAgentList(), process.env.METRO_AGENT);
+    if ('skip' in picked)
+        return picked;
+    if (await daemonServing())
+        return picked;
+    return { skip: 'the daemon is not serving here (stopped, or not running), so Claude Code talks to Anthropic directly' };
+}
+export function runClaude(args, env) {
+    return new Promise((resolve, reject) => {
+        const leaveToChild = () => undefined;
+        process.on('SIGINT', leaveToChild);
+        process.on('SIGTERM', leaveToChild);
+        const child = spawn('claude', args, { stdio: 'inherit', env });
+        child.on('error', (err) => {
+            reject(new Error(err.code === 'ENOENT'
+                ? 'the `claude` command is not on PATH — install Claude Code first'
+                : err.message));
+        });
+        child.on('exit', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+export async function launchClaude(extra) {
+    const decision = await verdict();
+    if ('skip' in decision) {
+        process.stderr.write(`metro claude: ${decision.skip}\n`);
+        return runClaude(claudeArgs(extra), process.env);
+    }
+    const port = localPort();
+    process.stderr.write(`metro claude: inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)\n`);
+    return runClaude(claudeArgs(extra), gatewayEnv(process.env, decision.key, port));
 }

package/dist/hold.js

@@ -145,8 +145,11 @@ async function listen(server, info) {
         }
     }
 }
+const CLOSE_WAIT_MS = 2_000;
 const close = (server) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, CLOSE_WAIT_MS);
     server.close(() => {
+        clearTimeout(timer);
         resolve();
     });
     server.closeAllConnections();
@@ -160,6 +163,13 @@ function releaseLock(lockFile) {
         return;
     }
 }
+function armFunnel(info, log, ending) {
+    if (info.funnel === null || ending !== null)
+        return null;
+    const funnel = new HeldFunnel(info.funnel, info.port, log);
+    funnel.start();
+    return funnel;
+}
 export const holdBanner = (info) => `metro is stopped. Holding http://${info.host}:${String(info.port)}${info.funnel === null ? '' : ' and the Funnel address'} ` +
     'until Start on the Server page; Ctrl-C or metro stop ends metro serve';
 export async function holdUntilStart(info, deps = {}) {
@@ -169,8 +179,12 @@ export async function holdUntilStart(info, deps = {}) {
             process.stderr.write(`${line}\n`);
         });
     let finish = () => undefined;
+    let ending = null;
     const ended = new Promise((resolve) => {
-        finish = resolve;
+        finish = (end) => {
+            ending ??= end;
+            resolve(end);
+        };
     });
     const server = holdServer(info, () => {
         finish('start');
@@ -178,14 +192,14 @@ export async function holdUntilStart(info, deps = {}) {
     const onSignal = () => {
         finish('exit');
     };
+    signals.on('SIGINT', onSignal);
+    signals.on('SIGTERM', onSignal);
     if (info.lockFile !== null)
         writeFileSync(info.lockFile, String(process.pid));
     await listen(server, info);
-    const funnel = info.funnel === null ? null : new HeldFunnel(info.funnel, info.port, log);
-    funnel?.start();
-    signals.on('SIGINT', onSignal);
-    signals.on('SIGTERM', onSignal);
-    log(holdBanner(info));
+    const funnel = armFunnel(info, log, ending);
+    if (ending === null)
+        log(holdBanner(info));
     const end = await ended;
     signals.off('SIGINT', onSignal);
     signals.off('SIGTERM', onSignal);

package/dist/provider-flags.js

@@ -0,0 +1,9 @@
+export const PROVIDER_FLAGS = [
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_MANTLE',
+    'CLAUDE_CODE_USE_VERTEX',
+    'CLAUDE_CODE_USE_FOUNDRY',
+    'CLAUDE_CODE_USE_ANTHROPIC_AWS',
+    'CLAUDE_CODE_USE_ANTHROPIC_GOOGLE_CLOUD',
+    'CLAUDE_CODE_USE_GATEWAY',
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.70",
+  "version": "0.1.0-beta.71",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

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

@@ -1,4 +1,5 @@
 import { handleSessionApis, type SessionApis } from './session-apis.js';
+import { handleGatewayRequest } from '../gateway/gateway.js';
 import { handleRelayRequest } from './relay.js';
 import {
   createServer,
@@ -348,6 +349,13 @@ function handleSignInRoutes(
   return apis.mode !== undefined && handleModeRequest(req, res, apis.mode);
 }
 
+function handleEarlyRoutes(req: IncomingMessage, res: ServerResponse, apis: SessionApis): boolean {
+  if (handleHealth(req, res)) return true;
+  if (apis.gateway !== undefined && handleGatewayRequest(req, res, apis.gateway)) return true;
+  if (handleSignInRoutes(req, res, apis)) return true;
+  return handleSessionApis(req, res, apis);
+}
+
 async function handlePreMcpRoutes(
   req: IncomingMessage,
   res: ServerResponse,
@@ -355,9 +363,7 @@ async function handlePreMcpRoutes(
   apis: SessionApis,
   monitorCall?: MonitorCall,
 ): Promise<boolean> {
-  if (handleHealth(req, res)) return true;
-  if (handleSignInRoutes(req, res, apis)) return true;
-  if (handleSessionApis(req, res, apis)) return true;
+  if (handleEarlyRoutes(req, res, apis)) return true;
   if (handleUploadRequest(req, res)) return true;
   if (handleAttachRequest(req, res)) return true;
   if (apis.relayApi && handleRelayRequest(req, res, apis.relayApi)) return true;

package/runtime/node_modules/@metro-labs/mcp/src/daemon/local-mode.ts

@@ -41,6 +41,7 @@ import {
   readLocalAgentFile,
 } from '../db/file-admin.js';
 import { listAgentFiles, readAgentFile } from '../db/file-source.js';
+import { readModelConfig } from '../gateway/model-config.js';
 import type { StationName } from '../db/stations.js';
 
 export interface LocalModeDeps {
@@ -177,6 +178,8 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     updateApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart },
     controlApi: { authorize: (subject) => { assertLocalOwner(subject); }, restart: deps.restart, stop: deps.stop },
     machineApi: { authorize: (subject) => { assertLocalOwner(subject); } },
+    modelApi: { authorize: (subject) => { assertLocalOwner(subject); } },
+    gateway: { config: readModelConfig },
     terminalApi: { authorize: (subject) => { assertLocalOwner(subject); } },
     identity: { owner: localOwner },
     mode: localModeInfo,

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

@@ -0,0 +1,169 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { ApiError } from './api-error.js';
+import { apiFailure, apiSession, cors, readJsonBody, sendJson } from './api-http.js';
+import { isRecord } from './is-record.js';
+import { log } from './log.js';
+import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from '../gateway/codex-auth.js';
+import { beginDeviceLogin, pollDeviceLogin } from '../gateway/codex-device.js';
+import { codexModels, currentTokens, freshCodexState } from '../gateway/codex.js';
+import type { CodexTokens } from '../gateway/codex-auth.js';
+import { GatewayError } from '../gateway/forward.js';
+import {
+  applyModelUpdate,
+  ModelConfigError,
+  publicModelConfig,
+  readModelConfig,
+  setCodexAuth,
+  writeModelConfig,
+  type ModelConfig,
+} from '../gateway/model-config.js';
+
+const PATH = '/api/model';
+const CODEX = '/api/model/codex/';
+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;
+}
+
+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;
+}
+
+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 publicModelConfig(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 publicModelConfig(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 routeFor(path: string, method: string | undefined): Route | number {
+  if (path === PATH) {
+    if (method === 'GET') return { method: 'GET', run: (_req, _deps, store) => Promise.resolve(publicModelConfig(store.read())) };
+    if (method === 'PUT') return { method: 'POST', run: (req, _deps, store) => update(req, store) };
+    return 405;
+  }
+  const rest = path.slice(CODEX.length);
+  const route = CODEX_ROUTES[rest];
+  if (route !== undefined) return route.method === method ? route : 405;
+  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;
+}
+
+export function handleModelRequest(req: IncomingMessage, res: ServerResponse, deps: ModelApiDeps): boolean {
+  const path = (req.url ?? '').split('?')[0] ?? '';
+  if (path !== PATH && !path.startsWith(CODEX)) 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/mcp/src/daemon/session-apis.ts

@@ -16,6 +16,8 @@ import { handleBundleRequest, type BundleApiDeps } from './bundle-api.js';
 import { handleUpdateRequest, type UpdateApiDeps } from './update-api.js';
 import { handleControlRequest, type ControlApiDeps } from './control-api.js';
 import { handleMachineRequest, type MachineApiDeps } from './machine-api.js';
+import { handleModelRequest, type ModelApiDeps } from './model-api.js';
+import type { GatewayDeps } from '../gateway/gateway.js';
 import { handleTerminalRequest, type TerminalApiDeps } from './terminal-api.js';
 
 export interface SessionApis {
@@ -26,6 +28,8 @@ export interface SessionApis {
   updateApi?: UpdateApiDeps;
   controlApi?: ControlApiDeps;
   machineApi?: MachineApiDeps;
+  modelApi?: ModelApiDeps;
+  gateway?: GatewayDeps;
   terminalApi?: TerminalApiDeps;
   localCli?: LocalCliDeps;
   claudeApi?: ClaudeApiDeps;
@@ -53,6 +57,7 @@ export function handleSessionApis(
     ...when(apis.updateApi, (d) => handleUpdateRequest(req, res, d)),
     ...when(apis.controlApi, (d) => handleControlRequest(req, res, d)),
     ...when(apis.machineApi, (d) => handleMachineRequest(req, res, d)),
+    ...when(apis.modelApi, (d) => handleModelRequest(req, res, d)),
     ...when(apis.terminalApi, (d) => handleTerminalRequest(req, res, d)),
     ...when(apis.claudeApi, (d) => handleClaudeRequest(req, res, d)),
     ...when(apis.agentApi, (d) => handleAgentApiRequest(req, res, d)),