@nocobase/plugin-ai 2.2.0-beta.8 → 2.2.0

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

package/dist/server/llm-providers/google-genai.d.ts

@@ -9,7 +9,7 @@
 import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { EmbeddingProvider, LLMProvider, ParsedAttachmentResult } from './provider';
 import { Model } from '@nocobase/database';
-import { AttachmentModel } from '@nocobase/plugin-file-manager';
+import type { AttachmentModel } from '@nocobase/plugin-file-manager';
 import { LLMProviderMeta } from '../manager/ai-manager';
 import { EmbeddingsInterface } from '@langchain/core/embeddings';
 import { Context } from '@nocobase/actions';

package/dist/server/llm-providers/google-genai.js

@@ -34,7 +34,6 @@ module.exports = __toCommonJS(google_genai_exports);
 var import_google_genai = require("@langchain/google-genai");
 var import_provider = require("./provider");
 var import_utils = require("@nocobase/utils");
-var import_utils2 = require("../utils");
 var import_ai_manager = require("../manager/ai-manager");
 const GOOGLE_GEN_AI_URL = "https://generativelanguage.googleapis.com";
 class GoogleGenAIProvider extends import_provider.LLMProvider {
@@ -120,10 +119,8 @@ class GoogleGenAIProvider extends import_provider.LLMProvider {
   }
   async convertToContent(ctx, attachment) {
     var _a;
-    const fileManager = this.app.pm.get("file-manager");
-    const url = await fileManager.getFileURL(attachment);
+    const data = await this.encodeAttachment(ctx, attachment);
     if ((_a = attachment.mimetype) == null ? void 0 : _a.startsWith("image/")) {
-      const data = await (0, import_utils2.encodeFile)(ctx, decodeURIComponent(url));
       return {
         placement: "contentBlocks",
         content: {
@@ -134,7 +131,6 @@ class GoogleGenAIProvider extends import_provider.LLMProvider {
         }
       };
     } else {
-      const data = await (0, import_utils2.encodeFile)(ctx, decodeURIComponent(url));
       return {
         placement: "contentBlocks",
         content: {

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

@@ -8,7 +8,7 @@
  */
 import { AIMessageChunk } from '@langchain/core/messages';
 import { Model } from '@nocobase/database';
-import { LLMProvider } from '../provider';
+import { LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from '../provider';
 import { LLMProviderMeta } from '../../manager/ai-manager';
 import { CachedDocumentLoader } from '../../document-loader';
 import { ReasoningChatOpenAI } from '../common/reasoning';
@@ -28,6 +28,7 @@ export declare class KimiProvider extends LLMProvider {
         status: string;
         content: string;
     };
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     protected isApiSupportedAttachment(attachment: AttachmentModel): boolean;
     protected get documentLoader(): CachedDocumentLoader;
 }

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

@@ -46,6 +46,7 @@ var import_ai_manager = require("../../manager/ai-manager");
 var import_document_loader = require("../../document-loader");
 var import_document_loader2 = require("./document-loader");
 var import_reasoning = require("../common/reasoning");
+const KIMI_THINKING_SWITCH_MODELS = /* @__PURE__ */ new Set(["kimi-k2.5", "kimi-k2.6"]);
 class KimiProvider extends import_provider.LLMProvider {
   _documentLoader;
   get baseURL() {
@@ -55,6 +56,7 @@ class KimiProvider extends import_provider.LLMProvider {
     const { apiKey } = this.serviceOptions || {};
     const { responseFormat, structuredOutput } = this.modelOptions || {};
     const { name, schema } = structuredOutput || {};
+    const reasoningOptions = this.resolveReasoningOptions(this.modelReasoningOptions);
     const responseFormatOptions = {
       type: responseFormat ?? "text"
     };
@@ -65,8 +67,10 @@ class KimiProvider extends import_provider.LLMProvider {
       apiKey,
       ...this.modelOptions,
       modelKwargs: {
-        response_format: responseFormatOptions
+        response_format: responseFormatOptions,
+        ...reasoningOptions.modelKwargs || {}
       },
+      ...reasoningOptions.modelRequestParams || {},
       configuration: {
         baseURL: this.getResolvedBaseURL()
       }
@@ -100,6 +104,22 @@ class KimiProvider extends import_provider.LLMProvider {
     }
     return null;
   }
+  resolveReasoningOptions(reasoning) {
+    var _a;
+    if (!reasoning || reasoning.mode === "default") {
+      return {};
+    }
+    if (!KIMI_THINKING_SWITCH_MODELS.has((_a = this.modelOptions) == null ? void 0 : _a.model)) {
+      return {};
+    }
+    return {
+      modelKwargs: {
+        thinking: {
+          type: reasoning.mode === "off" ? "disabled" : "enabled"
+        }
+      }
+    };
+  }
   isApiSupportedAttachment(attachment) {
     var _a;
     return ((_a = attachment.mimetype) == null ? void 0 : _a.startsWith("image/")) ?? false;
@@ -126,7 +146,7 @@ const kimiProviderOptions = {
   title: "Kimi",
   supportedModel: [import_ai_manager.SupportedModel.LLM],
   models: {
-    [import_ai_manager.SupportedModel.LLM]: ["kimi-k2.5", "kimi-k2-0905-Preview", "kimi-k2-turbo-preview"]
+    [import_ai_manager.SupportedModel.LLM]: ["kimi-k2.7-code", "kimi-k2.7-code-highspeed", "kimi-k2.6", "kimi-k2.5"]
   },
   provider: KimiProvider
 };

package/dist/server/llm-providers/mistral.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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 { EmbeddingsInterface } from '@langchain/core/embeddings';
+import { AIMessage, AIMessageChunk } from '@langchain/core/messages';
+import { ChatMistralAI } from '@langchain/mistralai';
+import { AttachmentModel } from '@nocobase/plugin-file-manager';
+import { EmbeddingProvider, LLMProvider, LLMProviderInvokeOptions, ReasoningMode, ReasoningOptions, ResolvedReasoningOptions } from './provider';
+import { LLMProviderMeta } from '../manager/ai-manager';
+import { AIChatContext, AIMessageInput } from '../types/ai-chat-conversation.type';
+import { Model } from '@nocobase/database';
+declare const MISTRAL_REASONING_MODE_KEY = "__nb_reasoning_mode";
+type MistralCallOptions = LLMProviderInvokeOptions & {
+    response_format?: {
+        type: 'text' | 'json_object';
+    };
+};
+type MistralBeforeRequestHook = (request: Request) => Request | void | Promise<Request | void>;
+type ReasoningChatMistralAIFields = ConstructorParameters<typeof ChatMistralAI>[0] & {
+    [MISTRAL_REASONING_MODE_KEY]?: ReasoningMode;
+};
+export declare const injectMistralReasoningEffort: MistralBeforeRequestHook;
+declare class ReasoningChatMistralAI extends ChatMistralAI {
+    private readonly reasoningMode?;
+    constructor(fields: ReasoningChatMistralAIFields);
+    invocationParams(options?: MistralCallOptions): Omit<import("@mistralai/mistralai/models/components/chatcompletionrequest").ChatCompletionRequest | import("@mistralai/mistralai/models/components/chatcompletionstreamrequest").ChatCompletionStreamRequest, "messages"> | {
+        __nb_reasoning_mode: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+        model: string;
+        tools?: import("@mistralai/mistralai/models/components/tool").Tool[];
+        metadata?: {
+            [k: string]: any;
+        } | {
+            [k: string]: any;
+        };
+        stream?: boolean;
+        responseFormat?: import("@mistralai/mistralai/models/components/responseformat").ResponseFormat;
+        temperature?: number;
+        maxTokens?: number;
+        topP?: number;
+        frequencyPenalty?: number;
+        presencePenalty?: number;
+        n?: number;
+        stop?: string | string[];
+        prediction?: import("@mistralai/mistralai/models/components/prediction").Prediction;
+        toolChoice?: import("@mistralai/mistralai/models/components/toolchoice").ToolChoice | import("@mistralai/mistralai/models/components/toolchoiceenum").ToolChoiceEnum;
+        randomSeed?: number;
+        parallelToolCalls?: boolean;
+        promptMode?: import("@mistralai/mistralai/models/components/mistralpromptmode").MistralPromptMode;
+        safePrompt?: boolean;
+    };
+}
+export declare class MistralProvider extends LLMProvider {
+    chatModel: ChatMistralAI;
+    get baseURL(): string;
+    createModel(): ReasoningChatMistralAI;
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
+    stream(context: AIChatContext, options?: MistralCallOptions): Promise<any>;
+    invoke(context: AIChatContext, options?: MistralCallOptions): Promise<any>;
+    listModels(): Promise<{
+        models?: {
+            id: string;
+        }[];
+        code?: number;
+        errMsg?: string;
+    }>;
+    protected isApiSupportedAttachment(attachment: AttachmentModel): boolean;
+    reshapeAIMessage({ aiMessage, values }: {
+        aiMessage: AIMessage;
+        values: AIMessageInput;
+    }): void;
+    parseResponseMessage(message: Model): {
+        key: any;
+        createdAt: any;
+        content: any;
+        role: any;
+    };
+    parseResponseChunk(chunk: unknown): string;
+    parseReasoningContent(chunk: AIMessageChunk): {
+        status: string;
+        content: string;
+    } | null;
+    private withResponseFormat;
+    private getResolvedServerURL;
+    private buildMistralRequestURL;
+}
+export declare class MistralEmbeddingProvider extends EmbeddingProvider {
+    protected getDefaultUrl(): string;
+    createEmbedding(): EmbeddingsInterface;
+}
+export declare const mistralProviderOptions: LLMProviderMeta;
+export {};