@axiom-lattice/gateway 2.1.63 → 2.1.64

package/dist/index.js

@@ -1734,6 +1734,296 @@ async function executeSqlQuery(client, body, reply) {
   };
 }
 
+// src/controllers/workflow-tracking.ts
+var import_core13 = require("@axiom-lattice/core");
+function getTenantId6(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return request.headers["x-tenant-id"] || "default";
+}
+function getTrackingStore() {
+  try {
+    const storeLattice = (0, import_core13.getStoreLattice)("default", "workflowTracking");
+    return storeLattice.store;
+  } catch {
+    return null;
+  }
+}
+async function getDefinitionsFromAssistants(tenantId) {
+  try {
+    const storeLattice = (0, import_core13.getStoreLattice)("default", "assistant");
+    const assistantStore = storeLattice.store;
+    const assistants = await assistantStore.getAllAssistants(tenantId);
+    const results = [];
+    for (const a of assistants) {
+      const def = a.graphDefinition;
+      if (!def || def.type !== "processing") continue;
+      if (!def.middleware) continue;
+      for (const mw of def.middleware) {
+        if (mw.type === "topology" && mw.enabled && mw.config?.edges?.length > 0) {
+          results.push({
+            assistantId: a.id,
+            assistantName: a.name,
+            topologyEdges: mw.config.edges,
+            totalEdges: mw.config.edges.length
+          });
+        }
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+async function getAllWorkflowDefinitions(request, reply) {
+  const tenantId = getTenantId6(request);
+  try {
+    const configDefs = await getDefinitionsFromAssistants(tenantId);
+    if (configDefs.length === 0) {
+      return {
+        success: true,
+        message: "No workflow definitions found",
+        data: { records: [] }
+      };
+    }
+    const runMap = /* @__PURE__ */ new Map();
+    try {
+      const store = getTrackingStore();
+      if (store) {
+        const runs = await store.getWorkflowRunsByTenantId(tenantId);
+        for (const r of runs) {
+          const entry = runMap.get(r.assistantId) || { runCount: 0 };
+          entry.runCount++;
+          if (!entry.lastRunAt || new Date(r.startedAt) > new Date(entry.lastRunAt)) {
+            entry.lastRunAt = r.startedAt instanceof Date ? r.startedAt.toISOString() : String(r.startedAt);
+          }
+          runMap.set(r.assistantId, entry);
+        }
+      }
+    } catch {
+    }
+    const definitions = configDefs.map((d) => {
+      const runInfo = runMap.get(d.assistantId);
+      return {
+        ...d,
+        lastRunAt: runInfo?.lastRunAt || null,
+        runCount: runInfo?.runCount || 0
+      };
+    });
+    return {
+      success: true,
+      message: "Successfully retrieved workflow definitions",
+      data: { records: definitions }
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow definitions");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow definitions" });
+  }
+}
+async function getAllWorkflowRuns(request, reply) {
+  const tenantId = getTenantId6(request);
+  const { assistantId, status } = request.query;
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+    let runs;
+    if (assistantId) {
+      runs = await store.getWorkflowRunsByAssistantId(tenantId, assistantId);
+    } else {
+      runs = await store.getWorkflowRunsByTenantId(tenantId);
+    }
+    if (status) {
+      runs = runs.filter((r) => r.status === status);
+    }
+    return {
+      success: true,
+      message: "Successfully retrieved workflow runs",
+      data: { records: runs, total: runs.length }
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow runs");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow runs" });
+  }
+}
+async function getInboxItems(request, reply) {
+  const tenantId = getTenantId6(request);
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return { success: true, message: "No tracking store configured", data: { records: [] } };
+    }
+    const nameMap = {};
+    try {
+      const asStoreLattice = (0, import_core13.getStoreLattice)("default", "assistant");
+      const assistantStore = asStoreLattice.store;
+      const assistants = await assistantStore.getAllAssistants(tenantId);
+      for (const a of assistants) {
+        nameMap[a.id] = a.name;
+      }
+    } catch {
+    }
+    const runs = await store.getWorkflowRunsByTenantId(tenantId);
+    const runningRuns = runs.filter((r) => r.status === "running");
+    if (runningRuns.length === 0) {
+      return { success: true, message: "No running workflows", data: { records: [] } };
+    }
+    const inboxItems = [];
+    for (const r of runningRuns) {
+      try {
+        const agent = import_core13.agentInstanceManager.getAgent({
+          assistant_id: r.assistantId,
+          thread_id: r.threadId,
+          tenant_id: r.tenantId
+        });
+        const runStatus = await agent.getRunStatus();
+        if (runStatus !== "interrupted") continue;
+        const state = await agent.getCurrentState();
+        const interrupts = state.tasks?.flatMap((t) => t.interrupts || []) || [];
+        for (const i of interrupts) {
+          inboxItems.push({
+            runId: r.id,
+            assistantId: r.assistantId,
+            assistantName: nameMap[r.assistantId] || r.assistantId,
+            threadId: r.threadId,
+            tenantId: r.tenantId,
+            interruptId: i.id,
+            interruptValue: i.value,
+            startedAt: r.startedAt,
+            totalEdges: r.totalEdges,
+            completedEdges: r.completedEdges
+          });
+        }
+      } catch {
+      }
+    }
+    inboxItems.sort(
+      (a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()
+    );
+    return {
+      success: true,
+      message: "Successfully retrieved inbox items",
+      data: { records: inboxItems }
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get inbox items");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve inbox items" });
+  }
+}
+async function getWorkflowDefinitions(request, reply) {
+  const { assistantId } = request.params;
+  const tenantId = getTenantId6(request);
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+    const runs = await store.getWorkflowRunsByAssistantId(tenantId, assistantId);
+    const seen = /* @__PURE__ */ new Set();
+    const definitions = runs.filter((r) => {
+      const key = JSON.stringify(r.topologyEdges);
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    }).map((r) => ({
+      assistantId: r.assistantId,
+      topologyEdges: r.topologyEdges,
+      totalEdges: r.totalEdges,
+      lastRunAt: r.startedAt
+    }));
+    return {
+      success: true,
+      message: "Successfully retrieved workflow definitions",
+      data: { records: definitions }
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow definitions");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow definitions" });
+  }
+}
+async function getWorkflowRuns(request, reply) {
+  const { threadId } = request.params;
+  const tenantId = getTenantId6(request);
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+    const runs = await store.getWorkflowRunsByThreadId(tenantId, threadId);
+    return {
+      success: true,
+      message: "Successfully retrieved workflow runs",
+      data: { records: runs, total: runs.length }
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow runs");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow runs" });
+  }
+}
+async function getWorkflowRun(request, reply) {
+  const { runId } = request.params;
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+    const run = await store.getWorkflowRun(runId);
+    if (!run) {
+      return reply.status(404).send({ success: false, message: "Workflow run not found" });
+    }
+    return { success: true, message: "Successfully retrieved workflow run", data: run };
+  } catch (error) {
+    request.log.error(error, "Failed to get workflow run");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve workflow run" });
+  }
+}
+async function getRunSteps(request, reply) {
+  const { runId } = request.params;
+  const { step_type, status: stepStatus } = request.query;
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+    let steps;
+    if (step_type) {
+      steps = await store.getRunStepsByType(runId, step_type);
+    } else {
+      steps = await store.getRunSteps(runId);
+    }
+    if (stepStatus) {
+      steps = steps.filter((s) => s.status === stepStatus);
+    }
+    return {
+      success: true,
+      message: "Successfully retrieved run steps",
+      data: { records: steps, total: steps.length }
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get run steps");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve run steps" });
+  }
+}
+async function getRunTasks(request, reply) {
+  const { runId } = request.params;
+  try {
+    const store = getTrackingStore();
+    if (!store) {
+      return reply.status(404).send({ success: false, message: "No workflow tracking store configured" });
+    }
+    const steps = await store.getInterruptedSteps(runId);
+    return {
+      success: true,
+      message: "Successfully retrieved user tasks",
+      data: { records: steps, total: steps.length }
+    };
+  } catch (error) {
+    request.log.error(error, "Failed to get run tasks");
+    return reply.status(500).send({ success: false, message: "Failed to retrieve user tasks" });
+  }
+}
+
 // src/schemas/data-query.ts
 var dataQuerySchema = {
   description: "Execute data query (semantic or SQL)",
@@ -2075,7 +2365,7 @@ var getHealthSchema = {
 };
 
 // src/controllers/thread_status.ts
-var import_core13 = require("@axiom-lattice/core");
+var import_core14 = require("@axiom-lattice/core");
 async function removePendingMessageHandler(request, reply) {
   try {
     const { assistant_id, thread_id, message_id } = request.params;
@@ -2088,7 +2378,7 @@ async function removePendingMessageHandler(request, reply) {
     if (!assistant_id) {
       return reply.code(400).send({ error: "Missing assistant_id parameter" });
     }
-    const agent = import_core13.agentInstanceManager.getAgent({
+    const agent = import_core14.agentInstanceManager.getAgent({
       assistant_id,
       thread_id,
       tenant_id,
@@ -2122,7 +2412,7 @@ async function removePendingMessageHandler(request, reply) {
 }
 
 // src/services/sandbox_service.ts
-var import_core14 = require("@axiom-lattice/core");
+var import_core15 = require("@axiom-lattice/core");
 var ERROR_HTML = `<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
@@ -2234,7 +2524,7 @@ var ERROR_HTML = `<!DOCTYPE html>
 </html>`;
 var SandboxService = class {
   getFilesystemVmIsolation(tenantId, assistantId) {
-    const agentLattice = import_core14.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
+    const agentLattice = import_core15.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
     if (!agentLattice) {
       return null;
     }
@@ -2248,9 +2538,9 @@ var SandboxService = class {
   computeSandboxName(assistantId, threadId, vmIsolation, tenantId, workspaceId, projectId) {
     switch (vmIsolation) {
       case "agent":
-        return (0, import_core14.normalizeSandboxName)(`${tenantId ?? "default"}-${assistantId}`);
+        return (0, import_core15.normalizeSandboxName)(`${tenantId ?? "default"}-${assistantId}`);
       case "project":
-        return (0, import_core14.normalizeSandboxName)(
+        return (0, import_core15.normalizeSandboxName)(
           `${tenantId ?? "default"}-${workspaceId ?? "default"}-${projectId ?? "default"}`
         );
       case "global":
@@ -2306,7 +2596,7 @@ var SandboxService = class {
 var sandboxService = new SandboxService();
 
 // src/controllers/sandbox.ts
-var import_core15 = require("@axiom-lattice/core");
+var import_core16 = require("@axiom-lattice/core");
 function getFilenameFromPath(path3) {
   const segments = path3.replace(/\/+$/, "").split("/");
   return segments[segments.length - 1] || "download";
@@ -2348,7 +2638,7 @@ function registerSandboxProxyRoutes(app2) {
         threadId,
         vmIsolation
       );
-      const sandboxManager = (0, import_core15.getSandBoxManager)();
+      const sandboxManager = (0, import_core16.getSandBoxManager)();
       const sandbox = await sandboxManager.createSandbox(sandboxName);
       try {
         const data = await request.file();
@@ -2392,7 +2682,7 @@ function registerSandboxProxyRoutes(app2) {
         threadId,
         vmIsolation
       );
-      const sandboxManager = (0, import_core15.getSandBoxManager)();
+      const sandboxManager = (0, import_core16.getSandBoxManager)();
       const sandbox = await sandboxManager.createSandbox(sandboxName);
       try {
         const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
@@ -2418,14 +2708,14 @@ function registerSandboxProxyRoutes(app2) {
 // src/controllers/workspace.ts
 var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
-var import_core16 = require("@axiom-lattice/core");
 var import_core17 = require("@axiom-lattice/core");
 var import_core18 = require("@axiom-lattice/core");
+var import_core19 = require("@axiom-lattice/core");
 var import_uuid2 = require("uuid");
 var WorkspaceController = class {
   constructor() {
-    this.workspaceStore = (0, import_core16.getStoreLattice)("default", "workspace").store;
-    this.projectStore = (0, import_core16.getStoreLattice)("default", "project").store;
+    this.workspaceStore = (0, import_core17.getStoreLattice)("default", "workspace").store;
+    this.projectStore = (0, import_core17.getStoreLattice)("default", "project").store;
   }
   getTenantId(request) {
     const userTenantId = request.user?.tenantId;
@@ -2558,7 +2848,7 @@ var WorkspaceController = class {
       throw new Error("Workspace not found");
     }
     if (workspace.storageType === "sandbox") {
-      const sandboxManager = (0, import_core18.getSandBoxManager)();
+      const sandboxManager = (0, import_core19.getSandBoxManager)();
       const volumeConfig = {
         assistant_id: assistantId || "",
         thread_id: "",
@@ -2572,14 +2862,14 @@ var WorkspaceController = class {
       }
       const sandbox = await sandboxManager.getSandboxFromConfig(volumeConfig);
       return {
-        backend: new import_core17.SandboxFilesystem({
+        backend: new import_core18.SandboxFilesystem({
           sandboxInstance: sandbox
         }),
         workspace
       };
     } else {
       return {
-        backend: new import_core17.FilesystemBackend({
+        backend: new import_core18.FilesystemBackend({
           rootDir: `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
           virtualMode: true
         }),
@@ -2657,7 +2947,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId, assistantId);
       const resolvedPath = filePath;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core18.getSandBoxManager)();
+        const sandboxManager = (0, import_core19.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -2707,7 +2997,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId, assistantId);
       const resolvedPath = filePath;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core18.getSandBoxManager)();
+        const sandboxManager = (0, import_core19.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -2841,7 +3131,7 @@ var WorkspaceController = class {
         return reply.status(400).send({ success: false, error: "Invalid path parameter" });
       }
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core18.getSandBoxManager)();
+        const sandboxManager = (0, import_core19.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -2949,9 +3239,9 @@ function registerWorkspaceRoutes(app2) {
 }
 
 // src/controllers/database-configs.ts
-var import_core19 = require("@axiom-lattice/core");
+var import_core20 = require("@axiom-lattice/core");
 var import_crypto3 = require("crypto");
-function getTenantId6(request) {
+function getTenantId7(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -2959,9 +3249,9 @@ function getTenantId6(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getDatabaseConfigList(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     console.log("Backend: getAllConfigs returned:", configs);
@@ -2989,10 +3279,10 @@ async function getDatabaseConfigList(request, reply) {
   }
 }
 async function getDatabaseConfig(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3015,10 +3305,10 @@ async function getDatabaseConfig(request, reply) {
   }
 }
 async function createDatabaseConfig(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -3031,7 +3321,7 @@ async function createDatabaseConfig(request, reply) {
     const id = body.id || (0, import_crypto3.randomUUID)();
     const config = await store.createConfig(tenantId, id, body);
     try {
-      import_core19.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
+      import_core20.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register database:", error);
     }
@@ -3050,11 +3340,11 @@ async function createDatabaseConfig(request, reply) {
   }
 }
 async function updateDatabaseConfig(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -3073,7 +3363,7 @@ async function updateDatabaseConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core19.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
+        import_core20.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register database:", error);
       }
@@ -3092,10 +3382,10 @@ async function updateDatabaseConfig(request, reply) {
   }
 }
 async function deleteDatabaseConfig(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     console.log("Delete request - keyOrId:", keyOrId);
     let config = await store.getConfigByKey(tenantId, keyOrId);
@@ -3122,8 +3412,8 @@ async function deleteDatabaseConfig(request, reply) {
       };
     }
     try {
-      if (import_core19.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
-        await import_core19.sqlDatabaseManager.removeDatabase(tenantId, configKey);
+      if (import_core20.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
+        await import_core20.sqlDatabaseManager.removeDatabase(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from SqlDatabaseManager:", error);
@@ -3141,10 +3431,10 @@ async function deleteDatabaseConfig(request, reply) {
   }
 }
 async function testDatabaseConnection(request, reply) {
-  const tenantId = getTenantId6(request);
+  const tenantId = getTenantId7(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core19.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3155,16 +3445,16 @@ async function testDatabaseConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core19.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
+    import_core20.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
     const startTime = Date.now();
-    const db = await import_core19.sqlDatabaseManager.getDatabase(tenantId, testKey);
+    const db = await import_core20.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_core19.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+      await import_core20.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       return {
         success: true,
         message: "Connection test successful",
@@ -3176,7 +3466,7 @@ async function testDatabaseConnection(request, reply) {
     } catch (error) {
       try {
         await db.disconnect();
-        await import_core19.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+        await import_core20.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       } catch {
       }
       return {
@@ -3228,9 +3518,9 @@ function registerDatabaseConfigRoutes(app2) {
 }
 
 // src/controllers/metrics-configs.ts
-var import_core20 = require("@axiom-lattice/core");
+var import_core21 = require("@axiom-lattice/core");
 var import_crypto4 = require("crypto");
-function getTenantId7(request) {
+function getTenantId8(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -3238,9 +3528,9 @@ function getTenantId7(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMetricsServerConfigList(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     return {
@@ -3264,10 +3554,10 @@ async function getMetricsServerConfigList(request, reply) {
   }
 }
 async function getMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3290,10 +3580,10 @@ async function getMetricsServerConfig(request, reply) {
   }
 }
 async function createMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -3322,7 +3612,7 @@ async function createMetricsServerConfig(request, reply) {
     };
     const config = await store.createConfig(tenantId, id, configData);
     try {
-      import_core20.metricsServerManager.registerServer(tenantId, config.key, config.config);
+      import_core21.metricsServerManager.registerServer(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register metrics server:", error);
     }
@@ -3341,11 +3631,11 @@ async function createMetricsServerConfig(request, reply) {
   }
 }
 async function updateMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -3373,7 +3663,7 @@ async function updateMetricsServerConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core20.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
+        import_core21.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register metrics server:", error);
       }
@@ -3392,10 +3682,10 @@ async function updateMetricsServerConfig(request, reply) {
   }
 }
 async function deleteMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     let config = await store.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -3420,8 +3710,8 @@ async function deleteMetricsServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core20.metricsServerManager.hasServer(tenantId, configKey)) {
-        import_core20.metricsServerManager.removeServer(tenantId, configKey);
+      if (import_core21.metricsServerManager.hasServer(tenantId, configKey)) {
+        import_core21.metricsServerManager.removeServer(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MetricsServerManager:", error);
@@ -3439,10 +3729,10 @@ async function deleteMetricsServerConfig(request, reply) {
   }
 }
 async function testMetricsServerConnection(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3453,11 +3743,11 @@ async function testMetricsServerConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core20.metricsServerManager.registerServer(tenantId, testKey, config.config);
+    import_core21.metricsServerManager.registerServer(tenantId, testKey, config.config);
     try {
-      const client = import_core20.metricsServerManager.getClient(tenantId, testKey);
+      const client = import_core21.metricsServerManager.getClient(tenantId, testKey);
       const result = await client.testConnection();
-      import_core20.metricsServerManager.removeServer(tenantId, testKey);
+      import_core21.metricsServerManager.removeServer(tenantId, testKey);
       return {
         success: true,
         message: result.connected ? "Connection test successful" : "Connection test failed",
@@ -3465,7 +3755,7 @@ async function testMetricsServerConnection(request, reply) {
       };
     } catch (error) {
       try {
-        import_core20.metricsServerManager.removeServer(tenantId, testKey);
+        import_core21.metricsServerManager.removeServer(tenantId, testKey);
       } catch {
       }
       return {
@@ -3490,10 +3780,10 @@ async function testMetricsServerConnection(request, reply) {
   }
 }
 async function listAvailableMetrics(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3503,10 +3793,10 @@ async function listAvailableMetrics(request, reply) {
         message: "Metrics server configuration not found"
       };
     }
-    if (!import_core20.metricsServerManager.hasServer(tenantId, key)) {
-      import_core20.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core21.metricsServerManager.hasServer(tenantId, key)) {
+      import_core21.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = import_core20.metricsServerManager.getClient(tenantId, key);
+    const client = import_core21.metricsServerManager.getClient(tenantId, key);
     const metrics = await client.listMetrics();
     return {
       success: true,
@@ -3528,11 +3818,11 @@ async function listAvailableMetrics(request, reply) {
   }
 }
 async function queryMetricsData(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   const { metricName, startTime, endTime, step, labels } = request.body;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3549,10 +3839,10 @@ async function queryMetricsData(request, reply) {
         message: "metricName is required"
       };
     }
-    if (!import_core20.metricsServerManager.hasServer(tenantId, key)) {
-      import_core20.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core21.metricsServerManager.hasServer(tenantId, key)) {
+      import_core21.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = import_core20.metricsServerManager.getClient(tenantId, key);
+    const client = import_core21.metricsServerManager.getClient(tenantId, key);
     const result = await client.queryMetricData(metricName, {
       startTime,
       endTime,
@@ -3576,10 +3866,10 @@ async function queryMetricsData(request, reply) {
   }
 }
 async function getDataSources(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3597,7 +3887,7 @@ async function getDataSources(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core20.SemanticMetricsClient(semanticConfig);
+    const client = new import_core21.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;
@@ -3617,10 +3907,10 @@ async function getDataSources(request, reply) {
   }
 }
 async function getDatasourceMetrics(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key, datasourceId } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3638,7 +3928,7 @@ async function getDatasourceMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core20.SemanticMetricsClient(semanticConfig);
+    const client = new import_core21.SemanticMetricsClient(semanticConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -3654,11 +3944,11 @@ async function getDatasourceMetrics(request, reply) {
   }
 }
 async function querySemanticMetrics(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId8(request);
   const { key } = request.params;
   const body = request.body;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3683,7 +3973,7 @@ async function querySemanticMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core20.SemanticMetricsClient(semanticConfig);
+    const client = new import_core21.SemanticMetricsClient(semanticConfig);
     const result = await client.semanticQuery(body);
     const columnNames = result.columns.map((col) => col.name);
     const allDataPoints = [];
@@ -3743,7 +4033,7 @@ async function testSemanticDataSources(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core20.SemanticMetricsClient(testConfig);
+    const client = new import_core21.SemanticMetricsClient(testConfig);
     const datasources = await client.getDataSources();
     return {
       success: true,
@@ -3779,7 +4069,7 @@ async function testDatasourceMetrics(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core20.SemanticMetricsClient(testConfig);
+    const client = new import_core21.SemanticMetricsClient(testConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -3811,9 +4101,9 @@ function registerMetricsServerConfigRoutes(app2) {
 }
 
 // src/controllers/mcp-configs.ts
-var import_core21 = require("@axiom-lattice/core");
+var import_core22 = require("@axiom-lattice/core");
 var import_crypto5 = require("crypto");
-function getTenantId8(request) {
+function getTenantId9(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -3821,9 +4111,9 @@ function getTenantId8(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMcpServerConfigList(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     return {
@@ -3847,10 +4137,10 @@ async function getMcpServerConfigList(request, reply) {
   }
 }
 async function getMcpServerConfig(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -3873,10 +4163,10 @@ async function getMcpServerConfig(request, reply) {
   }
 }
 async function createMcpServerConfig(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -3912,11 +4202,11 @@ async function createMcpServerConfig(request, reply) {
   }
 }
 async function updateMcpServerConfig(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -3936,8 +4226,8 @@ async function updateMcpServerConfig(request, reply) {
     }
     if (shouldReconnect) {
       try {
-        if (import_core21.mcpManager.hasServer(key)) {
-          await import_core21.mcpManager.removeServer(key);
+        if (import_core22.mcpManager.hasServer(key)) {
+          await import_core22.mcpManager.removeServer(key);
         }
         await connectAndRegisterTools(updated);
         await store.updateConfig(tenantId, existing.id, { status: "connected" });
@@ -3962,10 +4252,10 @@ async function updateMcpServerConfig(request, reply) {
   }
 }
 async function deleteMcpServerConfig(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     let config = await store.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -3983,8 +4273,8 @@ async function deleteMcpServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core21.mcpManager.hasServer(configKey)) {
-        await import_core21.mcpManager.removeServer(configKey);
+      if (import_core22.mcpManager.hasServer(configKey)) {
+        await import_core22.mcpManager.removeServer(configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MCP manager:", error);
@@ -4009,10 +4299,10 @@ async function deleteMcpServerConfig(request, reply) {
   }
 }
 async function testMcpServerConnection(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4026,11 +4316,11 @@ async function testMcpServerConnection(request, reply) {
     try {
       const testKey = `__test_${key}_${Date.now()}`;
       const connection = convertToConnection(config.config);
-      import_core21.mcpManager.addServer(testKey, connection);
-      await import_core21.mcpManager.connect();
-      const tools = await import_core21.mcpManager.getAllTools();
+      import_core22.mcpManager.addServer(testKey, connection);
+      await import_core22.mcpManager.connect();
+      const tools = await import_core22.mcpManager.getAllTools();
       const latency = Date.now() - startTime;
-      await import_core21.mcpManager.removeServer(testKey);
+      await import_core22.mcpManager.removeServer(testKey);
       return {
         success: true,
         message: "Connection test successful",
@@ -4062,10 +4352,10 @@ async function testMcpServerConnection(request, reply) {
   }
 }
 async function listMcpServerTools(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4075,10 +4365,10 @@ async function listMcpServerTools(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (!import_core21.mcpManager.hasServer(key)) {
+    if (!import_core22.mcpManager.hasServer(key)) {
       await connectAndRegisterTools(config);
     }
-    const tools = await import_core21.mcpManager.getAllTools();
+    const tools = await import_core22.mcpManager.getAllTools();
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -4095,10 +4385,10 @@ async function listMcpServerTools(request, reply) {
   }
 }
 async function connectMcpServer(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4119,7 +4409,7 @@ async function connectMcpServer(request, reply) {
     };
   } catch (error) {
     console.error("Failed to connect MCP server:", error);
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (config) {
@@ -4132,10 +4422,10 @@ async function connectMcpServer(request, reply) {
   }
 }
 async function disconnectMcpServer(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4145,8 +4435,8 @@ async function disconnectMcpServer(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (import_core21.mcpManager.hasServer(key)) {
-      await import_core21.mcpManager.removeServer(key);
+    if (import_core22.mcpManager.hasServer(key)) {
+      await import_core22.mcpManager.removeServer(key);
     }
     const updated = await store.updateConfig(tenantId, config.id, {
       status: "disconnected"
@@ -4176,10 +4466,10 @@ async function testMcpServerTools(request, reply) {
     }
     const testKey = `__test_${Date.now()}`;
     const connection = convertToConnection(body.config);
-    import_core21.mcpManager.addServer(testKey, connection);
-    await import_core21.mcpManager.connect();
-    const tools = await import_core21.mcpManager.getAllTools();
-    await import_core21.mcpManager.removeServer(testKey);
+    import_core22.mcpManager.addServer(testKey, connection);
+    await import_core22.mcpManager.connect();
+    const tools = await import_core22.mcpManager.getAllTools();
+    await import_core22.mcpManager.removeServer(testKey);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -4216,14 +4506,14 @@ function convertToConnection(config) {
 }
 async function connectAndRegisterTools(config) {
   const connection = convertToConnection(config.config);
-  import_core21.mcpManager.addServer(config.key, connection);
-  await import_core21.mcpManager.connect();
-  const allTools = await import_core21.mcpManager.getAllTools();
+  import_core22.mcpManager.addServer(config.key, connection);
+  await import_core22.mcpManager.connect();
+  const allTools = await import_core22.mcpManager.getAllTools();
   const selectedTools = allTools.filter(
     (tool) => config.selectedTools.includes(tool.name)
   );
   for (const tool of selectedTools) {
-    import_core21.toolLatticeManager.registerExistingTool(tool.name, tool);
+    import_core22.toolLatticeManager.registerExistingTool(tool.name, tool);
   }
 }
 function registerMcpServerConfigRoutes(app2) {
@@ -4240,11 +4530,11 @@ function registerMcpServerConfigRoutes(app2) {
 }
 
 // src/controllers/users.ts
-var import_core22 = require("@axiom-lattice/core");
+var import_core23 = require("@axiom-lattice/core");
 var import_uuid3 = require("uuid");
 var UsersController = class {
   constructor() {
-    this.userStore = (0, import_core22.getStoreLattice)("default", "user").store;
+    this.userStore = (0, import_core23.getStoreLattice)("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -4322,11 +4612,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-var import_core23 = require("@axiom-lattice/core");
+var import_core24 = require("@axiom-lattice/core");
 var import_uuid4 = require("uuid");
 var TenantsController = class {
   constructor() {
-    this.tenantStore = (0, import_core23.getStoreLattice)("default", "tenant").store;
+    this.tenantStore = (0, import_core24.getStoreLattice)("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -4390,7 +4680,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-var import_core24 = require("@axiom-lattice/core");
+var import_core25 = require("@axiom-lattice/core");
 var import_uuid5 = require("uuid");
 var defaultAuthConfig = {
   autoApproveUsers: true,
@@ -4399,9 +4689,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = (0, import_core24.getStoreLattice)("default", "user").store;
-    this.tenantStore = (0, import_core24.getStoreLattice)("default", "tenant").store;
-    this.userTenantLinkStore = (0, import_core24.getStoreLattice)("default", "userTenantLink").store;
+    this.userStore = (0, import_core25.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core25.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core25.getStoreLattice)("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -4773,7 +5063,7 @@ function registerAuthRoutes(app2, config) {
 }
 
 // src/channels/lark/routes.ts
-var import_core26 = require("@axiom-lattice/core");
+var import_core27 = require("@axiom-lattice/core");
 var import_pg_stores = require("@axiom-lattice/pg-stores");
 
 // src/channels/lark/parser.ts
@@ -5021,7 +5311,7 @@ function resolveSubjectType(mappingMode, chatType) {
 }
 
 // src/channels/lark/runner.ts
-var import_core25 = require("@axiom-lattice/core");
+var import_core26 = require("@axiom-lattice/core");
 var import_protocols4 = require("@axiom-lattice/protocols");
 
 // src/channels/lark/aggregator.ts
@@ -5034,7 +5324,7 @@ function aggregateLarkReply(messageId, chunks) {
 
 // src/channels/lark/runner.ts
 async function runAgentAndCollectLarkReply(input) {
-  const agent = import_core25.agentInstanceManager.getAgent({
+  const agent = import_core26.agentInstanceManager.getAgent({
     tenant_id: input.tenantId,
     assistant_id: input.assistantId,
     thread_id: input.threadId,
@@ -5146,7 +5436,7 @@ function createDefaultLarkDependencies() {
   const installationStore = new import_pg_stores.PostgreSQLChannelInstallationStore({
     poolConfig: getDatabaseUrl()
   });
-  const threadStore = (0, import_core26.getStoreLattice)("default", "thread").store;
+  const threadStore = (0, import_core27.getStoreLattice)("default", "thread").store;
   const mappingStore = new import_pg_stores.ChannelIdentityMappingStore({
     poolConfig: getDatabaseUrl()
   });
@@ -5227,7 +5517,7 @@ function registerChannelRoutes(app2, dependencies = {}) {
 
 // src/controllers/channel-installations.ts
 var import_crypto8 = require("crypto");
-function getTenantId9(request) {
+function getTenantId10(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -5245,7 +5535,7 @@ async function getInstallationStore() {
   });
 }
 async function getChannelInstallationList(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const { channel } = request.query;
   try {
     const store = await getInstallationStore();
@@ -5271,7 +5561,7 @@ async function getChannelInstallationList(request, reply) {
   }
 }
 async function getChannelInstallation(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const { installationId } = request.params;
   try {
     const store = await getInstallationStore();
@@ -5304,7 +5594,7 @@ async function getChannelInstallation(request, reply) {
   }
 }
 async function createChannelInstallation(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const body = request.body;
   try {
     if (!body.channel) {
@@ -5367,7 +5657,7 @@ async function createChannelInstallation(request, reply) {
   }
 }
 async function updateChannelInstallation(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const { installationId } = request.params;
   const body = request.body;
   try {
@@ -5413,7 +5703,7 @@ async function updateChannelInstallation(request, reply) {
   }
 }
 async function deleteChannelInstallation(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId10(request);
   const { installationId } = request.params;
   try {
     const store = await getInstallationStore();
@@ -5599,6 +5889,29 @@ var registerLatticeRoutes = (app2) => {
   });
   registerChannelRoutes(app2);
   registerChannelInstallationRoutes(app2);
+  app2.get(
+    "/api/workflows/definitions",
+    getAllWorkflowDefinitions
+  );
+  app2.get(
+    "/api/workflows/runs",
+    getAllWorkflowRuns
+  );
+  app2.get(
+    "/api/workflows/inbox",
+    getInboxItems
+  );
+  app2.get(
+    "/api/assistants/:assistantId/workflows/definitions",
+    getWorkflowDefinitions
+  );
+  app2.get(
+    "/api/assistants/:assistantId/threads/:threadId/workflows/runs",
+    getWorkflowRuns
+  );
+  app2.get("/api/workflows/runs/:runId", getWorkflowRun);
+  app2.get("/api/workflows/runs/:runId/steps", getRunSteps);
+  app2.get("/api/workflows/runs/:runId/tasks", getRunTasks);
   app2.delete(
     "/api/assistants/:assistant_id/threads/:thread_id/pending-messages/:message_id",
     removePendingMessageHandler
@@ -5668,7 +5981,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core27 = require("@axiom-lattice/core");
+var import_core28 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -5677,24 +5990,55 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     "x-tenant-id": tenant_id,
     command,
     callback_event,
-    runConfig
+    runConfig,
+    main_thread_id,
+    main_tenant_id,
+    main_assistant_id
   } = taskRequest;
   try {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = import_core27.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_core27.QueueMode.STEER);
+    const agent = import_core28.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_core28.QueueMode.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
-        import_core27.eventBus.publish(callback_event, {
+        import_core28.eventBus.publish(callback_event, {
           success: true,
           state: evt.state,
           config: { assistant_id, thread_id, tenant_id }
         });
+        if (main_thread_id && main_tenant_id) {
+          try {
+            const mainAgent = import_core28.agentInstanceManager.getAgent({
+              assistant_id: main_assistant_id ?? assistant_id,
+              thread_id: main_thread_id,
+              tenant_id: main_tenant_id
+            });
+            if (mainAgent) {
+              const messages = evt.state?.values?.messages;
+              const lastAIMessage = messages?.filter((m) => m.type === "ai" || m.getType?.() === "ai").pop();
+              const summary = lastAIMessage?.content?.substring(0, 500) ?? "(no output)";
+              mainAgent.addMessage(
+                {
+                  input: {
+                    message: `[Async task completed]
+task_id: ${thread_id}
+${summary}`
+                  }
+                }
+              ).catch((err) => {
+                console.error("Failed to notify main thread:", err);
+              });
+              mainAgent.updateAsyncTaskStatus(thread_id, "completed");
+            }
+          } catch (err) {
+            console.error("Failed to notify main thread:", err);
+          }
+        }
       });
       agent.subscribeOnce("message:interrupted", (evt) => {
-        import_core27.eventBus.publish(callback_event, {
+        import_core28.eventBus.publish(callback_event, {
           success: true,
           state: evt.state,
           config: { assistant_id, thread_id, tenant_id }
@@ -5718,7 +6062,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core27.eventBus.publish(callback_event, {
+      import_core28.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -5756,7 +6100,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core27.eventBus.subscribe(import_core27.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core28.eventBus.subscribe(import_core28.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");
   }
@@ -5875,7 +6219,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_core27.eventBus.publish(taskRequest.callback_event, {
+        import_core28.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {
@@ -5895,7 +6239,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core28 = require("@axiom-lattice/core");
+var import_core29 = require("@axiom-lattice/core");
 var import_protocols5 = require("@axiom-lattice/protocols");
 var import_meta = {};
 process.on("unhandledRejection", (reason, promise) => {
@@ -5911,11 +6255,11 @@ var DEFAULT_LOGGER_CONFIG = {
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core28.loggerLatticeManager.hasLattice("default")) {
-    import_core28.loggerLatticeManager.removeLattice("default");
+  if (import_core29.loggerLatticeManager.hasLattice("default")) {
+    import_core29.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core28.registerLoggerLattice)("default", config);
-  return (0, import_core28.getLoggerLattice)("default");
+  (0, import_core29.registerLoggerLattice)("default", config);
+  return (0, import_core29.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -6011,7 +6355,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core28.createSandboxProvider)({
+  return (0, import_core29.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -6040,17 +6384,32 @@ var start = async (config) => {
     app.decorate("loggerLattice", loggerLattice);
     registerLatticeRoutes(app);
     try {
-      const storeLattice = (0, import_core28.getStoreLattice)("default", "database");
+      const storeLattice = (0, import_core29.getStoreLattice)("default", "database");
       const store = storeLattice.store;
-      import_core28.sqlDatabaseManager.setConfigStore(store);
+      import_core29.sqlDatabaseManager.setConfigStore(store);
       logger.info("Database config store set for SqlDatabaseManager");
     } catch (error) {
       logger.warn("Failed to set database config store: " + (error instanceof Error ? error.message : String(error)));
     }
-    if (!import_core28.sandboxLatticeManager.hasLattice("default")) {
-      import_core28.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+    if (!import_core29.sandboxLatticeManager.hasLattice("default")) {
+      import_core29.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
       logger.info("Registered sandbox manager from env configuration");
     }
+    if (process.env.DATABASE_URL) {
+      try {
+        const { PostgreSQLWorkflowTrackingStore } = await import("@axiom-lattice/pg-stores");
+        const pgStore = new PostgreSQLWorkflowTrackingStore({
+          poolConfig: process.env.DATABASE_URL
+        });
+        if (import_core29.storeLatticeManager.hasLattice("default", "workflowTracking")) {
+          import_core29.storeLatticeManager.removeLattice("default", "workflowTracking");
+        }
+        import_core29.storeLatticeManager.registerLattice("default", "workflowTracking", pgStore);
+        logger.info("Workflow tracking store switched to PostgreSQL");
+      } catch (error) {
+        logger.warn("Failed to switch workflow tracking to PostgreSQL, keeping in-memory: " + (error instanceof Error ? error.message : String(error)));
+      }
+    }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
     await app.listen({ port: target_port, host: "0.0.0.0" });
     logger.info(`Lattice Gateway is running on port: ${target_port}`);
@@ -6069,7 +6428,7 @@ var start = async (config) => {
     }
     try {
       logger.info("Starting agent instance recovery...");
-      const restoreStats = await import_core28.agentInstanceManager.restore();
+      const restoreStats = await import_core29.agentInstanceManager.restore();
       logger.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
     } catch (error) {
       logger.error("Agent recovery failed", { error });