@copilotkitnext/core 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,93 @@
+import { AbstractAgent, Message, Context, HttpAgentConfig, HttpAgent, RunAgentInput, BaseEvent } from '@ag-ui/client';
+import { z } from 'zod';
+import { Observable } from 'rxjs';
+
+/**
+ * Status of a tool call execution
+ */
+declare enum ToolCallStatus {
+    InProgress = "inProgress",
+    Executing = "executing",
+    Complete = "complete"
+}
+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;
+};
+
+interface CopilotKitCoreConfig {
+    runtimeUrl?: string;
+    agents?: Record<string, AbstractAgent>;
+    headers?: Record<string, string>;
+    properties?: Record<string, unknown>;
+    tools?: Record<string, FrontendTool<any>>;
+}
+interface CopilotKitCoreAddAgentParams {
+    id: string;
+    agent: AbstractAgent;
+}
+interface RunAgentParams {
+    agent: AbstractAgent;
+    withMessages?: Message[];
+    agentId?: string;
+}
+interface CopilotKitCoreSubscriber {
+    onRuntimeLoaded?: (event: {
+        copilotkit: CopilotKitCore;
+    }) => void | Promise<void>;
+    onRuntimeLoadError?: (event: {
+        copilotkit: CopilotKitCore;
+    }) => void | Promise<void>;
+}
+declare class CopilotKitCore {
+    runtimeUrl?: string;
+    didLoadRuntime: boolean;
+    context: Record<string, Context>;
+    tools: Record<string, FrontendTool<any>>;
+    agents: Record<string, AbstractAgent>;
+    headers: Record<string, string>;
+    properties: Record<string, unknown>;
+    version?: string;
+    private localAgents;
+    private remoteAgents;
+    private subscribers;
+    constructor({ runtimeUrl, headers, properties, agents, tools, }: CopilotKitCoreConfig);
+    private getRuntimeInfo;
+    private fetchRemoteAgents;
+    setAgents(agents: Record<string, AbstractAgent>): void;
+    addAgent({ id, agent }: CopilotKitCoreAddAgentParams): void;
+    removeAgent(id: string): void;
+    getAgent(id: string): AbstractAgent | undefined;
+    addContext({ description, value }: Context): string;
+    removeContext(id: string): void;
+    setRuntimeUrl(runtimeUrl?: string): void;
+    addTool<T extends Record<string, unknown> = Record<string, unknown>>(tool: FrontendTool<T>): void;
+    removeTool(id: string): void;
+    setHeaders(headers: Record<string, string>): void;
+    setProperties(properties: Record<string, unknown>): void;
+    subscribe(subscriber: CopilotKitCoreSubscriber): () => void;
+    unsubscribe(subscriber: CopilotKitCoreSubscriber): void;
+    runAgent({ agent, withMessages, agentId, }: RunAgentParams): Promise<Awaited<ReturnType<typeof agent.runAgent>>>;
+}
+
+interface CopilotKitHttpAgentConfig extends Omit<HttpAgentConfig, "url"> {
+    runtimeUrl?: string;
+}
+declare class CopilotKitHttpAgent extends HttpAgent {
+    isCopilotKitAgent: boolean;
+    runtimeUrl?: string;
+    constructor(config: CopilotKitHttpAgentConfig);
+    run(input: RunAgentInput): Observable<BaseEvent>;
+}
+
+declare function completePartialMarkdown(input: string): string;
+
+export { CopilotKitCore, type CopilotKitCoreAddAgentParams, type CopilotKitCoreConfig, type CopilotKitCoreSubscriber, CopilotKitHttpAgent, type CopilotKitHttpAgentConfig, type FrontendTool, type RunAgentParams, ToolCallStatus, completePartialMarkdown };

package/dist/index.d.ts

