@stage-labs/metro 0.1.0-beta.311 → 0.1.0-beta.313

package/dist/route.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentsDir } from './local.js';
-const PROVIDERS = new Set(['bedrock', 'openrouter', 'codex', 'gemini']);
+const PROVIDERS = new Set(['bedrock', 'openrouter', 'codex', 'gemini', 'routeway']);
 const ANTHROPIC = 'anthropic';
 const text = (value) => (typeof value === 'string' ? value : '');
 function routedIn(cfg) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.311",
+  "version": "0.1.0-beta.313",
   "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/gateway/gateway.ts

@@ -43,6 +43,7 @@ import { notReady, resolveRoute, routeLabel, type Connection, type ModelSetup, t
 import { codexMessages, type CodexDeps } from './codex.js';
 import { countTokens } from './subscription.js';
 import { OPENROUTER_BASE } from './openrouter.js';
+import { refusedWithPage, ROUTEWAY_BASE, routewayHeaders, routewayTools } from './routeway.js';
 import { isRecord } from '@metro-labs/core/is-record';
 import { forgetServed, noteServed } from './served.js';
 import { forgetUsage, noteUsageHeaders, UsageScanner } from './usage.js';
@@ -63,6 +64,7 @@ export interface GatewayDeps {
   anthropicBase?: string;
   bedrockBase?: string;
   openrouterBase?: string;
+  routewayBase?: string;
   codex?: Partial<CodexDeps>;
 }
 
@@ -118,13 +120,21 @@ interface Payloads {
   bound: boolean;
 }
 
-function anthropicPayloads(raw: Buffer, sent: Record<string, unknown>, shaped: Record<string, unknown>, model: string): Payloads {
+interface Shaped {
+  raw: Buffer;
+  sent: Record<string, unknown>;
+  shaped: Record<string, unknown>;
+  bind: boolean;
+}
+
+function anthropicPayloads({ raw, sent, shaped, bind }: Shaped, model: string): Payloads {
   const runnable = withThinkingFor(sent, model);
   const rewrite = runnable !== sent || (typeof sent.model === 'string' && sent.model !== model);
   const asSent = rewrite ? Buffer.from(JSON.stringify({ ...runnable, model })) : raw;
-  const bound = withBlockBinding(withThinkingFor(shaped, model));
+  const fitted = withThinkingFor(shaped, model);
+  const bound = bind ? withBlockBinding(fitted) : fitted;
   if (bound === sent) return { metro: asSent, asSent: null, bound: false };
-  return { metro: Buffer.from(JSON.stringify(rewrite ? { ...bound, model } : bound)), asSent, bound: bound !== shaped };
+  return { metro: Buffer.from(JSON.stringify(rewrite ? { ...bound, model } : bound)), asSent, bound: bind && bound !== shaped };
 }
 
 type Send = (payload: Buffer, headers: Record<string, string>) => Promise<Response>;
@@ -153,32 +163,40 @@ async function refusedSubscription(conn: Connection, upstream: Response, watch:
   throw new SubscriptionRefused(conn.label);
 }
 
-async function toAnthropic(
-  req: IncomingMessage,
-  res: ServerResponse,
-  raw: Buffer,
-  sent: Record<string, unknown>,
-  shaped: Record<string, unknown>,
-  route: Route,
-  deps: GatewayDeps,
-): Promise<void> {
+async function shapedAttempt(send: Send, base: Record<string, string>, body: Shaped, route: Route): Promise<Response> {
+  const shape = (): Promise<Response> => asAnthropicWants(send, base, anthropicPayloads(body, route.model), route.connection.label, route.model);
+  const first = await shape();
+  return (await refusedThinkingOff(first, body.shaped, route.model)) ? shape() : first;
+}
+
+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);
+
+async function toAnthropic(req: IncomingMessage, res: ServerResponse, body: Shaped, route: Route, deps: GatewayDeps): Promise<void> {
   const conn = route.connection;
-  const url = `${deps.anthropicBase ?? ANTHROPIC_API}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
   const watch = watchUpstream(res);
-  const send = (payload: Buffer, headers: Record<string, string>): Promise<Response> =>
-    fetch(url, { method: 'POST', headers, body: new Uint8Array(payload), signal: watch.signal, redirect: 'manual' });
-  const attempt = async (base: Record<string, string>): Promise<Response> => {
-    const shape = (): Promise<Response> => asAnthropicWants(send, base, anthropicPayloads(raw, sent, shaped, route.model), conn.label, route.model);
-    const first = await shape();
-    return (await refusedThinkingOff(first, shaped, route.model)) ? shape() : first;
-  };
-  const upstream = await attempt(conn.apiKey !== '' ? anthropicHeaders(req, conn.apiKey) : loginHeaders(req, conn.claudeToken));
+  const send = sender(`${deps.anthropicBase ?? ANTHROPIC_API}${upstreamPath(req)}`, watch);
+  const upstream = await shapedAttempt(send, conn.apiKey !== '' ? anthropicHeaders(req, conn.apiKey) : loginHeaders(req, conn.claudeToken), body, route);
   await refusedSubscription(conn, upstream, watch);
   noteRefusal(conn.label, route.model, upstream);
   noteUsageHeaders('anthropic', conn.id, upstream.headers);
   await pipeResponse(upstream, res, watch, { ownCredential: true, scanner: new UsageScanner(conn.id) });
 }
 
+async function toRouteway(req: IncomingMessage, res: ServerResponse, body: Shaped, route: Route, deps: GatewayDeps): Promise<void> {
+  const conn = route.connection;
+  const watch = watchUpstream(res);
+  const send = sender(`${deps.routewayBase ?? ROUTEWAY_BASE}${upstreamPath(req)}`, watch);
+  const sent = routewayTools(body.sent);
+  const fitted: Shaped = { raw: sent === body.sent ? body.raw : Buffer.from(JSON.stringify(sent)), sent, shaped: routewayTools(body.shaped), bind: false };
+  const upstream = await shapedAttempt(send, routewayHeaders(req, conn.apiKey), fitted, route);
+  noteRefusal(conn.label, route.model, upstream);
+  await refusedWithPage(upstream, watch);
+  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id) });
+}
+
 async function toOpenRouter(req: IncomingMessage, res: ServerResponse, body: Record<string, unknown>, route: Route, deps: GatewayDeps): Promise<void> {
   const conn = route.connection;
   const headers: Record<string, string> = {
@@ -260,7 +278,8 @@ async function attempt(req: IncomingMessage, res: ServerResponse, ask: Request,
     await toCodex(req, res, path, body, route, deps);
     return;
   }
-  await toAnthropic(req, res, bytesOf(ask.raw, ask.parsed, ask.sent), ask.sent, body, route, deps);
+  const shaped: Shaped = { raw: bytesOf(ask.raw, ask.parsed, ask.sent), sent: ask.sent, shaped: body, bind: true };
+  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> {

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

@@ -1,4 +1,4 @@
-export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex'] as const;
+export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex', 'routeway'] as const;
 export type Provider = (typeof PROVIDERS)[number];
 export type CodexMethod = 'chatgpt' | 'code';
 export type RouteSource = 'agent' | 'organization';
@@ -50,7 +50,7 @@ export interface Route {
 
 export const CODEX_SIGN_IN = "Codex is not signed in: sign in again on the organization's Models page.";
 
-const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex):(.+)$/;
+const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex|routeway):(.+)$/;
 const SMALL_RE = /haiku/i;
 
 export const isProvider = (value: unknown): value is Provider => typeof value === 'string' && (PROVIDERS as readonly string[]).includes(value);
@@ -60,10 +60,12 @@ export const emptySetup = (): ModelSetup => ({ primary: null, fallbacks: [], con
 export const connectionOf = (setup: ModelSetup, id: string): Connection | null => setup.connections.find((c) => c.id === id) ?? null;
 
 export function primaryRoute(setup: ModelSetup): Route | null {
-  const primary = setup.primary;
-  const conn = primary === null ? null : connectionOf(setup, primary.connection);
-  if (primary === null || conn === null) return null;
-  return { connection: conn, model: primary.model === '' ? conn.model : primary.model };
+  const steps = setup.primary === null ? [] : [setup.primary, ...setup.fallbacks];
+  for (const step of steps) {
+    const conn = connectionOf(setup, step.connection);
+    if (conn !== null) return { connection: conn, model: step.model === '' ? conn.model : step.model };
+  }
+  return null;
 }
 
 const CHECKS: Record<Provider, [(r: Route) => boolean, string][]> = {
@@ -80,6 +82,10 @@ const CHECKS: Record<Provider, [(r: Route) => boolean, string][]> = {
     [(r) => r.connection.codex === null, CODEX_SIGN_IN],
     [(r) => r.model === '', "Codex needs a model id: choose one on the organization's Models 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."],
+  ],
 };
 
 export const notReady = (route: Route): string | null => CHECKS[route.connection.provider].find(([missing]) => missing(route))?.[1] ?? null;
@@ -90,6 +96,7 @@ const DEFAULTS: Record<Provider, (requested: string, model: string) => string> =
   openrouter: (requested, model) => (requested.includes('/') ? requested : model),
   bedrock: (requested, model) => (model === '' ? requested : model),
   codex: (requested, model) => (requested.startsWith('gpt-') ? requested : model),
+  routeway: (_requested, model) => model,
   anthropic: (requested, model) => (model === '' || isSmallModel(requested) ? requested : model),
 };
 

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

@@ -0,0 +1,32 @@
+import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { anthropicHeaders, GatewayError, type Watch } from './forward.js';
+
+export const ROUTEWAY_BASE = 'https://api.routeway.ai';
+const USER_AGENT = 'metro (+https://metro.box)';
+const HANDED_OVER = new Set([402, 429]);
+
+export function routewayHeaders(req: IncomingMessage, apiKey: string): Record<string, string> {
+  const headers = anthropicHeaders(req, apiKey);
+  headers['user-agent'] ??= USER_AGENT;
+  return headers;
+}
+
+export async function refusedWithPage(upstream: Response, watch: Watch): Promise<void> {
+  if (upstream.ok || HANDED_OVER.has(upstream.status) || !(upstream.headers.get('content-type') ?? '').includes('text/html')) return;
+  await upstream.body?.cancel();
+  watch.stop();
+  throw new GatewayError(502, 'api_error', `metro gateway: Routeway answered with a web page instead of its API (${String(upstream.status)}); try again in a moment`);
+}
+
+function withProperties(tool: unknown): unknown {
+  if (!isRecord(tool) || !isRecord(tool.input_schema) || Object.hasOwn(tool.input_schema, 'properties')) return tool;
+  return { ...tool, input_schema: { ...tool.input_schema, properties: {} } };
+}
+
+export function routewayTools(body: Record<string, unknown>): Record<string, unknown> {
+  const listed: unknown = body.tools;
+  if (!Array.isArray(listed)) return body;
+  const tools: unknown[] = listed.map(withProperties);
+  return tools.some((tool, at) => tool !== listed[at]) ? { ...body, tools } : body;
+}

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

@@ -10,7 +10,7 @@ export const CALL_TIMEOUT_MS = 120_000;
 const LIST_TIMEOUT_MS = 15_000;
 const REFRESH_MS = 5 * 60_000;
 
-export const NOT_SET_UP = 'Connectors are not set up on this agent: enroll it in its organization on the Server page of metro.box, then try again.';
+export const NOT_SET_UP = 'Connectors are not set up on this agent yet: it links to its organization once an admin of the organization opens its page on metro.box. Try again after that.';
 export const UNAVAILABLE = 'mcp.metro.box is unavailable, try again.';
 
 export interface ConnectorResult {

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

@@ -33,7 +33,7 @@ export function requireAdmin(session: ApiSession): void {
 export function cors(req: IncomingMessage): Record<string, string> {
   return {
     'access-control-allow-origin': req.headers.origin ?? '*',
-    'access-control-allow-methods': 'GET, POST, PUT, DELETE, OPTIONS',
+    'access-control-allow-methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
     'access-control-allow-headers': 'Authorization, Content-Type',
     'access-control-allow-private-network': 'true',
     'access-control-max-age': '86400',

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

@@ -9,6 +9,8 @@ export interface RemoteTool {
   title: string;
   description: string;
   readOnly: boolean;
+  destructive?: boolean;
+  openWorld?: boolean;
   inputSchema?: Record<string, unknown>;
 }
 
@@ -36,11 +38,15 @@ async function rpc(url: URL, auth: ConnectorAuth, session: Map<string, string>,
   return resultOf(text, res.headers.get('content-type') ?? '');
 }
 
+function hintsOf(annotations: Record<string, unknown>): Pick<RemoteTool, 'destructive' | 'openWorld'> {
+  return { ...(annotations.destructiveHint === true ? { destructive: true } : {}), ...(annotations.openWorldHint === true ? { openWorld: true } : {}) };
+}
+
 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;
-  return { name: raw.name, title, description: typeof raw.description === 'string' ? raw.description : '', readOnly: annotations.readOnlyHint === true, ...(isRecord(raw.inputSchema) ? { inputSchema: raw.inputSchema } : {}) };
+  return { name: raw.name, title, description: typeof raw.description === 'string' ? raw.description : '', readOnly: annotations.readOnlyHint === true, ...hintsOf(annotations), ...(isRecord(raw.inputSchema) ? { inputSchema: raw.inputSchema } : {}) };
 }
 
 async function endSession(url: URL, auth: ConnectorAuth, session: Map<string, string>, fetchImpl?: FetchLike): Promise<void> {

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.311"
+  "version": "0.1.0-beta.313"
 }

package/runtime/sdk-runner/runner.json

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

package/runtime/sdk-runner/src/activity.ts

@@ -7,7 +7,7 @@ import { runnerFailureSummary, type RunnerActivity, type RunnerDiagnostic, type
 import { writeAtomic } from '@metro-labs/core/secure-fs';
 import { ActivityTasks, activityName } from './activity-tasks.js';
 import type { ApprovalAsk } from './approvals.js';
-import type { SavedTask } from './task-state.js';
+import { sdkTask, type SavedTask } from './task-state.js';
 import { sessionFailure } from './errors.js';
 export { failureSummary } from './errors.js';
 
@@ -94,10 +94,11 @@ export class Activity {
   }
 
   recover(tasks: SavedTask[]): void {
-    this.tasks.restore(tasks.map((task) => ({
-      id: task.id, kind: null, agent: null, status: task.state === 'interrupted' ? 'unknown' : task.state,
+    const workers = tasks.filter(sdkTask);
+    this.tasks.restore(workers.map((task) => ({
+      id: task.id, kind: null, agent: null, status: task.state === 'interrupted' ? 'unknown' : task.state, ...(task.description === undefined ? {} : { description: task.description }),
       background: true, startedAt: 0, updatedAt: task.updatedAt, endedAt: null, lastTool: null, toolUses: 0, durationMs: 0,
-    })), tasks.flatMap((task) => task.toolUseId === null ? [] : [[task.toolUseId, task.id]]));
+    })), workers.flatMap((task) => task.toolUseId === null ? [] : [[task.toolUseId, task.id]]));
     for (const task of tasks) {
       if (task.notice === null) continue;
       const code = task.notice.reason === 'worker_restart' ? 'interrupted' : task.notice.reason;

package/runtime/sdk-runner/src/task-ledger.ts

@@ -1,4 +1,5 @@
 import { isRecord } from '@metro-labs/core/is-record';
+import { runnerTaskDescription } from '@metro-labs/core/runner-activity';
 import { activityName } from './activity-tasks.js';
 import type { Unanswered } from './inbox.js';
 import { pendingNotice, TASK_LIMIT, type SavedTask, type TaskReason } from './task-state.js';
@@ -67,9 +68,11 @@ export class TaskLedger {
   changed(handled?: ReadonlySet<string>): void { this.save(this.snapshot(), handled); }
 
   private taskEvent(id: string, m: Record<string, unknown>, event: string | null, now: number): void {
-    if (m.subtype === 'task_started') this.start(id, m.tool_use_id, event, now);
+    const known = this.rows.get(id);
+    if (m.subtype === 'task_started') this.start(id, m.tool_use_id, event, now, m.description);
     else if (m.subtype === 'task_notification') this.end(id, m, event, now);
-    else if (m.subtype === 'task_updated' && isRecord(m.patch) && this.rows.has(id)) {
+    else if (m.subtype === 'task_updated' && isRecord(m.patch) && known !== undefined) {
+      if (this.describe(known, m.patch.description)) this.save(this.snapshot());
       this.end(id, { status: m.patch.status === 'killed' ? 'stopped' : m.patch.status, summary: m.patch.error }, event, now);
     } else if (m.subtype === 'task_progress') this.progress(id, m.tool_use_id, now);
   }
@@ -114,10 +117,11 @@ export class TaskLedger {
     return task;
   }
 
-  private start(id: string, rawTool: unknown, event: string | null, now: number): void {
+  private start(id: string, rawTool: unknown, event: string | null, now: number, description?: unknown): void {
     const task = this.get(id, now);
     if (task.state !== 'running') task.attempt += 1;
     task.state = 'running';
+    this.describe(task, description);
     if (event !== null) task.events = [...task.events, event].slice(-16);
     task.updatedAt = now;
     task.toolUseId = activityName(rawTool) ?? task.toolUseId;
@@ -165,13 +169,24 @@ export class TaskLedger {
 
   private background(m: Record<string, unknown>, now: number): void {
     if (!Array.isArray(m.tasks)) return;
+    let described = false;
     for (const row of m.tasks) {
       if (!isRecord(row)) continue;
       const id = activityName(row.task_id);
       if (id === null) continue;
+      const known = this.rows.get(id);
       if (row.ambient === true) this.hide(id);
-      else if (!this.rows.has(id)) this.start(id, undefined, activityName(m.uuid), now);
+      else if (known === undefined) this.start(id, undefined, activityName(m.uuid), now, row.description);
+      else described = this.describe(known, row.description) || described;
     }
+    if (described) this.save(this.snapshot());
+  }
+
+  private describe(task: SavedTask, raw: unknown): boolean {
+    const description = runnerTaskDescription(raw);
+    if (description === null || description === task.description) return false;
+    task.description = description;
+    return true;
   }
 
   private content(m: Record<string, unknown>, now: number): void {

package/runtime/sdk-runner/src/task-state.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { isRecord } from '@metro-labs/core/is-record';
+import { runnerTaskDescription } from '@metro-labs/core/runner-activity';
 import { activityName } from './activity-tasks.js';
 import type { Uuid } from './inbox.js';
 
@@ -26,6 +27,7 @@ export interface SavedTask {
   attempt: number;
   handledAttempt?: number;
   state: (typeof STATES)[number];
+  description?: string;
   events: string[];
   updatedAt: number;
   notice: TaskNotice | null;
@@ -35,6 +37,7 @@ const integer = (raw: unknown): raw is number => typeof raw === 'number' && Numb
 const name = (raw: unknown): raw is string | null => raw === null || activityName(raw) !== null;
 const reason = (raw: unknown): raw is TaskReason => REASONS.some((value) => value === raw);
 const optionalInteger = (raw: unknown): boolean => raw === undefined || integer(raw);
+const description = (raw: unknown): boolean => raw === undefined || (typeof raw === 'string' && runnerTaskDescription(raw) === raw);
 const optionalUuid = (raw: unknown): boolean => raw === undefined || (typeof raw === 'string' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(raw));
 
 function notice(raw: unknown): raw is TaskNotice | null {
@@ -45,14 +48,17 @@ function notice(raw: unknown): raw is TaskNotice | null {
 }
 
 const events = (raw: unknown): boolean => Array.isArray(raw) && raw.length <= 16 && raw.every((event) => activityName(event) !== null);
+const optionalFields = (raw: Record<string, unknown>): boolean => optionalInteger(raw.handledAttempt) && description(raw.description);
 
 function task(raw: unknown): raw is SavedTask {
   if (!isRecord(raw) || activityName(raw.id) === null) return false;
   if (![raw.toolUseId, raw.owner, raw.parentToolUseId ?? null].every(name)) return false;
-  if (!events(raw.events) || !optionalInteger(raw.handledAttempt)) return false;
+  if (!events(raw.events) || !optionalFields(raw)) return false;
   return integer(raw.attempt) && integer(raw.updatedAt) && STATES.some((state) => state === raw.state) && notice(raw.notice);
 }
 
+export const sdkTask = (task: SavedTask): boolean => !/^(?:input|turn):/.test(task.id);
+
 export function savedTasks(raw: unknown): SavedTask[] {
   if (raw === undefined) return [];
   if (!Array.isArray(raw) || raw.length > TASK_LIMIT || !raw.every(task) || new Set(raw.map((row) => row.id)).size !== raw.length)