@worktango/ai-assistant 0.0.26 → 0.0.28

package/src/frontend/tools/useAiAssistantSession.test.ts

@@ -1,768 +0,0 @@
-import { ChatData, SupportedTextModel } from "@kazoohr/llm/types";
-import { act, renderHook } from "@kazoohr/test";
-
-import {
-  ChatItemWithTimestamp,
-  useAiAssistantSession,
-} from "./useAiAssistantSession";
-
-const mockFetch = jest.fn();
-global.fetch = mockFetch;
-
-const mockDecode = jest.fn();
-class MockTextDecoder {
-  decode(input: Uint8Array): string {
-    return mockDecode(input);
-  }
-}
-global.TextDecoder = MockTextDecoder as any;
-
-describe("useAiAssistantSession", () => {
-  let mockReader: { read: jest.Mock };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockDecode.mockClear();
-
-    mockReader = {
-      read: jest.fn(),
-    };
-
-    mockFetch.mockResolvedValue({
-      ok: true,
-      body: {
-        getReader: () => mockReader,
-      },
-    });
-  });
-
-  it("initializes with default values", () => {
-    const { result } = renderHook(() => useAiAssistantSession());
-
-    expect(result.current.isLoading).toBe(false);
-    expect(result.current.messages).toEqual([]);
-    expect(result.current.debugInfo).toEqual([]);
-  });
-
-  it("initializes with provided messages", () => {
-    const initialMessages: ChatItemWithTimestamp[] = [
-      {
-        role: "user",
-        parts: [{ type: "text", text: "Hello" }],
-        timestamp: new Date(),
-      },
-    ];
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({ initialMessages })
-    );
-
-    expect(result.current.messages).toEqual(initialMessages);
-  });
-
-  it("adds a message correctly", () => {
-    const { result } = renderHook(() => useAiAssistantSession());
-
-    const newMessage: ChatItemWithTimestamp = {
-      role: "user",
-      parts: [{ type: "text", text: "Test message" }],
-      timestamp: new Date(),
-    };
-
-    act(() => {
-      result.current.addMessage(newMessage);
-    });
-
-    expect(result.current.messages).toEqual([newMessage]);
-  });
-
-  it("sends a user message and processes the response stream", async () => {
-    const onBeforeLlmCall = jest.fn();
-    const onAfterLlmCall = jest.fn();
-    const onChunkAdded = jest.fn();
-
-    const streamedChunks: ChatData[] = [
-      { type: "text", text: "Hello" },
-      { type: "text", text: " world" },
-      { type: "toolCall", toolName: "testTool", args: { test: true } },
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        onBeforeLlmCall,
-        onAfterLlmCall,
-        onChunkAdded,
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(mockFetch).toHaveBeenCalledWith("/api/api-ai-assistant/v1/chat", {
-      method: "POST",
-      body: expect.any(String),
-      credentials: "include",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "text/event-stream",
-      },
-    });
-
-    expect(onBeforeLlmCall).toHaveBeenCalled();
-    expect(onAfterLlmCall).toHaveBeenCalled();
-    expect(onChunkAdded).toHaveBeenCalledTimes(3); // Once for each chunk
-
-    expect(result.current.messages).toHaveLength(3);
-    expect(result.current.messages[0]).toEqual({
-      role: "user",
-      parts: [{ type: "text", text: "Test message" }],
-      timestamp: expect.any(Date),
-    });
-    expect(result.current.messages[1]).toEqual({
-      role: "model",
-      parts: [
-        { type: "toolCall", toolName: "testTool", args: { test: true } },
-        { type: "text", text: "Hello world" },
-      ],
-      timestamp: expect.any(Date),
-    });
-  });
-
-  it("handles fetch errors gracefully", async () => {
-    const onError = jest.fn();
-    mockFetch.mockRejectedValue(new Error("Network error"));
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        onError,
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(onError).toHaveBeenCalledWith(expect.any(Error));
-    expect(result.current.messages).toHaveLength(0);
-  });
-
-  it("handles stream processing errors", async () => {
-    const onError = jest.fn();
-    mockReader.read.mockRejectedValue(new Error("Stream error"));
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        onError,
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(onError).toHaveBeenCalledWith(expect.any(Error));
-  });
-
-  it("respects model and temperature settings", async () => {
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        model: "large" as SupportedTextModel,
-        temperature: 0.7,
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    const requestBody = JSON.parse(mockFetch.mock.calls[0][1].body);
-    expect(requestBody.model).toBe("large");
-    expect(requestBody.temperature).toBe(0.7);
-  });
-
-  it("handles non-ok fetch response", async () => {
-    mockFetch.mockResolvedValue({
-      ok: false,
-      status: 500,
-    });
-
-    const { result } = renderHook(() => useAiAssistantSession());
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // Should only contain the user message
-    expect(result.current.messages).toHaveLength(0);
-  });
-
-  it("handles onBeforeLlmCall error", async () => {
-    const onError = jest.fn();
-    const onBeforeLlmCall = jest.fn().mockImplementation(() => {
-      throw new Error("Before LLM call error");
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        onBeforeLlmCall,
-        onError,
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(onBeforeLlmCall).toHaveBeenCalled();
-    expect(result.current.debugInfo).toContainEqual(
-      expect.objectContaining({
-        level: "error",
-        message: "Error calling onBeforeLlmCall",
-      })
-    );
-  });
-
-  it("handles onAfterLlmCall error", async () => {
-    const onError = jest.fn();
-    const onAfterLlmCall = jest.fn().mockImplementation(() => {
-      throw new Error("After LLM call error");
-    });
-
-    mockReader.read.mockResolvedValue({ done: true });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        onAfterLlmCall,
-        onError,
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(onAfterLlmCall).toHaveBeenCalled();
-    expect(result.current.debugInfo).toContainEqual(
-      expect.objectContaining({
-        level: "error",
-        message: "Error calling onAfterLlmCall",
-      })
-    );
-  });
-
-  it("handles setMessages directly", () => {
-    const { result } = renderHook(() => useAiAssistantSession());
-
-    const newMessages: ChatItemWithTimestamp[] = [
-      {
-        role: "user",
-        parts: [{ type: "text", text: "New message" }],
-        timestamp: new Date(),
-      },
-    ];
-
-    act(() => {
-      result.current.setMessages(newMessages);
-    });
-
-    expect(result.current.messages).toEqual(newMessages);
-  });
-
-  it("handles multiple tool calls in response", async () => {
-    const streamedChunks: ChatData[] = [
-      { type: "toolCall", toolName: "tool1", args: { test: 1 } },
-      { type: "toolCall", toolName: "tool2", args: { test: 2 } },
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() => useAiAssistantSession());
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // Verify that all tool calls are in the message
-    expect(result.current.messages[1].parts).toEqual(streamedChunks);
-  });
-
-  it("handles mixed text and tool calls in response", async () => {
-    const streamedChunks: ChatData[] = [
-      { type: "text", text: "Hello" },
-      { type: "toolCall", toolName: "tool1", args: { test: 1 } },
-      { type: "text", text: " world" },
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() => useAiAssistantSession());
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // Verify that tool calls and concatenated text are in the message
-    expect(result.current.messages[1].parts).toEqual([
-      { type: "toolCall", toolName: "tool1", args: { test: 1 } },
-      { type: "text", text: "Hello world" },
-    ]);
-  });
-
-  it("handles response with no reader available", async () => {
-    const onError = jest.fn();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      body: {
-        getReader: () => undefined,
-      },
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        onError,
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(onError).toHaveBeenCalledWith(
-      new Error("Unexpected client error. Response body reader not available.")
-    );
-    expect(result.current.messages).toHaveLength(0);
-  });
-
-  it("handles response with null body", async () => {
-    const onError = jest.fn();
-    mockFetch.mockResolvedValue({
-      ok: true,
-      body: null,
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        onError,
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(onError).toHaveBeenCalledWith(
-      new Error("Unexpected client error. Response body reader not available.")
-    );
-    expect(result.current.messages).toHaveLength(0);
-  });
-
-  it("handles unknown chunk type in response", async () => {
-    const streamedChunks = [
-      { type: "text", text: "Hello" } as ChatData,
-      {
-        type: "toolResult",
-        toolName: "unknownTool",
-        result: { test: true },
-      } as ChatData,
-      { type: "text", text: " world" } as ChatData,
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() => useAiAssistantSession());
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // Unknown chunk type should be ignored, only text chunks should be concatenated
-    expect(result.current.messages[1].parts).toEqual([
-      { type: "text", text: "Hello world" },
-    ]);
-  });
-
-  it("handles tool calls and executes them", async () => {
-    const mockTool = {
-      name: "testTool",
-      description: "A test tool",
-      fulfill: jest.fn().mockResolvedValue({ success: true }),
-    };
-
-    const streamedChunks = [
-      {
-        type: "toolCall",
-        toolName: "testTool",
-        args: { test: true },
-      } as ChatData,
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        tools: [mockTool],
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(mockTool.fulfill).toHaveBeenCalledWith({ test: true });
-    expect(result.current.messages[2]).toEqual({
-      role: "tool",
-      parts: [
-        {
-          type: "toolResult",
-          toolName: "testTool",
-          result: { success: true },
-        },
-      ],
-    });
-  });
-
-  it("handles tool not found scenario", async () => {
-    const onError = jest.fn();
-    const streamedChunks = [
-      {
-        type: "toolCall",
-        toolName: "nonExistentTool",
-        args: { test: true },
-      } as ChatData,
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        onError,
-        tools: [],
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    expect(onError).toHaveBeenCalledWith(
-      new Error("Tool nonExistentTool not found")
-    );
-  });
-
-  it("protects against infinite loops in stream reading", async () => {
-    const streamedChunks = [{ type: "text", text: "test" } as ChatData];
-
-    // Mock an implementation that never returns done: true
-    mockReader.read.mockImplementation(() => {
-      mockDecode.mockReturnValueOnce(JSON.stringify(streamedChunks[0]));
-      return Promise.resolve({ done: false, value: new Uint8Array() });
-    });
-
-    const { result } = renderHook(() => useAiAssistantSession());
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // The loop should have broken after 1,000,000 iterations
-    expect(mockReader.read).toHaveBeenCalledTimes(1_000_000);
-  });
-
-  it("initializes messages with timestamps when not provided", () => {
-    const initialMessages = [
-      {
-        role: "user" as const,
-        parts: [{ type: "text" as const, text: "Hello" }],
-      },
-    ];
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({ initialMessages })
-    );
-
-    expect(result.current.messages[0]).toEqual({
-      ...initialMessages[0],
-      timestamp: expect.any(Date),
-    });
-  });
-
-  it("handles tool execution and result processing", async () => {
-    const mockTool = {
-      name: "testTool",
-      description: "A test tool",
-      fulfill: jest.fn().mockResolvedValue({ success: true }),
-    };
-
-    const streamedChunks = [
-      {
-        type: "toolCall",
-        toolName: "testTool",
-        args: { test: true },
-      } as ChatData,
-      { type: "text", text: "Some text" } as ChatData,
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        tools: [mockTool],
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // Verify tool execution
-    expect(mockTool.fulfill).toHaveBeenCalledWith({ test: true });
-
-    // Verify messages are updated correctly
-    expect(result.current.messages).toHaveLength(3); // User message, model response, and tool result
-    expect(result.current.messages[2]).toEqual({
-      role: "tool",
-      parts: [
-        {
-          type: "toolResult",
-          toolName: "testTool",
-          result: { success: true },
-        },
-      ],
-    });
-  });
-
-  it("handles multiple tools execution in sequence", async () => {
-    const mockTool1 = {
-      name: "tool1",
-      description: "First test tool",
-      fulfill: jest.fn().mockResolvedValue({ result: 1 }),
-    };
-
-    const mockTool2 = {
-      name: "tool2",
-      description: "Second test tool",
-      fulfill: jest.fn().mockResolvedValue({ result: 2 }),
-    };
-
-    const streamedChunks = [
-      { type: "toolCall", toolName: "tool1", args: { test: 1 } } as ChatData,
-      { type: "toolCall", toolName: "tool2", args: { test: 2 } } as ChatData,
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        tools: [mockTool1, mockTool2],
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // Verify both tools were executed
-    expect(mockTool1.fulfill).toHaveBeenCalledWith({ test: 1 });
-    expect(mockTool2.fulfill).toHaveBeenCalledWith({ test: 2 });
-
-    // Verify messages contain both tool results
-    expect(result.current.messages[2]).toEqual({
-      role: "tool",
-      parts: [
-        {
-          type: "toolResult",
-          toolName: "tool1",
-          result: { result: 1 },
-        },
-        {
-          type: "toolResult",
-          toolName: "tool2",
-          result: { result: 2 },
-        },
-      ],
-    });
-  });
-
-  it("handles tool execution with empty tool results", async () => {
-    const mockTool = {
-      name: "testTool",
-      description: "A test tool",
-      fulfill: jest.fn().mockResolvedValue(undefined),
-    };
-
-    const streamedChunks = [
-      {
-        type: "toolCall",
-        toolName: "testTool",
-        args: { test: true },
-      } as ChatData,
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        tools: [mockTool],
-      })
-    );
-
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // Verify tool execution
-    expect(mockTool.fulfill).toHaveBeenCalledWith({ test: true });
-
-    // Verify messages are updated correctly
-    expect(result.current.messages[2]).toEqual({
-      role: "tool",
-      parts: [
-        {
-          type: "toolResult",
-          toolName: "testTool",
-          result: undefined,
-        },
-      ],
-    });
-  });
-
-  it("handles empty tool calls", async () => {
-    const mockTool = {
-      name: "testTool",
-      description: "A test tool",
-      fulfill: jest.fn(),
-    };
-
-    const streamedChunks = [
-      {
-        type: "toolCall",
-        toolName: "testTool",
-        args: { test: true },
-      } as ChatData,
-    ];
-
-    let chunkIndex = 0;
-    mockReader.read.mockImplementation(() => {
-      if (chunkIndex < streamedChunks.length) {
-        mockDecode.mockReturnValueOnce(
-          JSON.stringify(streamedChunks[chunkIndex])
-        );
-        chunkIndex++;
-        return Promise.resolve({ done: false, value: new Uint8Array() });
-      }
-      return Promise.resolve({ done: true });
-    });
-
-    const { result } = renderHook(() =>
-      useAiAssistantSession({
-        tools: [mockTool],
-      })
-    );
-
-    // Send a message that will trigger tool calls
-    await act(async () => {
-      await result.current.sendUserMessage("Test message");
-    });
-
-    // Send another message to verify tool calls are cleared
-    mockReader.read.mockImplementation(() => Promise.resolve({ done: true }));
-    await act(async () => {
-      await result.current.sendUserMessage("Another message");
-    });
-
-    expect(mockTool.fulfill).toHaveBeenCalledTimes(1);
-  });
-});