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

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

@@ -0,0 +1,83 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import type OpenAI from 'openai';
+import type { ReasoningOptions } from '../provider';
+export type DeepSeekApiProtocol = 'chat-completions' | 'responses';
+export type DeepSeekThinkingMode = 'enabled' | 'disabled';
+export type DeepSeekReasoningEffort = 'low' | 'high' | 'max';
+type DeepSeekReasoningBehavior = 'switchable' | 'always-on' | 'always-off';
+type DeepSeekModelCapabilities = {
+    protocol: DeepSeekApiProtocol;
+    reasoning: DeepSeekReasoningBehavior;
+    defaultThinking: DeepSeekThinkingMode;
+    efforts: ReadonlySet<DeepSeekReasoningEffort>;
+    supportsFunctionTools: boolean;
+    supportsStructuredOutput: boolean;
+    supportsWebSearch: boolean;
+};
+export type DeepSeekReasoningConfig = {
+    protocol: DeepSeekApiProtocol;
+    recognizedModel: boolean;
+    thinking?: DeepSeekThinkingMode;
+    effort?: DeepSeekReasoningEffort;
+    unsupportedRequestFields: ReadonlySet<string>;
+};
+type ReasoningSource = {
+    content?: unknown;
+    additional_kwargs?: Record<string, unknown>;
+    response_metadata?: Record<string, unknown>;
+};
+export declare const DEEPSEEK_MODEL_CAPABILITIES: {
+    readonly 'deepseek-v4-flash': {
+        readonly protocol: "responses";
+        readonly reasoning: "switchable";
+        readonly defaultThinking: "enabled";
+        readonly efforts: Set<DeepSeekReasoningEffort>;
+        readonly supportsFunctionTools: true;
+        readonly supportsStructuredOutput: true;
+        readonly supportsWebSearch: true;
+    };
+    readonly 'deepseek-v4-pro': {
+        readonly protocol: "responses";
+        readonly reasoning: "switchable";
+        readonly defaultThinking: "enabled";
+        readonly efforts: Set<DeepSeekReasoningEffort>;
+        readonly supportsFunctionTools: true;
+        readonly supportsStructuredOutput: true;
+        readonly supportsWebSearch: true;
+    };
+    readonly 'deepseek-chat': {
+        readonly protocol: "chat-completions";
+        readonly reasoning: "always-off";
+        readonly defaultThinking: "disabled";
+        readonly efforts: Set<DeepSeekReasoningEffort>;
+        readonly supportsFunctionTools: true;
+        readonly supportsStructuredOutput: true;
+        readonly supportsWebSearch: false;
+    };
+    readonly 'deepseek-reasoner': {
+        readonly protocol: "chat-completions";
+        readonly reasoning: "always-on";
+        readonly defaultThinking: "enabled";
+        readonly efforts: Set<DeepSeekReasoningEffort>;
+        readonly supportsFunctionTools: true;
+        readonly supportsStructuredOutput: true;
+        readonly supportsWebSearch: false;
+    };
+};
+export type OfficialDeepSeekModel = keyof typeof DEEPSEEK_MODEL_CAPABILITIES;
+export declare const getDeepSeekModelCapabilities: (model: string) => DeepSeekModelCapabilities | null;
+export declare const resolveDeepSeekReasoningConfig: (model: string, reasoning?: ReasoningOptions) => DeepSeekReasoningConfig;
+export declare const getDeepSeekReasoningRequestParams: (config: DeepSeekReasoningConfig) => Record<string, unknown>;
+export declare const normalizeDeepSeekChatRequest: <Request_1 extends OpenAI.Chat.Completions.ChatCompletionCreateParams>(request: Request_1, config: DeepSeekReasoningConfig) => Request_1;
+export declare const normalizeDeepSeekResponsesRequest: <Request_1 extends OpenAI.Responses.ResponseCreateParams>(request: Request_1, config: DeepSeekReasoningConfig) => Request_1;
+export declare const extractDeepSeekReasoningText: (source: Partial<ReasoningSource>) => string;
+export declare const getDeepSeekResponsesReasoningItem: (source: Partial<ReasoningSource>) => Record<string, unknown> | null;
+export declare function adaptDeepSeekResponsesStream(stream: AsyncIterable<OpenAI.Responses.ResponseStreamEvent>): AsyncGenerator<OpenAI.Responses.ResponseStreamEvent>;
+export {};

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

