@axiom-lattice/gateway 2.1.74 → 2.1.76

package/src/channels/lark/controller.ts

@@ -1,189 +1,47 @@
 import type { FastifyReply, FastifyRequest } from "fastify";
-import { parseLarkMessageEvent } from "./parser";
-import type {
-  LarkIngressConfig,
-  LarkUrlVerificationPayload,
-  ParsedLarkMessageEvent,
-} from "./types";
-
-export interface LarkEventHandlerDependencies {
-  getInstallationConfig: (
-    installationId: string,
-  ) => Promise<LarkIngressConfig | null>;
-  parseRequestBody: (
-    body: unknown,
-    encryptKey?: string,
-  ) => LarkUrlVerificationPayload;
-  verifyParsedBody: (
-    body: LarkUrlVerificationPayload,
-    config: LarkIngressConfig,
-  ) => boolean;
-  parseEvent: (payload: unknown) => ParsedLarkMessageEvent | null;
-  claimInboundReceipt: (input: {
-    channel: string;
-    channelAppId: string;
-    externalMessageId: string;
-    tenantId: string;
-  }) => Promise<{ accepted: boolean; status: "processing" | "completed" }>;
-  markInboundReceiptCompleted: (input: {
-    channel: string;
-    channelAppId: string;
-    externalMessageId: string;
-    tenantId: string;
-    threadId: string;
-  }) => Promise<void>;
-  markInboundReceiptFailed: (input: {
-    channel: string;
-    channelAppId: string;
-    externalMessageId: string;
-    tenantId: string;
-  }) => Promise<void>;
-  resolveThread: (input: {
-    channel: string;
-    channelAppId: string;
-    tenantId: string;
-    assistantId: string;
-    mappingMode: "user" | "group" | "hybrid";
-    openId: string;
-    chatId: string;
-    chatType: "direct" | "group";
-    messageId: string;
-    workspaceId?: string;
-    projectId?: string;
-  }) => Promise<{ threadId: string }>;
-  runAgentAndCollectText: (input: {
-    tenantId: string;
-    assistantId: string;
-    threadId: string;
-    text: string;
-    workspaceId?: string;
-    projectId?: string;
-  }) => Promise<string>;
-  sendTextReply: (input: {
-    chatId: string;
-    text: string;
-    config: LarkIngressConfig;
-  }) => Promise<void>;
-}
-
-export function createLarkEventHandler(
-  dependencies: LarkEventHandlerDependencies,
-) {
+import type { ChannelInstallationStore, LarkChannelInstallationConfig } from "@axiom-lattice/protocols";
+import { larkChannelAdapter } from "./LarkChannelAdapter";
+import type { MessageRouter } from "../../router/MessageRouter";
+import { parseLarkRequestBody } from "./verification";
+import { Logger } from "../../logger/Logger";
+
+const logger = new Logger({ serviceName: "lattice/gateway/lark" });
+
+export function createLarkEventHandler(deps: {
+  installationStore: ChannelInstallationStore;
+  router: MessageRouter;
+}) {
   return async function handleLarkEvent(
     request: FastifyRequest,
     reply: FastifyReply,
   ): Promise<void> {
-    const installationId = (request.params as { installationId?: string })
-      ?.installationId;
-
-    if (!installationId) {
-      reply.status(400).send({ success: false, message: "Missing installationId" });
-      return;
-    }
+    const { installationId } = request.params as { installationId: string };
 
-    const config = await dependencies.getInstallationConfig(installationId);
-    if (!config) {
-      reply.status(404).send({ success: false, message: "Lark installation not found" });
+    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 = dependencies.parseRequestBody(
-      request.body,
-      config.encryptKey,
-    ) as LarkUrlVerificationPayload;
-
-    if (!dependencies.verifyParsedBody(body, config)) {
-      reply.status(401).send({ success: false, message: "Invalid Lark request" });
-      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 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 },
-      );
+    const inboundMessage = await larkChannelAdapter.receive(request.body, installation);
+    if (!inboundMessage) {
+      reply.status(200).send();
       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,
+    deps.router.dispatch(inboundMessage).catch((error) => {
+      logger.error("Lark message dispatch error", {
+        error: error instanceof Error ? error.message : String(error),
       });
+    });
 
-      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;
-    }
+    reply.status(200).send();
   };
 }
-
-export const handleLarkEvent = createLarkEventHandler({
-  getInstallationConfig: async () => null,
-  parseRequestBody: (body) => (body || {}) as LarkUrlVerificationPayload,
-  verifyParsedBody: () => true,
-  parseEvent: parseLarkMessageEvent,
-  claimInboundReceipt: async () => ({ accepted: true, status: "processing" }),
-  markInboundReceiptCompleted: async () => undefined,
-  markInboundReceiptFailed: async () => undefined,
-  resolveThread: async () => ({ threadId: "" }),
-  runAgentAndCollectText: async () => "",
-  sendTextReply: async () => undefined,
-});

package/src/channels/lark/routes.ts

@@ -1,121 +1,22 @@
 import type { FastifyInstance } from "fastify";
-import { getStoreLattice } from "@axiom-lattice/core";
-import {
-  ChannelIdentityMappingStore,
-  PostgreSQLChannelInstallationStore,
-} from "@axiom-lattice/pg-stores";
-import {
-  createLarkEventHandler,
-  type LarkEventHandlerDependencies,
-} from "./controller";
-import {
-  isLarkIngressEnabled,
-  loadLarkIngressConfig,
-} from "./config";
-import { createChannelThreadMappingService } from "./mapping-service";
-import { parseLarkMessageEvent } from "./parser";
-import { runAgentAndCollectLarkReply } from "./runner";
-import { createLarkSender } from "./sender";
-import { createLarkRequestVerifier, parseLarkRequestBody } from "./verification";
+import { createLarkEventHandler } from "./controller";
+import type { MessageRouter } from "../../router/MessageRouter";
+import type { ChannelInstallationStore } from "@axiom-lattice/protocols";
 
 export function registerLarkChannelRoutes(
   app: FastifyInstance,
-  dependencies?: LarkEventHandlerDependencies,
+  deps: {
+    installationStore: ChannelInstallationStore;
+    router: MessageRouter;
+  },
 ): void {
-  const config = loadLarkIngressConfig();
-  if (!dependencies && !isLarkIngressEnabled(config)) {
-    return;
-  }
-  const handlerDependencies = dependencies || createDefaultLarkDependencies();
+  const handler = createLarkEventHandler({
+    installationStore: deps.installationStore,
+    router: deps.router,
+  });
 
   app.post(
     "/api/channels/lark/installations/:installationId/events",
-    createLarkEventHandler({
-      ...handlerDependencies,
-    }),
+    handler,
   );
 }
-
-function createDefaultLarkDependencies(): LarkEventHandlerDependencies {
-  const installationStore = new PostgreSQLChannelInstallationStore({
-    poolConfig: getDatabaseUrl(),
-  });
-  const threadStore = getStoreLattice("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,
-      } as unknown as Parameters<ReturnType<typeof createLarkRequestVerifier>>[0]);
-    },
-    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(): string {
-  const databaseUrl = process.env.DATABASE_URL;
-
-  if (!databaseUrl) {
-    throw new Error("DATABASE_URL is required for Lark channel ingress");
-  }
-
-  return databaseUrl;
-}

