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

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

@@ -0,0 +1,79 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { claudeLoginOf } from './claude-store.js';
+import { isProvider, LOCAL_PREFIX, loginConnection, sessionConnection, type Account, type CodexAccess, type Connection, type Fallback, type ModelSetup, type Provider } from './model-config.js';
+
+const MAX_CONNECTIONS = 20;
+const MAX_FALLBACKS = 8;
+const NEW_CLIENT = 'dynamic_agent_client';
+const NO_ACCOUNT: Account = { email: null, plan: null, method: null };
+
+type Row = Record<string, unknown>;
+
+const text = (value: unknown): string => (typeof value === 'string' ? value.trim() : '');
+const maybe = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
+
+const expiryOf = (value: unknown): number => (typeof value === 'number' && Number.isFinite(value) ? value : 0);
+
+function codexOf(raw: unknown): CodexAccess | null {
+  if (!isRecord(raw) || text(raw.accessToken) === '' || text(raw.refreshToken) === '') return null;
+  const accountId = maybe(text(raw.accountId));
+  const clientId = text(raw.clientId);
+  if (accountId === null && (clientId === '' || clientId === NEW_CLIENT)) return null;
+  return { method: accountId === null ? 'chatgpt' : 'code', accessToken: text(raw.accessToken), expiresAt: expiryOf(raw.expiresAt), accountId };
+}
+
+function accountOf(raw: unknown, codex: CodexAccess | null): Account {
+  if (codex === null || !isRecord(raw)) return NO_ACCOUNT;
+  return { email: maybe(raw.email), plan: codex.method === 'code' ? maybe(raw.plan) : null, method: codex.method };
+}
+
+function ownConnection(row: Row, id: string, provider: Provider): Connection {
+  const codex = provider === 'codex' ? codexOf(row.codex) : null;
+  const apiKey = provider === 'codex' ? '' : text(row.apiKey);
+  const label = text(row.label);
+  return {
+    id,
+    provider,
+    label: label === '' ? provider : label,
+    model: text(row.model),
+    apiKey,
+    region: text(row.region),
+    zdr: row.zdr === true,
+    revision: 0,
+    codex,
+    claude: null,
+    account: accountOf(row.codex, codex),
+    signedOut: codex === null && apiKey === '',
+  };
+}
+
+function connectionOf(row: Row): Connection | null {
+  const id = text(row.id);
+  if (id === '' || id.startsWith(LOCAL_PREFIX) || !isProvider(row.provider)) return null;
+  if (row.provider !== 'anthropic' || text(row.apiKey) !== '') return ownConnection(row, id, row.provider);
+  const login = claudeLoginOf(row.claude);
+  return login === null ? sessionConnection() : loginConnection(login.id, login);
+}
+
+function fallbacksOf(raw: unknown, linked: Map<string, Connection>): Fallback[] {
+  if (!Array.isArray(raw)) return [];
+  const known = raw.flatMap((f: unknown) => {
+    const conn = isRecord(f) ? linked.get(text(f.connection)) : undefined;
+    const model = isRecord(f) ? text(f.model) : '';
+    return conn === undefined || model === '' ? [] : [{ connection: conn.id, model }];
+  });
+  return known.filter((f, at) => known.findIndex((o) => o.connection === f.connection && o.model === f.model) === at).slice(0, MAX_FALLBACKS);
+}
+
+export function v2Setup(raw: Row & { connections: unknown[] }): ModelSetup {
+  const rows = raw.connections.filter((c): c is Row => isRecord(c) && (isProvider(c.provider) || c.provider === 'gemini')).slice(0, MAX_CONNECTIONS);
+  const linked = new Map(rows.flatMap((row) => {
+    const conn = connectionOf(row);
+    return conn === null ? [] : [[text(row.id), conn] as const];
+  }));
+  const routed = rows.find((row) => text(row.id) === text(raw.route)) ?? rows[0];
+  const head = routed === undefined ? undefined : linked.get(text(routed.id));
+  const primary = routed === undefined || head === undefined ? null : { connection: head.id, model: text(routed.model) };
+  const connections = [...linked.values()].filter((c, at, all) => all.findIndex((o) => o.id === c.id) === at);
+  return { primary, fallbacks: fallbacksOf(raw.fallbacks, linked), connections, source: null };
+}

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

