@lobu/gateway 3.0.8 → 3.0.12

package/src/__tests__/agent-routes.test.ts

@@ -1,68 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { MockRedisClient } from "@lobu/core/testing";
-import { AgentMetadataStore } from "../auth/agent-metadata-store";
-import { AgentSettingsStore } from "../auth/settings/agent-settings-store";
-import { UserAgentsStore } from "../auth/user-agents-store";
-import { createAgentRoutes } from "../routes/public/agents";
-import { setAuthProvider } from "../routes/public/settings-auth";
-
-describe("agent routes", () => {
-  let redis: MockRedisClient;
-  let agentMetadataStore: AgentMetadataStore;
-  let agentSettingsStore: AgentSettingsStore;
-  let userAgentsStore: UserAgentsStore;
-
-  beforeEach(async () => {
-    redis = new MockRedisClient();
-    agentMetadataStore = new AgentMetadataStore(redis as any);
-    agentSettingsStore = new AgentSettingsStore(redis as any);
-    userAgentsStore = new UserAgentsStore(redis as any);
-
-    await agentMetadataStore.createAgent(
-      "agent-1",
-      "Agent 1",
-      "telegram",
-      "u1"
-    );
-    await userAgentsStore.addAgent("telegram", "u1", "agent-1");
-  });
-
-  afterEach(() => {
-    setAuthProvider(null);
-  });
-
-  test("lists agents for external browser sessions by owner userId", async () => {
-    setAuthProvider(() => ({
-      userId: "u1",
-      oauthUserId: "u1",
-      platform: "external",
-      exp: Date.now() + 60_000,
-    }));
-
-    const app = createAgentRoutes({
-      userAgentsStore,
-      agentMetadataStore,
-      agentSettingsStore,
-      channelBindingService: {
-        async getBinding() {
-          return null;
-        },
-        async createBinding() {
-          return true;
-        },
-        async listBindings() {
-          return [];
-        },
-        async deleteAllBindings() {
-          return 0;
-        },
-      } as any,
-    });
-
-    const response = await app.request("/");
-    expect(response.status).toBe(200);
-    const data = (await response.json()) as any;
-    expect(data.agents).toHaveLength(1);
-    expect(data.agents[0]?.agentId).toBe("agent-1");
-  });
-});

package/src/__tests__/agent-schedules-routes.test.ts

@@ -1,59 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { OpenAPIHono } from "@hono/zod-openapi";
-import { MockRedisClient } from "@lobu/core/testing";
-import { AgentMetadataStore } from "../auth/agent-metadata-store";
-import { UserAgentsStore } from "../auth/user-agents-store";
-import { createAgentSchedulesRoutes } from "../routes/public/agent-schedules";
-import { setAuthProvider } from "../routes/public/settings-auth";
-
-describe("agent schedules routes", () => {
-  let redis: MockRedisClient;
-  let agentMetadataStore: AgentMetadataStore;
-  let userAgentsStore: UserAgentsStore;
-
-  beforeEach(async () => {
-    redis = new MockRedisClient();
-    agentMetadataStore = new AgentMetadataStore(redis as any);
-    userAgentsStore = new UserAgentsStore(redis as any);
-
-    await agentMetadataStore.createAgent(
-      "agent-1",
-      "Agent 1",
-      "external",
-      "u1"
-    );
-    await userAgentsStore.addAgent("external", "u1", "agent-1");
-  });
-
-  afterEach(() => {
-    setAuthProvider(null);
-  });
-
-  test("rejects neutral sessions that do not own the agent", async () => {
-    setAuthProvider(() => ({
-      userId: "u2",
-      platform: "external",
-      exp: Date.now() + 60_000,
-    }));
-
-    const app = new OpenAPIHono();
-    app.route(
-      "/api/v1/agents/:agentId/schedules",
-      createAgentSchedulesRoutes({
-        scheduledWakeupService: {
-          async listPendingForAgent() {
-            return [];
-          },
-        } as any,
-        userAgentsStore,
-        agentMetadataStore: {
-          getMetadata: (agentId: string) =>
-            agentMetadataStore.getMetadata(agentId),
-        },
-      })
-    );
-
-    const response = await app.request("/api/v1/agents/agent-1/schedules");
-    expect(response.status).toBe(401);
-  });
-});

