@axiom-lattice/gateway 2.1.74 → 2.1.76

package/dist/index.mjs

@@ -5700,12 +5700,8 @@ function registerAuthRoutes(app2, config) {
   );
 }
 
-// src/channels/lark/routes.ts
-import { getStoreLattice as getStoreLattice14 } from "@axiom-lattice/core";
-import {
-  ChannelIdentityMappingStore,
-  PostgreSQLChannelInstallationStore
-} from "@axiom-lattice/pg-stores";
+// src/channels/lark/LarkChannelAdapter.ts
+import { z } from "zod";
 
 // src/channels/lark/parser.ts
 function parseLarkMessageEvent(payload) {
@@ -5745,276 +5741,59 @@ 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/LarkChannelAdapter.ts
+var larkConfigSchema = z.object({
+  appId: z.string(),
+  appSecret: z.string(),
+  verificationToken: z.string().optional(),
+  encryptKey: z.string().optional()
 });
-
-// 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, {
+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: {
-          tenantId: input.tenantId,
-          workspaceId: input.workspaceId,
-          projectId: input.projectId,
-          channel: input.channel,
-          larkChatId: input.chatId,
-          larkOpenId: input.openId
+          chatId: event.chatId,
+          chatType: event.chatType,
+          messageId: event.messageId
         }
-      });
-      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;
+      },
+      conversation: {
+        id: event.chatId,
+        type: event.chatType
+      },
+      replyTarget: {
+        adapterChannel: "lark",
+        channelInstallationId: installation.id,
+        rawTarget: {
+          chatId: event.chatId,
+          messageId: event.messageId,
+          chatType: event.chatType
         }
-        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 agentInstanceManager6 } from "@axiom-lattice/core";
-import { MessageChunkTypes as MessageChunkTypes4 } from "@axiom-lattice/protocols";
-
-// src/channels/lark/aggregator.ts
-import { MessageChunkTypes as MessageChunkTypes3 } from "@axiom-lattice/protocols";
-function aggregateLarkReply(messageId, chunks) {
-  return chunks.filter(
-    (chunk) => chunk.type === MessageChunkTypes3.AI && chunk.data.id === messageId
-  ).map((chunk) => chunk.data.content || "").join("").trim();
-}
-
-// src/channels/lark/runner.ts
-async function runAgentAndCollectLarkReply(input) {
-  const agent = agentInstanceManager6.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, [
-    MessageChunkTypes4.MESSAGE_COMPLETED
-  ]);
-  for await (const chunk of stream) {
-    chunks.push(chunk);
+    };
+  },
+  async sendReply(replyTarget, message, installation) {
+    const { createLarkSender } = await import("./sender-PX32VSHB.mjs");
+    const sender = createLarkSender(installation.config);
+    await sender.sendTextReply({
+      chatId: replyTarget.rawTarget.chatId,
+      text: message.text
+    });
   }
-  return aggregateLarkReply(result.messageId, chunks);
-}
-
-// src/channels/lark/sender.ts
-async function createLarkSender(config, client) {
-  const resolved = client ?? await createDefaultLarkClient(config);
-  return {
-    async sendTextReply(input) {
-      const response = await resolved.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");
-      }
-    }
-  };
-}
-async function createDefaultLarkClient(config) {
-  const Lark = await import("@larksuiteoapi/node-sdk");
-  return new Lark.Client({
-    appId: config.appId,
-    appSecret: config.appSecret
-  });
-}
+};
 
 // src/channels/lark/verification.ts
 import crypto2 from "crypto";
@@ -6037,127 +5816,199 @@ function decryptLarkPayload(encryptKey, encryptedPayload) {
   ]).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;
