@copilotkit/runtime 1.5.15-next.7 → 1.5.15-next.8

package/dist/lib/integrations/node-http/index.mjs

@@ -1,6 +1,6 @@
 import {
   copilotRuntimeNodeHttpEndpoint
-} from "../../../chunk-OMS5GY45.mjs";
+} from "../../../chunk-HG6ZQKQW.mjs";
 import "../../../chunk-S3KKBII4.mjs";
 import "../../../chunk-U3V2BCGI.mjs";
 import "../../../chunk-HNUNXFTW.mjs";

package/dist/service-adapters/index.d.ts

@@ -1,8 +1,8 @@
-import { b as CopilotServiceAdapter, C as CopilotRuntimeChatCompletionRequest, a as CopilotRuntimeChatCompletionResponse } from '../langserve-9580bd66.js';
-export { c as RemoteChain, R as RemoteChainParameters } from '../langserve-9580bd66.js';
-export { G as GoogleGenerativeAIAdapter, f as GroqAdapter, e as GroqAdapterParams, L as LangChainAdapter, a as OpenAIAdapter, O as OpenAIAdapterParams, c as OpenAIAssistantAdapter, b as OpenAIAssistantAdapterParams, d as UnifyAdapter, U as UnifyAdapterParams } from '../groq-adapter-248058e8.js';
+import { b as CopilotServiceAdapter, C as CopilotRuntimeChatCompletionRequest, a as CopilotRuntimeChatCompletionResponse } from '../langserve-3a591089.js';
+export { c as RemoteChain, R as RemoteChainParameters } from '../langserve-3a591089.js';
+export { G as GoogleGenerativeAIAdapter, f as GroqAdapter, e as GroqAdapterParams, L as LangChainAdapter, a as OpenAIAdapter, O as OpenAIAdapterParams, c as OpenAIAssistantAdapter, b as OpenAIAssistantAdapterParams, d as UnifyAdapter, U as UnifyAdapterParams } from '../groq-adapter-3b894689.js';
 import Anthropic from '@anthropic-ai/sdk';
-import '../index-a7f37670.js';
+import '../index-f6d1f30b.js';
 import '../graphql/types/base/index.js';
 import 'rxjs';
 import '@copilotkit/shared';

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.15-next.7",
+  "version": "1.5.15-next.8",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -58,7 +58,7 @@
     "rxjs": "^7.8.1",
     "type-graphql": "2.0.0-rc.1",
     "zod": "^3.23.3",
-    "@copilotkit/shared": "1.5.15-next.7"
+    "@copilotkit/shared": "1.5.15-next.8"
   },
   "keywords": [
     "copilotkit",

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

@@ -136,6 +136,13 @@ export class RemoteLangGraphEventSource {
             value: acc.event.value,
           });
         }
+        if (acc.event.event === LangGraphEventTypes.OnCopilotKitInterrupt) {
+          events.push({
+            type: RuntimeEventTypes.MetaEvent,
+            name: RuntimeMetaEventName.CopilotKitLangGraphInterruptEvent,
+            data: acc.event.data,
+          });
+        }
 
         const responseMetadata = this.getResponseMetadata(acc.event);
 

package/src/agents/langgraph/events.ts

