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.

12.5 KB
Raw Blame
import { renderToStaticMarkup } from "react-dom/server";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";

const mocks = vi.hoisted(() => ({
  activeProject: { id: "project-1", environmentId: "env-1", workspaceRoot: "/tmp/project" },
  bot: {
    id: "bot-akeru",
    name: "Akeru",
    title: "Generalist",
    label: null,
    description: null,
    disabledMcpServerIds: [],
    avatar: { kind: "blob", shape: "circle", color: "#5B7FD4" },
    engine: null,
    sandbox: null,
    runtimeMode: "full-access",
    voiceEnabled: true,
    groupId: null,
    pinned: false,
    archivedAt: null,
    createdAt: "2026-08-27T00:00:00.000Z",
    updatedAt: "2026-08-27T00:00:00.000Z",
  },
  hangupVoiceCall: vi.fn(async () => ({ _tag: "Success", value: undefined })),
  navigate: vi.fn(async () => undefined),
  selectBot: vi.fn(),
  send: vi.fn(async () => true),
  appendTranscript: vi.fn(async () => undefined),
  startAtom: {},
  hangupAtom: {},
  startVoiceCall: vi.fn(),
  toast: vi.fn(),
  voiceProvider: "chatgpt" as "chatgpt" | "composed",
  captureSignals: [] as AbortSignal[],
}));

vi.mock("@effect/atom-react", () => ({ useAtomValue: () => [] }));

vi.mock("@tanstack/react-router", () => ({ useNavigate: () => mocks.navigate }));

vi.mock("../../hooks/useSettings", () => ({
  usePrimarySettings: <T,>(
    selector?: (settings: { voice: { enabled: boolean; provider: string } }) => T,
  ) => {
    const settings = { voice: { enabled: true, provider: mocks.voiceProvider } };

    return selector ? selector(settings) : settings;
  },
}));

vi.mock("../../modelSelection", () => ({
  resolveAppModelSelectionState: () => ({ instanceId: "codex", model: "gpt-5.6" }),
}));

vi.mock("../../providerInstances", () => ({
  applyProviderInstanceSettings: <T,>(entries: T) => entries,
  deriveProviderInstanceEntries: () => [],
  sortProviderInstanceEntries: <T,>(entries: T) => entries,
}));

vi.mock("../../state/entities", () => ({ useProjects: () => [mocks.activeProject] }));

vi.mock("../../state/environments", () => ({
  useEnvironmentConnectionState: () => ({ data: null }),
  usePrimaryEnvironmentId: () => "env-1",
}));

vi.mock("../../state/server", () => ({
  primaryServerProvidersAtom: {},
  serverEnvironment: {
    startVoiceCall: mocks.startAtom,
    hangupVoiceCall: mocks.hangupAtom,
  },
}));

vi.mock("../../state/use-atom-command", () => ({
  useAtomCommand: <T,>(atom: T) =>
    atom === mocks.startAtom ? mocks.startVoiceCall : mocks.hangupVoiceCall,
}));

vi.mock("../roster/botEngineSelection", () => ({
  resolveStickyBotEngine: () => ({ instanceId: "codex", model: "gpt-5.6" }),
}));

vi.mock("../roster/useBotThreadRuntime", () => ({
  useBotThreadRuntime: () => ({
    appendTranscript: mocks.appendTranscript,
    bootstrapped: true,
    botReady: true,
    defaultProject: mocks.activeProject,
    error: null,
    latestTurn: null,
    messages: [],
    send: mocks.send,
    sending: false,
  }),
}));

vi.mock("../roster/rosterStore", () => {
  const state = { bots: [mocks.bot], selectedBotId: mocks.bot.id, selectBot: mocks.selectBot };

  return {
    useRosterStore: Object.assign(<T,>(selector: (value: typeof state) => T) => selector(state), {
      getState: () => state,
    }),
  };
});

vi.mock("../ui/toast", () => ({ toastManager: { add: mocks.toast } }));

vi.mock("./browserVoiceAudio", () => ({
  // A silent microphone: capture waits until the call scope is cancelled.
  captureVoiceUtterance: <T,>(_microphone: T, signal: AbortSignal) => {
    mocks.captureSignals.push(signal);

    return new Promise((_, reject) =>
      signal.addEventListener("abort", () => reject(signal.reason), { once: true }),
    );
  },
  playVoiceAudio: vi.fn(async () => undefined),
}));

import { VoiceCallProvider, useVoiceCall } from "./VoiceCall";

type VoiceControls = ReturnType<typeof useVoiceCall>;

class TestDataChannel extends EventTarget {
  readyState: RTCDataChannelState = "open";
  readonly send = vi.fn();
}

