whale-code 6.5.10 → 6.6.0

package/dist/cli/services/__tests__/agent-events-global.test.js

@@ -1,39 +0,0 @@
-import { describe, it, expect, afterEach, vi } from "vitest";
-import { AgentEventEmitter, getGlobalEmitter, setGlobalEmitter, clearGlobalEmitter } from "../agent-events.js";
-
-// ============================================================================
-// Global Emitter Singleton (split from agent-events.test.ts)
-// ============================================================================
-
-describe("Global Emitter", () => {
-  afterEach(() => {
-    clearGlobalEmitter();
-  });
-  it("getGlobalEmitter lazily creates an emitter", () => {
-    const emitter = getGlobalEmitter();
-    expect(emitter).toBeInstanceOf(AgentEventEmitter);
-  });
-  it("getGlobalEmitter returns the same instance", () => {
-    const a = getGlobalEmitter();
-    const b = getGlobalEmitter();
-    expect(a).toBe(b);
-  });
-  it("setGlobalEmitter replaces the global emitter", () => {
-    const custom = new AgentEventEmitter();
-    setGlobalEmitter(custom);
-    expect(getGlobalEmitter()).toBe(custom);
-  });
-  it("clearGlobalEmitter destroys and nulls the emitter", () => {
-    const emitter = getGlobalEmitter();
-    const spy = vi.spyOn(emitter, "destroy");
-    clearGlobalEmitter();
-    expect(spy).toHaveBeenCalled();
-    // Next call creates a new one
-    const next = getGlobalEmitter();
-    expect(next).not.toBe(emitter);
-  });
-  it("clearGlobalEmitter is safe when no emitter exists", () => {
-    clearGlobalEmitter(); // nothing to destroy
-    clearGlobalEmitter(); // still safe
-  });
-});

package/dist/cli/services/__tests__/agent-events.part2.test.js

