@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

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

@@ -0,0 +1,147 @@
+import { log } from '@metro-labs/core/log';
+import { lastServed } from './served.js';
+import { PER_MINUTE, usageOf, type UsageWindow } from './usage.js';
+import { bareModel, connectionOf, isSmallModel, notReady, routedConnection, routeLabel, type Connection, type Fallback, type ModelConfig, type Route } from './model-config.js';
+
+export const USAGE_LIMIT = 0.95;
+const COOLDOWN_MS = 60_000;
+const SCOPED = 'Weekly, ';
+const MS_PER_SECOND = 1000;
+
+export interface Hold {
+  reason: string;
+  until: string | null;
+}
+
+interface Cooling {
+  until: number;
+  reason: string;
+}
+
+const cooling = new Map<string, Cooling>();
+let lastChoice = '';
+
+const keyOf = (route: Route): string => `${route.connection.id}\n${route.model}`;
+
+export function forgetFallbackState(): void {
+  cooling.clear();
+  lastChoice = '';
+}
+
+function scopeOf(label: string): string | null {
+  if (!label.startsWith(SCOPED) || label === 'Weekly, all models') return null;
+  return (label.slice(SCOPED.length).trim().split(/\s+/)[0] ?? '').toLowerCase();
+}
+
+function applies(window: UsageWindow, route: Route, now: number): boolean {
+  if (window.used === null || window.label === PER_MINUTE) return false;
+  if (window.resetAt !== null && Date.parse(window.resetAt) <= now) return false;
+  if (route.connection.provider === 'gemini') return window.label === route.model;
+  const scope = scopeOf(window.label);
+  return scope === null || route.model.toLowerCase().split(/[^a-z0-9]+/).includes(scope);
+}
+
+export function windowsFor(route: Route, now = Date.now()): UsageWindow[] {
+  return (usageOf(route.connection.id)?.windows ?? []).filter((w) => applies(w, route, now));
+}
+
+const percent = (used: number): string => `${String(Math.round(used * 100))}%`;
+
+export function holdOf(route: Route, now = Date.now()): Hold | null {
+  const cool = cooling.get(keyOf(route));
+  if (cool !== undefined && cool.until > now) return { reason: cool.reason, until: new Date(cool.until).toISOString() };
+  const over = windowsFor(route, now).find((w) => (w.used ?? 0) > USAGE_LIMIT);
+  return over === undefined ? null : { reason: `${over.label} ${percent(over.used ?? 0)}`, until: over.resetAt };
+}
+
+function fallbackModel(requested: string, conn: Connection, model: string): string {
+  const bare = bareModel(requested);
+  return conn.provider === 'anthropic' && isSmallModel(bare) ? bare : model;
+}
+
+function fallbackRoute(cfg: ModelConfig, fallback: Fallback, requested: string): Route | null {
+  const conn = connectionOf(cfg, fallback.connection);
+  if (conn === null || notReady(cfg, conn) !== null) return null;
+  return { connection: conn, model: fallbackModel(requested, conn, fallback.model) };
+}
+
+const unique = (routes: Route[]): Route[] => routes.filter((route, at) => routes.findIndex((other) => keyOf(other) === keyOf(route)) === at);
+
+export const chainOf = (primary: Route, cfg: ModelConfig, requested: string): Route[] =>
+  unique([primary, ...(cfg.fallbacks ?? []).flatMap((f) => fallbackRoute(cfg, f, requested) ?? [])]);
+
+export function routesToTry(chain: Route[], now = Date.now()): Route[] {
+  const open = chain.filter((route) => holdOf(route, now) === null);
+  return open.length > 0 ? open : chain.slice(0, 1);
+}
+
+function secondsHeader(headers: Headers, name: string): number | null {
+  const raw = headers.get(name);
+  if (raw === null || raw.trim() === '') return null;
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+
+function coolUntil(headers: Headers, now: number): number {
+  const after = secondsHeader(headers, 'retry-after');
+  if (after !== null) return now + after * MS_PER_SECOND;
+  const reset = secondsHeader(headers, 'anthropic-ratelimit-unified-reset');
+  if (reset !== null && reset * MS_PER_SECOND > now) return reset * MS_PER_SECOND;
+  return now + COOLDOWN_MS;
+}
+
+export function noteRefused(route: Route, status: number, headers: Headers, next: Route | undefined, now = Date.now()): void {
+  const reason = `answered ${String(status)}`;
+  cooling.set(keyOf(route), { until: coolUntil(headers, now), reason });
+  log.warn({ from: routeLabel(route), to: next === undefined ? null : routeLabel(next), status }, 'gateway: the model hit its limit, so the request goes to the next fallback model');
+}
+
+export function noteChoice(primary: Route, chosen: Route, now = Date.now()): void {
+  const key = keyOf(chosen);
+  if (key === lastChoice) return;
+  const first = lastChoice === '';
+  lastChoice = key;
+  if (key === keyOf(primary)) {
+    if (!first) log.info({ model: routeLabel(chosen), connection: chosen.connection.label }, 'gateway: back on the first model of the fallback list');
+    return;
+  }
+  const hold = holdOf(primary, now);
+  log.info(
+    { from: routeLabel(primary), to: routeLabel(chosen), connection: chosen.connection.label, reason: hold?.reason ?? null, until: hold?.until ?? null },
+    'gateway: the first model is over its limit, so requests go to a fallback model',
+  );
+}
+
+export interface ChainRow {
+  connection: string;
+  model: string;
+  used: number | null;
+  hold: Hold | null;
+  active: boolean;
+}
+
+function primaryOf(cfg: ModelConfig): Route | null {
+  const conn = routedConnection(cfg);
+  if (conn === null) return null;
+  const served = lastServed();
+  const model = conn.model !== '' ? conn.model : served?.connection === conn.id ? served.model : '';
+  return { connection: conn, model };
+}
+
+function rowOf(cfg: ModelConfig, route: Route, now: number): Omit<ChainRow, 'active'> {
+  const reason = notReady(cfg, route.connection);
+  const used = windowsFor(route, now).reduce<number | null>((most, w) => Math.max(most ?? 0, w.used ?? 0), null);
+  return { connection: route.connection.id, model: route.model, used, hold: reason === null ? holdOf(route, now) : { reason, until: null } };
+}
+
+export function chainStatus(cfg: ModelConfig, now = Date.now()): ChainRow[] {
+  const primary = primaryOf(cfg);
+  if (primary === null) return [];
+  const listed = (cfg.fallbacks ?? []).flatMap((f) => {
+    const conn = connectionOf(cfg, f.connection);
+    return conn === null ? [] : [{ connection: conn, model: f.model }];
+  });
+  const rows = unique([primary, ...listed]).map((route) => rowOf(cfg, route, now));
+  const active = Math.max(0, rows.findIndex((row) => row.hold === null));
+  return rows.map((row, at) => ({ ...row, active: at === active }));
+}

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

@@ -0,0 +1,285 @@
+import type { IncomingMessage, OutgoingHttpHeader, OutgoingHttpHeaders, ServerResponse } from 'node:http';
+import { UsageScanner } from './usage.js';
+
+export class GatewayError extends Error {
+  constructor(
+    readonly status: number,
+    readonly kind: string,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+const BODY_MAX = 64 * 1024 * 1024;
+const DRAIN_FACTOR = 2;
+const PING_MS = 25_000;
+const PING_FRAME = 'event: ping\ndata: {"type":"ping"}\n\n';
+const IDLE_MS = 300_000;
+const HOP_BY_HOP = new Set([
+  'host',
+  'connection',
+  'content-length',
+  'transfer-encoding',
+  'keep-alive',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'upgrade',
+  'accept-encoding',
+  'x-metro-key',
+  'x-metro-runner',
+]);
+const RESPONSE_DROP = new Set(['content-length', 'content-encoding', 'transfer-encoding', 'connection', 'keep-alive']);
+
+export function sendError(res: ServerResponse, status: number, kind: string, message: string): void {
+  res.writeHead(status, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ type: 'error', error: { type: kind, message } }));
+}
+
+export const errorFrame = (kind: string, message: string): string => `event: error\ndata: ${JSON.stringify({ type: 'error', error: { type: kind, message } })}\n\n`;
+
+export const providerStatus = (status: number): number => (status === 401 ? 403 : status);
+
+const idleMs = (): number => Number(process.env.METRO_GATEWAY_IDLE_MS) || IDLE_MS;
+
+const idleMessage = (ms: number): string => `metro gateway: the provider sent nothing for ${String(Math.round(ms / 1000))}s; giving up on this request`;
+
+export interface Watch {
+  signal: AbortSignal;
+  ms: number;
+  touch: () => void;
+  idle: () => boolean;
+  stop: () => void;
+}
+
+export function watchUpstream(res: ServerResponse, ms = idleMs()): Watch {
+  const control = new AbortController();
+  let expired = false;
+  let timer: NodeJS.Timeout | null = null;
+  const stop = (): void => {
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+  };
+  const arm = (): void => {
+    stop();
+    timer = setTimeout(() => {
+      expired = true;
+      control.abort();
+    }, ms);
+    timer.unref();
+  };
+  res.on('close', () => {
+    stop();
+    if (!res.writableEnded) control.abort();
+  });
+  arm();
+  return { signal: control.signal, ms, touch: arm, idle: () => expired, stop };
+}
+
+export async function readBody(req: IncomingMessage): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  let total = 0;
+  let over = false;
+  for await (const chunk of req) {
+    const buf = chunk as Buffer;
+    total += buf.length;
+    if (total > BODY_MAX) {
+      over = true;
+      if (total > BODY_MAX * DRAIN_FACTOR) break;
+      continue;
+    }
+    chunks.push(buf);
+  }
+  if (over) throw new GatewayError(413, 'invalid_request_error', 'request too large');
+  return Buffer.concat(chunks);
+}
+
+export function parseJson(raw: Buffer): Record<string, unknown> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw.toString('utf8'));
+  } catch {
+    throw new GatewayError(400, 'invalid_request_error', 'body must be JSON');
+  }
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+    throw new GatewayError(400, 'invalid_request_error', 'body must be a JSON object');
+  return parsed as Record<string, unknown>;
+}
+
+export function forwardedHeaders(req: IncomingMessage): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (HOP_BY_HOP.has(name) || value === undefined) continue;
+    out[name] = Array.isArray(value) ? value.join(', ') : value;
+  }
+  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 const OAUTH_BETA = 'oauth-2025-04-20';
+
+export function loginHeaders(req: IncomingMessage, token: string): Record<string, string> {
+  const headers = forwardedHeaders(req);
+  delete headers['x-api-key'];
+  headers.authorization = `Bearer ${token}`;
+  return addBeta(headers, OAUTH_BETA);
+}
+
+export function addBeta(headers: Record<string, string>, beta: string): Record<string, string> {
+  const listed = (headers['anthropic-beta'] ?? '')
+    .split(',')
+    .map((one) => one.trim())
+    .filter((one) => one !== '');
+  if (listed.includes(beta)) return headers;
+  return { ...headers, 'anthropic-beta': [...listed, beta].join(',') };
+}
+
+export interface PipeOptions {
+  keepalive?: boolean;
+  ownCredential?: boolean;
+  scanner?: UsageScanner;
+}
+
+function openResponse(upstream: Response, res: ServerResponse, opts: PipeOptions): boolean {
+  const headers: Record<string, string> = {};
+  upstream.headers.forEach((value, name) => {
+    if (!RESPONSE_DROP.has(name)) headers[name] = value;
+  });
+  res.writeHead(opts.ownCredential === true ? providerStatus(upstream.status) : upstream.status, headers);
+  return (upstream.headers.get('content-type') ?? '').startsWith('text/event-stream');
+}
+
+async function pump(body: ReadableStream<Uint8Array>, res: ServerResponse, watch: Watch, scanner?: UsageScanner): 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 }));
+    res.write(value);
+  }
+}
+
+export async function pipeResponse(upstream: Response, res: ServerResponse, watch: Watch, opts: PipeOptions = {}): Promise<void> {
+  const streaming = openResponse(upstream, res, opts);
+  const body = upstream.body;
+  if (body === null) {
+    res.end();
+    return;
+  }
+  const ping = opts.keepalive === true && streaming ? setInterval(() => res.write(PING_FRAME), PING_MS) : null;
+  try {
+    await pump(body, res, watch, opts.scanner);
+  } catch (err) {
+    if (!watch.idle()) throw err;
+    if (streaming) res.write(errorFrame('api_error', idleMessage(watch.ms)));
+  } finally {
+    if (ping !== null) clearInterval(ping);
+    watch.stop();
+    res.end();
+    opts.scanner?.done();
+  }
+}
+
+export interface Relayed {
+  push: (chunk: Uint8Array, emit: (frames: string) => void) => void;
+  close: () => string;
+  idle: (message: string) => string;
+}
+
+export async function relayFrames(upstream: Response, res: ServerResponse, watch: Watch, key: string, relayed: Relayed): Promise<void> {
+  res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive' });
+  const body = upstream.body;
+  if (body === null) {
+    res.end(relayed.close());
+    return;
+  }
+  const ping = setInterval(() => res.write(PING_FRAME), PING_MS);
+  const scanner = new UsageScanner(key);
+  const emit = (frames: string): void => {
+    if (frames === '') return;
+    scanner.feed(frames);
+    res.write(frames);
+  };
+  try {
+    const reader = body.getReader();
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      watch.touch();
+      relayed.push(value, emit);
+    }
+    emit(relayed.close());
+  } catch (err) {
+    if (!watch.idle()) throw err;
+    res.write(relayed.idle(idleMessage(watch.ms)));
+  } finally {
+    clearInterval(ping);
+    watch.stop();
+    res.end();
+    scanner.done();
+  }
+}
+
+export function upstreamMessage(text: string, fallback: string): string {
+  if (text === '') return fallback;
+  try {
+    const parsed = JSON.parse(text) as { message?: unknown; Message?: unknown; error?: { message?: unknown } };
+    const message = parsed.message ?? parsed.Message ?? parsed.error?.message;
+    return typeof message === 'string' && message !== '' ? message : text;
+  } catch {
+    return text;
+  }
+}
+
+const LIMIT_STATUSES = new Set([402, 429]);
+
+export interface Refusal {
+  status: number;
+  headers: Headers;
+}
+
+export interface Held {
+  res: ServerResponse;
+  refusal: () => Refusal | null;
+}
+
+function headersOf(raw: OutgoingHttpHeaders | OutgoingHttpHeader[] | undefined): Headers {
+  const out = new Headers();
+  if (raw === undefined || Array.isArray(raw)) return out;
+  for (const [name, value] of Object.entries(raw)) if (value !== undefined) out.set(name, Array.isArray(value) ? value.join(', ') : String(value));
+  return out;
+}
+
+export function holdLimitRefusal(res: ServerResponse): Held {
+  let refusal: Refusal | null = null;
+  const swallow = (): boolean => true;
+  const held: ServerResponse = new Proxy(res, {
+    get(target, prop) {
+      if (prop === 'writeHead')
+        return (status: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): ServerResponse => {
+          if (!LIMIT_STATUSES.has(status)) return target.writeHead(status, headers);
+          refusal = { status, headers: headersOf(headers) };
+          return held;
+        };
+      if (refusal !== null && (prop === 'write' || prop === 'end')) return swallow;
+      const value: unknown = Reflect.get(target, prop, target);
+      return typeof value === 'function' ? (value as (...args: unknown[]) => unknown).bind(target) : value;
+    },
+  });
+  return { res: held, refusal: () => refusal };
+}

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