+
+// src/logger/Logger.ts
+import pino from "pino";
+import "pino-pretty";
+import "pino-roll";
+var PinoLoggerFactory = class _PinoLoggerFactory {
+  constructor() {
+    const isProd = process.env.NODE_ENV === "production";
+    const loggerConfig = {
+      // 自定义时间戳格式
+      timestamp: () => `,"@timestamp":"${(/* @__PURE__ */ new Date()).toISOString()}"`,
+      // 关闭默认的时间戳键
+      base: {
+        "@version": "1",
+        app_name: "lattice",
+        service_name: "lattice/graph-server",
+        thread_name: "main",
+        logger_name: "lattice-graph-logger"
+      },
+      formatters: {
+        level: (label, number) => {
+          return {
+            level: label.toUpperCase(),
+            level_value: number * 1e3
+          };
+        }
+      }
+    };
+    if (isProd) {
+      try {
+        this.pinoLogger = pino(
+          loggerConfig,
+          pino.transport({
+            target: "pino-roll",
+            options: {
+              file: "./logs/fin_ai_graph_server",
+              frequency: "daily",
+              mkdir: true
+            }
+          })
+        );
+      } catch (error) {
+        console.error(
+          "\u65E0\u6CD5\u521D\u59CB\u5316 pino-roll \u65E5\u5FD7\u8BB0\u5F55\u5668\uFF0C\u56DE\u9000\u5230\u63A7\u5236\u53F0\u65E5\u5FD7",
+          error
+        );
+        this.pinoLogger = pino({
+          ...loggerConfig,
+          transport: {
+            target: "pino-pretty",
+            options: {
+              colorize: true
+            }
+          }
+        });
+      }
+    } else {
+      this.pinoLogger = pino({
+        ...loggerConfig,
+        transport: {
+          target: "pino-pretty",
+          options: {
+            colorize: true
+          }
+        }
+      });
+    }
   }
-  return extractVerificationToken(body) === config.verificationToken;
-}
-function extractVerificationToken(body) {
-  if (typeof body.token === "string") {
-    return body.token;
+  static getInstance() {
+    if (!_PinoLoggerFactory.instance) {
+      _PinoLoggerFactory.instance = new _PinoLoggerFactory();
+    }
+    return _PinoLoggerFactory.instance;
   }
-  if (typeof body.header?.token === "string") {
-    return body.header.token;
+  getPinoLogger() {
+    return this.pinoLogger;
   }
-  return void 0;
+};
+var Logger = class _Logger {
+  constructor(options) {
+    this.context = options?.context || {};
+    this.name = options?.name || "lattice-graph-logger";
+    this.serviceName = options?.serviceName || "lattice/graph-server";
+  }
+  /**
+   * 获取合并了上下文的日志对象
+   * @param additionalContext 额外的上下文数据
+   * @returns 带有上下文的pino日志对象
+   */
+  getContextualLogger(additionalContext) {
+    const pinoLogger = PinoLoggerFactory.getInstance().getPinoLogger();
+    const contextObj = {
+      "x-user-id": this.context["x-user-id"] || "",
+      "x-tenant-id": this.context["x-tenant-id"] || "",
+      "x-request-id": this.context["x-request-id"] || "",
+      "x-task-id": this.context["x-task-id"] || "",
+      "x-thread-id": this.context["x-thread-id"] || "",
+      service_name: this.serviceName,
+      logger_name: this.name,
+      ...additionalContext
+    };
+    return pinoLogger.child(contextObj);
+  }
+  info(msg, obj) {
+    this.getContextualLogger(obj).info(msg);
+  }
+  error(msg, obj) {
+    this.getContextualLogger(obj).error(msg);
+  }
+  warn(msg, obj) {
+    this.getContextualLogger(obj).warn(msg);
+  }
+  debug(msg, obj) {
+    this.getContextualLogger(obj).debug(msg);
+  }
+  /**
+   * 更新Logger实例的上下文
+   */
+  updateContext(context) {
+    this.context = {
+      ...this.context,
+      ...context
+    };
+  }
+  /**
+   * 创建一个新的Logger实例，继承当前Logger的上下文
+   */
+  child(options) {
+    return new _Logger({
+      name: options.name || this.name,
+      serviceName: options.serviceName || this.serviceName,
+      context: {
+        ...this.context,
+        ...options.context
+      }
+    });
+  }
+};
+
+// src/channels/lark/controller.ts
+var logger = new Logger({ serviceName: "lattice/gateway/lark" });
+function createLarkEventHandler(deps) {
+  return async function handleLarkEvent(request, reply) {
+    const { installationId } = request.params;
+    const installation = await deps.installationStore.getInstallationById(installationId);
+    if (!installation || installation.channel !== "lark") {
+      reply.status(404).send({ success: false, message: "Installation not found" });
+      return;
+    }
+    const body = parseLarkRequestBody(request.body, installation.config.encryptKey);
+    if (body.type === "url_verification" && body.challenge) {
+      reply.status(200).send({ challenge: body.challenge });
+      return;
+    }
+    const inboundMessage = await larkChannelAdapter.receive(request.body, installation);
+    if (!inboundMessage) {
+      reply.status(200).send();
+      return;
+    }
+    deps.router.dispatch(inboundMessage).catch((error) => {
+      logger.error("Lark message dispatch error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+    reply.status(200).send();
+  };
 }
 
 // src/channels/lark/routes.ts
-function registerLarkChannelRoutes(app2, dependencies) {
-  const config = loadLarkIngressConfig();
-  if (!dependencies && !isLarkIngressEnabled(config)) {
-    return;
-  }
-  const handlerDependencies = dependencies || createDefaultLarkDependencies();
+function registerLarkChannelRoutes(app2, deps) {
+  const handler = createLarkEventHandler({
+    installationStore: deps.installationStore,
+    router: deps.router
+  });
   app2.post(
     "/api/channels/lark/installations/:installationId/events",
-    createLarkEventHandler({
-      ...handlerDependencies
-    })
+    handler
   );
 }
-function createDefaultLarkDependencies() {
-  const installationStore = new PostgreSQLChannelInstallationStore({
-    poolConfig: getDatabaseUrl()
-  });
-  const threadStore = getStoreLattice14("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 = await 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)
+  (app2, deps) => registerLarkChannelRoutes(app2, deps)
 ];
-function registerChannelRoutes(app2, dependencies = {}) {
+function registerChannelRoutes(app2, dependencies) {
+  if (!dependencies) return;
   for (const registerRoutes of channelRouteRegistrars) {
     registerRoutes(app2, dependencies);
   }
 }
 
 // src/controllers/channel-installations.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function getTenantId11(request) {
   const userTenantId = request.user?.tenantId;
   if (userTenantId) {
@@ -6166,12 +6017,15 @@ function getTenantId11(request) {
   return request.headers["x-tenant-id"] || "default";
 }
 async function getInstallationStore() {
-  const { PostgreSQLChannelInstallationStore: PostgreSQLChannelInstallationStore2 } = await import("@axiom-lattice/pg-stores");
+  const { getStoreLattice: getStoreLattice16 } = await import("@axiom-lattice/core");
+  const store = getStoreLattice16("default", "channelInstallation").store;
+  if (store) return store;
+  const { PostgreSQLChannelInstallationStore } = await import("@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({
+  return new PostgreSQLChannelInstallationStore({
     poolConfig: databaseUrl
   });
 }
@@ -6270,7 +6124,7 @@ async function createChannelInstallation(request, reply) {
       }
     }
     const store = await getInstallationStore();
-    const installationId = body.id || randomUUID7();
+    const installationId = body.id || randomUUID6();
     const installation = await store.createInstallation(
       tenantId,
       installationId,
@@ -6393,8 +6247,129 @@ function registerChannelInstallationRoutes(app2) {
   app2.delete("/api/channel-installations/:installationId", deleteChannelInstallation);
 }
 
+// src/bindings/index.ts
+var registryInstance = null;
+function setBindingRegistry(registry) {
+  registryInstance = registry;
+}
+function getBindingRegistry() {
+  if (!registryInstance) {
+    throw new Error("BindingRegistry not initialized. Call setBindingRegistry() first.");
+  }
+  return registryInstance;
+}
+
+// src/controllers/channel-bindings.ts
+function getTenantId12(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 { channel, agentId, channelInstallationId, limit, offset } = request.query;
+  try {
+    const registry = 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) {
+    console.error("Failed to get bindings:", error);
+    return { success: false, message: "Failed to retrieve bindings", data: { records: [], total: 0 } };
+  }
+}
+async function getBinding(request, reply) {
+  const tenantId = getTenantId12(request);
+  try {
+    const registry = getBindingRegistry();
+    const bindings = await registry.list({ tenantId });
+    const binding = bindings.find((b) => b.id === request.params.id);
+    if (!binding || binding.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Binding not found" };
+    }
+    return { success: true, message: "Binding retrieved", data: binding };
+  } catch (error) {
+    console.error("Failed to get binding:", error);
+    return { success: false, message: "Failed to retrieve binding" };
+  }
+}
+async function createBinding(request, reply) {
+  const tenantId = getTenantId12(request);
+  try {
+    const registry = getBindingRegistry();
+    const binding = await registry.create({ ...request.body, tenantId });
+    reply.status(201);
+    return { success: true, message: "Binding created", data: binding };
+  } catch (error) {
+    console.error("Failed to create binding:", error);
+    reply.status(500);
+    return { success: false, message: "Failed to create binding" };
+  }
+}
+async function updateBinding(request, reply) {
+  try {
+    const tenantId = getTenantId12(request);
+    const registry = getBindingRegistry();
+    const bindings = await registry.list({ tenantId });
+    const existing = bindings.find((b) => b.id === request.params.id);
+    if (!existing || existing.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Binding not found" };
+    }
+    const binding = await registry.update(request.params.id, request.body);
+    return { success: true, message: "Binding updated", data: binding };
+  } catch (error) {
+    console.error("Failed to update binding:", error);
+    reply.status(500);
+    return { success: false, message: "Failed to update binding" };
+  }
+}
+async function deleteBinding(request, reply) {
+  try {
+    const tenantId = getTenantId12(request);
+    const registry = getBindingRegistry();
+    const bindings = await registry.list({ tenantId });
+    const existing = bindings.find((b) => b.id === request.params.id);
+    if (!existing || existing.tenantId !== tenantId) {
+      reply.status(404);
+      return { success: false, message: "Binding not found" };
+    }
+    await registry.delete(request.params.id);
+    return { success: true, message: "Binding deleted" };
+  } catch (error) {
+    console.error("Failed to delete binding:", error);
+    reply.status(500);
+    return { success: false, message: "Failed to delete binding" };
+  }
+}
+async function resolveBinding(request, _reply) {
+  const tenantId = getTenantId12(request);
+  const { channel, senderId, channelInstallationId } = request.query;
+  try {
+    const registry = getBindingRegistry();
+    const binding = await registry.resolve({ channel, senderId, channelInstallationId, tenantId });
+    if (!binding) {
+      return { success: false, message: "No binding found", data: null };
+    }
+    return { success: true, message: "Binding found", data: binding };
+  } catch (error) {
+    console.error("Failed to resolve binding:", error);
+    return { success: false, message: "Failed to resolve binding", data: null };
+  }
+}
+
+// src/routes/channel-bindings.ts
+function registerChannelBindingRoutes(app2) {
+  app2.get("/api/channel-bindings", getBindingList);
+  app2.get("/api/channel-bindings/resolve", resolveBinding);
+  app2.post("/api/channel-bindings", createBinding);
+  app2.get("/api/channel-bindings/:id", getBinding);
+  app2.put("/api/channel-bindings/:id", updateBinding);
+  app2.delete("/api/channel-bindings/:id", deleteBinding);
+}
+
 // src/routes/index.ts
-var registerLatticeRoutes = (app2) => {
+var registerLatticeRoutes = (app2, channelDeps) => {
   app2.post("/api/runs", createRun);
   app2.post("/api/resume_stream", resumeStream);
   app2.post("/api/assistants/:assistantId/threads/:threadId/abort", abortRun);
@@ -6529,8 +6504,46 @@ var registerLatticeRoutes = (app2) => {
     autoApproveUsers: process.env.AUTO_APPROVE_USERS !== "false",
     allowTenantRegistration: process.env.ALLOW_TENANT_REGISTRATION !== "false"
   });
-  registerChannelRoutes(app2);
+  registerChannelRoutes(app2, channelDeps);
   registerChannelInstallationRoutes(app2);
+  if (channelDeps) {
+    registerChannelBindingRoutes(app2);
+  }
+  if (channelDeps?.router) {
+    app2.post("/api/channels/inbound", async (request, reply) => {
+      try {
+        const router = channelDeps.router;
+        const msg = request.body;
+        if (!msg.channel || !msg.sender || !msg.content) {
+          reply.status(400).send({
+            success: false,
+            message: "Missing required fields: channel, sender, content"
+          });
+          return;
+        }
+        const inboundMessage = {
+          channel: msg.channel,
+          channelInstallationId: msg.channelInstallationId || "",
+          tenantId: msg.tenantId || "default",
+          sender: {
+            id: msg.sender.id,
+            displayName: msg.sender.displayName
+          },
+          content: {
+            text: msg.content.text
+          },
+          replyTarget: msg.replyTarget
+        };
+        await router.dispatch(inboundMessage).catch((error) => {
+          console.error("Inbound dispatch error:", error);
+        });
+        reply.status(200).send({ accepted: true });
+      } catch (error) {
+        console.error("Inbound route error:", error);
+        reply.status(500).send({ success: false, message: "Internal error" });
+      }
+    });
+  }
   app2.get(
     "/api/workflows/definitions",
     getAllWorkflowDefinitions
@@ -6561,6 +6574,270 @@ var registerLatticeRoutes = (app2) => {
   );
 };
 
+// src/router/MessageRouter.ts
+import {
+  getStoreLattice as getStoreLattice14,
+  agentInstanceManager as agentInstanceManager6
+} from "@axiom-lattice/core";
+import { randomUUID as randomUUID7 } from "crypto";
+var BindingNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BindingNotFoundError";
+  }
+};
+var MessageRouter = class {
+  constructor(config) {
+    this.middlewares = [...config.middlewares];
+    this.bindingRegistry = config.bindingRegistry;
+    this.adapterRegistry = config.adapterRegistry;
+    this.installationStore = config.installationStore;
+  }
+  use(middleware) {
+    this.middlewares.push(middleware);
+  }
+  async dispatch(message) {
+    const ctx = {
+      inboundMessage: message,
+      metadata: {}
+    };
+    try {
+      await this.runMiddlewares(ctx, async () => {
+        let binding = await this.bindingRegistry.resolve({
+          channel: message.channel,
+          senderId: message.sender.id,
+          channelInstallationId: message.channelInstallationId,
+          tenantId: message.tenantId
+        });
+        if (!binding) {
+          const installation = await this.installationStore.getInstallationById(
+            message.channelInstallationId
+          );
+          if (installation?.rejectWhenNoBinding) {
+            throw new BindingNotFoundError(
+              `No binding for sender "${message.sender.id}" on channel "${message.channel}"`
+            );
+          }
+          if (installation?.fallbackAgentId) {
+            binding = {
+              id: "fallback",
+              channel: message.channel,
+              channelInstallationId: message.channelInstallationId,
+              tenantId: message.tenantId,
+              senderId: message.sender.id,
+              agentId: installation.fallbackAgentId,
+              threadId: void 0,
+              threadMode: "fixed",
+              enabled: true,
+              createdAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date()
+            };
+          } else {
+            throw new BindingNotFoundError(
+              `No binding for sender "${message.sender.id}" and no fallback configured`
+            );
+          }
+        }
+        ctx.binding = binding;
+        if (!binding.enabled) {
+          throw new BindingNotFoundError(
+            `Binding for sender "${message.sender.id}" is disabled`
+          );
+        }
+        let threadId = ctx.binding.threadId;
+        if (!threadId) {
+          const threadStore = getStoreLattice14("default", "thread").store;
+          const newThreadId = randomUUID7();
+          const newThread = await threadStore.createThread(
+            message.tenantId,
+            ctx.binding.agentId,
+            newThreadId,
+            {
+              metadata: {
+                channel: message.channel,
+                channelInstallationId: message.channelInstallationId,
+                senderId: message.sender.id,
+                bindingId: ctx.binding.id
+              }
+            }
+          );
+          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;
+          }
+        }
+        const agent = agentInstanceManager6.getAgent({
+          tenant_id: message.tenantId,
+          assistant_id: ctx.binding.agentId,
+          thread_id: threadId,
+          workspace_id: ctx.binding.workspaceId || "",
+          project_id: ctx.binding.projectId || ""
+        });
+        const invokeResult = await agent.invoke({
+          input: { message: message.content.text }
+        });
+        ctx.result = extractTextFromInvokeResult(invokeResult);
+        if (message.replyTarget) {
+          const adapter = this.adapterRegistry.get(message.replyTarget.adapterChannel);
+          if (adapter) {
+            const installation = await this.installationStore.getInstallationById(
+              message.channelInstallationId
+            );
+            if (installation) {
+              await adapter.sendReply(
+                message.replyTarget,
+                { text: ctx.result },
+                installation
+              );
+            }
+          }
+        }
+      });
+      return {
+        success: true,
+        bindingId: ctx.binding?.id,
+        threadId: ctx.binding?.threadId,
+        result: ctx.result
+      };
+    } catch (error) {
+      ctx.error = error instanceof Error ? error : new Error(String(error));
+      return {
+        success: false,
+        bindingId: ctx.binding?.id,
+        threadId: ctx.binding?.threadId,
+        error: ctx.error
+      };
+    }
+  }
+  async runMiddlewares(ctx, finalHandler) {
+    const dispatch = (index) => {
+      if (index >= this.middlewares.length) {
+        return finalHandler();
+      }
+      const middleware = this.middlewares[index];
+      return middleware(ctx, () => dispatch(index + 1));
+    };
+    return dispatch(0);
+  }
+};
+function extractTextFromInvokeResult(result) {
+  if (result && typeof result === "object" && "messages" in result) {
+    const messages = result.messages;
+    if (Array.isArray(messages)) {
+      const aiMessages = messages.filter((m) => m.role === "ai");
+      if (aiMessages.length > 0) {
+        return aiMessages.map((m) => m.content).join("\n");
+      }
+    }
+  }
+  return JSON.stringify(result);
+}
+
+// src/channels/registry.ts
+var ChannelAdapterRegistry = class {
+  constructor() {
+    this.adapters = /* @__PURE__ */ new Map();
+  }
+  register(adapter) {
+    if (this.adapters.has(adapter.channel)) {
+      throw new Error(`Channel adapter "${adapter.channel}" already registered`);
+    }
+    this.adapters.set(adapter.channel, adapter);
+  }
+  get(channel) {
+    return this.adapters.get(channel);
+  }
+  list() {
+    return Array.from(this.adapters.keys());
+  }
+};
+
+// src/router/middlewares/deduplication.ts
+var processedMessages = /* @__PURE__ */ new Map();
+function createDeduplicationMiddleware(ttlMs = 5 * 60 * 1e3) {
+  return async (ctx, next) => {
+    const msg = ctx.inboundMessage;
+    const msgId = msg.content.metadata?.messageId;
+    const key = msgId ? `${msg.channel}:${msg.channelInstallationId}:${msgId}` : `${msg.channel}:${msg.channelInstallationId}:${msg.sender.id}`;
+    const now = Date.now();
+    const lastProcessed = processedMessages.get(key);
+    if (lastProcessed && now - lastProcessed < ttlMs) return;
+    processedMessages.set(key, now);
+    if (processedMessages.size > 1e4) {
+      const oldest = Array.from(processedMessages.entries()).sort((a, b) => a[1] - b[1])[0];
+      if (oldest) processedMessages.delete(oldest[0]);
+    }
+    await next();
+  };
+}
+
+// src/router/middlewares/rateLimit.ts
+var RateLimitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RateLimitError";
+  }
+};
+var rateCounters = /* @__PURE__ */ new Map();
+function createRateLimitMiddleware(maxRequests = 10, windowMs = 60 * 1e3, maxEntries = 1e4) {
+  return async (ctx, next) => {
+    const senderKey = `${ctx.inboundMessage.channel}:${ctx.inboundMessage.sender.id}`;
+    const now = Date.now();
+    let counter = rateCounters.get(senderKey);
+    if (!counter || now > counter.resetAt) {
+      counter = { count: 0, resetAt: now + windowMs };
+    }
+    counter.count++;
+    rateCounters.set(senderKey, counter);
+    if (rateCounters.size > maxEntries) {
+      const oldest = Array.from(rateCounters.entries()).sort((a, b) => a[1].resetAt - b[1].resetAt)[0];
+      if (oldest) rateCounters.delete(oldest[0]);
+    }
+    if (counter.count > maxRequests) {
+      throw new RateLimitError(`Rate limit exceeded`);
+    }
+    await next();
+  };
+}
+
+// src/router/middlewares/auditLogger.ts
+var logger2 = new Logger({ serviceName: "lattice/gateway/audit" });
+function createAuditLoggerMiddleware() {
+  return async (ctx, next) => {
+    const start2 = Date.now();
+    try {
+      await next();
+      logger2.info("message routed", {
+        event: "message:routed",
+        channel: ctx.inboundMessage.channel,
+        senderId: ctx.inboundMessage.sender.id,
+        agentId: ctx.binding?.agentId,
+        threadId: ctx.binding?.threadId,
+        duration: Date.now() - start2,
+        status: "success"
+      });
+    } catch (error) {
+      logger2.error(
+        error instanceof Error ? error.message : String(error),
+        {
+          event: "message:error",
+          channel: ctx.inboundMessage.channel,
+          senderId: ctx.inboundMessage.sender.id,
+          duration: Date.now() - start2,
+          status: "error"
+        }
+      );
+      throw error;
+    }
+  };
+}
+
+// src/index.ts
+import { setBindingRegistry as setCoreBindingRegistry } from "@axiom-lattice/core";
+
 // src/swagger.ts
 import swagger from "@fastify/swagger";
 import swaggerUi from "@fastify/swagger-ui";
@@ -6906,7 +7183,7 @@ var DEFAULT_LOGGER_CONFIG = {
   loggerName: "lattice/gateway"
 };
 var loggerLattice = initializeLogger(DEFAULT_LOGGER_CONFIG);
-var logger = loggerLattice.client;
+var logger3 = loggerLattice.client;
 function initializeLogger(config) {
   if (loggerLatticeManager.hasLattice("default")) {
     loggerLatticeManager.removeLattice("default");
@@ -6999,7 +7276,7 @@ app.setErrorHandler((error, request, reply) => {
     "x-request-id": getHeaderValue(request.headers["x-request-id"]),
     "x-user-id": getHeaderValue(request.headers["x-user-id"])
   };
-  logger.error(
+  logger3.error(
     `\u8BF7\u6C42\u9519\u8BEF: ${request.method} ${request.url} error:${error.message}`,
     {
       ...context,
@@ -7039,29 +7316,51 @@ var start = async (config) => {
         file: config.loggerConfig.file || DEFAULT_LOGGER_CONFIG.file
       };
       loggerLattice = initializeLogger(loggerConfig);
-      logger = loggerLattice.client;
+      logger3 = loggerLattice.client;
     }
     app.decorate("loggerLattice", loggerLattice);
-    registerLatticeRoutes(app);
+    let channelDeps;
+    try {
+      const { getStoreLattice: getStoreLattice16 } = await import("@axiom-lattice/core");
+      const bindingStore = getStoreLattice16("default", "channelBinding").store;
+      const installationStore = getStoreLattice16("default", "channelInstallation").store;
+      setBindingRegistry(bindingStore);
+      setCoreBindingRegistry(bindingStore);
+      const adapterRegistry = new ChannelAdapterRegistry();
+      adapterRegistry.register(larkChannelAdapter);
+      const router = new MessageRouter({
+        middlewares: [
+          createDeduplicationMiddleware(),
+          createRateLimitMiddleware(),
+          createAuditLoggerMiddleware()
+        ],
+        bindingRegistry: bindingStore,
+        adapterRegistry,
+        installationStore
+      });
+      channelDeps = { router, installationStore };
+    } catch {
+    }
+    registerLatticeRoutes(app, channelDeps);
     try {
       const storeLattice = getStoreLattice15("default", "database");
       const store = storeLattice.store;
       sqlDatabaseManager2.setConfigStore(store);
-      logger.info("Database config store set for SqlDatabaseManager");
+      logger3.info("Database config store set for SqlDatabaseManager");
     } catch (error) {
-      logger.warn("Failed to set database config store: " + (error instanceof Error ? error.message : String(error)));
+      logger3.warn("Failed to set database config store: " + (error instanceof Error ? error.message : String(error)));
     }
     if (!sandboxLatticeManager2.hasLattice("default")) {
       sandboxLatticeManager2.registerLattice("default", getConfiguredSandboxProvider());
-      logger.info("Registered sandbox manager from env configuration");
+      logger3.info("Registered sandbox manager from env configuration");
     }
     const target_port = config?.port || Number(process.env.PORT) || 4001;
     await app.listen({ port: target_port, host: "0.0.0.0" });
-    logger.info(`Lattice Gateway is running on port: ${target_port}`);
+    logger3.info(`Lattice Gateway is running on port: ${target_port}`);
     try {
-      logger.info("AgentLifecycleManager initialized");
+      logger3.info("AgentLifecycleManager initialized");
     } catch (error) {
-      logger.warn("Failed to initialize AgentLifecycleManager", { error });
+      logger3.warn("Failed to initialize AgentLifecycleManager", { error });
     }
     const queueServiceConfig = config?.queueServiceConfig;
     if (queueServiceConfig) {
@@ -7072,14 +7371,14 @@ var start = async (config) => {
       }
     }
     try {
-      logger.info("Starting agent instance recovery...");
+      logger3.info("Starting agent instance recovery...");
       const restoreStats = await agentInstanceManager8.restore();
-      logger.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
+      logger3.info(`Agent recovery complete: ${restoreStats.restored} threads restored, ${restoreStats.errors} errors`);
     } catch (error) {
-      logger.error("Agent recovery failed", { error });
+      logger3.error("Agent recovery failed", { error });
     }
   } catch (err) {
-    logger.error("Server start failed", { error: err });
+    logger3.error("Server start failed", { error: err });
     process.exit(1);
   }
 };