@runfusion/fusion 0.23.0 → 0.24.0

package/dist/plugins/fusion-plugin-whatsapp-chat/manifest.json

@@ -0,0 +1,8 @@
+{
+  "id": "fusion-plugin-whatsapp-chat",
+  "name": "WhatsApp Chat",
+  "version": "0.1.0",
+  "description": "WhatsApp Web (multi-device) bridge — pairs via QR/code, no Meta Cloud webhook required.",
+  "author": "Fusion Team",
+  "fusionVersion": ">=0.1.0"
+}

package/dist/plugins/fusion-plugin-whatsapp-chat/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@fusion-plugin-examples/whatsapp-chat",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "WhatsApp Web (Baileys) chat bridge for Fusion agents",
+  "keywords": [
+    "fusion-plugin",
+    "whatsapp",
+    "chat",
+    "integration"
+  ],
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "private": true,
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --silent=passed-only --reporter=dot"
+  },
+  "dependencies": {
+    "@fusion/plugin-sdk": "workspace:*",
+    "@whiskeysockets/baileys": "^6.7.21",
+    "pino": "^9.9.0",
+    "qrcode": "^1.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "typescript": "^5.7.0",
+    "vitest": "^3.2.4"
+  }
+}

package/dist/plugins/fusion-plugin-whatsapp-chat/src/__tests__/auth-state.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from "vitest";
+import { clearAuthState, createPluginDbAuthState } from "../auth-state.js";
+
+function createInMemoryDb() {
+  const creds = new Map<string, string>();
+  const keys = new Map<string, string>();
+  const makeKey = (category: string, id: string) => `${category}:${id}`;
+
+  return {
+    prepare(sql: string) {
+      return {
+        get: (...args: unknown[]) => {
+          if (sql.includes("FROM whatsapp_auth_creds")) {
+            const value = creds.get("creds");
+            return value ? { value } : undefined;
+          }
+          if (sql.includes("FROM whatsapp_auth_keys")) {
+            const key = makeKey(args[0] as string, args[1] as string);
+            const value = keys.get(key);
+            return value ? { value } : undefined;
+          }
+          return undefined;
+        },
+        run: (...args: unknown[]) => {
+          if (sql.includes("INSERT INTO whatsapp_auth_creds")) {
+            creds.set("creds", args[0] as string);
+          }
+          if (sql.includes("DELETE FROM whatsapp_auth_creds")) {
+            creds.clear();
+          }
+          if (sql.includes("INSERT INTO whatsapp_auth_keys")) {
+            keys.set(makeKey(args[0] as string, args[1] as string), args[2] as string);
+          }
+          if (sql.includes("DELETE FROM whatsapp_auth_keys WHERE category")) {
+            keys.delete(makeKey(args[0] as string, args[1] as string));
+          }
+          if (sql.includes("DELETE FROM whatsapp_auth_keys")) {
+            keys.clear();
+          }
+        },
+      };
+    },
+    exec() {},
+    _creds: creds,
+    _keys: keys,
+  };
+}
+
+describe("auth-state", () => {
+  it("round-trips creds", async () => {
+    const db = createInMemoryDb();
+    const auth = createPluginDbAuthState(db as any);
+    auth.state.creds.me = { id: "123@s.whatsapp.net", name: "Fusion" } as any;
+    await auth.saveCreds();
+
+    const next = createPluginDbAuthState(db as any);
+    expect(next.state.creds.me?.id).toBe("123@s.whatsapp.net");
+  });
+
+  it("sets, gets, and deletes key categories", async () => {
+    const db = createInMemoryDb();
+    const auth = createPluginDbAuthState(db as any);
+
+    await auth.state.keys.set({
+      session: { alpha: { foo: "bar" } as any },
+      "sender-key": { beta: { baz: "qux" } as any },
+    });
+
+    const loaded = await auth.state.keys.get("session", ["alpha", "missing"]);
+    expect((loaded as any).alpha.foo).toBe("bar");
+    expect((loaded as any).missing).toBeUndefined();
+
+    await auth.state.keys.set({ session: { alpha: null } });
+    const removed = await auth.state.keys.get("session", ["alpha"]);
+    expect((removed as any).alpha).toBeUndefined();
+  });
+
+  it("clears auth state", async () => {
+    const db = createInMemoryDb();
+    const auth = createPluginDbAuthState(db as any);
+    auth.state.creds.me = { id: "123@s.whatsapp.net", name: "Fusion" } as any;
+    await auth.saveCreds();
+    await auth.state.keys.set({ session: { alpha: { ok: true } as any } });
+
+    clearAuthState(db as any);
+
+    expect(db._creds.size).toBe(0);
+    expect(db._keys.size).toBe(0);
+  });
+
+  it("handles corrupt json gracefully", async () => {
+    const db = createInMemoryDb();
+    db._keys.set("session:bad", "not-json");
+
+    const auth = createPluginDbAuthState(db as any);
+    const loaded = await auth.state.keys.get("session", ["bad"]);
+    expect((loaded as any).bad).toBeUndefined();
+  });
+});

