plugin-agent-orchestrator 1.0.28 → 1.0.32

package/dist/server/collections/agent-memory-contexts.js

@@ -0,0 +1,125 @@
+/**
+ * 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 agent_memory_contexts_exports = {};
+__export(agent_memory_contexts_exports, {
+  default: () => agent_memory_contexts_default
+});
+module.exports = __toCommonJS(agent_memory_contexts_exports);
+var import_database = require("@nocobase/database");
+var agent_memory_contexts_default = (0, import_database.defineCollection)({
+  name: "agentMemoryContexts",
+  title: "Agent Memory Contexts",
+  fields: [
+    {
+      name: "id",
+      type: "bigInt",
+      autoIncrement: true,
+      primaryKey: true
+    },
+    {
+      name: "scope",
+      type: "string",
+      length: 30,
+      allowNull: false,
+      comment: "public, user, or agent_user"
+    },
+    {
+      name: "contextKey",
+      type: "string",
+      length: 300,
+      allowNull: false,
+      comment: "Normalized unique key: scope:userId:aiEmployeeUsername."
+    },
+    {
+      name: "userId",
+      type: "bigInt",
+      comment: "Null for public agent knowledge; required for user/private scopes."
+    },
+    {
+      name: "user",
+      type: "belongsTo",
+      target: "users",
+      targetKey: "id",
+      foreignKey: "userId"
+    },
+    {
+      name: "aiEmployeeUsername",
+      type: "string",
+      length: 100,
+      comment: "Target AI employee username; null/empty means shared within the scope."
+    },
+    {
+      name: "contentMd",
+      type: "text",
+      comment: "Markdown facts, preferences, or operating notes for the agent context."
+    },
+    {
+      name: "graphMd",
+      type: "text",
+      comment: "Markdown graph or relationship notes for the agent context."
+    },
+    {
+      name: "enabled",
+      type: "boolean",
+      defaultValue: true
+    },
+    {
+      name: "metadata",
+      type: "json",
+      defaultValue: {}
+    },
+    {
+      name: "createdAt",
+      type: "date"
+    },
+    {
+      name: "updatedAt",
+      type: "date"
+    }
+  ],
+  indexes: [
+    {
+      unique: true,
+      fields: ["contextKey"]
+    },
+    {
+      fields: ["scope", "userId", "aiEmployeeUsername"]
+    },
+    {
+      fields: ["scope"]
+    },
+    {
+      fields: ["userId"]
+    },
+    {
+      fields: ["aiEmployeeUsername"]
+    },
+    {
+      fields: ["enabled"]
+    }
+  ]
+});

package/dist/server/collections/orchestrator-logs.js

@@ -55,7 +55,7 @@ var orchestrator_logs_default = (0, import_database.defineCollection)({
     {
       name: "toolName",
       type: "string",
-      comment: "The tool name used for delegation (e.g., delegate_pm_to_sql_expert)"
+      comment: "Legacy delegation or native dispatch tool name"
     },
     {
       name: "context",
@@ -103,7 +103,7 @@ var orchestrator_logs_default = (0, import_database.defineCollection)({
       name: "messages",
       type: "json",
       defaultValue: [],
-      comment: "Serialized LangChain messages from the sub-agent run"
+      comment: "Serialized message snapshots from the sub-agent run"
     },
     {
       name: "userId",

package/dist/server/migrations/20260425000000-add-interaction-schema.js

@@ -52,7 +52,9 @@ class AddInteractionSchemaMigration extends import_server.Migration {
             interface: "textarea"
           }
         });
-        this.app.logger.info("[skill-hub] Restored NocoBase metadata for preexisting column interactionSchema");
+        this.app.logger.info(
+          "[skill-hub] Restored NocoBase metadata for preexisting column interactionSchema"
+        );
       }
     } catch (error) {
       this.app.logger.error(`[skill-hub] Failed to check interactionSchema field: ${error.message}`);

package/dist/server/migrations/20260427000000-change-packages-to-text.js

@@ -45,7 +45,9 @@ class ChangePackagesToTextMigration extends import_server.Migration {
         if (tableDesc[col]) {
           const dialect = this.db.sequelize.getDialect();
           if (dialect === "postgres") {
-            await this.db.sequelize.query(`ALTER TABLE "${tableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`);
+            await this.db.sequelize.query(
+              `ALTER TABLE "${tableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`
+            );
           } else {
             await queryInterface.changeColumn(tableName, col, {
               type: "TEXT"

package/dist/server/migrations/20260427000001-change-other-json-to-text.js

@@ -44,7 +44,9 @@ class ChangeOtherJsonToTextMigration extends import_server.Migration {
         for (const col of columns) {
           if (tableDesc[col]) {
             if (dialect === "postgres") {
-              await this.db.sequelize.query(`ALTER TABLE "${workerTableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`);
+              await this.db.sequelize.query(
+                `ALTER TABLE "${workerTableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`
+              );
             } else {
               await queryInterface.changeColumn(workerTableName, col, { type: "TEXT" });
             }
@@ -64,7 +66,9 @@ class ChangeOtherJsonToTextMigration extends import_server.Migration {
         const col = "outputFiles";
         if (tableDesc[col]) {
           if (dialect === "postgres") {
-            await this.db.sequelize.query(`ALTER TABLE "${execTableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`);
+            await this.db.sequelize.query(
+              `ALTER TABLE "${execTableName}" ALTER COLUMN "${col}" TYPE text USING "${col}"::text;`
+            );
           } else {
             await queryInterface.changeColumn(execTableName, col, { type: "TEXT" });
           }

package/dist/server/migrations/20260524001000-add-plan-approval-and-harness-profiles.js

@@ -108,38 +108,40 @@ class AddPlanApprovalAndHarnessProfiles extends import_server.Migration {
       {
         tag: "default",
         title: "Default",
-        description: "Balanced profile for normal multi-agent work.",
+        description: "Default native observer and memory policy for normal AI employee work.",
         settings: {
-          requirePlanApproval: true,
-          allowSubAgents: true,
-          allowToolCalls: true,
-          maxParallelSubAgents: 3,
-          maxControllerSteps: 100
+          nativeObserverEnabled: true,
+          memoryInjectionEnabled: true,
+          memoryScopes: ["public", "user", "agent_user"],
+          knowledgeScopes: ["public", "private"],
+          maxMemoryContextChars: 6e3,
+          tracingRetentionDays: 30
         }
       },
       {
         tag: "safe",
         title: "Safe",
-        description: "Strict approval-first profile for higher-risk work.",
+        description: "Conservative native observer policy with private context enabled only for matching user/agent pairs.",
         settings: {
-          requirePlanApproval: true,
-          allowSubAgents: true,
-          allowToolCalls: true,
-          maxParallelSubAgents: 1,
-          maxControllerSteps: 50,
-          requireVerification: true
+          nativeObserverEnabled: true,
+          memoryInjectionEnabled: true,
+          memoryScopes: ["public", "user", "agent_user"],
+          knowledgeScopes: ["public", "private"],
+          maxMemoryContextChars: 4e3,
+          tracingRetentionDays: 14
         }
       },
       {
         tag: "file-heavy",
         title: "File Heavy",
-        description: "Profile for tasks that inspect or transform many attachments/files.",
+        description: "Native observer policy for agents that need more context while working with files and artifacts.",
         settings: {
-          requirePlanApproval: true,
-          allowSubAgents: true,
-          allowToolCalls: true,
-          maxParallelSubAgents: 2,
-          maxControllerSteps: 120,
+          nativeObserverEnabled: true,
+          memoryInjectionEnabled: true,
+          memoryScopes: ["public", "user", "agent_user"],
+          knowledgeScopes: ["public", "private"],
+          maxMemoryContextChars: 8e3,
+          tracingRetentionDays: 30,
           preferFileTools: true
         }
       }

package/dist/server/migrations/20260621000000-native-policy-profile-defaults.js

@@ -0,0 +1,193 @@
+/**
+ * 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 native_policy_profile_defaults_exports = {};
+__export(native_policy_profile_defaults_exports, {
+  default: () => NativePolicyProfileDefaults
+});
+module.exports = __toCommonJS(native_policy_profile_defaults_exports);
+var import_database = require("@nocobase/database");
+var import_server = require("@nocobase/server");
+var import_skill_settings = require("../utils/skill-settings");
+const nativePolicyProfiles = [
+  {
+    tag: "default",
+    title: "Default",
+    description: "Default native observer and memory policy for normal AI employee work.",
+    settings: {
+      nativeObserverEnabled: true,
+      memoryInjectionEnabled: true,
+      memoryScopes: ["public", "user", "agent_user"],
+      knowledgeScopes: ["public", "private"],
+      maxMemoryContextChars: 6e3,
+      tracingRetentionDays: 30
+    }
+  },
+  {
+    tag: "safe",
+    title: "Safe",
+    description: "Conservative native observer policy with private context enabled only for matching user/agent pairs.",
+    settings: {
+      nativeObserverEnabled: true,
+      memoryInjectionEnabled: true,
+      memoryScopes: ["public", "user", "agent_user"],
+      knowledgeScopes: ["public", "private"],
+      maxMemoryContextChars: 4e3,
+      tracingRetentionDays: 14
+    }
+  },
+  {
+    tag: "file-heavy",
+    title: "File Heavy",
+    description: "Native observer policy for agents that need more context while working with files and artifacts.",
+    settings: {
+      nativeObserverEnabled: true,
+      memoryInjectionEnabled: true,
+      memoryScopes: ["public", "user", "agent_user"],
+      knowledgeScopes: ["public", "private"],
+      maxMemoryContextChars: 8e3,
+      tracingRetentionDays: 30,
+      preferFileTools: true
+    }
+  }
+];
+function readModelValue(record, key) {
+  const model = record;
+  return typeof (model == null ? void 0 : model.get) === "function" ? model.get(key) : model == null ? void 0 : model[key];
+}
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function dropRetiredPolicyKeys(settings) {
+  const retired = /* @__PURE__ */ new Set([
+    "requirePlanApproval",
+    "allowSubAgents",
+    "allowToolCalls",
+    "maxParallelSubAgents",
+    "maxControllerSteps",
+    "requireVerification"
+  ]);
+  return Object.fromEntries(Object.entries(settings).filter(([key]) => !retired.has(key)));
+}
+function normalizeOptionalString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function buildContextKey(record) {
+  const scope = normalizeOptionalString(record.scope);
+  const userPart = scope === "public" ? "public" : String(record.userId || "");
+  const agentPart = normalizeOptionalString(record.aiEmployeeUsername) || "*";
+  return `${scope}:${userPart}:${agentPart}`;
+}
+class NativePolicyProfileDefaults extends import_server.Migration {
+  on = "afterLoad";
+  appVersion = ">=0.1.0";
+  async up() {
+    await this.ensureNativePolicyProfiles();
+    await this.ensureAgentMemoryContextKeys();
+    await this.normalizeAIEmployeeToolBindings();
+  }
+  async ensureNativePolicyProfiles() {
+    const repo = this.db.getRepository(
+      "agentHarnessProfiles"
+    );
+    if (!repo) return;
+    for (const profile of nativePolicyProfiles) {
+      const existing = await repo.findOne({ filter: { tag: profile.tag } });
+      if (!existing) {
+        await repo.create({
+          values: {
+            ...profile,
+            enabled: true,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        });
+        continue;
+      }
+      const currentSettings = asObject(readModelValue(existing, "settings"));
+      const nextSettings = {
+        ...profile.settings,
+        ...dropRetiredPolicyKeys(currentSettings)
+      };
+      await existing.update({
+        settings: nextSettings,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  async ensureAgentMemoryContextKeys() {
+    var _a;
+    const db = this.db;
+    const queryInterface = db.sequelize.getQueryInterface();
+    const tableName = `${db.options.tablePrefix || ""}agentMemoryContexts`;
+    const tableExists = await queryInterface.describeTable(tableName).then(() => true).catch(() => false);
+    if (!tableExists) return;
+    const tableDesc = await queryInterface.describeTable(tableName);
+    if (!tableDesc.contextKey) {
+      await queryInterface.addColumn(tableName, "contextKey", {
+        type: import_database.DataTypes.STRING(300),
+        allowNull: true
+      });
+    }
+    const repo = db.getRepository("agentMemoryContexts");
+    const rows = await repo.find({});
+    for (const row of rows) {
+      const data = ((_a = row.toJSON) == null ? void 0 : _a.call(row)) || row;
+      if (!normalizeOptionalString(data.scope)) continue;
+      const contextKey = normalizeOptionalString(data.contextKey) || buildContextKey(data);
+      if (!contextKey) continue;
+      if (contextKey !== data.contextKey) {
+        await row.update({ contextKey });
+      }
+    }
+    await queryInterface.changeColumn(tableName, "contextKey", {
+      type: import_database.DataTypes.STRING(300),
+      allowNull: false
+    }).catch(() => {
+    });
+    await queryInterface.addIndex(tableName, ["contextKey"], {
+      unique: true,
+      name: `${tableName}_contextKey_unique`
+    }).catch(() => {
+    });
+  }
+  async normalizeAIEmployeeToolBindings() {
+    var _a;
+    const repo = this.db.getRepository("aiEmployees");
+    if (!repo) return;
+    const rows = await repo.find({});
+    for (const row of rows) {
+      const skillSettings = ((_a = row.get) == null ? void 0 : _a.call(row, "skillSettings")) ?? row.skillSettings;
+      const normalized = (0, import_skill_settings.normalizeAIEmployeeSkillSettings)(skillSettings);
+      if (!normalized.changed) continue;
+      await row.update({
+        skillSettings: normalized.skillSettings
+      });
+    }
+  }
+  async down() {
+  }
+}