@axiom-lattice/gateway 2.1.52 → 2.1.54

package/dist/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/index.ts
 import fastify from "fastify";
 import cors from "@fastify/cors";
@@ -591,11 +598,13 @@ async function getThreadList(request, reply) {
   const tenantId = getTenantId2(request);
   const { assistantId } = request.params;
   const metadataFilter = {};
-  if (request.query.workspaceId) {
-    metadataFilter.workspaceId = request.query.workspaceId;
+  const workspaceId = request.headers["x-workspace-id"];
+  const projectId = request.headers["x-project-id"];
+  if (workspaceId) {
+    metadataFilter.workspaceId = workspaceId;
   }
-  if (request.query.projectId) {
-    metadataFilter.projectId = request.query.projectId;
+  if (projectId) {
+    metadataFilter.projectId = projectId;
   }
   const storeLattice = getStoreLattice2("default", "thread");
   const threadStore = storeLattice.store;
@@ -4878,6 +4887,698 @@ function registerAuthRoutes(app2, config) {
   );
 }
 
+// src/channels/lark/routes.ts
+import { getStoreLattice as getStoreLattice12 } from "@axiom-lattice/core";
+import {
+  ChannelIdentityMappingStore,
+  PostgreSQLChannelInstallationStore
+} from "@axiom-lattice/pg-stores";
+
+// src/channels/lark/parser.ts
+function parseLarkMessageEvent(payload) {
+  const raw = payload;
+  if (raw.header?.event_type !== "im.message.receive_v1") {
+    return null;
+  }
+  const message = raw.event?.message;
+  const openId = raw.event?.sender?.sender_id?.open_id;
+  if (!message || !openId || message.message_type !== "text") {
+    return null;
+  }
+  const parsedContent = parseLarkTextContent(message.content);
+  if (!message.message_id || !message.chat_id || !parsedContent) {
+    return null;
+  }
+  return {
+    messageId: message.message_id,
+    openId,
+    chatId: message.chat_id,
+    chatType: normalizeChatType(message.chat_type),
+    text: parsedContent
+  };
+}
+function parseLarkTextContent(content) {
+  if (!content) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    return typeof parsed.text === "string" ? parsed.text : null;
+  } catch {
+    return null;
+  }
+}
+function normalizeChatType(chatType) {
+  return chatType === "p2p" ? "direct" : "group";
+}
+
+// src/channels/lark/controller.ts
+function createLarkEventHandler(dependencies) {
+  return async function handleLarkEvent2(request, reply) {
+    const installationId = request.params?.installationId;
+    if (!installationId) {
+      reply.status(400).send({ success: false, message: "Missing installationId" });
+      return;
+    }
+    const config = await dependencies.getInstallationConfig(installationId);
+    if (!config) {
+      reply.status(404).send({ success: false, message: "Lark installation not found" });
+      return;
+    }
+    const body = dependencies.parseRequestBody(
+      request.body,
+      config.encryptKey
+    );
+    if (!dependencies.verifyParsedBody(body, config)) {
+      reply.status(401).send({ success: false, message: "Invalid Lark request" });
+      return;
+    }
+    if (body.type === "url_verification" && body.challenge) {
+      reply.status(200).send({ challenge: body.challenge });
+      return;
+    }
+    const parsed = dependencies.parseEvent(request.body);
+    if (!parsed) {
+      reply.status(200).send({ success: true, ignored: true });
+      return;
+    }
+    const receipt = await dependencies.claimInboundReceipt({
+      channel: "lark",
+      channelAppId: config.appId,
+      externalMessageId: parsed.messageId,
+      tenantId: config.tenantId
+    });
+    if (!receipt.accepted) {
+      reply.status(200).send(
+        receipt.status === "processing" ? { success: true, processing: true } : { success: true, duplicate: true }
+      );
+      return;
+    }
+    try {
+      const { threadId } = await dependencies.resolveThread({
+        channel: "lark",
+        channelAppId: config.appId,
+        tenantId: config.tenantId,
+        assistantId: config.assistantId,
+        mappingMode: config.mappingMode,
+        openId: parsed.openId,
+        chatId: parsed.chatId,
+        chatType: parsed.chatType,
+        messageId: parsed.messageId,
+        workspaceId: config.workspaceId,
+        projectId: config.projectId
+      });
+      const text = await dependencies.runAgentAndCollectText({
+        tenantId: config.tenantId,
+        assistantId: config.assistantId,
+        threadId,
+        text: parsed.text,
+        workspaceId: config.workspaceId,
+        projectId: config.projectId
+      });
+      await dependencies.sendTextReply({
+        chatId: parsed.chatId,
+        text,
+        config
+      });
+      await dependencies.markInboundReceiptCompleted({
+        channel: "lark",
+        channelAppId: config.appId,
+        externalMessageId: parsed.messageId,
+        tenantId: config.tenantId,
+        threadId
+      });
+      reply.status(200).send({ success: true, threadId });
+    } catch (error) {
+      await dependencies.markInboundReceiptFailed({
+        channel: "lark",
+        channelAppId: config.appId,
+        externalMessageId: parsed.messageId,
+        tenantId: config.tenantId
+      });
+      throw error;
+    }
+  };
+}
+var handleLarkEvent = createLarkEventHandler({
+  getInstallationConfig: async () => null,
+  parseRequestBody: (body) => body || {},
+  verifyParsedBody: () => true,
+  parseEvent: parseLarkMessageEvent,
+  claimInboundReceipt: async () => ({ accepted: true, status: "processing" }),
+  markInboundReceiptCompleted: async () => void 0,
+  markInboundReceiptFailed: async () => void 0,
+  resolveThread: async () => ({ threadId: "" }),
+  runAgentAndCollectText: async () => "",
+  sendTextReply: async () => void 0
+});
+
+// src/channels/lark/config.ts
+function loadLarkIngressConfig() {
+  return {
+    enabled: process.env.LARK_ENABLED !== "false",
+    appId: process.env.LARK_APP_ID || "",
+    appSecret: process.env.LARK_APP_SECRET || "",
+    verificationToken: process.env.LARK_VERIFICATION_TOKEN,
+    encryptKey: process.env.LARK_ENCRYPT_KEY,
+    tenantId: process.env.LARK_TENANT_ID || "default",
+    assistantId: process.env.LARK_ASSISTANT_ID || "default_agent",
+    workspaceId: process.env.LARK_WORKSPACE_ID,
+    projectId: process.env.LARK_PROJECT_ID,
+    mappingMode: process.env.LARK_MAPPING_MODE || "hybrid"
+  };
+}
+function isLarkIngressEnabled(config) {
+  return config.enabled;
+}
+
+// src/channels/lark/mapping-service.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function createChannelThreadMappingService(deps) {
+  return {
+    async getOrCreateThread(input) {
+      const externalSubjectKey = buildExternalSubjectKey(input);
+      const existing = await deps.mappingStore.getMappingBySubject({
+        channel: input.channel,
+        channelAppId: input.channelAppId,
+        tenantId: input.tenantId,
+        assistantId: input.assistantId,
+        externalSubjectKey
+      });
+      if (existing) {
+        return { threadId: existing.threadId };
+      }
+      const threadId = (deps.uuid || randomUUID6)();
+      await deps.threadStore.createThread(input.tenantId, input.assistantId, threadId, {
+        metadata: {
+          tenantId: input.tenantId,
+          workspaceId: input.workspaceId,
+          projectId: input.projectId,
+          channel: input.channel,
+          larkChatId: input.chatId,
+          larkOpenId: input.openId
+        }
+      });
+      try {
+        await deps.mappingStore.createMapping({
+          channel: input.channel,
+          channelAppId: input.channelAppId,
+          tenantId: input.tenantId,
+          assistantId: input.assistantId,
+          mappingMode: input.mappingMode,
+          externalSubjectType: resolveSubjectType(input.mappingMode, input.chatType) === "user" ? "user" : "chat",
+          externalSubjectKey,
+          larkOpenId: input.openId,
+          larkChatId: input.chatId,
+          larkMessageId: input.messageId,
+          threadId
+        });
+      } catch (error) {
+        if (!isUniqueViolation(error)) {
+          throw error;
+        }
+        const canonical = await deps.mappingStore.getMappingBySubject({
+          channel: input.channel,
+          channelAppId: input.channelAppId,
+          tenantId: input.tenantId,
+          assistantId: input.assistantId,
+          externalSubjectKey
+        });
+        if (!canonical) {
+          throw error;
+        }
+        await deps.threadStore.deleteThread(input.tenantId, threadId);
+        return { threadId: canonical.threadId };
+      }
+      return { threadId };
+    }
+  };
+}
+function isUniqueViolation(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "23505";
+}
+function buildExternalSubjectKey(input) {
+  const subjectType = resolveSubjectType(input.mappingMode, input.chatType);
+  const subjectValue = subjectType === "user" ? input.openId : input.chatId;
+  return [
+    input.channel,
+    input.channelAppId,
+    `tenant:${input.tenantId}`,
+    `assistant:${input.assistantId}`,
+    `${subjectType}:${subjectValue}`
+  ].join(":");
+}
+function resolveSubjectType(mappingMode, chatType) {
+  if (mappingMode === "user") {
+    return "user";
+  }
+  if (mappingMode === "group") {
+    return "chat";
+  }
+  return chatType === "direct" ? "user" : "chat";
+}
+
+// src/channels/lark/runner.ts
+import { agentInstanceManager as agentInstanceManager5 } from "@axiom-lattice/core";
+import { MessageChunkTypes as MessageChunkTypes3 } from "@axiom-lattice/protocols";
+
+// src/channels/lark/aggregator.ts
+import { MessageChunkTypes as MessageChunkTypes2 } from "@axiom-lattice/protocols";
+function aggregateLarkReply(messageId, chunks) {
+  return chunks.filter(
+    (chunk) => chunk.type === MessageChunkTypes2.AI && chunk.data.id === messageId
+  ).map((chunk) => chunk.data.content || "").join("").trim();
+}
+
+// src/channels/lark/runner.ts
+async function runAgentAndCollectLarkReply(input) {
+  const agent = agentInstanceManager5.getAgent({
+    tenant_id: input.tenantId,
+    assistant_id: input.assistantId,
+    thread_id: input.threadId,
+    workspace_id: input.workspaceId,
+    project_id: input.projectId
+  });
+  const result = await agent.addMessage({
+    input: {
+      message: input.text
+    }
+  });
+  const chunks = [];
+  const stream = agent.chunkStream(result.messageId, [
+    MessageChunkTypes3.MESSAGE_COMPLETED
+  ]);
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return aggregateLarkReply(result.messageId, chunks);
+}
+
+// src/channels/lark/sender.ts
+function createLarkSender(config, client = createDefaultLarkClient(config)) {
+  return {
+    async sendTextReply(input) {
+      const response = await client.im.v1.message.create({
+        params: {
+          receive_id_type: "chat_id"
+        },
+        data: {
+          receive_id: input.chatId,
+          msg_type: "text",
+          content: JSON.stringify({ text: input.text })
+        }
+      });
+      if (response.code && response.code !== 0) {
+        throw new Error("Failed to send Lark reply");
+      }
+    }
+  };
+}
+function createDefaultLarkClient(config) {
+  const Lark = __require("@larksuiteoapi/node-sdk");
+  return new Lark.Client({
+    appId: config.appId,
+    appSecret: config.appSecret
+  });
+}
+
+// src/channels/lark/verification.ts
+import crypto2 from "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 = crypto2.createHash("sha256").update(encryptKey).digest();
+  const buffer = Buffer.from(encryptedPayload, "base64");
+  const iv = buffer.subarray(0, 16);
+  const ciphertext = buffer.subarray(16);
+  const decipher = crypto2.createDecipheriv("aes-256-cbc", key, iv);
+  const plaintext = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]).toString("utf8");
+  return JSON.parse(plaintext);
+}
+function createLarkRequestVerifier(config) {
+  return function verifyRequest(request) {
+    const body = parseLarkRequestBody(request.body, config.encryptKey);
+    return verifyLarkParsedBody(body, config);
+  };
+}
+function verifyLarkParsedBody(body, config) {
+  if (!config.verificationToken) {
+    return true;
+  }
+  return extractVerificationToken(body) === config.verificationToken;
+}
+function extractVerificationToken(body) {
+  if (typeof body.token === "string") {
+    return body.token;
+  }
+  if (typeof body.header?.token === "string") {
+    return body.header.token;
+  }
+  return void 0;
+}
+
+// src/channels/lark/routes.ts
+function registerLarkChannelRoutes(app2, dependencies) {
+  const config = loadLarkIngressConfig();
+  if (!dependencies && !isLarkIngressEnabled(config)) {
+    return;
+  }
+  const handlerDependencies = dependencies || createDefaultLarkDependencies();
+  app2.post(
+    "/api/channels/lark/installations/:installationId/events",
+    createLarkEventHandler({
+      ...handlerDependencies
+    })
+  );
+}
+function createDefaultLarkDependencies() {
+  const installationStore = new PostgreSQLChannelInstallationStore({
+    poolConfig: getDatabaseUrl()
+  });
+  const threadStore = getStoreLattice12("default", "thread").store;
+  const mappingStore = new ChannelIdentityMappingStore({
+    poolConfig: getDatabaseUrl()
+  });
+  const mappingService = createChannelThreadMappingService({
+    mappingStore,
+    threadStore
+  });
+  return {
+    getInstallationConfig: async (installationId) => {
+      const installation = await installationStore.getInstallationById(
+        installationId
+      );
+      if (!installation || installation.channel !== "lark") {
+        return null;
+      }
+      return {
+        enabled: true,
+        installationId: installation.id,
+        tenantId: installation.tenantId,
+        assistantId: installation.config.assistantId,
+        appId: installation.config.appId,
+        appSecret: installation.config.appSecret,
+        verificationToken: installation.config.verificationToken,
+        encryptKey: installation.config.encryptKey,
+        workspaceId: installation.config.workspaceId,
+        projectId: installation.config.projectId,
+        mappingMode: installation.config.mappingMode
+      };
+    },
+    parseRequestBody: (body, encryptKey) => parseLarkRequestBody(body, encryptKey),
+    verifyParsedBody: (body, config) => {
+      if (!config.verificationToken) {
+        return true;
+      }
+      return createLarkRequestVerifier(config)({
+        body
+      });
+    },
+    parseEvent: parseLarkMessageEvent,
+    claimInboundReceipt: (input) => mappingStore.claimInboundReceipt(input),
+    markInboundReceiptCompleted: (input) => mappingStore.markInboundReceiptCompleted(input),
+    markInboundReceiptFailed: (input) => mappingStore.markInboundReceiptFailed(input),
+    resolveThread: (input) => mappingService.getOrCreateThread(input),
+    runAgentAndCollectText: ({ tenantId, assistantId, threadId, text, workspaceId, projectId }) => runAgentAndCollectLarkReply({
+      tenantId,
+      assistantId,
+      threadId,
+      text,
+      workspaceId,
+      projectId
+    }),
+    sendTextReply: async ({ chatId, text, config }) => {
+      const sender = createLarkSender({
+        appId: config.appId,
+        appSecret: config.appSecret
+      });
+      await sender.sendTextReply({ chatId, text });
+    }
+  };
+}
+function getDatabaseUrl() {
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    throw new Error("DATABASE_URL is required for Lark channel ingress");
+  }
+  return databaseUrl;
+}
+
+// src/channels/routes.ts
+var channelRouteRegistrars = [
+  (app2, dependencies) => registerLarkChannelRoutes(app2, dependencies.lark)
+];
+function registerChannelRoutes(app2, dependencies = {}) {
+  for (const registerRoutes of channelRouteRegistrars) {
+    registerRoutes(app2, dependencies);
+  }
+}
+
+// src/controllers/channel-installations.ts
+import { randomUUID as randomUUID7 } from "crypto";
+function getTenantId9(request) {
+  const userTenantId = request.user?.tenantId;
+  if (userTenantId) {
+    return userTenantId;
+  }
+  return request.headers["x-tenant-id"] || "default";
+}
+function getInstallationStore() {
+  const { PostgreSQLChannelInstallationStore: PostgreSQLChannelInstallationStore2 } = __require("@axiom-lattice/pg-stores");
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    throw new Error("DATABASE_URL is required for channel installation store");
+  }
+  return new PostgreSQLChannelInstallationStore2({
+    poolConfig: databaseUrl
+  });
+}
+async function getChannelInstallationList(request, reply) {
+  const tenantId = getTenantId9(request);
+  const { channel } = request.query;
+  try {
+    const store = getInstallationStore();
+    const installations = await store.getInstallationsByTenant(tenantId, channel);
+    return {
+      success: true,
+      message: "Channel installations retrieved successfully",
+      data: {
+        records: installations,
+        total: installations.length
+      }
+    };
+  } catch (error) {
+    console.error("Failed to get channel installations:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve channel installations",
+      data: {
+        records: [],
+        total: 0
+      }
+    };
+  }
+}
+async function getChannelInstallation(request, reply) {
+  const tenantId = getTenantId9(request);
+  const { installationId } = request.params;
+  try {
+    const store = getInstallationStore();
+    const installation = await store.getInstallationById(installationId);
+    if (!installation) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Channel installation not found"
+      };
+    }
+    if (installation.tenantId !== tenantId) {
+      reply.code(403);
+      return {
+        success: false,
+        message: "Access denied"
+      };
+    }
+    return {
+      success: true,
+      message: "Channel installation retrieved successfully",
+      data: installation
+    };
+  } catch (error) {
+    console.error("Failed to get channel installation:", error);
+    return {
+      success: false,
+      message: "Failed to retrieve channel installation"
+    };
+  }
+}
+async function createChannelInstallation(request, reply) {
+  const tenantId = getTenantId9(request);
+  const body = request.body;
+  try {
+    if (!body.channel) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "Channel type is required"
+      };
+    }
+    if (!body.config) {
+      reply.code(400);
+      return {
+        success: false,
+        message: "Configuration is required"
+      };
+    }
+    if (body.channel === "lark") {
+      const larkConfig = body.config;
+      if (!larkConfig.appId || !larkConfig.appSecret) {
+        reply.code(400);
+        return {
+          success: false,
+          message: "appId and appSecret are required for Lark installations"
+        };
+      }
+      if (!larkConfig.assistantId) {
+        reply.code(400);
+        return {
+          success: false,
+          message: "assistantId is required for Lark installations"
+        };
+      }
+    }
+    const store = getInstallationStore();
+    const installationId = body.id || randomUUID7();
+    const installation = await store.createInstallation(
+      tenantId,
+      installationId,
+      body
+    );
+    reply.code(201);
+    return {
+      success: true,
+      message: "Channel installation created successfully",
+      data: installation
+    };
+  } catch (error) {
+    console.error("Failed to create channel installation:", error);
+    if (error.message?.includes("duplicate") || error.code === "23505") {
+      reply.code(409);
+      return {
+        success: false,
+        message: "Channel installation with this ID already exists"
+      };
+    }
+    return {
+      success: false,
+      message: "Failed to create channel installation"
+    };
+  }
+}
+async function updateChannelInstallation(request, reply) {
+  const tenantId = getTenantId9(request);
+  const { installationId } = request.params;
+  const body = request.body;
+  try {
+    const store = getInstallationStore();
+    const existing = await store.getInstallationById(installationId);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Channel installation not found"
+      };
+    }
+    if (existing.tenantId !== tenantId) {
+      reply.code(403);
+      return {
+        success: false,
+        message: "Access denied"
+      };
+    }
+    const installation = await store.updateInstallation(
+      tenantId,
+      installationId,
+      body
+    );
+    if (!installation) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Channel installation not found"
+      };
+    }
+    return {
+      success: true,
+      message: "Channel installation updated successfully",
+      data: installation
+    };
+  } catch (error) {
+    console.error("Failed to update channel installation:", error);
+    return {
+      success: false,
+      message: "Failed to update channel installation"
+    };
+  }
+}
+async function deleteChannelInstallation(request, reply) {
+  const tenantId = getTenantId9(request);
+  const { installationId } = request.params;
+  try {
+    const store = getInstallationStore();
+    const existing = await store.getInstallationById(installationId);
+    if (!existing) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Channel installation not found"
+      };
+    }
+    if (existing.tenantId !== tenantId) {
+      reply.code(403);
+      return {
+        success: false,
+        message: "Access denied"
+      };
+    }
+    const deleted = await store.deleteInstallation(tenantId, installationId);
+    if (!deleted) {
+      reply.code(404);
+      return {
+        success: false,
+        message: "Channel installation not found"
+      };
+    }
+    return {
+      success: true,
+      message: "Channel installation deleted successfully"
+    };
+  } catch (error) {
+    console.error("Failed to delete channel installation:", error);
+    return {
+      success: false,
+      message: "Failed to delete channel installation"
+    };
+  }
+}
+
+// src/routes/channel-installations.ts
+function registerChannelInstallationRoutes(app2) {
+  app2.get("/api/channel-installations", getChannelInstallationList);
+  app2.get("/api/channel-installations/:installationId", getChannelInstallation);
+  app2.post("/api/channel-installations", createChannelInstallation);
+  app2.put("/api/channel-installations/:installationId", updateChannelInstallation);
+  app2.delete("/api/channel-installations/:installationId", deleteChannelInstallation);
+}
+
 // src/routes/index.ts
 var registerLatticeRoutes = (app2) => {
   app2.post("/api/runs", createRun);
@@ -5013,6 +5714,8 @@ var registerLatticeRoutes = (app2) => {
     autoApproveUsers: process.env.AUTO_APPROVE_USERS !== "false",
     allowTenantRegistration: process.env.ALLOW_TENANT_REGISTRATION !== "false"
   });