@@ -1,76 +1,10 @@
 import { isRecord } from '@metro-labs/core/is-record';
 import { GatewayError } from './forward.js';
-import { listCache } from './model-lists.js';
-import { stringOf } from '@metro-labs/http/api-http';
 import type { KeySpend } from './usage.js';
 
 export const OPENROUTER_BASE = 'https://openrouter.ai/api';
-const MODELS_MAX = 2000;
 const KEY_TIMEOUT_MS = 10_000;
 
-export interface OpenRouterModel {
-  id: string;
-  name: string;
-  prompt: number | null;
-  completion: number | null;
-  created: number | null;
-}
-
-const modelLists = listCache<OpenRouterModel>('openrouter');
-const zdrLists = listCache<string>('openrouter-zdr');
-
-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;
-}
-
-const strings = (value: unknown): string[] | null => (Array.isArray(value) ? value.filter((v): v is string => typeof v === 'string') : null);
-
-function chatCapable(entry: Record<string, unknown>): boolean {
-  const output = strings(isRecord(entry.architecture) ? entry.architecture.output_modalities : undefined);
-  const params = strings(entry.supported_parameters);
-  return (output === null || output.includes('text')) && (params === null || params.includes('tools'));
-}
-
-function modelOf(entry: unknown): OpenRouterModel | null {
-  if (!isRecord(entry) || !chatCapable(entry)) return null;
-  const id = stringOf(entry.id);
-  if (id === '') return null;
-  const pricing = isRecord(entry.pricing) ? entry.pricing : {};
-  return {
-    id,
-    name: stringOf(entry.name) || id,
-    prompt: price(pricing.prompt),
-    completion: price(pricing.completion),
-    created: released(entry.created),
-  };
-}
-
-function newestFirst(a: OpenRouterModel, b: OpenRouterModel): number {
-  const when = (b.created ?? 0) - (a.created ?? 0);
-  return when !== 0 ? when : a.id.localeCompare(b.id);
-}
-
-async function listModels(base: string, fetchImpl: typeof 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 const openrouterModels = (base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<OpenRouterModel[]> =>
-  modelLists.get(base, () => listModels(base, fetchImpl));
-
 const nullableAmount = (raw: unknown): number | null => (typeof raw === 'number' && Number.isFinite(raw) ? raw : null);
 
 export async function openrouterKey(apiKey: string, base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<KeySpend> {
@@ -89,16 +23,3 @@ export async function openrouterKey(apiKey: string, base = OPENROUTER_BASE, fetc
   if (spent === null) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no spend for the key');
   return { limit: nullableAmount(data.limit), remaining: nullableAmount(data.limit_remaining), spent };
 }
-
-async function listZdr(base: string, fetchImpl: typeof 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) && stringOf(entry.model_id) !== '') ids.add(stringOf(entry.model_id));
-  return [...ids].sort();
-}
-
-export const openrouterZdrModels = (base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<string[]> => zdrLists.get(base, () => listZdr(base, fetchImpl));

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

@@ -0,0 +1,231 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import type { AgentKey } from '../connectors/agent-key.js';
+import { agentCall, MetroApiRefusal, type MetroApi } from '../connectors/metro-api.js';
+import { deliveredOf, refreshedConnection, type Delivered } from './delivered.js';
+import { importModelFile, settleModelFile, type Moved } from './model-import.js';
+import type { Connection } from './model-config.js';
+
+const MODELS_PATH = '/api/agents/models';
+const REFRESH_PATH = '/api/agents/models/refresh';
+const SYNC_MS = 60_000;
+const PAGE_SYNC_MS = 5_000;
+const AGENT_KEY_MISSING = 'agent_key_missing';
+
+export interface OrgModelsDeps {
+  owner: () => string | null;
+  key: () => AgentKey | null;
+  api: MetroApi;
+  dir: () => string;
+  pageSyncMs?: number;
+}
+
+export interface SyncStatus {
+  enrolled: boolean;
+  at: string | null;
+  error: string | null;
+}
+
+const identityRefused = (err: unknown): boolean => err instanceof MetroApiRefusal && err.upstreamStatus === 401 && err.code === AGENT_KEY_MISSING;
+
+const unrenewed = new Set<string>();
+
+function noteUnrenewed(conn: Connection): void {
+  if (unrenewed.has(conn.id)) return;
+  unrenewed.add(conn.id);
+  log.warn({ connection: conn.id }, 'org-models: a Codex sign-in still read from model.json is not renewed on this box; api.metro.box renews it once the box moved its model setup to the organization');
+}
+
+export class OrgModels {
+  private kept: Delivered | null = null;
+  private status: SyncStatus = { enrolled: false, at: null, error: null };
+  private running: Promise<void> | null = null;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private trailing: ReturnType<typeof setTimeout> | null = null;
+  private pageAt = Number.NEGATIVE_INFINITY;
+  private readonly refreshing = new Map<string, Promise<Connection | null>>();
+  private readonly listeners = new Set<() => void>();
+
+  constructor(private readonly deps: OrgModelsDeps) {}
+
+  current(): Delivered | null {
+    return this.kept;
+  }
+
+  syncStatus(): SyncStatus {
+    return { ...this.status };
+  }
+
+  onChange(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  sync(): Promise<void> {
+    this.running ??= this.run().finally(() => {
+      this.running = null;
+    });
+    return this.running;
+  }
+
+  requested(): Promise<void> {
+    const now = this.deps.api.now();
+    const wait = this.pageAt + (this.deps.pageSyncMs ?? PAGE_SYNC_MS) - now;
+    if (wait <= 0) {
+      this.pageAt = now;
+      return this.sync();
+    }
+    this.trailing ??= this.later(wait);
+    return this.running ?? Promise.resolve();
+  }
+
+  start(everyMs = SYNC_MS): void {
+    if (this.timer !== null) return;
+    const tick = (): void => {
+      this.sync().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'org-models: the model setup could not be read');
+      });
+    };
+    tick();
+    this.timer = setInterval(tick, everyMs);
+    this.timer.unref();
+  }
+
+  stop(): void {
+    if (this.timer !== null) clearInterval(this.timer);
+    if (this.trailing !== null) clearTimeout(this.trailing);
+    this.timer = null;
+    this.trailing = null;
+  }
+
+  refresh(conn: Connection): Promise<Connection | null> {
+    if (conn.revision < 1) {
+      noteUnrenewed(conn);
+      return Promise.resolve(null);
+    }
+    const newer = this.kept?.connections.find((c) => c.id === conn.id && c.revision > conn.revision);
+    if (newer !== undefined) return Promise.resolve(newer);
+    const slot = `${conn.id}\n${String(conn.revision)}`;
+    const found = this.refreshing.get(slot);
+    if (found !== undefined) return found;
+    const run = this.askRefresh(conn).finally(() => {
+      this.refreshing.delete(slot);
+    });
+    this.refreshing.set(slot, run);
+    return run;
+  }
+
+  private later(wait: number): ReturnType<typeof setTimeout> {
+    const timer = setTimeout(() => {
+      this.trailing = null;
+      this.requested().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'org-models: the model setup could not be read');
+      });
+    }, wait);
+    timer.unref();
+    return timer;
+  }
+
+  private enrolledKey(): AgentKey | null {
+    try {
+      const key = this.deps.key();
+      const owner = this.deps.owner();
+      return key !== null && owner !== null && key.enrollment?.organization === owner ? key : null;
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'org-models: the agent key could not be read');
+      return null;
+    }
+  }
+
+  private keep(next: Delivered | null): void {
+    const changed = JSON.stringify(next) !== JSON.stringify(this.kept);
+    this.kept = next;
+    if (changed) this.notify();
+  }
+
+  private notify(): void {
+    for (const listener of [...this.listeners])
+      try {
+        listener();
+      } catch (err) {
+        log.warn({ err: errMsg(err) }, 'org-models: a model change listener failed');
+      }
+  }
+
+  private failed(error: string, clear: boolean): void {
+    if (this.status.error !== error) log.warn({ err: error, kept: !clear && this.kept !== null }, clear ? 'org-models: api.metro.box no longer knows this agent key, so the model setup is cleared' : 'org-models: api.metro.box did not deliver the model setup, so the last one stands');
+    this.status = { ...this.status, error };
+    if (clear) this.keep(null);
+  }
+
+  private async run(): Promise<void> {
+    const key = this.enrolledKey();
+    if (key === null) {
+      this.status = { enrolled: false, at: null, error: null };
+      this.keep(null);
+      return;
+    }
+    this.status = { ...this.status, enrolled: true };
+    const moved = await importModelFile(this.deps.api, key, this.deps.dir()).catch((err: unknown) => {
+      log.warn({ err: errMsg(err) }, 'org-models: model.json could not be read for the move to the organization');
+      return null;
+    });
+    try {
+      const delivered = deliveredOf(await agentCall(this.deps.api, key, MODELS_PATH, {}));
+      if (delivered === null) {
+        this.failed('api.metro.box sent a model setup Metro cannot read', false);
+        return;
+      }
+      if (this.status.error !== null) log.info('org-models: the model setup is read from api.metro.box again');
+      this.status = { enrolled: true, at: new Date(this.deps.api.now()).toISOString(), error: null };
+      this.keep(delivered);
+    } catch (err) {
+      this.failed(errMsg(err), identityRefused(err));
+      return;
+    }
+    if (moved !== null) this.settle(moved);
+  }
+
+  private settle(moved: Moved): void {
+    try {
+      if (settleModelFile(this.deps.dir(), moved)) this.notify();
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'org-models: model.json could not be rewritten after the move to the organization');
+    }
+  }
+
+  private async askRefresh(conn: Connection): Promise<Connection | null> {
+    const key = this.enrolledKey();
+    if (key === null) return null;
+    try {
+      const fresh = refreshedConnection(await agentCall(this.deps.api, key, REFRESH_PATH, { connection: conn.id, revision: conn.revision }));
+      if (fresh?.id !== conn.id) throw new Error('api.metro.box answered the refresh with another connection');
+      const kept = this.kept;
+      if (kept !== null) this.keep({ ...kept, connections: kept.connections.map((c) => (c.id === fresh.id ? fresh : c)) });
+      log.info({ connection: conn.id, revision: fresh.revision }, 'org-models: api.metro.box renewed the sign-in of a connection');
+      return fresh;
+    } catch (err) {
+      log.warn({ connection: conn.id, err: errMsg(err) }, 'org-models: api.metro.box could not renew the sign-in of a connection');
+      return null;
+    }
+  }
+}
+
+let shared: OrgModels | null = null;
+
+export const orgModels = (): OrgModels | null => shared;
+
+export const deliveredSetup = (): Delivered | null => shared?.current() ?? null;
+
+export function startOrgModels(deps: OrgModelsDeps, everyMs = SYNC_MS): OrgModels {
+  shared?.stop();
+  shared = new OrgModels(deps);
+  shared.start(everyMs);
+  log.info('org-models: the model setup comes from the organization on api.metro.box once the agent is enrolled');
+  return shared;
+}
+
+export function stopOrgModels(): void {
+  shared?.stop();
+}

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

