@stage-labs/metro 0.1.0-beta.314 → 0.1.0-beta.316

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.314",
+  "version": "0.1.0-beta.316",
   "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/core/package.json

@@ -19,6 +19,7 @@
     "./trains/protocol": "./src/protocol.ts",
     "./ids": "./src/ids.ts",
     "./claude-token": "./src/claude-token.ts",
+    "./effort": "./src/effort.ts",
     "./tickets": "./src/tickets.ts",
     "./station-names": "./src/station-names.ts",
     "./str": "./src/str.ts",

package/runtime/node_modules/@metro-labs/core/src/effort.ts

@@ -0,0 +1,21 @@
+import { isRecord } from './is-record.js';
+
+export const EFFORT_LEVELS = ['low', 'medium', 'high', 'max', 'asked'] as const;
+
+export type EffortLevel = (typeof EFFORT_LEVELS)[number];
+
+export interface RouteEffort {
+  main?: EffortLevel;
+  helpers?: EffortLevel;
+}
+
+export const EFFORT_DEFAULTS: Required<RouteEffort> = { main: 'low', helpers: 'max' };
+
+export const isEffortLevel = (value: unknown): value is EffortLevel => typeof value === 'string' && (EFFORT_LEVELS as readonly string[]).includes(value);
+
+export function readEffort(raw: unknown): RouteEffort {
+  if (!isRecord(raw)) return {};
+  return { ...(isEffortLevel(raw.main) ? { main: raw.main } : {}), ...(isEffortLevel(raw.helpers) ? { helpers: raw.helpers } : {}) };
+}
+
+export const effortSet = (effort: RouteEffort): boolean => effort.main !== undefined || effort.helpers !== undefined;

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

@@ -1,9 +1,12 @@
+import { readEffort, type RouteEffort } from '@metro-labs/core/effort';
 import { isRecord } from '@metro-labs/core/is-record';
-import { isProvider, type Account, type CodexAccess, type Connection, type Fallback, type Provider, type RouteSource } from './model-config.js';
+import { isProvider, type Account, type Chain, type CodexAccess, type Connection, type Fallback, type Provider, type RouteSource } from './model-config.js';
 
 export interface DeliveredRoute {
   primary: Fallback | null;
   fallbacks: Fallback[];
+  helpers: Chain | null;
+  effort: RouteEffort;
 }
 
 export interface Delivered {
@@ -24,10 +27,20 @@ function refOf(raw: unknown): Fallback | null {
   return ref.connection === '' ? null : ref;
 }
 
+function fallbacksOf(raw: Record<string, unknown>): Fallback[] {
+  const fallbacks = Array.isArray(raw.fallbacks) ? raw.fallbacks.flatMap((f: unknown) => refOf(f) ?? []) : [];
+  return fallbacks.filter((f) => f.model !== '').slice(0, MAX_FALLBACKS);
+}
+
+function helpersOf(raw: unknown): Chain | null {
+  if (!isRecord(raw)) return null;
+  const primary = refOf(raw.primary);
+  return primary === null ? null : { primary, fallbacks: fallbacksOf(raw) };
+}
+
 function routeOf(raw: unknown): DeliveredRoute | null {
   if (!isRecord(raw)) return null;
-  const fallbacks = Array.isArray(raw.fallbacks) ? raw.fallbacks.flatMap((f: unknown) => refOf(f) ?? []) : [];
-  return { primary: refOf(raw.primary), fallbacks: fallbacks.filter((f) => f.model !== '').slice(0, MAX_FALLBACKS) };
+  return { primary: refOf(raw.primary), fallbacks: fallbacksOf(raw), helpers: helpersOf(raw.helpers), effort: readEffort(raw.effort) };
 }
 
 function accountOf(raw: unknown): Account {

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

@@ -6,7 +6,7 @@ import { deliveredSetup, type OrgModels } from './org-models.js';
 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 };
+  return { primary: route.primary, fallbacks: route.fallbacks, connections: delivered.connections, source: delivered.source, helpers: route.helpers, effort: route.effort };
 }
 
 export const effectiveSetup = (delivered: Delivered | null = deliveredSetup()): ModelSetup => setupOf(delivered);

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

