plugin-ai-api 1.1.1 → 1.1.2

package/dist/server/routes/responses.js

@@ -0,0 +1,530 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var responses_exports = {};
+__export(responses_exports, {
+  RESPONSES_CAPABLE_PROVIDERS: () => RESPONSES_CAPABLE_PROVIDERS,
+  handleDeleteResponse: () => handleDeleteResponse,
+  handleGetResponse: () => handleGetResponse,
+  handleResponses: () => handleResponses
+});
+module.exports = __toCommonJS(responses_exports);
+var import_billing = require("../billing");
+var import_file_processor = require("../services/file-processor");
+var import_usage = require("../usage");
+var import_app_observability = require("../utils/app-observability");
+var import_direct_llm_context = require("../utils/direct-llm-context");
+var import_openai_format = require("../utils/openai-format");
+var import_request_cache = require("../utils/request-cache");
+var import_response_store = require("../utils/response-store");
+var import_responses_format = require("../utils/responses-format");
+var import_responses_stream = require("../utils/responses-stream");
+var import_resolve_service = require("../utils/resolve-service");
+var import_streaming = require("../utils/streaming");
+var import_user_permissions = require("../utils/user-permissions");
+var import_virtual_models = require("../utils/virtual-models");
+var import_chat_completions = require("./chat-completions");
+const RESPONSES_CAPABLE_PROVIDERS = /* @__PURE__ */ new Set(["openai"]);
+function isResponsesCapableProvider(providerName) {
+  return RESPONSES_CAPABLE_PROVIDERS.has(providerName);
+}
+function getErrorMessage(error, fallback) {
+  return error instanceof Error && error.message ? error.message : fallback;
+}
+function getCurrentUserId(ctx) {
+  var _a;
+  return (_a = ctx.state.currentUser) == null ? void 0 : _a.id;
+}
+function validateRequest(ctx, body) {
+  if (typeof body.model !== "string" || !body.model) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'model' is required", "invalid_request_error", "missing_model");
+    return false;
+  }
+  if (body.input === void 0 || body.input === null) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'input' is required", "invalid_request_error", "missing_input");
+    return false;
+  }
+  if (body.model.trim().length === 0) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, "'model' must not be blank", "invalid_request_error", "missing_model");
+    return false;
+  }
+  const parameterProblem = (0, import_responses_format.findResponseParameterProblem)(body);
+  if (parameterProblem) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, parameterProblem, "invalid_request_error", "invalid_parameter");
+    return false;
+  }
+  const inputProblem = (0, import_responses_format.findResponseInputProblem)(body.input);
+  if (inputProblem) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, inputProblem, "invalid_request_error", "invalid_input");
+    return false;
+  }
+  const unsupportedParameter = (0, import_responses_format.findUnsupportedResponseParameter)(body);
+  if (unsupportedParameter) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      `Responses API parameter '${unsupportedParameter}' is not supported by this gateway`,
+      "invalid_request_error",
+      "unsupported_parameter"
+    );
+    return false;
+  }
+  if (body.truncation !== void 0 && body.truncation !== null && body.truncation !== "auto" && body.truncation !== "disabled") {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      "'truncation' must be 'auto' or 'disabled'",
+      "invalid_request_error",
+      "invalid_truncation"
+    );
+    return false;
+  }
+  if (body.service_tier !== void 0 && body.service_tier !== null && !(0, import_responses_format.isResponseServiceTier)(body.service_tier)) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      "'service_tier' must be one of auto, default, flex, scale, or priority",
+      "invalid_request_error",
+      "invalid_service_tier"
+    );
+    return false;
+  }
+  const unsupportedInput = (0, import_responses_format.findUnsupportedResponseInput)(body.input);
+  if (unsupportedInput) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      `Responses API input '${unsupportedInput}' is not supported because this gateway has no OpenAI file store. Use image_url, file_url, or file_data instead.`,
+      "invalid_request_error",
+      "unsupported_input"
+    );
+    return false;
+  }
+  const toolProblem = (0, import_responses_format.findResponseToolProblem)(body.tools);
+  if (toolProblem) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, toolProblem, "invalid_request_error", "unsupported_tool");
+    return false;
+  }
+  const toolChoiceProblem = (0, import_responses_format.findResponseToolChoiceProblem)(body.tool_choice);
+  if (toolChoiceProblem) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(400, toolChoiceProblem, "invalid_request_error", "invalid_tool_choice");
+    return false;
+  }
+  if (body.metadata !== void 0 && body.metadata !== null) {
+    const entries = (0, import_responses_format.isRecord)(body.metadata) ? Object.entries(body.metadata) : [];
+    if (!(0, import_responses_format.isRecord)(body.metadata) || entries.length > 16 || entries.some(([key, value]) => key.length > 64 || typeof value !== "string" || value.length > 512)) {
+      ctx.status = 400;
+      ctx.body = (0, import_openai_format.toOpenAIError)(
+        400,
+        "'metadata' must contain at most 16 string values (keys <= 64 chars, values <= 512 chars)",
+        "invalid_request_error",
+        "invalid_metadata"
+      );
+      return false;
+    }
+  }
+  return true;
+}
+function toLangChainMessages(messages) {
+  return messages.map((message) => {
+    const role = message.role === "assistant" ? "ai" : message.role;
+    const content = (0, import_chat_completions.normalizeMessageContent)(message.content);
+    if (message.role === "assistant" && message.tool_calls) {
+      return {
+        role,
+        content,
+        tool_calls: message.tool_calls,
+        additional_kwargs: {
+          ...(0, import_responses_format.isRecord)(message.additional_kwargs) ? message.additional_kwargs : {},
+          tool_calls: message.tool_calls
+        },
+        ...(0, import_responses_format.isRecord)(message.response_metadata) ? { response_metadata: message.response_metadata } : {}
+      };
+    }
+    if (message.role === "assistant" && message.additional_kwargs) {
+      return {
+        role,
+        content,
+        additional_kwargs: message.additional_kwargs,
+        ...(0, import_responses_format.isRecord)(message.response_metadata) ? { response_metadata: message.response_metadata } : {}
+      };
+    }
+    if (message.role === "tool") {
+      return { role: "tool", content, tool_call_id: message.tool_call_id, name: message.name };
+    }
+    return [role, content];
+  });
+}
+function responseOverflowBehavior(body) {
+  return body.truncation === "auto" ? "truncate" : "reject";
+}
+const RESPONSE_INVOCATION_PARAMETERS = /* @__PURE__ */ new Set([
+  "max_completion_tokens",
+  "parallel_tool_calls",
+  "promptCacheKey",
+  "promptCacheRetention",
+  "reasoning",
+  "response_format",
+  "service_tier",
+  "temperature",
+  "top_p",
+  "user",
+  "verbosity"
+]);
+function responseModelKwargs(parameters) {
+  return Object.fromEntries(Object.entries(parameters).filter(([name]) => !RESPONSE_INVOCATION_PARAMETERS.has(name)));
+}
+function findCompletedResponse(events) {
+  const terminal = events.find((event) => event.type === "response.completed" || event.type === "response.incomplete");
+  return terminal && (0, import_responses_format.isRecord)(terminal.response) ? terminal.response : void 0;
+}
+function findUnsupportedRetrieveParameter(ctx) {
+  const query = (0, import_responses_format.isRecord)(ctx.query) ? ctx.query : {};
+  for (const name of ["include", "include[]", "include_obfuscation", "starting_after"]) {
+    if (Object.hasOwn(query, name)) return name === "include[]" ? "include" : name;
+  }
+  if (Object.hasOwn(query, "stream") && query.stream !== false && query.stream !== "false") return "stream";
+  return void 0;
+}
+async function handleGetResponse(ctx, responseId) {
+  const unsupportedParameter = findUnsupportedRetrieveParameter(ctx);
+  if (unsupportedParameter) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      `Responses API retrieve parameter '${unsupportedParameter}' is not supported by this gateway`,
+      "invalid_request_error",
+      "unsupported_parameter"
+    );
+    return;
+  }
+  const userId = getCurrentUserId(ctx);
+  const record = userId === void 0 ? null : await (0, import_response_store.getResponseRecord)(ctx, responseId, userId);
+  if (!record) {
+    ctx.status = 404;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      404,
+      `Response '${responseId}' was not found`,
+      "invalid_request_error",
+      "response_not_found"
+    );
+    return;
+  }
+  ctx.status = 200;
+  ctx.body = record.output;
+}
+async function handleDeleteResponse(ctx, responseId) {
+  const userId = getCurrentUserId(ctx);
+  const deleted = userId === void 0 ? false : await (0, import_response_store.deleteResponseRecord)(ctx, responseId, userId);
+  if (!deleted) {
+    ctx.status = 404;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      404,
+      `Response '${responseId}' was not found`,
+      "invalid_request_error",
+      "response_not_found"
+    );
+    return;
+  }
+  ctx.status = 204;
+  ctx.body = void 0;
+}
+async function handleResponses(ctx, plugin) {
+  var _a, _b;
+  const body = ctx.request.body ?? {};
+  if (!validateRequest(ctx, body)) return;
+  const chatBody = (0, import_responses_format.responsesBodyToChatBody)(body);
+  let messages = Array.isArray(chatBody.messages) ? chatBody.messages : [];
+  if (messages.length === 0) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      "'input' must contain at least one supported message or function call item",
+      "invalid_request_error",
+      "invalid_input"
+    );
+    return;
+  }
+  const messageProblem = (0, import_chat_completions.findMessageProblem)(messages);
+  if (messageProblem) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      `Invalid input[${messageProblem.index}]: ${messageProblem.reason}.`,
+      "invalid_request_error",
+      "invalid_input"
+    );
+    return;
+  }
+  const blockProblem = (0, import_chat_completions.findContentBlockProblem)(messages);
+  if (blockProblem) {
+    ctx.status = 400;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      400,
+      `Invalid content block in input[${blockProblem.index}]: ${blockProblem.reason}.`,
+      "invalid_request_error",
+      "invalid_content_block"
+    );
+    return;
+  }
+  const userId = getCurrentUserId(ctx);
+  if (typeof body.previous_response_id === "string") {
+    if (userId === void 0) {
+      ctx.status = 401;
+      ctx.body = (0, import_openai_format.toOpenAIError)(401, "Authentication is required", "authentication_error", "invalid_api_key");
+      return;
+    }
+    const previousMessages = await (0, import_response_store.loadConversationChain)(ctx, body.previous_response_id, userId);
+    if (!previousMessages) {
+      ctx.status = 404;
+      ctx.body = (0, import_openai_format.toOpenAIError)(
+        404,
+        `Previous response '${body.previous_response_id}' was not found`,
+        "invalid_request_error",
+        "previous_response_not_found"
+      );
+      return;
+    }
+    messages = [...previousMessages, ...messages];
+  }
+  const virtual = await (0, import_virtual_models.resolveVirtualModel)(ctx, body.model, chatBody, "chat");
+  if ((virtual == null ? void 0 : virtual.status) === "unavailable") {
+    (0, import_virtual_models.respondVirtualModelUnavailable)(ctx, virtual);
+    return;
+  }
+  if ((virtual == null ? void 0 : virtual.status) === "resolved") {
+    ctx.state.aiApiVirtualModel = virtual.virtualModel;
+    ctx.state.aiApiRoutingReason = virtual.reason;
+  }
+  const resolved = (virtual == null ? void 0 : virtual.resolved) ?? await (0, import_resolve_service.resolveModelString)(ctx, body.model);
+  if (!resolved) {
+    ctx.status = 404;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      404,
+      `Could not resolve model '${body.model}'. Format: 'serviceName/modelId'. Use GET /v1/models to see available models.`,
+      "invalid_request_error",
+      "model_not_found"
+    );
+    return;
+  }
+  const { service, modelId } = resolved;
+  try {
+    const aiPlugin = ctx.app.pm.get("ai");
+    if (!((_a = aiPlugin == null ? void 0 : aiPlugin.aiManager) == null ? void 0 : _a.llmProviders)) {
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, "AI plugin not available", "server_error");
+      return;
+    }
+    if (service.get("enabled") === false) {
+      ctx.status = 404;
+      ctx.body = (0, import_openai_format.toOpenAIError)(404, "LLM service is disabled", "invalid_request_error", "model_not_found");
+      return;
+    }
+    const config = await (0, import_request_cache.getAiApiConfig)(ctx);
+    if (!await (0, import_user_permissions.enforceModelAccess)(ctx, config == null ? void 0 : config.enabledLlmServices, service, modelId)) return;
+    const providerName = service.get("provider");
+    const providerMeta = aiPlugin.aiManager.llmProviders.get(providerName);
+    if (!providerMeta) {
+      ctx.status = 500;
+      ctx.body = (0, import_openai_format.toOpenAIError)(500, `Provider '${providerName}' not registered`, "server_error");
+      return;
+    }
+    messages = await Promise.all(
+      messages.map(async (message) => ({
+        ...message,
+        content: await (0, import_chat_completions.processMessageContentFileBlocks)(message.content, ctx, plugin)
+      }))
+    );
+    const prepared = await (0, import_direct_llm_context.prepareDirectLlmContext)(ctx, {
+      serviceName: service.get("name"),
+      modelId,
+      messages,
+      tools: chatBody.tools,
+      maxCompletionTokens: chatBody.max_completion_tokens,
+      overflowBehavior: responseOverflowBehavior(body)
+    });
+    await (0, import_billing.prepareLlmBilling)(ctx, resolved);
+    const modelOptions = {
+      model: modelId,
+      llmService: service.get("name")
+    };
+    if (chatBody.temperature !== void 0) modelOptions.temperature = chatBody.temperature;
+    if (chatBody.top_p !== void 0) modelOptions.topP = chatBody.top_p;
+    if (chatBody.max_completion_tokens !== void 0) modelOptions.maxTokens = chatBody.max_completion_tokens;
+    if (chatBody.reasoning !== void 0) modelOptions.reasoning = chatBody.reasoning;
+    if (chatBody.service_tier !== void 0) modelOptions.service_tier = chatBody.service_tier;
+    if (chatBody.promptCacheKey !== void 0) modelOptions.promptCacheKey = chatBody.promptCacheKey;
+    if (chatBody.promptCacheRetention !== void 0) modelOptions.promptCacheRetention = chatBody.promptCacheRetention;
+    if (chatBody.verbosity !== void 0) modelOptions.verbosity = chatBody.verbosity;
+    if (chatBody.user !== void 0) modelOptions.user = chatBody.user;
+    const provider = new providerMeta.provider({
+      app: ctx.app,
+      serviceOptions: service.get("options"),
+      modelOptions
+    });
+    const providerParameters = (0, import_chat_completions.getProviderRequestParameters)(chatBody);
+    const baseModel = provider.createModel();
+    (0, import_chat_completions.applyProviderRequestParameters)(baseModel, responseModelKwargs(providerParameters));
+    if (body.store === false && isResponsesCapableProvider(providerName) && baseModel && typeof baseModel === "object") {
+      baseModel.modelKwargs = {
+        ...baseModel.modelKwargs ?? {},
+        store: false
+      };
+    }
+    const chatModel = (0, import_chat_completions.bindRequestTools)(
+      baseModel,
+      chatBody.tools,
+      chatBody.tool_choice,
+      providerParameters
+    );
+    (0, import_billing.markLlmProviderAttempted)(ctx);
+    const modelName = `${service.get("name")}/${modelId}`;
+    const langchainMessages = toLangChainMessages(prepared.messages);
+    if (body.stream === true) {
+      await handleStreamingResponse(ctx, chatModel, langchainMessages, body, modelName, providerParameters, userId);
+    } else {
+      await handleNonStreamingResponse(ctx, chatModel, langchainMessages, body, modelName, providerParameters, userId);
+    }
+  } catch (error) {
+    ctx.log.error("AI API responses error:", error);
+    if (!((_b = ctx.res) == null ? void 0 : _b.headersSent)) {
+      const quotaError = error instanceof import_billing.AiApiQuotaError;
+      const requestError = error instanceof import_direct_llm_context.DirectLlmContextError || error instanceof import_file_processor.FileProcessorError;
+      ctx.status = quotaError ? 429 : requestError ? 400 : 500;
+      if (quotaError) ctx.set("X-RateLimit-Reason", error.code);
+      ctx.body = (0, import_openai_format.toOpenAIError)(
+        ctx.status,
+        getErrorMessage(error, "Internal server error"),
+        quotaError ? "quota_error" : requestError ? "invalid_request_error" : "server_error",
+        quotaError || requestError ? error.code : void 0
+      );
+    }
+  }
+}
+async function handleNonStreamingResponse(ctx, chatModel, messages, body, modelName, providerParameters, userId) {
+  const result = await chatModel.invoke(messages, providerParameters);
+  const content = (0, import_responses_format.extractResponseOutputText)(result);
+  const responseId = (0, import_responses_format.generateResponseId)();
+  const usage = (0, import_usage.setAiApiUsageResult)(
+    ctx,
+    result.usage_metadata,
+    { gatewayResponseId: responseId, providerRequestId: (0, import_usage.extractProviderRequestId)(result) },
+    result.response_metadata
+  );
+  const response = (0, import_responses_format.chatResultToResponse)({
+    id: responseId,
+    model: modelName,
+    content,
+    reasoningText: (0, import_responses_format.extractReasoningText)(result),
+    usage,
+    toolCalls: (0, import_chat_completions.normalizeToolCalls)(result.tool_calls),
+    finishReason: (0, import_chat_completions.extractFinishReason)(result) ?? (0, import_responses_format.extractResponseIncompleteReason)(result),
+    serviceTier: (0, import_responses_format.extractResponseServiceTier)(result),
+    requestBody: body
+  });
+  if (body.store !== false && userId !== void 0) await (0, import_response_store.storeResponseRecord)(ctx, response, body, userId);
+  ctx.status = 200;
+  ctx.body = response;
+}
+async function handleStreamingResponse(ctx, chatModel, messages, body, modelName, providerParameters, userId) {
+  const responseId = (0, import_responses_format.generateResponseId)();
+  const state = (0, import_responses_stream.createResponseStreamState)(responseId, modelName, body);
+  ctx.set({
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  ctx.status = 200;
+  for (const event of (0, import_responses_stream.createResponseStartEvents)(state)) await (0, import_streaming.writeResponse)(ctx, (0, import_openai_format.formatSSE)(event));
+  const requestAbort = (0, import_streaming.createRequestAbortController)(ctx);
+  let usage;
+  let usageMetadata;
+  let providerRequestId;
+  try {
+    const stream = await chatModel.stream(messages, { ...providerParameters, signal: requestAbort.signal });
+    for await (const chunk of stream) {
+      if (requestAbort.signal.aborted) throw requestAbort.signal.reason;
+      const events = (0, import_responses_stream.appendResponseStreamChunk)(state, chunk);
+      if (events.length) (0, import_app_observability.markAiApiFirstProviderOutput)(ctx);
+      for (const event of events) await (0, import_streaming.writeResponse)(ctx, (0, import_openai_format.formatSSE)(event));
+      const normalized = (0, import_usage.normalizeUsage)(chunk.usage_metadata);
+      if (normalized) {
+        usage = normalized;
+        usageMetadata = chunk.response_metadata;
+        (0, import_responses_stream.setResponseStreamUsage)(state, normalized);
+      }
+      providerRequestId = providerRequestId ?? (0, import_usage.extractProviderRequestId)(chunk);
+    }
+    const finalEvents = (0, import_responses_stream.finalizeResponseStream)(state);
+    const response = findCompletedResponse(finalEvents);
+    if (response && body.store !== false && userId !== void 0) {
+      try {
+        await (0, import_response_store.storeResponseRecord)(ctx, response, body, userId);
+      } catch (storeError) {
+        ctx.log.error("[ai-api] Failed to persist streamed response record:", storeError);
+      }
+    }
+    for (const event of finalEvents) await (0, import_streaming.writeResponse)(ctx, (0, import_openai_format.formatSSE)(event));
+    await (0, import_streaming.writeResponse)(ctx, (0, import_openai_format.formatSSEDone)());
+    (0, import_usage.setAiApiUsageResult)(ctx, usage, { gatewayResponseId: responseId, providerRequestId }, usageMetadata);
+    ctx.state.aiApiStreamResult = { succeeded: true, id: responseId };
+  } catch (error) {
+    const cancelled = (0, import_streaming.isClientDisconnected)(ctx, error);
+    ctx.log.error("AI API Responses streaming error:", error);
+    if (!ctx.res.destroyed && !ctx.res.writableEnded) {
+      const streamError = {
+        message: getErrorMessage(error, "Streaming error"),
+        code: cancelled ? "client_disconnected" : "server_error"
+      };
+      await (0, import_streaming.writeResponse)(ctx, (0, import_openai_format.formatSSE)((0, import_responses_stream.createResponseErrorEvent)(state, streamError)));
+      await (0, import_streaming.writeResponse)(ctx, (0, import_openai_format.formatSSE)((0, import_responses_stream.createResponseFailedEvent)(state, streamError)));
+    }
+    (0, import_usage.setAiApiUsageResult)(ctx, usage, { gatewayResponseId: responseId, providerRequestId }, usageMetadata);
+    ctx.state.aiApiStreamResult = {
+      succeeded: false,
+      id: responseId,
+      errorCode: cancelled ? "client_disconnected" : "stream_error"
+    };
+  } finally {
+    requestAbort.dispose();
+    if (!ctx.res.writableEnded && !ctx.res.destroyed) ctx.res.end();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RESPONSES_CAPABLE_PROVIDERS,
+  handleDeleteResponse,
+  handleGetResponse,
+  handleResponses
+});

package/dist/server/routes/router.js

@@ -50,6 +50,7 @@ var import_chat_completions = require("./chat-completions");
 var import_completions = require("./completions");
 var import_agent_completions = require("./agent-completions");
 var import_embeddings = require("./embeddings");
+var import_responses = require("./responses");
 var import_openai_format = require("../utils/openai-format");
 var import_rate_limit = require("../middleware/rate-limit");
 var import_role_permission = require("../middleware/role-permission");
@@ -63,7 +64,7 @@ const AI_LLM_PREFIX = API_PREFIX;
 function createAiLlmRouter(plugin) {
   const checkRateLimit = (0, import_rate_limit.createRateLimitMiddleware)(plugin.rateLimiter);
   return async (ctx, next) => {
-    var _a, _b;
+    var _a, _b, _c;
     const { path, method } = ctx;
     if (!path.startsWith(API_PREFIX)) {
       return next();
@@ -124,11 +125,11 @@ function createAiLlmRouter(plugin) {
     }
     const requestBody = ctx.request.body || {};
     const model = requestBody.model === void 0 || requestBody.model === null ? "-" : String(requestBody.model);
-    const isUsageEndpoint = method === "POST" && (subPath === "/chat/completions" || subPath === "/completions" || subPath === "/embeddings");
-    const isStreamingEndpoint = method === "POST" && (subPath === "/chat/completions" || subPath === "/completions");
-    const resolvedMode = isUsageEndpoint ? await resolveMode(ctx) : "llm";
-    const streaming = isStreamingEndpoint && (0, import_streaming.isStreamingRequested)(requestBody.stream);
-    if (streaming) {
+    const isUsageEndpoint = method === "POST" && (subPath === "/chat/completions" || subPath === "/completions" || subPath === "/embeddings" || subPath === "/responses");
+    const isStreamingEndpoint = method === "POST" && (subPath === "/chat/completions" || subPath === "/completions" || subPath === "/responses");
+    const resolvedMode = subPath === "/responses" ? "llm" : isUsageEndpoint ? await resolveMode(ctx) : "llm";
+    const streaming = isStreamingEndpoint && (subPath === "/responses" ? requestBody.stream === true : (0, import_streaming.isStreamingRequested)(requestBody.stream));
+    if (streaming && subPath !== "/responses") {
       const streamOptions = requestBody.stream_options;
       ctx.request.body = {
         ...requestBody,
@@ -140,7 +141,7 @@ function createAiLlmRouter(plugin) {
     }
     const t0 = Date.now();
     if (isUsageEndpoint) {
-      const service = subPath === "/embeddings" ? "llm.embedding" : resolvedMode === "agent" ? "llm.agent" : subPath === "/completions" ? "llm.completion" : "llm.chat";
+      const service = subPath === "/embeddings" ? "llm.embedding" : subPath === "/responses" ? "llm.responses" : resolvedMode === "agent" ? "llm.agent" : subPath === "/completions" ? "llm.completion" : "llm.chat";
       (0, import_app_observability.startAiApiObservation)(ctx, {
         service,
         operation: subPath,
@@ -172,6 +173,51 @@ function createAiLlmRouter(plugin) {
         logRequest(ctx, requestId, model, "ok", Date.now() - t0);
         return;
       }
+      if (method === "POST" && subPath === "/responses") {
+        await (0, import_responses.handleResponses)(ctx, plugin);
+        logRequest(
+          ctx,
+          requestId,
+          model,
+          ((_b = ctx.state.aiApiStreamResult) == null ? void 0 : _b.succeeded) === false ? "error" : "ok",
+          Date.now() - t0
+        );
+        return;
+      }
+      if ((method === "GET" || method === "DELETE") && subPath.startsWith("/responses/")) {
+        const responseId = subPath.substring("/responses/".length);
+        if (responseId) {
+          let decodedResponseId;
+          try {
+            decodedResponseId = decodeURIComponent(responseId);
+          } catch {
+            ctx.status = 400;
+            ctx.body = (0, import_openai_format.toOpenAIError)(
+              400,
+              "Response ID contains invalid URL encoding",
+              "invalid_request_error",
+              "invalid_response_id"
+            );
+            logRequest(ctx, requestId, "-", "invalid_response_id", Date.now() - t0);
+            return;
+          }
+          if (decodedResponseId.includes("/")) {
+            ctx.status = 404;
+            ctx.body = (0, import_openai_format.toOpenAIError)(
+              404,
+              `Unknown endpoint: ${method} ${path}`,
+              "invalid_request_error",
+              "unknown_url"
+            );
+            logRequest(ctx, requestId, "-", "not_found", Date.now() - t0);
+            return;
+          }
+          if (method === "GET") await (0, import_responses.handleGetResponse)(ctx, decodedResponseId);
+          else await (0, import_responses.handleDeleteResponse)(ctx, decodedResponseId);
+          logRequest(ctx, requestId, "-", ctx.status === 404 ? "not_found" : "ok", Date.now() - t0);
+          return;
+        }
+      }
       if (method === "POST" && subPath === "/completions") {
         const completionsMode = resolvedMode;
         if (completionsMode === "agent") {
@@ -188,7 +234,7 @@ function createAiLlmRouter(plugin) {
           ctx,
           requestId,
           model,
-          ((_b = ctx.state.aiApiStreamResult) == null ? void 0 : _b.succeeded) === false ? "error" : "ok",
+          ((_c = ctx.state.aiApiStreamResult) == null ? void 0 : _c.succeeded) === false ? "error" : "ok",
           Date.now() - t0
         );
         return;
@@ -201,7 +247,16 @@ function createAiLlmRouter(plugin) {
       if (method === "GET" && subPath.startsWith("/models/")) {
         const modelId = subPath.substring("/models/".length);
         if (modelId) {
-          await (0, import_models.handleGetModel)(ctx, decodeURIComponent(modelId), plugin);
+          let decodedModelId;
+          try {
+            decodedModelId = decodeURIComponent(modelId);
+          } catch {
+            ctx.status = 400;
+            ctx.body = (0, import_openai_format.toOpenAIError)(400, "Model ID contains invalid URL encoding", "invalid_request_error");
+            logRequest(ctx, requestId, modelId, "bad_request", Date.now() - t0);
+            return;
+          }
+          await (0, import_models.handleGetModel)(ctx, decodedModelId, plugin);
           logRequest(ctx, requestId, modelId, "ok", Date.now() - t0);
           return;
         }
@@ -220,7 +275,7 @@ function createAiLlmRouter(plugin) {
       ctx.status = 404;
       ctx.body = (0, import_openai_format.toOpenAIError)(
         404,
-        `Unknown endpoint: ${method} ${path}. Supported: POST /v1/chat/completions, POST /v1/completions, POST /v1/embeddings, GET /v1/models`,
+        `Unknown endpoint: ${method} ${path}. Supported: POST /v1/chat/completions, POST /v1/completions, POST /v1/embeddings, POST /v1/responses, GET/DELETE /v1/responses/:id, GET /v1/models`,
         "invalid_request_error",
         "unknown_url"
       );