@copilotkitnext/core 0.0.19 → 0.0.21-alpha.0

package/dist/index.mjs

@@ -10,20 +10,55 @@ import {
 } from "@ag-ui/client";
 var ProxiedCopilotRuntimeAgent = class extends HttpAgent {
   runtimeUrl;
+  transport;
+  singleEndpointUrl;
   constructor(config) {
+    const normalizedRuntimeUrl = config.runtimeUrl ? config.runtimeUrl.replace(/\/$/, "") : void 0;
+    const transport = config.transport ?? "rest";
+    const runUrl = transport === "single" ? normalizedRuntimeUrl ?? config.runtimeUrl ?? "" : `${normalizedRuntimeUrl ?? config.runtimeUrl}/agent/${encodeURIComponent(config.agentId ?? "")}/run`;
+    if (!runUrl) {
+      throw new Error("ProxiedCopilotRuntimeAgent requires a runtimeUrl when transport is set to 'single'.");
+    }
     super({
       ...config,
-      url: `${config.runtimeUrl}/agent/${config.agentId}/run`
+      url: runUrl
     });
-    this.runtimeUrl = config.runtimeUrl;
+    this.runtimeUrl = normalizedRuntimeUrl ?? config.runtimeUrl;
+    this.transport = transport;
+    if (this.transport === "single") {
+      this.singleEndpointUrl = this.runtimeUrl;
+    }
   }
   abortRun() {
-    if (!this.runtimeUrl || !this.agentId || !this.threadId) {
+    if (!this.agentId || !this.threadId) {
       return;
     }
     if (typeof fetch === "undefined") {
       return;
     }
+    if (this.transport === "single") {
+      if (!this.singleEndpointUrl) {
+        return;
+      }
+      const headers = new Headers({ ...this.headers, "Content-Type": "application/json" });
+      void fetch(this.singleEndpointUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          method: "agent/stop",
+          params: {
+            agentId: this.agentId,
+            threadId: this.threadId
+          }
+        })
+      }).catch((error) => {
+        console.error("ProxiedCopilotRuntimeAgent: stop request failed", error);
+      });
+      return;
+    }
+    if (!this.runtimeUrl) {
+      return;
+    }
     const stopPath = `${this.runtimeUrl}/agent/${encodeURIComponent(this.agentId)}/stop/${encodeURIComponent(this.threadId)}`;
     const origin = typeof window !== "undefined" && window.location ? window.location.origin : "http://localhost";
     const base = new URL(this.runtimeUrl, origin);
@@ -39,9 +74,64 @@ var ProxiedCopilotRuntimeAgent = class extends HttpAgent {
     });
   }
   connect(input) {
+    if (this.transport === "single") {
+      if (!this.singleEndpointUrl) {
+        throw new Error("Single endpoint transport requires a runtimeUrl");
+      }
+      const requestInit = this.createSingleRouteRequestInit(input, "agent/connect", {
+        agentId: this.agentId
+      });
+      const httpEvents2 = runHttpRequest(this.singleEndpointUrl, requestInit);
+      return transformHttpEventStream(httpEvents2);
+    }
     const httpEvents = runHttpRequest(`${this.runtimeUrl}/agent/${this.agentId}/connect`, this.requestInit(input));
     return transformHttpEventStream(httpEvents);
   }
+  run(input) {
+    if (this.transport === "single") {
+      if (!this.singleEndpointUrl) {
+        throw new Error("Single endpoint transport requires a runtimeUrl");
+      }
+      const requestInit = this.createSingleRouteRequestInit(input, "agent/run", {
+        agentId: this.agentId
+      });
+      const httpEvents = runHttpRequest(this.singleEndpointUrl, requestInit);
+      return transformHttpEventStream(httpEvents);
+    }
+    return super.run(input);
+  }
+  createSingleRouteRequestInit(input, method, params) {
+    if (!this.agentId) {
+      throw new Error("ProxiedCopilotRuntimeAgent requires agentId to make runtime requests");
+    }
+    const baseInit = super.requestInit(input);
+    const headers = new Headers(baseInit.headers ?? {});
+    headers.set("Content-Type", "application/json");
+    headers.set("Accept", headers.get("Accept") ?? "text/event-stream");
+    let originalBody = void 0;
+    if (typeof baseInit.body === "string") {
+      try {
+        originalBody = JSON.parse(baseInit.body);
+      } catch (error) {
+        console.warn("ProxiedCopilotRuntimeAgent: failed to parse request body for single route transport", error);
+        originalBody = void 0;
+      }
+    }
+    const envelope = {
+      method
+    };
+    if (params && Object.keys(params).length > 0) {
+      envelope.params = params;
+    }
+    if (originalBody !== void 0) {
+      envelope.body = originalBody;
+    }
+    return {
+      ...baseInit,
+      headers,
+      body: JSON.stringify(envelope)
+    };
+  }
 };
 
 // src/core/agent-registry.ts