@@ -1,8 +1,7 @@
 import type { IncomingMessage } from 'node:http';
+import { EFFORT_DEFAULTS, type RouteEffort } from '@metro-labs/core/effort';
 import { isRecord } from '@metro-labs/core/is-record';
 
-const MAIN_EFFORT = 'low';
-const SUBAGENT_EFFORT = 'max';
 export const BINDING_BETA = 'thinking-binding-controls-2026-08-01';
 
 const SUBAGENT_HEADER = 'x-claude-code-agent-id';
@@ -42,12 +41,13 @@ const messagesOf = (body: Body): unknown[] => (Array.isArray(body.messages) ? bo
 
 const askedEfforts = (body: Body): string[] => [body, ...messagesOf(body).map(record)].map(effortOf).filter((effort) => effort !== '');
 
-export function plannedEffort(req: IncomingMessage, body: Body): string | null {
+export function plannedEffort(req: IncomingMessage, body: Body, setting: RouteEffort = {}): string | null {
   const asked = askedEfforts(body);
   if (asked.length === 0) return null;
   const kind = requestKind(req, body);
   if (kind === 'other') return null;
-  const wanted = kind === 'subagent' ? SUBAGENT_EFFORT : MAIN_EFFORT;
+  const wanted = kind === 'subagent' ? (setting.helpers ?? EFFORT_DEFAULTS.helpers) : (setting.main ?? EFFORT_DEFAULTS.main);
+  if (wanted === 'asked') return null;
   return asked.every((effort) => effort === wanted) ? null : wanted;
 }
 

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

@@ -18,14 +18,16 @@ interface Cooling {
   reason: string;
 }
 
+export type Lane = 'main' | 'helpers';
+
 const cooling = new Map<string, Cooling>();
-let lastChoice = '';
+const lastChoice = new Map<Lane, string>();
 
 const keyOf = (route: Route): string => `${route.connection.id}\n${route.model}`;
 
 export function forgetFallbackState(): void {
   cooling.clear();
-  lastChoice = '';
+  lastChoice.clear();
 }
 
 function scopeOf(label: string): string | null {
@@ -96,18 +98,18 @@ 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, now = Date.now()): void {
+export function noteChoice(primary: Route, chosen: Route, lane: Lane, now = Date.now()): void {
   const key = keyOf(chosen);
-  if (key === lastChoice) return;
-  const first = lastChoice === '';
-  lastChoice = key;
+  const last = lastChoice.get(lane);
+  if (key === last) return;
+  lastChoice.set(lane, key);
   if (key === keyOf(primary)) {
-    if (!first) log.info({ model: routeLabel(chosen), connection: chosen.connection.label }, 'gateway: back on the first model of the fallback list');
+    if (last !== undefined) log.info({ lane, model: routeLabel(chosen), connection: chosen.connection.label }, 'gateway: back on the first model of the fallback list');
     return;
   }
   const hold = holdOf(primary, now);
   log.info(
-    { from: routeLabel(primary), to: routeLabel(chosen), connection: chosen.connection.label, reason: hold?.reason ?? null, until: hold?.until ?? null },
+    { lane, from: routeLabel(primary), to: routeLabel(chosen), connection: chosen.connection.label, reason: hold?.reason ?? null, until: hold?.until ?? null },
     'gateway: the first model is over its limit, so requests go to a fallback model',
   );
 }

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

@@ -26,7 +26,7 @@ import {
   type Watch,
   type Refusal,
 } from './forward.js';
-import { chainOf, forgetFallbackState, noteChoice, noteRefused, routesToTry } from './fallback.js';
+import { chainOf, forgetFallbackState, noteChoice, noteRefused, routesToTry, type Lane } from './fallback.js';
 import {
   BINDING_BETA,
   cappedEffort,
@@ -34,12 +34,13 @@ import {
   forgetLearnedThinking,
   learnAlwaysThinks,
   plannedEffort,
+  requestKind,
   thinkingOff,
   withBlockBinding,
   withEffort,
   withThinkingFor,
 } from './effort.js';
-import { notReady, resolveRoute, routeLabel, type Connection, type ModelSetup, type Route } from './model-config.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';
 import { OPENROUTER_BASE } from './openrouter.js';
@@ -143,8 +144,8 @@ 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;
-  await upstream.body?.cancel();
-  log.warn({ connection, model }, 'gateway: Anthropic refused the request metro shaped, so it was sent again as Claude Code wrote it');
+  const reason = upstreamMessage(await upstream.text().catch(() => ''), '').slice(0, 300);
+  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);
 }
 
@@ -241,11 +242,23 @@ async function toCodex(req: IncomingMessage, res: ServerResponse, path: string,
   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> {
-  const effort = plannedEffort(req, sent);
+function shapedFor(req: IncomingMessage, sent: Record<string, unknown>, setup: ModelSetup): Record<string, unknown> {
+  const effort = plannedEffort(req, sent, setup.effort);
   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 = requestKind(req, sent) === 'subagent' ? helperSetup(setup) : null;
+  if (helpers === null) return { lane: 'main', setup, primary: resolveRoute(requested, setup) ?? noRoute() };
+  return { lane: 'helpers', setup: helpers, primary: pinnedRoute(requested, helpers) ?? noRoute() };
+}
+
 const bytesOf = (raw: Buffer, parsed: Record<string, unknown>, sent: Record<string, unknown>): Buffer => (sent === parsed ? raw : Buffer.from(JSON.stringify(sent)));
 
 interface Request {
@@ -299,12 +312,12 @@ async function dispatch(req: IncomingMessage, res: ServerResponse, path: string,
   const parsed = parseJson(raw);
   const sent = fitToolSearch(req, parsed);
   const requested = requestedModel(sent);
-  const primary = resolveRoute(requested, setup) ?? noRoute();
-  const ask: Request = { path, raw, parsed, sent, body: shapedFor(req, sent), setup };
-  const routes = routesToTry(chainOf(primary, setup, requested));
+  const { lane, setup: chain, primary } = chosenChain(req, sent, setup, requested);
+  const ask: Request = { path, raw, parsed, sent, body: shapedFor(req, sent, setup), 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);
+    if (path === MESSAGES) noteChoice(primary, route, lane);
     if (next === undefined) {
       await attempt(req, res, ask, route, deps);
       return;

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

@@ -1,9 +1,10 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import { EFFORT_DEFAULTS } from '@metro-labs/core/effort';
 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 './fallback.js';
-import { notReady, primaryRoute, type Connection, type ModelSetup } from './model-config.js';
+import { helperSetup, notReady, primaryRoute, type Connection, type ModelSetup } from './model-config.js';
 import { orgModels, type SyncStatus } from './org-models.js';
 import { lastServed } from './served.js';
 import { refreshUsage, type UsageDeps } from './usage-refresh.js';
@@ -41,6 +42,13 @@ function publicConnection(c: Connection): Record<string, unknown> {
 
 const setupOf = (deps: ModelApiDeps): ModelSetup => (deps.setup ?? (() => effectiveSetup()))();
 
+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) };
+}
+
 export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
   const setup = setupOf(deps);
   const primary = primaryRoute(setup);
@@ -55,6 +63,8 @@ export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
     connections: setup.connections.map(publicConnection),
     fallbacks: setup.fallbacks,
     chain: chainStatus(setup),
+    helpers: helpersBody(setup),
+    effort: { ...EFFORT_DEFAULTS, ...setup.effort },
     lastServed: lastServed(),
     usage: usageSeen(),
   };

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

@@ -1,3 +1,5 @@
+import type { RouteEffort } from '@metro-labs/core/effort';
+
 export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex', 'routeway'] as const;
 export type Provider = (typeof PROVIDERS)[number];
 export type CodexMethod = 'chatgpt' | 'code';
@@ -36,11 +38,18 @@ export interface Fallback {
   model: string;
 }
 
+export interface Chain {
+  primary: Fallback;
+  fallbacks: Fallback[];
+}
+
 export interface ModelSetup {
   primary: Fallback | null;
   fallbacks: Fallback[];
   connections: Connection[];
   source: RouteSource | null;
+  helpers?: Chain | null;
+  effort?: RouteEffort;
 }
 
 export interface Route {
@@ -119,6 +128,19 @@ export function resolveRoute(requested: string, setup: ModelSetup): Route | null
   return { connection: primary.connection, model: DEFAULTS[primary.connection.provider](bareModel(requested), primary.model) };
 }
 
+export function pinnedRoute(requested: string, setup: ModelSetup): Route | null {
+  const primary = primaryRoute(setup);
+  if (primary === null) return null;
+  const bare = bareModel(requested);
+  const passes = primary.connection.provider === 'anthropic' && (primary.model === '' || isSmallModel(bare));
+  return passes ? { connection: primary.connection, model: bare } : primary;
+}
+
+export function helperSetup(setup: ModelSetup): ModelSetup | null {
+  const helpers = setup.helpers ?? null;
+  return helpers === null ? null : { ...setup, primary: helpers.primary, fallbacks: helpers.fallbacks, helpers: null };
+}
+
 export const routeLabel = (route: Route): string =>
   route.connection.provider === 'anthropic' ? route.model : `${route.connection.provider}:${route.model}`;
 

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

@@ -42,7 +42,7 @@ export async function refreshUsage(setup: ModelSetup, deps: UsageDeps = {}, now
 export function watchFallbackUsage(setup: () => ModelSetup, deps: UsageDeps = {}, every = CREDITS_TTL_MS): void {
   const run = (): void => {
     const current = setup();
-    if (current.fallbacks.length === 0) return;
+    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');
     });

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.314"
+  "version": "0.1.0-beta.316"
 }

package/runtime/sdk-runner/node_modules/@metro-labs/core/package.json

@@ -19,6 +19,7 @@
     "./trains/protocol": "./src/protocol.ts",
     "./ids": "./src/ids.ts",
     "./claude-token": "./src/claude-token.ts",
+    "./effort": "./src/effort.ts",
     "./tickets": "./src/tickets.ts",
     "./station-names": "./src/station-names.ts",
     "./str": "./src/str.ts",

package/runtime/sdk-runner/node_modules/@metro-labs/core/src/effort.ts

@@ -0,0 +1,21 @@
+import { isRecord } from './is-record.js';
+
+export const EFFORT_LEVELS = ['low', 'medium', 'high', 'max', 'asked'] as const;
+
+export type EffortLevel = (typeof EFFORT_LEVELS)[number];
+
+export interface RouteEffort {
+  main?: EffortLevel;
+  helpers?: EffortLevel;
+}
+
+export const EFFORT_DEFAULTS: Required<RouteEffort> = { main: 'low', helpers: 'max' };
+
+export const isEffortLevel = (value: unknown): value is EffortLevel => typeof value === 'string' && (EFFORT_LEVELS as readonly string[]).includes(value);
+
+export function readEffort(raw: unknown): RouteEffort {
+  if (!isRecord(raw)) return {};
+  return { ...(isEffortLevel(raw.main) ? { main: raw.main } : {}), ...(isEffortLevel(raw.helpers) ? { helpers: raw.helpers } : {}) };
+}
+
+export const effortSet = (effort: RouteEffort): boolean => effort.main !== undefined || effort.helpers !== undefined;

package/runtime/sdk-runner/runner.json

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