@copilotkitnext/core 0.0.1

package/src/__tests__/core-full.test.ts

@@ -0,0 +1,320 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { CopilotKitCore } from "../core";
+import { FrontendTool } from "../types";
+import {
+  MockAgent,
+  createMessage,
+  createAssistantMessage,
+  createToolCallMessage,
+  createToolResultMessage,
+  createTool,
+  createMultipleToolCallsMessage,
+} from "./test-utils";
+
+describe("CopilotKitCore.runAgent - Full Test Suite", () => {
+  let copilotKitCore: CopilotKitCore;
+
+  beforeEach(() => {
+    copilotKitCore = new CopilotKitCore({});
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("Tests that should pass", () => {
+    it("TEST 1: should run agent without tools", async () => {
+      const messages = [
+        createMessage({ content: "Hello" }),
+        createAssistantMessage({ content: "Hi there!" }),
+      ];
+      const agent = new MockAgent({ newMessages: messages });
+
+      const result = await copilotKitCore.runAgent({ agent: agent as any });
+
+      expect(result.newMessages).toEqual(messages);
+      expect(agent.runAgentCalls).toHaveLength(1);
+    });
+
+    it("TEST 2: should execute tool with string result", async () => {
+      const toolName = "stringTool";
+      const tool = createTool({
+        name: toolName,
+        handler: vi.fn(async () => "String result"),
+        followUp: false,
+      });
+      copilotKitCore.addTool(tool);
+
+      const message = createToolCallMessage(toolName, { input: "test" });
+      const agent = new MockAgent({ newMessages: [message] });
+
+      await copilotKitCore.runAgent({ agent: agent as any });
+
+      expect(tool.handler).toHaveBeenCalledWith({ input: "test" });
+      expect(agent.messages.some(m => m.role === "tool")).toBe(true);
+    });
+
+    it("TEST 3: should skip tool when not found", async () => {
+      const message = createToolCallMessage("nonExistentTool");
+      const agent = new MockAgent({ newMessages: [message] });
+
+      await copilotKitCore.runAgent({ agent: agent as any });
+
+      expect(agent.messages.filter(m => m.role === "tool")).toHaveLength(0);
+    });
+  });
+
+  describe("Tests that might reveal problems", () => {
+    it("TEST 4: should handle follow-up with recursion", async () => {
+      console.log("TEST 4: Starting follow-up test");
+      const tool = createTool({
+        name: "followUpTool",
+        handler: vi.fn(async () => "Result"),
+        followUp: true, // This should trigger recursion
+      });
+      copilotKitCore.addTool(tool);
+
+      const message = createToolCallMessage("followUpTool");
+      const followUpMessage = createAssistantMessage({ content: "Follow-up response" });
+      
+      const agent = new MockAgent({ newMessages: [message] });
+      let callCount = 0;
+      agent.runAgentCallback = () => {
+        callCount++;
+        console.log(`TEST 4: Call count: ${callCount}`);
+        if (callCount === 2) {
+          agent.setNewMessages([followUpMessage]);
+        }
+      };
+
+      try {
+        const result = await copilotKitCore.runAgent({ agent: agent as any });
+        console.log(`TEST 4: Success - calls: ${agent.runAgentCalls.length}`);
+        expect(agent.runAgentCalls).toHaveLength(2);
+        expect(result.newMessages).toContain(followUpMessage);
+      } catch (error) {
+        console.log(`TEST 4: Error - ${error}`);
+        throw error;
+      }
+    });
+
+    it("TEST 5: should handle multiple tools with at least one follow-up", async () => {
+      console.log("TEST 5: Starting multiple tools test");
+      const tool1 = createTool({
+        name: "tool1",
+        handler: vi.fn(async () => "Result 1"),
+        followUp: false,
+      });
+      const tool2 = createTool({
+        name: "tool2",
+        handler: vi.fn(async () => "Result 2"),
+        followUp: true, // This one needs follow-up
+      });
+      copilotKitCore.addTool(tool1);
+      copilotKitCore.addTool(tool2);
+
+      const message = createMultipleToolCallsMessage([
+        { name: "tool1" },
+        { name: "tool2" },
+      ]);
+      
+      const agent = new MockAgent({ newMessages: [message] });
+      let callCount = 0;
+      agent.runAgentCallback = () => {
+        callCount++;
+        console.log(`TEST 5: Call count: ${callCount}`);
+        if (callCount === 2) {
+          agent.setNewMessages([]);
+        }
+      };
+
+      try {
+        await copilotKitCore.runAgent({ agent: agent as any });
+        console.log(`TEST 5: Success - calls: ${agent.runAgentCalls.length}`);
+        expect(agent.runAgentCalls).toHaveLength(2);
+      } catch (error) {
+        console.log(`TEST 5: Error - ${error}`);
+        throw error;
+      }
+    });
+
+    it("TEST 6: should handle tool with undefined follow-up (defaults to true)", async () => {
+      console.log("TEST 6: Starting undefined follow-up test");
+      const tool: FrontendTool = {
+        name: "defaultFollowUpTool",
+        handler: vi.fn(async () => "Result"),
+        // followUp is undefined - should default to true
+      };
+      copilotKitCore.addTool(tool);
+
+      const message = createToolCallMessage("defaultFollowUpTool");
+      const followUpMessage = createAssistantMessage({ content: "Follow-up" });
+      
+      const agent = new MockAgent({ newMessages: [message] });
+      let callCount = 0;
+      agent.runAgentCallback = () => {
+        callCount++;
+        console.log(`TEST 6: Call count: ${callCount}`);
+        if (callCount === 2) {
+          agent.setNewMessages([followUpMessage]);
+        }
+      };
+
+      try {
+        await copilotKitCore.runAgent({ agent: agent as any });
+        console.log(`TEST 6: Success - calls: ${agent.runAgentCalls.length}`);
+        expect(agent.runAgentCalls).toHaveLength(2);
+      } catch (error) {
+        console.log(`TEST 6: Error - ${error}`);
+        throw error;
+      }
+    });
+
+    it("TEST 7: should handle invalid JSON in tool arguments", async () => {
+      console.log("TEST 7: Starting invalid JSON test");
+      const toolName = "invalidJsonTool";
+      const tool = createTool({
+        name: toolName,
+        handler: vi.fn(async () => "Should not be called"),
+      });
+      copilotKitCore.addTool(tool);
+
+      const message = createAssistantMessage({
+        content: "",
+        toolCalls: [{
+          id: "tool-call-1",
+          type: "function",
+          function: {
+            name: toolName,
+            arguments: "{ invalid json",
+          },
+        }],
+      });
+      const agent = new MockAgent({ newMessages: [message] });
+
+      try {
+        await copilotKitCore.runAgent({ agent: agent as any });
+        console.log("TEST 7: ERROR - Should have thrown!");
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        console.log(`TEST 7: Success - caught error: ${error}`);
+        expect(tool.handler).not.toHaveBeenCalled();
+      }
+    });
+
+    it("TEST 8: should handle empty string arguments", async () => {
+      console.log("TEST 8: Starting empty arguments test");
+      const tool = createTool({
+        name: "emptyArgsTool",
+        handler: vi.fn(async (args) => `Received: ${JSON.stringify(args)}`),
+      });
+      copilotKitCore.addTool(tool);
+
+      const message = createAssistantMessage({
+        content: "",
+        toolCalls: [{
+          id: "empty-args-call",
+          type: "function",
+          function: {
+            name: "emptyArgsTool",
+            arguments: "",
+          },
+        }],
+      });
+
+      const agent = new MockAgent({ newMessages: [message] });
+
+      try {
+        await copilotKitCore.runAgent({ agent: agent as any });
+        console.log("TEST 8: ERROR - Should have thrown on empty string!");
+        expect(true).toBe(false);
+      } catch (error) {
+        console.log(`TEST 8: Success - caught error: ${error}`);
+        expect(tool.handler).not.toHaveBeenCalled();
+      }
+    });
+
+    it("TEST 9: should handle chain of follow-ups", async () => {
+      console.log("TEST 9: Starting chain test");
+      const tool1 = createTool({
+        name: "chainTool1",
+        handler: vi.fn(async () => "Result 1"),
+        followUp: true,
+      });
+      const tool2 = createTool({
+        name: "chainTool2",
+        handler: vi.fn(async () => "Result 2"),
+        followUp: true,
+      });
+      copilotKitCore.addTool(tool1);
+      copilotKitCore.addTool(tool2);
+
+      const msg1 = createToolCallMessage("chainTool1");
+      const msg2 = createToolCallMessage("chainTool2");
+      const finalMsg = createAssistantMessage({ content: "Done" });
+      
+      const agent = new MockAgent({ newMessages: [msg1] });
+      let callCount = 0;
+      agent.runAgentCallback = () => {
+        callCount++;
+        console.log(`TEST 9: Call count: ${callCount}`);
+        if (callCount === 2) {
+          agent.setNewMessages([msg2]);
+        } else if (callCount === 3) {
+          agent.setNewMessages([finalMsg]);
+        }
+      };
+
+      try {
+        const result = await copilotKitCore.runAgent({ agent: agent as any });
+        console.log(`TEST 9: Success - calls: ${agent.runAgentCalls.length}`);
+        expect(agent.runAgentCalls).toHaveLength(3);
+        expect(result.newMessages).toEqual([finalMsg]);
+      } catch (error) {
+        console.log(`TEST 9: Error - ${error}`);
+        throw error;
+      }
+    });
+
+    it("TEST 10: should handle concurrent tool calls", async () => {
+      console.log("TEST 10: Starting concurrent tools test");
+      const delays = [50, 30, 70];
+      const tools = delays.map((delay, i) => 
+        createTool({
+          name: `concurrentTool${i}`,
+          handler: vi.fn(async () => {
+            await new Promise(resolve => setTimeout(resolve, delay));
+            return `Result ${i} after ${delay}ms`;
+          }),
+          followUp: false,
+        })
+      );
+      
+      tools.forEach(tool => copilotKitCore.addTool(tool));
+
+      const message = createMultipleToolCallsMessage(
+        delays.map((_, i) => ({ name: `concurrentTool${i}` }))
+      );
+      const agent = new MockAgent({ newMessages: [message] });
+
+      const startTime = Date.now();
+      try {
+        await copilotKitCore.runAgent({ agent: agent as any });
+        const duration = Date.now() - startTime;
+        console.log(`TEST 10: Success - duration: ${duration}ms`);
+        
+        // Should execute sequentially
+        const expectedMinDuration = delays.reduce((a, b) => a + b, 0);
+        expect(duration).toBeGreaterThanOrEqual(expectedMinDuration - 10);
+        
+        tools.forEach(tool => {
+          expect(tool.handler).toHaveBeenCalled();
+        });
+      } catch (error) {
+        console.log(`TEST 10: Error - ${error}`);
+        throw error;
+      }
+    });
+  });
+});

package/src/__tests__/core-simple.test.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { CopilotKitCore } from "../core";
+import { MockAgent, createMessage, createAssistantMessage } from "./test-utils";
+
+describe("CopilotKitCore.runAgent Simple", () => {
+  let copilotKitCore: CopilotKitCore;
+
+  beforeEach(() => {
+    copilotKitCore = new CopilotKitCore({});
+  });
+
+  it("should run agent without tools", async () => {
+    const messages = [
+      createMessage({ content: "Hello" }),
+      createAssistantMessage({ content: "Hi there!" }),
+    ];
+    const agent = new MockAgent({ newMessages: messages });
+
+    const result = await copilotKitCore.runAgent({ agent: agent as any });
+
+    expect(result.newMessages).toEqual(messages);
+    expect(agent.runAgentCalls).toHaveLength(1);
+  });
+});

package/src/__tests__/core-tool-minimal.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { CopilotKitCore } from "../core";
+import {
+  MockAgent,
+  createToolCallMessage,
+  createTool,
+} from "./test-utils";
+
+describe("CopilotKitCore Tool Minimal", () => {
+  let copilotKitCore: CopilotKitCore;
+
+  beforeEach(() => {
+    copilotKitCore = new CopilotKitCore({});
+  });
+
+  it("should execute tool with string result", async () => {
+    const toolName = "stringTool";
+    const tool = createTool({
+      name: toolName,
+      handler: vi.fn(async () => "String result"),
+    });
+    copilotKitCore.addTool(tool);
+
+    const message = createToolCallMessage(toolName, { input: "test" });
+    const agent = new MockAgent({ newMessages: [message] });
+
+    await copilotKitCore.runAgent({ agent: agent as any });
+
+    expect(tool.handler).toHaveBeenCalledWith({ input: "test" });
+    expect(agent.messages.some(m => m.role === "tool")).toBe(true);
+  });
+
+  it("should skip tool call when tool not found", async () => {
+    const message = createToolCallMessage("nonExistentTool");
+    const agent = new MockAgent({ newMessages: [message] });
+
+    await copilotKitCore.runAgent({ agent: agent as any });
+
+    expect(agent.messages.filter(m => m.role === "tool")).toHaveLength(0);
+  });
+});

package/src/__tests__/core-tool-simple.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { CopilotKitCore } from "../core";
+import {
+  MockAgent,
+  createToolCallMessage,
+  createTool,
+} from "./test-utils";
+
+describe("CopilotKitCore Tool Simple", () => {
+  let copilotKitCore: CopilotKitCore;
+
+  beforeEach(() => {
+    copilotKitCore = new CopilotKitCore({});
+  });
+
+  it("should execute a simple tool", async () => {
+    console.log("Starting simple tool test");
+    
+    const toolName = "simpleTool";
+    const tool = createTool({
+      name: toolName,
+      handler: vi.fn(async () => {
+        console.log("Tool handler called");
+        return "Simple result";
+      }),
+      followUp: false, // Important: no follow-up to avoid recursion
+    });
+    copilotKitCore.addTool(tool);
+
+    const message = createToolCallMessage(toolName, { input: "test" });
+    const agent = new MockAgent({ newMessages: [message] });
+
+    console.log("About to run agent");
+    await copilotKitCore.runAgent({ agent: agent as any });
+    console.log("Agent run complete");
+
+    expect(tool.handler).toHaveBeenCalledWith({ input: "test" });
+    expect(agent.messages.length).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/core-wildcard.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CopilotKitCore } from '../core';
+import { FrontendTool } from '../types';
+
+describe('CopilotKitCore - Wildcard Tool Simple', () => {
+  it('should add wildcard tool', () => {
+    const core = new CopilotKitCore({
+      headers: {},
+      properties: {},
+    });
+    
+    const wildcardTool: FrontendTool = {
+      name: '*',
+      handler: vi.fn(),
+    };
+    
+    core.addTool(wildcardTool);
+    expect(core.tools['*']).toBeDefined();
+    expect(core.tools['*']?.name).toBe('*');
+  });
+
+  it('should not interfere with specific tools', () => {
+    const core = new CopilotKitCore({
+      headers: {},
+      properties: {},
+    });
+    
+    const specificTool: FrontendTool = {
+      name: 'specific',
+      handler: vi.fn(),
+    };
+    
+    const wildcardTool: FrontendTool = {
+      name: '*',
+      handler: vi.fn(),
+    };
+    
+    core.addTool(specificTool);
+    core.addTool(wildcardTool);
+    
+    expect(core.tools['specific']).toBeDefined();
+    expect(core.tools['*']).toBeDefined();
+    expect(Object.keys(core.tools).length).toBe(2);
+  });
+});

package/src/__tests__/import.test.ts

@@ -0,0 +1,13 @@
+import { describe, it, expect } from "vitest";
+import { Message } from "@ag-ui/client";
+
+describe("Import Test", () => {
+  it("should import Message type", () => {
+    const msg: Message = {
+      id: "test",
+      role: "user",
+      content: "test",
+    };
+    expect(msg.id).toBe("test");
+  });
+});

package/src/__tests__/simple.test.ts

@@ -0,0 +1,7 @@
+import { describe, it, expect } from "vitest";
+
+describe("Simple Test", () => {
+  it("should pass", () => {
+    expect(1 + 1).toBe(2);
+  });
+});

package/src/__tests__/test-utils.ts

@@ -0,0 +1,162 @@
+import { Message } from "@ag-ui/client";
+import { vi } from "vitest";
+import { FrontendTool } from "../types";
+
+export interface MockAgentOptions {
+  messages?: Message[];
+  newMessages?: Message[];
+  error?: Error | string;
+  runAgentDelay?: number;
+  runAgentCallback?: (input: any) => void;
+}
+
+export class MockAgent {
+  public messages: Message[] = [];
+  public addMessages = vi.fn((messages: Message[]) => {
+    this.messages.push(...messages);
+  });
+  
+  private newMessages: Message[];
+  private error?: Error | string;
+  private runAgentDelay: number;
+  public runAgentCallback?: (input: any) => void;
+  public runAgentCalls: any[] = [];
+
+  constructor(options: MockAgentOptions = {}) {
+    this.messages = options.messages || [];
+    this.newMessages = options.newMessages || [];
+    this.error = options.error;
+    this.runAgentDelay = options.runAgentDelay || 0;
+    this.runAgentCallback = options.runAgentCallback;
+  }
+
+  async runAgent(input: any): Promise<{ newMessages: Message[] }> {
+    this.runAgentCalls.push(input);
+    
+    if (this.runAgentCallback) {
+      this.runAgentCallback(input);
+    }
+
+    if (this.runAgentDelay > 0) {
+      await new Promise(resolve => setTimeout(resolve, this.runAgentDelay));
+    }
+
+    if (this.error) {
+      throw this.error;
+    }
+
+    return { newMessages: this.newMessages };
+  }
+
+  clone(): MockAgent {
+    return new MockAgent({
+      messages: [...this.messages],
+      newMessages: [...this.newMessages],
+      error: this.error,
+      runAgentDelay: this.runAgentDelay,
+      runAgentCallback: this.runAgentCallback,
+    });
+  }
+
+  setNewMessages(messages: Message[]): void {
+    this.newMessages = messages;
+  }
+}
+
+export function createMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: `msg-${Math.random().toString(36).substr(2, 9)}`,
+    role: "user",
+    content: "Test message",
+    ...overrides,
+  } as Message;
+}
+
+export function createAssistantMessage(
+  overrides: Partial<Message> = {}
+): Message {
+  return createMessage({
+    role: "assistant",
+    content: "Assistant message",
+    ...overrides,
+  });
+}
+
+export function createToolCallMessage(
+  toolCallName: string,
+  args: any = {},
+  overrides: Partial<Message> = {}
+): Message {
+  const toolCallId = `tool-call-${Math.random().toString(36).substr(2, 9)}`;
+  return createAssistantMessage({
+    content: "",
+    toolCalls: [
+      {
+        id: toolCallId,
+        type: "function",
+        function: {
+          name: toolCallName,
+          arguments: JSON.stringify(args),
+        },
+      },
+    ],
+    ...overrides,
+  });
+}
+
+export function createToolResultMessage(
+  toolCallId: string,
+  content: string,
+  overrides: Partial<Message> = {}
+): Message {
+  return createMessage({
+    role: "tool",
+    content,
+    toolCallId,
+    ...overrides,
+  });
+}
+
+export function createTool<T extends Record<string, unknown>>(
+  overrides: Partial<FrontendTool<T>> = {}
+): FrontendTool<T> {
+  return {
+    name: `tool-${Math.random().toString(36).substr(2, 9)}`,
+    description: "Test tool",
+    handler: vi.fn(async () => "Tool result"),
+    followUp: false, // Default to false to avoid unexpected recursion in tests
+    ...overrides,
+  };
+}
+
+export function createMultipleToolCallsMessage(
+  toolCalls: Array<{ name: string; args?: any }>,
+  overrides: Partial<Message> = {}
+): Message {
+  return createAssistantMessage({
+    content: "",
+    toolCalls: toolCalls.map((tc) => ({
+      id: `tool-call-${Math.random().toString(36).substr(2, 9)}`,
+      type: "function",
+      function: {
+        name: tc.name,
+        arguments: JSON.stringify(tc.args || {}),
+      },
+    })),
+    ...overrides,
+  });
+}
+
+export async function waitForCondition(
+  condition: () => boolean,
+  timeout: number = 1000,
+  interval: number = 10
+): Promise<void> {
+  const start = Date.now();
+  while (!condition()) {
+    if (Date.now() - start > timeout) {
+      throw new Error("Timeout waiting for condition");
+    }
+    await new Promise(resolve => setTimeout(resolve, interval));
+  }
+}

package/src/agent.ts

@@ -0,0 +1,37 @@
+import {
+  BaseEvent,
+  HttpAgent,
+  HttpAgentConfig,
+  RunAgentInput,
+  runHttpRequest,
+  transformHttpEventStream,
+} from "@ag-ui/client";
+import { Observable } from "rxjs";
+
+export interface CopilotKitHttpAgentConfig
+  extends Omit<HttpAgentConfig, "url"> {
+  runtimeUrl?: string;
+}
+
+export class CopilotKitHttpAgent extends HttpAgent {
+  isCopilotKitAgent = true;
+  runtimeUrl?: string;
+
+  constructor(config: CopilotKitHttpAgentConfig) {
+    super({
+      ...config,
+      url: `${config.runtimeUrl}/agent/${config.agentId}/run`,
+    });
+    this.runtimeUrl = config.runtimeUrl;
+  }
+
+  run(input: RunAgentInput): Observable<BaseEvent> {
+    const url = (
+      input.forwardedProps.__copilotkitConnect === true
+        ? `${this.runtimeUrl}/agent/${this.agentId}/connect`
+        : this.url
+    ) as string;
+    const httpEvents = runHttpRequest(url, this.requestInit(input));
+    return transformHttpEventStream(httpEvents);
+  }
+}