@axiom-lattice/core 2.1.95 → 2.1.97

package/dist/index.js

@@ -1538,11 +1538,13 @@ __export(index_exports, {
   AgentLatticeManager: () => AgentLatticeManager,
   AgentManager: () => AgentManager,
   AgentType: () => import_protocols.AgentType,
+  BUILTIN_PLUGINS: () => BUILTIN_PLUGINS,
   BUILTIN_SKILLS: () => BUILTIN_SKILLS,
   ChunkBuffer: () => ChunkBuffer,
   ChunkBufferLatticeManager: () => ChunkBufferLatticeManager,
   CollectionLatticeManager: () => CollectionLatticeManager,
   CompositeBackend: () => CompositeBackend,
+  ConnectionRegistry: () => ConnectionRegistry,
   ConsoleLoggerClient: () => ConsoleLoggerClient,
   CustomMetricsClient: () => CustomMetricsClient,
   CustomMiddlewareRegistry: () => CustomMiddlewareRegistry,
@@ -1592,6 +1594,7 @@ __export(index_exports, {
   MysqlDatabase: () => MysqlDatabase,
   PersonalAssistantConfig: () => PersonalAssistantConfig,
   PinoLoggerClient: () => PinoLoggerClient,
+  PluginRegistry: () => PluginRegistry,
   PostgresDatabase: () => PostgresDatabase,
   PrometheusClient: () => PrometheusClient,
   Protocols: () => Protocols,
@@ -1754,6 +1757,7 @@ __export(index_exports, {
   sandboxLatticeManager: () => sandboxLatticeManager,
   sanitizeToolCallId: () => sanitizeToolCallId,
   scheduleLatticeManager: () => scheduleLatticeManager,
+  serializePluginMeta: () => serializePluginMeta,
   setBindingRegistry: () => setBindingRegistry,
   setMenuRegistry: () => setMenuRegistry,
   skillLatticeManager: () => skillLatticeManager,
@@ -8836,6 +8840,31 @@ function createCodeEvalMiddleware(params = { vmIsolation: "agent" }) {
     tools: [createShellExecTool({ vmIsolation: params.vmIsolation })]
   });
 }
+var codeEvalPlugin = {
+  meta: {
+    type: "code_eval",
+    name: "Code Evaluation",
+    description: "Enables safe code execution",
+    configSchema: {
+      type: "object",
+      title: "Code Evaluation Configuration",
+      description: "Configure code execution sandbox settings",
+      required: ["vmIsolation"],
+      properties: {
+        vmIsolation: {
+          type: "string",
+          title: "VM Isolation",
+          description: "Controls how code execution is isolated between agents and projects",
+          enum: ["global", "agent", "project"],
+          default: "global",
+          widget: "segmented"
+        }
+      }
+    },
+    defaultConfig: { vmIsolation: "global" }
+  },
+  middleware: (cfg) => createCodeEvalMiddleware(cfg)
+};
 
 // src/middlewares/browserMiddleware.ts
 var import_langchain38 = require("langchain");
@@ -8871,6 +8900,31 @@ function createBrowserMiddleware(params = { vmIsolation: "agent" }) {
     tools
   });
 }
+var browserPlugin = {
+  meta: {
+    type: "browser",
+    name: "Browser",
+    description: "Provides browser automation capabilities",
+    configSchema: {
+      type: "object",
+      title: "Browser Configuration",
+      description: "Configure browser automation settings",
+      required: ["vmIsolation"],
+      properties: {
+        vmIsolation: {
+          type: "string",
+          title: "VM Isolation",
+          description: "Controls how browser instances are isolated between agents and projects",
+          enum: ["global", "agent", "project"],
+          default: "agent",
+          widget: "segmented"
+        }
+      }
+    },
+    defaultConfig: { headless: true, vmIsolation: "agent" }
+  },
+  middleware: (cfg) => createBrowserMiddleware(cfg)
+};
 
 // src/middlewares/sqlMiddleware.ts
 var import_langchain39 = require("langchain");
@@ -8897,6 +8951,36 @@ function createSqlMiddleware(params) {
     ]
   });
 }
+var sqlPlugin = {
+  meta: {
+    type: "sql",
+    name: "SQL Database",
+    description: "Provides SQL database query capabilities",
+    tools: [
+      { name: "list_tables_sql", description: "List all tables in a database" },
+      { name: "info_sql", description: "Get information about a database connection" },
+      { name: "query_checker_sql", description: "Check a SQL query for correctness" },
+      { name: "query_sql", description: "Execute a SQL query" }
+    ],
+    configSchema: {
+      type: "object",
+      title: "SQL Configuration",
+      description: "Configure database connection settings",
+      required: ["databaseKeys"],
+      properties: {
+        databaseKeys: {
+          type: "array",
+          title: "Select Databases",
+          description: "Select databases this agent can access (multi-select from registered databases)",
+          items: { type: "string" },
+          widget: "databaseSelect"
+        }
+      }
+    },
+    defaultConfig: { databaseKeys: [] }
+  },
+  middleware: (cfg) => createSqlMiddleware(cfg)
+};
 
 // src/middlewares/skillMiddleware.ts
 var import_langchain42 = require("langchain");
