@nextclaw/nextclaw-ncp-runtime-plugin-codex-sdk 0.1.21 → 0.1.22

package/dist/index.js

@@ -1,3 +1,4 @@
+// src/index.ts
 import {
   findProviderByModel,
   findProviderByName,
@@ -7,20 +8,1102 @@ import {
 import {
   CodexSdkNcpAgentRuntime
 } from "@nextclaw/nextclaw-ncp-runtime-codex-sdk";
+
+// src/codex-model-provider.ts
+function readOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function isValidExternalModelProvider(value) {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(value);
+}
+function resolveExternalModelProvider(params) {
+  const explicitModelProvider = readOptionalString(params.explicitModelProvider);
+  if (explicitModelProvider) {
+    return explicitModelProvider;
+  }
+  const providerName = readOptionalString(params.providerName);
+  if (providerName && !providerName.startsWith("custom-")) {
+    return providerName;
+  }
+  const providerDisplayName = readOptionalString(params.providerDisplayName);
+  if (providerDisplayName && isValidExternalModelProvider(providerDisplayName)) {
+    return providerDisplayName;
+  }
+  throw new Error(
+    `[codex] custom provider "${providerName ?? "unknown"}" requires an external model provider id. Set plugins.entries.${params.pluginId}.config.modelProvider or use a provider display name with only letters, numbers, ".", "_" or "-".`
+  );
+}
+function buildUserFacingModelRoute(params) {
+  const providerLocalModel = params.providerLocalModel.trim();
+  if (!providerLocalModel) {
+    return params.resolvedModel.trim();
+  }
+  return `${params.externalModelProvider}/${providerLocalModel}`;
+}
+function buildCodexBridgeModelProviderId(externalModelProvider) {
+  const normalized = externalModelProvider.trim();
+  if (!normalized) {
+    return "nextclaw-codex-bridge";
+  }
+  return `nextclaw-codex-bridge-${normalized}`;
+}
+
+// src/codex-access-mode.ts
+var DEFAULT_CODEX_ACCESS_MODE = "full-access";
+var CODEX_ACCESS_MODES = ["read-only", "workspace-write", "full-access"];
+var LEGACY_CODEX_SANDBOX_MODES = ["read-only", "workspace-write", "danger-full-access"];
+var CODEX_APPROVAL_POLICY = "never";
+function readEnumString(value, allowedValues) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const normalized = value.trim();
+  return allowedValues.includes(normalized) ? normalized : void 0;
+}
+function mapLegacySandboxModeToAccessMode(sandboxMode) {
+  switch (sandboxMode) {
+    case "read-only":
+      return "read-only";
+    case "workspace-write":
+      return "workspace-write";
+    case "danger-full-access":
+      return "full-access";
+  }
+}
+function mapAccessModeToSandboxMode(accessMode) {
+  switch (accessMode) {
+    case "read-only":
+      return "read-only";
+    case "workspace-write":
+      return "workspace-write";
+    case "full-access":
+      return "danger-full-access";
+  }
+}
+function resolveCodexAccessMode(pluginConfig) {
+  const explicitAccessMode = readEnumString(pluginConfig.accessMode, CODEX_ACCESS_MODES);
+  if (explicitAccessMode) {
+    return explicitAccessMode;
+  }
+  const legacySandboxMode = readEnumString(pluginConfig.sandboxMode, LEGACY_CODEX_SANDBOX_MODES);
+  if (legacySandboxMode) {
+    return mapLegacySandboxModeToAccessMode(legacySandboxMode);
+  }
+  return DEFAULT_CODEX_ACCESS_MODE;
+}
+
+// src/codex-input-builder.ts
 import {
-  buildUserFacingModelRoute,
-  buildCodexBridgeModelProviderId,
-  resolveExternalModelProvider
-} from "./codex-model-provider.js";
-import { buildCodexInputBuilder } from "./codex-input-builder.js";
-import { ensureCodexOpenAiResponsesBridge } from "./codex-openai-responses-bridge.js";
-import { resolveCodexResponsesApiSupport } from "./codex-responses-capability.js";
-import {
-  createDescribeCodexSessionType
-} from "./codex-session-type.js";
-const PLUGIN_ID = "nextclaw-ncp-runtime-plugin-codex-sdk";
-const CODEX_RUNTIME_KIND = "codex";
-class DeferredCodexSdkNcpAgentRuntime {
+  buildRequestedSkillsUserPrompt,
+  SkillsLoader
+} from "@nextclaw/core";
+function readString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function readRequestedSkills(metadata) {
+  const raw = metadata.requested_skills ?? metadata.requestedSkills;
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.map((entry) => readString(entry)).filter((entry) => Boolean(entry)).slice(0, 8);
+}
+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 "";
+}
+function buildCodexInputBuilder(workspace) {
+  const skillsLoader = new SkillsLoader(workspace);
+  return async (input) => {
+    const userText = readUserText(input);
+    const metadata = input.metadata && typeof input.metadata === "object" && !Array.isArray(input.metadata) ? input.metadata : {};
+    const requestedSkills = readRequestedSkills(metadata);
+    return buildRequestedSkillsUserPrompt(skillsLoader, requestedSkills, userText);
+  };
+}
+
+// src/codex-openai-responses-bridge.ts
+import { randomUUID } from "crypto";
+import { createServer } from "http";
+
+// src/codex-openai-responses-bridge-shared.ts
+function readString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return value;
+}
+function readRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  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}
+`);
+  response.write(`data: ${JSON.stringify(payload)}
+
+`);
+}
+function nextSequenceNumber(state) {
+  const nextValue = state.value;
+  state.value += 1;
+  return nextValue;
+}
+
+// src/codex-openai-responses-bridge-request.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(readString2(requestedModel) ?? "", prefixes) || stripModelPrefix(config.defaultModel ?? "", prefixes);
+  if (!model) {
+    throw new Error("Codex bridge could not resolve an upstream model.");
+  }
+  return model;
+}
+function normalizeTextPart(value) {
+  const record = readRecord(value);
+  if (!record) {
+    return "";
+  }
+  const type = readString2(record.type);
+  if (type !== "input_text" && type !== "output_text") {
+    return "";
+  }
+  return readString2(record.text) ?? "";
+}
+function normalizeImageUrl(value) {
+  const record = readRecord(value);
+  if (!record || readString2(record.type) !== "input_image") {
+    return null;
+  }
+  const source = readRecord(record.source);
+  if (!source) {
+    return null;
+  }
+  if (readString2(source.type) === "url") {
+    return readString2(source.url) ?? null;
+  }
+  if (readString2(source.type) === "base64") {
+    const mediaType = readString2(source.media_type) ?? "application/octet-stream";
+    const data = readString2(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;
+  }
+  const textOnly = chatContent.every((entry) => entry.type === "text");
+  if (textOnly) {
+    return chatContent.map((entry) => readString2(entry.text) ?? "").join("\n");
+  }
+  return chatContent;
+}
+function readAssistantMessageText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter((entry) => entry.type === "text").map((entry) => readString2(entry.text) ?? "").join("\n");
+}
+function appendMessageInputItem(params) {
+  const role = readString2(params.item.role);
+  const content = buildChatContent(params.item.content);
+  if (role === "assistant") {
+    const text = readAssistantMessageText(content);
+    if (text.trim()) {
+      params.assistantTextParts.push(text);
+    }
+    return;
+  }
+  params.flushAssistant();
+  const normalizedRole = role === "developer" ? "system" : role;
+  if ((normalizedRole === "system" || normalizedRole === "user") && content !== null) {
+    params.messages.push({
+      role: normalizedRole,
+      content
+    });
+  }
+}
+function appendFunctionCallItem(params) {
+  const name = readString2(params.item.name);
+  const argumentsText = readString2(params.item.arguments) ?? "{}";
+  if (!name) {
+    return;
+  }
+  const callId = readString2(params.item.call_id) ?? readString2(params.item.id) ?? `call_${params.assistantToolCalls.length}`;
+  params.assistantToolCalls.push({
+    id: callId,
+    type: "function",
+    function: {
+      name,
+      arguments: argumentsText
+    }
+  });
+}
+function appendFunctionCallOutputItem(params) {
+  params.flushAssistant();
+  const callId = readString2(params.item.call_id);
+  if (!callId) {
+    return;
+  }
+  params.messages.push({
+    role: "tool",
+    tool_call_id: callId,
+    content: normalizeToolOutput(params.item.output)
+  });
+}
+function buildOpenAiMessages(input, instructions) {
+  const messages = [];
+  const instructionText = readString2(instructions);
+  if (instructionText) {
+    messages.push({
+      role: "system",
+      content: instructionText
+    });
+  }
+  if (typeof input === "string") {
+    return [
+      ...messages,
+      {
+        role: "user",
+        content: input
+      }
+    ];
+  }
+  const assistantTextParts = [];
+  const assistantToolCalls = [];
+  const flushAssistant = () => {
+    if (assistantTextParts.length === 0 && assistantToolCalls.length === 0) {
+      return;
+    }
+    messages.push({
+      role: "assistant",
+      content: assistantTextParts.join("\n").trim() || null,
+      ...assistantToolCalls.length > 0 ? {
+        tool_calls: structuredClone(assistantToolCalls)
+      } : {}
+    });
+    assistantTextParts.length = 0;
+    assistantToolCalls.length = 0;
+  };
+  for (const rawItem of readArray(input)) {
+    const item = readRecord(rawItem);
+    if (!item) {
+      continue;
+    }
+    const type = readString2(item.type);
+    if (type === "message") {
+      appendMessageInputItem({
+        messages,
+        assistantTextParts,
+        assistantToolCalls,
+        item,
+        flushAssistant
+      });
+      continue;
+    }
+    if (type === "function_call") {
+      appendFunctionCallItem({
+        assistantToolCalls,
+        item
+      });
+      continue;
+    }
+    if (type === "function_call_output") {
+      appendFunctionCallOutputItem({
+        messages,
+        item,
+        flushAssistant
+      });
+    }
+  }
+  flushAssistant();
+  return messages;
+}
+function toOpenAiTools(value) {
+  const tools = [];
+  for (const entry of readArray(value)) {
+    const tool = readRecord(entry);
+    const type = readString2(tool?.type);
+    const fn = readRecord(tool?.function);
+    const name = readString2(fn?.name) ?? readString2(tool?.name);
+    if (type !== "function" || !name) {
+      continue;
+    }
+    const description = (fn ? readString2(fn.description) : void 0) ?? readString2(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 fn = readRecord(record?.function);
+  const name = readString2(fn?.name) ?? readString2(record?.name);
+  if (readString2(record?.type) === "function" && name) {
+    return {
+      type: "function",
+      function: {
+        name
+      }
+    };
+  }
+  return void 0;
+}
+async function callOpenAiCompatibleUpstream(params) {
+  const model = resolveUpstreamModel(params.body.model, params.config);
+  const upstreamUrl = new URL(
+    "chat/completions",
+    withTrailingSlash(params.config.upstreamApiBase)
+  );
+  const tools = toOpenAiTools(params.body.tools);
+  const toolChoice = toOpenAiToolChoice(params.body.tool_choice);
+  const upstreamResponse = await fetch(upstreamUrl.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...params.config.upstreamApiKey ? {
+        Authorization: `Bearer ${params.config.upstreamApiKey}`
+      } : {},
+      ...params.config.upstreamExtraHeaders ?? {}
+    },
+    body: JSON.stringify({
+      model,
+      messages: buildOpenAiMessages(params.body.input, params.body.instructions),
+      ...tools ? { tools } : {},
+      ...toolChoice ? { tool_choice: toolChoice } : {},
+      ...typeof params.body.max_output_tokens === "number" ? {
+        max_tokens: Math.max(
+          1,
+          Math.trunc(readNumber(params.body.max_output_tokens) ?? 1)
+        )
+      } : {}
+    })
+  });
+  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(
+      readString2(parsed.error?.message) ?? rawText.slice(0, 240) ?? `HTTP ${upstreamResponse.status}`
+    );
+  }
+  return {
+    model,
+    response: parsed
+  };
+}
+
+// src/codex-openai-responses-bridge-stream.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 = readString2(record.type);
+    if (type === "text" || type === "output_text") {
+      return readString2(record.text) ?? "";
+    }
+    return "";
+  }).filter(Boolean).join("");
+}
+function buildOpenResponsesOutputItems(response, responseId) {
+  const message = response.choices?.[0]?.message;
+  if (!message) {
+    return [];
+  }
+  const outputItems = [];
+  const text = extractAssistantText(message.content).trim();
+  if (text) {
+    outputItems.push({
+      type: "message",
+      id: `${responseId}:message:0`,
+      role: "assistant",
+      status: "completed",
+      content: [
+        {
+          type: "output_text",
+          text,
+          annotations: []
+        }
+      ]
+    });
+  }
+  const toolCalls = readArray(message.tool_calls);
+  toolCalls.forEach((entry, index) => {
+    const toolCall = readRecord(entry);
+    const fn = readRecord(toolCall?.function);
+    const name = readString2(fn?.name);
+    const argumentsText = readString2(fn?.arguments) ?? "{}";
+    if (!name) {
+      return;
+    }
+    const callId = readString2(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 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 {
+    input_tokens: promptTokens,
+    input_tokens_details: null,
+    output_tokens: completionTokens,
+    output_tokens_details: null,
+    total_tokens: totalTokens
+  };
+}
+function buildResponseResource(params) {
+  return {
+    id: params.responseId,
+    object: "response",
+    created_at: Math.floor(Date.now() / 1e3),
+    status: params.status ?? "completed",
+    model: params.model,
+    output: params.outputItems,
+    usage: params.usage,
+    error: null
+  };
+}
+function cloneRecord(value) {
+  return structuredClone(value);
+}
+function buildInProgressOutputItem(item) {
+  const type = readString2(item.type);
+  if (type === "message") {
+    return {
+      ...cloneRecord(item),
+      status: "in_progress",
+      content: []
+    };
+  }
+  if (type === "function_call") {
+    return {
+      ...cloneRecord(item),
+      status: "in_progress",
+      arguments: ""
+    };
+  }
+  return cloneRecord(item);
+}
+function writeMessageOutputItemEvents(params) {
+  const itemId = readString2(params.item.id);
+  const content = readArray(params.item.content);
+  const textPart = content.find((entry) => readString2(readRecord(entry)?.type) === "output_text");
+  const text = readString2(readRecord(textPart)?.text) ?? "";
+  writeSseEvent(params.response, "response.output_item.added", {
+    type: "response.output_item.added",
+    sequence_number: nextSequenceNumber(params.sequenceState),
+    output_index: params.outputIndex,
+    item: buildInProgressOutputItem(params.item)
+  });
+  if (itemId) {
+    writeSseEvent(params.response, "response.content_part.added", {
+      type: "response.content_part.added",
+      sequence_number: nextSequenceNumber(params.sequenceState),
+      output_index: params.outputIndex,
+      item_id: itemId,
+      content_index: 0,
+      part: {
+        type: "output_text",
+        text: "",
+        annotations: []
+      }
+    });
+    if (text) {
+      writeSseEvent(params.response, "response.output_text.delta", {
+        type: "response.output_text.delta",
+        sequence_number: nextSequenceNumber(params.sequenceState),
+        output_index: params.outputIndex,
+        item_id: itemId,
+        content_index: 0,
+        delta: text
+      });
+    }
+    writeSseEvent(params.response, "response.output_text.done", {
+      type: "response.output_text.done",
+      sequence_number: nextSequenceNumber(params.sequenceState),
+      output_index: params.outputIndex,
+      item_id: itemId,
+      content_index: 0,
+      text
+    });
+    writeSseEvent(params.response, "response.content_part.done", {
+      type: "response.content_part.done",
+      sequence_number: nextSequenceNumber(params.sequenceState),
+      output_index: params.outputIndex,
+      item_id: itemId,
+      content_index: 0,
+      part: {
+        type: "output_text",
+        text,
+        annotations: []
+      }
+    });
+  }
+  writeSseEvent(params.response, "response.output_item.done", {
+    type: "response.output_item.done",
+    sequence_number: nextSequenceNumber(params.sequenceState),
+    output_index: params.outputIndex,
+    item: params.item
+  });
+}
+function writeFunctionCallOutputItemEvents(params) {
+  const itemId = readString2(params.item.id);
+  const argumentsText = readString2(params.item.arguments) ?? "";
+  writeSseEvent(params.response, "response.output_item.added", {
+    type: "response.output_item.added",
+    sequence_number: nextSequenceNumber(params.sequenceState),
+    output_index: params.outputIndex,
+    item: buildInProgressOutputItem(params.item)
+  });
+  if (itemId && argumentsText) {
+    writeSseEvent(params.response, "response.function_call_arguments.delta", {
+      type: "response.function_call_arguments.delta",
+      sequence_number: nextSequenceNumber(params.sequenceState),
+      output_index: params.outputIndex,
+      item_id: itemId,
+      delta: argumentsText
+    });
+  }
+  if (itemId) {
+    writeSseEvent(params.response, "response.function_call_arguments.done", {
+      type: "response.function_call_arguments.done",
+      sequence_number: nextSequenceNumber(params.sequenceState),
+      output_index: params.outputIndex,
+      item_id: itemId,
+      arguments: argumentsText
+    });
+  }
+  writeSseEvent(params.response, "response.output_item.done", {
+    type: "response.output_item.done",
+    sequence_number: nextSequenceNumber(params.sequenceState),
+    output_index: params.outputIndex,
+    item: params.item
+  });
+}
+function writeResponseOutputItemEvents(params) {
+  params.outputItems.forEach((item, outputIndex) => {
+    const type = readString2(item.type);
+    if (type === "message") {
+      writeMessageOutputItemEvents({
+        response: params.response,
+        item,
+        outputIndex,
+        sequenceState: params.sequenceState
+      });
+      return;
+    }
+    if (type === "function_call") {
+      writeFunctionCallOutputItemEvents({
+        response: params.response,
+        item,
+        outputIndex,
+        sequenceState: params.sequenceState
+      });
+      return;
+    }
+    writeSseEvent(params.response, "response.output_item.done", {
+      type: "response.output_item.done",
+      sequence_number: nextSequenceNumber(params.sequenceState),
+      output_index: outputIndex,
+      item
+    });
+  });
+}
+function writeStreamError(response, message) {
+  response.statusCode = 200;
+  response.setHeader("content-type", "text/event-stream; charset=utf-8");
+  response.setHeader("cache-control", "no-cache, no-transform");
+  response.setHeader("connection", "keep-alive");
+  writeSseEvent(response, "error", {
+    type: "error",
+    error: {
+      code: "invalid_request_error",
+      message
+    }
+  });
+  response.end();
+}
+function buildBridgeResponsePayload(params) {
+  const outputItems = buildOpenResponsesOutputItems(params.response, params.responseId);
+  const usage = buildUsage(params.response);
+  return {
+    outputItems,
+    usage,
+    responseResource: buildResponseResource({
+      responseId: params.responseId,
+      model: params.model,
+      outputItems,
+      usage
+    })
+  };
+}
+function writeResponsesStream(params) {
+  const sequenceState = {
+    value: 0
+  };
+  params.response.statusCode = 200;
+  params.response.setHeader("content-type", "text/event-stream; charset=utf-8");
+  params.response.setHeader("cache-control", "no-cache, no-transform");
+  params.response.setHeader("connection", "keep-alive");
+  writeSseEvent(params.response, "response.created", {
+    type: "response.created",
+    sequence_number: nextSequenceNumber(sequenceState),
+    response: buildResponseResource({
+      responseId: params.responseId,
+      model: params.model,
+      outputItems: [],
+      usage: buildUsage({
+        usage: {}
+      }),
+      status: "in_progress"
+    })
+  });
+  writeResponseOutputItemEvents({
+    response: params.response,
+    outputItems: params.outputItems,
+    sequenceState
+  });
+  writeSseEvent(params.response, "response.completed", {
+    type: "response.completed",
+    sequence_number: nextSequenceNumber(sequenceState),
+    response: params.responseResource
+  });
+  params.response.end();
+}
+
+// src/codex-openai-responses-bridge.ts
+var 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())
+  });
+}
+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) {
+  const body = await readJsonBody(request);
+  if (!body) {
+    response.statusCode = 400;
+    response.setHeader("content-type", "application/json");
+    response.end(
+      JSON.stringify({
+        error: {
+          message: "Invalid JSON payload."
+        }
+      })
+    );
+    return;
+  }
+  try {
+    const upstream = await callOpenAiCompatibleUpstream({
+      config,
+      body
+    });
+    const responseId = randomUUID();
+    const { outputItems, responseResource } = buildBridgeResponsePayload({
+      responseId,
+      model: upstream.model,
+      response: upstream.response
+    });
+    const wantsStream = readBoolean(body.stream) !== false;
+    if (wantsStream) {
+      writeResponsesStream({
+        response,
+        responseId,
+        model: upstream.model,
+        outputItems,
+        responseResource
+      });
+      return;
+    }
+    response.statusCode = 200;
+    response.setHeader("content-type", "application/json");
+    response.end(JSON.stringify(responseResource));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Codex OpenAI bridge request failed.";
+    if (readBoolean(body.stream) !== false) {
+      writeStreamError(response, message);
+      return;
+    }
+    response.statusCode = 400;
+    response.setHeader("content-type", "application/json");
+    response.end(
+      JSON.stringify({
+        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")) {
+      void handleResponsesRequest(request, response, config);
+      return;
+    }
+    response.statusCode = 404;
+    response.setHeader("content-type", "application/json");
+    response.end(
+      JSON.stringify({
+        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) {
+  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;
+  }
+}
+
+// src/codex-responses-capability.ts
+var codexResponsesProbeCache = /* @__PURE__ */ new Map();
+function normalizeApiBase(value) {
+  return value.endsWith("/") ? value : `${value}/`;
+}
+function readErrorMessage(value) {
+  if (typeof value === "string") {
+    return value.trim();
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return "";
+  }
+  const record = value;
+  return readString2(record.message) ?? readString2(record.error) ?? "";
+}
+function shouldTreatResponsesProbeFailureAsUnsupported(params) {
+  const normalizedMessage = params.message.trim().toLowerCase();
+  if (params.status === 404 || params.status === 405 || params.status === 501) {
+    return true;
+  }
+  if (params.status >= 500) {
+    return false;
+  }
+  return [
+    "unsupported model",
+    "not support",
+    "not supported",
+    "unsupported endpoint",
+    "unknown url",
+    "no route matched",
+    "responses api"
+  ].some((token) => normalizedMessage.includes(token));
+}
+async function probeCodexResponsesApiSupport(params) {
+  const cacheKey = JSON.stringify({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    extraHeaders: params.extraHeaders ?? {},
+    model: params.model
+  });
+  const existing = codexResponsesProbeCache.get(cacheKey);
+  if (existing) {
+    return await existing;
+  }
+  const probePromise = (async () => {
+    const response = await fetch(new URL("responses", normalizeApiBase(params.apiBase)), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${params.apiKey}`,
+        ...params.extraHeaders ?? {}
+      },
+      body: JSON.stringify({
+        model: params.model,
+        input: "ping",
+        max_output_tokens: 1,
+        stream: false
+      })
+    });
+    const rawText = await response.text();
+    let parsed = null;
+    try {
+      parsed = JSON.parse(rawText);
+    } catch {
+      parsed = null;
+    }
+    const parsedRecord = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+    const message = readErrorMessage(parsedRecord?.error) || readErrorMessage(parsed) || rawText.slice(0, 240);
+    const responseFailed = readString2(parsedRecord?.status)?.toLowerCase() === "failed" || Boolean(parsedRecord?.error);
+    if (response.ok && !responseFailed) {
+      return true;
+    }
+    return !shouldTreatResponsesProbeFailureAsUnsupported({
+      status: response.status,
+      message
+    });
+  })();
+  codexResponsesProbeCache.set(cacheKey, probePromise);
+  try {
+    return await probePromise;
+  } catch (error) {
+    codexResponsesProbeCache.delete(cacheKey);
+    throw error;
+  }
+}
+async function resolveCodexResponsesApiSupport(params) {
+  if (params.capabilitySpec?.supportsResponsesApi === true) {
+    return true;
+  }
+  if (params.capabilitySpec?.supportsResponsesApi === false) {
+    return false;
+  }
+  const explicitWireApi = readString2(params.wireApi)?.toLowerCase();
+  if (explicitWireApi === "chat") {
+    return false;
+  }
+  if (explicitWireApi === "responses") {
+    return true;
+  }
+  return await probeCodexResponsesApiSupport({
+    apiBase: params.apiBase,
+    apiKey: params.apiKey,
+    extraHeaders: params.extraHeaders,
+    model: params.model
+  });
+}
+
+// src/codex-session-type.ts
+function readString3(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const values = value.map((entry) => readString3(entry)).filter((entry) => Boolean(entry));
+  return values.length > 0 ? values : void 0;
+}
+function dedupeStrings(values) {
+  return Array.from(new Set(values));
+}
+function resolveConfiguredCodexModels(params) {
+  const explicitSupportedModels = readStringArray(params.pluginConfig.supportedModels);
+  if (explicitSupportedModels) {
+    return dedupeStrings(explicitSupportedModels);
+  }
+  const configuredProviders = params.config.providers && typeof params.config.providers === "object" && !Array.isArray(params.config.providers) ? params.config.providers : {};
+  const configuredModels = Object.entries(configuredProviders).flatMap(
+    ([providerName, provider]) => (provider.models ?? []).map((modelName) => readString3(modelName)).filter((modelName) => Boolean(modelName)).map((modelName) => `${providerName}/${modelName}`)
+  );
+  const fallbackModel = readString3(params.pluginConfig.model) ?? params.config.agents.defaults.model;
+  const fallbackModels = fallbackModel ? [fallbackModel] : [];
+  return dedupeStrings(configuredModels.length > 0 ? configuredModels : fallbackModels);
+}
+function resolveRecommendedCodexModel(params) {
+  const configuredModel = readString3(params.pluginConfig.model) ?? params.config.agents.defaults.model;
+  if (params.supportedModels.includes(configuredModel)) {
+    return configuredModel;
+  }
+  return params.supportedModels[0] ?? configuredModel ?? null;
+}
+function createDescribeCodexSessionType(params) {
+  return () => {
+    const supportedModels = resolveConfiguredCodexModels(params);
+    return {
+      ready: true,
+      reason: null,
+      reasonMessage: null,
+      supportedModels,
+      recommendedModel: resolveRecommendedCodexModel({
+        config: params.config,
+        pluginConfig: params.pluginConfig,
+        supportedModels
+      }),
+      cta: null
+    };
+  };
+}
+
+// src/index.ts
+var PLUGIN_ID = "nextclaw-ncp-runtime-plugin-codex-sdk";
+var CODEX_RUNTIME_KIND = "codex";
+var DeferredCodexSdkNcpAgentRuntime = class {
   constructor(createRuntime) {
     this.createRuntime = createRuntime;
   }
@@ -38,28 +1121,28 @@ class DeferredCodexSdkNcpAgentRuntime {
     }.bind(this);
     return stream();
   }
