@copilotkit/runtime 1.4.8-coagents-v0-3.1 → 1.4.8-next.1

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

@@ -40,7 +40,6 @@ export function constructLGCRemoteAction({
       actionInputsWithoutAgents,
       threadId,
       nodeName,
-      additionalMessages = [],
     }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
       logger.debug({ actionName: agent.name }, "Executing LangGraph Platform agent");
 
@@ -67,7 +66,7 @@ export function constructLGCRemoteAction({
           agent,
           threadId,
           nodeName,
-          messages: [...messages, ...additionalMessages],
+          messages,
           state,
           properties: graphqlContext.properties,
           actions: actionInputsWithoutAgents.map((action) => ({
@@ -110,6 +109,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,
@@ -121,7 +122,7 @@ export function constructRemoteActions({
       telemetry.capture("oss.runtime.remote_action_executed", {
         agentExecution: false,
         type: "self-hosted",
-        agentsAmount: json["agents"].length,
+        agentsAmount: totalAgents,
       });
 
       try {
@@ -158,67 +159,68 @@ 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,
-      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 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: [...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();
-    },
-  }));
+        }: 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,
+              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,7 +53,6 @@ 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 { ActionExecutionMessage, Message, MessageType } from "../../graphql/types/converted";
+import { 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 = copilotkitMessagesToLangChain(messages);
+    formattedMessages = formatMessages(messages);
   } catch (e) {
     logger.error(e, `Error event thrown: ${e.message}`);
   }
@@ -319,7 +319,6 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
         state: state.values,
         running: !shouldExit,
         active: false,
-        includeMessages: true,
       }),
     );
 
@@ -342,7 +341,6 @@ function getStateSyncEvent({
   state,
   running,
   active,
-  includeMessages = false,
 }: {
   threadId: string;
   runId: string;
@@ -351,21 +349,13 @@ function getStateSyncEvent({
   state: State;
   running: boolean;
   active: boolean;
-  includeMessages?: boolean;
 }): string {
-  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 || []),
-    };
-  }
+  const stateWithoutMessages = Object.keys(state).reduce((acc, key) => {
+    if (key !== "messages") {
+      acc[key] = state[key];
+    }
+    return acc;
+  }, {} as State);
 
   return (
     JSON.stringify({
@@ -375,7 +365,7 @@ function getStateSyncEvent({
       agent_name: agentName,
       node_name: nodeName,
       active: active,
-      state: state,
+      state: stateWithoutMessages,
       running: running,
       role: "assistant",
     }) + "\n"
@@ -470,190 +460,179 @@ function langGraphDefaultMergeState(
   }
 
   // merge with existing messages
-  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,
-    },
-  };
-}
+  const mergedMessages: LangGraphPlatformMessage[] = state.messages || [];
+  const existingMessageIds = new Set(mergedMessages.map((message) => message.id));
+  const existingToolCallResults = new Set<string>();
 
-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 mergedMessages) {
+    if ("tool_call_id" in message) {
+      existingToolCallResults.add(message.tool_call_id);
     }
   }
 
   for (const message of messages) {
-    let content: any = message.content;
-    if (content instanceof Array) {
-      content = content[0];
+    // 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;
     }
-    if (content instanceof Object) {
-      content = content.text;
+
+    // filter results from activating the agent
+    if ("name" in message && message.name === agentName) {
+      continue;
     }
 
-    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,
-          });
+    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;
         }
-      } 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,
-      });
     }
   }
-  const resultsDict: Record<string, any> = {};
-  for (const msg of result) {
-    if (msg.actionExecutionId) {
-      resultsDict[msg.actionExecutionId] = msg;
+
+  // 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 reorderedResult: Message[] = [];
+  // try to auto-correct and log alignment issues
+  const correctedMessages: LangGraphPlatformMessage[] = [];
 
-  for (const msg of result) {
-    // If it's not a tool result, just append it
-    if (!("actionExecutionId" in msg)) {
-      reorderedResult.push(msg);
-    }
+  for (let i = 0; i < mergedMessages.length; i++) {
+    const currentMessage = mergedMessages[i];
+    const nextMessage = mergedMessages[i + 1] || null;
+    const prevMessage = mergedMessages[i - 1] || null;
 
-    // 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]);
-      } else {
-        console.warn("Tool call result message not found for id:", msgId);
+    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;
       }
-    }
-  }
-
-  return reorderedResult;
-}
 
-function copilotkitMessagesToLangChain(messages: Message[]): LangGraphPlatformMessage[] {
-  const result: LangGraphPlatformMessage[] = [];
-  const processedActionExecutions = new Set<string>();
+      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,
+        );
 
-  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,
-        });
+        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;
+        }
       }
+
+      correctedMessages.push(currentMessage);
       continue;
     }
 
-    // Handle ActionExecutionMessage (multiple tool calls per parentMessageId)
-    if (message.isActionExecutionMessage()) {
-      const messageId = message.parentMessageId ?? message.id;
+    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;
+      }
 
-      // If we've already processed this action execution group, skip
-      if (processedActionExecutions.has(messageId)) {
+      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);
         continue;
       }
 
-      processedActionExecutions.add(messageId);
+      correctedMessages.push(currentMessage);
+      continue;
+    }
 
-      // 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[];
+    correctedMessages.push(currentMessage);
+  }
 
-      const tool_calls: ToolCall[] = relatedActionExecutions.map((m) => ({
-        name: m.name,
-        args: m.arguments,
-        id: m.id,
-      }));
+  return {
+    ...state,
+    messages: correctedMessages,
+    copilotkit: {
+      actions,
+    },
+  };
+}
 
-      result.push({
-        id: messageId,
-        type: "ActionExecutionMessage",
+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,
         content: "",
-        tool_calls: tool_calls,
+        tool_calls: [toolCall],
         role: MessageRole.assistant,
-      } satisfies LangGraphPlatformActionExecutionMessage);
-
-      continue;
+        id: message.id,
+      } satisfies LangGraphPlatformActionExecutionMessage;
     }
-
-    // Handle ResultMessage
     if (message.isResultMessage()) {
-      result.push({
+      return {
         type: message.type,
         content: message.result,
         id: message.id,
         tool_call_id: message.actionExecutionId,
         name: message.actionName,
         role: MessageRole.tool,
-      } satisfies LangGraphPlatformResultMessage);
-      continue;
+      } satisfies LangGraphPlatformResultMessage;
     }
 
     throw new Error(`Unknown message type ${message.type}`);
-  }
-
-  return result;
+  });
 }

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

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

package/src/service-adapters/conversion.ts

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