@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.321

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

@@ -0,0 +1,150 @@
+import type { RouteEffort } from '@metro-labs/core/effort';
+
+export const PROVIDERS = ['anthropic', 'bedrock', 'openrouter', 'codex', 'routeway'] as const;
+export type Provider = (typeof PROVIDERS)[number];
+export type CodexMethod = 'chatgpt' | 'code';
+export type RouteSource = 'agent' | 'organization';
+
+export interface CodexAccess {
+  method: CodexMethod;
+  accessToken: string;
+  expiresAt: number;
+  accountId: string | null;
+}
+
+export interface Account {
+  email: string | null;
+  plan: string | null;
+  method: CodexMethod | null;
+}
+
+export interface Connection {
+  id: string;
+  provider: Provider;
+  label: string;
+  model: string;
+  apiKey: string;
+  region: string;
+  zdr: boolean;
+  revision: number;
+  codex: CodexAccess | null;
+  claudeToken: string;
+  account: Account;
+  signedOut: boolean;
+}
+
+export interface Fallback {
+  connection: string;
+  model: string;
+}
+
+export interface Chain {
+  primary: Fallback;
+  fallbacks: Fallback[];
+}
+
+export interface ModelSetup {
+  primary: Fallback | null;
+  fallbacks: Fallback[];
+  connections: Connection[];
+  source: RouteSource | null;
+  helpers?: Chain | null;
+  effort?: RouteEffort;
+}
+
+export interface Route {
+  connection: Connection;
+  model: string;
+}
+
+export const CODEX_SIGN_IN = "Codex is not signed in: sign in again on the organization's Models page.";
+
+const PREFIX_RE = /^(anthropic|bedrock|openrouter|codex|routeway):(.+)$/;
+const SMALL_RE = /haiku/i;
+
+export const isProvider = (value: unknown): value is Provider => typeof value === 'string' && (PROVIDERS as readonly string[]).includes(value);
+
+export const emptySetup = (): ModelSetup => ({ primary: null, fallbacks: [], connections: [], source: null });
+
+export const connectionOf = (setup: ModelSetup, id: string): Connection | null => setup.connections.find((c) => c.id === id) ?? null;
+
+export function primaryRoute(setup: ModelSetup): Route | null {
+  const steps = setup.primary === null ? [] : [setup.primary, ...setup.fallbacks];
+  for (const step of steps) {
+    const conn = connectionOf(setup, step.connection);
+    if (conn !== null) return { connection: conn, model: step.model === '' ? conn.model : step.model };
+  }
+  return null;
+}
+
+const CHECKS: Record<Provider, [(r: Route) => boolean, string][]> = {
+  anthropic: [[(r) => r.connection.apiKey === '' && r.connection.claudeToken === '', "Anthropic has no API key or Claude subscription: add one on the organization's Models page."]],
+  bedrock: [
+    [(r) => r.connection.apiKey === '', "Bedrock has no API key: add it on the organization's Models page."],
+    [(r) => r.connection.region === '', "Bedrock needs a region: add it on the organization's Models page."],
+  ],
+  openrouter: [
+    [(r) => r.connection.apiKey === '', "OpenRouter has no API key: add it on the organization's Models page."],
+    [(r) => r.model === '', "OpenRouter needs a model id: choose one on the organization's Models page."],
+  ],
+  codex: [
+    [(r) => r.connection.codex === null, CODEX_SIGN_IN],
+    [(r) => r.model === '', "Codex needs a model id: choose one on the organization's Models page."],
+  ],
+  routeway: [
+    [(r) => r.connection.apiKey === '', "Routeway has no API key: add it on the organization's Models page."],
+    [(r) => r.model === '', "Routeway needs a model id: choose one on the organization's Models page."],
+  ],
+};
+
+export const notReady = (route: Route): string | null => CHECKS[route.connection.provider].find(([missing]) => missing(route))?.[1] ?? null;
+
+export const isSmallModel = (requested: string): boolean => SMALL_RE.test(requested);
+
+const DEFAULTS: Record<Provider, (requested: string, model: string) => string> = {
+  openrouter: (requested, model) => (requested.includes('/') ? requested : model),
+  bedrock: (requested, model) => (model === '' ? requested : model),
+  codex: (requested, model) => (requested.startsWith('gpt-') ? requested : model),
+  routeway: (_requested, model) => model,
+  anthropic: (requested, model) => (model === '' || isSmallModel(requested) ? requested : model),
+};
+
+function forProvider(setup: ModelSetup, provider: Provider): Connection | null {
+  const routed = primaryRoute(setup)?.connection ?? null;
+  if (routed?.provider === provider) return routed;
+  return setup.connections.find((c) => c.provider === provider) ?? null;
+}
+
+export const bareModel = (requested: string): string => PREFIX_RE.exec(requested)?.[2]?.trim() ?? requested;
+
+export function resolveRoute(requested: string, setup: ModelSetup): Route | null {
+  const explicit = PREFIX_RE.exec(requested);
+  if (explicit !== null && isProvider(explicit[1])) {
+    const conn = forProvider(setup, explicit[1]);
+    if (conn !== null) return { connection: conn, model: (explicit[2] ?? '').trim() };
+  }
+  const primary = primaryRoute(setup);
+  if (primary === null) return null;
+  return { connection: primary.connection, model: DEFAULTS[primary.connection.provider](bareModel(requested), primary.model) };
+}
+
+export function pinnedRoute(requested: string, setup: ModelSetup): Route | null {
+  const primary = primaryRoute(setup);
+  if (primary === null) return null;
+  const bare = bareModel(requested);
+  const passes = primary.connection.provider === 'anthropic' && (primary.model === '' || isSmallModel(bare));
+  return passes ? { connection: primary.connection, model: bare } : primary;
+}
+
+export function helperSetup(setup: ModelSetup): ModelSetup | null {
+  const helpers = setup.helpers ?? null;
+  return helpers === null ? null : { ...setup, primary: helpers.primary, fallbacks: helpers.fallbacks, helpers: null };
+}
+
+export const routeLabel = (route: Route): string =>
+  route.connection.provider === 'anthropic' ? route.model : `${route.connection.provider}:${route.model}`;
+
+export function runnerModel(setup: ModelSetup): string | null {
+  const primary = primaryRoute(setup);
+  return primary === null || primary.model === '' ? null : routeLabel(primary);
+}

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

