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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.313",
+  "version": "0.1.0-beta.315",
   "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,7 +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 { noteRoutewayRefusal, 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';
@@ -143,8 +143,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);
 }
 
@@ -193,6 +193,7 @@ async function toRouteway(req: IncomingMessage, res: ServerResponse, body: Shape
   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 noteRoutewayRefusal(upstream);
   await refusedWithPage(upstream, watch);
   await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id) });
 }

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

@@ -1,5 +1,6 @@
 import type { IncomingMessage } from 'node:http';
 import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
 import { anthropicHeaders, GatewayError, type Watch } from './forward.js';
 
 export const ROUTEWAY_BASE = 'https://api.routeway.ai';
@@ -19,9 +20,49 @@ export async function refusedWithPage(upstream: Response, watch: Watch): Promise
   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`);
 }
 
+const SCHEMA_MAPS = ['properties', 'patternProperties', '$defs', 'definitions'];
+const SCHEMA_LISTS = ['anyOf', 'oneOf', 'allOf', 'prefixItems'];
+const SCHEMA_ONES = ['items', 'additionalProperties', 'not', 'contains'];
+
+function fitMap(raw: Record<string, unknown>): Record<string, unknown> {
+  const entries = Object.entries(raw).map(([key, value]) => [key, fitSchema(value)] as const);
+  return entries.some(([key, value]) => value !== raw[key]) ? Object.fromEntries(entries) : raw;
+}
+
+function fitList(raw: unknown[]): unknown[] {
+  const fitted = raw.map(fitSchema);
+  return fitted.some((value, at) => value !== raw[at]) ? fitted : raw;
+}
+
+function fitChild(key: string, value: unknown): unknown {
+  if (SCHEMA_MAPS.includes(key)) return isRecord(value) ? fitMap(value) : value;
+  if (SCHEMA_LISTS.includes(key)) return Array.isArray(value) ? fitList(value) : value;
+  return SCHEMA_ONES.includes(key) ? fitSchema(value) : value;
+}
+
+function singleTypes(schema: Record<string, unknown>): Record<string, unknown> {
+  const types: unknown = schema.type;
+  if (!Array.isArray(types) || !types.every((type) => typeof type === 'string')) return schema;
+  const rest = Object.fromEntries(Object.entries(schema).filter(([key]) => key !== 'type'));
+  if (types.length === 1) return { ...rest, type: types[0] };
+  const choices = types.map((type) => ({ type }));
+  if (!Object.hasOwn(rest, 'anyOf')) return { ...rest, anyOf: choices };
+  const { anyOf, ...others } = rest;
+  return { ...others, allOf: [{ anyOf: choices }, { anyOf }] };
+}
+
+function fitSchema(raw: unknown): unknown {
+  if (!isRecord(raw)) return raw;
+  const entries = Object.entries(raw).map(([key, value]) => [key, fitChild(key, value)] as const);
+  const children = entries.some(([key, value]) => value !== raw[key]) ? Object.fromEntries(entries) : raw;
+  return singleTypes(children);
+}
+
 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: {} } };
+  if (!isRecord(tool) || !isRecord(tool.input_schema)) return tool;
+  const schema = fitSchema(tool.input_schema);
+  const full = isRecord(schema) && !Object.hasOwn(schema, 'properties') ? { ...schema, properties: {} } : schema;
+  return full === tool.input_schema ? tool : { ...tool, input_schema: full };
 }
 
 export function routewayTools(body: Record<string, unknown>): Record<string, unknown> {
@@ -30,3 +71,12 @@ export function routewayTools(body: Record<string, unknown>): Record<string, unk
   const tools: unknown[] = listed.map(withProperties);
   return tools.some((tool, at) => tool !== listed[at]) ? { ...body, tools } : body;
 }
+
+export async function noteRoutewayRefusal(upstream: Response): Promise<void> {
+  if (upstream.ok || !(upstream.headers.get('content-type') ?? '').includes('application/json')) return;
+  const body: unknown = await upstream.clone().json().catch(() => null);
+  const error = isRecord(body) && isRecord(body.error) ? body.error : null;
+  if (error === null) return;
+  const text = (value: unknown): string | null => (typeof value === 'string' ? value.slice(0, 300) : null);
+  log.warn({ status: upstream.status, reason: text(error.message), param: text(error.param) }, 'gateway: Routeway refused the request');
+}

package/runtime/runtime.json

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

package/runtime/sdk-runner/runner.json

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