@excitedjs/agent-runtime-codex 1.0.0-beta.170 → 1.0.0-beta.173

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;
@@ -19,298 +10,340 @@ export class TurnManager {
     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;
-    /**
-     * 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.
-     */
     enqueue(input) {
-        return this.trackAdmission(this.reserveSource(input.sourceId, this.seenMessageIds, this.seenMessageIdOrder, this.pendingMessageIds, () => this.enqueueUnreserved(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>'}`))));
     }
-    async enqueueUnreserved(input) {
-        if (this.stopped)
-            return { status: 'stopped' };
-        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 };
-        }
-        const submissionIndex = activeTurn.slot.nextSubmissionIndex++;
-        activeTurn.slot.pendingSubmissions += 1;
-        let res;
-        try {
-            res = await submitTurnStart(this.opts.client, threadId, input.text, this.opts.turnCwd ?? null);
+    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));
-            this.recordTurnStartFailure(activeTurn.slot, error);
-            this.log('error', `turn/start submission failed for message ${input.sourceId === '' ? '<none>' : input.sourceId}: ${error.message}`, error);
-            return { status: 'ambiguous', error };
+        for (const [turnId, record] of this.nativeTurns) {
+            if (record.completion === null)
+                this.nativeTurns.delete(turnId);
         }
-        this.recordTurnStartSuccess(activeTurn.slot, res.turn.id, submissionIndex);
-        return { status: 'submitted', turn: activeTurn.slot.runtimeTurn };
-    }
-    submitTextInput(input) {
-        return this.trackAdmission(this.reserveSource(input.sourceId, this.seenTextInputIds, this.seenTextInputIdOrder, this.pendingTextInputIds, () => this.submitTextInputUnreserved(input)));
+        this.terminalOrder.length = 0;
+        this.pendingActivity.clear();
+        this.unboundObservedTurnIds.clear();
+        this.resolveIdleWaitersIfIdle();
     }
-    async submitTextInputUnreserved(input) {
+    async submit(text, codec, description) {
         if (this.stopped)
             return { status: 'stopped' };
+        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 };
         }
-        const submissionIndex = activeTurn.slot.nextSubmissionIndex++;
-        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);
-            this.log('error', `text turn/start submission failed: ${error.message}`, error);
-            return { status: 'ambiguous', error };
+        else {
+            this.bindSubmission(response.turn.id, deferred, codec);
         }
-        this.recordTurnStartSuccess(activeTurn.slot, res.turn.id, submissionIndex);
-        return { status: 'submitted', turn: activeTurn.slot.runtimeTurn };
+        this.inFlightNativeAdmissions.delete(admissionId);
+        this.releaseCompletedRecords(admissionId);
+        this.dropOrphanActivityIfIdle();
+        return { status: 'submitted', submission: deferred.submission };
     }
-    async stop() {
-        this.stopped = true;
-        const activeSlot = this.activeTurnSlot;
-        this.activeTurnSlot = null;
-        if (activeSlot !== null) {
-            activeSlot.stopped = true;
-            activeSlot.collector.dispose();
-            activeSlot.codec = null;
-            activeSlot.settle({ status: 'stopped' });
-        }
-        // 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 slot of this.pendingTurns.values()) {
-            slot.settle({ status: 'stopped' });
-        }
-        this.pendingTurns.clear();
-        this.resolveIdleWaitersIfIdle();
-        while (this.pendingAdmissions.size > 0) {
-            await Promise.allSettled([...this.pendingAdmissions]);
-        }
+    enqueueDecision(operation) {
+        const task = this.decisionTail.then(operation, operation);
+        this.decisionTail = task.then(() => undefined, () => undefined);
+        return task;
     }
-    claimActiveTurnSlot(threadId, codec) {
-        const active = this.activeTurnSlot;
-        if (active !== null) {
-            assertCompatibleCodec(active.codec, codec);
-            return { slot: active, primary: false };
+    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');
         }
-        const runtimeTurn = createRuntimeTurn();
-        const slot = {
-            collector: subscribeTurnCollection(this.opts.client, threadId, {
-                retainAfterTerminal: true,
-            }),
+        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,
-            runtimeTurn: runtimeTurn.turn,
-            settle: runtimeTurn.settle,
-            turnId: null,
-            pendingSubmissions: 0,
-            nextSubmissionIndex: 0,
-            acceptedTurnIds: new Map(),
-            pendingNativeTurnIds: new Set(),
-            completedNativeTurns: new Map(),
-            nativeFailures: new Map(),
-            lastSubmissionError: null,
-            stopped: false,
+            completion: null,
+            terminal: null,
+            releaseAfterAdmissions: null,
         };
-        this.activeTurnSlot = slot;
-        return { slot, primary: true };
-    }
-    recordTurnStartSuccess(slot, turnId, submissionIndex) {
-        slot.pendingSubmissions = Math.max(0, slot.pendingSubmissions - 1);
-        if (this.stopped) {
-            slot.settle({ status: 'stopped' });
+        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;
         }
-        slot.acceptedTurnIds.set(submissionIndex, turnId);
-        slot.turnId ??= turnId;
-        this.trackTurn(turnId, slot.collector, slot);
-        this.finalizeSlotIfReady(slot);
-    }
-    recordTurnStartFailure(slot, error) {
-        slot.pendingSubmissions = Math.max(0, slot.pendingSubmissions - 1);
-        slot.lastSubmissionError = error;
-        this.finalizeSlotIfReady(slot);
+        if (record.completion !== null)
+            deferred.settle({ kind: 'completion', completion: record.completion });
+        this.drainTerminalOrder();
     }