@@ -0,0 +1,63 @@
+import { lstatSync, readdirSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { errMsg, log } from '@metro-labs/core/log';
+import { agentsDir } from '../agents/files.js';
+import { existsSync } from '../agent-user/agent-fs.js';
+import { removeHome } from '../agent-user/home-fs.js';
+import { agentUser, agentUserExpected } from '../agent-user/user.js';
+
+const LEFTOVER_RE = /^(?:chatgpt-host|model)\.json(?:\.tmp-[0-9]+)?$/;
+
+const codeOf = (err: unknown): unknown => (err instanceof Error && 'code' in err ? err.code : undefined);
+
+function namesIn(dir: string): string[] {
+  try {
+    return readdirSync(dir).filter((name) => LEFTOVER_RE.test(name));
+  } catch (err) {
+    if (codeOf(err) !== 'ENOENT') log.warn({ err: errMsg(err), dir }, 'org-models: could not list the old model files');
+    return [];
+  }
+}
+
+function removeOne(path: string): boolean {
+  try {
+    if (!lstatSync(path).isFile()) {
+      log.warn({ path }, 'org-models: left an old model file alone, it is not a regular file');
+      return false;
+    }
+    unlinkSync(path);
+    return true;
+  } catch (err) {
+    if (codeOf(err) !== 'ENOENT') log.warn({ err: errMsg(err), path }, 'org-models: could not remove an old model file');
+    return false;
+  }
+}
+
+export function claudeLoginsDir(): string | null {
+  const user = agentUser();
+  if (user === null && agentUserExpected()) return null;
+  return join(user?.home ?? homedir(), '.metro', 'claude-logins');
+}
+
+function removeClaudeLogins(dir: string | null): number {
+  if (dir === null || !existsSync(dir)) return 0;
+  try {
+    removeHome(dir, true);
+    return 1;
+  } catch (err) {
+    log.warn({ err: errMsg(err), dir }, 'org-models: could not remove the folder of the old Claude logins');
+    return 0;
+  }
+}
+
+export function removeModelLeftovers(dir = agentsDir(), logins: string | null = claudeLoginsDir()): number {
+  try {
+    const removed = namesIn(dir).filter((name) => removeOne(join(dir, name))).length + removeClaudeLogins(logins);
+    log.info({ removed }, 'org-models: removed the files of the old model setup');
+    return removed;
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'org-models: could not remove the files of the old model setup');
+    return 0;
+  }
+}

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

