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

package/dist/server/document-loader/loader.js

@@ -7,9 +7,11 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -23,6 +25,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var loader_exports = {};
 __export(loader_exports, {
@@ -32,6 +42,11 @@ module.exports = __toCommonJS(loader_exports);
 var import_constants = require("./constants");
 var import_utils = require("./utils");
 var import_ai = require("@nocobase/ai");
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_promises2 = require("node:stream/promises");
 class DocumentLoader {
   constructor(fileManager) {
     this.fileManager = fileManager;
@@ -42,15 +57,17 @@ class DocumentLoader {
       return [];
     }
     const { stream, contentType } = await this.fileManager.getFileStream(file, options);
-    const blob = await this.streamToBlob(stream, contentType ?? file.mimetype);
-    return await (0, import_ai.loadByWorker)(extname, blob);
-  }
-  async streamToBlob(stream, mimeType = "application/octet-stream") {
-    const chunks = [];
-    for await (const chunk of stream) {
-      chunks.push(chunk);
+    const tempDir = await (0, import_promises.mkdtemp)(import_node_path.default.join(import_node_os.default.tmpdir(), "nocobase-document-loader-"));
+    const tempFilePath = import_node_path.default.join(tempDir, `source${extname}`);
+    try {
+      await (0, import_promises2.pipeline)(stream, (0, import_node_fs.createWriteStream)(tempFilePath));
+      return await (0, import_ai.loadByWorker)(extname, {
+        filePath: tempFilePath,
+        mimeType: contentType ?? file.mimetype
+      });
+    } finally {
+      await (0, import_promises.rm)(tempDir, { recursive: true, force: true });
     }
-    return new Blob(chunks, { type: mimeType });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/server/document-loader/types.d.ts

@@ -31,6 +31,13 @@ export type ParseableFile = {
     storageId?: number;
     meta?: Record<string, any>;
     size?: number;
+    source?: {
+        dataSourceKey?: string;
+        collectionName?: string;
+        field?: string;
+        documentCache?: boolean;
+        trustworthy?: boolean;
+    };
 };
 export type DocumentLoaderLike = {
     load(file: ParseableFile, options?: any): Promise<Document[]>;

package/dist/server/features/knowledge-base.d.ts

@@ -7,8 +7,10 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { DocumentSegmentedWithScore, KnowledgeBase, KnowledgeBaseGroup, SearchOptions } from '../types';
+export type KnowledgeBaseAccessOptions = Pick<SearchOptions, 'knowledgeBaseKeys' | 'roleNames'>;
 export interface KnowledgeBaseFeature {
     getKnowledgeBase(knowledgeBaseKeys: string[]): Promise<KnowledgeBase[]>;
     getKnowledgeBaseGroup(knowledgeBaseKeys: string[]): Promise<KnowledgeBaseGroup[]>;
+    getAccessibleKnowledgeBaseKeys(options: KnowledgeBaseAccessOptions): Promise<string[]>;
     search(options: SearchOptions): Promise<DocumentSegmentedWithScore[]>;
 }

package/dist/server/frontend-tools.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { Context } from '@nocobase/actions';
+import { type FrontendToolManifest } from '../common/frontend-tools';
+import type { WorkContext } from './types/ai-message.type';
+export declare const extractFrontendToolManifests: (workContext: WorkContext[]) => FrontendToolManifest[];
+export declare const listCurrentFrontendTools: (ctx: Context, sessionId?: string) => Promise<FrontendToolManifest[]>;
+export declare const findCurrentFrontendTool: (ctx: Context, toolId: string, sessionId?: string) => Promise<FrontendToolManifest | undefined>;
+export declare const shouldAutoExecuteFrontendTool: (tools: FrontendToolManifest[], args: unknown) => boolean;
+export declare const prepareToolsForFrontendConversation: <T extends {
+    definition: {
+        name: string;
+        description: string;
+    };
+}>(tools: T[], frontendTools: FrontendToolManifest[]) => T[];
+export declare const readFrontendToolResult: (ctx: Context, toolCallId: string) => {
+    provided: true;
+    value: unknown;
+} | undefined;

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/anthropic.d.ts

@@ -8,6 +8,7 @@
  */
 import { LLMProvider, ParsedAttachmentResult } from './provider';
 import { ChatAnthropic } from '@langchain/anthropic';
+import type { AttachmentModel } from '@nocobase/plugin-file-manager';
 import { Model } from '@nocobase/database';
 import { LLMProviderMeta } from '../manager/ai-manager';
 import { Context } from '@nocobase/actions';
@@ -36,7 +37,7 @@ export declare class AnthropicProvider extends LLMProvider {
         type: string;
         query: string;
     }[];
-    protected convertToContent(ctx: Context, attachment: any): Promise<ParsedAttachmentResult>;
+    protected convertToContent(ctx: Context, attachment: AttachmentModel): Promise<ParsedAttachmentResult>;
     private setMaxTokens;
 }
 export declare const anthropicProviderOptions: LLMProviderMeta;

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

@@ -186,9 +186,7 @@ class AnthropicProvider extends import_provider.LLMProvider {
     });
   }
   async convertToContent(ctx, attachment) {
-    const fileManager = this.app.pm.get("file-manager");
-    const url = await fileManager.getFileURL(attachment);
-    const data = await (0, import_utils2.encodeFile)(ctx, decodeURIComponent(url));
+    const data = await this.encodeAttachment(ctx, attachment);
     if (attachment.mimetype.startsWith("image/")) {
       return {
         placement: "contentBlocks",

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/dashscope.d.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { AIMessageChunk } from '@langchain/core/messages';
-import { EmbeddingProvider, LLMProvider } from './provider';
+import { EmbeddingProvider, LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from './provider';
 import { EmbeddingsInterface } from '@langchain/core/embeddings';
 import { SupportedModel } from '../manager/ai-manager';
 import { Model } from '@nocobase/database';
@@ -19,6 +19,7 @@ export declare class DashscopeProvider extends LLMProvider {
     createModel(): ReasoningChatOpenAI;
     isToolConflict(): boolean;
     resolveTools(toolDefinitions: any[]): any[];
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     parseResponseMessage(message: Model): {
         key: any;
         createdAt: any;

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

@@ -56,6 +56,7 @@ class DashscopeProvider extends import_provider.LLMProvider {
     const { apiKey } = this.serviceOptions || {};
     const { responseFormat, structuredOutput } = this.modelOptions || {};
     const { name, schema } = structuredOutput || {};
+    const reasoningOptions = this.resolveReasoningOptions(this.modelReasoningOptions);
     const modelKwargs = {};
     if (responseFormat) {
       const responseFormatOptions = {
@@ -76,7 +77,11 @@ class DashscopeProvider extends import_provider.LLMProvider {
       topP: 0.8,
       temperature: 0.7,
       ...this.modelOptions,
-      modelKwargs,
+      ...reasoningOptions.modelRequestParams || {},
+      modelKwargs: {
+        ...modelKwargs,
+        ...reasoningOptions.modelKwargs || {}
+      },
       configuration: {
         baseURL: this.getResolvedBaseURL()
       },
@@ -94,6 +99,16 @@ class DashscopeProvider extends import_provider.LLMProvider {
       return toolDefinitions;
     }
   }
+  resolveReasoningOptions(reasoning) {
+    if ((reasoning == null ? void 0 : reasoning.mode) !== "off") {
+      return {};
+    }
+    return {
+      modelKwargs: {
+        enable_thinking: false
+      }
+    };
+  }
   parseResponseMessage(message) {
     var _a;
     const result = super.parseResponseMessage(message);

package/dist/{client/ai-employees/datasource → server/llm-providers/deepseek}/index.d.ts

@@ -6,4 +6,5 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-export * from './DatasourceSelector';
+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 {};