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

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

@@ -1,283 +0,0 @@
-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({
-          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-lg-cloud-action.ts

@@ -1,441 +0,0 @@
-import { Client } from "@langchain/langgraph-sdk";
-import { randomUUID } from "node:crypto";
-import { parse as parsePartialJson } from "partial-json";
-import { ActionInput } from "../../graphql/inputs/action.input";
-import { LangGraphCloudAgent, LangGraphCloudEndpoint } from "./remote-actions";
-import { CopilotRequestContextProperties } from "../integrations";
-import { BaseMessageInput as CopilotKitBaseMessage } from "../../graphql/types/base";
-import { MessageRole } from "../../graphql/types/enums";
-
-type State = Record<string, any>;
-
-type ExecutionAction = Pick<ActionInput, "name" | "description"> & { parameters: string };
-
-interface ExecutionArgs extends Omit<LangGraphCloudEndpoint, "agents"> {
-  agent: LangGraphCloudAgent;
-  threadId: string;
-  nodeName: string;
-  messages: CopilotKitBaseMessage[];
-  state: State;
-  properties: CopilotRequestContextProperties;
-  actions: ExecutionAction[];
-}
-
-export async function execute(args: ExecutionArgs): Promise<ReadableStream<Uint8Array>> {
-  return new ReadableStream({
-    async start(controller) {
-      try {
-        await streamEvents(controller, args);
-        controller.close();
-      } catch (err) {}
-    },
-  });
-}
-
-async function streamEvents(controller: ReadableStreamDefaultController, args: ExecutionArgs) {
-  const {
-    deploymentUrl,
-    langsmithApiKey,
-    threadId: agrsInitialThreadId,
-    agent,
-    nodeName: initialNodeName,
-    state: initialState,
-    messages,
-    actions,
-  } = args;
-
-  let nodeName = initialNodeName;
-  let state = initialState;
-  const { name, assistantId: initialAssistantId } = agent;
-
-  // TODO: deploymentUrl is not required in local development
-  const client = new Client({ apiUrl: deploymentUrl, apiKey: langsmithApiKey });
-  let initialThreadId = agrsInitialThreadId;
-  const wasInitiatedWithExistingThread = !!initialThreadId;
-  if (initialThreadId && initialThreadId.startsWith("ck-")) {
-    initialThreadId = initialThreadId.substring(3);
-  }
-
-  const assistants = await client.assistants.search();
-  const retrievedAssistant = assistants.find((a) => a.name === name);
-  const threadId = initialThreadId ?? randomUUID();
-  if (initialThreadId === threadId) {
-    await client.threads.get(threadId);
-  } else {
-    await client.threads.create({ threadId: threadId });
-  }
-
-  let agentState = { values: {} };
-  if (wasInitiatedWithExistingThread) {
-    agentState = await client.threads.getState(threadId);
-  }
-  const agentStateValues = agentState.values as State;
-  state.messages = agentStateValues.messages;
-  const mode = wasInitiatedWithExistingThread && nodeName != "__end__" ? "continue" : "start";
-  state = langGraphDefaultMergeState(state, formatMessages(messages), actions);
-
-  if (mode === "continue") {
-    await client.threads.updateState(threadId, { values: state, asNode: nodeName });
-  }
-
-  const assistantId = initialAssistantId ?? retrievedAssistant.assistant_id;
-  const graphInfo = await client.assistants.getGraph(assistantId);
-  const streamInput = mode === "start" ? state : null;
-
-  let streamingStateExtractor = new StreamingStateExtractor([]);
-  let prevNodeName = null;
-  let emitIntermediateStateUntilEnd = null;
-  let shouldExit = null;
-  let externalRunId = null;
-
-  const streamResponse = client.runs.stream(threadId, assistantId, {
-    input: streamInput,
-    streamMode: ["events", "values"],
-  });
-
-  const emit = (message: string) => controller.enqueue(new TextEncoder().encode(message));
-
-  let latestStateValues = {};
-
-  for await (const chunk of streamResponse) {
-    if (!["events", "values"].includes(chunk.event)) continue;
-
-    if (chunk.event === "values") {
-      latestStateValues = chunk.data;
-      continue;
-    }
-
-    const event = chunk.data;
-    const currentNodeName = event.name;
-    const eventType = event.event;
-    const runId = event.metadata.run_id;
-    externalRunId = runId;
-    const metadata = event.metadata;
-
-    shouldExit = shouldExit != null ? shouldExit : metadata["copilotkit:exit"];
-    const emitIntermediateState = metadata["copilotkit:emit-intermediate-state"];
-    const forceEmitIntermediateState = metadata["copilotkit:force-emit-intermediate-state"];
-    const manuallyEmitMessage = metadata["copilotkit:manually-emit-messages"];
-    const manuallyEmitToolCall = metadata["copilotkit:manually-emit-tool-calls"];
-    // we only want to update the node name under certain conditions
-    // since we don't need any internal node names to be sent to the frontend
-    if (graphInfo["nodes"].some((node) => node.id === currentNodeName)) {
-      nodeName = currentNodeName;
-    }
-
-    if (!nodeName) {
-      continue;
-    }
-
-    if (forceEmitIntermediateState) {
-      if (eventType === "on_chain_end") {
-        state = event.data.output;
-        emit(
-          getStateSyncEvent({
-            threadId,
-            runId,
-            agentName: agent.name,
-            nodeName,
-            state: event.data.output,
-            running: true,
-            active: true,
-          }),
-        );
-      }
-      continue;
-    }
-
-    if (manuallyEmitMessage) {
-      if (eventType === "on_chain_end") {
-        state = event.data.output;
-        emit(
-          JSON.stringify({
-            event: "on_copilotkit_emit_message",
-            message: event.data.output,
-            messageId: randomUUID(),
-            role: MessageRole.assistant,
-          }) + "\n",
-        );
-      }
-      continue;
-    }
-
-    if (manuallyEmitToolCall) {
-      if (eventType === "on_chain_end") {
-        state = event.data.output;
-        emit(
-          JSON.stringify({
-            event: "on_copilotkit_emit_tool_call",
-            name: event.data.output.name,
-            args: event.data.output.args,
-            id: event.data.output.id,
-          }) + "\n",
-        );
-      }
-      continue;
-    }
-
-    if (emitIntermediateState && emitIntermediateStateUntilEnd == null) {
-      emitIntermediateStateUntilEnd = nodeName;
-    }
-
-    if (emitIntermediateState && eventType === "on_chat_model_start") {
-      // reset the streaming state extractor
-      streamingStateExtractor = new StreamingStateExtractor(emitIntermediateState);
-    }
-
-    let updatedState = latestStateValues;
-
-    if (emitIntermediateState && eventType === "on_chat_model_stream") {
-      streamingStateExtractor.bufferToolCalls(event);
-    }
-
-    if (emitIntermediateStateUntilEnd !== null) {
-      updatedState = {
-        ...updatedState,
-        ...streamingStateExtractor.extractState(),
-      };
-    }
-
-    if (
-      !emitIntermediateState &&
-      currentNodeName === emitIntermediateStateUntilEnd &&
-      eventType === "on_chain_end"
-    ) {
-      // stop emitting function call state
-      emitIntermediateStateUntilEnd = null;
-    }
-
-    const exitingNode = nodeName === currentNodeName && eventType === "on_chain_end";
-
-    if (
-      JSON.stringify(updatedState) !== JSON.stringify(state) ||
-      prevNodeName != nodeName ||
-      exitingNode
-    ) {
-      state = updatedState;
-      prevNodeName = nodeName;
-      emit(
-        getStateSyncEvent({
-          threadId,
-          runId,
-          agentName: agent.name,
-          nodeName,
-          state,
-          running: true,
-          active: !exitingNode,
-        }),
-      );
-    }
-
-    emit(JSON.stringify(event) + "\n");
-  }
-
-  state = await client.threads.getState(threadId);
-  const isEndNode = state.next.length === 0;
-  nodeName = Object.keys(state.metadata.writes)[0];
-
-  emit(
-    getStateSyncEvent({
-      threadId,
-      runId: externalRunId,
-      agentName: agent.name,
-      nodeName: isEndNode ? "__end__" : nodeName,
-      state: state.values,
-      running: !shouldExit,
-      active: false,
-    }),
-  );
-
-  return Promise.resolve();
-}
-
-function getStateSyncEvent({
-  threadId,
-  runId,
-  agentName,
-  nodeName,
-  state,
-  running,
-  active,
-}: {
-  threadId: string;
-  runId: string;
-  agentName: string;
-  nodeName: string;
-  state: State;
-  running: boolean;
-  active: boolean;
-}): string {
-  const stateWithoutMessages = Object.keys(state).reduce((acc, key) => {
-    if (key !== "messages") {
-      acc[key] = state[key];
-    }
-    return acc;
-  }, {} as State);
-
-  return (
-    JSON.stringify({
-      event: "on_copilotkit_state_sync",
-      thread_id: threadId,
-      run_id: runId,
-      agent_name: agentName,
-      node_name: nodeName,
-      active: active,
-      state: stateWithoutMessages,
-      running: running,
-      role: "assistant",
-    }) + "\n"
-  );
-}
-
-class StreamingStateExtractor {
-  private emitIntermediateState: { [key: string]: any }[];
-  private toolCallBuffer: { [key: string]: string };
-  private currentToolCall: string | null;
-  private previouslyParsableState: { [key: string]: any };
-
-  constructor(emitIntermediateState: { [key: string]: any }[]) {
-    this.emitIntermediateState = emitIntermediateState;
-    this.toolCallBuffer = {};
-    this.currentToolCall = null;
-    this.previouslyParsableState = {};
-  }
-
-  bufferToolCalls(event: {
-    data: { chunk: { tool_call_chunks: { name: string | null; args: string }[] } };
-  }) {
-    if (event.data.chunk.tool_call_chunks.length > 0) {
-      const chunk = event.data.chunk.tool_call_chunks[0];
-
-      if (chunk.name !== null) {
-        this.currentToolCall = chunk.name;
-        this.toolCallBuffer[this.currentToolCall] = chunk.args;
-      } else if (this.currentToolCall !== null) {
-        this.toolCallBuffer[this.currentToolCall] += chunk.args;
-      }
-    }
-  }
-
-  getEmitStateConfig(currentToolName: string): [string | null, string | null] {
-    for (const config of this.emitIntermediateState) {
-      const stateKey = config["state_key"];
-      const tool = config["tool"];
-      const toolArgument = config["tool_argument"];
-
-      if (currentToolName === tool) {
-        return [toolArgument, stateKey];
-      }
-    }
-    return [null, null];
-  }
-
-  extractState(): State {
-    const state: State = {};
-
-    for (const [key, value] of Object.entries(this.toolCallBuffer)) {
-      const [argumentName, stateKey] = this.getEmitStateConfig(key);
-
-      if (stateKey === null) {
-        continue;
-      }
-
-      let parsedValue;
-      try {
-        parsedValue = parsePartialJson(value);
-      } catch (error) {
-        if (key in this.previouslyParsableState) {
-          parsedValue = this.previouslyParsableState[key];
-        } else {
-          continue;
-        }
-      }
-
-      this.previouslyParsableState[key] = parsedValue;
-
-      if (!argumentName) {
-        state[stateKey] = parsedValue;
-      } else {
-        state[stateKey] = parsedValue[argumentName];
-      }
-    }
-
-    return state;
-  }
-}
-
-// Start of Selection
-function langGraphDefaultMergeState(
-  state: State,
-  messages: CopilotKitBaseMessage[],
-  actions: ExecutionAction[],
-): State {
-  if (messages.length > 0 && "role" in messages[0] && messages[0].role === "system") {
-    // remove system message
-    messages = messages.slice(1);
-  }
-
-  // merge with existing messages
-  const mergedMessages = state.messages || [];
-  const existingMessageIds = new Set(mergedMessages.map((message) => message.id));
-
-  for (const message of messages) {
-    if (!existingMessageIds.has(message.id)) {
-      mergedMessages.push(message);
-    }
-  }
-
-  return deepMerge(state, {
-    messages: mergedMessages,
-    copilotkit: {
-      actions,
-    },
-  });
-}
-
-function deepMerge(obj1: State, obj2: State) {
-  let result = { ...obj1 };
-  for (let key in obj2) {
-    if (typeof obj2[key] === "object" && !Array.isArray(obj2[key])) {
-      if (obj1[key]) {
-        result[key] = deepMerge(obj1[key], obj2[key]);
-      } else {
-        result[key] = { ...obj2[key] };
-      }
-    } else {
-      result[key] = obj2[key];
-    }
-  }
-  return result;
-}
-
-function formatMessages(messages: CopilotKitBaseMessage[]): CopilotKitBaseMessage[] {
-  return messages.map((message) => {
-    if ("content" in message) {
-      return message;
-    }
-    if ("arguments" in message) {
-      const toolCall = {
-        name: message["name"],
-        args: message["arguments"],
-        id: message["id"],
-      };
-      return {
-        ...message,
-        content: "",
-        tool_calls: [toolCall],
-        role: message["role"] ?? MessageRole.assistant,
-      };
-    }
-    if ("actionExecutionId" in message) {
-      return {
-        ...message,
-        content: message["result"],
-        name: message["actionName"],
-        tool_call_id: message["actionExecutionId"] as string,
-        role: message["role"] ?? MessageRole.user,
-      };
-    }
-    return message;
-  });
-}