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

package/src/service-adapters/events.ts

@@ -15,8 +15,6 @@ import { GuardrailsResult } from "../graphql/types/guardrails-result.type";
 import telemetry from "../lib/telemetry-client";
 import { isLangGraphAgentAction } from "../lib/runtime/remote-actions";
 import { ActionInput } from "../graphql/inputs/action.input";
-import { ActionExecutionMessage, ResultMessage } from "../graphql/types/converted";
-import { plainToInstance } from "class-transformer";
 
 export enum RuntimeEventTypes {
   TextMessageStart = "TextMessageStart",
@@ -29,22 +27,23 @@ export enum RuntimeEventTypes {
   AgentStateMessage = "AgentStateMessage",
 }
 
+type FunctionCallScope = "client" | "server" | "passThrough";
+
 export type RuntimeEvent =
-  | { type: RuntimeEventTypes.TextMessageStart; messageId: string; parentMessageId?: string }
+  | { type: RuntimeEventTypes.TextMessageStart; messageId: string }
   | {
       type: RuntimeEventTypes.TextMessageContent;
-      messageId: string;
       content: string;
     }
-  | { type: RuntimeEventTypes.TextMessageEnd; messageId: string }
+  | { type: RuntimeEventTypes.TextMessageEnd }
   | {
       type: RuntimeEventTypes.ActionExecutionStart;
       actionExecutionId: string;
       actionName: string;
-      parentMessageId?: string;
+      scope?: FunctionCallScope;
     }
-  | { type: RuntimeEventTypes.ActionExecutionArgs; actionExecutionId: string; args: string }
-  | { type: RuntimeEventTypes.ActionExecutionEnd; actionExecutionId: string }
+  | { type: RuntimeEventTypes.ActionExecutionArgs; args: string }
+  | { type: RuntimeEventTypes.ActionExecutionEnd }
   | {
       type: RuntimeEventTypes.ActionExecutionResult;
       actionName: string;
@@ -78,86 +77,47 @@ export class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
     super();
   }
 
-  sendTextMessageStart({
-    messageId,
-    parentMessageId,
-  }: {
-    messageId: string;
-    parentMessageId?: string;
-  }) {
-    this.next({ type: RuntimeEventTypes.TextMessageStart, messageId, parentMessageId });
+  sendTextMessageStart(messageId: string) {
+    this.next({ type: RuntimeEventTypes.TextMessageStart, messageId });
   }
 
-  sendTextMessageContent({ messageId, content }: { messageId: string; content: string }) {
-    this.next({ type: RuntimeEventTypes.TextMessageContent, content, messageId });
+  sendTextMessageContent(content: string) {
+    this.next({ type: RuntimeEventTypes.TextMessageContent, content });
   }
 
-  sendTextMessageEnd({ messageId }: { messageId: string }) {
-    this.next({ type: RuntimeEventTypes.TextMessageEnd, messageId });
+  sendTextMessageEnd() {
+    this.next({ type: RuntimeEventTypes.TextMessageEnd });
   }
 
   sendTextMessage(messageId: string, content: string) {
-    this.sendTextMessageStart({ messageId });
-    this.sendTextMessageContent({ messageId, content });
-    this.sendTextMessageEnd({ messageId });
+    this.sendTextMessageStart(messageId);
+    this.sendTextMessageContent(content);
+    this.sendTextMessageEnd();
   }
 
-  sendActionExecutionStart({
-    actionExecutionId,
-    actionName,
-    parentMessageId,
-  }: {
-    actionExecutionId: string;
-    actionName: string;
-    parentMessageId?: string;
-  }) {
+  sendActionExecutionStart(actionExecutionId: string, actionName: string) {
     this.next({
       type: RuntimeEventTypes.ActionExecutionStart,
       actionExecutionId,
       actionName,
-      parentMessageId,
     });
   }
 
-  sendActionExecutionArgs({
-    actionExecutionId,
-    args,
-  }: {
-    actionExecutionId: string;
-    args: string;
-  }) {
-    this.next({ type: RuntimeEventTypes.ActionExecutionArgs, args, actionExecutionId });
+  sendActionExecutionArgs(args: string) {
+    this.next({ type: RuntimeEventTypes.ActionExecutionArgs, args });
   }
 
-  sendActionExecutionEnd({ actionExecutionId }: { actionExecutionId: string }) {
-    this.next({ type: RuntimeEventTypes.ActionExecutionEnd, actionExecutionId });
+  sendActionExecutionEnd() {
+    this.next({ type: RuntimeEventTypes.ActionExecutionEnd });
   }
 
-  sendActionExecution({
-    actionExecutionId,
-    actionName,
-    args,
-    parentMessageId,
-  }: {
-    actionExecutionId: string;
-    actionName: string;
-    args: string;
-    parentMessageId?: string;
-  }) {
-    this.sendActionExecutionStart({ actionExecutionId, actionName, parentMessageId });
-    this.sendActionExecutionArgs({ actionExecutionId, args });
-    this.sendActionExecutionEnd({ actionExecutionId });
+  sendActionExecution(actionExecutionId: string, toolName: string, args: string) {
+    this.sendActionExecutionStart(actionExecutionId, toolName);
+    this.sendActionExecutionArgs(args);
+    this.sendActionExecutionEnd();
   }
 
-  sendActionExecutionResult({
-    actionExecutionId,
-    actionName,
-    result,
-  }: {
-    actionExecutionId: string;
-    actionName: string;
-    result: string;
-  }) {
+  sendActionExecutionResult(actionExecutionId: string, actionName: string, result: string) {
     this.next({
       type: RuntimeEventTypes.ActionExecutionResult,
       actionName,
@@ -166,25 +126,16 @@ export class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
     });
   }
 
-  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;
-  }) {
+  sendAgentStateMessage(
+    threadId: string,
+    agentName: string,
+    nodeName: string,
+    runId: string,
+    active: boolean,
+    role: string,
+    state: string,
+    running: boolean,
+  ) {
     this.next({
       type: RuntimeEventTypes.AgentStateMessage,
       threadId,
@@ -232,6 +183,17 @@ export class RuntimeEventSource {
       this.sendErrorMessageToChat();
     });
     return this.eventStream$.pipe(
+      // mark tools for server side execution
+      map((event) => {
+        if (event.type === RuntimeEventTypes.ActionExecutionStart) {
+          if (event.scope !== "passThrough") {
+            event.scope = serverSideActions.find((action) => action.name === event.actionName)
+              ? "server"
+              : "client";
+          }
+        }
+        return event;
+      }),
       // track state
       scan(
         (acc, event) => {
@@ -241,8 +203,7 @@ export class RuntimeEventSource {
           acc = { ...acc };
 
           if (event.type === RuntimeEventTypes.ActionExecutionStart) {
-            acc.callActionServerSide =
-              serverSideActions.find((action) => action.name === event.actionName) !== undefined;
+            acc.callActionServerSide = event.scope === "server";
             acc.args = "";
             acc.actionExecutionId = event.actionExecutionId;
             if (acc.callActionServerSide) {
@@ -320,34 +281,14 @@ async function executeAction(
 
   // handle LangGraph agents
   if (isLangGraphAgentAction(action)) {
-    const result = `${action.name} agent started`;
-
-    const agentExecution = plainToInstance(ActionExecutionMessage, {
-      id: actionExecutionId,
-      createdAt: new Date(),
-      name: action.name,
-      arguments: JSON.parse(actionArguments),
-      parentMessageId: actionExecutionId,
-    });
-
-    const agentExecutionResult = plainToInstance(ResultMessage, {
-      id: "result-" + actionExecutionId,
-      createdAt: new Date(),
-      actionExecutionId,
-      actionName: action.name,
-      result,
-    });
-
-    eventStream$.sendActionExecutionResult({
+    eventStream$.sendActionExecutionResult(
       actionExecutionId,
-      actionName: action.name,
-      result,
-    });
-
+      action.name,
+      `${action.name} agent started`,
+    );
     const stream = await action.langGraphAgentHandler({
       name: action.name,
       actionInputsWithoutAgents,
-      additionalMessages: [agentExecution, agentExecutionResult],
     });
 
     // forward to eventStream$

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

@@ -0,0 +1,33 @@
+/**
+ * CopilotKit Empty Adapter
+ *
+ * This adapter is meant to preserve adherence to runtime requirements, while doing nothing
+ * Ideal if you don't want to connect an LLM the to the runtime, and only use your LangGraph agent.
+ * Be aware that Copilot Suggestions will not work if you use this adapter
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { CopilotRuntime, ExperimentalEmptyAdapter } from "@copilotkit/runtime";
+ *
+ * const copilotKit = new CopilotRuntime();
+ *
+ * return new ExperimentalEmptyAdapter();
+ * ```
+ */
+import {
+  CopilotServiceAdapter,
+  CopilotRuntimeChatCompletionRequest,
+  CopilotRuntimeChatCompletionResponse,
+} from "../../service-adapter";
+import { randomId } from "@copilotkit/shared";
+
+export class ExperimentalEmptyAdapter implements CopilotServiceAdapter {
+  async process(
+    request: CopilotRuntimeChatCompletionRequest,
+  ): Promise<CopilotRuntimeChatCompletionResponse> {
+    return {
+      threadId: request.threadId || randomId(),
+    };
+  }
+}

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

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

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

@@ -106,9 +106,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;
@@ -118,48 +115,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,
-              parentMessageId: chunk.id,
-            });
+            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/index.ts

@@ -1,4 +1,8 @@
-export type { CopilotServiceAdapter } from "./service-adapter";
+export type {
+  CopilotRuntimeChatCompletionRequest,
+  CopilotRuntimeChatCompletionResponse,
+  CopilotServiceAdapter,
+} from "./service-adapter";
 export type { RemoteChainParameters } from "./langchain/langserve";
 export { RemoteChain } from "./langchain/langserve";
 export * from "./openai/openai-adapter";
@@ -8,3 +12,5 @@ export * from "./openai/openai-assistant-adapter";
 export * from "./unify/unify-adapter";
 export * from "./groq/groq-adapter";
 export * from "./anthropic/anthropic-adapter";
+export * from "./experimental/ollama/ollama-adapter";
+export * from "./experimental/empty/empty-adapter";

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

@@ -97,11 +97,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",
+    );
   }
 }
 
@@ -120,11 +120,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);
     }
   }
 
@@ -137,11 +133,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),
+      );
     }
   }
 
@@ -155,11 +151,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),
+        );
       }
     }
   }
@@ -172,7 +168,6 @@ export async function streamLangChainResponse({
     let reader = result.getReader();
 
     let mode: "function" | "message" | null = null;
-    let currentMessageId: string;
 
     const toolCallDetails = {
       name: null,
@@ -221,10 +216,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) {
@@ -235,39 +230,26 @@ export async function streamLangChainResponse({
         if (mode === null) {
           if (hasToolCall && toolCallId && toolCallName) {
             mode = "function";
-            eventStream$.sendActionExecutionStart({
-              actionExecutionId: toolCallId,
-              actionName: toolCallName,
-              parentMessageId: value.lc_kwargs?.id,
-            });
+            eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
           } else if (content) {
             mode = "message";
-            currentMessageId = value.lc_kwargs?.id || 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,
-              parentMessageId: value.lc_kwargs?.id,
-            });
+            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);
@@ -275,11 +257,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

@@ -140,8 +140,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;
@@ -155,48 +154,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,
-              parentMessageId: chunk.id,
-              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

@@ -226,28 +226,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;
@@ -264,26 +258,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,
-                parentMessageId: chunk.data.id,
-                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();
     });