@voltagent/ag-ui 0.1.0

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 VoltAgent Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,94 @@
+import { AbstractAgent } from '@ag-ui/client';
+import { RunAgentInput } from '@ag-ui/core';
+import { Agent } from '@voltagent/core';
+import { CopilotServiceAdapter } from '@copilotkit/runtime';
+
+type VoltAgentAGUIConfig = {
+    agent: Agent;
+    /**
+     * Optional function to derive userId for VoltAgent memory/telemetry.
+     */
+    deriveUserId?: (input: RunAgentInput) => string | undefined;
+};
+/**
+ * VoltAgent adapter that speaks the AG-UI protocol.
+ * Mirrors the Mastra integration strategy: preserve AG-UI state in working memory
+ * and stream VoltAgent events as AG-UI BaseEvents.
+ */
+declare class VoltAgentAGUI extends AbstractAgent {
+    private readonly agent;
+    private readonly deriveUserId?;
+    constructor(config: VoltAgentAGUIConfig);
+    run(input: RunAgentInput): ReturnType<AbstractAgent["run"]>;
+    private buildStreamOptions;
+    private persistStateToWorkingMemory;
+    private readWorkingMemorySnapshot;
+}
+declare function createVoltAgentAGUI(config: VoltAgentAGUIConfig): VoltAgentAGUI;
+
+type CopilotKitHandlerOptions = {
+    /**
+     * Static map of AG-UI agents. Use either this or `loadAgents`.
+     */
+    agents?: Record<string, AbstractAgent>;
+    /**
+     * Lazy loader for AG-UI agents. If provided, it overrides `agents`.
+     */
+    loadAgents?: () => Promise<Record<string, AbstractAgent>> | Record<string, AbstractAgent>;
+    /**
+     * Optional service adapter. Defaults to ExperimentalEmptyAdapter.
+     */
+    serviceAdapter?: CopilotServiceAdapter;
+    /**
+     * Endpoint path used by CopilotKit clients. Defaults to "/copilotkit".
+     */
+    endpoint?: string;
+};
+type RegisterCopilotKitRoutesOptions = {
+    /**
+     * Hono-style app instance with `all(path, handler)` support.
+     */
+    app: {
+        all: (path: string, handler: (c: any) => any) => any;
+        post?: (path: string, handler: (c: any) => any) => any;
+    };
+    /**
+     * VoltAgent agents to expose to CopilotKit. Will be wrapped lazily.
+     */
+    agents?: Record<string, Agent>;
+    /**
+     * Optional resource IDs to pick from the global AgentRegistry if `agents` is not provided.
+     * If omitted and no agents are provided, all registered agents will be exposed.
+     */
+    resourceIds?: string[];
+    /**
+     * Path to mount CopilotKit endpoint. Defaults to "/copilotkit".
+     */
+    path?: string;
+};
+/**
+ * Create a framework-agnostic fetch handler for CopilotKit that serves VoltAgent-backed AG-UI agents.
+ *
+ * @example
+ * ```ts
+ * import { createCopilotKitHandler } from "@voltagent/ag-ui";
+ * import { createVoltAgentAGUI } from "@voltagent/ag-ui";
+ * import { agent } from "./agent"; // VoltAgent instance
+ *
+ * const handler = createCopilotKitHandler({
+ *   agents: { assistant: createVoltAgentAGUI({ agent }) },
+ *   endpoint: "/api/copilotkit",
+ * });
+ *
+ * export default {
+ *   fetch: handler,
+ * };
+ * ```
+ */
+declare function createCopilotKitHandler(options: CopilotKitHandlerOptions): (req: Request) => Promise<Response>;
+/**
+ * Convenience helper: register CopilotKit routes on a Hono-like app using VoltAgent agents.
+ */
+declare function registerCopilotKitRoutes(options: RegisterCopilotKitRoutesOptions): void;
+
+export { type CopilotKitHandlerOptions, type RegisterCopilotKitRoutesOptions, VoltAgentAGUI, createCopilotKitHandler, createVoltAgentAGUI, registerCopilotKitRoutes };

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import { AbstractAgent } from '@ag-ui/client';
+import { RunAgentInput } from '@ag-ui/core';
+import { Agent } from '@voltagent/core';
+import { CopilotServiceAdapter } from '@copilotkit/runtime';
+
+type VoltAgentAGUIConfig = {
+    agent: Agent;
+    /**
+     * Optional function to derive userId for VoltAgent memory/telemetry.
+     */
+    deriveUserId?: (input: RunAgentInput) => string | undefined;
+};
+/**
+ * VoltAgent adapter that speaks the AG-UI protocol.
+ * Mirrors the Mastra integration strategy: preserve AG-UI state in working memory
+ * and stream VoltAgent events as AG-UI BaseEvents.
+ */
+declare class VoltAgentAGUI extends AbstractAgent {
+    private readonly agent;
+    private readonly deriveUserId?;
+    constructor(config: VoltAgentAGUIConfig);
+    run(input: RunAgentInput): ReturnType<AbstractAgent["run"]>;
+    private buildStreamOptions;
+    private persistStateToWorkingMemory;
+    private readWorkingMemorySnapshot;
+}
+declare function createVoltAgentAGUI(config: VoltAgentAGUIConfig): VoltAgentAGUI;
+
+type CopilotKitHandlerOptions = {
+    /**
+     * Static map of AG-UI agents. Use either this or `loadAgents`.
+     */
+    agents?: Record<string, AbstractAgent>;
+    /**
+     * Lazy loader for AG-UI agents. If provided, it overrides `agents`.
+     */
+    loadAgents?: () => Promise<Record<string, AbstractAgent>> | Record<string, AbstractAgent>;
+    /**
+     * Optional service adapter. Defaults to ExperimentalEmptyAdapter.
+     */
+    serviceAdapter?: CopilotServiceAdapter;
+    /**
+     * Endpoint path used by CopilotKit clients. Defaults to "/copilotkit".
+     */
+    endpoint?: string;
+};
+type RegisterCopilotKitRoutesOptions = {
+    /**
+     * Hono-style app instance with `all(path, handler)` support.
+     */
+    app: {
+        all: (path: string, handler: (c: any) => any) => any;
+        post?: (path: string, handler: (c: any) => any) => any;
+    };
+    /**
+     * VoltAgent agents to expose to CopilotKit. Will be wrapped lazily.
+     */
+    agents?: Record<string, Agent>;
+    /**
+     * Optional resource IDs to pick from the global AgentRegistry if `agents` is not provided.
+     * If omitted and no agents are provided, all registered agents will be exposed.
+     */
+    resourceIds?: string[];
+    /**
+     * Path to mount CopilotKit endpoint. Defaults to "/copilotkit".
+     */
+    path?: string;
+};
+/**
+ * Create a framework-agnostic fetch handler for CopilotKit that serves VoltAgent-backed AG-UI agents.
+ *
+ * @example
+ * ```ts
+ * import { createCopilotKitHandler } from "@voltagent/ag-ui";
+ * import { createVoltAgentAGUI } from "@voltagent/ag-ui";
+ * import { agent } from "./agent"; // VoltAgent instance
+ *
+ * const handler = createCopilotKitHandler({
+ *   agents: { assistant: createVoltAgentAGUI({ agent }) },
+ *   endpoint: "/api/copilotkit",
+ * });
+ *
+ * export default {
+ *   fetch: handler,
+ * };
+ * ```
+ */
+declare function createCopilotKitHandler(options: CopilotKitHandlerOptions): (req: Request) => Promise<Response>;
+/**
+ * Convenience helper: register CopilotKit routes on a Hono-like app using VoltAgent agents.
+ */
+declare function registerCopilotKitRoutes(options: RegisterCopilotKitRoutesOptions): void;
+
+export { type CopilotKitHandlerOptions, type RegisterCopilotKitRoutesOptions, VoltAgentAGUI, createCopilotKitHandler, createVoltAgentAGUI, registerCopilotKitRoutes };

