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

package/dist/index.js

@@ -1,4 +1,3 @@
-// src/index.ts
 import {
   findProviderByModel,
   findProviderByName,
@@ -8,1102 +7,20 @@ 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 {
-  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 {
+  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 {
   constructor(createRuntime) {
     this.createRuntime = createRuntime;
   }
@@ -1121,28 +38,28 @@ var DeferredCodexSdkNcpAgentRuntime = class {
     }.bind(this);
     return stream();
   }
-};
-function readString4(value) {
+}
+function readString(value) {
   if (typeof value !== "string") {
     return void 0;
   }
   const trimmed = value.trim();
   return trimmed || void 0;
 }
-function readBoolean2(value) {
+function readBoolean(value) {
   return typeof value === "boolean" ? value : void 0;
 }
-function readRecord2(value) {
+function readRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
   }
   return value;
 }
-function readStringArray2(value) {
+function readStringArray(value) {
   if (!Array.isArray(value)) {
     return void 0;
   }
-  const values = value.map((entry) => readString4(entry)).filter((entry) => Boolean(entry));
+  const values = value.map((entry) => readString(entry)).filter((entry) => Boolean(entry));
   return values.length > 0 ? values : void 0;
 }
 function resolveCodexCapabilitySpec(params) {
@@ -1178,25 +95,25 @@ function readThinkingLevel(value) {
   return void 0;
 }
 function resolveCodexExecutionOptions(params) {
-  const configuredWorkingDirectory = readString4(params.pluginConfig.workingDirectory);
+  const configuredWorkingDirectory = readString(params.pluginConfig.workingDirectory);
   const workspace = getWorkspacePath(
     configuredWorkingDirectory ?? params.config.agents.defaults.workspace
   );
   return {
     workingDirectory: workspace,
-    skipGitRepoCheck: readBoolean2(params.pluginConfig.skipGitRepoCheck) ?? true
+    skipGitRepoCheck: readBoolean(params.pluginConfig.skipGitRepoCheck) ?? true
   };
 }
 function resolveCodexCliConfig(params) {
-  const explicitConfig = readRecord2(params.pluginConfig.config);
-  const modelProvider = readString4(params.modelProviderOverride) ?? resolveExternalModelProvider({
+  const explicitConfig = readRecord(params.pluginConfig.config);
+  const modelProvider = readString(params.modelProviderOverride) ?? resolveExternalModelProvider({
     explicitModelProvider: params.pluginConfig.modelProvider,
     providerName: params.providerName,
     providerDisplayName: params.providerDisplayName,
     pluginId: PLUGIN_ID
   });
-  const preferredAuthMethod = readString4(params.pluginConfig.preferredAuthMethod) ?? "apikey";
-  const apiBase = readString4(params.pluginConfig.apiBase) ?? readString4(params.apiBase);
+  const preferredAuthMethod = readString(params.pluginConfig.preferredAuthMethod) ?? "apikey";
+  const apiBase = readString(params.pluginConfig.apiBase) ?? readString(params.apiBase);
   const config = {
     model_provider: modelProvider,
     preferred_auth_method: preferredAuthMethod
@@ -1217,9 +134,9 @@ function resolveCodexCliConfig(params) {
   };
 }
 function resolveCodexModel(params) {
-  return readString4(params.sessionMetadata.preferred_model) ?? readString4(params.sessionMetadata.model) ?? readString4(params.pluginConfig.model) ?? params.config.agents.defaults.model;
+  return readString(params.sessionMetadata.preferred_model) ?? readString(params.sessionMetadata.model) ?? readString(params.pluginConfig.model) ?? params.config.agents.defaults.model;
 }
-var plugin = {
+const plugin = {
   id: PLUGIN_ID,
   name: "NextClaw Codex NCP Runtime",
   description: "Registers NCP session type `codex` backed by OpenAI Codex SDK.",
@@ -1229,7 +146,7 @@ var plugin = {
     properties: {}
   },
   register(api) {
-    const pluginConfig = readRecord2(api.pluginConfig) ?? {};
+    const pluginConfig = readRecord(api.pluginConfig) ?? {};
     const describeCodexSessionType = createDescribeCodexSessionType({
       config: api.config,
       pluginConfig
@@ -1263,8 +180,8 @@ var plugin = {
             providerLocalModel: resolvedProviderRuntime.providerLocalModel,
             resolvedModel: resolvedProviderRuntime.resolvedModel
           });
-          const upstreamApiBase = readString4(pluginConfig.apiBase) ?? resolvedProviderRuntime.apiBase ?? void 0;
-          const apiKey = readString4(pluginConfig.apiKey) ?? resolvedProviderRuntime.apiKey ?? void 0;
+          const upstreamApiBase = readString(pluginConfig.apiBase) ?? resolvedProviderRuntime.apiBase ?? void 0;
+          const apiKey = readString(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}".`
@@ -1279,7 +196,7 @@ var plugin = {
           let codexModelProviderOverride;
           const supportsResponsesApi = await resolveCodexResponsesApiSupport({
             capabilitySpec,
-            wireApi: readString4(resolvedProviderRuntime.provider?.wireApi),
+            wireApi: readString(resolvedProviderRuntime.provider?.wireApi),
             apiBase: upstreamApiBase,
             apiKey,
             extraHeaders: resolvedProviderRuntime.provider?.extraHeaders ?? null,
@@ -1306,15 +223,14 @@ var 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: readString4(runtimeParams.sessionMetadata.codex_thread_id) ?? null,
-            codexPathOverride: readString4(pluginConfig.codexPathOverride),
+            threadId: readString(runtimeParams.sessionMetadata.codex_thread_id) ?? null,
+            codexPathOverride: readString(pluginConfig.codexPathOverride),
             env: readStringRecord(pluginConfig.env),
             cliConfig: resolveCodexCliConfig({
               pluginConfig,
@@ -1329,15 +245,15 @@ var plugin = {
             inputBuilder: buildCodexInputBuilder(executionOptions.workingDirectory),
             threadOptions: {
               model,
-              sandboxMode: mapAccessModeToSandboxMode(accessMode),
+              sandboxMode: readString(pluginConfig.sandboxMode),
               workingDirectory: executionOptions.workingDirectory,
               skipGitRepoCheck: executionOptions.skipGitRepoCheck,
               modelReasoningEffort: thinkingLevel,
-              networkAccessEnabled: readBoolean2(pluginConfig.networkAccessEnabled),
-              webSearchMode: readString4(pluginConfig.webSearchMode),
-              webSearchEnabled: readBoolean2(pluginConfig.webSearchEnabled),
-              approvalPolicy: CODEX_APPROVAL_POLICY,
-              additionalDirectories: readStringArray2(pluginConfig.additionalDirectories)
+              networkAccessEnabled: readBoolean(pluginConfig.networkAccessEnabled),
+              webSearchMode: readString(pluginConfig.webSearchMode),
+              webSearchEnabled: readBoolean(pluginConfig.webSearchEnabled),
+              approvalPolicy: readString(pluginConfig.approvalPolicy),
+              additionalDirectories: readStringArray(pluginConfig.additionalDirectories)
             }
           });
         });