@nextclaw/nextclaw-ncp-runtime-codex-sdk 0.1.33 → 0.1.34

package/dist/codex-model-provider.d.ts

@@ -0,0 +1,4 @@
+//#region src/codex-model-provider.d.ts
+declare function buildCodexBridgeModelProviderId(externalModelProvider: string): string;
+//#endregion
+export { buildCodexBridgeModelProviderId };

package/dist/codex-model-provider.js

@@ -0,0 +1,8 @@
+//#region src/codex-model-provider.ts
+function buildCodexBridgeModelProviderId(externalModelProvider) {
+	const normalized = externalModelProvider.trim();
+	if (!normalized) return "nextclaw-codex-bridge";
+	return `nextclaw-codex-bridge-${normalized}`;
+}
+//#endregion
+export { buildCodexBridgeModelProviderId };

package/dist/codex-openai-responses-bridge-assistant-output.utils.js

@@ -0,0 +1,106 @@
+import { readArray, readRawString, readRecord, readString } from "./codex-openai-responses-bridge-shared.utils.js";
+import { normalizeAssistantText } from "@nextclaw/ncp";
+//#region src/codex-openai-responses-bridge-assistant-output.utils.ts
+function extractAssistantText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.map((entry) => {
+		const record = readRecord(entry);
+		if (!record) return "";
+		const type = readString(record.type);
+		if (type === "text" || type === "output_text") return readString(record.text) ?? "";
+		return "";
+	}).filter(Boolean).join("");
+}
+function readReasoningRecordText(value) {
+	const record = readRecord(value);
+	if (!record) return "";
+	return readRawString(record.text) ?? readRawString(record.content) ?? readRawString(record.reasoning) ?? readRawString(record.reasoning_content) ?? readRawString(record.thinking) ?? "";
+}
+function extractReasoningDetailsText(value) {
+	const rawString = readRawString(value);
+	if (rawString !== void 0) return {
+		present: true,
+		text: rawString
+	};
+	const record = readRecord(value);
+	if (record) return {
+		present: true,
+		text: readReasoningRecordText(record)
+	};
+	if (!Array.isArray(value)) return;
+	return {
+		present: true,
+		text: readArray(value).map((entry) => readReasoningRecordText(entry)).join("")
+	};
+}
+function extractContentReasoningText(content) {
+	if (!Array.isArray(content)) return "";
+	return content.map((entry) => {
+		const record = readRecord(entry);
+		if (!record) return "";
+		const type = readString(record.type);
+		if (type === "reasoning" || type === "reasoning_text" || type === "thinking" || type === "thinking_text") return readReasoningRecordText(record);
+		return "";
+	}).join("");
+}
+function extractExplicitReasoning(message) {
+	const candidates = [
+		message?.reasoning_content,
+		message?.reasoning,
+		message?.thinking,
+		message?.reasoning_details
+	];
+	for (const candidate of candidates) {
+		const extracted = extractReasoningDetailsText(candidate);
+		if (extracted) return extracted;
+	}
+	const contentReasoning = extractContentReasoningText(message?.content);
+	return contentReasoning ? {
+		present: true,
+		text: contentReasoning
+	} : void 0;
+}
+function extractAssistantOutput(message) {
+	const rawText = extractAssistantText(message?.content);
+	const normalized = normalizeAssistantText(rawText, "think-tags");
+	const explicitReasoning = extractExplicitReasoning(message);
+	const reasoning = explicitReasoning?.text ?? readString(normalized.reasoning) ?? "";
+	const reasoningPresent = explicitReasoning?.present === true || Boolean(normalized.reasoning);
+	return {
+		text: explicitReasoning?.present === true ? readString(normalized.text) ?? readString(rawText) ?? "" : normalized.reasoning ? readString(normalized.text) ?? "" : readString(rawText) ?? "",
+		reasoning,
+		reasoningPresent
+	};
+}
+function buildAssistantOutputItems(params) {
+	const { reasoning, reasoningPresent, text } = extractAssistantOutput(params.message);
+	const outputItems = [];
+	if (reasoningPresent) outputItems.push({
+		type: "reasoning",
+		id: `${params.responseId}:reasoning:0`,
+		summary: [{
+			type: "summary_text",
+			text: reasoning
+		}],
+		content: [{
+			type: "reasoning_text",
+			text: reasoning
+		}],
+		status: "completed"
+	});
+	if (text) outputItems.push({
+		type: "message",
+		id: `${params.responseId}:message:${outputItems.length}`,
+		role: "assistant",
+		status: "completed",
+		content: [{
+			type: "output_text",
+			text,
+			annotations: []
+		}]
+	});
+	return outputItems;
+}
+//#endregion
+export { buildAssistantOutputItems };

package/dist/codex-openai-responses-bridge-message-content.utils.js

