@copilotkit/runtime 1.6.0 → 1.7.0-next.0

package/dist/lib/integrations/node-http/index.mjs

@@ -1,6 +1,6 @@
 import {
   copilotRuntimeNodeHttpEndpoint
-} from "../../../chunk-DUW72ZZB.mjs";
+} from "../../../chunk-34Y5DNNJ.mjs";
 import "../../../chunk-FZJAYGIR.mjs";
 import "../../../chunk-5BIEM2UU.mjs";
 import "../../../chunk-RTFJTJMA.mjs";

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.0",
+  "version": "1.7.0-next.0",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -59,7 +59,7 @@
     "rxjs": "^7.8.1",
     "type-graphql": "2.0.0-rc.1",
     "zod": "^3.23.3",
-    "@copilotkit/shared": "1.6.0"
+    "@copilotkit/shared": "1.7.0-next.0"
   },
   "keywords": [
     "copilotkit",

package/src/graphql/resolvers/copilot.resolver.ts

@@ -196,6 +196,10 @@ export class CopilotResolver {
       rejectOutputMessagesPromise = reject;
     });
 
+    if (copilotCloudPublicApiKey) {
+      ctx.properties["copilotCloudPublicApiKey"] = copilotCloudPublicApiKey;
+    }
+
     logger.debug("Processing");
     const {
       eventSource,

package/src/lib/runtime/__tests__/remote-action-constructors.test.ts

@@ -1,3 +1,4 @@
+import "reflect-metadata";
 import { TextEncoder } from "util";
 import { RemoteLangGraphEventSource } from "../../../agents/langgraph/event-source";
 import telemetry from "../../telemetry-client";
@@ -7,6 +8,7 @@ import {
   createHeaders,
 } from "../remote-action-constructors";
 import { execute } from "../remote-lg-action";
+import { ReplaySubject } from "rxjs";
 
 // Mock external dependencies
 jest.mock("../remote-lg-action", () => ({
@@ -49,7 +51,7 @@ beforeEach(() => {
 
 describe("remote action constructors", () => {
   describe("constructLGCRemoteAction", () => {
-    it("should create an agent with langGraphAgentHandler that processes events", async () => {
+    it("should create an agent with remoteAgentHandler that processes events", async () => {
       // Arrange: simulate execute returning a dummy ReadableStream
       const dummyEncodedEvent = new TextEncoder().encode(JSON.stringify({ event: "test" }) + "\n");
       const readerMock = {
@@ -72,7 +74,7 @@ describe("remote action constructors", () => {
         processLangGraphEvents: processLangGraphEventsMock,
       }));
 
-      // Act: build the action and call langGraphAgentHandler
+      // Act: build the action and call remoteAgentHandler
       const actions = constructLGCRemoteAction({
         endpoint,
         graphqlContext,
@@ -84,7 +86,7 @@ describe("remote action constructors", () => {
       const action = actions[0];
       expect(action.name).toEqual(dummyAgent.name);
 
-      const result = await action.langGraphAgentHandler({
+      const result = await action.remoteAgentHandler({
         name: dummyAgent.name,
         actionInputsWithoutAgents: [],
         threadId: "thread1",
@@ -160,26 +162,46 @@ describe("remote action constructors", () => {
     });
 
     it("should create remote agent handler that processes events", async () => {
-      // Arrange: mock fetch for agent handler to return a dummy stream
-      const dummyEncodedAgentEvent = new TextEncoder().encode('{"event":"data"}\n');
-      const agentReaderMock = {
-        read: jest
-          .fn()
-          .mockResolvedValueOnce({ done: false, value: dummyEncodedAgentEvent })
-          .mockResolvedValueOnce({ done: true, value: new Uint8Array() }),
-      };
-      const dummyStreamResponse = {
-        getReader: () => agentReaderMock,
+      const json = {
+        agents: [
+          {
+            name: "agent2",
+            description: "agent desc",
+            type: "langgraph", // Add type to match RemoteAgentType.LangGraph
+          },
+        ],
+        actions: [
+          {
+            name: "action1",
+            description: "action desc",
+            parameters: { param: "value" },
+          },
+        ],
       };
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        text: jest.fn().mockResolvedValue("ok"),
-        body: dummyStreamResponse,
-      });
 
-      const processLangGraphEventsMock = jest.fn(() => "agent events processed");
+      const dummyEncodedAgentEvent = new TextEncoder().encode('{"type":"data","content":"test"}\n');
+
+      const mockResponse = new Response(
+        new ReadableStream({
+          start(controller) {
+            controller.enqueue(dummyEncodedAgentEvent);
+            controller.close();
+          },
+        }),
+        {
+          status: 200,
+          statusText: "OK",
+          headers: new Headers({
+            "content-type": "application/json",
+          }),
+        },
+      );
+
+      global.fetch = jest.fn().mockResolvedValue(mockResponse);
+
+      const processLangGraphEventsMock = jest.fn().mockResolvedValue("agent events processed");
       (RemoteLangGraphEventSource as jest.Mock).mockImplementation(() => ({
-        eventStream$: { next: jest.fn(), complete: jest.fn(), error: jest.fn() },
+        eventStream$: new ReplaySubject(),
         processLangGraphEvents: processLangGraphEventsMock,
       }));
 
@@ -192,29 +214,17 @@ describe("remote action constructors", () => {
         messages: [],
         agentStates,
       });
-      // The remote agent is the second item in the array
-      expect(actionsArray).toHaveLength(2);
-      const remoteAgentHandler = (actionsArray[1] as any).langGraphAgentHandler;
+
+      const remoteAgentHandler = (actionsArray[1] as any).remoteAgentHandler;
       const result = await remoteAgentHandler({
         name: "agent2",
         actionInputsWithoutAgents: [],
         threadId: "thread2",
         nodeName: "node2",
-        additionalMessages: [],
-        metaEvents: [],
       });
+
       expect(processLangGraphEventsMock).toHaveBeenCalled();
       expect(result).toBe("agent events processed");
-
-      // Check telemetry.capture for agent execution
-      expect(telemetry.capture).toHaveBeenCalledWith(
-        "oss.runtime.remote_action_executed",
-        expect.objectContaining({
-          agentExecution: true,
-          type: "self-hosted",
-          agentsAmount: 1,
-        }),
-      );
     });
   });
 

package/src/lib/runtime/copilot-runtime.ts

@@ -39,8 +39,8 @@ import { Message } from "../../graphql/types/converted";
 import { ForwardedParametersInput } from "../../graphql/inputs/forwarded-parameters.input";
 
 import {
-  isLangGraphAgentAction,
-  LangGraphAgentAction,
+  isRemoteAgentAction,
+  RemoteAgentAction,
   EndpointType,
   setupRemoteActions,
   EndpointDefinition,
@@ -305,7 +305,7 @@ please use an LLM adapter instead.`,
           (action) =>
             // TODO-AGENTS: do not exclude ALL server side actions
             !serverSideActions.find((serverSideAction) => serverSideAction.name == action.name),
-          // !isLangGraphAgentAction(
+          // !isRemoteAgentAction(
           //   serverSideActions.find((serverSideAction) => serverSideAction.name == action.name),
           // ),
         ),
@@ -322,7 +322,6 @@ please use an LLM adapter instead.`,
   }
 
   async discoverAgentsFromEndpoints(graphqlContext: GraphQLContext): Promise<AgentWithEndpoint[]> {
-    const headers = createHeaders(null, graphqlContext);
     const agents = this.remoteEndpointDefinitions.reduce(
       async (acc: Promise<Agent[]>, endpoint) => {
         const agents = await acc;
@@ -355,12 +354,12 @@ please use an LLM adapter instead.`,
             description: string;
           }>;
         }
-
-        const fetchUrl = `${(endpoint as CopilotKitEndpoint).url}/info`;
+        const cpkEndpoint = endpoint as CopilotKitEndpoint;
+        const fetchUrl = `${endpoint.url}/info`;
         try {
           const response = await fetch(fetchUrl, {
             method: "POST",
-            headers,
+            headers: createHeaders(cpkEndpoint.onBeforeRequest, graphqlContext),
             body: JSON.stringify({ properties: graphqlContext.properties }),
           });
           if (!response.ok) {
@@ -444,11 +443,12 @@ please use an LLM adapter instead.`,
       agentWithEndpoint.endpoint.type === EndpointType.CopilotKit ||
       !("type" in agentWithEndpoint.endpoint)
     ) {
-      const fetchUrl = `${(agentWithEndpoint.endpoint as CopilotKitEndpoint).url}/agents/state`;
+      const cpkEndpoint = agentWithEndpoint.endpoint as CopilotKitEndpoint;
+      const fetchUrl = `${cpkEndpoint.url}/agents/state`;
       try {
         const response = await fetch(fetchUrl, {
           method: "POST",
-          headers,
+          headers: createHeaders(cpkEndpoint.onBeforeRequest, graphqlContext),
           body: JSON.stringify({
             properties: graphqlContext.properties,
             threadId,
@@ -505,8 +505,8 @@ please use an LLM adapter instead.`,
     const messages = convertGqlInputToMessages(rawMessages);
 
     const currentAgent = serverSideActions.find(
-      (action) => action.name === agentName && isLangGraphAgentAction(action),
-    ) as LangGraphAgentAction;
+      (action) => action.name === agentName && isRemoteAgentAction(action),
+    ) as RemoteAgentAction;
 
     if (!currentAgent) {
       throw new CopilotKitAgentDiscoveryError({ agentName });
@@ -519,9 +519,9 @@ please use an LLM adapter instead.`,
       .filter(
         (action) =>
           // Case 1: Keep all regular (non-agent) actions
-          !isLangGraphAgentAction(action) ||
+          !isRemoteAgentAction(action) ||
           // Case 2: For agent actions, keep all except self (prevent infinite loops)
-          (isLangGraphAgentAction(action) && action.name !== agentName) /* prevent self-calls */,
+          (isRemoteAgentAction(action) && action.name !== agentName) /* prevent self-calls */,
       )
       .map((action) => ({
         name: action.name,
@@ -542,7 +542,7 @@ please use an LLM adapter instead.`,
     });
     try {
       const eventSource = new RuntimeEventSource();
-      const stream = await currentAgent.langGraphAgentHandler({
+      const stream = await currentAgent.remoteAgentHandler({
         name: agentName,
         threadId,
         nodeName,

package/src/lib/runtime/remote-action-constructors.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import {
   CopilotKitEndpoint,
-  LangGraphAgentHandlerParams,
+  RemoteAgentHandlerParams,
   RemoteActionInfoResponse,
   LangGraphPlatformEndpoint,
 } from "./remote-actions";
@@ -10,13 +10,18 @@ import { Logger } from "pino";
 import { Message } from "../../graphql/types/converted";
 import { AgentStateInput } from "../../graphql/inputs/agent-state.input";
 import { Observable, ReplaySubject } from "rxjs";
-import { RuntimeEvent } from "../../service-adapters/events";
+import {
+  RuntimeEvent,
+  RuntimeEventSource,
+  RuntimeEventSubject,
+} from "../../service-adapters/events";
 import telemetry from "../telemetry-client";
 import { RemoteLangGraphEventSource } from "../../agents/langgraph/event-source";
 import { Action } from "@copilotkit/shared";
 import { LangGraphEvent } from "../../agents/langgraph/events";
 import { execute } from "./remote-lg-action";
 import { CopilotKitError, CopilotKitLowLevelError } from "@copilotkit/shared";
+import { writeJsonLineResponseToEventStream } from "../streaming";
 import { CopilotKitApiDiscoveryError, ResolvedCopilotKitError } from "@copilotkit/shared";
 import { parseJson, tryMap } from "@copilotkit/shared";
 import { ActionInput } from "../../graphql/inputs/action.input";
@@ -39,14 +44,14 @@ export function constructLGCRemoteAction({
     description: agent.description,
     parameters: [],
     handler: async (_args: any) => {},
-    langGraphAgentHandler: async ({
+    remoteAgentHandler: async ({
       name,
       actionInputsWithoutAgents,
       threadId,
       nodeName,
       additionalMessages = [],
       metaEvents,
-    }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
+    }: RemoteAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
       logger.debug({ actionName: agent.name }, "Executing LangGraph Platform agent");
 
       telemetry.capture("oss.runtime.remote_action_executed", {
@@ -87,7 +92,7 @@ export function constructLGCRemoteAction({
         });
 
         const eventSource = new RemoteLangGraphEventSource();
-        streamResponse(response, eventSource.eventStream$);
+        writeJsonLineResponseToEventStream(response, eventSource.eventStream$);
         return eventSource.processLangGraphEvents();
       } catch (error) {
         logger.error(
@@ -102,6 +107,11 @@ export function constructLGCRemoteAction({
   return [...agents];
 }
 
+export enum RemoteAgentType {
+  LangGraph = "langgraph",
+  CrewAI = "crewai",
+}
+
 export function constructRemoteActions({
   json,
   url,
@@ -183,14 +193,14 @@ export function constructRemoteActions({
         parameters: [],
         handler: async (_args: any) => {},
 
-        langGraphAgentHandler: async ({
+        remoteAgentHandler: async ({
           name,
           actionInputsWithoutAgents,
           threadId,
           nodeName,
           additionalMessages = [],
           metaEvents,
-        }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
+        }: RemoteAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
           logger.debug({ actionName: agent.name }, "Executing remote agent");
 
           const headers = createHeaders(onBeforeRequest, graphqlContext);
@@ -247,9 +257,17 @@ export function constructRemoteActions({
               });
             }
 
-            const eventSource = new RemoteLangGraphEventSource();
-            streamResponse(response.body!, eventSource.eventStream$);
-            return eventSource.processLangGraphEvents();
+            if (agent.type === RemoteAgentType.LangGraph) {
+              const eventSource = new RemoteLangGraphEventSource();
+              writeJsonLineResponseToEventStream(response.body!, eventSource.eventStream$);
+              return eventSource.processLangGraphEvents();
+            } else if (agent.type === RemoteAgentType.CrewAI) {
+              const eventStream$ = new RuntimeEventSubject();
+              writeJsonLineResponseToEventStream(response.body!, eventStream$);
+              return eventStream$;
+            } else {
+              throw new Error("Unsupported agent type");
+            }
           } catch (error) {
             if (error instanceof CopilotKitError) {
               throw error;
@@ -263,64 +281,6 @@ export function constructRemoteActions({
   return [...actions, ...agents];
 }
 
-async function streamResponse(
-  response: ReadableStream<Uint8Array>,
-  eventStream$: ReplaySubject<LangGraphEvent>,
-) {
-  const reader = response.getReader();
-  const decoder = new TextDecoder();
-  let buffer = [];
-
-  function flushBuffer() {
-    const currentBuffer = buffer.join("");
-    if (currentBuffer.trim().length === 0) {
-      return;
-    }
-    const parts = currentBuffer.split("\n");
-    if (parts.length === 0) {
-      return;
-    }
-
-    const lastPartIsComplete = currentBuffer.endsWith("\n");
-
-    // truncate buffer
-    buffer = [];
-
-    if (!lastPartIsComplete) {
-      // put back the last part
-      buffer.push(parts.pop());
-    }
-
-    parts
-      .map((part) => part.trim())
-      .filter((part) => part != "")
-      .forEach((part) => {
-        eventStream$.next(JSON.parse(part));
-      });
-  }
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-
-      if (!done) {
-        buffer.push(decoder.decode(value, { stream: true }));
-      }
-
-      flushBuffer();
-
-      if (done) {
-        break;
-      }
-    }
-  } catch (error) {
-    console.error("Error in stream", error);
-    eventStream$.error(error);
-    return;
-  }
-  eventStream$.complete();
-}
-
 export function createHeaders(
   onBeforeRequest: CopilotKitEndpoint["onBeforeRequest"],
   graphqlContext: GraphQLContext,

package/src/lib/runtime/remote-actions.ts

@@ -54,7 +54,7 @@ export type RemoteActionInfoResponse = {
   agents: any[];
 };
 
-export type LangGraphAgentHandlerParams = {
+export type RemoteAgentHandlerParams = {
   name: string;
   actionInputsWithoutAgents: ActionInput[];
   threadId?: string;
@@ -63,15 +63,15 @@ export type LangGraphAgentHandlerParams = {
   metaEvents?: MetaEventInput[];
 };
 
-export type LangGraphAgentAction = Action<any> & {
-  langGraphAgentHandler: (params: LangGraphAgentHandlerParams) => Promise<Observable<RuntimeEvent>>;
+export type RemoteAgentAction = Action<any> & {
+  remoteAgentHandler: (params: RemoteAgentHandlerParams) => Promise<Observable<RuntimeEvent>>;
 };
 
-export function isLangGraphAgentAction(action: Action<any>): action is LangGraphAgentAction {
+export function isRemoteAgentAction(action: Action<any>): action is RemoteAgentAction {
   if (!action) {
     return false;
   }
-  return typeof (action as LangGraphAgentAction).langGraphAgentHandler === "function";
+  return typeof (action as RemoteAgentAction).remoteAgentHandler === "function";
 }
 
 async function fetchRemoteInfo({

package/src/lib/streaming.ts

@@ -0,0 +1,59 @@
+import { ReplaySubject } from "rxjs";
+
+export async function writeJsonLineResponseToEventStream<T>(
+  response: ReadableStream<Uint8Array>,
+  eventStream$: ReplaySubject<T>,
+) {
+  const reader = response.getReader();
+  const decoder = new TextDecoder();
+  let buffer = [];
+
+  function flushBuffer() {
+    const currentBuffer = buffer.join("");
+    if (currentBuffer.trim().length === 0) {
+      return;
+    }
+    const parts = currentBuffer.split("\n");
+    if (parts.length === 0) {
+      return;
+    }
+
+    const lastPartIsComplete = currentBuffer.endsWith("\n");
+
+    // truncate buffer
+    buffer = [];
+
+    if (!lastPartIsComplete) {
+      // put back the last part
+      buffer.push(parts.pop());
+    }
+
+    parts
+      .map((part) => part.trim())
+      .filter((part) => part != "")
+      .forEach((part) => {
+        eventStream$.next(JSON.parse(part));
+      });
+  }
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (!done) {
+        buffer.push(decoder.decode(value, { stream: true }));
+      }
+
+      flushBuffer();
+
+      if (done) {
+        break;
+      }
+    }
+  } catch (error) {
+    console.error("Error in stream", error);
+    eventStream$.error(error);
+    return;
+  }
+  eventStream$.complete();
+}

package/src/service-adapters/events.ts

@@ -14,7 +14,7 @@ import {
 import { streamLangChainResponse } from "./langchain/utils";
 import { GuardrailsResult } from "../graphql/types/guardrails-result.type";
 import telemetry from "../lib/telemetry-client";
-import { isLangGraphAgentAction } from "../lib/runtime/remote-actions";
+import { isRemoteAgentAction } from "../lib/runtime/remote-actions";
 import { ActionInput } from "../graphql/inputs/action.input";
 import { ActionExecutionMessage, ResultMessage, TextMessage } from "../graphql/types/converted";
 import { plainToInstance } from "class-transformer";
@@ -372,7 +372,7 @@ async function executeAction(
   }
 
   // handle LangGraph agents
-  if (isLangGraphAgentAction(action)) {
+  if (isRemoteAgentAction(action)) {
     const result = `${action.name} agent started`;
 
     const agentExecution = plainToInstance(ActionExecutionMessage, {
@@ -397,7 +397,7 @@ async function executeAction(
       result,
     });
 
-    const stream = await action.langGraphAgentHandler({
+    const stream = await action.remoteAgentHandler({
       name: action.name,
       threadId,
       actionInputsWithoutAgents,