plugin-ai-api 1.1.1 → 1.1.2

package/dist/server/utils/responses-format.js

@@ -0,0 +1,686 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var responses_format_exports = {};
+__export(responses_format_exports, {
+  chatResultToResponse: () => chatResultToResponse,
+  createResponseOutputMessage: () => createResponseOutputMessage,
+  createResponseReasoningItem: () => createResponseReasoningItem,
+  extractReasoningText: () => extractReasoningText,
+  extractResponseIncompleteReason: () => extractResponseIncompleteReason,
+  extractResponseOutputText: () => extractResponseOutputText,
+  extractResponseServiceTier: () => extractResponseServiceTier,
+  findResponseInputProblem: () => findResponseInputProblem,
+  findResponseParameterProblem: () => findResponseParameterProblem,
+  findResponseToolChoiceProblem: () => findResponseToolChoiceProblem,
+  findResponseToolProblem: () => findResponseToolProblem,
+  findUnsupportedResponseInput: () => findUnsupportedResponseInput,
+  findUnsupportedResponseParameter: () => findUnsupportedResponseParameter,
+  generateResponseId: () => generateResponseId,
+  generateResponseItemId: () => generateResponseItemId,
+  isRecord: () => isRecord,
+  isResponseServiceTier: () => isResponseServiceTier,
+  responseIncompleteReason: () => responseIncompleteReason,
+  responseUsageFromOpenAIUsage: () => responseUsageFromOpenAIUsage,
+  responsesBodyToChatBody: () => responsesBodyToChatBody,
+  responsesInputToMessages: () => responsesInputToMessages,
+  responsesToolsToChatTools: () => responsesToolsToChatTools
+});
+module.exports = __toCommonJS(responses_format_exports);
+var import_crypto = __toESM(require("crypto"));
+function generateResponseId() {
+  return `resp_${import_crypto.default.randomBytes(16).toString("hex")}`;
+}
+function generateResponseItemId(prefix = "msg") {
+  return `${prefix}_${import_crypto.default.randomBytes(16).toString("hex")}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function responseImageToChatBlock(block) {
+  if (typeof block.image_url !== "string" || !block.image_url) return null;
+  return {
+    type: "image_url",
+    image_url: {
+      url: block.image_url,
+      ...typeof block.detail === "string" ? { detail: block.detail } : {}
+    }
+  };
+}
+function responseFileToChatBlock(block) {
+  if (typeof block.file_data === "string" && block.file_data) {
+    return {
+      type: "file",
+      file: {
+        file_data: block.file_data,
+        ...typeof block.filename === "string" ? { filename: block.filename } : {}
+      }
+    };
+  }
+  if (typeof block.file_url === "string" && block.file_url) {
+    return { type: "file_url", file_url: { url: block.file_url } };
+  }
+  return null;
+}
+function responseContentToChatContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return content;
+  return content.flatMap((block) => {
+    if (typeof block === "string") return [{ type: "text", text: block }];
+    if (!isRecord(block)) return [];
+    if ((block.type === "input_text" || block.type === "output_text") && typeof block.text === "string") {
+      return [{ type: "text", text: block.text }];
+    }
+    if (block.type === "input_image") {
+      const converted = responseImageToChatBlock(block);
+      return converted ? [converted] : [];
+    }
+    if (block.type === "input_file") {
+      const converted = responseFileToChatBlock(block);
+      return converted ? [converted] : [];
+    }
+    if (block.type === "text" || block.type === "image_url" || block.type === "file" || block.type === "file_url") {
+      return [block];
+    }
+    return [];
+  });
+}
+function messageItemToChatMessage(item) {
+  const role = typeof item.role === "string" ? item.role : void 0;
+  if (!role) return null;
+  return {
+    role,
+    content: responseContentToChatContent(item.content),
+    ...typeof item.phase === "string" ? { phase: item.phase } : {}
+  };
+}
+function functionCallToChatMessage(item) {
+  if (typeof item.call_id !== "string" || typeof item.name !== "string") return null;
+  return {
+    role: "assistant",
+    content: "",
+    tool_calls: [
+      {
+        id: item.call_id,
+        type: "function",
+        function: {
+          name: item.name,
+          arguments: typeof item.arguments === "string" ? item.arguments : "{}"
+        }
+      }
+    ]
+  };
+}
+function appendFunctionCall(messages, item) {
+  const message = functionCallToChatMessage(item);
+  if (!message) return false;
+  const previous = messages.at(-1);
+  const previousAdditional = isRecord(previous == null ? void 0 : previous.additional_kwargs) ? previous.additional_kwargs : {};
+  const hasReasoning = typeof previousAdditional.reasoning_content === "string" || isRecord(previousAdditional.reasoning);
+  if ((previous == null ? void 0 : previous.role) !== "assistant" || previous.content !== "" || (!Array.isArray(previous.tool_calls) || previous.tool_calls.length === 0) && !hasReasoning) {
+    messages.push(message);
+    return true;
+  }
+  const previousCalls = Array.isArray(previous.tool_calls) ? previous.tool_calls : [];
+  const nextCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+  previous.tool_calls = [...previousCalls, ...nextCalls];
+  previous.additional_kwargs = {
+    ...isRecord(previous.additional_kwargs) ? previous.additional_kwargs : {},
+    tool_calls: previous.tool_calls
+  };
+  const responseMetadata2 = isRecord(previous.response_metadata) ? previous.response_metadata : {};
+  const output = Array.isArray(responseMetadata2.output) ? responseMetadata2.output : [];
+  previous.response_metadata = { ...responseMetadata2, output: [...output, item] };
+  return true;
+}
+function reasoningToChatMessage(item) {
+  const summary = Array.isArray(item.summary) ? item.summary.filter((part) => isRecord(part) && typeof part.text === "string").map((part) => part.text).join("\n") : "";
+  const content = Array.isArray(item.content) ? item.content.filter((part) => isRecord(part) && typeof part.text === "string").map((part) => part.text).join("\n") : "";
+  return {
+    role: "assistant",
+    content: "",
+    additional_kwargs: {
+      reasoning_content: content || summary,
+      reasoning: item
+    },
+    response_metadata: { output: [item] }
+  };
+}
+function appendReasoningItem(messages, item) {
+  const previous = messages.at(-1);
+  if ((previous == null ? void 0 : previous.role) === "assistant" && previous.content === "") {
+    const reasoning = reasoningToChatMessage(item);
+    previous.additional_kwargs = {
+      ...isRecord(previous.additional_kwargs) ? previous.additional_kwargs : {},
+      ...isRecord(reasoning.additional_kwargs) ? reasoning.additional_kwargs : {}
+    };
+    const responseMetadata2 = isRecord(previous.response_metadata) ? previous.response_metadata : {};
+    const output = Array.isArray(responseMetadata2.output) ? responseMetadata2.output : [];
+    previous.response_metadata = { ...responseMetadata2, output: [...output, item] };
+    return;
+  }
+  messages.push(reasoningToChatMessage(item));
+}
+function functionCallOutputToChatMessage(item) {
+  if (typeof item.call_id !== "string") return null;
+  return {
+    role: "tool",
+    content: responseContentToChatContent(item.output),
+    tool_call_id: item.call_id
+  };
+}
+function responsesInputToMessages(input, instructions) {
+  const messages = [];
+  if (typeof instructions === "string" && instructions) {
+    messages.push({ role: "developer", content: instructions });
+  }
+  if (typeof input === "string") return [...messages, { role: "user", content: input }];
+  if (!Array.isArray(input)) return messages;
+  for (const item of input) {
+    if (!isRecord(item)) continue;
+    if (item.type === "function_call") {
+      appendFunctionCall(messages, item);
+      continue;
+    }
+    if (item.type === "reasoning") {
+      appendReasoningItem(messages, item);
+      continue;
+    }
+    let message = null;
+    if (item.type === "function_call_output") message = functionCallOutputToChatMessage(item);
+    else if (item.type === "message" || typeof item.role === "string") message = messageItemToChatMessage(item);
+    if (message) messages.push(message);
+  }
+  return messages;
+}
+function responseFunctionToolToChatTool(tool) {
+  if (tool.type !== "function" || typeof tool.name !== "string") return null;
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      ...typeof tool.description === "string" ? { description: tool.description } : {},
+      parameters: isRecord(tool.parameters) ? tool.parameters : {},
+      ...typeof tool.strict === "boolean" ? { strict: tool.strict } : {}
+    }
+  };
+}
+function responsesToolsToChatTools(tools) {
+  if (!Array.isArray(tools)) return void 0;
+  return tools.flatMap((tool) => {
+    if (!isRecord(tool)) return [];
+    const converted = responseFunctionToolToChatTool(tool);
+    return converted ? [converted] : [];
+  });
+}
+function responsesToolChoiceToChatToolChoice(toolChoice) {
+  if (!isRecord(toolChoice) || toolChoice.type !== "function" || typeof toolChoice.name !== "string") {
+    return toolChoice;
+  }
+  return { type: "function", function: { name: toolChoice.name } };
+}
+function responsesBodyToChatBody(body) {
+  const chatBody = {
+    model: body.model,
+    messages: responsesInputToMessages(body.input, body.instructions)
+  };
+  if (body.temperature !== void 0) chatBody.temperature = body.temperature;
+  if (body.top_p !== void 0) chatBody.top_p = body.top_p;
+  if (body.max_output_tokens !== void 0) chatBody.max_completion_tokens = body.max_output_tokens;
+  const tools = responsesToolsToChatTools(body.tools);
+  if (tools) chatBody.tools = tools;
+  if (body.tool_choice !== void 0) chatBody.tool_choice = responsesToolChoiceToChatToolChoice(body.tool_choice);
+  if (body.stream !== void 0) chatBody.stream = body.stream;
+  if (body.service_tier !== void 0 && body.service_tier !== null) chatBody.service_tier = body.service_tier;
+  if (body.prompt_cache_key !== void 0) chatBody.promptCacheKey = body.prompt_cache_key;
+  if (body.prompt_cache_retention !== void 0 && body.prompt_cache_retention !== null) {
+    chatBody.promptCacheRetention = body.prompt_cache_retention;
+  }
+  if (body.reasoning !== void 0 && body.reasoning !== null) chatBody.reasoning = body.reasoning;
+  if (body.safety_identifier !== void 0) chatBody.safety_identifier = body.safety_identifier;
+  if (body.text !== void 0) {
+    if (isRecord(body.text)) {
+      if (body.text.format !== void 0) chatBody.response_format = responsesTextFormatToChatFormat(body.text.format);
+      if (body.text.verbosity !== void 0) chatBody.verbosity = body.text.verbosity;
+    }
+  }
+  if (body.parallel_tool_calls !== void 0 && body.parallel_tool_calls !== null) {
+    chatBody.parallel_tool_calls = body.parallel_tool_calls;
+  }
+  if (body.user !== void 0) chatBody.user = body.user;
+  return chatBody;
+}
+function responseUsageFromOpenAIUsage(usage, reasoningTokens = 0) {
+  return {
+    input_tokens: (usage == null ? void 0 : usage.prompt_tokens) ?? 0,
+    input_tokens_details: { cached_tokens: (usage == null ? void 0 : usage.prompt_cache_tokens) ?? 0 },
+    output_tokens: (usage == null ? void 0 : usage.completion_tokens) ?? 0,
+    output_tokens_details: { reasoning_tokens: (usage == null ? void 0 : usage.reasoning_tokens) ?? reasoningTokens },
+    total_tokens: (usage == null ? void 0 : usage.total_tokens) ?? 0
+  };
+}
+function createResponseOutputMessage(text, status = "completed", id = generateResponseItemId("msg"), phase) {
+  return {
+    id,
+    type: "message",
+    status,
+    role: "assistant",
+    content: text ? [{ type: "output_text", text, annotations: [] }] : [],
+    ...phase === void 0 ? {} : { phase }
+  };
+}
+function extractResponseOutputText(value) {
+  if (!isRecord(value)) return "";
+  if (typeof value.content === "string") return value.content;
+  if (!Array.isArray(value.content)) return "";
+  return value.content.filter(
+    (block) => isRecord(block) && (block.type === "text" || block.type === "output_text")
+  ).map((block) => typeof block.text === "string" ? block.text : "").join("");
+}
+function toolCallToResponseFunctionCall(call) {
+  return {
+    id: generateResponseItemId("fc"),
+    type: "function_call",
+    status: "completed",
+    call_id: call.id,
+    name: call.function.name,
+    arguments: call.function.arguments
+  };
+}
+function createResponseReasoningItem(text) {
+  return {
+    id: generateResponseItemId("rs"),
+    type: "reasoning",
+    status: "completed",
+    summary: [],
+    content: text ? [{ type: "reasoning_text", text }] : []
+  };
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function responseMetadata(value) {
+  if (!isRecord(value)) return null;
+  const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+  return Object.fromEntries(entries);
+}
+function chatResultToResponse(options) {
+  const {
+    id = generateResponseId(),
+    model,
+    content,
+    reasoningText,
+    usage,
+    toolCalls,
+    finishReason,
+    serviceTier,
+    requestBody,
+    status = responseIncompleteReason(finishReason) ? "incomplete" : "completed"
+  } = options;
+  const output = [];
+  if (reasoningText) output.push(createResponseReasoningItem(reasoningText));
+  if (content) output.push(createResponseOutputMessage(content));
+  if (toolCalls == null ? void 0 : toolCalls.length) output.push(...toolCalls.map(toolCallToResponseFunctionCall));
+  const now = Math.floor(Date.now() / 1e3);
+  return {
+    id,
+    object: "response",
+    created_at: now,
+    completed_at: status === "completed" ? now : null,
+    status,
+    error: null,
+    incomplete_details: status === "incomplete" ? { reason: responseIncompleteReason(finishReason) ?? "max_output_tokens" } : null,
+    instructions: typeof requestBody.instructions === "string" ? requestBody.instructions : null,
+    ...requestBody.max_output_tokens === void 0 ? {} : { max_output_tokens: numberOrNull(requestBody.max_output_tokens) },
+    model,
+    output,
+    output_text: content,
+    parallel_tool_calls: requestBody.parallel_tool_calls !== false,
+    ...requestBody.previous_response_id === void 0 ? {} : {
+      previous_response_id: typeof requestBody.previous_response_id === "string" ? requestBody.previous_response_id : null
+    },
+    prompt_cache_key: typeof requestBody.prompt_cache_key === "string" ? requestBody.prompt_cache_key : void 0,
+    prompt_cache_retention: requestBody.prompt_cache_retention === "in_memory" || requestBody.prompt_cache_retention === "24h" ? requestBody.prompt_cache_retention : requestBody.prompt_cache_retention === null ? null : void 0,
+    ...requestBody.reasoning === void 0 ? {} : { reasoning: isRecord(requestBody.reasoning) ? requestBody.reasoning : null },
+    safety_identifier: typeof requestBody.safety_identifier === "string" ? requestBody.safety_identifier : void 0,
+    service_tier: serviceTier ?? (isResponseServiceTier(requestBody.service_tier) ? requestBody.service_tier : "auto"),
+    temperature: numberOrNull(requestBody.temperature),
+    ...requestBody.text === void 0 ? {} : { text: isRecord(requestBody.text) ? requestBody.text : void 0 },
+    tool_choice: requestBody.tool_choice ?? "auto",
+    tools: Array.isArray(requestBody.tools) ? requestBody.tools : [],
+    top_p: numberOrNull(requestBody.top_p),
+    truncation: requestBody.truncation === "auto" ? "auto" : "disabled",
+    usage: responseUsageFromOpenAIUsage(usage),
+    user: typeof requestBody.user === "string" ? requestBody.user : void 0,
+    metadata: responseMetadata(requestBody.metadata)
+  };
+}
+function extractReasoningText(value) {
+  if (!isRecord(value)) return void 0;
+  const candidates = [
+    value.reasoning_content,
+    value.reasoning,
+    isRecord(value.additional_kwargs) ? value.additional_kwargs.reasoning_content : void 0,
+    isRecord(value.additional_kwargs) ? value.additional_kwargs.reasoning : void 0,
+    isRecord(value.response_metadata) ? value.response_metadata.reasoning_content : void 0,
+    isRecord(value.response_metadata) ? value.response_metadata.reasoning : void 0
+  ];
+  for (const candidate of candidates) {
+    const text = reasoningValueToText(candidate);
+    if (text) return text;
+  }
+  if (Array.isArray(value.content)) {
+    const text = value.content.filter(
+      (block) => isRecord(block) && (block.type === "reasoning" || block.type === "reasoning_content")
+    ).map(reasoningValueToText).filter((part) => Boolean(part)).join("");
+    if (text) return text;
+  }
+  return void 0;
+}
+function reasoningValueToText(value) {
+  if (typeof value === "string") return value || void 0;
+  if (!isRecord(value)) return void 0;
+  if (typeof value.reasoning === "string" && value.reasoning) return value.reasoning;
+  if (typeof value.text === "string" && value.text) return value.text;
+  if (typeof value.content === "string" && value.content) return value.content;
+  for (const key of ["content", "summary"]) {
+    const parts = value[key];
+    if (!Array.isArray(parts)) continue;
+    const text = parts.filter(isRecord).map((part) => typeof part.text === "string" ? part.text : "").filter(Boolean).join("");
+    if (text) return text;
+  }
+  return void 0;
+}
+function responseIncompleteReason(finishReason) {
+  if (finishReason === "length" || finishReason === "max_tokens" || finishReason === "max_output_tokens") {
+    return "max_output_tokens";
+  }
+  if (finishReason === "content_filter") return "content_filter";
+  return null;
+}
+function extractResponseIncompleteReason(value) {
+  if (!isRecord(value)) return void 0;
+  const metadataCandidates = [value.response_metadata, value.additional_kwargs, value];
+  for (const candidate of metadataCandidates) {
+    if (!isRecord(candidate)) continue;
+    if (candidate.status === "incomplete" && candidate.incomplete_details === null) return "max_output_tokens";
+    const details = candidate.incomplete_details;
+    if (!isRecord(details)) continue;
+    if (details.reason === "max_output_tokens" || details.reason === "content_filter") return details.reason;
+  }
+  return void 0;
+}
+function extractResponseServiceTier(value) {
+  if (!isRecord(value)) return void 0;
+  const responseMetadata2 = isRecord(value.response_metadata) ? value.response_metadata : void 0;
+  const candidate = (responseMetadata2 == null ? void 0 : responseMetadata2.service_tier) ?? (responseMetadata2 == null ? void 0 : responseMetadata2.serviceTier) ?? value.service_tier;
+  return isResponseServiceTier(candidate) ? candidate : void 0;
+}
+function isResponseServiceTier(value) {
+  return value === "auto" || value === "default" || value === "flex" || value === "scale" || value === "priority";
+}
+function findResponseParameterProblem(body) {
+  if (body.instructions !== void 0 && body.instructions !== null && typeof body.instructions !== "string") {
+    return "'instructions' must be a string or null";
+  }
+  const numberFields = [
+    { name: "max_output_tokens", min: 1, integer: true },
+    { name: "temperature", min: 0, max: 2 },
+    { name: "top_p", min: 0, max: 1 }
+  ];
+  for (const field of numberFields) {
+    const value = body[field.name];
+    if (value === void 0 || value === null) continue;
+    if (typeof value !== "number" || !Number.isFinite(value) || value < field.min || field.max !== void 0 && value > field.max || field.integer && !Number.isSafeInteger(value)) {
+      return `'${field.name}' must be ${field.integer ? "an integer" : "a number"} between ${field.min} and ${field.max ?? "the supported model limit"}`;
+    }
+  }
+  for (const name of ["parallel_tool_calls", "store", "stream"]) {
+    if (body[name] !== void 0 && body[name] !== null && typeof body[name] !== "boolean") {
+      return `'${name}' must be a boolean or null`;
+    }
+  }
+  for (const name of ["prompt_cache_key", "safety_identifier", "user"]) {
+    if (body[name] !== void 0 && typeof body[name] !== "string") {
+      return `'${name}' must be a string`;
+    }
+  }
+  if (typeof body.safety_identifier === "string" && body.safety_identifier.length > 64) {
+    return "'safety_identifier' must be at most 64 characters";
+  }
+  if (body.prompt_cache_retention !== void 0 && body.prompt_cache_retention !== null && body.prompt_cache_retention !== "in_memory" && body.prompt_cache_retention !== "24h") {
+    return "'prompt_cache_retention' must be 'in_memory', '24h', or null";
+  }
+  if (body.reasoning !== void 0 && body.reasoning !== null) {
+    if (!isRecord(body.reasoning)) return "'reasoning' must be an object or null";
+    const effort = body.reasoning.effort;
+    if (effort !== void 0 && effort !== null && effort !== "none" && effort !== "minimal" && effort !== "low" && effort !== "medium" && effort !== "high" && effort !== "xhigh") {
+      return "'reasoning.effort' must be none, minimal, low, medium, high, xhigh, or null";
+    }
+  }
+  if (body.text !== void 0 && body.text !== null) {
+    if (!isRecord(body.text)) return "'text' must be an object or null";
+    if (body.text.verbosity !== void 0 && body.text.verbosity !== null) {
+      if (body.text.verbosity !== "low" && body.text.verbosity !== "medium" && body.text.verbosity !== "high") {
+        return "'text.verbosity' must be low, medium, high, or null";
+      }
+    }
+    const format = body.text.format;
+    if (format !== void 0 && format !== null) {
+      if (!isRecord(format)) return "'text.format' must be an object or null";
+      if (format.type !== "text" && format.type !== "json_object" && format.type !== "json_schema") {
+        return "'text.format.type' must be text, json_object, or json_schema";
+      }
+      if (format.type === "json_schema" && (typeof format.name !== "string" || !format.name || !isRecord(format.schema))) {
+        return "'text.format' with type json_schema requires a non-empty name and an object schema";
+      }
+    }
+  }
+  if (body.previous_response_id !== void 0 && body.previous_response_id !== null) {
+    if (typeof body.previous_response_id !== "string" || !body.previous_response_id) {
+      return "'previous_response_id' must be a non-empty string or null";
+    }
+  }
+  return void 0;
+}
+function findUnsupportedResponseInput(input) {
+  if (!Array.isArray(input)) return void 0;
+  for (const item of input) {
+    if (!isRecord(item) || !Array.isArray(item.content)) continue;
+    for (const block of item.content) {
+      if (!isRecord(block)) continue;
+      if (block.type === "input_image" && typeof block.file_id === "string") {
+        return "input_image.file_id";
+      }
+      if (block.type === "input_file" && typeof block.file_id === "string") {
+        return "input_file.file_id";
+      }
+    }
+  }
+  return void 0;
+}
+function findResponseToolProblem(tools) {
+  if (tools === void 0) return void 0;
+  if (!Array.isArray(tools)) return "'tools' must be an array";
+  for (const [index, tool] of tools.entries()) {
+    if (!isRecord(tool)) return `tools[${index}] must be an object`;
+    if (tool.type !== "function") return `tool type '${String(tool.type ?? "unknown")}' is not supported`;
+    if (typeof tool.name !== "string" || !tool.name) return `tools[${index}].name must be a non-empty string`;
+    if (tool.parameters !== void 0 && tool.parameters !== null && !isRecord(tool.parameters)) {
+      return `tools[${index}].parameters must be an object or null`;
+    }
+    if (tool.strict !== void 0 && tool.strict !== null && typeof tool.strict !== "boolean") {
+      return `tools[${index}].strict must be a boolean or null`;
+    }
+    if (tool.description !== void 0 && tool.description !== null && typeof tool.description !== "string") {
+      return `tools[${index}].description must be a string or null`;
+    }
+    if (tool.defer_loading !== void 0) return `tools[${index}].defer_loading is not supported`;
+  }
+  return void 0;
+}
+function findResponseToolChoiceProblem(toolChoice) {
+  if (toolChoice === void 0) return void 0;
+  if (toolChoice === "auto" || toolChoice === "none" || toolChoice === "required") return void 0;
+  if (!isRecord(toolChoice)) return "'tool_choice' must be auto, none, required, or a function choice object";
+  if (toolChoice.type !== "function" || typeof toolChoice.name !== "string" || !toolChoice.name) {
+    return "'tool_choice' object must have type='function' and a non-empty name";
+  }
+  return void 0;
+}
+function findResponseInputProblem(input) {
+  if (typeof input === "string") return input.length > 0 ? void 0 : "'input' string must not be empty";
+  if (!Array.isArray(input)) return "'input' must be a string or an array";
+  if (input.length === 0) return "'input' array must not be empty";
+  for (const [index, item] of input.entries()) {
+    if (!isRecord(item)) return `input[${index}] must be an object`;
+    if (item.type === "function_call") {
+      if (typeof item.call_id !== "string" || !item.call_id || typeof item.name !== "string" || !item.name || typeof item.arguments !== "string") {
+        return `input[${index}] function_call requires non-empty call_id and name strings plus string arguments`;
+      }
+      continue;
+    }
+    if (item.type === "reasoning") {
+      if (typeof item.id !== "string" || !item.id || !Array.isArray(item.summary)) {
+        return `input[${index}] reasoning requires a non-empty id and summary array`;
+      }
+      const invalidSummary = item.summary.some(
+        (part) => !isRecord(part) || part.type !== "summary_text" || typeof part.text !== "string"
+      );
+      if (invalidSummary) return `input[${index}].reasoning summary items must be summary_text objects`;
+      if (item.content !== void 0 && (!Array.isArray(item.content) || item.content.some(
+        (part) => !isRecord(part) || part.type !== "reasoning_text" || typeof part.text !== "string"
+      ))) {
+        return `input[${index}].reasoning content items must be reasoning_text objects`;
+      }
+      continue;
+    }
+    if (item.type === "function_call_output") {
+      if (typeof item.call_id !== "string" || !item.call_id || item.output === void 0) {
+        return `input[${index}] function_call_output requires call_id and output`;
+      }
+      if (typeof item.output !== "string" && (!Array.isArray(item.output) || item.output.some(
+        (part) => !isRecord(part) || part.type !== "input_text" && part.type !== "input_image" && part.type !== "input_file"
+      ))) {
+        return `input[${index}] function_call_output output must be a string or input content array`;
+      }
+      continue;
+    }
+    if (item.type === "message" || typeof item.role === "string") {
+      if (item.role !== "user" && item.role !== "assistant" && item.role !== "system" && item.role !== "developer") {
+        return `input[${index}].role is not supported`;
+      }
+      if (typeof item.content !== "string" && !Array.isArray(item.content)) {
+        return `input[${index}].content must be a string or an array`;
+      }
+      if (item.phase !== void 0 && item.phase !== null && item.phase !== "commentary" && item.phase !== "final_answer") {
+        return `input[${index}].phase must be commentary, final_answer, or null`;
+      }
+      if (Array.isArray(item.content)) {
+        for (const [contentIndex, block] of item.content.entries()) {
+          if (!isRecord(block) || typeof block.type !== "string") {
+            return `input[${index}].content[${contentIndex}] must be a typed object`;
+          }
+          if ((block.type === "input_text" || block.type === "output_text") && typeof block.text !== "string") {
+            return `input[${index}].content[${contentIndex}].text must be a string`;
+          }
+          if (block.type === "input_image" && typeof block.image_url !== "string" && typeof block.file_id !== "string") {
+            return `input[${index}].content[${contentIndex}] input_image requires image_url or file_id`;
+          }
+          if (block.type === "input_file" && typeof block.file_url !== "string" && typeof block.file_data !== "string" && typeof block.file_id !== "string") {
+            return `input[${index}].content[${contentIndex}] input_file requires file_url, file_data, or file_id`;
+          }
+          if (block.type !== "input_text" && block.type !== "output_text" && block.type !== "input_image" && block.type !== "input_file") {
+            return `input[${index}].content[${contentIndex}] type '${block.type}' is not supported`;
+          }
+        }
+      }
+      continue;
+    }
+    return `input[${index}] type '${String(item.type ?? "unknown")}' is not supported`;
+  }
+  return void 0;
+}
+function findUnsupportedResponseParameter(body) {
+  const unsupported = [
+    "background",
+    "context_management",
+    "conversation",
+    "include",
+    "max_tool_calls",
+    "prompt",
+    "stream_options",
+    "top_logprobs"
+  ];
+  return unsupported.find((name) => body[name] !== void 0);
+}
+function responsesTextFormatToChatFormat(format) {
+  if (!isRecord(format) || format.type !== "json_schema") return format;
+  return {
+    type: "json_schema",
+    json_schema: {
+      name: format.name,
+      schema: format.schema,
+      ...typeof format.description === "string" ? { description: format.description } : {},
+      ...typeof format.strict === "boolean" ? { strict: format.strict } : {}
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chatResultToResponse,
+  createResponseOutputMessage,
+  createResponseReasoningItem,
+  extractReasoningText,
+  extractResponseIncompleteReason,
+  extractResponseOutputText,
+  extractResponseServiceTier,
+  findResponseInputProblem,
+  findResponseParameterProblem,
+  findResponseToolChoiceProblem,
+  findResponseToolProblem,
+  findUnsupportedResponseInput,
+  findUnsupportedResponseParameter,
+  generateResponseId,
+  generateResponseItemId,
+  isRecord,
+  isResponseServiceTier,
+  responseIncompleteReason,
+  responseUsageFromOpenAIUsage,
+  responsesBodyToChatBody,
+  responsesInputToMessages,
+  responsesToolsToChatTools
+});