@excitedjs/agent-runtime-codex 0.3.5-beta.168 → 0.4.0

package/dist/turn-manager.js

@@ -1,14 +1,5 @@
-/**
- * Per-dispatcher in-memory inbound submitter.
- *
- * Contract:
- *   - accepted inbound messages are not persisted;
- *   - Feishu message_id redelivery is deduped within this server process;
- *   - one accepted inbound message becomes one Codex `turn/start` submission;
- *   - Codex text output alone does not send anything to Feishu.
- */
 import { extractAssistantText, subscribeTurnCollection, submitTurnStart, } from './events.js';
-import { compileCodexOutputSchema, } from './output-schema-codec.js';
+import { compileCodexOutputSchema } from './output-schema-codec.js';
 import { DEFAULT_MESSAGE_ID_DEDUPE_WINDOW, unsupportedFeatureError, } from '@excitedjs/dreamux-utils';
 export class TurnManager {
     opts;
@@ -16,332 +7,364 @@ export class TurnManager {
     seenMessageIdOrder = [];
     seenTextInputIds = new Set();
     seenTextInputIdOrder = [];
+    pendingMessageIds = new Map();
+    pendingTextInputIds = new Map();
+    pendingAdmissions = new Set();
+    inFlightNativeAdmissions = new Set();
+    nextNativeAdmission = 0;
+    nativeTurns = new Map();
+    pendingActivity = new Map();
+    unboundObservedTurnIds = new Set();
+    terminalOrder = [];
+    protocolFailure = null;
+    collector = null;
+    collectorThreadId = null;
+    decisionTail = Promise.resolve();
     stopped = false;
-    activeTurnSlot = null;
-    activeTurnId = null;
-    /**
-     * Turn ids submitted to Codex that have not yet reached `turn/completed`. On
-     * `stop()` each still-pending turn is settled as `stopped` so a teammate turn
-     * interrupted by teardown is not lost.
-     */
-    pendingTurns = new Map();
     idlePromise = null;
     idleResolve = null;
     log;
     messageIdDedupeWindow;
     constructor(opts) {
         this.opts = opts;
-        this.log = opts.log ?? ((lvl, msg, err) => {
-            const prefix = `[turn-manager ${opts.dispatcherId}] ${lvl}`;
-            if (err !== undefined)
-                console.error(prefix, msg, err);
+        this.log = opts.log ?? ((level, message, error) => {
+            const prefix = `[turn-manager ${opts.dispatcherId}] ${level}`;
+            if (error === undefined)
+                console.error(prefix, message);
             else
-                console.error(prefix, msg);
+                console.error(prefix, message, error);
         });
         this.messageIdDedupeWindow = Math.max(0, opts.messageIdDedupeWindow ?? DEFAULT_MESSAGE_ID_DEDUPE_WINDOW);
     }
     isBusy() {
-        return this.activeTurnSlot !== null || this.pendingTurns.size > 0;
+        return this.pendingAdmissions.size > 0 || [...this.nativeTurns.values()].some((record) => record.completion === null);
     }
     waitIdle() {
         if (!this.isBusy())
             return Promise.resolve();
-        // All concurrent waiters share one promise for the current busy period; it
-        // is replaced with a fresh one the next time the runtime goes busy.
-        if (this.idlePromise === null) {
-            this.idlePromise = new Promise((resolve) => {
-                this.idleResolve = resolve;
-            });
-        }
+        this.idlePromise ??= new Promise((resolve) => { this.idleResolve = resolve; });
         return this.idlePromise;
     }
-    /**
-     * Submit one accepted inbound message to Codex. Returns duplicate when this
-     * process already saw the message_id.
-     */
-    async enqueue(input) {
-        if (this.stopped)
-            return { status: 'stopped' };
-        if (!this.rememberMessageId(input.sourceId)) {
-            return { status: 'duplicate' };
-        }
-        const threadId = this.opts.getThreadId();
-        if (threadId === null) {
-            const error = new Error('inbound submitted without thread_id');
-            this.log('error', error.message);
-            return { status: 'failed', error };
-        }
-        let activeTurn;
-        try {
-            activeTurn = this.claimActiveTurnSlot(threadId, null);
-        }
-        catch (err) {
-            const error = asError(err);
-            this.log('error', error.message, error);
-            return { status: 'failed', error };
-        }
-        activeTurn.slot.pendingSubmissions += 1;
-        let res;
-        try {
-            res = await submitTurnStart(this.opts.client, threadId, input.text, this.opts.turnCwd ?? null);
-        }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.recordTurnStartFailure(activeTurn.slot, error, activeTurn.primary);
-            this.log('error', `turn/start submission failed for message ${input.sourceId === '' ? '<none>' : input.sourceId}: ${error.message}`, error);
-            return { status: 'failed', error };
-        }
-        const turnId = this.recordTurnStartSuccess(activeTurn.slot, res.turn.id, activeTurn.primary);
-        try {
-            return {
-                status: 'submitted',
-                turnId: turnId ?? await activeTurn.slot.turnIdPromise,
-            };
+    enqueue(input) {
+        return this.trackAdmission(this.reserveSource(input.sourceId, this.seenMessageIds, this.seenMessageIdOrder, this.pendingMessageIds, () => this.enqueueDecision(() => this.submit(input.text, null, `message ${input.sourceId || '<none>'}`))));
+    }
+    submitTextInput(input) {
+        return this.trackAdmission(this.reserveSource(input.sourceId, this.seenTextInputIds, this.seenTextInputIdOrder, this.pendingTextInputIds, async () => {
+            let codec = null;
+            if (input.outputSchema !== undefined) {
+                try {
+                    codec = compileCodexOutputSchema(input.outputSchema);
+                }
+                catch (error) {
+                    return { status: 'failed', error: asError(error) };
+                }
+            }
+            return this.enqueueDecision(() => this.submit(input.text, codec, 'text input'));
+        }));
+    }
+    async stop() {
+        this.stopped = true;
+        this.collector?.dispose();
+        this.collector = null;
+        while (this.pendingAdmissions.size > 0)
+            await Promise.allSettled([...this.pendingAdmissions]);
+        this.drainTerminalOrder();
+        for (const record of this.nativeTurns.values()) {
+            if (record.completion !== null)
+                continue;
+            for (const member of record.members)
+                member.settle({ kind: 'stopped' });
         }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            return { status: 'failed', error };
+        for (const [turnId, record] of this.nativeTurns) {
+            if (record.completion === null)
+                this.nativeTurns.delete(turnId);
         }
+        this.terminalOrder.length = 0;
+        this.pendingActivity.clear();
+        this.unboundObservedTurnIds.clear();
+        this.resolveIdleWaitersIfIdle();
     }
-    async submitTextInput(input) {
+    async submit(text, codec, description) {
         if (this.stopped)
             return { status: 'stopped' };
-        if (input.sourceId !== undefined &&
-            input.sourceId !== '' &&
-            !this.rememberTextInputId(input.sourceId)) {
-            return { status: 'duplicate' };
-        }
+        if (this.protocolFailure !== null)
+            return { status: 'failed', error: this.protocolFailure };
         const threadId = this.opts.getThreadId();
-        if (threadId === null) {
-            const error = new Error('text input submitted without thread_id');
-            this.log('error', error.message);
-            return { status: 'failed', error };
-        }
-        let codec = null;
-        if (input.outputSchema !== undefined) {
-            try {
-                codec = compileCodexOutputSchema(input.outputSchema);
-            }
-            catch (err) {
-                const error = asError(err);
-                this.log('error', error.message, error);
-                return { status: 'failed', error };
-            }
-        }
-        let activeTurn;
+        if (threadId === null)
+            return { status: 'failed', error: new Error('input submitted without thread_id') };
+        const deferred = createRuntimeSubmission();
+        this.ensureCollector(threadId);
+        const incompatible = this.incompatibleCodecError(codec);
+        if (incompatible !== null)
+            return { status: 'failed', error: incompatible };
+        const admissionId = this.nextNativeAdmission++;
+        this.inFlightNativeAdmissions.add(admissionId);
+        let response;
         try {
-            activeTurn = this.claimActiveTurnSlot(threadId, codec);
+            response = await submitTurnStart(this.opts.client, threadId, text, this.opts.turnCwd ?? null, codec?.wireSchema);
         }
-        catch (err) {
-            const error = asError(err);
-            this.log('error', error.message, error);
-            return { status: 'failed', error };
+        catch (error) {
+            const normalized = asError(error);
+            this.log('error', `turn/start submission failed for ${description}: ${normalized.message}`, normalized);
+            this.inFlightNativeAdmissions.delete(admissionId);
+            this.releaseCompletedRecords(admissionId);
+            this.dropOrphanActivityIfIdle();
+            return { status: 'ambiguous', error: normalized };
         }
-        activeTurn.slot.pendingSubmissions += 1;
-        let res;
-        try {
-            res = await submitTurnStart(this.opts.client, threadId, input.text, this.opts.turnCwd ?? null, activeTurn.slot.codec?.wireSchema);
+        const observed = this.nativeTurns.get(response.turn.id);
+        if (this.stopped && (observed === undefined || observed.terminal === null)) {
+            deferred.settle({ kind: 'stopped' });
         }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.recordTurnStartFailure(activeTurn.slot, error, activeTurn.primary);
-            this.log('error', `text turn/start submission failed: ${error.message}`, error);
-            return { status: 'failed', error };
+        else {
+            this.bindSubmission(response.turn.id, deferred, codec);
         }
-        const turnId = this.recordTurnStartSuccess(activeTurn.slot, res.turn.id, activeTurn.primary);
-        try {
-            return {
-                status: 'submitted',
-                turnId: turnId ?? await activeTurn.slot.turnIdPromise,
-            };
+        this.inFlightNativeAdmissions.delete(admissionId);
+        this.releaseCompletedRecords(admissionId);
+        this.dropOrphanActivityIfIdle();
+        return { status: 'submitted', submission: deferred.submission };
+    }
+    enqueueDecision(operation) {
+        const task = this.decisionTail.then(operation, operation);
+        this.decisionTail = task.then(() => undefined, () => undefined);
+        return task;
+    }
+    incompatibleCodecError(candidate) {
+        for (const record of this.nativeTurns.values()) {
+            if (record.completion !== null || record.terminal !== null)
+                continue;
+            if (sameCodec(record.codec, candidate))
+                continue;
+            return unsupportedFeatureError('outputSchema', 'codex cannot submit an incompatible outputSchema while a native turn is active');
         }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            return { status: 'failed', error };
+        return null;
+    }
+    ensureCollector(threadId) {
+        if (this.collector !== null && this.collectorThreadId === threadId)
+            return;
+        this.collector?.dispose();
+        this.collectorThreadId = threadId;
+        this.collector = subscribeTurnCollection(this.opts.client, threadId, {
+            retainAfterTerminal: true,
+            onItemStarted: (turnId, item) => this.observeItem(turnId, item, 'started', Date.now()),
+            onItemCompleted: (turnId, item, occurredAt) => this.observeItem(turnId, item, 'completed', occurredAt),
+            onTerminal: (turnId, terminal) => this.observeTerminal(turnId, terminal),
+            onUnscopedFailure: (error) => this.failProtocol(error),
+            onProtocolViolation: (error) => this.failProtocol(error),
+        });
+    }
+    bindSubmission(turnId, deferred, codec) {
+        this.unboundObservedTurnIds.delete(turnId);
+        const record = this.nativeTurns.get(turnId) ?? {
+            representative: null,
+            members: [],
+            codec,
+            completion: null,
+            terminal: null,
+            releaseAfterAdmissions: null,
+        };
+        if (record.representative === null && record.members.length === 0)
+            record.codec = codec;
+        record.representative ??= deferred.submission;
+        if (record.completion === null)
+            record.members.push(deferred);
+        this.nativeTurns.set(turnId, record);
+        for (const fact of this.pendingActivity.get(turnId) ?? [])
+            this.emitActivity(record, fact.activity, fact.occurredAt);
+        this.pendingActivity.delete(turnId);
+        if (this.protocolFailure !== null) {
+            this.failRecord(turnId, record, this.protocolFailure);
+            return;
         }
+        if (record.completion !== null)
+            deferred.settle({ kind: 'completion', completion: record.completion });
+        this.drainTerminalOrder();
     }
-    async stop() {
-        this.stopped = true;
-        const activeSlot = this.activeTurnSlot;
-        this.activeTurnSlot = null;
-        if (activeSlot !== null) {
-            activeSlot.collector.dispose();
-            activeSlot.codec = null;
+    observeTerminal(turnId, terminal) {
+        this.unboundObservedTurnIds.delete(turnId);
+        const record = this.nativeTurns.get(turnId) ?? {
+            representative: null, members: [], codec: null, completion: null, terminal: null,
+            releaseAfterAdmissions: null,
+        };
+        if (record.terminal !== null || record.completion !== null)
+            return;
+        record.terminal = terminal;
+        record.releaseAfterAdmissions = new Set(this.inFlightNativeAdmissions);
+        this.nativeTurns.set(turnId, record);
+        this.terminalOrder.push(turnId);
+        this.drainTerminalOrder();
+    }
+    drainTerminalOrder() {
+        while (this.terminalOrder.length > 0) {
+            const turnId = this.terminalOrder[0];
+            const record = this.nativeTurns.get(turnId);
+            if (record === undefined || record.terminal === null)
+                return;
+            if (record.representative === null) {
+                if (this.pendingAdmissions.size > 0)
+                    return;
+                this.terminalOrder.shift();
+                this.nativeTurns.delete(turnId);
+                this.pendingActivity.delete(turnId);
+                this.unboundObservedTurnIds.delete(turnId);
+                this.collector?.releaseTurn(turnId);
+                this.log('warn', `dropping native terminal ${turnId} without an accepted submission`);
+                continue;
+            }
+            this.terminalOrder.shift();
+            this.finalize(turnId, record, record.terminal);
         }
-        if (activeSlot !== null && activeSlot.turnId === null) {
-            activeSlot.rejectTurnId(new Error('codex turn stopped before acceptance'));
+    }
+    finalize(turnId, record, terminal) {
+        if (record.completion !== null)
+            return;
+        if (record.representative === null)
+            return;
+        let completion;
+        if (terminal instanceof Error) {
+            completion = Object.freeze({ status: 'failed', displaySubmission: record.representative, error: terminal });
         }
-        // Any turn still in flight at teardown will never reach `turn/completed`
-        // (the WS is closing). Settle each as `stopped` so an interrupted teammate
-        // turn is delivered with a status rather than vanishing.
-        for (const turnId of this.pendingTurns.keys()) {
-            this.opts.onTurnSettled?.({
-                turnId,
-                status: 'stopped',
-                result: { text: null },
+        else {
+            let completedTurn = terminal;
+            try {
+                if (record.codec !== null)
+                    completedTurn = restoreCollectedTurn(terminal, record.codec);
+            }
+            catch (error) {
+                completion = Object.freeze({ status: 'failed', displaySubmission: record.representative, error: asError(error) });
+                record.completion = completion;
+                for (const member of record.members)
+                    member.settle({ kind: 'completion', completion });
+                record.members.length = 0;
+                record.terminal = null;
+                this.releaseRecordIfReady(turnId, record);
+                this.resolveIdleWaitersIfIdle();
+                return;
+            }
+            this.opts.onTurnCompleted?.(completedTurn);
+            completion = Object.freeze({
+                status: 'completed',
+                displaySubmission: record.representative,
+                resultText: extractAssistantText(completedTurn),
+                truncated: false,
             });
         }
-        this.pendingTurns.clear();
-        this.activeTurnId = null;
+        record.completion = completion;
+        for (const member of record.members)
+            member.settle({ kind: 'completion', completion });
+        record.members.length = 0;
+        record.terminal = null;
+        this.releaseRecordIfReady(turnId, record);
         this.resolveIdleWaitersIfIdle();
     }
-    claimActiveTurnSlot(threadId, codec) {
-        const active = this.activeTurnSlot;
-        if (active !== null) {
-            assertCompatibleCodec(active.codec, codec);
-            return { slot: active, primary: false };
+    failProtocol(error) {
+        this.protocolFailure ??= error;
+        this.log('error', error.message, error);
+        this.terminalOrder.length = 0;
+        for (const [turnId, record] of this.nativeTurns) {
+            if (record.completion !== null)
+                continue;
+            this.failRecord(turnId, record, this.protocolFailure);
         }
-        let resolveTurnId;
-        let rejectTurnId;
-        const turnIdPromise = new Promise((resolve, reject) => {
-            resolveTurnId = resolve;
-            rejectTurnId = reject;
-        });
-        // The primary submitter returns its own failure directly. The shared promise
-        // only exists for concurrent followers waiting for that primary turn id, so
-        // reject it without producing an unhandled rejection when there are none.
-        turnIdPromise.catch(() => undefined);
-        const slot = {
-            collector: subscribeTurnCollection(this.opts.client, threadId),
-            codec,
-            turnId: null,
-            candidateTurnId: null,
-            primaryFailed: false,
-            pendingSubmissions: 0,
-            turnIdPromise,
-            resolveTurnId,
-            rejectTurnId,
-        };
-        this.activeTurnSlot = slot;
-        return { slot, primary: true };
+        this.resolveIdleWaitersIfIdle();
     }
-    recordTurnStartSuccess(slot, turnId, primary) {
-        slot.pendingSubmissions = Math.max(0, slot.pendingSubmissions - 1);
-        if (slot.turnId !== null)
-            return slot.turnId;
-        if (this.stopped) {
-            slot.rejectTurnId(new Error('codex turn stopped before acceptance'));
-            return null;
-        }
-        if (primary || slot.primaryFailed) {
-            this.activateTurnSlot(slot, turnId);
-            return turnId;
+    failRecord(turnId, record, error) {
+        for (const member of record.members)
+            member.settle({ kind: 'failed', error });
+        record.members.length = 0;
+        this.nativeTurns.delete(turnId);
+        this.pendingActivity.delete(turnId);
+        this.unboundObservedTurnIds.delete(turnId);
+        this.collector?.releaseTurn(turnId);
+    }
+    releaseCompletedRecords(admissionId) {
+        for (const [turnId, record] of this.nativeTurns) {
+            record.releaseAfterAdmissions?.delete(admissionId);
+            this.releaseRecordIfReady(turnId, record);
         }
-        slot.candidateTurnId ??= turnId;
-        return null;
     }
-    recordTurnStartFailure(slot, error, primary) {
-        slot.pendingSubmissions = Math.max(0, slot.pendingSubmissions - 1);
-        if (slot.turnId !== null)
+    releaseRecordIfReady(turnId, record) {
+        if (record.completion === null || (record.releaseAfterAdmissions?.size ?? 0) > 0)
             return;
-        if (primary)
-            slot.primaryFailed = true;
-        if (slot.primaryFailed && slot.candidateTurnId !== null) {
-            this.activateTurnSlot(slot, slot.candidateTurnId);
+        this.nativeTurns.delete(turnId);
+        this.pendingActivity.delete(turnId);
+        this.unboundObservedTurnIds.delete(turnId);
+        this.collector?.releaseTurn(turnId);
+    }
+    dropOrphanActivityIfIdle() {
+        if (this.inFlightNativeAdmissions.size !== 0)
             return;
+        for (const turnId of this.unboundObservedTurnIds) {
+            if (this.nativeTurns.has(turnId))
+                continue;
+            this.pendingActivity.delete(turnId);
+            this.collector?.releaseTurn(turnId);
         }
-        if (slot.primaryFailed && slot.pendingSubmissions === 0) {
-            if (this.activeTurnSlot === slot)
-                this.activeTurnSlot = null;
-            slot.collector.dispose();
-            slot.codec = null;
-            slot.rejectTurnId(error);
-            this.resolveIdleWaitersIfIdle();
-        }
+        this.unboundObservedTurnIds.clear();
     }
-    activateTurnSlot(slot, turnId) {
-        if (slot.turnId !== null)
+    observeItem(turnId, item, phase, occurredAt) {
+        const record = this.nativeTurns.get(turnId);
+        if (record === undefined || record.representative === null) {
+            this.unboundObservedTurnIds.add(turnId);
+            if (this.inFlightNativeAdmissions.size === 0) {
+                this.dropOrphanActivityIfIdle();
+                return;
+            }
+            const activity = itemActivity(turnId, item, phase);
+            if (activity === null)
+                return;
+            const pending = this.pendingActivity.get(turnId) ?? [];
+            pending.push({ activity, occurredAt });
+            this.pendingActivity.set(turnId, pending);
+            return;
+        }
+        const activity = itemActivity(turnId, item, phase);
+        if (activity === null)
             return;
-        slot.turnId = turnId;
-        this.trackTurn(turnId, slot.collector, slot);
-        slot.resolveTurnId(turnId);
+        this.emitActivity(record, activity, occurredAt);
     }
-    /**
-     * Record a submitted turn as pending and wire its completion. On
-     * `turn/completed` the turn is removed from the pending set and the snapshot
-     * hook fires (which is where the runtime emits the `completed` settlement). On
-     * a terminal turn failure (collector rejects: codex `error` with
-     * `willRetry: false`, or a `turn/completed` carrying `turn.error`) the turn is
-     * settled as `failed` here, so a teammate turn that errors at the model level
-     * is delivered with a status instead of hanging until teardown.
-     */
-    trackTurn(turnId, collector, slot) {
-        if (this.pendingTurns.has(turnId))
+    emitActivity(record, activity, occurredAt) {
+        if (record.representative === null)
             return;
-        this.pendingTurns.set(turnId, { codec: slot.codec });
-        this.activeTurnId = turnId;
-        void collector.awaitTurn(turnId).then((turn) => {
-            // Only forward completion if this turn was still pending. If `stop()`
-            // already settled it as `stopped`, the delete returns false and we drop
-            // the late completion so a turn is never settled twice.
-            const pending = this.pendingTurns.get(turnId);
-            if (pending !== undefined && this.pendingTurns.delete(turnId)) {
-                if (this.activeTurnSlot === slot)
-                    this.activeTurnSlot = null;
-                if (this.activeTurnId === turnId)
-                    this.activeTurnId = null;
-                let completedTurn;
-                try {
-                    completedTurn = pending.codec === null
-                        ? turn
-                        : restoreCollectedTurn(turn, pending.codec);
-                }
-                catch (err) {
-                    this.opts.onTurnSettled?.({
-                        turnId,
-                        status: 'failed',
-                        result: { text: null },
-                        error: asError(err),
-                    });
-                    this.resolveIdleWaitersIfIdle();
-                    return;
+        try {
+            this.opts.activitySink(Object.freeze({ submission: record.representative, activity: Object.freeze(activity), occurredAt }));
+        }
+        catch (error) {
+            this.log('warn', 'codex activity projection failed', error);
+        }
+    }
+    reserveSource(sourceId, committed, order, pending, operation) {
+        if (sourceId === undefined || sourceId === '')
+            return operation();
+        if (committed.has(sourceId))
+            return Promise.resolve({ status: 'duplicate' });
+        const existing = pending.get(sourceId);
+        if (existing !== undefined)
+            return existing;
+        const task = Promise.resolve().then(operation).catch((error) => ({ status: 'ambiguous', error: asError(error) }));
+        pending.set(sourceId, task);
+        void task.then((admission) => {
+            if (admission.status === 'submitted' || admission.status === 'ambiguous') {
+                committed.add(sourceId);
+                order.push(sourceId);
+                while (order.length > this.messageIdDedupeWindow) {
+                    const evicted = order.shift();
+                    if (evicted !== undefined)
+                        committed.delete(evicted);
                 }
-                this.opts.onTurnCompleted?.(completedTurn);
-                this.resolveIdleWaitersIfIdle();
-            }
-        }, (err) => {
-            // Same mutual-exclusion guard as the completed path: only settle as
-            // `failed` if `stop()` did not already settle it as `stopped`.
-            if (this.pendingTurns.delete(turnId)) {
-                if (this.activeTurnSlot === slot)
-                    this.activeTurnSlot = null;
-                if (this.activeTurnId === turnId)
-                    this.activeTurnId = null;
-                this.opts.onTurnSettled?.({
-                    turnId,
-                    status: 'failed',
-                    result: { text: null },
-                    error: err instanceof Error ? err : new Error(String(err)),
-                });
-                this.resolveIdleWaitersIfIdle();
             }
+            if (pending.get(sourceId) === task)
+                pending.delete(sourceId);
         });
+        return task;
     }
-    rememberMessageId(messageId) {
-        if (messageId === '')
-            return true;
-        if (this.seenMessageIds.has(messageId))
-            return false;
-        this.seenMessageIds.add(messageId);
-        this.seenMessageIdOrder.push(messageId);
-        while (this.seenMessageIdOrder.length > this.messageIdDedupeWindow) {
-            const evicted = this.seenMessageIdOrder.shift();
-            if (evicted !== undefined)
-                this.seenMessageIds.delete(evicted);
-        }
-        return true;
-    }
-    rememberTextInputId(id) {
-        if (this.seenTextInputIds.has(id))
-            return false;
-        this.seenTextInputIds.add(id);
-        this.seenTextInputIdOrder.push(id);
-        while (this.seenTextInputIdOrder.length > this.messageIdDedupeWindow) {
-            const evicted = this.seenTextInputIdOrder.shift();
-            if (evicted !== undefined)
-                this.seenTextInputIds.delete(evicted);
-        }
-        return true;
+    trackAdmission(admission) {
+        this.pendingAdmissions.add(admission);
+        void admission.finally(() => {
+            this.pendingAdmissions.delete(admission);
+            this.drainTerminalOrder();
+            this.resolveIdleWaitersIfIdle();
+        }).catch(() => undefined);
+        return admission;
     }
     resolveIdleWaitersIfIdle() {
         if (this.isBusy())
@@ -352,37 +375,80 @@ export class TurnManager {
         resolve?.();
     }
 }
-function assertCompatibleCodec(active, candidate) {
-    if (active === null && candidate === null)
-        return;
-    if (active !== null && candidate !== null) {
-        if (active.fingerprint === candidate.fingerprint)
-            return;
-        throw unsupportedFeatureError('outputSchema', 'codex active turn has an incompatible outputSchema');
+function sameCodec(left, right) {
+    return left === null ? right === null : right !== null && left.fingerprint === right.fingerprint;
+}
+function createRuntimeSubmission() {
+    let resolve;
+    let settled = false;
+    const submission = Object.freeze({ settled: new Promise((value) => { resolve = value; }) });
+    return { submission, settle(settlement) { if (settled)
+            return false; settled = true; resolve(settlement); return true; } };
+}
+function itemActivity(turnId, item, phase) {
+    const itemId = typeof item.id === 'string' && item.id !== '' ? item.id : null;
+    if (itemId === null)
+        return null;
+    if (item.type === 'agentMessage') {
+        if (phase !== 'completed' || typeof item.text !== 'string' || item.text === '')
+            return null;
+        return { kind: 'assistant.message', id: `${turnId}:${itemId}:completed`, text: item.text, truncated: false };
+    }
+    const toolName = toolNameFor(item);
+    if (toolName === null)
+        return null;
+    const failed = phase === 'completed' && (item['status'] === 'failed' || item['error'] != null);
+    return {
+        kind: 'tool.call',
+        id: `${turnId}:${itemId}:${phase}`,
+        callId: itemId,
+        toolName,
+        status: phase === 'started' ? 'started' : failed ? 'failed' : 'completed',
+        arguments: toJsonValue(item['arguments'] ?? item['input'] ?? item['command'] ?? null),
+        result: phase === 'completed' ? toJsonValue(item['result'] ?? item['output'] ?? item['aggregatedOutput'] ?? null) : null,
+        error: failed ? String(item['error'] ?? 'tool call failed') : null,
+    };
+}
+function toolNameFor(item) {
+    if (item.type === 'commandExecution')
+        return 'exec_command';
+    if (item.type === 'fileChange')
+        return 'apply_patch';
+    if (item.type === 'mcpToolCall') {
+        const server = typeof item['server'] === 'string' ? item['server'] : null;
+        const tool = typeof item['tool'] === 'string' ? item['tool'] : null;
+        return server !== null && tool !== null ? `${server}.${tool}` : null;
+    }
+    if (typeof item['name'] === 'string')
+        return item['name'];
+    if (typeof item['tool'] === 'string')
+        return item['tool'];
+    return null;
+}
+function toJsonValue(value) {
+    if (value === undefined)
+        return null;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return String(value);
     }
-    throw unsupportedFeatureError('outputSchema', active === null
-        ? 'codex cannot fold structured output into an active unstructured turn'
-        : 'codex cannot fold unstructured input into an active structured turn');
 }
 function restoreCollectedTurn(turn, codec) {
     const text = extractAssistantText(turn);
-    if (text === null) {
-        throw new Error(`codex outputSchema restoration for turn ${turn.turnId}: ` +
-            'completed turn has no assistant JSON text');
-    }
+    if (text === null)
+        throw new Error('codex outputSchema restoration failed: completed turn has no assistant JSON text');
     const restoredText = codec.restore(text);
     let replaced = false;
     const items = [...turn.items].reverse().map((item) => {
-        if (replaced || item.type !== 'agentMessage' || item.text !== text) {
+        if (replaced || item.type !== 'agentMessage' || item.text !== text)
             return item;
-        }
         replaced = true;
         return { ...item, text: restoredText };
     }).reverse();
-    if (!replaced) {
-        throw new Error(`codex outputSchema restoration for turn ${turn.turnId}: ` +
-            'assistant JSON text was not found');
-    }
+    if (!replaced)
+        throw new Error('codex outputSchema restoration failed: assistant JSON text was not found');
     return { ...turn, items };
 }
 function asError(error) {