@copilotkit/runtime 1.8.12-next.3 → 1.8.12-next.4

package/tests/service-adapters/openai/allowlist-approach.test.ts

@@ -0,0 +1,238 @@
+/**
+ * @jest-environment node
+ */
+
+import { describe, it, expect } from "@jest/globals";
+
+describe("OpenAI Adapter - Allowlist Approach", () => {
+  it("should filter out tool_result messages with no corresponding tool_call ID", () => {
+    // Setup test data
+    const validToolCallIds = new Set<string>(["valid-id-1", "valid-id-2"]);
+
+    // Messages to filter - valid and invalid ones
+    const messages = [
+      { type: "text", role: "user", content: "Hello" },
+      { type: "tool_result", actionExecutionId: "valid-id-1", result: "result1" },
+      { type: "tool_result", actionExecutionId: "invalid-id", result: "invalid" },
+      { type: "tool_result", actionExecutionId: "valid-id-2", result: "result2" },
+      { type: "tool_result", actionExecutionId: "valid-id-1", result: "duplicate" }, // Duplicate ID
+    ];
+
+    // Implement the filtering logic, similar to the adapter
+    const filteredMessages = messages.filter((message) => {
+      if (message.type === "tool_result") {
+        // Skip if there's no corresponding tool_call
+        if (!validToolCallIds.has(message.actionExecutionId)) {
+          return false;
+        }
+
+        // Remove this ID from valid IDs so we don't process duplicates
+        validToolCallIds.delete(message.actionExecutionId);
+      }
+
+      // Keep all non-tool-result messages
+      return true;
+    });
+
+    // Verify results
+    expect(filteredMessages.length).toBe(3); // text + 2 valid tool results (no duplicates or invalid)
+
+    // Valid results should be included
+    expect(
+      filteredMessages.some(
+        (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-1",
+      ),
+    ).toBe(true);
+
+    expect(
+      filteredMessages.some(
+        (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-2",
+      ),
+    ).toBe(true);
+
+    // Invalid result should be excluded
+    expect(
+      filteredMessages.some(
+        (m) => m.type === "tool_result" && m.actionExecutionId === "invalid-id",
+      ),
+    ).toBe(false);
+
+    // Duplicate should be excluded - we used a different approach than Anthropic
+    const validId1Count = filteredMessages.filter(
+      (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-1",
+    ).length;
+
+    expect(validId1Count).toBe(1);
+  });
+
+  it("should maintain correct order of messages when filtering", () => {
+    // Setup test data
+    const validToolCallIds = new Set<string>(["tool-1", "tool-2", "tool-3"]);
+
+    // Test with a complex conversation pattern
+    const messages = [
+      { type: "text", role: "user", content: "Initial message" },
+      { type: "text", role: "assistant", content: "I'll help with that" },
+      { type: "tool_call", id: "tool-1", name: "firstTool" },
+      { type: "tool_result", actionExecutionId: "tool-1", result: "result1" },
+      { type: "text", role: "assistant", content: "Got the first result" },
+      { type: "tool_call", id: "tool-2", name: "secondTool" },
+      { type: "tool_result", actionExecutionId: "tool-2", result: "result2" },
+      { type: "tool_result", actionExecutionId: "invalid-id", result: "invalid-result" },
+      { type: "tool_call", id: "tool-3", name: "thirdTool" },
+      { type: "tool_result", actionExecutionId: "tool-1", result: "duplicate-result" }, // Duplicate
+      { type: "tool_result", actionExecutionId: "tool-3", result: "result3" },
+      { type: "text", role: "user", content: "Final message" },
+    ];
+
+    // Apply OpenAI's filter approach (using filter instead of loop)
+    const filteredMessages = messages.filter((message) => {
+      if (message.type === "tool_result") {
+        // Skip if there's no corresponding tool_call
+        if (!validToolCallIds.has(message.actionExecutionId)) {
+          return false;
+        }
+
+        // Remove this ID from valid IDs so we don't process duplicates
+        validToolCallIds.delete(message.actionExecutionId);
+      }
+
+      // Keep all non-tool-result messages
+      return true;
+    });
+
+    // Verify results
+    expect(filteredMessages.length).toBe(10); // 12 original - 2 filtered out
+
+    // Check that the message order is preserved
+    expect(filteredMessages[0].type).toBe("text"); // Initial user message
+    expect(filteredMessages[0].content).toBe("Initial message");
+    expect(filteredMessages[1].type).toBe("text"); // Assistant response
+    expect(filteredMessages[2].type).toBe("tool_call"); // First tool
+    expect(filteredMessages[3].type).toBe("tool_result"); // First result
+    expect(filteredMessages[3].actionExecutionId).toBe("tool-1");
+    expect(filteredMessages[4].type).toBe("text"); // Assistant comment
+    expect(filteredMessages[5].type).toBe("tool_call"); // Second tool
+    expect(filteredMessages[6].type).toBe("tool_result"); // Second result
+    expect(filteredMessages[6].actionExecutionId).toBe("tool-2");
+    expect(filteredMessages[7].type).toBe("tool_call"); // Third tool
+    expect(filteredMessages[8].type).toBe("tool_result"); // Third result
+    expect(filteredMessages[8].actionExecutionId).toBe("tool-3");
+    expect(filteredMessages[9].type).toBe("text"); // Final user message
+
+    // Each valid tool result should appear exactly once
+    const toolResultCounts = new Map();
+    filteredMessages.forEach((message) => {
+      if (message.type === "tool_result") {
+        const id = message.actionExecutionId;
+        toolResultCounts.set(id, (toolResultCounts.get(id) || 0) + 1);
+      }
+    });
+
+    expect(toolResultCounts.size).toBe(3); // Should have 3 different tool results
+    expect(toolResultCounts.get("tool-1")).toBe(1);
+    expect(toolResultCounts.get("tool-2")).toBe(1);
+    expect(toolResultCounts.get("tool-3")).toBe(1);
+    expect(toolResultCounts.has("invalid-id")).toBe(false);
+  });
+
+  it("should handle empty message array", () => {
+    const validToolCallIds = new Set<string>(["valid-id-1", "valid-id-2"]);
+    const messages = [];
+
+    // Apply OpenAI's filter approach
+    const filteredMessages = messages.filter((message) => {
+      if (message.type === "tool_result") {
+        if (!validToolCallIds.has(message.actionExecutionId)) {
+          return false;
+        }
+        validToolCallIds.delete(message.actionExecutionId);
+      }
+      return true;
+    });
+
+    expect(filteredMessages.length).toBe(0);
+  });
+
+  it("should handle edge cases with mixed message types", () => {
+    // Setup test data with various message types
+    const validToolCallIds = new Set<string>(["valid-id-1"]);
+
+    const messages = [
+      { type: "text", role: "user", content: "Hello" },
+      { type: "image", url: "https://example.com/image.jpg" }, // Non-tool message type
+      { type: "tool_result", actionExecutionId: "valid-id-1", result: "result1" },
+      { type: "custom", data: { key: "value" } }, // Another custom type
+      { type: "tool_result", actionExecutionId: "valid-id-1", result: "duplicate" }, // Duplicate
+      { type: "null", value: null }, // Edge case
+      { type: "undefined" }, // Edge case
+    ];
+
+    // Apply OpenAI's filter approach
+    const filteredMessages = messages.filter((message) => {
+      if (message.type === "tool_result") {
+        if (!validToolCallIds.has(message.actionExecutionId)) {
+          return false;
+        }
+        validToolCallIds.delete(message.actionExecutionId);
+      }
+      return true;
+    });
+
+    // Should have all non-tool_result messages + 1 valid tool_result
+    expect(filteredMessages.length).toBe(6); // 7 original - 1 duplicate
+
+    // Valid tool_result should be included exactly once
+    const toolResults = filteredMessages.filter((m) => m.type === "tool_result");
+    expect(toolResults.length).toBe(1);
+    expect(toolResults[0].actionExecutionId).toBe("valid-id-1");
+
+    // All non-tool_result messages should be preserved
+    expect(filteredMessages.filter((m) => m.type === "text").length).toBe(1);
+    expect(filteredMessages.filter((m) => m.type === "image").length).toBe(1);
+    expect(filteredMessages.filter((m) => m.type === "custom").length).toBe(1);
+    expect(filteredMessages.filter((m) => m.type === "null").length).toBe(1);
+    expect(filteredMessages.filter((m) => m.type === "undefined").length).toBe(1);
+  });
+
+  it("should properly handle multiple duplicate tool results", () => {
+    // Setup test data with multiple duplicates
+    const validToolCallIds = new Set<string>(["tool-1", "tool-2"]);
+
+    const messages = [
+      { type: "text", role: "user", content: "Initial prompt" },
+      { type: "tool_call", id: "tool-1", name: "firstTool" },
+      { type: "tool_result", actionExecutionId: "tool-1", result: "first-result" },
+      { type: "tool_result", actionExecutionId: "tool-1", result: "duplicate-1" }, // Duplicate 1
+      { type: "tool_call", id: "tool-2", name: "secondTool" },
+      { type: "tool_result", actionExecutionId: "tool-1", result: "duplicate-2" }, // Duplicate 2
+      { type: "tool_result", actionExecutionId: "tool-2", result: "second-result" },
+      { type: "tool_result", actionExecutionId: "tool-2", result: "duplicate-3" }, // Duplicate 3
+      { type: "tool_result", actionExecutionId: "tool-1", result: "duplicate-4" }, // Duplicate 4
+    ];
+
+    // Apply OpenAI's filter approach
+    const filteredMessages = messages.filter((message) => {
+      if (message.type === "tool_result") {
+        if (!validToolCallIds.has(message.actionExecutionId)) {
+          return false;
+        }
+        validToolCallIds.delete(message.actionExecutionId);
+      }
+      return true;
+    });
+
+    // Should have text + tool calls + only the first occurrence of each tool result
+    expect(filteredMessages.length).toBe(5);
+
+    // Check that only the first occurrence of each tool result is kept
+    const toolResults = filteredMessages.filter((m) => m.type === "tool_result");
+    expect(toolResults.length).toBe(2);
+
+    expect(toolResults[0].actionExecutionId).toBe("tool-1");
+    expect(toolResults[0].result).toBe("first-result"); // First occurrence should be kept
+
+    expect(toolResults[1].actionExecutionId).toBe("tool-2");
+    expect(toolResults[1].result).toBe("second-result"); // First occurrence should be kept
+  });
+});

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

@@ -0,0 +1,301 @@
+// Mock the modules first
+jest.mock("openai", () => {
+  function MockOpenAI() {}
+  return { default: MockOpenAI };
+});
+
+// Mock the OpenAIAdapter class to avoid the "new OpenAI()" issue
+jest.mock("../../../src/service-adapters/openai/openai-adapter", () => {
+  class MockOpenAIAdapter {
+    _openai: any;
+    model: string = "gpt-4o";
+    keepSystemRole: boolean = false;
+    disableParallelToolCalls: boolean = false;
+
+    constructor() {
+      this._openai = {
+        beta: {
+          chat: {
+            completions: {
+              stream: jest.fn(),
+            },
+          },
+        },
+      };
+    }
+
+    get openai() {
+      return this._openai;
+    }
+
+    async process(request: any) {
+      // Mock implementation that calls our event source but doesn't do the actual processing
+      request.eventSource.stream(async (stream: any) => {
+        stream.complete();
+        return Promise.resolve();
+      });
+
+      return { threadId: request.threadId || "mock-thread-id" };
+    }
+  }
+
+  return { OpenAIAdapter: MockOpenAIAdapter };
+});
+
+// Now import the modules
+import { OpenAIAdapter } from "../../../src/service-adapters/openai/openai-adapter";
+
+// Mock the Message classes since they use TypeGraphQL decorators
+jest.mock("../../../src/graphql/types/converted", () => {
+  // Create minimal implementations of the message classes
+  class MockTextMessage {
+    content: string;
+    role: string;
+    id: string;
+
+    constructor(role: string, content: string) {
+      this.role = role;
+      this.content = content;
+      this.id = "mock-text-" + Math.random().toString(36).substring(7);
+    }
+
+    isTextMessage() {
+      return true;
+    }
+    isImageMessage() {
+      return false;
+    }
+    isActionExecutionMessage() {
+      return false;
+    }
+    isResultMessage() {
+      return false;
+    }
+  }
+
+  class MockActionExecutionMessage {
+    id: string;
+    name: string;
+    arguments: string;
+
+    constructor(params: { id: string; name: string; arguments: string }) {
+      this.id = params.id;
+      this.name = params.name;
+      this.arguments = params.arguments;
+    }
+
+    isTextMessage() {
+      return false;
+    }
+    isImageMessage() {
+      return false;
+    }
+    isActionExecutionMessage() {
+      return true;
+    }
+    isResultMessage() {
+      return false;
+    }
+  }
+
+  class MockResultMessage {
+    actionExecutionId: string;
+    result: string;
+    id: string;
+
+    constructor(params: { actionExecutionId: string; result: string }) {
+      this.actionExecutionId = params.actionExecutionId;
+      this.result = params.result;
+      this.id = "mock-result-" + Math.random().toString(36).substring(7);
+    }
+
+    isTextMessage() {
+      return false;
+    }
+    isImageMessage() {
+      return false;
+    }
+    isActionExecutionMessage() {
+      return false;
+    }
+    isResultMessage() {
+      return true;
+    }
+  }
+
+  return {
+    TextMessage: MockTextMessage,
+    ActionExecutionMessage: MockActionExecutionMessage,
+    ResultMessage: MockResultMessage,
+  };
+});
+
+describe("OpenAIAdapter", () => {
+  let adapter: OpenAIAdapter;
+  let mockEventSource: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    adapter = new OpenAIAdapter();
+    mockEventSource = {
+      stream: jest.fn((callback) => {
+        const mockStream = {
+          sendTextMessageStart: jest.fn(),
+          sendTextMessageContent: jest.fn(),
+          sendTextMessageEnd: jest.fn(),
+          sendActionExecutionStart: jest.fn(),
+          sendActionExecutionArgs: jest.fn(),
+          sendActionExecutionEnd: jest.fn(),
+          complete: jest.fn(),
+        };
+        callback(mockStream);
+      }),
+    };
+  });
+
+  describe("Tool ID handling", () => {
+    it("should filter out tool_result messages that don't have corresponding tool_call IDs", async () => {
+      // Import dynamically after mocking
+      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"}',
+      });
+
+      // Valid result for the above tool
+      const validToolResult = new ResultMessage({
+        actionExecutionId: "valid-tool-id",
+        result: '{"result":"success"}',
+      });
+
+      // Invalid tool result with no corresponding tool execution
+      const invalidToolResult = new ResultMessage({
+        actionExecutionId: "invalid-tool-id",
+        result: '{"result":"failure"}',
+      });
+
+      // Spy on the process method to test it's called properly
+      const processSpy = jest.spyOn(adapter, "process");
+
+      await adapter.process({
+        threadId: "test-thread",
+        model: "gpt-4o",
+        messages: [
+          systemMessage,
+          userMessage,
+          validToolExecution,
+          validToolResult,
+          invalidToolResult,
+        ],
+        actions: [],
+        eventSource: mockEventSource,
+        forwardedParameters: {},
+      });
+
+      // Verify the process method was called
+      expect(processSpy).toHaveBeenCalledTimes(1);
+
+      // Verify the stream function was called
+      expect(mockEventSource.stream).toHaveBeenCalled();
+    });
+
+    it("should handle duplicate tool IDs by only using each once", async () => {
+      // Import dynamically after mocking
+      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"}',
+      });
+
+      const duplicateToolResult = new ResultMessage({
+        actionExecutionId: "tool-id-1",
+        result: '{"result":"duplicate"}',
+      });
+
+      // Spy on the process method to test it's called properly
+      const processSpy = jest.spyOn(adapter, "process");
+
+      await adapter.process({
+        threadId: "test-thread",
+        model: "gpt-4o",
+        messages: [systemMessage, toolExecution, firstToolResult, duplicateToolResult],
+        actions: [],
+        eventSource: mockEventSource,
+        forwardedParameters: {},
+      });
+
+      // Verify the process method was called
+      expect(processSpy).toHaveBeenCalledTimes(1);
+
+      // Verify the stream function was called
+      expect(mockEventSource.stream).toHaveBeenCalled();
+    });
+
+    it("should call the stream method on eventSource", async () => {
+      // Import dynamically after mocking
+      const { TextMessage } = require("../../../src/graphql/types/converted");
+
+      // Create messages
+      const systemMessage = new TextMessage("system", "System message");
+      const userMessage = new TextMessage("user", "User message");
+
+      await adapter.process({
+        threadId: "test-thread",
+        model: "gpt-4o",
+        messages: [systemMessage, userMessage],
+        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");
+
+      // Create a message
+      const systemMessage = new TextMessage("system", "System message");
+
+      const result = await adapter.process({
+        threadId: "test-thread",
+        model: "gpt-4o",
+        messages: [systemMessage],
+        actions: [],
+        eventSource: mockEventSource,
+        forwardedParameters: {},
+      });
+
+      expect(result.threadId).toBe("test-thread");
+    });
+  });
+});

package/tests/setup.jest.ts

@@ -0,0 +1,21 @@
+// Import reflect-metadata to support TypeGraphQL
+import "reflect-metadata";
+
+// Import Jest types and functions
+import {
+  jest,
+  describe,
+  expect,
+  it,
+  test,
+  beforeEach,
+  afterEach,
+  beforeAll,
+  afterAll,
+} from "@jest/globals";
+
+// Suppress console output during tests
+jest.spyOn(console, "log").mockImplementation(() => {});
+jest.spyOn(console, "error").mockImplementation(() => {});
+
+// The global types are already declared in global.d.ts, so we don't need to set globals here

package/tests/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "types": ["node", "jest"],
+    "esModuleInterop": true,
+    "noEmit": true,
+    "allowJs": true
+  },
+  "include": ["./**/*.ts"]
+}

package/tsconfig.json

@@ -8,6 +8,6 @@
     "strict": false,
     "resolveJsonModule": true
   },
-  "include": ["./src/**/*.ts", "./src/**/*.test.ts", "./src/**/__tests__/*"],
+  "include": ["./src/**/*.ts", "./src/**/*.test.ts", "./src/**/__tests__/*", "./tests/**/*.ts"],
   "exclude": ["dist", "build", "node_modules"]
 }