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

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

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 {};