class TestPeer {
  /** Every peer the call constructed, newest last, so tests can drive connection events. */
  static readonly instances: TestPeer[] = [];
  iceGatheringState: RTCIceGatheringState = "complete";
  connectionState: RTCPeerConnectionState = "connected";
  localDescription: RTCSessionDescription | null = null;
  ontrack: ((event: RTCTrackEvent) => void) | null = null;
  onconnectionstatechange: (() => void) | null = null;
  readonly events = new TestDataChannel();
  constructor() {
    TestPeer.instances.push(this);
  }
  addTrack() {}
  addEventListener() {}
  removeEventListener() {}
  close() {}
  createDataChannel() {
    return this.events;
  }
  async createOffer(): Promise<RTCSessionDescriptionInit> {
    return { type: "offer", sdp: "offer-sdp" };
  }
  async setLocalDescription(description: RTCSessionDescriptionInit) {
    this.localDescription = description as RTCSessionDescription;
  }
  async setRemoteDescription() {}
}

function renderControls(): VoiceControls {
  let controls: VoiceControls | null = null;

  function Probe() {
    controls = useVoiceCall();

    return null;
  }

  renderToStaticMarkup(
    <VoiceCallProvider>
      <Probe />
    </VoiceCallProvider>,
  );

  if (controls === null) throw new Error("Voice controls did not mount.");

  return controls;
}

async function flushVoiceStart() {
  for (let index = 0; index < 12; index += 1) await Promise.resolve();
}

