@stage-labs/metro 0.1.0-beta.73 → 0.1.0-beta.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.73",
+  "version": "0.1.0-beta.75",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/node_modules/@metro-labs/mcp/src/daemon/model-api.ts

@@ -7,6 +7,7 @@ import { beginLogin, CodexAuthError, finishLogin, readCodexCliAuth } from '../ga
 import { beginDeviceLogin, pollDeviceLogin } from '../gateway/codex-device.js';
 import { codexModels, currentTokens, freshCodexState } from '../gateway/codex.js';
 import { openrouterModels } from '../gateway/openrouter.js';
+import { lastServed } from '../gateway/served.js';
 import type { CodexTokens } from '../gateway/codex-auth.js';
 import { GatewayError } from '../gateway/forward.js';
 import {
@@ -49,6 +50,8 @@ interface Route {
   run: Handler;
 }
 
+const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({ ...publicModelConfig(cfg), lastServed: lastServed() });
+
 function asApiError(err: unknown): never {
   if (err instanceof ModelConfigError || err instanceof CodexAuthError) throw new ApiError(err.message, 400);
   if (err instanceof GatewayError) throw new ApiError(err.message, 502);
@@ -65,13 +68,13 @@ async function update(req: IncomingMessage, store: Store): Promise<unknown> {
   }
   store.write(next);
   log.info({ provider: next.provider }, 'model-api: route updated');
-  return publicModelConfig(next);
+  return settingsBody(next);
 }
 
 function saveCodex(store: Store, cfg: ModelConfig, note: string): unknown {
   store.write(cfg);
   log.info({ signedIn: cfg.codex.auth !== null, plan: cfg.codex.auth?.plan ?? null }, note);
-  return publicModelConfig(cfg);
+  return settingsBody(cfg);
 }
 
 const modelApiState = freshCodexState();
@@ -146,7 +149,7 @@ const named = (table: Record<string, Route>, name: string, method: string | unde
 };
 
 function settingsRoute(method: string | undefined): Route | number {
-  if (method === 'GET') return { method: 'GET', run: (_req, _deps, store) => Promise.resolve(publicModelConfig(store.read())) };
+  if (method === 'GET') return { method: 'GET', run: (_req, _deps, store) => Promise.resolve(settingsBody(store.read())) };
   if (method === 'PUT') return { method: 'POST', run: (req, _deps, store) => update(req, store) };
   return 405;
 }

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

@@ -113,6 +113,19 @@ export function forwardedHeaders(req: IncomingMessage): Record<string, string> {
   return out;
 }
 
+export function anthropicHeaders(req: IncomingMessage, apiKey: string): Record<string, string> {
+  const headers = forwardedHeaders(req);
+  delete headers.authorization;
+  const betas = (headers['anthropic-beta'] ?? '')
+    .split(',')
+    .map((beta) => beta.trim())
+    .filter((beta) => beta !== '' && !beta.includes('oauth'));
+  if (betas.length > 0) headers['anthropic-beta'] = betas.join(',');
+  else delete headers['anthropic-beta'];
+  headers['x-api-key'] = apiKey;
+  return headers;
+}
+
 export interface PipeOptions {
   keepalive?: boolean;
   ownCredential?: boolean;

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

@@ -9,10 +9,11 @@ import {
   freshAdaptations,
   type Adaptations,
 } from './bedrock.js';
-import { forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
+import { anthropicHeaders, forwardedHeaders, GatewayError, parseJson, pipeResponse, readBody, sendError, watchUpstream } from './forward.js';
 import { notReady, readModelConfig, resolveRoute, routeLabel, setCodexAuth, writeModelConfig, type ModelConfig, type Route } from './model-config.js';
 import { codexCount, codexMessages, freshCodexState, type CodexDeps } from './codex.js';
 import { OPENROUTER_BASE } from './openrouter.js';
+import { forgetServed, noteServed } from './served.js';
 import type { CodexTokens } from './codex-auth.js';
 
 export const GATEWAY_PREFIX = '/gateway';
@@ -35,6 +36,7 @@ const learned: Adaptations = freshAdaptations();
 const codexState = freshCodexState();
 
 export function resetGatewayState(): void {
+  forgetServed();
   learned.fields.clear();
   learned.dropBetas = false;
   Object.assign(codexState, freshCodexState());
@@ -80,14 +82,15 @@ async function toAnthropic(
   const payload = explicit ? Buffer.from(JSON.stringify({ ...body, model: route.model })) : raw;
   const url = `${deps.anthropicBase ?? ANTHROPIC_BASE}${(req.url ?? '').slice(GATEWAY_PREFIX.length)}`;
   const watch = watchUpstream(res);
+  const key = deps.config().anthropic.apiKey;
   const upstream = await fetch(url, {
     method: 'POST',
-    headers: forwardedHeaders(req),
+    headers: key === '' ? forwardedHeaders(req) : anthropicHeaders(req, key),
     body: new Uint8Array(payload),
     signal: watch.signal,
     redirect: 'manual',
   });
-  await pipeResponse(upstream, res, watch);
+  await pipeResponse(upstream, res, watch, key === '' ? {} : { ownCredential: true });
 }
 
 async function toOpenRouter(
@@ -127,6 +130,7 @@ async function dispatch(req: IncomingMessage, res: ServerResponse, path: string,
   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) };

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

@@ -7,6 +7,11 @@ import type { CodexTokens } from './codex-auth.js';
 export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex'] as const;
 export type Provider = (typeof PROVIDERS)[number];
 
+export interface AnthropicSettings {
+  apiKey: string;
+  model: string;
+}
+
 export interface BedrockSettings {
   region: string;
   apiKey: string;
@@ -26,6 +31,7 @@ export interface CodexSettings {
 export interface ModelConfig {
   version: 1;
   provider: Provider;
+  anthropic: AnthropicSettings;
   bedrock: BedrockSettings;
   openrouter: OpenRouterSettings;
   codex: CodexSettings;
@@ -41,10 +47,12 @@ export class ModelConfigError extends Error {}
 export const MODEL_FILE = 'model.json';
 const MAX_FIELD = 512;
 const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex):(.+)$/;
+const SMALL_RE = /haiku/i;
 
 const empty = (): ModelConfig => ({
   version: 1,
   provider: 'anthropic',
+  anthropic: { apiKey: '', model: '' },
   bedrock: { region: '', apiKey: '', model: '' },
   openrouter: { apiKey: '', model: '' },
   codex: { model: '', auth: null },
@@ -76,12 +84,14 @@ function tokensFromDisk(raw: unknown): CodexTokens | null {
 function fromDisk(raw: unknown): ModelConfig {
   const base = empty();
   if (!isRecord(raw)) return base;
+  const anthropic = isRecord(raw.anthropic) ? raw.anthropic : {};
   const bedrock = isRecord(raw.bedrock) ? raw.bedrock : {};
   const openrouter = isRecord(raw.openrouter) ? raw.openrouter : {};
   const codex = isRecord(raw.codex) ? raw.codex : {};
   return {
     version: 1,
     provider: isProvider(raw.provider) ? raw.provider : 'anthropic',
+    anthropic: { apiKey: text(anthropic.apiKey), model: text(anthropic.model) },
     bedrock: { region: text(bedrock.region), apiKey: text(bedrock.apiKey), model: text(bedrock.model) },
     openrouter: { apiKey: text(openrouter.apiKey), model: text(openrouter.model) },
     codex: { model: text(codex.model), auth: tokensFromDisk(codex.auth) },
@@ -108,12 +118,17 @@ export function applyModelUpdate(cfg: ModelConfig, patch: unknown): ModelConfig
   if (!isRecord(patch)) throw new ModelConfigError('body must be a JSON object');
   const provider = 'provider' in patch ? patch.provider : cfg.provider;
   if (!isProvider(provider)) throw new ModelConfigError(`provider must be one of ${PROVIDERS.join(', ')}`);
+  const anthropic = isRecord(patch.anthropic) ? patch.anthropic : {};
   const bedrock = isRecord(patch.bedrock) ? patch.bedrock : {};
   const openrouter = isRecord(patch.openrouter) ? patch.openrouter : {};
   const codex = isRecord(patch.codex) ? patch.codex : {};
   return {
     version: 1,
     provider,
+    anthropic: {
+      apiKey: field(anthropic, 'apiKey', cfg.anthropic.apiKey, 'Anthropic API key'),
+      model: field(anthropic, 'model', cfg.anthropic.model, 'Anthropic model'),
+    },
     bedrock: {
       region: field(bedrock, 'region', cfg.bedrock.region, 'Bedrock region'),
       apiKey: field(bedrock, 'apiKey', cfg.bedrock.apiKey, 'Bedrock API key'),
@@ -155,17 +170,20 @@ export function publicModelConfig(cfg: ModelConfig): Record<string, unknown> {
     provider: cfg.provider,
     ready: notReady(cfg) === null,
     reason: notReady(cfg),
+    anthropic: { model: cfg.anthropic.model, hasKey: cfg.anthropic.apiKey !== '' },
     bedrock: { region: cfg.bedrock.region, model: cfg.bedrock.model, hasKey: cfg.bedrock.apiKey !== '' },
     openrouter: { model: cfg.openrouter.model, hasKey: cfg.openrouter.apiKey !== '' },
     codex: { model: cfg.codex.model, signedIn: auth !== null, account: auth?.email ?? null, plan: auth?.plan ?? null },
   };
 }
 
+export const isSmallModel = (requested: string): boolean => SMALL_RE.test(requested);
+
 function defaultModelFor(provider: Provider, requested: string, cfg: ModelConfig): string {
   if (provider === 'openrouter') return requested.includes('/') ? requested : cfg.openrouter.model;
   if (provider === 'bedrock') return cfg.bedrock.model === '' ? requested : cfg.bedrock.model;
   if (provider === 'codex') return requested.startsWith('gpt-') ? requested : cfg.codex.model;
-  return requested;
+  return cfg.anthropic.model === '' || isSmallModel(requested) ? requested : cfg.anthropic.model;
 }
 
 export function resolveRoute(requested: string, cfg: ModelConfig): Route {

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

@@ -1,3 +1,4 @@
+import { isRecord } from '../daemon/is-record.js';
 import { GatewayError } from './forward.js';
 
 export const OPENROUTER_BASE = 'https://openrouter.ai/api';
@@ -6,15 +7,23 @@ const MODELS_MAX = 2000;
 export interface OpenRouterModel {
   id: string;
   name: string;
+  prompt: number | null;
+  completion: number | null;
 }
 
 const str = (value: unknown): string => (typeof value === 'string' ? value : '');
 
+function price(raw: unknown): number | null {
+  const value = typeof raw === 'string' ? Number(raw) : typeof raw === 'number' ? raw : Number.NaN;
+  return Number.isFinite(value) && value >= 0 ? value : null;
+}
+
 function modelOf(entry: unknown): OpenRouterModel | null {
-  if (typeof entry !== 'object' || entry === null) return null;
-  const row = entry as { id?: unknown; name?: unknown };
-  const id = str(row.id);
-  return id === '' ? null : { id, name: str(row.name) || id };
+  if (!isRecord(entry)) return null;
+  const id = str(entry.id);
+  if (id === '') return null;
+  const pricing = isRecord(entry.pricing) ? entry.pricing : {};
+  return { id, name: str(entry.name) || id, prompt: price(pricing.prompt), completion: price(pricing.completion) };
 }
 
 export async function openrouterModels(base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<OpenRouterModel[]> {

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

@@ -0,0 +1,17 @@
+export interface Served {
+  provider: string;
+  model: string;
+  at: string;
+}
+
+let last: Served | null = null;
+
+export const noteServed = (served: Served): void => {
+  last = served;
+};
+
+export const lastServed = (): Served | null => last;
+
+export const forgetServed = (): void => {
+  last = null;
+};

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.73"
+  "version": "0.1.0-beta.75"
 }