package/src/__tests__/agent-settings-store.test.ts

@@ -1,323 +0,0 @@
-import {
-  afterAll,
-  beforeAll,
-  beforeEach,
-  describe,
-  expect,
-  test,
-} from "bun:test";
-import { MockRedisClient } from "@lobu/core/testing";
-import { AgentSettingsStore } from "../auth/settings/agent-settings-store";
-
-const TEST_ENCRYPTION_KEY =
-  "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
-
-let originalEncryptionKey: string | undefined;
-
-beforeAll(() => {
-  originalEncryptionKey = process.env.ENCRYPTION_KEY;
-  process.env.ENCRYPTION_KEY = TEST_ENCRYPTION_KEY;
-});
-
-afterAll(() => {
-  if (originalEncryptionKey !== undefined) {
-    process.env.ENCRYPTION_KEY = originalEncryptionKey;
-  } else {
-    delete process.env.ENCRYPTION_KEY;
-  }
-});
-
-function createStore(redis?: MockRedisClient) {
-  const r = redis ?? new MockRedisClient();
-  const store = new AgentSettingsStore(r as any);
-  return { store, redis: r };
-}
-
-describe("AgentSettingsStore", () => {
-  let redis: MockRedisClient;
-  let store: AgentSettingsStore;
-
-  beforeEach(() => {
-    const created = createStore();
-    redis = created.redis;
-    store = created.store;
-  });
-
-  describe("CRUD basics", () => {
-    test("saveSettings stores and getSettings retrieves", async () => {
-      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
-      const result = await store.getSettings("agent-1");
-      expect(result).not.toBeNull();
-      expect(result!.model).toBe("claude-sonnet-4");
-      expect(result!.updatedAt).toBeGreaterThan(0);
-    });
-
-    test("getSettings returns null for non-existent agent", async () => {
-      const result = await store.getSettings("missing");
-      expect(result).toBeNull();
-    });
-
-    test("updateSettings merges with existing", async () => {
-      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
-      await store.updateSettings("agent-1", { soulMd: "Be helpful" });
-      const result = await store.getSettings("agent-1");
-      expect(result!.model).toBe("claude-sonnet-4");
-      expect(result!.soulMd).toBe("Be helpful");
-    });
-
-    test("deleteSettings removes settings", async () => {
-      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
-      await store.deleteSettings("agent-1");
-      const result = await store.getSettings("agent-1");
-      expect(result).toBeNull();
-    });
-
-    test("hasSettings returns boolean", async () => {
-      expect(await store.hasSettings("agent-1")).toBe(false);
-      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
-      expect(await store.hasSettings("agent-1")).toBe(true);
-    });
-  });
-
-  describe("partial update merging", () => {
-    test("merges new fields with existing", async () => {
-      await store.saveSettings("agent-1", {
-        model: "claude-sonnet-4",
-        soulMd: "Original",
-      });
-      await store.updateSettings("agent-1", { userMd: "New field" });
-      const result = await store.getSettings("agent-1");
-      expect(result!.model).toBe("claude-sonnet-4");
-      expect(result!.soulMd).toBe("Original");
-      expect(result!.userMd).toBe("New field");
-    });
-
-    test("overwrites overlapping fields", async () => {
-      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
-      await store.updateSettings("agent-1", { model: "claude-opus-4" });
-      const result = await store.getSettings("agent-1");
-      expect(result!.model).toBe("claude-opus-4");
-    });
-
-    test("creates if no existing settings", async () => {
-      await store.updateSettings("agent-1", { model: "claude-opus-4" });
-      const result = await store.getSettings("agent-1");
-      expect(result).not.toBeNull();
-      expect(result!.model).toBe("claude-opus-4");
-    });
-  });
-
-  describe("encryption of authProfiles.credential", () => {
-    test("credential is encrypted in Redis and decrypted on read", async () => {
-      const apiKey = "sk-ant-secret-key-12345";
-      await store.saveSettings("agent-1", {
-        authProfiles: [
-          {
-            id: "profile-1",
-            provider: "anthropic",
-            model: "claude-sonnet-4",
-            credential: apiKey,
-            label: "test",
-            authType: "api-key",
-            createdAt: Date.now(),
-          },
-        ],
-      });
-
-      // Check raw value in Redis has enc:v1: prefix
-      const rawData = await redis.get("agent:settings:agent-1");
-      expect(rawData).not.toBeNull();
-      const parsed = JSON.parse(rawData!);
-      expect(parsed.authProfiles[0].credential).toStartWith("enc:v1:");
-      expect(parsed.authProfiles[0].credential).not.toBe(apiKey);
-
-      // Check decrypted on read
-      const result = await store.getSettings("agent-1");
-      expect(result!.authProfiles![0].credential).toBe(apiKey);
-    });
-  });
-
-  describe("encryption of refreshToken", () => {
-    test("refreshToken is encrypted in Redis and decrypted on read", async () => {
-      const refreshToken = "rt-secret-refresh-token-xyz";
-      await store.saveSettings("agent-1", {
-        authProfiles: [
-          {
-            id: "profile-1",
-            provider: "anthropic",
-            model: "claude-sonnet-4",
-            credential: "sk-key",
-            label: "test",
-            authType: "oauth",
-            metadata: {
-              refreshToken,
-              email: "user@example.com",
-            },
-            createdAt: Date.now(),
-          },
-        ],
-      });
-
-      // Check raw value in Redis
-      const rawData = await redis.get("agent:settings:agent-1");
-      const parsed = JSON.parse(rawData!);
-      expect(parsed.authProfiles[0].metadata.refreshToken).toStartWith(
-        "enc:v1:"
-      );
-
-      // Check decrypted on read
-      const result = await store.getSettings("agent-1");
-      expect(result!.authProfiles![0].metadata!.refreshToken).toBe(
-        refreshToken
-      );
-    });
-  });
-
-  describe("no double-encryption", () => {
-    test("already encrypted values are not re-encrypted", async () => {
-      // Save once to encrypt
-      await store.saveSettings("agent-1", {
-        authProfiles: [
-          {
-            id: "profile-1",
-            provider: "anthropic",
-            model: "claude-sonnet-4",
-            credential: "sk-key",
-            label: "test",
-            authType: "api-key",
-            createdAt: Date.now(),
-          },
-        ],
-      });
-
-      const rawAfterFirst = await redis.get("agent:settings:agent-1");
-      const parsedFirst = JSON.parse(rawAfterFirst!);
-      const encryptedCredential = parsedFirst.authProfiles[0].credential;
-
-      // Update to re-save (simulating save with already-encrypted value)
-      await store.updateSettings("agent-1", { model: "claude-opus-4" });
-
-      const rawAfterSecond = await redis.get("agent:settings:agent-1");
-      const parsedSecond = JSON.parse(rawAfterSecond!);
-
-      // The credential should still be encrypted, not double-encrypted
-      // Both should decrypt to the same plaintext
-      const result = await store.getSettings("agent-1");
-      expect(result!.authProfiles![0].credential).toBe("sk-key");
-    });
-  });
-
-  describe("graceful plaintext when ENCRYPTION_KEY missing", () => {
-    test("values stored as plaintext without encryption key", async () => {
-      const savedKey = process.env.ENCRYPTION_KEY;
-      delete process.env.ENCRYPTION_KEY;
-
-      try {
-        const { store: noEncStore, redis: noEncRedis } = createStore();
-
-        const apiKey = "sk-plaintext-key";
-        await noEncStore.saveSettings("agent-1", {
-          authProfiles: [
-            {
-              id: "profile-1",
-              provider: "anthropic",
-              model: "claude-sonnet-4",
-              credential: apiKey,
-              label: "test",
-              authType: "api-key",
-              createdAt: Date.now(),
-            },
-          ],
-        });
-
-        // Raw value should be plaintext (no enc:v1: prefix)
-        const rawData = await noEncRedis.get("agent:settings:agent-1");
-        const parsed = JSON.parse(rawData!);
-        expect(parsed.authProfiles[0].credential).toBe(apiKey);
-        expect(parsed.authProfiles[0].credential).not.toStartWith("enc:v1:");
-
-        // Read should also return plaintext
-        const result = await noEncStore.getSettings("agent-1");
-        expect(result!.authProfiles![0].credential).toBe(apiKey);
-      } finally {
-        process.env.ENCRYPTION_KEY = savedKey;
-      }
-    });
-  });
-
-  describe("findTemplateAgentId", () => {
-    test("returns first agent with installedProviders", async () => {
-      // Agent without installedProviders
-      await store.saveSettings("agent-no-providers", {
-        model: "claude-sonnet-4",
-      });
-
-      // Agent with installedProviders
-      await store.saveSettings("agent-with-providers", {
-        model: "claude-opus-4",
-        installedProviders: [
-          {
-            id: "anthropic",
-            displayName: "Anthropic",
-            envVarName: "ANTHROPIC_API_KEY",
-            upstreamBaseUrl: "https://api.anthropic.com",
-          },
-        ],
-      });
-
-      const templateId = await store.findTemplateAgentId();
-      expect(templateId).toBe("agent-with-providers");
-    });
-
-    test("returns null when no agents have providers", async () => {
-      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
-      await store.saveSettings("agent-2", { model: "claude-opus-4" });
-
-      const templateId = await store.findTemplateAgentId();
-      expect(templateId).toBeNull();
-    });
-  });
-
-  describe("findSandboxAgentIds", () => {
-    test("returns agent IDs referencing template", async () => {
-      const templateId = "template-agent";
-
-      await store.saveSettings(templateId, {
-        model: "claude-opus-4",
-        installedProviders: [
-          {
-            id: "anthropic",
-            displayName: "Anthropic",
-            envVarName: "ANTHROPIC_API_KEY",
-            upstreamBaseUrl: "https://api.anthropic.com",
-          },
-        ],
-      });
-
-      await store.saveSettings("sandbox-1", {
-        model: "claude-sonnet-4",
-        templateAgentId: templateId,
-      });
-
-      await store.saveSettings("sandbox-2", {
-        model: "claude-sonnet-4",
-        templateAgentId: templateId,
-      });
-
-      // Unrelated agent
-      await store.saveSettings("other-agent", {
-        model: "claude-sonnet-4",
-      });
-
-      const sandboxIds = await store.findSandboxAgentIds(templateId);
-      expect(sandboxIds).toHaveLength(2);
-      expect(sandboxIds.sort()).toEqual(["sandbox-1", "sandbox-2"]);
-    });
-
-    test("returns empty array when no sandboxes exist", async () => {
-      await store.saveSettings("agent-1", { model: "claude-sonnet-4" });
-      const sandboxIds = await store.findSandboxAgentIds("non-existent");
-      expect(sandboxIds).toEqual([]);
-    });
-  });
-});