@@ -0,0 +1,285 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reasoning_exports = {};
+__export(reasoning_exports, {
+  DEEPSEEK_MODEL_CAPABILITIES: () => DEEPSEEK_MODEL_CAPABILITIES,
+  adaptDeepSeekResponsesStream: () => adaptDeepSeekResponsesStream,
+  extractDeepSeekReasoningText: () => extractDeepSeekReasoningText,
+  getDeepSeekModelCapabilities: () => getDeepSeekModelCapabilities,
+  getDeepSeekReasoningRequestParams: () => getDeepSeekReasoningRequestParams,
+  getDeepSeekResponsesReasoningItem: () => getDeepSeekResponsesReasoningItem,
+  normalizeDeepSeekChatRequest: () => normalizeDeepSeekChatRequest,
+  normalizeDeepSeekResponsesRequest: () => normalizeDeepSeekResponsesRequest,
+  resolveDeepSeekReasoningConfig: () => resolveDeepSeekReasoningConfig
+});
+module.exports = __toCommonJS(reasoning_exports);
+const NO_EFFORTS = /* @__PURE__ */ new Set();
+const V4_EFFORTS = /* @__PURE__ */ new Set(["low", "high", "max"]);
+const THINKING_UNSUPPORTED_FIELDS = /* @__PURE__ */ new Set(["temperature", "top_p", "presence_penalty", "frequency_penalty"]);
+const NO_UNSUPPORTED_FIELDS = /* @__PURE__ */ new Set();
+const DEEPSEEK_MODEL_CAPABILITIES = {
+  "deepseek-v4-flash": {
+    protocol: "responses",
+    reasoning: "switchable",
+    defaultThinking: "enabled",
+    efforts: V4_EFFORTS,
+    supportsFunctionTools: true,
+    supportsStructuredOutput: true,
+    supportsWebSearch: true
+  },
+  "deepseek-v4-pro": {
+    protocol: "responses",
+    reasoning: "switchable",
+    defaultThinking: "enabled",
+    efforts: V4_EFFORTS,
+    supportsFunctionTools: true,
+    supportsStructuredOutput: true,
+    supportsWebSearch: true
+  },
+  "deepseek-chat": {
+    protocol: "chat-completions",
+    reasoning: "always-off",
+    defaultThinking: "disabled",
+    efforts: NO_EFFORTS,
+    supportsFunctionTools: true,
+    supportsStructuredOutput: true,
+    supportsWebSearch: false
+  },
+  "deepseek-reasoner": {
+    protocol: "chat-completions",
+    reasoning: "always-on",
+    defaultThinking: "enabled",
+    efforts: NO_EFFORTS,
+    supportsFunctionTools: true,
+    supportsStructuredOutput: true,
+    supportsWebSearch: false
+  }
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isOfficialDeepSeekModel = (model) => model in DEEPSEEK_MODEL_CAPABILITIES;
+const getDeepSeekModelCapabilities = (model) => isOfficialDeepSeekModel(model) ? DEEPSEEK_MODEL_CAPABILITIES[model] : null;
+const normalizeReasoningEffort = (mode) => {
+  if (mode === "minimal" || mode === "low") {
+    return "low";
+  }
+  if (mode === "xhigh") {
+    return "high";
+  }
+  return "high";
+};
+const resolveDeepSeekReasoningConfig = (model, reasoning) => {
+  const capabilities = getDeepSeekModelCapabilities(model);
+  if (!capabilities) {
+    return {
+      protocol: "chat-completions",
+      recognizedModel: false,
+      unsupportedRequestFields: NO_UNSUPPORTED_FIELDS
+    };
+  }
+  const mode = (reasoning == null ? void 0 : reasoning.mode) ?? "default";
+  if (mode === "default") {
+    return {
+      protocol: capabilities.protocol,
+      recognizedModel: true,
+      unsupportedRequestFields: capabilities.defaultThinking === "enabled" ? THINKING_UNSUPPORTED_FIELDS : NO_UNSUPPORTED_FIELDS
+    };
+  }
+  if (mode === "off") {
+    if (capabilities.reasoning === "always-on") {
+      throw new Error(`DeepSeek model "${model}" does not support disabling reasoning`);
+    }
+    return {
+      protocol: capabilities.protocol,
+      recognizedModel: true,
+      ...capabilities.reasoning === "switchable" ? { thinking: "disabled" } : {},
+      unsupportedRequestFields: NO_UNSUPPORTED_FIELDS
+    };
+  }
+  if (capabilities.reasoning === "always-off") {
+    throw new Error(`DeepSeek model "${model}" does not support reasoning`);
+  }
+  const effort = normalizeReasoningEffort(mode);
+  return {
+    protocol: capabilities.protocol,
+    recognizedModel: true,
+    ...capabilities.reasoning === "switchable" ? { thinking: "enabled" } : {},
+    ...capabilities.efforts.has(effort) ? { effort } : {},
+    unsupportedRequestFields: THINKING_UNSUPPORTED_FIELDS
+  };
+};
+const getDeepSeekReasoningRequestParams = (config) => {
+  if (!config.recognizedModel) {
+    return {};
+  }
+  if (config.protocol === "responses") {
+    if (config.thinking === "disabled") {
+      return { reasoning: { effort: "none" } };
+    }
+    return config.effort ? { reasoning: { effort: config.effort } } : {};
+  }
+  return {
+    ...config.thinking ? { thinking: { type: config.thinking } } : {},
+    ...config.effort ? { reasoning_effort: config.effort } : {}
+  };
+};
+const removeUnsupportedRequestFields = (request, fields) => {
+  for (const field of fields) {
+    delete request[field];
+  }
+};
+const normalizeDeepSeekChatRequest = (request, config) => {
+  if (!config.recognizedModel) {
+    return request;
+  }
+  const mutableRequest = request;
+  delete mutableRequest.thinking;
+  delete mutableRequest.reasoning_effort;
+  Object.assign(mutableRequest, getDeepSeekReasoningRequestParams(config));
+  removeUnsupportedRequestFields(mutableRequest, config.unsupportedRequestFields);
+  return request;
+};
+const normalizeResponsesReasoningItems = (input) => {
+  if (!Array.isArray(input)) {
+    return;
+  }
+  for (const item of input) {
+    if (!isRecord(item) || item.type !== "reasoning") {
+      continue;
+    }
+    const hasReasoningContent = Array.isArray(item.content) && item.content.some((part) => isRecord(part) && part.type === "reasoning_text" && typeof part.text === "string");
+    if (hasReasoningContent || !Array.isArray(item.summary)) {
+      continue;
+    }
+    const text = item.summary.filter(isRecord).map((part) => part.text).filter((part) => typeof part === "string" && part.length > 0).join("");
+    if (text) {
+      item.content = [{ type: "reasoning_text", text }];
+      item.summary = [];
+    }
+  }
+};
+const normalizeDeepSeekResponsesRequest = (request, config) => {
+  if (!config.recognizedModel) {
+    return request;
+  }
+  const mutableRequest = request;
+  delete mutableRequest.reasoning;
+  Object.assign(mutableRequest, getDeepSeekReasoningRequestParams(config));
+  removeUnsupportedRequestFields(mutableRequest, config.unsupportedRequestFields);
+  normalizeResponsesReasoningItems(request.input);
+  return request;
+};
+const getReasoningItemText = (value) => {
+  if (!isRecord(value)) {
+    return "";
+  }
+  if (Array.isArray(value.content)) {
+    const content = value.content.filter(isRecord).filter((part) => part.type === "reasoning_text").map((part) => part.text).filter((text) => typeof text === "string" && text.length > 0).join("");
+    if (content) {
+      return content;
+    }
+  }
+  if (Array.isArray(value.summary)) {
+    return value.summary.filter(isRecord).map((part) => part.text).filter((text) => typeof text === "string" && text.length > 0).join("");
+  }
+  return "";
+};
+const extractDeepSeekReasoningText = (source) => {
+  var _a, _b, _c;
+  const reasoningContent = (_a = source.additional_kwargs) == null ? void 0 : _a.reasoning_content;
+  if (typeof reasoningContent === "string" && reasoningContent.length > 0) {
+    return reasoningContent;
+  }
+  if (Array.isArray(source.content)) {
+    const contentBlockText = source.content.filter(isRecord).filter((block) => block.type === "reasoning").map((block) => typeof block.reasoning === "string" ? block.reasoning : "").filter(Boolean).join("");
+    if (contentBlockText) {
+      return contentBlockText;
+    }
+  }
+  const additionalReasoningText = getReasoningItemText((_b = source.additional_kwargs) == null ? void 0 : _b.reasoning);
+  if (additionalReasoningText) {
+    return additionalReasoningText;
+  }
+  const output = (_c = source.response_metadata) == null ? void 0 : _c.output;
+  if (Array.isArray(output)) {
+    const reasoningItem = output.find((item) => isRecord(item) && item.type === "reasoning");
+    return getReasoningItemText(reasoningItem);
+  }
+  return "";
+};
+const getDeepSeekResponsesReasoningItem = (source) => {
+  var _a, _b;
+  const output = (_a = source.response_metadata) == null ? void 0 : _a.output;
+  if (Array.isArray(output)) {
+    const reasoningItem = output.find((item) => isRecord(item) && item.type === "reasoning");
+    if (isRecord(reasoningItem)) {
+      return reasoningItem;
+    }
+  }
+  return isRecord((_b = source.additional_kwargs) == null ? void 0 : _b.reasoning) ? source.additional_kwargs.reasoning : null;
+};
+async function* adaptDeepSeekResponsesStream(stream) {
+  const emittedWebSearchItems = /* @__PURE__ */ new Set();
+  for await (const event of stream) {
+    if (event.type === "response.reasoning_text.delta") {
+      yield {
+        type: "response.reasoning_summary_text.delta",
+        delta: event.delta,
+        item_id: event.item_id,
+        output_index: event.output_index,
+        sequence_number: event.sequence_number,
+        summary_index: event.content_index
+      };
+      continue;
+    }
+    if (event.type === "response.output_item.added" && event.item.type === "web_search_call" && isRecord(event.item.action) && typeof event.item.action.query === "string") {
+      emittedWebSearchItems.add(event.item.id);
+      yield {
+        type: "response.output_item.done",
+        item: event.item,
+        output_index: event.output_index,
+        sequence_number: event.sequence_number
+      };
+      continue;
+    }
+    if (event.type === "response.output_item.done" && event.item.type === "web_search_call" && emittedWebSearchItems.has(event.item.id)) {
+      continue;
+    }
+    yield event;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEEPSEEK_MODEL_CAPABILITIES,
+  adaptDeepSeekResponsesStream,
+  extractDeepSeekReasoningText,
+  getDeepSeekModelCapabilities,
+  getDeepSeekReasoningRequestParams,
+  getDeepSeekResponsesReasoningItem,
+  normalizeDeepSeekChatRequest,
+  normalizeDeepSeekResponsesRequest,
+  resolveDeepSeekReasoningConfig
+});

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

@@ -46,9 +46,9 @@ declare class ReasoningChatMistralAI extends ChatMistralAI {
         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;
-        prediction?: import("@mistralai/mistralai/models/components/prediction").Prediction;
         parallelToolCalls?: boolean;
         promptMode?: import("@mistralai/mistralai/models/components/mistralpromptmode").MistralPromptMode;
         safePrompt?: boolean;

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

@@ -98,6 +98,7 @@ export declare abstract class LLMProvider {
     } | null;
     parseResponseMetadata(output: LLMResult): any;
     parseResponseError(err: any): any;
+    prepareStoredAssistantAdditionalKwargs(additionalKwargs?: Record<string, unknown>): Record<string, unknown> | undefined;
     reshapeAIMessage(_options: {
         aiMessage: AIMessage;
         values: AIMessageInput;

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

@@ -367,6 +367,9 @@ ${parsed.text}
   parseResponseError(err) {
     return (err == null ? void 0 : err.message) ?? "Unexpected LLM service error";
   }
+  prepareStoredAssistantAdditionalKwargs(additionalKwargs) {
+    return additionalKwargs;
+  }
   reshapeAIMessage(_options) {
   }
   get documentLoader() {

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

@@ -0,0 +1,29 @@
+/**
+ * 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 { ChatOpenAI } from '@langchain/openai';
+import { LLMProviderMeta } from '../manager/ai-manager';
+import { LLMProvider } from './provider';
+export type ShengSuanYunModel = {
+    id: string;
+    support_apis?: string[];
+};
+export declare function supportsChatCompletions(model: ShengSuanYunModel): boolean;
+export declare class ShengSuanYunProvider extends LLMProvider {
+    chatModel: ChatOpenAI;
+    get baseURL(): string;
+    createModel(): ChatOpenAI<import("@langchain/openai/dist/chat_models/index.cjs").ChatOpenAICallOptions>;
+    listModels(): Promise<{
+        models?: {
+            id: string;
+        }[];
+        code?: number;
+        errMsg?: string;
+    }>;
+}
+export declare const shengsuanyunProviderOptions: LLMProviderMeta;

package/dist/server/llm-providers/shengsuanyun.js

@@ -0,0 +1,114 @@
+/**
+ * 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 shengsuanyun_exports = {};
+__export(shengsuanyun_exports, {
+  ShengSuanYunProvider: () => ShengSuanYunProvider,
+  shengsuanyunProviderOptions: () => shengsuanyunProviderOptions,
+  supportsChatCompletions: () => supportsChatCompletions
+});
+module.exports = __toCommonJS(shengsuanyun_exports);
+var import_openai = require("@langchain/openai");
+var import_utils = require("@nocobase/utils");
+var import_ai_manager = require("../manager/ai-manager");
+var import_provider = require("./provider");
+const CHAT_COMPLETIONS_API = "/v1/chat/completions";
+function supportsChatCompletions(model) {
+  return !Array.isArray(model.support_apis) || model.support_apis.includes(CHAT_COMPLETIONS_API);
+}
+class ShengSuanYunProvider extends import_provider.LLMProvider {
+  get baseURL() {
+    return "https://router.shengsuanyun.com/api/v1";
+  }
+  createModel() {
+    const { apiKey, xTitle } = this.serviceOptions || {};
+    const { responseFormat, structuredOutput } = this.modelOptions || {};
+    const { name, schema } = structuredOutput || {};
+    const responseFormatOptions = {
+      type: responseFormat ?? "text"
+    };
+    if (responseFormat === "json_schema" && schema) {
+      responseFormatOptions.json_schema = {
+        schema,
+        name: name ?? "schema"
+      };
+    }
+    return new import_openai.ChatOpenAI({
+      apiKey,
+      ...this.modelOptions,
+      modelKwargs: {
+        response_format: responseFormatOptions
+      },
+      configuration: {
+        baseURL: this.getResolvedBaseURL(),
+        ...xTitle ? { defaultHeaders: { "X-Title": xTitle } } : {}
+      }
+    });
+  }
+  async listModels() {
+    var _a;
+    const { apiKey, xTitle } = this.serviceOptions || {};
+    let url;
+    try {
+      url = this.buildRequestURL("models");
+    } catch (error) {
+      return { code: 400, errMsg: error instanceof Error ? error.message : String(error) };
+    }
+    if (!apiKey) {
+      return { code: 400, errMsg: "API Key required" };
+    }
+    try {
+      const response = await (0, import_utils.serverRequest)({
+        method: "GET",
+        url,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          ...xTitle ? { "X-Title": xTitle } : {}
+        }
+      });
+      const models = Array.isArray((_a = response == null ? void 0 : response.data) == null ? void 0 : _a.data) ? response.data.data : [];
+      return {
+        models: models.filter(supportsChatCompletions).map(({ id }) => ({ id }))
+      };
+    } catch (error) {
+      return {
+        code: 500,
+        errMsg: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+}
+const shengsuanyunProviderOptions = {
+  title: "SSYCloud",
+  supportedModel: [import_ai_manager.SupportedModel.LLM],
+  provider: ShengSuanYunProvider
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ShengSuanYunProvider,
+  shengsuanyunProviderOptions,
+  supportsChatCompletions
+});

package/dist/server/manager/ai-manager.d.ts

@@ -16,6 +16,7 @@ export type LLMProviderMeta = {
     provider: new (opts: LLMProviderOptions) => LLMProvider;
     embedding?: new (opts: EmbeddingProviderOptions) => EmbeddingProvider;
     supportWebSearch?: boolean;
+    webSearchModels?: string[];
 };
 export declare enum SupportedModel {
     LLM = "LLM",
@@ -38,6 +39,7 @@ export type EnabledLLMService = {
     providerTitle?: string;
     enabledModels: EnabledLLMModel[];
     supportWebSearch: boolean;
+    webSearchModels?: string[];
     isToolConflict: boolean;
 };
 export declare class AIManager {
@@ -51,6 +53,7 @@ export declare class AIManager {
         title: string;
         supportedModel: SupportedModel[];
         supportWebSearch: boolean;
+        webSearchModels: string[];
     }[];
     getSupportedProvider(model: SupportedModel): string[];
     listAllEnabledModels(): Promise<EnabledLLMService[]>;

package/dist/server/manager/ai-manager.js

@@ -48,11 +48,12 @@ class AIManager {
   }
   listLLMProviders() {
     const providers = this.llmProviders.entries();
-    return Array.from(providers).map(([name, { title, supportedModel, supportWebSearch }]) => ({
+    return Array.from(providers).map(([name, { title, supportedModel, supportWebSearch, webSearchModels }]) => ({
       name,
       title,
       supportedModel: supportedModel ?? ["LLM" /* LLM */],
-      supportWebSearch: supportWebSearch ?? false
+      supportWebSearch: supportWebSearch ?? false,
+      webSearchModels
     }));
   }
   getSupportedProvider(model) {
@@ -98,6 +99,7 @@ class AIManager {
       providerTitle: providerMeta.title,
       enabledModels,
       supportWebSearch: providerMeta.supportWebSearch ?? false,
+      webSearchModels: providerMeta.webSearchModels,
       isToolConflict: providerClient.isToolConflict()
     };
   }
