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

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.312",
   "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 } 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,38 @@ 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 upstream = await shapedAttempt(send, routewayHeaders(req, conn.apiKey), { ...body, bind: false }, 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 +276,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,19 @@
+import type { IncomingMessage } from 'node:http';
+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`);
+}

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.312"
 }

package/runtime/sdk-runner/runner.json

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