@axiom-lattice/gateway 2.1.75 → 2.1.76

package/src/router/MessageRouter.ts

@@ -0,0 +1,201 @@
+import {
+  getStoreLattice,
+  agentInstanceManager,
+} from "@axiom-lattice/core";
+import type {
+  InboundMessage,
+  DispatchResult,
+  BindingRegistry,
+  ChannelInstallationStore,
+} from "@axiom-lattice/protocols";
+import { ChannelAdapterRegistry } from "../channels/registry";
+import type { MessageContext, MessageMiddleware } from "./MessageContext";
+import { randomUUID } from "crypto";
+
+export class BindingNotFoundError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "BindingNotFoundError";
+  }
+}
+
+export interface MessageRouterConfig {
+  middlewares: MessageMiddleware[];
+  bindingRegistry: BindingRegistry;
+  adapterRegistry: ChannelAdapterRegistry;
+  installationStore: ChannelInstallationStore;
+}
+
+export class MessageRouter {
+  private middlewares: MessageMiddleware[];
+  private bindingRegistry: BindingRegistry;
+  private adapterRegistry: ChannelAdapterRegistry;
+  private installationStore: ChannelInstallationStore;
+
+  constructor(config: MessageRouterConfig) {
+    this.middlewares = [...config.middlewares];
+    this.bindingRegistry = config.bindingRegistry;
+    this.adapterRegistry = config.adapterRegistry;
+    this.installationStore = config.installationStore;
+  }
+
+  use(middleware: MessageMiddleware): void {
+    this.middlewares.push(middleware);
+  }
+
+  async dispatch(message: InboundMessage): Promise<DispatchResult> {
+    const ctx: MessageContext = {
+      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: undefined,
+              threadMode: "fixed",
+              enabled: true,
+              createdAt: new Date(),
+              updatedAt: 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 = getStoreLattice("default", "thread").store;
+          const newThreadId = randomUUID();
+          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 = agentInstanceManager.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,
+      };
+    }
+  }
+
+  private async runMiddlewares(
+    ctx: MessageContext,
+    finalHandler: () => Promise<void>,
+  ): Promise<void> {
+    const dispatch = (index: number): Promise<void> => {
+      if (index >= this.middlewares.length) {
+        return finalHandler();
+      }
+      const middleware = this.middlewares[index];
+      return middleware(ctx, () => dispatch(index + 1));
+    };
+    return dispatch(0);
+  }
+}
+
+function extractTextFromInvokeResult(result: unknown): string {
+  if (result && typeof result === "object" && "messages" in result) {
+    const messages = (result as { messages: Array<{ role: string; content: string }> }).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);
+}

package/src/router/middlewares/auditLogger.ts

@@ -0,0 +1,34 @@
+import type { MessageMiddleware } from "../MessageContext";
+import { Logger } from "../../logger/Logger";
+
+const logger = new Logger({ serviceName: "lattice/gateway/audit" });
+
+export function createAuditLoggerMiddleware(): MessageMiddleware {
+  return async (ctx, next) => {
+    const start = Date.now();
+    try {
+      await next();
+      logger.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() - start,
+        status: "success",
+      });
+    } catch (error) {
+      logger.error(
+        error instanceof Error ? error.message : String(error),
+        {
+          event: "message:error",
+          channel: ctx.inboundMessage.channel,
+          senderId: ctx.inboundMessage.sender.id,
+          duration: Date.now() - start,
+          status: "error",
+        },
+      );
+      throw error;
+    }
+  };
+}

package/src/router/middlewares/deduplication.ts

@@ -0,0 +1,26 @@
+import type { MessageMiddleware } from "../MessageContext";
+
+const processedMessages = new Map<string, number>();
+
+export function createDeduplicationMiddleware(ttlMs: number = 5 * 60 * 1000): MessageMiddleware {
+  return async (ctx, next) => {
+    const msg = ctx.inboundMessage;
+    const msgId = msg.content.metadata?.messageId as string | undefined;
+    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 > 10000) {
+      const oldest = Array.from(processedMessages.entries())
+        .sort((a, b) => a[1] - b[1])[0];
+      if (oldest) processedMessages.delete(oldest[0]);
+    }
+
+    await next();
+  };
+}

