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

package/dist/claude-env.js

@@ -11,6 +11,7 @@ const RM_PROMPT_OFF = 'CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT';
 const OWN_CREDENTIALS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
 const CACHE_TTLS = ['CLAUDE_CODE_PROMPT_CACHE_TTL', 'CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL'];
 const LONG_CACHE = '1h';
+const HINT_HEADERS = 'CLAUDE_CODE_GATEWAY_HINT_HEADERS';
 export const AGENT_VIEW_OFF = 'CLAUDE_CODE_DISABLE_AGENT_VIEW';
 export const NO_UPDATES = { DISABLE_AUTOUPDATER: '1' };
 const set = (env, name) => (env[name] ?? '').trim() !== '';
@@ -29,6 +30,7 @@ export function gatewayEnv(base, agentKey, port) {
         ANTHROPIC_BASE_URL: `http://127.0.0.1:${String(port)}/gateway`,
         ANTHROPIC_CUSTOM_HEADERS: own === '' ? mine : `${own}\n${mine}`,
         CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: '1',
+        [HINT_HEADERS]: set(base, HINT_HEADERS) ? base[HINT_HEADERS] : '1',
     };
 }
 export const toolSearchEnv = (env) => set(env, 'ENABLE_TOOL_SEARCH') ? env : { ...env, ENABLE_TOOL_SEARCH: 'true' };

package/package.json

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

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import { log } from '@metro-labs/core/log';
 import { withoutCacheTtl, withoutTtlBeta } from './cache-ttl.js';
 import { EventStreamDecoder, type EventStreamMessage } from './eventstream.js';
+import { noteFailure, type FailureSite } from './failures.js';
 import { errorFrame, providerStatus, relayFrames, sendError, upstreamMessage, type Watch } from './forward.js';
 import type { Connection } from './model-config.js';
 import { estimateTokens } from './subscription.js';
@@ -177,7 +178,7 @@ function eventTypeOf(event: string): string {
   }
 }
 
