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

package/src/agents/langgraph/event-source.ts

@@ -5,13 +5,17 @@ import { randomId } from "@copilotkit/shared";
 
 interface LangGraphEventWithState {
   event: LangGraphEvent | null;
-  content: string | null;
-  toolCallName: string | null;
-  toolCallId: string | null;
-  toolCallMessageId: string | null;
-  prevToolCallMessageId: string | null;
-  messageId: string | null;
-  prevMessageId: string | null;
+
+  isMessageStart: boolean;
+  isMessageEnd: boolean;
+  isToolCallStart: boolean;
+  isToolCallEnd: boolean;
+  isToolCall: boolean;
+
+  lastMessageId: string | null;
+  lastToolCallId: string | null;
+  lastToolCallName: string | null;
+  currentContent: string | null;
 }
 
 export class RemoteLangGraphEventSource {
@@ -30,6 +34,43 @@ export class RemoteLangGraphEventSource {
     return shouldEmitToolCalls === toolCallName;
   }
 
+  private getCurrentContent(event: LangGraphEvent) {
+    // @ts-expect-error -- LangGraph Platform implementation stores data outside of kwargs
+    const content = event.data?.chunk?.kwargs?.content ?? event.data?.chunk?.content;
+
+    if (!content) {
+      const toolCallChunks = this.getCurrentToolCallChunks(event) ?? [];
+      for (const chunk of toolCallChunks) {
+        if (chunk.args) {
+          return chunk.args;
+        }
+      }
+    }
+
+    if (typeof content === "string") {
+      return content;
+    } else if (Array.isArray(content) && content.length > 0) {
+      return content[0].text;
+    }
+
+    return null;
+  }
+
+  private getCurrentMessageId(event: LangGraphEvent) {
+    // @ts-expect-error -- LangGraph Platform implementation stores data outside of kwargs
+    return event.data?.chunk?.kwargs?.id ?? event.data?.chunk?.id;
+  }
+
+  private getCurrentToolCallChunks(event: LangGraphEvent) {
+    // @ts-expect-error -- LangGraph Platform implementation stores data outside of kwargs
+    return event.data?.chunk?.kwargs?.tool_call_chunks ?? event.data?.chunk?.tool_call_chunks;
+  }
+
+  private getResponseMetadata(event: LangGraphEvent) {
+    // @ts-expect-error -- LangGraph Platform implementation stores data outside of kwargs
+    return event.data?.chunk?.kwargs?.response_metadata ?? event.data?.chunk?.response_metadata;
+  }
+
   processLangGraphEvents() {
     let lastEventWithState: LangGraphEventWithState | null = null;
 
@@ -37,104 +78,75 @@ export class RemoteLangGraphEventSource {
       scan(
         (acc, event) => {
           if (event.event === LangGraphEventTypes.OnChatModelStream) {
-            // @ts-expect-error -- LangGraph Platform implementation stores data outside of kwargs
-            const content = event.data?.chunk?.kwargs?.content ?? event.data?.chunk?.content;
-
-            if (typeof content === "string") {
-              acc.content = content;
-            } else if (Array.isArray(content) && content.length > 0) {
-              acc.content = content[0].text;
-            } else {
-              acc.content = null;
-            }
+            const prevMessageId = acc.lastMessageId;
+            acc.currentContent = this.getCurrentContent(event);
+            acc.lastMessageId = this.getCurrentMessageId(event) ?? acc.lastMessageId;
+            const toolCallChunks = this.getCurrentToolCallChunks(event) ?? [];
+            const responseMetadata = this.getResponseMetadata(event);
 
-            const toolCallChunks =
-              // @ts-expect-error -- LangGraph Platform implementation stores data outside of kwargs
-              event.data?.chunk?.kwargs?.tool_call_chunks ?? event.data?.chunk?.tool_call_chunks;
-
-            const toolCallMessageId =
-              event.data?.chunk?.kwargs?.id ??
-              (event.data?.chunk?.id as unknown as string | undefined);
-
-            if (toolCallChunks && toolCallChunks.length > 0) {
-              acc.prevToolCallMessageId = acc.toolCallMessageId;
-              acc.toolCallMessageId = toolCallMessageId;
-              if (toolCallChunks[0]?.name) {
-                acc.toolCallName = toolCallChunks[0].name;
-              }
-              if (toolCallChunks[0]?.id) {
-                acc.toolCallId = toolCallChunks[0].id;
-              }
-              acc.prevMessageId = acc.messageId;
-              acc.messageId = toolCallMessageId;
-            } else if (acc.content && acc.content != "") {
-              acc.prevMessageId = acc.messageId;
-              acc.messageId = toolCallMessageId;
-            } else {
-              acc.prevToolCallMessageId = acc.toolCallMessageId;
-              acc.prevMessageId = acc.messageId;
-            }
-          } else {
-            acc.prevToolCallMessageId = acc.toolCallMessageId;
-            acc.toolCallMessageId = null;
-            acc.prevMessageId = acc.messageId;
-            acc.messageId = null;
-            acc.toolCallName = null;
+            acc.isToolCallStart = toolCallChunks.some((chunk: any) => chunk.name && chunk.id);
+            acc.isMessageStart = prevMessageId !== acc.lastMessageId && !acc.isToolCallStart;
+            acc.isToolCall = toolCallChunks && toolCallChunks.length > 0;
+            acc.isToolCallEnd = responseMetadata?.finish_reason === "tool_calls";
+            acc.isMessageEnd = responseMetadata?.finish_reason === "stop";
+            ({ name: acc.lastToolCallName, id: acc.lastToolCallId } = toolCallChunks.find(
+              (chunk: any) => chunk.name && chunk.id,
+            ) ?? { name: acc.lastToolCallName, id: acc.lastToolCallId });
           }
-
           acc.event = event;
           lastEventWithState = acc; // Capture the state
           return acc;
         },
         {
           event: null,
-          toolCallId: null,
-          toolCallMessageId: null,
-          prevToolCallMessageId: null,
-          messageId: null,
-          toolCallName: null,
-          prevMessageId: null,
-          content: null,
+          isMessageStart: false,
+          isMessageEnd: false,
+          isToolCallStart: false,
+          isToolCallEnd: false,
+          isToolCall: false,
+          lastMessageId: null,
+          lastToolCallId: null,
+          lastToolCallName: null,
+          currentContent: null,
         } as LangGraphEventWithState,
       ),
-      mergeMap((eventWithState): RuntimeEvent[] => {
+      mergeMap((acc): RuntimeEvent[] => {
         const events: RuntimeEvent[] = [];
 
         let shouldEmitMessages = true;
-        let shouldEmitToolCalls: string | string[] | boolean = false;
+        let shouldEmitToolCalls: string | string[] | boolean = true;
 
-        if (eventWithState.event.event == LangGraphEventTypes.OnChatModelStream) {
-          if ("copilotkit:emit-tool-calls" in (eventWithState.event.metadata || {})) {
-            shouldEmitToolCalls = eventWithState.event.metadata["copilotkit:emit-tool-calls"];
+        if (acc.event.event == LangGraphEventTypes.OnChatModelStream) {
+          if ("copilotkit:emit-tool-calls" in (acc.event.metadata || {})) {
+            shouldEmitToolCalls = acc.event.metadata["copilotkit:emit-tool-calls"];
           }
-          if ("copilotkit:emit-messages" in (eventWithState.event.metadata || {})) {
-            shouldEmitMessages = eventWithState.event.metadata["copilotkit:emit-messages"];
+          if ("copilotkit:emit-messages" in (acc.event.metadata || {})) {
+            shouldEmitMessages = acc.event.metadata["copilotkit:emit-messages"];
           }
         }
 
+        const responseMetadata = this.getResponseMetadata(acc.event);
+
         // Tool call ended: emit ActionExecutionEnd
         if (
-          eventWithState.prevToolCallMessageId !== null &&
-          eventWithState.prevToolCallMessageId !== eventWithState.toolCallMessageId &&
-          this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)
+          responseMetadata?.finish_reason === "tool_calls" &&
+          this.shouldEmitToolCall(shouldEmitToolCalls, acc.lastToolCallName)
         ) {
           events.push({
             type: RuntimeEventTypes.ActionExecutionEnd,
+            actionExecutionId: acc.lastToolCallId,
           });
         }
 
         // Message ended: emit TextMessageEnd
-        if (
-          eventWithState.prevMessageId !== null &&
-          eventWithState.prevMessageId !== eventWithState.messageId &&
-          shouldEmitMessages
-        ) {
+        if (responseMetadata?.finish_reason === "stop" && shouldEmitMessages) {
           events.push({
             type: RuntimeEventTypes.TextMessageEnd,
+            messageId: acc.lastMessageId,
           });
         }
 
-        switch (eventWithState.event!.event) {
+        switch (acc.event!.event) {
           //
           // Custom events
           //
@@ -142,118 +154,94 @@ export class RemoteLangGraphEventSource {
             //
             // Manually emit a message
             //
-            if (eventWithState.event.name === CustomEventNames.CopilotKitManuallyEmitMessage) {
+            if (acc.event.name === CustomEventNames.CopilotKitManuallyEmitMessage) {
               events.push({
                 type: RuntimeEventTypes.TextMessageStart,
-                messageId: eventWithState.event.data.message_id,
+                messageId: acc.event.data.message_id,
               });
               events.push({
                 type: RuntimeEventTypes.TextMessageContent,
-                content: eventWithState.event.data.message,
+                messageId: acc.event.data.message_id,
+                content: acc.event.data.message,
               });
               events.push({
                 type: RuntimeEventTypes.TextMessageEnd,
+                messageId: acc.event.data.message_id,
               });
             }
             //
             // Manually emit a tool call
             //
-            else if (
-              eventWithState.event.name === CustomEventNames.CopilotKitManuallyEmitToolCall
-            ) {
+            else if (acc.event.name === CustomEventNames.CopilotKitManuallyEmitToolCall) {
               events.push({
                 type: RuntimeEventTypes.ActionExecutionStart,
-                actionExecutionId: eventWithState.event.data.id,
-                actionName: eventWithState.event.data.name,
+                actionExecutionId: acc.event.data.id,
+                actionName: acc.event.data.name,
+                parentMessageId: acc.event.data.id,
               });
               events.push({
                 type: RuntimeEventTypes.ActionExecutionArgs,
-                args: JSON.stringify(eventWithState.event.data.args),
+                actionExecutionId: acc.event.data.id,
+                args: JSON.stringify(acc.event.data.args),
               });
               events.push({
                 type: RuntimeEventTypes.ActionExecutionEnd,
+                actionExecutionId: acc.event.data.id,
               });
             }
             break;
           case LangGraphEventTypes.OnCopilotKitStateSync:
             events.push({
               type: RuntimeEventTypes.AgentStateMessage,
-              threadId: eventWithState.event.thread_id,
-              role: eventWithState.event.role,
-              agentName: eventWithState.event.agent_name,
-              nodeName: eventWithState.event.node_name,
-              runId: eventWithState.event.run_id,
-              active: eventWithState.event.active,
-              state: JSON.stringify(eventWithState.event.state),
-              running: eventWithState.event.running,
+              threadId: acc.event.thread_id,
+              role: acc.event.role,
+              agentName: acc.event.agent_name,
+              nodeName: acc.event.node_name,
+              runId: acc.event.run_id,
+              active: acc.event.active,
+              state: JSON.stringify(acc.event.state),
+              running: acc.event.running,
             });
             break;
-          case LangGraphEventTypes.OnToolEnd:
-            // TODO-AGENTS: emit ActionExecutionResult when needed
-            // Need a special tool node for that?
-
-            // const result = eventWithState.event.data?.output?.kwargs?.content?.[0];
-            // const toolCallId = eventWithState.event.data?.output?.kwargs?.tool_call_id;
-            // const toolCallName = eventWithState.event.data?.output?.kwargs?.name;
-            // if (result && toolCallId && toolCallName) {
-            //   events.push({
-            //     type: RuntimeEventTypes.ActionExecutionResult,
-            //     actionExecutionId: toolCallId,
-            //     actionName: toolCallName,
-            //     result,
-            //   });
-            // }
-            break;
           case LangGraphEventTypes.OnChatModelStream:
             if (
-              eventWithState.toolCallMessageId !== null &&
-              eventWithState.prevToolCallMessageId !== eventWithState.toolCallMessageId
+              acc.isToolCallStart &&
+              this.shouldEmitToolCall(shouldEmitToolCalls, acc.lastToolCallName)
             ) {
-              if (this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)) {
-                events.push({
-                  type: RuntimeEventTypes.ActionExecutionStart,
-                  actionExecutionId: eventWithState.toolCallMessageId,
-                  actionName: eventWithState.toolCallName,
-                  scope: "client",
-                });
-              }
+              events.push({
+                type: RuntimeEventTypes.ActionExecutionStart,
+                actionExecutionId: acc.lastToolCallId,
+                actionName: acc.lastToolCallName,
+                parentMessageId: acc.lastMessageId,
+              });
             }
             // Message started: emit TextMessageStart
-            else if (
-              eventWithState.messageId !== null &&
-              eventWithState.prevMessageId !== eventWithState.messageId
-            ) {
-              if (shouldEmitMessages) {
-                events.push({
-                  type: RuntimeEventTypes.TextMessageStart,
-                  messageId: eventWithState.messageId,
-                });
-              }
+            else if (acc.isMessageStart && shouldEmitMessages) {
+              events.push({
+                type: RuntimeEventTypes.TextMessageStart,
+                messageId: acc.lastMessageId,
+              });
             }
 
-            const args =
-              eventWithState.event.data?.chunk?.kwargs?.tool_call_chunks?.[0]?.args ??
-              // @ts-expect-error -- sdf
-              eventWithState.event.data?.chunk?.tool_call_chunks?.[0]?.args;
-            const content = eventWithState.content;
-
             // Tool call args: emit ActionExecutionArgs
-            if (args) {
-              if (this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)) {
-                events.push({
-                  type: RuntimeEventTypes.ActionExecutionArgs,
-                  args,
-                });
-              }
+            if (
+              acc.isToolCall &&
+              acc.currentContent &&
+              this.shouldEmitToolCall(shouldEmitToolCalls, acc.lastToolCallName)
+            ) {
+              events.push({
+                type: RuntimeEventTypes.ActionExecutionArgs,
+                actionExecutionId: acc.lastToolCallId,
+                args: acc.currentContent,
+              });
             }
             // Message content: emit TextMessageContent
-            else if (eventWithState.messageId !== null && content) {
-              if (shouldEmitMessages) {
-                events.push({
-                  type: RuntimeEventTypes.TextMessageContent,
-                  content,
-                });
-              }
+            else if (!acc.isToolCall && acc.currentContent && shouldEmitMessages) {
+              events.push({
+                type: RuntimeEventTypes.TextMessageContent,
+                messageId: acc.lastMessageId,
+                content: acc.currentContent,
+              });
             }
             break;
         }
@@ -263,14 +251,16 @@ export class RemoteLangGraphEventSource {
         console.error(error);
         const events: RuntimeEvent[] = [];
 
-        if (lastEventWithState?.messageId) {
+        if (lastEventWithState?.lastMessageId && !lastEventWithState.isToolCall) {
           events.push({
             type: RuntimeEventTypes.TextMessageEnd,
+            messageId: lastEventWithState.lastMessageId,
           });
         }
-        if (lastEventWithState?.toolCallMessageId) {
+        if (lastEventWithState?.lastToolCallId) {
           events.push({
             type: RuntimeEventTypes.ActionExecutionEnd,
+            actionExecutionId: lastEventWithState.lastToolCallId,
           });
         }
 
@@ -282,10 +272,12 @@ export class RemoteLangGraphEventSource {
         });
         events.push({
           type: RuntimeEventTypes.TextMessageContent,
+          messageId: messageId,
           content: "❌ An error occurred. Please try again.",
         });
         events.push({
           type: RuntimeEventTypes.TextMessageEnd,
+          messageId: messageId,
         });
 
         return events;

package/src/agents/langgraph/events.ts

@@ -119,7 +119,7 @@ type LangGraphOnChatModelStreamEvent = {
     chunk: {
       lc: number;
       type: string;
-      id: string[];
+      id: string;
       kwargs: {
         content: string | { text: string; type: string; index: number }[];
         additional_kwargs: {

package/src/graphql/inputs/message.input.ts

@@ -1,5 +1,5 @@
 import { Field, InputType } from "type-graphql";
-import { MessageRole, ActionExecutionScope } from "../types/enums";
+import { MessageRole } from "../types/enums";
 import { BaseMessageInput } from "../types/base";
 
 // GraphQL does not support union types in inputs, so we need to use
@@ -24,6 +24,9 @@ export class TextMessageInput {
   @Field(() => String)
   content: string;
 
+  @Field(() => String, { nullable: true })
+  parentMessageId?: string;
+
   @Field(() => MessageRole)
   role: MessageRole;
 }
@@ -36,8 +39,14 @@ export class ActionExecutionMessageInput {
   @Field(() => String)
   arguments: string;
 
-  @Field(() => ActionExecutionScope)
-  scope: ActionExecutionScope;
+  @Field(() => String, { nullable: true })
+  parentMessageId?: string;
+
+  @Field(() => String, {
+    nullable: true,
+    deprecationReason: "This field will be removed in a future version",
+  })
+  scope?: String;
 }
 
 @InputType()
@@ -48,6 +57,9 @@ export class ResultMessageInput {
   @Field(() => String)
   actionName: string;
 
+  @Field(() => String, { nullable: true })
+  parentMessageId?: string;
+
   @Field(() => String)
   result: string;
 }

package/src/graphql/resolvers/copilot.resolver.ts

@@ -3,6 +3,7 @@ import {
   ReplaySubject,
   Subject,
   Subscription,
+  filter,
   finalize,
   firstValueFrom,
   shareReplay,
@@ -288,7 +289,19 @@ export class CopilotResolver {
                   // skip until this message start event
                   skipWhile((e) => e !== event),
                   // take until the message end event
-                  takeWhile((e) => e.type != RuntimeEventTypes.TextMessageEnd),
+                  takeWhile(
+                    (e) =>
+                      !(
+                        e.type === RuntimeEventTypes.TextMessageEnd &&
+                        e.messageId == event.messageId
+                      ),
+                  ),
+                  // filter out any other message events or message ids
+                  filter(
+                    (e) =>
+                      e.type == RuntimeEventTypes.TextMessageContent &&
+                      e.messageId == event.messageId,
+                  ),
                 );
 
                 // signal when we are done streaming
@@ -298,6 +311,7 @@ export class CopilotResolver {
                 // push the new message
                 pushMessage({
                   id: messageId,
+                  parentMessageId: event.parentMessageId,
                   status: firstValueFrom(streamingTextStatus),
                   createdAt: new Date(),
                   role: MessageRole.assistant,
@@ -369,15 +383,28 @@ export class CopilotResolver {
                 logger.debug("Action execution start event received");
                 const actionExecutionArgumentStream = eventStream.pipe(
                   skipWhile((e) => e !== event),
-                  takeWhile((e) => e.type != RuntimeEventTypes.ActionExecutionEnd),
+                  // take until the action execution end event
+                  takeWhile(
+                    (e) =>
+                      !(
+                        e.type === RuntimeEventTypes.ActionExecutionEnd &&
+                        e.actionExecutionId == event.actionExecutionId
+                      ),
+                  ),
+                  // filter out any other action execution events or action execution ids
+                  filter(
+                    (e) =>
+                      e.type == RuntimeEventTypes.ActionExecutionArgs &&
+                      e.actionExecutionId == event.actionExecutionId,
+                  ),
                 );
                 const streamingArgumentsStatus = new Subject<typeof MessageStatusUnion>();
                 pushMessage({
                   id: event.actionExecutionId,
+                  parentMessageId: event.parentMessageId,
                   status: firstValueFrom(streamingArgumentsStatus),
                   createdAt: new Date(),
                   name: event.actionName,
-                  scope: event.scope!,
                   arguments: new Repeater(async (pushArgumentsChunk, stopStreamingArguments) => {
                     logger.debug("Action execution argument stream created");
 
@@ -413,7 +440,6 @@ export class CopilotResolver {
                             id: event.actionExecutionId,
                             createdAt: new Date(),
                             name: event.actionName,
-                            scope: event.scope!,
                             arguments: argumentChunks.join(""),
                           }),
                         );
@@ -428,7 +454,7 @@ export class CopilotResolver {
               case RuntimeEventTypes.ActionExecutionResult:
                 logger.debug({ result: event.result }, "Action execution result event received");
                 pushMessage({
-                  id: randomId(),
+                  id: "result-" + event.actionExecutionId,
                   status: new SuccessMessageStatus(),
                   createdAt: new Date(),
                   actionExecutionId: event.actionExecutionId,
@@ -438,7 +464,7 @@ export class CopilotResolver {
 
                 outputMessages.push(
                   plainToInstance(ResultMessage, {
-                    id: randomId(),
+                    id: "result-" + event.actionExecutionId,
                     createdAt: new Date(),
                     actionExecutionId: event.actionExecutionId,
                     actionName: event.actionName,

package/src/graphql/types/converted/index.ts

@@ -5,7 +5,7 @@ import {
   AgentStateMessageInput,
 } from "../../inputs/message.input";
 import { BaseMessageInput } from "../base";
-import { ActionExecutionScope, MessageRole } from "../enums";
+import { MessageRole } from "../enums";
 
 export type MessageType =
   | "TextMessage"
@@ -37,16 +37,17 @@ export class TextMessage extends Message implements TextMessageInput {
   type: MessageType = "TextMessage";
   content: string;
   role: MessageRole;
+  parentMessageId?: string;
 }
 
 export class ActionExecutionMessage
   extends Message
-  implements Omit<ActionExecutionMessageInput, "arguments">
+  implements Omit<ActionExecutionMessageInput, "arguments" | "scope">
 {
   type: MessageType = "ActionExecutionMessage";
   name: string;
   arguments: Record<string, any>;
-  scope: ActionExecutionScope;
+  parentMessageId?: string;
 }
 
 export class ResultMessage extends Message implements ResultMessageInput {

package/src/graphql/types/copilot-response.type.ts

@@ -1,5 +1,5 @@
 import { Field, InterfaceType, ObjectType } from "type-graphql";
-import { MessageRole, ActionExecutionScope } from "./enums";
+import { MessageRole } from "./enums";
 import { MessageStatusUnion } from "./message-status.type";
 import { ResponseStatusUnion } from "./response-status.type";
 
@@ -35,6 +35,9 @@ export class TextMessageOutput {
 
   @Field(() => [String])
   content: string[];
+
+  @Field(() => String, { nullable: true })
+  parentMessageId?: string;
 }
 
 @ObjectType({ implements: BaseMessageOutput })
@@ -42,11 +45,17 @@ export class ActionExecutionMessageOutput {
   @Field(() => String)
   name: string;
 
-  @Field(() => ActionExecutionScope)
-  scope: ActionExecutionScope;
+  @Field(() => String, {
+    nullable: true,
+    deprecationReason: "This field will be removed in a future version",
+  })
+  scope?: string;
 
   @Field(() => [String])
   arguments: string[];
+
+  @Field(() => String, { nullable: true })
+  parentMessageId?: string;
 }
 
 @ObjectType({ implements: BaseMessageOutput })

package/src/graphql/types/enums.ts

@@ -7,12 +7,6 @@ export enum MessageRole {
   tool = "tool",
 }
 
-export enum ActionExecutionScope {
-  server = "server",
-  client = "client",
-  passThrough = "passThrough",
-}
-
 export enum CopilotRequestType {
   Chat = "Chat",
   Task = "Task",
@@ -32,11 +26,6 @@ registerEnumType(MessageRole, {
   description: "The role of the message",
 });
 
-registerEnumType(ActionExecutionScope, {
-  name: "ActionExecutionScope",
-  description: "The scope of the action",
-});
-
 registerEnumType(CopilotRequestType, {
   name: "CopilotRequestType",
   description: "The type of Copilot request",

package/src/lib/logger.ts

@@ -12,6 +12,10 @@ export function createLogger(options?: { level?: LogLevel; component?: string })
   const logger = createPinoLogger(
     {
       level: process.env.LOG_LEVEL || level || "error",
+      redact: {
+        paths: ["pid", "hostname"],
+        remove: true,
+      },
     },
     stream,
   );