@axiom-lattice/gateway 2.1.112 → 2.1.113

package/dist/index.js

@@ -94,7 +94,7 @@ __export(mcp_configs_exports, {
   testMcpServerTools: () => testMcpServerTools,
   updateMcpServerConfig: () => updateMcpServerConfig
 });
-function getTenantId12(request) {
+function getTenantId13(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -102,9 +102,9 @@ function getTenantId12(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMcpServerConfigList(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const configs = await store2.getAllConfigs(tenantId);
     return {
@@ -128,10 +128,10 @@ async function getMcpServerConfigList(request, reply) {
   }
 }
 async function getMcpServerConfig(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -154,10 +154,10 @@ async function getMcpServerConfig(request, reply) {
   }
 }
 async function createMcpServerConfig(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -167,7 +167,7 @@ async function createMcpServerConfig(request, reply) {
         message: "MCP server configuration with this key already exists"
       };
     }
-    const id = body.id || (0, import_crypto6.randomUUID)();
+    const id = body.id || (0, import_crypto7.randomUUID)();
     const config = await store2.createConfig(tenantId, id, body);
     try {
       await connectAndRegisterTools(config);
@@ -193,11 +193,11 @@ async function createMcpServerConfig(request, reply) {
   }
 }
 async function updateMcpServerConfig(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -217,8 +217,8 @@ async function updateMcpServerConfig(request, reply) {
     }
     if (shouldReconnect) {
       try {
-        await import_core28.mcpManager.reconnectServer(key);
-        await import_core28.mcpManager.registerToolsToToolLattice(key, updated.selectedTools);
+        await import_core30.mcpManager.reconnectServer(key);
+        await import_core30.mcpManager.registerToolsToToolLattice(key, updated.selectedTools);
         await store2.updateConfig(tenantId, existing.id, { status: "connected" });
         updated.status = "connected";
       } catch (error) {
@@ -241,10 +241,10 @@ async function updateMcpServerConfig(request, reply) {
   }
 }
 async function deleteMcpServerConfig(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     let config = await store2.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -262,8 +262,8 @@ async function deleteMcpServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core28.mcpManager.hasServer(configKey)) {
-        await import_core28.mcpManager.removeServer(configKey);
+      if (import_core30.mcpManager.hasServer(configKey)) {
+        await import_core30.mcpManager.removeServer(configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MCP manager:", error);
@@ -288,10 +288,10 @@ async function deleteMcpServerConfig(request, reply) {
   }
 }
 async function testMcpServerConnection(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -304,7 +304,7 @@ async function testMcpServerConnection(request, reply) {
     try {
       const testKey = `__test_${key}_${Date.now()}`;
       const connection = convertToConnection(config.config);
-      const { latency } = await import_core28.McpLatticeManager.testConnection(testKey, connection);
+      const { latency } = await import_core30.McpLatticeManager.testConnection(testKey, connection);
       return {
         success: true,
         message: "Connection test successful",
@@ -336,10 +336,10 @@ async function testMcpServerConnection(request, reply) {
   }
 }
 async function listMcpServerTools(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -349,10 +349,10 @@ async function listMcpServerTools(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (!import_core28.mcpManager.hasServer(key)) {
+    if (!import_core30.mcpManager.hasServer(key)) {
       await connectAndRegisterTools(config);
     }
-    const tools = await import_core28.mcpManager.getServerTools(key);
+    const tools = await import_core30.mcpManager.getServerTools(key);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -369,10 +369,10 @@ async function listMcpServerTools(request, reply) {
   }
 }
 async function connectMcpServer(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -393,7 +393,7 @@ async function connectMcpServer(request, reply) {
     };
   } catch (error) {
     console.error("Failed to connect MCP server:", error);
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (config) {
@@ -406,10 +406,10 @@ async function connectMcpServer(request, reply) {
   }
 }
 async function disconnectMcpServer(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId13(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core28.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core30.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -419,8 +419,8 @@ async function disconnectMcpServer(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (import_core28.mcpManager.hasServer(key)) {
-      await import_core28.mcpManager.removeServer(key);
+    if (import_core30.mcpManager.hasServer(key)) {
+      await import_core30.mcpManager.removeServer(key);
     }
     const updated = await store2.updateConfig(tenantId, config.id, {
       status: "disconnected"
@@ -450,7 +450,7 @@ async function testMcpServerTools(request, reply) {
     }
     const testKey = `__test_${Date.now()}`;
     const connection = convertToConnection(body.config);
-    const { tools } = await import_core28.McpLatticeManager.testConnection(testKey, connection);
+    const { tools } = await import_core30.McpLatticeManager.testConnection(testKey, connection);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -487,9 +487,9 @@ function convertToConnection(config) {
 }
 async function connectAndRegisterTools(config) {
   const connection = convertToConnection(config.config);
-  import_core28.mcpManager.addServer(config.key, connection);
-  await import_core28.mcpManager.connect();
-  await import_core28.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
+  import_core30.mcpManager.addServer(config.key, connection);
+  await import_core30.mcpManager.connect();
+  await import_core30.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
 }
 function registerMcpServerConfigRoutes(app2) {
   app2.get("/api/mcp-servers", getMcpServerConfigList);
@@ -503,12 +503,12 @@ function registerMcpServerConfigRoutes(app2) {
   app2.post("/api/mcp-servers/:key/disconnect", disconnectMcpServer);
   app2.post("/api/mcp-servers/test-tools", testMcpServerTools);
 }
-var import_core28, import_crypto6;
+var import_core30, import_crypto7;
 var init_mcp_configs = __esm({
   "src/controllers/mcp-configs.ts"() {
     "use strict";
-    import_core28 = require("@axiom-lattice/core");
-    import_crypto6 = require("crypto");
+    import_core30 = require("@axiom-lattice/core");
+    import_crypto7 = require("crypto");
   }
 });
 
@@ -1290,7 +1290,7 @@ async function handleTasksSend(request, reply) {
   taskStore.set(taskId, record);
   let agent;
   try {
-    agent = import_core38.agentInstanceManager.getAgent({
+    agent = import_core54.agentInstanceManager.getAgent({
       assistant_id: assistantId,
       thread_id: threadId,
       tenant_id: tenantId,
@@ -1382,7 +1382,7 @@ async function handleTasksCancel(request, reply) {
     return;
   }
   try {
-    const agent = import_core38.agentInstanceManager.getAgent({
+    const agent = import_core54.agentInstanceManager.getAgent({
       assistant_id: record.assistantId,
       thread_id: record.threadId,
       tenant_id: record.tenantId,
@@ -1419,7 +1419,7 @@ async function handleTasksStream(request, reply) {
   }
   let agent;
   try {
-    agent = import_core38.agentInstanceManager.getAgent({
+    agent = import_core54.agentInstanceManager.getAgent({
       assistant_id: record.assistantId,
       thread_id: record.threadId,
       tenant_id: record.tenantId,
@@ -1614,12 +1614,12 @@ function registerA2ARoutes(app2) {
     handleApiKeyRotate
   );
 }
-var import_uuid10, import_core38, import_protocols4, taskStore, _a2aKeyStore, _storeKeyMap;
+var import_uuid10, import_core54, import_protocols4, taskStore, _a2aKeyStore, _storeKeyMap;
 var init_a2a = __esm({
   "src/routes/a2a.ts"() {
     "use strict";
     import_uuid10 = require("uuid");
-    import_core38 = require("@axiom-lattice/core");
+    import_core54 = require("@axiom-lattice/core");
     import_protocols4 = require("@axiom-lattice/protocols");
     taskStore = /* @__PURE__ */ new Map();
     _a2aKeyStore = null;
@@ -1632,12 +1632,12 @@ var resources_exports = {};
 __export(resources_exports, {
   ResourceController: () => ResourceController
 });
-var import_bcryptjs, import_core39, ResourceController;
+var import_bcryptjs, import_core55, ResourceController;
 var init_resources = __esm({
   "src/controllers/resources.ts"() {
     "use strict";
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_core39 = require("@axiom-lattice/core");
+    import_core55 = require("@axiom-lattice/core");
     init_mime();
     ResourceController = class {
       constructor(deps) {
@@ -1652,14 +1652,14 @@ var init_resources = __esm({
         if (!workspaceId || !projectId) {
           return reply.status(400).send({ error: "x-workspace-id and x-project-id headers required" });
         }
-        const payload = (0, import_core39.createSharePayload)(
+        const payload = (0, import_core55.createSharePayload)(
           tenantId,
           workspaceId,
           projectId,
           userId,
           body
         );
-        const token = (0, import_core39.generateToken)();
+        const token = (0, import_core55.generateToken)();
         try {
           await this.deps.store.create({ ...payload, token });
           this.deps.logger.info(
@@ -1811,7 +1811,7 @@ var init_resources = __esm({
             resourcePath: subPath
           }, subPath, ext, request, reply);
         }
-        const volume = (0, import_core39.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
+        const volume = (0, import_core55.buildNamedVolumeName)("p", "project", tenantId, workspaceId, projectId);
         return this._resolveAndServe(
           volume,
           subPath,
@@ -2261,6 +2261,20 @@ var createRun = async (request, reply) => {
       project_id,
       custom_run_config: mergedConfig
     });
+    if (background) {
+      const messageInput = message_id ? { ...input, id: message_id } : input;
+      const result = await agent.addMessage({
+        input: messageInput,
+        command,
+        custom_run_config: mergedConfig
+      }, mode);
+      reply.status(202).send({
+        success: true,
+        messageId: result.messageId,
+        queued: true
+      });
+      return;
+    }
     if (streaming) {
       reply.hijack();
       reply.raw.writeHead(200, {
@@ -2346,8 +2360,13 @@ var resumeStream = async (request, reply) => {
         workspace_id,
         project_id
       });
-      const stream = agent.chunkStream(message_id, [import_protocols.MessageChunkTypes.THREAD_IDLE]);
+      const stream = agent.chunkStream(message_id, []);
+      let closed = false;
+      request.raw.on("close", () => {
+        closed = true;
+      });
       for await (const chunk of stream) {
+        if (closed || reply.raw.destroyed) break;
         reply.raw.write(`data: ${JSON.stringify(chunk)}
 
 `);
@@ -4978,11 +4997,339 @@ async function completeTask(request, reply) {
   }
 }
 
-// src/controllers/middleware-types.ts
+// src/services/ExportImportService.ts
 var import_core18 = require("@axiom-lattice/core");
+var import_crypto4 = require("crypto");
+var exportJobs = /* @__PURE__ */ new Map();
+var JOB_TTL_MS = 60 * 60 * 1e3;
+function cleanExpiredJobs() {
+  const now = Date.now();
+  for (const [id, entry] of exportJobs) {
+    if (now - entry.createdAt > JOB_TTL_MS) {
+      exportJobs.delete(id);
+    }
+  }
+}
+var ExportImportService = class {
+  constructor() {
+    this.registry = import_core18.ExportableEntityRegistry.getInstance();
+  }
+  /**
+   * Preview an export: check which types would be auto-included, which dependencies are missing.
+   */
+  async exportPreview(tenantId, selectedTypes) {
+    const allDefs = this.registry.getAll();
+    const expanded = import_core18.DependencyResolver.expandCascade(allDefs, selectedTypes);
+    const cascadeAdditions = expanded.filter((t) => !selectedTypes.includes(t));
+    const deps = import_core18.DependencyResolver.computeDependencies(allDefs, expanded);
+    const registeredTypes = new Set(allDefs.map((d) => d.entityType));
+    const missingDependencies = deps.missing.filter((t) => registeredTypes.has(t));
+    return { missingDependencies, cascadeAdditions };
+  }
+  /**
+   * Generate a full ExportBundle for the given tenant and entity types.
+   * Stores the bundle in-memory and returns a jobId for download.
+   */
+  async export(tenantId, entityTypes, entityIds) {
+    const allDefs = this.registry.getAll();
+    const expanded = import_core18.DependencyResolver.expandCascade(allDefs, entityTypes);
+    const finalTypes = [.../* @__PURE__ */ new Set([...expanded, ...entityTypes])];
+    const dependencyOrder = import_core18.DependencyResolver.resolveOrder(
+      finalTypes.map((t) => this.registry.get(t))
+    );
+    const entities = {};
+    let exportCounter = 0;
+    for (const type of dependencyOrder) {
+      const def = this.registry.get(type);
+      let raw = await def.listForExport(tenantId);
+      if (entityIds && entityIds[type] && entityIds[type].length > 0) {
+        const idSet = new Set(entityIds[type]);
+        raw = raw.filter((e) => idSet.has(e.data.id));
+      }
+      entities[type] = raw.map((e) => ({
+        ...e,
+        _exportId: `exp-${type}-${String(++exportCounter).padStart(3, "0")}`,
+        data: this.sanitizeEntityData(e.data)
+      }));
+    }
+    const rawIdToExportId = /* @__PURE__ */ new Map();
+    for (const [, entityList] of Object.entries(entities)) {
+      for (const entity of entityList) {
+        const rawId = entity.data.id;
+        if (rawId) {
+          rawIdToExportId.set(rawId, entity._exportId);
+        }
+      }
+    }
+    for (const [type, entityList] of Object.entries(entities)) {
+      const def = this.registry.get(type);
+      const refFields = def.referenceFields || {};
+      for (const entity of entityList) {
+        for (const [fieldName, refEntityType] of Object.entries(refFields)) {
+          const rawValue = entity.data[fieldName];
+          if (typeof rawValue === "string" && rawValue) {
+            const exportId = rawIdToExportId.get(rawValue);
+            if (exportId) {
+              entity.data[fieldName] = `@${refEntityType}/${exportId}`;
+            }
+          }
+        }
+      }
+    }
+    const bundle = {
+      version: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      sourceTenantId: tenantId,
+      entities,
+      dependencyOrder,
+      _warning: "This file contains plaintext secrets (passwords, API keys, tokens). Store it securely and delete after import."
+    };
+    const jobId = (0, import_crypto4.randomUUID)();
+    exportJobs.set(jobId, { bundle, tenantId, createdAt: Date.now() });
+    return { jobId, bundle };
+  }
+  /**
+   * Retrieve a previously generated export bundle by jobId with tenant validation.
+   */
+  getExportJob(jobId, tenantId) {
+    cleanExpiredJobs();
+    const entry = exportJobs.get(jobId);
+    if (!entry || entry.tenantId !== tenantId) return void 0;
+    return entry.bundle;
+  }
+  /**
+   * Preview import: validate bundle and detect conflicts.
+   */
+  async previewImport(tenantId, bundle) {
+    this.validateBundle(bundle);
+    const allConflicts = [];
+    const allInsertions = [];
+    const allErrors = [];
+    for (const [entityType, entities] of Object.entries(bundle.entities)) {
+      if (entities.length === 0) continue;
+      try {
+        const def = this.registry.get(entityType);
+        const result = await def.previewImport(tenantId, entities);
+        allConflicts.push(...result.conflicts);
+        allInsertions.push(...result.insertions);
+        allErrors.push(...result.errors);
+      } catch (err) {
+        for (const entity of entities) {
+          allErrors.push({
+            _exportId: entity._exportId,
+            entityType,
+            error: `Preview failed: ${err.message}`
+          });
+        }
+      }
+    }
+    return { conflicts: allConflicts, insertions: allInsertions, errors: allErrors };
+  }
+  /**
+   * Apply import: create entities in dependency order with ID remapping.
+   */
+  async applyImport(tenantId, bundle, resolutions) {
+    this.validateBundle(bundle);
+    const results = [];
+    const idMap = {};
+    const skillIdRemap = {};
+    for (const entityType of bundle.dependencyOrder) {
+      const entities = bundle.entities[entityType];
+      if (!entities || entities.length === 0) continue;
+      const def = this.registry.get(entityType);
+      const remapper = new import_core18.IdRemapper(idMap);
+      for (const entity of entities) {
+        const resolution = resolutions[entity._exportId];
+        if (resolution?.action === "skip") {
+          results.push({ _exportId: entity._exportId, entityType, status: "skipped" });
+          continue;
+        }
+        try {
+          const remappedData = remapper.remapReferences(entity.data);
+          if (entityType === "agent" && Object.keys(skillIdRemap).length > 0) {
+            const skillRemapper = new import_core18.IdRemapper({});
+            remappedData.graphDefinition = skillRemapper.remapSkillIds(
+              remappedData.graphDefinition || {},
+              skillIdRemap
+            );
+          }
+          if (resolution?.action === "rename" && resolution.newId) {
+            remappedData.id = resolution.newId;
+          }
+          const entityWithRemappedData = { ...entity, data: remappedData };
+          const { newId } = await def.applyImport(
+            tenantId,
+            entityWithRemappedData,
+            resolution ?? { _exportId: entity._exportId, action: "overwrite" }
+          );
+          if (newId) {
+            idMap[entity._exportId] = newId;
+            if (entityType === "skill" && newId) {
+              const oldSkillId = remappedData.id;
+              if (oldSkillId !== newId) {
+                skillIdRemap[oldSkillId] = newId;
+              }
+            }
+            results.push({
+              _exportId: entity._exportId,
+              entityType,
+              status: resolution?.action === "overwrite" ? "updated" : "created",
+              newId
+            });
+          }
+        } catch (err) {
+          results.push({
+            _exportId: entity._exportId,
+            entityType,
+            status: "failed",
+            error: err.message
+          });
+        }
+      }
+    }
+    return { results, idMap };
+  }
+  /**
+   * List all registered exportable types (for frontend).
+   */
+  listExportableTypes() {
+    return this.registry.listTypes();
+  }
+  validateBundle(bundle) {
+    if (bundle.version !== 1) {
+      throw new Error(`Unsupported bundle version: ${bundle.version}. Expected: 1`);
+    }
+    if (!bundle.entities || typeof bundle.entities !== "object") {
+      throw new Error("Invalid bundle: missing entities");
+    }
+    if (!Array.isArray(bundle.dependencyOrder)) {
+      throw new Error("Invalid bundle: missing dependencyOrder");
+    }
+  }
+  sanitizeEntityData(data) {
+    const sanitized = { ...data };
+    delete sanitized.tenantId;
+    delete sanitized.createdAt;
+    delete sanitized.updatedAt;
+    return sanitized;
+  }
+};
+
+// src/controllers/export-import.ts
+var import_core19 = require("@axiom-lattice/core");
+var service = new ExportImportService();
+function getTenantId10(request) {
+  return request.user?.tenantId || request.headers["x-tenant-id"] || "default";
+}
+async function getExportableTypes(_request, reply) {
+  const types = service.listExportableTypes();
+  return reply.send({ success: true, data: types });
+}
+async function exportConfig(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const { entityTypes, entityIds } = request.body;
+  if (!Array.isArray(entityTypes) || entityTypes.length === 0) {
+    return reply.status(400).send({ success: false, message: "entityTypes must be a non-empty array" });
+  }
+  const preview = await service.exportPreview(tenantId, entityTypes);
+  if (preview.missingDependencies.length > 0 || preview.cascadeAdditions.length > 0) {
+    return reply.send({
+      success: true,
+      data: {
+        needsConfirmation: true,
+        missingDependencies: preview.missingDependencies,
+        cascadeAdditions: preview.cascadeAdditions
+      }
+    });
+  }
+  const { jobId, bundle } = await service.export(tenantId, entityTypes, entityIds);
+  return reply.send({
+    success: true,
+    data: {
+      jobId,
+      summary: Object.fromEntries(
+        Object.entries(bundle.entities).map(([type, entities]) => [type, entities.length])
+      )
+    }
+  });
+}
+async function exportConfigConfirm(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const { entityTypes, entityIds } = request.body;
+  const { jobId, bundle } = await service.export(tenantId, entityTypes, entityIds);
+  return reply.send({
+    success: true,
+    data: {
+      jobId,
+      summary: Object.fromEntries(
+        Object.entries(bundle.entities).map(([type, entities]) => [type, entities.length])
+      )
+    }
+  });
+}
+async function previewEntities(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const { entityTypes } = request.body;
+  try {
+    const registry = import_core19.ExportableEntityRegistry.getInstance();
+    const result = {};
+    for (const type of entityTypes) {
+      const def = registry.get(type);
+      const entities = await def.listForExport(tenantId);
+      result[type] = entities.map((e) => ({
+        id: e.data.id,
+        name: e.data.name || e.data.id,
+        description: e.data.description
+      }));
+    }
+    return reply.send({ success: true, data: result });
+  } catch (err) {
+    return reply.status(400).send({ success: false, message: err.message });
+  }
+}
+async function downloadExport(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const bundle = service.getExportJob(request.params.jobId, tenantId);
+  if (!bundle) {
+    return reply.status(404).send({ success: false, message: "Export job not found or expired" });
+  }
+  return reply.header("Content-Type", "application/json").header("Content-Disposition", `attachment; filename="tenant-export-${bundle.sourceTenantId}.json"`).send({ success: true, data: bundle });
+}
+async function importPreview(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  const { bundle } = request.body;
+  if (!bundle) {
+    return reply.status(400).send({ success: false, message: "No bundle provided in request body" });
+  }
+  try {
+    const preview = await service.previewImport(tenantId, bundle);
+    return reply.send({ success: true, data: preview });
+  } catch (err) {
+    return reply.status(400).send({
+      success: false,
+      message: `Invalid export file: ${err.message}`
+    });
+  }
+}
+async function importApply(request, reply) {
+  const tenantId = getTenantId10(request) || request.params.tenantId;
+  try {
+    const { bundle, resolutions } = request.body;
+    const result = await service.applyImport(tenantId, bundle, resolutions);
+    return reply.send({ success: true, data: result });
+  } catch (err) {
+    return reply.status(400).send({
+      success: false,
+      message: `Import failed: ${err.message}`
+    });
+  }
+}
+
+// src/controllers/middleware-types.ts
+var import_core20 = require("@axiom-lattice/core");
 function middlewareTypesRoutes(fastify2) {
   fastify2.get("/api/middleware-types", async (_request, reply) => {
-    const metas = import_core18.PluginRegistry.listMeta();
+    const metas = import_core20.PluginRegistry.listMeta();
     return reply.send(metas);
   });
 }
@@ -5328,7 +5675,7 @@ var getHealthSchema = {
 };
 
 // src/controllers/thread_status.ts
-var import_core19 = require("@axiom-lattice/core");
+var import_core21 = require("@axiom-lattice/core");
 async function removePendingMessageHandler(request, reply) {
   try {
     const { assistant_id, thread_id, message_id } = request.params;
@@ -5341,7 +5688,7 @@ async function removePendingMessageHandler(request, reply) {
     if (!assistant_id) {
       return reply.code(400).send({ error: "Missing assistant_id parameter" });
     }
-    const agent = import_core19.agentInstanceManager.getAgent({
+    const agent = import_core21.agentInstanceManager.getAgent({
       assistant_id,
       thread_id,
       tenant_id,
@@ -5375,7 +5722,7 @@ async function removePendingMessageHandler(request, reply) {
 }
 
 // src/services/sandbox_service.ts
-var import_core20 = require("@axiom-lattice/core");
+var import_core22 = require("@axiom-lattice/core");
 var ERROR_HTML = `<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
@@ -5487,7 +5834,7 @@ var ERROR_HTML = `<!DOCTYPE html>
 </html>`;
 var SandboxService = class {
   getFilesystemVmIsolation(tenantId, assistantId) {
-    const agentLattice = import_core20.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
+    const agentLattice = import_core22.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
     if (!agentLattice) {
       return null;
     }
@@ -5501,9 +5848,9 @@ var SandboxService = class {
   computeSandboxName(assistantId, threadId, vmIsolation, tenantId, workspaceId, projectId) {
     switch (vmIsolation) {
       case "agent":
-        return (0, import_core20.normalizeSandboxName)(`${tenantId ?? "default"}-${assistantId}`);
+        return (0, import_core22.normalizeSandboxName)(`${tenantId ?? "default"}-${assistantId}`);
       case "project":
-        return (0, import_core20.normalizeSandboxName)(
+        return (0, import_core22.normalizeSandboxName)(
           `${tenantId ?? "default"}-${workspaceId ?? "default"}-${projectId ?? "default"}`
         );
       case "global":
@@ -5559,7 +5906,7 @@ var SandboxService = class {
 var sandboxService = new SandboxService();
 
 // src/controllers/sandbox.ts
-var import_core21 = require("@axiom-lattice/core");
+var import_core23 = require("@axiom-lattice/core");
 init_mime();
 function registerSandboxProxyRoutes(app2) {
   app2.post(
@@ -5574,7 +5921,7 @@ function registerSandboxProxyRoutes(app2) {
       }
       const workspaceId = request.headers["x-workspace-id"];
       const projectId = request.headers["x-project-id"];
-      const sandboxManager = (0, import_core21.getSandBoxManager)();
+      const sandboxManager = (0, import_core23.getSandBoxManager)();
       const sandbox = await sandboxManager.getSandboxFromConfig({
         assistant_id: assistantId,
         thread_id: threadId,
@@ -5622,7 +5969,7 @@ function registerSandboxProxyRoutes(app2) {
       }
       const workspaceId = request.headers["x-workspace-id"];
       const projectId = request.headers["x-project-id"];
-      const sandboxManager = (0, import_core21.getSandBoxManager)();
+      const sandboxManager = (0, import_core23.getSandBoxManager)();
       const sandbox = await sandboxManager.getSandboxFromConfig({
         assistant_id: assistantId,
         thread_id: threadId,
@@ -5655,15 +6002,15 @@ function registerSandboxProxyRoutes(app2) {
 // src/controllers/workspace.ts
 var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
-var import_core22 = require("@axiom-lattice/core");
-var import_core23 = require("@axiom-lattice/core");
 var import_core24 = require("@axiom-lattice/core");
+var import_core25 = require("@axiom-lattice/core");
+var import_core26 = require("@axiom-lattice/core");
 var import_uuid3 = require("uuid");
 init_mime();
 var WorkspaceController = class {
   constructor() {
-    this.workspaceStore = (0, import_core22.getStoreLattice)("default", "workspace").store;
-    this.projectStore = (0, import_core22.getStoreLattice)("default", "project").store;
+    this.workspaceStore = (0, import_core24.getStoreLattice)("default", "workspace").store;
+    this.projectStore = (0, import_core24.getStoreLattice)("default", "project").store;
   }
   getTenantId(request) {
     const userTenantId = request.user?.tenantId;
@@ -5797,7 +6144,7 @@ var WorkspaceController = class {
     }
     console.log(`[getBackend] storageType=${workspace.storageType} filePath=${filePath}`);
     if (workspace.storageType === "sandbox") {
-      const sandboxManager = (0, import_core24.getSandBoxManager)();
+      const sandboxManager = (0, import_core26.getSandBoxManager)();
       const volumeConfig = {
         assistant_id: assistantId || "",
         thread_id: "",
@@ -5815,7 +6162,7 @@ var WorkspaceController = class {
       const sandbox = await sandboxManager.getSandboxFromConfig(volumeConfig);
       console.log(`[getBackend] sandbox acquired, name=${sandbox.name || "unknown"}`);
       return {
-        backend: new import_core23.SandboxFilesystem({
+        backend: new import_core25.SandboxFilesystem({
           sandboxInstance: sandbox
         }),
         workspace
@@ -5823,7 +6170,7 @@ var WorkspaceController = class {
     } else {
       console.log(`[getBackend] using FilesystemBackend rootDir=/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`);
       return {
-        backend: new import_core23.FilesystemBackend({
+        backend: new import_core25.FilesystemBackend({
           rootDir: `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
           virtualMode: true
         }),
@@ -5875,7 +6222,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId, assistantId);
       const resolvedPath = filePath;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core24.getSandBoxManager)();
+        const sandboxManager = (0, import_core26.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -5929,7 +6276,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId, assistantId);
       const resolvedPath = filePath;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core24.getSandBoxManager)();
+        const sandboxManager = (0, import_core26.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -6070,7 +6417,7 @@ var WorkspaceController = class {
         return reply.status(400).send({ success: false, error: "Invalid path parameter" });
       }
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core24.getSandBoxManager)();
+        const sandboxManager = (0, import_core26.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -6178,9 +6525,9 @@ function registerWorkspaceRoutes(app2) {
 }
 
 // src/controllers/database-configs.ts
-var import_core25 = require("@axiom-lattice/core");
-var import_crypto4 = require("crypto");
-function getTenantId10(request) {
+var import_core27 = require("@axiom-lattice/core");
+var import_crypto5 = require("crypto");
+function getTenantId11(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -6188,9 +6535,9 @@ function getTenantId10(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getDatabaseConfigList(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const configs = await store2.getAllConfigs(tenantId);
     console.log("Backend: getAllConfigs returned:", configs);
@@ -6218,10 +6565,10 @@ async function getDatabaseConfigList(request, reply) {
   }
 }
 async function getDatabaseConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6244,10 +6591,10 @@ async function getDatabaseConfig(request, reply) {
   }
 }
 async function createDatabaseConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -6257,10 +6604,10 @@ async function createDatabaseConfig(request, reply) {
         message: "Database configuration with this key already exists"
       };
     }
-    const id = body.id || (0, import_crypto4.randomUUID)();
+    const id = body.id || (0, import_crypto5.randomUUID)();
     const config = await store2.createConfig(tenantId, id, body);
     try {
-      import_core25.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
+      import_core27.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register database:", error);
     }
@@ -6279,11 +6626,11 @@ async function createDatabaseConfig(request, reply) {
   }
 }
 async function updateDatabaseConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -6302,7 +6649,7 @@ async function updateDatabaseConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core25.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
+        import_core27.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register database:", error);
       }
@@ -6321,10 +6668,10 @@ async function updateDatabaseConfig(request, reply) {
   }
 }
 async function deleteDatabaseConfig(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     console.log("Delete request - keyOrId:", keyOrId);
     let config = await store2.getConfigByKey(tenantId, keyOrId);
@@ -6351,8 +6698,8 @@ async function deleteDatabaseConfig(request, reply) {
       };
     }
     try {
-      if (import_core25.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
-        await import_core25.sqlDatabaseManager.removeDatabase(tenantId, configKey);
+      if (import_core27.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
+        await import_core27.sqlDatabaseManager.removeDatabase(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from SqlDatabaseManager:", error);
@@ -6370,10 +6717,10 @@ async function deleteDatabaseConfig(request, reply) {
   }
 }
 async function testDatabaseConnection(request, reply) {
-  const tenantId = getTenantId10(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core25.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6384,16 +6731,16 @@ async function testDatabaseConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core25.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
+    import_core27.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
     const startTime = Date.now();
-    const db = await import_core25.sqlDatabaseManager.getDatabase(tenantId, testKey);
+    const db = await import_core27.sqlDatabaseManager.getDatabase(tenantId, testKey);
     try {
       await db.connect();
       await db.listTables();
       const latency = Date.now() - startTime;
       await new Promise((resolve) => setTimeout(resolve, 100));
       await db.disconnect();
-      await import_core25.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+      await import_core27.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       return {
         success: true,
         message: "Connection test successful",
@@ -6405,7 +6752,7 @@ async function testDatabaseConnection(request, reply) {
     } catch (error) {
       try {
         await db.disconnect();
-        await import_core25.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+        await import_core27.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       } catch {
       }
       return {
@@ -6457,9 +6804,9 @@ function registerDatabaseConfigRoutes(app2) {
 }
 
 // src/controllers/metrics-configs.ts
-var import_core26 = require("@axiom-lattice/core");
-var import_crypto5 = require("crypto");
-function getTenantId11(request) {
+var import_core28 = require("@axiom-lattice/core");
+var import_crypto6 = require("crypto");
+function getTenantId12(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -6467,9 +6814,9 @@ function getTenantId11(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMetricsServerConfigList(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const configs = await store2.getAllConfigs(tenantId);
     return {
@@ -6493,10 +6840,10 @@ async function getMetricsServerConfigList(request, reply) {
   }
 }
 async function getMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6519,10 +6866,10 @@ async function getMetricsServerConfig(request, reply) {
   }
 }
 async function createMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -6539,7 +6886,7 @@ async function createMetricsServerConfig(request, reply) {
         message: "selectedDataSources is required for semantic metrics servers"
       };
     }
-    const id = body.id || (0, import_crypto5.randomUUID)();
+    const id = body.id || (0, import_crypto6.randomUUID)();
     const configData = {
       key: body.key,
       name: body.name,
@@ -6551,7 +6898,7 @@ async function createMetricsServerConfig(request, reply) {
     };
     const config = await store2.createConfig(tenantId, id, configData);
     try {
-      import_core26.metricsServerManager.registerServer(tenantId, config.key, config.config);
+      import_core28.metricsServerManager.registerServer(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register metrics server:", error);
     }
@@ -6570,11 +6917,11 @@ async function createMetricsServerConfig(request, reply) {
   }
 }
 async function updateMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const existing = await store2.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -6602,7 +6949,7 @@ async function updateMetricsServerConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core26.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
+        import_core28.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register metrics server:", error);
       }
@@ -6621,10 +6968,10 @@ async function updateMetricsServerConfig(request, reply) {
   }
 }
 async function deleteMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     let config = await store2.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -6649,8 +6996,8 @@ async function deleteMetricsServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core26.metricsServerManager.hasServer(tenantId, configKey)) {
-        import_core26.metricsServerManager.removeServer(tenantId, configKey);
+      if (import_core28.metricsServerManager.hasServer(tenantId, configKey)) {
+        import_core28.metricsServerManager.removeServer(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MetricsServerManager:", error);
@@ -6668,10 +7015,10 @@ async function deleteMetricsServerConfig(request, reply) {
   }
 }
 async function testMetricsServerConnection(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6682,11 +7029,11 @@ async function testMetricsServerConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core26.metricsServerManager.registerServer(tenantId, testKey, config.config);
+    import_core28.metricsServerManager.registerServer(tenantId, testKey, config.config);
     try {
-      const client = await import_core26.metricsServerManager.getClient(tenantId, testKey);
+      const client = await import_core28.metricsServerManager.getClient(tenantId, testKey);
       const result = await client.testConnection();
-      import_core26.metricsServerManager.removeServer(tenantId, testKey);
+      import_core28.metricsServerManager.removeServer(tenantId, testKey);
       return {
         success: true,
         message: result.connected ? "Connection test successful" : "Connection test failed",
@@ -6694,7 +7041,7 @@ async function testMetricsServerConnection(request, reply) {
       };
     } catch (error) {
       try {
-        import_core26.metricsServerManager.removeServer(tenantId, testKey);
+        import_core28.metricsServerManager.removeServer(tenantId, testKey);
       } catch {
       }
       return {
@@ -6719,10 +7066,10 @@ async function testMetricsServerConnection(request, reply) {
   }
 }
 async function listAvailableMetrics(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6732,10 +7079,10 @@ async function listAvailableMetrics(request, reply) {
         message: "Metrics server configuration not found"
       };
     }
-    if (!import_core26.metricsServerManager.hasServer(tenantId, key)) {
-      import_core26.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core28.metricsServerManager.hasServer(tenantId, key)) {
+      import_core28.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = await import_core26.metricsServerManager.getClient(tenantId, key);
+    const client = await import_core28.metricsServerManager.getClient(tenantId, key);
     const metrics = await client.listMetrics();
     return {
       success: true,
@@ -6757,11 +7104,11 @@ async function listAvailableMetrics(request, reply) {
   }
 }
 async function queryMetricsData(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   const { metricName, startTime, endTime, step, labels } = request.body;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6778,10 +7125,10 @@ async function queryMetricsData(request, reply) {
         message: "metricName is required"
       };
     }
-    if (!import_core26.metricsServerManager.hasServer(tenantId, key)) {
-      import_core26.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core28.metricsServerManager.hasServer(tenantId, key)) {
+      import_core28.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = await import_core26.metricsServerManager.getClient(tenantId, key);
+    const client = await import_core28.metricsServerManager.getClient(tenantId, key);
     const result = await client.queryMetricData(metricName, {
       startTime,
       endTime,
@@ -6805,10 +7152,10 @@ async function queryMetricsData(request, reply) {
   }
 }
 async function getDataSources(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6826,7 +7173,7 @@ async function getDataSources(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core26.SemanticMetricsClient(semanticConfig);
+    const client = new import_core28.SemanticMetricsClient(semanticConfig);
     const allDatasources = await client.getDataSources();
     const selectedIds = semanticConfig.selectedDataSources || [];
     const filteredDatasources = selectedIds.length > 0 ? allDatasources.filter((ds) => selectedIds.includes(String(ds.id))) : allDatasources;
@@ -6846,10 +7193,10 @@ async function getDataSources(request, reply) {
   }
 }
 async function getDatasourceMetrics(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key, datasourceId } = request.params;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6867,7 +7214,7 @@ async function getDatasourceMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core26.SemanticMetricsClient(semanticConfig);
+    const client = new import_core28.SemanticMetricsClient(semanticConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -6883,11 +7230,11 @@ async function getDatasourceMetrics(request, reply) {
   }
 }
 async function querySemanticMetrics(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId12(request);
   const { key } = request.params;
   const body = request.body;
   try {
-    const storeLattice = (0, import_core26.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core28.getStoreLattice)("default", "metrics");
     const store2 = storeLattice.store;
     const config = await store2.getConfigByKey(tenantId, key);
     if (!config) {
@@ -6912,7 +7259,7 @@ async function querySemanticMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core26.SemanticMetricsClient(semanticConfig);
+    const client = new import_core28.SemanticMetricsClient(semanticConfig);
     const result = await client.semanticQuery(body);
     const columnNames = result.columns.map((col) => col.name);
     const allDataPoints = [];
@@ -6972,7 +7319,7 @@ async function testSemanticDataSources(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core26.SemanticMetricsClient(testConfig);
+    const client = new import_core28.SemanticMetricsClient(testConfig);
     const datasources = await client.getDataSources();
     return {
       success: true,
@@ -7008,7 +7355,7 @@ async function testDatasourceMetrics(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core26.SemanticMetricsClient(testConfig);
+    const client = new import_core28.SemanticMetricsClient(testConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -7040,7 +7387,7 @@ function registerMetricsServerConfigRoutes(app2) {
 }
 
 // src/controllers/connections.ts
-var import_core27 = require("@axiom-lattice/core");
+var import_core29 = require("@axiom-lattice/core");
 var import_zod = require("zod");
 var createBody = import_zod.z.object({
   type: import_zod.z.string().min(1),
@@ -7081,7 +7428,7 @@ function maskSecrets(config) {
 }
 async function resolveConfig(type, body, tenantId) {
   if (body.key) {
-    const entry = await import_core27.ConnectionRegistry.get(type, body.key, tenantId);
+    const entry = await import_core29.ConnectionRegistry.get(type, body.key, tenantId);
     if (!entry) throw { status: 404, error: `Connection "${body.key}" not found` };
     return entry.config;
   }
@@ -7092,7 +7439,7 @@ function connectionRoutes(fastify2) {
   fastify2.get("/api/connections", async (request, reply) => {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
-    const entries = await import_core27.ConnectionRegistry.list(type, getTenant(request));
+    const entries = await import_core29.ConnectionRegistry.list(type, getTenant(request));
     return reply.send({
       success: true,
       data: { records: entries.map((e) => ({ ...e, config: maskSecrets(e.config) })), total: entries.length }
@@ -7100,7 +7447,7 @@ function connectionRoutes(fastify2) {
   });
   fastify2.post("/api/connections", async (request, reply) => {
     const parsed = createBody.parse(request.body);
-    const entry = await import_core27.ConnectionRegistry.create({
+    const entry = await import_core29.ConnectionRegistry.create({
       tenantId: getTenant(request),
       type: parsed.type,
       key: parsed.key,
@@ -7119,7 +7466,7 @@ function connectionRoutes(fastify2) {
     const { key } = request.params;
     const body = request.body;
     const tenantId = getTenant(request);
-    const existing = await import_core27.ConnectionRegistry.get(type, key, tenantId);
+    const existing = await import_core29.ConnectionRegistry.get(type, key, tenantId);
     if (!existing) return reply.status(404).send({ error: "not found" });
     const updates = {};
     if (body.name !== void 0) updates.name = body.name;
@@ -7127,7 +7474,7 @@ function connectionRoutes(fastify2) {
     if (body.config) {
       updates.config = { ...existing.config, ...body.config };
     }
-    const entry = await import_core27.ConnectionRegistry.update(tenantId, type, key, updates);
+    const entry = await import_core29.ConnectionRegistry.update(tenantId, type, key, updates);
     return reply.send({
       success: true,
       data: { ...entry, config: maskSecrets(entry?.config ?? {}) }
@@ -7137,13 +7484,13 @@ function connectionRoutes(fastify2) {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
     const { key } = request.params;
-    const ok = await import_core27.ConnectionRegistry.delete(getTenant(request), type, key);
+    const ok = await import_core29.ConnectionRegistry.delete(getTenant(request), type, key);
     return reply.send({ success: ok });
   });
   fastify2.post("/api/connections/test", async (request, reply) => {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
-    const plugin = import_core27.PluginRegistry.get(type);
+    const plugin = import_core29.PluginRegistry.get(type);
     if (!plugin?.connection?.test) {
       return reply.status(400).send({ error: "plugin does not support connection testing" });
     }
@@ -7171,7 +7518,7 @@ function connectionRoutes(fastify2) {
   fastify2.post("/api/connections/discover", async (request, reply) => {
     const { type } = request.query;
     if (!type) return reply.status(400).send({ error: "query 'type' required" });
-    const plugin = import_core27.PluginRegistry.get(type);
+    const plugin = import_core29.PluginRegistry.get(type);
     if (!plugin?.connection?.discover) {
       return reply.status(400).send({ error: "plugin does not support resource discovery" });
     }
@@ -7201,12 +7548,12 @@ function connectionRoutes(fastify2) {
 init_mcp_configs();
 
 // src/controllers/eval.ts
-var import_core30 = require("@axiom-lattice/core");
+var import_core32 = require("@axiom-lattice/core");
 var import_uuid5 = require("uuid");
 
 // src/services/eval-runner.ts
 var import_events = require("events");
-var import_core29 = require("@axiom-lattice/core");
+var import_core31 = require("@axiom-lattice/core");
 var import_uuid4 = require("uuid");
 function mapLogs(logs) {
   return logs.map((l) => ({
@@ -7265,12 +7612,12 @@ var EvalRunner = class {
     const judgeModelKey = judgeCfg.modelKey || "";
     let resolvedJudgeModelKey;
     if (judgeModelKey) {
-      if (!import_core29.modelLatticeManager.hasLattice(judgeModelKey)) {
+      if (!import_core31.modelLatticeManager.hasLattice(judgeModelKey)) {
         throw new Error(`Judge model "${judgeModelKey}" is not registered`);
       }
       resolvedJudgeModelKey = judgeModelKey;
     } else {
-      const firstModel = import_core29.modelLatticeManager.getAllLattices()[0];
+      const firstModel = import_core31.modelLatticeManager.getAllLattices()[0];
       if (!firstModel) {
         throw new Error("No model registered \u2014 cannot run eval without a judge model");
       }
@@ -7330,7 +7677,7 @@ var EvalRunner = class {
     };
     const runPromise = (async () => {
       try {
-        const evalProject = new import_core29.LatticeEvalProject(projectConfig, onCaseComplete);
+        const evalProject = new import_core31.LatticeEvalProject(projectConfig, onCaseComplete);
         const { report } = await evalProject.runAllSuitesBatch(concurrency, abortController.signal);
         if (!abortController.signal.aborted) {
           const completedCount = stats.passed + stats.failed;
@@ -7384,13 +7731,13 @@ var EvalRunner = class {
     return this.runs.has(runId);
   }
   getEvalStore() {
-    return (0, import_core29.getStoreLattice)("default", "eval").store;
+    return (0, import_core31.getStoreLattice)("default", "eval").store;
   }
 };
 var evalRunner = new EvalRunner();
 
 // src/controllers/eval.ts
-function getTenantId13(request) {
+function getTenantId14(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -7398,11 +7745,11 @@ function getTenantId13(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 function getEvalStore() {
-  return (0, import_core30.getStoreLattice)("default", "eval").store;
+  return (0, import_core32.getStoreLattice)("default", "eval").store;
 }
 async function createProject(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const id = (0, import_uuid5.v4)();
     const data = request.body;
@@ -7442,7 +7789,7 @@ async function createProject(request, reply) {
 }
 async function listProjects(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     let projects = await store2.getProjectsByTenant(tenantId);
     if (projects.length === 0) {
@@ -7476,7 +7823,7 @@ async function listProjects(request, reply) {
 }
 async function getProject(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { pid } = request.params;
     const project = await store2.getProjectById(tenantId, pid);
@@ -7496,7 +7843,7 @@ async function getProject(request, reply) {
 }
 async function updateProject(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { pid } = request.params;
     const existing = await store2.getProjectById(tenantId, pid);
@@ -7539,7 +7886,7 @@ async function updateProject(request, reply) {
 }
 async function deleteProject(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { pid } = request.params;
     const existing = await store2.getProjectById(tenantId, pid);
@@ -7558,7 +7905,7 @@ async function deleteProject(request, reply) {
 }
 async function createSuite(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { pid } = request.params;
     const project = await store2.getProjectById(tenantId, pid);
@@ -7580,7 +7927,7 @@ async function createSuite(request, reply) {
 }
 async function updateSuite(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { sid } = request.params;
     const existing = await store2.getSuiteById(tenantId, sid);
@@ -7600,7 +7947,7 @@ async function updateSuite(request, reply) {
 }
 async function deleteSuite(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { sid } = request.params;
     const existing = await store2.getSuiteById(tenantId, sid);
@@ -7619,7 +7966,7 @@ async function deleteSuite(request, reply) {
 }
 async function createCase(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { sid } = request.params;
     const suite = await store2.getSuiteById(tenantId, sid);
@@ -7648,7 +7995,7 @@ async function createCase(request, reply) {
 }
 async function listCasesForSuite(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { sid } = request.params;
     const cases = await store2.getCasesBySuite(tenantId, sid);
@@ -7664,7 +8011,7 @@ async function listCasesForSuite(request, reply) {
 }
 async function updateCase(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { cid } = request.params;
     const existing = await store2.getCaseById(tenantId, cid);
@@ -7684,7 +8031,7 @@ async function updateCase(request, reply) {
 }
 async function deleteCase(request, reply) {
   try {
-    const tenantId = getTenantId13(request);
+    const tenantId = getTenantId14(request);
     const store2 = getEvalStore();
     const { cid } = request.params;
     const existing = await store2.getCaseById(tenantId, cid);
@@ -7716,7 +8063,7 @@ function registerEvalRoutes(app2) {
   app2.delete("/api/eval/projects/:pid/suites/:sid/cases/:cid", deleteCase);
   app2.post("/api/eval/projects/:pid/runs", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const { pid } = request.params;
       const runId = await evalRunner.startRun(tenantId, pid);
       reply.status(202).send({ success: true, message: "Run started", data: { run_id: runId } });
@@ -7728,7 +8075,7 @@ function registerEvalRoutes(app2) {
   });
   app2.get("/api/eval/runs", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const query = request.query;
       const runs = await getEvalStore().getRunsByTenant(tenantId, { projectId: query.project_id, status: query.status });
       reply.send({ success: true, message: "Ok", data: { records: runs, total: runs.length } });
@@ -7738,7 +8085,7 @@ function registerEvalRoutes(app2) {
   });
   app2.get("/api/eval/runs/:rid", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const { rid } = request.params;
       const run = await getEvalStore().getRunById(tenantId, rid);
       if (!run) return reply.status(404).send({ success: false, message: "Run not found" });
@@ -7760,7 +8107,7 @@ function registerEvalRoutes(app2) {
     const emitter = evalRunner.getEventEmitter();
     const eventKey = `run:${rid}`;
     if (!evalRunner.isRunning(rid)) {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const run = await getEvalStore().getRunById(tenantId, rid);
       if (run) {
         const eventType = run.status === "completed" ? "completed" : "error";
@@ -7799,7 +8146,7 @@ data: ${JSON.stringify(event.data)}
   });
   app2.delete("/api/eval/runs/:rid", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const { rid } = request.params;
       const deleted = await getEvalStore().deleteRun(tenantId, rid);
       if (!deleted) return reply.status(404).send({ success: false, message: "Run not found" });
@@ -7810,7 +8157,7 @@ data: ${JSON.stringify(event.data)}
   });
   app2.get("/api/eval/reports/projects/:pid", async (request, reply) => {
     try {
-      const tenantId = getTenantId13(request);
+      const tenantId = getTenantId14(request);
       const { pid } = request.params;
       const report = await getEvalStore().getProjectReport(tenantId, pid);
       if (!report) return reply.status(404).send({ success: false, message: "Project not found" });
@@ -7822,11 +8169,11 @@ data: ${JSON.stringify(event.data)}
 }
 
 // src/controllers/users.ts
-var import_core31 = require("@axiom-lattice/core");
+var import_core33 = require("@axiom-lattice/core");
 var import_uuid6 = require("uuid");
 var UsersController = class {
   constructor() {
-    this.userStore = (0, import_core31.getStoreLattice)("default", "user").store;
+    this.userStore = (0, import_core33.getStoreLattice)("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -7904,11 +8251,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-var import_core32 = require("@axiom-lattice/core");
+var import_core34 = require("@axiom-lattice/core");
 var import_uuid7 = require("uuid");
 var TenantsController = class {
   constructor() {
-    this.tenantStore = (0, import_core32.getStoreLattice)("default", "tenant").store;
+    this.tenantStore = (0, import_core34.getStoreLattice)("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -7972,7 +8319,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-var import_core33 = require("@axiom-lattice/core");
+var import_core35 = require("@axiom-lattice/core");
 var import_uuid8 = require("uuid");
 var defaultAuthConfig = {
   autoApproveUsers: true,
@@ -7981,9 +8328,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = (0, import_core33.getStoreLattice)("default", "user").store;
-    this.tenantStore = (0, import_core33.getStoreLattice)("default", "tenant").store;
-    this.userTenantLinkStore = (0, import_core33.getStoreLattice)("default", "userTenantLink").store;
+    this.userStore = (0, import_core35.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core35.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core35.getStoreLattice)("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -8141,7 +8488,7 @@ var AuthController = class {
       const linkMeta = link?.metadata || {};
       let personalAssistant = null;
       if (linkMeta.personalAssistantId) {
-        const assistantStore = (0, import_core33.getStoreLattice)("default", "assistant").store;
+        const assistantStore = (0, import_core35.getStoreLattice)("default", "assistant").store;
         const exists = await assistantStore.hasAssistant(tenantId, linkMeta.personalAssistantId);
         if (exists) {
           personalAssistant = {
@@ -8561,7 +8908,7 @@ var larkChannelAdapter = {
 };
 
 // src/channels/lark/verification.ts
-var import_crypto7 = __toESM(require("crypto"));
+var import_crypto8 = __toESM(require("crypto"));
 function parseLarkRequestBody(body, encryptKey) {
   const parsed = body || {};
   if (encryptKey && typeof parsed.encrypt === "string") {
@@ -8570,11 +8917,11 @@ function parseLarkRequestBody(body, encryptKey) {
   return parsed;
 }
 function decryptLarkPayload(encryptKey, encryptedPayload) {
-  const key = import_crypto7.default.createHash("sha256").update(encryptKey).digest();
+  const key = import_crypto8.default.createHash("sha256").update(encryptKey).digest();
   const buffer = Buffer.from(encryptedPayload, "base64");
   const iv = buffer.subarray(0, 16);
   const ciphertext = buffer.subarray(16);
-  const decipher = import_crypto7.default.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = import_crypto8.default.createDecipheriv("aes-256-cbc", key, iv);
   const plaintext = Buffer.concat([
     decipher.update(ciphertext),
     decipher.final()
@@ -8691,14 +9038,14 @@ function registerChannelRoutes(app2, dependencies) {
 }
 
 // src/controllers/channel-installations.ts
-var import_crypto8 = require("crypto");
+var import_crypto9 = require("crypto");
 var _adapterRegistry;
 var _router;
 function setChannelControllerDeps(deps) {
   _adapterRegistry = deps.adapterRegistry;
   _router = deps.router;
 }
-function getTenantId14(request) {
+function getTenantId15(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -8706,8 +9053,8 @@ function getTenantId14(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getInstallationStore() {
-  const { getStoreLattice: getStoreLattice18 } = await import("@axiom-lattice/core");
-  const store2 = getStoreLattice18("default", "channelInstallation").store;
+  const { getStoreLattice: getStoreLattice31 } = await import("@axiom-lattice/core");
+  const store2 = getStoreLattice31("default", "channelInstallation").store;
   if (store2) return store2;
   const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
   const databaseUrl = process.env.DATABASE_URL;
@@ -8719,7 +9066,7 @@ async function getInstallationStore() {
   });
 }
 async function getChannelInstallationList(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const { channel } = request.query;
   try {
     const store2 = await getInstallationStore();
@@ -8745,7 +9092,7 @@ async function getChannelInstallationList(request, reply) {
   }
 }
 async function getChannelInstallation(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const { installationId } = request.params;
   try {
     const store2 = await getInstallationStore();
@@ -8778,7 +9125,7 @@ async function getChannelInstallation(request, reply) {
   }
 }
 async function createChannelInstallation(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const body = request.body;
   try {
     if (!body.channel) {
@@ -8813,7 +9160,7 @@ async function createChannelInstallation(request, reply) {
       }
     }
     const store2 = await getInstallationStore();
-    const installationId = body.id || (0, import_crypto8.randomUUID)();
+    const installationId = body.id || (0, import_crypto9.randomUUID)();
     const installation = await store2.createInstallation(
       tenantId,
       installationId,
@@ -8851,7 +9198,7 @@ async function createChannelInstallation(request, reply) {
   }
 }
 async function updateChannelInstallation(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const { installationId } = request.params;
   const body = request.body;
   try {
@@ -8905,7 +9252,7 @@ async function updateChannelInstallation(request, reply) {
   }
 }
 async function deleteChannelInstallation(request, reply) {
-  const tenantId = getTenantId14(request);
+  const tenantId = getTenantId15(request);
   const { installationId } = request.params;
   try {
     const store2 = await getInstallationStore();
@@ -8965,17 +9312,17 @@ function registerChannelInstallationRoutes(app2) {
 }
 
 // src/controllers/channel-bindings.ts
-var import_core34 = require("@axiom-lattice/core");
-function getTenantId15(request) {
+var import_core36 = require("@axiom-lattice/core");
+function getTenantId16(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
 }
 async function getBindingList(request, _reply) {
-  const tenantId = getTenantId15(request);
+  const tenantId = getTenantId16(request);
   const { channel, agentId, channelInstallationId, limit, offset } = request.query;
   try {
-    const registry = (0, import_core34.getBindingRegistry)();
+    const registry = (0, import_core36.getBindingRegistry)();
     const bindings = await registry.list({ channel, agentId, tenantId, channelInstallationId, limit, offset });
     return { success: true, message: "Bindings retrieved", data: { records: bindings, total: bindings.length } };
   } catch (error) {
@@ -8984,9 +9331,9 @@ async function getBindingList(request, _reply) {
   }
 }
 async function getBinding(request, reply) {
-  const tenantId = getTenantId15(request);
+  const tenantId = getTenantId16(request);
   try {
-    const registry = (0, import_core34.getBindingRegistry)();
+    const registry = (0, import_core36.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const binding = bindings.find((b) => b.id === request.params.id);
     if (!binding || binding.tenantId !== tenantId) {
@@ -9000,9 +9347,9 @@ async function getBinding(request, reply) {
   }
 }
 async function createBinding(request, reply) {
-  const tenantId = getTenantId15(request);
+  const tenantId = getTenantId16(request);
   try {
-    const registry = (0, import_core34.getBindingRegistry)();
+    const registry = (0, import_core36.getBindingRegistry)();
     const binding = await registry.create({ ...request.body, tenantId });
     reply.status(201);
     return { success: true, message: "Binding created", data: binding };
@@ -9014,8 +9361,8 @@ async function createBinding(request, reply) {
 }
 async function updateBinding(request, reply) {
   try {
-    const tenantId = getTenantId15(request);
-    const registry = (0, import_core34.getBindingRegistry)();
+    const tenantId = getTenantId16(request);
+    const registry = (0, import_core36.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const existing = bindings.find((b) => b.id === request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
@@ -9032,8 +9379,8 @@ async function updateBinding(request, reply) {
 }
 async function deleteBinding(request, reply) {
   try {
-    const tenantId = getTenantId15(request);
-    const registry = (0, import_core34.getBindingRegistry)();
+    const tenantId = getTenantId16(request);
+    const registry = (0, import_core36.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const existing = bindings.find((b) => b.id === request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
@@ -9049,10 +9396,10 @@ async function deleteBinding(request, reply) {
   }
 }
 async function resolveBinding(request, _reply) {
-  const tenantId = getTenantId15(request);
+  const tenantId = getTenantId16(request);
   const { channel, senderId, channelInstallationId } = request.query;
   try {
-    const registry = (0, import_core34.getBindingRegistry)();
+    const registry = (0, import_core36.getBindingRegistry)();
     const binding = await registry.resolve({ channel, senderId, channelInstallationId, tenantId });
     if (!binding) {
       return { success: false, message: "No binding found", data: null };
@@ -9075,8 +9422,8 @@ function registerChannelBindingRoutes(app2) {
 }
 
 // src/controllers/menu-items.ts
-var import_core35 = require("@axiom-lattice/core");
-function getTenantId16(request) {
+var import_core37 = require("@axiom-lattice/core");
+function getTenantId17(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
@@ -9085,9 +9432,9 @@ function errorMessage(err) {
   return err instanceof Error ? err.message : "Unexpected error";
 }
 async function getMenuItemList(request, _reply) {
-  const tenantId = getTenantId16(request);
+  const tenantId = getTenantId17(request);
   try {
-    const registry = (0, import_core35.getMenuRegistry)();
+    const registry = (0, import_core37.getMenuRegistry)();
     const items = await registry.list({ tenantId, menuTarget: request.query.menuTarget });
     return { success: true, message: "Menu items retrieved", data: { records: items, total: items.length } };
   } catch (error) {
@@ -9097,9 +9444,9 @@ async function getMenuItemList(request, _reply) {
   }
 }
 async function getMenuItem(request, reply) {
-  const tenantId = getTenantId16(request);
+  const tenantId = getTenantId17(request);
   try {
-    const registry = (0, import_core35.getMenuRegistry)();
+    const registry = (0, import_core37.getMenuRegistry)();
     const item = await registry.getById(request.params.id);
     if (!item || item.tenantId !== tenantId) {
       reply.status(404);
@@ -9114,9 +9461,9 @@ async function getMenuItem(request, reply) {
   }
 }
 async function createMenuItem(request, reply) {
-  const tenantId = getTenantId16(request);
+  const tenantId = getTenantId17(request);
   try {
-    const registry = (0, import_core35.getMenuRegistry)();
+    const registry = (0, import_core37.getMenuRegistry)();
     const item = await registry.create({ ...request.body, tenantId });
     reply.status(201);
     return { success: true, message: "Menu item created", data: item };
@@ -9129,8 +9476,8 @@ async function createMenuItem(request, reply) {
 }
 async function updateMenuItem(request, reply) {
   try {
-    const tenantId = getTenantId16(request);
-    const registry = (0, import_core35.getMenuRegistry)();
+    const tenantId = getTenantId17(request);
+    const registry = (0, import_core37.getMenuRegistry)();
     const existing = await registry.getById(request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
       reply.status(404);
@@ -9147,8 +9494,8 @@ async function updateMenuItem(request, reply) {
 }
 async function deleteMenuItem(request, reply) {
   try {
-    const tenantId = getTenantId16(request);
-    const registry = (0, import_core35.getMenuRegistry)();
+    const tenantId = getTenantId17(request);
+    const registry = (0, import_core37.getMenuRegistry)();
     const existing = await registry.getById(request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
       reply.status(404);
@@ -9586,6 +9933,31 @@ var registerLatticeRoutes = (app2, channelDeps) => {
     "/api/assistants/:assistant_id/threads/:thread_id/pending-messages/:message_id",
     removePendingMessageHandler
   );
+  app2.get("/api/tenants/exportable-types", getExportableTypes);
+  app2.post(
+    "/api/tenants/:tenantId/export",
+    exportConfig
+  );
+  app2.post(
+    "/api/tenants/:tenantId/export/confirm",
+    exportConfigConfirm
+  );
+  app2.post(
+    "/api/tenants/:tenantId/export/entities",
+    previewEntities
+  );
+  app2.get(
+    "/api/tenants/:tenantId/export/:jobId/download",
+    downloadExport
+  );
+  app2.post(
+    "/api/tenants/:tenantId/import/preview",
+    importPreview
+  );
+  app2.post(
+    "/api/tenants/:tenantId/import/apply",
+    importApply
+  );
 };
 
 // src/routes/resource-routes.ts
@@ -9614,20 +9986,1328 @@ function registerResourceRoutes(app2, controller) {
   app2.delete("/api/resources/share/:token", controller.revokeShare.bind(controller));
 }
 
-// src/router/MessageRouter.ts
-var import_core36 = require("@axiom-lattice/core");
-var import_crypto9 = require("crypto");
-var BindingNotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BindingNotFoundError";
-  }
-};
-var MessageRouter = class {
-  constructor(config) {
-    /**
-     * Tracks reply subscriptions per thread+channel to avoid duplicate
-     * `subscribeOnce` registrations and ensure proper cleanup.
+// src/export_registrations/index.ts
+var import_core51 = require("@axiom-lattice/core");
+
+// src/export_registrations/skill.registration.ts
+var import_core38 = require("@axiom-lattice/core");
+function getStore2() {
+  return (0, import_core38.getStoreLattice)("default", "skill").store;
+}
+var skillRegistration = {
+  entityType: "skill",
+  label: "Skill(\u6280\u80FD)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore2();
+    const skills = await store2.getAllSkills(tenantId);
+    return skills.map((s) => ({
+      _exportId: "",
+      data: {
+        id: s.id,
+        name: s.name,
+        description: s.description,
+        license: s.license,
+        compatibility: s.compatibility,
+        metadata: s.metadata,
+        content: s.content,
+        subSkills: s.subSkills
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore2();
+    const existing = await store2.getAllSkills(tenantId);
+    const existingIds = new Set(existing.map((s) => s.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const id = entity.data.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "skill",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: entity.data.name || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "skill",
+          name: entity.data.name || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore2();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteSkill(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createSkill(tenantId, id, {
+      name: data.name,
+      description: data.description,
+      license: data.license,
+      compatibility: data.compatibility,
+      metadata: data.metadata,
+      content: data.content,
+      subSkills: data.subSkills
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/agent.registration.ts
+var import_core39 = require("@axiom-lattice/core");
+function getStore3() {
+  return (0, import_core39.getStoreLattice)("default", "assistant").store;
+}
+var agentRegistration = {
+  entityType: "agent",
+  label: "Agent(\u667A\u80FD\u4F53)",
+  category: "core",
+  dependsOn: ["skill"],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore3();
+    const agents = await store2.getAllAssistants(tenantId);
+    return agents.map((a) => ({
+      _exportId: "",
+      data: {
+        id: a.id,
+        name: a.name,
+        description: a.description,
+        graphDefinition: a.graphDefinition
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore3();
+    const existing = await store2.getAllAssistants(tenantId);
+    const existingIds = new Set(existing.map((a) => a.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const id = entity.data.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "agent",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: entity.data.name || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "agent",
+          name: entity.data.name || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore3();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteAssistant(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createAssistant(tenantId, id, {
+      name: data.name,
+      description: data.description || "",
+      graphDefinition: data.graphDefinition
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/binding.registration.ts
+var import_core40 = require("@axiom-lattice/core");
+function getStore4() {
+  return (0, import_core40.getStoreLattice)("default", "channelBinding").store;
+}
+var bindingRegistration = {
+  entityType: "binding",
+  label: "Binding(\u6E20\u9053\u7ED1\u5B9A)",
+  category: "core",
+  dependsOn: ["agent", "channel_installation"],
+  cascadeParents: [],
+  referenceFields: { agentId: "agent", channelInstallationId: "channel_installation" },
+  async listForExport(tenantId) {
+    const store2 = getStore4();
+    const bindings = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    return bindings.map((b) => ({
+      _exportId: "",
+      data: {
+        channel: b.channel,
+        channelInstallationId: b.channelInstallationId,
+        senderId: b.senderId,
+        agentId: b.agentId,
+        threadId: b.threadId,
+        workspaceId: b.workspaceId,
+        projectId: b.projectId,
+        threadMode: b.threadMode,
+        senderDisplayName: b.senderDisplayName,
+        senderMetadata: b.senderMetadata,
+        enabled: b.enabled
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore4();
+    const existing = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    const existingKeys = new Set(
+      existing.map((b) => `${b.channel}:${b.channelInstallationId}:${b.senderId}`)
+    );
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const key = `${d.channel}:${d.channelInstallationId}:${d.senderId}`;
+      if (existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "binding",
+          conflictType: "unique_constraint",
+          existingName: `${d.channel}:${d.senderId}`,
+          field: "channel+channelInstallationId+senderId"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "binding",
+          name: `${d.channel}:${d.senderId}`
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore4();
+    const d = entity.data;
+    if (resolution.action === "overwrite") {
+      const existing = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+      const match = existing.find(
+        (b) => b.channel === d.channel && b.channelInstallationId === d.channelInstallationId && b.senderId === d.senderId
+      );
+      if (match) {
+        await store2.delete(match.id);
+      }
+    }
+    await store2.create({
+      channel: d.channel,
+      channelInstallationId: d.channelInstallationId,
+      tenantId,
+      senderId: d.senderId,
+      agentId: d.agentId,
+      threadMode: d.threadMode || "fixed",
+      senderDisplayName: d.senderDisplayName,
+      senderMetadata: d.senderMetadata,
+      workspaceId: d.workspaceId,
+      projectId: d.projectId
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/database-config.registration.ts
+var import_core41 = require("@axiom-lattice/core");
+function getStore5() {
+  return (0, import_core41.getStoreLattice)("default", "database").store;
+}
+var databaseConfigRegistration = {
+  entityType: "database_config",
+  label: "Database Config(\u6570\u636E\u5E93\u914D\u7F6E)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore5();
+    const configs = await store2.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore5();
+    const existing = await store2.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      const key = d.key;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "database_config",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || key
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "database_config",
+          conflictType: "unique_constraint",
+          existingName: d.name || key,
+          field: "key"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "database_config",
+          name: d.name || key
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore5();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteConfig(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createConfig(tenantId, id, {
+      key: data.key,
+      name: data.name,
+      description: data.description,
+      config: data.config
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/metrics-config.registration.ts
+var import_core42 = require("@axiom-lattice/core");
+function getStore6() {
+  return (0, import_core42.getStoreLattice)("default", "metrics").store;
+}
+var metricsConfigRegistration = {
+  entityType: "metrics_config",
+  label: "Metrics Config(\u6307\u6807\u914D\u7F6E)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore6();
+    const configs = await store2.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore6();
+    const existing = await store2.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      const key = d.key;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "metrics_config",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || key
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "metrics_config",
+          conflictType: "unique_constraint",
+          existingName: d.name || key,
+          field: "key"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "metrics_config",
+          name: d.name || key
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore6();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteConfig(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createConfig(tenantId, id, {
+      key: data.key,
+      name: data.name,
+      description: data.description,
+      config: data.config
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/mcp-config.registration.ts
+var import_core43 = require("@axiom-lattice/core");
+function getStore7() {
+  return (0, import_core43.getStoreLattice)("default", "mcp").store;
+}
+var mcpConfigRegistration = {
+  entityType: "mcp_config",
+  label: "MCP Config(MCP\u914D\u7F6E)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore7();
+    const configs = await store2.getAllConfigs(tenantId);
+    return configs.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config,
+        selectedTools: c.selectedTools,
+        status: c.status
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore7();
+    const existing = await store2.getAllConfigs(tenantId);
+    const existingIds = new Set(existing.map((c) => c.id));
+    const existingKeys = new Set(existing.map((c) => c.key));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      const key = d.key;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "mcp_config",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || key
+        });
+      } else if (key && existingKeys.has(key)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "mcp_config",
+          conflictType: "unique_constraint",
+          existingName: d.name || key,
+          field: "key"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "mcp_config",
+          name: d.name || key
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore7();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteConfig(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createConfig(tenantId, id, {
+      key: data.key,
+      name: data.name,
+      description: data.description,
+      config: data.config,
+      selectedTools: data.selectedTools
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/connection.registration.ts
+var import_core44 = require("@axiom-lattice/core");
+function getStore8() {
+  return (0, import_core44.getStoreLattice)("default", "connection").store;
+}
+async function listAllConnections(tenantId) {
+  const store2 = getStore8();
+  if (typeof store2.listByTenant !== "function") {
+    throw new Error("ConnectionStore.listByTenant is not implemented. SQL bypass removed \u2014 upgrade your store adapter.");
+  }
+  return store2.listByTenant(tenantId);
+}
+var connectionRegistration = {
+  entityType: "connection",
+  label: "Connection(\u8FDE\u63A5)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const connections2 = await listAllConnections(tenantId);
+    return connections2.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        type: c.type,
+        key: c.key,
+        name: c.name,
+        description: c.description,
+        config: c.config
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const existing = await listAllConnections(tenantId);
+    const existingCompositeKeys = new Set(
+      existing.map((c) => `${c.type}:${c.key}`)
+    );
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const compositeKey = `${d.type}:${d.key}`;
+      if (existingCompositeKeys.has(compositeKey)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "connection",
+          conflictType: "unique_constraint",
+          existingName: `${d.type}:${d.key}`,
+          field: "type+key"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "connection",
+          name: `${d.type}:${d.key}`
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore8();
+    const d = entity.data;
+    const type = d.type;
+    const key = d.key;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.delete(tenantId, type, key);
+      } catch {
+      }
+    }
+    await store2.create({
+      tenantId,
+      type,
+      key,
+      name: d.name,
+      description: d.description,
+      config: d.config
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/collection.registration.ts
+var import_core45 = require("@axiom-lattice/core");
+function getStore9() {
+  return (0, import_core45.getStoreLattice)("default", "collection").store;
+}
+var collectionRegistration = {
+  entityType: "collection",
+  label: "Collection(\u77E5\u8BC6\u5E93)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore9();
+    const collections = await store2.getAllCollections(tenantId);
+    return collections.map((c) => ({
+      _exportId: "",
+      data: {
+        id: c.id,
+        name: c.name,
+        label: c.label,
+        embeddingKey: c.embeddingKey,
+        schema: c.schema
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore9();
+    const existing = await store2.getAllCollections(tenantId);
+    const existingNames = new Set(existing.map((c) => c.name));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const name = d.name;
+      if (existingNames.has(name)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "collection",
+          conflictType: "unique_constraint",
+          existingName: name,
+          field: "name"
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "collection",
+          name
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore9();
+    const d = entity.data;
+    const name = d.name;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteCollection(tenantId, name);
+      } catch {
+      }
+    }
+    await store2.createCollection(tenantId, {
+      name,
+      label: d.label,
+      embeddingKey: d.embeddingKey,
+      schema: d.schema
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/channel-installation.registration.ts
+var import_core46 = require("@axiom-lattice/core");
+function getStore10() {
+  return (0, import_core46.getStoreLattice)("default", "channelInstallation").store;
+}
+var channelInstallationRegistration = {
+  entityType: "channel_installation",
+  label: "Channel Installation(\u6E20\u9053\u5B89\u88C5)",
+  category: "core",
+  dependsOn: ["agent"],
+  cascadeParents: [],
+  referenceFields: { fallbackAgentId: "agent" },
+  async listForExport(tenantId) {
+    const store2 = getStore10();
+    const installations = await store2.getInstallationsByTenant(tenantId);
+    return installations.map((i) => ({
+      _exportId: "",
+      data: {
+        id: i.id,
+        channel: i.channel,
+        name: i.name,
+        config: i.config,
+        enabled: i.enabled,
+        fallbackAgentId: i.fallbackAgentId,
+        rejectWhenNoBinding: i.rejectWhenNoBinding
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore10();
+    const existing = await store2.getInstallationsByTenant(tenantId);
+    const existingIds = new Set(existing.map((i) => i.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "channel_installation",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "channel_installation",
+          name: d.name || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore10();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.deleteInstallation(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.createInstallation(tenantId, id, {
+      channel: data.channel,
+      name: data.name,
+      config: data.config,
+      enabled: data.enabled,
+      fallbackAgentId: data.fallbackAgentId,
+      rejectWhenNoBinding: data.rejectWhenNoBinding
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/menu.registration.ts
+var import_core47 = require("@axiom-lattice/core");
+function getStore11() {
+  return (0, import_core47.getStoreLattice)("default", "menu").store;
+}
+var menuRegistration = {
+  entityType: "menu",
+  label: "Menu(\u83DC\u5355)",
+  category: "core",
+  dependsOn: ["agent"],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore11();
+    const menus = await store2.list({ tenantId });
+    return menus.map((m) => ({
+      _exportId: "",
+      data: {
+        id: m.id,
+        menuTarget: m.menuTarget,
+        group: m.group,
+        name: m.name,
+        icon: m.icon,
+        sortOrder: m.sortOrder,
+        contentType: m.contentType,
+        contentConfig: m.contentConfig,
+        enabled: m.enabled
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore11();
+    const existing = await store2.list({ tenantId });
+    const existingIds = new Set(existing.map((m) => m.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "menu",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.name || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "menu",
+          name: d.name || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore11();
+    const d = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : d.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.delete(id);
+      } catch {
+      }
+    }
+    await store2.create({
+      tenantId,
+      menuTarget: d.menuTarget,
+      group: d.group,
+      name: d.name,
+      icon: d.icon,
+      sortOrder: d.sortOrder,
+      contentType: d.contentType,
+      contentConfig: d.contentConfig
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/task.registration.ts
+var import_core48 = require("@axiom-lattice/core");
+function getStore12() {
+  return (0, import_core48.getStoreLattice)("default", "task").store;
+}
+var taskRegistration = {
+  entityType: "task",
+  label: "Task(\u4EFB\u52A1)",
+  category: "core",
+  dependsOn: ["agent"],
+  cascadeParents: [],
+  referenceFields: { ownerId: "agent", parentId: "task" },
+  async listForExport(tenantId) {
+    const store2 = getStore12();
+    const tasks = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    return tasks.map((t) => ({
+      _exportId: "",
+      data: {
+        id: t.id,
+        title: t.title,
+        description: t.description,
+        status: t.status,
+        priority: t.priority,
+        dueDate: t.dueDate,
+        ownerType: t.ownerType,
+        ownerId: t.ownerId,
+        metadata: t.metadata,
+        parentId: t.parentId,
+        sourceId: t.sourceId,
+        context: t.context
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore12();
+    const existing = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    const existingIds = new Set(existing.map((t) => t.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "task",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.title || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "task",
+          name: d.title || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    const store2 = getStore12();
+    const data = entity.data;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : data.id;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.delete(tenantId, id);
+      } catch {
+      }
+    }
+    await store2.create({
+      tenantId,
+      ownerType: data.ownerType || "user",
+      ownerId: data.ownerId || "",
+      title: data.title,
+      description: data.description,
+      status: data.status,
+      priority: data.priority,
+      dueDate: data.dueDate,
+      metadata: data.metadata,
+      parentId: data.parentId,
+      sourceId: data.sourceId,
+      context: data.context
+    });
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/a2a-api-key.registration.ts
+var import_core49 = require("@axiom-lattice/core");
+function getStore13() {
+  return (0, import_core49.getStoreLattice)("default", "a2aApiKey").store;
+}
+var a2aApiKeyRegistration = {
+  entityType: "a2a_api_key",
+  label: "A2A API Key(API\u5BC6\u94A5)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  async listForExport(tenantId) {
+    const store2 = getStore13();
+    const keys = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    return keys.map((k) => ({
+      _exportId: "",
+      data: {
+        id: k.id,
+        tenantId: k.tenantId,
+        projectId: k.projectId,
+        workspaceId: k.workspaceId,
+        label: k.label,
+        enabled: k.enabled
+      }
+    }));
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore13();
+    const existing = await store2.list({ tenantId, limit: 1e4, offset: 0 });
+    const existingIds = new Set(existing.map((k) => k.id));
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const id = d.id;
+      if (existingIds.has(id)) {
+        conflicts.push({
+          _exportId: entity._exportId,
+          entityType: "a2a_api_key",
+          conflictType: "id_exists",
+          existingId: id,
+          existingName: d.label || id
+        });
+      } else {
+        insertions.push({
+          _exportId: entity._exportId,
+          entityType: "a2a_api_key",
+          name: d.label || id
+        });
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore13();
+    const d = entity.data;
+    if (resolution.action === "overwrite") {
+      try {
+        await store2.delete(d.id);
+      } catch {
+      }
+    }
+    await store2.create({
+      tenantId,
+      projectId: d.projectId,
+      workspaceId: d.workspaceId,
+      label: d.label
+    });
+    return { newId: void 0 };
+  }
+};
+
+// src/export_registrations/eval.registration.ts
+var import_core50 = require("@axiom-lattice/core");
+function getStore14() {
+  return (0, import_core50.getStoreLattice)("default", "eval").store;
+}
+var evalRegistration = {
+  entityType: "eval",
+  label: "Eval(\u8BC4\u4F30)",
+  category: "core",
+  dependsOn: [],
+  cascadeParents: [],
+  referenceFields: { suiteId: "eval_suite", projectId: "eval_project", runId: "eval_run", caseId: "eval_case" },
+  async listForExport(tenantId) {
+    const store2 = getStore14();
+    const projects = await store2.getProjectsByTenant(tenantId);
+    const entities = [];
+    for (const project of projects) {
+      entities.push({
+        _exportId: "",
+        data: {
+          _subType: "eval_project",
+          id: project.id,
+          name: project.name,
+          description: project.description,
+          version: project.version,
+          judgeModelConfig: project.judgeModelConfig,
+          targetServerConfig: project.targetServerConfig,
+          concurrency: project.concurrency,
+          reportConfig: project.reportConfig
+        }
+      });
+      const suites = await store2.getSuitesByProject(tenantId, project.id);
+      for (const suite of suites) {
+        entities.push({
+          _exportId: "",
+          data: {
+            _subType: "eval_suite",
+            id: suite.id,
+            projectId: suite.projectId,
+            name: suite.name
+          }
+        });
+        const cases = await store2.getCasesBySuite(tenantId, suite.id);
+        for (const c of cases) {
+          entities.push({
+            _exportId: "",
+            data: {
+              _subType: "eval_case",
+              id: c.id,
+              suiteId: c.suiteId,
+              inputMessage: c.inputMessage,
+              inputFiles: c.inputFiles,
+              steps: c.steps,
+              outputType: c.outputType,
+              contentAssertion: c.contentAssertion,
+              rubrics: c.rubrics
+            }
+          });
+        }
+      }
+      const runs = await store2.getRunsByTenant(tenantId, { projectId: project.id });
+      for (const run of runs) {
+        entities.push({
+          _exportId: "",
+          data: {
+            _subType: "eval_run",
+            id: run.id,
+            projectId: run.projectId,
+            status: run.status,
+            concurrency: run.concurrency,
+            totalCases: run.totalCases,
+            passedCases: run.passedCases,
+            failedCases: run.failedCases,
+            avgScore: run.avgScore,
+            error: run.error
+          }
+        });
+        const results = await store2.getResultsByRun(tenantId, run.id);
+        for (const result of results) {
+          entities.push({
+            _exportId: "",
+            data: {
+              _subType: "eval_run_result",
+              id: result.id,
+              runId: result.runId,
+              suiteName: result.suiteName,
+              caseId: result.caseId,
+              pass: result.pass,
+              score: result.score,
+              summary: result.summary,
+              dimensionResults: result.dimensionResults,
+              durationMs: result.durationMs,
+              messages: result.messages,
+              logs: result.logs,
+              error: result.error
+            }
+          });
+        }
+      }
+    }
+    return entities;
+  },
+  async previewImport(tenantId, entities) {
+    const store2 = getStore14();
+    const existingProjects = await store2.getProjectsByTenant(tenantId);
+    const existingProjectIds = new Set(existingProjects.map((p) => p.id));
+    const existingProjectNames = new Set(existingProjects.map((p) => p.name));
+    const existingSuites = /* @__PURE__ */ new Map();
+    const existingSuiteIds = /* @__PURE__ */ new Set();
+    const existingCaseIds = /* @__PURE__ */ new Set();
+    const existingRunIds = /* @__PURE__ */ new Set();
+    const existingResultIds = /* @__PURE__ */ new Set();
+    for (const project of existingProjects) {
+      const suites = await store2.getSuitesByProject(tenantId, project.id);
+      existingSuites.set(project.id, new Set(suites.map((s) => `${s.projectId}:${s.name}`)));
+      for (const s of suites) {
+        existingSuiteIds.add(s.id);
+        try {
+          const cases = await store2.getCasesBySuite(tenantId, s.id);
+          for (const c of cases) existingCaseIds.add(c.id);
+        } catch {
+        }
+      }
+    }
+    for (const project of existingProjects) {
+      const runs = await store2.getRunsByTenant(tenantId, { projectId: project.id });
+      for (const run of runs) {
+        existingRunIds.add(run.id);
+        try {
+          const results = await store2.getResultsByRun(tenantId, run.id);
+          for (const r of results) existingResultIds.add(r.id);
+        } catch {
+        }
+      }
+    }
+    const conflicts = [];
+    const insertions = [];
+    for (const entity of entities) {
+      const d = entity.data;
+      const subType = d._subType;
+      const id = d.id;
+      switch (subType) {
+        case "eval_project": {
+          const name = d.name;
+          if (existingProjectIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_project",
+              conflictType: "id_exists",
+              existingId: id,
+              existingName: name
+            });
+          } else if (name && existingProjectNames.has(name)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_project",
+              conflictType: "unique_constraint",
+              existingName: name,
+              field: "name"
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_project", name });
+          }
+          break;
+        }
+        case "eval_suite": {
+          const projectId = d.projectId;
+          const name = d.name;
+          const suiteKey = `${projectId}:${name}`;
+          const projectSuites = existingSuites.get(projectId);
+          if (existingSuiteIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_suite",
+              conflictType: "id_exists",
+              existingId: id,
+              existingName: name
+            });
+          } else if (projectSuites?.has(suiteKey)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_suite",
+              conflictType: "unique_constraint",
+              existingName: name,
+              field: "projectId+name"
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_suite", name });
+          }
+          break;
+        }
+        case "eval_case": {
+          if (existingCaseIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_case",
+              conflictType: "id_exists",
+              existingId: id
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_case", name: id });
+          }
+          break;
+        }
+        case "eval_run": {
+          if (existingRunIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_run",
+              conflictType: "id_exists",
+              existingId: id
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_run", name: id });
+          }
+          break;
+        }
+        case "eval_run_result": {
+          if (existingResultIds.has(id)) {
+            conflicts.push({
+              _exportId: entity._exportId,
+              entityType: "eval_run_result",
+              conflictType: "id_exists",
+              existingId: id
+            });
+          } else {
+            insertions.push({ _exportId: entity._exportId, entityType: "eval_run_result", name: id });
+          }
+          break;
+        }
+      }
+    }
+    return { conflicts, insertions, errors: [] };
+  },
+  async applyImport(tenantId, entity, resolution) {
+    if (resolution.action === "skip") return {};
+    const store2 = getStore14();
+    const d = entity.data;
+    const subType = d._subType;
+    const id = resolution.action === "rename" && resolution.newId ? resolution.newId : d.id;
+    switch (subType) {
+      case "eval_project": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteProject(tenantId, id);
+          } catch {
+          }
+        }
+        await store2.createProject(tenantId, id, {
+          name: d.name,
+          description: d.description,
+          version: d.version,
+          judgeModelConfig: d.judgeModelConfig,
+          targetServerConfig: d.targetServerConfig,
+          concurrency: d.concurrency,
+          reportConfig: d.reportConfig
+        });
+        break;
+      }
+      case "eval_suite": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteSuite(tenantId, id);
+          } catch {
+          }
+        }
+        await store2.createSuite(tenantId, d.projectId, id, {
+          name: d.name
+        });
+        break;
+      }
+      case "eval_case": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteCase(tenantId, id);
+          } catch {
+          }
+        }
+        await store2.createCase(tenantId, d.suiteId, id, {
+          inputMessage: d.inputMessage,
+          inputFiles: d.inputFiles,
+          steps: d.steps,
+          outputType: d.outputType,
+          contentAssertion: d.contentAssertion,
+          rubrics: d.rubrics
+        });
+        break;
+      }
+      case "eval_run": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteRun(tenantId, id);
+          } catch {
+          }
+        }
+        await store2.createRun(tenantId, d.projectId, id, {
+          totalCases: d.totalCases,
+          concurrency: d.concurrency
+        });
+        break;
+      }
+      case "eval_run_result": {
+        if (resolution.action === "overwrite") {
+          try {
+            await store2.deleteRunResult(tenantId, entity.data.id);
+          } catch {
+          }
+        }
+        await store2.createRunResult(tenantId, d.runId, id, {
+          suiteName: d.suiteName,
+          caseId: d.caseId,
+          pass: d.pass,
+          score: d.score,
+          summary: d.summary,
+          dimensionResults: d.dimensionResults,
+          durationMs: d.durationMs,
+          messages: d.messages,
+          logs: d.logs,
+          error: d.error
+        });
+        break;
+      }
+    }
+    return { newId: id };
+  }
+};
+
+// src/export_registrations/index.ts
+function registerAllBuiltinEntities() {
+  const registry = import_core51.ExportableEntityRegistry.getInstance();
+  registry.register(skillRegistration);
+  registry.register(agentRegistration);
+  registry.register(bindingRegistration);
+  registry.register(databaseConfigRegistration);
+  registry.register(metricsConfigRegistration);
+  registry.register(mcpConfigRegistration);
+  registry.register(connectionRegistration);
+  registry.register(collectionRegistration);
+  registry.register(channelInstallationRegistration);
+  registry.register(menuRegistration);
+  registry.register(taskRegistration);
+  registry.register(a2aApiKeyRegistration);
+  registry.register(evalRegistration);
+}
+
+// src/router/MessageRouter.ts
+var import_core52 = require("@axiom-lattice/core");
+var import_crypto10 = require("crypto");
+var BindingNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BindingNotFoundError";
+  }
+};
+var MessageRouter = class {
+  constructor(config) {
+    /**
+     * Tracks reply subscriptions per thread+channel to avoid duplicate
+     * `subscribeOnce` registrations and ensure proper cleanup.
      *
      * Key format: `{threadId}:{adapterChannel}:reply`
      */
@@ -9776,7 +11456,7 @@ var MessageRouter = class {
             channel: message.channel,
             adapterChannel: adapter.channel
           }, "Thread resolved by adapter strategy");
-          const threadStore = (0, import_core36.getStoreLattice)("default", "thread").store;
+          const threadStore = (0, import_core52.getStoreLattice)("default", "thread").store;
           try {
             await threadStore.createThread(
               tenantId,
@@ -9813,8 +11493,8 @@ var MessageRouter = class {
           }
         }
         if (!threadId) {
-          const threadStore = (0, import_core36.getStoreLattice)("default", "thread").store;
-          const newThreadId = (0, import_crypto9.randomUUID)();
+          const threadStore = (0, import_core52.getStoreLattice)("default", "thread").store;
+          const newThreadId = (0, import_crypto10.randomUUID)();
           console.log({
             event: "dispatch:thread:create",
             agentId,
@@ -9853,7 +11533,7 @@ var MessageRouter = class {
           senderId: message.sender.id,
           contentLength: message.content.text.length
         }, "Dispatching to agent");
-        const agent = import_core36.agentInstanceManager.getAgent({
+        const agent = import_core52.agentInstanceManager.getAgent({
           tenant_id: tenantId,
           assistant_id: agentId,
           thread_id: threadId,
@@ -10098,7 +11778,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core40 = require("@axiom-lattice/core");
+var import_core56 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -10163,7 +11843,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core37 = require("@axiom-lattice/core");
+var import_core53 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -10181,17 +11861,17 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = import_core37.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
-    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core37.QueueMode.STEER);
+    const agent = import_core53.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core53.QueueMode.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
-        import_core37.eventBus.publish(callback_event, {
+        import_core53.eventBus.publish(callback_event, {
           success: true,
           state: evt.state
         });
         if (main_thread_id && main_tenant_id) {
           try {
-            const mainAgent = import_core37.agentInstanceManager.getAgent({
+            const mainAgent = import_core53.agentInstanceManager.getAgent({
               assistant_id: main_assistant_id ?? assistant_id,
               thread_id: main_thread_id,
               tenant_id: main_tenant_id,
@@ -10221,7 +11901,7 @@ ${summary}`
         }
       });
       agent.subscribeOnce("message:interrupted", (evt) => {
-        import_core37.eventBus.publish(callback_event, {
+        import_core53.eventBus.publish(callback_event, {
           success: true,
           state: evt.state
         });
@@ -10244,7 +11924,7 @@ ${summary}`
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core37.eventBus.publish(callback_event, {
+      import_core53.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -10281,7 +11961,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core37.eventBus.subscribe(import_core37.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core53.eventBus.subscribe(import_core53.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -10400,7 +12080,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core37.eventBus.publish(taskRequest.callback_event, {
+        import_core53.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error)
         });
@@ -10415,7 +12095,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core41 = require("@axiom-lattice/core");
+var import_core57 = require("@axiom-lattice/core");
 var import_protocols5 = require("@axiom-lattice/protocols");
 var import_meta = {};
 process.on("unhandledRejection", (reason, promise) => {
@@ -10431,11 +12111,11 @@ var DEFAULT_LOGGER_CONFIG = {
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger5 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core41.loggerLatticeManager.hasLattice("default")) {
-    import_core41.loggerLatticeManager.removeLattice("default");
+  if (import_core57.loggerLatticeManager.hasLattice("default")) {
+    import_core57.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core41.registerLoggerLattice)("default", config);
-  return (0, import_core41.getLoggerLattice)("default");
+  (0, import_core57.registerLoggerLattice)("default", config);
+  return (0, import_core57.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -10546,7 +12226,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core41.createSandboxProvider)({
+  return (0, import_core57.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -10562,7 +12242,7 @@ function getConfiguredSandboxProvider() {
 }
 async function restoreMcpConnections() {
   try {
-    const storeLattice = (0, import_core41.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core57.getStoreLattice)("default", "mcp");
     const store2 = storeLattice.store;
     if (!store2) {
       logger5.info("MCP store not configured, skipping connection restoration");
@@ -10576,15 +12256,15 @@ async function restoreMcpConnections() {
     for (const config of connectedConfigs) {
       try {
         const connection = convertToConnection2(config.config);
-        import_core41.mcpManager.addServer(config.key, connection);
+        import_core57.mcpManager.addServer(config.key, connection);
       } catch (err) {
         logger5.warn(`Failed to prepare MCP server "${config.key}" for restoration`, { error: err });
       }
     }
-    await import_core41.mcpManager.connect();
+    await import_core57.mcpManager.connect();
     for (const config of connectedConfigs) {
       try {
-        await import_core41.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
+        await import_core57.mcpManager.registerToolsToToolLattice(config.key, config.selectedTools);
         logger5.info(`MCP server "${config.key}" restored with ${config.selectedTools.length} tools`);
       } catch (err) {
         logger5.warn(`Failed to register tools for MCP server "${config.key}"`, { error: err });
@@ -10614,10 +12294,10 @@ var start = async (config) => {
     const { wechatChannelAdapter: wechatChannelAdapter2 } = await Promise.resolve().then(() => (init_WechatChannelAdapter(), WechatChannelAdapter_exports));
     adapterRegistry.register(wechatChannelAdapter2);
     try {
-      const { getStoreLattice: getStore2 } = await import("@axiom-lattice/core");
-      const bindingStore = getStore2("default", "channelBinding").store;
-      const installationStore = getStore2("default", "channelInstallation").store;
-      (0, import_core40.setBindingRegistry)(bindingStore);
+      const { getStoreLattice: getStore15 } = await import("@axiom-lattice/core");
+      const bindingStore = getStore15("default", "channelBinding").store;
+      const installationStore = getStore15("default", "channelInstallation").store;
+      (0, import_core56.setBindingRegistry)(bindingStore);
       const router = new MessageRouter({
         middlewares: [
           createDeduplicationMiddleware(),
@@ -10630,7 +12310,7 @@ var start = async (config) => {
       });
       channelDeps = { router, installationStore };
       try {
-        const a2aKeyStore = getStore2("default", "a2aApiKey").store;
+        const a2aKeyStore = getStore15("default", "a2aApiKey").store;
         const a2a = await Promise.resolve().then(() => (init_a2a(), a2a_exports));
         a2a.setA2AKeyStore(a2aKeyStore);
         await a2a.refreshStoreKeyMap();
@@ -10642,28 +12322,29 @@ var start = async (config) => {
         error: err instanceof Error ? err.message : String(err)
       });
     }
-    (0, import_core40.setEvalRunService)(evalRunner);
+    (0, import_core56.setEvalRunService)(evalRunner);
     try {
-      const menuStore = (0, import_core41.getStoreLattice)("default", "menu").store;
-      (0, import_core40.setMenuRegistry)(menuStore);
+      const menuStore = (0, import_core57.getStoreLattice)("default", "menu").store;
+      (0, import_core56.setMenuRegistry)(menuStore);
       logger5.info("Menu registry initialized");
     } catch {
     }
+    registerAllBuiltinEntities();
     if (channelDeps?.router) {
       setChannelControllerDeps({ adapterRegistry, router: channelDeps.router });
     }
     registerLatticeRoutes(app, channelDeps);
-    if (!import_core41.sandboxLatticeManager.hasLattice("default")) {
-      import_core41.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    if (!import_core57.sandboxLatticeManager.hasLattice("default")) {
+      import_core57.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger5.info("Registered sandbox manager from env configuration");
     }
     try {
       const { ResourceController: ResourceController2 } = await Promise.resolve().then(() => (init_resources(), resources_exports));
-      const sharedResourceStore = (0, import_core41.getStoreLattice)("default", "sharedResource").store;
-      const cache = new import_core41.TokenCache();
+      const sharedResourceStore = (0, import_core57.getStoreLattice)("default", "sharedResource").store;
+      const cache = new import_core57.TokenCache();
       const resourceController = new ResourceController2({
         store: sharedResourceStore,
-        sandboxManager: import_core41.sandboxLatticeManager,
+        sandboxManager: import_core57.sandboxLatticeManager,
         cache,
         logger: logger5
       });
@@ -10704,7 +12385,7 @@ var start = async (config) => {
       }
     }
     if (process.env.AXIOM_RESTORE_PENDING_ON_STARTUP === "true") {
-      import_core41.agentInstanceManager.restore().then((stats) => {
+      import_core57.agentInstanceManager.restore().then((stats) => {
         logger5.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
       }).catch((error) => {
         logger5.error("Agent recovery failed", { error });