@@ -9597,12 +9681,23 @@ Response: \`{"message":"Hello, Simon!"}\`
 From your frontend JS, call the API using relative paths:
 
 \`\`\`js
-// main.js
+// main.js \u2014 GET
 const res = await fetch(\`./api/hello.js?name=\${name}\`);
 const data = await res.json();
 console.log(data.message);
+
+// POST with JSON body
+await fetch("./api/hello.js", {
+  method: "POST",
+  body: JSON.stringify({ title: "New Task", done: false }),
+});
+
+// PUT / DELETE \u2014 same pattern
+await fetch("./api/hello.js", { method: "PUT", body: JSON.stringify({ id: 1, title: "Updated" }) });
+await fetch("./api/hello.js", { method: "DELETE", body: JSON.stringify({ id: 1 }) });
 \`\`\`
 
+The API receives the body as \`API_BODY\` env var (raw string), method as \`API_METHOD\`.
 The \`<base>\` tag injected into HTML ensures relative URLs resolve through the share proxy.
 
 ## 4. File Upload
@@ -9889,6 +9984,39 @@ ${skillsPrompt}
     }
   });
 }
+var skillPlugin = {
+  meta: {
+    type: "skill",
+    name: "Skills",
+    description: "Provides skill loading capabilities for the agent",
+    configSchema: {
+      type: "object",
+      title: "Skills Configuration",
+      description: "Configure which skills this agent can use",
+      properties: {
+        readAll: {
+          type: "boolean",
+          title: "Read All Skills",
+          description: "When enabled, the agent will have access to all available skills automatically",
+          default: false,
+          widget: "switch"
+        },
+        skills: {
+          type: "array",
+          title: "Select Skills",
+          description: "Select which skills this agent can use (ignored if 'Read All Skills' is enabled)",
+          items: { type: "string" },
+          widget: "skillSelect"
+        }
+      }
+    },
+    defaultConfig: {
+      readAll: false,
+      skills: []
+    }
+  },
+  middleware: (cfg) => createSkillMiddleware(cfg)
+};
 
 // src/deep_agent_new/middleware/fs.ts
 var import_langchain43 = require("langchain");
@@ -10756,6 +10884,31 @@ ${systemPrompt}` : systemPrompt;
     }) : void 0
   });
 }
+var filesystemPlugin = {
+  meta: {
+    type: "filesystem",
+    name: "Filesystem",
+    description: "Provides file system operations for reading, writing, and managing files",
+    configSchema: {
+      type: "object",
+      title: "Filesystem Configuration",
+      description: "Configure filesystem isolation and access settings",
+      required: ["vmIsolation"],
+      properties: {
+        vmIsolation: {
+          type: "string",
+          title: "VM Isolation",
+          description: "Controls how filesystem access is isolated between agents and projects",
+          enum: ["global", "agent", "project"],
+          default: "global",
+          widget: "segmented"
+        }
+      }
+    },
+    defaultConfig: { vmIsolation: "global" }
+  },
+  middleware: (cfg) => createFilesystemMiddleware(cfg)
+};
 
 // src/middlewares/metricsMiddleware.ts
 var import_langchain44 = require("langchain");
@@ -10790,6 +10943,45 @@ function createMetricsMiddleware(params) {
     ]
   });
 }
+var metricsPlugin = {
+  meta: {
+    type: "metrics",
+    name: "Metrics",
+    description: "Provides metrics querying capabilities",
+    tools: [
+      { name: "list_datasources", description: "List all datasources from all configured servers" },
+      { name: "query_metrics_list", description: "Query available metrics from datasources" },
+      { name: "query_metric_definition", description: "Get detailed definition of a specific metric" },
+      { name: "query_semantic_metric_data", description: "Query actual metric data" },
+      { name: "query_tables_list", description: "Query available tables from datasources" },
+      { name: "query_table_definition", description: "Get detailed definition of a specific table" },
+      { name: "execute_sql_query", description: "Execute custom SQL queries" }
+    ],
+    configSchema: {
+      type: "object",
+      title: "Metrics Configuration",
+      description: "Configure metrics server access settings",
+      properties: {
+        connectAll: {
+          type: "boolean",
+          title: "Connect All Servers",
+          description: "When enabled, the agent will connect to all available metrics servers automatically",
+          default: false,
+          widget: "switch"
+        },
+        serverKeys: {
+          type: "array",
+          title: "Select Metrics Servers",
+          description: "Select metrics servers this agent can query (ignored if 'Connect All Servers' is enabled)",
+          items: { type: "string" },
+          widget: "metricsSelect"
+        }
+      }
+    },
+    defaultConfig: { connectAll: false, serverKeys: [] }
+  },
+  middleware: (cfg) => createMetricsMiddleware(cfg)
+};
 
 // src/middlewares/collectionMiddleware.ts
 var import_langchain55 = require("langchain");
@@ -11375,6 +11567,48 @@ function createCollectionMiddleware(params) {
     ]
   });
 }
+var collectionPlugin = {
+  meta: {
+    type: "collection",
+    name: "Collection",
+    description: "Provides vector search and CRUD access to knowledge collections",
+    tools: [
+      { name: "list_collections", description: "List all available collections" },
+      { name: "search_collection", description: "Search for documents in a collection" },
+      { name: "get_collection", description: "Get a specific collection's details" },
+      { name: "list_entries", description: "List entries in a collection" },
+      { name: "create_collection", description: "Create a new collection" },
+      { name: "update_collection", description: "Update an existing collection" },
+      { name: "delete_collection", description: "Delete a collection" },
+      { name: "add_entry", description: "Add an entry to a collection" },
+      { name: "update_entry", description: "Update an entry in a collection" },
+      { name: "delete_entry", description: "Delete an entry from a collection" }
+    ],
+    configSchema: {
+      type: "object",
+      title: "Collection Configuration",
+      description: "Configure collection access for this agent",
+      properties: {
+        connectAll: {
+          type: "boolean",
+          title: "Connect All Collections",
+          description: "When enabled, the agent will have access to all collections automatically",
+          default: false,
+          widget: "switch"
+        },
+        collectionKeys: {
+          type: "array",
+          title: "Select Collections",
+          description: "Select which collections this agent can access",
+          items: { type: "string" },
+          widget: "collectionSelect"
+        }
+      }
+    },
+    defaultConfig: { connectAll: false, collectionKeys: [] }
+  },
+  middleware: (cfg) => createCollectionMiddleware(cfg)
+};
 
 // src/middlewares/askUserClarifyMiddleware.ts
 var import_langchain57 = require("langchain");
@@ -11495,6 +11729,21 @@ function createAskUserClarifyMiddleware() {
     }
   });
 }
+var askUserClarifyPlugin = {
+  meta: {
+    type: "ask_user_to_clarify",
+    name: "Ask User To Clarify",
+    description: "Enables the agent to ask users clarifying questions",
+    configSchema: {
+      type: "object",
+      title: "Ask User To Clarify Configuration",
+      description: "Configure user clarification settings",
+      properties: {}
+    },
+    defaultConfig: {}
+  },
+  middleware: () => createAskUserClarifyMiddleware()
+};
 
 // src/middlewares/widgetMiddleware.ts
 var import_langchain60 = require("langchain");
@@ -12385,6 +12634,21 @@ function createWidgetMiddleware() {
     tools
   });
 }
