@nocobase/plugin-ai 2.3.0-beta.6 → 2.3.0-beta.8

package/dist/server/ai-employees/middleware/tool-result-integrity.js

@@ -0,0 +1,211 @@
+/**
+ * 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 tool_result_integrity_exports = {};
+__export(tool_result_integrity_exports, {
+  isToolCallHistoryValid: () => isToolCallHistoryValid,
+  normalizeToolCallHistory: () => normalizeToolCallHistory,
+  toolResultIntegrityMiddleware: () => toolResultIntegrityMiddleware
+});
+module.exports = __toCommonJS(tool_result_integrity_exports);
+var import_messages = require("@langchain/core/messages");
+var import_langchain = require("langchain");
+const SYNTHETIC_TOOL_RESULT_ERROR = "Tool execution was interrupted before a result was recorded.";
+const getValidToolCalls = (message) => (message.tool_calls ?? []).filter((toolCall) => typeof toolCall.id === "string" && toolCall.id.length > 0);
+const isToolCallHistoryValid = (messages) => {
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (import_messages.ToolMessage.isInstance(message)) {
+      return false;
+    }
+    if (!import_messages.AIMessage.isInstance(message)) {
+      continue;
+    }
+    const toolCalls = getValidToolCalls(message);
+    if (!toolCalls.length) {
+      continue;
+    }
+    const expectedToolCallIds = new Set(toolCalls.map((toolCall) => toolCall.id));
+    const seenToolResultIds = /* @__PURE__ */ new Set();
+    for (let resultIndex = 0; resultIndex < toolCalls.length; resultIndex++) {
+      index++;
+      if (index >= messages.length) {
+        return false;
+      }
+      const result = messages[index];
+      if (!import_messages.ToolMessage.isInstance(result) || !expectedToolCallIds.has(result.tool_call_id) || seenToolResultIds.has(result.tool_call_id)) {
+        return false;
+      }
+      seenToolResultIds.add(result.tool_call_id);
+    }
+  }
+  return true;
+};
+const serializeToolResultContent = (content) => {
+  if (typeof content === "string") {
+    return content;
+  }
+  return JSON.stringify(content ?? null);
+};
+const createSyntheticToolResult = (sessionId, toolCall) => new import_messages.ToolMessage({
+  id: `synthetic-tool-result:${sessionId}:${toolCall.id}`,
+  tool_call_id: toolCall.id,
+  name: toolCall.name,
+  status: "error",
+  content: JSON.stringify({
+    status: "error",
+    error: SYNTHETIC_TOOL_RESULT_ERROR
+  })
+});
+const createRestoredToolResult = (sessionId, toolCall, persisted) => {
+  if (!persisted || persisted.invokeStatus !== "confirmed" && persisted.invokeStatus !== "done") {
+    return;
+  }
+  try {
+    return new import_messages.ToolMessage({
+      id: `restored-tool-result:${sessionId}:${toolCall.id}`,
+      tool_call_id: toolCall.id,
+      name: toolCall.name,
+      status: persisted.status === "error" ? "error" : "success",
+      content: serializeToolResultContent(persisted.content)
+    });
+  } catch {
+    return;
+  }
+};
+const countMisplacedResults = (messages) => {
+  let misplacedResultCount = 0;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index];
+    if (!import_messages.AIMessage.isInstance(message)) {
+      continue;
+    }
+    const toolCalls = getValidToolCalls(message);
+    if (!toolCalls.length) {
+      continue;
+    }
+    const expectedToolCallIds = new Set(toolCalls.map((toolCall) => toolCall.id));
+    const contiguousResultIds = /* @__PURE__ */ new Set();
+    for (let offset = 1; offset <= toolCalls.length; offset++) {
+      const result = messages[index + offset];
+      if (!import_messages.ToolMessage.isInstance(result)) {
+        break;
+      }
+      if (expectedToolCallIds.has(result.tool_call_id)) {
+        contiguousResultIds.add(result.tool_call_id);
+      }
+    }
+    misplacedResultCount += expectedToolCallIds.size - contiguousResultIds.size;
+  }
+  return misplacedResultCount;
+};
+const normalizeToolCallHistory = async (messages, options) => {
+  var _a;
+  const toolResultsByCallId = /* @__PURE__ */ new Map();
+  const referencedToolCallIds = /* @__PURE__ */ new Set();
+  let toolCallCount = 0;
+  let toolResultCount = 0;
+  for (const message of messages) {
+    if (import_messages.AIMessage.isInstance(message)) {
+      for (const toolCall of getValidToolCalls(message)) {
+        toolCallCount++;
+        referencedToolCallIds.add(toolCall.id);
+      }
+    } else if (import_messages.ToolMessage.isInstance(message)) {
+      toolResultCount++;
+      if (message.tool_call_id) {
+        const results = toolResultsByCallId.get(message.tool_call_id) ?? [];
+        results.push(message);
+        toolResultsByCallId.set(message.tool_call_id, results);
+      }
+    }
+  }
+  const missingToolCallIds = Array.from(referencedToolCallIds).filter((id) => !toolResultsByCallId.has(id));
+  const persistedResults = missingToolCallIds.length ? await options.loadToolResults(missingToolCallIds) : /* @__PURE__ */ new Map();
+  const normalized = [];
+  const nextToolResultIndexByCallId = /* @__PURE__ */ new Map();
+  let restoredResultCount = 0;
+  let syntheticResultCount = 0;
+  let consumedExistingResultCount = 0;
+  for (const message of messages) {
+    if (import_messages.ToolMessage.isInstance(message)) {
+      continue;
+    }
+    normalized.push(message);
+    if (!import_messages.AIMessage.isInstance(message)) {
+      continue;
+    }
+    for (const toolCall of getValidToolCalls(message)) {
+      const existingResults = toolResultsByCallId.get(toolCall.id);
+      const existingResultIndex = nextToolResultIndexByCallId.get(toolCall.id) ?? 0;
+      const existingResult = existingResults == null ? void 0 : existingResults[existingResultIndex];
+      if (existingResult) {
+        nextToolResultIndexByCallId.set(toolCall.id, existingResultIndex + 1);
+        normalized.push(existingResult);
+        consumedExistingResultCount++;
+        continue;
+      }
+      const restoredResult = createRestoredToolResult(options.sessionId, toolCall, persistedResults.get(toolCall.id));
+      if (restoredResult) {
+        normalized.push(restoredResult);
+        restoredResultCount++;
+        continue;
+      }
+      normalized.push(createSyntheticToolResult(options.sessionId, toolCall));
+      syntheticResultCount++;
+    }
+  }
+  const stats = {
+    messageCount: messages.length,
+    toolCallCount,
+    missingResultCount: missingToolCallIds.length,
+    misplacedResultCount: countMisplacedResults(messages),
+    orphanResultCount: toolResultCount - consumedExistingResultCount,
+    restoredResultCount,
+    syntheticResultCount
+  };
+  (_a = options.logger) == null ? void 0 : _a.warn("Normalize invalid tool call history before model call", {
+    sessionId: options.sessionId,
+    ...stats
+  });
+  return normalized;
+};
+const toolResultIntegrityMiddleware = (options) => (0, import_langchain.createMiddleware)({
+  name: "ToolResultIntegrityMiddleware",
+  wrapModelCall: async (request, handler) => {
+    if (isToolCallHistoryValid(request.messages)) {
+      return handler(request);
+    }
+    request.messages = await normalizeToolCallHistory(request.messages, options);
+    return handler(request);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isToolCallHistoryValid,
+  normalizeToolCallHistory,
+  toolResultIntegrityMiddleware
+});

package/dist/server/resource/aiEmployees.js

@@ -88,10 +88,30 @@ const setDefaultKnowledgeBaseRetrievalStrategy = (ctx) => {
     values.knowledgeBase = (0, import_ai_knowledge_base.withDefaultKnowledgeBaseRetrievalStrategy)(values.knowledgeBase);
   }
 };