-function eventFrame(message: EventStreamMessage): string {
+function eventFrame(message: EventStreamMessage, site: FailureSite): string {
   if (message.headers[':message-type'] === 'event') {
     const parsed = JSON.parse(message.payload.toString('utf8')) as { bytes?: unknown };
     if (typeof parsed.bytes !== 'string') return '';
@@ -185,14 +186,16 @@ function eventFrame(message: EventStreamMessage): string {
     return `event: ${eventTypeOf(event)}\ndata: ${event}\n\n`;
   }
   const errorType = message.headers[':exception-type'] ?? message.headers[':error-code'] ?? null;
-  return errorFrame(errorKind(500, errorType), upstreamMessage(message.payload.toString('utf8'), 'Bedrock stream error'));
+  const text = upstreamMessage(message.payload.toString('utf8'), 'Bedrock stream error');
+  noteFailure(site, { code: errorType ?? '', message: text }, 'gateway: the provider sent an error in the middle of its stream');
+  return errorFrame(errorKind(500, errorType), text);
 }
 
-function relayStream(upstream: Response, res: ServerResponse, watch: Watch, key: string): Promise<void> {
+function relayStream(upstream: Response, res: ServerResponse, watch: Watch, key: string, site: FailureSite): Promise<void> {
   const decoder = new EventStreamDecoder();
   return relayFrames(upstream, res, watch, key, {
     push: (chunk, emit) => {
-      for (const message of decoder.push(Buffer.from(chunk))) emit(eventFrame(message));
+      for (const message of decoder.push(Buffer.from(chunk))) emit(eventFrame(message, site));
     },
     close: () => '',
     idle: (message) => errorFrame('api_error', message),
@@ -218,7 +221,7 @@ export async function bedrockMessages(
     return;
   }
   if (rewritten.stream) {
-    await relayStream(upstream, res, up.watch, up.settings.id);
+    await relayStream(upstream, res, up.watch, up.settings.id, { connection: up.settings.label, model });
     return;
   }
   const text = await upstream.text();

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

@@ -1,6 +1,7 @@
 import { isRecord } from '@metro-labs/core/is-record';
 import { encodeSignature } from './codex-translate.js';
 import { errorFrame } from './forward.js';
+import type { Failure } from './failures.js';
 import { frame, messageEnd, messageStart, type Usage } from './frames.js';
 import { stringOf } from '@metro-labs/http/api-http';
 
@@ -13,6 +14,7 @@ interface Block {
 }
 
 const responseOf = (data: Item): Item => (isRecord(data.response) ? data.response : {});
+const reasonOf = (response: Item): string => (isRecord(response.incomplete_details) ? stringOf(response.incomplete_details.reason) : '');
 const itemOf = (data: Item): Item => (isRecord(data.item) ? data.item : {});
 
 const PLAN_LIMIT = 'subscription_sharing_usage_limit_exceeded';
@@ -53,6 +55,7 @@ export class CodexEventTranslator {
   private done = false;
   private readonly model: string;
   private readonly restore: (name: string) => string;
+  private readonly report: (failure: Failure) => void;
   private readonly handlers: Record<string, (data: Item) => string> = {
     'response.created': (d) => this.start(responseOf(d)),
     'response.output_item.added': (d) => this.start({}) + this.itemAdded(itemOf(d)),
@@ -67,9 +70,10 @@ export class CodexEventTranslator {
     error: (d) => this.failed({ error: d }, 'Codex stream error'),
   };
 
-  constructor(model: string, restore: (name: string) => string = (name) => name) {
+  constructor(model: string, restore: (name: string) => string = (name) => name, report: (failure: Failure) => void = () => undefined) {
     this.model = model;
     this.restore = restore;
+    this.report = report;
   }
 
   get finished(): boolean {
@@ -154,16 +158,18 @@ export class CodexEventTranslator {
   }
 
   private incomplete(response: Item): string {
-    const details = isRecord(response.incomplete_details) ? response.incomplete_details : {};
-    if (details.reason === 'max_output_tokens') return this.start(response) + this.completed(response, 'max_tokens');
-    return this.failed(response, `Codex left the response incomplete (${stringOf(details.reason) || 'no reason given'})`);
+    const reason = reasonOf(response);
+    if (reason === 'max_output_tokens') return this.start(response) + this.completed(response, 'max_tokens');
+    return this.failed(response, `Codex left the response incomplete (${reason || 'no reason given'})`);
   }
 
   private failed(response: Item, fallback: string): string {
     this.done = true;
     const error = isRecord(response.error) ? response.error : {};
     const code = stringOf(error.code);
-    return errorFrame(errorKind(code), withUsageLink(code, stringOf(error.message) || fallback));
+    const message = stringOf(error.message) || fallback;
+    this.report({ code: code || reasonOf(response), message });
+    return errorFrame(errorKind(code), withUsageLink(code, message));
   }
 
   push(event: string, data: Item): string {
@@ -174,6 +180,7 @@ export class CodexEventTranslator {
   close(message = 'Codex ended the stream before completing the response'): string {
     if (this.done) return '';
     this.done = true;
+    this.report({ code: '', message });
     return errorFrame('api_error', message);
   }
 }

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

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { arch, platform, release } from 'node:os';
 import { isRecord } from '@metro-labs/core/is-record';
@@ -7,6 +7,8 @@ import { stringOf } from '@metro-labs/http/api-http';
 import { codexVersion, learnCodexVersion } from './codex-version.js';
 import { CodexEventTranslator, withUsageLink } from './codex-stream.js';
 import { ToolNames, toResponsesRequest } from './codex-translate.js';
+import { agentIdOf } from './effort.js';
+import { noteFailure, type Failure, type FailureSite } from './failures.js';
 import { GatewayError, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
 import { parseEvent, SseParser, type SseEvent } from './frames.js';
 import { CODEX_SIGN_IN, type CodexAccess, type Connection } from './model-config.js';
@@ -46,24 +48,30 @@ function headersFor(access: CodexAccess, sessionId: string): Record<string, stri
 interface Call {
   body: Record<string, unknown>;
   model: string;
-  sessionId: string;
+  threadKey: string;
   watch: Watch;
   deps: CodexDeps;
   names: ToolNames;
 }
 
+function threadKey(req: IncomingMessage): string {
+  const session = sessionHeader(req) || randomUUID();
+  const agent = agentIdOf(req);
+  return agent === '' ? session : createHash('sha256').update(`${session}\n${agent}`).digest('base64url');
+}
+
 function send(call: Call, access: CodexAccess): Promise<Response> {
-  const request = toResponsesRequest(call.body, call.model, { promptCacheKey: call.sessionId, names: call.names });
+  const request = toResponsesRequest(call.body, call.model, { promptCacheKey: call.threadKey, names: call.names });
   return (call.deps.fetchImpl ?? fetch)(`${baseFor(access, call.deps)}/responses`, {
     method: 'POST',
-    headers: headersFor(access, call.sessionId),
+    headers: headersFor(access, call.threadKey),
     body: JSON.stringify(request),
     signal: call.watch.signal,
     redirect: 'manual',
   });
 }
 
-function refusalOf(text: string, status: number): string {
+function refusalOf(text: string, status: number): Failure {
   let code = '';
   try {
     const parsed: unknown = JSON.parse(text);
@@ -71,7 +79,7 @@ function refusalOf(text: string, status: number): string {
   } catch {
     code = '';
   }
-  return withUsageLink(code, upstreamMessage(text, `OpenAI answered ${String(status)}`));
+  return { code, message: upstreamMessage(text, `OpenAI answered ${String(status)}`), status };
 }
 
 let learning: Promise<unknown> | null = null;
@@ -99,15 +107,23 @@ async function reach(call: Call, conn: Connection): Promise<Response> {
 }
 
 export async function codexMessages(req: IncomingMessage, res: ServerResponse, body: Record<string, unknown>, model: string, conn: Connection, deps: CodexDeps, watch: Watch): Promise<void> {
-  const call: Call = { body, model, sessionId: sessionHeader(req) || randomUUID(), watch, deps, names: new ToolNames() };
+  const call: Call = { body, model, threadKey: threadKey(req), watch, deps, names: new ToolNames() };
+  const site: FailureSite = { connection: conn.label, model };
   const upstream = await reach(call, conn);
   noteUsageHeaders('codex', conn.id, upstream.headers);
   if (!upstream.ok) {
-    const text = await upstream.text();
-    sendError(res, providerStatus(upstream.status), errorKind(upstream.status, INVALID), refusalOf(text, upstream.status));
+    const refusal = refusalOf(await upstream.text(), upstream.status);
+    noteFailure(site, refusal, 'gateway: Codex refused the request');
+    sendError(res, providerStatus(upstream.status), errorKind(upstream.status, INVALID), withUsageLink(refusal.code, refusal.message));
     return;
   }
-  const translator = new CodexEventTranslator(model, (name) => call.names.restore(name));
+  const translator = new CodexEventTranslator(
+    model,
+    (name) => call.names.restore(name),
+    (failure) => {
+      noteFailure(site, failure, 'gateway: Codex did not complete the response');
+    },
+  );
   const onEvent = (raw: SseEvent): string => {
     const parsed = parseEvent(raw);
     return parsed === null ? '' : translator.push(parsed.event, parsed.data);

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

@@ -4,11 +4,15 @@ import { isRecord } from '@metro-labs/core/is-record';
 
 export const BINDING_BETA = 'thinking-binding-controls-2026-08-01';
 
+const COMPACT_EFFORT = 'low';
 const SUBAGENT_HEADER = 'x-claude-code-agent-id';
 const SUBAGENT_MARK = 'cc_is_subagent=true';
+const REQUEST_CLASS_HEADER = 'x-claude-code-request-class';
+const COMPACTION_CLASS = 'compaction';
+const COMPACT_PROMPT = 'CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.';
 const ABOVE_HIGH = new Set(['xhigh', 'max']);
 
-export type RequestKind = 'main' | 'subagent' | 'other';
+export type RequestKind = 'main' | 'subagent' | 'compact' | 'other';
 
 type Body = Record<string, unknown>;
 
@@ -32,22 +36,45 @@ function systemMarksSubagent(body: Body): boolean {
 
 const chore = (body: Body): boolean => record(body.output_config).format !== undefined || record(body.thinking).type === 'disabled';
 
+const messagesOf = (body: Body): unknown[] => (Array.isArray(body.messages) ? body.messages : []);
+
+function textsOf(content: unknown): string[] {
+  if (typeof content === 'string') return [content];
+  if (!Array.isArray(content)) return [];
+  return content.filter(isRecord).flatMap((block) => (block.type === 'text' && typeof block.text === 'string' ? [block.text] : []));
+}
+
+function asksForSummary(body: Body): boolean {
+  const last = messagesOf(body).map(record).findLast((message) => message.role === 'user');
+  return textsOf(last?.content).some((text) => text.trimStart().startsWith(COMPACT_PROMPT));
+}
+
+export const agentIdOf = (req: IncomingMessage): string => header(req, SUBAGENT_HEADER);
+
+export const helperRequest = (req: IncomingMessage, body: Body): boolean => agentIdOf(req) !== '' || systemMarksSubagent(body);
+
+export const compactionRequest = (req: IncomingMessage, body: Body): boolean => header(req, REQUEST_CLASS_HEADER) === COMPACTION_CLASS || asksForSummary(body);
+
 export function requestKind(req: IncomingMessage, body: Body): RequestKind {
-  if (header(req, SUBAGENT_HEADER) !== '' || systemMarksSubagent(body)) return 'subagent';
+  if (compactionRequest(req, body)) return 'compact';
+  if (helperRequest(req, body)) return 'subagent';
   return chore(body) ? 'other' : 'main';
 }
 
-const messagesOf = (body: Body): unknown[] => (Array.isArray(body.messages) ? body.messages : []);
-
 const askedEfforts = (body: Body): string[] => [body, ...messagesOf(body).map(record)].map(effortOf).filter((effort) => effort !== '');
 
+function wantedEffort(kind: RequestKind, setting: RouteEffort): string | null {
+  if (kind === 'compact') return COMPACT_EFFORT;
+  if (kind === 'other') return null;
+  const wanted = kind === 'subagent' ? (setting.helpers ?? EFFORT_DEFAULTS.helpers) : (setting.main ?? EFFORT_DEFAULTS.main);
+  return wanted === 'asked' ? null : wanted;
+}
+
 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' ? (setting.helpers ?? EFFORT_DEFAULTS.helpers) : (setting.main ?? EFFORT_DEFAULTS.main);
-  if (wanted === 'asked') return null;
+  const wanted = wantedEffort(requestKind(req, body), setting);
+  if (wanted === null) return null;
   return asked.every((effort) => effort === wanted) ? null : wanted;
 }
 

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

@@ -0,0 +1,40 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import { stringOf } from '@metro-labs/http/api-http';
+import { parseEvent, SseParser } from './frames.js';
+import type { Route } from './model-config.js';
+
+const MESSAGE_MAX = 300;
+const ERROR_DATA = /^\{\s*"type"\s*:\s*"error"/;
+
+export interface FailureSite {
+  connection: string;
+  model: string;
+}
+
+export interface Failure {
+  code: string;
+  message: string;
+  status?: number;
+}
+
+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);
+}
+
+export class StreamErrors {
+  private readonly parser = new SseParser();
+
+  constructor(private readonly site: FailureSite) {}
+
+  feed(text: string): void {
+    for (const raw of this.parser.push(text)) {
+      if (raw.event !== 'error' && !ERROR_DATA.test(raw.data)) continue;
+      const data = parseEvent(raw)?.data ?? {};
+      const error = isRecord(data.error) ? data.error : {};
+      noteFailure(this.site, { code: stringOf(error.type) || stringOf(error.code), message: stringOf(error.message) }, 'gateway: the provider sent an error in the middle of its stream');
+    }
+  }
+}

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

@@ -1,4 +1,5 @@
 import type { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'node:http';
+import { StreamErrors, type FailureSite } from './failures.js';
 import { UsageScanner } from './usage.js';
 
 export class GatewayError extends Error {
@@ -156,6 +157,7 @@ export interface PipeOptions {
   keepalive?: boolean;
   ownCredential?: boolean;
   scanner?: UsageScanner;
+  site?: FailureSite;
 }
 
 function openResponse(upstream: Response, res: ServerResponse, opts: PipeOptions): boolean {
@@ -167,14 +169,27 @@ function openResponse(upstream: Response, res: ServerResponse, opts: PipeOptions
   return (upstream.headers.get('content-type') ?? '').startsWith('text/event-stream');
 }
 
-async function pump(body: ReadableStream<Uint8Array>, res: ServerResponse, watch: Watch, scanner?: UsageScanner): Promise<void> {
+type Tap = (chunk: Uint8Array) => void;
+
+function tapOf(opts: PipeOptions, streaming: boolean): Tap | null {
+  const scanner = opts.scanner;
+  const errors = streaming && opts.site !== undefined ? new StreamErrors(opts.site) : null;
+  if (scanner === undefined && errors === null) return null;
+  const decoder = new TextDecoder();
+  return (chunk) => {
+    const text = decoder.decode(chunk, { stream: true });
+    scanner?.feed(text);
+    errors?.feed(text);
+  };
+}
+
+async function pump(body: ReadableStream<Uint8Array>, res: ServerResponse, watch: Watch, tap: Tap | null): Promise<void> {
   const reader = body.getReader();
-  const decoder = scanner === undefined ? null : new TextDecoder();
   for (;;) {
     const { done, value } = await reader.read();
     if (done) return;
     watch.touch();
-    if (decoder !== null) scanner?.feed(decoder.decode(value, { stream: true }));
+    tap?.(value);
     res.write(value);
   }
 }
@@ -188,7 +203,7 @@ export async function pipeResponse(upstream: Response, res: ServerResponse, watc
   }
   const ping = opts.keepalive === true && streaming ? setInterval(() => res.write(PING_FRAME), PING_MS) : null;
   try {
-    await pump(body, res, watch, opts.scanner);
+    await pump(body, res, watch, tapOf(opts, streaming));
   } catch (err) {
     if (!watch.idle()) throw err;
     if (streaming) res.write(errorFrame('api_error', idleMessage(watch.ms)));

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

@@ -33,9 +33,9 @@ import {
   cappedEffort,
   effortToApply,
   forgetLearnedThinking,
+  helperRequest,
   learnAlwaysThinks,
   plannedEffort,
-  requestKind,
   thinkingOff,
   withBlockBinding,
   withEffort,
@@ -50,6 +50,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';
 
 const GATEWAY_PREFIX = '/gateway';
@@ -183,7 +184,7 @@ async function toAnthropic(req: IncomingMessage, res: ServerResponse, body: Shap
   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) });
+  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> {
@@ -196,7 +197,7 @@ async function toRouteway(req: IncomingMessage, res: ServerResponse, body: Shape
   noteRefusal(conn.label, route.model, upstream);
   await noteRoutewayRefusal(upstream);
   await refusedWithPage(upstream, watch);
-  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id) });
+  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> {
@@ -220,7 +221,7 @@ async function toOpenRouter(req: IncomingMessage, res: ServerResponse, body: Rec
     redirect: 'manual',
   });
   noteRefusal(conn.label, route.model, upstream);
-  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id) });
+  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id), site: siteOf(route) });
 }
 
 function openrouterBody(body: Record<string, unknown>, model: string, zdr: boolean): Record<string, unknown> {
@@ -254,7 +255,7 @@ interface Chosen {
 }
 
 function chosenChain(req: IncomingMessage, sent: Record<string, unknown>, setup: ModelSetup, requested: string): Chosen {
-  const helpers = requestKind(req, sent) === 'subagent' ? helperSetup(setup) : null;
+  const helpers = helperRequest(req, sent) ? 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() };
 }

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.319"
+  "version": "0.1.0-beta.320"
 }

package/runtime/sdk-runner/runner.json

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