+var widgetPlugin = {
+  meta: {
+    type: "widget",
+    name: "Widget",
+    description: "Enables the agent to render interactive HTML widgets",
+    configSchema: {
+      type: "object",
+      title: "Widget Configuration",
+      description: "Configure widget rendering capabilities (zero configuration required)",
+      properties: {}
+    },
+    defaultConfig: {}
+  },
+  middleware: () => createWidgetMiddleware()
+};
 
 // src/middlewares/modelSelectorMiddleware.ts
 var import_langchain61 = require("langchain");
@@ -13000,6 +13264,31 @@ ${startupSections.join("\n\n")}
     }
   });
 }
+var clawPlugin = {
+  meta: {
+    type: "claw",
+    name: "Memory",
+    description: "Injects and manages memory/bootstrap files in the runtime workspace",
+    configSchema: {
+      type: "object",
+      title: "Memory Configuration",
+      description: "Configure bootstrap file injection behavior",
+      properties: {
+        injectBootstrapFiles: {
+          type: "boolean",
+          title: "Inject Bootstrap Files",
+          description: "Automatically inject default bootstrap files into the workspace context",
+          default: true,
+          widget: "switch"
+        }
+      }
+    },
+    defaultConfig: {
+      injectBootstrapFiles: true
+    }
+  },
+  middleware: (cfg) => createClawMiddleware(cfg)
+};
 
 // src/middlewares/unknownToolHandlerMiddleware.ts
 var import_langchain63 = require("langchain");
