@copilotkit/runtime 1.3.16-mme-azure-openai.0 → 1.3.16-mme-sdk-js.2

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;
+}

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

@@ -1,20 +1,47 @@
 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, RuntimeEventSubject } from "../../service-adapters/events";
-import { RemoteLangGraphEventSource } from "../../agents/langgraph/event-source";
+import { RuntimeEvent } from "../../service-adapters/events";
 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 RemoteActionDefinition = {
+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> {
   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[];
@@ -39,24 +66,6 @@ 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,
@@ -65,7 +74,7 @@ async function fetchRemoteInfo({
   frontendUrl,
 }: {
   url: string;
-  onBeforeRequest?: RemoteActionDefinition["onBeforeRequest"];
+  onBeforeRequest?: CopilotKitEndpoint["onBeforeRequest"];
   graphqlContext: GraphQLContext;
   logger: Logger;
   frontendUrl?: string;
@@ -100,164 +109,61 @@ 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({
-  remoteActionDefinitions,
+  remoteEndpointDefinitions,
   graphqlContext,
   messages,
   agentStates,
   frontendUrl,
 }: {
-  remoteActionDefinitions: RemoteActionDefinition[];
+  remoteEndpointDefinitions: EndpointDefinition[];
   graphqlContext: GraphQLContext;
   messages: Message[];
   agentStates?: AgentStateInput[];
   frontendUrl?: string;
 }): Promise<Action[]> {
   const logger = graphqlContext.logger.child({ component: "remote-actions.fetchRemoteActions" });
-  logger.debug({ remoteActionDefinitions }, "Fetching remote actions");
+  logger.debug({ remoteEndpointDefinitions }, "Fetching from remote endpoints");
 
-  // Remove duplicates of remoteActionDefinitions.url
-  const filtered = remoteActionDefinitions.filter(
-    (value, index, self) => index === self.findIndex((t) => t.url === value.url),
-  );
+  // 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);
+  });
 
   const result = await Promise.all(
-    filtered.map(async (actionDefinition) => {
+    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,
+        });
+      }
+
       const json = await fetchRemoteInfo({
-        url: actionDefinition.url,
-        onBeforeRequest: actionDefinition.onBeforeRequest,
+        url: endpoint.url,
+        onBeforeRequest: endpoint.onBeforeRequest,
         graphqlContext,
-        logger: logger.child({ component: "remote-actions.fetchActionsFromUrl", actionDefinition }),
+        logger: logger.child({ component: "remote-actions.fetchActionsFromUrl", endpoint }),
         frontendUrl,
       });
+
       return constructRemoteActions({
         json,
         messages,
-        url: actionDefinition.url,
-        onBeforeRequest: actionDefinition.onBeforeRequest,
+        url: endpoint.url,
+        onBeforeRequest: endpoint.onBeforeRequest,
         graphqlContext,
-        logger: logger.child({ component: "remote-actions.constructActions", actionDefinition }),
+        logger: logger.child({ component: "remote-actions.constructActions", endpoint }),
         agentStates,
       });
     }),