@nocobase/plugin-ai 2.3.0-alpha.1 → 2.3.0-beta.10

package/dist/server/frontend-tools.js

@@ -0,0 +1,171 @@
+/**
+ * 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 frontend_tools_exports = {};
+__export(frontend_tools_exports, {
+  extractFrontendToolManifests: () => extractFrontendToolManifests,
+  findCurrentFrontendTool: () => findCurrentFrontendTool,
+  listCurrentFrontendTools: () => listCurrentFrontendTools,
+  prepareToolsForFrontendConversation: () => prepareToolsForFrontendConversation,
+  readFrontendToolResult: () => readFrontendToolResult,
+  shouldAutoExecuteFrontendTool: () => shouldAutoExecuteFrontendTool
+});
+module.exports = __toCommonJS(frontend_tools_exports);
+var import_zod = require("zod");
+var import_frontend_tools = require("../common/frontend-tools");
+const isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const isMessageLike = (value) => !!value && typeof value === "object";
+const normalizeFrontendToolManifests = (value) => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const manifests = /* @__PURE__ */ new Map();
+  for (const manifest of value) {
+    if ((0, import_frontend_tools.isFrontendToolManifest)(manifest) && manifest.id === `${manifest.blockUid}:${manifest.name}`) {
+      manifests.set(manifest.id, manifest);
+    }
+  }
+  return Array.from(manifests.values());
+};
+const extractFrontendToolManifests = (workContext) => {
+  const manifests = /* @__PURE__ */ new Map();
+  for (const item of workContext) {
+    const frontendTools = Array.isArray(item == null ? void 0 : item.frontendTools) ? item.frontendTools : [];
+    for (const frontendTool of frontendTools) {
+      if ((0, import_frontend_tools.isFrontendToolManifest)(frontendTool) && frontendTool.blockUid === item.uid && frontendTool.id === `${item.uid}:${frontendTool.name}`) {
+        manifests.set(frontendTool.id, frontendTool);
+      }
+    }
+  }
+  return Array.from(manifests.values());
+};
+const findRequestFrontendTools = (ctx) => {
+  var _a, _b;
+  const values = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values;
+  const messages = Array.isArray(values == null ? void 0 : values.messages) ? values.messages.filter(isMessageLike) : [];
+  for (const message of messages) {
+    if (message.role !== "user") {
+      continue;
+    }
+    const frontendTools = extractFrontendToolManifests(Array.isArray(message.workContext) ? message.workContext : []);
+    if (frontendTools.length) {
+      return frontendTools;
+    }
+  }
+  return [];
+};
+const listCurrentFrontendTools = async (ctx, sessionId) => {
+  var _a, _b, _c;
+  const requestSessionId = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.sessionId;
+  const currentSessionId = sessionId ?? (typeof requestSessionId === "string" ? requestSessionId : "");
+  if (!currentSessionId) {
+    return findRequestFrontendTools(ctx);
+  }
+  const conversationRepository = ctx.db.getRepository("aiConversations");
+  const conversation = await conversationRepository.findOne({
+    filter: {
+      sessionId: currentSessionId
+    }
+  });
+  const options = conversation == null ? void 0 : conversation.options;
+  const boundTools = normalizeFrontendToolManifests(isRecord(options) ? options.frontendTools : void 0);
+  if (boundTools.length) {
+    return boundTools;
+  }
+  const frontendTools = findRequestFrontendTools(ctx);
+  if (!frontendTools.length || !conversation) {
+    return frontendTools;
+  }
+  await conversationRepository.update({
+    filter: {
+      sessionId: currentSessionId
+    },
+    values: {
+      options: {
+        ...isRecord(options) ? options : {},
+        frontendTools
+      }
+    }
+  });
+  return frontendTools;
+};
+const findCurrentFrontendTool = async (ctx, toolId, sessionId) => {
+  const tools = await listCurrentFrontendTools(ctx, sessionId);
+  return tools.find((tool) => tool.id === toolId);
+};
+const shouldAutoExecuteFrontendTool = (tools, args) => {
+  var _a;
+  if (!isRecord(args) || typeof args.toolId !== "string") {
+    return false;
+  }
+  return ((_a = tools.find((tool) => tool.id === args.toolId)) == null ? void 0 : _a.permission) === "ALLOW";
+};
+const prepareToolsForFrontendConversation = (tools, frontendTools) => {
+  if (!frontendTools.length) {
+    return tools.filter(
+      (tool) => tool.definition.name !== import_frontend_tools.LOAD_FRONTEND_TOOL_NAME && tool.definition.name !== import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME
+    );
+  }
+  const catalog = frontendTools.map(({ id, name, title, description }) => ({ id, name, title, description }));
+  const toolIds = frontendTools.map((tool) => tool.id);
+  const toolIdSchema = import_zod.z.enum(toolIds).describe(`Use an exact tool id from this catalog: ${JSON.stringify(catalog)}`);
+  return tools.map((tool) => {
+    if (tool.definition.name !== import_frontend_tools.LOAD_FRONTEND_TOOL_NAME && tool.definition.name !== import_frontend_tools.EXECUTE_FRONTEND_TOOL_NAME) {
+      return tool;
+    }
+    const isLoader = tool.definition.name === import_frontend_tools.LOAD_FRONTEND_TOOL_NAME;
+    return {
+      ...tool,
+      definition: {
+        ...tool.definition,
+        description: `${tool.definition.description}
+
+frontendToolCatalog: ${JSON.stringify(catalog)}`,
+        schema: isLoader ? import_zod.z.object({ toolId: toolIdSchema }) : import_zod.z.object({
+          toolId: toolIdSchema,
+          args: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).default({})
+        })
+      }
+    };
+  });
+};
+const readFrontendToolResult = (ctx, toolCallId) => {
+  var _a, _b, _c;
+  const toolCallResults = (_c = (_b = (_a = ctx.action) == null ? void 0 : _a.params) == null ? void 0 : _b.values) == null ? void 0 : _c.toolCallResults;
+  const result = Array.isArray(toolCallResults) ? toolCallResults.find(
+    (item) => isRecord(item) && item.id === toolCallId && "result" in item
+  ) : void 0;
+  return result ? { provided: true, value: result.result } : void 0;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractFrontendToolManifests,
+  findCurrentFrontendTool,
+  listCurrentFrontendTools,
+  prepareToolsForFrontendConversation,
+  readFrontendToolResult,
+  shouldAutoExecuteFrontendTool
+});

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/server/llm-providers/deepseek/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 * 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
+});