@@ -13188,6 +13477,53 @@ ${currentSystemPrompt}` : dateContext;
     }
   });
 }
+var datePlugin = {
+  meta: {
+    type: "date",
+    name: "Current Date",
+    description: "Injects the current date into the agent system prompt",
+    configSchema: {
+      type: "object",
+      title: "Date Configuration",
+      description: "Configure timezone for the current date",
+      properties: {
+        timezone: {
+          type: "string",
+          title: "Timezone",
+          description: "Select timezone for displaying the current date",
+          default: "UTC",
+          enumLabels: {
+            "UTC": "UTC (Coordinated Universal Time)",
+            "America/New_York": "New York (EST/EDT)",
+            "America/Chicago": "Chicago (CST/CDT)",
+            "America/Denver": "Denver (MST/MDT)",
+            "America/Los_Angeles": "Los Angeles (PST/PDT)",
+            "America/Toronto": "Toronto (EST/EDT)",
+            "America/Sao_Paulo": "S\xE3o Paulo (BRT)",
+            "Europe/London": "London (GMT/BST)",
+            "Europe/Paris": "Paris (CET/CEST)",
+            "Europe/Berlin": "Berlin (CET/CEST)",
+            "Europe/Moscow": "Moscow (MSK)",
+            "Asia/Dubai": "Dubai (GST)",
+            "Asia/Kolkata": "Kolkata (IST)",
+            "Asia/Shanghai": "Shanghai (CST)",
+            "Asia/Hong_Kong": "Hong Kong (HKT)",
+            "Asia/Singapore": "Singapore (SGT)",
+            "Asia/Tokyo": "Tokyo (JST)",
+            "Asia/Seoul": "Seoul (KST)",
+            "Australia/Sydney": "Sydney (AEDT/AEST)",
+            "Pacific/Auckland": "Auckland (NZDT/NZST)"
+          },
+          widget: "select"
+        }
+      }
+    },
+    defaultConfig: {
+      timezone: "UTC"
+    }
+  },
+  middleware: (cfg) => createDateMiddleware(cfg)
+};
 
 // src/deep_agent_new/middleware/scheduler.ts
 var import_langchain66 = require("langchain");
@@ -16194,6 +16530,32 @@ function createSchedulerMiddleware(options = {}) {
     ]
   });
 }
+var schedulerPlugin = {
+  meta: {
+    type: "scheduler",
+    name: "Scheduler",
+    description: "Enables the agent to schedule future work",
+    configSchema: {
+      type: "object",
+      title: "Scheduler Configuration",
+      description: "Configure retry behavior for scheduled tasks",
+      properties: {
+        defaultMaxRetries: {
+          type: "integer",
+          title: "Default Max Retries",
+          description: "Default retry count for scheduled tasks created through the middleware",
+          default: 0,
+          minimum: 0,
+          widget: "numberInput"
+        }
+      }
+    },
+    defaultConfig: {
+      defaultMaxRetries: 0
+    }
+  },
+  middleware: (cfg) => createSchedulerMiddleware(cfg)
+};
 
 // src/middlewares/taskMiddleware.ts
 var import_langchain67 = require("langchain");
@@ -16326,28 +16688,128 @@ function createTaskMiddleware() {
     ]
   });
 }
+var taskPlugin = {
+  meta: {
+    type: "task",
+    name: "Task Management",
+    description: "Enables persistent task management with delegation and tracking",
+    configSchema: {
+      type: "object",
+      title: "Task Management Configuration",
+      description: "Zero-configuration task management",
+      properties: {}
+    },
+    defaultConfig: {}
+  },
+  middleware: () => createTaskMiddleware()
+};
+
+// src/plugin/metaSerializer.ts
+function tryExtractTools(plugin) {
+  if (!plugin.middleware) return [];
+  try {
+    const result = plugin.middleware({});
+    if (result instanceof Promise) return [];
+    const mw = result;
+    if (Array.isArray(mw.tools)) {
+      return mw.tools.map((t) => ({
+        name: t.name || "",
+        description: t.description || ""
+      }));
+    }
+  } catch {
+  }
+  return [];
+}
+function serializePluginMeta(plugin) {
+  const meta = {
+    type: plugin.meta.type,
+    name: plugin.meta.name,
+    description: plugin.meta.description,
+    version: plugin.meta.version,
+    source: plugin.meta.source,
+    icon: plugin.meta.icon,
+    tools: plugin.meta.tools ?? tryExtractTools(plugin),
+    configSchema: plugin.meta.configSchema,
+    defaultConfig: plugin.meta.defaultConfig
+  };
+  if (plugin.connection) {
+    meta.connectionSchema = {
+      fields: plugin.connection.fields,
+      hasTest: typeof plugin.connection.test === "function",
+      hasDiscover: typeof plugin.connection.discover === "function",
+      resourceLabel: plugin.connection.resourceLabel
+    };
+  }
+  return meta;
+}
+
+// src/plugin/PluginRegistry.ts
+var PluginRegistry = class {
+  /** Register a plugin (overwrites if type conflicts) */
+  static register(plugin) {
+    const key4 = plugin.meta.type;
+    if (this.plugins.has(key4)) {
+      console.warn(`[PluginRegistry] "${key4}" overwritten`);
+    }
+    this.plugins.set(key4, plugin);
+  }
+  /** Unregister */
+  static unregister(key4) {
+    return this.plugins.delete(key4);
+  }
+  /** Get plugin instance */
+  static get(key4) {
+    return this.plugins.get(key4);
+  }
+  /** Check if registered */
+  static has(key4) {
+    return this.plugins.has(key4);
+  }
+  /** List all registered plugin keys */
+  static list() {
+    return Array.from(this.plugins.keys());
+  }
+  /** Serialize all registered plugins to API-ready meta list */
+  static listMeta() {
+    return Array.from(this.plugins.values()).map(serializePluginMeta);
+  }
+};
+PluginRegistry.plugins = /* @__PURE__ */ new Map();
 
 // src/agent_lattice/builders/CustomMiddlewareRegistry.ts
 var CustomMiddlewareRegistry = class {
   /**
    * Register a custom middleware factory under the given key.
    *
-   * The key is referenced by `config.key` in the database middleware configuration.
-   * When an agent is built, the framework looks up this key and calls the factory
-   * with the remaining config fields.
+   * Supports three calling conventions:
+   * - register(key, factory) — legacy, wraps factory as anonymous Plugin
+   * - register(key, factory, meta) — legacy with optional meta
+   *
+   * For new code, prefer PluginRegistry.register(plugin).
    *
    * @param key - Unique identifier, referenced in database config as `config.key`
    * @param factory - Function that receives config (minus `key`) and returns an AgentMiddleware
-   *
-   * @example
-   * ```ts
-   * CustomMiddlewareRegistry.register("my-logger", (config) =>
-   *   createMiddleware({ name: "Logger", beforeAgent: async () => { ... } }),
-   * );
-   * ```
+   * @param deprecatedMeta - Optional metadata for API discovery
    */
-  static register(key4, factory) {
+  static register(key4, factory, deprecatedMeta) {
     this.factories.set(key4, factory);
+    const existing = PluginRegistry.get(key4);
+    if (existing) return;
+    const plugin = {
+      meta: {
+        type: key4,
+        name: deprecatedMeta?.name || key4,
+        description: deprecatedMeta?.description || "",
+        version: deprecatedMeta?.version,
+        source: deprecatedMeta?.source,
+        tools: deprecatedMeta?.tools,
+        configSchema: deprecatedMeta?.configSchema,
+        defaultConfig: deprecatedMeta?.defaultConfig
+      },
+      middleware: factory
+    };
+    PluginRegistry.register(plugin);
   }
   /**
    * Remove a previously registered factory.
@@ -16356,6 +16818,7 @@ var CustomMiddlewareRegistry = class {
    * @returns `true` if a factory was removed, `false` if the key was not found
    */
   static unregister(key4) {
+    PluginRegistry.unregister(key4);
     return this.factories.delete(key4);
   }
   /**
@@ -16365,29 +16828,73 @@ var CustomMiddlewareRegistry = class {
    * @returns The factory function, or `undefined` if not registered
    */
   static get(key4) {
-    return this.factories.get(key4);
+    const factory = this.factories.get(key4);
+    if (factory) return factory;
+    const plugin = PluginRegistry.get(key4);
+    if (plugin?.middleware) {
+      return ((config) => plugin.middleware(config));
+    }
+    return void 0;
   }
   /**
    * Check whether a factory is registered under the given key.
-   *
-   * @param key - The factory key to check
    */
   static has(key4) {
-    return this.factories.has(key4);
+    return this.factories.has(key4) || PluginRegistry.has(key4);
   }
   /**
    * Get all currently registered factory keys.
-   *
-   * @returns Array of registered key strings
    */
   static list() {
-    return Array.from(this.factories.keys());
+    const keys = new Set(this.factories.keys());
+    for (const k of PluginRegistry.list()) keys.add(k);
+    return Array.from(keys);
   }
 };
 CustomMiddlewareRegistry.factories = /* @__PURE__ */ new Map();
 
+// src/connection/ConnectionRegistry.ts
+var ConnectionRegistry = class {
+  static setStore(store) {
+    this.store = store;
+  }
+  static async list(type, tenantId) {
+    this.ensureStore();
+    return this.store.listByType(tenantId, type);
+  }
+  static async get(type, key4, tenantId) {
+    this.ensureStore();
+    return this.store.getByKey(tenantId, type, key4);
+  }
+  static async create(entry) {
+    this.ensureStore();
+    return this.store.create(entry);
+  }
+  static async update(tenantId, type, key4, updates) {
+    this.ensureStore();
+    return this.store.update(tenantId, type, key4, updates);
+  }
+  static async delete(tenantId, type, key4) {
+    this.ensureStore();
+    return this.store.delete(tenantId, type, key4);
+  }
+  static ensureStore() {
+    if (!this.store) throw new Error("ConnectionStore not configured");
+  }
+};
+ConnectionRegistry.store = null;
+
 // src/agent_lattice/builders/commonMiddleware.ts
-async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsIsExised) {
+function applyToolFilter(mw, allowedTools) {
+  if (allowedTools?.length && mw.tools?.length) {
+    mw.tools = mw.tools.filter((t) => {
+      const toolName = t.name;
+      return typeof toolName === "string" && allowedTools.includes(toolName);
+    });
+  }
+  return mw;
+}
+async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsIsExised, tenantId) {
   const middlewares = [];
   middlewares.push(createUnknownToolHandlerMiddleware());
   middlewares.push(createModelSelectorMiddleware());
@@ -16397,17 +16904,26 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsI
   if (needsFilesystemBackend && filesystemBackend) {
     if (!fsIsExised) {
       const options = { backend: filesystemBackend };
-      middlewares.push(createFilesystemMiddleware(options));
+      middlewares.push(applyToolFilter(
+        createFilesystemMiddleware(options),
+        filesystemConfig?.allowedTools
+      ));
     }
   }
   for (const config of middlewareConfigs) {
     if (!config.enabled || config.type === "filesystem") continue;
     switch (config.type) {
       case "code_eval":
-        middlewares.push(createCodeEvalMiddleware(config.config));
+        middlewares.push(applyToolFilter(
+          createCodeEvalMiddleware(config.config),
+          config.allowedTools
+        ));
         break;
       case "browser":
-        middlewares.push(createBrowserMiddleware(config.config));
+        middlewares.push(applyToolFilter(
+          createBrowserMiddleware(config.config),
+          config.allowedTools
+        ));
         break;
       case "sql":
         {
@@ -16420,21 +16936,30 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsI
                 descriptions[db.key] = db.description || db.name || "";
               }
             }
-            middlewares.push(createSqlMiddleware({
-              databaseKeys: sqlConfig.databaseKeys,
-              databaseDescriptions: descriptions
-            }));
+            middlewares.push(applyToolFilter(
+              createSqlMiddleware({
+                databaseKeys: sqlConfig.databaseKeys,
+                databaseDescriptions: descriptions
+              }),
+              config.allowedTools
+            ));
           }
         }
         break;
       case "skill":
-        middlewares.push(createSkillMiddleware(config.config));
+        middlewares.push(applyToolFilter(
+          createSkillMiddleware(config.config),
+          config.allowedTools
+        ));
         break;
       case "metrics":
         {
           const metricsConfig = config.config;
           if (metricsConfig.connectAll || metricsConfig.serverKeys && metricsConfig.serverKeys.length > 0) {
-            middlewares.push(createMetricsMiddleware(metricsConfig));
+            middlewares.push(applyToolFilter(
+              createMetricsMiddleware(metricsConfig),
+              config.allowedTools
+            ));
           }
         }
         break;
@@ -16442,36 +16967,57 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsI
         {
           const collectionConfig = config.config;
           if (collectionConfig.connectAll || collectionConfig.collectionKeys && collectionConfig.collectionKeys.length > 0) {
-            middlewares.push(createCollectionMiddleware(collectionConfig));
+            middlewares.push(applyToolFilter(
+              createCollectionMiddleware(collectionConfig),
+              config.allowedTools
+            ));
           }
         }
         break;
       case "ask_user_to_clarify":
-        middlewares.push(createAskUserClarifyMiddleware());
+        middlewares.push(applyToolFilter(
+          createAskUserClarifyMiddleware(),
+          config.allowedTools
+        ));
         break;
       case "widget":
-        middlewares.push(createWidgetMiddleware());
+        middlewares.push(applyToolFilter(
+          createWidgetMiddleware(),
+          config.allowedTools
+        ));
         break;
       case "claw":
         if (filesystemBackend) {
           const clawMiddlewareConfig = config.config;
-          middlewares.push(createClawMiddleware({
-            backend: filesystemBackend,
-            injectBootstrapFiles: clawMiddlewareConfig.injectBootstrapFiles ?? true,
-            bootstrapFiles: clawMiddlewareConfig.bootstrapFiles ?? {}
-          }));
+          middlewares.push(applyToolFilter(
+            createClawMiddleware({
+              backend: filesystemBackend,
+              injectBootstrapFiles: clawMiddlewareConfig.injectBootstrapFiles ?? true,
+              bootstrapFiles: clawMiddlewareConfig.bootstrapFiles ?? {}
+            }),
+            config.allowedTools
+          ));
         } else {
           console.warn("[claw middleware] Filesystem backend not available. Claw middleware requires filesystem backend to function.");
         }
         break;
       case "date":
-        middlewares.push(createDateMiddleware(config.config));
+        middlewares.push(applyToolFilter(
+          createDateMiddleware(config.config),
+          config.allowedTools
+        ));
         break;
       case "scheduler":
-        middlewares.push(createSchedulerMiddleware(config.config));
+        middlewares.push(applyToolFilter(
+          createSchedulerMiddleware(config.config),
+          config.allowedTools
+        ));
         break;
       case "task":
-        middlewares.push(createTaskMiddleware());
+        middlewares.push(applyToolFilter(
+          createTaskMiddleware(),
+          config.allowedTools
+        ));
         break;
       case "custom":
         {
@@ -16479,8 +17025,20 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsI
           const { key: key4, ...rest } = customConfig;
           const factory = CustomMiddlewareRegistry.get(key4);
           if (factory) {
+            if (rest.connections?.length && tenantId) {
+              const resolved = (await Promise.all(
+                rest.connections.map(async (connKey) => {
+                  const entry = await ConnectionRegistry.get(key4, connKey, tenantId);
+                  return entry ? { key: connKey, config: entry.config } : null;
+                })
+              )).filter(Boolean);
+              rest._resolvedConnections = resolved;
+            }
             const middleware = factory(rest);
-            middlewares.push(middleware instanceof Promise ? await middleware : middleware);
+            middlewares.push(applyToolFilter(
+              middleware instanceof Promise ? await middleware : middleware,
+              config.allowedTools
+            ));
           } else {
             console.warn(
               `[custom middleware] No factory registered for key "${key4}". Use CustomMiddlewareRegistry.register("${key4}", factory) before building the agent.`
@@ -16488,6 +17046,30 @@ async function createCommonMiddlewares(middlewareConfigs, filesystemBackend, fsI
           }
         }
         break;
+      default:
+        {
+          const plugin = PluginRegistry.get(config.type);
+          if (plugin?.middleware) {
+            const pluginConfig = config.config;
+            if (pluginConfig.connections?.length && tenantId) {
+              const resolved = (await Promise.all(
+                pluginConfig.connections.map(async (connKey) => {
+                  const entry = await ConnectionRegistry.get(config.type, connKey, tenantId);
+                  return entry ? { key: connKey, config: entry.config } : null;
+                })
+              )).filter(Boolean);
+              pluginConfig._resolvedConnections = resolved;
+            }
+            const mw = plugin.middleware(pluginConfig);
+            middlewares.push(applyToolFilter(
+              mw instanceof Promise ? await mw : mw,
+              config.allowedTools
+            ));
+          } else {
+            console.warn(`[commonMiddleware] Unknown middleware type "${config.type}" \u2014 skipping`);
+          }
+        }
+        break;
     }
   }
   return middlewares;
@@ -16671,8 +17253,8 @@ function createFilesystemBackendFactory(middlewareConfigs) {
 
 // src/agent_lattice/builders/ReActAgentGraphBuilder.ts
 var ReActAgentGraphBuilder = class {
-  async createMiddlewares(middlewareConfigs) {
-    return await createCommonMiddlewares(middlewareConfigs);
+  async createMiddlewares(middlewareConfigs, tenantId) {
+    return await createCommonMiddlewares(middlewareConfigs, void 0, void 0, tenantId);
   }
   /**
    * 构建ReAct Agent Graph
@@ -16689,7 +17271,7 @@ var ReActAgentGraphBuilder = class {
     const stateSchema2 = createReactAgentSchema(params.stateSchema);
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, void 0, params.tenantId);
     return (0, import_langchain68.createAgent)({
       model: params.model,
       tools,
@@ -19039,7 +19621,7 @@ var DeepAgentGraphBuilder = class {
     }));
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true, params.tenantId);
     const deepAgent = createDeepAgent({
       tools,
       model: params.model,
@@ -21088,7 +21670,7 @@ var ProcessingAgentGraphBuilder = class {
     }));
     const middlewareConfigs = params.middleware || [];
     const filesystemBackend = createFilesystemBackendFactory(middlewareConfigs);
-    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, filesystemBackend, true, params.tenantId);
     const topologyConfig = middlewareConfigs.find(
       (m) => m.type === "topology" && m.enabled
     );
@@ -21350,7 +21932,7 @@ var WorkflowAgentGraphBuilder = class {
     const checkpointer = getCheckpointSaver("default");
     const tools = params.tools.map((t) => t.executor).filter(Boolean);
     const middlewareConfigs = params.middleware || [];
-    const middlewares = await createCommonMiddlewares(middlewareConfigs, void 0, false);
+    const middlewares = await createCommonMiddlewares(middlewareConfigs, void 0, false, params.tenantId);
     const askMiddlewares = await createCommonMiddlewares([
       {
         id: "ask_user_to_clarify",
@@ -21783,6 +22365,10 @@ async function configureStores(stores, options = {}) {
     }
     storeLatticeManager.registerLattice("default", type, store);
   }
+  if (storeLatticeManager.hasLattice("default", "connection")) {
+    const connectionStore = storeLatticeManager.getStoreLattice("default", "connection").store;
+    ConnectionRegistry.setStore(connectionStore);
+  }
   if (schedule !== void 0) {
     await initAndRegister(schedule, localDisposables);
     const scheduleConfig = {
@@ -23019,6 +23605,53 @@ registerToolLattice(
     }
   }
 );
+registerToolLattice(
+  "list_middleware_types",
+  {
+    name: "list_middleware_types",
+    description: "\u5217\u51FA\u5F53\u524D\u7CFB\u7EDF\u4E2D\u6240\u6709\u53EF\u7528\u7684\u4E2D\u95F4\u4EF6\u7C7B\u578B\uFF08Middlewares\uFF09\uFF0C\u5305\u62EC\u5185\u7F6E\u548C\u81EA\u5B9A\u4E49\u63D2\u4EF6\u3002\u8FD4\u56DE\u6BCF\u4E2A\u4E2D\u95F4\u4EF6\u7684 type\u3001name\u3001description\u3001tools \u6E05\u5355\uFF08\u652F\u6301 allowedTools \u8FC7\u6EE4\uFF09\u3001configSchema\uFF08\u914D\u7F6E\u9762\u677F\u9700\u8981\u54EA\u4E9B\u5B57\u6BB5\uFF09\u548C connectionSchema\uFF08\u662F\u5426\u652F\u6301\u8FDE\u63A5\u6D4B\u8BD5\u548C\u8D44\u6E90\u53D1\u73B0\uFF09\u3002\n\n\u4F7F\u7528\u573A\u666F\uFF1A\n1. \u5728\u521B\u5EFA agent \u524D\uFF0C\u5148\u8C03\u6B64\u5DE5\u5177\u4E86\u89E3\u6709\u54EA\u4E9B\u4E2D\u95F4\u4EF6\u53EF\u914D\u7F6E\n2. \u6839\u636E configSchema \u51B3\u5B9A\u9700\u8981\u63D0\u4F9B\u54EA\u4E9B\u914D\u7F6E\u5B57\u6BB5\uFF08\u5982 databaseKeys\u3001connections \u7B49\uFF09\n3. \u5982\u679C\u67D0\u4E2A\u4E2D\u95F4\u4EF6\u7684 connectionSchema \u5B58\u5728\uFF0C\u8BF4\u660E\u5B83\u662F\u8FDE\u63A5\u578B\u4E2D\u95F4\u4EF6\uFF0C\u9700\u8981\u518D\u8C03 list_connections \u83B7\u53D6\u53EF\u7528\u8FDE\u63A5\n4. \u7528\u8FD4\u56DE\u7684 type \u5B57\u6BB5\u6784\u5EFA middleware \u6570\u7EC4\u4F20\u7ED9 create_agent / update_agent",
+    schema: import_zod64.default.object({})
+  },
+  async () => {
+    const metas = PluginRegistry.listMeta();
+    return JSON.stringify(metas);
+  }
+);
+registerToolLattice(
+  "list_connections",
+  {
+    name: "list_connections",
+    description: "\u5217\u51FA\u6307\u5B9A\u63D2\u4EF6\u7C7B\u578B\u7684\u6240\u6709\u5DF2\u914D\u7F6E\u8FDE\u63A5\u3002\u7528\u4E8E\u67E5\u8BE2\u6709\u54EA\u4E9B\u53EF\u7528\u7684\u8FDE\u63A5\u5B9E\u4F8B\uFF08\u5982 'sap-prod', 'sap-dev'\uFF09\uFF0C\u65B9\u4FBF\u5728 agent \u914D\u7F6E\u4E2D\u9009\u62E9\u5177\u4F53\u8FDE\u63A5\u3002\n\n\u4F7F\u7528\u573A\u666F\uFF1A\n1. \u5148\u8C03 list_middleware_types \u786E\u5B9A\u67D0\u4E2A\u4E2D\u95F4\u4EF6\u662F\u8FDE\u63A5\u578B\uFF08\u6709 connectionSchema\uFF09\n2. \u8C03\u6B64\u5DE5\u5177\u4F20\u5165 type\uFF08\u5982 'erp'\uFF09\uFF0C\u83B7\u53D6\u8BE5\u7C7B\u578B\u4E0B\u5DF2\u914D\u597D\u7684\u8FDE\u63A5\u5217\u8868\n3. \u5728 create_agent \u7684 middleware[i].config.connections \u4E2D\u586B\u5165\u5BF9\u5E94\u7684 key \u503C\n\n\u8FD4\u56DE\u683C\u5F0F\uFF1A{ success: true, data: { records: [{ key, name, ... }] } }",
+    schema: import_zod64.default.object({
+      type: import_zod64.default.string().describe("\u63D2\u4EF6\u7C7B\u578B\u6807\u8BC6\uFF0C\u5982 'erp'\u3002\u4ECE list_middleware_types \u7684\u8FD4\u56DE\u4E2D\u83B7\u53D6")
+    }),
+    needUserApprove: false
+  },
+  async (input, config) => {
+    const tenantId = getTenantId(config);
+    try {
+      const entries = await ConnectionRegistry.list(input.type, tenantId);
+      return JSON.stringify({
+        success: true,
+        data: {
+          records: entries.map((e) => ({
+            key: e.key,
+            name: e.name,
+            description: e.description,
+            updatedAt: e.updatedAt
+          })),
+          total: entries.length
+        }
+      });
+    } catch (error) {
+      return JSON.stringify({
+        success: false,
+        error: error.message,
+        hint: "\u8BF7\u786E\u8BA4 ConnectionStore \u5DF2\u914D\u7F6E\u4E14\u63D2\u4EF6\u7C7B\u578B\u6B63\u786E\u3002\u8C03\u7528 list_middleware_types \u67E5\u770B\u53EF\u7528\u7C7B\u578B\u3002"
+      });
+    }
+  }
+);
 
 // src/agent_lattice/agentArchitectConfig.ts
 var import_protocols14 = require("@axiom-lattice/protocols");
@@ -23338,101 +23971,29 @@ Returns: \`{ valid: boolean, stepCount, issues: [{ type: "error"|"warning", mess
 
 ### Middleware Config Reference
 
+**Always call \`list_middleware_types\` first** to see what middleware types are currently available, their config schemas, and whether they are connection-type middleware. The static list below may be outdated \u2014 the tool is the source of truth.
+
 Each middleware entry uses this base shape:
 
 \`\`\`typescript
 {
   id: string,          // Unique ID, usually same as type
-  type: string,        // Middleware type from the table below
+  type: string,        // Middleware type from list_middleware_types
   name: string,        // Display name
   description: string, // What this middleware provides
   enabled: true,       // Always true for active middleware
-  config: { ... }      // Type-specific config (see table)
+  config: { ... }      // Type-specific config (see list_middleware_types result)
 }
 \`\`\`
 
-#### filesystem
-Provides: \`ls\`, \`read_file\`, \`write_file\`, \`edit_file\`, \`glob\`, \`grep\`
-| config field | type | description |
-|-------------|------|-------------|
-| backend | string | Pluggable backend, usually omitted (uses default) |
-| systemPrompt | string? | Custom system prompt override for filesystem conventions |
-
-#### code_eval
-Provides: \`run_code\` \u2014 execute Python/JavaScript in a sandbox
-| config field | type | description |
-|-------------|------|-------------|
-| vmIsolation | "agent" | "project" | "global" | Sandbox isolation level. Default recommended: \`"agent"\` |
-| timeout | number? | Execution timeout in milliseconds |
-| memoryLimit | number? | Memory limit in MB |
-
-#### browser
-Provides: \`browser_navigate\`, \`browser_click\`, \`browser_screenshot\`, \`browser_get_markdown\`, etc. (21 tools)
-| config field | type | description |
-|-------------|------|-------------|
-| vmIsolation | "agent" | "project" | "global" | Sandbox isolation level. Default recommended: \`"agent"\` |
-| headless | boolean? | Whether to run in headless mode |
-
-#### sql
-Provides: \`sql_list_tables\`, \`sql_table_info\`, \`sql_query_checker\`, \`sql_query\`
-| config field | type | description |
-|-------------|------|-------------|
-| databaseKeys | string[] | Array of database config keys to expose. Required. |
-| databaseDescriptions | Record<string,string>? | Optional human-readable descriptions keyed by database key |
-
-#### skill
-Provides: \`load_skill_content\` \u2014 load and read detailed skill instructions
-| config field | type | description |
-|-------------|------|-------------|
-| skills | string[]? | List of specific skill IDs to expose |
-| readAll | boolean? | When \`true\`, all available skills are exposed (recommended) |
-| heading | string? | Optional heading for the skills section |
-| extraNote | string? | Optional extra note appended after skills list |
-
-#### metrics
-Provides: \`list_datasources\`, \`query_metrics_list\`, \`query_semantic_metric_data\`, \`query_tables_list\`, \`execute_sql_query\`, etc. (7 tools)
-| config field | type | description |
-|-------------|------|-------------|
-| serverKeys | string[] | List of metrics server keys. Required. |
-| serverDescriptions | Record<string,string>? | Optional descriptions for each server |
-| connectAll | boolean? | When \`true\`, connects to all available metrics servers automatically |
-
-#### ask_user_to_clarify
-Provides: \`ask_user_to_clarify\` \u2014 pause execution and present questions with predefined options to the user. The agent halts until the user responds, then receives the answers as structured data.
-**Use this when:** the agent needs to confirm an action, get user approval, ask "which one?", or gather missing parameters. Without this middleware, the agent CANNOT interact with the user mid-execution.
-Config: \`{}\` \u2014 no configuration needed.
-
-#### widget
-Provides: \`load_guidelines\`, \`show_widget\` \u2014 render interactive HTML widgets and SVG diagrams
-Config: \`{}\` \u2014 no configuration needed.
-
-#### claw
-Provides: bootstrap file management (AGENTS.md, SOUL.md, etc.) \u2014 injects project context into system prompt
-| config field | type | description |
-|-------------|------|-------------|
-| injectBootstrapFiles | boolean? | Whether to inject bootstrap files into system prompt. Default: \`true\` |
-| bootstrapFiles | object? | Custom content for each bootstrap file |
-
-\`bootstrapFiles\` sub-fields: \`agents\`, \`soul\`, \`identity\`, \`user\`, \`tools\`, \`bootstrap\` \u2014 each is an optional string.
-
-#### date
-Provides: \`get_current_date_time\` \u2014 get current date and time
-| config field | type | description |
-|-------------|------|-------------|
-| timezone | string? | IANA timezone like \`"Asia/Shanghai"\` or \`"America/New_York"\`. Default: \`"UTC"\` |
-
-#### scheduler
-Provides: \`schedule_at\`, \`schedule_after\`, \`schedule_recurring\`, \`cancel_scheduled_task\`, \`list_scheduled_tasks\`
-| config field | type | description |
-|-------------|------|-------------|
-| defaultMaxRetries | number? | Default max retries for scheduled tasks. Default: \`0\` |
-
-#### topology [DEPRECATED \u2014 use WORKFLOW DSL instead]
-Provides: \`read_topo_progress\` \u2014 enforces multi-agent workflow topology for PROCESSING agents only. Not needed for WORKFLOW agents.
-| config field | type | description |
-|-------------|------|-------------|
-| edges | TopologyEdge[] | **Required.** Directed edges: \`{ from: string, to: string, purpose: string }\`. The \`purpose\` must describe the business intent of this delegation step. |
-| trackingStore | object? | Optional persistence for workflow run tracking | |
+**Connection-type middleware** (those with \`connectionSchema\` in list_middleware_types output):
+1. Call \`list_connections(type="xxx")\` to see available connection keys
+2. Use the returned keys in \`config.connections: ["sap-prod", "sap-dev"]\`
+
+**Tool filtering:** Use \`allowedTools\` to restrict which tools a middleware exposes:
+\`\`\`typescript
+{ type: "browser", enabled: true, config: {}, allowedTools: ["browser_navigate", "browser_screenshot"] }
+\`\`\`
 
 ### When to use ask_user_to_clarify Middleware
 
@@ -23455,19 +24016,6 @@ Provides: \`read_topo_progress\` \u2014 enforces multi-agent workflow topology f
 
 **Design rule:** If your agent's system prompt says anything like "confirm with the user before...", "ask the user to choose...", or "get approval for...", you MUST include the \`ask_user_to_clarify\` middleware.
 
-### Quick Pick: Common Middleware Combos
-
-| Agent Role | Recommended Middleware |
-|-----------|----------------------|
-| Code assistant | code_eval, widget |
-| Data analyst | sql, code_eval, widget |
-| Web researcher | browser, widget |
-| Operations / SRE | metrics, sql, widget |
-| Process orchestrator | skill, date, scheduler, widget |
-| General assistant | date, widget |
-| Approval-gated operations | ask_user_to_clarify, widget |
-| Interactive Q&A | ask_user_to_clarify, date, widget |
-
 ### manage_binding Reference
 
 Use \`manage_binding\` to bind external senders (email, Lark, Slack) to agents. A binding routes inbound messages from the sender to the specified agent.
@@ -23598,6 +24146,8 @@ var agentArchitectConfig = {
   tools: [
     "list_agents",
     "list_tools",
+    "list_middleware_types",
+    "list_connections",
     "get_agent",
     "create_agent",
     "create_workflow",
@@ -26768,7 +27318,9 @@ function generateToken() {
 function createSharePayload(tenantId, workspaceId, projectId, userId, request) {
   const resourcePath = (request.resourcePath || "").replace(/^\/?project\/?/, "").replace(/\/+$/, "");
   if (!resourcePath || resourcePath === "/") {
-    throw new Error("Cannot share project root \u2014 share a subdirectory or file instead");
+    if (request.visibility !== "internal") {
+      throw new Error("Cannot share project root \u2014 share a subdirectory or file instead");
+    }
   }
   return {
     address: createResourceAddress({
@@ -26895,6 +27447,28 @@ function clearEncryptionKeyCache() {
   keyValidated = false;
 }
 
+// src/plugin/BuiltinPlugins.ts
+var BUILTIN_PLUGINS = [
+  filesystemPlugin,
+  codeEvalPlugin,
+  browserPlugin,
+  sqlPlugin,
+  skillPlugin,
+  metricsPlugin,
+  askUserClarifyPlugin,
+  widgetPlugin,
+  clawPlugin,
+  datePlugin,
+  schedulerPlugin,
+  taskPlugin,
+  collectionPlugin
+];
+function registerBuiltinPlugins() {
+  for (const plugin of BUILTIN_PLUGINS) {
+    PluginRegistry.register(plugin);
+  }
+}
+
 // src/workflow/index.ts
 init_compile();
 init_parse_yaml();
@@ -27051,6 +27625,9 @@ var PersonalAssistantConfig = class {
   }
 };
 PersonalAssistantConfig._config = deepClone(DEFAULT_CONFIG);
+
+// src/index.ts
+registerBuiltinPlugins();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_TASK_EVENT,
@@ -27059,11 +27636,13 @@ PersonalAssistantConfig._config = deepClone(DEFAULT_CONFIG);
   AgentLatticeManager,
   AgentManager,
   AgentType,
+  BUILTIN_PLUGINS,
   BUILTIN_SKILLS,
   ChunkBuffer,
   ChunkBufferLatticeManager,
   CollectionLatticeManager,
   CompositeBackend,
+  ConnectionRegistry,
   ConsoleLoggerClient,
   CustomMetricsClient,
   CustomMiddlewareRegistry,
@@ -27113,6 +27692,7 @@ PersonalAssistantConfig._config = deepClone(DEFAULT_CONFIG);
   MysqlDatabase,
   PersonalAssistantConfig,
   PinoLoggerClient,
+  PluginRegistry,
   PostgresDatabase,
   PrometheusClient,
   Protocols,
@@ -27275,6 +27855,7 @@ PersonalAssistantConfig._config = deepClone(DEFAULT_CONFIG);
   sandboxLatticeManager,
   sanitizeToolCallId,
   scheduleLatticeManager,
+  serializePluginMeta,
   setBindingRegistry,
   setMenuRegistry,
   skillLatticeManager,