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

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

@@ -1,312 +0,0 @@
-import {
-  nextSequenceNumber,
-  readArray,
-  readNumber,
-  readRecord,
-  readString,
-  writeSseEvent
-} from "./codex-openai-responses-bridge-shared.js";
-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 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 = 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 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 = readString(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 = readString(params.item.id);
-  const content = readArray(params.item.content);
-  const textPart = content.find((entry) => readString(readRecord(entry)?.type) === "output_text");
-  const text = readString(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 = readString(params.item.id);
-  const argumentsText = readString(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 = readString(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();
-}
-export {
-  buildBridgeResponsePayload,
-  writeResponsesStream,
-  writeStreamError
-};

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

@@ -1,5 +0,0 @@
-import { CodexOpenAiResponsesBridgeConfig, CodexOpenAiResponsesBridgeResult } from './codex-openai-responses-bridge-shared.js';
-
-declare function ensureCodexOpenAiResponsesBridge(config: CodexOpenAiResponsesBridgeConfig): Promise<CodexOpenAiResponsesBridgeResult>;
-
-export { ensureCodexOpenAiResponsesBridge };

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

@@ -1,140 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { createServer } from "node:http";
-import { callOpenAiCompatibleUpstream } from "./codex-openai-responses-bridge-request.js";
-import {
-  buildBridgeResponsePayload,
-  writeResponsesStream,
-  writeStreamError
-} from "./codex-openai-responses-bridge-stream.js";
-import {
-  readBoolean,
-  readRecord
-} from "./codex-openai-responses-bridge-shared.js";
-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())
-  });
-}
-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;
-  }
-}
-export {
-  ensureCodexOpenAiResponsesBridge
-};

package/dist/codex-responses-capability.d.ts

@@ -1,12 +0,0 @@
-declare function resolveCodexResponsesApiSupport(params: {
-    capabilitySpec?: {
-        supportsResponsesApi?: boolean;
-    } | null;
-    wireApi?: string | null;
-    apiBase: string;
-    apiKey: string;
-    extraHeaders?: Record<string, string> | null;
-    model: string;
-}): Promise<boolean>;
-
-export { resolveCodexResponsesApiSupport };

package/dist/codex-responses-capability.js

@@ -1,109 +0,0 @@
-import { readString } from "./codex-openai-responses-bridge-shared.js";
-const 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 readString(record.message) ?? readString(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 = readString(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 = readString(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
-  });
-}
-export {
-  resolveCodexResponsesApiSupport
-};

package/dist/codex-session-type.d.ts

@@ -1,20 +0,0 @@
-import { Config } from '@nextclaw/core';
-
-type SessionTypeDescriptor = {
-    ready?: boolean;
-    reason?: string | null;
-    reasonMessage?: string | null;
-    supportedModels?: string[];
-    recommendedModel?: string | null;
-    cta?: {
-        kind: string;
-        label?: string;
-        href?: string;
-    } | null;
-};
-declare function createDescribeCodexSessionType(params: {
-    config: Config;
-    pluginConfig: Record<string, unknown>;
-}): () => SessionTypeDescriptor;
-
-export { type SessionTypeDescriptor, createDescribeCodexSessionType };

package/dist/codex-session-type.js

@@ -1,57 +0,0 @@
-function readString(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) => readString(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) => readString(modelName)).filter((modelName) => Boolean(modelName)).map((modelName) => `${providerName}/${modelName}`)
-  );
-  const fallbackModel = readString(params.pluginConfig.model) ?? params.config.agents.defaults.model;
-  const fallbackModels = fallbackModel ? [fallbackModel] : [];
-  return dedupeStrings(configuredModels.length > 0 ? configuredModels : fallbackModels);
-}
-function resolveRecommendedCodexModel(params) {
-  const configuredModel = readString(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
-    };
-  };
-}
-export {
-  createDescribeCodexSessionType
-};