@axiom-lattice/gateway 3.0.2 → 3.0.4

package/scripts/seed-lark-installation.ts

@@ -1,54 +0,0 @@
-/**
- * Seed script: creates a Lark channel installation in the local SQLite store.
- *
- * Usage:
- *   pnpm --filter @axiom-lattice/gateway exec tsx scripts/seed-lark-installation.ts
- */
-
-import {
-  initDatabase,
-  getDatabase,
-  LocalChannelInstallationStore,
-  closeDatabase,
-} from "@axiom-lattice/local-stores";
-
-const APP_ID = "cli_a92dc36def309cca";
-const APP_SECRET = "hNTWhEfti4Y7JIq8JA46Af7WNPcAclGa";
-const INSTALLATION_ID = "lark-main";
-const TENANT_ID = "default";
-
-async function main(): Promise<void> {
-  const dbPath = process.env.LOCAL_DB_PATH || "~/.axiom/lattice.db";
-
-  console.log(`[seed] Initializing SQLite at ${dbPath}`);
-  await initDatabase({ dbPath });
-
-  const db = getDatabase();
-  const store = new LocalChannelInstallationStore(db);
-
-  console.log(`[seed] Creating Lark installation: ${INSTALLATION_ID}`);
-  const installation = await store.createInstallation(
-    TENANT_ID,
-    INSTALLATION_ID,
-    {
-      channel: "lark",
-      config: {
-        appId: APP_ID,
-        appSecret: APP_SECRET,
-      },
-      enabled: true,
-      rejectWhenNoBinding: false,
-    },
-  );
-
-  console.log(`[seed] Installation created:`);
-  console.log(JSON.stringify(installation, null, 2));
-
-  await closeDatabase();
-  console.log(`[seed] Done. Installation persisted to ${dbPath}`);
-}
-
-main().catch((err) => {
-  console.error("[seed] Failed:", err);
-  process.exit(1);
-});

package/src/__tests__/__mocks__/e2b.ts

@@ -1 +0,0 @@
-export const Sandbox = jest.fn();

package/src/__tests__/a2a.test.ts

