@axiom-lattice/gateway 2.1.81 → 2.1.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.81",
+  "version": "2.1.82",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -287,8 +287,8 @@ const start = async (config?: LatticeGatewayConfig) => {
 
       const router = new MessageRouter({
         middlewares: [
-          createDeduplicationMiddleware(),
-          createRateLimitMiddleware(),
+          createDeduplicationMiddleware(undefined, logger),
+          createRateLimitMiddleware(undefined, undefined, undefined, logger),
           createAuditLoggerMiddleware(),
         ],
         bindingRegistry: bindingStore,

package/src/router/MessageRouter.ts

@@ -59,6 +59,13 @@ export class MessageRouter {
           || (await this.installationStore.getInstallationById(message.channelInstallationId))?.tenantId;
 
         if (!tenantId) {
+          this.logger?.error({
+            event: "dispatch:error",
+            error: "tenantId missing",
+            channel: message.channel,
+            channelInstallationId: message.channelInstallationId,
+            senderId: message.sender.id,
+          }, "tenantId is required");
           throw new Error(
             "tenantId is required: provide it in the message or ensure the channelInstallation has a tenantId"
           );
@@ -79,12 +86,25 @@ export class MessageRouter {
           );
 
           if (installation?.rejectWhenNoBinding) {
+            this.logger?.warn({
+              event: "dispatch:no_binding",
+              channel: message.channel,
+              senderId: message.sender.id,
+              tenantId,
+              channelInstallationId: message.channelInstallationId,
+            }, "No binding found and rejectWhenNoBinding is enabled");
             throw new BindingNotFoundError(
               `No binding for sender "${message.sender.id}" on channel "${message.channel}"`,
             );
           }
 
           if (installation?.fallbackAgentId) {
+            this.logger?.warn({
+              event: "dispatch:fallback",
+              channel: message.channel,
+              senderId: message.sender.id,
+              fallbackAgentId: installation.fallbackAgentId,
+            }, "No binding found, falling back to fallbackAgentId");
             binding = {
               id: "fallback",
               channel: message.channel,
@@ -99,6 +119,12 @@ export class MessageRouter {
               updatedAt: new Date(),
             };
           } else {
+            this.logger?.error({
+              event: "dispatch:no_fallback",
+              channel: message.channel,
+              senderId: message.sender.id,
+              tenantId,
+            }, "No binding found and no fallbackAgentId configured");
             throw new BindingNotFoundError(
               `No binding for sender "${message.sender.id}" and no fallback configured`,
             );
@@ -126,6 +152,12 @@ export class MessageRouter {
         }
 
         if (!binding.enabled) {
+          this.logger?.warn({
+            event: "dispatch:binding_disabled",
+            bindingId: binding.id,
+            agentId: binding.agentId,
+            senderId: message.sender.id,
+          }, "Binding is disabled, rejecting message");
           throw new BindingNotFoundError(
             `Binding for sender "${message.sender.id}" is disabled`,
           );

package/src/router/middlewares/deduplication.ts

@@ -2,18 +2,31 @@ import type { MessageMiddleware } from "../MessageContext";
 
 const processedMessages = new Map<string, number>();
 
-export function createDeduplicationMiddleware(ttlMs: number = 5 * 60 * 1000): MessageMiddleware {
+export function createDeduplicationMiddleware(
+  ttlMs: number = 5 * 60 * 1000,
+  logger?: any,
+): 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;
+      : null;
 
-    processedMessages.set(key, now);
+    if (key) {
+      const now = Date.now();
+      const lastProcessed = processedMessages.get(key);
+      if (lastProcessed && (now - lastProcessed) < ttlMs) {
+        logger?.warn({
+          event: "dedup:blocked",
+          channel: msg.channel,
+          senderId: msg.sender.id,
+          messageId: msgId,
+        }, "Duplicate message blocked by deduplication");
+        return;
+      }
+      processedMessages.set(key, now);
+    }
 
     if (processedMessages.size > 10000) {
       const oldest = Array.from(processedMessages.entries())

package/src/router/middlewares/rateLimit.ts

@@ -14,6 +14,7 @@ export function createRateLimitMiddleware(
   maxRequests: number = 10,
   windowMs: number = 60 * 1000,
   maxEntries: number = 10000,
+  logger?: any,
 ): MessageMiddleware {
   return async (ctx, next) => {
     const senderKey = `${ctx.inboundMessage.channel}:${ctx.inboundMessage.sender.id}`;
@@ -32,6 +33,13 @@ export function createRateLimitMiddleware(
     }
 
     if (counter.count > maxRequests) {
+      logger?.warn({
+        event: "ratelimit:blocked",
+        channel: ctx.inboundMessage.channel,
+        senderId: ctx.inboundMessage.sender.id,
+        count: counter.count,
+        maxRequests,
+      }, "Rate limit exceeded");
       throw new RateLimitError(`Rate limit exceeded`);
     }
     await next();

package/src/routes/index.ts

@@ -390,7 +390,12 @@ export const registerLatticeRoutes = (app: FastifyInstance, channelDeps?: { rout
         } as Parameters<typeof router.dispatch>[0];
 
         await router.dispatch(inboundMessage).catch((error) => {
-          console.error("Inbound dispatch error:", error);
+          console.error(JSON.stringify({
+            event: "inbound:dispatch_error",
+            error: error instanceof Error ? error.message : String(error),
+            channel: inboundMessage.channel,
+            senderId: inboundMessage.sender.id,
+          }));
         });
 
         reply.status(200).send({ accepted: true });