@@ -0,0 +1,93 @@
+import { AbstractAgent, Message, Context, HttpAgentConfig, HttpAgent, RunAgentInput, BaseEvent } from '@ag-ui/client';
+import { z } from 'zod';
+import { Observable } from 'rxjs';
+
+/**
+ * Status of a tool call execution
+ */
+declare enum ToolCallStatus {
+    InProgress = "inProgress",
+    Executing = "executing",
+    Complete = "complete"
+}
+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;
+};
+
+interface CopilotKitCoreConfig {
+    runtimeUrl?: string;
+    agents?: Record<string, AbstractAgent>;
+    headers?: Record<string, string>;
+    properties?: Record<string, unknown>;
+    tools?: Record<string, FrontendTool<any>>;
+}
+interface CopilotKitCoreAddAgentParams {
+    id: string;
+    agent: AbstractAgent;
+}
+interface RunAgentParams {
+    agent: AbstractAgent;
+    withMessages?: Message[];
+    agentId?: string;
+}
+interface CopilotKitCoreSubscriber {
+    onRuntimeLoaded?: (event: {
+        copilotkit: CopilotKitCore;
+    }) => void | Promise<void>;
+    onRuntimeLoadError?: (event: {
+        copilotkit: CopilotKitCore;
+    }) => void | Promise<void>;
+}
+declare class CopilotKitCore {
+    runtimeUrl?: string;
+    didLoadRuntime: boolean;
+    context: Record<string, Context>;
+    tools: Record<string, FrontendTool<any>>;
+    agents: Record<string, AbstractAgent>;
+    headers: Record<string, string>;
+    properties: Record<string, unknown>;
+    version?: string;
+    private localAgents;
+    private remoteAgents;
+    private subscribers;
+    constructor({ runtimeUrl, headers, properties, agents, tools, }: CopilotKitCoreConfig);
+    private getRuntimeInfo;
+    private fetchRemoteAgents;
+    setAgents(agents: Record<string, AbstractAgent>): void;
+    addAgent({ id, agent }: CopilotKitCoreAddAgentParams): void;
+    removeAgent(id: string): void;
+    getAgent(id: string): AbstractAgent | undefined;
+    addContext({ description, value }: Context): string;
+    removeContext(id: string): void;
+    setRuntimeUrl(runtimeUrl?: string): void;
+    addTool<T extends Record<string, unknown> = Record<string, unknown>>(tool: FrontendTool<T>): void;
+    removeTool(id: string): void;
+    setHeaders(headers: Record<string, string>): void;
+    setProperties(properties: Record<string, unknown>): void;
+    subscribe(subscriber: CopilotKitCoreSubscriber): () => void;
+    unsubscribe(subscriber: CopilotKitCoreSubscriber): void;
+    runAgent({ agent, withMessages, agentId, }: RunAgentParams): Promise<Awaited<ReturnType<typeof agent.runAgent>>>;
+}
+
+interface CopilotKitHttpAgentConfig extends Omit<HttpAgentConfig, "url"> {
+    runtimeUrl?: string;
+}
+declare class CopilotKitHttpAgent extends HttpAgent {
+    isCopilotKitAgent: boolean;
+    runtimeUrl?: string;
+    constructor(config: CopilotKitHttpAgentConfig);
+    run(input: RunAgentInput): Observable<BaseEvent>;
+}
+
+declare function completePartialMarkdown(input: string): string;
+
+export { CopilotKitCore, type CopilotKitCoreAddAgentParams, type CopilotKitCoreConfig, type CopilotKitCoreSubscriber, CopilotKitHttpAgent, type CopilotKitHttpAgentConfig, type FrontendTool, type RunAgentParams, ToolCallStatus, completePartialMarkdown };

package/dist/index.js

