@stage-labs/metro 0.1.0-beta.323 → 0.1.0-beta.325

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.323",
+  "version": "0.1.0-beta.325",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

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

@@ -58,9 +58,8 @@ import type { StationName } from '@metro-labs/core/station-names';
 import { startUploadReaper } from '../files/upload-store.js';
 import { startAttachReaper } from '../files/attach-reaper.js';
 import { startCloudWatchPublisher } from '../server/cloudwatch.js';
-import { watchFallbackUsage } from '@metro-labs/inference/usage-refresh';
 import { startOrgModels, stopOrgModels } from '../gateway/org-models.js';
-import { effectiveSetup, watchModelChanges } from '../gateway/effective.js';
+import { watchModelChanges } from '../gateway/effective.js';
 import { removeModelLeftovers } from '../gateway/model-leftovers.js';
 import { readAgentKey } from '../connectors/agent-key.js';
 import { METRO_API } from '../connectors/metro-api.js';
@@ -180,7 +179,6 @@ installBearerSessions(agentsDir(), localOwner);
   });
   watchConnectorTools();
   startCloudWatchPublisher();
-  watchFallbackUsage(() => effectiveSetup());
   announceLocalEndpoint();
   tunnel?.start();
   log.info(

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

@@ -11,12 +11,11 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { readJson, writeJson } from '@metro-labs/core/secure-fs';
 import { METRO_VERSION } from '@metro-labs/core/version';
 import { agentsDir, listAgentFiles } from '../agents/files.js';
-import { primaryRoute, type ModelSetup } from '@metro-labs/inference/model-config';
+import { primaryRoute, setupNotReady, type ModelSetup } from '@metro-labs/inference/model-config';
 import { effectiveSetup } from '../gateway/effective.js';
 import { inSessionScope } from './memory.js';
 import { runningAsRoot } from '../metro-user/privilege.js';
 import { agentUser, agentUserExpected, agentViewDir, asAgent, claudeHome } from '../agent-user/user.js';
-import { routeReadiness } from '../gateway/box-gateway.js';
 
 function sessionEnv(): Record<string, string> {
   const user = agentUser();
@@ -134,7 +133,7 @@ const NO_MODEL = "the organization routes this agent to no model yet: choose one
 function credentialReady(deps: SessionDeps): string | null {
   try {
     const primary = primaryRoute((deps.model ?? (() => effectiveSetup()))());
-    return primary === null ? NO_MODEL : routeReadiness(primary);
+    return primary === null ? NO_MODEL : setupNotReady(primary);
   } catch (err) {
     return `the model setup is not readable (${errMsg(err)})`;
   }

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

@@ -4,18 +4,14 @@ import { ApiError } from '@metro-labs/http/api-error';
 import { apiFailure, apiSession, cors, sendJson } from '@metro-labs/http/api-http';
 import { effectiveSetup } from './effective.js';
 import { chainStatus } from '@metro-labs/inference/fallback';
-import { helperSetup, primaryRoute, type Connection, type ModelSetup } from '@metro-labs/inference/model-config';
-import { routeReadiness } from './box-gateway.js';
+import { helperSetup, primaryRoute, setupNotReady, type Connection, type ModelSetup } from '@metro-labs/inference/model-config';
 import { orgModels, type SyncStatus } from './org-models.js';
-import { lastServed } from '@metro-labs/inference/served';
-import { refreshUsage, type UsageDeps } from '@metro-labs/inference/usage-refresh';
-import { usageSeen } from '@metro-labs/inference/usage';
 
 const PATH = '/api/model';
 const SNAPSHOT = '/api/model/snapshot';
 const SYNC = '/api/model/sync';
 
-export interface ModelApiDeps extends UsageDeps {
+export interface ModelApiDeps {
   setup?: () => ModelSetup;
   sync?: () => Promise<void>;
   syncStatus?: () => SyncStatus;
@@ -47,13 +43,13 @@ function helpersBody(setup: ModelSetup): Record<string, unknown> | null {
   const helpers = helperSetup(setup);
   if (helpers === null) return null;
   const primary = primaryRoute(helpers);
-  return { route: primary?.connection.id ?? '', model: primary?.model ?? '', fallbacks: helpers.fallbacks, chain: chainStatus(helpers) };
+  return { route: primary?.connection.id ?? '', model: primary?.model ?? '', fallbacks: helpers.fallbacks, chain: chainStatus(helpers, Date.now(), setupNotReady) };
 }
 
 export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
   const setup = setupOf(deps);
   const primary = primaryRoute(setup);
-  const reason = primary === null ? NO_MODEL : routeReadiness(primary);
+  const reason = primary === null ? NO_MODEL : setupNotReady(primary);
   return {
     source: setup.source,
     sync: (deps.syncStatus ?? (() => orgModels()?.syncStatus() ?? NO_SYNC))(),
@@ -63,19 +59,12 @@ export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
     reason,
     connections: setup.connections.map(publicConnection),
     fallbacks: setup.fallbacks,
-    chain: chainStatus(setup),
+    chain: chainStatus(setup, Date.now(), setupNotReady),
     helpers: helpersBody(setup),
     effort: { ...EFFORT_DEFAULTS, ...setup.effort },
-    lastServed: lastServed(),
-    usage: usageSeen(),
   };
 }
 
-async function withUsage(deps: ModelApiDeps): Promise<Record<string, unknown>> {
-  await refreshUsage(setupOf(deps), deps);
-  return settingsBody(deps);
-}
-
 async function synced(deps: ModelApiDeps): Promise<Record<string, unknown>> {
   await (deps.sync ?? (() => orgModels()?.requested() ?? Promise.resolve()))();
   return settingsBody(deps);
@@ -84,7 +73,7 @@ async function synced(deps: ModelApiDeps): Promise<Record<string, unknown>> {
 type Run = () => Promise<unknown>;
 
 const ROUTES: Record<string, [string, (deps: ModelApiDeps) => Promise<unknown>]> = {
-  [PATH]: ['GET', withUsage],
+  [PATH]: ['GET', (deps) => Promise.resolve(settingsBody(deps))],
   [SNAPSHOT]: ['GET', (deps) => Promise.resolve(settingsBody(deps))],
   [SYNC]: ['POST', synced],
 };

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

@@ -1,11 +1,9 @@
 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 '@metro-labs/inference/delivered';
-import type { Connection } from '@metro-labs/inference/model-config';
+import { deliveredOf, type Delivered } from '@metro-labs/inference/delivered';
 
 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';
@@ -32,7 +30,6 @@ export class OrgModels {
   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) {}
@@ -89,19 +86,6 @@ export class OrgModels {
     this.trailing = null;
   }
 
-  refresh(conn: Connection): Promise<Connection | 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;
@@ -166,22 +150,6 @@ export class OrgModels {
       this.failed(errMsg(err), identityRefused(err));
     }
   }
-
-  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;

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

@@ -2,7 +2,11 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from '@metro-labs/core/log';
 import { cameThroughProxy } from '@metro-labs/http/api-http';
 import { forwardedHeaders, pipeResponse, readBody, sendError, watchUpstream } from '@metro-labs/inference/forward';
+import { agentsDir } from '../agents/files.js';
+import { agentIdForKey } from '../agents/keys.js';
 import { usableServerUrl } from '../mcp-server/config.js';
+import { reregisterMcpToken } from '../mcp-server/link.js';
+import { readMcpToken } from '../mcp-server/token.js';
 
 const PREFIX = '/gateway';
 const HELLO = '/api/hello';
@@ -11,10 +15,11 @@ const DEFAULT_URL = 'https://gateway.metro.box';
 const DROPPED = ['authorization', 'x-api-key', 'cookie'];
 const NOT_LINKED = 'metro gateway: this agent is not linked to its organization yet, so it cannot reach its models. It links once an admin of the organization opens its page on metro.box.';
 const NOT_ACCEPTED = 'metro gateway: gateway.metro.box did not accept this agent yet. It registers again; Claude Code retries.';
+const NO_GATEWAY = 'metro gateway: this Metro has no model gateway, since METRO_GATEWAY_URL is empty or not an https url.';
 const UNREACHABLE = 'metro gateway: gateway.metro.box could not be reached. Claude Code retries.';
 
 export interface RelayDeps {
-  url: string;
+  url: string | null;
   identify: (key: string) => boolean;
   token: () => string | null;
   reregister: () => void;
@@ -29,7 +34,7 @@ export function gatewayUrl(env: NodeJS.ProcessEnv = process.env): string | null
   if (usableServerUrl(raw)) return raw.replace(/\/+$/, '');
   if (refused !== raw) {
     refused = raw;
-    log.warn({ url: raw }, 'gateway: METRO_GATEWAY_URL must be an https url (http only on this machine), so the box routes its models itself');
+    log.warn({ url: raw }, 'gateway: METRO_GATEWAY_URL must be an https url (http only on this machine), so this box has no model gateway');
   }
   return null;
 }
@@ -45,20 +50,26 @@ function upstreamHeaders(req: IncomingMessage, token: string): Record<string, st
   return { ...headers, authorization: `Bearer ${token}` };
 }
 
-async function relay(req: IncomingMessage, res: ServerResponse, path: string, deps: RelayDeps): Promise<void> {
+function targetOf(deps: RelayDeps): { url: string; token: string } | string {
+  if (deps.url === null) return NO_GATEWAY;
   const token = deps.token();
-  if (token === null) {
+  return token === null ? NOT_LINKED : { url: deps.url, token };
+}
+
+async function relay(req: IncomingMessage, res: ServerResponse, path: string, deps: RelayDeps): Promise<void> {
+  const target = targetOf(deps);
+  if (typeof target === 'string') {
     req.resume();
-    sendError(res, 503, 'api_error', NOT_LINKED);
+    sendError(res, 503, 'api_error', target);
     return;
   }
   const body = req.method === 'POST' ? await readBody(req) : undefined;
   const watch = watchUpstream(res);
   let upstream: Response;
   try {
-    upstream = await (deps.fetch ?? fetch)(`${deps.url}${path}`, {
+    upstream = await (deps.fetch ?? fetch)(`${target.url}${path}`, {
       method: req.method ?? 'GET',
-      headers: upstreamHeaders(req, token),
+      headers: upstreamHeaders(req, target.token),
       ...(body === undefined ? {} : { body: new Uint8Array(body) }),
       signal: watch.signal,
       redirect: 'manual',
@@ -106,3 +117,11 @@ export function handleGatewayRelay(req: IncomingMessage, res: ServerResponse, de
   });
   return true;
 }
+
+export function boxGatewayHandler(): (req: IncomingMessage, res: ServerResponse) => boolean {
+  const url = gatewayUrl();
+  if (url === null) log.warn('gateway: METRO_GATEWAY_URL is empty, so model requests are refused');
+  else log.info({ url }, 'gateway: model requests go through gateway.metro.box');
+  const deps: RelayDeps = { url, identify: (key) => agentIdForKey(key) !== undefined, token: () => readMcpToken(agentsDir()), reregister: reregisterMcpToken };
+  return (req, res) => handleGatewayRelay(req, res, deps);
+}

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

@@ -24,7 +24,7 @@ import {
   localOwner,
   readLocalAgentFile,
 } from '../agents/file-admin.js';
-import { boxGatewayHandler } from '../gateway/box-gateway.js';
+import { boxGatewayHandler } from '../gateway/relay.js';
 import type { StationName } from '@metro-labs/core/station-names';
 
 export interface LocalModeDeps {

package/runtime/node_modules/@metro-labs/inference/package.json

@@ -2,7 +2,7 @@
   "name": "@metro-labs/inference",
   "version": "0.1.0",
   "private": true,
-  "description": "The model router: Anthropic, Routeway, OpenRouter, Bedrock and Codex, backups with holds, effort per thread, tool search fitting and usage from headers and stream frames. Run by the daemon's /gateway today, by gateway.metro.box next (docs/GATEWAY-SERVER.md). Imports only core and http, never a station.",
+  "description": "The model router: Anthropic, Routeway, OpenRouter, Bedrock and Codex, backups with holds, effort per thread, tool search fitting and usage from headers and stream frames. Run by gateway.metro.box (apps/gateway, docs/GATEWAY-SERVER.md). Imports only core and http, never a station.",
   "type": "module",
   "exports": {
     "./attempts": "./src/attempts.ts",
@@ -21,12 +21,11 @@
     "./model-config": "./src/model-config.ts",
     "./served": "./src/served.ts",
     "./tool-search": "./src/tool-search.ts",
-    "./usage": "./src/usage.ts",
-    "./usage-refresh": "./src/usage-refresh.ts"
+    "./usage": "./src/usage.ts"
   },
   "scripts": {
     "build": "tsc",
-    "test": "tsc --noEmit"
+    "test": "tsc --noEmit && bun test test/"
   },
   "dependencies": {
     "@metro-labs/core": "workspace:*",

package/runtime/node_modules/@metro-labs/inference/src/fallback.ts

@@ -131,20 +131,22 @@ function primaryOf(setup: ModelSetup): Route | null {
   return { connection: primary.connection, model };
 }
 
-function rowOf(route: Route, now: number): Omit<ChainRow, 'active'> {
-  const reason = notReady(route);
+type Readiness = (route: Route) => string | null;
+
+function rowOf(route: Route, now: number, ready: Readiness): Omit<ChainRow, 'active'> {
+  const reason = ready(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(setup: ModelSetup, now = Date.now()): ChainRow[] {
+export function chainStatus(setup: ModelSetup, now = Date.now(), ready: Readiness = notReady): ChainRow[] {
   const primary = primaryOf(setup);
   if (primary === null) return [];
   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(route, now));
+  const rows = unique([primary, ...listed]).map((route) => rowOf(route, now, ready));
   const active = Math.max(0, rows.findIndex((row) => row.hold === null));
   return rows.map((row, at) => ({ ...row, active: at === active }));
 }

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.323"
+  "version": "0.1.0-beta.325"
 }

package/runtime/sdk-runner/runner.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0-beta.323",
+  "version": "0.1.0-beta.325",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.287",
     "@modelcontextprotocol/sdk": "^1.29.0",

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

@@ -1,35 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { log } from '@metro-labs/core/log';
-import { handleGatewayRequest, type GatewayDeps } from '@metro-labs/inference/gateway';
-import { notReady, setupNotReady, type Route } from '@metro-labs/inference/model-config';
-import { agentsDir } from '../agents/files.js';
-import { agentIdForKey } from '../agents/keys.js';
-import { reregisterMcpToken } from '../mcp-server/link.js';
-import { readMcpToken } from '../mcp-server/token.js';
-import { effectiveSetup } from './effective.js';
-import { orgModels } from './org-models.js';
-import { gatewayUrl, handleGatewayRelay } from './relay.js';
-
-type Handler = (req: IncomingMessage, res: ServerResponse) => boolean;
-
-const identify = (key: string): boolean => agentIdForKey(key) !== undefined;
-
-export const routeReadiness = (route: Route): string | null => (gatewayUrl() === null ? notReady(route) : setupNotReady(route));
-
-export const boxGateway = (): GatewayDeps => ({
-  setup: () => effectiveSetup(),
-  identify,
-  codex: { refresh: (conn) => orgModels()?.refresh(conn) ?? Promise.resolve(null) },
-});
-
-export function boxGatewayHandler(): Handler {
-  const url = gatewayUrl();
-  if (url === null) {
-    const deps = boxGateway();
-    log.info('gateway: this box routes its model requests itself (METRO_GATEWAY_URL is empty)');
-    return (req, res) => handleGatewayRequest(req, res, deps);
-  }
-  log.info({ url }, 'gateway: model requests go through gateway.metro.box');
-  const deps = { url, identify, token: () => readMcpToken(agentsDir()), reregister: reregisterMcpToken };
-  return (req, res) => handleGatewayRelay(req, res, deps);
-}

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

@@ -1,51 +0,0 @@
-import { errMsg, log } from '@metro-labs/core/log';
-import { openrouterKey } from './openrouter.js';
-import { mayProbe, noteUsage, openrouterUsage, usageOf } from './usage.js';
-import type { Connection, ModelSetup } from './model-config.js';
-
-export const CREDITS_TTL_MS = 5 * 60_000;
-const WAIT_MS = 4_000;
-
-export interface UsageDeps {
-  fetchImpl?: typeof fetch;
-  openrouterBase?: string;
-  usageWaitMs?: number;
-}
-
-const fresh = (id: string, now: number): boolean => {
-  const seen = usageOf(id);
-  return seen !== undefined && now - Date.parse(seen.at) < CREDITS_TTL_MS;
-};
-
-async function refreshKey(conn: Connection, deps: UsageDeps, now: number): Promise<void> {
-  if (conn.provider !== 'openrouter' || conn.apiKey === '' || fresh(conn.id, now) || !mayProbe(conn.id, now, CREDITS_TTL_MS)) return;
-  try {
-    noteUsage(conn.id, openrouterUsage(await openrouterKey(conn.apiKey, deps.openrouterBase, deps.fetchImpl), new Date(now)));
-  } catch (err) {
-    log.warn({ err: errMsg(err) }, 'model-api: could not read the OpenRouter key spend');
-  }
-}
-
-async function within(ms: number, work: Promise<unknown>): Promise<void> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const waited = new Promise<void>((resolve) => {
-    timer = setTimeout(resolve, ms);
-  });
-  await Promise.race([work, waited]);
-  clearTimeout(timer);
-}
-
-export async function refreshUsage(setup: ModelSetup, deps: UsageDeps = {}, now = Date.now()): Promise<void> {
-  await within(deps.usageWaitMs ?? WAIT_MS, Promise.all(setup.connections.map((conn) => refreshKey(conn, deps, now))));
-}
-
-export function watchFallbackUsage(setup: () => ModelSetup, deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
-  const run = (): void => {
-    const current = setup();
-    if (current.fallbacks.length === 0 && (current.helpers ?? null) === null) return;
-    refreshUsage(current, deps).catch((err: unknown) => {
-      log.warn({ err: errMsg(err) }, 'model-api: could not refresh the usage of the fallback models');
-    });
-  };
-  setInterval(run, every).unref();
-}