@copilotkit/runtime 1.4.0-pre-1-4-0-alpha.10 → 1.4.0-pre-1-4-0.14

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

@@ -108,9 +108,6 @@ 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;
@@ -120,47 +117,36 @@ 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({ messageId: currentMessageId });
+          eventStream$.sendTextMessageEnd();
         } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
           mode = null;
-          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+          eventStream$.sendActionExecutionEnd();
         }
 
         // If we send a new message type, send the appropriate start event.
         if (mode === null) {
           if (toolCall?.id) {
             mode = "function";
-            currentToolCallId = toolCall!.id;
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: currentToolCallId,
-              actionName: toolCall!.function!.name,
-            });
+            eventStream$.sendActionExecutionStart(toolCall!.id, toolCall!.function!.name);
           } else if (content) {
             mode = "message";
-            currentMessageId = chunk.id;
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+            eventStream$.sendTextMessageStart(chunk.id);
           }
         }
 
         // send the content events
         if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content,
-          });
+          eventStream$.sendTextMessageContent(content);
         } else if (mode === "function" && toolCall?.function?.arguments) {
-          eventStream$.sendActionExecutionArgs({
-            actionExecutionId: currentToolCallId,
-            args: toolCall.function.arguments,
-          });
+          eventStream$.sendActionExecutionArgs(toolCall.function.arguments);
         }
       }
 
       // send the end events
       if (mode === "message") {
-        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+        eventStream$.sendTextMessageEnd();
       } else if (mode === "function") {
-        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+        eventStream$.sendActionExecutionEnd();
       }
 
       eventStream$.complete();

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({
-      actionExecutionId: actionExecution.id,
-      actionName: actionExecution.name,
-      result: "Sending a message",
-    });
+    eventStream$.sendActionExecutionResult(
+      actionExecution.id,
+      actionExecution.name,
+      "Sending a message",
+    );
   }
 }
 
@@ -152,11 +152,7 @@ export async function streamLangChainResponse({
       eventStream$.sendTextMessage(randomId(), result);
     } else {
       // Send as a result
-      eventStream$.sendActionExecutionResult({
-        actionExecutionId: actionExecution.id,
-        actionName: actionExecution.name,
-        result: result,
-      });
+      eventStream$.sendActionExecutionResult(actionExecution.id, actionExecution.name, result);
     }
   }
 
@@ -169,11 +165,11 @@ export async function streamLangChainResponse({
       eventStream$.sendTextMessage(randomId(), result.content as string);
     }
     for (const toolCall of result.tool_calls) {
-      eventStream$.sendActionExecution({
-        actionExecutionId: toolCall.id || randomId(),
-        actionName: toolCall.name,
-        args: JSON.stringify(toolCall.args),
-      });
+      eventStream$.sendActionExecution(
+        toolCall.id || randomId(),
+        toolCall.name,
+        JSON.stringify(toolCall.args),
+      );
     }
   }
 
@@ -187,11 +183,11 @@ export async function streamLangChainResponse({
     }
     if (result.lc_kwargs?.tool_calls) {
       for (const toolCall of result.lc_kwargs?.tool_calls) {
-        eventStream$.sendActionExecution({
-          actionExecutionId: toolCall.id || randomId(),
-          actionName: toolCall.name,
-          args: JSON.stringify(toolCall.args),
-        });
+        eventStream$.sendActionExecution(
+          toolCall.id || randomId(),
+          toolCall.name,
+          JSON.stringify(toolCall.args),
+        );
       }
     }
   }
@@ -218,7 +214,6 @@ 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;
@@ -253,10 +248,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({ messageId: currentMessageId });
+          eventStream$.sendTextMessageEnd();
         } else if (mode === "function" && (!hasToolCall || done)) {
           mode = null;
-          eventStream$.sendActionExecutionEnd({ actionExecutionId: toolCallId });
+          eventStream$.sendActionExecutionEnd();
         }
 
         if (done) {
@@ -267,37 +262,26 @@ export async function streamLangChainResponse({
         if (mode === null) {
           if (hasToolCall && toolCallId && toolCallName) {
             mode = "function";
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: toolCallId,
-              actionName: toolCallName,
-            });
+            eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
           } else if (content) {
             mode = "message";
-            currentMessageId = randomId();
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+            eventStream$.sendTextMessageStart(randomId());
           }
         }
 
         // send the content events
         if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content: Array.isArray(content) ? (content[0]?.text ?? "") : content,
-          });
+          eventStream$.sendTextMessageContent(
+            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({ actionExecutionId: toolCallId });
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: toolCallId,
-              actionName: toolCallName,
-            });
+            eventStream$.sendActionExecutionEnd();
+            eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
             toolCallDetails.prevIndex = toolCallDetails.index;
           }
-          eventStream$.sendActionExecutionArgs({
-            actionExecutionId: toolCallId,
-            args: toolCallArgs,
-          });
+          eventStream$.sendActionExecutionArgs(toolCallArgs);
         }
       } catch (error) {
         console.error("Error reading from stream", error);
@@ -305,11 +289,11 @@ export async function streamLangChainResponse({
       }
     }
   } else if (actionExecution) {
-    eventStream$.sendActionExecutionResult({
-      actionExecutionId: actionExecution.id,
-      actionName: actionExecution.name,
-      result: encodeResult(result),
-    });
+    eventStream$.sendActionExecutionResult(
+      actionExecution.id,
+      actionExecution.name,
+      encodeResult(result),
+    );
   }
 
   // unsupported type

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

