Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

11.8 KB
Raw Blame
import { describe, expect, it, vi } from "vite-plus/test";
import {
  STORED_REPLY_SYNTHESIS_UNAVAILABLE,
  storedReplySynthesisCapability,
} from "./capability.ts";
import { replyReadoutMessageAction } from "./messageAction.ts";
import { createReplyPlaybackSession, SPOKEN_CACHE_LIMIT } from "./session.ts";

vi.mock("./messageAction.ts", async (importOriginal) => {
  const actual = await importOriginal<typeof import("./messageAction.ts")>();

  return { replyReadoutMessageAction: vi.fn(actual.replyReadoutMessageAction) };
});

const message = {
  id: "reply-1",
  role: "assistant" as const,
  streaming: false,
  text: "**Stored** answer",
  updatedAt: "2026-09-08T00:00:00.000Z",
};

const later = { ...message, id: "reply-2", updatedAt: "2026-09-08T00:01:00.000Z" };

const history = { ...message, id: "old", updatedAt: "2026-09-07T00:00:00.000Z" };

const context = {
  environmentId: "environment",
  threadId: "thread",
  provider: "unavailable",
  voice: "unavailable",
  connected: true,
  mediaBlocked: false,
};

function setup(available = false) {
  const prepare = vi.fn(async () => ({
    play: vi.fn(async () => {}),
    pause: vi.fn(),
    dispose: vi.fn(),
  }));

  const session = available
    ? createReplyPlaybackSession({
        storage: { getItem: async () => "true", setItem: async () => {} },
        prepare,
        synthesis: { available: true, provider: "speech", voice: "voice" },
      })
    : createReplyPlaybackSession({
        storage: { getItem: async () => "true", setItem: async () => {} },
        prepare,
      });

  session.setContext(available ? { ...context, provider: "speech", voice: "voice" } : context);

  return { session, prepare };
}

