@stage-labs/metro 0.1.0-beta.28 → 0.1.0-beta.280

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

@@ -0,0 +1,143 @@
+import { 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';
+import { stringOf } from '@metro-labs/http/api-http';
+import { OPENAI_API, CODEX_SIGN_IN, refreshTokens, tokensStale, type CodexTokens } from './codex-auth.js';
+import { refreshCodeTokens } from './codex-device.js';
+import { codexVersion, learnCodexVersion } from './codex-version.js';
+import { CodexEventTranslator, withUsageLink } from './codex-stream.js';
+import { ToolNames, toResponsesRequest } from './codex-translate.js';
+import { GatewayError, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
+import { parseEvent, SseParser, type SseEvent } from './frames.js';
+import type { Connection } from './model-config.js';
+import { listCache } from './model-lists.js';
+import { answerWhole, currentOf, errorKind, reach, refreshed, relayTranslated, sessionHeader, type TokenSource, type TokenState } from './subscription.js';
+import { noteUsageHeaders } from './usage.js';
+
+const CODEX_BACKEND = 'https://chatgpt.com/backend-api/codex';
+const INVALID = [400, 404, 422];
+
+export interface CodexDeps {
+  base?: string;
+  issuer?: string;
+  fetchImpl?: typeof fetch;
+  save: (id: string, tokens: CodexTokens) => void;
+}
+
+export type CodexState = TokenState<CodexTokens>;
+
+export const sharedCodexState: CodexState = new Map();
+
+const codexLists = listCache<string>('codex');
+
+const sourceOf = (deps: CodexDeps): TokenSource<CodexTokens> => ({
+  label: 'Codex',
+  stale: (tokens) => tokensStale(tokens),
+  refresh: (tokens) => (tokens.method === 'code' ? refreshCodeTokens(tokens, deps.issuer, deps.fetchImpl) : refreshTokens(tokens, deps.issuer, deps.fetchImpl)),
+  save: deps.save,
+});
+
+const OS_NAMES: Record<string, string> = { darwin: 'Mac OS', linux: 'Linux', win32: 'Windows' };
+
+export const userAgent = (): string => `codex_cli_rs/${codexVersion()} (${OS_NAMES[platform()] ?? platform()} ${release()}; ${arch()}) metro`;
+
+const baseFor = (tokens: CodexTokens, deps: Pick<CodexDeps, 'base'>): string => deps.base ?? (tokens.method === 'code' ? CODEX_BACKEND : OPENAI_API);
+
+function headersFor(tokens: CodexTokens, accept: string, sessionId: string): Record<string, string> {
+  const plain = { authorization: `Bearer ${tokens.accessToken}`, 'content-type': 'application/json', accept };
+  if (tokens.method === 'chatgpt') return plain;
+  return {
+    ...plain,
+    'chatgpt-account-id': tokens.accountId,
+    originator: 'codex_cli_rs',
+    'user-agent': userAgent(),
+    'openai-beta': 'responses=experimental',
+    'session-id': sessionId,
+  };
+}
+
+export const currentTokens = (conn: Connection, deps: CodexDeps, state: CodexState): Promise<CodexTokens> =>
+  currentOf(state, conn.id, conn.codex, sourceOf(deps), CODEX_SIGN_IN);
+
+interface Call {
+  body: Record<string, unknown>;
+  model: string;
+  sessionId: string;
+  watch: Watch;
+  deps: CodexDeps;
+  names: ToolNames;
+}
+
+function send(call: Call, tokens: CodexTokens): Promise<Response> {
+  const request = toResponsesRequest(call.body, call.model, { promptCacheKey: call.sessionId, names: call.names });
+  return (call.deps.fetchImpl ?? fetch)(`${baseFor(tokens, call.deps)}/responses`, {
+    method: 'POST',
+    headers: headersFor(tokens, 'text/event-stream', call.sessionId),
+    body: JSON.stringify(request),
+    signal: call.watch.signal,
+    redirect: 'manual',
+  });
+}
+
+function refusalOf(text: string, status: number): string {
+  let code = '';
+  try {
+    const parsed: unknown = JSON.parse(text);
+    code = isRecord(parsed) && isRecord(parsed.error) ? stringOf(parsed.error.code) : '';
+  } catch {
+    code = '';
+  }
+  return withUsageLink(code, upstreamMessage(text, `OpenAI answered ${String(status)}`));
+}
+
+export async function codexMessages(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  conn: Connection,
+  deps: CodexDeps,
+  state: CodexState,
+  watch: Watch,
+): Promise<void> {
+  const call: Call = { body, model, sessionId: sessionHeader(req) || randomUUID(), watch, deps, names: new ToolNames() };
+  const upstream = await reach(
+    () => currentTokens(conn, deps, state),
+    (tokens) => refreshed(state, conn.id, tokens, sourceOf(deps)),
+    (tokens) => send(call, tokens),
+  );
+  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));
+    return;
+  }
+  const translator = new CodexEventTranslator(model, (name) => call.names.restore(name));
+  const onEvent = (raw: SseEvent): string => {
+    const parsed = parseEvent(raw);
+    return parsed === null ? '' : translator.push(parsed.event, parsed.data);
+  };
+  if (body.stream === true) {
+    await relayTranslated(upstream, res, watch, conn.id, translator, onEvent);
+    return;
+  }
+  const frames = new SseParser().push(await upstream.text()).map(onEvent).join('');
+  answerWhole(res, frames + translator.close(), conn.id);
+}
+
+export async function codexModels(tokens: CodexTokens, deps: Omit<CodexDeps, 'save'>): Promise<string[]> {
+  const base = baseFor(tokens, deps);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  if (tokens.method === 'chatgpt') return codexLists.get(`${base}:${tokens.clientId}`, () => listCodex(tokens, `${base}/models`, fetchImpl));
+  const version = await learnCodexVersion();
+  return codexLists.get(`${base}:${tokens.accountId}:${version}`, () => listCodex(tokens, `${base}/models?client_version=${version}`, fetchImpl));
+}
+
+async function listCodex(tokens: CodexTokens, url: string, fetchImpl: typeof fetch): Promise<string[]> {
+  const res = await fetchImpl(url, { headers: headersFor(tokens, 'application/json', randomUUID()), redirect: 'manual' });
+  if (!res.ok) throw new GatewayError(res.status, errorKind(res.status, INVALID), `OpenAI would not list the models of this ChatGPT plan (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const models: unknown[] = isRecord(body) && Array.isArray(body.models) ? body.models : [];
+  return models.filter(isRecord).flatMap((m) => ((m.visibility ?? 'list') === 'list' && stringOf(m.slug) !== '' ? [stringOf(m.slug)] : []));
+}

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

@@ -0,0 +1,103 @@
+import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+
+const MAIN_EFFORT = 'low';
+const SUBAGENT_EFFORT = 'max';
+export const BINDING_BETA = 'thinking-binding-controls-2026-08-01';
+
+const SUBAGENT_HEADER = 'x-claude-code-agent-id';
+const SUBAGENT_MARK = 'cc_is_subagent=true';
+const ABOVE_HIGH = new Set(['xhigh', 'max']);
+
+export type RequestKind = 'main' | 'subagent' | 'other';
+
+type Body = Record<string, unknown>;
+
+const record = (value: unknown): Body => (isRecord(value) ? value : {});
+
+const effortOf = (body: Body): string => {
+  const effort = record(body.output_config).effort;
+  return typeof effort === 'string' ? effort : '';
+};
+
+function header(req: IncomingMessage, name: string): string {
+  const raw = req.headers[name];
+  return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
+}
+
+function systemMarksSubagent(body: Body): boolean {
+  const system = body.system;
+  if (!Array.isArray(system)) return false;
+  return system.some((block) => isRecord(block) && typeof block.text === 'string' && block.text.includes(SUBAGENT_MARK));
+}
+
+const chore = (body: Body): boolean => record(body.output_config).format !== undefined || record(body.thinking).type === 'disabled';
+
+export function requestKind(req: IncomingMessage, body: Body): RequestKind {
+  if (header(req, SUBAGENT_HEADER) !== '' || systemMarksSubagent(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 !== '');
+
+export function plannedEffort(req: IncomingMessage, body: Body): 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' ? SUBAGENT_EFFORT : MAIN_EFFORT;
+  return asked.every((effort) => effort === wanted) ? null : wanted;
+}
+
+const withOwnEffort = (item: Body, effort: string): Body => (effortOf(item) === '' ? item : { ...item, output_config: { ...record(item.output_config), effort } });
+
+export function withEffort(body: Body, effort: string): Body {
+  const top = withOwnEffort(body, effort);
+  if (!Array.isArray(body.messages)) return top;
+  return { ...top, messages: body.messages.map((message: unknown) => (isRecord(message) ? withOwnEffort(message, effort) : message)) };
+}
+
+export function withoutEffort(body: Body): Body {
+  const config = Object.fromEntries(Object.entries(record(body.output_config)).filter(([key]) => key !== 'effort'));
+  if (Object.keys(config).length > 0) return { ...body, output_config: config };
+  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'output_config'));
+}
+
+export function effortToApply(body: Body): string | null {
+  if (chore(body)) return null;
+  const effort = effortOf(body);
+  return effort === '' ? null : effort;
+}
+
+export const cappedEffort = (effort: string): string => (ABOVE_HIGH.has(effort) ? 'high' : effort);
+
+const THINKING_ALWAYS_ON = /claude-(fable|mythos)-5|claude-opus-5-5/;
+const REFUSES_THINKING_OFF = '"thinking.type.disabled" is not supported';
+const thinkingAlwaysOn = new Set<string>();
+
+export const thinkingOff = (body: Body): boolean => record(body.thinking).type === 'disabled';
+
+const alwaysThinks = (model: string): boolean => THINKING_ALWAYS_ON.test(model) || thinkingAlwaysOn.has(model);
+
+export function withThinkingFor(body: Body, model: string): Body {
+  if (!alwaysThinks(model) || !thinkingOff(body)) return body;
+  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'thinking'));
+}
+
+export function learnAlwaysThinks(model: string, refusal: string): boolean {
+  if (!refusal.includes(REFUSES_THINKING_OFF)) return false;
+  thinkingAlwaysOn.add(model);
+  return true;
+}
+
+export function forgetLearnedThinking(): void {
+  thinkingAlwaysOn.clear();
+}
+
+export function withBlockBinding(body: Body): Body {
+  const thinking = body.thinking;
+  if (!isRecord(thinking) || thinking.block_binding !== undefined) return body;
+  return { ...body, thinking: { ...thinking, block_binding: { prefix_mismatch_behavior: 'drop_block' } } };
+}

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

@@ -0,0 +1,123 @@
+export interface EventStreamMessage {
+  headers: Record<string, string>;
+  payload: Buffer;
+}
+
+const PRELUDE_BYTES = 12;
+const CRC_BYTES = 4;
+
+const HEADER_TRUE = 0;
+const HEADER_FALSE = 1;
+const HEADER_BYTE = 2;
+const HEADER_SHORT = 3;
+const HEADER_INT = 4;
+const HEADER_LONG = 5;
+const HEADER_BYTES = 6;
+const HEADER_STRING = 7;
+const HEADER_TIMESTAMP = 8;
+const HEADER_UUID = 9;
+
+const FIXED_WIDTH: Record<number, number> = {
+  [HEADER_TRUE]: 0,
+  [HEADER_FALSE]: 0,
+  [HEADER_BYTE]: 1,
+  [HEADER_SHORT]: 2,
+  [HEADER_INT]: 4,
+  [HEADER_LONG]: 8,
+  [HEADER_TIMESTAMP]: 8,
+  [HEADER_UUID]: 16,
+};
+
+function readHeaderValue(buf: Buffer, at: number, type: number): { value: string; next: number } {
+  if (type === HEADER_BYTES || type === HEADER_STRING) {
+    const len = buf.readUInt16BE(at);
+    const raw = buf.subarray(at + 2, at + 2 + len);
+    const value = type === HEADER_STRING ? raw.toString('utf8') : raw.toString('base64');
+    return { value, next: at + 2 + len };
+  }
+  const width = FIXED_WIDTH[type];
+  if (width === undefined) throw new Error(`eventstream: unknown header type ${String(type)}`);
+  if (type === HEADER_TRUE) return { value: 'true', next: at };
+  if (type === HEADER_FALSE) return { value: 'false', next: at };
+  return { value: buf.subarray(at, at + width).toString('hex'), next: at + width };
+}
+
+function readHeaders(buf: Buffer): Record<string, string> {
+  const out: Record<string, string> = {};
+  let at = 0;
+  while (at < buf.length) {
+    const nameLen = buf.readUInt8(at);
+    const name = buf.subarray(at + 1, at + 1 + nameLen).toString('utf8');
+    const type = buf.readUInt8(at + 1 + nameLen);
+    const parsed = readHeaderValue(buf, at + 2 + nameLen, type);
+    out[name] = parsed.value;
+    at = parsed.next;
+  }
+  return out;
+}
+
+function decodeFrame(buf: Buffer, offset: number): { message: EventStreamMessage; end: number } | null {
+  if (buf.length - offset < PRELUDE_BYTES) return null;
+  const total = buf.readUInt32BE(offset);
+  const headersLen = buf.readUInt32BE(offset + 4);
+  if (total < PRELUDE_BYTES + CRC_BYTES || headersLen > total) throw new Error('eventstream: malformed frame prelude');
+  if (buf.length - offset < total) return null;
+  const headersStart = offset + PRELUDE_BYTES;
+  const payloadStart = headersStart + headersLen;
+  const payloadEnd = offset + total - CRC_BYTES;
+  return {
+    message: {
+      headers: readHeaders(buf.subarray(headersStart, payloadStart)),
+      payload: Buffer.from(buf.subarray(payloadStart, payloadEnd)),
+    },
+    end: offset + total,
+  };
+}
+
+export class EventStreamDecoder {
+  private pending: Buffer = Buffer.alloc(0);
+
+  push(chunk: Buffer): EventStreamMessage[] {
+    this.pending = this.pending.length === 0 ? chunk : Buffer.concat([this.pending, chunk]);
+    const out: EventStreamMessage[] = [];
+    let offset = 0;
+    for (;;) {
+      const frame = decodeFrame(this.pending, offset);
+      if (frame === null) break;
+      out.push(frame.message);
+      offset = frame.end;
+    }
+    this.pending = this.pending.subarray(offset);
+    return out;
+  }
+}
+
+function encodeHeader(name: string, value: string): Buffer {
+  const nameBuf = Buffer.from(name, 'utf8');
+  const valueBuf = Buffer.from(value, 'utf8');
+  const out = Buffer.alloc(1 + nameBuf.length + 1 + 2 + valueBuf.length);
+  let at = 0;
+  out.writeUInt8(nameBuf.length, at);
+  at += 1;
+  nameBuf.copy(out, at);
+  at += nameBuf.length;
+  out.writeUInt8(HEADER_STRING, at);
+  at += 1;
+  out.writeUInt16BE(valueBuf.length, at);
+  at += 2;
+  valueBuf.copy(out, at);
+  return out;
+}
+
+export function encodeFrame(headers: Record<string, string>, payload: Buffer): Buffer {
+  const headerBuf = Buffer.concat(Object.entries(headers).map(([name, value]) => encodeHeader(name, value)));
+  const total = PRELUDE_BYTES + headerBuf.length + payload.length + CRC_BYTES;
+  const out = Buffer.alloc(total);
+  out.writeUInt32BE(total, 0);
+  out.writeUInt32BE(headerBuf.length, 4);
+  out.writeUInt32BE(0, 8);
+  headerBuf.copy(out, PRELUDE_BYTES);
+  payload.copy(out, PRELUDE_BYTES + headerBuf.length);
+  out.writeUInt32BE(0, total - CRC_BYTES);
+  return out;
+}

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 }));
+}