@@ -0,0 +1,79 @@
+import { readRecord, readString } from "./codex-openai-responses-bridge-shared.utils.js";
+//#region src/codex-openai-responses-bridge-message-content.utils.ts
+function normalizeTextPart(value) {
+	const record = readRecord(value);
+	if (!record) return "";
+	const type = readString(record.type);
+	if (type !== "input_text" && type !== "output_text") return "";
+	return readString(record.text) ?? "";
+}
+function normalizeImageUrl(value) {
+	const record = readRecord(value);
+	if (!record || readString(record.type) !== "input_image") return null;
+	const source = readRecord(record.source);
+	if (!source) return null;
+	if (readString(source.type) === "url") return readString(source.url) ?? null;
+	if (readString(source.type) === "base64") {
+		const mediaType = readString(source.media_type) ?? "application/octet-stream";
+		const data = readString(source.data);
+		if (!data) return null;
+		return `data:${mediaType};base64,${data}`;
+	}
+	return null;
+}
+function normalizeToolOutput(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		const text = value.map((entry) => normalizeTextPart(entry)).filter(Boolean).join("");
+		if (text) return text;
+	}
+	try {
+		return JSON.stringify(value ?? "");
+	} catch {
+		return String(value ?? "");
+	}
+}
+function buildChatContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return null;
+	const chatContent = [];
+	for (const entry of content) {
+		const text = normalizeTextPart(entry);
+		if (text) {
+			chatContent.push({
+				type: "text",
+				text
+			});
+			continue;
+		}
+		const imageUrl = normalizeImageUrl(entry);
+		if (imageUrl) chatContent.push({
+			type: "image_url",
+			image_url: { url: imageUrl }
+		});
+	}
+	if (chatContent.length === 0) return null;
+	if (chatContent.every((entry) => entry.type === "text")) return chatContent.map((entry) => readString(entry.text) ?? "").join("\n");
+	return chatContent;
+}
+function mergeChatContent(left, right) {
+	if (left === null) return right;
+	if (right === null) return left;
+	if (typeof left === "string" && typeof right === "string") return [left, right].filter((value) => value.length > 0).join("\n\n");
+	const normalizedLeft = typeof left === "string" ? [{
+		type: "text",
+		text: left
+	}] : left;
+	const normalizedRight = typeof right === "string" ? [{
+		type: "text",
+		text: right
+	}] : right;
+	return [...normalizedLeft, ...normalizedRight];
+}
+function readAssistantMessageText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((entry) => entry.type === "text").map((entry) => readString(entry.text) ?? "").join("\n");
+}
+//#endregion
+export { buildChatContent, mergeChatContent, normalizeToolOutput, readAssistantMessageText };

package/dist/codex-openai-responses-bridge-shared.utils.d.ts

@@ -0,0 +1,14 @@
+//#region src/codex-openai-responses-bridge-shared.utils.d.ts
+type CodexOpenAiResponsesBridgeConfig = {
+  upstreamApiBase: string;
+  upstreamApiKey?: string;
+  upstreamExtraHeaders?: Record<string, string>;
+  defaultModel?: string;
+  modelPrefixes?: string[];
+  upstreamReasoningSplit?: boolean;
+};
+type CodexOpenAiResponsesBridgeResult = {
+  baseUrl: string;
+};
+//#endregion
+export { CodexOpenAiResponsesBridgeConfig, CodexOpenAiResponsesBridgeResult };

package/dist/codex-openai-responses-bridge-shared.utils.js

