@axiom-lattice/gateway 2.1.52 → 2.1.54

package/dist/index.js

@@ -623,11 +623,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 = (0, import_core6.getStoreLattice)("default", "thread");
   const threadStore = storeLattice.store;
@@ -4892,6 +4894,695 @@ function registerAuthRoutes(app2, config) {
   );
 }
 
+// src/channels/lark/routes.ts
+var import_core27 = require("@axiom-lattice/core");
+var import_pg_stores = require("@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
+var import_crypto6 = require("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 || import_crypto6.randomUUID)();
+      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
+var import_core26 = require("@axiom-lattice/core");
+var import_protocols4 = require("@axiom-lattice/protocols");
+
+// src/channels/lark/aggregator.ts
+var import_protocols3 = require("@axiom-lattice/protocols");
+function aggregateLarkReply(messageId, chunks) {
+  return chunks.filter(
+    (chunk) => chunk.type === import_protocols3.MessageChunkTypes.AI && chunk.data.id === messageId
+  ).map((chunk) => chunk.data.content || "").join("").trim();
+}
+
+// src/channels/lark/runner.ts
+async function runAgentAndCollectLarkReply(input) {
+  const agent = import_core26.agentInstanceManager.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, [
+    import_protocols4.MessageChunkTypes.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
+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);
+}
+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 import_pg_stores.PostgreSQLChannelInstallationStore({
+    poolConfig: getDatabaseUrl()
+  });
+  const threadStore = (0, import_core27.getStoreLattice)("default", "thread").store;
+  const mappingStore = new import_pg_stores.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
+var import_crypto8 = require("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 || (0, import_crypto8.randomUUID)();
+    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);
@@ -5027,6 +5718,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
@@ -5096,7 +5789,7 @@ var configureSwagger = async (app2, customSwaggerConfig, customSwaggerUiConfig)
 };
 
 // src/services/agent_task_consumer.ts
-var import_core26 = require("@axiom-lattice/core");
+var import_core28 = require("@axiom-lattice/core");
 var handleAgentTask = async (taskRequest, retryCount = 0) => {
   const {
     assistant_id,
@@ -5111,18 +5804,18 @@ 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_core26.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_core26.QueueMode.STEER);
+    const agent = import_core28.agentInstanceManager.getAgent({ assistant_id, thread_id, tenant_id, workspace_id: runConfig?.workspaceId, project_id: runConfig?.projectId, custom_run_config: runConfig });
+    await agent.addMessage({ input, command, custom_run_config: runConfig }, import_core28.QueueMode.STEER);
     if (callback_event) {
       agent.subscribeOnce("message:completed", (evt) => {
-        import_core26.eventBus.publish(callback_event, {
+        import_core28.eventBus.publish(callback_event, {
           success: true,
           state: evt.state,
           config: { assistant_id, thread_id, tenant_id }
         });
       });
       agent.subscribeOnce("message:interrupted", (evt) => {
-        import_core26.eventBus.publish(callback_event, {
+        import_core28.eventBus.publish(callback_event, {
           success: true,
           state: evt.state,
           config: { assistant_id, thread_id, tenant_id }
@@ -5146,7 +5839,7 @@ var handleAgentTask = async (taskRequest, retryCount = 0) => {
       return handleAgentTask(taskRequest, nextRetryCount);
     }
     if (callback_event) {
-      import_core26.eventBus.publish(callback_event, {
+      import_core28.eventBus.publish(callback_event, {
         success: false,
         error: error instanceof Error ? error.message : String(error),
         config: { assistant_id, thread_id, tenant_id }
@@ -5184,7 +5877,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
    * 初始化事件监听和队列轮询
    */
   initialize() {
-    import_core26.eventBus.subscribe(import_core26.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
+    import_core28.eventBus.subscribe(import_core28.AGENT_TASK_EVENT, this.trigger_agent_task.bind(this));
     this.startPollingQueue();
     console.log("Agent\u4EFB\u52A1\u6D88\u8D39\u8005\u5DF2\u542F\u52A8\u5E76\u76D1\u542C\u4EFB\u52A1\u4E8B\u4EF6\u548C\u961F\u5217");
   }
@@ -5303,7 +5996,7 @@ var _AgentTaskConsumer = class _AgentTaskConsumer {
     handleAgentTask(taskRequest).catch((error) => {
       console.error("\u5904\u7406Agent\u4EFB\u52A1\u65F6\u53D1\u751F\u672A\u6355\u83B7\u7684\u9519\u8BEF:", error);
       if (taskRequest.callback_event) {
-        import_core26.eventBus.publish(taskRequest.callback_event, {
+        import_core28.eventBus.publish(taskRequest.callback_event, {
           success: false,
           error: error instanceof Error ? error.message : String(error),
           config: {
@@ -5323,26 +6016,26 @@ _AgentTaskConsumer.agent_run_endpoint = "http://localhost:4001/api/runs";
 var AgentTaskConsumer = _AgentTaskConsumer;
 
 // src/index.ts
-var import_core27 = require("@axiom-lattice/core");
-var import_protocols3 = require("@axiom-lattice/protocols");
+var import_core29 = require("@axiom-lattice/core");
+var import_protocols5 = require("@axiom-lattice/protocols");
 process.on("unhandledRejection", (reason, promise) => {
   console.error("\u672A\u5904\u7406\u7684Promise\u62D2\u7EDD:", reason);
 });
 var DEFAULT_LOGGER_CONFIG = {
   name: "default",
   description: "Default logger for lattice-gateway service",
-  type: import_protocols3.LoggerType.PINO,
+  type: import_protocols5.LoggerType.PINO,
   serviceName: "lattice/gateway",
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
 var logger = loggerLattice.client;
 function initializeLogger(config) {
-  if (import_core27.loggerLatticeManager.hasLattice("default")) {
-    import_core27.loggerLatticeManager.removeLattice("default");
+  if (import_core29.loggerLatticeManager.hasLattice("default")) {
+    import_core29.loggerLatticeManager.removeLattice("default");
   }
-  (0, import_core27.registerLoggerLattice)("default", config);
-  return (0, import_core27.getLoggerLattice)("default");
+  (0, import_core29.registerLoggerLattice)("default", config);
+  return (0, import_core29.getLoggerLattice)("default");
 }
 var app = (0, import_fastify.default)({
   logger: false,
@@ -5449,16 +6142,16 @@ var start = async (config) => {
     app.decorate("loggerLattice", loggerLattice);
     registerLatticeRoutes(app);
     try {
-      const storeLattice = (0, import_core27.getStoreLattice)("default", "database");
+      const storeLattice = (0, import_core29.getStoreLattice)("default", "database");
       const store = storeLattice.store;
-      import_core27.sqlDatabaseManager.setConfigStore(store);
+      import_core29.sqlDatabaseManager.setConfigStore(store);
       logger.info("Database config store set for SqlDatabaseManager");
     } catch (error) {
       logger.warn("Failed to set database config store: " + (error instanceof Error ? error.message : String(error)));
     }
-    if (!import_core27.sandboxLatticeManager.hasLattice("default")) {
+    if (!import_core29.sandboxLatticeManager.hasLattice("default")) {
       const sandboxBaseURL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
-      import_core27.sandboxLatticeManager.registerLattice("default", {
+      import_core29.sandboxLatticeManager.registerLattice("default", {
         baseURL: sandboxBaseURL
       });
       logger.info(`Registered sandbox manager with baseURL: ${sandboxBaseURL}`);
@@ -5481,7 +6174,7 @@ var start = async (config) => {
     }
     try {
       logger.info("Starting agent instance recovery...");
-      const restoreStats = await import_core27.agentInstanceManager.restore();
+      const restoreStats = await import_core29.agentInstanceManager.restore();
       logger.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
     } catch (error) {
       logger.error("Agent recovery failed", { error });