+  registerChannelRoutes(app2);
+  registerChannelInstallationRoutes(app2);
   app2.delete(
     "/api/assistants/:assistant_id/threads/:thread_id/pending-messages/:message_id",
     removePendingMessageHandler
@@ -5082,7 +5785,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-import { eventBus as eventBus2, AGENT_TASK_EVENT, agentInstanceManager as agentInstanceManager5, QueueMode as QueueMode2 } from "@axiom-lattice/core";
+import { eventBus as eventBus2, AGENT_TASK_EVENT, agentInstanceManager as agentInstanceManager6, QueueMode as QueueMode2 } from "@axiom-lattice/core";
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -5097,7 +5800,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
     console.log(
       `\u5F00\u59CB\u5904\u7406\u4EFB\u52A1 [assistant_id: ${assistant_id}, thread_id: ${thread_id}]`
     );
-    const agent = agentInstanceManager5.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    const agent = agentInstanceManager6.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 }, QueueMode2.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
@@ -5315,8 +6018,8 @@ import {
   loggerLatticeManager,
   sandboxLatticeManager as sandboxLatticeManager2,
   sqlDatabaseManager as sqlDatabaseManager2,
-  getStoreLattice as getStoreLattice12,
-  agentInstanceManager as agentInstanceManager6
+  getStoreLattice as getStoreLattice13,
+  agentInstanceManager as agentInstanceManager7
 } from "@axiom-lattice/core";
 import {
   LoggerType
@@ -5445,7 +6148,7 @@ var start = async (config) => {
     app.decorate("loggerLattice", loggerLattice);
     registerLatticeRoutes(app);
     try {
-      const storeLattice = getStoreLattice12("default", "database");
+      const storeLattice = getStoreLattice13("default", "database");
       const store = storeLattice.store;
       sqlDatabaseManager2.setConfigStore(store);
       logger.info("Database config store set for SqlDatabaseManager");
@@ -5477,7 +6180,7 @@ var start = async (config) => {
     }
     try {
       logger.info("Starting agent instance recovery...");
-      const restoreStats = await agentInstanceManager6.restore();
+      const restoreStats = await agentInstanceManager7.restore();
       logger.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
     } catch (error) {
       logger.error("Agent recovery failed", { error });