@stage-labs/metro 0.1.0-beta.320 → 0.1.0-beta.322

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

@@ -0,0 +1,120 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'node:http';
+import type { RequestKind } from './effort.js';
+import type { Route } from './model-config.js';
+
+export type AttemptOutcome = 'ok' | 'rate_limited' | 'refused' | 'provider_error' | 'cancelled';
+
+export type AttemptKind = 'main' | 'subagent' | 'compaction' | 'chore';
+
+export interface AttemptTokens {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite5m: number;
+  cacheWrite1h: number;
+}
+
+export interface AttemptCall {
+  connection: string;
+  provider: string;
+  model: string;
+  lane: 'main' | 'workers';
+  kind: AttemptKind;
+  attempt: number;
+  status: number;
+  outcome: AttemptOutcome;
+  tokens: AttemptTokens;
+  providerCost: number | null;
+  ms: number;
+  firstTokenMs: number | null;
+  at: number;
+}
+
+export type OnCall = (call: AttemptCall) => void;
+
+const KINDS: Record<RequestKind, AttemptKind> = { main: 'main', subagent: 'subagent', compact: 'compaction', other: 'chore' };
+
+const NO_TOKENS: AttemptTokens = { input: 0, output: 0, cacheRead: 0, cacheWrite5m: 0, cacheWrite1h: 0 };
+
+export class Attempt {
+  private readonly started = Date.now();
+  private firstAt: number | null = null;
+  private status: number | null = null;
+  private failedMidStream = false;
+  private tokens: AttemptTokens = NO_TOKENS;
+  private cost: number | null = null;
+
+  constructor(
+    private readonly route: Route,
+    private readonly lane: 'main' | 'helpers',
+    private readonly kind: RequestKind,
+    private readonly index: number,
+  ) {}
+
+  firstByte(): void {
+    this.firstAt ??= Date.now();
+  }
+
+  answered(status: number): void {
+    this.status ??= status;
+  }
+
+  failed(): void {
+    this.failedMidStream = true;
+  }
+
+  counted(tokens: AttemptTokens, cost: number | null): void {
+    this.tokens = tokens;
+    this.cost = cost;
+  }
+
+  call(fallbackStatus: number, cancelled: boolean): AttemptCall {
+    const status = this.status ?? fallbackStatus;
+    const ended = Date.now();
+    return {
+      connection: this.route.connection.id,
+      provider: this.route.connection.provider,
+      model: this.route.model,
+      lane: this.lane === 'helpers' ? 'workers' : 'main',
+      kind: KINDS[this.kind],
+      attempt: this.index,
+      status,
+      outcome: cancelled ? 'cancelled' : outcomeOf(status, this.failedMidStream),
+      tokens: this.tokens,
+      providerCost: this.cost,
+      ms: ended - this.started,
+      firstTokenMs: this.firstAt === null ? null : this.firstAt - this.started,
+      at: ended,
+    };
+  }
+}
+
+function outcomeOf(status: number, failedMidStream: boolean): AttemptOutcome {
+  if (status === 402 || status === 429) return 'rate_limited';
+  if (status >= 500) return 'provider_error';
+  if (status >= 400) return 'refused';
+  return failedMidStream ? 'provider_error' : 'ok';
+}
+
+const current = new AsyncLocalStorage<Attempt>();
+
+export const currentAttempt = (): Attempt | undefined => current.getStore();
+
+export const inAttempt = <T>(attempt: Attempt, run: () => Promise<T>): Promise<T> => current.run(attempt, run);
+
+export function tracked(res: ServerResponse, attempt: Attempt): ServerResponse {
+  const proxy: ServerResponse = new Proxy(res, {
+    get(target, prop) {
+      if (prop === 'writeHead')
+        return (status: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): ServerResponse => {
+          attempt.answered(status);
+          target.writeHead(status, headers);
+          return proxy;
+        };
+      const value: unknown = Reflect.get(target, prop, target);
+      return typeof value === 'function' ? (value as (...args: unknown[]) => unknown).bind(target) : value;
+    },
+  });
+  return proxy;
+}

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/codex.ts

@@ -18,7 +18,7 @@ import { noteUsageHeaders } from './usage.js';
 const CODEX_BACKEND = 'https://chatgpt.com/backend-api/codex';
 const OPENAI_API = 'https://api.openai.com/v1';
 const INVALID = [400, 404, 422];