-}
-function readString(value) {
+};
+function readString4(value) {
   if (typeof value !== "string") {
     return void 0;
   }
   const trimmed = value.trim();
   return trimmed || void 0;
 }
-function readBoolean(value) {
+function readBoolean2(value) {
   return typeof value === "boolean" ? value : void 0;
 }
-function readRecord(value) {
+function readRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
   return value;
 }
-function readStringArray(value) {
+function readStringArray2(value) {
   if (!Array.isArray(value)) {
     return void 0;
   }
-  const values = value.map((entry) => readString(entry)).filter((entry) => Boolean(entry));
+  const values = value.map((entry) => readString4(entry)).filter((entry) => Boolean(entry));
   return values.length > 0 ? values : void 0;
 }
 function resolveCodexCapabilitySpec(params) {
@@ -95,25 +1178,25 @@ function readThinkingLevel(value) {
   return void 0;
 }
 function resolveCodexExecutionOptions(params) {
-  const configuredWorkingDirectory = readString(params.pluginConfig.workingDirectory);
+  const configuredWorkingDirectory = readString4(params.pluginConfig.workingDirectory);
   const workspace = getWorkspacePath(
     configuredWorkingDirectory ?? params.config.agents.defaults.workspace
   );
   return {
     workingDirectory: workspace,
-    skipGitRepoCheck: readBoolean(params.pluginConfig.skipGitRepoCheck) ?? true
+    skipGitRepoCheck: readBoolean2(params.pluginConfig.skipGitRepoCheck) ?? true
   };
 }
 function resolveCodexCliConfig(params) {
-  const explicitConfig = readRecord(params.pluginConfig.config);
-  const modelProvider = readString(params.modelProviderOverride) ?? resolveExternalModelProvider({
+  const explicitConfig = readRecord2(params.pluginConfig.config);
+  const modelProvider = readString4(params.modelProviderOverride) ?? resolveExternalModelProvider({
     explicitModelProvider: params.pluginConfig.modelProvider,
     providerName: params.providerName,
     providerDisplayName: params.providerDisplayName,
     pluginId: PLUGIN_ID
   });
-  const preferredAuthMethod = readString(params.pluginConfig.preferredAuthMethod) ?? "apikey";
-  const apiBase = readString(params.pluginConfig.apiBase) ?? readString(params.apiBase);
+  const preferredAuthMethod = readString4(params.pluginConfig.preferredAuthMethod) ?? "apikey";
+  const apiBase = readString4(params.pluginConfig.apiBase) ?? readString4(params.apiBase);
   const config = {
     model_provider: modelProvider,
     preferred_auth_method: preferredAuthMethod
@@ -134,9 +1217,9 @@ function resolveCodexCliConfig(params) {
   };
 }
 function resolveCodexModel(params) {
-  return readString(params.sessionMetadata.preferred_model) ?? readString(params.sessionMetadata.model) ?? readString(params.pluginConfig.model) ?? params.config.agents.defaults.model;
+  return readString4(params.sessionMetadata.preferred_model) ?? readString4(params.sessionMetadata.model) ?? readString4(params.pluginConfig.model) ?? params.config.agents.defaults.model;
 }
-const plugin = {
+var plugin = {
   id: PLUGIN_ID,
   name: "NextClaw Codex NCP Runtime",
   description: "Registers NCP session type `codex` backed by OpenAI Codex SDK.",
@@ -146,7 +1229,7 @@ const plugin = {
     properties: {}
   },
   register(api) {
-    const pluginConfig = readRecord(api.pluginConfig) ?? {};
+    const pluginConfig = readRecord2(api.pluginConfig) ?? {};
     const describeCodexSessionType = createDescribeCodexSessionType({
       config: api.config,
       pluginConfig
@@ -180,8 +1263,8 @@ const plugin = {
             providerLocalModel: resolvedProviderRuntime.providerLocalModel,
             resolvedModel: resolvedProviderRuntime.resolvedModel
           });
-          const upstreamApiBase = readString(pluginConfig.apiBase) ?? resolvedProviderRuntime.apiBase ?? void 0;
-          const apiKey = readString(pluginConfig.apiKey) ?? resolvedProviderRuntime.apiKey ?? void 0;
+          const upstreamApiBase = readString4(pluginConfig.apiBase) ?? resolvedProviderRuntime.apiBase ?? void 0;
+          const apiKey = readString4(pluginConfig.apiKey) ?? resolvedProviderRuntime.apiKey ?? void 0;
           if (!apiKey) {
             throw new Error(
               `[codex] missing apiKey. Set plugins.entries.${PLUGIN_ID}.config.apiKey or providers.*.apiKey for model "${userFacingModelRoute}".`
@@ -196,7 +1279,7 @@ const plugin = {
           let codexModelProviderOverride;
           const supportsResponsesApi = await resolveCodexResponsesApiSupport({
             capabilitySpec,
-            wireApi: readString(resolvedProviderRuntime.provider?.wireApi),
+            wireApi: readString4(resolvedProviderRuntime.provider?.wireApi),
             apiBase: upstreamApiBase,
             apiKey,
             extraHeaders: resolvedProviderRuntime.provider?.extraHeaders ?? null,
@@ -223,14 +1306,15 @@ const plugin = {
             config: nextConfig,
             pluginConfig
           });
+          const accessMode = resolveCodexAccessMode(pluginConfig);
           const thinkingLevel = readThinkingLevel(runtimeParams.sessionMetadata.preferred_thinking) ?? readThinkingLevel(runtimeParams.sessionMetadata.thinking) ?? void 0;
           return new CodexSdkNcpAgentRuntime({
             sessionId: runtimeParams.sessionId,
             apiKey,
             apiBase: codexApiBase,
             model: resolvedProviderRuntime.providerLocalModel,
-            threadId: readString(runtimeParams.sessionMetadata.codex_thread_id) ?? null,
-            codexPathOverride: readString(pluginConfig.codexPathOverride),
+            threadId: readString4(runtimeParams.sessionMetadata.codex_thread_id) ?? null,
+            codexPathOverride: readString4(pluginConfig.codexPathOverride),
             env: readStringRecord(pluginConfig.env),
             cliConfig: resolveCodexCliConfig({
               pluginConfig,
@@ -245,15 +1329,15 @@ const plugin = {
             inputBuilder: buildCodexInputBuilder(executionOptions.workingDirectory),
             threadOptions: {
               model,
-              sandboxMode: readString(pluginConfig.sandboxMode),
+              sandboxMode: mapAccessModeToSandboxMode(accessMode),
               workingDirectory: executionOptions.workingDirectory,
               skipGitRepoCheck: executionOptions.skipGitRepoCheck,
               modelReasoningEffort: thinkingLevel,
-              networkAccessEnabled: readBoolean(pluginConfig.networkAccessEnabled),
-              webSearchMode: readString(pluginConfig.webSearchMode),
-              webSearchEnabled: readBoolean(pluginConfig.webSearchEnabled),
-              approvalPolicy: readString(pluginConfig.approvalPolicy),
-              additionalDirectories: readStringArray(pluginConfig.additionalDirectories)
+              networkAccessEnabled: readBoolean2(pluginConfig.networkAccessEnabled),
+              webSearchMode: readString4(pluginConfig.webSearchMode),
+              webSearchEnabled: readBoolean2(pluginConfig.webSearchEnabled),
+              approvalPolicy: CODEX_APPROVAL_POLICY,
+              additionalDirectories: readStringArray2(pluginConfig.additionalDirectories)
             }
           });
         });