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

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

@@ -45,6 +45,7 @@ var import_provider = require("./provider");
 var import_ai_manager = require("../manager/ai-manager");
 var import_lodash = __toESM(require("lodash"));
 var import_reasoning = require("./common/reasoning");
+const DEEPSEEK_REASONING_EFFORTS = /* @__PURE__ */ new Set(["low", "medium", "high"]);
 class ReasoningDeepSeek extends import_deepseek.ChatDeepSeek {
   async _generate(messages, options, runManager) {
     const reasoningMap = (0, import_reasoning.collectReasoningMap)(messages);
@@ -80,6 +81,7 @@ class DeepSeekProvider extends import_provider.LLMProvider {
   createModel() {
     const { apiKey } = this.serviceOptions || {};
     const { responseFormat } = this.modelOptions || {};
+    const reasoningOptions = this.resolveReasoningOptions(this.modelReasoningOptions);
     const modelKwargs = {};
     if (responseFormat) {
       modelKwargs["response_format"] = {
@@ -89,7 +91,11 @@ class DeepSeekProvider extends import_provider.LLMProvider {
     return new ReasoningDeepSeek({
       apiKey,
       ...this.modelOptions,
-      modelKwargs,
+      ...reasoningOptions.modelRequestParams || {},
+      modelKwargs: {
+        ...modelKwargs,
+        ...reasoningOptions.modelKwargs || {}
+      },
       configuration: {
         baseURL: this.getResolvedBaseURL()
       },
@@ -124,6 +130,31 @@ class DeepSeekProvider extends import_provider.LLMProvider {
     }
     return null;
   }
+  resolveReasoningOptions(reasoning) {
+    if (!reasoning || reasoning.mode === "default") {
+      return {};
+    }
+    if (reasoning.mode === "off") {
+      return {
+        modelKwargs: {
+          thinking: {
+            type: "disabled"
+          }
+        }
+      };
+    }
+    if (!DEEPSEEK_REASONING_EFFORTS.has(reasoning.mode)) {
+      return {};
+    }
+    return {
+      modelKwargs: {
+        thinking: {
+          type: "enabled"
+        },
+        reasoning_effort: reasoning.mode
+      }
+    };
+  }
   isApiSupportedAttachment(attachment) {
     return false;
   }
@@ -132,7 +163,7 @@ const deepseekProviderOptions = {
   title: "DeepSeek",
   supportedModel: [import_ai_manager.SupportedModel.LLM],
   models: {
-    [import_ai_manager.SupportedModel.LLM]: ["deepseek-chat", "deepseek-reasoner"]
+    [import_ai_manager.SupportedModel.LLM]: ["deepseek-v4-pro", "deepseek-v4-flash", "deepseek-chat", "deepseek-reasoner"]
   },
   provider: DeepSeekProvider
 };

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

@@ -10,21 +10,55 @@ 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 } from './provider';
+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[];
+        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;
+    };
+}
 export declare class MistralProvider extends LLMProvider {
     chatModel: ChatMistralAI;
     get baseURL(): string;
-    createModel(): ChatMistralAI<import("@langchain/mistralai/dist/chat_models").ChatMistralAICallOptions>;
+    createModel(): ReasoningChatMistralAI;
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     stream(context: AIChatContext, options?: MistralCallOptions): Promise<any>;
     invoke(context: AIChatContext, options?: MistralCallOptions): Promise<any>;
     listModels(): Promise<{

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

@@ -39,6 +39,8 @@ var import_ai_manager = require("../manager/ai-manager");
 const MISTRAL_URL = "https://api.mistral.ai";
 const MISTRAL_REASONING_EFFORT = "high";
 const MISTRAL_REASONING_MODELS = /* @__PURE__ */ new Set(["mistral-small-latest", "mistral-medium-3-5"]);
+const MISTRAL_REASONING_EFFORTS = /* @__PURE__ */ new Set(["off", "low", "medium", "high"]);
+const MISTRAL_REASONING_MODE_KEY = "__nb_reasoning_mode";
 function omitDisabledNumberOptions(options) {
   for (const key of ["maxTokens", "maxRetries"]) {
     if (options[key] === -1) {
@@ -73,19 +75,62 @@ const injectMistralReasoningEffort = async (request) => {
   if (!body || typeof body !== "object") {
     return;
   }
+  const reasoningMode = body[MISTRAL_REASONING_MODE_KEY];
+  delete body[MISTRAL_REASONING_MODE_KEY];
+  const shouldRewriteBody = reasoningMode != null;
   if (typeof body.model !== "string" || !MISTRAL_REASONING_MODELS.has(body.model)) {
+    if (shouldRewriteBody) {
+      const headers2 = new Headers(request.headers);
+      headers2.delete("content-length");
+      return new Request(request, {
+        headers: headers2,
+        body: JSON.stringify(body)
+      });
+    }
     return;
   }
+  if (reasoningMode === "off") {
+    delete body.reasoning_effort;
+    const headers2 = new Headers(request.headers);
+    headers2.delete("content-length");
+    return new Request(request, {
+      headers: headers2,
+      body: JSON.stringify(body)
+    });
+  }
+  if (body.reasoning_effort && !shouldRewriteBody) {
+    return;
+  }
+  const reasoningEffort = reasoningMode && reasoningMode !== "default" ? reasoningMode : MISTRAL_REASONING_EFFORT;
   const headers = new Headers(request.headers);
   headers.delete("content-length");
   return new Request(request, {
     headers,
     body: JSON.stringify({
       ...body,
-      reasoning_effort: MISTRAL_REASONING_EFFORT
+      reasoning_effort: reasoningEffort
     })
   });
 };
+class ReasoningChatMistralAI extends import_mistralai.ChatMistralAI {
+  reasoningMode;
+  constructor(fields) {
+    const { [MISTRAL_REASONING_MODE_KEY]: reasoningMode, ...modelFields } = fields;
+    super(modelFields);
+    this.reasoningMode = reasoningMode;
+  }
+  invocationParams(options) {
+    const params = super.invocationParams(options);
+    const mode = this.reasoningMode;
+    if (!mode || mode === "default") {
+      return params;
+    }
+    return {
+      ...params,
+      [MISTRAL_REASONING_MODE_KEY]: mode
+    };
+  }
+}
 class MistralProvider extends import_provider.LLMProvider {
   get baseURL() {
     return MISTRAL_URL;
@@ -95,14 +140,29 @@ class MistralProvider extends import_provider.LLMProvider {
     const { responseFormat, structuredOutput, ...modelOptions } = this.modelOptions || {};
     omitDisabledNumberOptions(modelOptions);
     const beforeRequestHooks = Array.isArray(modelOptions.beforeRequestHooks) ? [injectMistralReasoningEffort, ...modelOptions.beforeRequestHooks] : [injectMistralReasoningEffort];
-    return new import_mistralai.ChatMistralAI({
+    const reasoningOptions = this.resolveReasoningOptions(this.modelReasoningOptions);
+    return new ReasoningChatMistralAI({
       apiKey,
       ...modelOptions,
+      ...reasoningOptions.modelRequestParams || {},
       beforeRequestHooks,
       serverURL: this.getResolvedServerURL(),
       verbose: false
     });
   }
+  resolveReasoningOptions(reasoning) {
+    if (!reasoning || reasoning.mode === "default") {
+      return {};
+    }
+    if (!MISTRAL_REASONING_EFFORTS.has(reasoning.mode)) {
+      return {};
+    }
+    return {
+      modelRequestParams: {
+        [MISTRAL_REASONING_MODE_KEY]: reasoning.mode
+      }
+    };
+  }
   async stream(context, options) {
     return super.stream(context, this.withResponseFormat(options));
   }

package/dist/server/llm-providers/openai/completions.d.ts

@@ -7,9 +7,10 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { ChatOpenAI } from '@langchain/openai';
-import { LLMProvider } from '../provider';
+import { LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from '../provider';
 export declare class OpenAICompletionsProvider extends LLMProvider {
     chatModel: ChatOpenAI;
     get baseURL(): string;
     createModel(): ChatOpenAI<import("@langchain/openai/dist/chat_models/index.cjs").ChatOpenAICallOptions>;
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
 }

package/dist/server/llm-providers/openai/completions.js

@@ -39,6 +39,7 @@ class OpenAICompletionsProvider 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"
     };
@@ -48,14 +49,29 @@ class OpenAICompletionsProvider extends import_provider.LLMProvider {
     return new import_openai.ChatOpenAI({
       apiKey,
       ...this.modelOptions,
+      ...reasoningOptions.modelRequestParams || {},
       modelKwargs: {
-        response_format: responseFormatOptions
+        response_format: responseFormatOptions,
+        ...reasoningOptions.modelKwargs || {}
       },
       configuration: {
         baseURL: this.getResolvedBaseURL()
       }
     });
   }
+  resolveReasoningOptions(reasoning) {
+    if (!reasoning || reasoning.mode === "default") {
+      return {};
+    }
+    const effort = reasoning.mode === "off" ? "none" : reasoning.mode;
+    return {
+      modelRequestParams: {
+        reasoning: {
+          effort
+        }
+      }
+    };
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/server/llm-providers/openai/responses.d.ts

@@ -7,7 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { ChatOpenAI } from '@langchain/openai';
-import { LLMProvider } from '../provider';
+import { LLMProvider, ReasoningOptions, ResolvedReasoningOptions } from '../provider';
 import { Model } from '@nocobase/database';
 import { AIMessageChunk } from '@langchain/core/messages';
 export declare class OpenAIResponsesProvider extends LLMProvider {
@@ -22,6 +22,7 @@ export declare class OpenAIResponsesProvider extends LLMProvider {
         role: any;
     };
     protected builtInTools(): any[];
+    protected resolveReasoningOptions(reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     isToolConflict(): boolean;
     parseWebSearchAction(chunk: AIMessageChunk): {
         type: string;

package/dist/server/llm-providers/openai/responses.js

@@ -40,6 +40,7 @@ class OpenAIResponsesProvider extends import_provider.LLMProvider {
     const { apiKey } = this.serviceOptions || {};
     const { responseFormat, structuredOutput } = this.modelOptions || {};
     const { name, schema, strict } = structuredOutput || {};
+    const reasoningOptions = this.resolveReasoningOptions(this.modelReasoningOptions);
     let responseFormatOptions = {
       type: responseFormat ?? "text"
     };
@@ -54,10 +55,12 @@ class OpenAIResponsesProvider extends import_provider.LLMProvider {
     return new import_openai.ChatOpenAI({
       apiKey,
       ...this.modelOptions,
+      ...reasoningOptions.modelRequestParams || {},
       modelKwargs: {
         text: {
           format: responseFormatOptions
-        }
+        },
+        ...reasoningOptions.modelKwargs || {}
       },
       configuration: {
         baseURL: this.getResolvedBaseURL()
@@ -130,6 +133,19 @@ class OpenAIResponsesProvider extends import_provider.LLMProvider {
     }
     return [];
   }
+  resolveReasoningOptions(reasoning) {
+    if (!reasoning || reasoning.mode === "default") {
+      return {};
+    }
+    const effort = reasoning.mode === "off" ? "none" : reasoning.mode;
+    return {
+      modelRequestParams: {
+        reasoning: {
+          effort
+        }
+      }
+    };
+  }
   isToolConflict() {
     return false;
   }

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

@@ -27,6 +27,11 @@ export type LLMProviderInvokeOptions = {
     modelRequestParams?: Record<string, any>;
     [key: string]: any;
 };
+export type ReasoningMode = 'default' | 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export type ReasoningOptions = {
+    mode: ReasoningMode;
+};
+export type ResolvedReasoningOptions = Pick<LLMProviderInvokeOptions, 'modelKwargs' | 'modelRequestParams'>;
 export type LLMModelRequestBuilderResult = {
     context: AIChatContext;
     options?: LLMProviderInvokeOptions;
@@ -45,10 +50,12 @@ export declare abstract class LLMProvider {
     serviceOptions: Record<string, any>;
     modelOptions: Record<string, any> | undefined;
     chatModel: any;
+    protected modelReasoningOptions: ReasoningOptions | undefined;
     abstract createModel(): BaseChatModel | any;
     get baseURL(): string | null;
     constructor(opts: LLMProviderOptions);
     protected getModelRequestBuilder(_model?: string): LLMModelRequestBuilder | null;
+    protected resolveReasoningOptions(_reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     prepareChain(context: AIChatContext): any;
     invoke(context: AIChatContext, options?: LLMProviderInvokeOptions): Promise<any>;
     stream(context: AIChatContext, options?: any): Promise<any>;

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

@@ -84,6 +84,7 @@ class LLMProvider {
   serviceOptions;
   modelOptions;
   chatModel;
+  modelReasoningOptions;
   get baseURL() {
     return null;
   }
@@ -92,13 +93,18 @@ class LLMProvider {
     this.app = app;
     this.serviceOptions = resolveServiceOptions(serviceOptions, app);
     if (modelOptions) {
-      this.modelOptions = modelOptions;
+      const { _reasoning, ...restModelOptions } = modelOptions;
+      this.modelReasoningOptions = _reasoning;
+      this.modelOptions = restModelOptions;
       this.chatModel = this.createModel();
     }
   }
   getModelRequestBuilder(_model) {
     return null;
   }
+  resolveReasoningOptions(_reasoning) {
+    return {};
+  }
   prepareChain(context) {
     var _a, _b, _c, _d;
     let chain = this.chatModel;

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

@@ -60,6 +60,34 @@ function serializeQueryFieldValue(value) {
   }
   return value;
 }
+function getRecordFieldValue(record, field) {
+  return field.split(".").reduce((current, key) => {
+    if (current === null || current === void 0) {
+      return current;
+    }
+    if (typeof current.get === "function") {
+      return current.get(key);
+    }
+    return current[key];
+  }, record);
+}
+function getQueryFieldOptions(collection, field) {
+  const parts = field.split(".");
+  let currentCollection = collection;
+  for (const [index, part] of parts.entries()) {
+    const currentField = currentCollection == null ? void 0 : currentCollection.getField(part);
+    if (!currentField) {
+      return;
+    }
+    if (index === parts.length - 1) {
+      return currentField.options;
+    }
+    if (!currentField.isRelationField()) {
+      return;
+    }
+    currentCollection = currentField.targetCollection();
+  }
+}
 class AIContextDatasourceManager {
   constructor(plugin) {
     this.plugin = plugin;
@@ -149,17 +177,16 @@ class AIContextDatasourceManager {
         }
       });
     }
-    const { fields, filter, sort, offset, limit } = options;
-    const result = await collection.repository.find({ fields, filter, sort, offset: offset ?? 0, limit });
+    const { fields, appends, filter, sort, offset, limit } = options;
+    const result = await collection.repository.find({ fields, appends, filter, sort, offset: offset ?? 0, limit });
     const total = await collection.repository.count({ fields, filter });
     const records = result.map(
       (x) => fields.map((field) => {
-        var _a2;
-        const { name, type } = ((_a2 = collection.getField(field)) == null ? void 0 : _a2.options) || {};
-        const value = serializeQueryFieldValue(x[field]);
+        const { name, type } = getQueryFieldOptions(collection, field) || {};
+        const value = serializeQueryFieldValue(getRecordFieldValue(x, field));
         return {
-          name,
-          type,
+          name: field.includes(".") ? field : name || field,
+          type: type || "unknown",
           value
         };
       })

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

@@ -6,7 +6,7 @@
  * 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 { LLMProvider, LLMProviderOptions, EmbeddingProvider, EmbeddingProviderOptions } from '../llm-providers/provider';
+import { LLMProvider, LLMProviderOptions, EmbeddingProvider, EmbeddingProviderOptions, ReasoningOptions } from '../llm-providers/provider';
 import PluginAIServer from '../plugin';
 import { ToolManager } from './tool-manager';
 export type LLMProviderMeta = {
@@ -25,6 +25,7 @@ export type LLMModelOptions = {
     llmService: string;
     model: string;
     webSearch?: boolean;
+    reasoning?: ReasoningOptions;
 };
 export type EnabledLLMModel = {
     label: string;

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

@@ -123,7 +123,7 @@ class AIManager {
     return (0, import_recommended_models.getRecommendedModels)(provider);
   }
   async getLLMService(options) {
-    const { llmService, model, webSearch } = options ?? {};
+    const { llmService, model, webSearch, reasoning } = options ?? {};
     if (!llmService || !model) {
       throw new Error("LLM service not configured");
     }
@@ -134,6 +134,9 @@ class AIManager {
     if (webSearch === true) {
       modelOptions.builtIn = { webSearch: true };
     }
+    if (reasoning) {
+      modelOptions._reasoning = reasoning;
+    }
     const service = await this.plugin.db.getRepository("llmServices").findOne({
       filter: {
         name: llmService

package/dist/server/manager/work-context-handler.js

@@ -41,6 +41,7 @@ __export(work_context_handler_exports, {
 module.exports = __toCommonJS(work_context_handler_exports);
 var import_utils = require("@nocobase/utils");
 var import_lodash = __toESM(require("lodash"));
+const MODEL_EXCLUDED_FIELDS = /* @__PURE__ */ new Set(["frontendTools"]);
 const createWorkContextHandler = (plugin) => new WorkContextHandlerImpl(plugin);
 class WorkContextHandlerImpl {
   constructor(plugin) {
@@ -82,11 +83,17 @@ class WorkContextHandlerImpl {
     if (!contextItem) {
       return "";
     }
-    const { resolve } = this.strategies.get(contextItem.type) ?? {};
+    const modelContext = this.excludeInternalFields(contextItem);
+    const { resolve } = this.strategies.get(modelContext.type) ?? {};
     if (resolve) {
-      return await resolve(ctx, contextItem);
+      return await resolve(ctx, modelContext);
     }
-    return await ((_b = (_a = this.defaultStrategy).resolve) == null ? void 0 : _b.call(_a, ctx, contextItem));
+    return await ((_b = (_a = this.defaultStrategy).resolve) == null ? void 0 : _b.call(_a, ctx, modelContext));
+  }
+  excludeInternalFields(contextItem) {
+    return Object.fromEntries(
+      Object.entries(contextItem).filter(([field]) => !MODEL_EXCLUDED_FIELDS.has(field))
+    );
   }
 }
 const Stringify = (_plugin) => async (_ctx, contextItem) => {

package/dist/server/plugin.d.ts

@@ -62,6 +62,7 @@ export declare class PluginAIServer extends Plugin {
     get repositories(): {
         aiContextDatasources: import("@nocobase/database").Repository<any, any>;
     };
+    private registerAIFileAccessAuthorizer;
     get fileManager(): PluginFileManagerServer;
     private repository;
 }

package/dist/server/plugin.js

@@ -56,6 +56,7 @@ var import_ai_employees_manager = require("./ai-employees/ai-employees-manager")
 var import_ai_conversations = require("./ai-employees/ai-conversations");
 var import_snowflake = __toESM(require("./snowflake"));
 var aiEmployeeActions = __toESM(require("./resource/aiEmployees"));
+var llmServiceActions = __toESM(require("./resource/llmServices"));
 var import_google_genai = require("./llm-providers/google-genai");
 var import_ai_employee = require("./workflow/triggers/ai-employee");
 var import_tools = require("./tools");
@@ -169,6 +170,7 @@ class PluginAIServer extends import_server.Plugin {
     this.defineResources();
     this.registerMcpClientEvents();
     this.setPermissions();
+    this.registerAIFileAccessAuthorizer();
     this.registerWorkflow();
     this.registerWorkContextResolveStrategy();
     (0, import_employee.registerAIEmployeeTaskNotification)(this);
@@ -235,6 +237,9 @@ class PluginAIServer extends import_server.Plugin {
     Object.entries(aiEmployeeActions).forEach(([name, action]) => {
       this.app.resourceManager.registerActionHandler(`aiEmployees:${name}`, action);
     });
+    Object.entries(llmServiceActions).forEach(([name, action]) => {
+      this.app.resourceManager.registerActionHandler(`llmServices:${name}`, action);
+    });
   }
   registerMcpClientEvents() {
     this.db.on("aiMcpClients.afterCreate", (model, { transaction } = {}) => {
@@ -370,6 +375,26 @@ class PluginAIServer extends import_server.Plugin {
       aiContextDatasources: this.repository("aiContextDatasources")
     };
   }
+  registerAIFileAccessAuthorizer() {
+    this.fileManager.registerFileAccessAuthorizer({
+      name: "ai-files",
+      authorize: async (ctx, params) => {
+        var _a;
+        const currentUserId = (_a = ctx.state.currentUser) == null ? void 0 : _a.id;
+        if (params.dataSourceKey !== "main" || params.collectionName !== "aiFiles" || !currentUserId) {
+          return false;
+        }
+        const file = await ctx.db.getRepository("aiFiles").findOne({
+          filter: {
+            id: params.id,
+            createdById: currentUserId
+          },
+          fields: ["id"]
+        });
+        return Boolean(file);
+      }
+    });
+  }
   get fileManager() {
     return this.app.pm.get("file-manager");
   }

package/dist/server/resource/aiConversations.d.ts

@@ -7,6 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Context, Next } from '@nocobase/actions';
+import { Model } from '@nocobase/database';
+export declare function isAIEmployeeEnabled(employee: Model | null | undefined): boolean;
 declare function loginInCheck(ctx: Context, next: Next): Promise<never>;
 declare const _default: {
     name: string;