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

package/dist/runtime.d.ts

@@ -1,6 +1,6 @@
 import { CodexProcess, type CodexProcessOptions } from './supervisor.js';
 import { CodexWsClient } from './rpc.js';
-import type { AgentRuntime, AgentRuntimeCapabilities, AgentRuntimeIdentity, AgentRuntimeLastResult, AgentRuntimePathContext, AgentRuntimeSkillSource, AgentRuntimeStateCallbacks, AgentRuntimeStatus, AgentRuntimeTextInput, AgentRuntimeTurnResult, DreamuxLogger, InboundTurnInput, TurnSettledSignal } from '@excitedjs/dreamux-types';
+import type { AgentRuntime, AgentRuntimeCapabilities, AgentRuntimeIdentity, AgentRuntimePathContext, AgentRuntimeSkillSource, AgentRuntimeStateCallbacks, AgentRuntimeStatus, AgentRuntimeTextInput, DreamuxLogger, InboundTurnInput, RuntimeAdmission, RuntimeActivitySink } from '@excitedjs/dreamux-types';
 export interface CodexRuntimeDeps {
     cwd: string;
     systemPromptReplace?: string;
@@ -22,8 +22,9 @@ export interface CodexRuntimeDeps {
     extraEnv?: Record<string, string>;
     restartBackoffBaseMs?: number;
     restartBackoffMaxMs?: number;
-    onTurnSettled?: (settled: TurnSettledSignal) => void;
+    validateTranscriptPath?: (path: string, threadId: string) => Promise<string>;
     logger?: DreamuxLogger;
+    activitySink: RuntimeActivitySink;
 }
 export declare class CodexRuntime implements AgentRuntime {
     readonly identity: AgentRuntimeIdentity;
@@ -33,14 +34,18 @@ export declare class CodexRuntime implements AgentRuntime {
     private client;
     private turnManager;
     private threadId;
+    private transcriptLocator;
     private threadResumed;
     private status;
     private readonly log;
     private stopping;
     private restarting;
+    private generation;
+    private startupTask;
+    private restartTask;
+    private stopTask;
     private restartAttempts;
     private restartTimer;
-    private lastResult;
     private readonly state;
     private readonly paths;
     constructor(identity: AgentRuntimeIdentity, deps: CodexRuntimeDeps);
@@ -49,20 +54,23 @@ export declare class CodexRuntime implements AgentRuntime {
     getCapabilities(): AgentRuntimeCapabilities;
     getCheckpoint(): {
         id: string;
+        transcript_locator?: string | null;
     } | null;
     wasCheckpointResumed(): boolean;
-    getLast(): Promise<AgentRuntimeLastResult | null>;
     getContext(): Promise<null>;
     resume(): Promise<void>;
     start(): Promise<void>;
+    private startRuntime;
     private startCodexRuntime;
     private applySkillExtraRoots;
     private resolveThread;
+    private validateThreadPath;
     private threadInstructionParams;
-    channelInput(input: InboundTurnInput): Promise<AgentRuntimeTurnResult>;
+    channelInput(input: InboundTurnInput): Promise<RuntimeAdmission>;
     waitIdle(): Promise<void>;
-    completionInput(input: AgentRuntimeTextInput): Promise<AgentRuntimeTurnResult>;
+    completionInput(input: AgentRuntimeTextInput): Promise<RuntimeAdmission>;
     stop(): Promise<void>;
+    private stopRuntime;
     private cleanupOnFailure;
     private teardownCodexRuntime;
     private handleChildExit;
@@ -72,7 +80,7 @@ export declare class CodexRuntime implements AgentRuntime {
     private restartDelayMs;
     private clearRestartTimer;
     private markReady;
-    private recordCollectedTurn;
     private setStatus;
+    private assertGeneration;
 }
 //# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}

package/dist/runtime.js

@@ -3,13 +3,13 @@ import { CodexProcess, } from './supervisor.js';
 import { CodexWsClient } from './rpc.js';
 import { performInitializeHandshake } from './handshake.js';
 import { TurnManager, } from './turn-manager.js';
-import { extractAssistantText, } from './events.js';
 import { renderChannelInput } from '@excitedjs/dreamux-utils';
 import { createFailFastApprovalHandler } from './approval.js';
 import { BUILTIN_CODEX_PROVIDER_REF } from './provider-ref.js';
 import { CODEX_AGENT_RUNTIME_CAPABILITIES } from './provider.js';
 import { codexProcessEnv, renderCodexSystemPromptAppend, } from './runtime-support.js';
 import { applyCodexSkillExtraRoots } from './skill-roots.js';
+import { resolveCodexTranscriptRoots, validateCodexThreadPath, } from './transcript/path.js';
 const DEFAULT_RESTART_BACKOFF_BASE_MS = 1000;
 const DEFAULT_RESTART_BACKOFF_MAX_MS = 30_000;
 export class CodexRuntime {
@@ -20,14 +20,18 @@ export class CodexRuntime {
     client = null;
     turnManager = null;
     threadId = null;
+    transcriptLocator = null;
     threadResumed = false;
     status = 'declared';
     log;
     stopping = false;
     restarting = false;
+    generation = 0;
+    startupTask = null;
+    restartTask = null;
+    stopTask = null;
     restartAttempts = 0;
     restartTimer = null;
-    lastResult = null;
     state;
     paths;
     constructor(identity, deps) {
@@ -44,7 +48,9 @@ export class CodexRuntime {
                     else
                         console.error(prefix, msg);
                 };
-        this.threadId = identity.checkpoint_id ?? null;
+        this.threadId = identity.checkpoint?.id ?? null;
+        this.transcriptLocator =
+            identity.checkpoint?.transcript_locator ?? null;
         this.state = deps.state;
         this.paths = deps.paths;
     }
@@ -58,49 +64,91 @@ export class CodexRuntime {
         return CODEX_AGENT_RUNTIME_CAPABILITIES;
     }
     getCheckpoint() {
-        return this.threadId === null ? null : { id: this.threadId };
+        if (this.threadId === null)
+            return null;
+        return {
+            id: this.threadId,
+            transcript_locator: this.transcriptLocator,
+        };
     }
     wasCheckpointResumed() {
         return this.threadResumed;
     }
-    async getLast() {
-        return this.lastResult;
-    }
     async getContext() {
         return null;
     }
     async resume() {
         await this.start();
     }
-    async start() {
-        this.stopping = false;
+    start() {
+        if (this.startupTask !== null)
+            return this.startupTask;
+        if (this.stopping || this.stopTask !== null || this.status === 'stopped') {
+            return Promise.reject(new Error('codex runtime is stopped'));
+        }
+        if (this.status === 'ready')
+            return Promise.resolve();
         this.restarting = false;
+        this.generation += 1;
         this.clearRestartTimer();
+        const generation = this.generation;
+        const task = this.startRuntime(generation);
+        this.startupTask = task;
+        void task.finally(() => {
+            if (this.startupTask === task)
+                this.startupTask = null;
+        }).catch(() => undefined);
+        return task;
+    }
+    async startRuntime(generation) {
         this.setStatus('starting');
         await this.state.setStatus('starting', {
             last_started_at: Date.now(),
         });
         try {
-            await this.startCodexRuntime();
-            await this.markReady();
+            await this.startCodexRuntime(generation);
+            this.assertGeneration(generation);
+            await this.markReady(generation);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             this.log('error', `start failed: ${msg}`, err);
-            this.setStatus('degraded');
-            await this.state.setStatus('degraded', {
-                last_error: msg,
-            });
-            await this.cleanupOnFailure();
+            const failures = [err];
+            if (!this.stopping && generation === this.generation) {
+                this.setStatus('degraded');
+                try {
+                    await this.state.setStatus('degraded', {
+                        last_error: msg,
+                    });
+                }
+                catch (stateError) {
+                    failures.push(stateError);
+                }
+            }
+            try {
+                await this.cleanupOnFailure();
+            }
+            catch (cleanupError) {
+                failures.push(cleanupError);
+            }
+            if (failures.length > 1) {
+                const failureDetails = failures.slice(1).map((failure) => failure instanceof Error ? failure.message : String(failure)).join('; ');
+                throw new AggregateError(failures, `codex runtime start failed and cleanup did not fully converge: ${failureDetails}`);
+            }
             throw err;
         }
     }
-    async startCodexRuntime() {
+    async startCodexRuntime(generation) {
+        this.assertGeneration(generation);
+        if (this.process !== null) {
+            throw new Error('codex runtime retains an unterminated process from a prior attempt');
+        }
         const cwd = this.deps.cwd;
         const socketPath = this.deps.allocateSocketPath(this.dispatcherId);
         const extraArgs = this.deps.resolveExtraArgs?.() ?? [];
         if (this.deps.codexHomeDoctor !== undefined) {
             await this.deps.codexHomeDoctor({ runtimeId: this.dispatcherId, cwd });
+            this.assertGeneration(generation);
         }
         const codexLogDir = join(this.paths.logsDir(), 'codex-app-server');
         const factory = this.deps.codexProcessFactory ?? ((o) => new CodexProcess(o));
@@ -120,6 +168,7 @@ export class CodexRuntime {
             this.handleChildExit(exit);
         });
         await process.start();
+        this.assertGeneration(generation);
         const clientFactory = this.deps.codexClientFactory ?? ((sock) => new CodexWsClient({ socketPath: sock }));
         const client = clientFactory(socketPath);
         this.client = client;
@@ -129,6 +178,7 @@ export class CodexRuntime {
             this.handleClientClose(reason);
         });
         await client.ready();
+        this.assertGeneration(generation);
         const approvalHandler = createFailFastApprovalHandler({
             onReject: async (req) => {
                 this.log('warn', `rejected Codex approval request '${req.method}'; Feishu outbound is MCP reply-only`);
@@ -140,16 +190,18 @@ export class CodexRuntime {
                 ? { timeoutMs: this.deps.handshakeTimeoutMs }
                 : {}),
         });
+        this.assertGeneration(generation);
         this.log('info', `codex initialized: ${initResponse.userAgent} (home=${initResponse.codexHome}, ${initResponse.platformOs})`);
         await this.applySkillExtraRoots();
-        await this.resolveThread();
+        this.assertGeneration(generation);
+        await this.resolveThread(generation);
+        this.assertGeneration(generation);
         this.turnManager = new TurnManager({
             dispatcherId: this.dispatcherId,
             getThreadId: () => this.threadId,
             client: this.client,
-            onTurnCompleted: (turn) => this.recordCollectedTurn(turn),
-            onTurnSettled: this.deps.onTurnSettled,
             log: this.log,
+            activitySink: this.deps.activitySink,
         });
     }
     async applySkillExtraRoots() {
@@ -161,47 +213,88 @@ export class CodexRuntime {
             log: this.log,
         });
     }
-    async resolveThread() {
+    async resolveThread(generation) {
         if (this.client === null)
             throw new Error('client not initialized');
         this.threadResumed = false;
         const threadInstructions = this.threadInstructionParams();
-        const existing = this.threadId ?? this.identity.checkpoint_id ?? null;
+        const existing = this.threadId ?? this.identity.checkpoint?.id ?? null;
         if (existing === null) {
             const params = {
                 ...threadInstructions,
             };
             const res = await this.client.request('thread/start', params);
-            this.threadId = res.thread.id;
-            await this.state.setCheckpoint({ id: this.threadId });
+            this.assertGeneration(generation);
+            const candidateThreadId = res.thread.id;
+            const transcript = await this.validateThreadPath(res.thread.path, candidateThreadId);
+            await this.state.setCheckpoint({
+                id: candidateThreadId,
+                transcript_locator: transcript.path,
+            });
+            this.assertGeneration(generation);
+            this.threadId = candidateThreadId;
+            this.transcriptLocator = transcript.path;
             this.log('info', `started fresh thread ${this.threadId}`);
             return;
         }
+        let resumed;
         try {
             const params = {
                 threadId: existing,
                 ...threadInstructions,
             };
-            await this.client.request('thread/resume', params);
-            this.threadId = existing;
-            this.threadResumed = true;
-            this.log('info', `resumed thread ${this.threadId}`);
+            resumed = await this.client.request('thread/resume', params);
         }
         catch (err) {
+            this.assertGeneration(generation);
             const msg = err instanceof Error ? err.message : String(err);
             this.log('warn', `thread/resume failed for ${existing}: ${msg}; starting fresh thread`);
             const res = await this.client.request('thread/start', { ...threadInstructions });
-            this.threadId = res.thread.id;
+            this.assertGeneration(generation);
+            const replacementThreadId = res.thread.id;
+            const transcript = await this.validateThreadPath(res.thread.path, replacementThreadId);
+            const replacement = {
+                id: replacementThreadId,
+                transcript_locator: transcript.path,
+            };
             if (this.state.recordLostCheckpoint !== undefined) {
-                await this.state.recordLostCheckpoint({ id: existing }, { id: this.threadId }, `thread/resume failed: ${msg}`);
+                await this.state.recordLostCheckpoint({
+                    id: existing,
+                    transcript_locator: this.transcriptLocator,
+                }, replacement, `thread/resume failed: ${msg}`);
             }
             else {
-                await this.state.setCheckpoint({ id: this.threadId });
+                await this.state.setCheckpoint(replacement);
                 await this.state.setStatus('degraded', {
                     last_error: `thread/resume failed: ${msg}`,
                 });
             }
+            this.assertGeneration(generation);
+            this.threadId = replacementThreadId;
+            this.transcriptLocator = transcript.path;
+            return;
+        }
+        this.assertGeneration(generation);
+        const resumedThreadId = resumed.thread.id;
+        const transcript = await this.validateThreadPath(resumed.thread.path, resumedThreadId);
+        await this.state.setCheckpoint({
+            id: resumedThreadId,
+            transcript_locator: transcript.path,
+        });
+        this.assertGeneration(generation);
+        this.threadId = resumedThreadId;
+        this.transcriptLocator = transcript.path;
+        this.threadResumed = true;
+        this.log('info', `resumed thread ${this.threadId}`);
+    }
+    validateThreadPath(path, threadId) {
+        if (path === null || path === undefined) {
+            throw new Error('Codex thread response omitted the native transcript path');
+        }
+        if (this.deps.validateTranscriptPath !== undefined) {
+            return this.deps.validateTranscriptPath(path, threadId).then((validatedPath) => ({ path: validatedPath }));
         }
+        return resolveCodexTranscriptRoots(codexProcessEnv(this.deps.injectEnv, this.deps.extraEnv)).then((roots) => validateCodexThreadPath(path, threadId, roots));
     }
     threadInstructionParams() {
         const params = {};
@@ -217,6 +310,9 @@ export class CodexRuntime {
         return params;
     }
     async channelInput(input) {
+        if (this.stopping || this.status === 'stopped') {
+            return { status: 'stopped' };
+        }
         if (this.turnManager === null) {
             return { status: 'failed', error: new Error('turn manager not initialized') };
         }
@@ -226,18 +322,47 @@ export class CodexRuntime {
         return this.turnManager?.waitIdle() ?? Promise.resolve();
     }
     async completionInput(input) {
-        if (this.turnManager === null)
+        if (this.stopping || this.status === 'stopped') {
             return { status: 'stopped' };
+        }
+        if (this.turnManager === null) {
+            return { status: 'failed', error: new Error('turn manager not initialized') };
+        }
         return this.turnManager.submitTextInput(input);
     }
-    async stop() {
-        this.stopping = true;
+    stop() {
+        if (this.status === 'stopped')
+            return Promise.resolve();
+        if (this.stopTask !== null)
+            return this.stopTask;
+        if (!this.stopping) {
+            this.stopping = true;
+            this.generation += 1;
+        }
         this.clearRestartTimer();
+        const task = this.stopRuntime();
+        this.stopTask = task;
+        void task.catch(() => {
+            if (this.stopTask === task)
+                this.stopTask = null;
+        });
+        return task;
+    }
+    async stopRuntime() {
         this.setStatus('stopping');
-        await this.state.setStatus('stopping');
-        await this.teardownCodexRuntime();
-        this.setStatus('stopped');
+        // Teardown must be initiated before any status/start/restart join. Closing
+        // the client is what rejects stuck ready/RPC admissions; the generation
+        // fence prevents pre-authority startup work from publishing later.
+        const teardown = this.teardownCodexRuntime();
+        void teardown.catch(() => undefined);
+        const stoppingState = Promise.resolve().then(() => this.state.setStatus('stopping'));
+        const [stateResult, teardownResult] = await Promise.allSettled([
+            stoppingState,
+            teardown,
+        ]);
+        throwSettledFailures([stateResult, teardownResult], 'codex runtime stop did not converge');
         await this.state.setStatus('stopped');
+        this.setStatus('stopped');
     }
     async cleanupOnFailure() {
         this.clearRestartTimer();
@@ -245,31 +370,48 @@ export class CodexRuntime {
         this.stopping = true;
         try {
             await this.teardownCodexRuntime();
-        }
-        finally {
             this.stopping = wasStopping;
         }
+        catch (error) {
+            // Retain the stop fence together with the process authority. Only a
+            // successful stop retry may permit any later lifecycle transition.
+            this.stopping = true;
+            throw error;
+        }
     }
     async teardownCodexRuntime() {
         const turnManager = this.turnManager;
-        this.turnManager = null;
-        if (turnManager !== null)
-            await turnManager.stop();
+        const managerStop = turnManager?.stop() ?? Promise.resolve();
+        void managerStop.catch(() => undefined);
         const client = this.client;
-        this.client = null;
+        let clientClose = Promise.resolve();
         if (client !== null) {
             try {
                 client.close();
             }
-            catch {
-                /* */
+            catch (error) {
+                clientClose = Promise.reject(error);
+                void clientClose.catch(() => undefined);
             }
         }
         const process = this.process;
-        this.process = null;
-        if (process !== null) {
-            await process.reap();
+        const processReap = process?.reap() ?? Promise.resolve();
+        void processReap.catch(() => undefined);
+        const results = await Promise.allSettled([
+            managerStop,
+            clientClose,
+            processReap,
+        ]);
+        if (results[0]?.status === 'fulfilled' && this.turnManager === turnManager) {
+            this.turnManager = null;
+        }
+        if (results[1]?.status === 'fulfilled' && this.client === client) {
+            this.client = null;
         }
+        if (results[2]?.status === 'fulfilled' && this.process === process) {
+            this.process = null;
+        }
+        throwSettledFailures(results, 'codex runtime teardown did not converge');
     }
     handleChildExit(exit) {
         const details = exit.signal !== null ? `signal=${exit.signal}` : `code=${exit.code ?? 'null'}`;
@@ -291,39 +433,53 @@ export class CodexRuntime {
             .catch((err) => this.log('warn', 'failed to persist degraded status', err));
         this.restartTimer = setTimeout(() => {
             this.restartTimer = null;
-            void this.restartCodexRuntime(reason);
+            const task = this.restartCodexRuntime(reason, this.generation);
+            this.restartTask = task;
+            void task.finally(() => {
+                if (this.restartTask === task)
+                    this.restartTask = null;
+            }).catch(() => undefined);
         }, delay);
     }
-    async restartCodexRuntime(reason) {
-        if (this.stopping)
+    async restartCodexRuntime(reason, generation) {
+        if (this.stopping || generation !== this.generation)
             return;
         this.restarting = true;
         let retryReason = null;
-        this.setStatus('starting');
-        await this.state.setStatus('starting', {
-            last_started_at: Date.now(),
-        });
         try {
+            this.setStatus('starting');
+            await this.state.setStatus('starting', {
+                last_started_at: Date.now(),
+            });
             await this.teardownCodexRuntime();
-            if (this.stopping)
-                return;
-            await this.startCodexRuntime();
-            if (this.stopping) {
-                await this.teardownCodexRuntime();
-                return;
-            }
+            this.assertGeneration(generation);
+            await this.startCodexRuntime(generation);
+            this.assertGeneration(generation);
             this.restartAttempts = 0;
-            await this.markReady();
+            await this.markReady(generation);
             this.log('info', `restarted codex app-server after: ${reason}`);
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+            const failures = [err];
+            try {
+                await this.teardownCodexRuntime();
+            }
+            catch (cleanupError) {
+                failures.push(cleanupError);
+            }
+            if (this.stopping || generation !== this.generation)
+                return;
+            const msg = failures.map((failure) => failure instanceof Error ? failure.message : String(failure)).join('; ');
             this.log('error', `restart failed: ${msg}`, err);
             this.setStatus('degraded');
-            await this.state.setStatus('degraded', {
-                last_error: msg,
-            });
-            await this.teardownCodexRuntime();
+            try {
+                await this.state.setStatus('degraded', {
+                    last_error: msg,
+                });
+            }
+            catch (stateError) {
+                this.log('warn', 'failed to persist restart failure', stateError);
+            }
             retryReason = `codex app-server restart failed: ${msg}`;
         }
         finally {
@@ -343,26 +499,32 @@ export class CodexRuntime {
         clearTimeout(this.restartTimer);
         this.restartTimer = null;
     }
-    async markReady() {
+    async markReady(generation) {
+        this.assertGeneration(generation);
         this.setStatus('ready');
         await this.state.setStatus('ready', {
             last_ready_at: Date.now(),
             last_error: null,
         });
-    }
-    recordCollectedTurn(turn) {
-        const resultText = extractAssistantText(turn);
-        if (resultText !== null) {
-            this.lastResult = { text: resultText };
-        }
-        this.deps.onTurnSettled?.({
-            turnId: turn.turnId,
-            status: 'completed',
-            result: { text: resultText },
-        });
+        this.assertGeneration(generation);
     }
     setStatus(s) {
         this.status = s;
     }
+    assertGeneration(generation) {
+        if (this.stopping || generation !== this.generation) {
+            throw new Error('codex runtime is stopping');
+        }
+    }
+}
+function throwSettledFailures(results, message) {
+    const failures = results
+        .filter((result) => result.status === 'rejected')
+        .map((result) => result.reason);
+    if (failures.length === 0)
+        return;
+    if (failures.length === 1)
+        throw failures[0];
+    throw new AggregateError(failures, message);
 }
 //# sourceMappingURL=runtime.js.map