package/dist/plugins/fusion-plugin-whatsapp-chat/src/__tests__/connection.test.ts

@@ -0,0 +1,145 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockState = vi.hoisted(() => {
+  const handlers = new Map<string, (payload: any) => void>();
+  const sendMessage = vi.fn();
+  const end = vi.fn();
+  const logout = vi.fn();
+  const requestPairingCode = vi.fn().mockResolvedValue("123-456");
+  const makeWASocket = vi.fn(() => ({
+    ev: {
+      on: (name: string, handler: (payload: any) => void) => handlers.set(name, handler),
+      off: (name: string) => handlers.delete(name),
+    },
+    user: { id: "15550001111@s.whatsapp.net" },
+    sendMessage,
+    end,
+    logout,
+    requestPairingCode,
+  }));
+  return { handlers, sendMessage, end, logout, requestPairingCode, makeWASocket };
+});
+
+vi.mock("@whiskeysockets/baileys", () => ({
+  default: mockState.makeWASocket,
+  makeWASocket: mockState.makeWASocket,
+  DisconnectReason: { loggedOut: 401 },
+  BufferJSON: { reviver: undefined, replacer: undefined },
+  initAuthCreds: () => ({}),
+}));
+
+vi.mock("qrcode", () => ({
+  default: { toDataURL: vi.fn().mockResolvedValue("data:image/png;base64,abc") },
+}));
+
+import { WhatsAppConnection } from "../connection.js";
+
+function createInMemoryDb() {
+  const sessions = new Map<string, string>();
+  const dedupe = new Set<string>();
+  const creds = new Map<string, string>();
+  const keys = new Map<string, string>();
+  return {
+    exec() {},
+    prepare(sql: string) {
+      return {
+        get: (...args: unknown[]) => {
+          if (sql.includes("FROM whatsapp_chat_sessions")) {
+            const history = sessions.get(args[0] as string);
+            return history ? { history } : undefined;
+          }
+          if (sql.includes("FROM whatsapp_chat_dedupe")) return dedupe.has(args[0] as string) ? { found: 1 } : undefined;
+          if (sql.includes("FROM whatsapp_auth_creds")) return creds.get("creds") ? { value: creds.get("creds") } : undefined;
+          if (sql.includes("FROM whatsapp_auth_keys")) return keys.get(`${args[0]}:${args[1]}`) ? { value: keys.get(`${args[0]}:${args[1]}`) } : undefined;
+          return undefined;
+        },
+        run: (...args: unknown[]) => {
+          if (sql.includes("whatsapp_chat_sessions")) sessions.set(args[0] as string, args[1] as string);
+          if (sql.includes("whatsapp_chat_dedupe")) dedupe.add(args[0] as string);
+          if (sql.includes("INSERT INTO whatsapp_auth_creds")) creds.set("creds", args[0] as string);
+          if (sql.includes("DELETE FROM whatsapp_auth_creds")) creds.clear();
+          if (sql.includes("INSERT INTO whatsapp_auth_keys")) keys.set(`${args[0]}:${args[1]}`, args[2] as string);
+          if (sql.includes("DELETE FROM whatsapp_auth_keys WHERE category")) keys.delete(`${args[0]}:${args[1]}`);
+          if (sql.includes("DELETE FROM whatsapp_auth_keys")) keys.clear();
+        },
+      };
+    },
+  };
+}
+
+function makeCtx(settings: Record<string, unknown> = {}) {
+  return {
+    pluginId: "fusion-plugin-whatsapp-chat",
+    settings: { allowedSenders: ["15550001111"], ...settings },
+    taskStore: { getRootDir: () => "/tmp", getPluginStore: () => ({}) },
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+    emitEvent: vi.fn(),
+  } as any;
+}
+
+describe("WhatsAppConnection", () => {
+  beforeEach(() => {
+    mockState.handlers.clear();
+    mockState.makeWASocket.mockClear();
+    mockState.sendMessage.mockClear();
+    mockState.end.mockClear();
+  });
+
+  it("starts and stops idempotently", async () => {
+    const connection = new WhatsAppConnection(makeCtx(), "0.1.0", vi.fn().mockResolvedValue("reply"), createInMemoryDb() as any);
+    await connection.start();
+    await connection.stop();
+    await connection.stop();
+    expect(mockState.makeWASocket).toHaveBeenCalledTimes(1);
+    expect(mockState.end).toHaveBeenCalledTimes(1);
+  });
+
+  it("exposes qr updates", async () => {
+    const connection = new WhatsAppConnection(makeCtx(), "0.1.0", vi.fn().mockResolvedValue("reply"), createInMemoryDb() as any);
+    await connection.start();
+    await mockState.handlers.get("connection.update")?.({ qr: "abc" });
+    expect(connection.getStatus()).toMatchObject({ state: "awaiting-qr", qr: "abc" });
+  });
+
+  it("reconnects on close unless logged out", async () => {
+    vi.useFakeTimers();
+    const connection = new WhatsAppConnection(makeCtx(), "0.1.0", vi.fn().mockResolvedValue("reply"), createInMemoryDb() as any);
+    await connection.start();
+    await mockState.handlers.get("connection.update")?.({ connection: "close", lastDisconnect: { error: new Error("boom") } });
+    vi.advanceTimersByTime(1000);
+    expect(mockState.makeWASocket).toHaveBeenCalledTimes(2);
+
+    await mockState.handlers.get("connection.update")?.({ connection: "close", lastDisconnect: { error: { output: { statusCode: 401 } } } });
+    vi.advanceTimersByTime(1000);
+    expect(mockState.makeWASocket).toHaveBeenCalledTimes(2);
+    vi.useRealTimers();
+  });
+
+  it("drops unsupported inbound traffic", async () => {
+    const reply = vi.fn().mockResolvedValue("hello");
+    const connection = new WhatsAppConnection(makeCtx(), "0.1.0", reply, createInMemoryDb() as any);
+    await connection.start();
+    const upsert = mockState.handlers.get("messages.upsert")!;
+    await upsert({ type: "notify", messages: [{ key: { remoteJid: "abc@g.us", id: "1", fromMe: false }, message: { conversation: "hi" } }] });
+    await upsert({ type: "notify", messages: [{ key: { remoteJid: "15550001111@s.whatsapp.net", id: "2", fromMe: true }, message: { conversation: "hi" } }] });
+    await upsert({ type: "notify", messages: [{ key: { remoteJid: "15550001111@s.whatsapp.net", id: "3", fromMe: false }, message: {} }] });
+    expect(reply).not.toHaveBeenCalled();
+  });
+
+  it("dedupes and handles reply failure with fallback", async () => {
+    const reply = vi.fn().mockRejectedValue(new Error("nope"));
+    const connection = new WhatsAppConnection(makeCtx(), "0.1.0", reply, createInMemoryDb() as any);
+    await connection.start();
+    const payload = { type: "notify", messages: [{ key: { remoteJid: "15550001111@s.whatsapp.net", id: "m-1", fromMe: false }, message: { conversation: "hi" } }] };
+    await mockState.handlers.get("messages.upsert")?.(payload);
+    await mockState.handlers.get("messages.upsert")?.(payload);
+    expect(reply).toHaveBeenCalledTimes(1);
+    expect(mockState.sendMessage).toHaveBeenCalledWith("15550001111@s.whatsapp.net", { text: "Sorry, I hit an internal error while processing that message." });
+  });
+
+  it("splits oversized messages", () => {
+    const chunks = WhatsAppConnection.splitMessageForWhatsapp("x".repeat(9000));
+    expect(chunks.length).toBeGreaterThan(2);
+    expect(chunks[0].length).toBeLessThanOrEqual(4096);
+  });
+});

