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

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/files}/upload-api.ts

@@ -1,17 +1,16 @@
 import { open, rename, rm, type FileHandle } from 'node:fs/promises';
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { guessMime } from '../stations/attachments.js';
+import { guessMime } from '@metro-labs/core/stations/attachments';
 import { safeFileName } from '../stations/attach-inline.js';
 import {
   allowedAgents,
-  authConfigFromEnv,
   authenticate,
   extractToken,
 } from '../mcp/request-identity.js';
-import { ApiError } from './api-error.js';
-import { apiFailure, cors, sendJson } from './api-http.js';
-import { log } from './log.js';
-import { writeSecure } from './secure-fs.js';
+import { ApiError } from '@metro-labs/http/api-error';
+import { apiFailure, cors, sendJson } from '@metro-labs/http/api-http';
+import { log } from '@metro-labs/core/log';
+import { writeSecure } from '@metro-labs/core/secure-fs';
 import {
   createUploadSlot,
   liveUploadBytes,
@@ -38,7 +37,7 @@ const VAGUE_MIMES = new Set([
 
 const mib = (n: number): string => `${Math.round(n / (1024 * 1024))} MiB`;
 
-export const uploadLimit = (): string =>
+const uploadLimit = (): string =>
   `${mib(MAX_UPLOAD_BYTES)} (${MAX_UPLOAD_BYTES} bytes)`;
 
 const tooLarge = (): string =>
@@ -69,23 +68,7 @@ const query = (req: IncomingMessage, key: string): string | undefined =>
   new URL(req.url ?? '/', 'http://localhost').searchParams.get(key) ?? undefined;
 
 const identityScope = (req: IncomingMessage): Set<string> =>
-  allowedAgents(authenticate(req, authConfigFromEnv()) ?? undefined);
-
-function ownerFromScope(req: IncomingMessage, allowed: Set<string>): string {
-  const requested = query(req, 'agent');
-  if (requested !== undefined) {
-    if (!allowed.has(requested))
-      throw new ApiError(`agent ${requested} is outside your scope`, 403);
-    return requested;
-  }
-  const [only] = [...allowed];
-  if (allowed.size === 1 && only !== undefined) return only;
-  throw new ApiError(
-    `this credential covers ${allowed.size} agents; ` +
-      'name the owning agent with ?agent=<id>',
-    400,
-  );
-}
+  allowedAgents(authenticate(req) ?? undefined);
 
 function mimeFor(req: IncomingMessage, name: string): string {
   const explicit = query(req, 'mime');
@@ -186,10 +169,10 @@ async function handleCreate(
   req: IncomingMessage,
   res: ServerResponse,
 ): Promise<void> {
-  const allowed = identityScope(req);
-  if (allowed.size === 0) throw new ApiError('unauthorized', 401);
+  const [owner] = identityScope(req);
+  if (owner === undefined) throw new ApiError('unauthorized', 401);
   const name = safeFileName(query(req, 'name'));
-  const id = createUploadSlot(ownerFromScope(req, allowed), {
+  const id = createUploadSlot(owner, {
     name,
     mime: mimeFor(req, name),
   });

package/runtime/node_modules/@metro-labs/{mcp/src/daemon → daemon/src/files}/upload-store.ts

@@ -1,11 +1,11 @@
 import { randomBytes } from 'node:crypto';
 import { readdirSync, rmSync, statSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { ensureSecureDir, readJson, writeSecure } from './secure-fs.js';
+import { ensureSecureDir, readJson, writeSecure } from '@metro-labs/core/secure-fs';
 import { grantAllowsPath, issueGrant } from './attach-grant.js';
 import { ownerOf, recordOwner } from './attach-owner.js';
-import { errMsg, log } from './log.js';
+import { errMsg, log } from '@metro-labs/core/log';
 
 export const UPLOAD_TTL_MS = 30 * 60 * 1000;
 export const MAX_UPLOAD_BYTES = 64 * 1024 * 1024;
@@ -16,7 +16,7 @@ const SUFFIXES = ['', '.part', '.meta', '.owner', '.grant'] as const;
 const SWEEP_MS = 60_000;
 
 export const uploadDir = (): string =>
-  process.env.METRO_UPLOAD_DIR ?? join(tmpdir(), 'metro-uploads');
+  process.env.METRO_UPLOAD_DIR ?? join(homedir(), '.metro', 'uploads');
 
 export const newUploadId = (): string =>
   `up_${randomBytes(16).toString('base64url')}`;

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

@@ -0,0 +1,253 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { log } from '@metro-labs/core/log';
+import { withoutCacheTtl, withoutTtlBeta } from './cache-ttl.js';
+import { EventStreamDecoder, type EventStreamMessage } from './eventstream.js';
+import { noteFailure, type FailureSite } from './failures.js';
+import { errorFrame, providerStatus, relayFrames, sendError, upstreamMessage, type Watch } from './forward.js';
+import type { Connection } from './model-config.js';
+import { estimateTokens } from './subscription.js';
+import { UsageScanner } from './usage.js';
+
+const ANTHROPIC_VERSION = 'bedrock-2023-05-31';
+const EXTRA_INPUT_RE = /^([A-Za-z0-9_.]+): Extra inputs are not permitted/;
+const CACHE_TTL_PATH = '.cache_control.ttl';
+const MAX_REPAIRS = 4;
+
+export interface Adaptations {
+  fields: Set<string>;
+  dropBetas: boolean;
+  dropCacheTtl: boolean;
+}
+
+export const freshAdaptations = (): Adaptations => ({ fields: new Set(), dropBetas: false, dropCacheTtl: false });
+
+export function forgetAdaptations(learned: Adaptations): void {
+  learned.fields.clear();
+  learned.dropBetas = false;
+  learned.dropCacheTtl = false;
+}
+
+export interface BedrockUpstream {
+  settings: Connection;
+  base: string;
+  learned: Adaptations;
+  watch: Watch;
+}
+
+interface Rewritten {
+  modelId: string;
+  stream: boolean;
+  body: Record<string, unknown>;
+  betas: string[];
+}
+
+interface Attempt {
+  body: Record<string, unknown>;
+  betas: string[];
+}
+
+const PREFIXES: [RegExp, string][] = [
+  [/^us-gov-/, 'us-gov'],
+  [/^us-/, 'us'],
+  [/^eu-/, 'eu'],
+  [/^ap-/, 'apac'],
+];
+
+function regionPrefix(region: string): string {
+  for (const [pattern, prefix] of PREFIXES) if (pattern.test(region)) return prefix;
+  return 'global';
+}
+
+function bedrockModelId(requested: string, region: string): string {
+  if (requested.includes('anthropic.')) return requested;
+  return `${regionPrefix(region)}.anthropic.${requested}`;
+}
+
+export const bedrockBase = (region: string): string => `https://bedrock-runtime.${region}.amazonaws.com`;
+
+function splitBetas(header: string | string[] | undefined): string[] {
+  const raw = Array.isArray(header) ? header.join(',') : (header ?? '');
+  return raw
+    .split(',')
+    .map((b) => b.trim())
+    .filter((b) => b !== '');
+}
+
+function rewriteForBedrock(
+  body: Record<string, unknown>,
+  model: string,
+  betaHeader: string | string[] | undefined,
+  region: string,
+): Rewritten {
+  const betas = splitBetas(betaHeader);
+  const out: Record<string, unknown> = {
+    ...Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'model' && key !== 'stream')),
+    anthropic_version: ANTHROPIC_VERSION,
+  };
+  if (betas.length > 0) out.anthropic_beta = betas;
+  return { modelId: bedrockModelId(model, region), stream: body.stream === true, body: out, betas };
+}
+
+function errorKind(status: number, errorType: string | null): string {
+  if (status === 429 || errorType === 'ThrottlingException') return 'rate_limit_error';
+  if (status === 400) return 'invalid_request_error';
+  if (status === 401 || status === 403) return 'permission_error';
+  if (status === 404) return 'not_found_error';
+  if (status === 503) return 'overloaded_error';
+  return 'api_error';
+}
+
+const invokeUrl = (up: BedrockUpstream, modelId: string, action: string): string =>
+  `${up.base}/model/${encodeURIComponent(modelId)}/${action}`;
+
+function callBedrock(up: BedrockUpstream, url: string, body: unknown, accept: string): Promise<Response> {
+  return fetch(url, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${up.settings.apiKey}`,
+      'content-type': 'application/json',
+      accept,
+    },
+    body: JSON.stringify(body),
+    signal: up.watch.signal,
+  });
+}
+
+const without = (body: Record<string, unknown>, keys: Set<string>): Record<string, unknown> =>
+  Object.fromEntries(Object.entries(body).filter(([key]) => !keys.has(key)));
+
+function withBetas(body: Record<string, unknown>, betas: string[]): Attempt {
+  const rest = without(body, new Set(['anthropic_beta']));
+  return { body: betas.length > 0 ? { ...rest, anthropic_beta: betas } : rest, betas };
+}
+
+const withoutTtl = (attempt: Attempt): Attempt => withBetas(withoutCacheTtl(attempt.body), withoutTtlBeta(attempt.betas));
+
+function applyLearned(req: Rewritten, learned: Adaptations): Attempt {
+  const dropped = new Set(learned.fields);
+  if (learned.dropBetas) dropped.add('anthropic_beta');
+  const attempt = { body: without(req.body, dropped), betas: learned.dropBetas ? [] : req.betas };
+  return learned.dropCacheTtl ? withoutTtl(attempt) : attempt;
+}
+
+function repair(attempt: Attempt, learned: Adaptations, message: string): Attempt | null {
+  const named = EXTRA_INPUT_RE.exec(message)?.[1];
+  if (named !== undefined && named.endsWith(CACHE_TTL_PATH) && !learned.dropCacheTtl) {
+    learned.dropCacheTtl = true;
+    log.warn('gateway: Bedrock refused the one-hour cache; using the five-minute cache from now on');
+    return withoutTtl(attempt);
+  }
+  if (named !== undefined && !named.includes('.') && named in attempt.body) {
+    learned.fields.add(named);
+    log.warn({ field: named }, 'gateway: Bedrock refused an extra input; dropping it from every request');
+    return { body: without(attempt.body, new Set([named])), betas: attempt.betas };
+  }
+  if (attempt.betas.length > 0) {
+    learned.dropBetas = true;
+    log.warn({ betas: attempt.betas }, 'gateway: retrying without anthropic_beta');
+    return { body: without(attempt.body, new Set(['anthropic_beta'])), betas: [] };
+  }
+  return null;
+}
+
+async function withRepairs(up: BedrockUpstream, req: Rewritten, send: (attempt: Attempt) => Promise<Response>): Promise<Response> {
+  let attempt = applyLearned(req, up.learned);
+  for (let repairs = 0; ; repairs += 1) {
+    const res = await send(attempt);
+    if (res.status !== 400 || repairs >= MAX_REPAIRS) return res;
+    const text = await res.text();
+    const next = repair(attempt, up.learned, upstreamMessage(text, 'Bedrock returned no body'));
+    if (next === null) return new Response(text, { status: 400, headers: res.headers });
+    attempt = next;
+  }
+}
+
+function invoke(up: BedrockUpstream, req: Rewritten): Promise<Response> {
+  const action = req.stream ? 'invoke-with-response-stream' : 'invoke';
+  const accept = req.stream ? 'application/vnd.amazon.eventstream' : 'application/json';
+  const url = invokeUrl(up, req.modelId, action);
+  return withRepairs(up, req, (attempt) => callBedrock(up, url, attempt.body, accept));
+}
+
+function eventTypeOf(event: string): string {
+  try {
+    const parsed = JSON.parse(event) as { type?: unknown };
+    return typeof parsed.type === 'string' ? parsed.type : 'message';
+  } catch {
+    return 'message';
+  }
+}
+
+function eventFrame(message: EventStreamMessage, site: FailureSite): string {
+  if (message.headers[':message-type'] === 'event') {
+    const parsed = JSON.parse(message.payload.toString('utf8')) as { bytes?: unknown };
+    if (typeof parsed.bytes !== 'string') return '';
+    const event = Buffer.from(parsed.bytes, 'base64').toString('utf8');
+    return `event: ${eventTypeOf(event)}\ndata: ${event}\n\n`;
+  }
+  const errorType = message.headers[':exception-type'] ?? message.headers[':error-code'] ?? null;
+  const text = upstreamMessage(message.payload.toString('utf8'), 'Bedrock stream error');
+  noteFailure(site, { code: errorType ?? '', message: text }, 'gateway: the provider sent an error in the middle of its stream');
+  return errorFrame(errorKind(500, errorType), text);
+}
+
+function relayStream(upstream: Response, res: ServerResponse, watch: Watch, key: string, site: FailureSite): Promise<void> {
+  const decoder = new EventStreamDecoder();
+  return relayFrames(upstream, res, watch, key, {
+    push: (chunk, emit) => {
+      for (const message of decoder.push(Buffer.from(chunk))) emit(eventFrame(message, site));
+    },
+    close: () => '',
+    idle: (message) => errorFrame('api_error', message),
+  });
+}
+
+async function relayFailure(upstream: Response, res: ServerResponse): Promise<void> {
+  const text = await upstream.text();
+  sendError(res, providerStatus(upstream.status), errorKind(upstream.status, upstream.headers.get('x-amzn-errortype')), upstreamMessage(text, 'Bedrock returned no body'));
+}
+
+export async function bedrockMessages(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  up: BedrockUpstream,
+): Promise<void> {
+  const rewritten = rewriteForBedrock(body, model, req.headers['anthropic-beta'], up.settings.region);
+  const upstream = await invoke(up, rewritten);
+  if (!upstream.ok) {
+    await relayFailure(upstream, res);
+    return;
+  }
+  if (rewritten.stream) {
+    await relayStream(upstream, res, up.watch, up.settings.id, { connection: up.settings.label, model });
+    return;
+  }
+  const text = await upstream.text();
+  const scanner = new UsageScanner(up.settings.id);
+  scanner.feed(text);
+  scanner.done();
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(text);
+}
+
+export async function bedrockCount(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  up: BedrockUpstream,
+): Promise<void> {
+  const rewritten = rewriteForBedrock(body, model, req.headers['anthropic-beta'], up.settings.region);
+  const url = invokeUrl(up, rewritten.modelId, 'count-tokens');
+  const upstream = await withRepairs(up, rewritten, (attempt) => callBedrock(up, url, { input: { invokeModel: { body: JSON.stringify(attempt.body) } } }, 'application/json'));
+  const text = await upstream.text();
+  let counted: number | null = null;
+  if (upstream.ok) {
+    const parsed = JSON.parse(text) as { inputTokens?: unknown };
+    if (typeof parsed.inputTokens === 'number') counted = parsed.inputTokens;
+  }
+  res.writeHead(200, { 'content-type': 'application/json' });
+  res.end(JSON.stringify({ input_tokens: counted ?? estimateTokens(rewritten.body) }));
+}

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

@@ -0,0 +1,43 @@
+import { isRecord } from '@metro-labs/core/is-record';
+
+const TTL_BETA = 'extended-cache-ttl-';
+
+export const withoutTtlBeta = (betas: string[]): string[] => betas.filter((beta) => !beta.startsWith(TTL_BETA));
+
+function plainControl(block: unknown): unknown {
+  if (!isRecord(block) || !isRecord(block.cache_control) || !Object.hasOwn(block.cache_control, 'ttl')) return block;
+  const control = Object.fromEntries(Object.entries(block.cache_control).filter(([key]) => key !== 'ttl'));
+  return { ...block, cache_control: control };
+}
+
+function plainList(value: unknown): unknown {
+  if (!Array.isArray(value)) return value;
+  const out: unknown[] = value.map(plainControl);
+  return out.some((block, at) => block !== value[at]) ? out : value;
+}
+
+function plainMessage(message: unknown): unknown {
+  if (!isRecord(message)) return message;
+  const content = plainList(message.content);
+  return content === message.content ? message : { ...message, content };
+}
+
+export function withoutCacheTtl(body: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = { ...body };
+  let changed = false;
+  for (const key of ['tools', 'system']) {
+    const plain = plainList(body[key]);
+    if (plain === body[key]) continue;
+    out[key] = plain;
+    changed = true;
+  }
+  if (Array.isArray(body.messages)) {
+    const listed: unknown[] = body.messages;
+    const messages = listed.map(plainMessage);
+    if (messages.some((message, at) => message !== listed[at])) {
+      out.messages = messages;
+      changed = true;
+    }
+  }
+  return changed ? out : body;
+}

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

@@ -0,0 +1,186 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { encodeSignature } from './codex-translate.js';
+import { errorFrame } from './forward.js';
+import type { Failure } from './failures.js';
+import { frame, messageEnd, messageStart, type Usage } from './frames.js';
+import { stringOf } from '@metro-labs/http/api-http';
+
+type Item = Record<string, unknown>;
+
+interface Block {
+  index: number;
+  kind: 'text' | 'thinking' | 'tool_use';
+  deltas: number;
+}
+
+const responseOf = (data: Item): Item => (isRecord(data.response) ? data.response : {});
+const reasonOf = (response: Item): string => (isRecord(response.incomplete_details) ? stringOf(response.incomplete_details.reason) : '');
+const itemOf = (data: Item): Item => (isRecord(data.item) ? data.item : {});
+
+const PLAN_LIMIT = 'subscription_sharing_usage_limit_exceeded';
+const USAGE_URL = 'https://chatgpt.com/settings/usage';
+
+export const withUsageLink = (code: string, message: string): string => (code === PLAN_LIMIT ? `${message} Manage usage: ${USAGE_URL}` : message);
+
+function errorKind(code: string): string {
+  if (code === 'rate_limit_exceeded' || code === 'usage_limit_reached' || code === PLAN_LIMIT) return 'rate_limit_error';
+  if (code === 'context_length_exceeded' || code === 'invalid_prompt') return 'invalid_request_error';
+  if (code === 'insufficient_quota') return 'permission_error';
+  return 'api_error';
+}
+
+function usageOf(response: Item): Usage {
+  const usage = isRecord(response.usage) ? response.usage : {};
+  const details = isRecord(usage.input_tokens_details) ? usage.input_tokens_details : {};
+  const cached = typeof details.cached_tokens === 'number' ? details.cached_tokens : 0;
+  const input = typeof usage.input_tokens === 'number' ? usage.input_tokens : 0;
+  return {
+    input_tokens: Math.max(0, input - cached),
+    output_tokens: typeof usage.output_tokens === 'number' ? usage.output_tokens : 0,
+    cache_read_input_tokens: cached,
+  };
+}
+
+const startBlock = (kind: Block['kind'], id: string, name: string): Item =>
+  kind === 'text' ? { type: 'text', text: '' } : kind === 'thinking' ? { type: 'thinking', thinking: '' } : { type: 'tool_use', id, name, input: {} };
+
+const messageText = (item: Item): string =>
+  Array.isArray(item.content) ? item.content.filter(isRecord).map((part) => stringOf(part.text)).join('') : '';
+
+export class CodexEventTranslator {
+  private readonly blocks = new Map<string, Block>();
+  private next = 0;
+  private started = false;
+  private toolCalls = 0;
+  private done = false;
+  private readonly model: string;
+  private readonly restore: (name: string) => string;
+  private readonly report: (failure: Failure) => void;
+  private readonly handlers: Record<string, (data: Item) => string> = {
+    'response.created': (d) => this.start(responseOf(d)),
+    'response.output_item.added': (d) => this.start({}) + this.itemAdded(itemOf(d)),
+    'response.output_text.delta': (d) => this.delta(stringOf(d.item_id), 'text', stringOf(d.delta)),
+    'response.reasoning_summary_text.delta': (d) => this.delta(stringOf(d.item_id), 'thinking', stringOf(d.delta)),
+    'response.reasoning_summary_part.added': (d) => this.partAdded(stringOf(d.item_id)),
+    'response.function_call_arguments.delta': (d) => this.delta(stringOf(d.item_id), 'tool_use', stringOf(d.delta)),
+    'response.output_item.done': (d) => this.itemDone(itemOf(d)),
+    'response.completed': (d) => this.start(responseOf(d)) + this.completed(responseOf(d)),
+    'response.failed': (d) => this.failed(responseOf(d), 'Codex failed the response'),
+    'response.incomplete': (d) => this.incomplete(responseOf(d)),
+    error: (d) => this.failed({ error: d }, 'Codex stream error'),
+  };
+
+  constructor(model: string, restore: (name: string) => string = (name) => name, report: (failure: Failure) => void = () => undefined) {
+    this.model = model;
+    this.restore = restore;
+    this.report = report;
+  }
+
+  get finished(): boolean {
+    return this.done;
+  }
+
+  private open(key: string, kind: Block['kind'], id = '', name = ''): string {
+    const block: Block = { index: this.next, kind, deltas: 0 };
+    this.next += 1;
+    this.blocks.set(key, block);
+    return frame('content_block_start', { type: 'content_block_start', index: block.index, content_block: startBlock(kind, id, name) });
+  }
+
+  private start(response: Item): string {
+    if (this.started) return '';
+    this.started = true;
+    return messageStart(stringOf(response.id) || 'msg_codex', this.model);
+  }
+
+  private openCall(key: string, item: Item): string {
+    this.toolCalls += 1;
+    return this.open(key, 'tool_use', stringOf(item.call_id) || key, this.restore(stringOf(item.name)));
+  }
+
+  private itemAdded(item: Item): string {
+    const key = stringOf(item.id) || String(this.next);
+    if (item.type === 'function_call') return this.openCall(key, item);
+    if (item.type === 'reasoning') return this.open(key, 'thinking');
+    return '';
+  }
+
+  private partAdded(key: string): string {
+    const block = this.blocks.get(key);
+    return block !== undefined && block.deltas > 0 ? this.delta(key, 'thinking', '\n\n') : '';
+  }
+
+  private delta(key: string, kind: Block['kind'], text: string): string {
+    const opened = this.blocks.has(key) ? '' : this.open(key, kind);
+    const block = this.blocks.get(key);
+    if (block === undefined) return opened;
+    block.deltas += 1;
+    const delta =
+      kind === 'tool_use' ? { type: 'input_json_delta', partial_json: text } : kind === 'text' ? { type: 'text_delta', text } : { type: 'thinking_delta', thinking: text };
+    return opened + frame('content_block_delta', { type: 'content_block_delta', index: block.index, delta });
+  }
+
+  private stop(key: string): string {
+    const block = this.blocks.get(key);
+    if (block === undefined) return '';
+    this.blocks.delete(key);
+    return frame('content_block_stop', { type: 'content_block_stop', index: block.index });
+  }
+
+  private reasoningDone(key: string, item: Item): string {
+    const opened = this.blocks.has(key) ? '' : this.open(key, 'thinking');
+    const block = this.blocks.get(key);
+    if (block === undefined || typeof item.encrypted_content !== 'string') return opened + this.stop(key);
+    const signature = encodeSignature({ id: key, encrypted_content: item.encrypted_content });
+    return opened + frame('content_block_delta', { type: 'content_block_delta', index: block.index, delta: { type: 'signature_delta', signature } }) + this.stop(key);
+  }
+
+  private callDone(key: string, item: Item): string {
+    let out = this.blocks.has(key) ? '' : this.openCall(key, item);
+    if (this.blocks.get(key)?.deltas === 0 && stringOf(item.arguments) !== '') out += this.delta(key, 'tool_use', stringOf(item.arguments));
+    return out + this.stop(key);
+  }
+
+  private itemDone(item: Item): string {
+    const key = stringOf(item.id);
+    if (item.type === 'reasoning') return this.reasoningDone(key, item);
+    if (item.type === 'function_call') return this.callDone(key, item);
+    if (item.type === 'message' && !this.blocks.has(key) && messageText(item) !== '') return this.delta(key, 'text', messageText(item)) + this.stop(key);
+    return this.stop(key);
+  }
+
+  private completed(response: Item, forced: string | null = null): string {
+    this.done = true;
+    let out = '';
+    for (const key of [...this.blocks.keys()]) out += this.stop(key);
+    const stop = forced ?? (this.toolCalls > 0 ? 'tool_use' : 'end_turn');
+    return out + messageEnd(stop, usageOf(response));
+  }
+
+  private incomplete(response: Item): string {
+    const reason = reasonOf(response);
+    if (reason === 'max_output_tokens') return this.start(response) + this.completed(response, 'max_tokens');
+    return this.failed(response, `Codex left the response incomplete (${reason || 'no reason given'})`);
+  }
+
+  private failed(response: Item, fallback: string): string {
+    this.done = true;
+    const error = isRecord(response.error) ? response.error : {};
+    const code = stringOf(error.code);
+    const message = stringOf(error.message) || fallback;
+    this.report({ code: code || reasonOf(response), message });
+    return errorFrame(errorKind(code), withUsageLink(code, message));
+  }
+
+  push(event: string, data: Item): string {
+    const handler = this.handlers[event];
+    return handler === undefined ? '' : handler(data);
+  }
+
+  close(message = 'Codex ended the stream before completing the response'): string {
+    if (this.done) return '';
+    this.done = true;
+    this.report({ code: '', message });
+    return errorFrame('api_error', message);
+  }
+}