@axiom-lattice/gateway 2.1.92 → 2.1.94

package/dist/index.js

@@ -56,8 +56,8 @@ async function createLarkSender(config, client) {
   };
 }
 async function createDefaultLarkClient(config) {
-  const Lark = await import("@larksuiteoapi/node-sdk");
-  return new Lark.Client({
+  const Lark2 = await import("@larksuiteoapi/node-sdk");
+  return new Lark2.Client({
     appId: config.appId,
     appSecret: config.appSecret
   });
@@ -303,7 +303,7 @@ async function handleTasksSend(request, reply) {
   taskStore.set(taskId, record);
   let agent;
   try {
-    agent = import_core31.agentInstanceManager.getAgent({
+    agent = import_core34.agentInstanceManager.getAgent({
       assistant_id: assistantId,
       thread_id: threadId,
       tenant_id: tenantId,
@@ -395,7 +395,7 @@ async function handleTasksCancel(request, reply) {
     return;
   }
   try {
-    const agent = import_core31.agentInstanceManager.getAgent({
+    const agent = import_core34.agentInstanceManager.getAgent({
       assistant_id: record.assistantId,
       thread_id: record.threadId,
       tenant_id: record.tenantId,
@@ -432,7 +432,7 @@ async function handleTasksStream(request, reply) {
   }
   let agent;
   try {
-    agent = import_core31.agentInstanceManager.getAgent({
+    agent = import_core34.agentInstanceManager.getAgent({
       assistant_id: record.assistantId,
       thread_id: record.threadId,
       tenant_id: record.tenantId,
@@ -627,12 +627,12 @@ function registerA2ARoutes(app2) {
     handleApiKeyRotate
   );
 }
-var import_uuid9, import_core31, import_protocols4, taskStore, _a2aKeyStore, _storeKeyMap;
+var import_uuid9, import_core34, import_protocols4, taskStore, _a2aKeyStore, _storeKeyMap;
 var init_a2a = __esm({
   "src/routes/a2a.ts"() {
     "use strict";
     import_uuid9 = require("uuid");
-    import_core31 = require("@axiom-lattice/core");
+    import_core34 = require("@axiom-lattice/core");
     import_protocols4 = require("@axiom-lattice/protocols");
     taskStore = /* @__PURE__ */ new Map();
     _a2aKeyStore = null;
@@ -666,6 +666,11 @@ function getTenantId(request) {
   }
   return request.headers["x-tenant-id"] || "default";
 }
+function getUserId(request) {
+  const userId = request.user?.id;
+  if (userId) return userId;
+  return request.headers["x-user-id"] || void 0;
+}
 function convertAgentConfigToAssistant(config) {
   return {
     id: config.key,
@@ -698,12 +703,17 @@ async function getAssistantList(request, reply) {
     assistantMap.set(assistant.id, assistant);
   });
   const allAssistants = Array.from(assistantMap.values());
+  const userId = getUserId(request);
+  const filtered = allAssistants.filter((a) => {
+    if (!a.ownerUserId) return true;
+    return a.ownerUserId === userId;
+  });
   return {
     success: true,
     message: "Successfully retrieved assistant list",
     data: {
-      records: allAssistants,
-      total: allAssistants.length
+      records: filtered,
+      total: filtered.length
     }
   };
 }
@@ -849,7 +859,7 @@ var getAgentGraph = async (request, reply) => {
 var import_uuid = require("uuid");
 var import_core3 = require("@axiom-lattice/core");
 var import_protocols = require("@axiom-lattice/protocols");
-function getUserId(request) {
+function getUserId2(request) {
   const authUser = request.user;
   if (authUser?.id) return authUser.id;
   return request.headers["x-user-id"] || void 0;
@@ -871,7 +881,7 @@ var createRun = async (request, reply) => {
     const workspace_id = request.headers["x-workspace-id"];
     const project_id = request.headers["x-project-id"];
     const x_request_id = request.headers["x-request-id"] || (0, import_uuid.v4)();
-    const user_id = getUserId(request);
+    const user_id = getUserId2(request);
     const mergedConfig = user_id ? { ...custom_run_config, user_id } : custom_run_config;
     if (!assistant_id) {
       reply.status(400).send({
@@ -1025,6 +1035,33 @@ var abortRun = async (request, reply) => {
     });
   }
 };
+var recoverRun = async (request, reply) => {
+  try {
+    const { assistantId, threadId } = request.params;
+    const tenant_id = request.headers["x-tenant-id"];
+    const workspace_id = request.headers["x-workspace-id"] || "default";
+    const project_id = request.headers["x-project-id"] || "default";
+    const agent = import_core3.agentInstanceManager.getAgent({
+      assistant_id: assistantId,
+      thread_id: threadId,
+      tenant_id,
+      workspace_id,
+      project_id
+    });
+    await agent.resumeTask();
+    const status = await agent.getRunStatus();
+    reply.status(200).send({
+      success: true,
+      threadId,
+      status
+    });
+  } catch (error) {
+    reply.status(500).send({
+      success: false,
+      error: `Recover failed: ${error.message}`
+    });
+  }
+};
 
 // src/controllers/memory.ts
 var import_core4 = require("@axiom-lattice/core");
@@ -1197,6 +1234,8 @@ var triggerAgentTask = async (request, reply) => {
   try {
     const { assistant_id, thread_id, input, command } = request.body;
     const tenant_id = request.headers["x-tenant-id"];
+    const workspace_id = request.headers["x-workspace-id"];
+    const project_id = request.headers["x-project-id"];
     if (!assistant_id) {
       reply.status(400).send({
         success: false,
@@ -1217,7 +1256,12 @@ var triggerAgentTask = async (request, reply) => {
       thread_id,
       input,
       command,
-      "x-tenant-id": tenant_id
+      "x-tenant-id": tenant_id,
+      runConfig: {
+        workspaceId: workspace_id,
+        projectId: project_id,
+        user_id: request.user?.id
+      }
     });
     reply.status(200).send({
       success: true
@@ -2805,6 +2849,268 @@ async function replyInboxTask(request, reply) {
   }
 }
 
+// src/controllers/personal-assistant.ts
+var import_core14 = require("@axiom-lattice/core");
+var import_crypto3 = require("crypto");
+function getWorkspaceId2(request) {
+  return request.headers["x-workspace-id"] || "default";
+}
+function getTenantId7(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return request.headers["x-tenant-id"] || "default";
+}
+function getUserId3(request) {
+  const userId = request.user?.id || request.headers["x-user-id"];
+  if (!userId) throw new Error("User ID is required");
+  return userId;
+}
+function getLinkStore() {
+  return (0, import_core14.getStoreLattice)("default", "userTenantLink").store;
+}
+function getAssistantStore() {
+  return (0, import_core14.getStoreLattice)("default", "assistant").store;
+}
+function getProjectStore() {
+  return (0, import_core14.getStoreLattice)("default", "project").store;
+}
+async function getLinkMeta(userId, tenantId) {
+  const link = await getLinkStore().getLink(userId, tenantId);
+  return link?.metadata || {};
+}
+async function updateLinkMeta(userId, tenantId, meta) {
+  await getLinkStore().updateLink(userId, tenantId, { metadata: meta });
+}
+async function createPersonalAssistant(request, reply) {
+  const tenantId = getTenantId7(request);
+  const userId = getUserId3(request);
+  const { name, personality } = request.body;
+  if (!name || !personality) {
+    return reply.status(400).send({ success: false, message: "name and personality are required" });
+  }
+  const store = getAssistantStore();
+  const existing = await store.getByOwner(tenantId, userId);
+  if (existing) {
+    return reply.status(409).send({ success: false, message: "You already have a personal assistant" });
+  }
+  const assistantId = (0, import_crypto3.randomUUID)();
+  const projectStore = getProjectStore();
+  const projectId = (0, import_crypto3.randomUUID)();
+  const wsId = getWorkspaceId2(request);
+  await projectStore.createProject(tenantId, wsId, projectId, {
+    name: `${name}'s Space`,
+    description: "Personal workspace for your assistant"
+  });
+  const config = import_core14.PersonalAssistantConfig.get();
+  config.key = assistantId;
+  import_core14.PersonalAssistantConfig.render(config, name, personality);
+  const data = { name, graphDefinition: config, ownerUserId: userId };
+  const assistant = await store.createAssistant(tenantId, assistantId, data);
+  const meta = await getLinkMeta(userId, tenantId);
+  meta.personalAssistantId = assistantId;
+  meta.personalProjectId = projectId;
+  meta.personalWorkspaceId = wsId;
+  await updateLinkMeta(userId, tenantId, meta);
+  return reply.status(201).send({
+    success: true,
+    message: "Personal assistant created",
+    data: { id: assistant.id, name: assistant.name, projectId, workspaceId: wsId, createdAt: assistant.createdAt }
+  });
+}
+async function getPersonalAssistant(request, reply) {
+  const tenantId = getTenantId7(request);
+  const userId = getUserId3(request);
+  const store = getAssistantStore();
+  const assistant = await store.getByOwner(tenantId, userId);
+  if (!assistant) {
+    return reply.status(404).send({ success: false, message: "No personal assistant found" });
+  }
+  const meta = await getLinkMeta(userId, tenantId);
+  const projectId = meta.personalProjectId || "default";
+  const workspaceId = meta.personalWorkspaceId || "default";
+  return {
+    success: true,
+    message: "Personal assistant found",
+    data: { id: assistant.id, name: assistant.name, projectId, workspaceId, createdAt: assistant.createdAt }
+  };
+}
+async function deletePersonalAssistant(request, reply) {
+  const tenantId = getTenantId7(request);
+  const userId = getUserId3(request);
+  const store = getAssistantStore();
+  const assistant = await store.getByOwner(tenantId, userId);
+  if (!assistant) {
+    return reply.status(404).send({ success: false, message: "No personal assistant found" });
+  }
+  const deleted = await store.deleteAssistant(tenantId, assistant.id);
+  if (!deleted) {
+    return reply.status(500).send({ success: false, message: "Failed to delete personal assistant" });
+  }
+  const threadStore = (0, import_core14.getStoreLattice)("default", "thread").store;
+  try {
+    const threads = await threadStore.getThreadsByAssistantId(tenantId, assistant.id);
+    for (const t of threads) {
+      await threadStore.deleteThread(tenantId, t.id);
+    }
+  } catch {
+  }
+  const meta = await getLinkMeta(userId, tenantId);
+  const projectId = meta.personalProjectId;
+  const wsId = meta.personalWorkspaceId;
+  if (projectId && wsId) {
+    try {
+      await getProjectStore().deleteProject(tenantId, projectId);
+    } catch {
+    }
+  }
+  delete meta.personalAssistantId;
+  delete meta.personalProjectId;
+  delete meta.personalWorkspaceId;
+  await updateLinkMeta(userId, tenantId, meta);
+  return { success: true, message: "Personal assistant deleted" };
+}
+
+// src/controllers/tasks.ts
+var import_core15 = require("@axiom-lattice/core");
+function getTenantId8(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return request.headers["x-tenant-id"] || "default";
+}
+function getUserId4(request) {
+  const userId = request.user?.id || request.headers["x-user-id"];
+  if (!userId) throw new Error("User ID is required");
+  return userId;
+}
+function getStore() {
+  return (0, import_core15.getStoreLattice)("default", "task").store;
+}
+async function listTasks(request, reply) {
+  try {
+    const tenantId = getTenantId8(request);
+    const userId = getUserId4(request);
+    const query = request.query;
+    const store = getStore();
+    const tasks = await store.list({
+      tenantId,
+      ownerId: query.ownerId || userId,
+      status: query.status,
+      priority: query.priority,
+      ownerType: query.ownerType,
+      metadata: query.metadata ? JSON.parse(query.metadata) : void 0,
+      limit: query.limit ? parseInt(query.limit) : void 0,
+      offset: query.offset ? parseInt(query.offset) : void 0
+    });
+    return { success: true, data: tasks, count: tasks.length };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+async function getTask(request, reply) {
+  try {
+    const tenantId = getTenantId8(request);
+    const userId = getUserId4(request);
+    const { id } = request.params;
+    const store = getStore();
+    const task = await store.getById(tenantId, id);
+    if (!task) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    if (task.ownerType === "user" && task.ownerId !== userId) {
+      return reply.status(403).send({ success: false, error: "Access denied" });
+    }
+    return { success: true, data: task };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+async function createTask(request, reply) {
+  try {
+    const tenantId = getTenantId8(request);
+    const userId = getUserId4(request);
+    const body = request.body;
+    if (!body.title) {
+      return reply.status(400).send({ success: false, error: "title is required" });
+    }
+    const store = getStore();
+    const task = await store.create({
+      ...body,
+      tenantId,
+      ownerType: body.ownerType || "user",
+      ownerId: body.ownerId || userId
+    });
+    return reply.status(201).send({ success: true, data: task });
+  } catch (error) {
+    return reply.status(500).send({ success: false, error: error.message });
+  }
+}
+async function updateTask(request, reply) {
+  try {
+    const tenantId = getTenantId8(request);
+    const userId = getUserId4(request);
+    const { id } = request.params;
+    const store = getStore();
+    const existing = await store.getById(tenantId, id);
+    if (!existing) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    if (existing.ownerType === "user" && existing.ownerId !== userId) {
+      return reply.status(403).send({ success: false, error: "Access denied" });
+    }
+    const task = await store.update(tenantId, id, request.body);
+    if (!task) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    return { success: true, data: task };
+  } catch (error) {
+    return reply.status(500).send({ success: false, error: error.message });
+  }
+}
+async function deleteTask(request, reply) {
+  try {
+    const tenantId = getTenantId8(request);
+    const userId = getUserId4(request);
+    const { id } = request.params;
+    const store = getStore();
+    const existing = await store.getById(tenantId, id);
+    if (!existing) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    if (existing.ownerType === "user" && existing.ownerId !== userId) {
+      return reply.status(403).send({ success: false, error: "Access denied" });
+    }
+    const deleted = await store.delete(tenantId, id);
+    if (!deleted) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    return { success: true, message: "Task deleted" };
+  } catch (error) {
+    return reply.status(500).send({ success: false, error: error.message });
+  }
+}
+async function completeTask(request, reply) {
+  try {
+    const tenantId = getTenantId8(request);
+    const userId = getUserId4(request);
+    const { id } = request.params;
+    const store = getStore();
+    const existing = await store.getById(tenantId, id);
+    if (!existing) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    if (existing.ownerType === "user" && existing.ownerId !== userId) {
+      return reply.status(403).send({ success: false, error: "Access denied" });
+    }
+    const task = await store.update(tenantId, id, { status: "completed" });
+    if (!task) {
+      return reply.status(404).send({ success: false, error: "Task not found" });
+    }
+    return { success: true, data: task };
+  } catch (error) {
+    return reply.status(500).send({ success: false, error: error.message });
+  }
+}
+
 // src/schemas/data-query.ts
 var dataQuerySchema = {
   description: "Execute data query (semantic or SQL)",
@@ -3146,7 +3452,7 @@ var getHealthSchema = {
 };
 
 // src/controllers/thread_status.ts
-var import_core14 = require("@axiom-lattice/core");
+var import_core16 = require("@axiom-lattice/core");
 async function removePendingMessageHandler(request, reply) {
   try {
     const { assistant_id, thread_id, message_id } = request.params;
@@ -3159,7 +3465,7 @@ async function removePendingMessageHandler(request, reply) {
     if (!assistant_id) {
       return reply.code(400).send({ error: "Missing assistant_id parameter" });
     }
-    const agent = import_core14.agentInstanceManager.getAgent({
+    const agent = import_core16.agentInstanceManager.getAgent({
       assistant_id,
       thread_id,
       tenant_id,
@@ -3193,7 +3499,7 @@ async function removePendingMessageHandler(request, reply) {
 }
 
 // src/services/sandbox_service.ts
-var import_core15 = require("@axiom-lattice/core");
+var import_core17 = require("@axiom-lattice/core");
 var ERROR_HTML = `<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
@@ -3305,7 +3611,7 @@ var ERROR_HTML = `<!DOCTYPE html>
 </html>`;
 var SandboxService = class {
   getFilesystemVmIsolation(tenantId, assistantId) {
-    const agentLattice = import_core15.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
+    const agentLattice = import_core17.agentLatticeManager.getAgentLatticeWithTenant(tenantId, assistantId);
     if (!agentLattice) {
       return null;
     }
@@ -3319,9 +3625,9 @@ var SandboxService = class {
   computeSandboxName(assistantId, threadId, vmIsolation, tenantId, workspaceId, projectId) {
     switch (vmIsolation) {
       case "agent":
-        return (0, import_core15.normalizeSandboxName)(`${tenantId ?? "default"}-${assistantId}`);
+        return (0, import_core17.normalizeSandboxName)(`${tenantId ?? "default"}-${assistantId}`);
       case "project":
-        return (0, import_core15.normalizeSandboxName)(
+        return (0, import_core17.normalizeSandboxName)(
           `${tenantId ?? "default"}-${workspaceId ?? "default"}-${projectId ?? "default"}`
         );
       case "global":
@@ -3369,15 +3675,15 @@ var SandboxService = class {
     );
     return rewritten;
   }
-  generateErrorHtml(assistantId, threadId, vmIsolation, errorMessage) {
-    const encodedError = encodeURIComponent(errorMessage);
-    return ERROR_HTML.replace("{assistantId}", assistantId).replace("{threadId}", threadId).replace("{vmIsolation}", vmIsolation).replace("{errorMessage}", errorMessage);
+  generateErrorHtml(assistantId, threadId, vmIsolation, errorMessage2) {
+    const encodedError = encodeURIComponent(errorMessage2);
+    return ERROR_HTML.replace("{assistantId}", assistantId).replace("{threadId}", threadId).replace("{vmIsolation}", vmIsolation).replace("{errorMessage}", errorMessage2);
   }
 };
 var sandboxService = new SandboxService();
 
 // src/controllers/sandbox.ts
-var import_core16 = require("@axiom-lattice/core");
+var import_core18 = require("@axiom-lattice/core");
 function getFilenameFromPath(path3) {
   const segments = path3.replace(/\/+$/, "").split("/");
   return segments[segments.length - 1] || "download";
@@ -3416,7 +3722,7 @@ function registerSandboxProxyRoutes(app2) {
       }
       const workspaceId = request.headers["x-workspace-id"];
       const projectId = request.headers["x-project-id"];
-      const sandboxManager = (0, import_core16.getSandBoxManager)();
+      const sandboxManager = (0, import_core18.getSandBoxManager)();
       const sandbox = await sandboxManager.getSandboxFromConfig({
         assistant_id: assistantId,
         thread_id: threadId,
@@ -3464,7 +3770,7 @@ function registerSandboxProxyRoutes(app2) {
       }
       const workspaceId = request.headers["x-workspace-id"];
       const projectId = request.headers["x-project-id"];
-      const sandboxManager = (0, import_core16.getSandBoxManager)();
+      const sandboxManager = (0, import_core18.getSandBoxManager)();
       const sandbox = await sandboxManager.getSandboxFromConfig({
         assistant_id: assistantId,
         thread_id: threadId,
@@ -3497,14 +3803,14 @@ function registerSandboxProxyRoutes(app2) {
 // src/controllers/workspace.ts
 var fs = __toESM(require("fs/promises"));
 var path = __toESM(require("path"));
-var import_core17 = require("@axiom-lattice/core");
-var import_core18 = require("@axiom-lattice/core");
 var import_core19 = require("@axiom-lattice/core");
+var import_core20 = require("@axiom-lattice/core");
+var import_core21 = require("@axiom-lattice/core");
 var import_uuid2 = require("uuid");
 var WorkspaceController = class {
   constructor() {
-    this.workspaceStore = (0, import_core17.getStoreLattice)("default", "workspace").store;
-    this.projectStore = (0, import_core17.getStoreLattice)("default", "project").store;
+    this.workspaceStore = (0, import_core19.getStoreLattice)("default", "workspace").store;
+    this.projectStore = (0, import_core19.getStoreLattice)("default", "project").store;
   }
   getTenantId(request) {
     const userTenantId = request.user?.tenantId;
@@ -3636,8 +3942,9 @@ var WorkspaceController = class {
     if (!workspace) {
       throw new Error("Workspace not found");
     }
+    console.log(`[getBackend] storageType=${workspace.storageType} filePath=${filePath}`);
     if (workspace.storageType === "sandbox") {
-      const sandboxManager = (0, import_core19.getSandBoxManager)();
+      const sandboxManager = (0, import_core21.getSandBoxManager)();
       const volumeConfig = {
         assistant_id: assistantId || "",
         thread_id: "",
@@ -3645,20 +3952,25 @@ var WorkspaceController = class {
         workspaceId,
         projectId
       };
+      console.log(`[getBackend] trying volume backend for path=${filePath} assistant_id=${assistantId}`);
       const volumeBackend = await sandboxManager.getVolumeBackendForPath(volumeConfig, filePath || "/project");
       if (volumeBackend) {
+        console.log(`[getBackend] using VolumeFilesystem`);
         return { backend: volumeBackend, workspace };
       }
+      console.log(`[getBackend] volume not found, falling back to SandboxFilesystem`);
       const sandbox = await sandboxManager.getSandboxFromConfig(volumeConfig);
+      console.log(`[getBackend] sandbox acquired, name=${sandbox.name || "unknown"}`);
       return {
-        backend: new import_core18.SandboxFilesystem({
+        backend: new import_core20.SandboxFilesystem({
           sandboxInstance: sandbox
         }),
         workspace
       };
     } else {
+      console.log(`[getBackend] using FilesystemBackend rootDir=/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`);
       return {
-        backend: new import_core18.FilesystemBackend({
+        backend: new import_core20.FilesystemBackend({
           rootDir: `/lattice_store/tenants/${tenantId}/workspaces/${workspaceId}/${projectId}`,
           virtualMode: true
         }),
@@ -3736,7 +4048,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId, assistantId);
       const resolvedPath = filePath;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core19.getSandBoxManager)();
+        const sandboxManager = (0, import_core21.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -3786,7 +4098,7 @@ var WorkspaceController = class {
       const { workspace } = await this.getBackend(tenantId, workspaceId, projectId, assistantId);
       const resolvedPath = filePath;
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core19.getSandBoxManager)();
+        const sandboxManager = (0, import_core21.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -3873,8 +4185,11 @@ var WorkspaceController = class {
     const { workspaceId, projectId } = request.params;
     const path3 = request.query.path || "/";
     const assistantId = request.query.assistantId;
+    console.log(`[listPath] tenantId=${tenantId} workspaceId=${workspaceId} projectId=${projectId} path=${path3} assistantId=${assistantId}`);
     const { backend } = await this.getBackend(tenantId, workspaceId, projectId, assistantId, path3);
+    console.log(`[listPath] backend type=${backend.constructor.name} calling lsInfo(${path3})`);
     const files = await backend.lsInfo(path3);
+    console.log(`[listPath] result count=${files.length}`);
     return { success: true, data: files };
   }
   async readFile(request) {
@@ -3920,7 +4235,7 @@ var WorkspaceController = class {
         return reply.status(400).send({ success: false, error: "Invalid path parameter" });
       }
       if (workspace.storageType === "sandbox") {
-        const sandboxManager = (0, import_core19.getSandBoxManager)();
+        const sandboxManager = (0, import_core21.getSandBoxManager)();
         const volumeConfig = {
           assistant_id: assistantId || "",
           thread_id: "",
@@ -4028,9 +4343,9 @@ function registerWorkspaceRoutes(app2) {
 }
 
 // src/controllers/database-configs.ts
-var import_core20 = require("@axiom-lattice/core");
-var import_crypto3 = require("crypto");
-function getTenantId7(request) {
+var import_core22 = require("@axiom-lattice/core");
+var import_crypto4 = require("crypto");
+function getTenantId9(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -4038,9 +4353,9 @@ function getTenantId7(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getDatabaseConfigList(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId9(request);
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     console.log("Backend: getAllConfigs returned:", configs);
@@ -4068,10 +4383,10 @@ async function getDatabaseConfigList(request, reply) {
   }
 }
 async function getDatabaseConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4094,10 +4409,10 @@ async function getDatabaseConfig(request, reply) {
   }
 }
 async function createDatabaseConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId9(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -4107,10 +4422,10 @@ async function createDatabaseConfig(request, reply) {
         message: "Database configuration with this key already exists"
       };
     }
-    const id = body.id || (0, import_crypto3.randomUUID)();
+    const id = body.id || (0, import_crypto4.randomUUID)();
     const config = await store.createConfig(tenantId, id, body);
     try {
-      import_core20.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
+      import_core22.sqlDatabaseManager.registerDatabase(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register database:", error);
     }
@@ -4129,11 +4444,11 @@ async function createDatabaseConfig(request, reply) {
   }
 }
 async function updateDatabaseConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -4152,7 +4467,7 @@ async function updateDatabaseConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core20.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
+        import_core22.sqlDatabaseManager.registerDatabase(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register database:", error);
       }
@@ -4171,10 +4486,10 @@ async function updateDatabaseConfig(request, reply) {
   }
 }
 async function deleteDatabaseConfig(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId9(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     console.log("Delete request - keyOrId:", keyOrId);
     let config = await store.getConfigByKey(tenantId, keyOrId);
@@ -4201,8 +4516,8 @@ async function deleteDatabaseConfig(request, reply) {
       };
     }
     try {
-      if (import_core20.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
-        await import_core20.sqlDatabaseManager.removeDatabase(tenantId, configKey);
+      if (import_core22.sqlDatabaseManager.hasDatabase(tenantId, configKey)) {
+        await import_core22.sqlDatabaseManager.removeDatabase(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from SqlDatabaseManager:", error);
@@ -4220,10 +4535,10 @@ async function deleteDatabaseConfig(request, reply) {
   }
 }
 async function testDatabaseConnection(request, reply) {
-  const tenantId = getTenantId7(request);
+  const tenantId = getTenantId9(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core20.getStoreLattice)("default", "database");
+    const storeLattice = (0, import_core22.getStoreLattice)("default", "database");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4234,16 +4549,16 @@ async function testDatabaseConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core20.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
+    import_core22.sqlDatabaseManager.registerDatabase(tenantId, testKey, config.config);
     const startTime = Date.now();
-    const db = await import_core20.sqlDatabaseManager.getDatabase(tenantId, testKey);
+    const db = await import_core22.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_core20.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+      await import_core22.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       return {
         success: true,
         message: "Connection test successful",
@@ -4255,7 +4570,7 @@ async function testDatabaseConnection(request, reply) {
     } catch (error) {
       try {
         await db.disconnect();
-        await import_core20.sqlDatabaseManager.removeDatabase(tenantId, testKey);
+        await import_core22.sqlDatabaseManager.removeDatabase(tenantId, testKey);
       } catch {
       }
       return {
@@ -4307,9 +4622,9 @@ function registerDatabaseConfigRoutes(app2) {
 }
 
 // src/controllers/metrics-configs.ts
-var import_core21 = require("@axiom-lattice/core");
-var import_crypto4 = require("crypto");
-function getTenantId8(request) {
+var import_core23 = require("@axiom-lattice/core");
+var import_crypto5 = require("crypto");
+function getTenantId10(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -4317,9 +4632,9 @@ function getTenantId8(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMetricsServerConfigList(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     return {
@@ -4343,10 +4658,10 @@ async function getMetricsServerConfigList(request, reply) {
   }
 }
 async function getMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4369,10 +4684,10 @@ async function getMetricsServerConfig(request, reply) {
   }
 }
 async function createMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -4389,7 +4704,7 @@ async function createMetricsServerConfig(request, reply) {
         message: "selectedDataSources is required for semantic metrics servers"
       };
     }
-    const id = body.id || (0, import_crypto4.randomUUID)();
+    const id = body.id || (0, import_crypto5.randomUUID)();
     const configData = {
       key: body.key,
       name: body.name,
@@ -4401,7 +4716,7 @@ async function createMetricsServerConfig(request, reply) {
     };
     const config = await store.createConfig(tenantId, id, configData);
     try {
-      import_core21.metricsServerManager.registerServer(tenantId, config.key, config.config);
+      import_core23.metricsServerManager.registerServer(tenantId, config.key, config.config);
     } catch (error) {
       console.warn("Failed to auto-register metrics server:", error);
     }
@@ -4420,11 +4735,11 @@ async function createMetricsServerConfig(request, reply) {
   }
 }
 async function updateMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -4452,7 +4767,7 @@ async function updateMetricsServerConfig(request, reply) {
     }
     if (updates.config) {
       try {
-        import_core21.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
+        import_core23.metricsServerManager.registerServer(tenantId, updated.key, updated.config);
       } catch (error) {
         console.warn("Failed to re-register metrics server:", error);
       }
@@ -4471,10 +4786,10 @@ async function updateMetricsServerConfig(request, reply) {
   }
 }
 async function deleteMetricsServerConfig(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     let config = await store.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -4499,8 +4814,8 @@ async function deleteMetricsServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core21.metricsServerManager.hasServer(tenantId, configKey)) {
-        import_core21.metricsServerManager.removeServer(tenantId, configKey);
+      if (import_core23.metricsServerManager.hasServer(tenantId, configKey)) {
+        import_core23.metricsServerManager.removeServer(tenantId, configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MetricsServerManager:", error);
@@ -4518,10 +4833,10 @@ async function deleteMetricsServerConfig(request, reply) {
   }
 }
 async function testMetricsServerConnection(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4532,11 +4847,11 @@ async function testMetricsServerConnection(request, reply) {
       };
     }
     const testKey = `__test_${key}_${Date.now()}`;
-    import_core21.metricsServerManager.registerServer(tenantId, testKey, config.config);
+    import_core23.metricsServerManager.registerServer(tenantId, testKey, config.config);
     try {
-      const client = await import_core21.metricsServerManager.getClient(tenantId, testKey);
+      const client = await import_core23.metricsServerManager.getClient(tenantId, testKey);
       const result = await client.testConnection();
-      import_core21.metricsServerManager.removeServer(tenantId, testKey);
+      import_core23.metricsServerManager.removeServer(tenantId, testKey);
       return {
         success: true,
         message: result.connected ? "Connection test successful" : "Connection test failed",
@@ -4544,7 +4859,7 @@ async function testMetricsServerConnection(request, reply) {
       };
     } catch (error) {
       try {
-        import_core21.metricsServerManager.removeServer(tenantId, testKey);
+        import_core23.metricsServerManager.removeServer(tenantId, testKey);
       } catch {
       }
       return {
@@ -4569,10 +4884,10 @@ async function testMetricsServerConnection(request, reply) {
   }
 }
 async function listAvailableMetrics(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4582,10 +4897,10 @@ async function listAvailableMetrics(request, reply) {
         message: "Metrics server configuration not found"
       };
     }
-    if (!import_core21.metricsServerManager.hasServer(tenantId, key)) {
-      import_core21.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core23.metricsServerManager.hasServer(tenantId, key)) {
+      import_core23.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = await import_core21.metricsServerManager.getClient(tenantId, key);
+    const client = await import_core23.metricsServerManager.getClient(tenantId, key);
     const metrics = await client.listMetrics();
     return {
       success: true,
@@ -4607,11 +4922,11 @@ async function listAvailableMetrics(request, reply) {
   }
 }
 async function queryMetricsData(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   const { metricName, startTime, endTime, step, labels } = request.body;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4628,10 +4943,10 @@ async function queryMetricsData(request, reply) {
         message: "metricName is required"
       };
     }
-    if (!import_core21.metricsServerManager.hasServer(tenantId, key)) {
-      import_core21.metricsServerManager.registerServer(tenantId, key, config.config);
+    if (!import_core23.metricsServerManager.hasServer(tenantId, key)) {
+      import_core23.metricsServerManager.registerServer(tenantId, key, config.config);
     }
-    const client = await import_core21.metricsServerManager.getClient(tenantId, key);
+    const client = await import_core23.metricsServerManager.getClient(tenantId, key);
     const result = await client.queryMetricData(metricName, {
       startTime,
       endTime,
@@ -4655,10 +4970,10 @@ async function queryMetricsData(request, reply) {
   }
 }
 async function getDataSources(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4676,7 +4991,7 @@ async function getDataSources(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core21.SemanticMetricsClient(semanticConfig);
+    const client = new import_core23.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;
@@ -4696,10 +5011,10 @@ async function getDataSources(request, reply) {
   }
 }
 async function getDatasourceMetrics(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { key, datasourceId } = request.params;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4717,7 +5032,7 @@ async function getDatasourceMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core21.SemanticMetricsClient(semanticConfig);
+    const client = new import_core23.SemanticMetricsClient(semanticConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -4733,11 +5048,11 @@ async function getDatasourceMetrics(request, reply) {
   }
 }
 async function querySemanticMetrics(request, reply) {
-  const tenantId = getTenantId8(request);
+  const tenantId = getTenantId10(request);
   const { key } = request.params;
   const body = request.body;
   try {
-    const storeLattice = (0, import_core21.getStoreLattice)("default", "metrics");
+    const storeLattice = (0, import_core23.getStoreLattice)("default", "metrics");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4762,7 +5077,7 @@ async function querySemanticMetrics(request, reply) {
       };
     }
     const semanticConfig = config.config;
-    const client = new import_core21.SemanticMetricsClient(semanticConfig);
+    const client = new import_core23.SemanticMetricsClient(semanticConfig);
     const result = await client.semanticQuery(body);
     const columnNames = result.columns.map((col) => col.name);
     const allDataPoints = [];
@@ -4822,7 +5137,7 @@ async function testSemanticDataSources(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core21.SemanticMetricsClient(testConfig);
+    const client = new import_core23.SemanticMetricsClient(testConfig);
     const datasources = await client.getDataSources();
     return {
       success: true,
@@ -4858,7 +5173,7 @@ async function testDatasourceMetrics(request, reply) {
       password: body.password,
       headers: body.headers
     };
-    const client = new import_core21.SemanticMetricsClient(testConfig);
+    const client = new import_core23.SemanticMetricsClient(testConfig);
     const metrics = await client.getDatasourceMetrics(datasourceId);
     return {
       success: true,
@@ -4890,9 +5205,9 @@ function registerMetricsServerConfigRoutes(app2) {
 }
 
 // src/controllers/mcp-configs.ts
-var import_core22 = require("@axiom-lattice/core");
-var import_crypto5 = require("crypto");
-function getTenantId9(request) {
+var import_core24 = require("@axiom-lattice/core");
+var import_crypto6 = require("crypto");
+function getTenantId11(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -4900,9 +5215,9 @@ function getTenantId9(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getMcpServerConfigList(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const configs = await store.getAllConfigs(tenantId);
     return {
@@ -4926,10 +5241,10 @@ async function getMcpServerConfigList(request, reply) {
   }
 }
 async function getMcpServerConfig(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -4952,10 +5267,10 @@ async function getMcpServerConfig(request, reply) {
   }
 }
 async function createMcpServerConfig(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   const body = request.body;
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, body.key);
     if (existing) {
@@ -4965,7 +5280,7 @@ async function createMcpServerConfig(request, reply) {
         message: "MCP server configuration with this key already exists"
       };
     }
-    const id = body.id || (0, import_crypto5.randomUUID)();
+    const id = body.id || (0, import_crypto6.randomUUID)();
     const config = await store.createConfig(tenantId, id, body);
     try {
       await connectAndRegisterTools(config);
@@ -4991,11 +5306,11 @@ async function createMcpServerConfig(request, reply) {
   }
 }
 async function updateMcpServerConfig(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   const updates = request.body;
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const existing = await store.getConfigByKey(tenantId, key);
     if (!existing) {
@@ -5015,8 +5330,8 @@ async function updateMcpServerConfig(request, reply) {
     }
     if (shouldReconnect) {
       try {
-        if (import_core22.mcpManager.hasServer(key)) {
-          await import_core22.mcpManager.removeServer(key);
+        if (import_core24.mcpManager.hasServer(key)) {
+          await import_core24.mcpManager.removeServer(key);
         }
         await connectAndRegisterTools(updated);
         await store.updateConfig(tenantId, existing.id, { status: "connected" });
@@ -5041,10 +5356,10 @@ async function updateMcpServerConfig(request, reply) {
   }
 }
 async function deleteMcpServerConfig(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   const { keyOrId } = request.params;
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     let config = await store.getConfigByKey(tenantId, keyOrId);
     let configKey = keyOrId;
@@ -5062,8 +5377,8 @@ async function deleteMcpServerConfig(request, reply) {
       };
     }
     try {
-      if (import_core22.mcpManager.hasServer(configKey)) {
-        await import_core22.mcpManager.removeServer(configKey);
+      if (import_core24.mcpManager.hasServer(configKey)) {
+        await import_core24.mcpManager.removeServer(configKey);
       }
     } catch (error) {
       console.warn("Failed to remove from MCP manager:", error);
@@ -5088,10 +5403,10 @@ async function deleteMcpServerConfig(request, reply) {
   }
 }
 async function testMcpServerConnection(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -5105,11 +5420,11 @@ async function testMcpServerConnection(request, reply) {
     try {
       const testKey = `__test_${key}_${Date.now()}`;
       const connection = convertToConnection(config.config);
-      import_core22.mcpManager.addServer(testKey, connection);
-      await import_core22.mcpManager.connect();
-      const tools = await import_core22.mcpManager.getAllTools();
+      import_core24.mcpManager.addServer(testKey, connection);
+      await import_core24.mcpManager.connect();
+      const tools = await import_core24.mcpManager.getAllTools();
       const latency = Date.now() - startTime;
-      await import_core22.mcpManager.removeServer(testKey);
+      await import_core24.mcpManager.removeServer(testKey);
       return {
         success: true,
         message: "Connection test successful",
@@ -5141,10 +5456,10 @@ async function testMcpServerConnection(request, reply) {
   }
 }
 async function listMcpServerTools(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -5154,10 +5469,10 @@ async function listMcpServerTools(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (!import_core22.mcpManager.hasServer(key)) {
+    if (!import_core24.mcpManager.hasServer(key)) {
       await connectAndRegisterTools(config);
     }
-    const tools = await import_core22.mcpManager.getAllTools();
+    const tools = await import_core24.mcpManager.getAllTools();
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -5174,10 +5489,10 @@ async function listMcpServerTools(request, reply) {
   }
 }
 async function connectMcpServer(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -5198,7 +5513,7 @@ async function connectMcpServer(request, reply) {
     };
   } catch (error) {
     console.error("Failed to connect MCP server:", error);
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (config) {
@@ -5211,10 +5526,10 @@ async function connectMcpServer(request, reply) {
   }
 }
 async function disconnectMcpServer(request, reply) {
-  const tenantId = getTenantId9(request);
+  const tenantId = getTenantId11(request);
   const { key } = request.params;
   try {
-    const storeLattice = (0, import_core22.getStoreLattice)("default", "mcp");
+    const storeLattice = (0, import_core24.getStoreLattice)("default", "mcp");
     const store = storeLattice.store;
     const config = await store.getConfigByKey(tenantId, key);
     if (!config) {
@@ -5224,8 +5539,8 @@ async function disconnectMcpServer(request, reply) {
         message: "MCP server configuration not found"
       };
     }
-    if (import_core22.mcpManager.hasServer(key)) {
-      await import_core22.mcpManager.removeServer(key);
+    if (import_core24.mcpManager.hasServer(key)) {
+      await import_core24.mcpManager.removeServer(key);
     }
     const updated = await store.updateConfig(tenantId, config.id, {
       status: "disconnected"
@@ -5255,10 +5570,10 @@ async function testMcpServerTools(request, reply) {
     }
     const testKey = `__test_${Date.now()}`;
     const connection = convertToConnection(body.config);
-    import_core22.mcpManager.addServer(testKey, connection);
-    await import_core22.mcpManager.connect();
-    const tools = await import_core22.mcpManager.getAllTools();
-    await import_core22.mcpManager.removeServer(testKey);
+    import_core24.mcpManager.addServer(testKey, connection);
+    await import_core24.mcpManager.connect();
+    const tools = await import_core24.mcpManager.getAllTools();
+    await import_core24.mcpManager.removeServer(testKey);
     return {
       success: true,
       message: "Tools retrieved successfully",
@@ -5295,14 +5610,14 @@ function convertToConnection(config) {
 }
 async function connectAndRegisterTools(config) {
   const connection = convertToConnection(config.config);
-  import_core22.mcpManager.addServer(config.key, connection);
-  await import_core22.mcpManager.connect();
-  const allTools = await import_core22.mcpManager.getAllTools();
+  import_core24.mcpManager.addServer(config.key, connection);
+  await import_core24.mcpManager.connect();
+  const allTools = await import_core24.mcpManager.getAllTools();
   const selectedTools = allTools.filter(
     (tool) => config.selectedTools.includes(tool.name)
   );
   for (const tool of selectedTools) {
-    import_core22.toolLatticeManager.registerExistingTool(tool.name, tool);
+    import_core24.toolLatticeManager.registerExistingTool(tool.name, tool);
   }
 }
 function registerMcpServerConfigRoutes(app2) {
@@ -5319,12 +5634,12 @@ function registerMcpServerConfigRoutes(app2) {
 }
 
 // src/controllers/eval.ts
-var import_core24 = require("@axiom-lattice/core");
+var import_core26 = require("@axiom-lattice/core");
 var import_uuid4 = require("uuid");
 
 // src/services/eval-runner.ts
 var import_events = require("events");
-var import_core23 = require("@axiom-lattice/core");
+var import_core25 = require("@axiom-lattice/core");
 var import_agent_eval = require("@axiom-lattice/agent-eval");
 var import_uuid3 = require("uuid");
 function mapLogs(logs) {
@@ -5386,7 +5701,7 @@ var EvalRunner = class {
     if (hasModelKey) {
       judgeModelConfig = { modelKey: judgeCfg.modelKey };
     } else if (!hasCredentials) {
-      const firstModel = import_core23.modelLatticeManager.getAllLattices()[0];
+      const firstModel = import_core25.modelLatticeManager.getAllLattices()[0];
       if (firstModel) {
         judgeModelConfig = { modelKey: firstModel.key };
       } else {
@@ -5497,13 +5812,13 @@ var EvalRunner = class {
     return this.runs.has(runId);
   }
   getEvalStore() {
-    return (0, import_core23.getStoreLattice)("default", "eval").store;
+    return (0, import_core25.getStoreLattice)("default", "eval").store;
   }
 };
 var evalRunner = new EvalRunner();
 
 // src/controllers/eval.ts
-function getTenantId10(request) {
+function getTenantId12(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -5511,11 +5826,11 @@ function getTenantId10(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 function getEvalStore() {
-  return (0, import_core24.getStoreLattice)("default", "eval").store;
+  return (0, import_core26.getStoreLattice)("default", "eval").store;
 }
 async function createProject(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const id = (0, import_uuid4.v4)();
     const data = request.body;
@@ -5540,7 +5855,7 @@ async function createProject(request, reply) {
 }
 async function listProjects(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     let projects = await store.getProjectsByTenant(tenantId);
     if (projects.length === 0) {
@@ -5574,7 +5889,7 @@ async function listProjects(request, reply) {
 }
 async function getProject(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { pid } = request.params;
     const project = await store.getProjectById(tenantId, pid);
@@ -5594,7 +5909,7 @@ async function getProject(request, reply) {
 }
 async function updateProject(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { pid } = request.params;
     const existing = await store.getProjectById(tenantId, pid);
@@ -5614,7 +5929,7 @@ async function updateProject(request, reply) {
 }
 async function deleteProject(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { pid } = request.params;
     const existing = await store.getProjectById(tenantId, pid);
@@ -5633,7 +5948,7 @@ async function deleteProject(request, reply) {
 }
 async function createSuite(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { pid } = request.params;
     const project = await store.getProjectById(tenantId, pid);
@@ -5655,7 +5970,7 @@ async function createSuite(request, reply) {
 }
 async function updateSuite(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { sid } = request.params;
     const existing = await store.getSuiteById(tenantId, sid);
@@ -5675,7 +5990,7 @@ async function updateSuite(request, reply) {
 }
 async function deleteSuite(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { sid } = request.params;
     const existing = await store.getSuiteById(tenantId, sid);
@@ -5694,7 +6009,7 @@ async function deleteSuite(request, reply) {
 }
 async function createCase(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { sid } = request.params;
     const suite = await store.getSuiteById(tenantId, sid);
@@ -5723,7 +6038,7 @@ async function createCase(request, reply) {
 }
 async function listCasesForSuite(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { sid } = request.params;
     const cases = await store.getCasesBySuite(tenantId, sid);
@@ -5739,7 +6054,7 @@ async function listCasesForSuite(request, reply) {
 }
 async function updateCase(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { cid } = request.params;
     const existing = await store.getCaseById(tenantId, cid);
@@ -5759,7 +6074,7 @@ async function updateCase(request, reply) {
 }
 async function deleteCase(request, reply) {
   try {
-    const tenantId = getTenantId10(request);
+    const tenantId = getTenantId12(request);
     const store = getEvalStore();
     const { cid } = request.params;
     const existing = await store.getCaseById(tenantId, cid);
@@ -5791,7 +6106,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 = getTenantId10(request);
+      const tenantId = getTenantId12(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 } });
@@ -5803,7 +6118,7 @@ function registerEvalRoutes(app2) {
   });
   app2.get("/api/eval/runs", async (request, reply) => {
     try {
-      const tenantId = getTenantId10(request);
+      const tenantId = getTenantId12(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 } });
@@ -5813,7 +6128,7 @@ function registerEvalRoutes(app2) {
   });
   app2.get("/api/eval/runs/:rid", async (request, reply) => {
     try {
-      const tenantId = getTenantId10(request);
+      const tenantId = getTenantId12(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" });
@@ -5835,7 +6150,7 @@ function registerEvalRoutes(app2) {
     const emitter = evalRunner.getEventEmitter();
     const eventKey = `run:${rid}`;
     if (!evalRunner.isRunning(rid)) {
-      const tenantId = getTenantId10(request);
+      const tenantId = getTenantId12(request);
       const run = await getEvalStore().getRunById(tenantId, rid);
       if (run) {
         const eventType = run.status === "completed" ? "completed" : "error";
@@ -5874,7 +6189,7 @@ data: ${JSON.stringify(event.data)}
   });
   app2.delete("/api/eval/runs/:rid", async (request, reply) => {
     try {
-      const tenantId = getTenantId10(request);
+      const tenantId = getTenantId12(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" });
@@ -5885,7 +6200,7 @@ data: ${JSON.stringify(event.data)}
   });
   app2.get("/api/eval/reports/projects/:pid", async (request, reply) => {
     try {
-      const tenantId = getTenantId10(request);
+      const tenantId = getTenantId12(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" });
@@ -5897,11 +6212,11 @@ data: ${JSON.stringify(event.data)}
 }
 
 // src/controllers/users.ts
-var import_core25 = require("@axiom-lattice/core");
+var import_core27 = require("@axiom-lattice/core");
 var import_uuid5 = require("uuid");
 var UsersController = class {
   constructor() {
-    this.userStore = (0, import_core25.getStoreLattice)("default", "user").store;
+    this.userStore = (0, import_core27.getStoreLattice)("default", "user").store;
   }
   async listUsers(request, reply) {
     const { email } = request.query;
@@ -5979,11 +6294,11 @@ function registerUserRoutes(app2) {
 }
 
 // src/controllers/tenants.ts
-var import_core26 = require("@axiom-lattice/core");
+var import_core28 = require("@axiom-lattice/core");
 var import_uuid6 = require("uuid");
 var TenantsController = class {
   constructor() {
-    this.tenantStore = (0, import_core26.getStoreLattice)("default", "tenant").store;
+    this.tenantStore = (0, import_core28.getStoreLattice)("default", "tenant").store;
   }
   // ==================== Tenant CRUD ====================
   async listTenants(request, reply) {
@@ -6047,7 +6362,7 @@ function registerTenantRoutes(app2) {
 }
 
 // src/controllers/auth.ts
-var import_core27 = require("@axiom-lattice/core");
+var import_core29 = require("@axiom-lattice/core");
 var import_uuid7 = require("uuid");
 var defaultAuthConfig = {
   autoApproveUsers: true,
@@ -6056,9 +6371,9 @@ var defaultAuthConfig = {
 };
 var AuthController = class {
   constructor(config = {}) {
-    this.userStore = (0, import_core27.getStoreLattice)("default", "user").store;
-    this.tenantStore = (0, import_core27.getStoreLattice)("default", "tenant").store;
-    this.userTenantLinkStore = (0, import_core27.getStoreLattice)("default", "userTenantLink").store;
+    this.userStore = (0, import_core29.getStoreLattice)("default", "user").store;
+    this.tenantStore = (0, import_core29.getStoreLattice)("default", "tenant").store;
+    this.userTenantLinkStore = (0, import_core29.getStoreLattice)("default", "userTenantLink").store;
     this.config = { ...defaultAuthConfig, ...config };
   }
   async register(request, reply) {
@@ -6212,6 +6527,8 @@ var AuthController = class {
         });
       }
       const token = await this.generateToken(userId, tenantId);
+      const link = await this.userTenantLinkStore.getLink(userId, tenantId);
+      const linkMeta = link?.metadata || {};
       return {
         success: true,
         data: {
@@ -6220,7 +6537,12 @@ var AuthController = class {
             name: tenant.name,
             status: tenant.status
           },
-          token
+          token,
+          personalAssistant: linkMeta.personalAssistantId ? {
+            assistantId: linkMeta.personalAssistantId,
+            projectId: linkMeta.personalProjectId || "default",
+            workspaceId: linkMeta.personalWorkspaceId || "default"
+          } : null
         }
       };
     } catch (error) {
@@ -6466,82 +6788,6 @@ function normalizeChatType(chatType) {
   return chatType === "p2p" ? "direct" : "group";
 }
 
-// src/channels/lark/LarkChannelAdapter.ts
-var larkConfigSchema = import_zod.z.object({
-  appId: import_zod.z.string(),
-  appSecret: import_zod.z.string(),
-  verificationToken: import_zod.z.string().optional(),
-  encryptKey: import_zod.z.string().optional()
-});
-var larkChannelAdapter = {
-  channel: "lark",
-  configSchema: larkConfigSchema,
-  async receive(rawPayload, installation) {
-    const event = parseLarkMessageEvent(rawPayload);
-    if (!event) return null;
-    return {
-      channel: "lark",
-      channelInstallationId: installation.id,
-      tenantId: installation.tenantId,
-      sender: {
-        id: event.openId,
-        displayName: void 0
-      },
-      content: {
-        text: event.text,
-        metadata: {
-          chatId: event.chatId,
-          chatType: event.chatType,
-          messageId: event.messageId
-        }
-      },
-      conversation: {
-        id: event.chatId,
-        type: event.chatType
-      },
-      replyTarget: {
-        adapterChannel: "lark",
-        channelInstallationId: installation.id,
-        rawTarget: {
-          chatId: event.chatId,
-          messageId: event.messageId,
-          chatType: event.chatType
-        }
-      }
-    };
-  },
-  async sendReply(replyTarget, message, installation) {
-    const { createLarkSender: createLarkSender2 } = await Promise.resolve().then(() => (init_sender(), sender_exports));
-    const sender = await createLarkSender2(installation.config);
-    await sender.sendTextReply({
-      chatId: replyTarget.rawTarget.chatId,
-      text: message.text
-    });
-  }
-};
-
-// src/channels/lark/verification.ts
-var import_crypto6 = __toESM(require("crypto"));
-function parseLarkRequestBody(body, encryptKey) {
-  const parsed = body || {};
-  if (encryptKey && typeof parsed.encrypt === "string") {
-    return decryptLarkPayload(encryptKey, parsed.encrypt);
-  }
-  return parsed;
-}
-function decryptLarkPayload(encryptKey, encryptedPayload) {
-  const key = import_crypto6.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_crypto6.default.createDecipheriv("aes-256-cbc", key, iv);
-  const plaintext = Buffer.concat([
-    decipher.update(ciphertext),
-    decipher.final()
-  ]).toString("utf8");
-  return JSON.parse(plaintext);
-}
-
 // src/logger/Logger.ts
 var import_pino = __toESM(require("pino"));
 var import_pino_pretty = require("pino-pretty");
@@ -6680,8 +6926,165 @@ var Logger = class _Logger {
   }
 };
 
-// src/channels/lark/controller.ts
+// src/channels/lark/LarkChannelAdapter.ts
+var Lark = __toESM(require("@larksuiteoapi/node-sdk"));
 var logger = new Logger({ serviceName: "lattice/gateway/lark" });
+var activeConnections = /* @__PURE__ */ new Map();
+function parseTextContent(content) {
+  if (!content) return null;
+  try {
+    const parsed = JSON.parse(content);
+    return typeof parsed.text === "string" ? parsed.text : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeChatType2(chatType) {
+  return chatType === "p2p" ? "direct" : "group";
+}
+function wsEventToInbound(event, installationId, tenantId) {
+  const messageId = event.message?.message_id;
+  const chatId = event.message?.chat_id;
+  const openId = event.sender?.sender_id?.open_id;
+  if (!messageId || !chatId || !openId) return null;
+  if (event.message?.message_type !== "text") return null;
+  const text = parseTextContent(event.message.content);
+  if (!text) return null;
+  const chatType = normalizeChatType2(event.message.chat_type);
+  return {
+    channel: "lark",
+    channelInstallationId: installationId,
+    tenantId,
+    sender: { id: openId, displayName: void 0 },
+    content: { text, metadata: { chatId, chatType, messageId } },
+    conversation: { id: chatId, type: chatType },
+    replyTarget: {
+      adapterChannel: "lark",
+      channelInstallationId: installationId,
+      rawTarget: { chatId, messageId, chatType }
+    }
+  };
+}
+var larkConfigSchema = import_zod.z.object({
+  appId: import_zod.z.string(),
+  appSecret: import_zod.z.string(),
+  verificationToken: import_zod.z.string().optional(),
+  encryptKey: import_zod.z.string().optional()
+});
+var larkChannelAdapter = {
+  channel: "lark",
+  configSchema: larkConfigSchema,
+  async receive(rawPayload, installation) {
+    const event = parseLarkMessageEvent(rawPayload);
+    if (!event) return null;
+    return {
+      channel: "lark",
+      channelInstallationId: installation.id,
+      tenantId: installation.tenantId,
+      sender: { id: event.openId, displayName: void 0 },
+      content: {
+        text: event.text,
+        metadata: { chatId: event.chatId, chatType: event.chatType, messageId: event.messageId }
+      },
+      conversation: { id: event.chatId, type: event.chatType },
+      replyTarget: {
+        adapterChannel: "lark",
+        channelInstallationId: installation.id,
+        rawTarget: { chatId: event.chatId, messageId: event.messageId, chatType: event.chatType }
+      }
+    };
+  },
+  async sendReply(replyTarget, message, installation) {
+    const { createLarkSender: createLarkSender2 } = await Promise.resolve().then(() => (init_sender(), sender_exports));
+    const sender = await createLarkSender2(installation.config);
+    await sender.sendTextReply({
+      chatId: replyTarget.rawTarget.chatId,
+      text: message.text
+    });
+  },
+  resolveThreadId(message, binding) {
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const chatType = message.conversation?.type === "direct" ? "dm" : "group";
+    const agentId = binding.agentId;
+    if (chatType === "dm") {
+      return `lark:dm:${message.sender.id}:${agentId}:${date}`;
+    }
+    return `lark:group:${message.conversation?.id ?? "unknown"}:${agentId}:${date}`;
+  },
+  async connect(installation, deps) {
+    const { id: installationId, tenantId, config } = installation;
+    if (!config.appId || !config.appSecret) {
+      logger.warn("Lark installation missing credentials, skipping", { installationId });
+      return;
+    }
+    if (activeConnections.has(installationId)) {
+      logger.warn("Lark WS already connected for installation, skipping", { installationId });
+      return;
+    }
+    logger.info("Lark WS client starting", { installationId, tenantId });
+    const router = deps?.router;
+    const eventDispatcher = new Lark.EventDispatcher({}).register({
+      "im.message.receive_v1": async (data) => {
+        try {
+          const inbound = wsEventToInbound(data, installationId, tenantId);
+          if (!inbound) return;
+          logger.info("Lark WS message received", {
+            installationId,
+            senderId: inbound.sender.id,
+            chatId: data.message?.chat_id
+          });
+          if (router) {
+            const result = await router.dispatch(inbound);
+            if (!result.success) {
+              logger.warn("Lark WS dispatch failed", {
+                installationId,
+                error: result.error?.message
+              });
+            }
+          }
+        } catch (err) {
+          logger.error("Lark WS event handler error", {
+            installationId,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    });
+    const client = new Lark.WSClient({
+      appId: config.appId,
+      appSecret: config.appSecret,
+      loggerLevel: Lark.LoggerLevel.info
+    });
+    await client.start({ eventDispatcher });
+    activeConnections.set(installationId, client);
+    logger.info("Lark WS client connected", { installationId });
+  }
+};
+
+// src/channels/lark/verification.ts
+var import_crypto7 = __toESM(require("crypto"));
+function parseLarkRequestBody(body, encryptKey) {
+  const parsed = body || {};
+  if (encryptKey && typeof parsed.encrypt === "string") {
+    return decryptLarkPayload(encryptKey, parsed.encrypt);
+  }
+  return parsed;
+}
+function decryptLarkPayload(encryptKey, encryptedPayload) {
+  const key = import_crypto7.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 plaintext = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]).toString("utf8");
+  return JSON.parse(plaintext);
+}
+
+// src/channels/lark/controller.ts
+var logger2 = new Logger({ serviceName: "lattice/gateway/lark" });
 function createLarkEventHandler(deps) {
   return async function handleLarkEvent(request, reply) {
     const { installationId } = request.params;
@@ -6702,7 +7105,7 @@ function createLarkEventHandler(deps) {
       return;
     }
     deps.router.dispatch(inboundMessage).catch((error) => {
-      logger.error("Lark message dispatch error", {
+      logger2.error("Lark message dispatch error", {
         error: error instanceof Error ? error.message : String(error)
       });
     });
@@ -6734,8 +7137,8 @@ function registerChannelRoutes(app2, dependencies) {
 }
 
 // src/controllers/channel-installations.ts
-var import_crypto7 = require("crypto");
-function getTenantId11(request) {
+var import_crypto8 = require("crypto");
+function getTenantId13(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
     return userTenantId;
@@ -6743,8 +7146,8 @@ function getTenantId11(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getInstallationStore() {
-  const { getStoreLattice: getStoreLattice16 } = await import("@axiom-lattice/core");
-  const store = getStoreLattice16("default", "channelInstallation").store;
+  const { getStoreLattice: getStoreLattice18 } = await import("@axiom-lattice/core");
+  const store = getStoreLattice18("default", "channelInstallation").store;
   if (store) return store;
   const { PostgreSQLChannelInstallationStore } = await import("@axiom-lattice/pg-stores");
   const databaseUrl = process.env.DATABASE_URL;
@@ -6756,7 +7159,7 @@ async function getInstallationStore() {
   });
 }
 async function getChannelInstallationList(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId13(request);
   const { channel } = request.query;
   try {
     const store = await getInstallationStore();
@@ -6782,7 +7185,7 @@ async function getChannelInstallationList(request, reply) {
   }
 }
 async function getChannelInstallation(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId13(request);
   const { installationId } = request.params;
   try {
     const store = await getInstallationStore();
@@ -6815,7 +7218,7 @@ async function getChannelInstallation(request, reply) {
   }
 }
 async function createChannelInstallation(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId13(request);
   const body = request.body;
   try {
     if (!body.channel) {
@@ -6850,7 +7253,7 @@ async function createChannelInstallation(request, reply) {
       }
     }
     const store = await getInstallationStore();
-    const installationId = body.id || (0, import_crypto7.randomUUID)();
+    const installationId = body.id || (0, import_crypto8.randomUUID)();
     const installation = await store.createInstallation(
       tenantId,
       installationId,
@@ -6878,7 +7281,7 @@ async function createChannelInstallation(request, reply) {
   }
 }
 async function updateChannelInstallation(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId13(request);
   const { installationId } = request.params;
   const body = request.body;
   try {
@@ -6924,7 +7327,7 @@ async function updateChannelInstallation(request, reply) {
   }
 }
 async function deleteChannelInstallation(request, reply) {
-  const tenantId = getTenantId11(request);
+  const tenantId = getTenantId13(request);
   const { installationId } = request.params;
   try {
     const store = await getInstallationStore();
@@ -6974,17 +7377,17 @@ function registerChannelInstallationRoutes(app2) {
 }
 
 // src/controllers/channel-bindings.ts
-var import_core28 = require("@axiom-lattice/core");
-function getTenantId12(request) {
+var import_core30 = require("@axiom-lattice/core");
+function getTenantId14(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) return userTenantId;
   return request.headers["x-tenant-id"] || "default";
 }
 async function getBindingList(request, _reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId14(request);
   const { channel, agentId, channelInstallationId, limit, offset } = request.query;
   try {
-    const registry = (0, import_core28.getBindingRegistry)();
+    const registry = (0, import_core30.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) {
@@ -6993,9 +7396,9 @@ async function getBindingList(request, _reply) {
   }
 }
 async function getBinding(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId14(request);
   try {
-    const registry = (0, import_core28.getBindingRegistry)();
+    const registry = (0, import_core30.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const binding = bindings.find((b) => b.id === request.params.id);
     if (!binding || binding.tenantId !== tenantId) {
@@ -7009,9 +7412,9 @@ async function getBinding(request, reply) {
   }
 }
 async function createBinding(request, reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId14(request);
   try {
-    const registry = (0, import_core28.getBindingRegistry)();
+    const registry = (0, import_core30.getBindingRegistry)();
     const binding = await registry.create({ ...request.body, tenantId });
     reply.status(201);
     return { success: true, message: "Binding created", data: binding };
@@ -7023,8 +7426,8 @@ async function createBinding(request, reply) {
 }
 async function updateBinding(request, reply) {
   try {
-    const tenantId = getTenantId12(request);
-    const registry = (0, import_core28.getBindingRegistry)();
+    const tenantId = getTenantId14(request);
+    const registry = (0, import_core30.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const existing = bindings.find((b) => b.id === request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
@@ -7041,8 +7444,8 @@ async function updateBinding(request, reply) {
 }
 async function deleteBinding(request, reply) {
   try {
-    const tenantId = getTenantId12(request);
-    const registry = (0, import_core28.getBindingRegistry)();
+    const tenantId = getTenantId14(request);
+    const registry = (0, import_core30.getBindingRegistry)();
     const bindings = await registry.list({ tenantId });
     const existing = bindings.find((b) => b.id === request.params.id);
     if (!existing || existing.tenantId !== tenantId) {
@@ -7058,10 +7461,10 @@ async function deleteBinding(request, reply) {
   }
 }
 async function resolveBinding(request, _reply) {
-  const tenantId = getTenantId12(request);
+  const tenantId = getTenantId14(request);
   const { channel, senderId, channelInstallationId } = request.query;
   try {
-    const registry = (0, import_core28.getBindingRegistry)();
+    const registry = (0, import_core30.getBindingRegistry)();
     const binding = await registry.resolve({ channel, senderId, channelInstallationId, tenantId });
     if (!binding) {
       return { success: false, message: "No binding found", data: null };
@@ -7083,6 +7486,105 @@ function registerChannelBindingRoutes(app2) {
   app2.delete("/api/channel-bindings/:id", deleteBinding);
 }
 
+// src/controllers/menu-items.ts
+var import_core31 = require("@axiom-lattice/core");
+function getTenantId15(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return request.headers["x-tenant-id"] || "default";
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : "Unexpected error";
+}
+async function getMenuItemList(request, _reply) {
+  const tenantId = getTenantId15(request);
+  try {
+    const registry = (0, import_core31.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) {
+    const msg = errorMessage(error);
+    console.error("Failed to get menu items:", msg);
+    return { success: false, message: msg, data: { records: [], total: 0 } };
+  }
+}
+async function getMenuItem(request, reply) {
+  const tenantId = getTenantId15(request);
+  try {
+    const registry = (0, import_core31.getMenuRegistry)();
+    const item = await registry.getById(request.params.id);
+    if (!item || item.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Menu item not found" };
+    }
+    return { success: true, message: "Menu item retrieved", data: item };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to get menu item:", msg);
+    reply.status(500);
+    return { success: false, message: msg };
+  }
+}
+async function createMenuItem(request, reply) {
+  const tenantId = getTenantId15(request);
+  try {
+    const registry = (0, import_core31.getMenuRegistry)();
+    const item = await registry.create({ ...request.body, tenantId });
+    reply.status(201);
+    return { success: true, message: "Menu item created", data: item };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to create menu item:", msg);
+    reply.status(500);
+    return { success: false, message: msg };
+  }
+}
+async function updateMenuItem(request, reply) {
+  try {
+    const tenantId = getTenantId15(request);
+    const registry = (0, import_core31.getMenuRegistry)();
+    const existing = await registry.getById(request.params.id);
+    if (!existing || existing.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Menu item not found" };
+    }
+    const item = await registry.update(request.params.id, request.body);
+    return { success: true, message: "Menu item updated", data: item };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to update menu item:", msg);
+    reply.status(500);
+    return { success: false, message: msg };
+  }
+}
+async function deleteMenuItem(request, reply) {
+  try {
+    const tenantId = getTenantId15(request);
+    const registry = (0, import_core31.getMenuRegistry)();
+    const existing = await registry.getById(request.params.id);
+    if (!existing || existing.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Menu item not found" };
+    }
+    await registry.delete(request.params.id);
+    return { success: true, message: "Menu item deleted" };
+  } catch (error) {
+    const msg = errorMessage(error);
+    console.error("Failed to delete menu item:", msg);
+    reply.status(500);
+    return { success: false, message: msg };
+  }
+}
+
+// src/routes/menu-items.ts
+function registerMenuItemRoutes(app2) {
+  app2.get("/api/menu-items", getMenuItemList);
+  app2.post("/api/menu-items", createMenuItem);
+  app2.get("/api/menu-items/:id", getMenuItem);
+  app2.put("/api/menu-items/:id", updateMenuItem);
+  app2.delete("/api/menu-items/:id", deleteMenuItem);
+}
+
 // src/routes/a2a-bridge.ts
 var import_uuid8 = require("uuid");
 var log = {
@@ -7263,6 +7765,7 @@ var registerLatticeRoutes = (app2, channelDeps) => {
   app2.post("/api/runs", createRun);
   app2.post("/api/resume_stream", resumeStream);
   app2.post("/api/assistants/:assistantId/threads/:threadId/abort", abortRun);
+  app2.post("/api/assistants/:assistantId/threads/:threadId/recover", recoverRun);
   app2.get(
     "/api/assistants/:assistantId/:thread_id/memory",
     { schema: getAllMemoryItemsSchema },
@@ -7298,6 +7801,15 @@ var registerLatticeRoutes = (app2, channelDeps) => {
   app2.post("/api/assistants", createAssistant);
   app2.put("/api/assistants/:id", updateAssistant);
   app2.delete("/api/assistants/:id", deleteAssistant);
+  app2.post("/api/personal-assistant", createPersonalAssistant);
+  app2.get("/api/personal-assistant", getPersonalAssistant);
+  app2.delete("/api/personal-assistant", deletePersonalAssistant);
+  app2.get("/api/tasks", listTasks);
+  app2.get("/api/tasks/:id", getTask);
+  app2.post("/api/tasks", createTask);
+  app2.put("/api/tasks/:id", updateTask);
+  app2.delete("/api/tasks/:id", deleteTask);
+  app2.patch("/api/tasks/:id/complete", completeTask);
   app2.get(
     "/api/assistants/:assistantId/graph",
     { schema: getAgentGraphSchema },
@@ -7396,6 +7908,7 @@ var registerLatticeRoutes = (app2, channelDeps) => {
   });
   registerChannelRoutes(app2, channelDeps);
   registerChannelInstallationRoutes(app2);
+  registerMenuItemRoutes(app2);
   if (channelDeps) {
     registerChannelBindingRoutes(app2);
   }
@@ -7473,8 +7986,8 @@ var registerLatticeRoutes = (app2, channelDeps) => {
 };
 
 // src/router/MessageRouter.ts
-var import_core29 = require("@axiom-lattice/core");
-var import_crypto8 = require("crypto");
+var import_core32 = require("@axiom-lattice/core");
+var import_crypto9 = require("crypto");
 var BindingNotFoundError = class extends Error {
   constructor(message) {
     super(message);
@@ -7521,6 +8034,9 @@ var MessageRouter = class {
       inboundMessage: message,
       metadata: {}
     };
+    let binding = null;
+    let threadId;
+    let agentId;
     try {
       await this.runMiddlewares(ctx, async () => {
         const tenantId = message.tenantId || (await this.installationStore.getInstallationById(message.channelInstallationId))?.tenantId;
@@ -7537,16 +8053,18 @@ var MessageRouter = class {
           );
         }
         console.log({ event: "dispatch:start", channel: message.channel, senderId: message.sender.id, tenantId }, "Message dispatch started");
-        let binding = await this.bindingRegistry.resolve({
+        const adapter = this.adapterRegistry.get(message.channel);
+        const hasAdapterThreadStrategy = !!adapter?.resolveThreadId;
+        binding = await this.bindingRegistry.resolve({
           channel: message.channel,
           senderId: message.sender.id,
           channelInstallationId: message.channelInstallationId,
           tenantId
         });
+        const installation = await this.installationStore.getInstallationById(
+          message.channelInstallationId
+        );
         if (!binding) {
-          const installation = await this.installationStore.getInstallationById(
-            message.channelInstallationId
-          );
           if (installation?.rejectWhenNoBinding) {
             console.warn({
               event: "dispatch:no_binding",
@@ -7579,7 +8097,7 @@ var MessageRouter = class {
               createdAt: /* @__PURE__ */ new Date(),
               updatedAt: /* @__PURE__ */ new Date()
             };
-          } else {
+          } else if (!hasAdapterThreadStrategy) {
             console.error({
               event: "dispatch:no_fallback",
               channel: message.channel,
@@ -7591,47 +8109,99 @@ var MessageRouter = class {
             );
           }
         }
-        ctx.binding = binding;
-        console.log({
-          event: "dispatch:binding",
-          bindingId: binding.id,
-          agentId: binding.agentId,
-          threadId: binding.threadId,
-          threadMode: binding.threadMode,
-          workspaceId: binding.workspaceId,
-          projectId: binding.projectId
-        }, "Binding resolved");
-        if (!binding.enabled) {
-          console.warn({
-            event: "dispatch:binding_disabled",
+        ctx.binding = binding ?? void 0;
+        if (binding) {
+          console.log({
+            event: "dispatch:binding",
             bindingId: binding.id,
             agentId: binding.agentId,
-            senderId: message.sender.id
-          }, "Binding is disabled, rejecting message");
+            threadId: binding.threadId,
+            threadMode: binding.threadMode,
+            workspaceId: binding.workspaceId,
+            projectId: binding.projectId
+          }, "Binding resolved");
+          if (!binding.enabled) {
+            console.warn({
+              event: "dispatch:binding_disabled",
+              bindingId: binding.id,
+              agentId: binding.agentId,
+              senderId: message.sender.id
+            }, "Binding is disabled, rejecting message");
+            throw new BindingNotFoundError(
+              `Binding for sender "${message.sender.id}" is disabled`
+            );
+          }
+        }
+        agentId = binding?.agentId ?? installation?.fallbackAgentId;
+        if (!agentId) {
           throw new BindingNotFoundError(
-            `Binding for sender "${message.sender.id}" is disabled`
+            `No agent configured for sender "${message.sender.id}"`
           );
         }
-        let threadId = ctx.binding.threadMode === "per_conversation" ? void 0 : ctx.binding.threadId;
+        if (hasAdapterThreadStrategy) {
+          const resolvedThreadId = await adapter.resolveThreadId(message, binding);
+          threadId = resolvedThreadId;
+          console.log({
+            event: "dispatch:thread:adapter",
+            threadId,
+            channel: message.channel,
+            adapterChannel: adapter.channel
+          }, "Thread resolved by adapter strategy");
+          const threadStore = (0, import_core32.getStoreLattice)("default", "thread").store;
+          try {
+            await threadStore.createThread(
+              tenantId,
+              agentId,
+              threadId,
+              {
+                metadata: {
+                  channel: message.channel,
+                  channelInstallationId: message.channelInstallationId,
+                  senderId: message.sender.id,
+                  bindingId: binding?.id,
+                  ...message.conversation ? {
+                    conversationId: message.conversation.id,
+                    conversationType: message.conversation.type
+                  } : {}
+                }
+              }
+            );
+            console.log({
+              event: "dispatch:thread:adapter:created",
+              threadId
+            }, "Thread created by adapter strategy");
+          } catch {
+            console.log({
+              event: "dispatch:thread:adapter:reuse",
+              threadId
+            }, "Thread already exists, reusing");
+          }
+        } else if (binding) {
+          if (binding.threadMode === "per_conversation") {
+            threadId = void 0;
+          } else {
+            threadId = binding.threadId;
+          }
+        }
         if (!threadId) {
-          const threadStore = (0, import_core29.getStoreLattice)("default", "thread").store;
-          const newThreadId = (0, import_crypto8.randomUUID)();
+          const threadStore = (0, import_core32.getStoreLattice)("default", "thread").store;
+          const newThreadId = (0, import_crypto9.randomUUID)();
           console.log({
             event: "dispatch:thread:create",
-            agentId: ctx.binding.agentId,
+            agentId,
             newThreadId,
             tenantId
           }, "Creating new thread for binding");
           const newThread = await threadStore.createThread(
             tenantId,
-            ctx.binding.agentId,
+            agentId,
             newThreadId,
             {
               metadata: {
                 channel: message.channel,
                 channelInstallationId: message.channelInstallationId,
                 senderId: message.sender.id,
-                bindingId: ctx.binding.id,
+                bindingId: binding?.id,
                 ...message.conversation ? {
                   conversationId: message.conversation.id,
                   conversationType: message.conversation.type
@@ -7640,36 +8210,35 @@ var MessageRouter = class {
             }
           );
           threadId = newThread.id;
-          if (ctx.binding.id !== "fallback") {
-            await this.bindingRegistry.update(ctx.binding.id, { threadId });
-            ctx.binding.threadId = threadId;
-          } else {
-            ctx.binding.threadId = threadId;
+          if (binding && binding.id !== "fallback") {
+            await this.bindingRegistry.update(binding.id, { threadId });
+            binding.threadId = threadId;
+          } else if (binding) {
+            binding.threadId = threadId;
           }
         }
         console.log({
           event: "dispatch:agent",
-          agentId: ctx.binding.agentId,
+          agentId,
           threadId,
-          threadMode: ctx.binding.threadMode,
           senderId: message.sender.id,
           contentLength: message.content.text.length
         }, "Dispatching to agent");
-        const agent = import_core29.agentInstanceManager.getAgent({
+        const agent = import_core32.agentInstanceManager.getAgent({
           tenant_id: tenantId,
-          assistant_id: ctx.binding.agentId,
+          assistant_id: agentId,
           thread_id: threadId,
-          workspace_id: ctx.binding.workspaceId || "",
-          project_id: ctx.binding.projectId || ""
+          workspace_id: binding?.workspaceId || "",
+          project_id: binding?.projectId || ""
         });
         if (message.replyTarget) {
           const replySubKey = `${threadId}:${message.replyTarget.adapterChannel}:reply`;
-          const adapter = this.adapterRegistry.get(message.replyTarget.adapterChannel);
-          if (adapter) {
-            const installation = await this.installationStore.getInstallationById(
+          const adapter2 = this.adapterRegistry.get(message.replyTarget.adapterChannel);
+          if (adapter2) {
+            const installation2 = await this.installationStore.getInstallationById(
               message.channelInstallationId
             );
-            if (installation) {
+            if (installation2) {
               const existing = this._replySubs.get(replySubKey);
               if (!existing || existing.count === 0) {
                 const timer = setTimeout(() => {
@@ -7709,7 +8278,7 @@ var MessageRouter = class {
                       channel: message.replyTarget.adapterChannel,
                       replyLength: replyText.length
                     }, "Sending channel reply");
-                    adapter.sendReply(message.replyTarget, { text: replyText }, installation).then(() => {
+                    adapter2.sendReply(message.replyTarget, { text: replyText }, installation2).then(() => {
                       console.log({
                         event: "dispatch:reply:sent",
                         threadId,
@@ -7747,7 +8316,7 @@ var MessageRouter = class {
         });
         console.log({
           event: "dispatch:complete",
-          agentId: ctx.binding.agentId,
+          agentId,
           threadId,
           messageId: addResult?.messageId,
           result: JSON.stringify(addResult)
@@ -7756,7 +8325,7 @@ var MessageRouter = class {
       return {
         success: true,
         bindingId: ctx.binding?.id,
-        threadId: ctx.binding?.threadId,
+        threadId,
         result: ctx.result
       };
     } catch (error) {
@@ -7867,13 +8436,13 @@ function createRateLimitMiddleware(maxRequests = 10, windowMs = 60 * 1e3, maxEnt
 }
 
 // src/router/middlewares/auditLogger.ts
-var logger2 = new Logger({ serviceName: "lattice/gateway/audit" });
+var logger3 = new Logger({ serviceName: "lattice/gateway/audit" });
 function createAuditLoggerMiddleware() {
   return async (ctx, next) => {
     const start2 = Date.now();
     try {
       await next();
-      logger2.info("message routed", {
+      logger3.info("message routed", {
         event: "message:routed",
         channel: ctx.inboundMessage.channel,
         senderId: ctx.inboundMessage.sender.id,
@@ -7883,7 +8452,7 @@ function createAuditLoggerMiddleware() {
         status: "success"
       });
     } catch (error) {
-      logger2.error(
+      logger3.error(
         error instanceof Error ? error.message : String(error),
         {
           event: "message:error",
@@ -7899,7 +8468,7 @@ function createAuditLoggerMiddleware() {
 }
 
 // src/index.ts
-var import_core32 = require("@axiom-lattice/core");
+var import_core35 = require("@axiom-lattice/core");
 
 // src/swagger.ts
 var import_swagger = __toESM(require("@fastify/swagger"));
@@ -7964,7 +8533,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core30 = require("@axiom-lattice/core");
+var import_core33 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -7982,21 +8551,22 @@ 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_core30.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_core30.QueueMode.STEER);
+    const agent = import_core33.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_core33.QueueMode.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
-        import_core30.eventBus.publish(callback_event, {
+        import_core33.eventBus.publish(callback_event, {
           success: true,
-          state: evt.state,
-          config: { assistant_id, thread_id, tenant_id }
+          state: evt.state
         });
         if (main_thread_id && main_tenant_id) {
           try {
-            const mainAgent = import_core30.agentInstanceManager.getAgent({
+            const mainAgent = import_core33.agentInstanceManager.getAgent({
               assistant_id: main_assistant_id ?? assistant_id,
               thread_id: main_thread_id,
-              tenant_id: main_tenant_id
+              tenant_id: main_tenant_id,
+              workspace_id: runConfig?.workspaceId,
+              project_id: runConfig?.projectId
             });
             if (mainAgent) {
               const messages = evt.state?.values?.messages;
@@ -8021,10 +8591,9 @@ ${summary}`
         }
       });
       agent.subscribeOnce("message:interrupted", (evt) => {
-        import_core30.eventBus.publish(callback_event, {
+        import_core33.eventBus.publish(callback_event, {
           success: true,
-          state: evt.state,
-          config: { assistant_id, thread_id, tenant_id }
+          state: evt.state
         });
       });
     }
@@ -8045,10 +8614,9 @@ ${summary}`
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core30.eventBus.publish(callback_event, {
+      import_core33.eventBus.publish(callback_event, {
         success: false,
-        error: error instanceof Error ? error.message : String(error),
-        config: { assistant_id, thread_id, tenant_id }
+        error: error instanceof Error ? error.message : String(error)
       });
     }
     console.error(
@@ -8083,7 +8651,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core30.eventBus.subscribe(import_core30.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core33.eventBus.subscribe(import_core33.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");
   }
@@ -8202,14 +8770,9 @@ 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_core30.eventBus.publish(taskRequest.callback_event, {
+        import_core33.eventBus.publish(taskRequest.callback_event, {
           success: false,
-          error: error instanceof Error ? error.message : String(error),
-          config: {
-            assistant_id: taskRequest.assistant_id,
-            thread_id: taskRequest.thread_id,
-            tenant_id: taskRequest["x-tenant-id"]
-          }
+          error: error instanceof Error ? error.message : String(error)
         });
       }
     });
@@ -8222,7 +8785,7 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core33 = require("@axiom-lattice/core");
+var import_core36 = require("@axiom-lattice/core");
 var import_protocols5 = require("@axiom-lattice/protocols");
 var import_meta = {};
 process.on("unhandledRejection", (reason, promise) => {
@@ -8236,13 +8799,13 @@ var DEFAULT_LOGGER_CONFIG = {
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
-var logger3 = loggerLattice.client;
+var logger4 = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core33.loggerLatticeManager.hasLattice("default")) {
-    import_core33.loggerLatticeManager.removeLattice("default");
+  if (import_core36.loggerLatticeManager.hasLattice("default")) {
+    import_core36.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core33.registerLoggerLattice)("default", config);
-  return (0, import_core33.getLoggerLattice)("default");
+  (0, import_core36.registerLoggerLattice)("default", config);
+  return (0, import_core36.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -8279,6 +8842,8 @@ app.addHook("preHandler", async (request, reply) => {
   if (!authRequired) return;
   if (request.method === "OPTIONS") return;
   if (PUBLIC_ROUTES.some((r) => request.url === r)) return;
+  const urlPath = request.url.split("?")[0];
+  if (urlPath.includes("/viewfile") || urlPath.includes("/downloadfile")) return;
   return reply.status(401).send({
     success: false,
     error: "Unauthorized - Missing or invalid token"
@@ -8335,7 +8900,7 @@ app.setErrorHandler((error, request, reply) => {
     "x-request-id": getHeaderValue(request.headers["x-request-id"]),
     "x-user-id": getHeaderValue(request.headers["x-user-id"])
   };
-  logger3.error(
+  logger4.error(
     `\u8BF7\u6C42\u9519\u8BEF: ${request.method} ${request.url} error:${error.message}`,
     {
       ...context,
@@ -8351,7 +8916,7 @@ app.setErrorHandler((error, request, reply) => {
 });
 function getConfiguredSandboxProvider() {
   const sandboxProviderType = process.env.SANDBOX_PROVIDER_TYPE || "microsandbox-remote";
-  return (0, import_core33.createSandboxProvider)({
+  return (0, import_core36.createSandboxProvider)({
     type: sandboxProviderType,
     remoteBaseURL: process.env.SANDBOX_BASE_URL,
     microsandboxServiceBaseURL: process.env.MICROSANDBOX_SERVICE_BASE_URL,
@@ -8375,17 +8940,19 @@ var start = async (config) => {
         file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
       };
       loggerLattice = initializeLogger(loggerConfig);
-      logger3 = loggerLattice.client;
+      logger4 = loggerLattice.client;
     }
     app.decorate("loggerLattice", loggerLattice);
     let channelDeps;
+    const adapterRegistry = new ChannelAdapterRegistry();
+    adapterRegistry.register(larkChannelAdapter);
     try {
-      const { getStoreLattice: getStoreLattice16 } = await import("@axiom-lattice/core");
-      const bindingStore = getStoreLattice16("default", "channelBinding").store;
-      const installationStore = getStoreLattice16("default", "channelInstallation").store;
-      (0, import_core32.setBindingRegistry)(bindingStore);
-      const adapterRegistry = new ChannelAdapterRegistry();
-      adapterRegistry.register(larkChannelAdapter);
+      const { getStoreLattice: getStore2 } = await import("@axiom-lattice/core");
+      let bindingStore;
+      let installationStore;
+      bindingStore = getStore2("default", "channelBinding").store;
+      installationStore = getStore2("default", "channelInstallation").store;
+      (0, import_core35.setBindingRegistry)(bindingStore);
       const router = new MessageRouter({
         middlewares: [
           createDeduplicationMiddleware(),
@@ -8398,27 +8965,49 @@ var start = async (config) => {
       });
       channelDeps = { router, installationStore };
       try {
-        const a2aKeyStore = getStoreLattice16("default", "a2aApiKey").store;
+        const a2aKeyStore = getStore2("default", "a2aApiKey").store;
         const a2a = await Promise.resolve().then(() => (init_a2a(), a2a_exports));
         a2a.setA2AKeyStore(a2aKeyStore);
         await a2a.refreshStoreKeyMap();
-        logger3.info("A2A key store initialized");
+        logger4.info("A2A key store initialized");
       } catch {
       }
+    } catch (err) {
+      logger4.warn("Channel infrastructure unavailable", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    try {
+      const menuStore = (0, import_core36.getStoreLattice)("default", "menu").store;
+      (0, import_core35.setMenuRegistry)(menuStore);
+      logger4.info("Menu registry initialized");
     } catch {
     }
     registerLatticeRoutes(app, channelDeps);
-    if (!import_core33.sandboxLatticeManager.hasLattice("default")) {
-      import_core33.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
-      logger3.info("Registered sandbox manager from env configuration");
+    if (!import_core36.sandboxLatticeManager.hasLattice("default")) {
+      import_core36.sandboxLatticeManager.registerLattice("default", getConfiguredSandboxProvider());
+      logger4.info("Registered sandbox manager from env configuration");
+    }
+    if (channelDeps && process.env.CHANNELS_ENABLED !== "false") {
+      const { connectAllChannels } = await import("@axiom-lattice/core");
+      try {
+        await connectAllChannels(
+          (channel) => adapterRegistry.get(channel),
+          { deps: { router: channelDeps.router } }
+        );
+      } catch (err) {
+        logger4.error("Failed to start channel connections", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
     }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
     await app.listen({ port: target_port, host: "0.0.0.0" });
-    logger3.info(`Lattice Gateway is running on port: ${target_port}`);
+    logger4.info(`Lattice Gateway is running on port: ${target_port}`);
     try {
-      logger3.info("AgentLifecycleManager initialized");
+      logger4.info("AgentLifecycleManager initialized");
     } catch (error) {
-      logger3.warn("Failed to initialize AgentLifecycleManager", { error });
+      logger4.warn("Failed to initialize AgentLifecycleManager", { error });
     }
     const queueServiceConfig = config?.queueServiceConfig;
     if (queueServiceConfig) {
@@ -8428,15 +9017,13 @@ var start = async (config) => {
         agentTaskConsumer.startPollingQueue();
       }
     }
-    try {
-      logger3.info("Starting agent instance recovery...");
-      const restoreStats = await import_core33.agentInstanceManager.restore();
-      logger3.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
-    } catch (error) {
-      logger3.error("Agent recovery failed", { error });
-    }
+    import_core36.agentInstanceManager.restore().then((stats) => {
+      logger4.info(`Agent recovery complete: ${stats.restored} threads restored, ${stats.errors} errors`);
+    }).catch((error) => {
+      logger4.error("Agent recovery failed", { error });
+    });
   } catch (err) {
-    logger3.error("Server start failed", { error: err });
+    logger4.error("Server start failed", { error: err });
     process.exit(1);
   }
 };