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

package/dist/claude-env.js

@@ -90,7 +90,7 @@ async function verdict() {
     return { skip: 'the daemon is not serving here (stopped, or not running), so Claude Code talks to Anthropic directly' };
 }
 function gatewayLaunchEnv(key, port, claude, say) {
-    say(`inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Model page decides where)`);
+    say(`inference goes through the daemon at http://127.0.0.1:${String(port)}/gateway (the Gateway page decides where)`);
     const pointed = routeModelEnv(gatewayEnv(process.env, key, port), currentRoute());
     const searched = toolSearchEnv(pointed);
     if (searched !== pointed)
@@ -98,7 +98,7 @@ function gatewayLaunchEnv(key, port, claude, say) {
     const routed = cacheTtlEnv(searched);
     const env = credentialEnv(routed, key, claudeSignedIn(claude));
     if (env !== routed)
-        say("Claude Code has no login of its own here, so metro's key stands in as its credential; the organization's Models page decides where requests go");
+        say("Claude Code has no login of its own here, so metro's key stands in as its credential; the organization's Gateway page decides where requests go");
     return env;
 }
 export async function headlessEnv(claude, command) {

package/dist/cli.js

@@ -30,7 +30,7 @@ const USAGE = `metro: run your agent on this machine
                   follow this machine's inbound events, one JSON line each
   metro whoami    print the agent this machine runs
   metro agent     run chat, calls and background workers in one Agent SDK conversation,
-                  using the Model page's model through the daemon's model gateway;
+                  using the Gateway page's model through the daemon's model gateway;
                   resume it after a restart; call audio runs independently
   metro agent --prepare
                   install the Agent SDK runtime and the Claude Code it bundles if needed,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.321",
+  "version": "0.1.0-beta.323",
   "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/src/runner-activity.ts

@@ -8,17 +8,17 @@ export type RunnerTaskState = (typeof TASK_STATES)[number];
 export type RunnerEventKind = (typeof EVENTS)[number];
 
 const FAILURE = {
-  authentication: 'The provider refused authentication. Check the Model page.',
-  billing: 'The provider refused billing. Check the Model page.',
-  rate_limit: 'The provider rate limit was reached. Retry later or check the Model page.',
-  provider_unavailable: 'The provider is unavailable. Retry later or check the Model page.',
-  invalid_request: 'The provider rejected the request. Check Conversations and the Model page.',
+  authentication: 'The provider refused authentication. Check the Gateway page.',
+  billing: 'The provider refused billing. Check the Gateway page.',
+  rate_limit: 'The provider rate limit was reached. Retry later or check the Gateway page.',
+  provider_unavailable: 'The provider is unavailable. Retry later or check the Gateway page.',
+  invalid_request: 'The provider rejected the request. Check Conversations and the Gateway page.',
   output_limit: 'The model reached its output token limit. Check Conversations.',
-  provider_error: 'SDK turn failed (provider_error). Check Conversations and the Model page.',
-  error_during_execution: 'SDK turn failed (error_during_execution). Check Conversations and the Model page.',
-  error_max_turns: 'SDK turn failed (error_max_turns). Check Conversations and the Model page.',
-  error_max_budget_usd: 'SDK turn failed (error_max_budget_usd). Check Conversations and the Model page.',
-  error_max_structured_output_retries: 'SDK turn failed (error_max_structured_output_retries). Check Conversations and the Model page.',
+  provider_error: 'SDK turn failed (provider_error). Check Conversations and the Gateway page.',
+  error_during_execution: 'SDK turn failed (error_during_execution). Check Conversations and the Gateway page.',
+  error_max_turns: 'SDK turn failed (error_max_turns). Check Conversations and the Gateway page.',
+  error_max_budget_usd: 'SDK turn failed (error_max_budget_usd). Check Conversations and the Gateway page.',
+  error_max_structured_output_retries: 'SDK turn failed (error_max_structured_output_retries). Check Conversations and the Gateway page.',
   read_token_limit: 'Read exceeded its token limit. Read a smaller range with offset and limit, or search the file.',
   tool_error: 'A tool failed. See its result in Conversations.',
   task_error: 'A background task failed. See Conversations and Terminal.',
@@ -27,12 +27,12 @@ const FAILURE = {
   saved_state: 'The saved Agent SDK state cannot be read. Restore it before starting.',
   executable: 'The SDK executable could not start. Prepare the SDK runtime again.',
   module: 'The SDK runtime could not load a required module. Prepare the SDK runtime again.',
-  configuration: 'The SDK launch configuration is missing or invalid. Check Harness and the Model page before starting.',
+  configuration: 'The SDK launch configuration is missing or invalid. Check Harness and the Gateway page before starting.',
   process_exit: 'The SDK process exited unexpectedly. Check its reported exit code or signal before retrying.',
   connection: 'The SDK connection failed. Check the server and provider connection.',
   session_ended: 'The Agent SDK session ended unexpectedly.',
   interrupted: 'The SDK stopped before finishing a chat request. Check Conversations before retrying; actions may already have run.',
-  session_error: 'The Agent SDK session failed. Check Terminal and the Model page.',
+  session_error: 'The Agent SDK session failed. Check Terminal and the Gateway page.',
 } as const;
 export type RunnerFailureCode = keyof typeof FAILURE;
 

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

@@ -25,6 +25,7 @@
   "dependencies": {
     "@metro-labs/core": "workspace:*",
     "@metro-labs/http": "workspace:*",
+    "@metro-labs/inference": "workspace:*",
     "@metro-labs/discord-bot": "workspace:*",
     "@metro-labs/telegram": "workspace:*",
     "@metro-labs/telegram-bot": "workspace:*",

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

@@ -58,7 +58,7 @@ 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 '../gateway/usage-refresh.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 { removeModelLeftovers } from '../gateway/model-leftovers.js';

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

@@ -11,11 +11,12 @@ 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 { notReady, primaryRoute, type ModelSetup } from '../gateway/model-config.js';
+import { primaryRoute, 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();
@@ -128,12 +129,12 @@ export function prepareRunnerStore(): Promise<void> {
   });
 }
 
-const NO_MODEL = "the organization routes this agent to no model yet: choose one on the organization's Models page";
+const NO_MODEL = "the organization routes this agent to no model yet: choose one on the organization's Gateway page";
 
 function credentialReady(deps: SessionDeps): string | null {
   try {
     const primary = primaryRoute((deps.model ?? (() => effectiveSetup()))());
-    return primary === null ? NO_MODEL : notReady(primary);
+    return primary === null ? NO_MODEL : routeReadiness(primary);
   } catch (err) {
     return `the model setup is not readable (${errMsg(err)})`;
   }

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

@@ -0,0 +1,35 @@
+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/daemon/src/gateway/effective.ts

@@ -1,14 +1,8 @@
 import { log } from '@metro-labs/core/log';
-import type { Delivered } from './delivered.js';
-import { emptySetup, primaryRoute, runnerModel, type ModelSetup } from './model-config.js';
+import { setupOf, type Delivered } from '@metro-labs/inference/delivered';
+import { primaryRoute, runnerModel, type ModelSetup } from '@metro-labs/inference/model-config';
 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, helpers: route.helpers, effort: route.effort };
-}
-
 export const effectiveSetup = (delivered: Delivered | null = deliveredSetup()): ModelSetup => setupOf(delivered);
 
 export function modelViewText(setup: ModelSetup): string | null {

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

@@ -3,12 +3,13 @@ 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 { helperSetup, notReady, primaryRoute, type Connection, type ModelSetup } from './model-config.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 { orgModels, type SyncStatus } from './org-models.js';
-import { lastServed } from './served.js';
-import { refreshUsage, type UsageDeps } from './usage-refresh.js';
-import { usageSeen } from './usage.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';
@@ -21,7 +22,7 @@ export interface ModelApiDeps extends UsageDeps {
 }
 
 const NO_SYNC: SyncStatus = { enrolled: false, at: null, error: null };
-const NO_MODEL = "No model is set up for this agent yet: choose one on the organization's Models page.";
+const NO_MODEL = "No model is set up for this agent yet: choose one on the organization's Gateway page.";
 
 function publicConnection(c: Connection): Record<string, unknown> {
   return {
@@ -29,8 +30,8 @@ function publicConnection(c: Connection): Record<string, unknown> {
     provider: c.provider,
     label: c.label,
     model: c.model,
-    hasKey: c.apiKey !== '',
-    subscription: c.claudeToken !== '',
+    hasKey: c.apiKey !== '' || c.auth === 'key',
+    subscription: c.claudeToken !== '' || c.auth === 'subscription',
     region: c.region,
     zdr: c.zdr,
     signedOut: c.signedOut,
@@ -52,7 +53,7 @@ function helpersBody(setup: ModelSetup): Record<string, unknown> | null {
 export function settingsBody(deps: ModelApiDeps): Record<string, unknown> {
   const setup = setupOf(deps);
   const primary = primaryRoute(setup);
-  const reason = primary === null ? NO_MODEL : notReady(primary);
+  const reason = primary === null ? NO_MODEL : routeReadiness(primary);
   return {
     source: setup.source,
     sync: (deps.syncStatus ?? (() => orgModels()?.syncStatus() ?? NO_SYNC))(),

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

@@ -1,8 +1,8 @@
 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 type { Connection } from './model-config.js';
+import { deliveredOf, refreshedConnection, type Delivered } from '@metro-labs/inference/delivered';
+import type { Connection } from '@metro-labs/inference/model-config';
 
 const MODELS_PATH = '/api/agents/models';
 const REFRESH_PATH = '/api/agents/models/refresh';

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

@@ -0,0 +1,108 @@
+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 { usableServerUrl } from '../mcp-server/config.js';
+
+const PREFIX = '/gateway';
+const HELLO = '/api/hello';
+const ROUTES = new Set(['GET /v1/models', 'POST /v1/messages', 'POST /v1/messages/count_tokens']);
+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 UNREACHABLE = 'metro gateway: gateway.metro.box could not be reached. Claude Code retries.';
+
+export interface RelayDeps {
+  url: string;
+  identify: (key: string) => boolean;
+  token: () => string | null;
+  reregister: () => void;
+  fetch?: (url: string, init: RequestInit) => Promise<Response>;
+}
+
+let refused: string | undefined;
+
+export function gatewayUrl(env: NodeJS.ProcessEnv = process.env): string | null {
+  const raw = env.METRO_GATEWAY_URL?.trim() ?? DEFAULT_URL;
+  if (raw === '') return 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');
+  }
+  return null;
+}
+
+const keyOf = (req: IncomingMessage): string => {
+  const raw = req.headers['x-metro-key'];
+  return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
+};
+
+function upstreamHeaders(req: IncomingMessage, token: string): Record<string, string> {
+  const headers = forwardedHeaders(req);
+  for (const name of DROPPED) Reflect.deleteProperty(headers, name);
+  return { ...headers, authorization: `Bearer ${token}` };
+}
+
+async function relay(req: IncomingMessage, res: ServerResponse, path: string, deps: RelayDeps): Promise<void> {
+  const token = deps.token();
+  if (token === null) {
+    req.resume();
+    sendError(res, 503, 'api_error', NOT_LINKED);
+    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}`, {
+      method: req.method ?? 'GET',
+      headers: upstreamHeaders(req, token),
+      ...(body === undefined ? {} : { body: new Uint8Array(body) }),
+      signal: watch.signal,
+      redirect: 'manual',
+    });
+  } catch (err) {
+    watch.stop();
+    log.warn({ err: errMsg(err) }, 'gateway: gateway.metro.box could not be reached');
+    sendError(res, 502, 'api_error', UNREACHABLE);
+    return;
+  }
+  if (upstream.status === 401) {
+    await upstream.body?.cancel();
+    watch.stop();
+    deps.reregister();
+    sendError(res, 503, 'api_error', NOT_ACCEPTED);
+    return;
+  }
+  await pipeResponse(upstream, res, watch);
+}
+
+function refusal(req: IncomingMessage, path: string, deps: RelayDeps): [number, string, string] | null {
+  if (cameThroughProxy(req)) return [401, 'authentication_error', 'metro gateway: the agent key works only on this machine, not through its public address'];
+  if (keyOf(req) === '' || !deps.identify(keyOf(req))) return [401, 'authentication_error', 'metro gateway: no agent key (x-metro-key); start the agent with metro agent'];
+  return ROUTES.has(`${req.method ?? 'GET'} ${path}`) ? null : [404, 'not_found_error', 'not found'];
+}
+
+export function handleGatewayRelay(req: IncomingMessage, res: ServerResponse, deps: RelayDeps): boolean {
+  const full = req.url ?? '';
+  if (full !== PREFIX && !full.startsWith(`${PREFIX}/`)) return false;
+  const [path = '', query] = full.slice(PREFIX.length).split('?', 2);
+  if (req.method === 'HEAD' && path === HELLO) {
+    res.writeHead(200).end();
+    return true;
+  }
+  const refused = refusal(req, path, deps);
+  if (refused !== null) {
+    req.resume();
+    sendError(res, ...refused);
+    return true;
+  }
+  relay(req, res, query === undefined ? path : `${path}?${query}`, deps).catch((err: unknown) => {
+    log.warn({ err: errMsg(err) }, 'gateway: relaying a request failed');
+    if (!res.headersSent) sendError(res, 502, 'api_error', UNREACHABLE);
+    else res.end();
+  });
+  return true;
+}

