@copilotkit/runtime 0.0.0-feat-dynamic-copilotcloud-qa-20250117190454

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

@@ -0,0 +1,304 @@
+import { createHash } from "node:crypto";
+import {
+  CopilotKitEndpoint,
+  LangGraphAgentHandlerParams,
+  RemoteActionInfoResponse,
+  LangGraphPlatformEndpoint,
+} 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-action";
+
+export function constructLGCRemoteAction({
+  endpoint,
+  graphqlContext,
+  logger,
+  messages,
+  agentStates,
+}: {
+  endpoint: LangGraphPlatformEndpoint;
+  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,
+      additionalMessages = [],
+    }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
+      logger.debug({ actionName: agent.name }, "Executing LangGraph Platform agent");
+
+      telemetry.capture("oss.runtime.remote_action_executed", {
+        agentExecution: true,
+        type: "langgraph-platform",
+        agentsAmount: endpoint.agents.length,
+        hashedLgcKey: createHash("sha256").update(endpoint.langsmithApiKey).digest("hex"),
+      });
+
+      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: [...messages, ...additionalMessages],
+          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 Platform agent",
+        );
+        throw new Error("Failed to execute LangGraph Platform 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 totalAgents = Array.isArray(json["agents"]) ? json["agents"].length : 0;
+
+  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", {
+        agentExecution: false,
+        type: "self-hosted",
+        agentsAmount: totalAgents,
+      });
+
+      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 = totalAgents
+    ? json["agents"].map((agent) => ({
+        name: agent.name,
+        description: agent.description,
+        parameters: [],
+        handler: async (_args: any) => {},
+
+        langGraphAgentHandler: async ({
+          name,
+          actionInputsWithoutAgents,
+          threadId,
+          nodeName,
+          additionalMessages = [],
+        }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
+          logger.debug({ actionName: agent.name }, "Executing remote agent");
+
+          const headers = createHeaders(onBeforeRequest, graphqlContext);
+          telemetry.capture("oss.runtime.remote_action_executed", {
+            agentExecution: true,
+            type: "self-hosted",
+            agentsAmount: json["agents"].length,
+          });
+
+          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: [...messages, ...additionalMessages],
+              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

@@ -0,0 +1,174 @@
+import { Action } from "@copilotkit/shared";
+import { GraphQLContext } from "../integrations/shared";
+import { Logger } from "pino";
+import { Message } from "../../graphql/types/converted";
+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 EndpointDefinition = CopilotKitEndpoint | LangGraphPlatformEndpoint;
+
+export enum EndpointType {
+  CopilotKit = "copilotKit",
+  LangGraphPlatform = "langgraph-platform",
+}
+
+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 LangGraphPlatformAgent {
+  name: string;
+  description: string;
+  assistantId?: string;
+}
+
+export interface LangGraphPlatformEndpoint
+  extends BaseEndpointDefinition<EndpointType.LangGraphPlatform> {
+  deploymentUrl: string;
+  langsmithApiKey: string;
+  agents: LangGraphPlatformAgent[];
+}
+
+export type RemoteActionInfoResponse = {
+  actions: any[];
+  agents: any[];
+};
+
+export type LangGraphAgentHandlerParams = {
+  name: string;
+  actionInputsWithoutAgents: ActionInput[];
+  threadId?: string;
+  nodeName?: string;
+  additionalMessages?: Message[];
+};
+
+export type LangGraphAgentAction = Action<any> & {
+  langGraphAgentHandler: (params: LangGraphAgentHandlerParams) => Promise<Observable<RuntimeEvent>>;
+};
+
+export function isLangGraphAgentAction(action: Action<any>): action is LangGraphAgentAction {
+  if (!action) {
+    return false;
+  }
+  return typeof (action as LangGraphAgentAction).langGraphAgentHandler === "function";
+}
+
+async function fetchRemoteInfo({
+  url,
+  onBeforeRequest,
+  graphqlContext,
+  logger,
+  frontendUrl,
+}: {
+  url: string;
+  onBeforeRequest?: CopilotKitEndpoint["onBeforeRequest"];
+  graphqlContext: GraphQLContext;
+  logger: Logger;
+  frontendUrl?: string;
+}): Promise<RemoteActionInfoResponse> {
+  logger.debug({ url }, "Fetching actions from url");
+  const headers = createHeaders(onBeforeRequest, graphqlContext);
+
+  try {
+    const response = await fetch(`${url}/info`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ properties: graphqlContext.properties, frontendUrl }),
+    });
+
+    if (!response.ok) {
+      logger.error(
+        { url, status: response.status, body: await response.text() },
+        "Failed to fetch actions from url",
+      );
+      return { actions: [], agents: [] };
+    }
+
+    const json = await response.json();
+    logger.debug({ json }, "Fetched actions from url");
+    return json;
+  } catch (error) {
+    logger.error(
+      { error: error.message ? error.message : error + "" },
+      "Failed to fetch actions from url",
+    );
+    return { actions: [], agents: [] };
+  }
+}
+
+export async function setupRemoteActions({
+  remoteEndpointDefinitions,
+  graphqlContext,
+  messages,
+  agentStates,
+  frontendUrl,
+}: {
+  remoteEndpointDefinitions: EndpointDefinition[];
+  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");
+
+  // Remove duplicates of remoteEndpointDefinitions.url
+  const filtered = remoteEndpointDefinitions.filter((value, index, self) => {
+    if (value.type === EndpointType.LangGraphPlatform) {
+      return value;
+    }
+    return index === self.findIndex((t: CopilotKitEndpoint) => t.url === value.url);
+  });
+
+  const result = await Promise.all(
+    filtered.map(async (endpoint) => {
+      // Check for properties that can distinguish LG platform from other actions
+      if (endpoint.type === EndpointType.LangGraphPlatform) {
+        return constructLGCRemoteAction({
+          endpoint,
+          messages,
+          graphqlContext,
+          logger: logger.child({
+            component: "remote-actions.constructLGCRemoteAction",
+            endpoint,
+          }),
+          agentStates,
+        });
+      }
+
+      const json = await fetchRemoteInfo({
+        url: endpoint.url,
+        onBeforeRequest: endpoint.onBeforeRequest,
+        graphqlContext,
+        logger: logger.child({ component: "remote-actions.fetchActionsFromUrl", endpoint }),
+        frontendUrl,
+      });
+
+      return constructRemoteActions({
+        json,
+        messages,
+        url: endpoint.url,
+        onBeforeRequest: endpoint.onBeforeRequest,
+        graphqlContext,
+        logger: logger.child({ component: "remote-actions.constructActions", endpoint }),
+        agentStates,
+      });
+    }),
+  );
+
+  return result.flat();
+}