@copilotkit/runtime 1.3.15 → 1.4.0-pre-1-4-0.0

package/src/agents/langgraph/event-source.ts

@@ -1,5 +1,5 @@
 import { ReplaySubject, scan, mergeMap, catchError } from "rxjs";
-import { LangGraphEvent, LangGraphEventTypes } from "./events";
+import { CustomEventNames, LangGraphEvent, LangGraphEventTypes } from "./events";
 import { RuntimeEvent, RuntimeEventTypes } from "../../service-adapters/events";
 import { randomId } from "@copilotkit/shared";
 
@@ -15,63 +15,7 @@ interface LangGraphEventWithState {
 }
 
 export class RemoteLangGraphEventSource {
-  private eventStream$ = new ReplaySubject<LangGraphEvent>();
-
-  async streamResponse(response: Response) {
-    const reader = response.body!.getReader();
-    const decoder = new TextDecoder();
-    let buffer = [];
-    const eventStream$ = this.eventStream$;
-
-    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();
-  }
+  public eventStream$ = new ReplaySubject<LangGraphEvent>();
 
   private shouldEmitToolCall(
     shouldEmitToolCalls: string | string[] | boolean,
@@ -93,7 +37,7 @@ export class RemoteLangGraphEventSource {
       scan(
         (acc, event) => {
           if (event.event === LangGraphEventTypes.OnChatModelStream) {
-            // @ts-ignore
+            // @ts-expect-error -- LangGraph Cloud implementation stores data outside of kwargs
             const content = event.data?.chunk?.kwargs?.content ?? event.data?.chunk?.content;
 
             if (typeof content === "string") {
@@ -104,20 +48,28 @@ export class RemoteLangGraphEventSource {
               acc.content = null;
             }
 
-            if (event.data?.chunk?.kwargs?.tool_call_chunks) {
+            const toolCallChunks =
+              // @ts-expect-error -- LangGraph Cloud implementation stores data outside of kwargs
+              event.data?.chunk?.kwargs?.tool_call_chunks ?? event.data?.chunk?.tool_call_chunks;
+
+            const toolCallMessageId =
+              event.data?.chunk?.kwargs?.id ??
+              (event.data?.chunk?.id as unknown as string | undefined);
+
+            if (toolCallChunks && toolCallChunks.length > 0) {
               acc.prevToolCallMessageId = acc.toolCallMessageId;
-              acc.toolCallMessageId = event.data.chunk.kwargs?.id;
-              if (event.data.chunk.kwargs.tool_call_chunks[0]?.name) {
-                acc.toolCallName = event.data.chunk.kwargs.tool_call_chunks[0].name;
+              acc.toolCallMessageId = toolCallMessageId;
+              if (toolCallChunks[0]?.name) {
+                acc.toolCallName = toolCallChunks[0].name;
               }
-              if (event.data.chunk.kwargs.tool_call_chunks[0]?.id) {
-                acc.toolCallId = event.data.chunk.kwargs.tool_call_chunks[0].id;
+              if (toolCallChunks[0]?.id) {
+                acc.toolCallId = toolCallChunks[0].id;
               }
               acc.prevMessageId = acc.messageId;
-              acc.messageId = event.data?.chunk?.kwargs?.id;
+              acc.messageId = toolCallMessageId;
             } else if (acc.content && acc.content != "") {
               acc.prevMessageId = acc.messageId;
-              acc.messageId = event.data?.chunk?.kwargs?.id;
+              acc.messageId = toolCallMessageId;
             } else {
               acc.prevToolCallMessageId = acc.toolCallMessageId;
               acc.prevMessageId = acc.messageId;
@@ -183,32 +135,45 @@ export class RemoteLangGraphEventSource {
         }
 
         switch (eventWithState.event!.event) {
-          case LangGraphEventTypes.OnCopilotKitEmitMessage:
-            events.push({
-              type: RuntimeEventTypes.TextMessageStart,
-              messageId: eventWithState.event.message_id,
-            });
-            events.push({
-              type: RuntimeEventTypes.TextMessageContent,
-              content: eventWithState.event.message,
-            });
-            events.push({
-              type: RuntimeEventTypes.TextMessageEnd,
-            });
-            break;
-          case LangGraphEventTypes.OnCopilotKitEmitToolCall:
-            events.push({
-              type: RuntimeEventTypes.ActionExecutionStart,
-              actionExecutionId: eventWithState.event.id,
-              actionName: eventWithState.event.name,
-            });
-            events.push({
-              type: RuntimeEventTypes.ActionExecutionArgs,
-              args: JSON.stringify(eventWithState.event.args),
-            });
-            events.push({
-              type: RuntimeEventTypes.ActionExecutionEnd,
-            });
+          //
+          // Custom events
+          //
+          case LangGraphEventTypes.OnCustomEvent:
+            //
+            // Manually emit a message
+            //
+            if (eventWithState.event.name === CustomEventNames.CopilotKitManuallyEmitMessage) {
+              events.push({
+                type: RuntimeEventTypes.TextMessageStart,
+                messageId: eventWithState.event.data.message_id,
+              });
+              events.push({
+                type: RuntimeEventTypes.TextMessageContent,
+                content: eventWithState.event.data.message,
+              });
+              events.push({
+                type: RuntimeEventTypes.TextMessageEnd,
+              });
+            }
+            //
+            // Manually emit a tool call
+            //
+            else if (
+              eventWithState.event.name === CustomEventNames.CopilotKitManuallyEmitToolCall
+            ) {
+              events.push({
+                type: RuntimeEventTypes.ActionExecutionStart,
+                actionExecutionId: eventWithState.event.data.id,
+                actionName: eventWithState.event.data.name,
+              });
+              events.push({
+                type: RuntimeEventTypes.ActionExecutionArgs,
+                args: JSON.stringify(eventWithState.event.data.args),
+              });
+              events.push({
+                type: RuntimeEventTypes.ActionExecutionEnd,
+              });
+            }
             break;
           case LangGraphEventTypes.OnCopilotKitStateSync:
             events.push({
@@ -266,7 +231,10 @@ export class RemoteLangGraphEventSource {
               }
             }
 
-            const args = eventWithState.event.data?.chunk?.kwargs?.tool_call_chunks?.[0]?.args;
+            const args =
+              eventWithState.event.data?.chunk?.kwargs?.tool_call_chunks?.[0]?.args ??
+              // @ts-expect-error -- sdf
+              eventWithState.event.data?.chunk?.tool_call_chunks?.[0]?.args;
             const content = eventWithState.content;
 
             // Tool call args: emit ActionExecutionArgs

package/src/agents/langgraph/events.ts

@@ -8,8 +8,13 @@ export enum LangGraphEventTypes {
   OnToolStart = "on_tool_start",
   OnToolEnd = "on_tool_end",
   OnCopilotKitStateSync = "on_copilotkit_state_sync",
-  OnCopilotKitEmitMessage = "on_copilotkit_emit_message",
-  OnCopilotKitEmitToolCall = "on_copilotkit_emit_tool_call",
+  OnCustomEvent = "on_custom_event",
+}
+
+export enum CustomEventNames {
+  CopilotKitManuallyEmitMessage = "copilotkit_manually_emit_message",
+  CopilotKitManuallyEmitToolCall = "copilotkit_manually_emit_tool_call",
+  CopilotKitManuallyEmitIntermediateState = "copilotkit_manually_emit_intermediate_state",
 }
 
 type LangGraphOnCopilotKitStateSyncEvent = {
@@ -24,19 +29,6 @@ type LangGraphOnCopilotKitStateSyncEvent = {
   running: boolean;
 };
 
-type LangGraphOnCopilotKitManualMessageEvent = {
-  event: LangGraphEventTypes.OnCopilotKitEmitMessage;
-  message: string;
-  message_id: string;
-};
-
-type LangGraphOnCopilotKitEmitToolCallEvent = {
-  event: LangGraphEventTypes.OnCopilotKitEmitToolCall;
-  name: string;
-  args: any;
-  id: string;
-};
-
 type LangGraphOnChainStartEvent = {
   event: LangGraphEventTypes.OnChainStart;
   run_id: string;
@@ -312,6 +304,24 @@ type LangGraphOnToolEndEvent = {
   parent_ids: string[];
 };
 
+type LangGraphOnCustomEvent = {
+  event: LangGraphEventTypes.OnCustomEvent;
+  run_id: string;
+  name: string;
+  tags: string[];
+  metadata: {
+    thread_id: string;
+    langgraph_step: number;
+    langgraph_node: string;
+    langgraph_triggers: string[];
+    langgraph_path: [string, string];
+    langgraph_checkpoint_ns: string;
+    checkpoint_ns: string;
+  };
+  data: any;
+  parent_ids: string[];
+};
+
 export type LangGraphEvent =
   | LangGraphOnChainStartEvent
   | LangGraphOnChainStreamEvent
@@ -322,5 +332,4 @@ export type LangGraphEvent =
   | LangGraphOnToolStartEvent
   | LangGraphOnToolEndEvent
   | LangGraphOnCopilotKitStateSyncEvent
-  | LangGraphOnCopilotKitManualMessageEvent
-  | LangGraphOnCopilotKitEmitToolCallEvent;
+  | LangGraphOnCustomEvent;

package/src/graphql/types/converted/index.ts

@@ -7,7 +7,11 @@ import {
 import { BaseMessageInput } from "../base";
 import { ActionExecutionScope, MessageRole } from "../enums";
 
-type MessageType = "TextMessage" | "ActionExecutionMessage" | "ResultMessage" | "AgentStateMessage";
+export type MessageType =
+  | "TextMessage"
+  | "ActionExecutionMessage"
+  | "ResultMessage"
+  | "AgentStateMessage";
 
 export class Message extends BaseMessageInput {
   type: MessageType;

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

@@ -12,19 +12,22 @@
  * ```
  */
 
-import { Action, actionParametersToJsonSchema, Parameter, randomId } from "@copilotkit/shared";
-import { RemoteChain, RemoteChainParameters, CopilotServiceAdapter } from "../../service-adapters";
+import { Action, actionParametersToJsonSchema, Parameter } from "@copilotkit/shared";
+import { CopilotServiceAdapter, RemoteChain, RemoteChainParameters } from "../../service-adapters";
 import { MessageInput } from "../../graphql/inputs/message.input";
 import { ActionInput } from "../../graphql/inputs/action.input";
 import { RuntimeEventSource } from "../../service-adapters/events";
 import { convertGqlInputToMessages } from "../../service-adapters/conversion";
-import { AgentStateMessage, Message } from "../../graphql/types/converted";
+import { Message } from "../../graphql/types/converted";
 import { ForwardedParametersInput } from "../../graphql/inputs/forwarded-parameters.input";
 import {
-  setupRemoteActions,
-  RemoteActionDefinition,
-  LangGraphAgentAction,
   isLangGraphAgentAction,
+  LangGraphAgentAction,
+  EndpointType,
+  setupRemoteActions,
+  EndpointDefinition,
+  CopilotKitEndpoint,
+  LangGraphCloudEndpoint,
 } from "./remote-actions";
 import { GraphQLContext } from "../integrations/shared";
 import { AgentSessionInput } from "../../graphql/inputs/agent-session.input";
@@ -121,10 +124,15 @@ export interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []
    */
   actions?: ActionsConfiguration<T>;
 
+  /*
+   * Deprecated: See `remoteEndpoints`.
+   */
+  remoteActions?: EndpointDefinition[];
+
   /*
    * A list of remote actions that can be executed.
    */
-  remoteActions?: RemoteActionDefinition[];
+  remoteEndpoints?: EndpointDefinition[];
 
   /*
    * An array of LangServer URLs.
@@ -134,7 +142,7 @@ export interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []
 
 export class CopilotRuntime<const T extends Parameter[] | [] = []> {
   public actions: ActionsConfiguration<T>;
-  private remoteActionDefinitions: RemoteActionDefinition[];
+  private remoteEndpointDefinitions: EndpointDefinition[];
   private langserve: Promise<Action<any>>[] = [];
   private onBeforeRequest?: OnBeforeRequestHandler;
   private onAfterRequest?: OnAfterRequestHandler;
@@ -147,7 +155,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       this.langserve.push(remoteChain.toAction());
     }
 
-    this.remoteActionDefinitions = params?.remoteActions || [];
+    this.remoteEndpointDefinitions = params?.remoteEndpoints || [];
 
     this.onBeforeRequest = params?.middleware?.onBeforeRequest;
     this.onAfterRequest = params?.middleware?.onAfterRequest;
@@ -244,7 +252,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
     request: CopilotRuntimeRequest,
   ): Promise<CopilotRuntimeResponse> {
     const { messages: rawMessages, outputMessagesPromise, graphqlContext, agentSession } = request;
-    const { threadId = randomId(), agentName, nodeName } = agentSession;
+    const { threadId, agentName, nodeName } = agentSession;
     const serverSideActions = await this.getServerSideActions(request);
 
     const messages = convertGqlInputToMessages(rawMessages);
@@ -331,8 +339,17 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
         console.error("Error loading langserve chain:", error);
       }
     }
+
+    const remoteEndpointDefinitions = this.remoteEndpointDefinitions.map(
+      (endpoint) =>
+        ({
+          ...endpoint,
+          type: this.resolveEndpointType(endpoint),
+        }) as EndpointDefinition,
+    );
+
     const remoteActions = await setupRemoteActions({
-      remoteActionDefinitions: this.remoteActionDefinitions,
+      remoteEndpointDefinitions,
       graphqlContext,
       messages: inputMessages,
       agentStates,
@@ -346,6 +363,19 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
 
     return [...configuredActions, ...langserveFunctions, ...remoteActions];
   }
+
+  private resolveEndpointType(endpoint: EndpointDefinition) {
+    if (
+      !endpoint.type &&
+      "langsmithApiKey" in endpoint &&
+      "deploymentUrl" in endpoint &&
+      "agents" in endpoint
+    ) {
+      return EndpointType.LangGraphCloud;
+    }
+
+    return endpoint.type;
+  }
 }
 
 export function flattenToolCallsNoDuplicates(toolsByPriority: ActionInput[]): ActionInput[] {
@@ -359,3 +389,20 @@ export function flattenToolCallsNoDuplicates(toolsByPriority: ActionInput[]): Ac
   }
   return allTools;
 }
+
+// The two functions below are "factory functions", meant to create the action objects that adhere to the expected interfaces
+export function copilotKitEndpoint(config: Omit<CopilotKitEndpoint, "type">): CopilotKitEndpoint {
+  return {
+    ...config,
+    type: EndpointType.CopilotKit,
+  };
+}
+
+export function langGraphCloudEndpoint(
+  config: Omit<LangGraphCloudEndpoint, "type">,
+): LangGraphCloudEndpoint {
+  return {
+    ...config,
+    type: EndpointType.LangGraphCloud,
+  };
+}

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

@@ -0,0 +1,284 @@
+import {
+  CopilotKitEndpoint,
+  LangGraphAgentHandlerParams,
+  RemoteActionInfoResponse,
+  LangGraphCloudEndpoint,
+} from "./remote-actions";
+import { GraphQLContext } from "../integrations";
+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 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-cloud-action";
+
+export function constructLGCRemoteAction({
+  endpoint,
+  graphqlContext,
+  logger,
+  messages,
+  agentStates,
+}: {
+  endpoint: LangGraphCloudEndpoint;
+  graphqlContext: GraphQLContext;
+  logger: Logger;
+  messages: Message[];
+  agentStates?: AgentStateInput[];
+}) {
+  const agents = endpoint.agents.map((agent) => ({
+    name: agent.name,
+    description: agent.description,
+    parameters: [],
+    handler: async (_args: any) => {},
+    langGraphAgentHandler: async ({
+      name,
+      actionInputsWithoutAgents,
+      threadId,
+      nodeName,
+    }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
+      logger.debug({ actionName: agent.name }, "Executing LangGraph Cloud agent");
+
+      telemetry.capture("oss.runtime.remote_action_executed", {});
+
+      let state = {};
+      if (agentStates) {
+        const jsonState = agentStates.find((state) => state.agentName === name)?.state;
+        if (jsonState) {
+          state = JSON.parse(jsonState);
+        }
+      }
+
+      try {
+        const response = await execute({
+          logger,
+          deploymentUrl: endpoint.deploymentUrl,
+          langsmithApiKey: endpoint.langsmithApiKey,
+          agent,
+          threadId,
+          nodeName,
+          messages,
+          state,
+          properties: graphqlContext.properties,
+          actions: actionInputsWithoutAgents.map((action) => ({
+            name: action.name,
+            description: action.description,
+            parameters: JSON.parse(action.jsonSchema) as string,
+          })),
+        });
+
+        const eventSource = new RemoteLangGraphEventSource();
+        streamResponse(response, eventSource.eventStream$);
+        return eventSource.processLangGraphEvents();
+      } catch (error) {
+        logger.error(
+          { url: endpoint.deploymentUrl, status: 500, body: error.message },
+          "Failed to execute LangGraph Cloud agent",
+        );
+        throw new Error("Failed to execute LangGraph Cloud agent");
+      }
+    },
+  }));
+
+  return [...agents];
+}
+
+export function constructRemoteActions({
+  json,
+  url,
+  onBeforeRequest,
+  graphqlContext,
+  logger,
+  messages,
+  agentStates,
+}: {
+  json: RemoteActionInfoResponse;
+  url: string;
+  onBeforeRequest?: CopilotKitEndpoint["onBeforeRequest"];
+  graphqlContext: GraphQLContext;
+  logger: Logger;
+  messages: Message[];
+  agentStates?: AgentStateInput[];
+}): Action<any>[] {
+  const actions = json["actions"].map((action) => ({
+    name: action.name,
+    description: action.description,
+    parameters: action.parameters,
+    handler: async (args: any) => {
+      logger.debug({ actionName: action.name, args }, "Executing remote action");
+
+      const headers = createHeaders(onBeforeRequest, graphqlContext);
+      telemetry.capture("oss.runtime.remote_action_executed", {});
+
+      try {
+        const response = await fetch(`${url}/actions/execute`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            name: action.name,
+            arguments: args,
+            properties: graphqlContext.properties,
+          }),
+        });
+
+        if (!response.ok) {
+          logger.error(
+            { url, status: response.status, body: await response.text() },
+            "Failed to execute remote action",
+          );
+          return "Failed to execute remote action";
+        }
+
+        const requestResult = await response.json();
+
+        const result = requestResult["result"];
+        logger.debug({ actionName: action.name, result }, "Executed remote action");
+        return result;
+      } catch (error) {
+        logger.error(
+          { error: error.message ? error.message : error + "" },
+          "Failed to execute remote action",
+        );
+        return "Failed to execute remote action";
+      }
+    },
+  }));
+
+  const agents = json["agents"].map((agent) => ({
+    name: agent.name,
+    description: agent.description,
+    parameters: [],
+    handler: async (_args: any) => {},
+
+    langGraphAgentHandler: async ({
+      name,
+      actionInputsWithoutAgents,
+      threadId,
+      nodeName,
+    }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
+      logger.debug({ actionName: agent.name }, "Executing remote agent");
+
+      const headers = createHeaders(onBeforeRequest, graphqlContext);
+      telemetry.capture("oss.runtime.remote_action_executed", {});
+
+      let state = {};
+      if (agentStates) {
+        const jsonState = agentStates.find((state) => state.agentName === name)?.state;
+        if (jsonState) {
+          state = JSON.parse(jsonState);
+        }
+      }
+
+      const response = await fetch(`${url}/agents/execute`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          name,
+          threadId,
+          nodeName,
+          messages,
+          state,
+          properties: graphqlContext.properties,
+          actions: actionInputsWithoutAgents.map((action) => ({
+            name: action.name,
+            description: action.description,
+            parameters: JSON.parse(action.jsonSchema),
+          })),
+        }),
+      });
+
+      if (!response.ok) {
+        logger.error(
+          { url, status: response.status, body: await response.text() },
+          "Failed to execute remote agent",
+        );
+        throw new Error("Failed to execute remote agent");
+      }
+
+      const eventSource = new RemoteLangGraphEventSource();
+      streamResponse(response.body!, eventSource.eventStream$);
+      return eventSource.processLangGraphEvents();
+    },
+  }));
+
+  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,
+) {
+  const headers = {
+    "Content-Type": "application/json",
+  };
+
+  if (onBeforeRequest) {
+    const { headers: additionalHeaders } = onBeforeRequest({ ctx: graphqlContext });
+    if (additionalHeaders) {
+      Object.assign(headers, additionalHeaders);
+    }
+  }
+
+  return headers;
+}