package/runtime/node_modules/@metro-labs/daemon/src/mcp-server/config.ts

@@ -6,7 +6,7 @@ const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]']);
 
 let refused: string | undefined;
 
-function usable(raw: string): boolean {
+export function usableServerUrl(raw: string): boolean {
   let url: URL;
   try {
     url = new URL(raw);
@@ -20,7 +20,7 @@ function usable(raw: string): boolean {
 export function mcpServerUrl(env: NodeJS.ProcessEnv = process.env): string | null {
   const raw = env.METRO_MCP_SERVER_URL?.trim() ?? DEFAULT_URL;
   if (raw === '') return null;
-  if (usable(raw)) return raw.replace(/\/+$/, '');
+  if (usableServerUrl(raw)) return raw.replace(/\/+$/, '');
   if (refused !== raw) {
     refused = raw;
     log.warn({ url: raw }, 'mcp-server: METRO_MCP_SERVER_URL must be an https url (http only on this machine), so it is ignored');

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

@@ -1,5 +1,4 @@
 import { handleSessionApis, type SessionApis } from './session-apis.js';
-import { handleGatewayRequest } from '../gateway/gateway.js';
 import { handleThreemaCallback } from './threema-callback.js';
 import { BodyTooLargeError, readBody, WEBHOOK_BODY_MAX } from './body.js';
 
@@ -329,7 +328,7 @@ function handleSignInRoutes(
 
 function handleEarlyRoutes(req: IncomingMessage, res: ServerResponse, apis: SessionApis): boolean {
   if (handleHealth(req, res)) return true;
-  if (apis.gateway !== undefined && handleGatewayRequest(req, res, apis.gateway)) return true;
+  if (apis.gateway?.(req, res) === true) return true;
   if (handleSignInRoutes(req, res, apis)) return true;
   return handleSessionApis(req, res, apis);
 }

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 { effectiveSetup } from '../gateway/effective.js';
+import { boxGatewayHandler } from '../gateway/box-gateway.js';
 import type { StationName } from '@metro-labs/core/station-names';
 
 export interface LocalModeDeps {
@@ -148,7 +148,7 @@ export function localSessionApis(deps: LocalModeDeps): SessionApis {
     ownerApi: { setOwner: setLocalOwner },
     machineApi: {},
     modelApi: {},
-    gateway: { setup: () => effectiveSetup() },
+    gateway: boxGatewayHandler(),
     terminalApi: {},
     mode: localModeInfo,
   };

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

@@ -11,7 +11,6 @@ import { handleControlRequest, type ControlApiDeps } from '../server/control.js'
 import { handleOwnerRequest, type OwnerApiDeps } from '../server/owner.js';
 import { handleMachineRequest, type MachineApiDeps } from '../server/machine.js';
 import { handleModelRequest, type ModelApiDeps } from '../gateway/model-api.js';
-import type { GatewayDeps } from '../gateway/gateway.js';
 import { handleTerminalRequest, type TerminalApiDeps } from '../terminal/api.js';
 import { handleSchedulesRequest } from '../agent-user/schedules-api.js';
 import { handleFilesRequest } from '../agent-user/files-api.js';
@@ -26,7 +25,7 @@ export interface SessionApis {
   ownerApi?: OwnerApiDeps;
   machineApi?: MachineApiDeps;
   modelApi?: ModelApiDeps;
-  gateway?: GatewayDeps;
+  gateway?: (req: IncomingMessage, res: ServerResponse) => boolean;
   terminalApi?: TerminalApiDeps;
   claudeApi?: ClaudeApiDeps;
   enrollApi?: EnrollApiDeps;

package/runtime/node_modules/@metro-labs/http/src/api-http.ts

@@ -94,10 +94,23 @@ export function apiFailure(
     sendJson(req, res, err.status, { error: err.message });
     return;
   }
-  log.warn({ err: errMsg(err) }, `${label}: request failed`);
+  log.warn({ err: errMsg(err), ...causesOf(err) }, `${label}: request failed`);
   if (!res.headersSent) sendJson(req, res, 500, { error: `${label} failed` });
 }
 
+const CAUSES_MAX = 3;
+
+export function causesOf(err: unknown): { causes?: string[] } {
+  const causes: string[] = [];
+  let at = err instanceof Error ? err.cause : undefined;
+  while (at !== undefined && at !== null && causes.length < CAUSES_MAX) {
+    const code = typeof at === 'object' && 'code' in at && typeof at.code === 'string' ? `${at.code} ` : '';
+    causes.push(`${code}${errMsg(at)}`.slice(0, 300));
+    at = at instanceof Error ? at.cause : undefined;
+  }
+  return causes.length === 0 ? {} : { causes };
+}
+
 export interface SessionRoute {
   methods: Readonly<Record<string, readonly string[]>>;
   admin: boolean | readonly string[];

package/runtime/node_modules/@metro-labs/http/src/connector-tools.ts

@@ -42,10 +42,19 @@ function hintsOf(annotations: Record<string, unknown>): Pick<RemoteTool, 'destru
   return { ...(annotations.destructiveHint === true ? { destructive: true } : {}), ...(annotations.openWorldHint === true ? { openWorld: true } : {}) };
 }
 
+export function toolTitleOf(name: string): string {
+  const words = name.replace(/([a-z0-9])([A-Z])/g, '$1 $2').split(/[\s_\-.]+/).filter((word) => word !== '');
+  if (words.length === 0) return name;
+  const text = words.map((word, at) => (at > 0 && word !== word.toUpperCase() ? word.toLowerCase() : word)).join(' ');
+  return `${text.slice(0, 1).toUpperCase()}${text.slice(1)}`;
+}
+
+const filled = (value: unknown): string | null => (typeof value === 'string' && value.trim() !== '' ? value.trim() : null);
+
 function toTool(raw: unknown): RemoteTool | null {
   if (!isRecord(raw) || typeof raw.name !== 'string') return null;
   const annotations = isRecord(raw.annotations) ? raw.annotations : {};
-  const title = typeof raw.title === 'string' && raw.title !== '' ? raw.title : raw.name;
+  const title = filled(raw.title) ?? filled(annotations.title) ?? toolTitleOf(raw.name);
   return { name: raw.name, title, description: typeof raw.description === 'string' ? raw.description : '', readOnly: annotations.readOnlyHint === true, ...hintsOf(annotations), ...(isRecord(raw.inputSchema) ? { inputSchema: raw.inputSchema } : {}) };
 }
 

package/runtime/node_modules/@metro-labs/http/src/mcp-server-tools.ts

@@ -45,15 +45,29 @@ const callSchema = {
   additionalProperties: false,
 };
 
-function connectorsLine(keys: string[] | null): string {
-  if (keys === null) return 'The connectors of this agent are named here once Metro reaches mcp.metro.box.';
-  return keys.length === 0 ? 'This agent has no connectors it may use yet.' : `This agent's connectors: ${keys.join(', ')}.`;
+export interface ConnectorLabel {
+  key: string;
+  name: string;
+}
+
+const LABELS_MAX = 900;
+
+export function connectorLabel(connector: ConnectorLabel): string {
+  const name = connector.name.replace(/\s+/g, ' ').trim();
+  return name === '' || name.toLowerCase() === connector.key ? connector.key : `${connector.key} (${name})`;
+}
+
+function connectorsLine(connectors: ConnectorLabel[] | null): string {
+  if (connectors === null) return 'The connectors of this agent are named here once Metro reaches mcp.metro.box.';
+  if (connectors.length === 0) return 'This agent has no connectors it may use yet.';
+  const labels = connectors.map(connectorLabel).join(', ');
+  return `This agent's connectors: ${labels.length > LABELS_MAX ? connectors.map((connector) => connector.key).join(', ') : labels}.`;
 }
 
-export const toolSearchDescription = (keys: string[] | null): string =>
+export const toolSearchDescription = (connectors: ConnectorLabel[] | null): string =>
   [
     'Search the tools of every connector assigned to this agent: third-party services such as Notion, n8n, Linear or Gmail, run by mcp.metro.box. Same design as Claude Code\'s ToolSearch, for connectors.',
-    connectorsLine(keys),
+    connectorsLine(connectors),
     'Three query forms, one example each:',
     '- "select:notion.search" loads exact tools by name (comma separated for several).',
     '- "notion create page" ranks tools by the words in their name and description.',
@@ -84,12 +98,12 @@ const toolCallDescription = (place: ApprovalPlace): string =>
 
 export const TOOL_CALL_DESCRIPTION = toolCallDescription('session');
 
-export function mcpServerTools(keys: string[] | null, place: ApprovalPlace = 'session'): McpServerTool[] {
+export function mcpServerTools(connectors: ConnectorLabel[] | null, place: ApprovalPlace = 'session'): McpServerTool[] {
   return [
     {
       name: TOOL_SEARCH,
       title: 'Search connector tools',
-      description: toolSearchDescription(keys),
+      description: toolSearchDescription(connectors),
       inputSchema: searchSchema,
       annotations: { title: 'Search connector tools', readOnlyHint: true, openWorldHint: false },
     },

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

@@ -0,0 +1,42 @@
+{
+  "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.",
+  "type": "module",
+  "exports": {
+    "./attempts": "./src/attempts.ts",
+    "./codex": "./src/codex.ts",
+    "./codex-stream": "./src/codex-stream.ts",
+    "./codex-translate": "./src/codex-translate.ts",
+    "./codex-version": "./src/codex-version.ts",
+    "./delivered": "./src/delivered.ts",
+    "./effort": "./src/effort.ts",
+    "./eventstream": "./src/eventstream.ts",
+    "./failures": "./src/failures.ts",
+    "./fallback": "./src/fallback.ts",
+    "./forward": "./src/forward.ts",
+    "./frames": "./src/frames.ts",
+    "./gateway": "./src/gateway.ts",
+    "./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"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@metro-labs/core": "workspace:*",
+    "@metro-labs/http": "workspace:*"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.3",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}