describe("voice call provider", () => {
  const track = {
    enabled: true,
    stop: vi.fn(),
    addEventListener: vi.fn(),
    removeEventListener: vi.fn(),
  };

  const microphone = {
    getTracks: () => [track],
    getAudioTracks: () => [track],
  };

  beforeEach(() => {
    vi.clearAllMocks();
    TestPeer.instances.length = 0;
    mocks.voiceProvider = "chatgpt";
    mocks.captureSignals = [];
    vi.stubGlobal("RTCPeerConnection", TestPeer);
    vi.stubGlobal(
      "Audio",
      class {
        autoplay = false;
        srcObject: MediaProvider | null = null;
        pause() {}
        async play() {}
      },
    );
    mocks.startVoiceCall.mockResolvedValue({
      _tag: "Success",
      value: {
        call: {
          callId: "call-1",
          status: "live",
          botId: mocks.bot.id,
          botName: mocks.bot.name,
          startedAt: "2026-08-27T00:00:00.000Z",
        },
        answerSdp: "answer-sdp",
        transport: "webrtc",
      },
    });
  });

  it("refuses a second start while the first call is pending and lets hangup cancel it", async () => {
    let resolveMicrophone!: (value: typeof microphone) => void;

    const pendingMicrophone = new Promise<typeof microphone>((resolve) => {
      resolveMicrophone = resolve;
    });

    vi.stubGlobal("navigator", {
      mediaDevices: { getUserMedia: vi.fn(() => pendingMicrophone) },
    });
    const controls = renderControls();

    controls.startOrReturn(mocks.bot as never);
    controls.startOrReturn({ ...mocks.bot, id: "bot-other", name: "Other" } as never);
    expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalledOnce();

    controls.hangup();
    resolveMicrophone(microphone);
    await flushVoiceStart();
    expect(track.stop).toHaveBeenCalled();
    expect(mocks.startVoiceCall).not.toHaveBeenCalled();
  });

  it("returns to the active bot instead of starting a second call", async () => {
    vi.stubGlobal("navigator", {
      mediaDevices: { getUserMedia: vi.fn(async () => microphone) },
    });
    const controls = renderControls();

    controls.startOrReturn(mocks.bot as never);
    await flushVoiceStart();
    expect(mocks.startVoiceCall).toHaveBeenCalledOnce();

    controls.startOrReturn(mocks.bot as never);
    expect(mocks.startVoiceCall).toHaveBeenCalledOnce();
    expect(mocks.selectBot).toHaveBeenCalledWith(mocks.bot.id);
    expect(mocks.navigate).toHaveBeenCalledWith({
      to: "/bots/$botId",
      params: { botId: mocks.bot.id },
    });
  });

  it("uses speech-safe microphone constraints and resumes input after playback drains", async () => {
    vi.stubGlobal("navigator", {
      mediaDevices: { getUserMedia: vi.fn(async () => microphone) },
    });
    const controls = renderControls();

    controls.startOrReturn(mocks.bot as never);
    await flushVoiceStart();

    expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalledWith({
      audio: {
        echoCancellation: true,
        noiseSuppression: true,
        autoGainControl: true,
      },
      video: false,
    });
    TestPeer.instances.at(-1)?.events.dispatchEvent(
      new MessageEvent("message", {
        data: JSON.stringify({ type: "output_audio_buffer.started" }),
      }),
    );
    expect(track.enabled).toBe(false);
    TestPeer.instances.at(-1)?.events.dispatchEvent(
      new MessageEvent("message", {
        data: JSON.stringify({ type: "response.done", response: { status: "completed" } }),
      }),
    );
    expect(track.enabled).toBe(false);
    TestPeer.instances.at(-1)?.events.dispatchEvent(
      new MessageEvent("message", {
        data: JSON.stringify({ type: "output_audio_buffer.stopped" }),
      }),
    );
    expect(track.enabled).toBe(true);
  });

  it("sends a repeated realtime function call to chat once", async () => {
    vi.stubGlobal("navigator", {
      mediaDevices: { getUserMedia: vi.fn(async () => microphone) },
    });
    const controls = renderControls();
    controls.startOrReturn(mocks.bot as never);
    await flushVoiceStart();

    const event = new MessageEvent("message", {
      data: JSON.stringify({
        type: "response.function_call_arguments.done",
        event_id: "event-1",
        call_id: "function-1",
        name: "send_to_chat",
        arguments: JSON.stringify({ message: "Run tests" }),
      }),
    });

    TestPeer.instances.at(-1)?.events.dispatchEvent(event);
    TestPeer.instances.at(-1)?.events.dispatchEvent(event);
    await Promise.resolve();
    expect(mocks.send).toHaveBeenCalledOnce();
    controls.hangup();
    TestPeer.instances.at(-1)?.events.dispatchEvent(event);
    expect(mocks.send).toHaveBeenCalledOnce();
  });

  it("drops a replayed realtime event instead of saving its transcript twice", async () => {
    vi.stubGlobal("navigator", {
      mediaDevices: { getUserMedia: vi.fn(async () => microphone) },
    });
    const controls = renderControls();
    controls.startOrReturn(mocks.bot as never);
    await flushVoiceStart();

    const replayed = new MessageEvent("message", {
      data: JSON.stringify({
        event_id: "event-1",
        type: "conversation.item.input_audio_transcription.completed",
        transcript: "Hello",
      }),
    });

    TestPeer.instances.at(-1)?.events.dispatchEvent(replayed);
    TestPeer.instances.at(-1)?.events.dispatchEvent(replayed);
    expect(mocks.appendTranscript).toHaveBeenCalledOnce();
  });

  it("starts a composed call without WebRTC and releases the microphone on hangup", async () => {
    mocks.voiceProvider = "composed";
    mocks.startVoiceCall.mockResolvedValue({
      _tag: "Success",
      value: {
        call: {
          callId: "call-2",
          status: "live",
          botId: mocks.bot.id,
          botName: mocks.bot.name,
          startedAt: "2026-09-25T00:00:00.000Z",
        },
        transport: "composed",
      },
    });
    vi.stubGlobal("navigator", {
      mediaDevices: { getUserMedia: vi.fn(async () => microphone) },
    });
    const controls = renderControls();

    controls.startOrReturn(mocks.bot as never);
    await flushVoiceStart();

    expect(mocks.startVoiceCall).toHaveBeenCalledWith({
      environmentId: "env-1",
      input: { botId: mocks.bot.id },
    });
    expect(TestPeer.instances).toHaveLength(0);
    expect(mocks.captureSignals).toHaveLength(1);

    controls.hangup();
    expect(mocks.captureSignals[0]?.aborted).toBe(true);
    expect(track.stop).toHaveBeenCalled();
    expect(mocks.hangupVoiceCall).toHaveBeenCalledWith({
      environmentId: "env-1",
      input: { callId: "call-2" },
    });
  });

  it("refuses a call when the server pinned a different voice mode", async () => {
    mocks.voiceProvider = "composed";
    vi.stubGlobal("navigator", {
      mediaDevices: { getUserMedia: vi.fn(async () => microphone) },
    });
    const controls = renderControls();

    controls.startOrReturn(mocks.bot as never);
    await flushVoiceStart();

    expect(mocks.captureSignals).toHaveLength(0);
    expect(track.stop).toHaveBeenCalled();
    expect(mocks.hangupVoiceCall).toHaveBeenCalledWith({
      environmentId: "env-1",
      input: { callId: "call-1" },
    });
    expect(mocks.toast).toHaveBeenCalledWith(
      expect.objectContaining({
        title: "Could not start call",
        description: "Voice settings changed while the call was starting. Start the call again.",
      }),
    );
  });
});