@axiom-lattice/gateway 2.1.75 → 2.1.76

package/dist/sender-PX32VSHB.mjs

@@ -0,0 +1,32 @@
+// 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
+  });
+}
+export {
+  createLarkSender
+};
+//# sourceMappingURL=sender-PX32VSHB.mjs.map

package/dist/sender-PX32VSHB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/channels/lark/sender.ts"],"sourcesContent":["interface LarkSenderConfig {\n  appId: string;\n  appSecret: string;\n}\n\ninterface LarkSdkMessageClient {\n  im: {\n    v1: {\n      message: {\n        create(input: {\n          params: {\n            receive_id_type: \"chat_id\";\n          };\n          data: {\n            receive_id: string;\n            msg_type: \"text\";\n            content: string;\n          };\n        }): Promise<{ code?: number }>;\n      };\n    };\n  };\n}\n\nexport async function createLarkSender(\n  config: LarkSenderConfig,\n  client?: LarkSdkMessageClient,\n) {\n  const resolved = client ?? (await createDefaultLarkClient(config));\n\n  return {\n    async sendTextReply(input: { chatId: string; text: string }): Promise<void> {\n      const response = await resolved.im.v1.message.create({\n        params: {\n          receive_id_type: \"chat_id\",\n        },\n        data: {\n          receive_id: input.chatId,\n          msg_type: \"text\",\n          content: JSON.stringify({ text: input.text }),\n        },\n      });\n\n      if (response.code && response.code !== 0) {\n        throw new Error(\"Failed to send Lark reply\");\n      }\n    },\n  };\n}\n\nasync function createDefaultLarkClient(config: LarkSenderConfig): Promise<LarkSdkMessageClient> {\n  const Lark = await import(\"@larksuiteoapi/node-sdk\");\n\n  return new Lark.Client({\n    appId: config.appId,\n    appSecret: config.appSecret,\n  }) as LarkSdkMessageClient;\n}\n"],"mappings":";AAwBA,eAAsB,iBACpB,QACA,QACA;AACA,QAAM,WAAW,UAAW,MAAM,wBAAwB,MAAM;AAEhE,SAAO;AAAA,IACL,MAAM,cAAc,OAAwD;AAC1E,YAAM,WAAW,MAAM,SAAS,GAAG,GAAG,QAAQ,OAAO;AAAA,QACnD,QAAQ;AAAA,UACN,iBAAiB;AAAA,QACnB;AAAA,QACA,MAAM;AAAA,UACJ,YAAY,MAAM;AAAA,UAClB,UAAU;AAAA,UACV,SAAS,KAAK,UAAU,EAAE,MAAM,MAAM,KAAK,CAAC;AAAA,QAC9C;AAAA,MACF,CAAC;AAED,UAAI,SAAS,QAAQ,SAAS,SAAS,GAAG;AACxC,cAAM,IAAI,MAAM,2BAA2B;AAAA,MAC7C;AAAA,IACF;AAAA,EACF;AACF;AAEA,eAAe,wBAAwB,QAAyD;AAC9F,QAAM,OAAO,MAAM,OAAO,yBAAyB;AAEnD,SAAO,IAAI,KAAK,OAAO;AAAA,IACrB,OAAO,OAAO;AAAA,IACd,WAAW,OAAO;AAAA,EACpB,CAAC;AACH;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.75",
+  "version": "2.1.76",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -39,11 +39,12 @@
     "pg": "^8.11.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/agent-eval": "2.1.59",
-    "@axiom-lattice/core": "2.1.65",
-    "@axiom-lattice/pg-stores": "1.0.55",
-    "@axiom-lattice/protocols": "2.1.33",
-    "@axiom-lattice/queue-redis": "1.0.32"
+    "zod": "3.25.76",
+    "@axiom-lattice/agent-eval": "2.1.60",
+    "@axiom-lattice/core": "2.1.66",
+    "@axiom-lattice/pg-stores": "1.0.56",
+    "@axiom-lattice/protocols": "2.1.34",
+    "@axiom-lattice/queue-redis": "1.0.33"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/bindings/index.ts

@@ -0,0 +1,14 @@
+import type { BindingRegistry } from "@axiom-lattice/protocols";
+
+let registryInstance: BindingRegistry | null = null;
+
+export function setBindingRegistry(registry: BindingRegistry): void {
+  registryInstance = registry;
+}
+
+export function getBindingRegistry(): BindingRegistry {
+  if (!registryInstance) {
+    throw new Error("BindingRegistry not initialized. Call setBindingRegistry() first.");
+  }
+  return registryInstance;
+}

package/src/channels/__tests__/routes.test.ts

@@ -2,61 +2,40 @@ import fastify from "fastify";
 import { registerChannelRoutes } from "../routes";
 
 describe("registerChannelRoutes", () => {
-  const envBackup = { ...process.env };
-
-  afterEach(() => {
-    process.env = { ...envBackup };
-  });
-
-  it("registers the lark route dynamically", async () => {
+  it("skips registration when no dependencies are provided", async () => {
     const app = fastify();
-    registerChannelRoutes(app, {
-      lark: {
-        getInstallationConfig: jest.fn().mockResolvedValue({
-          installationId: "install-1",
-          tenantId: "tenant-a",
-          assistantId: "assistant-a",
-          appId: "cli_app_1",
-          appSecret: "secret",
-          verificationToken: "token-1",
-          mappingMode: "hybrid",
-        }),
-        parseRequestBody: jest.fn().mockReturnValue({
-          type: "url_verification",
-          challenge: "challenge-token",
-          token: "token-1",
-        }),
-        verifyParsedBody: jest.fn().mockReturnValue(true),
-        parseEvent: jest.fn(),
-        claimInboundReceipt: jest.fn(),
-        markInboundReceiptCompleted: jest.fn(),
-        markInboundReceiptFailed: jest.fn(),
-        resolveThread: jest.fn(),
-        runAgentAndCollectText: jest.fn(),
-        sendTextReply: jest.fn(),
-      },
-    });
+    registerChannelRoutes(app);
 
     const response = await app.inject({
       method: "POST",
       url: "/api/channels/lark/installations/install-1/events",
-      payload: {
-        challenge: "challenge-token",
-        type: "url_verification",
-      },
+      payload: {},
     });
 
-    expect(response.statusCode).toBe(200);
-    expect(response.json()).toEqual({ challenge: "challenge-token" });
+    expect(response.statusCode).toBe(404);
 
     await app.close();
   });
 
-  it("skips lark route registration when lark config is disabled", async () => {
-    process.env.LARK_ENABLED = "false";
-
+  it("registers the lark route when dependencies are provided", async () => {
     const app = fastify();
-    registerChannelRoutes(app);
+    registerChannelRoutes(app, {
+      router: {
+        dispatch: jest.fn().mockResolvedValue({ success: true }),
+      } as any,
+      installationStore: {
+        getInstallationById: jest.fn().mockResolvedValue({
+          id: "install-1",
+          tenantId: "tenant-a",
+          channel: "lark",
+          config: { appId: "cli_app_1", appSecret: "secret" },
+          enabled: true,
+          rejectWhenNoBinding: false,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        }),
+      } as any,
+    });
 
     const response = await app.inject({
       method: "POST",
@@ -64,7 +43,7 @@ describe("registerChannelRoutes", () => {
       payload: {},
     });
 
-    expect(response.statusCode).toBe(404);
+    expect(response.statusCode).toBe(200);
 
     await app.close();
   });

package/src/channels/lark/LarkChannelAdapter.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import type {
+  ChannelAdapter,
+  InboundMessage,
+  OutboundMessage,
+  ReplyTarget,
+  ChannelInstallation,
+} from "@axiom-lattice/protocols";
+import type { LarkChannelInstallationConfig } from "@axiom-lattice/protocols";
+import { parseLarkMessageEvent } from "./parser";
+
+export const larkConfigSchema = z.object({
+  appId: z.string(),
+  appSecret: z.string(),
+  verificationToken: z.string().optional(),
+  encryptKey: z.string().optional(),
+});
+
+export const larkChannelAdapter: ChannelAdapter<LarkChannelInstallationConfig> = {
+  channel: "lark",
+
+  configSchema: larkConfigSchema,
+
+  async receive(
+    rawPayload: unknown,
+    installation: ChannelInstallation<LarkChannelInstallationConfig>,
+  ): Promise<InboundMessage | null> {
+    const event = parseLarkMessageEvent(rawPayload);
+    if (!event) return null;
+
+    return {
+      channel: "lark",
+      channelInstallationId: installation.id,
+      tenantId: installation.tenantId,
+      sender: {
+        id: event.openId,
+        displayName: undefined,
+      },
+      content: {
+        text: event.text,
+        metadata: {
+          chatId: event.chatId,
+          chatType: event.chatType,
+          messageId: event.messageId,
+        },
+      },
+      conversation: {
+        id: event.chatId,
+        type: event.chatType,
+      },
+      replyTarget: {
+        adapterChannel: "lark",
+        channelInstallationId: installation.id,
+        rawTarget: {
+          chatId: event.chatId,
+          messageId: event.messageId,
+          chatType: event.chatType,
+        },
+      },
+    };
+  },
+
+  async sendReply(
+    replyTarget: ReplyTarget,
+    message: OutboundMessage,
+    installation: ChannelInstallation<LarkChannelInstallationConfig>,
+  ): Promise<void> {
+    const { createLarkSender } = await import("./sender");
+    const sender = createLarkSender(installation.config);
+    await sender.sendTextReply({
+      chatId: replyTarget.rawTarget.chatId as string,
+      text: message.text,
+    });
+  },
+};

package/src/channels/lark/__tests__/controller.test.ts

@@ -1,269 +1,135 @@
-import type { ThreadStore } from "@axiom-lattice/protocols";
 import fastify from "fastify";
 import { createLarkEventHandler } from "../controller";
 
-const installationConfig = {
-  installationId: "install-1",
+const installation = {
+  id: "install-1",
   tenantId: "tenant-a",
-  assistantId: "assistant-a",
-  appId: "cli_app_1",
-  appSecret: "secret",
-  verificationToken: "token-1",
-  encryptKey: "encrypt-key",
-  mappingMode: "hybrid" as const,
+  channel: "lark" as const,
+  config: { appId: "cli_app_1", appSecret: "secret" },
+  enabled: true,
+  rejectWhenNoBinding: false,
+  createdAt: new Date(),
+  updatedAt: new Date(),
 };
 
 describe("createLarkEventHandler", () => {
-  it("returns the challenge response during URL verification", async () => {
+  it("returns 404 when installation is not found", async () => {
     const app = fastify();
+    const handler = createLarkEventHandler({
+      installationStore: {
+        getInstallationById: jest.fn().mockResolvedValue(null),
+      } as any,
+      router: { dispatch: jest.fn() } as any,
+    });
+
     app.post(
       "/api/channels/lark/installations/:installationId/events",
-      createLarkEventHandler({
-        getInstallationConfig: jest.fn().mockResolvedValue(installationConfig),
-        parseRequestBody: jest.fn().mockReturnValue({
-          type: "url_verification",
-          challenge: "challenge-token",
-          token: "token-1",
-        }),
-        verifyParsedBody: jest.fn().mockReturnValue(true),
-        parseEvent: jest.fn(),
-        claimInboundReceipt: jest.fn(),
-        markInboundReceiptCompleted: jest.fn(),
-        markInboundReceiptFailed: jest.fn(),
-        resolveThread: jest.fn(),
-        runAgentAndCollectText: jest.fn(),
-        sendTextReply: jest.fn(),
-      }),
+      handler,
     );
 
     const response = await app.inject({
       method: "POST",
       url: "/api/channels/lark/installations/install-1/events",
-      payload: {
-        challenge: "challenge-token",
-        type: "url_verification",
-      },
+      payload: {},
     });
 
-    expect(response.statusCode).toBe(200);
-    expect(response.json()).toEqual({ challenge: "challenge-token" });
+    expect(response.statusCode).toBe(404);
+    expect(response.json()).toEqual({ success: false, message: "Installation not found" });
 
     await app.close();
   });
 
-  it("handles one direct text message end to end", async () => {
+  it("returns 404 when installation channel is not lark", async () => {
     const app = fastify();
-    const parseEvent = jest.fn().mockReturnValue({
-      messageId: "om_1",
-      openId: "ou_1",
-      chatId: "oc_1",
-      chatType: "direct",
-      text: "hello",
+    const handler = createLarkEventHandler({
+      installationStore: {
+        getInstallationById: jest.fn().mockResolvedValue({ ...installation, channel: "slack" }),
+      } as any,
+      router: { dispatch: jest.fn() } as any,
     });
-    const claimInboundReceipt = jest
-      .fn()
-      .mockResolvedValue({ accepted: true, status: "processing" });
-    const markInboundReceiptCompleted = jest.fn().mockResolvedValue(undefined);
-    const markInboundReceiptFailed = jest.fn().mockResolvedValue(undefined);
-    const resolveThread = jest.fn().mockResolvedValue({ threadId: "thread-1" });
-    const runAgentAndCollectText = jest.fn().mockResolvedValue("hi there");
-    const sendTextReply = jest.fn().mockResolvedValue(undefined);
 
     app.post(
       "/api/channels/lark/installations/:installationId/events",
-      createLarkEventHandler({
-        getInstallationConfig: jest.fn().mockResolvedValue(installationConfig),
-        parseRequestBody: jest.fn().mockImplementation((body) => body),
-        verifyParsedBody: jest.fn().mockReturnValue(true),
-        parseEvent,
-        claimInboundReceipt,
-        markInboundReceiptCompleted,
-        markInboundReceiptFailed,
-        resolveThread,
-        runAgentAndCollectText,
-        sendTextReply,
-      }),
+      handler,
     );
 
     const response = await app.inject({
       method: "POST",
       url: "/api/channels/lark/installations/install-1/events",
-      payload: {
-        header: { event_type: "im.message.receive_v1" },
-        event: {
-          sender: { sender_id: { open_id: "ou_1" } },
-          message: {
-            message_id: "om_1",
-            chat_id: "oc_1",
-            chat_type: "p2p",
-            message_type: "text",
-            content: '{"text":"hello"}',
-          },
-        },
-      },
+      payload: {},
     });
 
-    expect(response.statusCode).toBe(200);
-    expect(claimInboundReceipt).toHaveBeenCalledWith({
-      channel: "lark",
-      channelAppId: "cli_app_1",
-      externalMessageId: "om_1",
-      tenantId: "tenant-a",
-    });
-    expect(resolveThread).toHaveBeenCalled();
-    expect(runAgentAndCollectText).toHaveBeenCalledWith({
-      assistantId: "assistant-a",
-      threadId: "thread-1",
-      text: "hello",
-      tenantId: "tenant-a",
-      workspaceId: undefined,
-      projectId: undefined,
-    });
-    expect(sendTextReply).toHaveBeenCalledWith({
-      chatId: "oc_1",
-      text: "hi there",
-      config: installationConfig,
-    });
-    expect(markInboundReceiptCompleted).toHaveBeenCalledWith({
-      channel: "lark",
-      channelAppId: "cli_app_1",
-      externalMessageId: "om_1",
-      tenantId: "tenant-a",
-      threadId: "thread-1",
-    });
-    expect(markInboundReceiptFailed).not.toHaveBeenCalled();
+    expect(response.statusCode).toBe(404);
 
     await app.close();
   });
 
-  it("short-circuits when an inbound receipt is already processing", async () => {
+  it("returns 200 for non-message events (e.g. url verification)", async () => {
     const app = fastify();
-    const parseEvent = jest.fn().mockReturnValue({
-      messageId: "om_processing",
-      openId: "ou_1",
-      chatId: "oc_1",
-      chatType: "direct",
-      text: "hello",
+    const handler = createLarkEventHandler({
+      installationStore: {
+        getInstallationById: jest.fn().mockResolvedValue(installation),
+      } as any,
+      router: { dispatch: jest.fn() } as any,
     });
-    const claimInboundReceipt = jest
-      .fn()
-      .mockResolvedValue({ accepted: false, status: "processing" });
-    const resolveThread = jest.fn();
-    const runAgentAndCollectText = jest.fn();
-    const sendTextReply = jest.fn();
 
     app.post(
       "/api/channels/lark/installations/:installationId/events",
-      createLarkEventHandler({
-        getInstallationConfig: jest.fn().mockResolvedValue(installationConfig),
-        parseRequestBody: jest.fn().mockImplementation((body) => body),
-        verifyParsedBody: jest.fn().mockReturnValue(true),
-        parseEvent,
-        claimInboundReceipt,
-        markInboundReceiptCompleted: jest.fn(),
-        markInboundReceiptFailed: jest.fn(),
-        resolveThread,
-        runAgentAndCollectText,
-        sendTextReply,
-      }),
+      handler,
     );
 
     const response = await app.inject({
       method: "POST",
       url: "/api/channels/lark/installations/install-1/events",
-      payload: {
-        header: { event_type: "im.message.receive_v1" },
-        event: {
-          sender: { sender_id: { open_id: "ou_1" } },
-          message: {
-            message_id: "om_processing",
-            chat_id: "oc_1",
-            chat_type: "p2p",
-            message_type: "text",
-            content: '{"text":"hello"}',
-          },
-        },
-      },
+      payload: { type: "url_verification", challenge: "challenge-token" },
     });
 
     expect(response.statusCode).toBe(200);
-    expect(response.json()).toEqual({ success: true, processing: true });
-    expect(resolveThread).not.toHaveBeenCalled();
-    expect(runAgentAndCollectText).not.toHaveBeenCalled();
-    expect(sendTextReply).not.toHaveBeenCalled();
 
     await app.close();
   });
 
-  it("rejects requests when verification fails", async () => {
+  it("dispatches valid message events via router", async () => {
     const app = fastify();
+    const dispatch = jest.fn().mockResolvedValue({ success: true });
 
-    app.post(
-      "/api/channels/lark/installations/:installationId/events",
-      createLarkEventHandler({
-        getInstallationConfig: jest.fn().mockResolvedValue(installationConfig),
-        parseRequestBody: jest.fn().mockReturnValue({ header: { token: "bad" } }),
-        verifyParsedBody: jest.fn().mockReturnValue(false),
-        parseEvent: jest.fn(),
-        claimInboundReceipt: jest.fn(),
-        markInboundReceiptCompleted: jest.fn(),
-        markInboundReceiptFailed: jest.fn(),
-        resolveThread: jest.fn(),
-        runAgentAndCollectText: jest.fn(),
-        sendTextReply: jest.fn(),
-      }),
-    );
-
-    const response = await app.inject({
-      method: "POST",
-      url: "/api/channels/lark/installations/install-1/events",
-      payload: {
-        header: { event_type: "im.message.receive_v1" },
-      },
+    const handler = createLarkEventHandler({
+      installationStore: {
+        getInstallationById: jest.fn().mockResolvedValue(installation),
+      } as any,
+      router: { dispatch } as any,
     });
 
-    expect(response.statusCode).toBe(401);
-    expect(response.json()).toEqual({ success: false, message: "Invalid Lark request" });
-
-    await app.close();
-  });
-
-  it("loads installation-scoped config from the route parameter", async () => {
-    const app = fastify();
-    const getInstallationConfig = jest.fn().mockResolvedValue(installationConfig);
-
     app.post(
       "/api/channels/lark/installations/:installationId/events",
-      createLarkEventHandler({
-        getInstallationConfig,
-        parseRequestBody: jest.fn().mockReturnValue({
-          type: "url_verification",
-          challenge: "challenge-token",
-          token: "token-1",
-        }),
-        verifyParsedBody: jest.fn().mockReturnValue(true),
-        parseEvent: jest.fn(),
-        claimInboundReceipt: jest.fn(),
-        markInboundReceiptCompleted: jest.fn(),
-        markInboundReceiptFailed: jest.fn(),
-        resolveThread: jest.fn(),
-        runAgentAndCollectText: jest.fn(),
-        sendTextReply: jest.fn(),
-      }),
+      handler,
     );
 
     const response = await app.inject({
       method: "POST",
       url: "/api/channels/lark/installations/install-1/events",
       payload: {
-        type: "url_verification",
-        challenge: "challenge-token",
-        token: "token-1",
+        header: { event_type: "im.message.receive_v1" },
+        event: {
+          sender: { sender_id: { open_id: "ou_1" } },
+          message: {
+            message_id: "om_1",
+            chat_id: "oc_1",
+            chat_type: "p2p",
+            message_type: "text",
+            content: '{"text":"hello"}',
+          },
+        },
       },
     });
 
     expect(response.statusCode).toBe(200);
-    expect(getInstallationConfig).toHaveBeenCalledWith("install-1");
+    expect(dispatch).toHaveBeenCalledTimes(1);
+    expect(dispatch.mock.calls[0][0]).toMatchObject({
+      channel: "lark",
+      channelInstallationId: "install-1",
+      tenantId: "tenant-a",
+    });
 
     await app.close();
   });