@copilotkit/runtime 1.3.12-lgc-alpha-1.0 → 1.3.12

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

@@ -15,7 +15,63 @@ interface LangGraphEventWithState {
 }
 
 export class RemoteLangGraphEventSource {
-  public eventStream$ = new ReplaySubject<LangGraphEvent>();
+  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();
+  }
 
   private shouldEmitToolCall(
     shouldEmitToolCalls: string | string[] | boolean,
@@ -37,7 +93,7 @@ export class RemoteLangGraphEventSource {
       scan(
         (acc, event) => {
           if (event.event === LangGraphEventTypes.OnChatModelStream) {
-            // @ts-expect-error -- LangGraph Cloud implementation stores data outside of kwargs
+            // @ts-ignore
             const content = event.data?.chunk?.kwargs?.content ?? event.data?.chunk?.content;
 
             if (typeof content === "string") {
@@ -48,28 +104,20 @@ export class RemoteLangGraphEventSource {
               acc.content = null;
             }
 
-            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) {
+            if (event.data?.chunk?.kwargs?.tool_call_chunks) {
               acc.prevToolCallMessageId = acc.toolCallMessageId;
-              acc.toolCallMessageId = toolCallMessageId;
-              if (toolCallChunks[0]?.name) {
-                acc.toolCallName = toolCallChunks[0].name;
+              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;
               }
-              if (toolCallChunks[0]?.id) {
-                acc.toolCallId = toolCallChunks[0].id;
+              if (event.data.chunk.kwargs.tool_call_chunks[0]?.id) {
+                acc.toolCallId = event.data.chunk.kwargs.tool_call_chunks[0].id;
               }
               acc.prevMessageId = acc.messageId;
-              acc.messageId = toolCallMessageId;
+              acc.messageId = event.data?.chunk?.kwargs?.id;
             } else if (acc.content && acc.content != "") {
               acc.prevMessageId = acc.messageId;
-              acc.messageId = toolCallMessageId;
+              acc.messageId = event.data?.chunk?.kwargs?.id;
             } else {
               acc.prevToolCallMessageId = acc.toolCallMessageId;
               acc.prevMessageId = acc.messageId;
@@ -218,10 +266,7 @@ export class RemoteLangGraphEventSource {
               }
             }
 
-            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 args = eventWithState.event.data?.chunk?.kwargs?.tool_call_chunks?.[0]?.args;
             const content = eventWithState.content;
 
             // Tool call args: emit ActionExecutionArgs

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

@@ -12,22 +12,19 @@
  * ```
  */
 
-import { Action, actionParametersToJsonSchema, Parameter } from "@copilotkit/shared";
-import { CopilotServiceAdapter, RemoteChain, RemoteChainParameters } from "../../service-adapters";
+import { Action, actionParametersToJsonSchema, Parameter, randomId } from "@copilotkit/shared";
+import { RemoteChain, RemoteChainParameters, CopilotServiceAdapter } 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 { Message } from "../../graphql/types/converted";
+import { AgentStateMessage, Message } from "../../graphql/types/converted";
 import { ForwardedParametersInput } from "../../graphql/inputs/forwarded-parameters.input";
 import {
-  isLangGraphAgentAction,
-  LangGraphAgentAction,
-  EndpointType,
   setupRemoteActions,
-  EndpointDefinition,
-  CopilotKitEndpoint,
-  LangGraphCloudEndpoint,
+  RemoteActionDefinition,
+  LangGraphAgentAction,
+  isLangGraphAgentAction,
 } from "./remote-actions";
 import { GraphQLContext } from "../integrations/shared";
 import { AgentSessionInput } from "../../graphql/inputs/agent-session.input";
@@ -124,15 +121,10 @@ export interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []
    */
   actions?: ActionsConfiguration<T>;
 
-  /*
-   * Deprecated: See `remoteEndpoints`.
-   */
-  remoteActions?: EndpointDefinition[];
-
   /*
    * A list of remote actions that can be executed.
    */
-  remoteEndpoints?: EndpointDefinition[];
+  remoteActions?: RemoteActionDefinition[];
 
   /*
    * An array of LangServer URLs.
@@ -142,7 +134,7 @@ export interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []
 
 export class CopilotRuntime<const T extends Parameter[] | [] = []> {
   public actions: ActionsConfiguration<T>;
-  private remoteEndpointDefinitions: EndpointDefinition[];
+  private remoteActionDefinitions: RemoteActionDefinition[];
   private langserve: Promise<Action<any>>[] = [];
   private onBeforeRequest?: OnBeforeRequestHandler;
   private onAfterRequest?: OnAfterRequestHandler;
@@ -155,7 +147,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       this.langserve.push(remoteChain.toAction());
     }
 
-    this.remoteEndpointDefinitions = params?.remoteEndpoints || [];
+    this.remoteActionDefinitions = params?.remoteActions || [];
 
     this.onBeforeRequest = params?.middleware?.onBeforeRequest;
     this.onAfterRequest = params?.middleware?.onAfterRequest;
@@ -252,7 +244,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
     request: CopilotRuntimeRequest,
   ): Promise<CopilotRuntimeResponse> {
     const { messages: rawMessages, outputMessagesPromise, graphqlContext, agentSession } = request;
-    const { threadId, agentName, nodeName } = agentSession;
+    const { threadId = randomId(), agentName, nodeName } = agentSession;
     const serverSideActions = await this.getServerSideActions(request);
 
     const messages = convertGqlInputToMessages(rawMessages);
@@ -339,17 +331,8 @@ 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({
-      remoteEndpointDefinitions,
+      remoteActionDefinitions: this.remoteActionDefinitions,
       graphqlContext,
       messages: inputMessages,
       agentStates,
@@ -363,19 +346,6 @@ 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[] {
@@ -389,20 +359,3 @@ 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-actions.ts

@@ -1,47 +1,20 @@
 import { Action } from "@copilotkit/shared";
 import { GraphQLContext } from "../integrations/shared";
 import { Logger } from "pino";
+import telemetry from "../../lib/telemetry-client";
 import { Message } from "../../graphql/types/converted";
-import { RuntimeEvent } from "../../service-adapters/events";
+import { RuntimeEvent, RuntimeEventSubject } from "../../service-adapters/events";
+import { RemoteLangGraphEventSource } from "../../agents/langgraph/event-source";
 import { Observable } from "rxjs";
 import { ActionInput } from "../../graphql/inputs/action.input";
 import { AgentStateInput } from "../../graphql/inputs/agent-state.input";
-import {
-  constructLGCRemoteAction,
-  constructRemoteActions,
-  createHeaders,
-} from "./remote-action-constructors";
 
-export type EndpointDefinition = CopilotKitEndpoint | LangGraphCloudEndpoint;
-
-export enum EndpointType {
-  CopilotKit = "copilotKit",
-  LangGraphCloud = "langgraph-cloud",
-}
-
-export interface BaseEndpointDefinition<TActionType extends EndpointType> {
-  type?: TActionType;
-}
-
-export interface CopilotKitEndpoint extends BaseEndpointDefinition<EndpointType.CopilotKit> {
+export type RemoteActionDefinition = {
   url: string;
   onBeforeRequest?: ({ ctx }: { ctx: GraphQLContext }) => {
     headers?: Record<string, string> | undefined;
   };
-}
-
-export interface LangGraphCloudAgent {
-  name: string;
-  description: string;
-  assistantId?: string;
-}
-
-export interface LangGraphCloudEndpoint
-  extends BaseEndpointDefinition<EndpointType.LangGraphCloud> {
-  deploymentUrl: string;
-  langsmithApiKey: string;
-  agents: LangGraphCloudAgent[];
-}
+};
 
 export type RemoteActionInfoResponse = {
   actions: any[];
@@ -66,6 +39,24 @@ export function isLangGraphAgentAction(action: Action<any>): action is LangGraph
   return typeof (action as LangGraphAgentAction).langGraphAgentHandler === "function";
 }
 
+function createHeaders(
+  onBeforeRequest: RemoteActionDefinition["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;
+}
+
 async function fetchRemoteInfo({
   url,
   onBeforeRequest,
@@ -74,7 +65,7 @@ async function fetchRemoteInfo({
   frontendUrl,
 }: {
   url: string;
-  onBeforeRequest?: CopilotKitEndpoint["onBeforeRequest"];
+  onBeforeRequest?: RemoteActionDefinition["onBeforeRequest"];
   graphqlContext: GraphQLContext;
   logger: Logger;
   frontendUrl?: string;
@@ -109,61 +100,164 @@ async function fetchRemoteInfo({
   }
 }
 
+function constructRemoteActions({
+  json,
+  url,
+  onBeforeRequest,
+  graphqlContext,
+  logger,
+  messages,
+  agentStates,
+}: {
+  json: RemoteActionInfoResponse;
+  url: string;
+  onBeforeRequest?: RemoteActionDefinition["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();
+      eventSource.streamResponse(response);
+      return eventSource.processLangGraphEvents();
+    },
+  }));
+
+  return [...actions, ...agents];
+}
+
 export async function setupRemoteActions({
-  remoteEndpointDefinitions,
+  remoteActionDefinitions,
   graphqlContext,
   messages,
   agentStates,
   frontendUrl,
 }: {
-  remoteEndpointDefinitions: EndpointDefinition[];
+  remoteActionDefinitions: RemoteActionDefinition[];
   graphqlContext: GraphQLContext;
   messages: Message[];
   agentStates?: AgentStateInput[];
   frontendUrl?: string;
 }): Promise<Action[]> {
   const logger = graphqlContext.logger.child({ component: "remote-actions.fetchRemoteActions" });
-  logger.debug({ remoteEndpointDefinitions }, "Fetching from remote endpoints");
+  logger.debug({ remoteActionDefinitions }, "Fetching remote actions");
 
-  // Remove duplicates of remoteEndpointDefinitions.url
-  const filtered = remoteEndpointDefinitions.filter((value, index, self) => {
-    if (value.type === EndpointType.LangGraphCloud) {
-      return value;
-    }
-    return index === self.findIndex((t: CopilotKitEndpoint) => t.url === value.url);
-  });
+  // Remove duplicates of remoteActionDefinitions.url
+  const filtered = remoteActionDefinitions.filter(
+    (value, index, self) => index === self.findIndex((t) => t.url === value.url),
+  );
 
   const result = await Promise.all(
-    filtered.map(async (endpoint) => {
-      // Check for properties that can distinguish LG cloud from other actions
-      if (endpoint.type === EndpointType.LangGraphCloud) {
-        return constructLGCRemoteAction({
-          endpoint,
-          messages,
-          graphqlContext,
-          logger: logger.child({
-            component: "remote-actions.constructLGCRemoteAction",
-            endpoint,
-          }),
-          agentStates,
-        });
-      }
-
+    filtered.map(async (actionDefinition) => {
       const json = await fetchRemoteInfo({
-        url: endpoint.url,
-        onBeforeRequest: endpoint.onBeforeRequest,
+        url: actionDefinition.url,
+        onBeforeRequest: actionDefinition.onBeforeRequest,
         graphqlContext,
-        logger: logger.child({ component: "remote-actions.fetchActionsFromUrl", endpoint }),
+        logger: logger.child({ component: "remote-actions.fetchActionsFromUrl", actionDefinition }),
         frontendUrl,
       });
-
       return constructRemoteActions({
         json,
         messages,
-        url: endpoint.url,
-        onBeforeRequest: endpoint.onBeforeRequest,
+        url: actionDefinition.url,
+        onBeforeRequest: actionDefinition.onBeforeRequest,
         graphqlContext,
-        logger: logger.child({ component: "remote-actions.constructActions", endpoint }),
+        logger: logger.child({ component: "remote-actions.constructActions", actionDefinition }),
         agentStates,
       });
     }),

package/src/service-adapters/events.ts

@@ -260,7 +260,11 @@ async function executeAction(
   // Prepare arguments for function calling
   let args: Record<string, any>[] = [];
   if (actionArguments) {
-    args = JSON.parse(actionArguments);
+    try {
+      args = JSON.parse(actionArguments);
+    } catch (e) {
+      console.warn("Action argument unparsable", { actionArguments });
+    }
   }
 
   // handle LangGraph agents