@@ -1,428 +0,0 @@
-import { FastifyInstance } from "fastify";
-import fastify from "fastify";
-import { registerA2ARoutes } from "../routes/a2a";
-
-const mockChunkStream = jest.fn();
-const mockAddMessage = jest.fn();
-const mockAbort = jest.fn();
-
-const mockAgent = {
-  addMessage: mockAddMessage,
-  chunkStream: mockChunkStream,
-  abort: mockAbort,
-};
-
-const mockGetAgent = jest.fn(() => mockAgent);
-
-jest.mock("@axiom-lattice/core", () => ({
-  agentInstanceManager: {
-    getAgent: (...args: unknown[]) => mockGetAgent(...args),
-  },
-}));
-
-describe("A2A Routes", () => {
-  let app: FastifyInstance;
-
-  beforeEach(() => {
-    mockGetAgent.mockClear();
-    mockAddMessage.mockClear();
-    mockChunkStream.mockClear();
-    mockAbort.mockClear();
-    mockGetAgent.mockReturnValue(mockAgent);
-
-    process.env.A2A_API_KEYS = "valid-key:tenant-a";
-    process.env.A2A_DEFAULT_AGENT_ID = "agent-1";
-    process.env.A2A_DEFAULT_TENANT_ID = "default-tenant";
-    delete process.env.A2A_DEFAULT_PROJECT_ID;
-    delete process.env.A2A_DEFAULT_WORKSPACE_ID;
-
-    app = fastify();
-    registerA2ARoutes(app);
-  });
-
-  afterEach(async () => {
-    await app.close();
-    delete process.env.A2A_API_KEYS;
-    delete process.env.A2A_DEFAULT_AGENT_ID;
-    delete process.env.A2A_DEFAULT_TENANT_ID;
-  });
-
-  // ─── Agent Card ──────────────────────────────────────────────────────
-
-  describe("GET /api/a2a/.well-known/agent.json", () => {
-    it("should return agent card without auth", async () => {
-      const response = await app.inject({
-        method: "GET",
-        url: "/api/a2a/.well-known/agent.json",
-      });
-
-      expect(response.statusCode).toBe(200);
-      const body = JSON.parse(response.body);
-      expect(body).toHaveProperty("name", "Axiom Lattice Agent");
-      expect(body).toHaveProperty("capabilities");
-      expect(body.capabilities).toHaveProperty("streaming", true);
-      expect(body).toHaveProperty("defaultInputModes");
-      expect(body).toHaveProperty("defaultOutputModes");
-      expect(body).toHaveProperty("url");
-    });
-  });
-
-  describe("GET /api/a2a/.well-known/agent-card.json", () => {
-    it("should support alternate path", async () => {
-      const response = await app.inject({
-        method: "GET",
-        url: "/api/a2a/.well-known/agent-card.json",
-      });
-
-      expect(response.statusCode).toBe(200);
-      const body = JSON.parse(response.body);
-      expect(body).toHaveProperty("name", "Axiom Lattice Agent");
-    });
-  });
-
-  // ─── Agent Card with env override ────────────────────────────────────
-
-  describe("Agent Card with custom env", () => {
-    it("should reflect custom agent name from env", async () => {
-      process.env.A2A_AGENT_NAME = "Custom Bot";
-      process.env.A2A_ORGANIZATION = "Custom Org";
-      process.env.A2A_VERSION = "2.0.0";
-
-      const response = await app.inject({
-        method: "GET",
-        url: "/api/a2a/.well-known/agent.json",
-      });
-
-      expect(response.statusCode).toBe(200);
-      const body = JSON.parse(response.body);
-      expect(body.name).toBe("Custom Bot");
-      expect(body.provider.organization).toBe("Custom Org");
-      expect(body.version).toBe("2.0.0");
-
-      delete process.env.A2A_AGENT_NAME;
-      delete process.env.A2A_ORGANIZATION;
-      delete process.env.A2A_VERSION;
-    });
-  });
-
-  // ─── Task Send ───────────────────────────────────────────────────────
-
-  describe("POST /api/a2a/tasks/send", () => {
-    it("should return 400 when message.parts is missing", async () => {
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-        payload: { message: {} },
-      });
-
-      expect(response.statusCode).toBe(400);
-      const body = JSON.parse(response.body);
-      expect(body.error).toBe("message.parts is required");
-    });
-
-    it("should return 400 when message text is empty", async () => {
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "" }],
-          },
-        },
-      });
-
-      expect(response.statusCode).toBe(400);
-      const body = JSON.parse(response.body);
-      expect(body.error).toBe("message must contain text content");
-    });
-
-    it("should return 500 when no agent is configured", async () => {
-      delete process.env.A2A_DEFAULT_AGENT_ID;
-
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "Hello" }],
-          },
-        },
-      });
-
-      expect(response.statusCode).toBe(500);
-      const body = JSON.parse(response.body);
-      expect(body.error).toBe("No agent configured");
-    });
-
-    it("should return 401 with invalid API key", async () => {
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer wrong-key",
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "Hello" }],
-          },
-        },
-      });
-
-      expect(response.statusCode).toBe(401);
-    });
-
-    it("should stream task result with valid key and message", async () => {
-      mockAddMessage.mockResolvedValueOnce({ messageId: "msg-1" });
-
-      const mockStream = (async function* () {
-        yield {
-          type: "ai",
-          data: { id: "c1", content: "Hello " },
-        };
-        yield {
-          type: "ai",
-          data: { id: "c2", content: "World" },
-        };
-      })();
-      mockChunkStream.mockReturnValueOnce(mockStream);
-
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "Hello World" }],
-          },
-        },
-      });
-
-      expect(response.statusCode).toBe(200);
-      expect(response.headers["content-type"]).toBe("text/event-stream");
-
-      // Verify SSE events were emitted
-      const body = response.body;
-      expect(body).toContain("event: status-update");
-      expect(body).toContain('"state":"working"');
-      expect(body).toContain("Hello ");
-      expect(body).toContain("World");
-      expect(body).toContain('"state":"completed"');
-      expect(body).toContain('"final":true');
-
-      // Verify agent was called with correct scope from API key
-      expect(mockGetAgent).toHaveBeenCalledWith(
-        expect.objectContaining({
-          assistant_id: "agent-1",
-          tenant_id: "tenant-a",
-        }),
-      );
-
-      // Verify agent was called with workspace/project from API key
-      // tenant-a has no project/workspace, so they should be undefined
-      const getAgentCall = mockGetAgent.mock.calls[0][0];
-      expect(getAgentCall.project_id).toBeUndefined();
-      expect(getAgentCall.workspace_id).toBeUndefined();
-    });
-
-    it("should propagate project scope from API key", async () => {
-      process.env.A2A_API_KEYS = "scoped-key:tenant-a:proj-x:ws-y";
-
-      mockAddMessage.mockResolvedValueOnce({ messageId: "msg-1" });
-      const mockStream = (async function* () {
-        yield { type: "ai", data: { id: "c1", content: "ok" } };
-      })();
-      mockChunkStream.mockReturnValueOnce(mockStream);
-
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer scoped-key",
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "Hello" }],
-          },
-        },
-      });
-
-      expect(response.statusCode).toBe(200);
-
-      const getAgentCall = mockGetAgent.mock.calls[0][0];
-      expect(getAgentCall.tenant_id).toBe("tenant-a");
-      expect(getAgentCall.project_id).toBe("proj-x");
-      expect(getAgentCall.workspace_id).toBe("ws-y");
-    });
-
-    it("should create fresh internal threads for each new task with same contextId", async () => {
-      const contextId = "ctx-multi-turn";
-
-      mockAddMessage.mockResolvedValue({ messageId: "msg-1" });
-      const shortStream = (async function* () {
-        yield { type: "ai", data: { id: "c1", content: "response" } };
-      })();
-      mockChunkStream.mockReturnValue(shortStream);
-
-      // First request
-      await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "First message" }],
-            contextId,
-          },
-        },
-      });
-
-      const threadId1 = mockGetAgent.mock.calls[0][0].thread_id;
-
-      mockChunkStream.mockReturnValue(shortStream);
-
-      // Second request — same contextId, should get a different thread
-      await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "Follow up" }],
-            contextId,
-          },
-        },
-      });
-
-      const threadId2 = mockGetAgent.mock.calls[1][0].thread_id;
-
-      expect(threadId1).toBeDefined();
-      expect(threadId2).toBeDefined();
-      expect(threadId1).not.toBe(threadId2);
-    });
-
-    it("should accept referenceTaskIds in the message without error", async () => {
-      mockAddMessage.mockResolvedValueOnce({ messageId: "msg-1" });
-      const mockStream = (async function* () {
-        yield { type: "ai", data: { id: "c1", content: "ok" } };
-      })();
-      mockChunkStream.mockReturnValueOnce(mockStream);
-
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "Follow up" }],
-            referenceTaskIds: ["task-prev-1"],
-          },
-        },
-      });
-
-      expect(response.statusCode).toBe(200);
-      expect(response.headers["content-type"]).toBe("text/event-stream");
-      expect(response.body).toContain('"state":"completed"');
-    });
-  });
-
-  // ─── Task Cancel ─────────────────────────────────────────────────────
-
-  describe("POST /api/a2a/tasks/:taskId/cancel", () => {
-    it("should return 404 for unknown task", async () => {
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/nonexistent/cancel",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-        payload: {},
-      });
-
-      expect(response.statusCode).toBe(404);
-    });
-  });
-
-  // ─── Task Get ────────────────────────────────────────────────────────
-
-  describe("GET /api/a2a/tasks/:taskId", () => {
-    it("should return 404 for unknown task", async () => {
-      const response = await app.inject({
-        method: "GET",
-        url: "/api/a2a/tasks/nonexistent",
-        headers: {
-          authorization: "Bearer valid-key",
-          "content-type": "application/json",
-        },
-      });
-
-      expect(response.statusCode).toBe(404);
-    });
-  });
-
-  // ─── No auth mode ────────────────────────────────────────────────────
-
-  describe("when no API keys configured", () => {
-    beforeEach(() => {
-      delete process.env.A2A_API_KEYS;
-    });
-
-    it("should accept requests without auth", async () => {
-      mockAddMessage.mockResolvedValueOnce({ messageId: "msg-1" });
-      const mockStream = (async function* () {
-        yield { type: "ai", data: { id: "c1", content: "Hi" } };
-      })();
-      mockChunkStream.mockReturnValueOnce(mockStream);
-
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/a2a/tasks/send",
-        headers: {
-          "content-type": "application/json",
-        },
-        payload: {
-          message: {
-            role: "user",
-            parts: [{ type: "text", text: "Hello" }],
-          },
-        },
-      });
-
-      expect(response.statusCode).toBe(200);
-    });
-  });
-});