@@ -0,0 +1,118 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+
+type Item = Record<string, unknown>;
+
+export interface Usage {
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_input_tokens: number;
+}
+
+export const frame = (event: string, data: unknown): string => `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+
+export const messageStart = (id: string, model: string): string =>
+  frame('message_start', {
+    type: 'message_start',
+    message: { id, type: 'message', role: 'assistant', model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0 } },
+  });
+
+export const messageEnd = (stop: string, usage: Usage): string =>
+  frame('message_delta', { type: 'message_delta', delta: { stop_reason: stop, stop_sequence: null }, usage }) + frame('message_stop', { type: 'message_stop' });
+
+export interface SseEvent {
+  event: string;
+  data: string;
+}
+
+export class SseParser {
+  private pending = '';
+
+  push(chunk: string): SseEvent[] {
+    this.pending += chunk;
+    const out: SseEvent[] = [];
+    for (;;) {
+      const at = this.pending.indexOf('\n\n');
+      if (at < 0) break;
+      const raw = this.pending.slice(0, at);
+      this.pending = this.pending.slice(at + 2);
+      let event = '';
+      const data: string[] = [];
+      for (const line of raw.split('\n')) {
+        if (line.startsWith('event:')) event = line.slice(6).trim();
+        else if (line.startsWith('data:')) data.push(line.slice(5).trimStart());
+      }
+      if (data.length > 0) out.push({ event, data: data.join('\n') });
+    }
+    return out;
+  }
+}
+
+export function parseEvent(raw: SseEvent): { event: string; data: Item } | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw.data);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed)) return null;
+  const event = raw.event !== '' ? raw.event : stringOf(parsed.type);
+  return event === '' ? null : { event, data: parsed };
+}
+
+interface Assembled {
+  message: Item;
+  blocks: Item[];
+}
+
+const FOLDS: Record<string, (state: Assembled, data: Item) => void> = {
+  message_start: (state, data) => {
+    if (isRecord(data.message)) state.message = { ...data.message };
+  },
+  content_block_start: (state, data) => {
+    if (isRecord(data.content_block)) state.blocks.push({ ...data.content_block });
+  },
+  content_block_delta: (state, data) => {
+    if (isRecord(data.delta)) applyDelta(state.blocks[typeof data.index === 'number' ? data.index : -1], data.delta);
+  },
+  message_delta: (state, data) => {
+    if (isRecord(data.delta)) state.message.stop_reason = data.delta.stop_reason ?? null;
+    if (isRecord(data.usage)) state.message.usage = data.usage;
+  },
+  error: (state, data) => {
+    state.message = { type: 'error', error: data.error };
+  },
+};
+
+function foldFrame(state: Assembled, event: string, data: Item): void {
+  FOLDS[event]?.(state, data);
+}
+
+function applyDelta(block: Item | undefined, delta: Item): void {
+  if (block === undefined) return;
+  if (delta.type === 'text_delta') block.text = stringOf(block.text) + stringOf(delta.text);
+  else if (delta.type === 'thinking_delta') block.thinking = stringOf(block.thinking) + stringOf(delta.thinking);
+  else if (delta.type === 'signature_delta') block.signature = stringOf(delta.signature);
+  else if (delta.type === 'input_json_delta') block.json = stringOf(block.json) + stringOf(delta.partial_json);
+}
+
+export function assembleMessage(frames: string): Item {
+  const state: Assembled = { message: {}, blocks: [] };
+  for (const raw of new SseParser().push(frames)) {
+    const parsed = parseEvent(raw);
+    if (parsed !== null) foldFrame(state, parsed.event, parsed.data);
+  }
+  if (state.message.type === 'error') return state.message;
+  const content = state.blocks.map((block) => {
+    if (block.type !== 'tool_use') return block;
+    const { json, ...rest } = block;
+    let input: unknown = {};
+    try {
+      input = JSON.parse(stringOf(json) || '{}');
+    } catch {
+      input = {};
+    }
+    return { ...rest, input };
+  });
+  return { ...state.message, content };
+}