@copilotkit/runtime 1.4.8-no-pino-redact.1 → 1.5.0-coagents-v0-3.0

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

@@ -249,13 +249,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
     } catch (error) {
       console.error("Error getting response:", error);
       eventSource.sendErrorMessageToChat();
-      return {
-        threadId: threadId || randomId(),
-        runId: runId || randomId(),
-        eventSource,
-        serverSideActions: [],
-        actionInputsWithoutAgents: [],
-      };
+      throw error;
     }
   }
 

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

@@ -40,6 +40,7 @@ export function constructLGCRemoteAction({
       actionInputsWithoutAgents,
       threadId,
       nodeName,
+      additionalMessages = [],
     }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
       logger.debug({ actionName: agent.name }, "Executing LangGraph Platform agent");
 
@@ -66,7 +67,7 @@ export function constructLGCRemoteAction({
           agent,
           threadId,
           nodeName,
-          messages,
+          messages: [...messages, ...additionalMessages],
           state,
           properties: graphqlContext.properties,
           actions: actionInputsWithoutAgents.map((action) => ({
@@ -109,6 +110,8 @@ export function constructRemoteActions({
   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,
@@ -120,7 +123,7 @@ export function constructRemoteActions({
       telemetry.capture("oss.runtime.remote_action_executed", {
         agentExecution: false,
         type: "self-hosted",
-        agentsAmount: json["agents"].length,
+        agentsAmount: totalAgents,
       });
 
       try {
@@ -157,66 +160,69 @@ export function constructRemoteActions({
     },
   }));
 
-  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", {
-        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 agents = totalAgents
+    ? json["agents"].map((agent) => ({
+        name: agent.name,
+        description: agent.description,
+        parameters: [],
+        handler: async (_args: any) => {},
 
-      const response = await fetch(`${url}/agents/execute`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
+        langGraphAgentHandler: async ({
           name,
+          actionInputsWithoutAgents,
           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();
-    },
-  }));
+          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];
 }

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

@@ -53,6 +53,7 @@ export type LangGraphAgentHandlerParams = {
   actionInputsWithoutAgents: ActionInput[];
   threadId?: string;
   nodeName?: string;
+  additionalMessages?: Message[];
 };
 
 export type LangGraphAgentAction = Action<any> & {

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

@@ -5,7 +5,7 @@ import { Logger } from "pino";
 import { ActionInput } from "../../graphql/inputs/action.input";
 import { LangGraphPlatformAgent, LangGraphPlatformEndpoint } from "./remote-actions";
 import { CopilotRequestContextProperties } from "../integrations";
-import { Message, MessageType } from "../../graphql/types/converted";
+import { ActionExecutionMessage, Message, MessageType } from "../../graphql/types/converted";
 import { MessageRole } from "../../graphql/types/enums";
 import { CustomEventNames, LangGraphEventTypes } from "../../agents/langgraph/events";
 import telemetry from "../telemetry-client";
@@ -112,7 +112,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   const mode = wasInitiatedWithExistingThread && nodeName != "__end__" ? "continue" : "start";
   let formattedMessages = [];
   try {
-    formattedMessages = formatMessages(messages);
+    formattedMessages = copilotkitMessagesToLangChain(messages);
   } catch (e) {
     logger.error(e, `Error event thrown: ${e.message}`);
   }
@@ -319,6 +319,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
         state: state.values,
         running: !shouldExit,
         active: false,
+        includeMessages: true,
       }),
     );
 
@@ -341,6 +342,7 @@ function getStateSyncEvent({
   state,
   running,
   active,
+  includeMessages = false,
 }: {
   threadId: string;
   runId: string;
@@ -349,13 +351,21 @@ function getStateSyncEvent({
   state: State;
   running: boolean;
   active: boolean;
+  includeMessages?: boolean;
 }): string {
-  const stateWithoutMessages = Object.keys(state).reduce((acc, key) => {
-    if (key !== "messages") {
-      acc[key] = state[key];
-    }
-    return acc;
-  }, {} as State);
+  if (!includeMessages) {
+    state = Object.keys(state).reduce((acc, key) => {
+      if (key !== "messages") {
+        acc[key] = state[key];
+      }
+      return acc;
+    }, {} as State);
+  } else {
+    state = {
+      ...state,
+      messages: langchainMessagesToCopilotKit(state.messages || []),
+    };
+  }
 
   return (
     JSON.stringify({
@@ -365,7 +375,7 @@ function getStateSyncEvent({
       agent_name: agentName,
       node_name: nodeName,
       active: active,
-      state: stateWithoutMessages,
+      state: state,
       running: running,
       role: "assistant",
     }) + "\n"
@@ -460,179 +470,188 @@ function langGraphDefaultMergeState(
   }
 
   // merge with existing messages
-  const mergedMessages: LangGraphPlatformMessage[] = state.messages || [];
-  const existingMessageIds = new Set(mergedMessages.map((message) => message.id));
-  const existingToolCallResults = new Set<string>();
+  const existingMessages: LangGraphPlatformMessage[] = state.messages || [];
+  const existingMessageIds = new Set(existingMessages.map((message) => message.id));
+  const newMessages = messages.filter((message) => !existingMessageIds.has(message.id));
+
+  return {
+    ...state,
+    messages: newMessages,
+    copilotkit: {
+      actions,
+    },
+  };
+}
 
-  for (const message of mergedMessages) {
-    if ("tool_call_id" in message) {
-      existingToolCallResults.add(message.tool_call_id);
+function langchainMessagesToCopilotKit(messages: any[]): any[] {
+  const result: any[] = [];
+  const tool_call_names: Record<string, string> = {};
+
+  // First pass: gather all tool call names from AI messages
+  for (const message of messages) {
+    if (message.type === "ai") {
+      for (const tool_call of message.tool_calls) {
+        tool_call_names[tool_call.id] = tool_call.name;
+      }
     }
   }
 
   for (const message of messages) {
-    // filter tool calls to activate the agent itself
-    if (
-      "tool_calls" in message &&
-      message.tool_calls.length > 0 &&
-      message.tool_calls[0].name === agentName
-    ) {
-      continue;
+    let content: any = message.content;
+    if (content instanceof Array) {
+      content = content[0];
     }
-
-    // filter results from activating the agent
-    if ("name" in message && message.name === agentName) {
-      continue;
+    if (content instanceof Object) {
+      content = content.text;
     }
 
-    if (!existingMessageIds.has(message.id)) {
-      // skip duplicate tool call results
-      if ("tool_call_id" in message && existingToolCallResults.has(message.tool_call_id)) {
-        console.warn("Warning: Duplicate tool call result, skipping:", message.tool_call_id);
-        continue;
-      }
-
-      mergedMessages.push(message);
-    } else {
-      // Replace the message with the existing one
-      for (let i = 0; i < mergedMessages.length; i++) {
-        if (mergedMessages[i].id === message.id && message.role === "assistant") {
-          if (
-            ("tool_calls" in mergedMessages[i] || "additional_kwargs" in mergedMessages[i]) &&
-            mergedMessages[i].content
-          ) {
-            // @ts-expect-error -- message did not have a tool call, now it will
-            message.tool_calls = mergedMessages[i]["tool_calls"];
-            message.additional_kwargs = mergedMessages[i].additional_kwargs;
-          }
-          mergedMessages[i] = message;
+    if (message.type === "human") {
+      result.push({
+        role: "user",
+        content: content,
+        id: message.id,
+      });
+    } else if (message.type === "system") {
+      result.push({
+        role: "system",
+        content: content,
+        id: message.id,
+      });
+    } else if (message.type === "ai") {
+      if (message.tool_calls && message.tool_calls.length > 0) {
+        for (const tool_call of message.tool_calls) {
+          result.push({
+            id: tool_call.id,
+            name: tool_call.name,
+            arguments: tool_call.args,
+            parentMessageId: message.id,
+          });
         }
+      } else {
+        result.push({
+          role: "assistant",
+          content: content,
+          id: message.id,
+          parentMessageId: message.id,
+        });
       }
+    } else if (message.type === "tool") {
+      const actionName = tool_call_names[message.tool_call_id] || message.name || "";
+      result.push({
+        actionExecutionId: message.tool_call_id,
+        actionName: actionName,
+        result: content,
+        id: message.id,
+      });
     }
   }
-
-  // fix wrong tool call ids
-  for (let i = 0; i < mergedMessages.length - 1; i++) {
-    const currentMessage = mergedMessages[i];
-    const nextMessage = mergedMessages[i + 1];
-
-    if (
-      "tool_calls" in currentMessage &&
-      currentMessage.tool_calls.length > 0 &&
-      "tool_call_id" in nextMessage
-    ) {
-      nextMessage.tool_call_id = currentMessage.tool_calls[0].id;
+  const resultsDict: Record<string, any> = {};
+  for (const msg of result) {
+    if (msg.actionExecutionId) {
+      resultsDict[msg.actionExecutionId] = msg;
     }
   }
 
-  // try to auto-correct and log alignment issues
-  const correctedMessages: LangGraphPlatformMessage[] = [];
+  const reorderedResult: Message[] = [];
 
-  for (let i = 0; i < mergedMessages.length; i++) {
-    const currentMessage = mergedMessages[i];
-    const nextMessage = mergedMessages[i + 1] || null;
-    const prevMessage = mergedMessages[i - 1] || null;
+  for (const msg of result) {
+    // If it's not a tool result, just append it
+    if (!("actionExecutionId" in msg)) {
+      reorderedResult.push(msg);
+    }
 
-    if ("tool_calls" in currentMessage && currentMessage.tool_calls.length > 0) {
-      if (!nextMessage) {
-        console.warn(
-          "No next message to auto-correct tool call, skipping:",
-          currentMessage.tool_calls[0].id,
-        );
-        continue;
+    // If the message has arguments (i.e., is a tool call invocation),
+    // append the corresponding result right after it
+    if ("arguments" in msg) {
+      const msgId = msg.id;
+      if (msgId in resultsDict) {
+        reorderedResult.push(resultsDict[msgId]);
       }
+    }
+  }
 
-      if (
-        !("tool_call_id" in nextMessage) ||
-        nextMessage.tool_call_id !== currentMessage.tool_calls[0].id
-      ) {
-        const toolMessage = mergedMessages.find(
-          (m) => "tool_call_id" in m && m.tool_call_id === currentMessage.tool_calls[0].id,
-        );
+  return reorderedResult;
+}
 
-        if (toolMessage) {
-          console.warn(
-            "Auto-corrected tool call alignment issue:",
-            currentMessage.tool_calls[0].id,
-          );
-          correctedMessages.push(currentMessage, toolMessage);
-          continue;
-        } else {
-          console.warn(
-            "No corresponding tool call result found for tool call, skipping:",
-            currentMessage.tool_calls[0].id,
-          );
-          continue;
-        }
-      }
+function copilotkitMessagesToLangChain(messages: Message[]): LangGraphPlatformMessage[] {
+  const result: LangGraphPlatformMessage[] = [];
+  const processedActionExecutions = new Set<string>();
 
-      correctedMessages.push(currentMessage);
+  for (const message of messages) {
+    // Handle TextMessage
+    if (message.isTextMessage()) {
+      if (message.role === "user") {
+        // Human message
+        result.push({
+          ...message,
+          role: MessageRole.user,
+        });
+      } else if (message.role === "system") {
+        // System message
+        result.push({
+          ...message,
+          role: MessageRole.system,
+        });
+      } else if (message.role === "assistant") {
+        // Assistant message
+        result.push({
+          ...message,
+          role: MessageRole.assistant,
+        });
+      }
       continue;
     }
 
-    if ("tool_call_id" in currentMessage) {
-      if (!prevMessage || !("tool_calls" in prevMessage)) {
-        console.warn("No previous tool call, skipping tool call result:", currentMessage.id);
-        continue;
-      }
+    // Handle ActionExecutionMessage (multiple tool calls per parentMessageId)
+    if (message.isActionExecutionMessage()) {
+      const messageId = message.parentMessageId ?? message.id;
 
-      if (prevMessage.tool_calls && prevMessage.tool_calls[0].id !== currentMessage.tool_call_id) {
-        console.warn("Tool call id is incorrect, skipping tool call result:", currentMessage.id);
+      // If we've already processed this action execution group, skip
+      if (processedActionExecutions.has(messageId)) {
         continue;
       }
 
-      correctedMessages.push(currentMessage);
-      continue;
-    }
+      processedActionExecutions.add(messageId);
 
-    correctedMessages.push(currentMessage);
-  }
+      // Gather all tool calls related to this messageId
+      const relatedActionExecutions = messages.filter(
+        (m) =>
+          m.isActionExecutionMessage() &&
+          ((m.parentMessageId && m.parentMessageId === messageId) || m.id === messageId),
+      ) as ActionExecutionMessage[];
 
-  return {
-    ...state,
-    messages: correctedMessages,
-    copilotkit: {
-      actions,
-    },
-  };
-}
+      const tool_calls: ToolCall[] = relatedActionExecutions.map((m) => ({
+        name: m.name,
+        args: m.arguments,
+        id: m.id,
+      }));
 
-function formatMessages(messages: Message[]): LangGraphPlatformMessage[] {
-  return messages.map((message) => {
-    if (message.isTextMessage() && message.role === "assistant") {
-      return message;
-    }
-    if (message.isTextMessage() && message.role === "system") {
-      return message;
-    }
-    if (message.isTextMessage() && message.role === "user") {
-      return message;
-    }
-    if (message.isActionExecutionMessage()) {
-      const toolCall: ToolCall = {
-        name: message.name,
-        args: message.arguments,
-        id: message.id,
-      };
-      return {
-        type: message.type,
+      result.push({
+        id: messageId,
+        type: "ActionExecutionMessage",
         content: "",
-        tool_calls: [toolCall],
+        tool_calls: tool_calls,
         role: MessageRole.assistant,
-        id: message.id,
-      } satisfies LangGraphPlatformActionExecutionMessage;
+      } satisfies LangGraphPlatformActionExecutionMessage);
+
+      continue;
     }
+
+    // Handle ResultMessage
     if (message.isResultMessage()) {
-      return {
+      result.push({
         type: message.type,
         content: message.result,
         id: message.id,
         tool_call_id: message.actionExecutionId,
         name: message.actionName,
         role: MessageRole.tool,
-      } satisfies LangGraphPlatformResultMessage;
+      } satisfies LangGraphPlatformResultMessage);
+      continue;
     }
 
     throw new Error(`Unknown message type ${message.type}`);
-  });
+  }
+
+  return result;
 }

package/src/service-adapters/anthropic/anthropic-adapter.ts

@@ -120,7 +120,11 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
             mode = "message";
           } else if (chunk.content_block.type === "tool_use") {
             currentToolCallId = chunk.content_block.id;
-            eventStream$.sendActionExecutionStart(currentToolCallId, chunk.content_block.name);
+            eventStream$.sendActionExecutionStart({
+              actionExecutionId: currentToolCallId,
+              actionName: chunk.content_block.name,
+              parentMessageId: currentMessageId,
+            });
             mode = "function";
           }
         } else if (chunk.type === "content_block_delta") {
@@ -128,21 +132,27 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
             const text = filterThinkingTextBuffer.onTextChunk(chunk.delta.text);
             if (text.length > 0) {
               if (!didOutputText) {
-                eventStream$.sendTextMessageStart(currentMessageId);
+                eventStream$.sendTextMessageStart({ messageId: currentMessageId });
                 didOutputText = true;
               }
-              eventStream$.sendTextMessageContent(text);
+              eventStream$.sendTextMessageContent({
+                messageId: currentMessageId,
+                content: text,
+              });
             }
           } else if (chunk.delta.type === "input_json_delta") {
-            eventStream$.sendActionExecutionArgs(chunk.delta.partial_json);
+            eventStream$.sendActionExecutionArgs({
+              actionExecutionId: currentToolCallId,
+              args: chunk.delta.partial_json,
+            });
           }
         } else if (chunk.type === "content_block_stop") {
           if (mode === "message") {
             if (didOutputText) {
-              eventStream$.sendTextMessageEnd();
+              eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
             }
           } else if (mode === "function") {
-            eventStream$.sendActionExecutionEnd();
+            eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
           }
         }
       }

package/src/service-adapters/conversion.ts

@@ -19,6 +19,7 @@ export function convertGqlInputToMessages(inputMessages: MessageInput[]): Messag
           createdAt: message.createdAt,
           role: message.textMessage.role,
           content: message.textMessage.content,
+          parentMessageId: message.textMessage.parentMessageId,
         }),
       );
     } else if (message.actionExecutionMessage) {
@@ -28,7 +29,7 @@ export function convertGqlInputToMessages(inputMessages: MessageInput[]): Messag
           createdAt: message.createdAt,
           name: message.actionExecutionMessage.name,
           arguments: JSON.parse(message.actionExecutionMessage.arguments),
-          scope: message.actionExecutionMessage.scope,
+          parentMessageId: message.actionExecutionMessage.parentMessageId,
         }),
       );
     } else if (message.resultMessage) {