@stage-labs/metro 0.1.0-beta.13 → 0.1.0-beta.131

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

@@ -0,0 +1,288 @@
+import { isRecord } from '@metro-labs/core/is-record';
+import { encodeSignature } from './codex-translate.js';
+
+type Item = Record<string, unknown>;
+
+interface Block {
+  index: number;
+  kind: 'text' | 'thinking' | 'tool_use';
+  deltas: number;
+}
+
+interface Usage {
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_input_tokens: number;
+}
+
+const frame = (event: string, data: unknown): string => `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+const str = (value: unknown): string => (typeof value === 'string' ? value : '');
+const responseOf = (data: Item): Item => (isRecord(data.response) ? data.response : {});
+const itemOf = (data: Item): Item => (isRecord(data.item) ? data.item : {});
+
+function errorKind(code: string): string {
+  if (code === 'rate_limit_exceeded' || code === 'usage_limit_reached') 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) => str(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 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(str(d.item_id), 'text', str(d.delta)),
+    'response.reasoning_summary_text.delta': (d) => this.delta(str(d.item_id), 'thinking', str(d.delta)),
+    'response.reasoning_summary_part.added': (d) => this.partAdded(str(d.item_id)),
+    'response.function_call_arguments.delta': (d) => this.delta(str(d.item_id), 'tool_use', str(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) {
+    this.model = model;
+    this.restore = restore;
+  }
+
+  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 frame('message_start', {
+      type: 'message_start',
+      message: {
+        id: str(response.id) || 'msg_codex',
+        type: 'message',
+        role: 'assistant',
+        model: this.model,
+        content: [],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 0, output_tokens: 0 },
+      },
+    });
+  }
+
+  private openCall(key: string, item: Item): string {
+    this.toolCalls += 1;
+    return this.open(key, 'tool_use', str(item.call_id) || key, this.restore(str(item.name)));
+  }
+
+  private itemAdded(item: Item): string {
+    const key = str(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 && str(item.arguments) !== '') out += this.delta(key, 'tool_use', str(item.arguments));
+    return out + this.stop(key);
+  }
+
+  private itemDone(item: Item): string {
+    const key = str(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');
+    out += frame('message_delta', { type: 'message_delta', delta: { stop_reason: stop, stop_sequence: null }, usage: usageOf(response) });
+    return out + frame('message_stop', { type: 'message_stop' });
+  }
+
+  private incomplete(response: Item): string {
+    const details = isRecord(response.incomplete_details) ? response.incomplete_details : {};
+    if (details.reason === 'max_output_tokens') return this.start(response) + this.completed(response, 'max_tokens');
+    return this.failed(response, `Codex left the response incomplete (${str(details.reason) || 'no reason given'})`);
+  }
+
+  private failed(response: Item, fallback: string): string {
+    this.done = true;
+    const error = isRecord(response.error) ? response.error : {};
+    return frame('error', { type: 'error', error: { type: errorKind(str(error.code)), message: str(error.message) || fallback } });
+  }
+
+  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;
+    return frame('error', { type: 'error', error: { type: 'api_error', message } });
+  }
+}
+
+export interface SseEvent {
+  event: string;
+  data: string;
+}
+
+export class SseParser {
+  private pending = '';
+
+  push(chunk: string): SseEvent[] {
+    this.pending += chunk;
+    const out: SseEvent[] = [];
+    for (;;) {
+      const at = this.pending.indexOf('\n\n');
+      if (at < 0) break;
+      const raw = this.pending.slice(0, at);
+      this.pending = this.pending.slice(at + 2);
+      let event = '';
+      const data: string[] = [];
+      for (const line of raw.split('\n')) {
+        if (line.startsWith('event:')) event = line.slice(6).trim();
+        else if (line.startsWith('data:')) data.push(line.slice(5).trimStart());
+      }
+      if (data.length > 0) out.push({ event, data: data.join('\n') });
+    }
+    return out;
+  }
+}
+
+export function parseEvent(raw: SseEvent): { event: string; data: Item } | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw.data);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed)) return null;
+  const event = raw.event !== '' ? raw.event : str(parsed.type);
+  return event === '' ? null : { event, data: parsed };
+}
+
+interface Assembled {
+  message: Item;
+  blocks: Item[];
+}
+
+const FOLDS: Record<string, (state: Assembled, data: Item) => void> = {
+  message_start: (state, data) => {
+    if (isRecord(data.message)) state.message = { ...data.message };
+  },
+  content_block_start: (state, data) => {
+    if (isRecord(data.content_block)) state.blocks.push({ ...data.content_block });
+  },
+  content_block_delta: (state, data) => {
+    if (isRecord(data.delta)) applyDelta(state.blocks[typeof data.index === 'number' ? data.index : -1], data.delta);
+  },
+  message_delta: (state, data) => {
+    if (isRecord(data.delta)) state.message.stop_reason = data.delta.stop_reason ?? null;
+    if (isRecord(data.usage)) state.message.usage = data.usage;
+  },
+  error: (state, data) => {
+    state.message = { type: 'error', error: data.error };
+  },
+};
+
+function foldFrame(state: Assembled, event: string, data: Item): void {
+  FOLDS[event]?.(state, data);
+}
+
+function applyDelta(block: Item | undefined, delta: Item): void {
+  if (block === undefined) return;
+  if (delta.type === 'text_delta') block.text = str(block.text) + str(delta.text);
+  else if (delta.type === 'thinking_delta') block.thinking = str(block.thinking) + str(delta.thinking);
+  else if (delta.type === 'signature_delta') block.signature = str(delta.signature);
+  else if (delta.type === 'input_json_delta') block.json = str(block.json) + str(delta.partial_json);
+}
+
+export function assembleMessage(frames: string): Item {
+  const state: Assembled = { message: {}, blocks: [] };
+  for (const raw of new SseParser().push(frames)) {
+    const parsed = parseEvent(raw);
+    if (parsed !== null) foldFrame(state, parsed.event, parsed.data);
+  }
+  if (state.message.type === 'error') return state.message;
+  const content = state.blocks.map((block) => {
+    if (block.type !== 'tool_use') return block;
+    const { json, ...rest } = block;
+    let input: unknown = {};
+    try {
+      input = JSON.parse(str(json) || '{}');
+    } catch {
+      input = {};
+    }
+    return { ...rest, input };
+  });
+  return { ...state.message, content };
+}

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

@@ -0,0 +1,203 @@
+import { createHash } from 'node:crypto';
+import { isRecord } from '@metro-labs/core/is-record';
+
+export const SIGNATURE_PREFIX = 'metro-codex:';
+const DEFAULT_EFFORT = 'medium';
+const EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
+const EFFORT_ALIAS: Record<string, string> = { max: 'xhigh' };
+const IMAGE_NOTE = '[an image was attached here; this model cannot see it]';
+const NAME_MAX = 64;
+const NAME_RE = /^[a-zA-Z0-9_-]+$/;
+const HASH_LEN = 8;
+
+type Item = Record<string, unknown>;
+
+export interface TranslateOptions {
+  promptCacheKey: string;
+  names?: ToolNames;
+}
+
+export interface ResponsesRequest {
+  model: string;
+  instructions?: string;
+  input: Item[];
+  tools: Item[];
+  tool_choice: unknown;
+  parallel_tool_calls: boolean;
+  reasoning: { effort: string; summary: string };
+  store: false;
+  stream: true;
+  include: string[];
+  prompt_cache_key: string;
+}
+
+const textOf = (value: unknown): string => (typeof value === 'string' ? value : '');
+
+export function codexToolName(name: string): string {
+  if (name.length <= NAME_MAX && NAME_RE.test(name)) return name;
+  const clean = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+  const hash = createHash('sha256').update(name).digest('hex').slice(0, HASH_LEN);
+  return `${clean.slice(0, NAME_MAX - HASH_LEN - 1)}_${hash}`;
+}
+
+export class ToolNames {
+  private readonly original = new Map<string, string>();
+
+  alias(name: string): string {
+    const alias = codexToolName(name);
+    if (alias !== name) this.original.set(alias, name);
+    return alias;
+  }
+
+  restore(alias: string): string {
+    return this.original.get(alias) ?? alias;
+  }
+}
+
+function blocksText(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter(isRecord)
+    .filter((block) => block.type === 'text')
+    .map((block) => textOf(block.text))
+    .join('\n');
+}
+
+export function systemText(system: unknown): string {
+  return blocksText(system).trim();
+}
+
+export function encodeSignature(item: Item): string {
+  return `${SIGNATURE_PREFIX}${Buffer.from(JSON.stringify(item)).toString('base64url')}`;
+}
+
+export function decodeSignature(signature: unknown): Item | null {
+  if (typeof signature !== 'string' || !signature.startsWith(SIGNATURE_PREFIX)) return null;
+  try {
+    const parsed: unknown = JSON.parse(Buffer.from(signature.slice(SIGNATURE_PREFIX.length), 'base64url').toString('utf8'));
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function userPart(block: Item): Item | null {
+  if (block.type === 'text') return { type: 'input_text', text: textOf(block.text) };
+  if (block.type === 'image' && isRecord(block.source) && block.source.type === 'base64')
+    return { type: 'input_image', image_url: `data:${textOf(block.source.media_type)};base64,${textOf(block.source.data)}` };
+  return null;
+}
+
+const partText = (part: Item): string => (part.type === 'text' ? textOf(part.text) : part.type === 'image' ? IMAGE_NOTE : '');
+
+function resultText(block: Item): string {
+  const content = block.content;
+  const text = typeof content === 'string' ? content : Array.isArray(content) ? content.filter(isRecord).map(partText).filter((t) => t !== '').join('\n') : '';
+  return block.is_error === true ? `[tool error] ${text}` : text;
+}
+
+function userItems(content: unknown): Item[] {
+  if (typeof content === 'string') return [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: content }] }];
+  if (!Array.isArray(content)) return [];
+  const out: Item[] = [];
+  let parts: Item[] = [];
+  const flush = (): void => {
+    if (parts.length > 0) out.push({ type: 'message', role: 'user', content: parts });
+    parts = [];
+  };
+  for (const block of content.filter(isRecord)) {
+    if (block.type === 'tool_result') {
+      flush();
+      out.push({ type: 'function_call_output', call_id: textOf(block.tool_use_id), output: resultText(block) });
+      continue;
+    }
+    const part = userPart(block);
+    if (part !== null) parts.push(part);
+  }
+  flush();
+  return out;
+}
+
+function assistantItems(content: unknown, names: ToolNames): Item[] {
+  if (typeof content === 'string') return [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: content }] }];
+  if (!Array.isArray(content)) return [];
+  const out: Item[] = [];
+  for (const block of content.filter(isRecord)) {
+    if (block.type === 'text') out.push({ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: textOf(block.text) }] });
+    else if (block.type === 'tool_use')
+      out.push({ type: 'function_call', call_id: textOf(block.id), name: names.alias(textOf(block.name)), arguments: JSON.stringify(block.input ?? {}) });
+    else if (block.type === 'thinking') {
+      const reasoning = decodeSignature(block.signature);
+      if (reasoning !== null) out.push({ type: 'reasoning', ...reasoning, summary: [] });
+    }
+  }
+  return out;
+}
+
+export function inputItems(messages: unknown, names = new ToolNames()): Item[] {
+  const out: Item[] = [];
+  if (!Array.isArray(messages)) return out;
+  for (const message of messages.filter(isRecord)) {
+    if (message.role === 'assistant') out.push(...assistantItems(message.content, names));
+    else out.push(...userItems(message.content));
+  }
+  return out;
+}
+
+export function toolItems(tools: unknown, names = new ToolNames()): Item[] {
+  if (!Array.isArray(tools)) return [];
+  return tools
+    .filter(isRecord)
+    .filter((tool) => typeof tool.name === 'string' && isRecord(tool.input_schema))
+    .map((tool) => ({
+      type: 'function',
+      name: names.alias(textOf(tool.name)),
+      description: textOf(tool.description),
+      parameters: tool.input_schema,
+      strict: false,
+    }));
+}
+
+export function toolChoiceOf(choice: unknown, names = new ToolNames()): unknown {
+  if (!isRecord(choice)) return 'auto';
+  if (choice.type === 'any') return 'required';
+  if (choice.type === 'none') return 'none';
+  if (choice.type === 'tool' && typeof choice.name === 'string') return { type: 'function', name: names.alias(choice.name) };
+  return 'auto';
+}
+
+function configuredEffort(body: Item): string | null {
+  const config = isRecord(body.output_config) ? body.output_config : {};
+  const effort = typeof config.effort === 'string' ? (EFFORT_ALIAS[config.effort] ?? config.effort) : '';
+  return EFFORTS.has(effort) ? effort : null;
+}
+
+export function effortOf(body: Item): string {
+  const configured = configuredEffort(body);
+  if (configured !== null) return configured;
+  const thinking = isRecord(body.thinking) ? body.thinking : {};
+  if (thinking.type === 'disabled') return 'low';
+  const budget = typeof thinking.budget_tokens === 'number' ? thinking.budget_tokens : 0;
+  if (budget > 0 && budget <= 4_000) return 'low';
+  if (budget > 16_000) return 'high';
+  return DEFAULT_EFFORT;
+}
+
+export function toResponsesRequest(body: Item, model: string, opts: TranslateOptions): ResponsesRequest {
+  const system = systemText(body.system);
+  const names = opts.names ?? new ToolNames();
+  return {
+    model,
+    ...(system === '' ? {} : { instructions: system }),
+    input: inputItems(body.messages, names),
+    tools: toolItems(body.tools, names),
+    tool_choice: toolChoiceOf(body.tool_choice, names),
+    parallel_tool_calls: true,
+    reasoning: { effort: effortOf(body), summary: 'auto' },
+    store: false,
+    stream: true,
+    include: ['reasoning.encrypted_content'],
+    prompt_cache_key: opts.promptCacheKey,
+  };
+}