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

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/gateway.ts

@@ -3,7 +3,6 @@ import { errMsg, log } from '@metro-labs/core/log';
 import { cameThroughProxy } from '@metro-labs/http/api-http';
 import { agentIdForKey } from '../agents/keys.js';
 import {
-  assertBedrockReady,
   bedrockBase,
   bedrockCount,
   bedrockMessages,
@@ -37,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';
@@ -60,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;
 }
 
@@ -79,18 +73,10 @@ 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'];
@@ -99,27 +85,23 @@ const keyOf = (req: IncomingMessage): string => {
 
 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;
@@ -175,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));
   });
@@ -184,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(
@@ -204,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);
@@ -223,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',
@@ -270,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> {
@@ -290,16 +261,17 @@ interface Request {
   parsed: Record<string, unknown>;
   sent: Record<string, unknown>;
   body: Record<string, unknown>;
-  cfg: ModelConfig;
+  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;
   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);
@@ -307,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);
@@ -357,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)) {

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

@@ -1,217 +1,105 @@
 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 { openrouterModels, openrouterZdrModels } from './openrouter.js';
-import { anthropicModels, bedrockModels } from './provider-models.js';
-import { runnerAlive } from '../claude/session.js';
-import { forgetOne, forgetReported } from './usage.js';
-import {
-  addConnection,
-  connectionOf,
-  parseModelConfig,
-  readModelConfig,
-  readModelSnapshot,
-  removeConnection,
-  routedConnection,
-  setFallbacks,
-  setRoute,
-  updateConnection,
-  writeModelConfig,
-  type ModelConfig,
-} from './model-config.js';
-import { asApiError, BODY_MAX, claudeLoginDeps, connectionFor, settingsBody, type ModelApiDeps, type Route, type Store } from './model-store.js';
-import { dropUnusedClaudeLogins } from './claude-logins.js';
-import { CODEX_ROUTES, codexDeviceRoute, GEMINI_ROUTES } from './model-signin.js';
-import { refreshUsage } from './usage-refresh.js';
-import { handleOpenRouterSignIn } from './openrouter-signin.js';
+import { apiFailure, apiSession, cors, requireAdmin, sendJson, type ApiSession } from '@metro-labs/http/api-http';
+import { agentsDir } from '../agents/files.js';
+import { removeClaudeLogin } from './claude-logins.js';
+import { readClaudeLogins, type ClaudeLogin } from './claude-store.js';
+import { effectiveSetup } from './effective.js';
+import { chainStatus } from './fallback.js';
+import { notReady, primaryRoute, type Connection, type ModelSetup } from './model-config.js';
+import { orgModels, type SyncStatus } from './org-models.js';
+import { claudeModels } from './provider-models.js';
+import { lastServed } from './served.js';
+import { refreshUsage, type UsageDeps } from './usage-refresh.js';
+import { usageSeen } from './usage.js';
 
 const PATH = '/api/model';
 const SNAPSHOT = '/api/model/snapshot';
-const CONNECTIONS = '/api/model/connections';
-const FALLBACKS = '/api/model/fallbacks';
-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 DEVICE_PREFIX = 'device/';
-const DEVICE_ID_RE = /^[A-Za-z0-9_-]{16,64}$/;
-
-export type { ModelApiDeps } from './model-store.js';
-
-function runnerModel(cfg: ModelConfig): string | null {
-  const conn = routedConnection(cfg);
-  if (conn === null || conn.model === '') return null;
-  return conn.provider === 'anthropic' ? conn.model : `${conn.provider}:${conn.model}`;
-}
-
-function switchLive(before: ModelConfig, next: ModelConfig, deps: ModelApiDeps): void {
-  const [was, now] = [runnerModel(before), runnerModel(next)];
-  if (was === now) return;
-  if (deps.switchModel?.(now) === true) log.info({ was, now }, 'model-api: the model changed, so the Agent SDK session switches to it live, with no restart');
-  else if (runnerIsUp(deps)) throw new ApiError('The running Agent SDK could not be told about this model change. Nothing was saved. Let its work finish, stop it, then save and start it again.', 409);
-  else log.info({ was, now }, 'model-api: the model changed while no Agent SDK runner is up; its next start loads it');
-}
-
-function kept(store: Store, next: ModelConfig, deps: ModelApiDeps, note: string, fields: Record<string, unknown>): unknown {
-  const before = store.read();
-  store.write(next);
-  try {
-    switchLive(before, next, deps);
-  } catch (err) {
-    store.write(before);
-    throw err;
-  }
-  log.info(fields, note);
-  return settingsBody(next);
-}
-
-async function withBody(req: IncomingMessage, run: (body: Record<string, unknown>) => ModelConfig): Promise<ModelConfig> {
-  const body = await readJsonBody(req, BODY_MAX);
-  if (!isRecord(body)) throw new ApiError('body must be a JSON object', 400);
-  try {
-    return run(body);
-  } catch (err) {
-    return asApiError(err);
-  }
-}
-
-async function chooseRoute(req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<unknown> {
-  const next = await withBody(req, (body) => setRoute(store.read(), typeof body.route === 'string' ? body.route : ''));
-  return kept(store, next, deps, 'model-api: route changed', { route: next.route });
-}
-
-async function chooseFallbacks(req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<unknown> {
-  const next = await withBody(req, (body) => setFallbacks(store.read(), body.fallbacks));
-  return kept(store, next, deps, 'model-api: fallback models changed', { fallbacks: (next.fallbacks ?? []).map((f) => `${f.connection}:${f.model}`) });
-}
-
-async function create(req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<unknown> {
-  const next = await withBody(req, (body) => addConnection(store.read(), body));
-  return kept(store, next, deps, 'model-api: connection added', { connection: next.connections.at(-1)?.id ?? '' });
-}
-
-async function change(req: IncomingMessage, deps: ModelApiDeps, store: Store, id: string): Promise<unknown> {
-  const before = connectionOf(store.read(), id)?.apiKey;
-  const next = await withBody(req, (body) => updateConnection(store.read(), id, body));
-  if (connectionOf(next, id)?.apiKey !== before) forgetReported(id);
-  return kept(store, next, deps, 'model-api: connection changed', { connection: id });
-}
-
-function drop(deps: ModelApiDeps, store: Store, id: string): unknown {
-  const before = store.read();
-  let next: ModelConfig;
-  try {
-    next = removeConnection(before, id);
-  } catch (err) {
-    asApiError(err);
-  }
-  forgetOne(id);
-  const body = kept(store, next, deps, 'model-api: connection removed', { connection: id });
-  dropUnusedClaudeLogins(before, next, claudeLoginDeps(deps));
-  return body;
-}
-
-async function settingsWithUsage(deps: ModelApiDeps, store: Store): Promise<Record<string, unknown>> {
-  await refreshUsage(deps, store);
-  return settingsBody(store.read());
-}
-
-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(connectionFor(store.read(), req, 'anthropic'), deps.anthropicBase, deps.fetchImpl).catch(asApiError) }),
-  },
-};
-
-const BEDROCK_ROUTES: Record<string, Route> = {
-  models: {
-    method: 'GET',
-    run: async (req, deps, store) => ({ models: await bedrockModels(connectionFor(store.read(), req, '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 before = store.read();
-  const next = parseModelConfig(body);
-  const answer = kept(store, next, deps, 'model-api: model setup restored from a file', {});
-  dropUnusedClaudeLogins(before, next, claudeLoginDeps(deps));
-  return answer;
-}
-
-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(path: string, method: string | undefined): Route | number {
-  if (path === FALLBACKS) return method === 'PUT' ? { method: 'POST', run: chooseFallbacks } : 405;
-  if (method === 'GET') return { method: 'GET', run: (_req, deps, store) => settingsWithUsage(deps, store) };
-  if (method === 'PUT') return { method: 'POST', run: chooseRoute };
-  return 405;
-}
-
-function connectionsRoute(path: string, method: string | undefined): Route | number {
-  if (path === CONNECTIONS) return method === 'POST' ? { method: 'POST', run: create } : 405;
-  const id = path.slice(CONNECTIONS.length + 1);
-  if (id === '' || id.includes('/')) return 404;
-  if (method === 'PUT') return { method: 'POST', run: (req, deps, store) => change(req, deps, store, id) };
-  if (method === 'DELETE') return { method: 'GET', run: (_req, deps, store) => Promise.resolve(drop(deps, store, id)) };
-  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 codexDeviceRoute(id, method);
-}
-
-const TABLES: [string, Record<string, Route>][] = [
-  [OPENROUTER, OPENROUTER_ROUTES],
-  [ANTHROPIC, ANTHROPIC_ROUTES],
-  [BEDROCK, BEDROCK_ROUTES],
-  [GEMINI, GEMINI_ROUTES],
-];
-const EXACT = new Set([PATH, SNAPSHOT, FALLBACKS, BUNDLE, RESTORE, CONNECTIONS]);
-const PREFIXES = [`${CONNECTIONS}/`, CODEX, ...TABLES.map(([prefix]) => prefix)];
-
-const mine = (path: string): boolean => EXACT.has(path) || PREFIXES.some((prefix) => path.startsWith(prefix));
-
-function routeFor(path: string, method: string | undefined): Route | number {
-  if (path === SNAPSHOT) return method === 'GET' ? { method: 'GET', run: (_req, _deps, store) => Promise.resolve().then(() => settingsBody(store.read())).catch(asApiError) } : 405;
-  if (path === PATH || path === FALLBACKS) return settingsRoute(path, method);
-  if (path === BUNDLE || path === RESTORE) return bundleRoute(path, method);
-  if (path === CONNECTIONS || path.startsWith(`${CONNECTIONS}/`)) return connectionsRoute(path, method);
-  const table = TABLES.find(([prefix]) => path.startsWith(prefix));
-  if (table !== undefined) return named(table[1], path.slice(table[0].length), method);
-  return codexRoute(path.slice(CODEX.length), method);
-}
-
-const runnerIsUp = (deps: ModelApiDeps): boolean => (deps.runnerAlive ?? (() => runnerAlive()))();
-
-const storeFor = (path: string, deps: ModelApiDeps): Store => ({
-  read: deps.read ?? (path === SNAPSHOT ? readModelSnapshot : readModelConfig),
-  write: deps.write ?? writeModelConfig,
-});
+const SYNC = '/api/model/sync';
+const CLAUDE_MODELS = '/api/model/claude-models';
+const CLAUDE_LOGIN = '/api/model/claude/';
+const LOGIN_RE = /^[A-Za-z0-9_-]{11}$/;
+
+export interface ModelApiDeps extends UsageDeps {
+  dir?: () => string;
+  setup?: () => ModelSetup;
+  sync?: () => Promise<void>;
+  syncStatus?: () => SyncStatus;
+  anthropicBase?: string;
+}
+
+const NO_SYNC: SyncStatus = { enrolled: false, at: null, error: null };
+
+function publicConnection(c: Connection): Record<string, unknown> {
+  return {
+    id: c.id,
+    provider: c.provider,
+    label: c.label,
+    model: c.model,
+    hasKey: c.apiKey !== '',
+    region: c.region,
+    zdr: c.zdr,
+    signedIn: c.codex !== null || (c.claude !== null && !c.signedOut),
+    signedOut: c.signedOut,
+    account: c.account.email,
+    plan: c.account.plan,
+    method: c.account.method,
+  };
+}
+
+const loginsOf = (deps: ModelApiDeps): ClaudeLogin[] => readClaudeLogins(deps.dir?.() ?? agentsDir());
+const setupOf = (deps: ModelApiDeps): ModelSetup => (deps.setup ?? (() => effectiveSetup(deps.dir?.())))();
+
+export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
+  const setup = setupOf(deps);
+  const primary = primaryRoute(setup);
+  const reason = primary === null ? null : notReady(primary);
+  return {
+    source: setup.source,
+    sync: (deps.syncStatus ?? (() => orgModels()?.syncStatus() ?? NO_SYNC))(),
+    route: primary?.connection.id ?? '',
+    model: primary?.model ?? '',
+    ready: reason === null,
+    reason,
+    connections: setup.connections.map(publicConnection),
+    fallbacks: setup.fallbacks,
+    chain: chainStatus(setup),
+    claude: loginsOf(deps),
+    lastServed: lastServed(),
+    usage: usageSeen(),
+  };
+}
+
+async function withUsage(deps: ModelApiDeps): Promise<Record<string, unknown>> {
+  await refreshUsage(setupOf(deps), loginsOf(deps), deps);
+  return settingsBody(deps);
+}
+
+async function synced(deps: ModelApiDeps): Promise<Record<string, unknown>> {
+  await (deps.sync ?? (() => orgModels()?.requested() ?? Promise.resolve()))();
+  return settingsBody(deps);
+}
+
+function dropLogin(session: ApiSession, login: string, deps: ModelApiDeps): Record<string, unknown> {
+  requireAdmin(session);
+  removeClaudeLogin(login, { ...deps.claudeLogins, dir: deps.dir?.() ?? deps.claudeLogins?.dir });
+  return settingsBody(deps);
+}
+
+type Run = (session: ApiSession) => Promise<unknown>;
+
+function routeFor(path: string, method: string | undefined, deps: ModelApiDeps): Run | number {
+  const only = (wanted: string, run: Run): Run | number => (method === wanted ? run : 405);
+  if (path === PATH) return only('GET', () => withUsage(deps));
+  if (path === SNAPSHOT) return only('GET', () => Promise.resolve(settingsBody(deps)));
+  if (path === SYNC) return only('POST', () => synced(deps));
+  if (path === CLAUDE_MODELS) return only('GET', () => Promise.resolve({ models: claudeModels(deps.anthropicBase) }));
+  const login = path.slice(CLAUDE_LOGIN.length);
+  if (!LOGIN_RE.test(login)) return 404;
+  return only('DELETE', (session) => Promise.resolve(dropLogin(session, login, deps)));
+}
+
+const mine = (path: string): boolean => path === PATH || path.startsWith(`${PATH}/`);
 
 export function handleModelRequest(req: IncomingMessage, res: ServerResponse, deps: ModelApiDeps): boolean {
   const path = (req.url ?? '').split('?')[0] ?? '';
@@ -220,9 +108,7 @@ export function handleModelRequest(req: IncomingMessage, res: ServerResponse, de
     res.writeHead(204, cors(req)).end();
     return true;
   }
-  const store = storeFor(path, deps);
-  if (handleOpenRouterSignIn(req, res, deps, store)) return true;
-  const route = routeFor(path, req.method);
+  const route = path === PATH || path.startsWith(CLAUDE_LOGIN) || [SNAPSHOT, SYNC, CLAUDE_MODELS].includes(path) ? routeFor(path, req.method, deps) : 404;
   if (typeof route === 'number') {
     sendJson(req, res, route, { error: route === 404 ? 'not found' : 'method not allowed' });
     return true;
@@ -230,7 +116,7 @@ export function handleModelRequest(req: IncomingMessage, res: ServerResponse, de
   apiSession(req)
     .then(async (session) => {
       if (!session) throw new ApiError('unauthorized', 401);
-      sendJson(req, res, 200, await route.run(req, deps, store));
+      sendJson(req, res, 200, await route(session));
     })
     .catch((err: unknown) => {
       apiFailure(req, res, err, 'model-api');