package/src/__tests__/channel-installations.test.ts

@@ -1,199 +0,0 @@
-import { FastifyInstance } from "fastify";
-import fastify from "fastify";
-import { registerChannelInstallationRoutes } from "../routes/channel-installations";
-
-// Set DATABASE_URL before importing controller
-process.env.DATABASE_URL = "postgres://test:test@localhost:5432/test";
-
-// Mock the store
-const mockGetInstallationsByTenant = jest.fn();
-const mockGetInstallationById = jest.fn();
-const mockCreateInstallation = jest.fn();
-const mockUpdateInstallation = jest.fn();
-const mockDeleteInstallation = jest.fn();
-
-jest.mock("@axiom-lattice/pg-stores", () => ({
-  PostgreSQLChannelInstallationStore: jest.fn().mockImplementation(() => ({
-    getInstallationsByTenant: mockGetInstallationsByTenant,
-    getInstallationById: mockGetInstallationById,
-    createInstallation: mockCreateInstallation,
-    updateInstallation: mockUpdateInstallation,
-    deleteInstallation: mockDeleteInstallation,
-  })),
-}));
-
-describe("Channel Installation API", () => {
-  let app: FastifyInstance;
-
-  beforeEach(() => {
-    // Reset mocks
-    mockGetInstallationsByTenant.mockReset();
-    mockGetInstallationById.mockReset();
-    mockCreateInstallation.mockReset();
-    mockUpdateInstallation.mockReset();
-    mockDeleteInstallation.mockReset();
-
-    app = fastify();
-    registerChannelInstallationRoutes(app);
-  });
-
-  afterEach(async () => {
-    await app.close();
-  });
-
-  describe("GET /api/channel-installations", () => {
-    it("should return list of installations for tenant", async () => {
-      mockGetInstallationsByTenant.mockResolvedValueOnce([
-        {
-          id: "install-1",
-          tenantId: "tenant-a",
-          channel: "lark",
-          name: "Test Installation",
-          config: {
-            appId: "cli_test",
-            appSecret: "secret",
-            assistantId: "assistant-1",
-            mappingMode: "hybrid",
-          },
-          createdAt: new Date(),
-          updatedAt: new Date(),
-        },
-      ]);
-
-      const response = await app.inject({
-        method: "GET",
-        url: "/api/channel-installations",
-        headers: {
-          "x-tenant-id": "tenant-a",
-        },
-      });
-
-      expect(response.statusCode).toBe(200);
-      const body = JSON.parse(response.body);
-      expect(body.success).toBe(true);
-      expect(body.data).toHaveProperty("records");
-      expect(body.data).toHaveProperty("total");
-      expect(body.data.records).toHaveLength(1);
-    });
-
-    it("should filter by channel type", async () => {
-      const response = await app.inject({
-        method: "GET",
-        url: "/api/channel-installations?channel=lark",
-        headers: {
-          "x-tenant-id": "tenant-a",
-        },
-      });
-
-      expect(response.statusCode).toBe(200);
-    });
-  });
-
-  describe("GET /api/channel-installations/:installationId", () => {
-    it("should return installation by id", async () => {
-      const response = await app.inject({
-        method: "GET",
-        url: "/api/channel-installations/install-1",
-        headers: {
-          "x-tenant-id": "tenant-a",
-        },
-      });
-
-      // Will return 404 since mock returns null, but route is accessible
-      expect([200, 404]).toContain(response.statusCode);
-    });
-  });
-
-  describe("POST /api/channel-installations", () => {
-    it("should create new installation", async () => {
-      mockCreateInstallation.mockResolvedValueOnce({
-        id: "new-install-id",
-        tenantId: "tenant-a",
-        channel: "lark",
-        name: "Test Lark Installation",
-        config: {
-          appId: "cli_test",
-          appSecret: "secret",
-          assistantId: "assistant-1",
-          mappingMode: "hybrid",
-        },
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
-
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/channel-installations",
-        headers: {
-          "x-tenant-id": "tenant-a",
-          "content-type": "application/json",
-        },
-        payload: {
-          channel: "lark",
-          name: "Test Lark Installation",
-          config: {
-            appId: "cli_test",
-            appSecret: "secret",
-            assistantId: "assistant-1",
-            mappingMode: "hybrid",
-          },
-        },
-      });
-
-      expect(response.statusCode).toBe(201);
-      const body = JSON.parse(response.body);
-      expect(body.success).toBe(true);
-      expect(body.data).toHaveProperty("id");
-    });
-
-    it("should validate required fields", async () => {
-      const response = await app.inject({
-        method: "POST",
-        url: "/api/channel-installations",
-        headers: {
-          "x-tenant-id": "tenant-a",
-          "content-type": "application/json",
-        },
-        payload: {
-          // Missing channel and config
-        },
-      });
-
-      expect(response.statusCode).toBe(400);
-    });
-  });
-
-  describe("PUT /api/channel-installations/:installationId", () => {
-    it("should update installation", async () => {
-      const response = await app.inject({
-        method: "PUT",
-        url: "/api/channel-installations/install-1",
-        headers: {
-          "x-tenant-id": "tenant-a",
-          "content-type": "application/json",
-        },
-        payload: {
-          name: "Updated Name",
-        },
-      });
-
-      // Will return 404 since mock returns null, but route is accessible
-      expect([200, 404]).toContain(response.statusCode);
-    });
-  });
-
-  describe("DELETE /api/channel-installations/:installationId", () => {
-    it("should delete installation", async () => {
-      const response = await app.inject({
-        method: "DELETE",
-        url: "/api/channel-installations/install-1",
-        headers: {
-          "x-tenant-id": "tenant-a",
-        },
-      });
-
-      // Will return 404 since mock returns null, but route is accessible
-      expect([200, 404]).toContain(response.statusCode);
-    });
-  });
-});