@nextclaw/nextclaw-ncp-runtime-codex-sdk 0.1.29 → 0.1.30

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import { CodexLiveOutputChannel, CodexLiveOutputEvent, CodexLiveOutputStream } from "./services/codex-live-output-stream.service.js";
 import { CodexAssetContentPathResolver, CodexThreadInput, buildCodexInputBuilder } from "./codex-input.utils.js";
 import { NcpAgentConversationStateManager, NcpAgentRunInput, NcpAgentRunOptions, NcpAgentRuntime, NcpEndpointEvent } from "@nextclaw/ncp";
 import { CodexOptions, ThreadOptions } from "@openai/codex-sdk";
@@ -16,12 +17,15 @@ type CodexSdkNcpAgentRuntimeConfig = {
   sessionMetadata?: Record<string, unknown>;
   setSessionMetadata?: (nextMetadata: Record<string, unknown>) => void;
   inputBuilder?: (input: NcpAgentRunInput) => Promise<CodexThreadInput> | CodexThreadInput;
+  liveOutputStream?: CodexLiveOutputStream;
   resolveAssetContentPath?: CodexAssetContentPathResolver;
   stateManager?: NcpAgentConversationStateManager;
 };
 declare class CodexSdkNcpAgentRuntime implements NcpAgentRuntime {
   private readonly config;
   private codexPromise;
+  private readonly eventEmitter;
+  private readonly liveOutputEventMergeService;
   private thread;
   private threadId;
   private readonly sessionMetadata;
@@ -30,14 +34,9 @@ declare class CodexSdkNcpAgentRuntime implements NcpAgentRuntime {
   private getCodex;
   private resolveThread;
   private buildTurnInput;
-  private emitEvent;
-  private emitRunStarted;
-  private emitReadyMetadata;
-  private emitRunError;
-  private emitRunCompleted;
   private streamTurnEvents;
   private handleThreadEvent;
   private updateThreadId;
 }
 //#endregion
-export { type CodexAssetContentPathResolver, CodexSdkNcpAgentRuntime, CodexSdkNcpAgentRuntimeConfig, buildCodexInputBuilder };
+export { type CodexAssetContentPathResolver, type CodexLiveOutputChannel, type CodexLiveOutputEvent, CodexLiveOutputStream, CodexSdkNcpAgentRuntime, CodexSdkNcpAgentRuntimeConfig, buildCodexInputBuilder };

package/dist/index.js

@@ -1,9 +1,11 @@
-import { buildCompletedAssistantMessage } from "./completed-assistant-message.utils.js";
+import { CodexLiveOutputEventMergeService } from "./services/codex-live-output-event-merge.service.js";
+import { CodexNcpRunEventEmitter } from "./services/codex-ncp-run-event-emitter.service.js";
 import { mapCodexItemEvent } from "./utils/codex-sdk-ncp-event-mapper.utils.js";
 import { buildCodexCliEnv } from "./codex-cli-env.js";
 import { buildCodexInputBuilder, buildCodexTurnInputFromRunInput } from "./codex-input.utils.js";
+import { CodexLiveOutputStream } from "./services/codex-live-output-stream.service.js";
 import { createRequire } from "node:module";
-import { NcpEventType } from "@nextclaw/ncp";
+import "@nextclaw/ncp";
 //#region src/index.ts
 const codexLoader = createRequire(import.meta.url)("../codex-sdk-loader.cjs");
 function createId(prefix) {
@@ -28,36 +30,41 @@ function isItemLifecycleEvent(event) {
 }
 var CodexSdkNcpAgentRuntime = class {
 	codexPromise = null;
+	eventEmitter;
+	liveOutputEventMergeService = new CodexLiveOutputEventMergeService();
 	thread = null;
 	threadId;
 	sessionMetadata;
 	constructor(config) {
 		this.config = config;
+		this.eventEmitter = new CodexNcpRunEventEmitter(config.stateManager);
 		this.threadId = config.threadId?.trim() || null;
 		this.sessionMetadata = { ...config.sessionMetadata ? structuredClone(config.sessionMetadata) : {} };
 	}
 	run = async function* (input, options) {
+		const signal = options?.signal;
 		const messageId = createId("codex-message");
 		const runId = createId("codex-run");
 		const itemTextById = /* @__PURE__ */ new Map();
 		const toolStateById = /* @__PURE__ */ new Map();
-		yield* this.emitRunStarted(input.sessionId, messageId, runId);
-		yield* this.emitReadyMetadata(input.sessionId, messageId, runId);
+		yield* this.eventEmitter.emitRunStarted(input.sessionId, messageId, runId);
+		yield* this.eventEmitter.emitReadyMetadata(input.sessionId, messageId, runId);
 		const thread = await this.resolveThread();
 		const turnInput = await this.buildTurnInput(input);
-		const streamed = await thread.runStreamed(turnInput, { ...options?.signal ? { signal: options.signal } : {} });
+		this.config.liveOutputStream?.reset();
+		const streamed = await thread.runStreamed(turnInput, { ...signal ? { signal } : {} });
 		try {
 			yield* this.streamTurnEvents({
 				sessionId: input.sessionId,
 				messageId,
 				runId,
 				streamed,
-				signal: options?.signal,
+				signal,
 				itemTextById,
 				toolStateById
 			});
 		} catch (error) {
-			if (options?.signal?.aborted) throw toAbortError(options.signal.reason);
+			if (signal?.aborted) throw toAbortError(signal.reason);
 			throw error;
 		}
 	};
@@ -85,122 +92,63 @@ var CodexSdkNcpAgentRuntime = class {
 		if (this.config.inputBuilder) return await this.config.inputBuilder(input);
 		return await buildCodexTurnInputFromRunInput(input, { resolveAssetContentPath: this.config.resolveAssetContentPath });
 	};
-	emitEvent = async function* (event) {
-		await this.config.stateManager?.dispatch(event);
-		yield event;
-	};
-	emitRunStarted = async function* (sessionId, messageId, runId) {
-		yield* this.emitEvent({
-			type: NcpEventType.RunStarted,
-			payload: {
-				sessionId,
-				messageId,
-				runId
-			}
-		});
-	};
-	emitReadyMetadata = async function* (sessionId, messageId, runId) {
-		yield* this.emitEvent({
-			type: NcpEventType.RunMetadata,
-			payload: {
-				sessionId,
-				messageId,
-				runId,
-				metadata: {
-					kind: "ready",
-					runId,
-					sessionId,
-					supportsAbort: true
-				}
-			}
-		});
-	};
-	emitRunError = async function* (sessionId, messageId, runId, error) {
-		yield* this.emitEvent({
-			type: NcpEventType.RunError,
-			payload: {
-				sessionId,
-				messageId,
-				runId,
-				error
-			}
-		});
-	};
-	emitRunCompleted = async function* (sessionId, messageId, runId) {
-		yield* this.emitEvent({
-			type: NcpEventType.RunMetadata,
-			payload: {
-				sessionId,
-				messageId,
-				runId,
-				metadata: {
-					kind: "final",
-					sessionId
-				}
-			}
-		});
-		yield* this.emitEvent({
-			type: NcpEventType.MessageCompleted,
-			payload: {
-				sessionId,
-				message: buildCompletedAssistantMessage({
-					stateManager: this.config.stateManager,
-					sessionId,
-					messageId
-				})
-			}
-		});
-		yield* this.emitEvent({
-			type: NcpEventType.RunFinished,
-			payload: {
-				sessionId,
-				messageId,
-				runId
-			}
-		});
-	};
 	streamTurnEvents = async function* (params) {
+		const { itemTextById, messageId, runId, sessionId, signal, streamed, toolStateById } = params;
+		const liveOutputStream = this.config.liveOutputStream;
+		if (liveOutputStream) {
+			yield* this.liveOutputEventMergeService.stream({
+				...params,
+				liveOutputStream,
+				emitEvent: (event) => this.eventEmitter.emitEvent(event),
+				emitRunCompleted: (sessionId, messageId, runId) => this.eventEmitter.emitRunCompleted(sessionId, messageId, runId),
+				handleThreadEvent: (handlerParams) => this.handleThreadEvent(handlerParams)
+			});
+			return;
+		}
 		let finished = false;
-		for await (const event of params.streamed.events) if (yield* this.handleThreadEvent({
-			sessionId: params.sessionId,
-			messageId: params.messageId,
-			runId: params.runId,
+		for await (const event of streamed.events) if (yield* this.handleThreadEvent({
+			sessionId,
+			messageId,
+			runId,
 			event,
-			signal: params.signal,
-			itemTextById: params.itemTextById,
-			toolStateById: params.toolStateById
+			signal,
+			itemTextById,
+			toolStateById
 		})) {
 			finished = true;
 			return;
 		}
-		if (!finished) yield* this.emitRunCompleted(params.sessionId, params.messageId, params.runId);
+		if (!finished) yield* this.eventEmitter.emitRunCompleted(sessionId, messageId, runId);
 	};
 	handleThreadEvent = async function* (params) {
-		if (params.signal?.aborted) throw toAbortError(params.signal.reason);
-		if (params.event.type === "thread.started") {
-			this.updateThreadId(params.event.thread_id);
+		const { event, itemTextById, messageId, runId, sessionId, signal, suppressLiveChannels, toolStateById } = params;
+		if (signal?.aborted) throw toAbortError(signal.reason);
+		if (event.type === "thread.started") {
+			this.updateThreadId(event.thread_id);
 			return false;
 		}
-		if (params.event.type === "turn.failed") {
-			yield* this.emitRunError(params.sessionId, params.messageId, params.runId, params.event.error.message);
+		if (event.type === "turn.failed") {
+			yield* this.eventEmitter.emitRunError(sessionId, messageId, runId, event.error.message);
 			return true;
 		}
-		if (params.event.type === "error") {
-			yield* this.emitRunError(params.sessionId, params.messageId, params.runId, params.event.message);
+		if (event.type === "error") {
+			yield* this.eventEmitter.emitRunError(sessionId, messageId, runId, event.message);
 			return true;
 		}
-		if (isItemLifecycleEvent(params.event)) {
+		if (isItemLifecycleEvent(event)) {
+			const suppressedChannel = event.item.type === "agent_message" ? "text" : event.item.type === "reasoning" ? "reasoning" : null;
+			if (suppressedChannel && suppressLiveChannels?.has(suppressedChannel)) return false;
 			for await (const mappedEvent of mapCodexItemEvent({
-				sessionId: params.sessionId,
-				messageId: params.messageId,
-				event: params.event,
-				itemTextById: params.itemTextById,
-				toolStateById: params.toolStateById
-			})) yield* this.emitEvent(mappedEvent);
+				sessionId,
+				messageId,
+				event,
+				itemTextById,
+				toolStateById
+			})) yield* this.eventEmitter.emitEvent(mappedEvent);
 			return false;
 		}
-		if (params.event.type === "turn.completed") {
-			yield* this.emitRunCompleted(params.sessionId, params.messageId, params.runId);
+		if (event.type === "turn.completed") {
+			yield* this.eventEmitter.emitRunCompleted(sessionId, messageId, runId);
 			return true;
 		}
 		return false;
@@ -220,4 +168,4 @@ var CodexSdkNcpAgentRuntime = class {
 	};
 };
 //#endregion
-export { CodexSdkNcpAgentRuntime, buildCodexInputBuilder };
+export { CodexLiveOutputStream, CodexSdkNcpAgentRuntime, buildCodexInputBuilder };

package/dist/services/codex-live-output-event-merge.service.js

@@ -0,0 +1,101 @@
+import { NcpEventType } from "@nextclaw/ncp";
+//#region src/services/codex-live-output-event-merge.service.ts
+var CodexLiveOutputEventMergeService = class {
+	stream = async function* (params) {
+		const { emitEvent, emitRunCompleted, handleThreadEvent, itemTextById, liveOutputStream, messageId, runId, sessionId, signal, streamed, toolStateById } = params;
+		const liveChannels = /* @__PURE__ */ new Set();
+		const codexIterator = streamed.events[Symbol.asyncIterator]();
+		const liveIterator = this.streamLiveOutputEvents({
+			emitEvent,
+			liveChannels,
+			liveOutputStream,
+			messageId,
+			sessionId,
+			signal
+		})[Symbol.asyncIterator]();
+		let finished = false;
+		let codexDone = false;
+		let liveDone = false;
+		let codexNext = codexIterator.next();
+		let liveNext = liveIterator.next();
+		while (!codexDone || !liveDone) {
+			const pending = [...!codexDone ? [codexNext.then((next) => ({
+				source: "codex",
+				next
+			}))] : [], ...!liveDone ? [liveNext.then((next) => ({
+				source: "live",
+				next
+			}))] : []];
+			const result = await Promise.race(pending);
+			if (result.source === "live") {
+				if (result.next.done) liveDone = true;
+				else {
+					yield result.next.value;
+					liveNext = liveIterator.next();
+				}
+				continue;
+			}
+			if (result.next.done) {
+				codexDone = true;
+				continue;
+			}
+			if (yield* handleThreadEvent({
+				event: result.next.value,
+				itemTextById,
+				messageId,
+				runId,
+				sessionId,
+				signal,
+				suppressLiveChannels: liveChannels,
+				toolStateById
+			})) {
+				finished = true;
+				break;
+			}
+			codexNext = codexIterator.next();
+		}
+		await liveIterator.return?.(void 0);
+		if (!finished) yield* emitRunCompleted(sessionId, messageId, runId);
+	};
+	streamLiveOutputEvents = async function* (params) {
+		const { emitEvent, liveChannels, liveOutputStream, messageId, sessionId, signal } = params;
+		const startedChannels = /* @__PURE__ */ new Set();
+		for await (const event of liveOutputStream.events(signal)) {
+			if (event.type === "delta") {
+				liveChannels.add(event.channel);
+				if (!startedChannels.has(event.channel)) {
+					startedChannels.add(event.channel);
+					yield* emitEvent({
+						type: event.channel === "reasoning" ? NcpEventType.MessageReasoningStart : NcpEventType.MessageTextStart,
+						payload: {
+							sessionId,
+							messageId
+						}
+					});
+				}
+				yield* emitEvent({
+					type: event.channel === "reasoning" ? NcpEventType.MessageReasoningDelta : NcpEventType.MessageTextDelta,
+					payload: {
+						sessionId,
+						messageId,
+						delta: event.delta
+					}
+				});
+				continue;
+			}
+			if (event.type === "end") {
+				if (startedChannels.has(event.channel)) yield* emitEvent({
+					type: event.channel === "reasoning" ? NcpEventType.MessageReasoningEnd : NcpEventType.MessageTextEnd,
+					payload: {
+						sessionId,
+						messageId
+					}
+				});
+				continue;
+			}
+			return;
+		}
+	};
+};
+//#endregion
+export { CodexLiveOutputEventMergeService };

package/dist/services/codex-live-output-stream.service.d.ts

@@ -0,0 +1,31 @@
+//#region src/services/codex-live-output-stream.service.d.ts
+type CodexLiveOutputChannel = "reasoning" | "text";
+type CodexLiveOutputEvent = {
+  type: "delta";
+  channel: CodexLiveOutputChannel;
+  delta: string;
+} | {
+  type: "end";
+  channel: CodexLiveOutputChannel;
+} | {
+  type: "done";
+};
+declare class CodexLiveOutputStream {
+  private eventsQueue;
+  private waiters;
+  private done;
+  private reasoningEnded;
+  private textEnded;
+  reset: () => void;
+  onReasoningDelta: (delta: string) => void;
+  onReasoningDone: () => void;
+  onTextDelta: (delta: string) => void;
+  onTextDone: () => void;
+  onDone: () => void;
+  events: (this: CodexLiveOutputStream, signal?: AbortSignal) => AsyncGenerator<CodexLiveOutputEvent>;
+  private pushDelta;
+  private pushEnd;
+  private push;
+}
+//#endregion
+export { CodexLiveOutputChannel, CodexLiveOutputEvent, CodexLiveOutputStream };

package/dist/services/codex-live-output-stream.service.js

@@ -0,0 +1,81 @@
+//#region src/services/codex-live-output-stream.service.ts
+var CodexLiveOutputStream = class {
+	eventsQueue = [];
+	waiters = [];
+	done = false;
+	reasoningEnded = false;
+	textEnded = false;
+	reset = () => {
+		this.eventsQueue = [];
+		this.done = false;
+		this.reasoningEnded = false;
+		this.textEnded = false;
+	};
+	onReasoningDelta = (delta) => {
+		this.pushDelta("reasoning", delta);
+	};
+	onReasoningDone = () => {
+		this.pushEnd("reasoning");
+	};
+	onTextDelta = (delta) => {
+		this.pushDelta("text", delta);
+	};
+	onTextDone = () => {
+		this.pushEnd("text");
+	};
+	onDone = () => {
+		if (this.done) return;
+		this.done = true;
+		this.push({ type: "done" });
+	};
+	events = async function* (signal) {
+		while (!signal?.aborted) {
+			const event = this.eventsQueue.shift();
+			if (event) {
+				yield event;
+				if (event.type === "done") return;
+				continue;
+			}
+			await new Promise((resolve) => {
+				const abort = () => {
+					signal?.removeEventListener("abort", abort);
+					resolve();
+				};
+				this.waiters.push(() => {
+					signal?.removeEventListener("abort", abort);
+					resolve();
+				});
+				signal?.addEventListener("abort", abort, { once: true });
+			});
+		}
+	};
+	pushDelta = (channel, delta) => {
+		if (!delta || this.done) return;
+		this.push({
+			type: "delta",
+			channel,
+			delta
+		});
+	};
+	pushEnd = (channel) => {
+		if (this.done) return;
+		if (channel === "reasoning") {
+			if (this.reasoningEnded) return;
+			this.reasoningEnded = true;
+		} else {
+			if (this.textEnded) return;
+			this.textEnded = true;
+		}
+		this.push({
+			type: "end",
+			channel
+		});
+	};
+	push = (event) => {
+		this.eventsQueue.push(event);
+		const waiters = this.waiters.splice(0);
+		for (const waiter of waiters) waiter();
+	};
+};
+//#endregion
+export { CodexLiveOutputStream };

package/dist/services/codex-ncp-run-event-emitter.service.js

@@ -0,0 +1,84 @@
+import { buildCompletedAssistantMessage } from "../completed-assistant-message.utils.js";
+import { NcpEventType } from "@nextclaw/ncp";
+//#region src/services/codex-ncp-run-event-emitter.service.ts
+var CodexNcpRunEventEmitter = class {
+	constructor(stateManager) {
+		this.stateManager = stateManager;
+	}
+	emitEvent = async function* (event) {
+		await this.stateManager?.dispatch(event);
+		yield event;
+	};
+	emitRunStarted = async function* (sessionId, messageId, runId) {
+		yield* this.emitEvent({
+			type: NcpEventType.RunStarted,
+			payload: {
+				sessionId,
+				messageId,
+				runId
+			}
+		});
+	};
+	emitReadyMetadata = async function* (sessionId, messageId, runId) {
+		yield* this.emitEvent({
+			type: NcpEventType.RunMetadata,
+			payload: {
+				sessionId,
+				messageId,
+				runId,
+				metadata: {
+					kind: "ready",
+					runId,
+					sessionId,
+					supportsAbort: true
+				}
+			}
+		});
+	};
+	emitRunError = async function* (sessionId, messageId, runId, error) {
+		yield* this.emitEvent({
+			type: NcpEventType.RunError,
+			payload: {
+				sessionId,
+				messageId,
+				runId,
+				error
+			}
+		});
+	};
+	emitRunCompleted = async function* (sessionId, messageId, runId) {
+		yield* this.emitEvent({
+			type: NcpEventType.RunMetadata,
+			payload: {
+				sessionId,
+				messageId,
+				runId,
+				metadata: {
+					kind: "final",
+					sessionId
+				}
+			}
+		});
+		yield* this.emitEvent({
+			type: NcpEventType.MessageCompleted,
+			payload: {
+				sessionId,
+				message: buildCompletedAssistantMessage({
+					stateManager: this.stateManager,
+					sessionId,
+					messageId
+				})
+			}
+		});
+		yield* this.emitEvent({
+			type: NcpEventType.RunFinished,
+			payload: {
+				sessionId,
+				messageId,
+				runId
+			}
+		});
+	};
+};
+//#endregion
+export { CodexNcpRunEventEmitter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/nextclaw-ncp-runtime-codex-sdk",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "private": false,
   "description": "Optional NCP runtime adapter backed by OpenAI Codex SDK.",
   "type": "module",
@@ -27,7 +27,7 @@
   "scripts": {
     "build": "tsdown src/index.ts --dts --clean --target es2022 --no-fixedExtension --unbundle",
     "lint": "eslint .",
-    "test": "vitest run src/utils/codex-sdk-ncp-event-mapper.utils.test.ts",
+    "test": "vitest run src/utils/codex-sdk-ncp-event-mapper.utils.test.ts src/services/codex-live-output-stream.service.test.ts",
     "tsc": "tsc -p tsconfig.json"
   }
 }