@nocobase/plugin-ai 2.4.0-alpha.3 → 2.4.0-alpha.4

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/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.4.0-alpha.3",
+  "version": "2.4.0-alpha.4",
   "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": "746e2e042c12df2cb03877361ea9f2a8797a1921"
+  "gitHead": "527910882037ce1558ee6b0ef748208b8d6996bb"
 }