@copilotkit/runtime 1.6.0 → 1.7.0-next.1

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,

package/dist/chunk-DFOKBSIS.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-DFOKBSIS.mjs.map