@@ -144,8 +144,7 @@ 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;
@@ -159,47 +158,36 @@ 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({ messageId: currentMessageId });
+          eventStream$.sendTextMessageEnd();
         } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
           mode = null;
-          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+          eventStream$.sendActionExecutionEnd();
         }
 
         // If we send a new message type, send the appropriate start event.
         if (mode === null) {
           if (toolCall?.id) {
             mode = "function";
-            currentToolCallId = toolCall!.id;
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: currentToolCallId,
-              actionName: toolCall!.function!.name,
-            });
+            eventStream$.sendActionExecutionStart(toolCall!.id, toolCall!.function!.name);
           } else if (content) {
             mode = "message";
-            currentMessageId = chunk.id;
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+            eventStream$.sendTextMessageStart(chunk.id);
           }
         }
 
         // send the content events
         if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content: content,
-          });
+          eventStream$.sendTextMessageContent(content);
         } else if (mode === "function" && toolCall?.function?.arguments) {
-          eventStream$.sendActionExecutionArgs({
-            actionExecutionId: currentToolCallId,
-            args: toolCall.function.arguments,
-          });
+          eventStream$.sendActionExecutionArgs(toolCall.function.arguments);
         }
       }
 
       // send the end events
       if (mode === "message") {
-        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+        eventStream$.sendTextMessageEnd();
       } else if (mode === "function") {
-        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+        eventStream$.sendActionExecutionEnd();
       }
 
       eventStream$.complete();

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

@@ -228,28 +228,22 @@ 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({ actionExecutionId: currentToolCallId });
+              eventStream$.sendActionExecutionEnd();
             }
-            currentMessageId = chunk.data.id;
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+            eventStream$.sendTextMessageStart(chunk.data.id);
             break;
           case "thread.message.delta":
             if (chunk.data.delta.content?.[0].type === "text") {
-              eventStream$.sendTextMessageContent({
-                messageId: currentMessageId,
-                content: chunk.data.delta.content?.[0].text.value,
-              });
+              eventStream$.sendTextMessageContent(chunk.data.delta.content?.[0].text.value);
             }
             break;
           case "thread.message.completed":
-            eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+            eventStream$.sendTextMessageEnd();
             break;
           case "thread.run.step.delta":
             let toolCallId: string | undefined;
@@ -266,25 +260,18 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
 
             if (toolCallName && toolCallId) {
               if (inFunctionCall) {
-                eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+                eventStream$.sendActionExecutionEnd();
               }
               inFunctionCall = true;
-              currentToolCallId = toolCallId;
-              eventStream$.sendActionExecutionStart({
-                actionExecutionId: currentToolCallId,
-                actionName: toolCallName,
-              });
+              eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
             } else if (toolCallArgs) {
-              eventStream$.sendActionExecutionArgs({
-                actionExecutionId: currentToolCallId,
-                args: toolCallArgs,
-              });
+              eventStream$.sendActionExecutionArgs(toolCallArgs);
             }
             break;
         }
       }
       if (inFunctionCall) {
-        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+        eventStream$.sendActionExecutionEnd();
       }
       eventStream$.complete();
     });

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

@@ -66,20 +66,14 @@ export class UnifyAdapter implements CopilotServiceAdapter {
     });
 
     let model = null;
-    let currentMessageId: string;
-    let currentToolCallId: string;
     request.eventSource.stream(async (eventStream$) => {
       let mode: "function" | "message" | null = null;
       for await (const chunk of stream) {
         if (this.start) {
           model = chunk.model;
-          currentMessageId = randomId();
-          eventStream$.sendTextMessageStart({ messageId: currentMessageId });
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content: `Model used: ${model}\n`,
-          });
-          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+          eventStream$.sendTextMessageStart(randomId());
+          eventStream$.sendTextMessageContent(`Model used: ${model}\n`);
+          eventStream$.sendTextMessageEnd();
           this.start = false;
         }
         const toolCall = chunk.choices[0].delta.tool_calls?.[0];
@@ -90,47 +84,36 @@ export class UnifyAdapter implements CopilotServiceAdapter {
         // If toolCall?.id is defined, it means a new tool call starts.
         if (mode === "message" && toolCall?.id) {
           mode = null;
-          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+          eventStream$.sendTextMessageEnd();
         } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
           mode = null;
-          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+          eventStream$.sendActionExecutionEnd();
         }
 
         // If we send a new message type, send the appropriate start event.
         if (mode === null) {
           if (toolCall?.id) {
             mode = "function";
-            currentToolCallId = toolCall!.id;
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: currentToolCallId,
-              actionName: toolCall!.function!.name,
-            });
+            eventStream$.sendActionExecutionStart(toolCall!.id, toolCall!.function!.name);
           } else if (content) {
             mode = "message";
-            currentMessageId = chunk.id;
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+            eventStream$.sendTextMessageStart(chunk.id);
           }
         }
 
         // send the content events
         if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content: content,
-          });
+          eventStream$.sendTextMessageContent(content);
         } else if (mode === "function" && toolCall?.function?.arguments) {
-          eventStream$.sendActionExecutionArgs({
-            actionExecutionId: currentToolCallId,
-            args: toolCall.function.arguments,
-          });
+          eventStream$.sendActionExecutionArgs(toolCall.function.arguments);
         }
       }
 
       // send the end events
       if (mode === "message") {
-        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+        eventStream$.sendTextMessageEnd();
       } else if (mode === "function") {
-        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+        eventStream$.sendActionExecutionEnd();
       }
 
       eventStream$.complete();