@nocobase/plugin-ai 2.2.0-beta.9 → 2.2.1

package/dist/server/llm-providers/deepseek/provider.js

@@ -0,0 +1,320 @@
+/**
+ * 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 provider_exports = {};
+__export(provider_exports, {
+  DeepSeekProvider: () => DeepSeekProvider,
+  deepseekProviderOptions: () => deepseekProviderOptions
+});
+module.exports = __toCommonJS(provider_exports);
+var import_deepseek = require("@langchain/deepseek");
+var import_openai = require("@langchain/openai");
+var import_provider = require("../provider");
+var import_ai_manager = require("../../manager/ai-manager");
+var import_reasoning = require("../common/reasoning");
+var import_reasoning2 = require("./reasoning");
+var import_utils = require("../../utils");
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const collectReferences = (content, responseMetadata) => {
+  const references = [];
+  const addAnnotations = (annotations) => {
+    if (!Array.isArray(annotations)) {
+      return;
+    }
+    for (const annotation of annotations) {
+      if (!isRecord(annotation)) {
+        continue;
+      }
+      const value = isRecord(annotation.value) ? annotation.value : annotation;
+      const url = typeof annotation.url === "string" ? annotation.url : value.url;
+      const title = typeof annotation.title === "string" ? annotation.title : value.title;
+      if (typeof url === "string") {
+        references.push({ title: typeof title === "string" ? title : "", url });
+      }
+    }
+  };
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (isRecord(block) && block.type === "text") {
+        addAnnotations(block.annotations);
+      }
+    }
+  }
+  if (isRecord(responseMetadata) && Array.isArray(responseMetadata.output)) {
+    for (const item of responseMetadata.output) {
+      if (!isRecord(item) || item.type !== "message" || !Array.isArray(item.content)) {
+        continue;
+      }
+      for (const part of item.content) {
+        if (isRecord(part) && part.type === "output_text") {
+          addAnnotations(part.annotations);
+        }
+      }
+    }
+  }
+  return Array.from(new Map(references.map((reference) => [reference.url, reference])).values());
+};
+class ReasoningDeepSeek extends import_deepseek.ChatDeepSeek {
+  constructor(fields, reasoningConfig) {
+    super(fields);
+    this.reasoningConfig = reasoningConfig;
+  }
+  async _generate(messages, options, runManager) {
+    const reasoningMap = (0, import_reasoning.collectReasoningMap)(messages);
+    return super._generate(
+      messages,
+      {
+        ...options || {},
+        [import_reasoning.REASONING_MAP_KEY]: reasoningMap
+      },
+      runManager
+    );
+  }
+  async *_streamResponseChunks(messages, options, runManager) {
+    const reasoningMap = (options == null ? void 0 : options[import_reasoning.REASONING_MAP_KEY]) instanceof Map ? options[import_reasoning.REASONING_MAP_KEY] : (0, import_reasoning.collectReasoningMap)(messages);
+    yield* super._streamResponseChunks(
+      messages,
+      {
+        ...options || {},
+        [import_reasoning.REASONING_MAP_KEY]: reasoningMap
+      },
+      runManager
+    );
+  }
+  async completionWithRetry(request, requestOptions) {
+    const reasoningMap = requestOptions == null ? void 0 : requestOptions[import_reasoning.REASONING_MAP_KEY];
+    const modelKwargs = requestOptions == null ? void 0 : requestOptions[import_reasoning.MODEL_KWARGS_KEY];
+    (0, import_reasoning.patchRequestMessagesReasoning)(request, reasoningMap);
+    (0, import_reasoning.patchRequestModelKwargs)(request, modelKwargs);
+    (0, import_reasoning2.normalizeDeepSeekChatRequest)(request, this.reasoningConfig);
+    if (request.stream === true) {
+      return super.completionWithRetry(request, requestOptions);
+    }
+    return super.completionWithRetry(request, requestOptions);
+  }
+}
+class DeepSeekChatOpenAIResponses extends import_openai.ChatOpenAIResponses {
+  constructor(fields, reasoningConfig) {
+    super(fields);
+    this.reasoningConfig = reasoningConfig;
+  }
+  async completionWithRetry(request, requestOptions) {
+    (0, import_reasoning2.normalizeDeepSeekResponsesRequest)(request, this.reasoningConfig);
+    if (request.stream === true) {
+      const stream = await super.completionWithRetry(
+        request,
+        requestOptions
+      );
+      return (0, import_reasoning2.adaptDeepSeekResponsesStream)(stream);
+    }
+    return super.completionWithRetry(request, requestOptions);
+  }
+}
+class DeepSeekProvider extends import_provider.LLMProvider {
+  get baseURL() {
+    return "https://api.deepseek.com";
+  }
+  createModel() {
+    const { apiKey } = this.serviceOptions || {};
+    const { responseFormat, structuredOutput, ...modelOptions } = this.modelOptions || {};
+    const model = typeof modelOptions.model === "string" ? modelOptions.model : "";
+    const reasoningConfig = (0, import_reasoning2.resolveDeepSeekReasoningConfig)(model, this.modelReasoningOptions);
+    const reasoningParams = (0, import_reasoning2.getDeepSeekReasoningRequestParams)(reasoningConfig);
+    if (reasoningConfig.protocol === "responses") {
+      const { name, schema, strict } = structuredOutput || {};
+      let responseFormatOptions = {
+        type: responseFormat ?? "text"
+      };
+      if (responseFormat === "json_schema" && schema) {
+        responseFormatOptions = {
+          ...responseFormatOptions,
+          schema,
+          name: name ?? "default",
+          strict: strict ?? false
+        };
+      }
+      const fields = {
+        apiKey,
+        ...modelOptions,
+        modelKwargs: {
+          text: {
+            format: responseFormatOptions
+          },
+          ...reasoningParams
+        },
+        configuration: {
+          baseURL: this.getResolvedBaseURL()
+        },
+        verbose: false
+      };
+      return new import_openai.ChatOpenAI({
+        ...fields,
+        responses: new DeepSeekChatOpenAIResponses(fields, reasoningConfig),
+        useResponsesApi: true
+      });
+    }
+    const modelKwargs = {
+      ...reasoningParams
+    };
+    if (responseFormat) {
+      modelKwargs.response_format = {
+        type: responseFormat
+      };
+    }
+    return new ReasoningDeepSeek(
+      {
+        apiKey,
+        ...modelOptions,
+        modelKwargs,
+        configuration: {
+          baseURL: this.getResolvedBaseURL()
+        },
+        verbose: false
+      },
+      reasoningConfig
+    );
+  }
+  parseResponseChunk(chunk) {
+    if (Array.isArray(chunk)) {
+      const text = chunk.filter(isRecord).filter((block) => block.type === "text").map((block) => block.text).filter((value) => typeof value === "string").join("");
+      return text ? (0, import_utils.stripToolCallTags)(text) : null;
+    }
+    return typeof chunk === "string" ? (0, import_utils.stripToolCallTags)(chunk) : null;
+  }
+  parseResponseMessage(message) {
+    var _a, _b;
+    const result = super.parseResponseMessage(message);
+    if (["user", "tool"].includes(result == null ? void 0 : result.role)) {
+      return result;
+    }
+    const json = ((_a = message == null ? void 0 : message.toJSON) == null ? void 0 : _a.call(message)) ?? {};
+    const metadata = isRecord(json.metadata) ? json.metadata : {};
+    const additionalKwargs = isRecord(metadata.additional_kwargs) ? metadata.additional_kwargs : {};
+    const responseMetadata = isRecord(metadata.response_metadata) ? metadata.response_metadata : {};
+    const reasoningContent = (0, import_reasoning2.extractDeepSeekReasoningText)({
+      additional_kwargs: additionalKwargs,
+      response_metadata: responseMetadata
+    });
+    if (reasoningContent) {
+      result.content = {
+        ...result.content ?? {},
+        reasoning: {
+          status: "stop",
+          content: reasoningContent
+        }
+      };
+    }
+    const references = collectReferences((_b = result == null ? void 0 : result.content) == null ? void 0 : _b.content, responseMetadata);
+    if (references.length) {
+      result.content.reference = references;
+    }
+    return result;
+  }
+  parseReasoningContent(chunk) {
+    const content = (0, import_reasoning2.extractDeepSeekReasoningText)({
+      content: chunk.content,
+      additional_kwargs: chunk.additional_kwargs
+    });
+    return content ? { status: "streaming", content } : null;
+  }
+  reshapeAIMessage({ aiMessage, values }) {
+    const reasoningItem = (0, import_reasoning2.getDeepSeekResponsesReasoningItem)(aiMessage);
+    const reasoningContent = (0, import_reasoning2.extractDeepSeekReasoningText)(aiMessage);
+    if (reasoningItem || reasoningContent) {
+      const additionalKwargs = {
+        ...values.metadata.additional_kwargs ?? {},
+        ...reasoningItem ? { reasoning: reasoningItem } : {},
+        ...reasoningContent ? { reasoning_content: reasoningContent } : {}
+      };
+      values.metadata.additional_kwargs = additionalKwargs;
+      aiMessage.additional_kwargs = {
+        ...aiMessage.additional_kwargs,
+        ...reasoningItem ? { reasoning: reasoningItem } : {}
+      };
+      aiMessage.lc_kwargs.additional_kwargs = aiMessage.additional_kwargs;
+    }
+    const references = collectReferences(aiMessage.content, aiMessage.response_metadata);
+    if (references.length) {
+      values.content.reference = references;
+    }
+  }
+  prepareStoredAssistantAdditionalKwargs(additionalKwargs) {
+    var _a, _b;
+    if (((_b = (0, import_reasoning2.getDeepSeekModelCapabilities)(String((_a = this.modelOptions) == null ? void 0 : _a.model))) == null ? void 0 : _b.protocol) !== "responses" || !additionalKwargs) {
+      return additionalKwargs;
+    }
+    const nextAdditionalKwargs = { ...additionalKwargs };
+    delete nextAdditionalKwargs.reasoning;
+    delete nextAdditionalKwargs.reasoning_content;
+    return Object.keys(nextAdditionalKwargs).length ? nextAdditionalKwargs : void 0;
+  }
+  builtInTools() {
+    var _a, _b, _c, _d;
+    if (((_b = (0, import_reasoning2.getDeepSeekModelCapabilities)(String((_a = this.modelOptions) == null ? void 0 : _a.model))) == null ? void 0 : _b.supportsWebSearch) === true && ((_d = (_c = this.modelOptions) == null ? void 0 : _c.builtIn) == null ? void 0 : _d.webSearch) === true) {
+      return [{ type: "web_search" }];
+    }
+    return [];
+  }
+  parseWebSearchAction(chunk) {
+    var _a;
+    const toolOutputs = (_a = chunk.additional_kwargs) == null ? void 0 : _a.tool_outputs;
+    if (!Array.isArray(toolOutputs)) {
+      return [];
+    }
+    return toolOutputs.filter(isRecord).filter((tool) => tool.type === "web_search_call" && isRecord(tool.action)).map((tool) => tool.action).filter((action) => typeof action.query === "string").map((action) => ({
+      type: typeof action.type === "string" ? action.type : "web_search",
+      query: action.query
+    }));
+  }
+  resolveReasoningOptions(reasoning) {
+    var _a;
+    const model = typeof ((_a = this.modelOptions) == null ? void 0 : _a.model) === "string" ? this.modelOptions.model : "";
+    const config = (0, import_reasoning2.resolveDeepSeekReasoningConfig)(model, reasoning);
+    const params = (0, import_reasoning2.getDeepSeekReasoningRequestParams)(config);
+    return Object.keys(params).length ? { modelKwargs: params } : {};
+  }
+  isToolConflict() {
+    return false;
+  }
+  isApiSupportedAttachment() {
+    return false;
+  }
+}
+const deepseekProviderOptions = {
+  title: "DeepSeek",
+  supportedModel: [import_ai_manager.SupportedModel.LLM],
+  models: {
+    [import_ai_manager.SupportedModel.LLM]: ["deepseek-v4-pro", "deepseek-v4-flash", "deepseek-chat", "deepseek-reasoner"]
+  },
+  supportWebSearch: true,
+  webSearchModels: ["deepseek-v4-flash", "deepseek-v4-pro"],
+  provider: DeepSeekProvider
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeepSeekProvider,
+  deepseekProviderOptions
+});

package/dist/server/llm-providers/deepseek/reasoning.d.ts

@@ -0,0 +1,83 @@
+/**
+ * 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.
+ */
+import type OpenAI from 'openai';
+import type { ReasoningOptions } from '../provider';
+export type DeepSeekApiProtocol = 'chat-completions' | 'responses';
+export type DeepSeekThinkingMode = 'enabled' | 'disabled';
+export type DeepSeekReasoningEffort = 'low' | 'high' | 'max';
+type DeepSeekReasoningBehavior = 'switchable' | 'always-on' | 'always-off';
+type DeepSeekModelCapabilities = {
+    protocol: DeepSeekApiProtocol;
+    reasoning: DeepSeekReasoningBehavior;
+    defaultThinking: DeepSeekThinkingMode;
+    efforts: ReadonlySet<DeepSeekReasoningEffort>;
+    supportsFunctionTools: boolean;
+    supportsStructuredOutput: boolean;
+    supportsWebSearch: boolean;
+};
+export type DeepSeekReasoningConfig = {
+    protocol: DeepSeekApiProtocol;
+    recognizedModel: boolean;
+    thinking?: DeepSeekThinkingMode;
+    effort?: DeepSeekReasoningEffort;
+    unsupportedRequestFields: ReadonlySet<string>;
+};
+type ReasoningSource = {
+    content?: unknown;
+    additional_kwargs?: Record<string, unknown>;
+    response_metadata?: Record<string, unknown>;
+};
+export declare const DEEPSEEK_MODEL_CAPABILITIES: {
+    readonly 'deepseek-v4-flash': {
+        readonly protocol: "responses";
+        readonly reasoning: "switchable";
+        readonly defaultThinking: "enabled";
+        readonly efforts: Set<DeepSeekReasoningEffort>;
+        readonly supportsFunctionTools: true;
+        readonly supportsStructuredOutput: true;
+        readonly supportsWebSearch: true;
+    };
+    readonly 'deepseek-v4-pro': {
+        readonly protocol: "responses";
+        readonly reasoning: "switchable";
+        readonly defaultThinking: "enabled";
+        readonly efforts: Set<DeepSeekReasoningEffort>;
+        readonly supportsFunctionTools: true;
+        readonly supportsStructuredOutput: true;
+        readonly supportsWebSearch: true;
+    };
+    readonly 'deepseek-chat': {
+        readonly protocol: "chat-completions";
+        readonly reasoning: "always-off";
+        readonly defaultThinking: "disabled";
+        readonly efforts: Set<DeepSeekReasoningEffort>;
+        readonly supportsFunctionTools: true;
+        readonly supportsStructuredOutput: true;
+        readonly supportsWebSearch: false;
+    };
+    readonly 'deepseek-reasoner': {
+        readonly protocol: "chat-completions";
+        readonly reasoning: "always-on";
+        readonly defaultThinking: "enabled";
+        readonly efforts: Set<DeepSeekReasoningEffort>;
+        readonly supportsFunctionTools: true;
+        readonly supportsStructuredOutput: true;
+        readonly supportsWebSearch: false;
+    };
+};
+export type OfficialDeepSeekModel = keyof typeof DEEPSEEK_MODEL_CAPABILITIES;
+export declare const getDeepSeekModelCapabilities: (model: string) => DeepSeekModelCapabilities | null;
+export declare const resolveDeepSeekReasoningConfig: (model: string, reasoning?: ReasoningOptions) => DeepSeekReasoningConfig;
+export declare const getDeepSeekReasoningRequestParams: (config: DeepSeekReasoningConfig) => Record<string, unknown>;
+export declare const normalizeDeepSeekChatRequest: <Request_1 extends OpenAI.Chat.Completions.ChatCompletionCreateParams>(request: Request_1, config: DeepSeekReasoningConfig) => Request_1;
+export declare const normalizeDeepSeekResponsesRequest: <Request_1 extends OpenAI.Responses.ResponseCreateParams>(request: Request_1, config: DeepSeekReasoningConfig) => Request_1;
+export declare const extractDeepSeekReasoningText: (source: Partial<ReasoningSource>) => string;
+export declare const getDeepSeekResponsesReasoningItem: (source: Partial<ReasoningSource>) => Record<string, unknown> | null;
+export declare function adaptDeepSeekResponsesStream(stream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>): AsyncGenerator<OpenAI.Responses.ResponseStreamEvent>;
+export {};