-const RENEW_FAILED = "Codex refused its sign-in and api.metro.box could not renew it: sign in again on the organization's Models page.";
+const RENEW_FAILED = "Codex refused its sign-in and api.metro.box could not renew it: sign in again on the organization's Gateway page.";
 
 export interface CodexDeps {
   base?: string;

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/delivered.ts

@@ -1,6 +1,6 @@
 import { readEffort, type RouteEffort } from '@metro-labs/core/effort';
 import { isRecord } from '@metro-labs/core/is-record';
-import { isProvider, type Account, type Chain, type CodexAccess, type Connection, type Fallback, type Provider, type RouteSource } from './model-config.js';
+import { emptySetup, isProvider, type ModelSetup, type Account, type Chain, type CodexAccess, type Connection, type Fallback, type Provider, type RouteSource } from './model-config.js';
 
 export interface DeliveredRoute {
   primary: Fallback | null;
@@ -100,3 +100,9 @@ export function deliveredOf(raw: Record<string, unknown>): Delivered | null {
 export function refreshedConnection(raw: Record<string, unknown>): Connection | null {
   return deliveredConnection(isRecord(raw.connection) ? raw.connection : raw);
 }
+
+export function setupOf(delivered: Delivered | null): ModelSetup {
+  const route = delivered?.route ?? null;
+  if (delivered === null || route === null) return { ...emptySetup(), source: delivered?.source ?? null };
+  return { primary: route.primary, fallbacks: route.fallbacks, connections: delivered.connections, source: delivered.source, helpers: route.helpers, effort: route.effort };
+}

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/effort.ts

@@ -70,10 +70,10 @@ function wantedEffort(kind: RequestKind, setting: RouteEffort): string | null {
   return wanted === 'asked' ? null : wanted;
 }
 
-export function plannedEffort(req: IncomingMessage, body: Body, setting: RouteEffort = {}): string | null {
+export function plannedEffort(req: IncomingMessage, body: Body, setting: RouteEffort = {}, kind: RequestKind = requestKind(req, body)): string | null {
   const asked = askedEfforts(body);
   if (asked.length === 0) return null;
-  const wanted = wantedEffort(requestKind(req, body), setting);
+  const wanted = wantedEffort(kind, setting);
   if (wanted === null) return null;
   return asked.every((effort) => effort === wanted) ? null : wanted;
 }

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/failures.ts

@@ -1,10 +1,19 @@
 import { isRecord } from '@metro-labs/core/is-record';
 import { log } from '@metro-labs/core/log';
 import { stringOf } from '@metro-labs/http/api-http';
+import { currentAttempt } from './attempts.js';
 import { parseEvent, SseParser } from './frames.js';
 import type { Route } from './model-config.js';
 
 const MESSAGE_MAX = 300;
+
+let keepProviderText = true;
+
+export const quietProviderText = (): void => {
+  keepProviderText = false;
+};
+
+export const providerText = (text: string): string | undefined => (keepProviderText ? text.slice(0, MESSAGE_MAX) : undefined);
 const ERROR_DATA = /^\{\s*"type"\s*:\s*"error"/;
 
 export interface FailureSite {
@@ -21,7 +30,8 @@ export interface Failure {
 export const siteOf = (route: Route): FailureSite => ({ connection: route.connection.label, model: route.model });
 
 export function noteFailure(site: FailureSite, failure: Failure, what: string): void {
-  log.warn({ connection: site.connection, model: site.model, ...failure, message: failure.message.slice(0, MESSAGE_MAX) }, what);
+  currentAttempt()?.failed();
+  log.warn({ connection: site.connection, model: site.model, ...failure, message: providerText(failure.message) }, what);
 }
 
 export class StreamErrors {

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/fallback.ts

@@ -21,7 +21,7 @@ interface Cooling {
 export type Lane = 'main' | 'helpers';
 
 const cooling = new Map<string, Cooling>();
-const lastChoice = new Map<Lane, string>();
+const lastChoice = new Map<string, string>();
 
 const keyOf = (route: Route): string => `${route.connection.id}\n${route.model}`;
 
@@ -98,11 +98,12 @@ export function noteRefused(route: Route, status: number, headers: Headers, next
   log.warn({ from: routeLabel(route), to: next === undefined ? null : routeLabel(next), status }, why);
 }
 
-export function noteChoice(primary: Route, chosen: Route, lane: Lane, now = Date.now()): void {
+export function noteChoice(primary: Route, chosen: Route, lane: Lane, now = Date.now(), scope = ''): void {
   const key = keyOf(chosen);
-  const last = lastChoice.get(lane);
+  const at = `${scope}\n${lane}`;
+  const last = lastChoice.get(at);
   if (key === last) return;
-  lastChoice.set(lane, key);
+  lastChoice.set(at, key);
   if (key === keyOf(primary)) {
     if (last !== undefined) log.info({ lane, model: routeLabel(chosen), connection: chosen.connection.label }, 'gateway: back on the first model of the fallback list');
     return;

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/forward.ts

@@ -34,7 +34,7 @@ const RESPONSE_DROP = new Set(['content-length', 'content-encoding', 'transfer-e
 
 export class SubscriptionRefused extends GatewayError {
   constructor(label: string) {
-    super(403, 'permission_error', `Anthropic refused the Claude subscription ${label}: sign in again on the Models page`);
+    super(403, 'permission_error', `Anthropic refused the Claude subscription ${label}: sign in again on the Gateway page`);
   }
 }
 

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/gateway.ts

@@ -1,7 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { errMsg, log } from '@metro-labs/core/log';
 import { cameThroughProxy } from '@metro-labs/http/api-http';
-import { agentIdForKey } from '../agents/keys.js';
 import {
   bedrockBase,
   bedrockCount,
@@ -36,11 +35,16 @@ import {
   helperRequest,
   learnAlwaysThinks,
   plannedEffort,
+  requestKind,
   thinkingOff,
   withBlockBinding,
   withEffort,
   withThinkingFor,
+  type RequestKind,
 } from './effort.js';
+import { currentAttempt, type OnCall } from './attempts.js';
+import { measured } from './measure.js';
+import { NAMED_MODELS, namedChoice, WORKERS, type Chosen } from './named.js';
 import { helperSetup, notReady, pinnedRoute, resolveRoute, routeLabel, type Connection, type ModelSetup, type Route } from './model-config.js';
 import { codexMessages, type CodexDeps } from './codex.js';
 import { countTokens } from './subscription.js';
@@ -50,8 +54,7 @@ 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 { siteOf } from './failures.js';
-import { orgModels } from './org-models.js';
+import { providerText, siteOf } from './failures.js';
 
 const GATEWAY_PREFIX = '/gateway';
 const MESSAGES = '/v1/messages';
@@ -59,20 +62,28 @@ const COUNT = '/v1/messages/count_tokens';
 const MODELS = '/v1/models';
 const HELLO = '/api/hello';
 const ANTHROPIC_API = 'https://api.anthropic.com';
-const NO_ROUTE = "metro gateway: no model is set up for this agent yet: enroll it with its organization and choose a model on the organization's Models page";
+const NO_ROUTE = "metro gateway: no model is set up for this agent yet: enroll it with its organization and choose a model on the organization's Gateway page";
 
-export interface GatewayDeps {
+export interface ModelDeps {
   setup: () => ModelSetup;
-  identify?: (key: string) => boolean;
   anthropicBase?: string;
   bedrockBase?: string;
   openrouterBase?: string;
   routewayBase?: string;
   codex?: Partial<CodexDeps>;
+  onCall?: OnCall;
+  scope?: string;
+  named?: boolean;
+}
+
+export interface GatewayDeps extends ModelDeps {
+  identify: (key: string) => boolean;
 }
 
 const learned: Adaptations = freshAdaptations();
 
+const noRefresh = (): Promise<Connection | null> => Promise.resolve(null);
+
 export function resetGatewayState(): void {
   forgetServed();
   forgetFallbackState();
@@ -81,15 +92,11 @@ export function resetGatewayState(): void {
   forgetLearnedThinking();
 }
 
-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'];
   return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
 };
 
-const defaultIdentify = (key: string): boolean => key !== '' && agentIdForKey(key) !== undefined;
-
 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);
@@ -145,7 +152,7 @@ async function asAnthropicWants(send: Send, base: Record<string, string>, payloa
   const { metro, asSent, bound } = payloads;
   const upstream = await send(metro, bound ? addBeta(base, BINDING_BETA) : base);
   if (upstream.status !== 400 || asSent === null) return upstream;
-  const reason = upstreamMessage(await upstream.text().catch(() => ''), '').slice(0, 300);
+  const reason = providerText(upstreamMessage(await upstream.text().catch(() => ''), ''));
   log.warn({ connection, model, reason }, 'gateway: the provider refused the request metro shaped, so it was sent again as Claude Code wrote it');
   return send(asSent, base);
 }
@@ -174,9 +181,12 @@ async function shapedAttempt(send: Send, base: Record<string, string>, body: Sha
 const sender = (url: string, watch: Watch): Send => (payload, headers) =>
   fetch(url, { method: 'POST', headers, body: new Uint8Array(payload), signal: watch.signal, redirect: 'manual' });
 
-const upstreamPath = (req: IncomingMessage): string => (req.url ?? '').slice(GATEWAY_PREFIX.length);
+const upstreamPath = (req: IncomingMessage): string => {
+  const url = req.url ?? '';
+  return url.startsWith(`${GATEWAY_PREFIX}/`) ? url.slice(GATEWAY_PREFIX.length) : url;
+};
 
-async function toAnthropic(req: IncomingMessage, res: ServerResponse, body: Shaped, route: Route, deps: GatewayDeps): Promise<void> {
+async function toAnthropic(req: IncomingMessage, res: ServerResponse, body: Shaped, route: Route, deps: ModelDeps): Promise<void> {
   const conn = route.connection;
   const watch = watchUpstream(res);
   const send = sender(`${deps.anthropicBase ?? ANTHROPIC_API}${upstreamPath(req)}`, watch);
@@ -187,7 +197,7 @@ async function toAnthropic(req: IncomingMessage, res: ServerResponse, body: Shap
   await pipeResponse(upstream, res, watch, { ownCredential: true, scanner: new UsageScanner(conn.id), site: siteOf(route) });
 }
 
-async function toRouteway(req: IncomingMessage, res: ServerResponse, body: Shaped, route: Route, deps: GatewayDeps): Promise<void> {
+async function toRouteway(req: IncomingMessage, res: ServerResponse, body: Shaped, route: Route, deps: ModelDeps): Promise<void> {
   const conn = route.connection;
   const watch = watchUpstream(res);
   const send = sender(`${deps.routewayBase ?? ROUTEWAY_BASE}${upstreamPath(req)}`, watch);
@@ -200,7 +210,7 @@ async function toRouteway(req: IncomingMessage, res: ServerResponse, body: Shape
   await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id), site: siteOf(route) });
 }
 
-async function toOpenRouter(req: IncomingMessage, res: ServerResponse, body: Record<string, unknown>, route: Route, deps: GatewayDeps): Promise<void> {
+async function toOpenRouter(req: IncomingMessage, res: ServerResponse, body: Record<string, unknown>, route: Route, deps: ModelDeps): Promise<void> {
   const conn = route.connection;
   const headers: Record<string, string> = {
     'content-type': 'application/json',
@@ -238,22 +248,16 @@ 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 toCodex(req: IncomingMessage, res: ServerResponse, path: string, body: Record<string, unknown>, route: Route, deps: GatewayDeps): Promise<void> {
+async function toCodex(req: IncomingMessage, res: ServerResponse, path: string, body: Record<string, unknown>, route: Route, deps: ModelDeps): Promise<void> {
   if (path === COUNT) countTokens(res, body);
-  else await codexMessages(req, res, body, route.model, route.connection, { refresh: refreshCodex, ...deps.codex }, watchUpstream(res));
+  else await codexMessages(req, res, body, route.model, route.connection, { refresh: noRefresh, ...deps.codex }, watchUpstream(res));
 }
 
-function shapedFor(req: IncomingMessage, sent: Record<string, unknown>, setup: ModelSetup): Record<string, unknown> {
-  const effort = plannedEffort(req, sent, setup.effort);
+function shapedFor(req: IncomingMessage, sent: Record<string, unknown>, setup: ModelSetup, kind: RequestKind): Record<string, unknown> {
+  const effort = plannedEffort(req, sent, setup.effort, kind);
   return effort === null ? sent : withEffort(sent, effort);
 }
 
-interface Chosen {
-  lane: Lane;
-  setup: ModelSetup;
-  primary: Route;
-}
-
 function chosenChain(req: IncomingMessage, sent: Record<string, unknown>, setup: ModelSetup, requested: string): Chosen {
   const helpers = helperRequest(req, sent) ? helperSetup(setup) : null;
   if (helpers === null) return { lane: 'main', setup, primary: resolveRoute(requested, setup) ?? noRoute() };
@@ -264,6 +268,8 @@ const bytesOf = (raw: Buffer, parsed: Record<string, unknown>, sent: Record<stri
 
 interface Request {
   path: string;
+  lane: Lane;
+  kind: RequestKind;
   raw: Buffer;
   parsed: Record<string, unknown>;
   sent: Record<string, unknown>;
@@ -271,13 +277,13 @@ interface Request {
   setup: ModelSetup;
 }
 
-async function attempt(req: IncomingMessage, res: ServerResponse, ask: Request, route: Route, deps: GatewayDeps): Promise<void> {
+async function attempt(req: IncomingMessage, res: ServerResponse, ask: Request, route: Route, deps: ModelDeps): 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 (path === MESSAGES) noteServed({ connection: conn.id, provider: conn.provider, model: route.model, at: new Date().toISOString() }, deps.scope);
   if (conn.provider === 'bedrock') {
     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);
@@ -297,33 +303,37 @@ async function attempt(req: IncomingMessage, res: ServerResponse, ask: Request,
   await (conn.provider === 'routeway' ? toRouteway : toAnthropic)(req, res, shaped, route, deps);
 }
 
-async function heldAttempt(req: IncomingMessage, held: Held, ask: Request, route: Route, deps: GatewayDeps): Promise<Refusal | null> {
+async function heldAttempt(req: IncomingMessage, held: Held, ask: Request, route: Route, deps: ModelDeps): Promise<Refusal | null> {
   try {
     await attempt(req, held.res, ask, route, deps);
   } catch (err) {
     if (!(err instanceof SubscriptionRefused)) throw err;
+    currentAttempt()?.answered(401);
     return { status: 401, headers: new Headers() };
   }
   return held.refusal();
 }
 
-async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
+async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: ModelDeps): Promise<void> {
   const setup = deps.setup();
   const raw = await readBody(req);
   const parsed = parseJson(raw);
   const sent = fitToolSearch(req, parsed);
   const requested = requestedModel(sent);
-  const { lane, setup: chain, primary } = chosenChain(req, sent, setup, requested);
-  const ask: Request = { path, raw, parsed, sent, body: shapedFor(req, sent, setup), setup };
+  const named = deps.named === true ? namedChoice(requested, setup) : null;
+  const { lane, setup: chain, primary } = named ?? chosenChain(req, sent, setup, requested);
+  const kind: RequestKind = named === null ? requestKind(req, sent) : requested === WORKERS ? 'subagent' : 'main';
+  const ask: Request = { path, lane, kind, raw, parsed, sent, body: shapedFor(req, sent, setup, kind), setup };
   const routes = routesToTry(chainOf(primary, chain, requested));
   for (const [at, route] of routes.entries()) {
     const next = routes[at + 1];
-    if (path === MESSAGES) noteChoice(primary, route, lane);
+    if (path === MESSAGES) noteChoice(primary, route, lane, Date.now(), deps.scope);
     if (next === undefined) {
-      await attempt(req, res, ask, route, deps);
+      await measured(res, ask, route, at, deps.onCall, (out) => attempt(req, out, ask, route, deps));
       return;
     }
-    const refusal = await heldAttempt(req, holdLimitRefusal(res), ask, route, deps);
+    const held = holdLimitRefusal(res);
+    const refusal = await measured(held.res, ask, route, at, deps.onCall, (out) => heldAttempt(req, { res: out, refusal: held.refusal }, ask, route, deps));
     if (refusal === null) return;
     noteRefused(route, refusal.status, refusal.headers, next);
   }
@@ -342,10 +352,10 @@ function failed(res: ServerResponse, err: unknown): void {
   sendError(res, 502, 'api_error', `metro gateway: ${errMsg(err)}`);
 }
 
-function answer(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): void {
+export function answerModels(req: IncomingMessage, res: ServerResponse, path: string, deps: ModelDeps): void {
   if (req.method === 'GET' && path === MODELS) {
     res.writeHead(200, { 'content-type': 'application/json' });
-    res.end(JSON.stringify(modelsBody(deps.setup())));
+    res.end(JSON.stringify(deps.named === true ? NAMED_MODELS : modelsBody(deps.setup())));
     return;
   }
   if (req.method === 'POST' && (path === MESSAGES || path === COUNT)) {
@@ -366,7 +376,7 @@ export function handleGatewayRequest(req: IncomingMessage, res: ServerResponse,
     return true;
   }
   if (cameThroughProxy(req)) sendError(res, 401, 'authentication_error', 'metro gateway: the agent key works only on this machine, not through its public address');
-  else if ((deps.identify ?? defaultIdentify)(keyOf(req))) answer(req, res, path, deps);
+  else if (keyOf(req) !== '' && deps.identify(keyOf(req))) answerModels(req, res, path, deps);
   else sendError(res, 401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start the agent with metro agent');
   return true;
 }

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

@@ -0,0 +1,42 @@
+import type { ServerResponse } from 'node:http';
+import { errMsg, log } from '@metro-labs/core/log';
+import { Attempt, inAttempt, tracked, type AttemptCall, type OnCall } from './attempts.js';
+import type { RequestKind } from './effort.js';
+import { GatewayError, SubscriptionRefused } from './forward.js';
+import type { Route } from './model-config.js';
+
+const MESSAGES = '/v1/messages';
+
+export interface Asked {
+  path: string;
+  lane: 'main' | 'helpers';
+  kind: RequestKind;
+}
+
+function statusOf(failure: unknown, res: ServerResponse): number {
+  if (failure === null) return res.statusCode;
+  if (failure instanceof GatewayError) return failure.status;
+  return failure instanceof SubscriptionRefused ? 401 : 502;
+}
+
+function report(onCall: OnCall, call: AttemptCall): void {
+  try {
+    onCall(call);
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'gateway: recording a call failed');
+  }
+}
+
+export async function measured<T>(res: ServerResponse, ask: Asked, route: Route, at: number, onCall: OnCall | undefined, run: (out: ServerResponse) => Promise<T>): Promise<T> {
+  if (ask.path !== MESSAGES || onCall === undefined) return run(res);
+  const counted = new Attempt(route, ask.lane, ask.kind, at);
+  let failure: unknown = null;
+  try {
+    return await inAttempt(counted, () => run(tracked(res, counted)));
+  } catch (err) {
+    failure = err;
+    throw err;
+  } finally {
+    report(onCall, counted.call(statusOf(failure, res), res.destroyed && !res.writableFinished));
+  }
+}

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/model-config.ts

@@ -57,7 +57,7 @@ export interface Route {
   model: string;
 }
 
-export const CODEX_SIGN_IN = "Codex is not signed in: sign in again on the organization's Models page.";
+export const CODEX_SIGN_IN = "Codex is not signed in: sign in again on the organization's Gateway page.";
 
 const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex|routeway):(.+)$/;
 const SMALL_RE = /haiku/i;
@@ -78,22 +78,22 @@ export function primaryRoute(setup: ModelSetup): Route | null {
 }
 
 const CHECKS: Record<Provider, [(r: Route) => boolean, string][]> = {
-  anthropic: [[(r) => r.connection.apiKey === '' && r.connection.claudeToken === '', "Anthropic has no API key or Claude subscription: add one on the organization's Models page."]],
+  anthropic: [[(r) => r.connection.apiKey === '' && r.connection.claudeToken === '', "Anthropic has no API key or Claude subscription: add one on the organization's Gateway page."]],
   bedrock: [
-    [(r) => r.connection.apiKey === '', "Bedrock has no API key: add it on the organization's Models page."],
-    [(r) => r.connection.region === '', "Bedrock needs a region: add it on the organization's Models page."],
+    [(r) => r.connection.apiKey === '', "Bedrock has no API key: add it on the organization's Gateway page."],
+    [(r) => r.connection.region === '', "Bedrock needs a region: add it on the organization's Gateway page."],
   ],
   openrouter: [
-    [(r) => r.connection.apiKey === '', "OpenRouter has no API key: add it on the organization's Models page."],
-    [(r) => r.model === '', "OpenRouter needs a model id: choose one on the organization's Models page."],
+    [(r) => r.connection.apiKey === '', "OpenRouter has no API key: add it on the organization's Gateway page."],
+    [(r) => r.model === '', "OpenRouter needs a model id: choose one on the organization's Gateway page."],
   ],
   codex: [
     [(r) => r.connection.codex === null, CODEX_SIGN_IN],
-    [(r) => r.model === '', "Codex needs a model id: choose one on the organization's Models page."],
+    [(r) => r.model === '', "Codex needs a model id: choose one on the organization's Gateway page."],
   ],
   routeway: [
-    [(r) => r.connection.apiKey === '', "Routeway has no API key: add it on the organization's Models page."],
-    [(r) => r.model === '', "Routeway needs a model id: choose one on the organization's Models page."],
+    [(r) => r.connection.apiKey === '', "Routeway has no API key: add it on the organization's Gateway page."],
+    [(r) => r.model === '', "Routeway needs a model id: choose one on the organization's Gateway page."],
   ],
 };
 

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

@@ -0,0 +1,36 @@
+import type { Lane } from './fallback.js';
+import { GatewayError } from './forward.js';
+import { helperSetup, primaryRoute, type ModelSetup, type Route } from './model-config.js';
+
+export interface Chosen {
+  lane: Lane;
+  setup: ModelSetup;
+  primary: Route;
+}
+
+const NO_ROUTE = "metro gateway: no model is set up for this agent yet: choose one on the organization's Gateway page";
+
+const noRoute = (message: string): never => {
+  throw new GatewayError(503, 'api_error', message);
+};
+
+const MAIN = 'metro';
+export const WORKERS = 'metro-workers';
+const NAMES = `Use the model "${MAIN}" (this agent's main models) or "${WORKERS}" (its worker models).`;
+
+export const NAMED_MODELS = {
+  data: [
+    { id: MAIN, display_name: 'Main models', description: "This agent's main model order on Metro" },
+    { id: WORKERS, display_name: 'Worker models', description: "This agent's worker model order on Metro" },
+  ],
+  has_more: false,
+  first_id: MAIN,
+  last_id: WORKERS,
+};
+
+export function namedChoice(requested: string, setup: ModelSetup): Chosen {
+  if (requested !== MAIN && requested !== WORKERS) throw new GatewayError(400, 'invalid_request_error', NAMES);
+  const helpers = requested === WORKERS ? helperSetup(setup) : null;
+  const chain = helpers ?? setup;
+  return { lane: helpers === null ? 'main' : 'helpers', setup: chain, primary: primaryRoute(chain) ?? noRoute(NO_ROUTE) };
+}

package/runtime/node_modules/@metro-labs/{daemon/src/gateway → inference/src}/routeway.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage } from 'node:http';
 import { isRecord } from '@metro-labs/core/is-record';
 import { log } from '@metro-labs/core/log';
+import { providerText } from './failures.js';
 import { withoutCacheTtl, withoutTtlBeta } from './cache-ttl.js';
 import { anthropicHeaders, GatewayError, type Watch } from './forward.js';
 
@@ -84,5 +85,5 @@ export async function noteRoutewayRefusal(upstream: Response): Promise<void> {
   const error = isRecord(body) && isRecord(body.error) ? body.error : null;
   if (error === null) return;
   const text = (value: unknown): string | null => (typeof value === 'string' ? value.slice(0, 300) : null);
-  log.warn({ status: upstream.status, reason: text(error.message), param: text(error.param) }, 'gateway: Routeway refused the request');
+  log.warn({ status: upstream.status, reason: providerText(text(error.message) ?? ''), param: providerText(text(error.param) ?? '') }, 'gateway: Routeway refused the request');
 }

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

@@ -0,0 +1,18 @@
+export interface Served {
+  connection: string;
+  provider: string;
+  model: string;
+  at: string;
+}
+
+const last = new Map<string, Served>();
+
+export const noteServed = (served: Served, scope = ''): void => {
+  last.set(scope, served);
+};
+
+export const lastServed = (scope = ''): Served | null => last.get(scope) ?? null;
+
+export const forgetServed = (): void => {
+  last.clear();
+};