@copilotkitnext/core 0.0.2 → 0.0.4

package/src/__tests__/simple.test.ts

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

package/src/__tests__/test-utils.ts

@@ -1,162 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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);
-  }
-}

package/src/core.ts

@@ -1,336 +0,0 @@
-import {
-  AgentDescription,
-  randomUUID,
-  RuntimeInfo,
-} from "@copilotkitnext/shared";
-import { logger } from "@copilotkitnext/shared";
-import { AbstractAgent, Context, HttpAgent, Message } from "@ag-ui/client";
-import { FrontendTool } from "./types";
-import { CopilotKitHttpAgent } from "./agent";
-
-export interface CopilotKitCoreConfig {
-  runtimeUrl?: string;
-  agents?: Record<string, AbstractAgent>;
-  headers?: Record<string, string>;
-  properties?: Record<string, unknown>;
-  tools?: Record<string, FrontendTool<any>>;
-}
-
-export interface CopilotKitCoreAddAgentParams {
-  id: string;
-  agent: AbstractAgent;
-}
-
-export interface RunAgentParams {
-  agent: AbstractAgent;
-  withMessages?: Message[];
-  agentId?: string;
-}
-
-export interface CopilotKitCoreSubscriber {
-  onRuntimeLoaded?: (event: {
-    copilotkit: CopilotKitCore;
-  }) => void | Promise<void>;
-  onRuntimeLoadError?: (event: {
-    copilotkit: CopilotKitCore;
-  }) => void | Promise<void>;
-}
-
-export class CopilotKitCore {
-  runtimeUrl?: string;
-  didLoadRuntime: boolean = false;
-
-  context: Record<string, Context> = {};
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  tools: Record<string, FrontendTool<any>> = {};
-  agents: Record<string, AbstractAgent> = {};
-
-  headers: Record<string, string>;
-  properties: Record<string, unknown>;
-
-  version?: string;
-
-  private localAgents: Record<string, AbstractAgent> = {};
-  private remoteAgents: Record<string, AbstractAgent> = {};
-  private subscribers: Set<CopilotKitCoreSubscriber> = new Set();
-
-  constructor({
-    runtimeUrl,
-    headers = {},
-    properties = {},
-    agents = {},
-    tools = {},
-  }: CopilotKitCoreConfig) {
-    this.headers = headers;
-    this.properties = properties;
-    this.localAgents = agents;
-    this.agents = this.localAgents;
-    this.tools = tools;
-
-    this.setRuntimeUrl(runtimeUrl);
-  }
-
-  private async getRuntimeInfo() {
-    const response = await fetch(`${this.runtimeUrl}/info`, {
-      headers: this.headers,
-    });
-    const {
-      version,
-      ...runtimeInfo
-    }: {
-      agents: Record<string, AgentDescription>;
-      version: string;
-    } = (await response.json()) as RuntimeInfo;
-
-    const agents: Record<string, AbstractAgent> = Object.fromEntries(
-      Object.entries(runtimeInfo.agents).map(([id, { description }]) => {
-        const agent = new CopilotKitHttpAgent({
-          runtimeUrl: this.runtimeUrl,
-          agentId: id,
-          description: description,
-        });
-        return [id, agent];
-      })
-    );
-
-    return { agents, version };
-  }
-
-  private async fetchRemoteAgents() {
-    if (this.runtimeUrl) {
-      this.getRuntimeInfo()
-        .then(({ agents, version }) => {
-          this.remoteAgents = agents;
-          this.agents = { ...this.localAgents, ...this.remoteAgents };
-          this.didLoadRuntime = true;
-          this.version = version;
-
-          this.subscribers.forEach(async (subscriber) => {
-            try {
-              await subscriber.onRuntimeLoaded?.({ copilotkit: this });
-            } catch (error) {
-              logger.error(
-                "Error in CopilotKitCore subscriber (onRuntimeLoaded):",
-                error
-              );
-            }
-          });
-        })
-        .catch((error) => {
-          this.subscribers.forEach(async (subscriber) => {
-            try {
-              await subscriber.onRuntimeLoadError?.({ copilotkit: this });
-            } catch (error) {
-              logger.error(
-                "Error in CopilotKitCore subscriber (onRuntimeLoadError):",
-                error
-              );
-            }
-          });
-          logger.warn(`Failed to load runtime info: ${error.message}`);
-        });
-    }
-  }
-
-  setAgents(agents: Record<string, AbstractAgent>) {
-    this.localAgents = agents;
-    this.agents = { ...this.localAgents, ...this.remoteAgents };
-  }
-
-  addAgent({ id, agent }: CopilotKitCoreAddAgentParams) {
-    this.localAgents[id] = agent;
-    this.agents = { ...this.localAgents, ...this.remoteAgents };
-  }
-
-  removeAgent(id: string) {
-    delete this.localAgents[id];
-    this.agents = { ...this.localAgents, ...this.remoteAgents };
-  }
-
-  getAgent(id: string): AbstractAgent | undefined {
-    if (id in this.agents) {
-      return this.agents[id] as AbstractAgent;
-    } else {
-      if (!this.didLoadRuntime) {
-        return undefined;
-      } else {
-        throw new Error(`Agent ${id} not found`);
-      }
-    }
-  }
-
-  addContext({ description, value }: Context): string {
-    const id = randomUUID();
-    this.context[id] = { description, value };
-    return id;
-  }
-
-  removeContext(id: string) {
-    delete this.context[id];
-  }
-
-  setRuntimeUrl(runtimeUrl?: string) {
-    this.runtimeUrl = runtimeUrl ? runtimeUrl.replace(/\/$/, "") : undefined;
-    this.fetchRemoteAgents();
-  }
-
-  addTool<T extends Record<string, unknown> = Record<string, unknown>>(
-    tool: FrontendTool<T>
-  ) {
-    if (tool.name in this.tools) {
-      logger.warn(`Tool already exists: '${tool.name}', skipping.`);
-      return;
-    }
-
-    this.tools[tool.name] = tool;
-  }
-
-  removeTool(id: string) {
-    delete this.tools[id];
-  }
-
-  setHeaders(headers: Record<string, string>) {
-    this.headers = headers;
-  }
-
-  setProperties(properties: Record<string, unknown>) {
-    this.properties = properties;
-  }
-
-  subscribe(subscriber: CopilotKitCoreSubscriber): () => void {
-    this.subscribers.add(subscriber);
-
-    // Return unsubscribe function
-    return () => {
-      this.unsubscribe(subscriber);
-    };
-  }
-
-  unsubscribe(subscriber: CopilotKitCoreSubscriber) {
-    this.subscribers.delete(subscriber);
-  }
-
-  // TODO: AG-UI needs to expose the runAgent result type
-  async runAgent({
-    agent,
-    withMessages,
-    agentId,
-  }: RunAgentParams): Promise<Awaited<ReturnType<typeof agent.runAgent>>> {
-    if (withMessages) {
-      agent.addMessages(withMessages);
-    }
-
-    const runAgentResult = await agent.runAgent({
-      forwardedProps: this.properties,
-    });
-
-    const { newMessages } = runAgentResult;
-
-    let needsFollowUp = false;
-
-    for (const message of newMessages) {
-      if (message.role === "assistant") {
-        for (const toolCall of message.toolCalls || []) {
-          if (
-            newMessages.findIndex(
-              (m) => m.role === "tool" && m.toolCallId === toolCall.id
-            ) === -1
-          ) {
-            if (toolCall.function.name in this.tools) {
-              const tool = this.tools[toolCall.function.name];
-
-              // Check if tool is constrained to a specific agent
-              if (tool?.agentId && tool.agentId !== agentId) {
-                // Tool is not available for this agent, skip it
-                continue;
-              }
-
-              let toolCallResult = "";
-              if (tool?.handler) {
-                const args = JSON.parse(toolCall.function.arguments);
-                try {
-                  const result = await tool.handler(args);
-                  if (result === undefined || result === null) {
-                    toolCallResult = "";
-                  } else if (typeof result === "string") {
-                    toolCallResult = result;
-                  } else {
-                    toolCallResult = JSON.stringify(result);
-                  }
-                } catch (error) {
-                  toolCallResult = `Error: ${error instanceof Error ? error.message : String(error)}`;
-                }
-              }
-
-              const messageIndex = agent.messages.findIndex(
-                (m) => m.id === message.id
-              );
-              const toolMessage = {
-                id: randomUUID(),
-                role: "tool" as const,
-                toolCallId: toolCall.id,
-                content: toolCallResult,
-              };
-              agent.messages.splice(messageIndex + 1, 0, toolMessage);
-
-              if (tool?.followUp !== false) {
-                needsFollowUp = true;
-              }
-            } else if ("*" in this.tools) {
-              // Wildcard fallback for undefined tools
-              const wildcardTool = this.tools["*"];
-
-              // Check if wildcard tool is constrained to a specific agent
-              if (wildcardTool?.agentId && wildcardTool.agentId !== agentId) {
-                // Wildcard tool is not available for this agent, skip it
-                continue;
-              }
-
-              let toolCallResult = "";
-              if (wildcardTool?.handler) {
-                // Pass both the tool name and original args to the wildcard handler
-                const wildcardArgs = {
-                  toolName: toolCall.function.name,
-                  args: JSON.parse(toolCall.function.arguments),
-                };
-                try {
-                  const result = await wildcardTool.handler(wildcardArgs);
-                  if (result === undefined || result === null) {
-                    toolCallResult = "";
-                  } else if (typeof result === "string") {
-                    toolCallResult = result;
-                  } else {
-                    toolCallResult = JSON.stringify(result);
-                  }
-                } catch (error) {
-                  toolCallResult = `Error: ${error instanceof Error ? error.message : String(error)}`;
-                }
-              }
-
-              const messageIndex = agent.messages.findIndex(
-                (m) => m.id === message.id
-              );
-              const toolMessage = {
-                id: randomUUID(),
-                role: "tool" as const,
-                toolCallId: toolCall.id,
-                content: toolCallResult,
-              };
-              agent.messages.splice(messageIndex + 1, 0, toolMessage);
-
-              if (wildcardTool?.followUp !== false) {
-                needsFollowUp = true;
-              }
-            }
-          }
-        }
-      }
-    }
-
-    if (needsFollowUp) {
-      return await this.runAgent({ agent, agentId });
-    }
-
-    return runAgentResult;
-  }
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./core";
-export * from "./types";
-export * from "./agent";
-export * from "./utils/markdown";

package/src/types.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-
-/**
- * Status of a tool call execution
- */
-export enum ToolCallStatus {
-  InProgress = "inProgress",
-  Executing = "executing",
-  Complete = "complete"
-}
-
-export type FrontendTool<T extends Record<string, unknown> = Record<string, unknown>> = {
-  name: string;
-  description?: string;
-  parameters?: z.ZodType<T>;
-  handler?: (args: T) => Promise<unknown>;
-  followUp?: boolean;
-  /**
-   * Optional agent ID to constrain this tool to a specific agent.
-   * If specified, this tool will only be available to the specified agent.
-   */
-  agentId?: string;
-};