smol-symphony 0.1.0 → 0.2.0

package/scripts/vm-agent.mjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+// symphony-vm-agent — in-guest proxy that runs the ACP adapter and bridges its stdio
+// to a TCP socket dialed back to the host orchestrator.
+//
+// Why TCP and not stdio: the previous version of this proxy bridged the in-VM adapter's
+// stdio to the VM-exec stdio channel directly. That channel has a stdin-pump bug
+// that wedges the adapter after the SDK's first `available_commands_update` notification
+// (the in-guest reader never wakes for subsequent kernel events unless host stdin keeps
+// writing). We worked around it for a while with a 1.5 s `\n` keepalive on the host
+// side, but the proper fix is to stop piping ACP through the VM-exec stdio at all. This proxy
+// dials back to a TCP listener on the host (`SYMPHONY_ACP_URL`), authenticates with a
+// per-dispatch bearer token (`SYMPHONY_ACP_TOKEN`), and from then on talks ACP over a
+// plain socket the host owns. the VM exec is reduced to a launcher: its stdio just
+// carries this proxy's own diagnostic stderr and the adapter's stderr (`inherit`'d).
+//
+// The same proxy works under any sandbox tech that can launch a process with env vars
+// and reach the host loopback — that's the portability win.
+//
+// Configuration (all required unless noted):
+//   SYMPHONY_ACP_URL          — `tcp://host:port` to dial. `127.0.0.1:8788` under the Gondolin bridge mapping
+//                               since the guest loopback is rewritten to the host
+//                               loopback.
+//   SYMPHONY_ACP_TOKEN        — opaque per-dispatch bearer; sent as `Bearer <token>\n`
+//                               first line.
+//   SYMPHONY_ADAPTER_BIN      — adapter executable to spawn (PATH-resolved).
+//   SYMPHONY_ADAPTER_ARGS     — JSON array of extra argv. Optional; defaults to `[]`.
+//   SYMPHONY_VM_AGENT_DEBUG   — optional; truthy → log lifecycle to stderr.
+//
+// Exit code: mirrors the adapter's exit when it exits, or 1 if the connection fails
+// before the adapter starts.
+
+import { connect as netConnect } from 'node:net';
+import { spawn } from 'node:child_process';
+import { constants as osConstants } from 'node:os';
+import { URL } from 'node:url';
+
+const requiredEnv = (name) => {
+  const v = process.env[name];
+  if (!v) {
+    process.stderr.write(`symphony-vm-agent: ${name} is not set\n`);
+    process.exit(2);
+  }
+  return v;
+};
+
+const acpUrl = requiredEnv('SYMPHONY_ACP_URL');
+const acpToken = requiredEnv('SYMPHONY_ACP_TOKEN');
+const adapterBin = requiredEnv('SYMPHONY_ADAPTER_BIN');
+
+let adapterArgs = [];
+const rawArgs = process.env.SYMPHONY_ADAPTER_ARGS;
+if (rawArgs && rawArgs.length > 0) {
+  try {
+    const parsed = JSON.parse(rawArgs);
+    if (!Array.isArray(parsed) || !parsed.every((a) => typeof a === 'string')) {
+      throw new Error('must be a JSON array of strings');
+    }
+    adapterArgs = parsed;
+  } catch (err) {
+    process.stderr.write(`symphony-vm-agent: SYMPHONY_ADAPTER_ARGS invalid: ${err.message}\n`);
+    process.exit(2);
+  }
+}
+
+const debug = !!process.env.SYMPHONY_VM_AGENT_DEBUG;
+const log = (msg) => {
+  if (debug) process.stderr.write(`symphony-vm-agent: ${msg}\n`);
+};
+
+let parsed;
+try {
+  parsed = new URL(acpUrl);
+} catch (err) {
+  process.stderr.write(`symphony-vm-agent: SYMPHONY_ACP_URL invalid: ${err.message}\n`);
+  process.exit(2);
+}
+if (parsed.protocol !== 'tcp:') {
+  process.stderr.write(
+    `symphony-vm-agent: SYMPHONY_ACP_URL must use tcp:// scheme (got ${parsed.protocol})\n`,
+  );
+  process.exit(2);
+}
+const acpHost = parsed.hostname;
+const acpPort = parseInt(parsed.port, 10);
+if (!Number.isFinite(acpPort) || acpPort <= 0) {
+  process.stderr.write(`symphony-vm-agent: SYMPHONY_ACP_URL has no port\n`);
+  process.exit(2);
+}
+
+log(`dialing ${acpHost}:${acpPort}`);
+
+const socket = netConnect({ host: acpHost, port: acpPort, allowHalfOpen: false });
+socket.setNoDelay(true);
+
+// Pre-connect error handler: a TCP-level failure here means we couldn't reach the host
+// bridge at all. Exit hard so symphony's host-side bridge-connect-timeout fires its own
+// error path. We REMOVE this listener once `connect` fires; otherwise it would also kick
+// in for post-auth errors and bypass startBridge()'s graceful adapter teardown.
+const onPreConnectError = (err) => {
+  process.stderr.write(`symphony-vm-agent: socket error: ${err.message}\n`);
+  process.exit(1);
+};
+socket.once('error', onPreConnectError);
+
+socket.once('connect', () => {
+  socket.off('error', onPreConnectError);
+  log('connected; sending bearer line');
+  // The bearer line MUST end with a bare \n; the host expects exactly that delimiter.
+  socket.write(`Bearer ${acpToken}\n`);
+  startBridge();
+});
+
+function startBridge() {
+  log(`spawn ${adapterBin} ${JSON.stringify(adapterArgs)}`);
+  const child = spawn(adapterBin, adapterArgs, {
+    // Adapter stdio: kernel pipes we fully own. Adapter stderr is inherited so any
+    // crashes / warnings show up on this proxy's stderr → VM-exec stderr → host
+    // orchestrator stderr capture. ACP frames flow ONLY over the TCP socket.
+    stdio: ['pipe', 'pipe', 'inherit'],
+  });
+  // Bridge socket ↔ adapter stdio with explicit `data` handlers + `write()` (NOT
+  // stream.pipe()): we observed during the bisect that pipe() can interact badly with
+  // certain transport quirks, so we forward bytes synchronously and let the kernel pipe
+  // buffer absorb any short-term mismatch. With a clean TCP socket this is moot but
+  // costs nothing and keeps the pattern uniform.
+  socket.on('data', (chunk) => {
+    try {
+      child.stdin.write(chunk);
+    } catch {
+      /* adapter stdin closed while we were writing — see exit handler */
+    }
+  });
+  child.stdout.on('data', (chunk) => {
+    try {
+      socket.write(chunk);
+    } catch {
+      /* host socket closed while we were writing — see exit handlers */
+    }
+  });
+  // Half-closes: when the host closes its write side, the adapter should see stdin EOF;
+  // when the adapter closes stdout, the host should see socket-half-close.
+  socket.on('end', () => {
+    log('host closed socket; ending adapter stdin');
+    try {
+      child.stdin.end();
+    } catch {
+      /* ignore */
+    }
+  });
+  child.stdout.on('end', () => {
+    log('adapter closed stdout; ending socket write side');
+    try {
+      socket.end();
+    } catch {
+      /* ignore */
+    }
+  });
+  child.stdin.on('error', (err) => {
+    if (err.code !== 'EPIPE') log(`adapter stdin error: ${err.message}`);
+  });
+  socket.on('error', (err) => {
+    log(`socket error after auth: ${err.message}`);
+    try {
+      child.kill('SIGTERM');
+    } catch {
+      /* ignore */
+    }
+  });
+  child.on('error', (err) => {
+    process.stderr.write(`symphony-vm-agent: failed to spawn adapter: ${err.message}\n`);
+    try {
+      socket.end();
+    } catch {
+      /* ignore */
+    }
+    process.exit(127);
+  });
+  // Use `close` not `exit`: `exit` fires when the adapter process terminates but its
+  // stdio pipes may still have buffered bytes our `data` handlers haven't drained yet.
+  // `close` fires only after all stdio streams have been closed AND drained, so by then
+  // every byte the adapter wrote has been forwarded to our socket.write() above. We
+  // still need to wait for the socket itself to flush those forwarded bytes to the
+  // kernel before exiting, hence the `socket.end(callback)` pattern: end() signals
+  // shutdown and the callback fires after the write buffer has drained.
+  child.on('close', (code, signal) => {
+    log(`adapter close code=${code} signal=${signal}`);
+    const finalize = () => {
+      if (signal) {
+        const sig = osConstants.signals[signal] ?? 0;
+        process.exit(128 + sig);
+      }
+      process.exit(code ?? 0);
+    };
+    try {
+      socket.end(finalize);
+    } catch {
+      finalize();
+    }
+  });
+  // Forward host-side termination signals to the adapter.
+  for (const sig of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
+    process.on(sig, () => {
+      log(`received ${sig}; forwarding to adapter`);
+      try {
+        child.kill(sig);
+      } catch {
+        /* ignore */
+      }
+    });
+  }
+}