@@ -1,113 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { AgentEventEmitter } from "../agent-events.js";
-
-// ============================================================================
-// AgentEventEmitter — subagent & team events
-// ============================================================================
-
-describe("AgentEventEmitter — subagent & team events", () => {
-  let emitter;
-  let events;
-  beforeEach(() => {
-    emitter = new AgentEventEmitter();
-    events = [];
-    emitter.onEvent(e => events.push(e));
-  });
-  afterEach(() => {
-    emitter.destroy();
-  });
-  it("emitSubagentStart emits subagent_start event", () => {
-    emitter.emitSubagentStart("sa-1", "code", "opus", "Fix a bug");
-    const e = events[0];
-    expect(e.type).toBe("subagent_start");
-    expect(e.id).toBe("sa-1");
-    expect(e.agentType).toBe("code");
-    expect(e.model).toBe("opus");
-    expect(e.description).toBe("Fix a bug");
-  });
-  it("emitSubagentProgress emits subagent_progress event", () => {
-    emitter.emitSubagentProgress("sa-1", "code", "reading file...", 2, "read_file");
-    const e = events[0];
-    expect(e.type).toBe("subagent_progress");
-    expect(e.id).toBe("sa-1");
-    expect(e.message).toBe("reading file...");
-    expect(e.turn).toBe(2);
-    expect(e.toolName).toBe("read_file");
-  });
-  it("emitSubagentDone emits subagent_done event", () => {
-    emitter.emitSubagentDone("sa-1", "code", true, "done", {
-      input: 100,
-      output: 50
-    }, ["read_file"], 5000);
-    const e = events[0];
-    expect(e.type).toBe("subagent_done");
-    expect(e.success).toBe(true);
-    expect(e.output).toBe("done");
-    expect(e.tokens).toEqual({
-      input: 100,
-      output: 50
-    });
-    expect(e.tools).toEqual(["read_file"]);
-    expect(e.durationMs).toBe(5000);
-  });
-  it("emitSubagentToolStart emits subagent_tool_start event", () => {
-    emitter.emitSubagentToolStart("sa-1", "bash", {
-      command: "ls"
-    });
-    const e = events[0];
-    expect(e.type).toBe("subagent_tool_start");
-    expect(e.agentId).toBe("sa-1");
-    expect(e.toolName).toBe("bash");
-    expect(e.toolInput).toEqual({
-      command: "ls"
-    });
-  });
-  it("emitSubagentToolEnd emits subagent_tool_end event", () => {
-    emitter.emitSubagentToolEnd("sa-1", "bash", true, 250);
-    const e = events[0];
-    expect(e.type).toBe("subagent_tool_end");
-    expect(e.agentId).toBe("sa-1");
-    expect(e.success).toBe(true);
-    expect(e.durationMs).toBe(250);
-  });
-  it("emitTeamStart emits team_start event", () => {
-    emitter.emitTeamStart("tm-1", "refactor", 3, 5);
-    const e = events[0];
-    expect(e.type).toBe("team_start");
-    expect(e.teamId).toBe("tm-1");
-    expect(e.name).toBe("refactor");
-    expect(e.teammateCount).toBe(3);
-    expect(e.taskCount).toBe(5);
-  });
-  it("emitTeamProgress emits team_progress event", () => {
-    emitter.emitTeamProgress("tm-1", "mate-1", "Alice", "working on task", "task-1");
-    const e = events[0];
-    expect(e.type).toBe("team_progress");
-    expect(e.teamId).toBe("tm-1");
-    expect(e.teammateId).toBe("mate-1");
-    expect(e.teammateName).toBe("Alice");
-    expect(e.message).toBe("working on task");
-    expect(e.taskId).toBe("task-1");
-  });
-  it("emitTeamTask emits team_task event", () => {
-    emitter.emitTeamTask("tm-1", "mate-1", "task-1", "Fix tests", "completed", "all green");
-    const e = events[0];
-    expect(e.type).toBe("team_task");
-    expect(e.status).toBe("completed");
-    expect(e.result).toBe("all green");
-  });
-  it("emitTeamDone emits team_done event", () => {
-    emitter.emitTeamDone("tm-1", true, "All done", 4, 5, {
-      input: 500,
-      output: 300
-    }, 60000);
-    const e = events[0];
-    expect(e.type).toBe("team_done");
-    expect(e.teamId).toBe("tm-1");
-    expect(e.success).toBe(true);
-    expect(e.summary).toBe("All done");
-    expect(e.tasksCompleted).toBe(4);
-    expect(e.tasksTotal).toBe(5);
-    expect(e.durationMs).toBe(60000);
-  });
-});

package/dist/cli/services/__tests__/agent-events.test.js