+const readEmployeeValue = (employee, key) => typeof (employee == null ? void 0 : employee.get) === "function" ? employee.get(key) : employee == null ? void 0 : employee[key];
+const validateKnowledgeBasePrompt = (ctx, employee) => {
+  const values = ctx.action.params.values;
+  if (!isRecord(values)) {
+    return;
+  }
+  const enableKnowledgeBase = typeof values.enableKnowledgeBase === "boolean" ? values.enableKnowledgeBase : readEmployeeValue(employee, "enableKnowledgeBase") === true;
+  const knowledgeBasePrompt = "knowledgeBasePrompt" in values ? values.knowledgeBasePrompt : readEmployeeValue(employee, "knowledgeBasePrompt");
+  if (enableKnowledgeBase && !(0, import_ai_employee_validation.hasKnowledgeBaseDataPlaceholder)(knowledgeBasePrompt)) {
+    ctx.throw(400, {
+      code: import_error_codes.AI_EMPLOYEE_KNOWLEDGE_BASE_PROMPT_INVALID,
+      message: ctx.t("The Knowledge Base Prompt must include {knowledgeBaseData} before you can save it."),
+      data: { field: "knowledgeBasePrompt" }
+    });
+  }
+};
+const hasKnowledgeBaseConfigurationChanges = (values) => isRecord(values) && ["enableKnowledgeBase", "knowledgeBase", "knowledgeBasePrompt"].some(
+  (key) => Object.prototype.hasOwnProperty.call(values, key)
+);
 const create = async (ctx, next) => {
   var _a;
   validateAndNormalizeProfileValues(ctx);
   setDefaultKnowledgeBaseRetrievalStrategy(ctx);
+  validateKnowledgeBasePrompt(ctx);
   const username = (_a = ctx.action.params.values) == null ? void 0 : _a.username;
   if (typeof username === "string") {
     const existingEmployee = await ctx.db.getRepository("aiEmployees").findOne({
@@ -112,6 +132,12 @@ const create = async (ctx, next) => {
 };
 const update = async (ctx, next) => {
   validateAndNormalizeProfileValues(ctx);
+  if (hasKnowledgeBaseConfigurationChanges(ctx.action.params.values)) {
+    const employee = await ctx.db.getRepository("aiEmployees").findOne({
+      filterByTk: ctx.action.params.filterByTk
+    });
+    validateKnowledgeBasePrompt(ctx, employee);
+  }
   await import_actions.default.update(ctx, next);
 };
 const list = async (ctx, next) => {

package/dist/server/workflow/nodes/employee/files.d.ts

@@ -11,7 +11,7 @@ import { Plugin } from '@nocobase/server';
 export declare abstract class Files {
     static resolvers(plugin: Plugin, attachmentPart: {
         attachments?: unknown[];
-    }): {
+    }, fileUrlOrigin?: string): {
         resolveAttachments: (files: AIEmployeeInstructionFiles[]) => Promise<void>;
         resolveFileIds: (files: AIEmployeeInstructionFiles[]) => Promise<void>;
         resolveUrls: (files: AIEmployeeInstructionFiles[]) => Promise<void>;

package/dist/server/workflow/nodes/employee/files.js

@@ -44,6 +44,7 @@ var import_node_os = __toESM(require("node:os"));
 var import_node_path = __toESM(require("node:path"));
 var import_lodash = __toESM(require("lodash"));
 var import_axios = __toESM(require("axios"));
+var import_plugin_file_manager = require("@nocobase/plugin-file-manager");
 var import_utils = require("../../utils");
 var import_attachments = require("../../../attachments");
 function appendSource(record, source) {
@@ -55,8 +56,45 @@ function appendSource(record, source) {
     source
   };
 }
+function toFilePlainObject(record) {
+  const value = typeof record.toJSON === "function" ? record.toJSON() : record;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid file record");
+  }
+  return value;
+}
+async function resolveInternalFileURL(plugin, url, origin) {
+  var _a;
+  const reference = (0, import_plugin_file_manager.parsePermanentFileReference)(url, origin);
+  if (!reference) {
+    return null;
+  }
+  if (reference.appName !== (plugin.app.name || "main")) {
+    throw new Error("File not found");
+  }
+  const dataSource = plugin.app.dataSourceManager.get(reference.dataSourceKey);
+  const collection = dataSource == null ? void 0 : dataSource.collectionManager.getCollection(reference.collectionName);
+  if (!dataSource || !collection || collection.name !== "attachments" && ((_a = collection.options) == null ? void 0 : _a.template) !== "file") {
+    throw new Error("File not found");
+  }
+  const record = await dataSource.collectionManager.getRepository(collection.name).findOne({
+    filter: { id: reference.id }
+  });
+  if (!record) {
+    throw new Error("File not found");
+  }
+  const file = toFilePlainObject(record);
+  if (file.storageId == null || reference.extname && reference.extname !== file.extname) {
+    throw new Error("File not found");
+  }
+  return appendSource(file, {
+    dataSourceKey: reference.dataSourceKey,
+    collectionName: collection.name,
+    trustworthy: true
+  });
+}
 class Files {
-  static resolvers(plugin, attachmentPart) {
+  static resolvers(plugin, attachmentPart, fileUrlOrigin) {
     const resolveAttachments = async (files) => {
       const attachments = files.filter((it) => it.type === "attachments").flatMap((it) => import_lodash.default.isArray(it.value) ? it.value : [it.value]).map(
         (attachment) => appendSource(attachment, {
@@ -114,6 +152,15 @@ class Files {
         const storageName = (_a = settings == null ? void 0 : settings.options) == null ? void 0 : _a.storage;
         const attachments = await Promise.all(
           urls.map(async (url) => {
+            const internalFile = await resolveInternalFileURL(plugin, url, fileUrlOrigin);
+            if (internalFile) {
+              return internalFile;
+            }
+            try {
+              new URL(url);
+            } catch (error) {
+              throw new Error(`File URL must be an absolute URL or a NocoBase permanent file URL: ${url}`);
+            }
             const response = await import_axios.default.get(url, {
               responseType: "arraybuffer"
             });

package/dist/server/workflow/nodes/employee/index.js

@@ -59,7 +59,8 @@ class AIEmployeeInstruction extends import_plugin_workflow.Instruction {
       model,
       requiresApproval = import_constants.REQUIRES_APPROVAL.NO_REQUIRED,
       userId,
-      files
+      files,
+      fileUrlOrigin
     } = processor.getParsedValue(node.config, node.id);
     const toolName = import_ai.SYSTEM_TOOLS.WORK_FLOW_TASK_OUTPUT;
     const workflowSystemPrompt = `
@@ -153,7 +154,11 @@ ${typeof message.system === "object" ? JSON.stringify(message.system) : message.
         });
         const attachmentPart = {};
         if (files == null ? void 0 : files.length) {
-          const { resolveAttachments, resolveFileIds, resolveUrls } = import_files.Files.resolvers(this.workflow, attachmentPart);
+          const { resolveAttachments, resolveFileIds, resolveUrls } = import_files.Files.resolvers(
+            this.workflow,
+            attachmentPart,
+            fileUrlOrigin
+          );
           await resolveAttachments(files);
           await resolveFileIds(files);
           await resolveUrls(files);

package/dist/server/workflow/nodes/employee/types.d.ts

@@ -29,6 +29,7 @@ export type AIEmployeeInstructionConfig = {
     assignees?: string[];
     userId: string;
     files: AIEmployeeInstructionFiles[];
+    fileUrlOrigin?: string;
 };
 export type AIEmployeeInstructionFiles = {
     type: 'attachments' | 'file_id' | 'file_url';

package/package.json

@@ -6,7 +6,7 @@
   "description": "Create AI employees with diverse skills to collaborate with humans, build systems, and handle business operations.",
   "description.ru-RU": "Поддержка интеграции с AI-сервисами: предоставляются AI-узлы для рабочих процессов, расширяя возможности бизнес-обработки.",
   "description.zh-CN": "创建各种技能的 AI 员工，与人类协同，搭建系统，处理业务。",
-  "version": "2.3.0-beta.6",
+  "version": "2.3.0-beta.8",
   "main": "dist/server/index.js",
   "homepage": "https://docs.nocobase.com/handbook/action-ai",
   "homepage.ru-RU": "https://docs-ru.nocobase.com/handbook/action-ai",
@@ -66,5 +66,5 @@
   "keywords": [
     "AI"
   ],
-  "gitHead": "45b23791f5245d1417047b122d1a76764aaf5473"
+  "gitHead": "5d458884528593b2d3142a6a33de93bf0ad96543"
 }