package/dist/plugins/fusion-plugin-whatsapp-chat/src/__tests__/index.test.ts

@@ -0,0 +1,216 @@
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import type { PluginContext } from "@fusion/plugin-sdk";
+
+const connectionInstances: Array<{
+  start: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+  getStatus: ReturnType<typeof vi.fn>;
+  requestPairingCode: ReturnType<typeof vi.fn>;
+  logout: ReturnType<typeof vi.fn>;
+}> = [];
+
+vi.mock("../connection.js", () => {
+  const ctor = vi.fn((ctx: PluginContext) => {
+    const root = ctx.taskStore.getRootDir();
+    const instance = {
+      start: vi.fn(async () => {}),
+      stop: vi.fn(async () => {}),
+      getStatus: vi.fn(() => ({ state: "open", jid: root })),
+      requestPairingCode: vi.fn(async () => "123-456"),
+      logout: vi.fn(async () => {}),
+    };
+    connectionInstances.push(instance);
+    return instance;
+  });
+  (ctor as unknown as { splitMessageForWhatsapp: (text: string) => string[] }).splitMessageForWhatsapp =
+    (text: string) => (text.length > 4096 ? [text.slice(0, 4096), text.slice(4096, 8192), text.slice(8192)] : [text]);
+  return { WhatsAppConnection: ctor };
+});
+
+import plugin, { ensureSchema, getDedupeRetentionDays, markProcessed, splitMessageForWhatsapp, wasProcessed } from "../index.js";
+import { WhatsAppConnection } from "../connection.js";
+
+function createInMemoryDb() {
+  const dedupe = new Map<string, { sender: string; receivedAt: string }>();
+
+  return {
+    exec(_sql: string) {},
+    prepare(sql: string) {
+      return {
+        get: (...args: unknown[]) => {
+          if (sql.includes("FROM whatsapp_chat_dedupe") && sql.includes("messageId = ?")) {
+            const row = dedupe.get(args[0] as string);
+            return row ? { found: 1, ...row } : undefined;
+          }
+          return undefined;
+        },
+        run: (...args: unknown[]) => {
+          if (sql.includes("INSERT INTO whatsapp_chat_dedupe")) {
+            dedupe.set(args[0] as string, {
+              sender: args[1] as string,
+              receivedAt: args[2] as string,
+            });
+          }
+          if (sql.includes("DELETE FROM whatsapp_chat_dedupe WHERE receivedAt < ?")) {
+            const cutoff = args[0] as string;
+            for (const [id, row] of dedupe.entries()) {
+              if (row.receivedAt < cutoff) dedupe.delete(id);
+            }
+          }
+        },
+      };
+    },
+    _dedupe: dedupe,
+  };
+}
+
+describe("whatsapp plugin", () => {
+  beforeEach(() => {
+    connectionInstances.length = 0;
+    vi.clearAllMocks();
+  });
+  it("registers schema init hook", () => {
+    expect(plugin.hooks?.onSchemaInit).toBeDefined();
+  });
+
+  it("registers pairing routes", () => {
+    const paths = (plugin.routes ?? []).map((route) => `${route.method} ${route.path}`);
+    expect(paths).toContain("GET /status");
+    expect(paths).toContain("GET /qr");
+    expect(paths).toContain("POST /pair-code");
+    expect(paths).toContain("POST /logout");
+  });
+
+  it("uses only pairing-era settings", () => {
+    const schema = plugin.manifest.settingsSchema ?? {};
+    expect(Object.keys(schema).sort()).toEqual([
+      "agentSystemPrompt",
+      "allowedSenders",
+      "dedupeRetentionDays",
+      "historyTurnLimit",
+      "pairingMode",
+      "pairingPhoneNumber",
+    ]);
+  });
+
+  it("splits oversized messages", () => {
+    const chunks = splitMessageForWhatsapp("x".repeat(9000));
+    expect(chunks.length).toBeGreaterThan(2);
+    expect(chunks[0].length).toBeLessThanOrEqual(4096);
+  });
+});
+
+describe("multi-project isolation", () => {
+  it("keeps project contexts isolated with shared plugin id", async () => {
+    const db = createInMemoryDb();
+    const makeCtx = (rootDir: string): PluginContext => ({
+      pluginId: "fusion-plugin-whatsapp-chat",
+      settings: {},
+      logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+      },
+      emitEvent: vi.fn(),
+      taskStore: {
+        getRootDir: () => rootDir,
+        getPluginStore: () => ({
+          db,
+        }),
+      } as unknown as PluginContext["taskStore"],
+    });
+
+    const ctxA = makeCtx("/repo-a");
+    const ctxB = makeCtx("/repo-b");
+
+    await plugin.hooks!.onLoad!(ctxA);
+    await plugin.hooks!.onLoad!(ctxB);
+
+    expect(WhatsAppConnection).toHaveBeenCalledTimes(2);
+    expect(connectionInstances[0]?.start).toHaveBeenCalledTimes(1);
+    expect(connectionInstances[1]?.start).toHaveBeenCalledTimes(1);
+
+    const statusRoute = plugin.routes!.find((route) => route.method === "GET" && route.path === "/status")!;
+
+    const statusA = await statusRoute.handler({} as never, ctxA) as { status: number; body: unknown };
+    const statusB = await statusRoute.handler({} as never, ctxB) as { status: number; body: unknown };
+    expect(statusA.status).toBe(200);
+    expect((statusA.body as { jid: string }).jid).toBe("/repo-a");
+    expect(statusB.status).toBe(200);
+    expect((statusB.body as { jid: string }).jid).toBe("/repo-b");
+
+    await plugin.hooks!.onUnload!(ctxA);
+    expect(connectionInstances[0]?.stop).toHaveBeenCalledTimes(1);
+    expect(connectionInstances[1]?.stop).not.toHaveBeenCalled();
+
+    const afterUnloadA = await statusRoute.handler({} as never, ctxA) as { status: number; body: unknown };
+    const afterUnloadB = await statusRoute.handler({} as never, ctxB) as { status: number; body: unknown };
+    expect(afterUnloadA.status).toBe(503);
+    expect(afterUnloadB.status).toBe(200);
+    expect((afterUnloadB.body as { jid: string }).jid).toBe("/repo-b");
+
+    await plugin.hooks!.onUnload!(ctxB);
+    expect(connectionInstances[1]?.stop).toHaveBeenCalledTimes(1);
+
+    const finalStatusA = await statusRoute.handler({} as never, ctxA) as { status: number; body: unknown };
+    const finalStatusB = await statusRoute.handler({} as never, ctxB) as { status: number; body: unknown };
+    expect(finalStatusA.status).toBe(503);
+    expect(finalStatusB.status).toBe(503);
+  });
+});
+
+describe("markProcessed retention", () => {
+  it("prunes rows older than retention and keeps recent rows", () => {
+    const db = createInMemoryDb();
+    ensureSchema(db as any);
+    const now = Date.now();
+
+    db.prepare("INSERT INTO whatsapp_chat_dedupe(messageId, sender, receivedAt) VALUES(?, ?, ?)").run(
+      "old-id",
+      "sender",
+      new Date(now - 30 * 86_400_000).toISOString(),
+    );
+    db.prepare("INSERT INTO whatsapp_chat_dedupe(messageId, sender, receivedAt) VALUES(?, ?, ?)").run(
+      "recent-id",
+      "sender",
+      new Date(now - 3_600_000).toISOString(),
+    );
+
+    markProcessed(db as any, "new-id", "sender", 7);
+
+    const oldRow = db.prepare("SELECT 1 as found FROM whatsapp_chat_dedupe WHERE messageId = ?").get("old-id") as { found?: number } | undefined;
+    const recentRow = db.prepare("SELECT 1 as found FROM whatsapp_chat_dedupe WHERE messageId = ?").get("recent-id") as { found?: number } | undefined;
+    expect(Boolean(oldRow?.found)).toBe(false);
+    expect(Boolean(recentRow?.found)).toBe(true);
+    expect(wasProcessed(db as any, "new-id")).toBe(true);
+  });
+
+  it("keeps entries inside retention window", () => {
+    const db = createInMemoryDb();
+    ensureSchema(db as any);
+
+    db.prepare("INSERT INTO whatsapp_chat_dedupe(messageId, sender, receivedAt) VALUES(?, ?, ?)").run(
+      "one-day-old-id",
+      "sender",
+      new Date(Date.now() - 86_400_000).toISOString(),
+    );
+
+    markProcessed(db as any, "new-id", "sender", 7);
+
+    const oneDayOld = db.prepare("SELECT 1 as found FROM whatsapp_chat_dedupe WHERE messageId = ?").get("one-day-old-id") as { found?: number } | undefined;
+    expect(Boolean(oneDayOld?.found)).toBe(true);
+  });
+
+  it("parses dedupeRetentionDays safely", () => {
+    expect(getDedupeRetentionDays({})).toBe(7);
+    expect(getDedupeRetentionDays({ dedupeRetentionDays: undefined })).toBe(7);
+    expect(getDedupeRetentionDays({ dedupeRetentionDays: null })).toBe(7);
+    expect(getDedupeRetentionDays({ dedupeRetentionDays: 0 })).toBe(7);
+    expect(getDedupeRetentionDays({ dedupeRetentionDays: -3 })).toBe(7);
+    expect(getDedupeRetentionDays({ dedupeRetentionDays: "foo" })).toBe(7);
+    expect(getDedupeRetentionDays({ dedupeRetentionDays: Number.POSITIVE_INFINITY })).toBe(7);
+    expect(getDedupeRetentionDays({ dedupeRetentionDays: 14 })).toBe(14);
+    expect(getDedupeRetentionDays({ dedupeRetentionDays: 3.7 })).toBe(3);
+  });
+});