package/dist/agent/codex.js

@@ -1,439 +0,0 @@
-// JSON-RPC client for the Codex app-server protocol (SPEC §10).
-//
-// Transport: newline-delimited JSON over stdio. Each line is a JSON object that is either
-// a request, a response, or a notification, as defined by the Codex protocol.
-//
-// This client takes a pre-existing stdio pair (e.g. the streams of a smolvm exec session)
-// and drives the §10 lifecycle: initialize → thread/start → turn/start → process notifications
-// until turn/completed. Approval requests are answered according to the documented high-trust
-// posture (auto-approve). User-input-required, unsupported dynamic tools, and signal exits are
-// surfaced as failures so a run never stalls (§10.5).
-import { log } from '../logging.js';
-export class CodexProtocolError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'CodexProtocolError';
-    }
-}
-function nowIso() {
-    return new Date().toISOString();
-}
-function summarize(raw, max = 240) {
-    let s;
-    try {
-        s = typeof raw === 'string' ? raw : JSON.stringify(raw);
-    }
-    catch {
-        s = String(raw);
-    }
-    if (s.length > max)
-        s = s.slice(0, max) + '…';
-    return s;
-}
-// Extract absolute token totals from a `thread/tokenUsage/updated` notification.
-//
-// The current Codex protocol nests totals under `tokenUsage.total.{inputTokens, outputTokens,
-// totalTokens}` (see ThreadTokenUsageUpdatedNotification schema). We deliberately prefer the
-// `total` breakdown over `last` so accumulation matches §13.5: "prefer absolute thread totals".
-// Older payload shapes (`total_token_usage`, flat `usage`) are accepted as a fallback.
-function extractTokenTotals(params) {
-    if (!params || typeof params !== 'object' || Array.isArray(params))
-        return null;
-    const obj = params;
-    const candidates = [];
-    const tokenUsage = obj['tokenUsage'];
-    if (tokenUsage && typeof tokenUsage === 'object' && !Array.isArray(tokenUsage)) {
-        const totalBreakdown = tokenUsage['total'];
-        if (totalBreakdown && typeof totalBreakdown === 'object' && !Array.isArray(totalBreakdown)) {
-            candidates.push(totalBreakdown);
-        }
-    }
-    const totalTokenUsage = obj['total_token_usage'];
-    if (totalTokenUsage && typeof totalTokenUsage === 'object' && !Array.isArray(totalTokenUsage)) {
-        candidates.push(totalTokenUsage);
-    }
-    const usage = obj['usage'];
-    if (usage && typeof usage === 'object' && !Array.isArray(usage)) {
-        candidates.push(usage);
-    }
-    candidates.push(obj);
-    for (const c of candidates) {
-        const inRaw = c['input_tokens'] ?? c['inputTokens'];
-        const outRaw = c['output_tokens'] ?? c['outputTokens'];
-        const totRaw = c['total_tokens'] ?? c['totalTokens'];
-        if (inRaw === undefined && outRaw === undefined && totRaw === undefined)
-            continue;
-        const inN = Number(inRaw ?? 0);
-        const outN = Number(outRaw ?? 0);
-        const totN = Number(totRaw ?? inN + outN);
-        if (Number.isFinite(totN)) {
-            return { input: inN, output: outN, total: totN };
-        }
-    }
-    return null;
-}
-export class CodexClient {
-    opts;
-    nextId = 1;
-    pending = new Map();
-    notificationHandlers = new Map();
-    serverRequestHandlers = new Map();
-    buffer = '';
-    closed = false;
-    threadId = null;
-    turnWaiter = null;
-    turnTimer = null;
-    currentTurnId = null;
-    constructor(opts) {
-        this.opts = opts;
-        this.opts.stdout.setEncoding('utf8');
-        this.opts.stdout.on('data', (chunk) => this.onData(chunk));
-        this.opts.stdout.on('close', () => this.handleTransportClose('stdout_closed'));
-        this.opts.stdout.on('error', (e) => this.handleTransportClose(`stdout_error:${e.message}`));
-        this.opts.stdin.on('error', () => {
-            /* ignore: pipe errors surface via close */
-        });
-        this.installDefaultHandlers();
-    }
-    onData(chunk) {
-        this.buffer += chunk;
-        let nl;
-        while ((nl = this.buffer.indexOf('\n')) >= 0) {
-            const line = this.buffer.slice(0, nl).trim();
-            this.buffer = this.buffer.slice(nl + 1);
-            if (line.length === 0)
-                continue;
-            let msg;
-            try {
-                msg = JSON.parse(line);
-            }
-            catch (err) {
-                this.emitRuntime('malformed', `cannot parse: ${err.message}: ${summarize(line)}`);
-                continue;
-            }
-            this.dispatch(msg);
-        }
-    }
-    dispatch(msg) {
-        // Response to one of our requests.
-        if (msg && 'id' in msg && msg.id !== undefined && (!('method' in msg) || msg.method === undefined)) {
-            const id = msg.id;
-            const pending = this.pending.get(id);
-            if (!pending) {
-                this.emitRuntime('other_message', `unmatched response id=${id}`);
-                return;
-            }
-            this.pending.delete(id);
-            clearTimeout(pending.timer);
-            const asResp = msg;
-            if (asResp.error) {
-                pending.reject(new CodexProtocolError('response_error', asResp.error.message));
-            }
-            else {
-                pending.resolve((asResp.result ?? null));
-            }
-            return;
-        }
-        // Server request — needs response (e.g. approvals, dynamic tools).
-        if (msg && 'method' in msg && 'id' in msg && msg.id !== undefined) {
-            const method = msg.method;
-            const params = (msg.params ?? null);
-            const handler = this.serverRequestHandlers.get(method);
-            void this.respondToServerRequest(msg.id, method, params, handler);
-            return;
-        }
-        // Notification.
-        if (msg && 'method' in msg && msg.method) {
-            const method = msg.method;
-            const params = (msg.params ?? null);
-            const handler = this.notificationHandlers.get(method);
-            if (handler)
-                handler(params);
-            else
-                this.emitRuntime('notification', `${method} ${summarize(params)}`);
-            return;
-        }
-        this.emitRuntime('other_message', summarize(msg));
-    }
-    async respondToServerRequest(id, method, params, handler) {
-        try {
-            let result;
-            if (handler) {
-                result = await handler(params);
-            }
-            else {
-                // Unsupported server request: respond with structured error so the session doesn't
-                // stall (§10.5 — unsupported dynamic tool calls).
-                result = { error: { code: 'unsupported', message: `unsupported method ${method}` } };
-                this.emitRuntime('unsupported_tool_call', `${method} ${summarize(params)}`);
-            }
-            this.writeMessage({ jsonrpc: '2.0', id, result });
-        }
-        catch (err) {
-            this.writeMessage({
-                jsonrpc: '2.0',
-                id,
-                error: { code: -32000, message: err.message },
-            });
-        }
-    }
-    installDefaultHandlers() {
-        // Approvals — auto-approve under the documented high-trust posture.
-        //
-        // Method names and decision values come from the Codex v2 protocol:
-        //   - item/commandExecution/requestApproval → CommandExecutionApprovalDecision
-        //   - item/fileChange/requestApproval       → FileChangeApprovalDecision
-        //   - item/permissions/requestApproval      → PermissionsRequestApprovalDecision
-        // All three accept "acceptForSession" so future prompts for the same scope auto-pass.
-        const autoApproveSession = async (params) => {
-            this.emitRuntime('approval_auto_approved', summarize(params));
-            return { decision: 'acceptForSession' };
-        };
-        this.serverRequestHandlers.set('item/commandExecution/requestApproval', autoApproveSession);
-        this.serverRequestHandlers.set('item/fileChange/requestApproval', autoApproveSession);
-        this.serverRequestHandlers.set('item/permissions/requestApproval', autoApproveSession);
-        // Legacy v1 request names retained for transitional compatibility.
-        this.serverRequestHandlers.set('execCommandApproval', autoApproveSession);
-        this.serverRequestHandlers.set('applyPatchApproval', autoApproveSession);
-        this.serverRequestHandlers.set('fileChangeRequestApproval', autoApproveSession);
-        this.serverRequestHandlers.set('commandExecutionRequestApproval', autoApproveSession);
-        this.serverRequestHandlers.set('permissionsRequestApproval', autoApproveSession);
-        this.serverRequestHandlers.set('mcpServer/elicitation/request', autoApproveSession);
-        // User-input requests fail the run instead of stalling (§10.5).
-        this.serverRequestHandlers.set('item/tool/requestUserInput', async (params) => {
-            this.emitRuntime('turn_input_required', summarize(params));
-            this.completeTurn({
-                turnId: this.currentTurnId ?? '',
-                reason: 'turn_input_required',
-                message: summarize(params),
-            });
-            return { decision: 'reject', reason: 'user input not supported' };
-        });
-        // Dynamic tool calls — reject unsupported tools without stalling (§10.5).
-        this.serverRequestHandlers.set('item/tool/call', async (params) => {
-            const supported = new Set(this.opts.supportedTools ?? []);
-            const toolName = params && typeof params === 'object' && !Array.isArray(params)
-                ? params['name']
-                : null;
-            if (typeof toolName === 'string' && supported.has(toolName)) {
-                // The runtime advertised it but has no in-process implementation yet — still fail
-                // gracefully rather than throw. Implementations override this handler to do real work.
-                return { isError: true, content: [{ type: 'text', text: `tool ${toolName} not implemented` }] };
-            }
-            this.emitRuntime('unsupported_tool_call', summarize(params));
-            return { isError: true, content: [{ type: 'text', text: `unsupported tool: ${toolName ?? '?'}` }] };
-        });
-        // Notifications — extract observability signal.
-        //
-        // Schema notes (Codex v2):
-        //   thread/started.params = { thread: { id, ... } }      — id nested under thread
-        //   turn/started.params   = { threadId, turn: { id, status, ... } }
-        //   turn/completed.params = { threadId, turn: { id, status: "completed"|"failed"|... } }
-        // The turn/completed notification fires for every terminal status. We must look at
-        // turn.status to know whether the turn truly succeeded.
-        const idOfThread = (params) => {
-            if (params && typeof params === 'object' && !Array.isArray(params)) {
-                const thread = params['thread'];
-                if (thread && typeof thread === 'object' && !Array.isArray(thread)) {
-                    const id = thread['id'];
-                    if (typeof id === 'string')
-                        return id;
-                }
-            }
-            return null;
-        };
-        const turnFromParams = (params) => {
-            if (params && typeof params === 'object' && !Array.isArray(params)) {
-                const turn = params['turn'];
-                if (turn && typeof turn === 'object' && !Array.isArray(turn)) {
-                    return turn;
-                }
-            }
-            return null;
-        };
-        this.notificationHandlers.set('thread/started', (params) => {
-            const tid = idOfThread(params);
-            if (tid)
-                this.threadId = tid;
-            this.emitRuntime('session_started', summarize(params));
-        });
-        this.notificationHandlers.set('turn/started', (params) => {
-            const turn = turnFromParams(params);
-            const tid = turn ? turn['id'] : null;
-            if (typeof tid === 'string')
-                this.currentTurnId = tid;
-            this.emitRuntime('turn_started', summarize(params));
-        });
-        this.notificationHandlers.set('turn/completed', (params) => {
-            const turn = turnFromParams(params);
-            const status = typeof turn?.['status'] === 'string' ? turn['status'] : 'completed';
-            const turnId = typeof turn?.['id'] === 'string' ? turn['id'] : this.currentTurnId ?? '';
-            if (status === 'completed') {
-                this.emitRuntime('turn_completed', summarize(params));
-                this.completeTurn({ turnId, reason: 'turn_completed', message: summarize(params) });
-            }
-            else if (status === 'interrupted') {
-                this.emitRuntime('turn_cancelled', summarize(params));
-                this.completeTurn({ turnId, reason: 'turn_cancelled', message: summarize(params) });
-            }
-            else {
-                // failed or any other non-completed terminal status
-                this.emitRuntime('turn_failed', summarize(params));
-                this.completeTurn({ turnId, reason: 'turn_failed', message: summarize(params) });
-            }
-        });
-        this.notificationHandlers.set('thread/tokenUsage/updated', (params) => {
-            const totals = extractTokenTotals(params);
-            if (totals) {
-                this.opts.onTokenUsage({
-                    input_tokens: totals.input,
-                    output_tokens: totals.output,
-                    total_tokens: totals.total,
-                });
-            }
-            this.emitRuntime('thread_tokenUsage_updated', summarize(params));
-        });
-        this.notificationHandlers.set('account/rateLimits/updated', (params) => {
-            this.opts.onRateLimits(params);
-            this.emitRuntime('account_rateLimits_updated', summarize(params));
-        });
-        this.notificationHandlers.set('error', (params) => {
-            this.emitRuntime('error_notification', summarize(params));
-        });
-    }
-    handleTransportClose(reason) {
-        if (this.closed)
-            return;
-        this.closed = true;
-        const err = new CodexProtocolError('port_exit', reason);
-        for (const [, p] of this.pending) {
-            clearTimeout(p.timer);
-            p.reject(err);
-        }
-        this.pending.clear();
-        if (this.turnWaiter) {
-            const w = this.turnWaiter;
-            this.turnWaiter = null;
-            if (this.turnTimer) {
-                clearTimeout(this.turnTimer);
-                this.turnTimer = null;
-            }
-            w.resolve({
-                turnId: this.currentTurnId ?? '',
-                reason: 'subprocess_exit',
-                message: reason,
-            });
-        }
-    }
-    emitRuntime(event, message, raw) {
-        this.opts.onEvent({ at: nowIso(), event, message }, raw);
-    }
-    writeMessage(msg) {
-        if (this.closed)
-            return;
-        try {
-            this.opts.stdin.write(JSON.stringify(msg) + '\n');
-        }
-        catch (err) {
-            log.warn('codex write failed', { error: err.message });
-        }
-    }
-    async request(method, params) {
-        const id = this.nextId++;
-        const promise = new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                if (this.pending.has(id)) {
-                    this.pending.delete(id);
-                    reject(new CodexProtocolError('response_timeout', `request ${method} timed out`));
-                }
-            }, this.opts.readTimeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
-        });
-        this.writeMessage({ jsonrpc: '2.0', id, method, params });
-        return (await promise);
-    }
-    async initialize(params) {
-        return this.request('initialize', params);
-    }
-    async startThread(params) {
-        const result = await this.request('thread/start', params);
-        // Codex v2 ThreadStartResponse nests the id under `thread.id`.
-        if (result && typeof result === 'object' && !Array.isArray(result)) {
-            const thread = result['thread'];
-            if (thread && typeof thread === 'object' && !Array.isArray(thread)) {
-                const id = thread['id'];
-                if (typeof id === 'string') {
-                    this.threadId = id;
-                    return id;
-                }
-            }
-            // Legacy v1 shape: `{ threadId: "..." }`
-            const legacy = result['threadId'];
-            if (typeof legacy === 'string') {
-                this.threadId = legacy;
-                return legacy;
-            }
-        }
-        throw new CodexProtocolError('response_error', 'thread/start did not return a thread id');
-    }
-    // Send turn/start and resolve when one of the turn-terminating notifications fires (or the
-    // subprocess exits, or the turn timeout elapses).
-    async runTurn(params) {
-        if (this.turnWaiter) {
-            throw new CodexProtocolError('turn_in_progress', 'another turn is already in flight');
-        }
-        const result = new Promise((resolve, reject) => {
-            this.turnWaiter = { resolve, reject };
-            this.turnTimer = setTimeout(() => {
-                if (this.turnWaiter) {
-                    const w = this.turnWaiter;
-                    this.turnWaiter = null;
-                    w.resolve({
-                        turnId: this.currentTurnId ?? '',
-                        reason: 'turn_timeout',
-                        message: `turn exceeded ${this.opts.turnTimeoutMs}ms`,
-                    });
-                }
-            }, this.opts.turnTimeoutMs);
-        });
-        // Fire-and-forget: server will signal completion via a notification.
-        try {
-            await this.request('turn/start', params);
-        }
-        catch (err) {
-            this.completeTurn({
-                turnId: this.currentTurnId ?? '',
-                reason: 'turn_failed',
-                message: err.message,
-            });
-        }
-        return result;
-    }
-    completeTurn(r) {
-        if (!this.turnWaiter)
-            return;
-        const w = this.turnWaiter;
-        this.turnWaiter = null;
-        if (this.turnTimer) {
-            clearTimeout(this.turnTimer);
-            this.turnTimer = null;
-        }
-        w.resolve(r);
-    }
-    async interrupt() {
-        if (!this.threadId)
-            return;
-        try {
-            await this.request('turn/interrupt', { threadId: this.threadId });
-        }
-        catch (err) {
-            log.debug('turn/interrupt failed', { error: err.message });
-        }
-    }
-    get currentThreadId() {
-        return this.threadId;
-    }
-}
-//# sourceMappingURL=codex.js.map