package/src/channels/registry.ts

@@ -0,0 +1,20 @@
+import type { ChannelAdapter } from "@axiom-lattice/protocols";
+
+export class ChannelAdapterRegistry {
+  private adapters = new Map<string, ChannelAdapter>();
+
+  register(adapter: ChannelAdapter): void {
+    if (this.adapters.has(adapter.channel)) {
+      throw new Error(`Channel adapter "${adapter.channel}" already registered`);
+    }
+    this.adapters.set(adapter.channel, adapter);
+  }
+
+  get(channel: string): ChannelAdapter | undefined {
+    return this.adapters.get(channel);
+  }
+
+  list(): string[] {
+    return Array.from(this.adapters.keys());
+  }
+}

package/src/channels/routes.ts

@@ -1,9 +1,11 @@
 import type { FastifyInstance } from "fastify";
-import type { LarkEventHandlerDependencies } from "./lark/controller";
 import { registerLarkChannelRoutes } from "./lark/routes";
+import type { MessageRouter } from "../router/MessageRouter";
+import type { ChannelInstallationStore } from "@axiom-lattice/protocols";
 
 interface ChannelRouteDependencies {
-  lark?: LarkEventHandlerDependencies;
+  router: MessageRouter;
+  installationStore: ChannelInstallationStore;
 }
 
 type ChannelRouteRegistrar = (
@@ -12,13 +14,14 @@ type ChannelRouteRegistrar = (
 ) => void;
 
 const channelRouteRegistrars: ChannelRouteRegistrar[] = [
-  (app, dependencies) => registerLarkChannelRoutes(app, dependencies.lark),
+  (app, deps) => registerLarkChannelRoutes(app, deps),
 ];
 
 export function registerChannelRoutes(
   app: FastifyInstance,
-  dependencies: ChannelRouteDependencies = {},
+  dependencies?: ChannelRouteDependencies,
 ): void {
+  if (!dependencies) return;
   for (const registerRoutes of channelRouteRegistrars) {
     registerRoutes(app, dependencies);
   }

package/src/controllers/channel-bindings.ts

@@ -0,0 +1,135 @@
+import type { FastifyRequest, FastifyReply } from "fastify";
+import type { CreateBindingInput } from "@axiom-lattice/protocols";
+import { getBindingRegistry } from "../bindings";
+
+function getTenantId(request: FastifyRequest): string {
+  const userTenantId = (request as any).user?.tenantId;
+  if (userTenantId) return userTenantId;
+  return (request.headers["x-tenant-id"] as string) || "default";
+}
+
+export async function getBindingList(
+  request: FastifyRequest<{
+    Querystring: {
+      channel?: string;
+      agentId?: string;
+      channelInstallationId?: string;
+      limit?: number;
+      offset?: number;
+    };
+  }>,
+  _reply: FastifyReply,
+) {
+  const tenantId = getTenantId(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 } };
+  }
+}
+
+export async function getBinding(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  const tenantId = getTenantId(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" };
+  }
+}
+
+export async function createBinding(
+  request: FastifyRequest<{ Body: CreateBindingInput }>,
+  reply: FastifyReply,
+) {
+  const tenantId = getTenantId(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" };
+  }
+}
+
+export async function updateBinding(
+  request: FastifyRequest<{ Params: { id: string }; Body: Partial<CreateBindingInput & { enabled: boolean }> }>,
+  reply: FastifyReply,
+) {
+  try {
+    const tenantId = getTenantId(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" };
+  }
+}
+
+export async function deleteBinding(
+  request: FastifyRequest<{ Params: { id: string } }>,
+  reply: FastifyReply,
+) {
+  try {
+    const tenantId = getTenantId(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" };
+  }
+}
+
+export async function resolveBinding(
+  request: FastifyRequest<{
+    Querystring: { channel: string; senderId: string; channelInstallationId: string };
+  }>,
+  _reply: FastifyReply,
+) {
+  const tenantId = getTenantId(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 };
+  }
+}

package/src/controllers/channel-installations.ts

@@ -54,14 +54,17 @@ interface ChannelInstallationResponse {
  * Get channel installation store
  */
 async function getInstallationStore(): Promise<ChannelInstallationStore> {
-  // Import dynamically to avoid circular dependencies
+  // Use registered store from StoreLatticeManager (supports both PG and in-memory)
+  const { getStoreLattice } = await import("@axiom-lattice/core");
+  const store = getStoreLattice("default", "channelInstallation").store as ChannelInstallationStore | undefined;
+  if (store) return store;
+
+  // Fallback: create PG store directly (legacy path)
   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 PostgreSQLChannelInstallationStore({
     poolConfig: databaseUrl,
   });

package/src/index.ts

@@ -7,6 +7,13 @@ import staticPlugin from "@fastify/static";
 import path from "path";
 import { fileURLToPath } from "url";
 import { registerLatticeRoutes } from "./routes";
+import type { ChannelInstallationStore, BindingRegistry } from "@axiom-lattice/protocols";
+import { MessageRouter } from "./router/MessageRouter";
+import { ChannelAdapterRegistry } from "./channels/registry";
+import { createDeduplicationMiddleware, createRateLimitMiddleware, createAuditLoggerMiddleware } from "./router/middlewares";
+import { setBindingRegistry } from "./bindings";
+import { setBindingRegistry as setCoreBindingRegistry } from "@axiom-lattice/core";
+import { larkChannelAdapter } from "./channels/lark/LarkChannelAdapter";
 import { extractUserFromAuthHeader } from "./controllers/auth";
 import { configureSwagger } from "./swagger";
 import {
@@ -265,8 +272,37 @@ const start = async (config?: LatticeGatewayConfig) => {
     // Access via: request.server.loggerLattice or app.loggerLattice
     app.decorate("loggerLattice", loggerLattice);
 
-    // Register all routes
-    registerLatticeRoutes(app);
+    // Channel infrastructure: use stores from StoreLatticeManager (defaults: InMemory).
+    // Projects can override with PG stores via registerStoreLattice before start().
+    let channelDeps: { router: MessageRouter; installationStore: ChannelInstallationStore } | undefined;
+    try {
+      const { getStoreLattice } = await import("@axiom-lattice/core");
+      const bindingStore = getStoreLattice("default", "channelBinding").store as BindingRegistry;
+      const installationStore = getStoreLattice("default", "channelInstallation").store as ChannelInstallationStore;
+      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 {
+      // Stores not registered — channel routes will be skipped gracefully
+    }
+
+    // Register all routes (channel routes only active if channelDeps is set)
+    registerLatticeRoutes(app, channelDeps);
 
     // Set up database config store for on-demand loading
     try {

package/src/router/MessageContext.ts

@@ -0,0 +1,14 @@
+import type { InboundMessage, Binding } from "@axiom-lattice/protocols";
+
+export interface MessageContext {
+  inboundMessage: InboundMessage;
+  binding?: Binding;
+  result?: string;
+  error?: Error;
+  metadata: Record<string, unknown>;
+}
+
+export type MessageMiddleware = (
+  ctx: MessageContext,
+  next: () => Promise<void>,
+) => Promise<void>;