package/dist/plugins/fusion-plugin-whatsapp-chat/src/__tests__/reply.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it, vi } from "vitest";
+import { generateReply } from "../reply.js";
+
+function makeCtx(overrides: Record<string, unknown> = {}) {
+  const prompt = vi.fn();
+  const createAiSession = vi.fn().mockResolvedValue({
+    session: {
+      prompt,
+      state: { messages: [{ role: "assistant", content: "hello back" }] },
+    },
+  });
+
+  return {
+    settings: {},
+    taskStore: { getRootDir: () => "/repo" },
+    createAiSession,
+    ...overrides,
+  } as any;
+}
+
+describe("generateReply", () => {
+  it("creates ai session with readonly tools and cwd root", async () => {
+    const ctx = makeCtx();
+    await expect(generateReply(ctx, "1555", "hi", [])).resolves.toBe("hello back");
+    expect(ctx.createAiSession).toHaveBeenCalledWith(expect.objectContaining({ cwd: "/repo", tools: "readonly" }));
+  });
+
+  it("uses system prompt override and transcript continuity", async () => {
+    const prompt = vi.fn();
+    const ctx = makeCtx({
+      settings: { agentSystemPrompt: "custom prompt" },
+      createAiSession: vi.fn().mockResolvedValue({ session: { prompt, state: { messages: [{ role: "assistant", content: "ok" }] } } }),
+    });
+
+    await generateReply(ctx, "1555", "new", [{ role: "user", text: "old", createdAt: "t" }]);
+    expect(ctx.createAiSession).toHaveBeenCalledWith(expect.objectContaining({ systemPrompt: "custom prompt" }));
+    expect(prompt.mock.calls[0][0]).toContain("User: old");
+    expect(prompt.mock.calls[0][0]).toContain("User: new");
+  });
+
+  it("throws on empty assistant content", async () => {
+    const ctx = makeCtx({
+      createAiSession: vi.fn().mockResolvedValue({ session: { prompt: vi.fn(), state: { messages: [{ role: "assistant", content: "   " }] } } }),
+    });
+    await expect(generateReply(ctx, "1555", "hi", [])).rejects.toThrow("no assistant text");
+  });
+
+  it("throws when createAiSession missing", async () => {
+    const ctx = makeCtx({ createAiSession: undefined });
+    await expect(generateReply(ctx, "1555", "hi", [])).rejects.toThrow("AI session factory unavailable");
+  });
+});