@@ -1,157 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { AgentEventEmitter } from "../agent-events.js";
-
-// ============================================================================
-// AgentEventEmitter — core events
-// ============================================================================
-
-describe("AgentEventEmitter — core events", () => {
-  let emitter;
-  let events;
-  beforeEach(() => {
-    emitter = new AgentEventEmitter();
-    events = [];
-    emitter.onEvent(e => events.push(e));
-  });
-  afterEach(() => {
-    emitter.destroy();
-  });
-  it("emitText emits a text event", () => {
-    emitter.emitText("hello");
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.type).toBe("text");
-    expect(e.text).toBe("hello");
-    expect(e.accumulated).toBe("");
-  });
-  it("emitText emits multiple text events in sequence", () => {
-    emitter.emitText("a");
-    emitter.emitText("b");
-    emitter.emitText("c");
-    expect(events).toHaveLength(3);
-    expect(events[0].text).toBe("a");
-    expect(events[1].text).toBe("b");
-    expect(events[2].text).toBe("c");
-  });
-  it("emitText handles empty string", () => {
-    emitter.emitText("");
-    expect(events).toHaveLength(1);
-    expect(events[0].text).toBe("");
-  });
-  it("flushText is a no-op", () => {
-    emitter.flushText();
-    expect(events).toHaveLength(0);
-  });
-  it("emitToolStart emits a tool_start event", () => {
-    emitter.emitToolStart("tool-1", "read_file");
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.type).toBe("tool_start");
-    expect(e.id).toBe("tool-1");
-    expect(e.name).toBe("read_file");
-  });
-  it("emitToolEnd emits a tool_end event with all fields", () => {
-    emitter.emitToolEnd("tool-1", "read_file", true, "contents", {
-      path: "/a"
-    }, 120);
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.type).toBe("tool_end");
-    expect(e.id).toBe("tool-1");
-    expect(e.name).toBe("read_file");
-    expect(e.success).toBe(true);
-    expect(e.result).toBe("contents");
-    expect(e.input).toEqual({
-      path: "/a"
-    });
-    expect(e.durationMs).toBe(120);
-  });
-  it("emitToolEnd handles undefined result/input", () => {
-    emitter.emitToolEnd("t", "bash", false, undefined, undefined, 0);
-    const e = events[0];
-    expect(e.result).toBeUndefined();
-    expect(e.input).toBeUndefined();
-  });
-  it("emitUsage emits a usage event", () => {
-    emitter.emitUsage(100, 200, "claude-3", 0.05, 50, 10);
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.type).toBe("usage");
-    expect(e.inputTokens).toBe(100);
-    expect(e.outputTokens).toBe(200);
-    expect(e.model).toBe("claude-3");
-    expect(e.costUsd).toBe(0.05);
-    expect(e.cacheReadTokens).toBe(50);
-    expect(e.cacheCreationTokens).toBe(10);
-  });
-  it("emitUsage handles optional parameters", () => {
-    emitter.emitUsage(10, 20);
-    const e = events[0];
-    expect(e.model).toBeUndefined();
-    expect(e.costUsd).toBeUndefined();
-  });
-  it("emitDone emits a done event", () => {
-    const msgs = [{
-      role: "user",
-      content: "hi"
-    }];
-    emitter.emitDone("final text", msgs);
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.type).toBe("done");
-    expect(e.text).toBe("final text");
-    expect(e.messages).toEqual(msgs);
-  });
-  it("emitError emits an error event", () => {
-    emitter.emitError("something broke");
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.type).toBe("error");
-    expect(e.error).toBe("something broke");
-  });
-  it("emitCompact emits a compact event", () => {
-    emitter.emitCompact(10000, 5000, 5000);
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.type).toBe("compact");
-    expect(e.before).toBe(10000);
-    expect(e.after).toBe(5000);
-    expect(e.tokensSaved).toBe(5000);
-  });
-  it("emitToolOutput emits a tool_output event", () => {
-    emitter.emitToolOutput("bash", "line of output");
-    expect(events).toHaveLength(1);
-    const e = events[0];
-    expect(e.type).toBe("tool_output");
-    expect(e.toolName).toBe("bash");
-    expect(e.line).toBe("line of output");
-  });
-  it("onEvent returns unsubscribe function", () => {
-    const localEvents = [];
-    const unsub = emitter.onEvent(e => localEvents.push(e));
-    emitter.emitText("first");
-    expect(localEvents).toHaveLength(1);
-    unsub();
-    emitter.emitText("second");
-    expect(localEvents).toHaveLength(1);
-  });
-  it("supports multiple concurrent subscribers", () => {
-    const sub1 = [];
-    const sub2 = [];
-    emitter.onEvent(e => sub1.push(e));
-    emitter.onEvent(e => sub2.push(e));
-    emitter.emitText("test");
-    expect(sub1).toHaveLength(1);
-    expect(sub2).toHaveLength(1);
-  });
-  it("destroy removes all listeners", () => {
-    emitter.destroy();
-    emitter.emitText("after destroy");
-    expect(events).toHaveLength(0);
-  });
-  it("destroy is idempotent", () => {
-    emitter.destroy();
-    emitter.destroy();
-    expect(emitter.listenerCount("event")).toBe(0);
-  });
-});

package/dist/cli/services/__tests__/agent-loop-auth.test.js