-    /**
-     * 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 (slot.pendingNativeTurnIds.has(turnId))
+    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;
-        slot.pendingNativeTurnIds.add(turnId);
-        this.pendingTurns.set(turnId, slot);
-        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)) {
-                pending.pendingNativeTurnIds.delete(turnId);
-                let completedTurn;
-                try {
-                    completedTurn = pending.codec === null
-                        ? turn
-                        : restoreCollectedTurn(turn, pending.codec);
-                }
-                catch (err) {
-                    pending.nativeFailures.set(turnId, asError(err));
-                    this.finalizeSlotIfReady(pending);
+        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;
-                }
-                pending.completedNativeTurns.set(turnId, completedTurn);
-                this.finalizeSlotIfReady(pending);
-            }
-        }, (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)) {
-                slot.pendingNativeTurnIds.delete(turnId);
-                slot.nativeFailures.set(turnId, err instanceof Error ? err : new Error(String(err)));
-                this.finalizeSlotIfReady(slot);
+                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);
+        }
     }
-    finalizeSlotIfReady(slot) {
-        if (slot.stopped ||
-            slot.pendingSubmissions !== 0 ||
-            slot.pendingNativeTurnIds.size !== 0) {
+    finalize(turnId, record, terminal) {
+        if (record.completion !== null)
             return;
-        }
-        const accepted = [...slot.acceptedTurnIds.entries()]
-            .sort(([left], [right]) => left - right);
-        if (accepted.length === 0 && slot.lastSubmissionError === null)
+        if (record.representative === null)
             return;
-        if (this.activeTurnSlot === slot)
-            this.activeTurnSlot = null;
-        slot.collector.dispose();
-        slot.codec = null;
-        const nativeFailure = accepted
-            .map(([, turnId]) => slot.nativeFailures.get(turnId))
-            .find((error) => error !== undefined);
-        if (nativeFailure !== undefined) {
-            slot.settle({ status: 'failed', error: nativeFailure });
-        }
-        else if (accepted.length === 0) {
-            slot.settle({ status: 'failed', error: slot.lastSubmissionError });
+        let completion;
+        if (terminal instanceof Error) {
+            completion = Object.freeze({ status: 'failed', displaySubmission: record.representative, error: terminal });
         }
         else {
-            const finalTurnId = accepted.at(-1)[1];
-            const finalTurn = slot.completedNativeTurns.get(finalTurnId);
-            if (finalTurn === undefined) {
-                throw new Error(`codex logical Turn lost terminal output for native turn ${finalTurnId}`);
+            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?.(finalTurn);
-            slot.settle({
+            this.opts.onTurnCompleted?.(completedTurn);
+            completion = Object.freeze({
                 status: 'completed',
-                resultText: extractAssistantText(finalTurn),
+                displaySubmission: record.representative,
+                resultText: extractAssistantText(completedTurn),
                 truncated: false,
             });
         }
+        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();
     }
+    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);
+        }
+        this.resolveIdleWaitersIfIdle();
+    }
+    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);
+        }
+    }
+    releaseRecordIfReady(turnId, record) {
+        if (record.completion === null || (record.releaseAfterAdmissions?.size ?? 0) > 0)
+            return;
+        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);
+        }
+        this.unboundObservedTurnIds.clear();
+    }
+    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;
+        this.emitActivity(record, activity, occurredAt);
+    }
+    emitActivity(record, activity, occurredAt) {
+        if (record.representative === null)
+            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)) {
+        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),
-        }));
+        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') {
+            if (admission.status === 'submitted' || admission.status === 'ambiguous') {
                 committed.add(sourceId);
                 order.push(sourceId);
                 while (order.length > this.messageIdDedupeWindow) {
@@ -328,6 +361,8 @@ export class TurnManager {
         this.pendingAdmissions.add(admission);
         void admission.finally(() => {
             this.pendingAdmissions.delete(admission);
+            this.drainTerminalOrder();
+            this.resolveIdleWaitersIfIdle();
         }).catch(() => undefined);
         return admission;
     }
@@ -340,58 +375,83 @@ 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 failed: 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) {
+    if (!replaced)
         throw new Error('codex outputSchema restoration failed: assistant JSON text was not found');
-    }
     return { ...turn, items };
 }
 function asError(error) {
     return error instanceof Error ? error : new Error(String(error));
 }
-function createRuntimeTurn() {
-    let resolve;
-    let settled = false;
-    const turn = Object.freeze({
-        settled: new Promise((value) => {
-            resolve = value;
-        }),
-    });
-    return {
-        turn,
-        settle(outcome) {
-            if (settled)
-                return false;
-            settled = true;
-            resolve(outcome);
-            return true;
-        },
-    };
-}
 //# sourceMappingURL=turn-manager.js.map