@copilotkit/runtime 1.10.7-next.0 → 1.50.0-beta.0

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

@@ -1,331 +0,0 @@
-import { createHash } from "node:crypto";
-import {
-  CopilotKitEndpoint,
-  RemoteAgentHandlerParams,
-  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 } from "rxjs";
-import { RuntimeEvent, RuntimeEventSubject } from "../../service-adapters/events";
-import telemetry from "../telemetry-client";
-import { RemoteLangGraphEventSource } from "../../agents/langgraph/event-source";
-import { Action } from "@copilotkit/shared";
-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";
-import { fetchWithRetry } from "./retry-utils";
-
-// Import the utility function from remote-lg-action
-import { isUserConfigurationError } 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) => {},
-    remoteAgentHandler: async ({
-      name,
-      actionInputsWithoutAgents,
-      threadId,
-      nodeName,
-      additionalMessages = [],
-      metaEvents,
-    }: RemoteAgentHandlerParams): 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: endpoint.langsmithApiKey
-          ? createHash("sha256").update(endpoint.langsmithApiKey).digest("hex")
-          : null,
-      });
-
-      let state = {};
-      let config = {};
-      if (agentStates) {
-        const jsonState = agentStates.find((state) => state.agentName === name);
-        if (jsonState) {
-          state = parseJson(jsonState.state, {});
-          config = parseJson(jsonState.config, {});
-        }
-      }
-
-      try {
-        const response = await execute({
-          logger: logger.child({ component: "remote-actions.remote-lg-action.streamEvents" }),
-          deploymentUrl: endpoint.deploymentUrl,
-          langsmithApiKey: endpoint.langsmithApiKey,
-          agent,
-          threadId,
-          nodeName,
-          messages: [...messages, ...additionalMessages],
-          state,
-          config,
-          properties: graphqlContext.properties,
-          actions: tryMap(actionInputsWithoutAgents, (action: ActionInput) => ({
-            name: action.name,
-            description: action.description,
-            parameters: JSON.parse(action.jsonSchema),
-          })),
-          metaEvents,
-        });
-
-        const eventSource = new RemoteLangGraphEventSource();
-        writeJsonLineResponseToEventStream(response, eventSource.eventStream$);
-        return eventSource.processLangGraphEvents();
-      } catch (error) {
-        // Preserve structured CopilotKit errors with semantic information
-        if (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) {
-          // Distinguish between user errors and system errors for logging
-          if (isUserConfigurationError(error)) {
-            logger.debug(
-              { url: endpoint.deploymentUrl, error: error.message, code: error.code },
-              "User configuration error in LangGraph Platform agent",
-            );
-          } else {
-            logger.error(
-              { url: endpoint.deploymentUrl, error: error.message, type: error.constructor.name },
-              "LangGraph Platform agent error",
-            );
-          }
-          throw error; // Re-throw the structured error to preserve semantic information
-        }
-
-        // For other errors, log and wrap them
-        logger.error(
-          { url: endpoint.deploymentUrl, status: 500, body: error.message },
-          "Failed to execute LangGraph Platform agent",
-        );
-        throw new CopilotKitLowLevelError({
-          error: error instanceof Error ? error : new Error(String(error)),
-          url: endpoint.deploymentUrl,
-          message: "Failed to execute LangGraph Platform agent",
-        });
-      }
-    },
-  }));
-
-  return [...agents];
-}
-
-export enum RemoteAgentType {
-  LangGraph = "langgraph",
-  CrewAI = "crewai",
-}
-
-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,
-      });
-
-      const fetchUrl = `${url}/actions/execute`;
-      try {
-        const response = await fetchWithRetry(
-          fetchUrl,
-          {
-            method: "POST",
-            headers,
-            body: JSON.stringify({
-              name: action.name,
-              arguments: args,
-              properties: graphqlContext.properties,
-            }),
-          },
-          logger,
-        );
-
-        if (!response.ok) {
-          logger.error(
-            { url, status: response.status, body: await response.text() },
-            "Failed to execute remote action",
-          );
-          if (response.status === 404) {
-            throw new CopilotKitApiDiscoveryError({ url: fetchUrl });
-          }
-          throw new ResolvedCopilotKitError({
-            status: response.status,
-            url: fetchUrl,
-            isRemoteEndpoint: true,
-          });
-        }
-
-        const requestResult = await response.json();
-
-        const result = requestResult["result"];
-        logger.debug({ actionName: action.name, result }, "Executed remote action");
-        return result;
-      } catch (error) {
-        if (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) {
-          throw error;
-        }
-        throw new CopilotKitLowLevelError({ error, url: fetchUrl });
-      }
-    },
-  }));
-
-  const agents = totalAgents
-    ? json["agents"].map((agent) => ({
-        name: agent.name,
-        description: agent.description,
-        parameters: [],
-        handler: async (_args: any) => {},
-
-        remoteAgentHandler: async ({
-          name,
-          actionInputsWithoutAgents,
-          threadId,
-          nodeName,
-          additionalMessages = [],
-          metaEvents,
-        }: RemoteAgentHandlerParams): 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 = {};
-          let config = {};
-          if (agentStates) {
-            const jsonState = agentStates.find((state) => state.agentName === name);
-            if (jsonState) {
-              state = parseJson(jsonState.state, {});
-              config = parseJson(jsonState.config, {});
-            }
-          }
-
-          const fetchUrl = `${url}/agents/execute`;
-          try {
-            const response = await fetchWithRetry(
-              fetchUrl,
-              {
-                method: "POST",
-                headers,
-                body: JSON.stringify({
-                  name,
-                  threadId,
-                  nodeName,
-                  messages: [...messages, ...additionalMessages],
-                  state,
-                  config,
-                  properties: graphqlContext.properties,
-                  actions: tryMap(actionInputsWithoutAgents, (action: ActionInput) => ({
-                    name: action.name,
-                    description: action.description,
-                    parameters: JSON.parse(action.jsonSchema),
-                  })),
-                  metaEvents,
-                }),
-              },
-              logger,
-            );
-
-            if (!response.ok) {
-              logger.error(
-                { url, status: response.status, body: await response.text() },
-                "Failed to execute remote agent",
-              );
-              if (response.status === 404) {
-                throw new CopilotKitApiDiscoveryError({ url: fetchUrl });
-              }
-              throw new ResolvedCopilotKitError({
-                status: response.status,
-                url: fetchUrl,
-                isRemoteEndpoint: true,
-              });
-            }
-
-            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 || error instanceof CopilotKitLowLevelError) {
-              throw error;
-            }
-            throw new CopilotKitLowLevelError({ error, url: fetchUrl });
-          }
-        },
-      }))
-    : [];
-
-  return [...actions, ...agents];
-}
-
-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,217 +0,0 @@
-import { Action, CopilotKitErrorCode } from "@copilotkit/shared";
-import { GraphQLContext } from "../integrations/shared";
-import { Logger } from "pino";
-import { Message } from "../../graphql/types/converted";
-import { ActionInput } from "../../graphql/inputs/action.input";
-import { AgentStateInput } from "../../graphql/inputs/agent-state.input";
-import {
-  constructLGCRemoteAction,
-  constructRemoteActions,
-  createHeaders,
-} from "./remote-action-constructors";
-import {
-  CopilotKitLowLevelError,
-  ResolvedCopilotKitError,
-  CopilotKitError,
-} from "@copilotkit/shared";
-import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
-import { AbstractAgent } from "@ag-ui/client";
-import { constructAGUIRemoteAction, RemoteAgentAction } from "./agui-action";
-import { CopilotContextInput } from "../../graphql/inputs/copilot-context.input";
-
-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 | null;
-  agents: LangGraphPlatformAgent[];
-}
-
-export type RemoteActionInfoResponse = {
-  actions: any[];
-  agents: any[];
-};
-
-export type RemoteAgentHandlerParams = {
-  name: string;
-  actionInputsWithoutAgents: ActionInput[];
-  threadId?: string;
-  nodeName?: string;
-  additionalMessages?: Message[];
-  metaEvents?: MetaEventInput[];
-};
-
-export function isRemoteAgentAction(action: Action<any>): action is RemoteAgentAction {
-  if (!action) {
-    return false;
-  }
-  return typeof (action as RemoteAgentAction).remoteAgentHandler === "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);
-
-  const fetchUrl = `${url}/info`;
-  try {
-    const response = await fetch(fetchUrl, {
-      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",
-      );
-      throw new ResolvedCopilotKitError({
-        status: response.status,
-        url: fetchUrl,
-        isRemoteEndpoint: true,
-      });
-    }
-
-    const json = await response.json();
-    logger.debug({ json }, "Fetched actions from url");
-    return json;
-  } catch (error) {
-    if (error instanceof CopilotKitError) {
-      throw error;
-    }
-    throw new CopilotKitLowLevelError({ error, url: fetchUrl });
-  }
-}
-
-export async function setupRemoteActions({
-  remoteEndpointDefinitions,
-  graphqlContext,
-  messages,
-  agentStates,
-  frontendUrl,
-  agents,
-  metaEvents,
-  nodeName,
-  context,
-}: {
-  remoteEndpointDefinitions: EndpointDefinition[];
-  graphqlContext: GraphQLContext;
-  messages: Message[];
-  agentStates?: AgentStateInput[];
-  frontendUrl?: string;
-  agents: Record<string, AbstractAgent>;
-  metaEvents?: MetaEventInput[];
-  nodeName?: string;
-  context?: CopilotContextInput[];
-}): Promise<Action<any>[]> {
-  const logger = graphqlContext.logger.child({ component: "remote-actions.fetchRemoteActions" });
-  logger.debug({ remoteEndpointDefinitions }, "Fetching from remote endpoints");
-
-  const threadMetadata = (graphqlContext.properties?.threadMetadata as Record<string, any>) || {};
-
-  // 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,
-      });
-    }),
-  );
-
-  for (const [key, agent] of Object.entries(agents)) {
-    if (agent.agentId !== undefined && agent.agentId !== key) {
-      throw new CopilotKitError({
-        message: `Agent ${key} has agentId ${agent.agentId} which does not match the key ${key}`,
-        code: CopilotKitErrorCode.UNKNOWN,
-      });
-    } else if (agent.agentId === undefined) {
-      agent.agentId = key;
-    }
-
-    result.push(
-      constructAGUIRemoteAction({
-        logger,
-        messages,
-        agentStates,
-        agent: agent,
-        metaEvents,
-        threadMetadata,
-        nodeName,
-        graphqlContext,
-        context,
-      }),
-    );
-  }
-
-  return result.flat();
-}