@nextclaw/nextclaw-ncp-runtime-codex-sdk 0.1.14 → 0.1.16

package/dist/codex-cli-env.js

@@ -1,36 +1,26 @@
+//#region src/codex-cli-env.ts
 function readString(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  return value;
+	if (typeof value !== "string") return;
+	return value;
 }
 function copyProcessEnv() {
-  const env = {};
-  for (const [key, value] of Object.entries(process.env)) {
-    const normalized = readString(value);
-    if (normalized === void 0) {
-      continue;
-    }
-    env[key] = normalized;
-  }
-  return env;
+	const env = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		const normalized = readString(value);
+		if (normalized === void 0) continue;
+		env[key] = normalized;
+	}
+	return env;
 }
 function buildCodexCliEnv(config) {
-  const env = copyProcessEnv();
-  for (const [key, value] of Object.entries(config.env ?? {})) {
-    if (typeof value !== "string") {
-      continue;
-    }
-    env[key] = value;
-  }
-  if (config.apiKey.trim()) {
-    env.OPENAI_API_KEY = config.apiKey;
-  }
-  if (config.apiBase?.trim()) {
-    env.OPENAI_BASE_URL = config.apiBase.trim();
-  }
-  return Object.keys(env).length > 0 ? env : void 0;
+	const env = copyProcessEnv();
+	for (const [key, value] of Object.entries(config.env ?? {})) {
+		if (typeof value !== "string") continue;
+		env[key] = value;
+	}
+	if (config.apiKey.trim()) env.OPENAI_API_KEY = config.apiKey;
+	if (config.apiBase?.trim()) env.OPENAI_BASE_URL = config.apiBase.trim();
+	return Object.keys(env).length > 0 ? env : void 0;
 }
-export {
-  buildCodexCliEnv
-};
+//#endregion
+export { buildCodexCliEnv };

package/dist/codex-input.utils.d.ts

@@ -0,0 +1,23 @@
+import { NcpAgentRunInput } from "@nextclaw/ncp";
+import { Thread } from "@openai/codex-sdk";
+
+//#region src/codex-input.utils.d.ts
+type CodexThreadInput = Parameters<Thread["runStreamed"]>[0];
+type CodexAssetContentPathResolver = (assetUri: string) => Promise<string | null> | string | null;
+type RuntimeAgentPromptBuilder = {
+  buildRuntimeUserPrompt: (params: {
+    workspace?: string;
+    hostWorkspace?: string;
+    sessionKey?: string;
+    metadata?: Record<string, unknown>;
+    userMessage: string;
+  }) => string;
+};
+declare function buildCodexInputBuilder(runtimeAgent: RuntimeAgentPromptBuilder, params: {
+  workspace: string;
+  hostWorkspace?: string;
+  sessionMetadata?: Record<string, unknown>;
+  resolveAssetContentPath?: CodexAssetContentPathResolver;
+}): (input: NcpAgentRunInput) => Promise<CodexThreadInput>;
+//#endregion
+export { CodexAssetContentPathResolver, CodexThreadInput, buildCodexInputBuilder };

package/dist/codex-input.utils.js

