@orion-agents/orion-code 0.1.8 → 0.2.0

package/dist/runtime/thread-runtime.js

@@ -0,0 +1,704 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadRuntimeV1 = void 0;
+const runtime_event_buffer_1 = require("./runtime-event-buffer");
+const thread_admission_1 = require("./thread-admission");
+const runtime_protocol_v1_1 = require("./protocol/runtime-protocol-v1");
+class ThreadRuntimeV1 {
+    constructor(options) {
+        this.consumers = new Map();
+        this.compactMaintenance = new Map();
+        this.goalControlTurns = new Map();
+        this.queuedGoalControls = new Map();
+        this.idleWaiters = new Set();
+        this.closed = false;
+        this.store = options.store;
+        this.threadId = options.store.threadId;
+        this.runner = options.runner;
+        this.maintenanceRunner = options.maintenanceRunner;
+        this.idFactory = options.idFactory ?? runtime_protocol_v1_1.createRuntimeId;
+        this.requireTurnCommit = options.requireTurnCommit === true;
+        this.onTurnStarted = options.onTurnStarted;
+        this.onTurnDurablyTerminal = options.onTurnDurablyTerminal;
+        this.onTurnSettled = options.onTurnSettled;
+        this.admission = new thread_admission_1.ThreadAdmissionControllerV1({
+            ...options.admission,
+            idFactory: this.idFactory,
+        });
+        this.unsubscribeStore = this.store.subscribeCommitted(events => this.publish(events));
+        let projection = this.store.loadProjection();
+        if (projection.cursor === 0) {
+            projection = this.commitAndPublish([
+                {
+                    payload: {
+                        type: 'thread.started',
+                        data: options.projectPath ? { projectPath: options.projectPath } : {},
+                    },
+                },
+            ]).projection;
+        }
+        else if (projection.activeTurnId && options.recoverIncomplete !== false) {
+            projection = this.store.recoverIncomplete();
+        }
+        this.admission.restore({
+            queue: projection.queue.map(item => ({
+                queueId: item.queueId,
+                input: item.input,
+                inputBytes: Buffer.byteLength(item.input, 'utf8'),
+                mode: item.mode,
+                kind: item.kind,
+                source: item.source,
+                enqueuedAt: item.enqueuedAt,
+                deadline: item.deadline,
+            })),
+            queuedBytes: projection.queue.reduce((total, item) => total + Buffer.byteLength(item.input, 'utf8'), 0),
+            continuationMode: latestContinuationMode(projection),
+            shutdown: false,
+        });
+        if (projection.queue.length > 0) {
+            queueMicrotask(() => this.promoteQueuedTurn());
+        }
+    }
+    dispatch(command) {
+        if (this.closed)
+            return { status: 'rejected', reason: 'shutdown' };
+        const before = this.admission.getSnapshot();
+        const result = this.admission.admit(command);
+        if (result.status === 'rejected')
+            return result;
+        try {
+            switch (result.status) {
+                case 'started': {
+                    const active = this.requiredActiveTurn(result.turnId);
+                    this.persistTurnStart(active);
+                    this.scheduleTurn(active);
+                    break;
+                }
+                case 'queued': {
+                    const queued = this.admission
+                        .getSnapshot()
+                        .queue.find(item => item.queueId === result.queueId);
+                    if (!queued)
+                        throw new Error(`Queued turn ${result.queueId} disappeared before commit`);
+                    this.commitAndPublish([
+                        {
+                            payload: {
+                                type: 'turn.queued',
+                                data: {
+                                    queueId: queued.queueId,
+                                    input: queued.input,
+                                    mode: queued.mode,
+                                    kind: queued.kind,
+                                    source: queued.source,
+                                    enqueuedAt: queued.enqueuedAt,
+                                    deadline: queued.deadline,
+                                },
+                            },
+                        },
+                    ]);
+                    break;
+                }
+                case 'steered': {
+                    if (command.type !== 'turn.steer') {
+                        throw new Error('Admission returned steered for a non-steer command');
+                    }
+                    const steerInput = command.data.input;
+                    const stepId = this.idFactory();
+                    this.commitAndPublish([
+                        {
+                            turnId: result.activeTurnId,
+                            payload: {
+                                type: 'turn.steered',
+                                data: { itemId: result.itemId, input: steerInput },
+                            },
+                        },
+                        {
+                            turnId: result.activeTurnId,
+                            stepId,
+                            itemId: result.itemId,
+                            payload: { type: 'item.started', data: { kind: 'message', role: 'user' } },
+                        },
+                        {
+                            turnId: result.activeTurnId,
+                            stepId,
+                            itemId: result.itemId,
+                            payload: { type: 'item.completed', data: { content: steerInput } },
+                        },
+                    ]);
+                    void Promise.resolve(this.steerHandler?.(steerInput, result.itemId)).catch(() => undefined);
+                    break;
+                }
+                case 'interrupt_requested':
+                    if (!result.alreadyRequested) {
+                        const reason = command.type === 'turn.interrupt' ? command.data.reason : undefined;
+                        this.commitAndPublish([
+                            {
+                                turnId: result.activeTurnId,
+                                payload: {
+                                    type: 'turn.interrupt_requested',
+                                    data: { intentId: result.intentId, ...(reason ? { reason } : {}) },
+                                },
+                            },
+                        ]);
+                        // The durable intent is flushed before AbortSignal is propagated.
+                        this.activeAbort?.abort(reason ?? 'thread interrupted');
+                    }
+                    break;
+            }
+            return result;
+        }
+        catch (error) {
+            this.admission.restore(before);
+            throw error;
+        }
+    }
+    startMaintenance(input) {
+        if (this.closed)
+            return { status: 'rejected', reason: 'shutdown' };
+        const before = this.admission.getSnapshot();
+        const result = this.admission.start({ input, mode: 'maintenance', kind: 'maintenance' });
+        try {
+            if (result.status === 'started') {
+                const active = this.requiredActiveTurn(result.turnId);
+                this.persistTurnStart(active);
+                this.scheduleTurn(active);
+            }
+            else if (result.status === 'queued') {
+                this.persistQueuedTurn(result.queueId);
+            }
+            return result;
+        }
+        catch (error) {
+            this.admission.restore(before);
+            throw error;
+        }
+    }
+    /**
+     * Serialize a Goal control mutation through the same bounded admission and
+     * durable terminal lane as every other Thread turn. The callback owns no
+     * scheduling; it must write its TurnCommit before returning completed.
+     */
+    startGoalControl(request) {
+        if (this.closed)
+            return { status: 'rejected', reason: 'shutdown' };
+        const before = this.admission.getSnapshot();
+        const result = this.admission.start({
+            input: request.input,
+            mode: 'maintenance',
+            kind: 'maintenance',
+        });
+        try {
+            if (result.status === 'started') {
+                this.goalControlTurns.set(result.turnId, request);
+                const active = this.requiredActiveTurn(result.turnId);
+                this.persistTurnStart(active);
+                this.scheduleTurn(active);
+            }
+            else if (result.status === 'queued') {
+                this.queuedGoalControls.set(result.queueId, request);
+                this.persistQueuedTurn(result.queueId);
+            }
+            return result;
+        }
+        catch (error) {
+            if (result.status === 'started')
+                this.goalControlTurns.delete(result.turnId);
+            if (result.status === 'queued')
+                this.queuedGoalControls.delete(result.queueId);
+            this.admission.restore(before);
+            throw error;
+        }
+    }
+    /** Start an explicit Compact maintenance transaction only from an idle boundary. */
+    startCompactMaintenance(request, input = 'compact:explicit') {
+        if (this.closed)
+            return { status: 'rejected', reason: 'shutdown' };
+        if (!this.maintenanceRunner)
+            throw new Error('Compact maintenance runner is not configured');
+        const snapshot = this.admission.getSnapshot();
+        if (snapshot.activeTurn)
+            return { status: 'rejected', reason: 'non_steerable' };
+        if (snapshot.queue.length > 0)
+            return { status: 'rejected', reason: 'overloaded' };
+        const result = this.admission.start({ input, mode: 'maintenance', kind: 'maintenance' });
+        if (result.status !== 'started')
+            return result;
+        try {
+            this.compactMaintenance.set(result.turnId, request);
+            const active = this.requiredActiveTurn(result.turnId);
+            this.persistTurnStart(active);
+            this.scheduleTurn(active);
+            return result;
+        }
+        catch (error) {
+            this.compactMaintenance.delete(result.turnId);
+            this.admission.restore(snapshot);
+            throw error;
+        }
+    }
+    subscribe(consumerId, cursor = this.store.getCursor(), options = {}) {
+        if (this.consumers.has(consumerId))
+            throw new Error(`Consumer already exists: ${consumerId}`);
+        const buffer = new runtime_event_buffer_1.RuntimeEventBufferV1(this.threadId, { ...options, initialCursor: cursor });
+        this.consumers.set(consumerId, buffer);
+        return buffer;
+    }
+    unsubscribe(consumerId) {
+        this.consumers.delete(consumerId);
+    }
+    replay(cursor = 0, limit) {
+        return this.store.replay(cursor, limit);
+    }
+    getProjection() {
+        return this.store.loadProjection();
+    }
+    getAdmissionSnapshot() {
+        return this.admission.getSnapshot();
+    }
+    async waitForIdle() {
+        if (!this.admission.getSnapshot().activeTurn && !this.activeRun)
+            return;
+        await new Promise(resolve => this.idleWaiters.add(resolve));
+    }
+    async waitForTurnTerminal(turnId) {
+        const current = terminalStatus(this.store.loadProjection().turns[turnId]?.status);
+        if (current)
+            return current;
+        return new Promise(resolve => {
+            let settled = false;
+            const finish = (status) => {
+                if (settled)
+                    return;
+                settled = true;
+                unsubscribe();
+                resolve(status);
+            };
+            const unsubscribe = this.store.subscribeCommitted(events => {
+                for (const event of events) {
+                    if (event.turnId !== turnId)
+                        continue;
+                    const status = terminalEventStatus(event);
+                    if (status)
+                        finish(status);
+                }
+            });
+            const raced = terminalStatus(this.store.loadProjection().turns[turnId]?.status);
+            if (raced)
+                finish(raced);
+        });
+    }
+    close(reason = 'runtime shutdown') {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.deferredGoalContinuation = undefined;
+        for (const request of this.queuedGoalControls.values())
+            request.onRejected?.('shutdown');
+        this.goalControlTurns.clear();
+        this.queuedGoalControls.clear();
+        this.admission.close();
+        this.activeAbort?.abort(reason);
+        this.consumers.clear();
+        this.unsubscribeStore();
+    }
+    /** Runtime-owned entry for a recovered Goal; public input still uses dispatch(). */
+    startGoalContinuation(request) {
+        if (this.closed)
+            return { status: 'rejected', reason: 'shutdown' };
+        if (request.mode !== 'goal' || request.kind !== 'goal') {
+            return { status: 'rejected', reason: 'invalid_input' };
+        }
+        const before = this.admission.getSnapshot();
+        const result = this.admission.start(request);
+        try {
+            if (result.status === 'started') {
+                const active = this.requiredActiveTurn(result.turnId);
+                this.persistTurnStart(active);
+                this.scheduleTurn(active);
+            }
+            else if (result.status === 'queued') {
+                this.persistQueuedTurn(result.queueId);
+            }
+            return result;
+        }
+        catch (error) {
+            this.admission.restore(before);
+            throw error;
+        }
+    }
+    persistTurnStart(active, queueId) {
+        const stepId = this.idFactory();
+        const itemId = this.idFactory();
+        const inputs = [
+            {
+                turnId: active.turnId,
+                payload: {
+                    type: 'turn.started',
+                    data: {
+                        input: active.input,
+                        mode: active.mode,
+                        ...(queueId ? { queueId } : {}),
+                    },
+                },
+            },
+        ];
+        if (active.kind !== 'maintenance') {
+            inputs.push({
+                turnId: active.turnId,
+                stepId,
+                itemId,
+                payload: { type: 'item.started', data: { kind: 'message', role: 'user' } },
+            });
+            inputs.push({
+                turnId: active.turnId,
+                stepId,
+                itemId,
+                payload: { type: 'item.completed', data: { content: active.input } },
+            });
+        }
+        this.commitAndPublish(inputs);
+        try {
+            this.onTurnStarted?.({
+                turnId: active.turnId,
+                input: active.input,
+                mode: active.mode,
+                kind: active.kind,
+                startedAt: active.startedAt,
+            });
+        }
+        catch {
+            // Timing is an observation only; a durable turn.start cannot be rolled back.
+        }
+    }
+    scheduleTurn(active) {
+        if (this.activeRun)
+            throw new Error('ThreadRuntime attempted to schedule a second active run');
+        const abortController = new AbortController();
+        this.activeAbort = abortController;
+        this.activeTurnId = active.turnId;
+        const context = this.createExecutionContext(active, abortController.signal);
+        const compactRequest = this.compactMaintenance.get(active.turnId);
+        const goalControlRequest = this.goalControlTurns.get(active.turnId);
+        this.activeRun = Promise.resolve()
+            .then(() => {
+            if (goalControlRequest)
+                return goalControlRequest.run(context);
+            if (compactRequest) {
+                if (!this.maintenanceRunner)
+                    throw new Error('Compact maintenance runner is missing');
+                return this.maintenanceRunner.run(compactRequest, context);
+            }
+            return this.runner.run(context);
+        })
+            .then(outcome => this.finalizeTurn(active, normalizeOutcome(outcome, abortController)))
+            .catch(error => this.finalizeTurn(active, {
+            status: abortController.signal.aborted ? 'interrupted' : 'failed',
+            error: error instanceof Error ? error.message : String(error),
+        }))
+            .finally(async () => {
+            try {
+                await this.onTurnSettled?.(active.turnId);
+            }
+            catch {
+                // The resource owner remains fail-closed; no lease is handed to the
+                // next turn even if teardown diagnostics fail.
+            }
+            this.activeRun = undefined;
+            this.activeAbort = undefined;
+            this.activeTurnId = undefined;
+            this.steerHandler = undefined;
+            this.compactMaintenance.delete(active.turnId);
+            this.goalControlTurns.delete(active.turnId);
+            const next = this.admission.getSnapshot().activeTurn;
+            if (this.closed && next)
+                this.admission.finish(next.turnId);
+            else if (next)
+                this.scheduleTurn(next);
+            else
+                this.promoteQueuedTurn();
+            this.resolveIdleIfNeeded();
+        });
+    }
+    createExecutionContext(active, abortSignal) {
+        return {
+            threadId: this.threadId,
+            turnId: active.turnId,
+            input: active.input,
+            mode: active.mode,
+            kind: active.kind,
+            abortSignal,
+            startItem: input => {
+                const handle = {
+                    turnId: active.turnId,
+                    stepId: input.stepId ?? this.idFactory(),
+                    itemId: input.itemId ?? this.idFactory(),
+                };
+                this.commitAndPublish([
+                    {
+                        ...handle,
+                        payload: {
+                            type: 'item.started',
+                            data: {
+                                kind: input.kind,
+                                ...(input.role ? { role: input.role } : {}),
+                                ...(input.name ? { name: input.name } : {}),
+                                ...(input.inputDigest ? { inputDigest: input.inputDigest } : {}),
+                            },
+                        },
+                    },
+                ]);
+                return handle;
+            },
+            emitDelta: (handle, delta, channel = 'content') => {
+                const event = this.store.createEphemeral({
+                    ...handle,
+                    payload: { type: 'item.delta', data: { delta, channel } },
+                });
+                this.publish([event]);
+            },
+            completeItem: (handle, input = {}) => {
+                this.commitAndPublish([
+                    {
+                        ...handle,
+                        payload: {
+                            type: 'item.completed',
+                            data: {
+                                ...(input.content === undefined ? {} : { content: input.content }),
+                                ...(input.summary === undefined ? {} : { summary: input.summary }),
+                                ...(input.outputDigest === undefined ? {} : { outputDigest: input.outputDigest }),
+                            },
+                        },
+                    },
+                ]);
+            },
+            failItem: (handle, error) => {
+                this.commitAndPublish([{ ...handle, payload: { type: 'item.failed', data: { error } } }]);
+            },
+            onSteer: handler => {
+                this.steerHandler = handler;
+            },
+        };
+    }
+    finalizeTurn(active, outcome) {
+        const turnId = active.turnId;
+        const goalControl = this.goalControlTurns.has(turnId);
+        let terminalPublished = false;
+        try {
+            if (this.requireTurnCommit && (active.kind !== 'maintenance' || goalControl)) {
+                const committed = this.store.loadProjection().turns[turnId]?.commit;
+                if (!committed)
+                    throw new Error(`Turn ${turnId} has no durable TurnCommitV1`);
+                if (committed.terminal !== outcome.status) {
+                    throw new Error(`Turn ${turnId} outcome ${outcome.status} conflicts with committed ${committed.terminal}`);
+                }
+            }
+            if (outcome.status === 'completed') {
+                this.commitAndPublish([
+                    {
+                        turnId,
+                        payload: {
+                            type: 'turn.completed',
+                            data: outcome.outcome === undefined ? {} : { outcome: outcome.outcome },
+                        },
+                    },
+                ]);
+            }
+            else if (outcome.status === 'failed') {
+                this.commitAndPublish([
+                    {
+                        turnId,
+                        payload: { type: 'turn.failed', data: { error: outcome.error } },
+                    },
+                ]);
+            }
+            else {
+                this.commitAndPublish([
+                    {
+                        turnId,
+                        payload: {
+                            type: 'turn.interrupted',
+                            data: (() => {
+                                const reason = 'error' in outcome ? outcome.error : outcome.reason;
+                                return reason === undefined ? {} : { reason };
+                            })(),
+                        },
+                    },
+                ]);
+            }
+            terminalPublished = true;
+        }
+        catch {
+            // A runner that exits with open Items cannot publish a false turn
+            // terminal. Recovery marks those Items indeterminate first.
+            this.store.recoverIncomplete('turn_finished_with_uncommitted_items');
+        }
+        const terminal = outcome.status;
+        let continuation;
+        if (terminalPublished && !this.closed) {
+            try {
+                continuation = this.onTurnDurablyTerminal?.({
+                    turnId,
+                    input: active.input,
+                    mode: active.mode,
+                    kind: active.kind,
+                    terminal,
+                });
+            }
+            catch {
+                // Goal continuation is fail-closed. The durable terminal remains authoritative.
+            }
+        }
+        if (active.kind !== 'maintenance')
+            this.deferredGoalContinuation = undefined;
+        const maintenance = terminalPublished && active.kind !== 'maintenance' && outcome.status === 'completed'
+            ? outcome.maintenance
+            : undefined;
+        if (maintenance && continuation) {
+            this.deferredGoalContinuation = continuation;
+            continuation = undefined;
+        }
+        else if (active.kind === 'maintenance' && !goalControl) {
+            continuation = terminal === 'completed' ? this.deferredGoalContinuation : undefined;
+            this.deferredGoalContinuation = undefined;
+        }
+        const finish = maintenance
+            ? this.admission.finishAndStartPriority(turnId, {
+                input: `compact:${maintenance.source}`,
+                mode: 'maintenance',
+                kind: 'maintenance',
+            })
+            : this.admission.finish(turnId);
+        if (finish.status === 'rejected')
+            throw new Error(`Admission lost active turn ${turnId}`);
+        for (const queueId of finish.expiredQueueIds) {
+            this.rejectQueuedGoalControl(queueId, 'deadline_expired');
+            this.commitAndPublish([{ payload: { type: 'turn.queue_expired', data: { queueId } } }]);
+        }
+        if (finish.status === 'started') {
+            if (maintenance)
+                this.compactMaintenance.set(finish.turnId, maintenance);
+            this.promoteQueuedGoalControl(finish.turnId, finish.queueId);
+            const active = this.requiredActiveTurn(finish.turnId);
+            this.persistTurnStart(active, finish.queueId);
+        }
+        else if (finish.status === 'idle' && continuation && !this.closed) {
+            const started = this.admission.start(continuation);
+            if (started.status !== 'started') {
+                throw new Error('Goal continuation could not start from an idle durable boundary');
+            }
+            const next = this.requiredActiveTurn(started.turnId);
+            this.persistTurnStart(next);
+        }
+    }
+    promoteQueuedTurn() {
+        if (this.closed || this.activeRun || this.admission.getSnapshot().activeTurn)
+            return;
+        const result = this.admission.startNextQueued();
+        if (result.status === 'rejected')
+            return;
+        for (const queueId of result.expiredQueueIds) {
+            this.rejectQueuedGoalControl(queueId, 'deadline_expired');
+            this.commitAndPublish([{ payload: { type: 'turn.queue_expired', data: { queueId } } }]);
+        }
+        if (result.status === 'started') {
+            this.promoteQueuedGoalControl(result.turnId, result.queueId);
+            const active = this.requiredActiveTurn(result.turnId);
+            this.persistTurnStart(active, result.queueId);
+            this.scheduleTurn(active);
+        }
+    }
+    persistQueuedTurn(queueId) {
+        const queued = this.admission.getSnapshot().queue.find(item => item.queueId === queueId);
+        if (!queued)
+            throw new Error(`Queued maintenance turn ${queueId} disappeared before commit`);
+        this.commitAndPublish([
+            {
+                payload: {
+                    type: 'turn.queued',
+                    data: {
+                        queueId: queued.queueId,
+                        input: queued.input,
+                        mode: queued.mode,
+                        kind: queued.kind,
+                        source: queued.source,
+                        enqueuedAt: queued.enqueuedAt,
+                        deadline: queued.deadline,
+                    },
+                },
+            },
+        ]);
+    }
+    requiredActiveTurn(turnId) {
+        const active = this.admission.getSnapshot().activeTurn;
+        if (!active || active.turnId !== turnId)
+            throw new Error(`Active turn ${turnId} is missing`);
+        return active;
+    }
+    promoteQueuedGoalControl(turnId, queueId) {
+        if (!queueId)
+            return;
+        const request = this.queuedGoalControls.get(queueId);
+        if (!request)
+            return;
+        this.queuedGoalControls.delete(queueId);
+        this.goalControlTurns.set(turnId, request);
+    }
+    rejectQueuedGoalControl(queueId, reason) {
+        const request = this.queuedGoalControls.get(queueId);
+        this.queuedGoalControls.delete(queueId);
+        request?.onRejected?.(reason);
+    }
+    commitAndPublish(inputs) {
+        return this.store.appendDurableBatch(inputs);
+    }
+    publish(events) {
+        for (const event of events) {
+            for (const buffer of this.consumers.values())
+                buffer.offer(event);
+        }
+    }
+    resolveIdleIfNeeded() {
+        if (this.activeRun || this.admission.getSnapshot().activeTurn)
+            return;
+        for (const resolve of this.idleWaiters)
+            resolve();
+        this.idleWaiters.clear();
+    }
+}
+exports.ThreadRuntimeV1 = ThreadRuntimeV1;
+function normalizeOutcome(outcome, abortController) {
+    if (abortController.signal.aborted && outcome.status !== 'interrupted') {
+        return {
+            status: 'interrupted',
+            reason: typeof abortController.signal.reason === 'string'
+                ? abortController.signal.reason
+                : 'thread interrupted',
+        };
+    }
+    return outcome;
+}
+function terminalStatus(status) {
+    return status === 'completed' || status === 'failed' || status === 'interrupted'
+        ? status
+        : undefined;
+}
+function terminalEventStatus(event) {
+    switch (event.payload.type) {
+        case 'turn.completed':
+            return 'completed';
+        case 'turn.failed':
+            return 'failed';
+        case 'turn.interrupted':
+            return 'interrupted';
+        default:
+            return undefined;
+    }
+}
+function latestContinuationMode(projection) {
+    const mode = Object.values(projection.turns)
+        .filter(turn => turn.mode !== 'maintenance')
+        .sort((left, right) => left.startedSeq - right.startedSeq)
+        .at(-1)?.mode;
+    return mode === 'plan' || mode === 'auto' || mode === 'goal' ? mode : 'build';
+}
+//# sourceMappingURL=thread-runtime.js.map