@copilotkitnext/core 0.0.1

package/src/core.ts

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

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

package/src/types.ts

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

package/src/utils/markdown.ts

@@ -0,0 +1,271 @@
+export function completePartialMarkdown(input: string): string {
+  let s = input;
+
+  // Handle code fences first - use FIRST unmatched fence for proper nesting
+  const fenceMatches = Array.from(s.matchAll(/^(\s*)(`{3,}|~{3,})/gm));
+  if (fenceMatches.length % 2 === 1) {
+    const [, indent, fence] = fenceMatches[0]!;
+    s += `\n${indent}${fence}`;
+  }
+
+  // Identify incomplete links at the end and close them
+  const incompleteLinkMatch = s.match(/\[([^\]]*)\]\(([^)]*)$/);
+  if (incompleteLinkMatch) {
+    s += ")";
+  }
+
+  // State-based parsing
+  interface OpenElement {
+    type: string;
+    marker: string;
+    position: number;
+  }
+
+  const openElements: OpenElement[] = [];
+  const chars = Array.from(s);
+
+  // First pass: identify code block boundaries and inline code to avoid processing their content
+  const codeBlockRanges: Array<{ start: number; end: number }> = [];
+  const inlineCodeRanges: Array<{ start: number; end: number }> = [];
+
+  // Find code block ranges
+  let tempCodeFenceCount = 0;
+  let currentCodeBlockStart = -1;
+
+  for (let i = 0; i < chars.length; i++) {
+    if (i === 0 || chars[i - 1] === "\n") {
+      const lineMatch = s.substring(i).match(/^(\s*)(`{3,}|~{3,})/);
+      if (lineMatch) {
+        tempCodeFenceCount++;
+        if (tempCodeFenceCount % 2 === 1) {
+          currentCodeBlockStart = i;
+        } else if (currentCodeBlockStart !== -1) {
+          codeBlockRanges.push({
+            start: currentCodeBlockStart,
+            end: i + lineMatch[0].length,
+          });
+          currentCodeBlockStart = -1;
+        }
+        i += lineMatch[0].length - 1;
+      }
+    }
+  }
+
+  // Find inline code ranges
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "`") {
+      // Check if escaped
+      let backslashCount = 0;
+      for (let j = i - 1; j >= 0 && chars[j] === "\\"; j--) {
+        backslashCount++;
+      }
+      if (backslashCount % 2 === 0) {
+        // Not escaped - find the closing backtick
+        for (let j = i + 1; j < chars.length; j++) {
+          if (chars[j] === "`") {
+            let closingBackslashCount = 0;
+            for (let k = j - 1; k >= 0 && chars[k] === "\\"; k--) {
+              closingBackslashCount++;
+            }
+            if (closingBackslashCount % 2 === 0) {
+              inlineCodeRanges.push({ start: i, end: j + 1 });
+              i = j;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Helper function to check if position is in code
+  const isInCode = (pos: number): boolean => {
+    return (
+      codeBlockRanges.some((range) => pos >= range.start && pos < range.end) ||
+      inlineCodeRanges.some((range) => pos >= range.start && pos < range.end)
+    );
+  };
+
+  // Second pass: process markdown elements, skipping code regions
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i];
+    const nextChar = chars[i + 1];
+    const prevChar = chars[i - 1];
+
+    if (isInCode(i)) {
+      continue;
+    }
+
+    // Handle brackets (but not if they're part of already-complete links)
+    if (char === "[") {
+      // Check if this is part of a complete link [text](url)
+      let isCompleteLink = false;
+      let bracketDepth = 1;
+      let j = i + 1;
+
+      // Find the matching ]
+      while (j < chars.length && bracketDepth > 0) {
+        if (chars[j] === "[" && !isInCode(j)) bracketDepth++;
+        if (chars[j] === "]" && !isInCode(j)) bracketDepth--;
+        j++;
+      }
+
+      // Check if followed by (
+      if (bracketDepth === 0 && chars[j] === "(") {
+        // Find the closing )
+        let parenDepth = 1;
+        j++;
+        while (j < chars.length && parenDepth > 0) {
+          if (chars[j] === "(" && !isInCode(j)) parenDepth++;
+          if (chars[j] === ")" && !isInCode(j)) parenDepth--;
+          j++;
+        }
+        if (parenDepth === 0) {
+          isCompleteLink = true;
+          i = j - 1;
+          continue;
+        }
+      }
+
+      // This is a standalone bracket, treat as markdown
+      if (!isCompleteLink) {
+        const existingIndex = openElements.findIndex(
+          (el) => el.type === "bracket"
+        );
+        if (existingIndex !== -1) {
+          openElements.splice(existingIndex, 1);
+        } else {
+          openElements.push({ type: "bracket", marker: "[", position: i });
+        }
+      }
+    }
+
+    // Handle double emphasis first (**, __, ~~) - these take precedence
+    else if (char === "*" && nextChar === "*") {
+      const existingIndex = openElements.findIndex(
+        (el) => el.type === "bold_star"
+      );
+      if (existingIndex !== -1) {
+        openElements.splice(existingIndex, 1);
+      } else {
+        openElements.push({ type: "bold_star", marker: "**", position: i });
+      }
+      i++; // Skip next character
+    } else if (char === "_" && nextChar === "_") {
+      const existingIndex = openElements.findIndex(
+        (el) => el.type === "bold_underscore"
+      );
+      if (existingIndex !== -1) {
+        openElements.splice(existingIndex, 1);
+      } else {
+        openElements.push({
+          type: "bold_underscore",
+          marker: "__",
+          position: i,
+        });
+      }
+      i++; // Skip next character
+    } else if (char === "~" && nextChar === "~") {
+      const existingIndex = openElements.findIndex(
+        (el) => el.type === "strike"
+      );
+      if (existingIndex !== -1) {
+        openElements.splice(existingIndex, 1);
+      } else {
+        openElements.push({ type: "strike", marker: "~~", position: i });
+      }
+      i++; // Skip next character
+    }
+
+    // Handle single emphasis (*, _) - only if not part of double
+    else if (char === "*" && prevChar !== "*" && nextChar !== "*") {
+      const existingIndex = openElements.findIndex(
+        (el) => el.type === "italic_star"
+      );
+      if (existingIndex !== -1) {
+        openElements.splice(existingIndex, 1);
+      } else {
+        openElements.push({ type: "italic_star", marker: "*", position: i });
+      }
+    } else if (char === "_" && prevChar !== "_" && nextChar !== "_") {
+      const existingIndex = openElements.findIndex(
+        (el) => el.type === "italic_underscore"
+      );
+      if (existingIndex !== -1) {
+        openElements.splice(existingIndex, 1);
+      } else {
+        openElements.push({
+          type: "italic_underscore",
+          marker: "_",
+          position: i,
+        });
+      }
+    }
+  }
+
+  // Handle remaining unmatched backticks (outside of inline code ranges)
+  let backtickCount = 0;
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "`" && !isInCode(i)) {
+      backtickCount++;
+    }
+  }
+  if (backtickCount % 2 === 1) {
+    s += "`";
+  }
+
+  // Close remaining open elements in reverse order (LIFO stack semantics)
+  openElements.sort((a, b) => b.position - a.position);
+
+  const closers = openElements.map((el) => {
+    switch (el.type) {
+      case "bracket":
+        return "]";
+      case "bold_star":
+        return "**";
+      case "bold_underscore":
+        return "__";
+      case "strike":
+        return "~~";
+      case "italic_star":
+        return "*";
+      case "italic_underscore":
+        return "_";
+      default:
+        return "";
+    }
+  });
+
+  let result = s + closers.join("");
+
+  // Handle parentheses ONLY if not inside code
+  const finalFenceMatches = Array.from(
+    result.matchAll(/^(\s*)(`{3,}|~{3,})/gm)
+  );
+  const hasUnclosedBacktick = (result.match(/`/g) || []).length % 2 === 1;
+  const hasUnclosedCodeFence = finalFenceMatches.length % 2 === 1;
+
+  let shouldCloseParens = !hasUnclosedBacktick && !hasUnclosedCodeFence;
+
+  if (shouldCloseParens) {
+    const lastOpenParen = result.lastIndexOf("(");
+    if (lastOpenParen !== -1) {
+      // Check if this paren is inside a backtick pair
+      const beforeParen = result.substring(0, lastOpenParen);
+      const backticksBeforeParen = (beforeParen.match(/`/g) || []).length;
+      if (backticksBeforeParen % 2 === 1) {
+        shouldCloseParens = false;
+      }
+    }
+  }
+
+  if (shouldCloseParens) {
+    const openParens = (result.match(/\(/g) || []).length;
+    const closeParens = (result.match(/\)/g) || []).length;
+    if (openParens > closeParens) {
+      result += ")".repeat(openParens - closeParens);
+    }
+  }
+
+  return result;
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "@copilotkitnext/typescript-config/base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  target: 'es2022',
+  outDir: 'dist',
+});

package/vitest.config.mjs

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    globals: true,
+    include: ["src/**/__tests__/**/*.{test,spec}.ts"],
+    coverage: {
+      reporter: ["text", "lcov", "html"],
+      include: ["src/**/*.ts"],
+      exclude: ["src/**/*.d.ts", "src/**/index.ts", "src/**/__tests__/**"],
+    },
+    setupFiles: [],
+  },
+});