@@ -0,0 +1,124 @@
+import { isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/codex-input.utils.ts
+function readOptionalString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function isImageMimeType(value) {
+	return value?.startsWith("image/") ?? false;
+}
+function readLatestUserMessageParts(input) {
+	for (let index = input.messages.length - 1; index >= 0; index -= 1) {
+		const message = input.messages[index];
+		if (message?.role !== "user") continue;
+		if (message.parts.length > 0) return message.parts;
+	}
+	return [];
+}
+function formatAssetReferenceBlock(part) {
+	const fileName = readOptionalString(part.name) ?? "asset";
+	const mimeType = readOptionalString(part.mimeType) ?? "application/octet-stream";
+	const assetUri = readOptionalString(part.assetUri);
+	const url = readOptionalString(part.url);
+	const sizeText = typeof part.sizeBytes === "number" && Number.isFinite(part.sizeBytes) ? String(part.sizeBytes) : null;
+	return [
+		`[Asset: ${fileName}]`,
+		`[MIME: ${mimeType}]`,
+		...assetUri ? [`[Asset URI: ${assetUri}]`] : [],
+		...sizeText ? [`[Size Bytes: ${sizeText}]`] : [],
+		...url ? [`[Preview URL: ${url}]`] : [],
+		"[Instruction: This file is not embedded in the prompt. If you need to inspect or transform it, use asset_export to copy it to a normal file path first.]"
+	].join("\n");
+}
+function formatImageAttachmentHint(part) {
+	const fileName = readOptionalString(part.name) ?? "asset";
+	const mimeType = readOptionalString(part.mimeType) ?? "application/octet-stream";
+	const assetUri = readOptionalString(part.assetUri);
+	const sizeText = typeof part.sizeBytes === "number" && Number.isFinite(part.sizeBytes) ? String(part.sizeBytes) : null;
+	return [
+		`[Attached Image: ${fileName}]`,
+		`[MIME: ${mimeType}]`,
+		...assetUri ? [`[Asset URI: ${assetUri}]`] : [],
+		...sizeText ? [`[Size Bytes: ${sizeText}]`] : [],
+		assetUri ? "[Instruction: This image is embedded in the prompt. If you need to transform or process the original file with tools, use the asset URI.]" : "[Instruction: This image is embedded in the prompt.]"
+	].join("\n");
+}
+function resolveFileUrlToPath(value) {
+	if (!value) return null;
+	if (value.startsWith("file://")) try {
+		return fileURLToPath(value);
+	} catch {
+		return null;
+	}
+	return isAbsolute(value) ? value : null;
+}
+async function resolveLocalImagePath(part, resolveAssetContentPath) {
+	if (!isImageMimeType(readOptionalString(part.mimeType))) return null;
+	const assetUri = readOptionalString(part.assetUri);
+	if (assetUri && resolveAssetContentPath) {
+		const resolvedPath = readOptionalString(await resolveAssetContentPath(assetUri));
+		if (resolvedPath) return resolvedPath;
+	}
+	return resolveFileUrlToPath(readOptionalString(part.url));
+}
+async function buildCodexPromptContent(parts, resolveAssetContentPath) {
+	const promptBlocks = [];
+	const userInputs = [];
+	for (const part of parts) {
+		if ((part.type === "text" || part.type === "rich-text") && part.text.trim().length > 0) {
+			promptBlocks.push(part.text);
+			continue;
+		}
+		if (part.type !== "file") continue;
+		const localImagePath = await resolveLocalImagePath(part, resolveAssetContentPath);
+		if (localImagePath) {
+			promptBlocks.push(formatImageAttachmentHint(part));
+			userInputs.push({
+				type: "local_image",
+				path: localImagePath
+			});
+			continue;
+		}
+		promptBlocks.push(formatAssetReferenceBlock(part));
+	}
+	return {
+		promptText: promptBlocks.join("\n\n").trim(),
+		userInputs
+	};
+}
+function buildCodexThreadInput(promptText, userInputs) {
+	const normalizedPrompt = promptText.trim();
+	if (userInputs.length === 0) return normalizedPrompt;
+	return [...normalizedPrompt ? [{
+		type: "text",
+		text: normalizedPrompt
+	}] : [], ...userInputs];
+}
+function readMetadata(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return value;
+}
+function buildCodexInputBuilder(runtimeAgent, params) {
+	return async (input) => {
+		const { promptText, userInputs } = await buildCodexPromptContent(readLatestUserMessageParts(input), params.resolveAssetContentPath);
+		const metadata = {
+			...readMetadata(params.sessionMetadata),
+			...readMetadata(input.metadata)
+		};
+		return buildCodexThreadInput(runtimeAgent.buildRuntimeUserPrompt({
+			workspace: params.workspace,
+			hostWorkspace: params.hostWorkspace,
+			sessionKey: input.sessionId,
+			metadata,
+			userMessage: promptText
+		}), userInputs);
+	};
+}
+async function buildCodexTurnInputFromRunInput(input, options = {}) {
+	const { promptText, userInputs } = await buildCodexPromptContent(readLatestUserMessageParts(input), options.resolveAssetContentPath);
+	return buildCodexThreadInput(promptText, userInputs);
+}
+//#endregion
+export { buildCodexInputBuilder, buildCodexTurnInputFromRunInput };

package/dist/codex-sdk-ncp-event-mapper.js

@@ -1,218 +1,195 @@
 import { NcpEventType } from "@nextclaw/ncp";
+//#region src/codex-sdk-ncp-event-mapper.ts
 function buildToolDescriptor(item) {
-  switch (item.type) {
-    case "mcp_tool_call":
-      return {
-        toolName: item.server ? `mcp:${item.server}.${item.tool}` : `mcp:${item.tool}`,
-        args: item.arguments
-      };
-    case "command_execution":
-      return {
-        toolName: "command_execution",
-        args: {
-          command: item.command
-        }
-      };
-    case "web_search":
-      return {
-        toolName: "web_search",
-        args: {
-          query: item.query
-        }
-      };
-    case "file_change":
-      return {
-        toolName: "file_change",
-        args: {
-          changes: item.changes
-        }
-      };
-    case "todo_list":
-      return {
-        toolName: "todo_list",
-        args: {
-          items: item.items
-        }
-      };
-  }
+	switch (item.type) {
+		case "mcp_tool_call": return {
+			toolName: item.server ? `mcp:${item.server}.${item.tool}` : `mcp:${item.tool}`,
+			args: item.arguments
+		};
+		case "command_execution": return {
+			toolName: "command_execution",
+			args: { command: item.command }
+		};
+		case "web_search": return {
+			toolName: "web_search",
+			args: { query: item.query }
+		};
+		case "file_change": return {
+			toolName: "file_change",
+			args: { changes: item.changes }
+		};
+		case "todo_list": return {
+			toolName: "todo_list",
+			args: { items: item.items }
+		};
+	}
 }
 function buildToolResult(item) {
-  switch (item.type) {
-    case "mcp_tool_call":
-      return item.status === "failed" ? { ok: false, error: item.error ?? { message: "MCP tool call failed." } } : {
-        ok: item.status === "completed",
-        status: item.status,
-        result: item.result ?? null
-      };
-    case "command_execution":
-      return {
-        status: item.status,
-        command: item.command,
-        aggregated_output: item.aggregated_output,
-        ...typeof item.exit_code === "number" ? { exit_code: item.exit_code } : {}
-      };
-    case "web_search":
-      return {
-        status: "completed",
-        query: item.query
-      };
-    case "file_change":
-      return {
-        status: item.status,
-        changes: item.changes
-      };
-    case "todo_list":
-      return {
-        status: "completed",
-        items: item.items
-      };
-  }
+	switch (item.type) {
+		case "mcp_tool_call": return item.status === "failed" ? {
+			ok: false,
+			error: item.error ?? { message: "MCP tool call failed." }
+		} : {
+			ok: item.status === "completed",
+			status: item.status,
+			result: item.result ?? null
+		};
+		case "command_execution": return {
+			status: item.status,
+			command: item.command,
+			aggregated_output: item.aggregated_output,
+			...typeof item.exit_code === "number" ? { exit_code: item.exit_code } : {}
+		};
+		case "web_search": return {
+			status: "completed",
+			query: item.query
+		};
+		case "file_change": return {
+			status: item.status,
+			changes: item.changes
+		};
+		case "todo_list": return {
+			status: "completed",
+			items: item.items
+		};
+	}
 }
 function stringifyToolArgs(args) {
-  try {
-    return JSON.stringify(args ?? {});
-  } catch {
-    return JSON.stringify({
-      __serialization_error__: "tool arguments are not JSON serializable"
-    });
-  }
+	try {
+		return JSON.stringify(args ?? {});
+	} catch {
+		return JSON.stringify({ __serialization_error__: "tool arguments are not JSON serializable" });
+	}
 }
 function isToolLikeItem(item) {
-  return item.type === "mcp_tool_call" || item.type === "command_execution" || item.type === "web_search" || item.type === "file_change" || item.type === "todo_list";
+	return item.type === "mcp_tool_call" || item.type === "command_execution" || item.type === "web_search" || item.type === "file_change" || item.type === "todo_list";
 }
 async function* mapCodexItemEvent(params) {
-  const { sessionId, messageId, event, itemTextById, toolStateById } = params;
-  const { item } = event;
-  if (item.type === "agent_message") {
-    const currentText = item.text ?? "";
-    const previous2 = itemTextById.get(item.id) ?? { text: "", started: false };
-    if (!previous2.started) {
-      yield {
-        type: NcpEventType.MessageTextStart,
-        payload: {
-          sessionId,
-          messageId
-        }
-      };
-    }
-    if (currentText.length > previous2.text.length) {
-      const delta = currentText.slice(previous2.text.length);
-      yield {
-        type: NcpEventType.MessageTextDelta,
-        payload: {
-          sessionId,
-          messageId,
-          delta
-        }
-      };
-    }
-    itemTextById.set(item.id, {
-      text: currentText,
-      started: true
-    });
-    if (event.type === "item.completed") {
-      yield {
-        type: NcpEventType.MessageTextEnd,
-        payload: {
-          sessionId,
-          messageId
-        }
-      };
-    }
-    return;
-  }
-  if (item.type === "reasoning") {
-    const currentText = item.text ?? "";
-    const previous2 = itemTextById.get(item.id) ?? { text: "", started: false };
-    if (!previous2.started) {
-      yield {
-        type: NcpEventType.MessageReasoningStart,
-        payload: {
-          sessionId,
-          messageId
-        }
-      };
-    }
-    if (currentText.length > previous2.text.length) {
-      const delta = currentText.slice(previous2.text.length);
-      yield {
-        type: NcpEventType.MessageReasoningDelta,
-        payload: {
-          sessionId,
-          messageId,
-          delta
-        }
-      };
-    }
-    itemTextById.set(item.id, {
-      text: currentText,
-      started: true
-    });
-    if (event.type === "item.completed") {
-      yield {
-        type: NcpEventType.MessageReasoningEnd,
-        payload: {
-          sessionId,
-          messageId
-        }
-      };
-    }
-    return;
-  }
-  if (!isToolLikeItem(item)) {
-    return;
-  }
-  const previous = toolStateById.get(item.id) ?? {
-    started: false,
-    argsEmitted: false,
-    ended: false
-  };
-  const descriptor = buildToolDescriptor(item);
-  if (!previous.started) {
-    yield {
-      type: NcpEventType.MessageToolCallStart,
-      payload: {
-        sessionId,
-        messageId,
-        toolCallId: item.id,
-        toolName: descriptor.toolName
-      }
-    };
-    previous.started = true;
-  }
-  if (!previous.argsEmitted) {
-    yield {
-      type: NcpEventType.MessageToolCallArgs,
-      payload: {
-        sessionId,
-        toolCallId: item.id,
-        args: stringifyToolArgs(descriptor.args)
-      }
-    };
-    previous.argsEmitted = true;
-  }
-  if (!previous.ended) {
-    yield {
-      type: NcpEventType.MessageToolCallEnd,
-      payload: {
-        sessionId,
-        toolCallId: item.id
-      }
-    };
-    previous.ended = true;
-  }
-  if (event.type === "item.updated" || event.type === "item.completed") {
-    yield {
-      type: NcpEventType.MessageToolCallResult,
-      payload: {
-        sessionId,
-        toolCallId: item.id,
-        content: buildToolResult(item)
-      }
-    };
-  }
-  toolStateById.set(item.id, previous);
+	const { sessionId, messageId, event, itemTextById, toolStateById } = params;
+	const { item } = event;
+	if (item.type === "agent_message") {
+		const currentText = item.text ?? "";
+		const previous = itemTextById.get(item.id) ?? {
+			text: "",
+			started: false
+		};
+		if (!previous.started) yield {
+			type: NcpEventType.MessageTextStart,
+			payload: {
+				sessionId,
+				messageId
+			}
+		};
+		if (currentText.length > previous.text.length) {
+			const delta = currentText.slice(previous.text.length);
+			yield {
+				type: NcpEventType.MessageTextDelta,
+				payload: {
+					sessionId,
+					messageId,
+					delta
+				}
+			};
+		}
+		itemTextById.set(item.id, {
+			text: currentText,
+			started: true
+		});
+		if (event.type === "item.completed") yield {
+			type: NcpEventType.MessageTextEnd,
+			payload: {
+				sessionId,
+				messageId
+			}
+		};
+		return;
+	}
+	if (item.type === "reasoning") {
+		const currentText = item.text ?? "";
+		const previous = itemTextById.get(item.id) ?? {
+			text: "",
+			started: false
+		};
+		if (!previous.started) yield {
+			type: NcpEventType.MessageReasoningStart,
+			payload: {
+				sessionId,
+				messageId
+			}
+		};
+		if (currentText.length > previous.text.length) {
+			const delta = currentText.slice(previous.text.length);
+			yield {
+				type: NcpEventType.MessageReasoningDelta,
+				payload: {
+					sessionId,
+					messageId,
+					delta
+				}
+			};
+		}
+		itemTextById.set(item.id, {
+			text: currentText,
+			started: true
+		});
+		if (event.type === "item.completed") yield {
+			type: NcpEventType.MessageReasoningEnd,
+			payload: {
+				sessionId,
+				messageId
+			}
+		};
+		return;
+	}
+	if (!isToolLikeItem(item)) return;
+	const previous = toolStateById.get(item.id) ?? {
+		started: false,
+		argsEmitted: false,
+		ended: false
+	};
+	const descriptor = buildToolDescriptor(item);
+	if (!previous.started) {
+		yield {
+			type: NcpEventType.MessageToolCallStart,
+			payload: {
+				sessionId,
+				messageId,
+				toolCallId: item.id,
+				toolName: descriptor.toolName
+			}
+		};
+		previous.started = true;
+	}
+	if (!previous.argsEmitted) {
+		yield {
+			type: NcpEventType.MessageToolCallArgs,
+			payload: {
+				sessionId,
+				toolCallId: item.id,
+				args: stringifyToolArgs(descriptor.args)
+			}
+		};
+		previous.argsEmitted = true;
+	}
+	if (!previous.ended) {
+		yield {
+			type: NcpEventType.MessageToolCallEnd,
+			payload: {
+				sessionId,
+				toolCallId: item.id
+			}
+		};
+		previous.ended = true;
+	}
+	if (event.type === "item.updated" || event.type === "item.completed") yield {
+		type: NcpEventType.MessageToolCallResult,
+		payload: {
+			sessionId,
+			toolCallId: item.id,
+			content: buildToolResult(item)
+		}
+	};
+	toolStateById.set(item.id, previous);
 }
-export {
-  mapCodexItemEvent
-};
+//#endregion
+export { mapCodexItemEvent };

package/dist/completed-assistant-message.utils.js

@@ -0,0 +1,25 @@
+//#region src/completed-assistant-message.utils.ts
+function buildCompletedAssistantMessage(params) {
+	const { stateManager, sessionId, messageId } = params;
+	const snapshot = stateManager?.getSnapshot();
+	const existingMessage = snapshot?.messages.find((message) => message.id === messageId && message.role === "assistant");
+	if (existingMessage) return {
+		...structuredClone(existingMessage),
+		status: "final"
+	};
+	const streamingMessage = snapshot?.streamingMessage;
+	if (streamingMessage?.id === messageId && streamingMessage.role === "assistant") return {
+		...structuredClone(streamingMessage),
+		status: "final"
+	};
+	return {
+		id: messageId,
+		sessionId,
+		role: "assistant",
+		status: "final",
+		parts: [],
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+//#endregion
+export { buildCompletedAssistantMessage };

package/dist/index.d.ts

@@ -1,34 +1,43 @@
-import { CodexOptions, ThreadOptions } from '@openai/codex-sdk';
-import { NcpAgentRunInput, NcpAgentConversationStateManager, NcpAgentRuntime, NcpAgentRunOptions, NcpEndpointEvent } from '@nextclaw/ncp';
+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";
 
+//#region src/index.d.ts
 type CodexSdkNcpAgentRuntimeConfig = {
-    sessionId: string;
-    apiKey: string;
-    apiBase?: string;
-    model?: string;
-    threadId?: string | null;
-    codexPathOverride?: string;
-    env?: Record<string, string>;
-    cliConfig?: CodexOptions["config"];
-    threadOptions?: ThreadOptions;
-    sessionMetadata?: Record<string, unknown>;
-    setSessionMetadata?: (nextMetadata: Record<string, unknown>) => void;
-    inputBuilder?: (input: NcpAgentRunInput) => Promise<string> | string;
-    stateManager?: NcpAgentConversationStateManager;
+  sessionId: string;
+  apiKey: string;
+  apiBase?: string;
+  model?: string;
+  threadId?: string | null;
+  codexPathOverride?: string;
+  env?: Record<string, string>;
+  cliConfig?: CodexOptions["config"];
+  threadOptions?: ThreadOptions;
+  sessionMetadata?: Record<string, unknown>;
+  setSessionMetadata?: (nextMetadata: Record<string, unknown>) => void;
+  inputBuilder?: (input: NcpAgentRunInput) => Promise<CodexThreadInput> | CodexThreadInput;
+  resolveAssetContentPath?: CodexAssetContentPathResolver;
+  stateManager?: NcpAgentConversationStateManager;
 };
 declare class CodexSdkNcpAgentRuntime implements NcpAgentRuntime {
-    private readonly config;
-    private codexPromise;
-    private thread;
-    private threadId;
-    private readonly sessionMetadata;
-    constructor(config: CodexSdkNcpAgentRuntimeConfig);
-    run(input: NcpAgentRunInput, options?: NcpAgentRunOptions): AsyncGenerator<NcpEndpointEvent>;
-    private getCodex;
-    private resolveThread;
-    private buildTurnInput;
-    private emitEvent;
-    private updateThreadId;
+  private readonly config;
+  private codexPromise;
+  private thread;
+  private threadId;
+  private readonly sessionMetadata;
+  constructor(config: CodexSdkNcpAgentRuntimeConfig);
+  run: (this: CodexSdkNcpAgentRuntime, input: NcpAgentRunInput, options?: NcpAgentRunOptions) => AsyncGenerator<NcpEndpointEvent>;
+  private getCodex;
+  private resolveThread;
+  private buildTurnInput;
+  private emitEvent;
+  private emitRunStarted;
+  private emitReadyMetadata;
+  private emitRunError;
+  private emitRunCompleted;
+  private streamTurnEvents;
+  private handleThreadEvent;
+  private updateThreadId;
 }
-
-export { CodexSdkNcpAgentRuntime, type CodexSdkNcpAgentRuntimeConfig };
+//#endregion
+export { type CodexAssetContentPathResolver, CodexSdkNcpAgentRuntime, CodexSdkNcpAgentRuntimeConfig, buildCodexInputBuilder };

package/dist/index.js

@@ -1,241 +1,223 @@
-import { createRequire } from "node:module";
-import {
-  NcpEventType
-} from "@nextclaw/ncp";
-import {
-  mapCodexItemEvent
-} from "./codex-sdk-ncp-event-mapper.js";
+import { buildCompletedAssistantMessage } from "./completed-assistant-message.utils.js";
+import { mapCodexItemEvent } from "./codex-sdk-ncp-event-mapper.js";
 import { buildCodexCliEnv } from "./codex-cli-env.js";
-const require2 = createRequire(import.meta.url);
-const codexLoader = require2("../codex-sdk-loader.cjs");
+import { buildCodexInputBuilder, buildCodexTurnInputFromRunInput } from "./codex-input.utils.js";
+import { createRequire } from "node:module";
+import { NcpEventType } from "@nextclaw/ncp";
+//#region src/index.ts
+const codexLoader = createRequire(import.meta.url)("../codex-sdk-loader.cjs");
 function createId(prefix) {
-  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}
-function readUserText(input) {
-  for (let index = input.messages.length - 1; index >= 0; index -= 1) {
-    const message = input.messages[index];
-    if (message?.role !== "user") {
-      continue;
-    }
-    const text = message.parts.filter((part) => part.type === "text").map((part) => part.text).join("").trim();
-    if (text) {
-      return text;
-    }
-  }
-  return "";
+	return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 }
 function toAbortError(reason) {
-  if (reason instanceof Error) {
-    return reason;
-  }
-  const message = typeof reason === "string" && reason.trim() ? reason.trim() : "operation aborted";
-  const error = new Error(message);
-  error.name = "AbortError";
-  return error;
+	if (reason instanceof Error) return reason;
+	const message = typeof reason === "string" && reason.trim() ? reason.trim() : "operation aborted";
+	const error = new Error(message);
+	error.name = "AbortError";
+	return error;
 }
 function normalizeThreadOptions(options, model) {
-  return {
-    ...options,
-    skipGitRepoCheck: options?.skipGitRepoCheck ?? true,
-    ...model ? { model } : {}
-  };
+	return {
+		...options,
+		skipGitRepoCheck: options?.skipGitRepoCheck ?? true,
+		...model ? { model } : {}
+	};
 }
-class CodexSdkNcpAgentRuntime {
-  constructor(config) {
-    this.config = config;
-    this.threadId = config.threadId?.trim() || null;
-    this.sessionMetadata = {
-      ...config.sessionMetadata ? structuredClone(config.sessionMetadata) : {}
-    };
-  }
-  codexPromise = null;
-  thread = null;
-  threadId;
-  sessionMetadata;
-  async *run(input, options) {
-    const messageId = createId("codex-message");
-    const runId = createId("codex-run");
-    const itemTextById = /* @__PURE__ */ new Map();
-    const toolStateById = /* @__PURE__ */ new Map();
-    let finished = false;
-    yield* this.emitEvent({
-      type: NcpEventType.RunStarted,
-      payload: {
-        sessionId: input.sessionId,
-        messageId,
-        runId
-      }
-    });
-    yield* this.emitEvent({
-      type: NcpEventType.RunMetadata,
-      payload: {
-        sessionId: input.sessionId,
-        messageId,
-        runId,
-        metadata: {
-          kind: "ready",
-          runId,
-          sessionId: input.sessionId,
-          supportsAbort: true
-        }
-      }
-    });
-    const thread = await this.resolveThread();
-    const turnInput = await this.buildTurnInput(input);
-    const streamed = await thread.runStreamed(turnInput, {
-      ...options?.signal ? { signal: options.signal } : {}
-    });
-    try {
-      for await (const event of streamed.events) {
-        if (options?.signal?.aborted) {
-          throw toAbortError(options.signal.reason);
-        }
-        if (event.type === "thread.started") {
-          this.updateThreadId(event.thread_id);
-          continue;
-        }
-        if (event.type === "turn.failed") {
-          yield* this.emitEvent({
-            type: NcpEventType.RunError,
-            payload: {
-              sessionId: input.sessionId,
-              messageId,
-              runId,
-              error: event.error.message
-            }
-          });
-          finished = true;
-          return;
-        }
-        if (event.type === "error") {
-          yield* this.emitEvent({
-            type: NcpEventType.RunError,
-            payload: {
-              sessionId: input.sessionId,
-              messageId,
-              runId,
-              error: event.message
-            }
-          });
-          finished = true;
-          return;
-        }
-        if (event.type === "item.started" || event.type === "item.updated" || event.type === "item.completed") {
-          for await (const mappedEvent of mapCodexItemEvent({
-            sessionId: input.sessionId,
-            messageId,
-            event,
-            itemTextById,
-            toolStateById
-          })) {
-            yield* this.emitEvent(mappedEvent);
-          }
-          continue;
-        }
-        if (event.type === "turn.completed") {
-          yield* this.emitEvent({
-            type: NcpEventType.RunMetadata,
-            payload: {
-              sessionId: input.sessionId,
-              messageId,
-              runId,
-              metadata: {
-                kind: "final",
-                sessionId: input.sessionId
-              }
-            }
-          });
-          yield* this.emitEvent({
-            type: NcpEventType.RunFinished,
-            payload: {
-              sessionId: input.sessionId,
-              messageId,
-              runId
-            }
-          });
-          finished = true;
-          return;
-        }
-      }
-      if (!finished) {
-        yield* this.emitEvent({
-          type: NcpEventType.RunMetadata,
-          payload: {
-            sessionId: input.sessionId,
-            messageId,
-            runId,
-            metadata: {
-              kind: "final",
-              sessionId: input.sessionId
-            }
-          }
-        });
-        yield* this.emitEvent({
-          type: NcpEventType.RunFinished,
-          payload: {
-            sessionId: input.sessionId,
-            messageId,
-            runId
-          }
-        });
-      }
-    } catch (error) {
-      if (options?.signal?.aborted) {
-        throw toAbortError(options.signal.reason);
-      }
-      throw error;
-    }
-  }
-  async getCodex() {
-    if (!this.codexPromise) {
-      const env = buildCodexCliEnv(this.config);
-      this.codexPromise = codexLoader.loadCodexConstructor().then(
-        (Ctor) => new Ctor({
-          apiKey: this.config.apiKey,
-          baseUrl: this.config.apiBase,
-          ...this.config.codexPathOverride ? { codexPathOverride: this.config.codexPathOverride } : {},
-          ...env ? { env } : {},
-          ...this.config.cliConfig ? { config: this.config.cliConfig } : {}
-        })
-      );
-    }
-    return this.codexPromise;
-  }
-  async resolveThread() {
-    if (this.thread) {
-      return this.thread;
-    }
-    const codex = await this.getCodex();
-    const threadOptions = normalizeThreadOptions(this.config.threadOptions, this.config.model);
-    this.thread = this.threadId ? codex.resumeThread(this.threadId, threadOptions) : codex.startThread(threadOptions);
-    return this.thread;
-  }
-  async buildTurnInput(input) {
-    if (this.config.inputBuilder) {
-      return await this.config.inputBuilder(input);
-    }
-    return readUserText(input);
-  }
-  async *emitEvent(event) {
-    await this.config.stateManager?.dispatch(event);
-    yield event;
-  }
-  updateThreadId(nextThreadId) {
-    const normalizedThreadId = nextThreadId.trim();
-    if (!normalizedThreadId || normalizedThreadId === this.threadId) {
-      return;
-    }
-    this.threadId = normalizedThreadId;
-    const nextMetadata = {
-      ...this.sessionMetadata,
-      session_type: "codex",
-      codex_thread_id: normalizedThreadId
-    };
-    this.sessionMetadata.codex_thread_id = normalizedThreadId;
-    this.sessionMetadata.session_type = "codex";
-    this.config.setSessionMetadata?.(nextMetadata);
-  }
+function isItemLifecycleEvent(event) {
+	return event.type === "item.started" || event.type === "item.updated" || event.type === "item.completed";
 }
-export {
-  CodexSdkNcpAgentRuntime
+var CodexSdkNcpAgentRuntime = class {
+	codexPromise = null;
+	thread = null;
+	threadId;
+	sessionMetadata;
+	constructor(config) {
+		this.config = config;
+		this.threadId = config.threadId?.trim() || null;
+		this.sessionMetadata = { ...config.sessionMetadata ? structuredClone(config.sessionMetadata) : {} };
+	}
+	run = async function* (input, options) {
+		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);
+		const thread = await this.resolveThread();
+		const turnInput = await this.buildTurnInput(input);
+		const streamed = await thread.runStreamed(turnInput, { ...options?.signal ? { signal: options.signal } : {} });
+		try {
+			yield* this.streamTurnEvents({
+				sessionId: input.sessionId,
+				messageId,
+				runId,
+				streamed,
+				signal: options?.signal,
+				itemTextById,
+				toolStateById
+			});
+		} catch (error) {
+			if (options?.signal?.aborted) throw toAbortError(options.signal.reason);
+			throw error;
+		}
+	};
+	getCodex = async () => {
+		if (!this.codexPromise) {
+			const env = buildCodexCliEnv(this.config);
+			this.codexPromise = codexLoader.loadCodexConstructor().then((Ctor) => new Ctor({
+				apiKey: this.config.apiKey,
+				baseUrl: this.config.apiBase,
+				...this.config.codexPathOverride ? { codexPathOverride: this.config.codexPathOverride } : {},
+				...env ? { env } : {},
+				...this.config.cliConfig ? { config: this.config.cliConfig } : {}
+			}));
+		}
+		return this.codexPromise;
+	};
+	resolveThread = async () => {
+		if (this.thread) return this.thread;
+		const codex = await this.getCodex();
+		const threadOptions = normalizeThreadOptions(this.config.threadOptions, this.config.model);
+		this.thread = this.threadId ? codex.resumeThread(this.threadId, threadOptions) : codex.startThread(threadOptions);
+		return this.thread;
+	};
+	buildTurnInput = async (input) => {
+		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) {
+		let finished = false;
+		for await (const event of params.streamed.events) if (yield* this.handleThreadEvent({
+			sessionId: params.sessionId,
+			messageId: params.messageId,
+			runId: params.runId,
+			event,
+			signal: params.signal,
+			itemTextById: params.itemTextById,
+			toolStateById: params.toolStateById
+		})) {
+			finished = true;
+			return;
+		}
+		if (!finished) yield* this.emitRunCompleted(params.sessionId, params.messageId, params.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);
+			return false;
+		}
+		if (params.event.type === "turn.failed") {
+			yield* this.emitRunError(params.sessionId, params.messageId, params.runId, params.event.error.message);
+			return true;
+		}
+		if (params.event.type === "error") {
+			yield* this.emitRunError(params.sessionId, params.messageId, params.runId, params.event.message);
+			return true;
+		}
+		if (isItemLifecycleEvent(params.event)) {
+			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);
+			return false;
+		}
+		if (params.event.type === "turn.completed") {
+			yield* this.emitRunCompleted(params.sessionId, params.messageId, params.runId);
+			return true;
+		}
+		return false;
+	};
+	updateThreadId = (nextThreadId) => {
+		const normalizedThreadId = nextThreadId.trim();
+		if (!normalizedThreadId || normalizedThreadId === this.threadId) return;
+		this.threadId = normalizedThreadId;
+		const nextMetadata = {
+			...this.sessionMetadata,
+			session_type: "codex",
+			codex_thread_id: normalizedThreadId
+		};
+		this.sessionMetadata.codex_thread_id = normalizedThreadId;
+		this.sessionMetadata.session_type = "codex";
+		this.config.setSessionMetadata?.(nextMetadata);
+	};
 };
+//#endregion
+export { CodexSdkNcpAgentRuntime, buildCodexInputBuilder };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/nextclaw-ncp-runtime-codex-sdk",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "private": false,
   "description": "Optional NCP runtime adapter backed by OpenAI Codex SDK.",
   "type": "module",
@@ -17,15 +17,14 @@
   ],
   "dependencies": {
     "@openai/codex-sdk": "^0.107.0",
-    "@nextclaw/ncp": "0.4.6"
+    "@nextclaw/ncp": "0.5.0"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
-    "tsup": "^8.3.5",
     "typescript": "^5.6.3"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts",
+    "build": "tsdown src/index.ts --dts --clean --target es2022 --no-fixedExtension --unbundle",
     "lint": "eslint .",
     "tsc": "tsc -p tsconfig.json"
   }

package/dist/codex-cli-env.d.ts

@@ -1,7 +0,0 @@
-import { CodexSdkNcpAgentRuntimeConfig } from './index.js';
-import '@openai/codex-sdk';
-import '@nextclaw/ncp';
-
-declare function buildCodexCliEnv(config: CodexSdkNcpAgentRuntimeConfig): Record<string, string> | undefined;
-
-export { buildCodexCliEnv };

package/dist/codex-sdk-ncp-event-mapper.d.ts

@@ -1,23 +0,0 @@
-import { ThreadEvent } from '@openai/codex-sdk';
-import { NcpEndpointEvent } from '@nextclaw/ncp';
-
-type ItemTextSnapshot = {
-    text: string;
-    started: boolean;
-};
-type ToolSnapshot = {
-    started: boolean;
-    argsEmitted: boolean;
-    ended: boolean;
-};
-declare function mapCodexItemEvent(params: {
-    sessionId: string;
-    messageId: string;
-    event: Extract<ThreadEvent, {
-        type: "item.started" | "item.updated" | "item.completed";
-    }>;
-    itemTextById: Map<string, ItemTextSnapshot>;
-    toolStateById: Map<string, ToolSnapshot>;
-}): AsyncGenerator<NcpEndpointEvent>;
-
-export { type ItemTextSnapshot, type ToolSnapshot, mapCodexItemEvent };