@@ -149,6 +151,9 @@ class AIManager {
     if (!providerOptions) {
       throw new Error("LLM service provider not found");
     }
+    if (webSearch === true && providerOptions.webSearchModels && !providerOptions.webSearchModels.includes(model)) {
+      throw new Error(`Web search is not supported by model "${model}"`);
+    }
     const Provider = providerOptions.provider;
     const provider = new Provider({
       app: this.plugin.app,

package/dist/server/plugin.js

@@ -77,6 +77,7 @@ var import_checkpoints = require("./ai-employees/checkpoints");
 var import_mimo = require("./llm-providers/mimo");
 var import_mistral = require("./llm-providers/mistral");
 var import_orcarouter = require("./llm-providers/orcarouter");
+var import_shengsuanyun = require("./llm-providers/shengsuanyun");
 var import_sub_agents = require("./ai-employees/sub-agents");
 var import_employee = require("./workflow/nodes/employee");
 var import_ai_knowledge_base = require("./ai-employees/ai-knowledge-base");
@@ -191,6 +192,7 @@ class PluginAIServer extends import_server.Plugin {
     this.aiManager.registerLLMProvider("kimi", import_kimi.kimiProviderOptions);
     this.aiManager.registerLLMProvider("xai", import_xai.xaiProviderOptions);
     this.aiManager.registerLLMProvider("orcarouter", import_orcarouter.orcarouterProviderOptions);
+    this.aiManager.registerLLMProvider("shengsuanyun", import_shengsuanyun.shengsuanyunProviderOptions);
   }
   registerTools() {
     const toolsManager = this.ai.toolsManager;

package/dist/server/types/ai-message.type.d.ts

@@ -27,6 +27,10 @@ export type WorkContext = {
 export type AIMessageContent = {
     type: string;
     content: unknown;
+    reference?: {
+        title: string;
+        url: string;
+    }[];
 };
 export type AIToolCall = {
     id: string;

package/dist/swagger/index.d.ts

@@ -699,6 +699,10 @@ declare const _default: {
         '/llmServices:create': {
             post: {
                 operationId: string;
+                'x-nocobase-cli-ui': {
+                    path: string;
+                    parameters: string[];
+                };
                 tags: string[];
                 summary: string;
                 requestBody: {
@@ -748,6 +752,10 @@ declare const _default: {
         '/llmServices:update': {
             post: {
                 operationId: string;
+                'x-nocobase-cli-ui': {
+                    path: string;
+                    parameters: string[];
+                };
                 tags: string[];
                 summary: string;
                 parameters: {
@@ -897,6 +905,12 @@ declare const _default: {
                     supportWebSearch: {
                         type: string;
                     };
+                    webSearchModels: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
                 };
                 additionalProperties: boolean;
             };