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

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

@@ -5,17 +5,13 @@ import { randomId } from "@copilotkit/shared";
 
 interface LangGraphEventWithState {
   event: LangGraphEvent | null;
-
-  isMessageStart: boolean;
-  isMessageEnd: boolean;
-  isToolCallStart: boolean;
-  isToolCallEnd: boolean;
-  isToolCall: boolean;
-
-  lastMessageId: string | null;
-  lastToolCallId: string | null;
-  lastToolCallName: string | null;
-  currentContent: string | null;
+  content: string | null;
+  toolCallName: string | null;
+  toolCallId: string | null;
+  toolCallMessageId: string | null;
+  prevToolCallMessageId: string | null;
+  messageId: string | null;
+  prevMessageId: string | null;
 }
 
 export class RemoteLangGraphEventSource {
@@ -34,43 +30,6 @@ 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;
 
@@ -78,75 +37,104 @@ export class RemoteLangGraphEventSource {
       scan(
         (acc, event) => {
           if (event.event === LangGraphEventTypes.OnChatModelStream) {
-            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);
+            // @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;
+            }
 
-            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 });
+            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.event = event;
           lastEventWithState = acc; // Capture the state
           return acc;
         },
         {
           event: null,
-          isMessageStart: false,
-          isMessageEnd: false,
-          isToolCallStart: false,
-          isToolCallEnd: false,
-          isToolCall: false,
-          lastMessageId: null,
-          lastToolCallId: null,
-          lastToolCallName: null,
-          currentContent: null,
+          toolCallId: null,
+          toolCallMessageId: null,
+          prevToolCallMessageId: null,
+          messageId: null,
+          toolCallName: null,
+          prevMessageId: null,
+          content: null,
         } as LangGraphEventWithState,
       ),