@@ -1,8 +1,7 @@
 import type { IncomingHttpHeaders } from 'node:http';
 import { isRecord } from '@metro-labs/core/is-record';
 import { GatewayError, OAUTH_BETA } from './forward.js';
-import type { Connection } from './model-config.js';
-import { fingerprint, listCache } from './model-lists.js';
+import { listCache } from './model-lists.js';
 import { stringOf } from '@metro-labs/http/api-http';
 
 export const ANTHROPIC_API = 'https://api.anthropic.com';
@@ -30,7 +29,6 @@ const KNOWN_CLAUDE: ProviderModel[] = [
 ];
 
 const claudeLists = listCache<ProviderModel>('anthropic');
-const bedrockLists = listCache<ProviderModel>('bedrock');
 
 const newestFirst = (list: Dated[]): ProviderModel[] =>
   list.sort((a, b) => b.created.localeCompare(a.created) || a.id.localeCompare(b.id)).map(({ id, name }) => ({ id, name }));
@@ -73,45 +71,7 @@ export function refreshLoginModels(headers: IncomingHttpHeaders, base = ANTHROPI
   return claudeLists.refresh(loginKey(base), () => listClaude(auth, 'the Claude Code login', base, fetchImpl));
 }
 
-export async function anthropicModels(settings: Connection, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
-  if (settings.apiKey === '') {
-    const live = claudeLists.peek(loginKey(base)) ?? [];
-    return live.length > 0 ? live : KNOWN_CLAUDE;
-  }
-  return claudeLists.get(`key:${base}:${fingerprint(settings.apiKey)}`, () => listClaude({ 'x-api-key': settings.apiKey }, 'the stored key', base, fetchImpl));
-}
-
-export const bedrockControlBase = (region: string): string => `https://bedrock.${region}.amazonaws.com`;
-
-function bedrockEntry(entry: unknown): Dated[] {
-  if (!isRecord(entry)) return [];
-  const id = stringOf(entry.inferenceProfileId);
-  const status = stringOf(entry.status);
-  if (id === '' || !id.includes('anthropic') || (status !== '' && status !== 'ACTIVE')) return [];
-  return [{ id, name: stringOf(entry.inferenceProfileName) || id, created: stringOf(entry.createdAt) }];
-}
-
-async function listBedrock(settings: Connection, base: string, fetchImpl: typeof fetch): Promise<ProviderModel[]> {
-  const res = await fetchImpl(`${base}/inference-profiles?maxResults=${String(LIST_MAX)}`, {
-    headers: { authorization: `Bearer ${settings.apiKey}`, accept: 'application/json' },
-    redirect: 'manual',
-    signal: AbortSignal.timeout(LIST_TIMEOUT_MS),
-  });
-  if (!res.ok)
-    throw new GatewayError(
-      res.status,
-      'api_error',
-      `Bedrock would not list its inference profiles (${String(res.status)}); the stored key may cover the runtime only, so type the model id instead`,
-    );
-  const body: unknown = await res.json();
-  const list = isRecord(body) && Array.isArray(body.inferenceProfileSummaries) ? body.inferenceProfileSummaries : null;
-  if (list === null) throw new GatewayError(502, 'api_error', 'Bedrock answered with no inference profile list');
-  return newestFirst(list.flatMap(bedrockEntry));
-}
-
-export async function bedrockModels(settings: Connection, base?: string, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
-  if (settings.region === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs a region before its models can be listed');
-  if (settings.apiKey === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key before its models can be listed');
-  const from = base ?? bedrockControlBase(settings.region);
-  return bedrockLists.get(`${from}:${fingerprint(settings.apiKey)}`, () => listBedrock(settings, from, fetchImpl));
+export function claudeModels(base = ANTHROPIC_API): ProviderModel[] {
+  const live = claudeLists.peek(loginKey(base)) ?? [];
+  return live.length > 0 ? live : KNOWN_CLAUDE;
 }

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

@@ -4,8 +4,6 @@ import { stringOf } from '@metro-labs/http/api-http';
 const IMAGE_NOTE = '[an image was attached here; this model cannot see it]';
 export const TOOL_ERROR = '[tool error]';
 
-export const nonEmpty = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
-
 export interface InlineImage {
   mediaType: string;
   data: string;

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

@@ -1,16 +1,23 @@
 import { errMsg, log } from '@metro-labs/core/log';
 import { readClaudeUsage } from '../claude/usage-probe.js';
 import { openrouterKey } from './openrouter.js';
-import { lastServed } from './served.js';
-import { claudeLoginUsage, geminiUsage, keepProbeAnswer, mayProbe, mergeUsage, noteUsage, openrouterUsage, probeAnswer, usageOf } from './usage.js';
-import { PASSTHROUGH_ID, readModelConfig, routedConnection, writeModelConfig, type Connection, type ModelConfig } from './model-config.js';
-import { geminiModelsOf } from './model-signin.js';
-import { claudeLoginDeps, CREDITS_TTL_MS, type ModelApiDeps, type Store } from './model-store.js';
-import { probeClaudeLogin } from './claude-logins.js';
+import { claudeLoginUsage, keepProbeAnswer, mayProbe, mergeUsage, noteUsage, openrouterUsage, probeAnswer, usageOf } from './usage.js';
+import { loginRef, primaryRoute, SESSION_LOGIN, type Connection, type ModelSetup } from './model-config.js';
+import { probeClaudeLogin, type ClaudeLoginDeps } from './claude-logins.js';
+import type { ClaudeLogin } from './claude-store.js';
 
+export const CREDITS_TTL_MS = 5 * 60_000;
 const WAIT_MS = 4_000;
 const LOGIN_PROBE = 'claude-login';
 
+export interface UsageDeps {
+  fetchImpl?: typeof fetch;
+  openrouterBase?: string;
+  claudeUsage?: (env?: Record<string, string>) => Promise<unknown>;
+  claudeLogins?: ClaudeLoginDeps;
+  usageWaitMs?: number;
+}
+
 const fresh = (id: string, now: number): boolean => {
   const seen = usageOf(id);
   return seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS;
@@ -26,66 +33,35 @@ async function probe(what: string, run: () => Promise<void>): Promise<void> {
   }
 }
 
-async function refreshKey(conn: Connection, deps: ModelApiDeps, now: number): Promise<void> {
-  if (conn.apiKey === '' || !due(conn.id, now)) return;
+async function refreshKey(conn: Connection, deps: UsageDeps, now: number): Promise<void> {
+  if (conn.provider !== 'openrouter' || conn.apiKey === '' || !due(conn.id, now)) return;
   await probe('OpenRouter key spend', async () => {
     noteUsage(conn.id, openrouterUsage(await openrouterKey(conn.apiKey, deps.openrouterBase, deps.fetchImpl), new Date(now)));
   });
 }
 
-const modelsInUse = (conn: Connection, cfg: ModelConfig): Set<string> => {
-  const served = lastServed();
-  const fallbacks = (cfg.fallbacks ?? []).filter((f) => f.connection === conn.id).map((f) => f.model);
-  return new Set([conn.model, served?.connection === conn.id ? served.model : '', ...fallbacks].filter((m) => m !== ''));
-};
-
-async function refreshQuota(conn: Connection, deps: ModelApiDeps, store: Store, now: number): Promise<void> {
-  if (conn.gemini === null) return;
-  const inUse = modelsInUse(conn, store.read());
-  const seen = usageOf(conn.id);
-  const covers = seen !== undefined && [...inUse].every((id) => seen.windows.some((w) => w.label === id));
-  if (seen !== undefined && covers && now - Date.parse(seen.at) < CREDITS_TTL_MS) return;
-  await probe('Gemini quota', async () => {
-    const rows = (await geminiModelsOf(conn, deps, store)).filter((m) => inUse.has(m.id));
-    const usage = geminiUsage(rows, new Date(now));
-    if (usage !== null) noteUsage(conn.id, usage);
-  });
-}
+const hasFallbacks = (setup: ModelSetup): boolean => setup.fallbacks.length > 0;
 
-const loginIds = (cfg: ModelConfig): string[] => [
-  ...(routedConnection(cfg) === null ? [PASSTHROUGH_ID] : []),
-  ...cfg.connections.filter((c) => c.provider === 'anthropic' && c.apiKey === '' && c.claude === null).map((c) => c.id),
-];
-
-const hasFallbacks = (cfg: ModelConfig): boolean => (cfg.fallbacks ?? []).length > 0;
-
-async function refreshOwnLogin(conn: Connection, cfg: ModelConfig, deps: ModelApiDeps, now: number): Promise<void> {
-  const login = conn.apiKey === '' ? conn.claude : null;
-  if (login === null || (fresh(conn.id, now) && !hasFallbacks(cfg)) || !mayProbe(conn.id, now, CREDITS_TTL_MS)) return;
+async function refreshOwnLogin(login: string, setup: ModelSetup, deps: UsageDeps, now: number): Promise<void> {
+  const key = loginRef(login);
+  if ((fresh(key, now) && !hasFallbacks(setup)) || !mayProbe(key, now, CREDITS_TTL_MS)) return;
   await probe('usage of a Claude login', async () => {
-    const usage = claudeLoginUsage(await probeClaudeLogin(login.id, claudeLoginDeps(deps)), new Date(now));
-    if (usage !== null) mergeUsage(conn.id, usage);
+    const usage = claudeLoginUsage(await probeClaudeLogin(login, deps.claudeLogins), new Date(now));
+    if (usage !== null) mergeUsage(key, usage);
   });
 }
 
-async function refreshLogin(cfg: ModelConfig, deps: ModelApiDeps, now: number): Promise<void> {
-  const ids = loginIds(cfg);
-  if (!ids.some((id) => !fresh(id, now)) && !(hasFallbacks(cfg) && ids.length > 0)) return;
+const ridesSession = (setup: ModelSetup): boolean => primaryRoute(setup) === null || setup.connections.some((c) => c.id === SESSION_LOGIN);
+
+async function refreshSession(setup: ModelSetup, deps: UsageDeps, now: number): Promise<void> {
+  if (!ridesSession(setup) || (fresh(SESSION_LOGIN, now) && !hasFallbacks(setup))) return;
   if (mayProbe(LOGIN_PROBE, now, CREDITS_TTL_MS))
     await probe('usage of the Claude Code login', async () => {
       const usage = claudeLoginUsage(await (deps.claudeUsage ?? (() => readClaudeUsage()))(), new Date(now));
       if (usage !== null) keepProbeAnswer(LOGIN_PROBE, usage);
     });
   const usage = probeAnswer(LOGIN_PROBE);
-  if (usage === undefined || now - Date.parse(usage.at) >= CREDITS_TTL_MS) return;
-  for (const id of ids) mergeUsage(id, usage);
-}
-
-function refreshOne(conn: Connection, cfg: ModelConfig, deps: ModelApiDeps, store: Store, now: number): Promise<void> {
-  if (conn.provider === 'openrouter') return refreshKey(conn, deps, now);
-  if (conn.provider === 'gemini') return refreshQuota(conn, deps, store, now);
-  if (conn.provider === 'anthropic') return refreshOwnLogin(conn, cfg, deps, now);
-  return Promise.resolve();
+  if (usage !== undefined && now - Date.parse(usage.at) < CREDITS_TTL_MS) mergeUsage(SESSION_LOGIN, usage);
 }
 
 async function within(ms: number, work: Promise<unknown>): Promise<void> {
@@ -97,17 +73,21 @@ async function within(ms: number, work: Promise<unknown>): Promise<void> {
   clearTimeout(timer);
 }
 
-export async function refreshUsage(deps: ModelApiDeps, store: Store, now = Date.now()): Promise<void> {
-  const cfg = store.read();
-  const work = Promise.all([...cfg.connections.map((conn) => refreshOne(conn, cfg, deps, store, now)), refreshLogin(cfg, deps, now)]);
+export async function refreshUsage(setup: ModelSetup, logins: ClaudeLogin[], deps: UsageDeps = {}, now = Date.now()): Promise<void> {
+  const own = new Set([...logins.map((l) => l.id), ...setup.connections.flatMap((c) => (c.claude === null || c.signedOut ? [] : [c.claude]))]);
+  const work = Promise.all([
+    ...setup.connections.map((conn) => refreshKey(conn, deps, now)),
+    ...[...own].map((login) => refreshOwnLogin(login, setup, deps, now)),
+    refreshSession(setup, deps, now),
+  ]);
   await within(deps.usageWaitMs ?? WAIT_MS, work);
 }
 
-export function watchFallbackUsage(deps: ModelApiDeps = {}, every = CREDITS_TTL_MS): void {
-  const store: Store = { read: deps.read ?? readModelConfig, write: deps.write ?? writeModelConfig };
+export function watchFallbackUsage(setup: () => ModelSetup, logins: () => ClaudeLogin[], deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
   const run = (): void => {
-    if (!hasFallbacks(store.read())) return;
-    refreshUsage(deps, store).catch((err: unknown) => {
+    const current = setup();
+    if (!hasFallbacks(current)) return;
+    refreshUsage(current, logins(), deps).catch((err: unknown) => {
       log.warn({ err: errMsg(err) }, 'model-api: could not refresh the usage of the fallback models');
     });
   };

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

@@ -315,19 +315,6 @@ export function noteUsageHeaders(kind: 'anthropic' | 'codex', key: Key, headers:
 
 const dollars = (value: number): string => `$${value.toFixed(2)}`;
 
-export interface QuotaRow {
-  id: string;
-  remaining: number | null;
-  resetAt: string | null;
-}
-
-export function geminiUsage(rows: QuotaRow[], now = new Date()): Reported | null {
-  const windows: UsageWindow[] = rows
-    .filter((row) => row.remaining !== null)
-    .map((row) => ({ label: row.id, used: clamp(1 - (row.remaining ?? 0)), resetAt: row.resetAt, detail: null }));
-  return windows.length === 0 ? null : { windows, note: null, at: now.toISOString() };
-}
-
 export interface KeySpend {
   limit: number | null;
   remaining: number | null;

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

@@ -23,7 +23,7 @@ import {
   localOwner,
   readLocalAgentFile,
 } from '../agents/file-admin.js';
-import { readModelConfig } from '../gateway/model-config.js';
+import { effectiveSetup } from '../gateway/effective.js';
 import type { StationName } from '@metro-labs/core/station-names';
 
 export interface LocalModeDeps {
@@ -36,7 +36,6 @@ export interface LocalModeDeps {
   toolGroups?: AgentApiDeps['toolGroups'];
   prepareAccount: AccountApiDeps['prepareAccount'];
   liveEvents?: (on: boolean) => void;
-  switchModel?: (model: string | null) => boolean;
 }
 
 function attachSessions(deps: LocalModeDeps): AttachSessions {
@@ -142,8 +141,8 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     controlApi: { restart: deps.restart, stop: deps.stop },
     ownerApi: { setOwner: setLocalOwner },
     machineApi: {},
-    modelApi: { switchModel: deps.switchModel, owner: localOwner },
-    gateway: { config: readModelConfig },
+    modelApi: {},
+    gateway: { setup: () => effectiveSetup() },
     terminalApi: {},
     mode: localModeInfo,
   };