@@ -1,3 +1,5 @@
+import { ActionExecutionMessage, ResultMessage, TextMessage } from "../../graphql/types/converted";
+
 export enum LangGraphEventTypes {
   OnChainStart = "on_chain_start",
   OnChainStream = "on_chain_stream",
@@ -12,10 +14,12 @@ export enum LangGraphEventTypes {
   OnCopilotKitEmitToolCall = "on_copilotkit_emit_tool_call",
   OnCustomEvent = "on_custom_event",
   OnInterrupt = "on_interrupt",
+  OnCopilotKitInterrupt = "on_copilotkit_interrupt",
 }
 
 export enum MetaEventNames {
   LangGraphInterruptEvent = "LangGraphInterruptEvent",
+  CopilotKitLangGraphInterruptEvent = "CopilotKitLangGraphInterruptEvent",
 }
 
 export enum CustomEventNames {
@@ -335,6 +339,11 @@ interface LangGraphInterruptEvent {
   value: string;
 }
 
+interface CopilotKitLangGraphInterruptEvent {
+  event: LangGraphEventTypes.OnCopilotKitInterrupt;
+  data: { value: string; messages: (TextMessage | ActionExecutionMessage | ResultMessage)[] };
+}
+
 export type LangGraphEvent =
   | LangGraphOnChainStartEvent
   | LangGraphOnChainStreamEvent
@@ -346,4 +355,5 @@ export type LangGraphEvent =
   | LangGraphOnToolEndEvent
   | LangGraphOnCopilotKitStateSyncEvent
   | LangGraphOnCustomEvent
-  | LangGraphInterruptEvent;
+  | LangGraphInterruptEvent
+  | CopilotKitLangGraphInterruptEvent;

package/src/graphql/inputs/meta-event.input.ts

@@ -1,11 +1,9 @@
 import { Field, InputType } from "type-graphql";
 import { MetaEventName } from "../types/meta-events.type";
+import { MessageInput } from "./message.input";
 
 @InputType()
 export class MetaEventInput {
-  @Field(() => String)
-  type: "MetaEvent" = "MetaEvent";
-
   @Field(() => MetaEventName)
   name: MetaEventName;
 
@@ -14,4 +12,7 @@ export class MetaEventInput {
 
   @Field(() => String, { nullable: true })
   response?: string;
+
+  @Field(() => [MessageInput], { nullable: true })
+  messages?: MessageInput[];
 }

package/src/graphql/resolvers/copilot.resolver.ts

@@ -14,7 +14,10 @@ import {
 } from "rxjs";
 import { GenerateCopilotResponseInput } from "../inputs/generate-copilot-response.input";
 import { CopilotResponse } from "../types/copilot-response.type";
-import { LangGraphInterruptEvent } from "../types/meta-events.type";
+import {
+  CopilotKitLangGraphInterruptEvent,
+  LangGraphInterruptEvent,
+} from "../types/meta-events.type";
 import { ActionInputAvailability, MessageRole } from "../types/enums";
 import { Repeater } from "graphql-yoga";
 import type { CopilotRequestContextProperties, GraphQLContext } from "../../lib/integrations";
@@ -25,6 +28,7 @@ import {
 } from "../../service-adapters/events";
 import {
   FailedMessageStatus,
+  MessageStatusCode,
   MessageStatusUnion,
   SuccessMessageStatus,
 } from "../types/message-status.type";
@@ -42,6 +46,7 @@ import {
   ActionExecutionMessage,
   AgentStateMessage,
   Message,
+  MessageType,
   ResultMessage,
   TextMessage,
 } from "../types/converted";
@@ -263,6 +268,44 @@ export class CopilotResolver {
                   }),
                 );
                 break;
+              case RuntimeMetaEventName.CopilotKitLangGraphInterruptEvent:
+                push(
+                  plainToInstance(CopilotKitLangGraphInterruptEvent, {
+                    type: event.type,
+                    name: event.name,
+                    data: {
+                      value:
+                        typeof event.data.value === "string"
+                          ? event.data.value
+                          : JSON.stringify(event.data.value),
+                      messages: event.data.messages.map((message) => {
+                        if (
+                          message.type === "TextMessage" ||
+                          ("content" in message && "role" in message)
+                        ) {
+                          return plainToInstance(TextMessage, {
+                            id: message.id,
+                            createdAt: new Date(),
+                            content: [(message as TextMessage).content],
+                            role: (message as TextMessage).role,
+                            status: new SuccessMessageStatus(),
+                          });
+                        }
+                        if ("arguments" in message) {
+                          return plainToInstance(ActionExecutionMessage, {
+                            name: message.name,
+                            id: message.id,
+                            arguments: [JSON.stringify(message.arguments)],
+                            createdAt: new Date(),
+                            status: new SuccessMessageStatus(),
+                          });
+                        }
+                        throw new Error("Unknown message in metaEvents copilot resolver");
+                      }),
+                    },
+                  }),
+                );
+                break;
             }
           },
           error: (err) => {

package/src/graphql/types/copilot-response.type.ts

@@ -3,7 +3,7 @@ import { MessageRole } from "./enums";
 import { MessageStatusUnion } from "./message-status.type";
 import { ResponseStatusUnion } from "./response-status.type";
 import { ExtensionsResponse } from "./extensions-response.type";
-import { BaseMetaEvent, LangGraphInterruptEvent, MetaEventName } from "./meta-events.type";
+import { BaseMetaEvent } from "./meta-events.type";
 
 @InterfaceType({
   resolveType(value) {
@@ -15,8 +15,6 @@ import { BaseMetaEvent, LangGraphInterruptEvent, MetaEventName } from "./meta-ev
       return ResultMessageOutput;
     } else if (value.hasOwnProperty("state")) {
       return AgentStateMessageOutput;
-    } else if (value.name === MetaEventName.LangGraphInterruptEvent) {
-      return LangGraphInterruptEvent;
     }
     return undefined;
   },

package/src/graphql/types/meta-events.type.ts

@@ -1,7 +1,15 @@
-import { Field, InterfaceType, ObjectType, registerEnumType } from "type-graphql";
+import { createUnionType, Field, InterfaceType, ObjectType, registerEnumType } from "type-graphql";
+import {
+  ActionExecutionMessageOutput,
+  AgentStateMessageOutput,
+  BaseMessageOutput,
+  ResultMessageOutput,
+  TextMessageOutput,
+} from "./copilot-response.type";
 
 export enum MetaEventName {
   LangGraphInterruptEvent = "LangGraphInterruptEvent",
+  CopilotKitLangGraphInterruptEvent = "CopilotKitLangGraphInterruptEvent",
 }
 
 registerEnumType(MetaEventName, {
@@ -9,6 +17,16 @@ registerEnumType(MetaEventName, {
   description: "Meta event types",
 });
 
+@InterfaceType({
+  resolveType(value) {
+    if (value.name === MetaEventName.LangGraphInterruptEvent) {
+      return LangGraphInterruptEvent;
+    } else if (value.name === MetaEventName.CopilotKitLangGraphInterruptEvent) {
+      return CopilotKitLangGraphInterruptEvent;
+    }
+    return undefined;
+  },
+})
 @InterfaceType()
 export abstract class BaseMetaEvent {
   @Field(() => String)
@@ -18,6 +36,15 @@ export abstract class BaseMetaEvent {
   name: MetaEventName;
 }
 
+@ObjectType()
+export class CopilotKitLangGraphInterruptEventData {
+  @Field(() => String)
+  value: string;
+
+  @Field(() => [BaseMessageOutput])
+  messages: (typeof BaseMessageOutput)[];
+}
+
 @ObjectType({ implements: BaseMetaEvent })
 export class LangGraphInterruptEvent {
   @Field(() => MetaEventName)
@@ -29,3 +56,16 @@ export class LangGraphInterruptEvent {
   @Field(() => String, { nullable: true })
   response?: string;
 }
+
+@ObjectType({ implements: BaseMetaEvent })
+export class CopilotKitLangGraphInterruptEvent {
+  @Field(() => MetaEventName)
+  name: MetaEventName.CopilotKitLangGraphInterruptEvent =
+    MetaEventName.CopilotKitLangGraphInterruptEvent;
+
+  @Field(() => CopilotKitLangGraphInterruptEventData)
+  data: CopilotKitLangGraphInterruptEventData;
+
+  @Field(() => String, { nullable: true })
+  response?: string;
+}

package/src/lib/runtime/remote-lg-action.ts

@@ -66,6 +66,8 @@ type LangGraphPlatformMessage =
   | LangGraphPlatformResultMessage
   | BaseLangGraphPlatformMessage;
 
+let activeInterruptEvent = false;
+
 export async function execute(args: ExecutionArgs): Promise<ReadableStream<Uint8Array>> {
   return new ReadableStream({
     async start(controller) {
@@ -144,11 +146,25 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   }
   state = langGraphDefaultMergeState(state, formattedMessages, actions, name);
 
-  const lgInterruptEvent = metaEvents?.find(
+  const streamInput = mode === "start" ? state : null;
+
+  const payload: RunsStreamPayload = {
+    input: streamInput,
+    streamMode: ["events", "values", "updates"],
+    command: undefined,
+  };
+
+  const lgInterruptMetaEvent = metaEvents?.find(
     (ev) => ev.name === MetaEventName.LangGraphInterruptEvent,
   );
+  if (activeInterruptEvent && !lgInterruptMetaEvent) {
+    payload.command = { resume: formattedMessages[formattedMessages.length - 1] };
+  }
+  if (lgInterruptMetaEvent?.response) {
+    payload.command = { resume: lgInterruptMetaEvent.response };
+  }
 
-  if (mode === "continue" && !lgInterruptEvent) {
+  if (mode === "continue" && !activeInterruptEvent) {
     await client.threads.updateState(threadId, { values: state, asNode: nodeName });
   }
 
@@ -181,7 +197,6 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   const assistantId = retrievedAssistant.assistant_id;
 
   const graphInfo = await client.assistants.getGraph(assistantId);
-  const streamInput = mode === "start" ? state : null;
 
   let streamingStateExtractor = new StreamingStateExtractor([]);
   let prevNodeName = null;
@@ -189,15 +204,6 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   let shouldExit = false;
   let externalRunId = null;
 
-  const payload: RunsStreamPayload = {
-    input: streamInput,
-    streamMode: ["events", "values", "updates"],
-    command: undefined,
-  };
-
-  if (lgInterruptEvent?.response) {
-    payload.command = { resume: lgInterruptEvent.response };
-  }
   const streamResponse = client.runs.stream(threadId, assistantId, payload);
 
   const emit = (message: string) => controller.enqueue(new TextEncoder().encode(message));
@@ -208,6 +214,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   // Therefore, this value should either hold null, or the only edition of state that should be used.
   let manuallyEmittedState = null;
 
+  activeInterruptEvent = false;
   try {
     telemetry.capture("oss.runtime.agent_execution_stream_started", {
       hashedLgcKey: streamInfo.hashedLgcKey,
@@ -219,13 +226,31 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
         throw new Error(`Error event thrown: ${chunk.data.message}`);
       }
 
-      if (chunk.event === "updates" && chunk.data.__interrupt__) {
-        emit(
-          JSON.stringify({
-            event: LangGraphEventTypes.OnInterrupt,
-            value: chunk.data.__interrupt__[0].value,
-          }) + "\n",
-        );
+      const interruptEvents = chunk.data?.__interrupt__;
+      if (interruptEvents?.length) {
+        activeInterruptEvent = true;
+        const interruptValue = interruptEvents?.[0].value;
+        if (
+          typeof interruptValue != "string" &&
+          "__copilotkit_interrupt_value__" in interruptValue
+        ) {
+          emit(
+            JSON.stringify({
+              event: LangGraphEventTypes.OnCopilotKitInterrupt,
+              data: {
+                value: interruptValue.__copilotkit_interrupt_value__,
+                messages: langchainMessagesToCopilotKit(interruptValue.__copilotkit_messages__),
+              },
+            }) + "\n",
+          );
+        } else {
+          emit(
+            JSON.stringify({
+              event: LangGraphEventTypes.OnInterrupt,
+              value: interruptValue,
+            }) + "\n",
+          );
+        }
         continue;
       }
       if (chunk.event === "updates") continue;

package/src/service-adapters/events.ts

@@ -16,7 +16,7 @@ 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 { ActionExecutionMessage, ResultMessage, TextMessage } from "../graphql/types/converted";
 import { plainToInstance } from "class-transformer";
 
 export enum RuntimeEventTypes {
@@ -34,6 +34,7 @@ export enum RuntimeEventTypes {
 export enum RuntimeMetaEventName {
   LangGraphInterruptEvent = "LangGraphInterruptEvent",
   LangGraphInterruptResumeEvent = "LangGraphInterruptResumeEvent",
+  CopilotKitLangGraphInterruptEvent = "CopilotKitLangGraphInterruptEvent",
 }
 
 export type RunTimeMetaEvent =
@@ -42,10 +43,15 @@ export type RunTimeMetaEvent =
       name: RuntimeMetaEventName.LangGraphInterruptEvent;
       value: string;
     }
+  | {
+      type: RuntimeEventTypes.MetaEvent;
+      name: RuntimeMetaEventName.CopilotKitLangGraphInterruptEvent;
+      data: { value: string; messages: (TextMessage | ActionExecutionMessage | ResultMessage)[] };
+    }
   | {
       type: RuntimeEventTypes.MetaEvent;
       name: RuntimeMetaEventName.LangGraphInterruptResumeEvent;
-      value: string;
+      data: string;
     };
 
 export type RuntimeEvent =