@@ -0,0 +1,25 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { GatewayError } from './forward.js';
+import type { KeySpend } from './usage.js';
+
+export const OPENROUTER_BASE = 'https://openrouter.ai/api';
+const KEY_TIMEOUT_MS = 10_000;
+
+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 };
+}

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

@@ -0,0 +1,203 @@
+import { errMsg, log } from '@metro-labs/core/log';
+import type { AgentKey } from '../connectors/agent-key.js';
+import { agentCall, MetroApiRefusal, type MetroApi } from '../connectors/metro-api.js';
+import { deliveredOf, refreshedConnection, type Delivered } from './delivered.js';
+import type { Connection } from './model-config.js';
+
+const MODELS_PATH = '/api/agents/models';
+const REFRESH_PATH = '/api/agents/models/refresh';
+const SYNC_MS = 60_000;
+const PAGE_SYNC_MS = 5_000;
+const AGENT_KEY_MISSING = 'agent_key_missing';
+
+export interface OrgModelsDeps {
+  owner: () => string | null;
+  key: () => AgentKey | null;
+  api: MetroApi;
+  pageSyncMs?: number;
+}
+
+export interface SyncStatus {
+  enrolled: boolean;
+  at: string | null;
+  error: string | null;
+}
+
+const identityRefused = (err: unknown): boolean => err instanceof MetroApiRefusal && err.upstreamStatus === 401 && err.code === AGENT_KEY_MISSING;
+
+export class OrgModels {
+  private kept: Delivered | null = null;
+  private status: SyncStatus = { enrolled: false, at: null, error: null };
+  private running: Promise<void> | null = null;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private trailing: ReturnType<typeof setTimeout> | null = null;
+  private pageAt = Number.NEGATIVE_INFINITY;
+  private readonly refreshing = new Map<string, Promise<Connection | null>>();
+  private readonly listeners = new Set<() => void>();
+
+  constructor(private readonly deps: OrgModelsDeps) {}
+
+  current(): Delivered | null {
+    return this.kept;
+  }
+
+  syncStatus(): SyncStatus {
+    return { ...this.status };
+  }
+
+  onChange(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  sync(): Promise<void> {
+    this.running ??= this.run().finally(() => {
+      this.running = null;
+    });
+    return this.running;
+  }
+
+  requested(): Promise<void> {
+    const now = this.deps.api.now();
+    const wait = this.pageAt + (this.deps.pageSyncMs ?? PAGE_SYNC_MS) - now;
+    if (wait <= 0) {
+      this.pageAt = now;
+      return this.sync();
+    }
+    this.trailing ??= this.later(wait);
+    return this.running ?? Promise.resolve();
+  }
+
+  start(everyMs = SYNC_MS): void {
+    if (this.timer !== null) return;
+    const tick = (): void => {
+      this.sync().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'org-models: the model setup could not be read');
+      });
+    };
+    tick();
+    this.timer = setInterval(tick, everyMs);
+    this.timer.unref();
+  }
+
+  stop(): void {
+    if (this.timer !== null) clearInterval(this.timer);
+    if (this.trailing !== null) clearTimeout(this.trailing);
+    this.timer = null;
+    this.trailing = null;
+  }
+
+  refresh(conn: Connection): Promise<Connection | null> {
+    const newer = this.kept?.connections.find((c) => c.id === conn.id && c.revision > conn.revision);
+    if (newer !== undefined) return Promise.resolve(newer);
+    const slot = `${conn.id}\n${String(conn.revision)}`;
+    const found = this.refreshing.get(slot);
+    if (found !== undefined) return found;
+    const run = this.askRefresh(conn).finally(() => {
+      this.refreshing.delete(slot);
+    });
+    this.refreshing.set(slot, run);
+    return run;
+  }
+
+  private later(wait: number): ReturnType<typeof setTimeout> {
+    const timer = setTimeout(() => {
+      this.trailing = null;
+      this.requested().catch((err: unknown) => {
+        log.warn({ err: errMsg(err) }, 'org-models: the model setup could not be read');
+      });
+    }, wait);
+    timer.unref();
+    return timer;
+  }
+
+  private enrolledKey(): AgentKey | null {
+    try {
+      const key = this.deps.key();
+      const owner = this.deps.owner();
+      return key !== null && owner !== null && key.enrollment?.organization === owner ? key : null;
+    } catch (err) {
+      log.warn({ err: errMsg(err) }, 'org-models: the agent key could not be read');
+      return null;
+    }
+  }
+
+  private keep(next: Delivered | null): void {
+    const changed = JSON.stringify(next) !== JSON.stringify(this.kept);
+    this.kept = next;
+    if (changed) this.notify();
+  }
+
+  private notify(): void {
+    for (const listener of [...this.listeners])
+      try {
+        listener();
+      } catch (err) {
+        log.warn({ err: errMsg(err) }, 'org-models: a model change listener failed');
+      }
+  }
+
+  private failed(error: string, clear: boolean): void {
+    if (this.status.error !== error) log.warn({ err: error, kept: !clear && this.kept !== null }, clear ? 'org-models: api.metro.box no longer knows this agent key, so the model setup is cleared' : 'org-models: api.metro.box did not deliver the model setup, so the last one stands');
+    this.status = { ...this.status, error };
+    if (clear) this.keep(null);
+  }
+
+  private async run(): Promise<void> {
+    const key = this.enrolledKey();
+    if (key === null) {
+      this.status = { enrolled: false, at: null, error: null };
+      this.keep(null);
+      return;
+    }
+    this.status = { ...this.status, enrolled: true };
+    try {
+      const delivered = deliveredOf(await agentCall(this.deps.api, key, MODELS_PATH, {}));
+      if (delivered === null) {
+        this.failed('api.metro.box sent a model setup Metro cannot read', false);
+        return;
+      }
+      if (this.status.error !== null) log.info('org-models: the model setup is read from api.metro.box again');
+      this.status = { enrolled: true, at: new Date(this.deps.api.now()).toISOString(), error: null };
+      this.keep(delivered);
+    } catch (err) {
+      this.failed(errMsg(err), identityRefused(err));
+    }
+  }
+
+  private async askRefresh(conn: Connection): Promise<Connection | null> {
+    const key = this.enrolledKey();
+    if (key === null) return null;
+    try {
+      const fresh = refreshedConnection(await agentCall(this.deps.api, key, REFRESH_PATH, { connection: conn.id, revision: conn.revision }));
+      if (fresh?.id !== conn.id) throw new Error('api.metro.box answered the refresh with another connection');
+      const kept = this.kept;
+      if (kept !== null) this.keep({ ...kept, connections: kept.connections.map((c) => (c.id === fresh.id ? fresh : c)) });
+      log.info({ connection: conn.id, revision: fresh.revision }, 'org-models: api.metro.box renewed the sign-in of a connection');
+      return fresh;
+    } catch (err) {
+      log.warn({ connection: conn.id, err: errMsg(err) }, 'org-models: api.metro.box could not renew the sign-in of a connection');
+      return null;
+    }
+  }
+}
+
+let shared: OrgModels | null = null;
+
+export const orgModels = (): OrgModels | null => shared;
+
+export const deliveredSetup = (): Delivered | null => shared?.current() ?? null;
+
+export function startOrgModels(deps: OrgModelsDeps, everyMs = SYNC_MS): OrgModels {
+  shared?.stop();
+  shared = new OrgModels(deps);
+  shared.start(everyMs);
+  log.info('org-models: the model setup comes from the organization on api.metro.box once the agent is enrolled');
+  return shared;
+}
+
+export function stopOrgModels(): void {
+  shared?.stop();
+}

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