package/src/router/middlewares/index.ts

@@ -0,0 +1,3 @@
+export { createDeduplicationMiddleware } from "./deduplication";
+export { createRateLimitMiddleware } from "./rateLimit";
+export { createAuditLoggerMiddleware } from "./auditLogger";

package/src/router/middlewares/rateLimit.ts

@@ -0,0 +1,39 @@
+import type { MessageMiddleware } from "../MessageContext";
+
+export class RateLimitError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RateLimitError";
+  }
+}
+
+interface Counter { count: number; resetAt: number; }
+const rateCounters = new Map<string, Counter>();
+
+export function createRateLimitMiddleware(
+  maxRequests: number = 10,
+  windowMs: number = 60 * 1000,
+  maxEntries: number = 10000,
+): MessageMiddleware {
+  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();
+  };
+}

package/src/routes/channel-bindings.ts

@@ -0,0 +1,11 @@
+import type { FastifyInstance } from "fastify";
+import * as bindingsController from "../controllers/channel-bindings";
+
+export function registerChannelBindingRoutes(app: FastifyInstance): void {
+  app.get("/api/channel-bindings", bindingsController.getBindingList);
+  app.get("/api/channel-bindings/resolve", bindingsController.resolveBinding);
+  app.post("/api/channel-bindings", bindingsController.createBinding);
+  app.get("/api/channel-bindings/:id", bindingsController.getBinding);
+  app.put("/api/channel-bindings/:id", bindingsController.updateBinding);
+  app.delete("/api/channel-bindings/:id", bindingsController.deleteBinding);
+}

package/src/routes/index.ts

@@ -43,6 +43,9 @@ import { registerTenantRoutes } from "../controllers/tenants";
 import { registerAuthRoutes } from "../controllers/auth";
 import { registerChannelRoutes } from "../channels/routes";
 import { registerChannelInstallationRoutes } from "./channel-installations";
+import { registerChannelBindingRoutes } from "./channel-bindings";
+import type { MessageRouter } from "../router/MessageRouter";
+import type { ChannelInstallationStore } from "@axiom-lattice/protocols";
 // import {
 //   getThreadStatusHandler,
 //   getAgentThreadsHandler,
@@ -52,7 +55,7 @@ import { registerChannelInstallationRoutes } from "./channel-installations";
 //   updateQueueConfigHandler,
 // } from "../controllers/thread_status";
 
-export const registerLatticeRoutes = (app: FastifyInstance): void => {
+export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { router: MessageRouter; installationStore: ChannelInstallationStore }): void => {
   // 运行路由
   app.post<{
     Body: any;
@@ -349,10 +352,55 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
     allowTenantRegistration: process.env.ALLOW_TENANT_REGISTRATION !== "false",
   });
 
-  registerChannelRoutes(app);
+  registerChannelRoutes(app, channelDeps);
 
   registerChannelInstallationRoutes(app);
 
+  if (channelDeps) {
+    registerChannelBindingRoutes(app);
+  }
+
+  // Direct inbound message dispatch
+  if (channelDeps?.router) {
+    app.post("/api/channels/inbound", async (request, reply) => {
+      try {
+        const router = channelDeps.router;
+        const msg = request.body as Record<string, unknown>;
+
+        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 as string,
+          channelInstallationId: (msg.channelInstallationId || "") as string,
+          tenantId: (msg.tenantId || "default") as string,
+          sender: {
+            id: (msg.sender as Record<string, unknown>).id as string,
+            displayName: (msg.sender as Record<string, unknown>).displayName as string | undefined,
+          },
+          content: {
+            text: (msg.content as Record<string, unknown>).text as string,
+          },
+          replyTarget: msg.replyTarget as Record<string, unknown> | undefined,
+        } as Parameters<typeof router.dispatch>[0];
+
+        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" });
+      }
+    });
+  }
+
   // Workflow tracking routes
   app.get(
     "/api/workflows/definitions",