@copilotkit/runtime 1.3.2 → 1.3.3

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

@@ -1,12 +1,14 @@
-import { ReplaySubject, scan, mergeMap } from "rxjs";
+import { ReplaySubject, scan, mergeMap, catchError } from "rxjs";
 import { LangGraphEvent, LangGraphEventTypes } from "./events";
 import { RuntimeEvent, RuntimeEventTypes } from "../../service-adapters/events";
+import { randomId } from "@copilotkit/shared";
 
 interface LangGraphEventWithState {
   event: LangGraphEvent | null;
   toolCallName: string | null;
   toolCallId: string | null;
-  prevToolCallId: string | null;
+  toolCallMessageId: string | null;
+  prevToolCallMessageId: string | null;
   messageId: string | null;
   prevMessageId: string | null;
 }
@@ -48,51 +50,77 @@ export class RemoteLangGraphEventSource {
         });
     }
 
-    while (true) {
-      const { done, value } = await reader.read();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
 
-      if (!done) {
-        buffer.push(decoder.decode(value, { stream: true }));
-      }
+        if (!done) {
+          buffer.push(decoder.decode(value, { stream: true }));
+        }
 
-      flushBuffer();
+        flushBuffer();
 
-      if (done) {
-        break;
+        if (done) {
+          break;
+        }
       }
+    } catch (error) {
+      console.error("Error in stream", error);
+      eventStream$.error(error);
+      return;
     }
     eventStream$.complete();
   }
 