-      mergeMap((acc): RuntimeEvent[] => {
+      mergeMap((eventWithState): RuntimeEvent[] => {
         const events: RuntimeEvent[] = [];
 
         let shouldEmitMessages = true;
-        let shouldEmitToolCalls: string | string[] | boolean = true;
+        let shouldEmitToolCalls: string | string[] | boolean = false;
 
-        if (acc.event.event == LangGraphEventTypes.OnChatModelStream) {
-          if ("copilotkit:emit-tool-calls" in (acc.event.metadata || {})) {
-            shouldEmitToolCalls = acc.event.metadata["copilotkit:emit-tool-calls"];
+        if (eventWithState.event.event == LangGraphEventTypes.OnChatModelStream) {
+          if ("copilotkit:emit-tool-calls" in (eventWithState.event.metadata || {})) {
+            shouldEmitToolCalls = eventWithState.event.metadata["copilotkit:emit-tool-calls"];
           }
-          if ("copilotkit:emit-messages" in (acc.event.metadata || {})) {
-            shouldEmitMessages = acc.event.metadata["copilotkit:emit-messages"];
+          if ("copilotkit:emit-messages" in (eventWithState.event.metadata || {})) {
+            shouldEmitMessages = eventWithState.event.metadata["copilotkit:emit-messages"];
           }
         }
 
-        const responseMetadata = this.getResponseMetadata(acc.event);
-
         // Tool call ended: emit ActionExecutionEnd
         if (
-          responseMetadata?.finish_reason === "tool_calls" &&
-          this.shouldEmitToolCall(shouldEmitToolCalls, acc.lastToolCallName)
+          eventWithState.prevToolCallMessageId !== null &&
+          eventWithState.prevToolCallMessageId !== eventWithState.toolCallMessageId &&
+          this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)
         ) {
           events.push({
             type: RuntimeEventTypes.ActionExecutionEnd,
-            actionExecutionId: acc.lastToolCallId,
           });
         }
 
         // Message ended: emit TextMessageEnd
-        if (responseMetadata?.finish_reason === "stop" && shouldEmitMessages) {
+        if (
+          eventWithState.prevMessageId !== null &&
+          eventWithState.prevMessageId !== eventWithState.messageId &&
+          shouldEmitMessages
+        ) {
           events.push({
             type: RuntimeEventTypes.TextMessageEnd,
-            messageId: acc.lastMessageId,
           });
         }
 
-        switch (acc.event!.event) {
+        switch (eventWithState.event!.event) {
           //
           // Custom events
           //
@@ -154,94 +142,118 @@ export class RemoteLangGraphEventSource {
             //
             // Manually emit a message
             //
-            if (acc.event.name === CustomEventNames.CopilotKitManuallyEmitMessage) {
+            if (eventWithState.event.name === CustomEventNames.CopilotKitManuallyEmitMessage) {
               events.push({
                 type: RuntimeEventTypes.TextMessageStart,
-                messageId: acc.event.data.message_id,
+                messageId: eventWithState.event.data.message_id,
               });
               events.push({
                 type: RuntimeEventTypes.TextMessageContent,
-                messageId: acc.event.data.message_id,
-                content: acc.event.data.message,
+                content: eventWithState.event.data.message,
               });
               events.push({
                 type: RuntimeEventTypes.TextMessageEnd,
-                messageId: acc.event.data.message_id,
               });
             }
             //
             // Manually emit a tool call
             //
-            else if (acc.event.name === CustomEventNames.CopilotKitManuallyEmitToolCall) {
+            else if (
+              eventWithState.event.name === CustomEventNames.CopilotKitManuallyEmitToolCall
+            ) {
               events.push({
                 type: RuntimeEventTypes.ActionExecutionStart,
-                actionExecutionId: acc.event.data.id,
-                actionName: acc.event.data.name,
-                parentMessageId: acc.event.data.id,
+                actionExecutionId: eventWithState.event.data.id,
+                actionName: eventWithState.event.data.name,
               });
               events.push({
                 type: RuntimeEventTypes.ActionExecutionArgs,
-                actionExecutionId: acc.event.data.id,
-                args: JSON.stringify(acc.event.data.args),
+                args: JSON.stringify(eventWithState.event.data.args),
               });
               events.push({
                 type: RuntimeEventTypes.ActionExecutionEnd,
-                actionExecutionId: acc.event.data.id,
               });
             }
             break;
           case LangGraphEventTypes.OnCopilotKitStateSync:
             events.push({
               type: RuntimeEventTypes.AgentStateMessage,
-              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,
+              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,
             });
             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 (
-              acc.isToolCallStart &&
-              this.shouldEmitToolCall(shouldEmitToolCalls, acc.lastToolCallName)
+              eventWithState.toolCallMessageId !== null &&
+              eventWithState.prevToolCallMessageId !== eventWithState.toolCallMessageId
             ) {
-              events.push({
-                type: RuntimeEventTypes.ActionExecutionStart,
-                actionExecutionId: acc.lastToolCallId,
-                actionName: acc.lastToolCallName,
-                parentMessageId: acc.lastMessageId,
-              });
+              if (this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)) {
+                events.push({
+                  type: RuntimeEventTypes.ActionExecutionStart,
+                  actionExecutionId: eventWithState.toolCallMessageId,
+                  actionName: eventWithState.toolCallName,
+                  scope: "client",
+                });
+              }
             }
             // Message started: emit TextMessageStart
-            else if (acc.isMessageStart && shouldEmitMessages) {
-              events.push({
-                type: RuntimeEventTypes.TextMessageStart,
-                messageId: acc.lastMessageId,
-              });
+            else if (
+              eventWithState.messageId !== null &&
+              eventWithState.prevMessageId !== eventWithState.messageId
+            ) {
+              if (shouldEmitMessages) {
+                events.push({
+                  type: RuntimeEventTypes.TextMessageStart,
+                  messageId: eventWithState.messageId,
+                });
+              }
             }
 
+            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 (
-              acc.isToolCall &&
-              acc.currentContent &&
-              this.shouldEmitToolCall(shouldEmitToolCalls, acc.lastToolCallName)
-            ) {
-              events.push({
-                type: RuntimeEventTypes.ActionExecutionArgs,
-                actionExecutionId: acc.lastToolCallId,
-                args: acc.currentContent,
-              });
+            if (args) {
+              if (this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)) {
+                events.push({
+                  type: RuntimeEventTypes.ActionExecutionArgs,
+                  args,
+                });
+              }
             }
             // Message content: emit TextMessageContent
-            else if (!acc.isToolCall && acc.currentContent && shouldEmitMessages) {
-              events.push({
-                type: RuntimeEventTypes.TextMessageContent,
-                messageId: acc.lastMessageId,
-                content: acc.currentContent,
-              });
+            else if (eventWithState.messageId !== null && content) {
+              if (shouldEmitMessages) {
+                events.push({
+                  type: RuntimeEventTypes.TextMessageContent,
+                  content,
+                });
+              }
             }
             break;
         }
@@ -251,16 +263,14 @@ export class RemoteLangGraphEventSource {
         console.error(error);
         const events: RuntimeEvent[] = [];
 
-        if (lastEventWithState?.lastMessageId && !lastEventWithState.isToolCall) {
+        if (lastEventWithState?.messageId) {
           events.push({
             type: RuntimeEventTypes.TextMessageEnd,
-            messageId: lastEventWithState.lastMessageId,
           });
         }
-        if (lastEventWithState?.lastToolCallId) {
+        if (lastEventWithState?.toolCallMessageId) {
           events.push({
             type: RuntimeEventTypes.ActionExecutionEnd,
-            actionExecutionId: lastEventWithState.lastToolCallId,
           });
         }
 
@@ -272,12 +282,10 @@ 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/forwarded-parameters.input.ts

@@ -16,4 +16,7 @@ export class ForwardedParametersInput {
 
   @Field(() => String, { nullable: true })
   toolChoiceFunctionName?: string;
+
+  @Field(() => Number, { nullable: true })
+  temperature?: number;
 }

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

@@ -1,5 +1,5 @@
 import { Field, InputType } from "type-graphql";
-import { MessageRole } from "../types/enums";
+import { MessageRole, ActionExecutionScope } from "../types/enums";
 import { BaseMessageInput } from "../types/base";
 
 // GraphQL does not support union types in inputs, so we need to use
@@ -24,9 +24,6 @@ export class TextMessageInput {
   @Field(() => String)
   content: string;
 
-  @Field(() => String, { nullable: true })
-  parentMessageId?: string;
-
   @Field(() => MessageRole)
   role: MessageRole;
 }
@@ -39,14 +36,8 @@ export class ActionExecutionMessageInput {
   @Field(() => String)
   arguments: string;
 
-  @Field(() => String, { nullable: true })
-  parentMessageId?: string;
-
-  @Field(() => String, {
-    nullable: true,
-    deprecationReason: "This field will be removed in a future version",
-  })
-  scope?: String;
+  @Field(() => ActionExecutionScope)
+  scope: ActionExecutionScope;
 }
 
 @InputType()
@@ -57,9 +48,6 @@ 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,7 +3,6 @@ import {
   ReplaySubject,
   Subject,
   Subscription,
-  filter,
   finalize,
   firstValueFrom,
   shareReplay,
@@ -289,19 +288,7 @@ 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 &&
-                        e.messageId == event.messageId
-                      ),
-                  ),
-                  // filter out any other message events or message ids
-                  filter(
-                    (e) =>
-                      e.type == RuntimeEventTypes.TextMessageContent &&
-                      e.messageId == event.messageId,
-                  ),
+                  takeWhile((e) => e.type != RuntimeEventTypes.TextMessageEnd),
                 );
 
                 // signal when we are done streaming
@@ -311,7 +298,6 @@ export class CopilotResolver {
                 // push the new message
                 pushMessage({
                   id: messageId,
-                  parentMessageId: event.parentMessageId,
                   status: firstValueFrom(streamingTextStatus),
                   createdAt: new Date(),
                   role: MessageRole.assistant,
@@ -383,28 +369,15 @@ export class CopilotResolver {
                 logger.debug("Action execution start event received");
                 const actionExecutionArgumentStream = eventStream.pipe(
                   skipWhile((e) => e !== event),
-                  // 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,
-                  ),
+                  takeWhile((e) => e.type != RuntimeEventTypes.ActionExecutionEnd),
                 );
                 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");
 
@@ -440,6 +413,7 @@ export class CopilotResolver {
                             id: event.actionExecutionId,
                             createdAt: new Date(),
                             name: event.actionName,
+                            scope: event.scope!,
                             arguments: argumentChunks.join(""),
                           }),
                         );
@@ -454,7 +428,7 @@ export class CopilotResolver {
               case RuntimeEventTypes.ActionExecutionResult:
                 logger.debug({ result: event.result }, "Action execution result event received");
                 pushMessage({
-                  id: "result-" + event.actionExecutionId,
+                  id: randomId(),
                   status: new SuccessMessageStatus(),
                   createdAt: new Date(),
                   actionExecutionId: event.actionExecutionId,
@@ -464,7 +438,7 @@ export class CopilotResolver {
 
                 outputMessages.push(
                   plainToInstance(ResultMessage, {
-                    id: "result-" + event.actionExecutionId,
+                    id: randomId(),
                     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 { MessageRole } from "../enums";
+import { ActionExecutionScope, MessageRole } from "../enums";
 
 export type MessageType =
   | "TextMessage"
@@ -37,17 +37,16 @@ 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" | "scope">
+  implements Omit<ActionExecutionMessageInput, "arguments">
 {
   type: MessageType = "ActionExecutionMessage";
   name: string;
   arguments: Record<string, any>;
-  parentMessageId?: string;
+  scope: ActionExecutionScope;
 }
 
 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 } from "./enums";
+import { MessageRole, ActionExecutionScope } from "./enums";
 import { MessageStatusUnion } from "./message-status.type";
 import { ResponseStatusUnion } from "./response-status.type";
 
@@ -35,9 +35,6 @@ export class TextMessageOutput {
 
   @Field(() => [String])
   content: string[];
-
-  @Field(() => String, { nullable: true })
-  parentMessageId?: string;
 }
 
 @ObjectType({ implements: BaseMessageOutput })
@@ -45,17 +42,11 @@ export class ActionExecutionMessageOutput {
   @Field(() => String)
   name: string;
 
-  @Field(() => String, {
-    nullable: true,
-    deprecationReason: "This field will be removed in a future version",
-  })
-  scope?: string;
+  @Field(() => ActionExecutionScope)
+  scope: ActionExecutionScope;
 
   @Field(() => [String])
   arguments: string[];
-
-  @Field(() => String, { nullable: true })
-  parentMessageId?: string;
 }
 
 @ObjectType({ implements: BaseMessageOutput })

package/src/graphql/types/enums.ts

@@ -7,6 +7,12 @@ export enum MessageRole {
   tool = "tool",
 }
 
+export enum ActionExecutionScope {
+  server = "server",
+  client = "client",
+  passThrough = "passThrough",
+}
+
 export enum CopilotRequestType {
   Chat = "Chat",
   Task = "Task",
@@ -26,6 +32,11 @@ 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",