@copilotkit/runtime 1.4.0-pre-1-4-0.11 → 1.4.0-pre-1-4-0.12

package/src/service-adapters/events.ts

@@ -1,4 +1,4 @@
-import { Action } from "@copilotkit/shared";
+import { Action, randomId } from "@copilotkit/shared";
 import {
   of,
   concat,
@@ -33,17 +33,18 @@ export type RuntimeEvent =
   | { type: RuntimeEventTypes.TextMessageStart; messageId: string }
   | {
       type: RuntimeEventTypes.TextMessageContent;
+      messageId: string;
       content: string;
     }
-  | { type: RuntimeEventTypes.TextMessageEnd }
+  | { type: RuntimeEventTypes.TextMessageEnd; messageId: string }
   | {
       type: RuntimeEventTypes.ActionExecutionStart;
       actionExecutionId: string;
       actionName: string;
       scope?: FunctionCallScope;
     }
-  | { type: RuntimeEventTypes.ActionExecutionArgs; args: string }
-  | { type: RuntimeEventTypes.ActionExecutionEnd }
+  | { type: RuntimeEventTypes.ActionExecutionArgs; actionExecutionId: string; args: string }
+  | { type: RuntimeEventTypes.ActionExecutionEnd; actionExecutionId: string }
   | {
       type: RuntimeEventTypes.ActionExecutionResult;
       actionName: string;
@@ -77,25 +78,31 @@ export class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
     super();
   }
 
-  sendTextMessageStart(messageId: string) {
+  sendTextMessageStart({ messageId }: { messageId: string }) {
     this.next({ type: RuntimeEventTypes.TextMessageStart, messageId });
   }
 
-  sendTextMessageContent(content: string) {
-    this.next({ type: RuntimeEventTypes.TextMessageContent, content });
+  sendTextMessageContent({ messageId, content }: { messageId: string; content: string }) {
+    this.next({ type: RuntimeEventTypes.TextMessageContent, content, messageId });
   }
 
-  sendTextMessageEnd() {
-    this.next({ type: RuntimeEventTypes.TextMessageEnd });
+  sendTextMessageEnd({ messageId }: { messageId: string }) {
+    this.next({ type: RuntimeEventTypes.TextMessageEnd, messageId });
   }
 
   sendTextMessage(messageId: string, content: string) {
-    this.sendTextMessageStart(messageId);
-    this.sendTextMessageContent(content);
-    this.sendTextMessageEnd();
+    this.sendTextMessageStart({ messageId });
+    this.sendTextMessageContent({ messageId, content });
+    this.sendTextMessageEnd({ messageId });
   }
 
-  sendActionExecutionStart(actionExecutionId: string, actionName: string) {
+  sendActionExecutionStart({
+    actionExecutionId,
+    actionName,
+  }: {
+    actionExecutionId: string;
+    actionName: string;
+  }) {
     this.next({
       type: RuntimeEventTypes.ActionExecutionStart,
       actionExecutionId,
@@ -103,21 +110,43 @@ export class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
     });
   }
 
-  sendActionExecutionArgs(args: string) {
-    this.next({ type: RuntimeEventTypes.ActionExecutionArgs, args });
+  sendActionExecutionArgs({
+    actionExecutionId,
+    args,
+  }: {
+    actionExecutionId: string;
+    args: string;
+  }) {
+    this.next({ type: RuntimeEventTypes.ActionExecutionArgs, args, actionExecutionId });
   }
 
-  sendActionExecutionEnd() {
-    this.next({ type: RuntimeEventTypes.ActionExecutionEnd });
+  sendActionExecutionEnd({ actionExecutionId }: { actionExecutionId: string }) {
+    this.next({ type: RuntimeEventTypes.ActionExecutionEnd, actionExecutionId });
   }
 
-  sendActionExecution(actionExecutionId: string, toolName: string, args: string) {
-    this.sendActionExecutionStart(actionExecutionId, toolName);
-    this.sendActionExecutionArgs(args);
-    this.sendActionExecutionEnd();
+  sendActionExecution({
+    actionExecutionId,
+    actionName,
+    args,
+  }: {
+    actionExecutionId: string;
+    actionName: string;
+    args: string;
+  }) {
+    this.sendActionExecutionStart({ actionExecutionId, actionName });
+    this.sendActionExecutionArgs({ actionExecutionId, args });
+    this.sendActionExecutionEnd({ actionExecutionId });
   }
 
-  sendActionExecutionResult(actionExecutionId: string, actionName: string, result: string) {
+  sendActionExecutionResult({
+    actionExecutionId,
+    actionName,
+    result,
+  }: {
+    actionExecutionId: string;
+    actionName: string;
+    result: string;
+  }) {
     this.next({
       type: RuntimeEventTypes.ActionExecutionResult,
       actionName,
@@ -126,16 +155,25 @@ export class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
     });
   }
 
-  sendAgentStateMessage(
-    threadId: string,
-    agentName: string,
-    nodeName: string,
-    runId: string,
-    active: boolean,
-    role: string,
-    state: string,
-    running: boolean,
-  ) {
+  sendAgentStateMessage({
+    threadId,
+    agentName,
+    nodeName,
+    runId,
+    active,
+    role,
+    state,
+    running,
+  }: {
+    threadId: string;
+    agentName: string;
+    nodeName: string;
+    runId: string;
+    active: boolean;
+    role: string;
+    state: string;
+    running: boolean;
+  }) {
     this.next({
       type: RuntimeEventTypes.AgentStateMessage,
       threadId,
@@ -158,6 +196,17 @@ export class RuntimeEventSource {
     this.callback = callback;
   }
 
+  sendErrorMessageToChat() {
+    const errorMessage = "❌ An error occurred. Please try again.";
+    if (!this.callback) {
+      this.stream(async (eventStream$) => {
+        eventStream$.sendTextMessage(randomId(), errorMessage);
+      });
+    } else {
+      this.eventStream$.sendTextMessage(randomId(), errorMessage);
+    }
+  }
+
   processRuntimeEvents({
     serverSideActions,
     guardrailsResult$,
@@ -169,6 +218,7 @@ export class RuntimeEventSource {
   }) {
     this.callback(this.eventStream$).catch((error) => {
       console.error("Error in event source callback", error);
+      this.sendErrorMessageToChat();
     });
     return this.eventStream$.pipe(
       // mark tools for server side execution
@@ -269,11 +319,11 @@ async function executeAction(
 
   // handle LangGraph agents
   if (isLangGraphAgentAction(action)) {
-    eventStream$.sendActionExecutionResult(
+    eventStream$.sendActionExecutionResult({
       actionExecutionId,
-      action.name,
-      `${action.name} agent started`,
-    );
+      actionName: action.name,
+      result: `${action.name} agent started`,
+    });
     const stream = await action.langGraphAgentHandler({
       name: action.name,
       actionInputsWithoutAgents,

package/src/service-adapters/experimental/ollama/ollama-adapter.ts

@@ -58,11 +58,15 @@ export class ExperimentalOllamaAdapter implements CopilotServiceAdapter {
     const _stream = await ollama.stream(contents); // [TODO] role info is dropped...
 
     eventSource.stream(async (eventStream$) => {
-      eventStream$.sendTextMessageStart(randomId());
+      const currentMessageId = randomId();
+      eventStream$.sendTextMessageStart({ messageId: currentMessageId });
       for await (const chunkText of _stream) {
-        eventStream$.sendTextMessageContent(chunkText);
+        eventStream$.sendTextMessageContent({
+          messageId: currentMessageId,
+          content: chunkText,
+        });
       }
-      eventStream$.sendTextMessageEnd();
+      eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
       // we may need to add this later.. [nc]
       // let calls = (await result.response).functionCalls();
 

package/src/service-adapters/google/google-genai-adapter.ts

@@ -29,12 +29,12 @@ interface GoogleGenerativeAIAdapterOptions {
 export class GoogleGenerativeAIAdapter extends LangChainAdapter {
   constructor(options?: GoogleGenerativeAIAdapterOptions) {
     super({
-      chainFn: async ({ messages, tools }) => {
+      chainFn: async ({ messages, tools, threadId }) => {
         const model = new ChatGoogle({
           modelName: options?.model ?? "gemini-1.5-pro",
           apiVersion: "v1beta",
         }).bindTools(tools);
-        return model.stream(messages);
+        return model.stream(messages, { metadata: { conversation_id: threadId } });
       },
     });
   }

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

@@ -108,6 +108,9 @@ export class GroqAdapter implements CopilotServiceAdapter {
 
     eventSource.stream(async (eventStream$) => {
       let mode: "function" | "message" | null = null;
+      let currentMessageId: string;
+      let currentToolCallId: string;
+
       for await (const chunk of stream) {
         const toolCall = chunk.choices[0].delta.tool_calls?.[0];
         const content = chunk.choices[0].delta.content;
@@ -117,36 +120,47 @@ export class GroqAdapter implements CopilotServiceAdapter {
         // If toolCall?.id is defined, it means a new tool call starts.
         if (mode === "message" && toolCall?.id) {
           mode = null;
-          eventStream$.sendTextMessageEnd();
+          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
         } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
           mode = null;
-          eventStream$.sendActionExecutionEnd();
+          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
         }
 
         // If we send a new message type, send the appropriate start event.
         if (mode === null) {
           if (toolCall?.id) {
             mode = "function";
-            eventStream$.sendActionExecutionStart(toolCall!.id, toolCall!.function!.name);
+            currentToolCallId = toolCall!.id;
+            eventStream$.sendActionExecutionStart({
+              actionExecutionId: currentToolCallId,
+              actionName: toolCall!.function!.name,
+            });
           } else if (content) {
             mode = "message";
-            eventStream$.sendTextMessageStart(chunk.id);
+            currentMessageId = chunk.id;
+            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
           }
         }
 
         // send the content events
         if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent(content);
+          eventStream$.sendTextMessageContent({
+            messageId: currentMessageId,
+            content,
+          });
         } else if (mode === "function" && toolCall?.function?.arguments) {
-          eventStream$.sendActionExecutionArgs(toolCall.function.arguments);
+          eventStream$.sendActionExecutionArgs({
+            actionExecutionId: currentToolCallId,
+            args: toolCall.function.arguments,
+          });
         }
       }
 
       // send the end events
       if (mode === "message") {
-        eventStream$.sendTextMessageEnd();
+        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
       } else if (mode === "function") {
-        eventStream$.sendActionExecutionEnd();
+        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
       }
 
       eventStream$.complete();

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

@@ -47,6 +47,7 @@ import {
 import { DynamicStructuredTool } from "@langchain/core/tools";
 import { LangChainReturnType } from "./types";
 import { randomId } from "@copilotkit/shared";
+import { awaitAllCallbacks } from "@langchain/core/callbacks/promises";
 
 interface ChainFnParameters {
   model: string;
@@ -72,24 +73,29 @@ export class LangChainAdapter implements CopilotServiceAdapter {
   async process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
-    const { eventSource, model, actions, messages, threadId, runId } = request;
-    const result = await this.options.chainFn({
-      messages: messages.map(convertMessageToLangChainMessage),
-      tools: actions.map(convertActionInputToLangChainTool),
-      model,
-      threadId,
-      runId,
-    });
+    try {
+      const { eventSource, model, actions, messages, runId } = request;
+      const threadId = request.threadId ?? randomId();
+      const result = await this.options.chainFn({
+        messages: messages.map(convertMessageToLangChainMessage),
+        tools: actions.map(convertActionInputToLangChainTool),
+        model,
+        threadId,
+        runId,
+      });
 
-    eventSource.stream(async (eventStream$) => {
-      await streamLangChainResponse({
-        result,
-        eventStream$,
+      eventSource.stream(async (eventStream$) => {
+        await streamLangChainResponse({
+          result,
+          eventStream$,
+        });
       });
-    });
 
-    return {
-      threadId: threadId || randomId(),
-    };
+      return {
+        threadId,
+      };
+    } finally {
+      await awaitAllCallbacks();
+    }
   }
 }

package/src/service-adapters/langchain/utils.ts

@@ -129,11 +129,11 @@ function maybeSendActionExecutionResultIsMessage(
   // language models need a result after the function call
   // we simply let them know that we are sending a message
   if (actionExecution) {
-    eventStream$.sendActionExecutionResult(
-      actionExecution.id,
-      actionExecution.name,
-      "Sending a message",
-    );
+    eventStream$.sendActionExecutionResult({
+      actionExecutionId: actionExecution.id,
+      actionName: actionExecution.name,
+      result: "Sending a message",
+    });
   }
 }
 
@@ -152,7 +152,11 @@ export async function streamLangChainResponse({
       eventStream$.sendTextMessage(randomId(), result);
     } else {
       // Send as a result
-      eventStream$.sendActionExecutionResult(actionExecution.id, actionExecution.name, result);
+      eventStream$.sendActionExecutionResult({
+        actionExecutionId: actionExecution.id,
+        actionName: actionExecution.name,
+        result: result,
+      });
     }
   }
 
@@ -165,11 +169,11 @@ export async function streamLangChainResponse({
       eventStream$.sendTextMessage(randomId(), result.content as string);
     }
     for (const toolCall of result.tool_calls) {
-      eventStream$.sendActionExecution(
-        toolCall.id || randomId(),
-        toolCall.name,
-        JSON.stringify(toolCall.args),
-      );
+      eventStream$.sendActionExecution({
+        actionExecutionId: toolCall.id || randomId(),
+        actionName: toolCall.name,
+        args: JSON.stringify(toolCall.args),
+      });
     }
   }
 
@@ -183,11 +187,11 @@ export async function streamLangChainResponse({
     }
     if (result.lc_kwargs?.tool_calls) {
       for (const toolCall of result.lc_kwargs?.tool_calls) {
-        eventStream$.sendActionExecution(
-          toolCall.id || randomId(),
-          toolCall.name,
-          JSON.stringify(toolCall.args),
-        );
+        eventStream$.sendActionExecution({
+          actionExecutionId: toolCall.id || randomId(),
+          actionName: toolCall.name,
+          args: JSON.stringify(toolCall.args),
+        });
       }
     }
   }
@@ -214,6 +218,7 @@ export async function streamLangChainResponse({
 
         let toolCallName: string | undefined = undefined;
         let toolCallId: string | undefined = undefined;
+        let currentMessageId: string;
         let toolCallArgs: string | undefined = undefined;
         let hasToolCall: boolean = false;
         let content = value?.content as string;
@@ -248,10 +253,10 @@ export async function streamLangChainResponse({
         // If toolCallName is defined, it means a new tool call starts.
         if (mode === "message" && (toolCallId || done)) {
           mode = null;
-          eventStream$.sendTextMessageEnd();
+          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
         } else if (mode === "function" && (!hasToolCall || done)) {
           mode = null;
-          eventStream$.sendActionExecutionEnd();
+          eventStream$.sendActionExecutionEnd({ actionExecutionId: toolCallId });
         }
 
         if (done) {
@@ -262,26 +267,37 @@ export async function streamLangChainResponse({
         if (mode === null) {
           if (hasToolCall && toolCallId && toolCallName) {
             mode = "function";
-            eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
+            eventStream$.sendActionExecutionStart({
+              actionExecutionId: toolCallId,
+              actionName: toolCallName,
+            });
           } else if (content) {
             mode = "message";
-            eventStream$.sendTextMessageStart(randomId());
+            currentMessageId = randomId();
+            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
           }
         }
 
         // send the content events
         if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent(
-            Array.isArray(content) ? (content[0]?.text ?? "") : content,
-          );
+          eventStream$.sendTextMessageContent({
+            messageId: currentMessageId,
+            content: Array.isArray(content) ? (content[0]?.text ?? "") : content,
+          });
         } else if (mode === "function" && toolCallArgs) {
           // For calls of the same tool with different index, we seal last tool call and register a new one
           if (toolCallDetails.index !== toolCallDetails.prevIndex) {
-            eventStream$.sendActionExecutionEnd();
-            eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
+            eventStream$.sendActionExecutionEnd({ actionExecutionId: toolCallId });
+            eventStream$.sendActionExecutionStart({
+              actionExecutionId: toolCallId,
+              actionName: toolCallName,
+            });
             toolCallDetails.prevIndex = toolCallDetails.index;
           }
-          eventStream$.sendActionExecutionArgs(toolCallArgs);
+          eventStream$.sendActionExecutionArgs({
+            actionExecutionId: toolCallId,
+            args: toolCallArgs,
+          });
         }
       } catch (error) {
         console.error("Error reading from stream", error);
@@ -289,11 +305,11 @@ export async function streamLangChainResponse({
       }
     }
   } else if (actionExecution) {
-    eventStream$.sendActionExecutionResult(
-      actionExecution.id,
-      actionExecution.name,
-      encodeResult(result),
-    );
+    eventStream$.sendActionExecutionResult({
+      actionExecutionId: actionExecution.id,
+      actionName: actionExecution.name,
+      result: encodeResult(result),
+    });
   }
 
   // unsupported type

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

@@ -144,7 +144,13 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
 
     eventSource.stream(async (eventStream$) => {
       let mode: "function" | "message" | null = null;
+      let currentMessageId: string;
+      let currentToolCallId: string;
       for await (const chunk of stream) {
+        if (chunk.choices.length === 0) {
+          continue;
+        }
+
         const toolCall = chunk.choices[0].delta.tool_calls?.[0];
         const content = chunk.choices[0].delta.content;
 
@@ -153,36 +159,47 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
         // If toolCall?.id is defined, it means a new tool call starts.
         if (mode === "message" && toolCall?.id) {
           mode = null;
-          eventStream$.sendTextMessageEnd();
+          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
         } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
           mode = null;
-          eventStream$.sendActionExecutionEnd();
+          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
         }
 
         // If we send a new message type, send the appropriate start event.
         if (mode === null) {
           if (toolCall?.id) {
             mode = "function";
-            eventStream$.sendActionExecutionStart(toolCall!.id, toolCall!.function!.name);
+            currentToolCallId = toolCall!.id;
+            eventStream$.sendActionExecutionStart({
+              actionExecutionId: currentToolCallId,
+              actionName: toolCall!.function!.name,
+            });
           } else if (content) {
             mode = "message";
-            eventStream$.sendTextMessageStart(chunk.id);
+            currentMessageId = chunk.id;
+            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
           }
         }
 
         // send the content events
         if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent(content);
+          eventStream$.sendTextMessageContent({
+            messageId: currentMessageId,
+            content: content,
+          });
         } else if (mode === "function" && toolCall?.function?.arguments) {
-          eventStream$.sendActionExecutionArgs(toolCall.function.arguments);
+          eventStream$.sendActionExecutionArgs({
+            actionExecutionId: currentToolCallId,
+            args: toolCall.function.arguments,
+          });
         }
       }
 
       // send the end events
       if (mode === "message") {
-        eventStream$.sendTextMessageEnd();
+        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
       } else if (mode === "function") {
-        eventStream$.sendActionExecutionEnd();
+        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
       }
 
       eventStream$.complete();

package/src/service-adapters/openai/openai-assistant-adapter.ts

@@ -228,22 +228,28 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
   private async streamResponse(stream: AssistantStream, eventSource: RuntimeEventSource) {
     eventSource.stream(async (eventStream$) => {
       let inFunctionCall = false;
+      let currentMessageId: string;
+      let currentToolCallId: string;
 
       for await (const chunk of stream) {
         switch (chunk.event) {
           case "thread.message.created":
             if (inFunctionCall) {
-              eventStream$.sendActionExecutionEnd();
+              eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
             }
-            eventStream$.sendTextMessageStart(chunk.data.id);
+            currentMessageId = chunk.data.id;
+            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
             break;
           case "thread.message.delta":
             if (chunk.data.delta.content?.[0].type === "text") {
-              eventStream$.sendTextMessageContent(chunk.data.delta.content?.[0].text.value);
+              eventStream$.sendTextMessageContent({
+                messageId: currentMessageId,
+                content: chunk.data.delta.content?.[0].text.value,
+              });
             }
             break;
           case "thread.message.completed":
-            eventStream$.sendTextMessageEnd();
+            eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
             break;
           case "thread.run.step.delta":
             let toolCallId: string | undefined;
@@ -260,18 +266,25 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
 
             if (toolCallName && toolCallId) {
               if (inFunctionCall) {
-                eventStream$.sendActionExecutionEnd();
+                eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
               }
               inFunctionCall = true;
-              eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
+              currentToolCallId = toolCallId;
+              eventStream$.sendActionExecutionStart({
+                actionExecutionId: currentToolCallId,
+                actionName: toolCallName,
+              });
             } else if (toolCallArgs) {
-              eventStream$.sendActionExecutionArgs(toolCallArgs);
+              eventStream$.sendActionExecutionArgs({
+                actionExecutionId: currentToolCallId,
+                args: toolCallArgs,
+              });
             }
             break;
         }
       }
       if (inFunctionCall) {
-        eventStream$.sendActionExecutionEnd();
+        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
       }
       eventStream$.complete();
     });