@copilotkit/runtime 1.9.2-next.9 → 1.9.3-next.0

package/tests/service-adapters/anthropic/anthropic-adapter.test.ts

@@ -2,59 +2,21 @@
  * @jest-environment node
  */
 
-// Mock the modules first
-jest.mock("@anthropic-ai/sdk", () => {
-  const mockAnthropic = jest.fn().mockImplementation(() => ({
-    messages: {
-      create: jest.fn().mockResolvedValue({
-        [Symbol.asyncIterator]: () => ({
-          next: async () => ({ done: true, value: undefined }),
-        }),
-      }),
-    },
-  }));
-
-  return { default: mockAnthropic };
-});
-
-// Mock the AnthropicAdapter class to avoid the "new Anthropic()" issue
-jest.mock("../../../src/service-adapters/anthropic/anthropic-adapter", () => {
-  class MockAnthropicAdapter {
-    _anthropic: any;
-    model: string = "claude-3-5-sonnet-latest";
-
-    constructor() {
-      this._anthropic = {
-        messages: {
-          create: jest.fn(),
-        },
-      };
-    }
-
-    get anthropic() {
-      return this._anthropic;
-    }
-
-    async process(request: any) {
-      // Mock implementation that calls our event source but doesn't do the actual processing
-      request.eventSource.stream((stream: any) => {
-        stream.complete();
-      });
-
-      return { threadId: request.threadId || "mock-thread-id" };
-    }
-  }
+import { AnthropicAdapter } from "../../../src/service-adapters/anthropic/anthropic-adapter";
 
-  return { AnthropicAdapter: MockAnthropicAdapter };
+// Mock only the Anthropic SDK, not our adapter
+jest.mock("@anthropic-ai/sdk", () => {
+  return {
+    default: jest.fn().mockImplementation(() => ({
+      messages: {
+        create: jest.fn(),
+      },
+    })),
+  };
 });
 
-// Now import the modules
-import { AnthropicAdapter } from "../../../src/service-adapters/anthropic/anthropic-adapter";
-import { ActionInput } from "../../../src/graphql/inputs/action.input";
-
-// Mock the Message classes since they use TypeGraphQL decorators
+// Mock the message classes
 jest.mock("../../../src/graphql/types/converted", () => {
-  // Create minimal implementations of the message classes
   class MockTextMessage {
     content: string;
     role: string;
@@ -140,10 +102,24 @@ jest.mock("../../../src/graphql/types/converted", () => {
 describe("AnthropicAdapter", () => {
   let adapter: AnthropicAdapter;
   let mockEventSource: any;
+  let mockAnthropicCreate: jest.Mock;
 
   beforeEach(() => {
     jest.clearAllMocks();
-    adapter = new AnthropicAdapter();
+
+    // Create a mock Anthropic instance
+    const mockAnthropic = {
+      messages: {
+        create: jest.fn(),
+      },
+    };
+
+    // Create adapter with the mocked instance
+    adapter = new AnthropicAdapter({ anthropic: mockAnthropic as any });
+
+    // Mock the create method to capture what's being sent
+    mockAnthropicCreate = mockAnthropic.messages.create;
+
     mockEventSource = {
       stream: jest.fn((callback) => {
         const mockStream = {
@@ -156,449 +132,258 @@ describe("AnthropicAdapter", () => {
           complete: jest.fn(),
         };
         callback(mockStream);
+        return Promise.resolve();
       }),
     };
   });
 
-  describe("Tool ID handling", () => {
-    it("should filter out tool_result messages that don't have corresponding tool_use IDs", async () => {
-      // Import dynamically after mocking
+  describe("Deduplication Logic", () => {
+    it("should filter out duplicate result messages", async () => {
       const {
         TextMessage,
         ActionExecutionMessage,
         ResultMessage,
       } = require("../../../src/graphql/types/converted");
 
-      // Create messages including one valid pair and one invalid tool_result
       const systemMessage = new TextMessage("system", "System message");
-      const userMessage = new TextMessage("user", "User message");
+      const userMessage = new TextMessage("user", "Set theme to orange");
 
-      // Valid tool execution message
-      const validToolExecution = new ActionExecutionMessage({
-        id: "valid-tool-id",
-        name: "validTool",
-        arguments: '{"arg":"value"}',
+      // Tool execution
+      const toolExecution = new ActionExecutionMessage({
+        id: "tool-123",
+        name: "setThemeColor",
+        arguments: '{"themeColor": "orange"}',
       });
 
-      // Valid result for the above tool
-      const validToolResult = new ResultMessage({
-        actionExecutionId: "valid-tool-id",
-        result: '{"result":"success"}',
+      // Multiple duplicate results (this was causing the infinite loop)
+      const result1 = new ResultMessage({
+        actionExecutionId: "tool-123",
+        result: "Theme color set to orange",
       });
-
-      // Invalid tool result with no corresponding tool execution
-      const invalidToolResult = new ResultMessage({
-        actionExecutionId: "invalid-tool-id",
-        result: '{"result":"failure"}',
+      const result2 = new ResultMessage({
+        actionExecutionId: "tool-123",
+        result: "Theme color set to orange",
       });
-
-      // Spy on the actual message conversion to verify what's being sent
-      const mockCreate = jest.fn().mockImplementation((params) => {
-        // We'll check what messages are being sent
-        expect(params.messages.length).toBe(4); // Messages passed directly in our mock implementation
-
-        // Verify the valid tool result is included
-        const toolResults = params.messages.filter(
-          (m: any) => m.role === "user" && m.content[0]?.type === "tool_result",
-        );
-        expect(toolResults.length).toBe(1);
-        expect(toolResults[0].content[0].tool_use_id).toBe("valid-tool-id");
-
-        return {
-          [Symbol.asyncIterator]: () => ({
-            next: async () => ({ done: true, value: undefined }),
-          }),
-        };
+      const result3 = new ResultMessage({
+        actionExecutionId: "tool-123",
+        result: "Theme color set to orange",
       });
 
-      // Mock the anthropic property to use our mock create function
-      const anthropicMock = {
-        messages: { create: mockCreate },
-      };
+      // Mock Anthropic to return empty stream (simulating the original problem)
+      mockAnthropicCreate.mockResolvedValue({
+        [Symbol.asyncIterator]: async function* () {
+          // Empty stream - no content from Anthropic
+        },
+      });
 
-      // Use Object.defineProperty to mock the anthropic getter
-      Object.defineProperty(adapter, "_anthropic", {
-        value: anthropicMock,
-        writable: true,
+      await adapter.process({
+        threadId: "test-thread",
+        model: "claude-3-5-sonnet-latest",
+        messages: [systemMessage, userMessage, toolExecution, result1, result2, result3],
+        actions: [],
+        eventSource: mockEventSource,
+        forwardedParameters: {},
       });
 
-      // Ensure process method will call our mock
-      jest.spyOn(adapter, "process").mockImplementation(async (request) => {
-        const { eventSource } = request;
-
-        // Direct call to the mocked create method
-        mockCreate({
-          messages: [
-            // Include the actual messages for better testing
-            { role: "assistant", content: [{ type: "text", text: "System message" }] },
-            { role: "user", content: [{ type: "text", text: "User message" }] },
-            {
+      // Check that only one result message was sent to Anthropic
+      expect(mockAnthropicCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          messages: expect.arrayContaining([
+            expect.objectContaining({
+              role: "user",
+              content: [{ type: "text", text: "Set theme to orange" }],
+            }),
+            expect.objectContaining({
               role: "assistant",
               content: [
-                {
-                  id: "valid-tool-id",
+                expect.objectContaining({
                   type: "tool_use",
-                  name: "validTool",
-                  input: '{"arg":"value"}',
-                },
+                  id: "tool-123",
+                  name: "setThemeColor",
+                }),
               ],
-            },
-            {
+            }),
+            expect.objectContaining({
               role: "user",
               content: [
-                {
+                expect.objectContaining({
                   type: "tool_result",
-                  content: '{"result":"success"}',
-                  tool_use_id: "valid-tool-id",
-                },
+                  content: "Theme color set to orange",
+                  tool_use_id: "tool-123",
+                }),
               ],
-            },
-          ],
-        });
-
-        // Call the event source with an async callback that returns a Promise
-        eventSource.stream(async (stream: any) => {
-          stream.complete();
-          return Promise.resolve();
-        });
-
-        return { threadId: request.threadId || "mock-thread-id" };
-      });
+            }),
+          ]),
+        }),
+      );
 
-      await adapter.process({
-        threadId: "test-thread",
-        model: "claude-3-5-sonnet-latest",
-        messages: [
-          systemMessage,
-          userMessage,
-          validToolExecution,
-          validToolResult,
-          invalidToolResult,
-        ],
-        actions: [],
-        eventSource: mockEventSource,
-        forwardedParameters: {},
-      });
+      // Verify only 3 messages sent (user, assistant tool_use, user tool_result) - no duplicates
+      const sentMessages = mockAnthropicCreate.mock.calls[0][0].messages;
+      expect(sentMessages).toHaveLength(3);
 
-      // Verify the stream function was called
-      expect(mockEventSource.stream).toHaveBeenCalled();
-      expect(mockCreate).toHaveBeenCalled();
+      // Count tool_result messages - should be only 1
+      const toolResults = sentMessages.filter(
+        (msg: any) => msg.role === "user" && msg.content.some((c: any) => c.type === "tool_result"),
+      );
+      expect(toolResults).toHaveLength(1);
     });
 
-    it("should handle duplicate tool IDs by only using each once", async () => {
-      // Import dynamically after mocking
+    it("should filter out invalid result messages without corresponding tool_use", async () => {
       const {
         TextMessage,
         ActionExecutionMessage,
         ResultMessage,
       } = require("../../../src/graphql/types/converted");
 
-      // Create messages including duplicate tool results for the same ID
       const systemMessage = new TextMessage("system", "System message");
 
-      // Valid tool execution message
-      const toolExecution = new ActionExecutionMessage({
-        id: "tool-id-1",
-        name: "someTool",
-        arguments: '{"arg":"value"}',
-      });
-
-      // Two results for the same tool ID
-      const firstToolResult = new ResultMessage({
-        actionExecutionId: "tool-id-1",
-        result: '{"result":"first"}',
+      // Valid tool execution
+      const validTool = new ActionExecutionMessage({
+        id: "valid-tool",
+        name: "validAction",
+        arguments: "{}",
       });
-
-      const duplicateToolResult = new ResultMessage({
-        actionExecutionId: "tool-id-1",
-        result: '{"result":"duplicate"}',
-      });
-
-      // Spy on the message create call
-      const mockCreate = jest.fn().mockImplementation((params) => {
-        // Verify only one tool result is included despite two being provided
-        const toolResults = params.messages.filter(
-          (m: any) => m.role === "user" && m.content[0]?.type === "tool_result",
-        );
-        expect(toolResults.length).toBe(1);
-        expect(toolResults[0].content[0].tool_use_id).toBe("tool-id-1");
-
-        return {
-          [Symbol.asyncIterator]: () => ({
-            next: async () => ({ done: true, value: undefined }),
-          }),
-        };
+      const validResult = new ResultMessage({
+        actionExecutionId: "valid-tool",
+        result: "Valid result",
       });
 
-      // Mock the anthropic property to use our mock create function
-      const anthropicMock = {
-        messages: { create: mockCreate },
-      };
-
-      // Use Object.defineProperty to mock the anthropic getter
-      Object.defineProperty(adapter, "_anthropic", {
-        value: anthropicMock,
-        writable: true,
+      // Invalid result with no corresponding tool_use
+      const invalidResult = new ResultMessage({
+        actionExecutionId: "nonexistent-tool",
+        result: "Invalid result",
       });
 
-      // Ensure process method will call our mock
-      jest.spyOn(adapter, "process").mockImplementation(async (request) => {
-        const { eventSource } = request;
-
-        // Direct call to the mocked create method
-        mockCreate({
-          messages: [
-            { role: "assistant", content: [{ type: "text", text: "System message" }] },
-            {
-              role: "assistant",
-              content: [
-                { id: "tool-id-1", type: "tool_use", name: "someTool", input: '{"arg":"value"}' },
-              ],
-            },
-            {
-              role: "user",
-              content: [
-                { type: "tool_result", content: '{"result":"first"}', tool_use_id: "tool-id-1" },
-              ],
-            },
-          ],
-        });
-
-        // Call the event source with an async callback that returns a Promise
-        eventSource.stream(async (stream: any) => {
-          stream.complete();
-          return Promise.resolve();
-        });
-
-        return { threadId: request.threadId || "mock-thread-id" };
+      mockAnthropicCreate.mockResolvedValue({
+        [Symbol.asyncIterator]: async function* () {},
       });
 
       await adapter.process({
         threadId: "test-thread",
-        model: "claude-3-5-sonnet-latest",
-        messages: [systemMessage, toolExecution, firstToolResult, duplicateToolResult],
+        messages: [systemMessage, validTool, validResult, invalidResult],
         actions: [],
         eventSource: mockEventSource,
         forwardedParameters: {},
       });
 
-      expect(mockCreate).toHaveBeenCalled();
+      const sentMessages = mockAnthropicCreate.mock.calls[0][0].messages;
+
+      // Should only include the valid tool result
+      const toolResults = sentMessages.filter(
+        (msg: any) => msg.role === "user" && msg.content.some((c: any) => c.type === "tool_result"),
+      );
+      expect(toolResults).toHaveLength(1);
+      expect(toolResults[0].content[0].tool_use_id).toBe("valid-tool");
     });
+  });
 
-    it("should correctly handle complex message patterns with multiple tool calls and results", async () => {
-      // Import dynamically after mocking
+  describe("Fallback Response Logic", () => {
+    it("should generate contextual fallback when Anthropic returns no content", async () => {
       const {
         TextMessage,
         ActionExecutionMessage,
         ResultMessage,
       } = require("../../../src/graphql/types/converted");
 
-      // Setup a complex conversation with multiple tools and results, including duplicates and invalids
       const systemMessage = new TextMessage("system", "System message");
-      const userMessage = new TextMessage("user", "Initial user message");
+      const userMessage = new TextMessage("user", "Set theme to orange");
 
-      // First tool execution and result (valid pair)
-      const toolExecution1 = new ActionExecutionMessage({
-        id: "tool-id-1",
-        name: "firstTool",
-        arguments: '{"param":"value1"}',
-      });
-      const toolResult1 = new ResultMessage({
-        actionExecutionId: "tool-id-1",
-        result: '{"success":true,"data":"result1"}',
-      });
-
-      // Assistant response after first tool
-      const assistantResponse = new TextMessage("assistant", "I got the first result");
-
-      // Second and third tool executions
-      const toolExecution2 = new ActionExecutionMessage({
-        id: "tool-id-2",
-        name: "secondTool",
-        arguments: '{"param":"value2"}',
-      });
-      const toolExecution3 = new ActionExecutionMessage({
-        id: "tool-id-3",
-        name: "thirdTool",
-        arguments: '{"param":"value3"}',
-      });
-
-      // Results for second and third tools
-      const toolResult2 = new ResultMessage({
-        actionExecutionId: "tool-id-2",
-        result: '{"success":true,"data":"result2"}',
-      });
-      const toolResult3 = new ResultMessage({
-        actionExecutionId: "tool-id-3",
-        result: '{"success":true,"data":"result3"}',
-      });
-
-      // Invalid result (no corresponding execution)
-      const invalidToolResult = new ResultMessage({
-        actionExecutionId: "invalid-tool-id",
-        result: '{"success":false,"error":"No such tool"}',
+      const toolExecution = new ActionExecutionMessage({
+        id: "tool-123",
+        name: "setThemeColor",
+        arguments: '{"themeColor": "orange"}',
       });
 
-      // Duplicate result for first tool
-      const duplicateToolResult1 = new ResultMessage({
-        actionExecutionId: "tool-id-1",
-        result: '{"success":true,"data":"duplicate-result1"}',
+      const toolResult = new ResultMessage({
+        actionExecutionId: "tool-123",
+        result: "Theme color set to orange",
       });
 
-      // User follow-up
-      const userFollowUp = new TextMessage("user", "Follow-up question");
-
-      // Fourth tool execution with two competing results
-      const toolExecution4 = new ActionExecutionMessage({
-        id: "tool-id-4",
-        name: "fourthTool",
-        arguments: '{"param":"value4"}',
-      });
-      const toolResult4a = new ResultMessage({
-        actionExecutionId: "tool-id-4",
-        result: '{"success":true,"data":"result4-version-a"}',
-      });
-      const toolResult4b = new ResultMessage({
-        actionExecutionId: "tool-id-4",
-        result: '{"success":true,"data":"result4-version-b"}',
-      });
-
-      // Spy on the message create call
-      const mockCreate = jest.fn().mockImplementation((params) => {
-        // Return a valid mock response
-        return {
-          [Symbol.asyncIterator]: () => ({
-            next: async () => ({ done: true, value: undefined }),
-          }),
-        };
+      // Mock Anthropic to return empty stream
+      mockAnthropicCreate.mockResolvedValue({
+        [Symbol.asyncIterator]: async function* () {
+          // No content blocks - simulates Anthropic not responding
+        },
       });
 
-      // Mock the anthropic property to use our mock create function
-      const anthropicMock = {
-        messages: { create: mockCreate },
+      const mockStream = {
+        sendTextMessageStart: jest.fn(),
+        sendTextMessageContent: jest.fn(),
+        sendTextMessageEnd: jest.fn(),
+        complete: jest.fn(),
       };
 
-      // Use Object.defineProperty to mock the anthropic getter
-      Object.defineProperty(adapter, "_anthropic", {
-        value: anthropicMock,
-        writable: true,
-      });
-
-      // Ensure process method will call our mock
-      jest.spyOn(adapter, "process").mockImplementation(async (request) => {
-        const { eventSource } = request;
-
-        // Direct call to the mocked create method to ensure it's called
-        mockCreate({
-          messages: [{ role: "user", content: [{ type: "text", text: "Mock message" }] }],
-        });
-
-        // Call the event source with an async callback that returns a Promise
-        eventSource.stream(async (stream: any) => {
-          stream.complete();
-          return Promise.resolve();
-        });
-
-        return { threadId: request.threadId || "mock-thread-id" };
+      mockEventSource.stream.mockImplementation((callback) => {
+        callback(mockStream);
+        return Promise.resolve();
       });
 
-      // Process the complex message sequence
       await adapter.process({
         threadId: "test-thread",
-        model: "claude-3-5-sonnet-latest",
-        messages: [
-          systemMessage,
-          userMessage,
-          toolExecution1,
-          toolResult1,
-          assistantResponse,
-          toolExecution2,
-          toolExecution3,
-          toolResult2,
-          toolResult3,
-          invalidToolResult,
-          duplicateToolResult1,
-          userFollowUp,
-          toolExecution4,
-          toolResult4a,
-          toolResult4b,
-        ],
+        messages: [systemMessage, userMessage, toolExecution, toolResult],
         actions: [],
         eventSource: mockEventSource,
         forwardedParameters: {},
       });
 
-      // Verify our mock was called
-      expect(mockCreate).toHaveBeenCalled();
+      // Should generate fallback response with the tool result content
+      expect(mockStream.sendTextMessageStart).toHaveBeenCalled();
+      expect(mockStream.sendTextMessageContent).toHaveBeenCalledWith({
+        messageId: expect.any(String),
+        content: "Theme color set to orange", // Uses the actual result content
+      });
+      expect(mockStream.sendTextMessageEnd).toHaveBeenCalled();
     });
 
-    it("should call the stream method on eventSource", async () => {
-      // Import dynamically after mocking
+    it("should use generic fallback when no tool result content available", async () => {
       const {
         TextMessage,
         ActionExecutionMessage,
         ResultMessage,
       } = require("../../../src/graphql/types/converted");
 
-      // Create messages including one valid pair and one invalid tool_result
       const systemMessage = new TextMessage("system", "System message");
-      const userMessage = new TextMessage("user", "User message");
 
-      // Valid tool execution message
-      const validToolExecution = new ActionExecutionMessage({
-        id: "valid-tool-id",
-        name: "validTool",
-        arguments: '{"arg":"value"}',
+      const toolExecution = new ActionExecutionMessage({
+        id: "tool-123",
+        name: "someAction",
+        arguments: "{}",
       });
 
-      // Valid result for the above tool
-      const validToolResult = new ResultMessage({
-        actionExecutionId: "valid-tool-id",
-        result: '{"result":"success"}',
+      const toolResult = new ResultMessage({
+        actionExecutionId: "tool-123",
+        result: "", // Empty result
       });
 
-      // Invalid tool result with no corresponding tool execution
-      const invalidToolResult = new ResultMessage({
-        actionExecutionId: "invalid-tool-id",
-        result: '{"result":"failure"}',
+      mockAnthropicCreate.mockResolvedValue({
+        [Symbol.asyncIterator]: async function* () {},
       });
 
-      await adapter.process({
-        threadId: "test-thread",
-        model: "claude-3-5-sonnet-latest",
-        messages: [
-          systemMessage,
-          userMessage,
-          validToolExecution,
-          validToolResult,
-          invalidToolResult,
-        ],
-        actions: [],
-        eventSource: mockEventSource,
-        forwardedParameters: {},
-      });
-
-      // Verify the stream function was called
-      expect(mockEventSource.stream).toHaveBeenCalled();
-    });
-
-    it("should return the provided threadId", async () => {
-      // Import dynamically after mocking
-      const { TextMessage } = require("../../../src/graphql/types/converted");
+      const mockStream = {
+        sendTextMessageStart: jest.fn(),
+        sendTextMessageContent: jest.fn(),
+        sendTextMessageEnd: jest.fn(),
+        complete: jest.fn(),
+      };
 
-      // Create messages including duplicate tool results for the same ID
-      const systemMessage = new TextMessage("system", "System message");
+      mockEventSource.stream.mockImplementation((callback) => {
+        callback(mockStream);
+        return Promise.resolve();
+      });
 
-      const result = await adapter.process({
+      await adapter.process({
         threadId: "test-thread",
-        model: "claude-3-5-sonnet-latest",
-        messages: [systemMessage],
+        messages: [systemMessage, toolExecution, toolResult],
         actions: [],
         eventSource: mockEventSource,
         forwardedParameters: {},
       });
 
-      expect(result.threadId).toBe("test-thread");
+      // Should use generic fallback
+      expect(mockStream.sendTextMessageContent).toHaveBeenCalledWith({
+        messageId: expect.any(String),
+        content: "Task completed successfully.",
+      });
     });
   });
 });