@nocobase/plugin-ai 2.2.0-beta.16 → 2.2.0-beta.18

package/dist/server/ai-employees/ai-employee.js

@@ -58,6 +58,7 @@ var import_tool_call_sanitizer = require("./tool-call-sanitizer");
 var import_attachments = require("../attachments");
 var import_frontend_tools = require("../../common/frontend-tools");
 var import_frontend_tools2 = require("../frontend-tools");
+var import_reasoning_stream_state = require("./reasoning-stream-state");
 class AIEmployee {
   sessionId;
   from = "main-agent";
@@ -415,10 +416,21 @@ class AIEmployee {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z;
     const aiMessageIdMap = /* @__PURE__ */ new Map();
     const { signal, providerName, llmService, model, provider, responseMetadata, allowEmpty = false } = options;
-    let isReasoning = false;
+    const reasoningState = new import_reasoning_stream_state.ReasoningStreamState();
+    const stopReasoning = async (conversation) => {
+      if (reasoningState.stop(conversation)) {
+        await this.protocol.with(conversation).stopReasoning();
+      }
+    };
+    const stopAllReasoning = async () => {
+      for (const conversation of reasoningState.drain()) {
+        await this.protocol.with(conversation).stopReasoning();
+      }
+    };
     let gathered;
     signal.addEventListener("abort", async () => {
       try {
+        await stopAllReasoning();
         if ((gathered == null ? void 0 : gathered.type) === "ai") {
           const values = (0, import_utils2.convertAIMessage)({
             aiEmployee: this,
@@ -460,27 +472,27 @@ class AIEmployee {
           const { currentConversation } = metadata;
           if (chunk.type === "ai") {
             gathered = gathered !== void 0 ? (0, import_stream.concat)(gathered, chunk) : chunk;
-            if (chunk.content) {
-              if (isReasoning) {
-                isReasoning = false;
-                await this.protocol.with(currentConversation).stopReasoning();
-              }
-              const parsedContent = provider.parseResponseChunk(chunk.content);
-              if (parsedContent) {
-                await this.protocol.with(currentConversation).content(parsedContent);
-              }
+            const reasoningContent = provider.parseReasoningContent(chunk);
+            if (reasoningContent) {
+              reasoningState.start(currentConversation);
+              await this.protocol.with(currentConversation).reasoning(reasoningContent);
+            }
+            const parsedContent = chunk.content ? provider.parseResponseChunk(chunk.content) : null;
+            if (parsedContent) {
+              await stopReasoning(currentConversation);
+              await this.protocol.with(currentConversation).content(parsedContent);
             }
             if ((_a = chunk.tool_call_chunks) == null ? void 0 : _a.length) {
+              await stopReasoning(currentConversation);
               await this.protocol.with(currentConversation).toolCallChunks(chunk.tool_call_chunks);
             }
             const webSearch = provider.parseWebSearchAction(chunk);
             if (webSearch == null ? void 0 : webSearch.length) {
+              await stopReasoning(currentConversation);
               await this.protocol.with(currentConversation).webSearch(webSearch);
             }
-            const reasoningContent = provider.parseReasoningContent(chunk);
-            if (reasoningContent) {
-              isReasoning = true;
-              await this.protocol.with(currentConversation).reasoning(reasoningContent);
+            if ((0, import_reasoning_stream_state.isReasoningFinishChunk)(chunk)) {
+              await stopReasoning(currentConversation);
             }
           }
         } else if (mode === "updates") {
@@ -536,6 +548,7 @@ class AIEmployee {
               }
             }
           } else if (chunks.action === "initToolCalls") {
+            await stopReasoning(currentConversation);
             await this.protocol.with(currentConversation).toolCalls(chunks.body);
           } else if (chunks.action === "beforeToolCall") {
             const toolsMap = await this.getToolsMap();
@@ -597,12 +610,14 @@ class AIEmployee {
           }
         }
       }
+      await stopAllReasoning();
       if (this.protocol.statistics.sent === 0 && !signal.aborted && !allowEmpty) {
         this.sendErrorResponse("Empty message");
         return;
       }
       await this.protocol.with(aiEmployeeConversation).endStream();
     } catch (err) {
+      await stopAllReasoning();
       this.ctx.log.error(err);
       if (err.name === "GraphRecursionError") {
         this.sendSpecificError({ name: err.name, message: err.message });
@@ -1132,20 +1147,21 @@ If information is missing, clearly state it in the summary.</Important>`;
         });
         continue;
       }
+      const additionalKwargs = (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)((_b = msg.metadata) == null ? void 0 : _b.additional_kwargs, msg.toolCalls, {
+        onDiscard: (info) => {
+          var _a2;
+          this.logger.warn("Discard malformed raw tool calls from AI message", {
+            phase: "formatMessages",
+            messageId: (_a2 = msg.metadata) == null ? void 0 : _a2.id,
+            ...info
+          });
+        }
+      }).additionalKwargs;
       formattedMessages.push({
         role: "assistant",
         content,
         tool_calls: msg.toolCalls,
-        additional_kwargs: (0, import_tool_call_sanitizer.sanitizeAdditionalKwargsForToolCalls)((_b = msg.metadata) == null ? void 0 : _b.additional_kwargs, msg.toolCalls, {
-          onDiscard: (info) => {
-            var _a2;
-            this.logger.warn("Discard malformed raw tool calls from AI message", {
-              phase: "formatMessages",
-              messageId: (_a2 = msg.metadata) == null ? void 0 : _a2.id,
-              ...info
-            });
-          }
-        }).additionalKwargs
+        additional_kwargs: provider.prepareStoredAssistantAdditionalKwargs(additionalKwargs)
       });
     }
     return formattedMessages;

package/dist/server/ai-employees/reasoning-stream-state.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+export type StreamConversation = {
+    sessionId: string;
+    from: string;
+    username: string;
+};
+export declare class ReasoningStreamState {
+    private readonly active;
+    start(conversation: StreamConversation): void;
+    stop(conversation: StreamConversation): boolean;
+    drain(): StreamConversation[];
+}
+export declare const isReasoningFinishChunk: (chunk: {
+    response_metadata?: Record<string, unknown>;
+    usage_metadata?: Record<string, unknown>;
+}) => boolean;

package/dist/server/ai-employees/reasoning-stream-state.js

@@ -0,0 +1,63 @@
+/**
+ * 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_stream_state_exports = {};
+__export(reasoning_stream_state_exports, {
+  ReasoningStreamState: () => ReasoningStreamState,
+  isReasoningFinishChunk: () => isReasoningFinishChunk
+});
+module.exports = __toCommonJS(reasoning_stream_state_exports);
+const getConversationKey = (conversation) => `${conversation.from}:${conversation.sessionId}:${conversation.username}`;
+class ReasoningStreamState {
+  active = /* @__PURE__ */ new Map();
+  start(conversation) {
+    this.active.set(getConversationKey(conversation), conversation);
+  }
+  stop(conversation) {
+    return this.active.delete(getConversationKey(conversation));
+  }
+  drain() {
+    const conversations = Array.from(this.active.values());
+    this.active.clear();
+    return conversations;
+  }
+}
+const isReasoningFinishChunk = (chunk) => {
+  const metadata = chunk.response_metadata;
+  if (!metadata) {
+    return false;
+  }
+  const finishReason = metadata.finish_reason ?? metadata.finishReason;
+  if (typeof finishReason === "string" && finishReason.length > 0) {
+    return true;
+  }
+  return metadata.status === "completed" || metadata.status === "incomplete" || metadata.status === "failed";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReasoningStreamState,
+  isReasoningFinishChunk
+});

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

@@ -55,19 +55,27 @@ const collectReasoningMap = (messages) => {
   return reasoningMap;
 };
 const patchRequestMessagesReasoning = (request, reasoningMap) => {
+  var _a;
   if (!(reasoningMap == null ? void 0 : reasoningMap.size) || !Array.isArray(request == null ? void 0 : request.messages)) {
     return;
   }
-  if (request.messages.some((msg) => msg.role === "tool")) {
-    for (let i = 0; i < request.messages.length; i++) {
-      const message = request.messages[i];
-      if ((message == null ? void 0 : message.role) !== "assistant") {
-        continue;
-      }
-      if (message.reasoning_content) {
-        continue;
-      }
-      const reasoningContent = reasoningMap.get(String(i));
+  let lastUserMessageIndex = -1;
+  for (let i = request.messages.length - 1; i >= 0; i--) {
+    if (((_a = request.messages[i]) == null ? void 0 : _a.role) === "user") {
+      lastUserMessageIndex = i;
+      break;
+    }
+  }
+  for (let i = lastUserMessageIndex + 1; i < request.messages.length; i++) {
+    const message = request.messages[i];
+    if ((message == null ? void 0 : message.role) !== "assistant" || !Array.isArray(message.tool_calls) || message.tool_calls.length === 0) {
+      continue;
+    }
+    if (typeof message.reasoning_content === "string" && message.reasoning_content.length > 0) {
+      continue;
+    }
+    const reasoningContent = reasoningMap.get(String(i));
+    if (typeof reasoningContent === "string" && reasoningContent.length > 0) {
       message.reasoning_content = reasoningContent;
     }
   }

package/dist/{client-v2/ai-employees/chatbox/components/DebugPanel.d.ts → server/llm-providers/deepseek/index.d.ts}

@@ -6,5 +6,5 @@
  * 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 React from 'react';
-export declare const DebugPanel: React.FC;
+export * from './provider';
+export * from './reasoning';

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

@@ -0,0 +1,32 @@
+/**
+ * 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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deepseek_exports = {};
+module.exports = __toCommonJS(deepseek_exports);
+__reExport(deepseek_exports, require("./provider"), module.exports);
+__reExport(deepseek_exports, require("./reasoning"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./provider"),
+  ...require("./reasoning")
+});

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

@@ -0,0 +1,57 @@
+/**
+ * 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 { ChatDeepSeek, type ChatDeepSeekInput } from '@langchain/deepseek';
+import { AIMessage, AIMessageChunk, BaseMessage } from '@langchain/core/messages';
+import { ChatOpenAI } from '@langchain/openai';
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
+import type OpenAI from 'openai';
+import { Model } from '@nocobase/database';
+import { LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from '../provider';
+import { LLMProviderMeta } from '../../manager/ai-manager';
+import { DeepSeekReasoningConfig } from './reasoning';
+import type { AIMessageInput } from '../../types';
+declare class ReasoningDeepSeek extends ChatDeepSeek {
+    private readonly reasoningConfig;
+    constructor(fields: ChatDeepSeekInput, reasoningConfig: DeepSeekReasoningConfig);
+    _generate(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): Promise<import("@langchain/core/dist/outputs").ChatResult>;
+    _streamResponseChunks(messages: BaseMessage[], options: this['ParsedCallOptions'], runManager?: CallbackManagerForLLMRun): AsyncGenerator<import("@langchain/core/dist/outputs").ChatGenerationChunk, void, unknown>;
+    completionWithRetry(request: OpenAI.Chat.ChatCompletionCreateParamsStreaming, requestOptions?: OpenAI.RequestOptions): Promise<AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>>;
+    completionWithRetry(request: OpenAI.Chat.ChatCompletionCreateParamsNonStreaming, requestOptions?: OpenAI.RequestOptions): Promise<OpenAI.Chat.Completions.ChatCompletion>;
+}
+export declare class DeepSeekProvider extends LLMProvider {
+    chatModel: ChatDeepSeek | ChatOpenAI;
+    get baseURL(): string;
+    createModel(): ChatOpenAI<import("@langchain/openai/dist/chat_models/index.cjs").ChatOpenAICallOptions> | ReasoningDeepSeek;
+    parseResponseChunk(chunk: unknown): string;
+    parseResponseMessage(message: Model): {
+        key: any;
+        createdAt: any;
+        content: any;
+        role: any;
+    };
+    parseReasoningContent(chunk: AIMessageChunk): {
+        status: string;
+        content: string;
+    } | null;
+    reshapeAIMessage({ aiMessage, values }: {
+        aiMessage: AIMessage;
+        values: AIMessageInput;
+    }): void;
+    prepareStoredAssistantAdditionalKwargs(additionalKwargs?: Record<string, unknown>): Record<string, unknown> | undefined;
+    protected builtInTools(): Record<string, unknown>[];
+    parseWebSearchAction(chunk: AIMessageChunk): {
+        type: string;
+        query: string;
+    }[];
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
+    isToolConflict(): boolean;
+    protected isApiSupportedAttachment(): boolean;
+}
+export declare const deepseekProviderOptions: LLMProviderMeta;
+export {};

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
+});