@amalgm/chat 0.1.2 → 0.2.1

package/host/adapters/codex.js

@@ -0,0 +1,733 @@
+// Codex app-server JSON-RPC-over-stdio adapter.
+//
+// Event construction and normalization come from the SDK; the adapter session
+// object doubles as normalizer state. Effectful tooling and the recorder are
+// sibling host modules.
+//
+// Hook renderers are injected through the constructor option
+// `options.renderers` on `CodexAdapter` and the optional trailing `renderers`
+// parameter on config builders. Hook rendering stays inside this boundary.
+// The uninjected default reports no hooks; the JSON/map renderers throw if
+// reached without injection (unreachable when `hasHooks` is false).
+
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createEventConstructors } from '../../dist/events/index.js';
+import { codexErrorMessage, createCodexNormalizer } from '../../dist/normalizers/codex.js';
+import { recordNativeEvent } from '../recorder.js';
+import { relayedMcpServers, toCodexMcpToml } from '../tooling/mcp-bundle.js';
+import { bundledCodexBinary, bundledCodexPathDirs, executableExists, findOnPath } from '../tooling/native-binaries.js';
+import { syncCodexProviderAuth } from '../tooling/native-config.js';
+import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
+import { composeSystemPrompt } from '../tooling/system-prompt.js';
+import { requestPermission } from '../permissions.js';
+import {
+  COMMON_REASONING_SETTINGS,
+  COMMON_SPEED_SETTINGS,
+  nativeInputCapabilities,
+} from './input-capabilities.js';
+import { codexPromptInput } from './prompt.js';
+
+const events = createEventConstructors({ clockMs: () => Date.now() });
+const { done, errorEvent } = events;
+const { normalizeCodexNotification } = createCodexNormalizer(events);
+
+// Engine default: require('../../amalgm-mcp/agent-config/renderers/hooks').
+const defaultRenderers = {
+  hasHooks: () => false,
+  toCodexHooksJson() {
+    throw new Error('CodexAdapter: renderers.toCodexHooksJson was not injected (engine source: amalgm-mcp/agent-config/renderers/hooks.js)');
+  },
+  toHookMap() {
+    throw new Error('CodexAdapter: renderers.toHookMap was not injected (engine source: amalgm-mcp/agent-config/renderers/hooks.js)');
+  },
+};
+
+class JsonLineRpc {
+  constructor({ binary, cwd, env }) {
+    this.id = 1;
+    this.pending = new Map();
+    this.handlers = new Set();
+    this.requestHandler = null;
+    this.buffer = '';
+    this.closed = false;
+    this.closeError = null;
+    this.child = spawn(binary, ['app-server'], {
+      cwd,
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: process.platform !== 'win32',
+      windowsHide: true,
+    });
+    this.child.stdout.setEncoding('utf8');
+    this.child.stdout.on('data', (chunk) => this.onData(chunk));
+    this.child.stderr.setEncoding('utf8');
+    this.child.stderr.on('data', (chunk) => {
+      const text = String(chunk || '').trim();
+      if (text && process.env.AMALGM_CHAT_DEBUG) console.warn('[Codex]', text.slice(0, 1000));
+    });
+    this.child.on('error', (err) => {
+      this.failAll(err);
+    });
+    this.child.on('exit', (code, signal) => {
+      const err = new Error(`codex app-server exited (${code ?? signal ?? 'unknown'})`);
+      this.failAll(err);
+    });
+    this.child.stdin.on('error', (err) => {
+      this.failAll(err);
+    });
+  }
+
+  failAll(err) {
+    this.closed = true;
+    this.closeError = err;
+    for (const pending of this.pending.values()) pending.reject(err);
+    this.pending.clear();
+  }
+
+  rejectPending(id, err) {
+    const pending = this.pending.get(id);
+    if (!pending) return;
+    this.pending.delete(id);
+    pending.reject(err);
+  }
+
+  onData(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let msg;
+      try { msg = JSON.parse(line); } catch { continue; }
+      if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
+        const pending = this.pending.get(msg.id);
+        if (!pending) continue;
+        this.pending.delete(msg.id);
+        if (msg.error) pending.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+        else pending.resolve(msg.result);
+      } else if (msg.id !== undefined && msg.method) {
+        this.handleServerRequest(msg);
+      } else {
+        if (process.env.AMALGM_CHAT_DEBUG_CODEX === '1') {
+          console.log('[Codex:event]', JSON.stringify(msg).slice(0, 4000));
+        }
+        for (const handler of this.handlers) handler(msg);
+      }
+    }
+  }
+
+  async handleServerRequest(msg) {
+    try {
+      if (!this.requestHandler) throw new Error(`Method not supported: ${msg.method}`);
+      const result = await this.requestHandler(msg.method, msg.params || {});
+      this.write({ id: msg.id, result: result ?? {} });
+    } catch (error) {
+      this.write({ id: msg.id, error: { code: -32603, message: error.message || 'Internal error' } });
+    }
+  }
+
+  write(value) {
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) return;
+    try {
+      this.child.stdin.write(`${JSON.stringify(value)}\n`, (error) => {
+        if (error) this.failAll(error);
+      });
+    } catch (error) {
+      this.failAll(error);
+    }
+  }
+
+  request(method, params = {}, timeoutMs = 180000) {
+    if (this.closeError) return Promise.reject(this.closeError);
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) {
+      return Promise.reject(new Error('codex app-server is not running'));
+    }
+    const id = this.id++;
+    const payload = `${JSON.stringify({ id, method, params })}\n`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`${method} timed out`));
+      }, timeoutMs);
+      this.pending.set(id, {
+        resolve: (value) => { clearTimeout(timer); resolve(value); },
+        reject: (err) => { clearTimeout(timer); reject(err); },
+      });
+      try {
+        this.child.stdin.write(payload, (err) => {
+          if (err) this.rejectPending(id, err);
+        });
+      } catch (err) {
+        this.rejectPending(id, err);
+      }
+    });
+  }
+
+  notify(method, params) {
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) return;
+    const payload = `${JSON.stringify(params === undefined ? { method } : { method, params })}\n`;
+    try {
+      this.child.stdin.write(payload, (err) => {
+        if (err) this.failAll(err);
+      });
+    } catch (err) {
+      this.failAll(err);
+    }
+  }
+
+  on(handler) {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
+  }
+
+  onRequest(handler) {
+    this.requestHandler = handler;
+  }
+
+  close() {
+    try { this.child.stdin.end(); } catch {}
+    try {
+      if (process.platform !== 'win32' && this.child.pid) process.kill(-this.child.pid, 'SIGTERM');
+      else this.child.kill('SIGTERM');
+    } catch {}
+  }
+}
+
+function resolveBinary() {
+  const home = process.env.HOME || os.homedir();
+  const candidates = [
+    process.env.CODEX_BINARY,
+    bundledCodexBinary(),
+    path.join(home, '.npm-global/bin/codex'),
+    '/opt/homebrew/bin/codex',
+    '/usr/local/bin/codex',
+    findOnPath('codex'),
+  ].filter(Boolean);
+  const failures = [];
+  for (const candidate of candidates) {
+    if (!executableExists(candidate)) {
+      failures.push(`${candidate} (missing or not executable)`);
+      continue;
+    }
+    const res = spawnSync(candidate, ['--version'], { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8' });
+    if (res.status === 0) return candidate;
+    failures.push(`${candidate} (--version failed: ${res.error?.message || res.status || res.signal || 'unknown'})`);
+  }
+  throw new Error(`Codex CLI binary is not available. Checked: ${failures.join(', ') || 'no candidates'}. Reinstall Amalgm or run amalgm update so the bundled Codex native package is present.`);
+}
+
+function codexEnv(baseEnv, binary) {
+  const env = { ...(baseEnv || {}) };
+  if (binary !== bundledCodexBinary()) return env;
+  const pathDirs = bundledCodexPathDirs();
+  if (pathDirs.length > 0) {
+    env.PATH = [...pathDirs, env.PATH].filter(Boolean).join(path.delimiter);
+  }
+  env.CODEX_MANAGED_BY_NPM = '1';
+  return env;
+}
+
+function positiveInteger(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : null;
+}
+
+function modelWindowConfigLines(contract) {
+  const contextWindow = positiveInteger(contract.contextWindow);
+  if (!contextWindow) return [];
+  return [
+    `model_context_window = ${contextWindow}`,
+    `model_auto_compact_token_limit = ${Math.max(1, Math.floor(contextWindow * 0.9))}`,
+    '',
+  ];
+}
+
+function serviceTierForContract(contract) {
+  return contract.fastMode ? 'fast' : null;
+}
+
+function isCompactCommand(text) {
+  return String(text || '').trim().toLowerCase() === '/compact';
+}
+
+function readTextFile(file) {
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function ensureCodexHomeAlias(home) {
+  if (!home) return null;
+  const alias = path.join(home, '.codex');
+  try {
+    const stat = fs.lstatSync(alias);
+    return stat.isDirectory() || stat.isSymbolicLink() ? alias : null;
+  } catch {}
+  try {
+    fs.symlinkSync('.', alias, 'dir');
+    return alias;
+  } catch {
+    try {
+      fs.mkdirSync(alias, { recursive: true });
+      return alias;
+    } catch {
+      return null;
+    }
+  }
+}
+
+function codexConfigDirs(home) {
+  fs.mkdirSync(home, { recursive: true });
+  const dirs = [home];
+  const alias = ensureCodexHomeAlias(home);
+  if (alias) dirs.push(alias);
+  const seen = new Set();
+  return dirs.filter((dir) => {
+    let key;
+    try {
+      key = fs.realpathSync(dir);
+    } catch {
+      key = path.resolve(dir);
+    }
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function unlinkSymlinkIfPresent(target) {
+  try {
+    if (fs.lstatSync(target).isSymbolicLink()) fs.unlinkSync(target);
+  } catch {}
+}
+
+function writeCodexHomeFile(home, filename, contents, mode = 0o600, options = {}) {
+  for (const dir of codexConfigDirs(home)) {
+    const target = path.join(dir, filename);
+    if (options.unlinkSymlink) unlinkSymlinkIfPresent(target);
+    fs.writeFileSync(target, contents, { mode });
+    try { fs.chmodSync(target, mode); } catch {}
+  }
+}
+
+function tomlSectionName(line) {
+  const match = String(line || '').match(/^\s*\[([^\]]+)\]\s*$/);
+  return match ? match[1].trim() : null;
+}
+
+function removeTopLevelKeys(toml, keys) {
+  const remove = new Set(keys);
+  let inTopLevel = true;
+  return String(toml || '')
+    .split(/\r?\n/)
+    .filter((line) => {
+      if (tomlSectionName(line)) inTopLevel = false;
+      if (!inTopLevel) return true;
+      const match = line.match(/^\s*([A-Za-z0-9_-]+)\s*=/);
+      return !match || !remove.has(match[1]);
+    })
+    .join('\n');
+}
+
+function removeTomlSections(toml, sectionNames) {
+  const remove = new Set(sectionNames);
+  let skipping = false;
+  const out = [];
+  for (const line of String(toml || '').split(/\r?\n/)) {
+    const section = tomlSectionName(line);
+    if (section) {
+      skipping = [...remove].some((name) => section === name || section.startsWith(`${name}.`));
+    }
+    if (!skipping) out.push(line);
+  }
+  return out.join('\n');
+}
+
+function ensureFeatureBoolean(toml, key, value) {
+  const lines = String(toml || '').split(/\r?\n/);
+  const sectionIndex = lines.findIndex((line) => tomlSectionName(line) === 'features');
+  const rendered = `${key} = ${value ? 'true' : 'false'}`;
+  if (sectionIndex === -1) {
+    return `${String(toml || '').trimEnd()}\n\n[features]\n${rendered}\n`;
+  }
+  let insertAt = lines.length;
+  for (let i = sectionIndex + 1; i < lines.length; i += 1) {
+    if (tomlSectionName(lines[i])) {
+      insertAt = i;
+      break;
+    }
+    if (new RegExp(`^\\s*${key}\\s*=`).test(lines[i])) {
+      lines[i] = rendered;
+      return lines.join('\n');
+    }
+  }
+  lines.splice(insertAt, 0, rendered);
+  return lines.join('\n');
+}
+
+function tomlQuoted(value) {
+  return JSON.stringify(String(value || ''));
+}
+
+function hookTrustBlocks(toml) {
+  const lines = String(toml || '').split(/\r?\n/);
+  const blocks = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    const section = tomlSectionName(lines[i]);
+    const match = section?.match(/^hooks\.state\."([^"]+)"$/);
+    if (!match) continue;
+    let end = lines.length;
+    for (let j = i + 1; j < lines.length; j += 1) {
+      if (tomlSectionName(lines[j])) {
+        end = j;
+        break;
+      }
+    }
+    blocks.push({ key: match[1], lines: lines.slice(i, end) });
+  }
+  return blocks;
+}
+
+function hookTrustToml(toml) {
+  return hookTrustBlocks(toml).map((block) => block.lines.join('\n')).join('\n\n');
+}
+
+function mirrorCodexHookTrust(toml, sourceDir, runtimeHome) {
+  if (!sourceDir || !runtimeHome) return toml;
+  const sourceHookPrefix = `${path.join(sourceDir, 'hooks.json')}:`;
+  const runtimePrefixes = [
+    `${path.join(runtimeHome, 'hooks.json')}:`,
+    `${path.join(runtimeHome, '.codex', 'hooks.json')}:`,
+  ];
+  const blocks = hookTrustBlocks(toml);
+  if (blocks.length === 0) return toml;
+  const existing = new Set(blocks.map((block) => block.key));
+  const additions = [];
+  for (const block of blocks) {
+    if (!block.key.startsWith(sourceHookPrefix)) continue;
+    const suffix = block.key.slice(sourceHookPrefix.length);
+    for (const prefix of runtimePrefixes) {
+      const nextKey = `${prefix}${suffix}`;
+      if (existing.has(nextKey)) continue;
+      existing.add(nextKey);
+      const lines = [...block.lines];
+      lines[0] = `[hooks.state.${tomlQuoted(nextKey)}]`;
+      additions.push(lines.join('\n'));
+    }
+  }
+  if (additions.length === 0) return toml;
+  const parent = /\n\s*\[hooks\.state\]\s*(?:\n|$)/.test(`\n${toml}`) ? '' : '\n[hooks.state]\n';
+  return `${String(toml || '').trimEnd()}${parent}\n${additions.join('\n\n')}\n`;
+}
+
+function generatedCodexHookTrust(contract, renderers = defaultRenderers) {
+  const home = contract.auth.runtimeHome;
+  if (!home || !renderers.hasHooks(contract.agentConfig)) return '';
+  const hookMap = renderers.toHookMap(contract.agentConfig);
+  const hookFiles = [
+    path.join(home, 'hooks.json'),
+    path.join(home, '.codex', 'hooks.json'),
+  ];
+  const lines = ['[hooks.state]'];
+  for (const hooksPath of hookFiles) {
+    for (const [event, entries] of Object.entries(hookMap)) {
+      for (let index = 0; index < entries.length; index += 1) {
+        lines.push('');
+        lines.push(`[hooks.state.${tomlQuoted(`${hooksPath}:${event}:${index}`)}]`);
+        lines.push('trusted = true');
+      }
+    }
+  }
+  return lines.join('\n');
+}
+
+function generatedMcpSectionNames(contract) {
+  return relayedMcpServers(contract).map((server) => `mcp_servers.${server.name}`);
+}
+
+function buildCodexConfig(contract, existingConfig, syncInfo, renderers = defaultRenderers) {
+  const mcpToml = toCodexMcpToml(contract);
+  const topLevelKeys = [
+    'model_provider',
+    ...(contract.authMethod === 'amalgm' ? ['model_context_window', 'model_auto_compact_token_limit'] : []),
+  ];
+  let config = removeTopLevelKeys(existingConfig, topLevelKeys);
+  config = removeTomlSections(config, [
+    ...(contract.authMethod === 'amalgm' ? ['model_providers.amalgm'] : []),
+    ...generatedMcpSectionNames(contract),
+  ]);
+  if (renderers.hasHooks(contract.agentConfig)) {
+    config = ensureFeatureBoolean(config, 'codex_hooks', true);
+  }
+  const generated = contract.authMethod === 'amalgm'
+    ? [
+        'model_provider = "amalgm"',
+        ...modelWindowConfigLines(contract),
+        '',
+        '[model_providers.amalgm]',
+        'name = "amalgm"',
+        `base_url = "${contract.auth.baseUrl}"`,
+        'env_key = "OPENAI_API_KEY"',
+        'wire_api = "responses"',
+        'requires_openai_auth = false',
+      ].join('\n')
+    : contract.authMethod === 'byok'
+      ? 'model_provider = "openai"'
+      : contract.authMethod === 'provider_auth'
+        ? 'model_provider = "openai"'
+      : '';
+  return [
+    generated.trimEnd(),
+    String(config || '').trim(),
+    generatedCodexHookTrust(contract, renderers).trim(),
+    String(mcpToml || '').trim(),
+  ].filter(Boolean).join('\n\n') + '\n';
+}
+
+function baseNativeConfigForContract(contract, syncInfo) {
+  return readTextFile(syncInfo?.sourceConfigPath);
+}
+
+function writeConfig(contract, syncInfo, renderers = defaultRenderers) {
+  const home = contract.auth.runtimeHome;
+  if (!home) return;
+  fs.mkdirSync(home, { recursive: true });
+  ensureCodexHomeAlias(home);
+  if (syncInfo === undefined) {
+    syncInfo = contract.authMethod === 'provider_auth' ? syncCodexProviderAuth(home) : null;
+  }
+  const nativeConfig = baseNativeConfigForContract(contract, syncInfo);
+  if (renderers.hasHooks(contract.agentConfig)) {
+    writeCodexHomeFile(home, 'hooks.json', renderers.toCodexHooksJson(contract.agentConfig), 0o600);
+  }
+  if (contract.authMethod === 'provider_auth') {
+    writeCodexHomeFile(home, 'config.toml', buildCodexConfig(contract, nativeConfig, syncInfo, renderers), 0o600);
+    return;
+  }
+  writeCodexHomeFile(home, 'config.toml', buildCodexConfig(contract, nativeConfig, syncInfo, renderers), 0o600);
+  writeCodexHomeFile(home, 'auth.json', JSON.stringify({
+    auth_mode: 'apikey',
+    OPENAI_API_KEY: contract.auth.tokenRef,
+  }, null, 2), 0o600, { unlinkSymlink: true });
+}
+
+class CodexAdapter {
+  constructor(options = {}) {
+    this.renderers = { ...defaultRenderers, ...(options.renderers || {}) };
+    this.permissionPort = options.requestPermission || null;
+    this.inputCapabilities = nativeInputCapabilities({
+      authModes: ['platform', 'subscription', 'byok'],
+      modelSettings: [...COMMON_REASONING_SETTINGS, ...COMMON_SPEED_SETTINGS],
+      tools: true,
+    });
+  }
+
+  async create(contract) {
+    const runtime = prepareHarnessRuntime(contract);
+    writeConfig(contract, runtime.syncInfo, this.renderers);
+    const binary = resolveBinary();
+    const client = new JsonLineRpc({ binary, cwd: contract.cwd, env: codexEnv(runtime.env, binary) });
+    await client.request('initialize', { clientInfo: { name: 'amalgm-chat', version: '1.0.0' }, capabilities: { experimentalApi: true } });
+    client.notify('initialized');
+    const fullAccess = contract.permissionMode === 'full_access';
+    const threadOptions = {
+      cwd: contract.cwd,
+      approvalPolicy: fullAccess ? 'never' : 'on-request',
+      sandbox: fullAccess ? 'danger-full-access' : 'workspace-write',
+      modelProvider: contract.authMethod === 'amalgm' ? 'amalgm' : 'openai',
+      serviceTier: serviceTierForContract(contract),
+      developerInstructions: composeSystemPrompt(contract) || null,
+      persistExtendedHistory: true,
+    };
+    const session = {
+      sessionId: contract.sessionId,
+      providerSessionId: contract.providerSessionId || null,
+      client,
+      permissionMode: contract.permissionMode,
+      activeTurnId: null,
+      activeTurnHadAssistant: false,
+      cancelCurrentTurn: null,
+      cancelRequested: false,
+    };
+    client.onRequest((method, params) => this.handleServerRequest(session, method, params));
+    const thread = contract.providerSessionId
+      ? await client.request('thread/resume', {
+          threadId: contract.providerSessionId,
+          ...threadOptions,
+          excludeTurns: true,
+        })
+      : await client.request('thread/start', threadOptions);
+    session.providerSessionId = thread.thread.id;
+    return session;
+  }
+
+  async handleServerRequest(session, method, params) {
+    const permissionMethods = new Set([
+      'item/commandExecution/requestApproval',
+      'item/fileChange/requestApproval',
+      'item/permissions/requestApproval',
+      'execCommandApproval',
+      'applyPatchApproval',
+    ]);
+    if (!permissionMethods.has(method)) throw new Error(`Method not supported: ${method}`);
+    const decision = session.permissionMode === 'full_access'
+      ? { outcome: 'allow_always' }
+      : await requestPermission(this.permissionPort, {
+          adapterId: 'codex',
+          providerSessionId: session.providerSessionId,
+          kind: method.includes('fileChange') || method === 'applyPatchApproval' ? 'file_change' : 'command',
+          title: params.reason || params.command || 'Codex requests permission',
+          input: params,
+        });
+    const allow = decision.outcome === 'allow_once' || decision.outcome === 'allow_always';
+    const always = decision.outcome === 'allow_always';
+    if (method === 'item/commandExecution/requestApproval') {
+      return { decision: allow ? (always ? 'acceptForSession' : 'accept') : decision.outcome === 'cancel' ? 'cancel' : 'decline' };
+    }
+    if (method === 'item/fileChange/requestApproval') {
+      return { decision: allow ? (always ? 'acceptForSession' : 'accept') : decision.outcome === 'cancel' ? 'cancel' : 'decline' };
+    }
+    if (method === 'item/permissions/requestApproval') {
+      return {
+        permissions: allow
+          ? {
+              ...(params.permissions?.network ? { network: params.permissions.network } : {}),
+              ...(params.permissions?.fileSystem ? { fileSystem: params.permissions.fileSystem } : {}),
+            }
+          : {},
+        scope: always ? 'session' : 'turn',
+      };
+    }
+    return {
+      decision: allow
+        ? (always ? 'approved_for_session' : 'approved')
+        : decision.outcome === 'cancel'
+          ? 'abort'
+          : { denied: { rejection: 'Denied by the user' } },
+    };
+  }
+
+  async resume(session) { return session; }
+
+  async stop(session) {
+    session.cancelRequested = true;
+    try { session.cancelCurrentTurn?.(); } catch {}
+    if (!session.activeTurnId) return;
+    await session.client.request('turn/interrupt', { threadId: session.providerSessionId, turnId: session.activeTurnId }).catch(() => {});
+  }
+
+  async destroy(session) { session.client.close(); }
+
+  async *prompt(session, input, contract) {
+    const queue = [];
+    let complete = false;
+    let compactCompletionTimer = null;
+    let wake = null;
+    const wakeLoop = () => { if (wake) { wake(); wake = null; } };
+    const push = (e) => { queue.push(e); wakeLoop(); };
+    session.cancelRequested = false;
+    session.cancelCurrentTurn = () => {
+      if (complete) return;
+      complete = true;
+      push(done({ providerSessionId: session.providerSessionId, stopReason: 'cancelled' }));
+    };
+    const off = session.client.on((msg) => {
+      const p = msg.params || {};
+      if (p.threadId && p.threadId !== session.providerSessionId) return;
+      recordNativeEvent('codex.app-server.notification', msg, {
+        providerSessionId: session.providerSessionId,
+        sessionId: contract.sessionId,
+        assistantMessageId: contract.assistantMessageId,
+        method: msg.method,
+      });
+      if (msg.method === 'turn/started' && p.turn?.id) {
+        session.activeTurnId = p.turn.id;
+        session.activeTurnHadAssistant = false;
+      }
+      if (p.turnId && !session.activeTurnId && msg.method !== 'turn/started') return;
+      if (p.turnId && session.activeTurnId && p.turnId !== session.activeTurnId) return;
+      if (msg.method === 'item/started' && ['agentMessage', 'reasoning', 'commandExecution', 'contextCompaction'].includes(p.item?.type)) {
+        session.activeTurnHadAssistant = true;
+      }
+      if (msg.method === 'thread/tokenUsage/updated' && !session.activeTurnHadAssistant) return;
+      for (const e of normalizeCodexNotification(msg, session.providerSessionId, session)) {
+        if (session.cancelRequested && e.type === 'done') e.stopReason = 'cancelled';
+        if (e.type === 'done' || e.type === 'error') complete = true;
+        push(e);
+      }
+      if (compactCommand && msg.method === 'item/completed' && p.item?.type === 'contextCompaction') {
+        if (compactCompletionTimer) clearTimeout(compactCompletionTimer);
+        compactCompletionTimer = setTimeout(() => {
+          push(done({ providerSessionId: session.providerSessionId, stopReason: 'end_turn' }));
+          complete = true;
+          wakeLoop();
+        }, 500);
+      }
+    });
+    session.activeTurnId = null;
+    session.activeTurnHadAssistant = false;
+    const nativeInput = codexPromptInput(input);
+    const compactCommand = nativeInput.length === 1
+      && nativeInput[0].type === 'text'
+      && isCompactCommand(nativeInput[0].text);
+    const startRequest = compactCommand
+      ? session.client.request('thread/compact/start', { threadId: session.providerSessionId })
+      : session.client.request('turn/start', {
+          threadId: session.providerSessionId,
+          input: nativeInput,
+          cwd: contract.cwd,
+          model: contract.cliModel.replace(/\/(?:low|medium|high|xhigh|max|ultra)$/i, ''),
+          effort: contract.reasoningEffort || undefined,
+          serviceTier: serviceTierForContract(contract),
+          approvalPolicy: contract.permissionMode === 'full_access' ? 'never' : 'on-request',
+        });
+    startRequest.then((result) => {
+      if (compactCommand) return;
+      session.activeTurnId = result?.turn?.id || session.activeTurnId;
+      const resultError = result?.error || result?.turn?.error || result?.turn?.lastError;
+      if (!resultError) return;
+      push(errorEvent(codexErrorMessage(resultError), { providerSessionId: session.providerSessionId }));
+      push(done({ providerSessionId: session.providerSessionId, stopReason: 'error' }));
+      complete = true;
+    }).catch((err) => {
+      if (session.cancelRequested) {
+        push(done({ providerSessionId: session.providerSessionId, stopReason: 'cancelled' }));
+        complete = true;
+        return;
+      }
+      push(errorEvent(err.message, { providerSessionId: session.providerSessionId }));
+      push(done({ providerSessionId: session.providerSessionId, stopReason: 'error' }));
+      complete = true;
+    });
+    try {
+      while (!complete || queue.length) {
+        if (!queue.length) await new Promise((resolve) => { wake = resolve; });
+        else yield queue.shift();
+      }
+    } finally {
+      if (compactCompletionTimer) clearTimeout(compactCompletionTimer);
+      off();
+      session.cancelCurrentTurn = null;
+      session.cancelRequested = false;
+    }
+  }
+}
+
+const __private = {
+  buildCodexConfig,
+  ensureFeatureBoolean,
+  hookTrustToml,
+  mirrorCodexHookTrust,
+  modelWindowConfigLines,
+  removeTomlSections,
+  removeTopLevelKeys,
+  serviceTierForContract,
+  writeConfig,
+};
+
+export { CodexAdapter, __private };