@@ -0,0 +1,526 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CopilotKitCore: () => CopilotKitCore,
+  CopilotKitHttpAgent: () => CopilotKitHttpAgent,
+  ToolCallStatus: () => ToolCallStatus,
+  completePartialMarkdown: () => completePartialMarkdown
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+var import_shared = require("@copilotkitnext/shared");
+var import_shared2 = require("@copilotkitnext/shared");
+
+// src/agent.ts
+var import_client = require("@ag-ui/client");
+var CopilotKitHttpAgent = class extends import_client.HttpAgent {
+  isCopilotKitAgent = true;
+  runtimeUrl;
+  constructor(config) {
+    super({
+      ...config,
+      url: `${config.runtimeUrl}/agent/${config.agentId}/run`
+    });
+    this.runtimeUrl = config.runtimeUrl;
+  }
+  run(input) {
+    const url = input.forwardedProps.__copilotkitConnect === true ? `${this.runtimeUrl}/agent/${this.agentId}/connect` : this.url;
+    const httpEvents = (0, import_client.runHttpRequest)(url, this.requestInit(input));
+    return (0, import_client.transformHttpEventStream)(httpEvents);
+  }
+};
+
+// src/core.ts
+var CopilotKitCore = class {
+  runtimeUrl;
+  didLoadRuntime = false;
+  context = {};
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  tools = {};
+  agents = {};
+  headers;
+  properties;
+  version;
+  localAgents = {};
+  remoteAgents = {};
+  subscribers = /* @__PURE__ */ new Set();
+  constructor({
+    runtimeUrl,
+    headers = {},
+    properties = {},
+    agents = {},
+    tools = {}
+  }) {
+    this.headers = headers;
+    this.properties = properties;
+    this.localAgents = agents;
+    this.agents = this.localAgents;
+    this.tools = tools;
+    this.setRuntimeUrl(runtimeUrl);
+  }
+  async getRuntimeInfo() {
+    const response = await fetch(`${this.runtimeUrl}/info`, {
+      headers: this.headers
+    });
+    const {
+      version,
+      ...runtimeInfo
+    } = await response.json();
+    const agents = Object.fromEntries(
+      Object.entries(runtimeInfo.agents).map(([id, { description }]) => {
+        const agent = new CopilotKitHttpAgent({
+          runtimeUrl: this.runtimeUrl,
+          agentId: id,
+          description
+        });
+        return [id, agent];
+      })
+    );
+    return { agents, version };
+  }
+  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) {
+            import_shared2.logger.error(
+              "Error in CopilotKitCore subscriber (onRuntimeLoaded):",
+              error
+            );
+          }
+        });
+      }).catch((error) => {
+        this.subscribers.forEach(async (subscriber) => {
+          try {
+            await subscriber.onRuntimeLoadError?.({ copilotkit: this });
+          } catch (error2) {
+            import_shared2.logger.error(
+              "Error in CopilotKitCore subscriber (onRuntimeLoadError):",
+              error2
+            );
+          }
+        });
+        import_shared2.logger.warn(`Failed to load runtime info: ${error.message}`);
+      });
+    }
+  }
+  setAgents(agents) {
+    this.localAgents = agents;
+    this.agents = { ...this.localAgents, ...this.remoteAgents };
+  }
+  addAgent({ id, agent }) {
+    this.localAgents[id] = agent;
+    this.agents = { ...this.localAgents, ...this.remoteAgents };
+  }
+  removeAgent(id) {
+    delete this.localAgents[id];
+    this.agents = { ...this.localAgents, ...this.remoteAgents };
+  }
+  getAgent(id) {
+    if (id in this.agents) {
+      return this.agents[id];
+    } else {
+      if (!this.didLoadRuntime) {
+        return void 0;
+      } else {
+        throw new Error(`Agent ${id} not found`);
+      }
+    }
+  }
+  addContext({ description, value }) {
+    const id = (0, import_shared.randomUUID)();
+    this.context[id] = { description, value };
+    return id;
+  }
+  removeContext(id) {
+    delete this.context[id];
+  }
+  setRuntimeUrl(runtimeUrl) {
+    this.runtimeUrl = runtimeUrl ? runtimeUrl.replace(/\/$/, "") : void 0;
+    this.fetchRemoteAgents();
+  }
+  addTool(tool) {
+    if (tool.name in this.tools) {
+      import_shared2.logger.warn(`Tool already exists: '${tool.name}', skipping.`);
+      return;
+    }
+    this.tools[tool.name] = tool;
+  }
+  removeTool(id) {
+    delete this.tools[id];
+  }
+  setHeaders(headers) {
+    this.headers = headers;
+  }
+  setProperties(properties) {
+    this.properties = properties;
+  }
+  subscribe(subscriber) {
+    this.subscribers.add(subscriber);
+    return () => {
+      this.unsubscribe(subscriber);
+    };
+  }
+  unsubscribe(subscriber) {
+    this.subscribers.delete(subscriber);
+  }
+  // TODO: AG-UI needs to expose the runAgent result type
+  async runAgent({
+    agent,
+    withMessages,
+    agentId
+  }) {
+    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];
+              if (tool?.agentId && tool.agentId !== agentId) {
+                continue;
+              }
+              let toolCallResult = "";
+              if (tool?.handler) {
+                const args = JSON.parse(toolCall.function.arguments);
+                try {
+                  const result = await tool.handler(args);
+                  if (result === void 0 || 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: (0, import_shared.randomUUID)(),
+                role: "tool",
+                toolCallId: toolCall.id,
+                content: toolCallResult
+              };
+              agent.messages.splice(messageIndex + 1, 0, toolMessage);
+              if (tool?.followUp !== false) {
+                needsFollowUp = true;
+              }
+            } else if ("*" in this.tools) {
+              const wildcardTool = this.tools["*"];
+              if (wildcardTool?.agentId && wildcardTool.agentId !== agentId) {
+                continue;
+              }
+              let toolCallResult = "";
+              if (wildcardTool?.handler) {
+                const wildcardArgs = {
+                  toolName: toolCall.function.name,
+                  args: JSON.parse(toolCall.function.arguments)
+                };
+                try {
+                  const result = await wildcardTool.handler(wildcardArgs);
+                  if (result === void 0 || 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: (0, import_shared.randomUUID)(),
+                role: "tool",
+                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;
+  }
+};
+
+// src/types.ts
+var ToolCallStatus = /* @__PURE__ */ ((ToolCallStatus2) => {
+  ToolCallStatus2["InProgress"] = "inProgress";
+  ToolCallStatus2["Executing"] = "executing";
+  ToolCallStatus2["Complete"] = "complete";
+  return ToolCallStatus2;
+})(ToolCallStatus || {});
+
+// src/utils/markdown.ts
+function completePartialMarkdown(input) {
+  let s = input;
+  const fenceMatches = Array.from(s.matchAll(/^(\s*)(`{3,}|~{3,})/gm));
+  if (fenceMatches.length % 2 === 1) {
+    const [, indent, fence] = fenceMatches[0];
+    s += `
+${indent}${fence}`;
+  }
+  const incompleteLinkMatch = s.match(/\[([^\]]*)\]\(([^)]*)$/);
+  if (incompleteLinkMatch) {
+    s += ")";
+  }
+  const openElements = [];
+  const chars = Array.from(s);
+  const codeBlockRanges = [];
+  const inlineCodeRanges = [];
+  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;
+      }
+    }
+  }
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "`") {
+      let backslashCount = 0;
+      for (let j = i - 1; j >= 0 && chars[j] === "\\"; j--) {
+        backslashCount++;
+      }
+      if (backslashCount % 2 === 0) {
+        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;
+            }
+          }
+        }
+      }
+    }
+  }
+  const isInCode = (pos) => {
+    return codeBlockRanges.some((range) => pos >= range.start && pos < range.end) || inlineCodeRanges.some((range) => pos >= range.start && pos < range.end);
+  };
+  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;
+    }
+    if (char === "[") {
+      let isCompleteLink = false;
+      let bracketDepth = 1;
+      let j = i + 1;
+      while (j < chars.length && bracketDepth > 0) {
+        if (chars[j] === "[" && !isInCode(j)) bracketDepth++;
+        if (chars[j] === "]" && !isInCode(j)) bracketDepth--;
+        j++;
+      }
+      if (bracketDepth === 0 && chars[j] === "(") {
+        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;
+        }
+      }
+      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 });
+        }
+      }
+    } 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++;
+    } 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++;
+    } 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++;
+    } 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
+        });
+      }
+    }
+  }
+  let backtickCount = 0;
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === "`" && !isInCode(i)) {
+      backtickCount++;
+    }
+  }
+  if (backtickCount % 2 === 1) {
+    s += "`";
+  }
+  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("");
+  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) {
+      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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CopilotKitCore,
+  CopilotKitHttpAgent,
+  ToolCallStatus,
+  completePartialMarkdown
+});
+//# sourceMappingURL=index.js.map