@@ -55,6 +145,7 @@ var AgentRegistry = class {
   _runtimeUrl;
   _runtimeVersion;
   _runtimeConnectionStatus = "disconnected" /* Disconnected */;
+  _runtimeTransport = "rest";
   /**
    * Get all agents as a readonly record
    */
@@ -70,6 +161,9 @@ var AgentRegistry = class {
   get runtimeConnectionStatus() {
     return this._runtimeConnectionStatus;
   }
+  get runtimeTransport() {
+    return this._runtimeTransport;
+  }
   /**
    * Initialize agents from configuration
    */
@@ -89,6 +183,13 @@ var AgentRegistry = class {
     this._runtimeUrl = normalizedRuntimeUrl;
     void this.updateRuntimeConnection();
   }
+  setRuntimeTransport(runtimeTransport) {
+    if (this._runtimeTransport === runtimeTransport) {
+      return;
+    }
+    this._runtimeTransport = runtimeTransport;
+    void this.updateRuntimeConnection();
+  }
   /**
    * Set all agents at once (for development use)
    */
@@ -169,20 +270,19 @@ var AgentRegistry = class {
     this._runtimeConnectionStatus = "connecting" /* Connecting */;
     await this.notifyRuntimeStatusChanged("connecting" /* Connecting */);
     try {
-      const response = await fetch(`${this.runtimeUrl}/info`, {
-        headers: this.core.headers
-      });
+      const runtimeInfoResponse = await this.fetchRuntimeInfo();
       const {
         version,
         ...runtimeInfo
-      } = await response.json();
+      } = runtimeInfoResponse;
       const agents = Object.fromEntries(
         Object.entries(runtimeInfo.agents).map(([id, { description }]) => {
           const agent = new ProxiedCopilotRuntimeAgent({
             runtimeUrl: this.runtimeUrl,
             agentId: id,
             // Runtime agents always have their ID set correctly
-            description
+            description,
+            transport: this._runtimeTransport
           });
           this.applyHeadersToAgent(agent);
           return [id, agent];
@@ -213,6 +313,36 @@ var AgentRegistry = class {
       });
     }
   }
+  async fetchRuntimeInfo() {
+    if (!this.runtimeUrl) {
+      throw new Error("Runtime URL is not set");
+    }
+    const baseHeaders = this.core.headers;
+    const headers = {
+      ...baseHeaders
+    };
+    if (this._runtimeTransport === "single") {
+      if (!headers["Content-Type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+      const response2 = await fetch(this.runtimeUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ method: "info" })
+      });
+      if ("ok" in response2 && !response2.ok) {
+        throw new Error(`Runtime info request failed with status ${response2.status}`);
+      }
+      return await response2.json();
+    }
+    const response = await fetch(`${this.runtimeUrl}/info`, {
+      headers
+    });
+    if ("ok" in response && !response.ok) {
+      throw new Error(`Runtime info request failed with status ${response.status}`);
+    }
+    return await response.json();
+  }
   /**
    * Assign agent IDs to a record of agents
    */
@@ -763,7 +893,8 @@ var RunHandler = class {
       const runAgentResult = await agent.runAgent(
         {
           forwardedProps: this.core.properties,
-          tools: this.buildFrontendTools(agent.agentId)
+          tools: this.buildFrontendTools(agent.agentId),
+          context: Object.values(this.core.context)
         },
         this.createAgentErrorSubscriber(agent)
       );
@@ -1318,6 +1449,7 @@ var CopilotKitCore = class {
   stateManager;
   constructor({
     runtimeUrl,
+    runtimeTransport = "rest",
     headers = {},
     properties = {},
     agents__unsafe_dev_only = {},
@@ -1335,6 +1467,7 @@ var CopilotKitCore = class {
     this.runHandler.initialize(tools);
     this.suggestionEngine.initialize(suggestionsConfig);
     this.stateManager.initialize();
+    this.agentRegistry.setRuntimeTransport(runtimeTransport);
     this.agentRegistry.setRuntimeUrl(runtimeUrl);
     this.subscribe({
       onAgentsChanged: ({ agents }) => {
@@ -1396,6 +1529,12 @@ var CopilotKitCore = class {
   setRuntimeUrl(runtimeUrl) {
     this.agentRegistry.setRuntimeUrl(runtimeUrl);
   }
+  get runtimeTransport() {
+    return this.agentRegistry.runtimeTransport;
+  }
+  setRuntimeTransport(runtimeTransport) {
+    this.agentRegistry.setRuntimeTransport(runtimeTransport);
+  }
   get runtimeVersion() {
     return this.agentRegistry.runtimeVersion;
   }