@canonmsg/codex-plugin 0.29.4 → 0.31.0

package/dist/attached-session-adapter.js

@@ -0,0 +1,769 @@
+import { createRequire } from 'node:module';
+import { mapCodexAppServerApprovalRequest, mapCanonApprovalResultToCodexDecision } from './app-server-approval.js';
+export class CodexAttachedSessionError extends Error {
+    submissionUncertain;
+    constructor(message, submissionUncertain = false) {
+        super(message);
+        this.submissionUncertain = submissionUncertain;
+        this.name = 'CodexAttachedSessionError';
+    }
+}
+export class CodexSharedRpcError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'CodexAttachedSessionRpcError';
+    }
+}
+/** Explicit local endpoints only. Never discover or fall back to a private runner. */
+export function validateAttachedSessionEndpoint(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error('Specify a loopback WebSocket endpoint for the shared Codex server.');
+    }
+    if (url.protocol !== 'ws:'
+        || !['127.0.0.1', '[::1]'].includes(url.hostname)
+        || !url.port
+        || url.username || url.password || url.search || url.hash) {
+        throw new Error('The shared Codex endpoint must use ws://127.0.0.1:PORT or ws://[::1]:PORT without credentials, query, or fragment.');
+    }
+    return url.toString();
+}
+function createSocket(endpoint, timeoutMs) {
+    const WebSocket = createRequire(import.meta.url)('ws');
+    return new WebSocket(endpoint, {
+        handshakeTimeout: timeoutMs,
+        followRedirects: false,
+        perMessageDeflate: false,
+        maxPayload: 8 * 1024 * 1024,
+    });
+}
+function requireStableItemProtocol(result) {
+    const userAgent = string(object(result)?.userAgent);
+    // Codex uses the first client's originator as the product name, including
+    // our own client name on a fresh server. The following version is Codex's.
+    const match = userAgent?.match(/^[^\s/][^/\r\n]*\/(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?(?:\s|$)/);
+    // 0.147 rebuilds snapshot item IDs, unlike the tested 0.154 protocol. Numeric
+    // comparison also admits the bundled 0.154.0-alpha.6.2 build used by the smoke.
+    const supported = match && (Number(match[1]) > 0 || Number(match[2]) >= 154);
+    if (!supported) {
+        const detected = match ? `Detected ${match[1]}.${match[2]}.${match[3]}. ` : 'The server version could not be verified. ';
+        throw new CodexAttachedSessionError(`${detected}Canon attachment requires Codex 0.154.0 or newer with stable transcript item IDs. Upgrade the shared server before attaching.`);
+    }
+}
+export class CodexSharedConnection {
+    options;
+    shared;
+    endpoint;
+    timeoutMs;
+    pending = new Map();
+    socket = null;
+    connecting = null;
+    rejectOpen = null;
+    sequence = 0;
+    closed = false;
+    fault = null;
+    observers = new Set();
+    createdThreads = new Map();
+    pendingNativeRequests = new Map();
+    constructor(options, shared) {
+        this.options = options;
+        this.shared = shared;
+        this.endpoint = validateAttachedSessionEndpoint(options.endpoint);
+        this.timeoutMs = options.requestTimeoutMs ?? 10_000;
+        if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
+            throw new Error('requestTimeoutMs must be a positive finite number.');
+        }
+        shared?.observers.add(this);
+    }
+    async connect() {
+        this.assertAvailable();
+        if (this.shared) {
+            await this.shared.connect();
+            this.assertAvailable();
+            return;
+        }
+        this.connecting ??= this.open();
+        await this.connecting;
+        this.assertAvailable();
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.shared) {
+            this.shared.observers.delete(this);
+            return;
+        }
+        this.rejectAll('Canon disconnected from the shared Codex server.');
+        this.rejectOpen?.(new CodexAttachedSessionError('Canon observer closed during connection.'));
+        const socket = this.socket;
+        this.socket = null;
+        if (!socket || socket.readyState === 3)
+            return;
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => { socket.terminate(); resolve(); }, Math.min(this.timeoutMs, 1_000));
+            socket.on('close', () => { clearTimeout(timer); resolve(); });
+            // Closing this connection removes its subscriptions. No native interrupt,
+            // archive, process signal, or shared-daemon shutdown is sent.
+            if (socket.readyState === 0)
+                socket.terminate();
+            else
+                socket.close(1000, 'Canon observer closed');
+        });
+    }
+    async open() {
+        try {
+            const socket = (this.options.createSocket ?? createSocket)(this.endpoint, this.timeoutMs);
+            this.socket = socket;
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => this.fail(new Error('Shared Codex connection timed out.')), this.timeoutMs);
+                this.rejectOpen = (error) => { clearTimeout(timer); reject(error); };
+                socket.on('message', (data) => this.handleMessage(data));
+                socket.on('error', (error) => this.fail(error));
+                socket.on('close', () => this.fail(new Error('Shared Codex connection closed.')));
+                socket.on('open', () => { clearTimeout(timer); this.rejectOpen = null; resolve(); });
+            });
+            this.assertAvailable();
+            const initialization = await this.request('initialize', {
+                clientInfo: { name: 'canon-attached-session', version: '0.0.0' },
+                capabilities: { experimentalApi: true },
+            });
+            requireStableItemProtocol(initialization);
+            this.write({ method: 'initialized' });
+        }
+        catch (error) {
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    assertAvailable() {
+        if (this.closed)
+            throw new CodexAttachedSessionError('The Canon observer is closed.');
+        if (this.fault)
+            throw new CodexAttachedSessionError(`Shared Codex connection is unavailable: ${this.fault.message}`);
+        this.shared?.assertAvailable();
+    }
+    request(method, params, submission = false) {
+        this.assertAvailable();
+        if (this.shared)
+            return this.shared.request(method, params, submission);
+        if (this.socket?.readyState !== 1)
+            throw new CodexAttachedSessionError('Shared Codex connection is not open.');
+        const id = ++this.sequence;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new CodexAttachedSessionError(`Shared Codex ${method} timed out.`, submission));
+            }, this.timeoutMs);
+            this.pending.set(id, {
+                method, submission,
+                resolve: (value) => { clearTimeout(timer); resolve(value); },
+                reject: (error) => { clearTimeout(timer); reject(error); },
+            });
+            try {
+                this.write({ id, method, params }, (error) => {
+                    if (!error)
+                        return;
+                    const pending = this.pending.get(id);
+                    this.pending.delete(id);
+                    pending?.reject(new CodexAttachedSessionError(`Shared Codex ${method} transport failed.`, submission));
+                    this.fail(error);
+                });
+            }
+            catch (error) {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                reject(new CodexAttachedSessionError(errorMessage(error), submission));
+            }
+        });
+    }
+    async createThread(params) {
+        const result = await this.request('thread/start', params, true);
+        const id = string(object(object(result)?.thread)?.id);
+        if (id)
+            this.createdThreads.set(id, { pristine: true });
+        return result;
+    }
+    hasCreatedThread(threadId) {
+        return this.shared ? this.shared.hasCreatedThread(threadId) : this.createdThreads.has(threadId);
+    }
+    isPristineCreatedThread(threadId) {
+        return this.shared ? this.shared.isPristineCreatedThread(threadId) : this.createdThreads.get(threadId)?.pristine === true;
+    }
+    respond(id, result) {
+        this.assertAvailable();
+        if (this.shared)
+            this.shared.respond(id, result);
+        else
+            this.write({ id, result });
+    }
+    replayPendingRequests(threadId) {
+        const owner = this.shared ?? this;
+        for (const [id, request] of owner.pendingNativeRequests) {
+            if (request.params.threadId === threadId)
+                this.onServerRequest(id, request.method, request.params);
+        }
+    }
+    write(message, callback) {
+        if (this.socket?.readyState !== 1)
+            throw new CodexAttachedSessionError('Shared Codex connection is not open.');
+        this.socket.send(JSON.stringify(message), callback);
+    }
+    handleMessage(raw) {
+        if (this.closed || this.fault)
+            return;
+        let message;
+        try {
+            message = object(JSON.parse(String(raw)));
+        }
+        catch {
+            this.fail(new Error('Shared Codex sent invalid JSON.'));
+            return;
+        }
+        if (!message)
+            return;
+        if ('id' in message) {
+            // The native UI retains ownership unless an observer explicitly supplies
+            // a Canon interaction bridge. The transport itself never answers requests.
+            if (typeof message.method === 'string') {
+                const params = object(message.params);
+                if (params && (typeof message.id === 'string' || typeof message.id === 'number')) {
+                    this.pendingNativeRequests.set(message.id, { method: message.method, params });
+                    this.onServerRequest(message.id, message.method, params);
+                    for (const observer of this.observers)
+                        observer.onServerRequest(message.id, message.method, params);
+                }
+                return;
+            }
+            if (typeof message.id !== 'number')
+                return;
+            const pending = this.pending.get(message.id);
+            if (!pending)
+                return;
+            this.pending.delete(message.id);
+            const error = object(message.error);
+            if (error)
+                pending.reject(new CodexSharedRpcError(string(error.message) ?? 'Codex rejected the request.', typeof error.code === 'number' ? error.code : null));
+            else
+                pending.resolve(message.result);
+            return;
+        }
+        const params = object(message.params);
+        if (typeof message.method === 'string' && params) {
+            if (message.method === 'serverRequest/resolved' && (typeof params.requestId === 'string' || typeof params.requestId === 'number')) {
+                this.pendingNativeRequests.delete(params.requestId);
+            }
+            const threadId = string(params.threadId) ?? string(object(params.turn)?.threadId);
+            if (threadId && ['turn/started', 'item/started', 'item/completed'].includes(message.method)) {
+                const created = this.createdThreads.get(threadId);
+                if (created)
+                    created.pristine = false;
+            }
+            this.onNotification(message.method, params);
+            for (const observer of this.observers)
+                observer.onNotification(message.method, params);
+        }
+    }
+    onNotification(_method, _params) { }
+    onServerRequest(_id, _method, _params) { }
+    onDisconnected(_error) { }
+    rejectAll(reason) {
+        for (const request of this.pending.values()) {
+            request.reject(new CodexAttachedSessionError(`${reason} (${request.method})`, request.submission));
+        }
+        this.pending.clear();
+    }
+    fail(error) {
+        if (this.closed || this.fault)
+            return;
+        this.fault = error;
+        this.shared?.observers.delete(this);
+        this.rejectOpen?.(error);
+        this.rejectOpen = null;
+        this.rejectAll('Shared Codex connection was lost.');
+        this.onDisconnected(error);
+        for (const observer of this.observers)
+            observer.fail(error);
+        this.report(error);
+        this.socket?.terminate();
+    }
+    report(error) {
+        // Reporting callbacks cannot prevent pending requests/socket cleanup.
+        try {
+            this.options.onError?.(error);
+        }
+        catch { /* Caller owns its reporter. */ }
+    }
+}
+/** Read only live-thread metadata. No transcript, resume, or Canon credentials. */
+export async function listLoadedCodexSessions(options, sharedConnection) {
+    const connection = sharedConnection ?? new CodexSharedConnection(options);
+    try {
+        await connection.connect();
+        const sessions = [];
+        const seen = new Set();
+        for await (const threadId of loadedThreadIds(connection)) {
+            if (seen.has(threadId))
+                continue;
+            seen.add(threadId);
+            const result = object(await connection.request('thread/read', { threadId, includeTurns: false }));
+            const thread = object(result?.thread);
+            if (!thread || thread.id !== threadId)
+                throw new Error('Codex returned a different native thread.');
+            if (statusType(thread.status) === 'notLoaded')
+                continue;
+            const name = string(thread.name);
+            const cwd = string(thread.cwd);
+            const model = string(thread.model);
+            const reasoningEffort = string(thread.reasoningEffort);
+            sessions.push({ threadId, ...(name ? { name } : {}), ...(cwd ? { cwd } : {}),
+                ...(sharedConnection ? { status: statusType(thread.status) === 'active' ? 'running' : 'idle',
+                    ...(model ? { model } : {}), ...(reasoningEffort ? { reasoningEffort } : {}) } : {}),
+            });
+        }
+        return sessions;
+    }
+    finally {
+        if (!sharedConnection)
+            await connection.close();
+    }
+}
+/**
+ * Experimental second client of an explicitly shared, already-running server.
+ * It observes a native thread without owning its process, settings, or approvals.
+ */
+export class CodexAttachedSessionAdapter extends CodexSharedConnection {
+    threadId;
+    listeners = new Set();
+    attachment = null;
+    submitting = false;
+    inspecting = null;
+    terminalTurns = new Map();
+    turnOrder = [];
+    historyRevision = 0;
+    eventRevision = 0;
+    interactions = new Map();
+    interactionBridge;
+    constructor(options) {
+        super(options, options.sharedConnection);
+        if (!options.threadId.trim() || options.threadId !== options.threadId.trim()) {
+            throw new Error('An exact native Codex thread ID is required.');
+        }
+        this.threadId = options.threadId;
+        this.interactionBridge = options.interactionBridge;
+    }
+    async subscribe(listener) {
+        this.assertAvailable();
+        this.listeners.add(listener);
+        // Install observation before resuming/subscribing, and before any snapshot.
+        this.attachment ??= this.attach();
+        try {
+            await this.attachment;
+        }
+        catch (error) {
+            this.listeners.delete(listener);
+            throw error;
+        }
+    }
+    async inspect() {
+        await this.ready();
+        // One complete read boundary lets Core buffer live events while pages load.
+        this.inspecting ??= this.snapshot().finally(() => { this.inspecting = null; });
+        return this.inspecting;
+    }
+    async submit(text) {
+        if (!text.trim())
+            return { status: 'not_submitted', reason: 'A non-empty message is required.' };
+        if (this.submitting)
+            return { status: 'not_submitted', reason: 'Another Canon input submission is pending.' };
+        this.submitting = true;
+        try {
+            let snapshot;
+            try {
+                snapshot = await this.inspect();
+            }
+            catch (error) {
+                return { status: 'not_submitted', reason: errorMessage(error) };
+            }
+            const input = [{ type: 'text', text, text_elements: [] }];
+            const activeTurnId = snapshot.activeTurnId;
+            const result = await this.request(activeTurnId ? 'turn/steer' : 'turn/start', activeTurnId
+                ? { threadId: this.threadId, expectedTurnId: activeTurnId, input }
+                : { threadId: this.threadId, input }, true);
+            const data = object(result);
+            const turnId = activeTurnId ? string(data?.turnId) : string(object(data?.turn)?.id);
+            if (!turnId || (activeTurnId && turnId !== activeTurnId)) {
+                throw new CodexAttachedSessionError('Codex accepted a request without a matching native turn ID; submission needs reconciliation.', true);
+            }
+            // turn/start has no atomic idle guard: a concurrent native input can make
+            // it append to that turn. Never claim that it necessarily created a turn.
+            return { status: 'accepted', turnId, mode: activeTurnId ? 'appended' : 'started_or_appended' };
+        }
+        catch (error) {
+            if ((error instanceof CodexSharedRpcError && [-32600, -32601, -32602].includes(error.code ?? 0))
+                || (error instanceof CodexAttachedSessionError && !error.submissionUncertain)) {
+                return { status: 'not_submitted', reason: error.message };
+            }
+            // A timeout/disconnect after writing input is uncertain. Never resend it.
+            throw error;
+        }
+        finally {
+            this.submitting = false;
+        }
+    }
+    async close() {
+        this.abortInteractions();
+        this.listeners.clear();
+        await super.close();
+    }
+    async attach() {
+        try {
+            await this.connect();
+            let loaded = false;
+            for await (const id of loadedThreadIds(this)) {
+                if (id === this.threadId) {
+                    loaded = true;
+                    break;
+                }
+            }
+            if (!loaded)
+                throw new Error('This exact thread is not loaded in the selected shared Codex server. Canon will not reopen its saved history in another runner.');
+            // A new thread is already subscribed on its creating connection but has
+            // no persisted rollout to resume until the first real user input.
+            if (this.hasCreatedThread(this.threadId)) {
+                this.replayPendingRequests(this.threadId);
+                return;
+            }
+            const result = await this.request('thread/resume', { threadId: this.threadId, excludeTurns: true });
+            this.readThread(result);
+            this.replayPendingRequests(this.threadId);
+        }
+        catch (error) {
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
+    }
+    async ready() {
+        this.assertAvailable();
+        if (!this.attachment)
+            throw new CodexAttachedSessionError('Subscribe to the native session before reading or submitting.');
+        await this.attachment;
+        this.assertAvailable();
+    }
+    readThread(result) {
+        const thread = object(object(result)?.thread);
+        if (!thread || thread.id !== this.threadId)
+            throw new Error('Codex returned a different native thread.');
+        if (object(thread.status)?.type === 'notLoaded') {
+            const error = new Error('The attached native thread is no longer loaded.');
+            this.fail(error);
+            throw error;
+        }
+        return thread;
+    }
+    async snapshot() {
+        const revision = this.historyRevision;
+        const turns = await this.readTurnManifest();
+        const order = turns.map((turn) => turn.id);
+        // Revert/rollback can replace a suffix without changing this thread's ID.
+        if (this.turnOrder.some((id, index) => order[index] !== id))
+            this.terminalTurns.clear();
+        this.turnOrder = order;
+        const items = [];
+        const baselineItemIds = [];
+        let activeTurnId = null;
+        for (const turn of turns) {
+            const turnId = turn.id;
+            const active = statusType(turn.status) === 'inProgress';
+            if (active) {
+                activeTurnId = turnId;
+            }
+            const fingerprint = JSON.stringify([turn.status, turn.startedAt, turn.completedAt, turn.durationMs]);
+            const cached = this.terminalTurns.get(turnId);
+            let snapshot = !active && cached?.fingerprint === fingerprint ? cached.snapshot : undefined;
+            if (!snapshot) {
+                const eventRevision = this.eventRevision;
+                snapshot = await this.readTurnItems(turnId, active);
+                // An item/turn/history event during the read may make these pages stale.
+                if (!active && eventRevision === this.eventRevision)
+                    this.terminalTurns.set(turnId, { fingerprint, snapshot });
+            }
+            items.push(...snapshot.items);
+            baselineItemIds.push(...snapshot.baselineItemIds);
+        }
+        if (revision !== this.historyRevision)
+            throw new Error('Native history changed during reconciliation; inspect it again.');
+        return { nativeSessionId: this.threadId, items, activeTurnId, baselineItemIds };
+    }
+    async readTurnManifest() {
+        // Metadata and pages are separate RPCs. A normal turn transition between
+        // them needs a fresh state check, not a false missing-active-turn failure.
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const readMetadata = async () => this.readThread(await this.request('thread/read', { threadId: this.threadId, includeTurns: false }));
+            let thread = await readMetadata();
+            const turns = [];
+            const turnIds = new Set();
+            try {
+                for await (const raw of this.pages('thread/turns/list', { itemsView: 'notLoaded', limit: 100 })) {
+                    const turn = object(raw);
+                    const id = string(turn?.id);
+                    const status = statusType(turn?.status);
+                    if (!turn || !id || !['inProgress', 'completed', 'failed', 'interrupted'].includes(status ?? '') || turnIds.has(id)) {
+                        throw new Error('Codex returned invalid or repeated native turn history.');
+                    }
+                    turnIds.add(id);
+                    turns.push(turn);
+                }
+            }
+            catch (error) {
+                if (error instanceof CodexSharedRpcError && error.code === -32600
+                    && /is not materialized yet; thread\/turns\/list is unavailable before first user message/.test(error.message)
+                    && this.isPristineCreatedThread(this.threadId) && statusType(thread.status) === 'idle')
+                    return [];
+                throw error;
+            }
+            const activeCount = turns.filter((turn) => statusType(turn.status) === 'inProgress').length;
+            const matches = () => activeCount === (statusType(thread.status) === 'active' ? 1 : 0);
+            if (matches())
+                return turns;
+            thread = await readMetadata();
+            if (matches())
+                return turns;
+        }
+        throw new Error('Codex history kept changing or reported an active thread without its active turn ID; inspect it again.');
+    }
+    async readTurnItems(turnId, active) {
+        const items = [];
+        const baselineItemIds = [];
+        const seen = new Set();
+        // A page holds one native item so aggregate history cannot exceed the
+        // transport cap. Individual oversized items still fail closed at 8 MiB.
+        // Display summaries omit intermediate assistant messages and are unsafe for
+        // the private-history baseline and lost-ACK correlation.
+        for await (const raw of this.pages('thread/items/list', { turnId, limit: 1 })) {
+            const entry = object(raw);
+            const existing = object(entry?.item);
+            const itemId = string(existing?.id);
+            if (entry?.turnId !== turnId || !existing || !itemId || seen.has(itemId)) {
+                throw new Error('Codex returned invalid, repeated, or mismatched native item history.');
+            }
+            seen.add(itemId);
+            if (existing.type === 'userMessage' && /^item-\d+$/.test(itemId)) {
+                // Legacy rollouts can still reconstruct IDs on a newer server.
+                const error = new CodexAttachedSessionError('This thread history uses reconstructed user item IDs and cannot be attached safely. Use a native thread with stable transcript item IDs on Codex 0.154.0 or newer.');
+                this.fail(error);
+                throw error;
+            }
+            if (existing.type === 'userMessage' || existing.type === 'agentMessage') {
+                // Even partial/empty messages existing at attachment are private.
+                baselineItemIds.push({ itemId, turnId });
+            }
+            const item = plainItem(existing, turnId);
+            if (item && (!active || item.role === 'user'))
+                items.push(item);
+        }
+        return { nativeSessionId: this.threadId, items, baselineItemIds, activeTurnId: active ? turnId : null };
+    }
+    async *pages(method, params) {
+        const seen = new Set();
+        let cursor;
+        do {
+            const page = object(await this.request(method, {
+                threadId: this.threadId, sortDirection: 'asc', ...params, ...(cursor ? { cursor } : {}),
+            }));
+            if (!page || !Array.isArray(page.data))
+                throw new Error(`Codex returned an invalid ${method} page.`);
+            for (const entry of page.data)
+                yield entry;
+            if (page.nextCursor !== undefined && page.nextCursor !== null && !string(page.nextCursor)) {
+                throw new Error(`Codex returned an invalid ${method} cursor.`);
+            }
+            cursor = string(page.nextCursor);
+            if (cursor && seen.has(cursor))
+                throw new Error(`Codex repeated a ${method} cursor.`);
+            if (cursor)
+                seen.add(cursor);
+        } while (cursor);
+    }
+    onNotification(method, params) {
+        const turn = object(params.turn);
+        const threadId = string(params.threadId) ?? string(turn?.threadId) ?? string(object(params.thread)?.id);
+        if (threadId !== this.threadId)
+            return;
+        if (method === 'serverRequest/resolved' && (typeof params.requestId === 'string' || typeof params.requestId === 'number')) {
+            this.interactions.get(params.requestId)?.abort();
+            this.interactions.delete(params.requestId);
+            return;
+        }
+        if (method === 'thread/reverted' || method === 'thread/compacted') {
+            this.historyRevision += 1;
+            this.eventRevision += 1;
+            this.terminalTurns.clear();
+        }
+        if (['thread/closed', 'thread/deleted', 'thread/archived'].includes(method)
+            || (method === 'thread/status/changed' && statusType(params.status) === 'notLoaded')) {
+            this.fail(new Error('The attached native thread is no longer available on the shared server.'));
+            return;
+        }
+        const turnId = string(params.turnId) ?? string(turn?.id);
+        if (!turnId)
+            return;
+        if (method.startsWith('item/') || method === 'turn/started' || method === 'turn/completed') {
+            this.eventRevision += 1;
+            this.terminalTurns.delete(turnId);
+        }
+        if (method === 'item/completed') {
+            const item = plainItem(params.item, turnId);
+            if (item)
+                this.emit({ type: 'item', nativeSessionId: this.threadId, item });
+        }
+        else if (method === 'turn/started') {
+            this.emit({ type: 'turn', nativeSessionId: this.threadId, turnId, state: 'running' });
+        }
+        else if (method === 'turn/completed') {
+            const status = statusType(turn?.status);
+            this.emit({ type: 'turn', nativeSessionId: this.threadId, turnId, state: status === 'failed' || status === 'interrupted' ? status : 'completed' });
+        }
+    }
+    emit(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                this.report(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+    onDisconnected(error) {
+        this.abortInteractions();
+        this.emit({ type: 'disconnected', nativeSessionId: this.threadId, reason: error.message });
+    }
+    abortInteractions() {
+        for (const controller of this.interactions.values())
+            controller.abort();
+        this.interactions.clear();
+    }
+    onServerRequest(id, method, params) {
+        if (!this.interactionBridge || params.threadId !== this.threadId || this.interactions.has(id))
+            return;
+        const turnId = string(params.turnId);
+        const identity = { nativeRequestId: JSON.stringify([turnId ?? null, id]), nativeSessionId: this.threadId, ...(turnId ? { turnId } : {}) };
+        const approval = mapCodexAppServerApprovalRequest({ method: method, params });
+        const questions = method === 'item/tool/requestUserInput' ? attachedQuestions(params.questions) : null;
+        let request;
+        if (approval)
+            request = { ...identity, kind: 'approval', approval };
+        else if (questions)
+            request = { ...identity, kind: 'input', input: { kind: 'clarify', title: 'Codex needs input', questions,
+                    sensitive: questions.some((question) => question.isSecret === true),
+                    native: { runtime: 'codex', method, requestId: String(id), ...(turnId ? { turnId } : {}) },
+                } };
+        else {
+            this.report(new Error(`The native session requires an unsupported interaction: ${method}. Open its native client to respond.`));
+            return;
+        }
+        const controller = new AbortController();
+        this.interactions.set(id, controller);
+        void Promise.resolve().then(() => controller.signal.aborted
+            ? { kind: 'cancelled' }
+            : this.interactionBridge.request(request, { signal: controller.signal })).then((result) => {
+            if (controller.signal.aborted || this.interactions.get(id) !== controller)
+                return;
+            if (request.kind === 'approval') {
+                const allow = result.kind === 'approval' && result.decision === 'allow';
+                this.respond(id, method === 'item/permissions/requestApproval'
+                    ? { permissions: allow ? object(params.permissions) ?? {} : {}, scope: 'turn' }
+                    : mapCanonApprovalResultToCodexDecision({ decision: allow ? 'allow' : 'deny' }));
+            }
+            else
+                this.respond(id, { answers: result.kind === 'input' ? result.answers : {} });
+        }).catch((error) => {
+            if (!controller.signal.aborted) {
+                this.report(error instanceof Error ? error : new Error(String(error)));
+                // A failed Canon interaction must not leave an unseen approval waiting
+                // forever. Decline/cancel safely; a native resolution aborts this path.
+                try {
+                    this.respond(id, request.kind === 'input' ? { answers: {} }
+                        : method === 'item/permissions/requestApproval' ? { permissions: {}, scope: 'turn' }
+                            : { decision: 'decline' });
+                }
+                catch { /* A lost transport cannot carry a decision. */ }
+            }
+        }).finally(() => { if (this.interactions.get(id) === controller)
+            this.interactions.delete(id); });
+    }
+}
+function attachedQuestions(value) {
+    if (!Array.isArray(value) || !value.length || value.length > 12)
+        return null;
+    const questions = [];
+    for (const raw of value) {
+        const entry = object(raw);
+        const id = string(entry?.id);
+        const question = string(entry?.question);
+        if (!entry || !id || !/^[A-Za-z0-9_.:-]{1,120}$/.test(id) || !question || question.length > 1000)
+            return null;
+        const choices = Array.isArray(entry.options) ? entry.options.flatMap((raw) => {
+            const option = object(raw);
+            const label = string(option?.label);
+            return label ? [{ label, value: label, ...(string(option?.description) ? { description: option.description } : {}) }] : [];
+        }) : [];
+        questions.push({ id, question, ...(string(entry.header) ? { header: entry.header } : {}),
+            ...(choices.length ? { choices, allowOther: entry.allowOther !== false && entry.isOther !== false } : {}),
+            ...(entry.isSecret === true ? { isSecret: true } : {}), ...(entry.multiSelect === true ? { multiSelect: true } : {}), });
+    }
+    return questions;
+}
+async function* loadedThreadIds(connection) {
+    const seen = new Set();
+    let cursor;
+    do {
+        const page = object(await connection.request('thread/loaded/list', { limit: 100, ...(cursor ? { cursor } : {}) }));
+        if (!page || !Array.isArray(page.data))
+            throw new Error('Codex returned an invalid loaded-thread list.');
+        for (const id of page.data) {
+            if (typeof id !== 'string' || !id)
+                throw new Error('Codex returned an invalid native thread ID.');
+            yield id;
+        }
+        cursor = string(page.nextCursor);
+        if (cursor && seen.has(cursor))
+            throw new Error('Codex repeated a loaded-thread cursor.');
+        if (cursor)
+            seen.add(cursor);
+    } while (cursor);
+}
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function string(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function statusType(value) {
+    return string(value) ?? string(object(value)?.type);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function plainItem(value, turnId) {
+    const item = object(value);
+    const itemId = string(item?.id);
+    if (!item || !itemId)
+        return null;
+    if (item.type === 'agentMessage' && typeof item.text === 'string' && item.text.length) {
+        return { itemId, turnId, role: 'assistant', text: item.text };
+    }
+    if (item.type !== 'userMessage' || !Array.isArray(item.content))
+        return null;
+    const text = item.content.flatMap((raw) => {
+        const part = object(raw);
+        return part?.type === 'text' && typeof part.text === 'string' ? [part.text] : [];
+    }).join('\n');
+    return text.length ? { itemId, turnId, role: 'user', text } : null;
+}