package/dist/index.js

@@ -0,0 +1,489 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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, {
+  VoltAgentAGUI: () => VoltAgentAGUI,
+  createCopilotKitHandler: () => createCopilotKitHandler,
+  createVoltAgentAGUI: () => createVoltAgentAGUI,
+  registerCopilotKitRoutes: () => registerCopilotKitRoutes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/voltagent-agent.ts
+var import_client = require("@ag-ui/client");
+var import_core = require("@ag-ui/core");
+var import_utils = require("@voltagent/internal/utils");
+var import_rxjs = require("rxjs");
+function debugLog(message, data) {
+  console.log(`[VoltAgentAGUI] ${message}`, data ?? {});
+}
+__name(debugLog, "debugLog");
+var VoltAgentAGUI = class extends import_client.AbstractAgent {
+  static {
+    __name(this, "VoltAgentAGUI");
+  }
+  agent;
+  deriveUserId;
+  constructor(config) {
+    super();
+    this.agent = config.agent;
+    this.deriveUserId = config.deriveUserId;
+  }
+  run(input) {
+    const stream$ = new import_rxjs.Observable((subscriber) => {
+      const abortController = new AbortController();
+      let finishedSent = false;
+      debugLog("run start", { threadId: input.threadId, runId: input.runId });
+      const runStarted = {
+        type: import_core.EventType.RUN_STARTED,
+        threadId: input.threadId,
+        runId: input.runId
+      };
+      subscriber.next(runStarted);
+      const run = /* @__PURE__ */ __name(async () => {
+        let currentMessageId = generateId();
+        try {
+          await this.persistStateToWorkingMemory(input);
+          const streamOptions = this.buildStreamOptions(input, abortController);
+          const voltMessages = convertAGUIMessagesToVoltMessages(input.messages);
+          debugLog("calling agent.streamText", { messagesLength: voltMessages.length });
+          const result = await this.agent.streamText(voltMessages, streamOptions);
+          for await (const part of result.fullStream) {
+            debugLog("fullStream part", { partType: part.type, id: part.id });
+            const events = convertVoltStreamPartToEvents(part, currentMessageId);
+            if (!events) continue;
+            for (const event of events) {
+              debugLog("emit event", { type: event.type, messageId: event.messageId });
+              subscriber.next(event);
+              if ((event.type === import_core.EventType.TEXT_MESSAGE_START || event.type === import_core.EventType.TEXT_MESSAGE_CHUNK || event.type === import_core.EventType.TEXT_MESSAGE_END) && "messageId" in event && event.messageId) {
+                currentMessageId = event.messageId;
+              }
+            }
+          }
+          const snapshotEvent = await this.readWorkingMemorySnapshot(input);
+          if (snapshotEvent) {
+            subscriber.next(snapshotEvent);
+          }
+          const finished = {
+            type: import_core.EventType.RUN_FINISHED,
+            threadId: input.threadId,
+            runId: input.runId
+          };
+          subscriber.next(finished);
+          finishedSent = true;
+          subscriber.complete();
+          debugLog("run finished", { threadId: input.threadId, runId: input.runId });
+        } catch (error) {
+          debugLog("run error", {
+            threadId: input.threadId,
+            runId: input.runId,
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0
+          });
+          const runError = {
+            type: import_core.EventType.RUN_ERROR,
+            message: error instanceof Error ? error.message : "Unknown error"
+          };
+          subscriber.next(runError);
+          const finished = {
+            type: import_core.EventType.RUN_FINISHED,
+            threadId: input.threadId,
+            runId: input.runId
+          };
+          subscriber.next(finished);
+          finishedSent = true;
+          subscriber.complete();
+        }
+      }, "run");
+      void run();
+      return () => {
+        debugLog("run abort/unsubscribe", {
+          threadId: input.threadId,
+          runId: input.runId,
+          finishedSent
+        });
+        abortController.abort();
+        if (!finishedSent) {
+          const finished = {
+            type: import_core.EventType.RUN_FINISHED,
+            threadId: input.threadId,
+            runId: input.runId
+          };
+          subscriber.next(finished);
+          finishedSent = true;
+          subscriber.complete();
+        }
+      };
+    });
+    return stream$;
+  }
+  buildStreamOptions(input, abortController) {
+    const context = /* @__PURE__ */ new Map();
+    const aguiContext = {
+      state: input.state || void 0,
+      context: input.context,
+      forwardedProps: input.forwardedProps
+    };
+    context.set("agui:context", aguiContext);
+    return {
+      abortSignal: abortController.signal,
+      conversationId: input.threadId,
+      userId: this.deriveUserId?.(input),
+      context
+    };
+  }
+  async persistStateToWorkingMemory(input) {
+    const state = input.state;
+    if (!state || typeof state !== "object" || Object.keys(state).length === 0) {
+      return;
+    }
+    const memory = this.agent.getMemory?.();
+    if (!memory) {
+      return;
+    }
+    try {
+      await memory.updateWorkingMemory({
+        conversationId: input.threadId,
+        content: (0, import_utils.safeStringify)(state)
+      });
+    } catch (error) {
+      console.debug?.("Failed to persist AG-UI state to working memory", error);
+    }
+  }
+  async readWorkingMemorySnapshot(input) {
+    const memory = this.agent.getMemory?.();
+    if (!memory) {
+      return;
+    }
+    try {
+      const raw = await memory.getWorkingMemory({
+        conversationId: input.threadId
+      });
+      if (!raw) {
+        return;
+      }
+      let snapshot = raw;
+      try {
+        snapshot = JSON.parse(raw);
+      } catch {
+      }
+      return {
+        type: import_core.EventType.STATE_SNAPSHOT,
+        snapshot
+      };
+    } catch (error) {
+      console.debug?.("Failed to read AG-UI working memory snapshot", error);
+      return;
+    }
+  }
+};
+var isUserMessage = /* @__PURE__ */ __name((message) => message.role === "user", "isUserMessage");
+var isAssistantMessage = /* @__PURE__ */ __name((message) => message.role === "assistant", "isAssistantMessage");
+var isSystemMessage = /* @__PURE__ */ __name((message) => message.role === "system", "isSystemMessage");
+var isDeveloperMessage = /* @__PURE__ */ __name((message) => message.role === "developer", "isDeveloperMessage");
+var isToolMessage = /* @__PURE__ */ __name((message) => message.role === "tool", "isToolMessage");
+function convertAGUIMessagesToVoltMessages(messages) {
+  const toolNameById = /* @__PURE__ */ new Map();
+  return messages.map((msg) => {
+    const messageId = msg.id || generateId();
+    if (isUserMessage(msg)) {
+      return {
+        id: messageId,
+        role: "user",
+        content: extractTextContent(msg.content)
+      };
+    }
+    if (isAssistantMessage(msg)) {
+      const parts = [];
+      const textContent = msg.content ? extractTextContent(msg.content) : "";
+      if (textContent) {
+        parts.push({ type: "text", text: textContent });
+      }
+      for (const call of msg.toolCalls ?? []) {
+        const args = safelyParseJson(call.function.arguments);
+        toolNameById.set(call.id, call.function.name);
+        parts.push({
+          type: "tool-call",
+          toolCallId: call.id,
+          toolName: call.function.name,
+          args
+        });
+      }
+      return {
+        id: messageId,
+        role: "assistant",
+        parts
+      };
+    }
+    if (isSystemMessage(msg) || isDeveloperMessage(msg)) {
+      return {
+        id: messageId,
+        role: "system",
+        content: msg.content
+      };
+    }
+    if (isToolMessage(msg)) {
+      const toolName = msg.toolCallId ? toolNameById.get(msg.toolCallId) : void 0;
+      return {
+        id: messageId,
+        role: "tool",
+        parts: [
+          {
+            type: "tool-result",
+            toolCallId: msg.toolCallId,
+            toolName: toolName ?? "tool",
+            output: safelyParseJson(msg.content)
+          }
+        ]
+      };
+    }
+    return {
+      id: messageId,
+      role: "assistant",
+      parts: [{ type: "text", text: (0, import_utils.safeStringify)(msg.content ?? "") }]
+    };
+  });
+}
+__name(convertAGUIMessagesToVoltMessages, "convertAGUIMessagesToVoltMessages");
+function extractTextContent(content) {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = content;
+  return parts.map((part) => {
+    const textValue = typeof part.text === "string" ? part.text : "";
+    return textValue;
+  }).filter((text) => text.length > 0).join("\n");
+}
+__name(extractTextContent, "extractTextContent");
+function safelyParseJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+__name(safelyParseJson, "safelyParseJson");
+function convertVoltStreamPartToEvents(part, fallbackMessageId) {
+  const payload = part.payload ?? part;
+  switch (part.type) {
+    case "text-start": {
+      return null;
+    }
+    case "text-delta": {
+      const event = {
+        type: import_core.EventType.TEXT_MESSAGE_CHUNK,
+        delta: part.text ?? "",
+        messageId: part.id ?? fallbackMessageId,
+        role: "assistant"
+      };
+      return [event];
+    }
+    case "text-end": {
+      return null;
+    }
+    case "tool-call": {
+      const toolCallId = payload.toolCallId ?? generateId();
+      const toolName = payload.toolName ?? "tool";
+      const rawArgs = payload.args ?? payload.input ?? payload.arguments;
+      const argsEvent = {
+        type: import_core.EventType.TOOL_CALL_ARGS,
+        toolCallId,
+        delta: (0, import_utils.safeStringify)(rawArgs ?? {})
+      };
+      const startEvent = {
+        type: import_core.EventType.TOOL_CALL_START,
+        toolCallId,
+        toolCallName: toolName,
+        parentMessageId: fallbackMessageId
+      };
+      const endEvent = {
+        type: import_core.EventType.TOOL_CALL_END,
+        toolCallId
+      };
+      return [startEvent, argsEvent, endEvent];
+    }
+    case "tool-result": {
+      const rawResult = payload.result ?? payload.output ?? payload.data ?? payload;
+      const resultEvent = {
+        type: import_core.EventType.TOOL_CALL_RESULT,
+        toolCallId: payload.toolCallId ?? generateId(),
+        content: (0, import_utils.safeStringify)(rawResult ?? {}),
+        messageId: generateId(),
+        role: "tool"
+      };
+      return [resultEvent];
+    }
+    case "error": {
+      const errorEvent = {
+        type: import_core.EventType.TEXT_MESSAGE_CHUNK,
+        delta: `Error: ${payload.error}`,
+        messageId: fallbackMessageId,
+        role: "assistant"
+      };
+      return [errorEvent];
+    }
+    default:
+      return null;
+  }
+}
+__name(convertVoltStreamPartToEvents, "convertVoltStreamPartToEvents");
+function createVoltAgentAGUI(config) {
+  return new VoltAgentAGUI(config);
+}
+__name(createVoltAgentAGUI, "createVoltAgentAGUI");
+function generateId() {
+  const cryptoApi = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (cryptoApi && typeof cryptoApi.randomUUID === "function") {
+    return cryptoApi.randomUUID();
+  }
+  const random = /* @__PURE__ */ __name(() => Math.floor(Math.random() * 65535), "random");
+  let uuid = "";
+  uuid += random().toString(16).padStart(4, "0");
+  uuid += random().toString(16).padStart(4, "0");
+  uuid += "-";
+  uuid += random().toString(16).padStart(4, "0");
+  uuid += "-";
+  uuid += (random() & 4095 | 16384).toString(16).padStart(4, "0");
+  uuid += "-";
+  uuid += (random() & 16383 | 32768).toString(16).padStart(4, "0");
+  uuid += "-";
+  uuid += random().toString(16).padStart(4, "0");
+  uuid += random().toString(16).padStart(4, "0");
+  uuid += random().toString(16).padStart(4, "0");
+  return uuid;
+}
+__name(generateId, "generateId");
+
+// src/copilotkit.ts
+var import_client2 = require("@ag-ui/client");
+var import_runtime2 = require("@copilotkit/runtime");
+var import_core2 = require("@voltagent/core");
+function createCopilotKitHandler(options) {
+  const endpoint = options.endpoint ?? "/copilotkit";
+  const serviceAdapter = options.serviceAdapter ?? new import_runtime2.ExperimentalEmptyAdapter();
+  return async (req) => {
+    await req.clone().text().catch(() => void 0);
+    const agents = await options.loadAgents?.() ?? options.agents ?? (() => {
+      throw new Error("No agents provided to CopilotKit handler");
+    })();
+    const wrappedAgents = {};
+    for (const [id, agent] of Object.entries(agents)) {
+      wrappedAgents[id] = new class extends import_client2.AbstractAgent {
+        run(input) {
+          console.log("[CopilotKit] agent.run", {
+            agentId: id,
+            threadId: input.threadId,
+            runId: input.runId
+          });
+          return agent.run(input);
+        }
+        // Forward connect if the agent implements it
+        connect(input) {
+          console.log("[CopilotKit] agent.connect", {
+            agentId: id,
+            threadId: input.threadId,
+            runId: input.runId
+          });
+          return agent.connect?.(input);
+        }
+        clone() {
+          return this;
+        }
+      }();
+    }
+    const runtime = new import_runtime2.CopilotRuntime({ agents: wrappedAgents });
+    const { handleRequest } = (0, import_runtime2.copilotRuntimeNextJSAppRouterEndpoint)({
+      runtime,
+      serviceAdapter,
+      endpoint
+    });
+    let response;
+    try {
+      response = await handleRequest(req);
+    } catch (error) {
+      console.error("[CopilotKit] handler failed", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : void 0
+      });
+      throw error;
+    }
+    return response;
+  };
+}
+__name(createCopilotKitHandler, "createCopilotKitHandler");
+function registerCopilotKitRoutes(options) {
+  const path = options.path ?? "/copilotkit";
+  const resolveAgents = /* @__PURE__ */ __name(() => {
+    if (options.agents) return options.agents;
+    const registry = import_core2.AgentRegistry.getInstance();
+    const ids = options.resourceIds;
+    if (ids && ids.length > 0) {
+      return Object.fromEntries(
+        ids.map((id) => {
+          const agent = registry.getAgent(id);
+          return agent ? [id, agent] : void 0;
+        }).filter(Boolean)
+      );
+    }
+    return Object.fromEntries(registry.getAllAgents().map((agent) => [agent.id, agent]));
+  }, "resolveAgents");
+  const handler = createCopilotKitHandler({
+    loadAgents: /* @__PURE__ */ __name(() => Object.fromEntries(
+      Object.entries(resolveAgents()).map(([id, agent]) => [id, createVoltAgentAGUI({ agent })])
+    ), "loadAgents"),
+    endpoint: path
+  });
+  const routeHandler = /* @__PURE__ */ __name(async (c) => {
+    const method = c.req?.method;
+    if (method && method !== "POST") {
+      return c.json?.({ success: false, error: "Use POST with CopilotKit runtime requests." }, 405);
+    }
+    try {
+      return await handler(c.req?.raw ?? c.request ?? c);
+    } catch (error) {
+      console.error("[copilotkit] handler error", error);
+      return c.json?.(
+        { success: false, error: "CopilotKit handler failed", detail: `${error}` },
+        500
+      );
+    }
+  }, "routeHandler");
+  const register = /* @__PURE__ */ __name((p) => {
+    if (typeof options.app.post === "function") {
+      options.app.post(p, routeHandler);
+    } else {
+      options.app.all(p, routeHandler);
+    }
+  }, "register");
+  [path, `${path}/*`].forEach(register);
+}
+__name(registerCopilotKitRoutes, "registerCopilotKitRoutes");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VoltAgentAGUI,
+  createCopilotKitHandler,
+  createVoltAgentAGUI,
+  registerCopilotKitRoutes
+});
+//# sourceMappingURL=index.js.map