describe("reply playback session", () => {
  it("derives spoken text once per stored reply text", async () => {
    const { session } = setup(true);
    await session.preference.load();
    vi.mocked(replyReadoutMessageAction).mockClear();
    session.actionFor(message);
    session.actionFor(message);
    session.observe([message]);
    session.observe([message]);
    expect(replyReadoutMessageAction).toHaveBeenCalledTimes(1);
    const edited = { ...message, text: "Edited answer", updatedAt: later.updatedAt };
    expect(session.actionFor(edited)?.request.text).toBe("Edited answer");
    expect(replyReadoutMessageAction).toHaveBeenCalledTimes(2);
  });

  it("keeps a long chat cached across repeated passes", async () => {
    const { session } = setup(true);
    await session.preference.load();

    const replies = Array.from({ length: 501 }, (_, index) => ({
      ...message,
      id: `reply-${index}`,
    }));

    for (const reply of replies) session.actionFor(reply);
    vi.mocked(replyReadoutMessageAction).mockClear();

    for (const reply of replies) session.actionFor(reply);
    expect(replyReadoutMessageAction).not.toHaveBeenCalled();
  });

  it("evicts only the oldest reply past the cache limit", async () => {
    const { session } = setup(true);
    await session.preference.load();

    const replies = Array.from({ length: SPOKEN_CACHE_LIMIT + 1 }, (_, index) => ({
      ...message,
      id: `reply-${index}`,
    }));

    for (const reply of replies) session.actionFor(reply);
    vi.mocked(replyReadoutMessageAction).mockClear();
    session.actionFor(replies[1]!);
    session.actionFor(replies.at(-1)!);
    expect(replyReadoutMessageAction).not.toHaveBeenCalled();
    session.actionFor(replies[0]!);
    expect(replyReadoutMessageAction).toHaveBeenCalledTimes(1);
  });

  it("derives capability from configured synthesis settings", () => {
    expect(
      storedReplySynthesisCapability({
        provider: "composed",
        synthesisProvider: "elevenlabs",
        synthesisVoices: { elevenlabs: "voice-1" },
      }),
    ).toEqual({ available: true, provider: "elevenlabs", voice: "voice-1" });
    expect(storedReplySynthesisCapability({ provider: "composed", openaiVoice: "nova" })).toEqual({
      available: true,
      provider: "openai",
      voice: "alloy",
    });
    expect(storedReplySynthesisCapability({ provider: "chatgpt" }).available).toBe(false);
  });

  it("keeps the readout preference while the selected environment changes voice settings", async () => {
    const { session } = setup();
    await session.preference.load();
    const onSynthesisChanged = vi.fn();
    const unsubscribe = session.subscribeSynthesis(onSynthesisChanged);
    expect(session.preference.getSnapshot().enabled).toBe(true);
    expect(session.actionFor(message)?.unavailableReason).toBe(STORED_REPLY_SYNTHESIS_UNAVAILABLE);
    session.setSynthesis({ available: true, provider: "openai", voice: "alloy" });
    expect(session.actionFor(message)?.unavailableReason).toBeUndefined();
    expect(session.getSynthesisSnapshot()).toMatchObject({ available: true, voice: "alloy" });
    expect(onSynthesisChanged).toHaveBeenCalledOnce();
    expect(session.preference.getSnapshot().enabled).toBe(true);
    unsubscribe();
  });

  it("exposes settled assistant readout without starting a turn", () => {
    const { session, prepare } = setup();
    expect(session.actionFor(message)).toMatchObject({
      request: { text: "Stored answer", automatic: false },
      unavailableReason: STORED_REPLY_SYNTHESIS_UNAVAILABLE,
    });
    expect(session.actionFor({ ...message, role: "user" })).toBeNull();
    expect(session.actionFor({ ...message, streaming: true })).toBeNull();
    expect(prepare).not.toHaveBeenCalled();
  });

  it("resolves synthesis per environment when given a lookup", () => {
    const session = createReplyPlaybackSession({
      storage: { getItem: async () => "true", setItem: async () => {} },
      prepare: vi.fn(),
      synthesis: (environmentId) =>
        environmentId === "environment"
          ? { available: true, provider: "speech", voice: "voice" }
          : { available: false, provider: "unavailable", voice: "unavailable", reason: "no" },
    });

    expect(session.synthesisFor("environment")).toEqual({
      available: true,
      provider: "speech",
      voice: "voice",
    });
    expect(session.synthesisFor("other").available).toBe(false);
  });

  it("keeps an environment's applied voice settings out of other environments", () => {
    const session = createReplyPlaybackSession({
      storage: { getItem: async () => "true", setItem: async () => {} },
      prepare: vi.fn(),
      synthesis: () => ({
        available: false,
        provider: "unavailable",
        voice: "unavailable",
        reason: "no",
      }),
    });

    session.setSynthesis({ available: true, provider: "speech", voice: "voice" }, "a");

    const context = {
      threadId: "thread",
      provider: "p",
      voice: "v",
      connected: true,
      mediaBlocked: false,
    };

    session.setContext({ ...context, environmentId: "a" });
    expect(session.actionFor(message)?.unavailableReason).toBeUndefined();
    session.setContext({ ...context, environmentId: "b" });
    expect(session.actionFor(message)?.unavailableReason).toBe("no");
    expect(session.getSynthesisSnapshot().available).toBe(false);
  });

  it("keeps the synthesis snapshot stable until the capability changes", () => {
    const session = createReplyPlaybackSession({
      storage: { getItem: async () => "true", setItem: async () => {} },
      prepare: vi.fn(),
      synthesis: (environmentId) =>
        environmentId === "environment"
          ? { available: true, provider: "speech", voice: "voice" }
          : { available: false, provider: "unavailable", voice: "unavailable", reason: "no" },
    });

    const onSynthesisChanged = vi.fn();
    session.subscribeSynthesis(onSynthesisChanged);
    const empty = session.getSynthesisSnapshot();
    expect(session.getSynthesisSnapshot()).toBe(empty);

    session.setContext(context);
    const selected = session.getSynthesisSnapshot();
    expect(selected).toMatchObject({ available: true });
    expect(session.getSynthesisSnapshot()).toBe(selected);
    expect(onSynthesisChanged).toHaveBeenCalledOnce();

    session.setContext({ ...context, mediaBlocked: true });
    expect(onSynthesisChanged).toHaveBeenCalledOnce();

    session.clearContextIf(context.environmentId, context.threadId);
    expect(session.getSynthesisSnapshot().available).toBe(false);
    expect(session.getSynthesisSnapshot()).toBe(session.getSynthesisSnapshot());
    expect(onSynthesisChanged).toHaveBeenCalledTimes(2);
  });

  it("returns the default capability for a null or empty environment", () => {
    const lookup = vi.fn(() => ({
      available: true as const,
      provider: "speech",
      voice: "voice",
    }));

    const session = createReplyPlaybackSession({
      storage: { getItem: async () => "true", setItem: async () => {} },
      prepare: vi.fn(),
      synthesis: lookup,
    });

    expect(session.synthesisFor(null).available).toBe(false);
    expect(session.synthesisFor("").available).toBe(false);
    expect(lookup).not.toHaveBeenCalled();
    expect(session.actionFor(message)).toBeNull();
    expect(lookup).not.toHaveBeenCalled();
  });

  it("hydrates history and loaded-earlier replies without automatic playback", async () => {
    const { session, prepare } = setup(true);
    await session.preference.load();
    session.observe([message]);
    session.observe([history, message]);
    expect(prepare).not.toHaveBeenCalled();
  });

  it("reads a newly completed reply once after opt-in, then stops when disabled", async () => {
    const { session, prepare } = setup(true);
    await session.preference.load();
    session.observe([message]);
    session.observe([message, later]);
    expect(prepare).toHaveBeenCalledOnce();
    expect(prepare).toHaveBeenCalledWith(
      expect.objectContaining({
        automatic: true,
        identity: expect.objectContaining({ messageId: "reply-2" }),
      }),
      expect.any(AbortSignal),
      expect.any(Object),
    );
    await session.preference.setEnabled(false);
    session.observe([
      message,
      later,
      { ...later, id: "reply-3", updatedAt: "2026-09-08T00:02:00.000Z" },
    ]);
    expect(prepare).toHaveBeenCalledOnce();
  });

  it("does not replay after reconnect on the same chat", async () => {
    const { session, prepare } = setup(true);
    await session.preference.load();
    session.observe([message]);
    session.observe([message, later]);
    session.setContext({ ...context, provider: "speech", voice: "voice", connected: false });
    session.setContext({ ...context, provider: "speech", voice: "voice", connected: true });
    session.observe([message, later]);
    expect(prepare).toHaveBeenCalledOnce();
  });

  it("clears only the owning chat so a stacked route can restore the revealed one", async () => {
    const { session } = setup(true);
    session.setContext({ ...context, threadId: "other", provider: "speech", voice: "voice" });
    await session.controller.start({
      identity: {
        ...context,
        threadId: "other",
        provider: "speech",
        voice: "voice",
        messageId: "reply-1",
        contentVersion: message.updatedAt,
      },
      text: "Stored answer",
      automatic: false,
    });
    session.clearContextIf(context.environmentId, context.threadId);
    expect(session.controller.getSnapshot()).toMatchObject({
      status: "playing",
      identity: { threadId: "other" },
    });
    session.clearContextIf(context.environmentId, "other");
    expect(session.controller.getSnapshot().status).toBe("idle");
  });

  it("stops playback when the active chat changes", async () => {
    const { session } = setup(true);
    await session.controller.start({
      identity: {
        ...context,
        provider: "speech",
        voice: "voice",
        messageId: "reply-1",
        contentVersion: message.updatedAt,
      },
      text: "Stored answer",
      automatic: false,
    });
    session.setContext({ ...context, threadId: "other", provider: "speech", voice: "voice" });
    expect(session.controller.getSnapshot().status).toBe("idle");
  });
});