@@ -0,0 +1,88 @@
+import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { log } from '@metro-labs/core/log';
+import { withoutCacheTtl, withoutTtlBeta } from './cache-ttl.js';
+import { anthropicHeaders, GatewayError, type Watch } from './forward.js';
+
+export const ROUTEWAY_BASE = 'https://api.routeway.ai';
+const USER_AGENT = 'metro (+https://metro.box)';
+const HANDED_OVER = new Set([402, 429]);
+
+export function routewayHeaders(req: IncomingMessage, apiKey: string): Record<string, string> {
+  const headers = anthropicHeaders(req, apiKey);
+  headers['user-agent'] ??= USER_AGENT;
+  const betas = withoutTtlBeta((headers['anthropic-beta'] ?? '').split(',').filter((beta) => beta !== ''));
+  if (betas.length > 0) headers['anthropic-beta'] = betas.join(',');
+  else delete headers['anthropic-beta'];
+  return headers;
+}
+
+export async function refusedWithPage(upstream: Response, watch: Watch): Promise<void> {
+  if (upstream.ok || HANDED_OVER.has(upstream.status) || !(upstream.headers.get('content-type') ?? '').includes('text/html')) return;
+  await upstream.body?.cancel();
+  watch.stop();
+  throw new GatewayError(502, 'api_error', `metro gateway: Routeway answered with a web page instead of its API (${String(upstream.status)}); try again in a moment`);
+}
+
+const SCHEMA_MAPS = ['properties', 'patternProperties', '$defs', 'definitions'];
+const SCHEMA_LISTS = ['anyOf', 'oneOf', 'allOf', 'prefixItems'];
+const SCHEMA_ONES = ['items', 'additionalProperties', 'not', 'contains'];
+
+function fitMap(raw: Record<string, unknown>): Record<string, unknown> {
+  const entries = Object.entries(raw).map(([key, value]) => [key, fitSchema(value)] as const);
+  return entries.some(([key, value]) => value !== raw[key]) ? Object.fromEntries(entries) : raw;
+}
+
+function fitList(raw: unknown[]): unknown[] {
+  const fitted = raw.map(fitSchema);
+  return fitted.some((value, at) => value !== raw[at]) ? fitted : raw;
+}
+
+function fitChild(key: string, value: unknown): unknown {
+  if (SCHEMA_MAPS.includes(key)) return isRecord(value) ? fitMap(value) : value;
+  if (SCHEMA_LISTS.includes(key)) return Array.isArray(value) ? fitList(value) : value;
+  return SCHEMA_ONES.includes(key) ? fitSchema(value) : value;
+}
+
+function singleTypes(schema: Record<string, unknown>): Record<string, unknown> {
+  const types: unknown = schema.type;
+  if (!Array.isArray(types) || !types.every((type) => typeof type === 'string')) return schema;
+  const rest = Object.fromEntries(Object.entries(schema).filter(([key]) => key !== 'type'));
+  if (types.length === 1) return { ...rest, type: types[0] };
+  const choices = types.map((type) => ({ type }));
+  if (!Object.hasOwn(rest, 'anyOf')) return { ...rest, anyOf: choices };
+  const { anyOf, ...others } = rest;
+  return { ...others, allOf: [{ anyOf: choices }, { anyOf }] };
+}
+
+function fitSchema(raw: unknown): unknown {
+  if (!isRecord(raw)) return raw;
+  const entries = Object.entries(raw).map(([key, value]) => [key, fitChild(key, value)] as const);
+  const children = entries.some(([key, value]) => value !== raw[key]) ? Object.fromEntries(entries) : raw;
+  return singleTypes(children);
+}
+
+function withProperties(tool: unknown): unknown {
+  if (!isRecord(tool) || !isRecord(tool.input_schema)) return tool;
+  const schema = fitSchema(tool.input_schema);
+  const full = isRecord(schema) && !Object.hasOwn(schema, 'properties') ? { ...schema, properties: {} } : schema;
+  return full === tool.input_schema ? tool : { ...tool, input_schema: full };
+}
+
+function routewayTools(body: Record<string, unknown>): Record<string, unknown> {
+  const listed: unknown = body.tools;
+  if (!Array.isArray(listed)) return body;
+  const tools: unknown[] = listed.map(withProperties);
+  return tools.some((tool, at) => tool !== listed[at]) ? { ...body, tools } : body;
+}
+
+export const routewayBody = (body: Record<string, unknown>): Record<string, unknown> => withoutCacheTtl(routewayTools(body));
+
+export async function noteRoutewayRefusal(upstream: Response): Promise<void> {
+  if (upstream.ok || !(upstream.headers.get('content-type') ?? '').includes('application/json')) return;
+  const body: unknown = await upstream.clone().json().catch(() => null);
+  const error = isRecord(body) && isRecord(body.error) ? body.error : null;
+  if (error === null) return;
+  const text = (value: unknown): string | null => (typeof value === 'string' ? value.slice(0, 300) : null);
+  log.warn({ status: upstream.status, reason: text(error.message), param: text(error.param) }, 'gateway: Routeway refused the request');
+}

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,60 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+import { assembleMessage, SseParser, type SseEvent } from './frames.js';
+import { 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 };
+
+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,33 @@
+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 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) ?? []);