@stage-labs/metro 0.1.0-beta.164 → 0.1.0-beta.166

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

@@ -9,8 +9,9 @@ import {
   freshAdaptations,
   type Adaptations,
 } from './bedrock.js';
-import { anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
-import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, setGeminiAuth, writeModelConfig, type ModelConfig, type Route } from './model-config.js';
+import { addBeta, anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
+import { BINDING_BETA, cappedEffort, effortToApply, plannedEffort, withBlockBinding, withEffort } from './effort.js';
+import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, setGeminiAuth, writeModelConfig, type Connection, type ModelConfig, type Route } from './model-config.js';
 import { codexCount, codexMessages, freshCodexState } from './codex.js';
 import { freshGeminiState, geminiCount, geminiMessages } from './gemini.js';
 import type { GeminiDeps } from './gemini.js';
@@ -52,12 +53,12 @@ export function resetGatewayState(): void {
   Object.assign(geminiState, freshGeminiState());
 }
 
-const saveCodexTokens = (tokens: CodexTokens): void => {
-  writeModelConfig(setCodexAuth(readModelConfig(), tokens));
+const saveCodexTokens = (id: string, tokens: CodexTokens): void => {
+  writeModelConfig(setCodexAuth(readModelConfig(), id, tokens));
 };
 
-const saveGeminiTokens = (tokens: GeminiTokens): void => {
-  writeModelConfig(setGeminiAuth(readModelConfig(), tokens));
+const saveGeminiTokens = (id: string, tokens: GeminiTokens): void => {
+  writeModelConfig(setGeminiAuth(readModelConfig(), id, tokens));
 };
 
 const keyOf = (req: IncomingMessage): string => {
@@ -68,18 +69,16 @@ const keyOf = (req: IncomingMessage): string => {
 const defaultIdentify = (key: string): boolean => key !== '' && agentIdForKey(key) !== undefined;
 
 function modelsBody(cfg: ModelConfig): Record<string, unknown> {
-  const data: Record<string, string>[] = [];
-  if (cfg.bedrock.model !== '')
-    data.push({ id: `bedrock:${cfg.bedrock.model}`, display_name: `Bedrock · ${cfg.bedrock.model}`, description: 'Through metro, billed to Amazon Bedrock' });
-  if (cfg.openrouter.model !== '')
-    data.push({ id: `openrouter:${cfg.openrouter.model}`, display_name: `OpenRouter · ${cfg.openrouter.model}`, description: 'Through metro, billed to OpenRouter' });
-  if (cfg.codex.model !== '')
-    data.push({ id: `codex:${cfg.codex.model}`, display_name: `Codex · ${cfg.codex.model}`, description: 'Through metro, on your ChatGPT subscription' });
-  if (cfg.gemini.model !== '')
-    data.push({ id: `gemini:${cfg.gemini.model}`, display_name: `Gemini · ${cfg.gemini.model}`, description: 'Through metro, on your Google account' });
+  const data = cfg.connections
+    .filter((c) => c.provider !== 'anthropic' && c.model !== '')
+    .map((c) => ({ id: `${c.provider}:${c.model}`, display_name: `${c.label} · ${c.model}`, description: 'Through metro' }));
   return { data, has_more: false, first_id: data[0]?.id ?? null, last_id: data.at(-1)?.id ?? null };
 }
 
+const PASSTHROUGH: Connection = { id: 'passthrough', provider: 'anthropic', label: 'Claude Code login', model: '', apiKey: '', region: '', zdr: false, codex: null, gemini: null };
+
+const passthrough = (body: Record<string, unknown>): Route => ({ connection: PASSTHROUGH, model: requestedModel(body) });
+
 function requestedModel(body: Record<string, unknown>): string {
   const model = body.model;
   if (typeof model !== 'string' || model === '') throw new GatewayError(400, 'invalid_request_error', 'model is required');
@@ -91,18 +90,43 @@ const standsInFor = (req: IncomingMessage): boolean => {
   return typeof metroKey === 'string' && metroKey !== '' && req.headers.authorization === `Bearer ${metroKey}`;
 };
 
+interface Payloads {
+  metro: Buffer;
+  asSent: Buffer | null;
+  bound: boolean;
+}
+
+function anthropicPayloads(raw: Buffer, sent: Record<string, unknown>, shaped: Record<string, unknown>, model: string): Payloads {
+  const rewrite = typeof sent.model === 'string' && sent.model !== model;
+  const asSent = rewrite ? Buffer.from(JSON.stringify({ ...sent, model })) : raw;
+  const bound = withBlockBinding(shaped);
+  if (bound === sent) return { metro: asSent, asSent: null, bound: false };
+  return { metro: Buffer.from(JSON.stringify(rewrite ? { ...bound, model } : bound)), asSent, bound: bound !== shaped };
+}
+
+type Send = (payload: Buffer, headers: Record<string, string>) => Promise<Response>;
+
+async function asAnthropicWants(send: Send, base: Record<string, string>, payloads: Payloads, connection: string, model: string): Promise<Response> {
+  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');
+  return send(asSent, base);
+}
+
 async function toAnthropic(
   req: IncomingMessage,
   res: ServerResponse,
   raw: Buffer,
-  body: Record<string, unknown>,
+  sent: Record<string, unknown>,
+  shaped: Record<string, unknown>,
   route: Route,
   deps: GatewayDeps,
 ): Promise<void> {
-  const explicit = typeof body.model === 'string' && body.model !== route.model;
-  const payload = explicit ? Buffer.from(JSON.stringify({ ...body, model: route.model })) : raw;
+  const conn = route.connection;
   const url = `${deps.anthropicBase ?? ANTHROPIC_BASE}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
-  const key = deps.config().anthropic.apiKey;
+  const key = conn.apiKey;
   if (key === '' && standsInFor(req))
     throw new GatewayError(
       403,
@@ -110,16 +134,13 @@ async function toAnthropic(
       'Claude Code on this machine has no Anthropic login of its own; choose Bedrock, OpenRouter, Codex or Gemini on the Model page, or sign in on the Claude tab',
     );
   const watch = watchUpstream(res);
-  const upstream = await fetch(url, {
-    method: 'POST',
-    headers: key === '' ? forwardedHeaders(req) : anthropicHeaders(req, key),
-    body: new Uint8Array(payload),
-    signal: watch.signal,
-    redirect: 'manual',
-  });
-  noteRefusal('anthropic', route.model, upstream);
-  noteUsageHeaders('anthropic', upstream.headers);
-  const scanner = new UsageScanner('anthropic');
+  const base = key === '' ? forwardedHeaders(req) : anthropicHeaders(req, key);
+  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 upstream = await asAnthropicWants(send, base, anthropicPayloads(raw, sent, shaped, route.model), conn.label, route.model);
+  noteRefusal(conn.label, route.model, upstream);
+  noteUsageHeaders('anthropic', conn.id, upstream.headers);
+  const scanner = new UsageScanner(conn.id);
   await pipeResponse(upstream, res, watch, key === '' ? { scanner } : { ownCredential: true, scanner });
 }
 
@@ -131,12 +152,13 @@ async function toOpenRouter(
   cfg: ModelConfig,
   deps: GatewayDeps,
 ): Promise<void> {
-  const reason = notReady(cfg, 'openrouter');
+  const conn = route.connection;
+  const reason = notReady(cfg, conn);
   if (reason !== null) throw new GatewayError(400, 'invalid_request_error', reason);
   const headers: Record<string, string> = {
     'content-type': 'application/json',
     accept: req.headers.accept ?? 'application/json',
-    authorization: `Bearer ${cfg.openrouter.apiKey}`,
+    authorization: `Bearer ${conn.apiKey}`,
     'anthropic-version': typeof req.headers['anthropic-version'] === 'string' ? req.headers['anthropic-version'] : '2023-06-01',
     'http-referer': 'https://metro.box',
     'x-title': 'metro',
@@ -147,12 +169,12 @@ async function toOpenRouter(
   const upstream = await fetch(`${deps.openrouterBase ?? OPENROUTER_BASE}${MESSAGES}`, {
     method: 'POST',
     headers,
-    body: JSON.stringify(openrouterBody(body, route.model, cfg.openrouter.zdr)),
+    body: JSON.stringify(openrouterBody(body, route.model, conn.zdr)),
     signal: watch.signal,
     redirect: 'manual',
   });
-  noteRefusal('openrouter', route.model, upstream);
-  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner('openrouter') });
+  noteRefusal(conn.label, route.model, upstream);
+  await pipeResponse(upstream, res, watch, { keepalive: true, ownCredential: true, scanner: new UsageScanner(conn.id) });
 }
 
 const thinkingOff = (body: Record<string, unknown>): boolean => isRecord(body.thinking) && body.thinking.type === 'disabled';
@@ -160,49 +182,59 @@ const thinkingOff = (body: Record<string, unknown>): boolean => isRecord(body.th
 export function openrouterBody(body: Record<string, unknown>, model: string, zdr: boolean): Record<string, unknown> {
   const sent: Record<string, unknown> = { ...body, model };
   if (thinkingOff(body)) delete sent.thinking;
+  const effort = effortToApply(body);
+  if (effort !== null) sent.reasoning = { ...(isRecord(body.reasoning) ? body.reasoning : {}), effort: cappedEffort(effort) };
   if (!zdr) return sent;
   const provider = isRecord(body.provider) ? body.provider : {};
   return { ...sent, provider: { ...provider, zdr: true } };
 }
 
-function noteRefusal(provider: string, model: string, upstream: Response): void {
-  if (!upstream.ok) log.warn({ provider, model, status: upstream.status }, 'gateway: the provider refused the request');
+function noteRefusal(connection: string, model: string, upstream: Response): void {
+  if (!upstream.ok) log.warn({ connection, model, status: upstream.status }, 'gateway: the provider refused the request');
 }
 
-async function toSubscription(req: IncomingMessage, res: ServerResponse, path: string, body: Record<string, unknown>, route: Route, cfg: ModelConfig, deps: GatewayDeps): Promise<void> {
-  if (route.provider === 'gemini') {
+async function toSubscription(req: IncomingMessage, res: ServerResponse, path: string, body: Record<string, unknown>, route: Route, deps: GatewayDeps): Promise<void> {
+  const conn = route.connection;
+  if (conn.provider === 'gemini') {
     if (path === COUNT) geminiCount(res, body);
-    else await geminiMessages(req, res, body, route.model, cfg, { save: saveGeminiTokens, ...deps.gemini }, geminiState, watchUpstream(res));
+    else await geminiMessages(req, res, body, route.model, conn, { save: saveGeminiTokens, ...deps.gemini }, geminiState, watchUpstream(res));
     return;
   }
   if (path === COUNT) codexCount(res, body);
-  else await codexMessages(req, res, body, route.model, cfg, { save: saveCodexTokens, ...deps.codex }, codexState, watchUpstream(res));
+  else await codexMessages(req, res, body, route.model, conn, { save: saveCodexTokens, ...deps.codex }, codexState, watchUpstream(res));
+}
+
+function shapedFor(req: IncomingMessage, sent: Record<string, unknown>): Record<string, unknown> {
+  const effort = plannedEffort(req, sent);
+  return effort === null ? sent : withEffort(sent, effort);
 }
 
 async function dispatch(req: IncomingMessage, res: ServerResponse, path: string, deps: GatewayDeps): Promise<void> {
   const cfg = deps.config();
   const raw = await readBody(req);
-  const body = parseJson(raw);
-  const route = resolveRoute(requestedModel(body), cfg);
-  log.info({ route: routeLabel(route), path }, 'gateway: routing');
-  if (path === MESSAGES) noteServed({ provider: route.provider, model: route.model, at: new Date().toISOString() });
-  if (route.provider === 'bedrock') {
-    assertBedrockReady(cfg.bedrock);
-    const up = { settings: cfg.bedrock, base: deps.bedrockBase ?? bedrockBase(cfg.bedrock.region), learned, watch: watchUpstream(res) };
+  const sent = parseJson(raw);
+  const body = shapedFor(req, sent);
+  const route = resolveRoute(requestedModel(body), cfg) ?? passthrough(body);
+  const conn = route.connection;
+  log.info({ route: routeLabel(route), connection: conn.label, path }, 'gateway: routing');
+  if (path === MESSAGES) noteServed({ connection: conn.id, provider: conn.provider, model: route.model, at: new Date().toISOString() });
+  if (conn.provider === 'bedrock') {
+    assertBedrockReady(conn);
+    const up = { settings: conn, base: deps.bedrockBase ?? bedrockBase(conn.region), learned, watch: watchUpstream(res) };
     if (path === COUNT) await bedrockCount(req, res, body, route.model, up);
     else await bedrockMessages(req, res, body, route.model, up);
     return;
   }
-  if (route.provider === 'openrouter') {
+  if (conn.provider === 'openrouter') {
     if (path === COUNT) throw new GatewayError(404, 'not_found_error', 'OpenRouter does not count tokens');
     await toOpenRouter(req, res, body, route, cfg, deps);
     return;
   }
-  if (route.provider === 'codex' || route.provider === 'gemini') {
-    await toSubscription(req, res, path, body, route, cfg, deps);
+  if (conn.provider === 'codex' || conn.provider === 'gemini') {
+    await toSubscription(req, res, path, body, route, deps);
     return;
   }
-  await toAnthropic(req, res, raw, body, route, deps);
+  await toAnthropic(req, res, raw, sent, body, route, deps);
 }
 
 function failed(res: ServerResponse, err: unknown): void {

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

@@ -2,6 +2,7 @@ import { randomBytes } from 'node:crypto';
 import { isRecord } from '@metro-labs/core/is-record';
 import { ToolNames } from './codex-translate.js';
 import { CLIENT_NAME, requestId, SYSTEM_PREFIX } from './gemini-client.js';
+import { cappedEffort, effortToApply } from './effort.js';
 
 type Item = Record<string, unknown>;
 
@@ -190,6 +191,8 @@ function generationConfig(body: Item): Item {
   if (typeof body.temperature === 'number') out.temperature = body.temperature;
   if (typeof body.top_p === 'number') out.topP = body.top_p;
   if (isRecord(body.thinking) && body.thinking.type === 'enabled') out.thinkingConfig = { includeThoughts: true };
+  const effort = effortToApply(body);
+  if (effort !== null) out.thinkingLevel = cappedEffort(effort);
   return out;
 }
 

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

@@ -8,8 +8,9 @@ import { toGeminiRequest } from './gemini-translate.js';
 import { ToolNames } from './codex-translate.js';
 import { assembleMessage, SseParser } from './codex-stream.js';
 import { GatewayError, idleMessage, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
-import type { ModelConfig } from './model-config.js';
+import type { Connection } from './model-config.js';
 import { UsageScanner } from './usage.js';
+import { effortToApply, withoutEffort } from './effort.js';
 
 const PING_MS = 25_000;
 const STATUS_OF: Record<string, number> = { rate_limit_error: 429, invalid_request_error: 400, permission_error: 403, overloaded_error: 529 };
@@ -18,7 +19,7 @@ export interface GeminiDeps {
   base?: Bases;
   tokenBase?: string;
   fetchImpl?: typeof fetch;
-  save: (tokens: GeminiTokens) => void;
+  save: (id: string, tokens: GeminiTokens) => void;
 }
 
 export interface GeminiState {
@@ -30,13 +31,13 @@ export const freshGeminiState = (): GeminiState => ({ refreshing: null, latest:
 
 const newerThan = (a: GeminiTokens, b: GeminiTokens): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
 
-function refreshed(tokens: GeminiTokens, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
+function refreshed(id: string, tokens: GeminiTokens, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
   const latest = state.latest;
   if (latest !== null && newerThan(latest, tokens) && !tokensStale(latest)) return Promise.resolve(latest);
   if (state.refreshing !== null) return state.refreshing;
   const run = refreshTokens(tokens, deps.tokenBase, deps.fetchImpl)
     .then((fresh) => {
-      deps.save(fresh);
+      deps.save(id, fresh);
       state.latest = fresh;
       return fresh;
     })
@@ -50,10 +51,10 @@ function refreshed(tokens: GeminiTokens, deps: GeminiDeps, state: GeminiState):
   return run;
 }
 
-export function currentGeminiTokens(cfg: ModelConfig, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
-  const tokens = cfg.gemini.auth;
+export function currentGeminiTokens(conn: Connection, deps: GeminiDeps, state: GeminiState): Promise<GeminiTokens> {
+  const tokens = conn.gemini;
   if (tokens === null) throw new GatewayError(400, 'invalid_request_error', 'Gemini is not connected: sign in with Google on the Model page.');
-  return tokensStale(tokens) ? refreshed(tokens, deps, state) : Promise.resolve(tokens);
+  return tokensStale(tokens) ? refreshed(conn.id, tokens, deps, state) : Promise.resolve(tokens);
 }
 
 function errorKind(status: number): string {
@@ -76,6 +77,7 @@ interface Call {
   watch: Watch;
   deps: GeminiDeps;
   names: ToolNames;
+  conn: Connection;
 }
 
 const headersFor = (token: string, stream: boolean): Record<string, string> => ({
@@ -140,12 +142,12 @@ export function refusalMessage(text: string, status: number): string {
   return notes.length === 0 ? message : `${message} (${notes.join('; ')})`;
 }
 
-async function reach(call: Call, cfg: ModelConfig, state: GeminiState, stream: boolean): Promise<Response> {
-  let tokens = await currentGeminiTokens(cfg, call.deps, state);
+async function reach(call: Call, conn: Connection, state: GeminiState, stream: boolean): Promise<Response> {
+  let tokens = await currentGeminiTokens(conn, call.deps, state);
   let upstream = await send(call, tokens, stream);
   if (upstream.status === 401) {
     await upstream.body?.cancel();
-    tokens = await refreshed(tokens, call.deps, state);
+    tokens = await refreshed(conn.id, tokens, call.deps, state);
     upstream = await send(call, tokens, stream);
   }
   return upstream;
@@ -210,7 +212,7 @@ async function relayStream(upstream: Response, res: ServerResponse, call: Call):
     return;
   }
   const ping = setInterval(() => res.write('event: ping\ndata: {"type":"ping"}\n\n'), PING_MS);
-  const scanner = new UsageScanner('gemini');
+  const scanner = new UsageScanner(call.conn.id);
   const emit = (frames: string): void => {
     if (frames === '') return;
     scanner.feed(frames);
@@ -245,7 +247,7 @@ async function relayWhole(upstream: Response, res: ServerResponse, call: Call):
   const translator = new GeminiStreamTranslator(call.model, (name) => call.names.restore(name));
   const data = parseData(await upstream.text());
   const frames = (data === null ? '' : translator.push(data)) + translator.close();
-  const scanner = new UsageScanner('gemini');
+  const scanner = new UsageScanner(call.conn.id);
   scanner.feed(frames);
   scanner.done();
   const message = assembleMessage(frames);
@@ -254,23 +256,38 @@ async function relayWhole(upstream: Response, res: ServerResponse, call: Call):
   res.end(JSON.stringify(message));
 }
 
+const NAMES_THINKING = /thinking|thought/i;
+
+function refuse(res: ServerResponse, model: string, status: number, text: string): void {
+  log.warn({ provider: 'gemini', model, status, body: text.slice(0, REFUSAL_LOG_MAX) }, 'gateway: the provider refused the request');
+  sendError(res, providerStatus(status), errorKind(status), refusalMessage(text, status));
+}
+
 export async function geminiMessages(
   req: IncomingMessage,
   res: ServerResponse,
   body: Record<string, unknown>,
   model: string,
-  cfg: ModelConfig,
+  conn: Connection,
   deps: GeminiDeps,
   state: GeminiState,
   watch: Watch,
 ): Promise<void> {
   const stream = body.stream === true;
-  const call: Call = { body, model, promptId: promptIdOf(req), watch, deps, names: new ToolNames() };
-  const upstream = await reach(call, cfg, state, stream);
-  if (!upstream.ok) {
+  let call: Call = { body, model, promptId: promptIdOf(req), watch, deps, names: new ToolNames(), conn };
+  let upstream = await reach(call, conn, state, stream);
+  if (upstream.status === 400 && effortToApply(body) !== null) {
     const text = await upstream.text();
-    log.warn({ provider: 'gemini', model, status: upstream.status, body: text.slice(0, REFUSAL_LOG_MAX) }, 'gateway: the provider refused the request');
-    sendError(res, providerStatus(upstream.status), errorKind(upstream.status), refusalMessage(text, upstream.status));
+    if (!NAMES_THINKING.test(text)) {
+      refuse(res, model, 400, text);
+      return;
+    }
+    log.warn({ provider: 'gemini', model }, 'gateway: Gemini refused the thinking level, so metro asked again without it');
+    call = { ...call, body: withoutEffort(body) };
+    upstream = await reach(call, conn, state, stream);
+  }
+  if (!upstream.ok) {
+    refuse(res, model, upstream.status, await upstream.text());
     return;
   }
   if (stream) await relayStream(upstream, res, call);