@stage-labs/metro 0.1.0-beta.23 → 0.1.0-beta.231

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

@@ -0,0 +1,161 @@
+import type { IncomingMessage } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { readJsonBody } from '@metro-labs/http/api-http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import { beginLogin, finishLogin, readCodexCliAuth, type CodexTokens } from './codex-auth.js';
+import { beginDeviceLogin, pollDeviceLogin } from './codex-device.js';
+import { codexModels, currentTokens, sharedCodexState } from './codex.js';
+import { beginLogin as beginGeminiLogin, exchangeCode as exchangeGeminiCode, userEmail, type GeminiTokens } from './gemini-auth.js';
+import { onboard, parseGeminiProject } from './gemini-setup.js';
+import { currentGeminiTokens, listGeminiModels, sharedGeminiState, type GeminiDeps } from './gemini.js';
+import { listCache } from './model-lists.js';
+import { forgetReported } from './usage.js';
+import {
+  addConnection,
+  connectionOf,
+  setCodexAuth,
+  setGeminiAuth,
+  type Connection,
+  type ModelConfig,
+  type Provider,
+} from './model-config.js';
+import { asApiError, askedConnection, BODY_MAX, connectionFor, settingsBody, type ModelApiDeps, type Route, type Store } from './model-store.js';
+
+function connectionToFill(store: Store, req: IncomingMessage, provider: Provider): { cfg: ModelConfig; id: string } {
+  const asked = askedConnection(req);
+  const current = store.read();
+  if (asked !== '') {
+    if (connectionOf(current, asked)?.provider !== provider) throw new ApiError('no such connection', 404);
+    return { cfg: current, id: asked };
+  }
+  const cfg = addConnection(current, { provider });
+  return { cfg, id: cfg.connections.at(-1)?.id ?? '' };
+}
+
+const saved = (store: Store, cfg: ModelConfig, note: string, fields: { connection: string } & Record<string, unknown>): unknown => {
+  store.write(cfg);
+  forgetReported(fields.connection);
+  log.info(fields, note);
+  return settingsBody(cfg);
+};
+
+function keepCodex(store: Store, req: IncomingMessage, tokens: CodexTokens | null, note: string): unknown {
+  const { cfg, id } = connectionToFill(store, req, 'codex');
+  const next = setCodexAuth(cfg, id, tokens);
+  return saved(store, next, note, { connection: id, plan: tokens?.plan ?? null });
+}
+
+async function pollDevice(id: string, req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<unknown> {
+  const result = await pollDeviceLogin(id, deps.fetchImpl).catch(asApiError);
+  if (result.status !== 'done') return result;
+  return { status: 'done', settings: keepCodex(store, req, result.tokens, 'model-api: Codex connected by device code') };
+}
+
+export const codexDepsFor = (deps: ModelApiDeps, store: Store, id: string): { issuer?: string; fetchImpl?: typeof fetch; base?: string; save: (connId: string, t: CodexTokens) => void } => ({
+  issuer: deps.issuer,
+  fetchImpl: deps.fetchImpl,
+  base: deps.codexBase,
+  save: (connId, t) => {
+    store.write(setCodexAuth(store.read(), connId === '' ? id : connId, t));
+  },
+});
+
+export const CODEX_ROUTES: Record<string, Route> = {
+  device: {
+    method: 'POST',
+    run: async (_req, deps) => {
+      const login = await beginDeviceLogin(deps.issuer, deps.fetchImpl).catch(asApiError);
+      return { id: login.id, user_code: login.userCode, verify_url: login.verifyUrl, interval: login.interval };
+    },
+  },
+  login: { method: 'POST', run: (_req, deps) => Promise.resolve({ url: beginLogin(deps.issuer).url }) },
+  callback: {
+    method: 'POST',
+    run: async (req, deps, store) => {
+      const body = await readJsonBody(req, BODY_MAX);
+      const raw = isRecord(body) && typeof body.url === 'string' ? body.url : '';
+      const tokens = await finishLogin(raw, deps.issuer, deps.fetchImpl).catch(asApiError);
+      return keepCodex(store, req, tokens, 'model-api: Codex connected');
+    },
+  },
+  import: {
+    method: 'POST',
+    run: (_req, deps, store) => {
+      let tokens;
+      try {
+        tokens = readCodexCliAuth(deps.codexHome);
+      } catch (err) {
+        asApiError(err);
+      }
+      return Promise.resolve(keepCodex(store, _req, tokens, 'model-api: Codex CLI login imported'));
+    },
+  },
+  models: {
+    method: 'GET',
+    run: async (req, deps, store) => {
+      const conn = connectionFor(store.read(), req, 'codex');
+      if (conn.codex === null) throw new ApiError('this connection is not signed in yet', 400);
+      const codexDeps = codexDepsFor(deps, store, conn.id);
+      const auth = await currentTokens(conn, codexDeps, sharedCodexState).catch(asApiError);
+      return { models: await codexModels(auth, codexDeps).catch(asApiError) };
+    },
+  },
+};
+
+const geminiDeps = (deps: ModelApiDeps, store: Store): GeminiDeps => ({
+  base: deps.geminiBase,
+  tokenBase: deps.geminiTokenBase,
+  fetchImpl: deps.fetchImpl,
+  save: (id, t) => {
+    store.write(setGeminiAuth(store.read(), id, t));
+  },
+});
+
+export async function geminiModelsOf(conn: Connection, deps: ModelApiDeps, store: Store): Promise<Awaited<ReturnType<typeof listGeminiModels>>> {
+  if (conn.gemini === null) throw new ApiError('this connection is not signed in yet', 400);
+  const tokens = await currentGeminiTokens(conn, geminiDeps(deps, store), sharedGeminiState);
+  return listGeminiModels(tokens, geminiDeps(deps, store));
+}
+
+function projectOf(body: unknown): string | null {
+  try {
+    return parseGeminiProject(isRecord(body) ? body.project : null);
+  } catch (err) {
+    return asApiError(err);
+  }
+}
+
+async function connectGemini(req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<unknown> {
+  const body = await readJsonBody(req, BODY_MAX);
+  const code = isRecord(body) && typeof body.code === 'string' ? body.code : '';
+  const state = isRecord(body) && typeof body.state === 'string' ? body.state : '';
+  const project = projectOf(body);
+  const tokens = await exchangeGeminiCode(code, state, deps.geminiTokenBase, deps.fetchImpl).catch(asApiError);
+  const email = await userEmail(tokens, deps.geminiUserBase, deps.fetchImpl);
+  const onboarded = await onboard(tokens, project, deps.geminiBase, deps.fetchImpl).catch(asApiError);
+  const { cfg, id } = connectionToFill(store, req, 'gemini');
+  const full: GeminiTokens = { ...tokens, email, project: onboarded.project, tier: onboarded.tier };
+  return saved(store, setGeminiAuth(cfg, id, full), 'model-api: Gemini connected', { connection: id, tier: onboarded.tier });
+}
+
+const geminiLists = listCache<string>('gemini');
+
+async function geminiIds(req: IncomingMessage, deps: ModelApiDeps, store: Store): Promise<string[]> {
+  const conn = connectionFor(store.read(), req, 'gemini');
+  const key = `${deps.geminiBase ?? ''}:${conn.id}:${conn.gemini?.email ?? ''}:${conn.gemini?.project ?? ''}`;
+  return geminiLists.get(key, async () => (await geminiModelsOf(conn, deps, store)).map((m) => m.id));
+}
+
+export const GEMINI_ROUTES: Record<string, Route> = {
+  login: { method: 'POST', run: (_req, deps) => Promise.resolve(beginGeminiLogin(deps.geminiAuthBase)) },
+  code: { method: 'POST', run: connectGemini },
+  models: {
+    method: 'GET',
+    run: async (req, deps, store) => ({ models: await geminiIds(req, deps, store).catch(asApiError) }),
+  },
+};
+
+export function codexDeviceRoute(id: string, method: string | undefined): Route | number {
+  return method === 'GET' ? { method: 'GET', run: (req, deps, store) => pollDevice(id, req, deps, store) } : 405;
+}

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

@@ -0,0 +1,72 @@
+import type { IncomingMessage } from 'node:http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { CodexAuthError } from './codex-auth.js';
+import { GeminiAuthError } from './gemini-auth.js';
+import { GatewayError } from './forward.js';
+import { lastServed } from './served.js';
+import { usageSeen } from './usage.js';
+import { ModelConfigError, connectionOf, publicModelConfig, routedConnection, type Connection, type ModelConfig, type Provider } from './model-config.js';
+import type { SetupDeps } from '../claude/setup.js';
+
+export interface ModelApiDeps {
+  read?: () => ModelConfig;
+  write?: (cfg: ModelConfig) => void;
+  issuer?: string;
+  fetchImpl?: typeof fetch;
+  codexHome?: string;
+  codexBase?: string;
+  geminiAuthBase?: string;
+  geminiTokenBase?: string;
+  geminiUserBase?: string;
+  geminiBase?: string;
+  openrouterBase?: string;
+  anthropicBase?: string;
+  bedrockControlBase?: string;
+  setup?: SetupDeps;
+  restartSession?: () => boolean;
+  claudeUsage?: () => Promise<unknown>;
+  usageWaitMs?: number;
+}
+
+export interface Store {
+  read: () => ModelConfig;
+  write: (cfg: ModelConfig) => void;
+}
+
+type Handler = (req: IncomingMessage, deps: ModelApiDeps, store: Store) => Promise<unknown>;
+
+export interface Route {
+  method: 'GET' | 'POST';
+  run: Handler;
+}
+
+export const BODY_MAX = 16 * 1024;
+export const CREDITS_TTL_MS = 5 * 60_000;
+
+export const settingsBody = (cfg: ModelConfig): Record<string, unknown> => ({
+  ...publicModelConfig(cfg),
+  lastServed: lastServed(),
+  usage: usageSeen(),
+});
+
+export function asApiError(err: unknown): never {
+  if (err instanceof ModelConfigError || err instanceof CodexAuthError || err instanceof GeminiAuthError) throw new ApiError(err.message, 400);
+  if (err instanceof GatewayError) throw new ApiError(err.message, err.status >= 400 && err.status < 500 ? 400 : 502);
+  throw err;
+}
+
+export const askedConnection = (req: IncomingMessage): string => new URL(req.url ?? '', 'http://metro').searchParams.get('connection') ?? '';
+
+export function connectionFor(cfg: ModelConfig, req: IncomingMessage, provider: Provider): Connection {
+  const asked = askedConnection(req);
+  if (asked !== '') {
+    const found = connectionOf(cfg, asked);
+    if (found?.provider !== provider) throw new ApiError('no such connection', 404);
+    return found;
+  }
+  const routed = routedConnection(cfg);
+  if (routed?.provider === provider) return routed;
+  const first = cfg.connections.find((c) => c.provider === provider);
+  if (first === undefined) throw new ApiError(`no ${provider} connection yet`, 400);
+  return first;
+}

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

@@ -0,0 +1,104 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { GatewayError } from './forward.js';
+import { listCache } from './model-lists.js';
+import { stringOf } from '@metro-labs/http/api-http';
+import type { KeySpend } from './usage.js';
+
+export const OPENROUTER_BASE = 'https://openrouter.ai/api';
+const MODELS_MAX = 2000;
+const KEY_TIMEOUT_MS = 10_000;
+
+export interface OpenRouterModel {
+  id: string;
+  name: string;
+  prompt: number | null;
+  completion: number | null;
+  created: number | null;
+}
+
+const modelLists = listCache<OpenRouterModel>('openrouter');
+const zdrLists = listCache<string>('openrouter-zdr');
+
+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 released(raw: unknown): number | null {
+  return typeof raw === 'number' && Number.isFinite(raw) && raw > 0 ? raw : null;
+}
+
+const strings = (value: unknown): string[] | null => (Array.isArray(value) ? value.filter((v): v is string => typeof v === 'string') : null);
+
+function chatCapable(entry: Record<string, unknown>): boolean {
+  const output = strings(isRecord(entry.architecture) ? entry.architecture.output_modalities : undefined);
+  const params = strings(entry.supported_parameters);
+  return (output === null || output.includes('text')) && (params === null || params.includes('tools'));
+}
+
+function modelOf(entry: unknown): OpenRouterModel | null {
+  if (!isRecord(entry) || !chatCapable(entry)) return null;
+  const id = stringOf(entry.id);
+  if (id === '') return null;
+  const pricing = isRecord(entry.pricing) ? entry.pricing : {};
+  return {
+    id,
+    name: stringOf(entry.name) || id,
+    prompt: price(pricing.prompt),
+    completion: price(pricing.completion),
+    created: released(entry.created),
+  };
+}
+
+function newestFirst(a: OpenRouterModel, b: OpenRouterModel): number {
+  const when = (b.created ?? 0) - (a.created ?? 0);
+  return when !== 0 ? when : a.id.localeCompare(b.id);
+}
+
+async function listModels(base: string, fetchImpl: typeof fetch): Promise<OpenRouterModel[]> {
+  const res = await fetchImpl(`${base}/v1/models`, { headers: { accept: 'application/json' }, redirect: 'manual' });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its models (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = typeof body === 'object' && body !== null ? (body as { data?: unknown }).data : undefined;
+  if (!Array.isArray(data)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no model list');
+  return data
+    .map(modelOf)
+    .filter((model): model is OpenRouterModel => model !== null)
+    .sort(newestFirst)
+    .slice(0, MODELS_MAX);
+}
+
+export const openrouterModels = (base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<OpenRouterModel[]> =>
+  modelLists.get(base, () => listModels(base, fetchImpl));
+
+const nullableAmount = (raw: unknown): number | null => (typeof raw === 'number' && Number.isFinite(raw) ? raw : null);
+
+export async function openrouterKey(apiKey: string, base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<KeySpend> {
+  const res = await fetchImpl(`${base}/v1/key`, {
+    headers: { accept: 'application/json', authorization: `Bearer ${apiKey}` },
+    redirect: 'manual',
+    signal: AbortSignal.timeout(KEY_TIMEOUT_MS),
+  });
+  if (!res.ok) {
+    await res.body?.cancel();
+    throw new GatewayError(res.status, 'api_error', `OpenRouter would not describe the stored key (${String(res.status)})`);
+  }
+  const body: unknown = await res.json();
+  const data = isRecord(body) && isRecord(body.data) ? body.data : {};
+  const spent = nullableAmount(data.usage);
+  if (spent === null) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no spend for the key');
+  return { limit: nullableAmount(data.limit), remaining: nullableAmount(data.limit_remaining), spent };
+}
+
+async function listZdr(base: string, fetchImpl: typeof fetch): Promise<string[]> {
+  const res = await fetchImpl(`${base}/v1/endpoints/zdr`, { headers: { accept: 'application/json' }, redirect: 'manual' });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `OpenRouter would not list its zero data retention endpoints (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = typeof body === 'object' && body !== null ? (body as { data?: unknown }).data : undefined;
+  if (!Array.isArray(data)) throw new GatewayError(502, 'api_error', 'OpenRouter answered with no endpoint list');
+  const ids = new Set<string>();
+  for (const entry of data) if (isRecord(entry) && stringOf(entry.model_id) !== '') ids.add(stringOf(entry.model_id));
+  return [...ids].sort();
+}
+
+export const openrouterZdrModels = (base = OPENROUTER_BASE, fetchImpl: typeof fetch = fetch): Promise<string[]> => zdrLists.get(base, () => listZdr(base, fetchImpl));

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

@@ -0,0 +1,36 @@
+import { createHash, randomBytes } from 'node:crypto';
+
+const PENDING_TTL_MS = 10 * 60_000;
+
+const b64url = (buf: Buffer): string => buf.toString('base64url');
+
+export function newPkce(): { verifier: string; challenge: string } {
+  const verifier = b64url(randomBytes(32));
+  return { verifier, challenge: b64url(createHash('sha256').update(verifier).digest()) };
+}
+
+export class PendingLogins {
+  private readonly pending = new Map<string, { verifier: string; at: number }>();
+
+  constructor(private readonly stateBytes: number) {}
+
+  private sweep(now: number): void {
+    for (const [state, entry] of this.pending) if (now - entry.at > PENDING_TTL_MS) this.pending.delete(state);
+  }
+
+  begin(now: number): { state: string; challenge: string } {
+    this.sweep(now);
+    const { verifier, challenge } = newPkce();
+    const state = b64url(randomBytes(this.stateBytes));
+    this.pending.set(state, { verifier, at: now });
+    return { state, challenge };
+  }
+
+  take(state: string, now: number): string | null {
+    this.sweep(now);
+    const entry = this.pending.get(state);
+    if (entry === undefined) return null;
+    this.pending.delete(state);
+    return entry.verifier;
+  }
+}

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

@@ -0,0 +1,118 @@
+import type { IncomingHttpHeaders } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { GatewayError } from './forward.js';
+import type { Connection } from './model-config.js';
+import { fingerprint, listCache } from './model-lists.js';
+import { stringOf } from '@metro-labs/http/api-http';
+
+export const ANTHROPIC_API = 'https://api.anthropic.com';
+const ANTHROPIC_VERSION = '2023-06-01';
+const LIST_MAX = 1000;
+const LIST_TIMEOUT_MS = 10_000;
+const OAUTH_BETA = 'oauth-2025-04-20';
+const BEARER = 'Bearer ';
+
+export interface ProviderModel {
+  id: string;
+  name: string;
+}
+
+interface Dated extends ProviderModel {
+  created: string;
+}
+
+const KNOWN_CLAUDE: ProviderModel[] = [
+  { id: 'claude-sonnet-5-5', name: 'Claude Sonnet 5.5' },
+  { id: 'claude-opus-5-5', name: 'Claude Opus 5.5' },
+  { id: 'claude-fable-5-1', name: 'Claude Fable 5.1' },
+  { id: 'claude-opus-5', name: 'Claude Opus 5' },
+  { id: 'claude-sonnet-5', name: 'Claude Sonnet 5' },
+  { id: 'claude-haiku-4-5', name: 'Claude Haiku 4.5' },
+];
+
+const claudeLists = listCache<ProviderModel>('anthropic');
+const bedrockLists = listCache<ProviderModel>('bedrock');
+
+const newestFirst = (list: Dated[]): ProviderModel[] =>
+  list.sort((a, b) => b.created.localeCompare(a.created) || a.id.localeCompare(b.id)).map(({ id, name }) => ({ id, name }));
+
+function claudeEntry(entry: unknown): Dated[] {
+  if (!isRecord(entry) || stringOf(entry.id) === '') return [];
+  const type = stringOf(entry.type);
+  if (type !== '' && type !== 'model') return [];
+  const id = stringOf(entry.id);
+  return [{ id, name: stringOf(entry.display_name) || id, created: stringOf(entry.created_at) }];
+}
+
+async function listClaude(auth: Record<string, string>, what: string, base: string, fetchImpl: typeof fetch): Promise<ProviderModel[]> {
+  const res = await fetchImpl(`${base}/v1/models?limit=${String(LIST_MAX)}`, {
+    headers: { ...auth, 'anthropic-version': ANTHROPIC_VERSION, accept: 'application/json' },
+    redirect: 'manual',
+    signal: AbortSignal.timeout(LIST_TIMEOUT_MS),
+  });
+  if (!res.ok) throw new GatewayError(res.status, 'api_error', `Anthropic would not list its models with ${what} (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const data = isRecord(body) && Array.isArray(body.data) ? body.data : null;
+  if (data === null) throw new GatewayError(502, 'api_error', 'Anthropic answered with no model list');
+  return newestFirst(data.flatMap(claudeEntry));
+}
+
+const loginKey = (base: string): string => `login:${base}`;
+
+const first = (value: string | string[] | undefined): string => (Array.isArray(value) ? value[0] : value)?.trim() ?? '';
+
+function loginAuth(headers: IncomingHttpHeaders): Record<string, string> | null {
+  const bearer = first(headers.authorization);
+  if (bearer.startsWith(BEARER) && bearer.length > BEARER.length) return { authorization: bearer, 'anthropic-beta': OAUTH_BETA };
+  const key = first(headers['x-api-key']);
+  return key === '' ? null : { 'x-api-key': key };
+}
+
+export function refreshLoginModels(headers: IncomingHttpHeaders, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<void> {
+  const auth = loginAuth(headers);
+  if (auth === null) return Promise.resolve();
+  return claudeLists.refresh(loginKey(base), () => listClaude(auth, 'the Claude Code login', base, fetchImpl));
+}
+
+export async function anthropicModels(settings: Connection, base = ANTHROPIC_API, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
+  if (settings.apiKey === '') {
+    const live = claudeLists.peek(loginKey(base)) ?? [];
+    return live.length > 0 ? live : KNOWN_CLAUDE;
+  }
+  return claudeLists.get(`key:${base}:${fingerprint(settings.apiKey)}`, () => listClaude({ 'x-api-key': settings.apiKey }, 'the stored key', base, fetchImpl));
+}
+
+export const bedrockControlBase = (region: string): string => `https://bedrock.${region}.amazonaws.com`;
+
+function bedrockEntry(entry: unknown): Dated[] {
+  if (!isRecord(entry)) return [];
+  const id = stringOf(entry.inferenceProfileId);
+  const status = stringOf(entry.status);
+  if (id === '' || !id.includes('anthropic') || (status !== '' && status !== 'ACTIVE')) return [];
+  return [{ id, name: stringOf(entry.inferenceProfileName) || id, created: stringOf(entry.createdAt) }];
+}
+
+async function listBedrock(settings: Connection, base: string, fetchImpl: typeof fetch): Promise<ProviderModel[]> {
+  const res = await fetchImpl(`${base}/inference-profiles?maxResults=${String(LIST_MAX)}`, {
+    headers: { authorization: `Bearer ${settings.apiKey}`, accept: 'application/json' },
+    redirect: 'manual',
+    signal: AbortSignal.timeout(LIST_TIMEOUT_MS),
+  });
+  if (!res.ok)
+    throw new GatewayError(
+      res.status,
+      'api_error',
+      `Bedrock would not list its inference profiles (${String(res.status)}); the stored key may cover the runtime only, so type the model id instead`,
+    );
+  const body: unknown = await res.json();
+  const list = isRecord(body) && Array.isArray(body.inferenceProfileSummaries) ? body.inferenceProfileSummaries : null;
+  if (list === null) throw new GatewayError(502, 'api_error', 'Bedrock answered with no inference profile list');
+  return newestFirst(list.flatMap(bedrockEntry));
+}
+
+export async function bedrockModels(settings: Connection, base?: string, fetchImpl: typeof fetch = fetch): Promise<ProviderModel[]> {
+  if (settings.region === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs a region before its models can be listed');
+  if (settings.apiKey === '') throw new GatewayError(400, 'invalid_request_error', 'Bedrock needs an API key before its models can be listed');
+  const from = base ?? bedrockControlBase(settings.region);
+  return bedrockLists.get(`${from}:${fingerprint(settings.apiKey)}`, () => listBedrock(settings, from, fetchImpl));
+}

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

@@ -0,0 +1,18 @@
+export interface Served {
+  connection: string;
+  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/node_modules/@metro-labs/daemon/src/gateway/subscription.ts

@@ -0,0 +1,120 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { errMsg } from '@metro-labs/core/log';
+import { assembleMessage, SseParser, type SseEvent } from './frames.js';
+import { GatewayError, relayFrames, type Watch } from './forward.js';
+import { UsageScanner } from './usage.js';
+
+const STATUS_OF: Record<string, number> = { rate_limit_error: 429, invalid_request_error: 400, permission_error: 403, overloaded_error: 529 };
+
+interface Slot<T> {
+  refreshing: Promise<T> | null;
+  latest: T | null;
+}
+
+export type TokenState<T> = Map<string, Slot<T>>;
+
+export interface TokenSource<T extends { savedAt: string }> {
+  label: string;
+  stale: (tokens: T) => boolean;
+  refresh: (tokens: T) => Promise<T>;
+  save: (id: string, tokens: T) => void;
+}
+
+function slotFor<T>(state: TokenState<T>, id: string): Slot<T> {
+  const found = state.get(id);
+  if (found !== undefined) return found;
+  const made: Slot<T> = { refreshing: null, latest: null };
+  state.set(id, made);
+  return made;
+}
+
+const newerThan = (a: { savedAt: string }, b: { savedAt: string }): boolean => Date.parse(a.savedAt) > Date.parse(b.savedAt);
+
+export function refreshed<T extends { savedAt: string }>(state: TokenState<T>, id: string, tokens: T, source: TokenSource<T>): Promise<T> {
+  const slot = slotFor(state, id);
+  const latest = slot.latest;
+  if (latest !== null && newerThan(latest, tokens) && !source.stale(latest)) return Promise.resolve(latest);
+  if (slot.refreshing !== null) return slot.refreshing;
+  const run = source
+    .refresh(tokens)
+    .then((fresh) => {
+      source.save(id, fresh);
+      slot.latest = fresh;
+      return fresh;
+    })
+    .catch((err: unknown) => {
+      throw new GatewayError(403, 'permission_error', `${source.label} sign-in expired (${errMsg(err)}): connect again on the Model page`);
+    })
+    .finally(() => {
+      slot.refreshing = null;
+    });
+  slot.refreshing = run;
+  return run;
+}
+
+export function currentOf<T extends { savedAt: string }>(state: TokenState<T>, id: string, tokens: T | null, source: TokenSource<T>, missing: string): Promise<T> {
+  if (tokens === null) throw new GatewayError(400, 'invalid_request_error', missing);
+  return source.stale(tokens) ? refreshed(state, id, tokens, source) : Promise.resolve(tokens);
+}
+
+export async function reach<T>(current: () => Promise<T>, again: (tokens: T) => Promise<T>, send: (tokens: T) => Promise<Response>): Promise<Response> {
+  const tokens = await current();
+  const upstream = await send(tokens);
+  if (upstream.status !== 401) return upstream;
+  await upstream.body?.cancel();
+  return send(await again(tokens));
+}
+
+export function errorKind(status: number, invalid: readonly number[] = [400, 404]): string {
+  if (status === 401 || status === 403) return 'permission_error';
+  if (status === 429) return 'rate_limit_error';
+  if (invalid.includes(status)) return 'invalid_request_error';
+  return 'api_error';
+}
+
+export function sessionHeader(req: IncomingMessage): string {
+  const raw = req.headers['x-claude-code-session-id'];
+  return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
+}
+
+interface Translator {
+  readonly finished: boolean;
+  close: (message?: string) => string;
+}
+
+export function relayTranslated(
+  upstream: Response,
+  res: ServerResponse,
+  watch: Watch,
+  key: string,
+  translator: Translator,
+  onEvent: (raw: SseEvent) => string,
+): Promise<void> {
+  const parser = new SseParser();
+  const decoder = new TextDecoder();
+  return relayFrames(upstream, res, watch, key, {
+    push: (chunk, emit) => {
+      for (const raw of parser.push(decoder.decode(chunk, { stream: true }))) emit(onEvent(raw));
+    },
+    close: () => translator.close(),
+    idle: (message) => (translator.finished ? '' : translator.close(message)),
+  });
+}
+
+export function answerWhole(res: ServerResponse, frames: string, key: string): void {
+  const scanner = new UsageScanner(key);
+  scanner.feed(frames);
+  scanner.done();
+  const message = assembleMessage(frames);
+  const kind = isRecord(message.error) ? String(message.error.type) : '';
+  res.writeHead(message.type === 'error' ? (STATUS_OF[kind] ?? 502) : 200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify(message));
+}
+
+export const estimateTokens = (body: Record<string, unknown>): number => Math.ceil(JSON.stringify(body).length / 4);
+
+export function countTokens(res: ServerResponse, body: Record<string, unknown>): void {
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ input_tokens: estimateTokens(body) }));
+}

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

@@ -0,0 +1,35 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+
+const IMAGE_NOTE = '[an image was attached here; this model cannot see it]';
+export const TOOL_ERROR = '[tool error]';
+
+export const nonEmpty = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
+
+export interface InlineImage {
+  mediaType: string;
+  data: string;
+}
+
+type Part = Record<string, unknown>;
+type Accepts = (mediaType: string) => boolean;
+const anyImage: Accepts = () => true;
+
+export function inlineImage(block: Part, accepts = anyImage): InlineImage | null {
+  if (block.type !== 'image' || !isRecord(block.source) || block.source.type !== 'base64') return null;
+  const image = { mediaType: stringOf(block.source.media_type), data: stringOf(block.source.data) };
+  return image.mediaType !== '' && image.data !== '' && accepts(image.mediaType) ? image : null;
+}
+
+export const resultParts = (block: Part): Part[] => (Array.isArray(block.content) ? block.content.filter(isRecord) : []);
+
+export const partText = (part: Part, accepts = anyImage): string =>
+  part.type === 'text' ? stringOf(part.text) : part.type === 'image' && inlineImage(part, accepts) === null ? IMAGE_NOTE : '';
+
+export function resultText(block: Part, accepts = anyImage): string {
+  const content = block.content;
+  const text = typeof content === 'string' ? content : resultParts(block).map((part) => partText(part, accepts)).filter((t) => t !== '').join('\n');
+  return block.is_error === true ? `${TOOL_ERROR} ${text}` : text;
+}
+
+export const resultImages = (block: Part, accepts = anyImage): InlineImage[] => resultParts(block).flatMap((part) => inlineImage(part, accepts) ?? []);