@@ -0,0 +1,36 @@
+//#region src/codex-openai-responses-bridge-shared.utils.ts
+function readString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readRawString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function readBoolean(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+function readNumber(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	return value;
+}
+function readRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function readArray(value) {
+	return Array.isArray(value) ? value : [];
+}
+function withTrailingSlash(value) {
+	return value.endsWith("/") ? value : `${value}/`;
+}
+function writeSseEvent(response, eventType, payload) {
+	response.write(`event: ${eventType}\n`);
+	response.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+function nextSequenceNumber(state) {
+	const nextValue = state.value;
+	state.value += 1;
+	return nextValue;
+}
+//#endregion
+export { nextSequenceNumber, readArray, readBoolean, readNumber, readRawString, readRecord, readString, withTrailingSlash, writeSseEvent };

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 import { CodexLiveOutputChannel, CodexLiveOutputEvent, CodexLiveOutputStream } from "./services/codex-live-output-stream.service.js";
 import { CodexAssetContentPathResolver, CodexThreadInput, buildCodexInputBuilder } from "./codex-input.utils.js";
+import { buildCodexBridgeModelProviderId } from "./codex-model-provider.js";
+import { CodexOpenAiResponsesBridgeResult } from "./codex-openai-responses-bridge-shared.utils.js";
+import { CodexOpenAiResponsesBridgeRuntimeConfig, ensureCodexOpenAiResponsesBridge } from "./utils/codex-openai-responses-bridge.utils.js";
 import { NcpAgentConversationStateManager, NcpAgentRunInput, NcpAgentRunOptions, NcpAgentRuntime, NcpEndpointEvent } from "@nextclaw/ncp";
 import { CodexOptions, ThreadOptions } from "@openai/codex-sdk";
 
@@ -39,4 +42,4 @@ declare class CodexSdkNcpAgentRuntime implements NcpAgentRuntime {
   private updateThreadId;
 }
 //#endregion
-export { type CodexAssetContentPathResolver, type CodexLiveOutputChannel, type CodexLiveOutputEvent, CodexLiveOutputStream, CodexSdkNcpAgentRuntime, CodexSdkNcpAgentRuntimeConfig, buildCodexInputBuilder };
+export { type CodexAssetContentPathResolver, type CodexLiveOutputChannel, type CodexLiveOutputEvent, CodexLiveOutputStream, type CodexOpenAiResponsesBridgeResult, type CodexOpenAiResponsesBridgeRuntimeConfig, CodexSdkNcpAgentRuntime, CodexSdkNcpAgentRuntimeConfig, buildCodexBridgeModelProviderId, buildCodexInputBuilder, ensureCodexOpenAiResponsesBridge };

package/dist/index.js

@@ -3,6 +3,8 @@ import { CodexNcpRunEventEmitter } from "./services/codex-ncp-run-event-emitter.
 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 { buildCodexBridgeModelProviderId } from "./codex-model-provider.js";
+import { ensureCodexOpenAiResponsesBridge } from "./utils/codex-openai-responses-bridge.utils.js";
 import { CodexLiveOutputStream } from "./services/codex-live-output-stream.service.js";
 import { createRequire } from "node:module";
 import "@nextclaw/ncp";
@@ -44,7 +46,7 @@ var CodexSdkNcpAgentRuntime = class {
 	run = async function* (input, options) {
 		const signal = options?.signal;
 		const messageId = createId("codex-message");
-		const runId = createId("codex-run");
+		const runId = input.runId ?? createId("codex-run");
 		const itemTextById = /* @__PURE__ */ new Map();
 		const toolStateById = /* @__PURE__ */ new Map();
 		yield* this.eventEmitter.emitRunStarted(input.sessionId, messageId, runId);
@@ -168,4 +170,4 @@ var CodexSdkNcpAgentRuntime = class {
 	};
 };
 //#endregion
-export { CodexLiveOutputStream, CodexSdkNcpAgentRuntime, buildCodexInputBuilder };
+export { CodexLiveOutputStream, CodexSdkNcpAgentRuntime, buildCodexBridgeModelProviderId, buildCodexInputBuilder, ensureCodexOpenAiResponsesBridge };

package/dist/utils/codex-openai-responses-bridge-request.utils.js

@@ -0,0 +1,218 @@
+import { readArray, readBoolean, readNumber, readRecord, readString, withTrailingSlash } from "../codex-openai-responses-bridge-shared.utils.js";
+import { buildChatContent, mergeChatContent, normalizeToolOutput, readAssistantMessageText } from "../codex-openai-responses-bridge-message-content.utils.js";
+//#region src/utils/codex-openai-responses-bridge-request.utils.ts
+function stripModelPrefix(model, prefixes) {
+	const normalizedModel = model.trim();
+	for (const prefix of prefixes) {
+		const normalizedPrefix = prefix.trim().toLowerCase();
+		if (!normalizedPrefix) continue;
+		const candidatePrefix = `${normalizedPrefix}/`;
+		if (normalizedModel.toLowerCase().startsWith(candidatePrefix)) return normalizedModel.slice(candidatePrefix.length);
+	}
+	return normalizedModel;
+}
+function resolveUpstreamModel(requestedModel, config) {
+	const prefixes = (config.modelPrefixes ?? []).filter((value) => value.trim().length > 0);
+	const model = stripModelPrefix(readString(requestedModel) ?? "", prefixes) || stripModelPrefix(config.defaultModel ?? "", prefixes);
+	if (!model) throw new Error("Codex bridge could not resolve an upstream model.");
+	return model;
+}
+function buildOpenAiMessages(input, instructions) {
+	return new OpenAiMessagesBuilder(input, instructions).build();
+}
+var OpenAiMessagesBuilder = class {
+	messages = [];
+	assistantTextParts = [];
+	assistantToolCalls = [];
+	assistantReasoningContent = {
+		present: false,
+		value: ""
+	};
+	systemContent;
+	constructor(input, instructions) {
+		this.input = input;
+		this.systemContent = readString(instructions) ?? null;
+	}
+	build = () => {
+		if (typeof this.input === "string") {
+			this.messages.push({
+				role: "user",
+				content: this.input
+			});
+			return this.withSystemMessage();
+		}
+		for (const rawItem of readArray(this.input)) {
+			const item = readRecord(rawItem);
+			if (!item) continue;
+			this.appendItem(item);
+		}
+		this.flushAssistant();
+		return this.withSystemMessage();
+	};
+	appendItem = (item) => {
+		const type = readString(item.type);
+		if (type === "message") this.appendMessageInputItem(item);
+		else if (type === "reasoning") this.appendReasoningItem(item);
+		else if (type === "function_call") this.appendFunctionCallItem(item);
+		else if (type === "function_call_output") this.appendFunctionCallOutputItem(item);
+	};
+	appendMessageInputItem = (item) => {
+		const role = readString(item.role);
+		const content = buildChatContent(item.content);
+		if (role === "assistant") {
+			const text = readAssistantMessageText(content);
+			if (text.trim()) this.assistantTextParts.push(text);
+			return;
+		}
+		this.flushAssistant();
+		const normalizedRole = role === "developer" ? "system" : role;
+		if (normalizedRole === "system") this.systemContent = mergeChatContent(this.systemContent, content);
+		else if (normalizedRole === "user" && content !== null) this.messages.push({
+			role: "user",
+			content
+		});
+	};
+	appendReasoningItem = (item) => {
+		this.assistantReasoningContent = {
+			present: true,
+			value: readArray(item.content).map((entry) => {
+				const record = readRecord(entry);
+				if (!record || readString(record.type) !== "reasoning_text") return "";
+				return typeof record.text === "string" ? record.text : "";
+			}).join("")
+		};
+	};
+	appendFunctionCallItem = (item) => {
+		const name = readString(item.name);
+		const argumentsText = readString(item.arguments) ?? "{}";
+		if (!name) return;
+		const callId = readString(item.call_id) ?? readString(item.id) ?? `call_${this.assistantToolCalls.length}`;
+		this.assistantToolCalls.push({
+			id: callId,
+			type: "function",
+			function: {
+				name,
+				arguments: argumentsText
+			}
+		});
+	};
+	appendFunctionCallOutputItem = (item) => {
+		this.flushAssistant();
+		const callId = readString(item.call_id);
+		if (!callId) return;
+		this.messages.push({
+			role: "tool",
+			tool_call_id: callId,
+			content: normalizeToolOutput(item.output)
+		});
+	};
+	flushAssistant = () => {
+		if (this.assistantTextParts.length === 0 && this.assistantToolCalls.length === 0 && !this.assistantReasoningContent.present) return;
+		this.messages.push({
+			role: "assistant",
+			content: this.assistantTextParts.join("\n").trim() || null,
+			...this.assistantReasoningContent.present ? { reasoning_content: this.assistantReasoningContent.value } : {},
+			...this.assistantToolCalls.length > 0 ? { tool_calls: structuredClone(this.assistantToolCalls) } : {}
+		});
+		this.assistantTextParts.length = 0;
+		this.assistantToolCalls.length = 0;
+		this.assistantReasoningContent = {
+			present: false,
+			value: ""
+		};
+	};
+	withSystemMessage = () => this.systemContent === null ? this.messages : [{
+		role: "system",
+		content: this.systemContent
+	}, ...this.messages];
+};
+function toOpenAiTools(value) {
+	const tools = [];
+	for (const entry of readArray(value)) {
+		const tool = readRecord(entry);
+		const type = readString(tool?.type);
+		const fn = readRecord(tool?.function);
+		const name = readString(fn?.name) ?? readString(tool?.name);
+		if (type !== "function" || !name) continue;
+		const description = (fn ? readString(fn.description) : void 0) ?? readString(tool?.description);
+		const parameters = (fn ? readRecord(fn.parameters) : void 0) ?? readRecord(tool?.parameters);
+		const strict = (fn ? readBoolean(fn.strict) : void 0) ?? readBoolean(tool?.strict);
+		tools.push({
+			type: "function",
+			function: {
+				name,
+				...description ? { description } : {},
+				parameters: parameters ?? {
+					type: "object",
+					properties: {}
+				},
+				...strict !== void 0 ? { strict } : {}
+			}
+		});
+	}
+	return tools.length > 0 ? tools : void 0;
+}
+function toOpenAiToolChoice(value) {
+	if (value === "auto" || value === "none" || value === "required") return value;
+	const record = readRecord(value);
+	const name = readString(readRecord(record?.function)?.name) ?? readString(record?.name);
+	if (readString(record?.type) === "function" && name) return {
+		type: "function",
+		function: { name }
+	};
+}
+async function callOpenAiCompatibleUpstream(params) {
+	const { model, request } = buildOpenAiCompatibleUpstreamRequest({
+		config: params.config,
+		body: params.body,
+		stream: false
+	});
+	const upstreamResponse = await fetch(request.url, request.init);
+	const rawText = await upstreamResponse.text();
+	let parsed;
+	try {
+		parsed = JSON.parse(rawText);
+	} catch {
+		throw new Error(`Bridge upstream returned invalid JSON: ${rawText.slice(0, 240)}`);
+	}
+	if (!upstreamResponse.ok) throw new Error(readString(parsed.error?.message) ?? rawText.slice(0, 240) ?? `HTTP ${upstreamResponse.status}`);
+	return {
+		model,
+		response: parsed
+	};
+}
+function buildOpenAiCompatibleUpstreamRequest(params) {
+	const { body, config, stream } = params;
+	const model = resolveUpstreamModel(body.model, config);
+	const upstreamUrl = new URL("chat/completions", withTrailingSlash(config.upstreamApiBase));
+	const tools = toOpenAiTools(body.tools);
+	const toolChoice = toOpenAiToolChoice(body.tool_choice);
+	return {
+		model,
+		request: {
+			url: upstreamUrl.toString(),
+			init: {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...config.upstreamApiKey ? { Authorization: `Bearer ${config.upstreamApiKey}` } : {},
+					...config.upstreamExtraHeaders ?? {}
+				},
+				body: JSON.stringify({
+					model,
+					messages: buildOpenAiMessages(body.input, body.instructions),
+					...tools ? { tools } : {},
+					...toolChoice ? { tool_choice: toolChoice } : {},
+					...config.upstreamReasoningSplit ? { reasoning_split: true } : {},
+					...stream ? {
+						stream: true,
+						stream_options: { include_usage: true }
+					} : {},
+					...typeof body.max_output_tokens === "number" ? { max_tokens: Math.max(1, Math.trunc(readNumber(body.max_output_tokens) ?? 1)) } : {}
+				})
+			}
+		}
+	};
+}
+//#endregion
+export { buildOpenAiCompatibleUpstreamRequest, callOpenAiCompatibleUpstream };

package/dist/utils/codex-openai-responses-bridge-stream.utils.js

@@ -0,0 +1,131 @@
+import { readArray, readNumber, readRecord, readString, writeSseEvent } from "../codex-openai-responses-bridge-shared.utils.js";
+import { buildAssistantOutputItems } from "../codex-openai-responses-bridge-assistant-output.utils.js";
+//#region src/utils/codex-openai-responses-bridge-stream.utils.ts
+function buildOpenResponsesOutputItems(response, responseId) {
+	const message = response.choices?.[0]?.message;
+	if (!message) return [];
+	const outputItems = buildAssistantOutputItems({
+		message,
+		responseId
+	});
+	readArray(message.tool_calls).forEach((entry, index) => {
+		const toolCall = readRecord(entry);
+		const fn = readRecord(toolCall?.function);
+		const name = readString(fn?.name);
+		const argumentsText = readString(fn?.arguments) ?? "{}";
+		if (!name) return;
+		const callId = readString(toolCall?.id) ?? `${responseId}:call:${index}`;
+		outputItems.push({
+			type: "function_call",
+			id: `${responseId}:function:${index}`,
+			call_id: callId,
+			name,
+			arguments: argumentsText,
+			status: "completed"
+		});
+	});
+	return outputItems;
+}
+function normalizeUsageValue(value) {
+	const numericValue = readNumber(value);
+	if (numericValue !== void 0) return Math.max(0, Math.trunc(numericValue));
+	const record = readRecord(value);
+	if (!record) return null;
+	const next = {};
+	for (const [key, entry] of Object.entries(record)) {
+		const normalizedEntry = normalizeUsageValue(entry);
+		if (normalizedEntry !== null) next[key] = normalizedEntry;
+	}
+	return Object.keys(next).length > 0 ? next : null;
+}
+function normalizeUsageRecord(rawUsage) {
+	const usage = readRecord(rawUsage);
+	if (!usage) return {};
+	const next = {};
+	for (const [key, value] of Object.entries(usage)) {
+		const normalizedValue = normalizeUsageValue(value);
+		if (normalizedValue === null) continue;
+		if (key === "prompt_tokens") {
+			next.input_tokens = normalizedValue;
+			continue;
+		}
+		if (key === "completion_tokens") {
+			next.output_tokens = normalizedValue;
+			continue;
+		}
+		if (key === "prompt_tokens_details") {
+			next.input_tokens_details = normalizedValue;
+			continue;
+		}
+		if (key === "completion_tokens_details") {
+			next.output_tokens_details = normalizedValue;
+			continue;
+		}
+		next[key] = normalizedValue;
+	}
+	return next;
+}
+function buildUsage(response) {
+	const promptTokens = Math.max(0, Math.trunc(readNumber(response.usage?.prompt_tokens) ?? 0));
+	const completionTokens = Math.max(0, Math.trunc(readNumber(response.usage?.completion_tokens) ?? 0));
+	const totalTokens = Math.max(0, Math.trunc(readNumber(response.usage?.total_tokens) ?? promptTokens + completionTokens));
+	return {
+		...normalizeUsageRecord(response.usage),
+		input_tokens: promptTokens,
+		output_tokens: completionTokens,
+		total_tokens: totalTokens
+	};
+}
+function buildResponseResource(params) {
+	const { model, outputItems, responseId, status, usage } = params;
+	return {
+		id: responseId,
+		object: "response",
+		created_at: Math.floor(Date.now() / 1e3),
+		status: status ?? "completed",
+		model,
+		output: outputItems,
+		usage,
+		error: null
+	};
+}
+function writeStreamError(response, message) {
+	new StreamErrorWriter(response, message).write();
+}
+var StreamErrorWriter = class {
+	constructor(response, message) {
+		this.response = response;
+		this.message = message;
+	}
+	write = () => {
+		this.response.statusCode = 200;
+		this.response.setHeader("content-type", "text/event-stream; charset=utf-8");
+		this.response.setHeader("cache-control", "no-cache, no-transform");
+		this.response.setHeader("connection", "keep-alive");
+		writeSseEvent(this.response, "error", {
+			type: "error",
+			error: {
+				code: "invalid_request_error",
+				message: this.message
+			}
+		});
+		this.response.end();
+	};
+};
+function buildBridgeResponsePayload(params) {
+	const { model, response, responseId } = params;
+	const outputItems = buildOpenResponsesOutputItems(response, responseId);
+	const usage = buildUsage(response);
+	return {
+		outputItems,
+		usage,
+		responseResource: buildResponseResource({
+			responseId,
+			model,
+			outputItems,
+			usage
+		})
+	};
+}
+//#endregion
+export { buildBridgeResponsePayload, buildResponseResource, buildUsage, writeStreamError };

package/dist/utils/codex-openai-responses-bridge.utils.d.ts

@@ -0,0 +1,10 @@
+import { CodexOpenAiResponsesBridgeConfig, CodexOpenAiResponsesBridgeResult } from "../codex-openai-responses-bridge-shared.utils.js";
+import { CodexOpenAiResponsesOutputObserver } from "./codex-openai-responses-stream-writer.utils.js";
+
+//#region src/utils/codex-openai-responses-bridge.utils.d.ts
+type CodexOpenAiResponsesBridgeRuntimeConfig = CodexOpenAiResponsesBridgeConfig & {
+  outputObserver?: CodexOpenAiResponsesOutputObserver;
+};
+declare function ensureCodexOpenAiResponsesBridge(config: CodexOpenAiResponsesBridgeRuntimeConfig): Promise<CodexOpenAiResponsesBridgeResult>;
+//#endregion
+export { CodexOpenAiResponsesBridgeRuntimeConfig, ensureCodexOpenAiResponsesBridge };

package/dist/utils/codex-openai-responses-bridge.utils.js

@@ -0,0 +1,138 @@
+import { readBoolean, readRecord } from "../codex-openai-responses-bridge-shared.utils.js";
+import { buildOpenAiCompatibleUpstreamRequest, callOpenAiCompatibleUpstream } from "./codex-openai-responses-bridge-request.utils.js";
+import { buildBridgeResponsePayload, writeStreamError } from "./codex-openai-responses-bridge-stream.utils.js";
+import { writeResponsesUpstreamStream } from "./codex-openai-responses-stream-writer.utils.js";
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+//#region src/utils/codex-openai-responses-bridge.utils.ts
+const bridgeCache = /* @__PURE__ */ new Map();
+function toBridgeCacheKey(config) {
+	return JSON.stringify({
+		upstreamApiBase: config.upstreamApiBase,
+		upstreamApiKey: config.upstreamApiKey ?? "",
+		upstreamExtraHeaders: config.upstreamExtraHeaders ?? {},
+		defaultModel: config.defaultModel ?? "",
+		modelPrefixes: (config.modelPrefixes ?? []).map((prefix) => prefix.trim().toLowerCase()),
+		upstreamReasoningSplit: config.upstreamReasoningSplit === true
+	});
+}
+async function readJsonBody(request) {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	const rawText = Buffer.concat(chunks).toString("utf8").trim();
+	if (!rawText) return {};
+	try {
+		return readRecord(JSON.parse(rawText)) ?? null;
+	} catch {
+		return null;
+	}
+}
+async function handleResponsesRequest(request, response, config) {
+	await new CodexResponsesBridgeRequestHandler(request, response, config).handle();
+}
+var JsonResponseWriter = class {
+	constructor(response) {
+		this.response = response;
+	}
+	write = (statusCode, body) => {
+		this.response.statusCode = statusCode;
+		this.response.setHeader("content-type", "application/json");
+		this.response.end(JSON.stringify(body));
+	};
+};
+var CodexResponsesBridgeRequestHandler = class {
+	jsonWriter;
+	constructor(request, response, config) {
+		this.request = request;
+		this.response = response;
+		this.config = config;
+		this.jsonWriter = new JsonResponseWriter(response);
+	}
+	handle = async () => {
+		const body = await readJsonBody(this.request);
+		if (!body) {
+			this.writeErrorJson(400, "Invalid JSON payload.");
+			return;
+		}
+		try {
+			if (readBoolean(body.stream) !== false) {
+				await this.writeStreamingResponse(body);
+				return;
+			}
+			await this.writeJsonResponse(body);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Codex OpenAI bridge request failed.";
+			if (readBoolean(body.stream) !== false) {
+				writeStreamError(this.response, message);
+				return;
+			}
+			this.writeErrorJson(400, message);
+		}
+	};
+	writeStreamingResponse = async (body) => {
+		const responseId = randomUUID();
+		const upstream = buildOpenAiCompatibleUpstreamRequest({
+			config: this.config,
+			body,
+			stream: true
+		});
+		const upstreamResponse = await fetch(upstream.request.url, upstream.request.init);
+		if (!upstreamResponse.ok) throw new Error((await upstreamResponse.text()).slice(0, 240));
+		await writeResponsesUpstreamStream({
+			response: this.response,
+			responseId,
+			model: upstream.model,
+			outputObserver: this.config.outputObserver,
+			upstreamResponse
+		});
+	};
+	writeJsonResponse = async (body) => {
+		const responseId = randomUUID();
+		const upstream = await callOpenAiCompatibleUpstream({
+			config: this.config,
+			body
+		});
+		const { responseResource } = buildBridgeResponsePayload({
+			responseId,
+			model: upstream.model,
+			response: upstream.response
+		});
+		this.jsonWriter.write(200, responseResource);
+	};
+	writeErrorJson = (statusCode, message) => {
+		this.jsonWriter.write(statusCode, { error: { message } });
+	};
+};
+async function createCodexOpenAiResponsesBridge(config) {
+	const server = createServer((request, response) => {
+		const pathname = request.url ? new URL(request.url, "http://127.0.0.1").pathname : "/";
+		if (request.method === "POST" && (pathname === "/responses" || pathname === "/v1/responses")) {
+			handleResponsesRequest(request, response, config);
+			return;
+		}
+		new JsonResponseWriter(response).write(404, { error: { message: `Unsupported Codex bridge path: ${pathname}` } });
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => resolve());
+	});
+	const address = server.address();
+	if (!address || typeof address === "string") throw new Error("Codex bridge failed to bind a loopback port.");
+	return { baseUrl: `http://127.0.0.1:${address.port}` };
+}
+async function ensureCodexOpenAiResponsesBridge(config) {
+	if (config.outputObserver) return await createCodexOpenAiResponsesBridge(config);
+	const key = toBridgeCacheKey(config);
+	const existing = bridgeCache.get(key);
+	if (existing) return await existing.promise;
+	const promise = createCodexOpenAiResponsesBridge(config);
+	bridgeCache.set(key, { promise });
+	try {
+		return await promise;
+	} catch (error) {
+		bridgeCache.delete(key);
+		throw error;
+	}
+}
+//#endregion
+export { ensureCodexOpenAiResponsesBridge };

package/dist/utils/codex-openai-responses-stream-writer.utils.d.ts

@@ -0,0 +1,10 @@
+//#region src/utils/codex-openai-responses-stream-writer.utils.d.ts
+type CodexOpenAiResponsesOutputObserver = {
+  onDone: () => void;
+  onReasoningDelta: (delta: string) => void;
+  onReasoningDone: () => void;
+  onTextDelta: (delta: string) => void;
+  onTextDone: () => void;
+};
+//#endregion
+export { CodexOpenAiResponsesOutputObserver };

package/dist/utils/codex-openai-responses-stream-writer.utils.js

@@ -0,0 +1,324 @@
+import { nextSequenceNumber, readArray, readNumber, readRecord, readString, writeSseEvent } from "../codex-openai-responses-bridge-shared.utils.js";
+import { buildResponseResource, buildUsage } from "./codex-openai-responses-bridge-stream.utils.js";
+import { extractContentText, extractReasoningText, readOpenAiSseChunks } from "./codex-openai-sse-chunks.utils.js";
+//#region src/utils/codex-openai-responses-stream-writer.utils.ts
+async function writeResponsesUpstreamStream(params) {
+	await new CodexResponsesOpenAiStreamWriter(params).write();
+}
+var CodexResponsesOpenAiStreamWriter = class {
+	sequenceState = { value: 0 };
+	outputItems = [];
+	toolCalls = /* @__PURE__ */ new Map();
+	outputCount = 0;
+	textState = null;
+	reasoningState = null;
+	usage = {};
+	constructor(params) {
+		this.params = params;
+	}
+	write = async () => {
+		this.writeHeaders();
+		this.writeCreatedEvent();
+		for await (const chunk of readOpenAiSseChunks(this.params.upstreamResponse)) this.handleChunk(chunk);
+		this.finishReasoning();
+		this.finishText();
+		this.finishToolCalls();
+		this.writeCompletedEvent();
+		this.params.outputObserver?.onDone();
+		this.params.response.end();
+	};
+	nextOutputIndex = () => {
+		const value = this.outputCount;
+		this.outputCount += 1;
+		return value;
+	};
+	writeEvent = (eventType, payload) => {
+		writeSseEvent(this.params.response, eventType, {
+			...payload,
+			sequence_number: nextSequenceNumber(this.sequenceState)
+		});
+	};
+	writeHeaders = () => {
+		this.params.response.statusCode = 200;
+		this.params.response.setHeader("content-type", "text/event-stream; charset=utf-8");
+		this.params.response.setHeader("cache-control", "no-cache, no-transform");
+		this.params.response.setHeader("connection", "keep-alive");
+	};
+	writeCreatedEvent = () => {
+		this.writeEvent("response.created", {
+			type: "response.created",
+			response: buildResponseResource({
+				responseId: this.params.responseId,
+				model: this.params.model,
+				outputItems: [],
+				usage: buildUsage({ usage: {} }),
+				status: "in_progress"
+			})
+		});
+	};
+	ensureTextState = () => {
+		if (this.textState) return this.textState;
+		this.textState = {
+			outputIndex: this.nextOutputIndex(),
+			itemId: `${this.params.responseId}:message:${this.outputCount}`,
+			text: ""
+		};
+		this.writeEvent("response.output_item.added", {
+			type: "response.output_item.added",
+			output_index: this.textState.outputIndex,
+			item: {
+				type: "message",
+				id: this.textState.itemId,
+				role: "assistant",
+				status: "in_progress",
+				content: []
+			}
+		});
+		this.writeEvent("response.content_part.added", {
+			type: "response.content_part.added",
+			output_index: this.textState.outputIndex,
+			item_id: this.textState.itemId,
+			content_index: 0,
+			part: {
+				type: "output_text",
+				text: "",
+				annotations: []
+			}
+		});
+		return this.textState;
+	};
+	ensureReasoningState = () => {
+		if (this.reasoningState) return this.reasoningState;
+		this.reasoningState = {
+			outputIndex: this.nextOutputIndex(),
+			itemId: `${this.params.responseId}:reasoning:${this.outputCount}`,
+			text: ""
+		};
+		this.writeEvent("response.output_item.added", {
+			type: "response.output_item.added",
+			output_index: this.reasoningState.outputIndex,
+			item: {
+				type: "reasoning",
+				id: this.reasoningState.itemId,
+				status: "in_progress",
+				content: [],
+				summary: []
+			}
+		});
+		this.writeEvent("response.reasoning_summary_part.added", {
+			type: "response.reasoning_summary_part.added",
+			output_index: this.reasoningState.outputIndex,
+			item_id: this.reasoningState.itemId,
+			summary_index: 0,
+			part: {
+				type: "summary_text",
+				text: ""
+			}
+		});
+		return this.reasoningState;
+	};
+	ensureToolCallState = (index, delta) => {
+		const existing = this.toolCalls.get(index);
+		if (existing) return existing;
+		const fn = readRecord(delta.function);
+		const state = {
+			outputIndex: this.nextOutputIndex(),
+			itemId: `${this.params.responseId}:function:${this.outputCount}`,
+			callId: readString(delta.id) ?? `${this.params.responseId}:call:${index}`,
+			name: readString(fn?.name) ?? "tool",
+			argumentsText: ""
+		};
+		this.toolCalls.set(index, state);
+		this.writeEvent("response.output_item.added", {
+			type: "response.output_item.added",
+			output_index: state.outputIndex,
+			item: {
+				type: "function_call",
+				id: state.itemId,
+				call_id: state.callId,
+				name: state.name,
+				arguments: "",
+				status: "in_progress"
+			}
+		});
+		return state;
+	};
+	handleChunk = (chunk) => {
+		this.usage = chunk.usage ?? this.usage;
+		const delta = chunk.choices?.[0]?.delta;
+		this.writeReasoningDelta(extractReasoningText(delta));
+		this.writeTextDelta(extractContentText(delta?.content));
+		for (const rawToolCall of readArray(delta?.tool_calls)) this.writeToolCallDelta(readRecord(rawToolCall));
+	};
+	writeReasoningDelta = (reasoningDelta) => {
+		if (!reasoningDelta) return;
+		const state = this.ensureReasoningState();
+		state.text += reasoningDelta;
+		this.params.outputObserver?.onReasoningDelta(reasoningDelta);
+		this.writeEvent("response.reasoning_summary_text.delta", {
+			type: "response.reasoning_summary_text.delta",
+			output_index: state.outputIndex,
+			item_id: state.itemId,
+			summary_index: 0,
+			delta: reasoningDelta
+		});
+		this.writeEvent("response.reasoning_text.delta", {
+			type: "response.reasoning_text.delta",
+			output_index: state.outputIndex,
+			item_id: state.itemId,
+			content_index: 0,
+			delta: reasoningDelta
+		});
+	};
+	writeTextDelta = (textDelta) => {
+		if (!textDelta) return;
+		const state = this.ensureTextState();
+		state.text += textDelta;
+		this.params.outputObserver?.onTextDelta(textDelta);
+		this.writeEvent("response.output_text.delta", {
+			type: "response.output_text.delta",
+			output_index: state.outputIndex,
+			item_id: state.itemId,
+			content_index: 0,
+			delta: textDelta
+		});
+	};
+	writeToolCallDelta = (toolCall) => {
+		const toolIndex = Math.trunc(readNumber(toolCall?.index) ?? this.toolCalls.size);
+		const fn = readRecord(toolCall?.function);
+		const state = this.ensureToolCallState(toolIndex, toolCall ?? {});
+		state.name = readString(fn?.name) ?? state.name;
+		const argumentsDelta = readString(fn?.arguments) ?? "";
+		state.argumentsText += argumentsDelta;
+		if (!argumentsDelta) return;
+		this.writeEvent("response.function_call_arguments.delta", {
+			type: "response.function_call_arguments.delta",
+			output_index: state.outputIndex,
+			item_id: state.itemId,
+			delta: argumentsDelta
+		});
+	};
+	finishReasoning = () => {
+		if (!this.reasoningState) return;
+		const item = {
+			type: "reasoning",
+			id: this.reasoningState.itemId,
+			summary: [{
+				type: "summary_text",
+				text: this.reasoningState.text
+			}],
+			content: [{
+				type: "reasoning_text",
+				text: this.reasoningState.text
+			}],
+			status: "completed"
+		};
+		this.outputItems[this.reasoningState.outputIndex] = item;
+		this.writeEvent("response.reasoning_summary_text.done", {
+			type: "response.reasoning_summary_text.done",
+			output_index: this.reasoningState.outputIndex,
+			item_id: this.reasoningState.itemId,
+			summary_index: 0,
+			text: this.reasoningState.text
+		});
+		this.writeEvent("response.reasoning_summary_part.done", {
+			type: "response.reasoning_summary_part.done",
+			output_index: this.reasoningState.outputIndex,
+			item_id: this.reasoningState.itemId,
+			summary_index: 0,
+			part: {
+				type: "summary_text",
+				text: this.reasoningState.text
+			}
+		});
+		this.writeEvent("response.reasoning_text.done", {
+			type: "response.reasoning_text.done",
+			output_index: this.reasoningState.outputIndex,
+			item_id: this.reasoningState.itemId,
+			content_index: 0,
+			text: this.reasoningState.text
+		});
+		this.writeEvent("response.output_item.done", {
+			type: "response.output_item.done",
+			output_index: this.reasoningState.outputIndex,
+			item
+		});
+		this.params.outputObserver?.onReasoningDone();
+	};
+	finishText = () => {
+		if (!this.textState) return;
+		const item = {
+			type: "message",
+			id: this.textState.itemId,
+			role: "assistant",
+			status: "completed",
+			content: [{
+				type: "output_text",
+				text: this.textState.text,
+				annotations: []
+			}]
+		};
+		this.outputItems[this.textState.outputIndex] = item;
+		this.writeEvent("response.output_text.done", {
+			type: "response.output_text.done",
+			output_index: this.textState.outputIndex,
+			item_id: this.textState.itemId,
+			content_index: 0,
+			text: this.textState.text
+		});
+		this.writeEvent("response.content_part.done", {
+			type: "response.content_part.done",
+			output_index: this.textState.outputIndex,
+			item_id: this.textState.itemId,
+			content_index: 0,
+			part: {
+				type: "output_text",
+				text: this.textState.text,
+				annotations: []
+			}
+		});
+		this.writeEvent("response.output_item.done", {
+			type: "response.output_item.done",
+			output_index: this.textState.outputIndex,
+			item
+		});
+		this.params.outputObserver?.onTextDone();
+	};
+	finishToolCalls = () => {
+		for (const state of [...this.toolCalls.values()].sort((a, b) => a.outputIndex - b.outputIndex)) {
+			const item = {
+				type: "function_call",
+				id: state.itemId,
+				call_id: state.callId,
+				name: state.name,
+				arguments: state.argumentsText,
+				status: "completed"
+			};
+			this.outputItems[state.outputIndex] = item;
+			this.writeEvent("response.function_call_arguments.done", {
+				type: "response.function_call_arguments.done",
+				output_index: state.outputIndex,
+				item_id: state.itemId,
+				arguments: state.argumentsText
+			});
+			this.writeEvent("response.output_item.done", {
+				type: "response.output_item.done",
+				output_index: state.outputIndex,
+				item
+			});
+		}
+	};
+	writeCompletedEvent = () => {
+		this.writeEvent("response.completed", {
+			type: "response.completed",
+			response: buildResponseResource({
+				responseId: this.params.responseId,
+				model: this.params.model,
+				outputItems: this.outputItems.filter(Boolean),
+				usage: buildUsage({ usage: this.usage })
+			})
+		});
+	};
+};
+//#endregion
+export { writeResponsesUpstreamStream };

package/dist/utils/codex-openai-sse-chunks.utils.js

@@ -0,0 +1,30 @@
+import { readArray, readRawString, readRecord } from "../codex-openai-responses-bridge-shared.utils.js";
+//#region src/utils/codex-openai-sse-chunks.utils.ts
+function extractContentText(content) {
+	if (typeof content === "string") return content;
+	return readArray(content).map((entry) => {
+		const record = readRecord(entry);
+		return readRawString(record?.text) ?? readRawString(record?.content) ?? "";
+	}).join("");
+}
+function extractReasoningText(delta) {
+	return readRawString(delta?.reasoning_content) ?? readRawString(delta?.reasoning) ?? readRawString(delta?.thinking) ?? "";
+}
+async function* readOpenAiSseChunks(upstreamResponse) {
+	const stream = upstreamResponse.body;
+	if (!stream) return;
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for await (const rawChunk of stream) {
+		buffer += decoder.decode(rawChunk, { stream: true }).replaceAll("\r\n", "\n");
+		const blocks = buffer.split("\n\n");
+		buffer = blocks.pop() ?? "";
+		for (const block of blocks) {
+			const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n").trim();
+			if (!data || data === "[DONE]") continue;
+			yield JSON.parse(data);
+		}
+	}
+}
+//#endregion
+export { extractContentText, extractReasoningText, readOpenAiSseChunks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/nextclaw-ncp-runtime-codex-sdk",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "private": false,
   "description": "Optional NCP runtime adapter backed by OpenAI Codex SDK.",
   "type": "module",
@@ -17,7 +17,7 @@
   ],
   "dependencies": {
     "@openai/codex-sdk": "^0.130.0",
-    "@nextclaw/ncp": "0.5.12"
+    "@nextclaw/ncp": "0.5.13"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",
@@ -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 src/services/codex-live-output-stream.service.test.ts",
+    "test": "vitest run src/utils/codex-model-provider.utils.test.ts src/utils/codex-sdk-ncp-event-mapper.utils.test.ts src/services/codex-live-output-stream.service.test.ts src/utils/codex-openai-sse-chunks.utils.test.ts",
     "tsc": "tsc -p tsconfig.json"
   }
 }