package/src/__tests__/bedrock-model-catalog.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { BedrockModelCatalog } from "../services/bedrock-model-catalog";
-
-describe("BedrockModelCatalog", () => {
-  test("returns configured models from the loader", async () => {
-    const catalog = new BedrockModelCatalog({
-      cacheTtlMs: 0,
-      loadModels: async () => [
-        {
-          id: "amazon.nova-lite-v1:0",
-          label: "Amazon / Nova Lite",
-          inputModalities: ["TEXT"],
-          outputModalities: ["TEXT"],
-        },
-      ],
-    });
-
-    await expect(catalog.listModelOptions()).resolves.toEqual([
-      {
-        id: "amazon.nova-lite-v1:0",
-        label: "Amazon / Nova Lite",
-      },
-    ]);
-  });
-
-  test("falls back to the static registry when AWS loading fails", async () => {
-    const catalog = new BedrockModelCatalog({
-      cacheTtlMs: 0,
-      loadModels: async () => {
-        throw new Error("boom");
-      },
-    });
-
-    const models = await catalog.listModelOptions();
-    expect(models.length).toBeGreaterThan(0);
-    expect(models.some((model) => model.id === "amazon.nova-lite-v1:0")).toBe(
-      true
-    );
-  });
-});

package/src/__tests__/bedrock-openai-service.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { Model } from "@mariozechner/pi-ai/dist/types.js";
-import { BedrockModelCatalog } from "../services/bedrock-model-catalog";
-import { BedrockOpenAIService } from "../services/bedrock-openai-service";
-
-function createCatalog() {
-  return new BedrockModelCatalog({
-    cacheTtlMs: 0,
-    loadModels: async () => [
-      {
-        id: "amazon.nova-lite-v1:0",
-        label: "Amazon / Nova Lite",
-        providerName: "Amazon",
-        modelName: "Nova Lite",
-        inputModalities: ["TEXT"],
-        outputModalities: ["TEXT"],
-      },
-    ],
-  });
-}
-
-describe("BedrockOpenAIService", () => {
-  test("lists models in OpenAI format", async () => {
-    const service = new BedrockOpenAIService({
-      modelCatalog: createCatalog(),
-    });
-
-    const response = await service
-      .getApp()
-      .request("http://localhost/openai/a/test-agent/v1/models");
-
-    expect(response.status).toBe(200);
-    expect(await response.json()).toEqual({
-      object: "list",
-      data: [
-        {
-          id: "amazon.nova-lite-v1:0",
-          object: "model",
-          created: 0,
-          owned_by: "amazon-bedrock",
-        },
-      ],
-    });
-  });
-
-  test("streams OpenAI chat completion chunks for Bedrock events", async () => {
-    process.env.AWS_REGION = "eu-west-1";
-
-    const service = new BedrockOpenAIService({
-      modelCatalog: createCatalog(),
-      modelResolver: () => undefined,
-      bedrockStreamer: (() =>
-        (async function* () {
-          yield { type: "text_delta", delta: "hello" };
-          yield {
-            type: "toolcall_start",
-            contentIndex: 1,
-            toolCall: { id: "call_1", name: "lookup" },
-          };
-          yield {
-            type: "toolcall_delta",
-            contentIndex: 1,
-            delta: '{"city":"London"}',
-          };
-          yield {
-            type: "done",
-            reason: "toolUse",
-            message: {
-              usage: {
-                input: 10,
-                output: 4,
-                cacheRead: 2,
-                totalTokens: 16,
-              },
-            },
-          };
-        })()) as any,
-    });
-
-    const response = await service
-      .getApp()
-      .request("http://localhost/openai/a/test-agent/v1/chat/completions", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          model: "amazon.nova-lite-v1:0",
-          stream: true,
-          stream_options: { include_usage: true },
-          messages: [{ role: "user", content: "hi" }],
-          tools: [
-            {
-              type: "function",
-              function: {
-                name: "lookup",
-                parameters: { type: "object", properties: {} },
-              },
-            },
-          ],
-        }),
-      });
-
-    expect(response.status).toBe(200);
-    const body = await response.text();
-    expect(body).toContain('"content":"hello"');
-    expect(body).toContain('"tool_calls":[{"index":0,"id":"call_1"');
-    expect(body).toContain('"finish_reason":"tool_calls"');
-    expect(body).toContain('"prompt_tokens":12');
-    expect(body).toContain("[DONE]");
-  });
-
-  test("builds a dynamic Bedrock runtime model when not in registry", async () => {
-    process.env.AWS_REGION = "eu-west-1";
-
-    let resolvedModel: Model<"bedrock-converse-stream"> | null = null;
-
-    const service = new BedrockOpenAIService({
-      modelCatalog: new BedrockModelCatalog({
-        cacheTtlMs: 0,
-        loadModels: async () => [
-          {
-            id: "custom.model-v1:0",
-            label: "Custom / Model",
-            providerName: "Custom",
-            modelName: "Model",
-            inputModalities: ["TEXT"],
-            outputModalities: ["TEXT"],
-          },
-        ],
-      }),
-      modelResolver: () => undefined,
-      bedrockStreamer: ((model: Model<"bedrock-converse-stream">) => {
-        resolvedModel = model;
-        return (async function* () {
-          yield { type: "done", reason: "stop", message: { usage: {} } };
-        })();
-      }) as any,
-    });
-
-    const response = await service
-      .getApp()
-      .request("http://localhost/openai/a/test-agent/v1/chat/completions", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          model: "custom.model-v1:0",
-          stream: true,
-          messages: [{ role: "user", content: "hi" }],
-        }),
-      });
-
-    expect(response.status).toBe(200);
-    await response.text();
-    expect(resolvedModel?.id).toBe("custom.model-v1:0");
-    expect(resolvedModel?.provider).toBe("amazon-bedrock");
-    expect(resolvedModel?.api).toBe("bedrock-converse-stream");
-  });
-});