farming-code 2.2.6

package/backend/agent-activity.js

@@ -0,0 +1,186 @@
+function agentKindForCommand(command) {
+  const executable = String(command || '')
+    .trim()
+    .split(/\s+/)
+    .find(token => token !== 'env' && !/^[A-Za-z_][A-Za-z0-9_]*=/.test(token));
+  const basename = (executable || '').split('/').pop() || '';
+  if (basename === 'codex') return 'codex';
+  if (basename === 'claude') return 'claude';
+  if (['bash', 'zsh', 'sh', 'fish'].includes(basename)) return 'shell';
+  return executable ? 'agent' : null;
+}
+
+function currentTerminalText(agent) {
+  if (!agent) return '';
+  const previewText = typeof agent.previewText === 'string' ? agent.previewText : '';
+  if (previewText.trim()) return previewText.toLowerCase();
+  return String(agent.output || '').slice(-1800).toLowerCase();
+}
+
+function lastIndexOfAny(text, needles) {
+  return needles.reduce((last, needle) => Math.max(last, text.lastIndexOf(needle)), -1);
+}
+
+function lastCodexIdleFooterIndex(text) {
+  const matches = Array.from(text.matchAll(/(?:^|\n)\s*(?:gpt|codex)[^\n]*(?:·|•)\s*(?:~|\/)[^\n]*$/gim));
+  const lastMatch = matches.length > 0 ? matches[matches.length - 1] : undefined;
+  return lastMatch && typeof lastMatch.index === 'number' ? lastMatch.index : -1;
+}
+
+function codexActiveIndex(text) {
+  const activeTextIndex = lastIndexOfAny(text, [
+    'pursuing goal',
+    'esc to interrupt',
+    'press esc to interrupt',
+    'reconnecting',
+    '/stop to close',
+    'background terminal running',
+  ]);
+  const workingIndex = /\bworking\b/.test(text) ? text.lastIndexOf('working') : -1;
+  const stepMatches = Array.from(text.matchAll(/step\s+\d+\s*\/\s*\d+/g));
+  const lastStepMatch = stepMatches.length > 0 ? stepMatches[stepMatches.length - 1] : undefined;
+  const stepIndex = lastStepMatch && typeof lastStepMatch.index === 'number' ? lastStepMatch.index : -1;
+  return Math.max(activeTextIndex, workingIndex, stepIndex);
+}
+
+function codexKindIndex(text) {
+  const codexSpecificIndex = lastIndexOfAny(text, [
+    'pursuing goal',
+    'reconnecting',
+    '/stop to close',
+    'background terminal running',
+    'messages to be submitted after next tool call',
+    'stream disconnected before completion',
+  ]);
+  const workingIndex = /\bworking\b/.test(text) ? text.lastIndexOf('working') : -1;
+  const stepMatches = Array.from(text.matchAll(/step\s+\d+\s*\/\s*\d+/g));
+  const lastStepMatch = stepMatches.length > 0 ? stepMatches[stepMatches.length - 1] : undefined;
+  const stepIndex = lastStepMatch && typeof lastStepMatch.index === 'number' ? lastStepMatch.index : -1;
+  return Math.max(codexSpecificIndex, workingIndex, stepIndex);
+}
+
+function codexBlockedIndex(text) {
+  return lastIndexOfAny(text, [
+    'goal blocked',
+    'input exceeds the context window',
+    'please adjust your input and try again',
+  ]);
+}
+
+function titleWithoutActivityPrefix(title) {
+  return String(title || '')
+    .trim()
+    .replace(/^[\s*＊✳✱✲✶·•:.\u2800-\u28FF]+/u, '')
+    .replace(/\s+/g, ' ')
+    .toLowerCase();
+}
+
+function activeTerminalTitleKind(agent) {
+  const title = typeof agent.sessionTitle === 'string' ? agent.sessionTitle.trim() : '';
+  if (/^[\u2800-\u28ff]/u.test(title)) return 'codex';
+  return null;
+}
+
+function genericTerminalTitleKind(agent) {
+  const normalized = titleWithoutActivityPrefix(agent && agent.sessionTitle);
+  if (!normalized) return null;
+  if (/\bclaude(?:\s+code)?\b/.test(normalized)) return 'claude';
+  if (/\bcodex\b/.test(normalized)) return 'codex';
+  if (/^(?:bash|zsh|sh|fish)(?:\s|$)/.test(normalized)) return 'shell';
+  return null;
+}
+
+function lastMatchIndex(text, pattern) {
+  const matches = Array.from(text.matchAll(pattern));
+  const lastMatch = matches.length > 0 ? matches[matches.length - 1] : undefined;
+  return lastMatch && typeof lastMatch.index === 'number' ? lastMatch.index : -1;
+}
+
+function latestTerminalOutputKind(text) {
+  const candidates = [];
+  const codexIndex = Math.max(
+    lastCodexIdleFooterIndex(text),
+    codexKindIndex(text),
+    lastMatchIndex(text, /(?:^|\n)\s*›\s/g)
+  );
+  if (codexIndex >= 0) candidates.push({ kind: 'codex', index: codexIndex });
+
+  const claudeIndex = Math.max(
+    lastIndexOfAny(text, ['claude code']),
+    lastMatchIndex(text, /(?:thinking|claude)[\s\S]*(?:esc|escape|ctrl\+c|ctrl-c) to interrupt/g)
+  );
+  if (claudeIndex >= 0) candidates.push({ kind: 'claude', index: claudeIndex });
+
+  const shellIndex = lastMatchIndex(text, /(?:^|\n)\s*(?:[\w./~:@-]+\s*)?[$%#]\s*$/gm);
+  if (shellIndex >= 0) candidates.push({ kind: 'shell', index: shellIndex });
+
+  const latest = candidates.sort((a, b) => b.index - a.index)[0];
+  return latest ? latest.kind : null;
+}
+
+function inferAgentKind(agent) {
+  if (!agent) return null;
+  return activeTerminalTitleKind(agent)
+    || latestTerminalOutputKind(currentTerminalText(agent))
+    || (agent.terminalStatus && agent.terminalStatus.kind !== 'unknown' ? agent.terminalStatus.kind : null)
+    || (agent.terminalBusy === true ? 'shell' : null)
+    || genericTerminalTitleKind(agent)
+    || agentKindForCommand(agent.command);
+}
+
+function isAgentTerminalBusy(agent) {
+  if (agent && agent.terminalStatus) {
+    if (agent.terminalStatus.activity === 'busy') return true;
+    if (agent.terminalStatus.activity === 'idle' || agent.terminalStatus.activity === 'exited') return false;
+  }
+  return agent && agent.terminalBusy === true;
+}
+
+function isCodexRestartBlocking(agent) {
+  const output = currentTerminalText(agent);
+  if (!output) return false;
+  if (output.includes('messages to be submitted after next tool call')) return true;
+
+  const activeIndex = codexActiveIndex(output);
+  if (activeIndex < 0) return false;
+
+  const blockedIndex = codexBlockedIndex(output);
+  if (blockedIndex >= activeIndex) return false;
+
+  return lastCodexIdleFooterIndex(output) <= activeIndex;
+}
+
+function isClaudeRestartBlocking(agent) {
+  const output = currentTerminalText(agent);
+  return (
+    output.includes('esc to interrupt') ||
+    output.includes('escape to interrupt') ||
+    output.includes('ctrl+c to interrupt') ||
+    output.includes('ctrl-c to interrupt') ||
+    output.includes('press esc to interrupt')
+  );
+}
+
+function isRecoverableEngineAgent(agent) {
+  return agent && agent.engineName === 'native';
+}
+
+function isRestartBlockingAgent(agent) {
+  if (!agent || agent.isMain === true || agent.archived === true) return false;
+  if (agent.status === 'pending') return true;
+  if (agent.status !== 'running') return false;
+  if (isRecoverableEngineAgent(agent)) return false;
+  if (isAgentTerminalBusy(agent)) return true;
+
+  const kind = inferAgentKind(agent);
+  if (kind === 'shell') return false;
+  if (kind === 'codex') return isCodexRestartBlocking(agent);
+  if (kind === 'claude') return isClaudeRestartBlocking(agent);
+  return true;
+}
+
+module.exports = {
+  agentKindForCommand,
+  isRecoverableEngineAgent,
+  isRestartBlockingAgent,
+};

package/backend/agent-env.js

@@ -0,0 +1,250 @@
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const SHELL_ENV_BEGIN = '__FARMING_AGENT_ENV_BEGIN__';
+const SHELL_ENV_END = '__FARMING_AGENT_ENV_END__';
+const DEFAULT_SHELL_ENV_TIMEOUT_MS = 2500;
+
+function isCatPager(value) {
+  const text = String(value || '').trim();
+  if (!text) return false;
+  return /^(?:\/[^\s]+\/)?cat(?:\s|$)/.test(text);
+}
+
+function scrubNonInteractivePagerEnv(env) {
+  const next = env || {};
+  if (next.FARMING_PRESERVE_AGENT_CAT_PAGER === '1') {
+    return next;
+  }
+
+  if (isCatPager(next.PAGER)) delete next.PAGER;
+  if (isCatPager(next.GIT_PAGER)) delete next.GIT_PAGER;
+  return next;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function normalizeTimeoutMs(value, fallback = DEFAULT_SHELL_ENV_TIMEOUT_MS) {
+  const parsed = Math.floor(Number(value));
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(250, Math.min(parsed, 15000));
+}
+
+function defaultShell(processEnv = process.env) {
+  if (processEnv.SHELL) return processEnv.SHELL;
+  if (process.platform === 'win32') return '';
+  if (fsExists('/bin/bash')) return '/bin/bash';
+  return '/bin/sh';
+}
+
+function fsExists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+
+function shellEnvArgs(shell, command) {
+  const name = path.basename(String(shell || '')).toLowerCase();
+  if (name === 'bash' || name === 'zsh' || name === 'fish' || name === 'ksh') {
+    return ['-lic', command];
+  }
+  if (process.platform === 'win32' && (name === 'cmd.exe' || name === 'cmd')) {
+    return ['/d', '/s', '/c', command];
+  }
+  return ['-lc', command];
+}
+
+function buildShellEnvCommand(nodePath = process.execPath) {
+  const script = 'process.stdout.write(JSON.stringify(process.env))';
+  return [
+    `printf '\\n${SHELL_ENV_BEGIN}\\n'`,
+    `${shellQuote(nodePath)} -e ${shellQuote(script)}`,
+    `printf '\\n${SHELL_ENV_END}\\n'`,
+  ].join('; ');
+}
+
+function parseShellEnvOutput(output) {
+  const text = Buffer.isBuffer(output) ? output.toString('utf8') : String(output || '');
+  const start = text.indexOf(SHELL_ENV_BEGIN);
+  const end = text.lastIndexOf(SHELL_ENV_END);
+  if (start < 0 || end <= start) return null;
+
+  const jsonText = text.slice(start + SHELL_ENV_BEGIN.length, end).trim();
+  if (!jsonText) return null;
+
+  try {
+    const parsed = JSON.parse(jsonText);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+    return Object.fromEntries(
+      Object.entries(parsed)
+        .filter(([key, value]) => typeof key === 'string' && typeof value === 'string')
+    );
+  } catch {
+    return null;
+  }
+}
+
+function resolveUserShellEnvSync(options = {}) {
+  const processEnv = options.processEnv || process.env;
+  if (String(processEnv.FARMING_AGENT_SHELL_ENV || '').toLowerCase() === '0' ||
+      String(processEnv.FARMING_AGENT_SHELL_ENV || '').toLowerCase() === 'false') {
+    return null;
+  }
+
+  const shell = options.shell || defaultShell(processEnv);
+  if (!shell) return null;
+
+  const command = options.command || buildShellEnvCommand(options.nodePath || process.execPath);
+  const args = options.args || shellEnvArgs(shell, command);
+  const timeout = normalizeTimeoutMs(options.timeoutMs ?? processEnv.FARMING_AGENT_SHELL_ENV_TIMEOUT_MS);
+  const env = {
+    ...processEnv,
+    FARMING_COLLECT_AGENT_SHELL_ENV: '1',
+  };
+
+  const result = spawnSync(shell, args, {
+    cwd: options.cwd || processEnv.HOME || os.homedir(),
+    env,
+    input: '',
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024,
+    timeout,
+    windowsHide: true,
+  });
+
+  if (result.error || result.signal === 'SIGTERM' || result.status === 124) {
+    return null;
+  }
+
+  return parseShellEnvOutput(result.stdout);
+}
+
+const PROCESS_ENV_EXACT_KEYS = new Set([
+  'ANTHROPIC_API_KEY',
+  'ANTHROPIC_AUTH_TOKEN',
+  'ANTHROPIC_BASE_URL',
+  'ALL_PROXY',
+  'all_proxy',
+  'CLAUDE_CONFIG_DIR',
+  'CODEX_HOME',
+  'OPENCODE_CONFIG_DIR',
+  'QODER_CONFIG_DIR',
+  'CURL_CA_BUNDLE',
+  'DASHSCOPE_API_KEY',
+  'EDITOR',
+  'FARMING_ANONYMIZE_SHELL_PROMPT',
+  'FARMING_PRESERVE_AGENT_CAT_PAGER',
+  'FARMING_SHELL_CONTROLLED_PROMPT',
+  'GEMINI_API_KEY',
+  'GIT_ASKPASS',
+  'GITHUB_TOKEN',
+  'GITLAB_TOKEN',
+  'GPG_TTY',
+  'HTTPS_PROXY',
+  'https_proxy',
+  'HTTP_PROXY',
+  'http_proxy',
+  'LANG',
+  'LC_ALL',
+  'LC_CTYPE',
+  'NO_PROXY',
+  'no_proxy',
+  'NODE_EXTRA_CA_CERTS',
+  'OPENAI_API_KEY',
+  'OPENAI_BASE_URL',
+  'OPENAI_MODEL',
+  'REQUESTS_CA_BUNDLE',
+  'SHELL',
+  'SSH_AGENT_PID',
+  'SSH_AUTH_SOCK',
+  'SSL_CERT_DIR',
+  'SSL_CERT_FILE',
+  'VISUAL',
+]);
+
+const PROCESS_ENV_PREFIXES = [
+  'ANTHROPIC_',
+  'AWS_',
+  'AZURE_OPENAI_',
+  'CLAUDE_CODE_',
+  'DASHSCOPE_',
+  'GEMINI_',
+  'GITHUB_',
+  'GITLAB_',
+  'GOOGLE_API_',
+  'GOOGLE_CLOUD_',
+  'LANGCHAIN_',
+  'LC_',
+  'NPM_CONFIG_',
+  'OPENAI_',
+  'PIP_',
+  'QWEN_',
+  'UV_',
+  'npm_config_',
+];
+
+function shouldOverlayProcessEnv(key) {
+  return PROCESS_ENV_EXACT_KEYS.has(key) || PROCESS_ENV_PREFIXES.some(prefix => key.startsWith(prefix));
+}
+
+function buildInteractiveAgentBaseEnv(options = {}) {
+  const processEnv = options.processEnv || process.env;
+  const shellEnv = options.shellEnv && typeof options.shellEnv === 'object' ? options.shellEnv : null;
+  const env = shellEnv ? { ...shellEnv } : { ...processEnv };
+
+  for (const [key, value] of Object.entries(processEnv)) {
+    if (typeof value !== 'string') continue;
+    if (!shouldOverlayProcessEnv(key)) continue;
+    if (key in env && env[key] !== '') continue;
+    env[key] = value;
+  }
+
+  if (!env.HOME) env.HOME = processEnv.HOME || os.homedir();
+  if (!env.USER && processEnv.USER) env.USER = processEnv.USER;
+  if (!env.LOGNAME && processEnv.LOGNAME) env.LOGNAME = processEnv.LOGNAME;
+  if (!env.PATH && processEnv.PATH) env.PATH = processEnv.PATH;
+
+  return env;
+}
+
+function normalizeInteractiveTerminalEnv(env, options = {}) {
+  const next = env || {};
+
+  if (options.stripRuntimeShims !== false) {
+    delete next.LD_LIBRARY_PATH;
+  }
+  if (options.stripNodeOptions !== false) {
+    delete next.NODE_OPTIONS;
+  }
+
+  delete next.NO_COLOR;
+  scrubNonInteractivePagerEnv(next);
+
+  if (!next.TERM || String(next.TERM).toLowerCase() === 'dumb') {
+    next.TERM = 'xterm-256color';
+  }
+  next.COLORTERM = 'truecolor';
+  next.CLICOLOR = next.CLICOLOR || '1';
+  next.TERM_PROGRAM = 'farming';
+  next.TERM_PROGRAM_VERSION = process.env.npm_package_version || '';
+  return next;
+}
+
+module.exports = {
+  SHELL_ENV_BEGIN,
+  SHELL_ENV_END,
+  buildInteractiveAgentBaseEnv,
+  buildShellEnvCommand,
+  isCatPager,
+  normalizeInteractiveTerminalEnv,
+  parseShellEnvOutput,
+  resolveUserShellEnvSync,
+  scrubNonInteractivePagerEnv,
+  shellEnvArgs,
+};

package/backend/agent-json-stream.js

@@ -0,0 +1,268 @@
+const { buildTranscriptFromEvents } = require('./codex-transcript');
+
+const DEFAULT_MAX_EVENTS = 12_000;
+
+class JsonlStreamDecoder {
+  constructor() {
+    this.buffer = '';
+  }
+
+  push(chunk) {
+    this.buffer += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk || '');
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+    return lines.flatMap(parseJsonLine);
+  }
+
+  flush() {
+    const trailing = this.buffer;
+    this.buffer = '';
+    return parseJsonLine(trailing);
+  }
+}
+
+function parseJsonLine(line) {
+  const text = String(line || '').trim();
+  if (!text) return [];
+  try {
+    return [JSON.parse(text)];
+  } catch {
+    // Coding-agent CLIs occasionally print update notices or diagnostics to
+    // stdout. They should remain visible in the terminal, but must not poison
+    // the structured chat stream.
+    return [];
+  }
+}
+
+function itemEvent(type, turnId, item) {
+  return { type, turn_id: turnId, item };
+}
+
+class CodexJsonAdapter {
+  constructor(options) {
+    this.prompt = options.prompt;
+    this.operationId = options.operationId;
+    this.turnId = `codex-${this.operationId}`;
+    this.sessionId = '';
+    this.started = false;
+  }
+
+  adapt(raw) {
+    if (!raw || typeof raw !== 'object') return [];
+    if (raw.type === 'thread.started') {
+      this.sessionId = typeof raw.thread_id === 'string' ? raw.thread_id : this.sessionId;
+      return [];
+    }
+    if (raw.type === 'turn.started') {
+      if (this.started) return [];
+      this.started = true;
+      return [
+        { type: 'turn.started', turn_id: this.turnId },
+        ...this.userMessageEvents(),
+      ];
+    }
+    if (raw.type === 'item.started' || raw.type === 'item.completed') {
+      this.ensureStarted();
+      return [itemEvent(raw.type, this.turnId, raw.item)];
+    }
+    if (raw.type === 'turn.completed') {
+      this.ensureStarted();
+      return [{ ...raw, turn_id: this.turnId }];
+    }
+    if (raw.type === 'turn.failed' || raw.type === 'error') {
+      this.ensureStarted();
+      const message = raw.message || raw.error?.message || raw.error || 'Codex execution failed';
+      return [
+        itemEvent('item.completed', this.turnId, {
+          id: `${this.turnId}-error`,
+          type: 'error',
+          message: typeof message === 'string' ? message : JSON.stringify(message),
+          status: 'failed',
+        }),
+        { type: 'turn.completed', turn_id: this.turnId },
+      ];
+    }
+    return [];
+  }
+
+  flush() {
+    return [];
+  }
+
+  ensureStarted() {
+    this.started = true;
+  }
+
+  userMessageEvents() {
+    if (!this.prompt) return [];
+    return [itemEvent('item.completed', this.turnId, {
+      id: `${this.turnId}-user`,
+      type: 'user_message',
+      content: [{ type: 'text', text: this.prompt }],
+    })];
+  }
+}
+
+function openCodeToolItem(part) {
+  const state = part.state && typeof part.state === 'object' ? part.state : {};
+  const input = state.input && typeof state.input === 'object' ? state.input : {};
+  const id = part.callID || part.id;
+  if (part.tool === 'bash') {
+    return {
+      id,
+      type: 'command_execution',
+      command: input.command || state.title || '',
+      aggregated_output: state.output || state.metadata?.output || '',
+      exit_code: Number.isFinite(state.metadata?.exit) ? state.metadata.exit : null,
+      status: state.status,
+    };
+  }
+  return {
+    id,
+    type: 'mcp_tool_call',
+    server: 'opencode',
+    tool: part.tool || 'tool',
+    arguments: input,
+    result: state.output,
+    error: state.error,
+    status: state.status,
+  };
+}
+
+class OpenCodeJsonAdapter {
+  constructor(options) {
+    this.prompt = options.prompt;
+    this.operationId = options.operationId;
+    this.turnId = `opencode-${this.operationId}`;
+    this.sessionId = '';
+    this.started = false;
+    this.completed = false;
+    this.text = '';
+  }
+
+  adapt(raw) {
+    if (!raw || typeof raw !== 'object') return [];
+    if (typeof raw.sessionID === 'string') this.sessionId = raw.sessionID;
+    const events = this.startEvents(raw.timestamp);
+    const part = raw.part && typeof raw.part === 'object' ? raw.part : {};
+
+    if (raw.type === 'text' && typeof part.text === 'string') {
+      this.text += part.text;
+      events.push(itemEvent('item.completed', this.turnId, {
+        id: `${this.turnId}-assistant`,
+        type: 'agent_message',
+        text: this.text,
+      }));
+    } else if (raw.type === 'tool_use' && (part.callID || part.id)) {
+      const state = part.state && typeof part.state === 'object' ? part.state : {};
+      const eventType = state.status === 'completed' || state.status === 'error'
+        ? 'item.completed'
+        : 'item.started';
+      events.push(itemEvent(eventType, this.turnId, openCodeToolItem(part)));
+    } else if (raw.type === 'error') {
+      const message = raw.error?.message || raw.message || raw.error || 'OpenCode execution failed';
+      events.push(itemEvent('item.completed', this.turnId, {
+        id: `${this.turnId}-error`,
+        type: 'error',
+        message: typeof message === 'string' ? message : JSON.stringify(message),
+        status: 'failed',
+      }));
+    }
+
+    if (raw.type === 'step_finish' && part.reason !== 'tool-calls') {
+      events.push(...this.completeEvents(raw.timestamp));
+    }
+    return events;
+  }
+
+  flush() {
+    return this.completeEvents();
+  }
+
+  startEvents(timestamp) {
+    if (this.started) return [];
+    this.started = true;
+    const events = [{
+      type: 'turn.started',
+      turn_id: this.turnId,
+      ...(Number.isFinite(timestamp) ? { startedAtMs: timestamp } : {}),
+    }];
+    if (this.prompt) {
+      events.push(itemEvent('item.completed', this.turnId, {
+        id: `${this.turnId}-user`,
+        type: 'user_message',
+        content: [{ type: 'text', text: this.prompt }],
+      }));
+    }
+    return events;
+  }
+
+  completeEvents(timestamp) {
+    if (!this.started || this.completed) return [];
+    this.completed = true;
+    return [{
+      type: 'turn.completed',
+      turn_id: this.turnId,
+      ...(Number.isFinite(timestamp) ? { completedAt: timestamp } : {}),
+    }];
+  }
+}
+
+function createAdapter(provider, options) {
+  if (provider === 'codex') return new CodexJsonAdapter(options);
+  if (provider === 'opencode') return new OpenCodeJsonAdapter(options);
+  throw new Error(`Unsupported agent JSON provider: ${provider}`);
+}
+
+class AgentJsonStreamParser {
+  constructor(options = {}) {
+    const provider = String(options.provider || '').trim().toLowerCase();
+    const operationId = String(options.operationId || Date.now());
+    this.provider = provider;
+    this.decoder = new JsonlStreamDecoder();
+    this.adapter = createAdapter(provider, {
+      operationId,
+      prompt: typeof options.prompt === 'string' ? options.prompt.trim() : '',
+    });
+    this.events = [];
+    this.maxEvents = Number.isFinite(options.maxEvents)
+      ? Math.max(1, Math.floor(options.maxEvents))
+      : DEFAULT_MAX_EVENTS;
+  }
+
+  get sessionId() {
+    return this.adapter.sessionId;
+  }
+
+  push(chunk) {
+    return this.appendRaw(this.decoder.push(chunk));
+  }
+
+  flush() {
+    const events = this.appendRaw(this.decoder.flush());
+    return [...events, ...this.appendEvents(this.adapter.flush())];
+  }
+
+  transcript(options = {}) {
+    return buildTranscriptFromEvents(this.events, options);
+  }
+
+  appendRaw(rawEvents) {
+    const normalized = rawEvents.flatMap(event => this.adapter.adapt(event));
+    return this.appendEvents(normalized);
+  }
+
+  appendEvents(events) {
+    if (!events.length) return [];
+    this.events.push(...events);
+    if (this.events.length > this.maxEvents) {
+      this.events.splice(0, this.events.length - this.maxEvents);
+    }
+    return events;
+  }
+}
+
+module.exports = {
+  AgentJsonStreamParser,
+  JsonlStreamDecoder,
+};