@@ -1,392 +0,0 @@
-/**
- * Tests for agent-loop.ts — auth handling (split from agent-loop-tools-lifecycle)
- */
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ============================================================================
-// Mocks — must be declared before imports
-// ============================================================================
-
-vi.mock("../local-tools.js", () => ({
-  LOCAL_TOOL_DEFINITIONS: [{
-    name: "bash",
-    description: "Run shell commands",
-    input_schema: {
-      type: "object",
-      properties: {
-        command: {
-          type: "string"
-        }
-      }
-    }
-  }, {
-    name: "read_file",
-    description: "Read a file",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: {
-          type: "string"
-        }
-      }
-    }
-  }],
-  executeLocalTool: vi.fn(async (name, _input) => ({
-    success: true,
-    output: `local-tool-result:${name}`
-  })),
-  isLocalTool: vi.fn(name => ["bash", "read_file"].includes(name))
-}));
-vi.mock("../interactive-tools.js", () => ({
-  INTERACTIVE_TOOL_DEFINITIONS: [{
-    name: "ask_user_question",
-    description: "Ask user",
-    input_schema: {
-      type: "object",
-      properties: {
-        question: {
-          type: "string"
-        }
-      }
-    }
-  }],
-  executeInteractiveTool: vi.fn(async () => ({
-    success: true,
-    output: "user answered"
-  }))
-}));
-vi.mock("../config-store.js", () => ({
-  loadConfig: vi.fn(() => ({
-    access_token: "test-token",
-    refresh_token: "test-refresh",
-    proxy_url: "https://proxy.test"
-  })),
-  resolveConfig: vi.fn(() => ({
-    storeId: "store-123",
-    proxyUrl: "https://proxy.test"
-  })),
-  getProxyUrl: vi.fn(() => "https://proxy.test")
-}));
-vi.mock("../auth-service.js", () => ({
-  getValidToken: vi.fn(async () => "test-jwt-token"),
-  refreshSession: vi.fn(async () => ({
-    success: true,
-    config: {
-      access_token: "refreshed-token"
-    }
-  }))
-}));
-vi.mock("../server-tools.js", () => ({
-  isServerTool: vi.fn(() => false),
-  loadServerToolDefinitions: vi.fn(async () => []),
-  executeServerTool: vi.fn(async () => ({
-    success: true,
-    output: "server-result"
-  })),
-  getServerStatus: vi.fn(() => ({
-    connected: false
-  })),
-  setServerToolContext: vi.fn()
-}));
-vi.mock("../telemetry.js", () => ({
-  nextTurn: vi.fn(() => 1),
-  createTurnContext: vi.fn(() => ({
-    traceId: "trace-1",
-    spanId: "span-1",
-    conversationId: "conv-1",
-    userId: "user-1",
-    userEmail: "test@test.com"
-  })),
-  logSpan: vi.fn(),
-  generateSpanId: vi.fn(() => "span-gen-1"),
-  flushCliSpans: vi.fn()
-}));
-vi.mock("../error-logger.js", () => ({
-  captureError: vi.fn(),
-  addBreadcrumb: vi.fn()
-}));
-vi.mock("../agent-events.js", () => ({
-  AgentEventEmitter: vi.fn(),
-  setGlobalEmitter: vi.fn(),
-  clearGlobalEmitter: vi.fn()
-}));
-vi.mock("../mcp-client.js", () => ({
-  mcpClientManager: {
-    getTools: vi.fn(() => []),
-    isMcpTool: vi.fn(() => false),
-    callTool: vi.fn(async () => ({
-      success: true,
-      output: "mcp-result"
-    }))
-  }
-}));
-vi.mock("../hooks.js", () => ({
-  loadHooks: vi.fn(() => []),
-  runBeforeToolHook: vi.fn(async () => ({
-    allow: true
-  })),
-  runAfterToolHook: vi.fn(async () => ({})),
-  runSessionHook: vi.fn(async () => {})
-}));
-vi.mock("../../../shared/agent-core.js", () => {
-  class MockLoopDetector {
-    resetTurn = vi.fn();
-    getSessionStats = vi.fn(() => ({
-      totalErrors: 0,
-      failedStrategies: 0,
-      consecutiveFailedTurns: 0
-    }));
-  }
-  return {
-    LoopDetector: MockLoopDetector,
-    COMPACTION_TRIGGER_TOKENS: 167_000,
-    COMPACTION_TOTAL_BUDGET: 2_000_000,
-    DEFAULT_SESSION_COST_BUDGET_USD: 25,
-    AGENT_DEFAULTS: {
-      maxTurns: 200,
-      temperature: 1.0,
-      maxConcurrentTools: 7,
-      enableDelegation: true,
-      maxDurationMs: 900_000,
-      maxDurationMsWorkflow: 120_000,
-      enableModelRouting: true,
-      subagentMaxTokens: 32000,
-      subagentMaxTurns: 25,
-      subagentTemperature: 1.0,
-      subagentMaxRetries: 3,
-      maxContinuations: 10,
-      subagentMaxContinuations: 5,
-      maxMessageChars: 100_000,
-      maxToolResultChars: 2048,
-      compactionTriggerTokens: 167_000,
-      compactionTotalBudget: 2_000_000,
-      sessionCostBudgetUsd: 25.00,
-      teammateMaxTotalTurns: 50,
-      teamTimeoutMs: 600_000,
-      workerStallMs: 180_000,
-      teamReviewMaxTokens: 1024,
-      apiTimeoutMs: 90_000,
-      toolTimeoutMs: 60_000,
-      toolResultTruncateChars: 500_000
-    },
-    emitCostWarningIfNeeded: vi.fn(),
-    getCompactionConfig: vi.fn(() => ({
-      isNative: true,
-      triggerTokens: 167_000,
-      totalBudget: 2_000_000
-    })),
-    getContextManagement: vi.fn(() => ({
-      betas: [],
-      config: {
-        edits: []
-      }
-    })),
-    resolveAgentLoopConfig: vi.fn(() => ({
-      maxTurns: 200,
-      temperature: 1.0,
-      maxTokens: 32000,
-      maxConcurrentTools: 7,
-      enableDelegation: true,
-      maxDurationMs: 900_000,
-      enableModelRouting: true,
-      maxMessageChars: 100_000,
-      contextOverrides: {},
-      subagentMaxTokens: 32000,
-      subagentMaxTurns: 25,
-      subagentTemperature: 1.0,
-      maxContinuations: 10,
-      subagentMaxContinuations: 5,
-      subagentMaxRetries: 3,
-      maxToolResultChars: 2048,
-      defaultsUsed: []
-    }))
-  };
-});
-vi.mock("../agent-config.js", () => ({
-  loadCLIAgentConfig: vi.fn(async () => null),
-  resetAgentConfigCache: vi.fn()
-}));
-vi.mock("../../../shared/sse-parser.js", () => ({
-  parseSSEStream: vi.fn(() => async function* () {}()),
-  processStreamWithCallbacks: vi.fn(async () => ({
-    text: "Hello from Claude",
-    toolUseBlocks: [],
-    thinkingBlocks: [],
-    thinkingTokens: 0,
-    citations: [],
-    usage: {
-      inputTokens: 100,
-      outputTokens: 50,
-      cacheCreationTokens: 0,
-      cacheReadTokens: 0
-    },
-    compactionContent: null,
-    contextManagementApplied: false,
-    stopReason: "end_turn"
-  })),
-  collectStreamResult: vi.fn(async () => ({
-    text: "summary",
-    usage: {
-      inputTokens: 10,
-      outputTokens: 5,
-      cacheCreationTokens: 0,
-      cacheReadTokens: 0
-    }
-  }))
-}));
-vi.mock("../../../shared/api-client.js", () => ({
-  callServerProxy: vi.fn(async () => new ReadableStream()),
-  callTranscribe: vi.fn(async () => "transcribed text"),
-  buildAPIRequest: vi.fn(() => ({
-    maxTokens: 16384,
-    betas: ["context-management-2025-06-27"],
-    contextManagement: {
-      edits: []
-    },
-    thinking: undefined
-  })),
-  buildSystemBlocks: vi.fn((prompt, cost) => [{
-    type: "text",
-    text: prompt,
-    cache_control: {
-      type: "ephemeral"
-    }
-  }, {
-    type: "text",
-    text: cost
-  }]),
-  prepareWithCaching: vi.fn((tools, messages) => ({
-    tools,
-    messages
-  })),
-  trimGeminiContext: vi.fn(msgs => msgs),
-  trimOpenAIContext: vi.fn(msgs => msgs),
-  requestProviderCompaction: vi.fn(async () => null)
-}));
-vi.mock("../../../shared/constants.js", () => ({
-  MODELS: {
-    HAIKU: "claude-haiku-4-5-20251001",
-    SONNET: "claude-sonnet-4-6",
-    OPUS: "claude-opus-4-6"
-  },
-  getProvider: vi.fn(() => "anthropic")
-}));
-vi.mock("../../../shared/tool-dispatch.js", () => ({
-  dispatchTools: vi.fn(async () => ({
-    results: [],
-    bailOut: false,
-    bailMessage: undefined
-  })),
-  buildAssistantContent: vi.fn(({
-    text,
-    toolUseBlocks
-  }) => {
-    const blocks = [];
-    if (text) blocks.push({
-      type: "text",
-      text
-    });
-    for (const t of toolUseBlocks) blocks.push({
-      type: "tool_use",
-      id: t.id,
-      name: t.name,
-      input: t.input
-    });
-    return blocks;
-  })
-}));
-vi.mock("../memory-manager.js", () => ({
-  loadMemory: vi.fn(async () => "memory content"),
-  addMemory: vi.fn(async () => {}),
-  removeMemory: vi.fn(async () => {}),
-  listMemories: vi.fn(async () => [])
-}));
-vi.mock("../git-context.js", () => ({
-  refreshGitContext: vi.fn(async () => "git context"),
-  resetGitContext: vi.fn()
-}));
-vi.mock("../claude-md-loader.js", () => ({
-  loadClaudeMd: vi.fn(async () => "claude md"),
-  reloadClaudeMd: vi.fn(async () => "claude md"),
-  resetClaudeMdCache: vi.fn()
-}));
-vi.mock("../permission-modes.js", () => ({
-  setPermissionMode: vi.fn(),
-  getPermissionMode: vi.fn(() => "normal"),
-  isToolAllowedByPermission: vi.fn(() => true)
-}));
-vi.mock("../model-manager.js", () => ({
-  setModel: vi.fn(),
-  setModelById: vi.fn(),
-  getModel: vi.fn(() => "claude-sonnet-4-6"),
-  getModelShortName: vi.fn(() => "sonnet"),
-  estimateCostUsd: vi.fn(() => 0.005)
-}));
-vi.mock("../session-persistence.js", () => ({
-  saveSession: vi.fn(async () => {}),
-  loadSession: vi.fn(async () => null),
-  listSessions: vi.fn(async () => []),
-  findLatestSessionForCwd: vi.fn(async () => null)
-}));
-vi.mock("../system-prompt.js", () => ({
-  buildSystemPrompt: vi.fn(async () => "You are a helpful AI assistant.")
-}));
-vi.mock("../background-processes.js", () => ({
-  listProcesses: vi.fn(() => []),
-  listBackgroundAgents: vi.fn(() => [])
-}));
-
-// ============================================================================
-// Imports — after all mocks
-// ============================================================================
-
-import { runAgentLoop, resetSessionState } from "../agent-loop.js";
-import { getValidToken } from "../auth-service.js";
-import { loadConfig } from "../config-store.js";
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function makeCallbacks(overrides = {}) {
-  return {
-    onText: vi.fn(),
-    onToolStart: vi.fn(),
-    onToolResult: vi.fn(),
-    onUsage: vi.fn(),
-    onDone: vi.fn(),
-    onError: vi.fn(),
-    onAutoCompact: vi.fn(),
-    ...overrides
-  };
-}
-
-// ============================================================================
-// TESTS — auth
-// ============================================================================
-
-describe("runAgentLoop — auth", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    resetSessionState();
-    vi.mocked(getValidToken).mockResolvedValue("test-jwt-token");
-    vi.mocked(loadConfig).mockReturnValue({
-      access_token: "test-token",
-      refresh_token: "test-refresh",
-      proxy_url: "https://proxy.test"
-    });
-  });
-  it("throws when no valid token available", async () => {
-    vi.mocked(getValidToken).mockResolvedValueOnce(null);
-    const callbacks = makeCallbacks();
-    await runAgentLoop({
-      message: "No auth",
-      conversationHistory: [],
-      callbacks
-    });
-    expect(callbacks.onError).toHaveBeenCalledOnce();
-    const errorMsg = vi.mocked(callbacks.onError).mock.calls[0][0];
-    expect(errorMsg).toContain("Not logged in");
-  });
-});