+  private shouldEmitToolCall(
+    shouldEmitToolCalls: string | string[] | boolean,
+    toolCallName: string,
+  ) {
+    if (typeof shouldEmitToolCalls === "boolean") {
+      return shouldEmitToolCalls;
+    }
+    if (Array.isArray(shouldEmitToolCalls)) {
+      return shouldEmitToolCalls.includes(toolCallName);
+    }
+    return shouldEmitToolCalls === toolCallName;
+  }
+
   processLangGraphEvents() {
+    let lastEventWithState: LangGraphEventWithState | null = null;
+
     return this.eventStream$.pipe(
       scan(
         (acc, event) => {
           if (event.event === LangGraphEventTypes.OnChatModelStream) {
             if (event.data?.chunk?.kwargs?.tool_call_chunks) {
-              acc.prevToolCallId = acc.toolCallId;
-              acc.toolCallId = event.data.chunk.kwargs?.id;
+              acc.prevToolCallMessageId = acc.toolCallMessageId;
+              acc.toolCallMessageId = event.data.chunk.kwargs?.id;
               if (event.data.chunk.kwargs.tool_call_chunks[0]?.name) {
                 acc.toolCallName = event.data.chunk.kwargs.tool_call_chunks[0].name;
               }
+              if (event.data.chunk.kwargs.tool_call_chunks[0]?.id) {
+                acc.toolCallId = event.data.chunk.kwargs.tool_call_chunks[0].id;
+              }
             }
             acc.prevMessageId = acc.messageId;
             acc.messageId = event.data?.chunk?.kwargs?.id;
           } else {
-            acc.prevToolCallId = acc.toolCallId;
-            acc.toolCallId = null;
+            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,
           toolCallId: null,
-          prevToolCallId: null,
+          toolCallMessageId: null,
+          prevToolCallMessageId: null,
           messageId: null,
           toolCallName: null,
           prevMessageId: null,
@@ -102,7 +130,7 @@ export class RemoteLangGraphEventSource {
         const events: RuntimeEvent[] = [];
 
         let shouldEmitMessages = true;
-        let shouldEmitToolCalls = false;
+        let shouldEmitToolCalls: string | string[] | boolean = false;
 
         if (eventWithState.event.event == LangGraphEventTypes.OnChatModelStream) {
           if ("copilotkit:emit-tool-calls" in (eventWithState.event.metadata || {})) {
@@ -115,9 +143,9 @@ export class RemoteLangGraphEventSource {
 
         // Tool call ended: emit ActionExecutionEnd
         if (
-          eventWithState.prevToolCallId !== null &&
-          eventWithState.prevToolCallId !== eventWithState.toolCallId &&
-          shouldEmitToolCalls
+          eventWithState.prevToolCallMessageId !== null &&
+          eventWithState.prevToolCallMessageId !== eventWithState.toolCallMessageId &&
+          this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)
         ) {
           events.push({
             type: RuntimeEventTypes.ActionExecutionEnd,
@@ -149,6 +177,20 @@ export class RemoteLangGraphEventSource {
               type: RuntimeEventTypes.TextMessageEnd,
             });
             break;
+          case LangGraphEventTypes.OnCopilotKitEmitToolCall:
+            events.push({
+              type: RuntimeEventTypes.ActionExecutionStart,
+              actionExecutionId: eventWithState.event.id,
+              actionName: eventWithState.event.name,
+            });
+            events.push({
+              type: RuntimeEventTypes.ActionExecutionArgs,
+              args: JSON.stringify(eventWithState.event.args),
+            });
+            events.push({
+              type: RuntimeEventTypes.ActionExecutionEnd,
+            });
+            break;
           case LangGraphEventTypes.OnCopilotKitStateSync:
             events.push({
               type: RuntimeEventTypes.AgentStateMessage,
@@ -180,13 +222,13 @@ export class RemoteLangGraphEventSource {
             break;
           case LangGraphEventTypes.OnChatModelStream:
             if (
-              eventWithState.toolCallId !== null &&
-              eventWithState.prevToolCallId !== eventWithState.toolCallId
+              eventWithState.toolCallMessageId !== null &&
+              eventWithState.prevToolCallMessageId !== eventWithState.toolCallMessageId
             ) {
-              if (shouldEmitToolCalls) {
+              if (this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)) {
                 events.push({
                   type: RuntimeEventTypes.ActionExecutionStart,
-                  actionExecutionId: eventWithState.toolCallId,
+                  actionExecutionId: eventWithState.toolCallMessageId,
                   actionName: eventWithState.toolCallName,
                   scope: "client",
                 });
@@ -210,7 +252,7 @@ export class RemoteLangGraphEventSource {
 
             // Tool call args: emit ActionExecutionArgs
             if (args) {
-              if (shouldEmitToolCalls) {
+              if (this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)) {
                 events.push({
                   type: RuntimeEventTypes.ActionExecutionArgs,
                   args,
@@ -230,6 +272,37 @@ export class RemoteLangGraphEventSource {
         }
         return events;
       }),
+      catchError((error) => {
+        console.error(error);
+        const events: RuntimeEvent[] = [];
+
+        if (lastEventWithState?.messageId) {
+          events.push({
+            type: RuntimeEventTypes.TextMessageEnd,
+          });
+        }
+        if (lastEventWithState?.toolCallMessageId) {
+          events.push({
+            type: RuntimeEventTypes.ActionExecutionEnd,
+          });
+        }
+
+        const messageId = randomId();
+
+        events.push({
+          type: RuntimeEventTypes.TextMessageStart,
+          messageId: messageId,
+        });
+        events.push({
+          type: RuntimeEventTypes.TextMessageContent,
+          content: "❌ An error occurred. Please try again.",
+        });
+        events.push({
+          type: RuntimeEventTypes.TextMessageEnd,
+        });
+
+        return events;
+      }),
     );
   }
 }

package/src/agents/langgraph/events.ts

@@ -9,6 +9,7 @@ export enum LangGraphEventTypes {
   OnToolEnd = "on_tool_end",
   OnCopilotKitStateSync = "on_copilotkit_state_sync",
   OnCopilotKitEmitMessage = "on_copilotkit_emit_message",
+  OnCopilotKitEmitToolCall = "on_copilotkit_emit_tool_call",
 }
 
 type LangGraphOnCopilotKitStateSyncEvent = {
@@ -29,6 +30,13 @@ type LangGraphOnCopilotKitManualMessageEvent = {
   message_id: string;
 };
 
+type LangGraphOnCopilotKitEmitToolCallEvent = {
+  event: LangGraphEventTypes.OnCopilotKitEmitToolCall;
+  name: string;
+  args: any;
+  id: string;
+};
+
 type LangGraphOnChainStartEvent = {
   event: LangGraphEventTypes.OnChainStart;
   run_id: string;
@@ -314,4 +322,5 @@ export type LangGraphEvent =
   | LangGraphOnToolStartEvent
   | LangGraphOnToolEndEvent
   | LangGraphOnCopilotKitStateSyncEvent
-  | LangGraphOnCopilotKitManualMessageEvent;
+  | LangGraphOnCopilotKitManualMessageEvent
+  | LangGraphOnCopilotKitEmitToolCallEvent;

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

@@ -16,6 +16,11 @@ export type RemoteActionDefinition = {
   };
 };
 
+export type RemoteActionInfoResponse = {
+  actions: any[];
+  agents: any[];
+};
+
 export type LangGraphAgentHandlerParams = {
   name: string;
   actionInputsWithoutAgents: ActionInput[];
@@ -64,27 +69,35 @@ async function fetchRemoteInfo({
   graphqlContext: GraphQLContext;
   logger: Logger;
   frontendUrl?: string;
-}): Promise<any[]> {
+}): Promise<RemoteActionInfoResponse> {
   logger.debug({ url }, "Fetching actions from url");
   const headers = createHeaders(onBeforeRequest, graphqlContext);
 
-  const response = await fetch(`${url}/info`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ properties: graphqlContext.properties, frontendUrl }),
-  });
+  try {
+    const response = await fetch(`${url}/info`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ properties: graphqlContext.properties, frontendUrl }),
+    });
 
-  if (!response.ok) {
+    if (!response.ok) {
+      logger.error(
+        { url, status: response.status, body: await response.text() },
+        "Failed to fetch actions from url",
+      );
+      return { actions: [], agents: [] };
+    }
+
+    const json = await response.json();
+    logger.debug({ json }, "Fetched actions from url");
+    return json;
+  } catch (error) {
     logger.error(
-      { url, status: response.status, body: await response.text() },
+      { error: error.message ? error.message : error + "" },
       "Failed to fetch actions from url",
     );
-    return [];
+    return { actions: [], agents: [] };
   }
-
-  const json = await response.json();
-  logger.debug({ json }, "Fetched actions from url");
-  return json;
 }
 
 function constructRemoteActions({
@@ -96,7 +109,7 @@ function constructRemoteActions({
   messages,
   agentStates,
 }: {
-  json: any[];
+  json: RemoteActionInfoResponse;
   url: string;
   onBeforeRequest?: RemoteActionDefinition["onBeforeRequest"];
   graphqlContext: GraphQLContext;
@@ -114,29 +127,37 @@ function constructRemoteActions({
       const headers = createHeaders(onBeforeRequest, graphqlContext);
       telemetry.capture("oss.runtime.remote_action_executed", {});
 
-      const response = await fetch(`${url}/actions/execute`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          name: action.name,
-          arguments: args,
-          properties: graphqlContext.properties,
-        }),
-      });
+      try {
+        const response = await fetch(`${url}/actions/execute`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            name: action.name,
+            arguments: args,
+            properties: graphqlContext.properties,
+          }),
+        });
 
-      if (!response.ok) {
+        if (!response.ok) {
+          logger.error(
+            { url, status: response.status, body: await response.text() },
+            "Failed to execute remote action",
+          );
+          return "Failed to execute remote action";
+        }
+
+        const requestResult = await response.json();
+
+        const result = requestResult["result"];
+        logger.debug({ actionName: action.name, result }, "Executed remote action");
+        return result;
+      } catch (error) {
         logger.error(
-          { url, status: response.status, body: await response.text() },
+          { error: error.message ? error.message : error + "" },
           "Failed to execute remote action",
         );
         return "Failed to execute remote action";
       }
-
-      const requestResult = await response.json();
-
-      const result = requestResult["result"];
-      logger.debug({ actionName: action.name, result }, "Executed remote action");
-      return result;
     },
   }));