package/dist/server/llm-providers/deepseek/reasoning.js

@@ -0,0 +1,285 @@
+/**
+ * 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 reasoning_exports = {};
+__export(reasoning_exports, {
+  DEEPSEEK_MODEL_CAPABILITIES: () => DEEPSEEK_MODEL_CAPABILITIES,
+  adaptDeepSeekResponsesStream: () => adaptDeepSeekResponsesStream,
+  extractDeepSeekReasoningText: () => extractDeepSeekReasoningText,
+  getDeepSeekModelCapabilities: () => getDeepSeekModelCapabilities,
+  getDeepSeekReasoningRequestParams: () => getDeepSeekReasoningRequestParams,
+  getDeepSeekResponsesReasoningItem: () => getDeepSeekResponsesReasoningItem,
+  normalizeDeepSeekChatRequest: () => normalizeDeepSeekChatRequest,
+  normalizeDeepSeekResponsesRequest: () => normalizeDeepSeekResponsesRequest,
+  resolveDeepSeekReasoningConfig: () => resolveDeepSeekReasoningConfig
+});
+module.exports = __toCommonJS(reasoning_exports);
+const NO_EFFORTS = /* @__PURE__ */ new Set();
+const V4_EFFORTS = /* @__PURE__ */ new Set(["low", "high", "max"]);
+const THINKING_UNSUPPORTED_FIELDS = /* @__PURE__ */ new Set(["temperature", "top_p", "presence_penalty", "frequency_penalty"]);
+const NO_UNSUPPORTED_FIELDS = /* @__PURE__ */ new Set();
+const DEEPSEEK_MODEL_CAPABILITIES = {
+  "deepseek-v4-flash": {
+    protocol: "responses",
+    reasoning: "switchable",
+    defaultThinking: "enabled",
+    efforts: V4_EFFORTS,
+    supportsFunctionTools: true,
+    supportsStructuredOutput: true,
+    supportsWebSearch: true
+  },
+  "deepseek-v4-pro": {
+    protocol: "responses",
+    reasoning: "switchable",
+    defaultThinking: "enabled",
+    efforts: V4_EFFORTS,
+    supportsFunctionTools: true,
+    supportsStructuredOutput: true,
+    supportsWebSearch: true
+  },
+  "deepseek-chat": {
+    protocol: "chat-completions",
+    reasoning: "always-off",
+    defaultThinking: "disabled",
+    efforts: NO_EFFORTS,
+    supportsFunctionTools: true,
+    supportsStructuredOutput: true,
+    supportsWebSearch: false
+  },
+  "deepseek-reasoner": {
+    protocol: "chat-completions",
+    reasoning: "always-on",
+    defaultThinking: "enabled",
+    efforts: NO_EFFORTS,
+    supportsFunctionTools: true,
+    supportsStructuredOutput: true,
+    supportsWebSearch: false
+  }
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isOfficialDeepSeekModel = (model) => model in DEEPSEEK_MODEL_CAPABILITIES;
+const getDeepSeekModelCapabilities = (model) => isOfficialDeepSeekModel(model) ? DEEPSEEK_MODEL_CAPABILITIES[model] : null;
+const normalizeReasoningEffort = (mode) => {
+  if (mode === "minimal" || mode === "low") {
+    return "low";
+  }
+  if (mode === "xhigh") {
+    return "high";
+  }
+  return "high";
+};
+const resolveDeepSeekReasoningConfig = (model, reasoning) => {
+  const capabilities = getDeepSeekModelCapabilities(model);
+  if (!capabilities) {
+    return {
+      protocol: "chat-completions",
+      recognizedModel: false,
+      unsupportedRequestFields: NO_UNSUPPORTED_FIELDS
+    };
+  }
+  const mode = (reasoning == null ? void 0 : reasoning.mode) ?? "default";
+  if (mode === "default") {
+    return {
+      protocol: capabilities.protocol,
+      recognizedModel: true,
+      unsupportedRequestFields: capabilities.defaultThinking === "enabled" ? THINKING_UNSUPPORTED_FIELDS : NO_UNSUPPORTED_FIELDS
+    };
+  }
+  if (mode === "off") {
+    if (capabilities.reasoning === "always-on") {
+      throw new Error(`DeepSeek model "${model}" does not support disabling reasoning`);
+    }
+    return {
+      protocol: capabilities.protocol,
+      recognizedModel: true,
+      ...capabilities.reasoning === "switchable" ? { thinking: "disabled" } : {},
+      unsupportedRequestFields: NO_UNSUPPORTED_FIELDS
+    };
+  }
+  if (capabilities.reasoning === "always-off") {
+    throw new Error(`DeepSeek model "${model}" does not support reasoning`);
+  }
+  const effort = normalizeReasoningEffort(mode);
+  return {
+    protocol: capabilities.protocol,
+    recognizedModel: true,
+    ...capabilities.reasoning === "switchable" ? { thinking: "enabled" } : {},
+    ...capabilities.efforts.has(effort) ? { effort } : {},
+    unsupportedRequestFields: THINKING_UNSUPPORTED_FIELDS
+  };
+};
+const getDeepSeekReasoningRequestParams = (config) => {
+  if (!config.recognizedModel) {
+    return {};
+  }
+  if (config.protocol === "responses") {
+    if (config.thinking === "disabled") {
+      return { reasoning: { effort: "none" } };
+    }
+    return config.effort ? { reasoning: { effort: config.effort } } : {};
+  }
+  return {
+    ...config.thinking ? { thinking: { type: config.thinking } } : {},
+    ...config.effort ? { reasoning_effort: config.effort } : {}
+  };
+};
+const removeUnsupportedRequestFields = (request, fields) => {
+  for (const field of fields) {
+    delete request[field];
+  }
+};
+const normalizeDeepSeekChatRequest = (request, config) => {
+  if (!config.recognizedModel) {
+    return request;
+  }
+  const mutableRequest = request;
+  delete mutableRequest.thinking;
+  delete mutableRequest.reasoning_effort;
+  Object.assign(mutableRequest, getDeepSeekReasoningRequestParams(config));
+  removeUnsupportedRequestFields(mutableRequest, config.unsupportedRequestFields);
+  return request;
+};
+const normalizeResponsesReasoningItems = (input) => {
+  if (!Array.isArray(input)) {
+    return;
+  }
+  for (const item of input) {
+    if (!isRecord(item) || item.type !== "reasoning") {
+      continue;
+    }
+    const hasReasoningContent = Array.isArray(item.content) && item.content.some((part) => isRecord(part) && part.type === "reasoning_text" && typeof part.text === "string");
+    if (hasReasoningContent || !Array.isArray(item.summary)) {
+      continue;
+    }
+    const text = item.summary.filter(isRecord).map((part) => part.text).filter((part) => typeof part === "string" && part.length > 0).join("");
+    if (text) {
+      item.content = [{ type: "reasoning_text", text }];
+      item.summary = [];
+    }
+  }
+};
+const normalizeDeepSeekResponsesRequest = (request, config) => {
+  if (!config.recognizedModel) {
+    return request;
+  }
+  const mutableRequest = request;
+  delete mutableRequest.reasoning;
+  Object.assign(mutableRequest, getDeepSeekReasoningRequestParams(config));
+  removeUnsupportedRequestFields(mutableRequest, config.unsupportedRequestFields);
+  normalizeResponsesReasoningItems(request.input);
+  return request;
+};
+const getReasoningItemText = (value) => {
+  if (!isRecord(value)) {
+    return "";
+  }
+  if (Array.isArray(value.content)) {
+    const content = value.content.filter(isRecord).filter((part) => part.type === "reasoning_text").map((part) => part.text).filter((text) => typeof text === "string" && text.length > 0).join("");
+    if (content) {
+      return content;
+    }
+  }
+  if (Array.isArray(value.summary)) {
+    return value.summary.filter(isRecord).map((part) => part.text).filter((text) => typeof text === "string" && text.length > 0).join("");
+  }
+  return "";
+};
+const extractDeepSeekReasoningText = (source) => {
+  var _a, _b, _c;
+  const reasoningContent = (_a = source.additional_kwargs) == null ? void 0 : _a.reasoning_content;
+  if (typeof reasoningContent === "string" && reasoningContent.length > 0) {
+    return reasoningContent;
+  }
+  if (Array.isArray(source.content)) {
+    const contentBlockText = source.content.filter(isRecord).filter((block) => block.type === "reasoning").map((block) => typeof block.reasoning === "string" ? block.reasoning : "").filter(Boolean).join("");
+    if (contentBlockText) {
+      return contentBlockText;
+    }
+  }
+  const additionalReasoningText = getReasoningItemText((_b = source.additional_kwargs) == null ? void 0 : _b.reasoning);
+  if (additionalReasoningText) {
+    return additionalReasoningText;
+  }
+  const output = (_c = source.response_metadata) == null ? void 0 : _c.output;
+  if (Array.isArray(output)) {
+    const reasoningItem = output.find((item) => isRecord(item) && item.type === "reasoning");
+    return getReasoningItemText(reasoningItem);
+  }
+  return "";
+};
+const getDeepSeekResponsesReasoningItem = (source) => {
+  var _a, _b;
+  const output = (_a = source.response_metadata) == null ? void 0 : _a.output;
+  if (Array.isArray(output)) {
+    const reasoningItem = output.find((item) => isRecord(item) && item.type === "reasoning");
+    if (isRecord(reasoningItem)) {
+      return reasoningItem;
+    }
+  }
+  return isRecord((_b = source.additional_kwargs) == null ? void 0 : _b.reasoning) ? source.additional_kwargs.reasoning : null;
+};
+async function* adaptDeepSeekResponsesStream(stream) {
+  const emittedWebSearchItems = /* @__PURE__ */ new Set();
+  for await (const event of stream) {
+    if (event.type === "response.reasoning_text.delta") {
+      yield {
+        type: "response.reasoning_summary_text.delta",
+        delta: event.delta,
+        item_id: event.item_id,
+        output_index: event.output_index,
+        sequence_number: event.sequence_number,
+        summary_index: event.content_index
+      };
+      continue;
+    }
+    if (event.type === "response.output_item.added" && event.item.type === "web_search_call" && isRecord(event.item.action) && typeof event.item.action.query === "string") {
+      emittedWebSearchItems.add(event.item.id);
+      yield {
+        type: "response.output_item.done",
+        item: event.item,
+        output_index: event.output_index,
+        sequence_number: event.sequence_number
+      };
+      continue;
+    }
+    if (event.type === "response.output_item.done" && event.item.type === "web_search_call" && emittedWebSearchItems.has(event.item.id)) {
+      continue;
+    }
+    yield event;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEEPSEEK_MODEL_CAPABILITIES,
+  adaptDeepSeekResponsesStream,
+  extractDeepSeekReasoningText,
+  getDeepSeekModelCapabilities,
+  getDeepSeekReasoningRequestParams,
+  getDeepSeekResponsesReasoningItem,
+  normalizeDeepSeekChatRequest,
+  normalizeDeepSeekResponsesRequest,
+  resolveDeepSeekReasoningConfig
+});