package/dist/plugins/fusion-plugin-whatsapp-chat/src/auth-state.ts

@@ -0,0 +1,89 @@
+import { BufferJSON, initAuthCreds, type AuthenticationState, type AuthenticationCreds, type SignalDataSet, type SignalDataTypeMap } from "@whiskeysockets/baileys";
+import type { PluginDb } from "./index.js";
+
+type AuthStateResult = {
+  state: AuthenticationState;
+  saveCreds: () => Promise<void>;
+};
+
+type AuthRow = { value: string };
+
+function parseStoredValue<T>(value: string): T | null {
+  try {
+    return JSON.parse(value, BufferJSON.reviver) as T;
+  } catch {
+    return null;
+  }
+}
+
+function serialize(value: unknown): string {
+  return JSON.stringify(value, BufferJSON.replacer);
+}
+
+function loadCreds(db: PluginDb): AuthenticationCreds {
+  const row = db.prepare("SELECT value FROM whatsapp_auth_creds WHERE id = 'creds'").get() as AuthRow | undefined;
+  if (!row) return initAuthCreds();
+  return parseStoredValue<AuthenticationCreds>(row.value) ?? initAuthCreds();
+}
+
+export function clearAuthState(db: PluginDb): void {
+  db.prepare("DELETE FROM whatsapp_auth_creds").run();
+  db.prepare("DELETE FROM whatsapp_auth_keys").run();
+}
+
+export function createPluginDbAuthState(db: PluginDb): AuthStateResult {
+  const state: AuthenticationState = {
+    creds: loadCreds(db),
+    keys: {
+      get: async <T extends keyof SignalDataTypeMap>(type: T, ids: string[]) => {
+        const result: Record<string, SignalDataTypeMap[T]> = {};
+        const select = db.prepare("SELECT value FROM whatsapp_auth_keys WHERE category = ? AND keyId = ?");
+        for (const id of ids) {
+          const row = select.get(type, id) as AuthRow | undefined;
+          if (!row) continue;
+          const parsed = parseStoredValue<SignalDataTypeMap[T]>(row.value);
+          if (parsed != null) {
+            result[id] = parsed;
+          }
+        }
+        return result;
+      },
+      set: async (data: SignalDataSet) => {
+        const upsert = db.prepare(`
+          INSERT INTO whatsapp_auth_keys(category, keyId, value, updatedAt)
+          VALUES(?, ?, ?, ?)
+          ON CONFLICT(category, keyId)
+          DO UPDATE SET value = excluded.value, updatedAt = excluded.updatedAt
+        `);
+        const remove = db.prepare("DELETE FROM whatsapp_auth_keys WHERE category = ? AND keyId = ?");
+        const now = new Date().toISOString();
+
+        for (const category of Object.keys(data) as Array<keyof SignalDataSet>) {
+          const categoryEntries = data[category];
+          if (!categoryEntries) continue;
+          for (const id of Object.keys(categoryEntries)) {
+            const value = categoryEntries[id];
+            if (value == null) {
+              remove.run(category, id);
+              continue;
+            }
+            upsert.run(category, id, serialize(value), now);
+          }
+        }
+      },
+    },
+  };
+
+  return {
+    state,
+    saveCreds: async () => {
+      const now = new Date().toISOString();
+      db.prepare(`
+        INSERT INTO whatsapp_auth_creds(id, value, updatedAt)
+        VALUES('creds', ?, ?)
+        ON CONFLICT(id)
+        DO UPDATE SET value = excluded.value, updatedAt = excluded.updatedAt
+      `).run(serialize(state.creds), now);
+    },
+  };
+}