@copilotkit/runtime 1.5.15-next.2 → 1.5.15-next.4

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

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

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

@@ -1,6 +1,6 @@
-import { b as CopilotServiceAdapter, C as CopilotRuntimeChatCompletionRequest, a as CopilotRuntimeChatCompletionResponse } from '../langserve-9614171f.js';
-export { c as RemoteChain, R as RemoteChainParameters } from '../langserve-9614171f.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-acb6ed0b.js';
+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 Anthropic from '@anthropic-ai/sdk';
 import '../index-a7f37670.js';
 import '../graphql/types/base/index.js';

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.15-next.2",
+  "version": "1.5.15-next.4",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -41,7 +41,7 @@
     "@langchain/community": "^0.0.53",
     "@langchain/core": "^0.3.13",
     "@langchain/google-gauth": "^0.1.0",
-    "@langchain/langgraph-sdk": "^0.0.16",
+    "@langchain/langgraph-sdk": "^0.0.36",
     "@langchain/openai": "^0.0.28",
     "class-transformer": "^0.5.1",
     "express": "^4.19.2",
@@ -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.2"
+    "@copilotkit/shared": "1.5.15-next.4"
   },
   "keywords": [
     "copilotkit",

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

@@ -1,6 +1,10 @@
-import { ReplaySubject, scan, mergeMap, catchError } from "rxjs";
+import { catchError, mergeMap, ReplaySubject, scan } from "rxjs";
 import { CustomEventNames, LangGraphEvent, LangGraphEventTypes } from "./events";
-import { RuntimeEvent, RuntimeEventTypes } from "../../service-adapters/events";
+import {
+  RuntimeEvent,
+  RuntimeEventTypes,
+  RuntimeMetaEventName,
+} from "../../service-adapters/events";
 import { randomId } from "@copilotkit/shared";
 
 interface LangGraphEventWithState {
@@ -125,6 +129,14 @@ export class RemoteLangGraphEventSource {
           }
         }
 
+        if (acc.event.event === LangGraphEventTypes.OnInterrupt) {
+          events.push({
+            type: RuntimeEventTypes.MetaEvent,
+            name: RuntimeMetaEventName.LangGraphInterruptEvent,
+            value: acc.event.value,
+          });
+        }
+
         const responseMetadata = this.getResponseMetadata(acc.event);
 
         // Tool call ended: emit ActionExecutionEnd

package/src/agents/langgraph/events.ts

@@ -11,6 +11,11 @@ export enum LangGraphEventTypes {
   OnCopilotKitEmitMessage = "on_copilotkit_emit_message",
   OnCopilotKitEmitToolCall = "on_copilotkit_emit_tool_call",
   OnCustomEvent = "on_custom_event",
+  OnInterrupt = "on_interrupt",
+}
+
+export enum MetaEventNames {
+  LangGraphInterruptEvent = "LangGraphInterruptEvent",
 }
 
 export enum CustomEventNames {
@@ -325,6 +330,11 @@ type LangGraphOnCustomEvent = {
   parent_ids: string[];
 };
 
+interface LangGraphInterruptEvent {
+  event: LangGraphEventTypes.OnInterrupt;
+  value: string;
+}
+
 export type LangGraphEvent =
   | LangGraphOnChainStartEvent
   | LangGraphOnChainStreamEvent
@@ -335,4 +345,5 @@ export type LangGraphEvent =
   | LangGraphOnToolStartEvent
   | LangGraphOnToolEndEvent
   | LangGraphOnCopilotKitStateSyncEvent
-  | LangGraphOnCustomEvent;
+  | LangGraphOnCustomEvent
+  | LangGraphInterruptEvent;

package/src/graphql/inputs/generate-copilot-response.input.ts

@@ -7,6 +7,7 @@ import { ForwardedParametersInput } from "./forwarded-parameters.input";
 import { AgentSessionInput } from "./agent-session.input";
 import { AgentStateInput } from "./agent-state.input";
 import { ExtensionsInput } from "./extensions.input";
+import { MetaEventInput } from "./meta-event.input";
 
 @InputType()
 export class GenerateCopilotResponseMetadataInput {
@@ -48,4 +49,7 @@ export class GenerateCopilotResponseInput {
 
   @Field(() => ExtensionsInput, { nullable: true })
   extensions?: ExtensionsInput;
+
+  @Field(() => [MetaEventInput], { nullable: true })
+  metaEvents?: MetaEventInput[];
 }

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

@@ -0,0 +1,17 @@
+import { Field, InputType } from "type-graphql";
+import { MetaEventName } from "../types/meta-events.type";
+
+@InputType()
+export class MetaEventInput {
+  @Field(() => String)
+  type: "MetaEvent" = "MetaEvent";
+
+  @Field(() => MetaEventName)
+  name: MetaEventName;
+
+  @Field(() => String)
+  value?: string;
+
+  @Field(() => String, { nullable: true })
+  response?: string;
+}

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

@@ -14,10 +14,15 @@ 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 { ActionInputAvailability, MessageRole } from "../types/enums";
 import { Repeater } from "graphql-yoga";
 import type { CopilotRequestContextProperties, GraphQLContext } from "../../lib/integrations";
-import { RuntimeEvent, RuntimeEventTypes } from "../../service-adapters/events";
+import {
+  RuntimeEvent,
+  RuntimeEventTypes,
+  RuntimeMetaEventName,
+} from "../../service-adapters/events";
 import {
   FailedMessageStatus,
   MessageStatusUnion,
@@ -210,15 +215,74 @@ export class CopilotResolver {
       agentStates: data.agentStates,
       url: data.frontend.url,
       extensions: data.extensions,
+      metaEvents: data.metaEvents,
     });
 
     logger.debug("Event source created, creating response");
+    // run and process the event stream
+    const eventStream = eventSource
+      .processRuntimeEvents({
+        serverSideActions,
+        guardrailsResult$: data.cloud?.guardrails ? guardrailsResult$ : null,
+        actionInputsWithoutAgents: actionInputsWithoutAgents.filter(
+          // TODO-AGENTS: do not exclude ALL server side actions
+          (action) =>
+            !serverSideActions.find((serverSideAction) => serverSideAction.name == action.name),
+        ),
+        threadId,
+      })
+      .pipe(
+        // shareReplay() ensures that later subscribers will see the whole stream instead of
+        // just the events that were emitted after the subscriber was added.
+        shareReplay(),
+        finalize(() => {
+          logger.debug("Event stream finalized");
+        }),
+      );
 
     const response = {
       threadId,
       runId,
       status: firstValueFrom(responseStatus$),
       extensions,
+      metaEvents: new Repeater(async (push, stop) => {
+        let eventStreamSubscription: Subscription;
+
+        eventStreamSubscription = eventStream.subscribe({
+          next: async (event) => {
+            if (event.type != RuntimeEventTypes.MetaEvent) {
+              return;
+            }
+            switch (event.name) {
+              case RuntimeMetaEventName.LangGraphInterruptEvent:
+                push(
+                  plainToInstance(LangGraphInterruptEvent, {
+                    type: event.type,
+                    name: event.name,
+                    value: event.value,
+                  }),
+                );
+                break;
+            }
+          },
+          error: (err) => {
+            logger.error({ err }, "Error in meta events stream");
+            responseStatus$.next(
+              new UnknownErrorResponse({
+                description: `An unknown error has occurred in the event stream`,
+              }),
+            );
+            eventStreamSubscription?.unsubscribe();
+            stop();
+          },
+          complete: async () => {
+            logger.debug("Meta events stream completed");
+            responseStatus$.next(new SuccessResponseStatus());
+            eventStreamSubscription?.unsubscribe();
+            stop();
+          },
+        });
+      }),
       messages: new Repeater(async (pushMessage, stopStreamingMessages) => {
         logger.debug("Messages repeater created");
 
@@ -275,32 +339,13 @@ export class CopilotResolver {
 
         let eventStreamSubscription: Subscription;
 
-        // run and process the event stream
-        const eventStream = eventSource
-          .processRuntimeEvents({
-            serverSideActions,
-            guardrailsResult$: data.cloud?.guardrails ? guardrailsResult$ : null,
-            actionInputsWithoutAgents: actionInputsWithoutAgents.filter(
-              // TODO-AGENTS: do not exclude ALL server side actions
-              (action) =>
-                !serverSideActions.find((serverSideAction) => serverSideAction.name == action.name),
-            ),
-            threadId,
-          })
-          .pipe(
-            // shareReplay() ensures that later subscribers will see the whole stream instead of
-            // just the events that were emitted after the subscriber was added.
-            shareReplay(),
-            finalize(() => {
-              logger.debug("Event stream finalized");
-            }),
-          );
-
         logger.debug("Event stream created, subscribing to event stream");
 
         eventStreamSubscription = eventStream.subscribe({
           next: async (event) => {
             switch (event.type) {
+              case RuntimeEventTypes.MetaEvent:
+                break;
               ////////////////////////////////
               // TextMessageStart
               ////////////////////////////////

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

@@ -3,6 +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";
 
 @InterfaceType({
   resolveType(value) {
@@ -14,6 +15,8 @@ import { ExtensionsResponse } from "./extensions-response.type";
       return ResultMessageOutput;
     } else if (value.hasOwnProperty("state")) {
       return AgentStateMessageOutput;
+    } else if (value.name === MetaEventName.LangGraphInterruptEvent) {
+      return LangGraphInterruptEvent;
     }
     return undefined;
   },
@@ -114,4 +117,7 @@ export class CopilotResponse {
 
   @Field(() => ExtensionsResponse, { nullable: true })
   extensions?: ExtensionsResponse;
+
+  @Field(() => [BaseMetaEvent], { nullable: true })
+  metaEvents?: (typeof BaseMetaEvent)[];
 }

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

@@ -0,0 +1,31 @@
+import { Field, InterfaceType, ObjectType, registerEnumType } from "type-graphql";
+
+export enum MetaEventName {
+  LangGraphInterruptEvent = "LangGraphInterruptEvent",
+}
+
+registerEnumType(MetaEventName, {
+  name: "MetaEventName",
+  description: "Meta event types",
+});
+
+@InterfaceType()
+export abstract class BaseMetaEvent {
+  @Field(() => String)
+  type: "MetaEvent" = "MetaEvent";
+
+  @Field(() => MetaEventName)
+  name: MetaEventName;
+}
+
+@ObjectType({ implements: BaseMetaEvent })
+export class LangGraphInterruptEvent {
+  @Field(() => MetaEventName)
+  name: MetaEventName.LangGraphInterruptEvent = MetaEventName.LangGraphInterruptEvent;
+
+  @Field(() => String)
+  value: string;
+
+  @Field(() => String, { nullable: true })
+  response?: string;
+}

package/src/lib/runtime/copilot-runtime.ts

@@ -60,6 +60,7 @@ import { ExtensionsResponse } from "../../graphql/types/extensions-response.type
 import { LoadAgentStateResponse } from "../../graphql/types/load-agent-state-response.type";
 import { Client as LangGraphClient } from "@langchain/langgraph-sdk";
 import { langchainMessagesToCopilotKit } from "./remote-lg-action";
+import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
 
 interface CopilotRuntimeRequest {
   serviceAdapter: CopilotServiceAdapter;
@@ -75,6 +76,7 @@ interface CopilotRuntimeRequest {
   forwardedParameters?: ForwardedParametersInput;
   url?: string;
   extensions?: ExtensionsInput;
+  metaEvents?: MetaEventInput[];
 }
 
 interface CopilotRuntimeResponse {
@@ -319,9 +321,14 @@ please use an LLM adapter instead.`,
       async (acc: Promise<Agent[]>, endpoint) => {
         const agents = await acc;
         if (endpoint.type === EndpointType.LangGraphPlatform) {
+          const propertyHeaders = graphqlContext.properties.authorization
+            ? { authorization: `Bearer ${graphqlContext.properties.authorization}` }
+            : null;
+
           const client = new LangGraphClient({
             apiUrl: endpoint.deploymentUrl,
             apiKey: endpoint.langsmithApiKey,
+            defaultHeaders: { ...propertyHeaders },
           });
 
           const data: Array<{ assistant_id: string; graph_id: string }> =
@@ -392,9 +399,14 @@ please use an LLM adapter instead.`,
     const headers = createHeaders(null, graphqlContext);
 
     if (agentWithEndpoint.endpoint.type === EndpointType.LangGraphPlatform) {
+      const propertyHeaders = graphqlContext.properties.authorization
+        ? { authorization: `Bearer ${graphqlContext.properties.authorization}` }
+        : null;
+
       const client = new LangGraphClient({
         apiUrl: agentWithEndpoint.endpoint.deploymentUrl,
         apiKey: agentWithEndpoint.endpoint.langsmithApiKey,
+        defaultHeaders: { ...propertyHeaders },
       });
       let state: any = {};
       try {
@@ -455,6 +467,7 @@ please use an LLM adapter instead.`,
       graphqlContext,
       agentSession,
       threadId: threadIdFromRequest,
+      metaEvents,
     } = request;
     const { agentName, nodeName } = agentSession;
 
@@ -499,6 +512,7 @@ please use an LLM adapter instead.`,
         threadId,
         nodeName,
         actionInputsWithoutAgents,
+        metaEvents,
       });
 
       eventSource.stream(async (eventStream$) => {

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

@@ -42,6 +42,7 @@ export function constructLGCRemoteAction({
       threadId,
       nodeName,
       additionalMessages = [],
+      metaEvents,
     }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
       logger.debug({ actionName: agent.name }, "Executing LangGraph Platform agent");
 
@@ -62,7 +63,7 @@ export function constructLGCRemoteAction({
 
       try {
         const response = await execute({
-          logger,
+          logger: logger.child({ component: "remote-actions.remote-lg-action.streamEvents" }),
           deploymentUrl: endpoint.deploymentUrl,
           langsmithApiKey: endpoint.langsmithApiKey,
           agent,
@@ -76,6 +77,7 @@ export function constructLGCRemoteAction({
             description: action.description,
             parameters: JSON.parse(action.jsonSchema) as string,
           })),
+          metaEvents,
         });
 
         const eventSource = new RemoteLangGraphEventSource();
@@ -174,6 +176,7 @@ export function constructRemoteActions({
           threadId,
           nodeName,
           additionalMessages = [],
+          metaEvents,
         }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
           logger.debug({ actionName: agent.name }, "Executing remote agent");
 
@@ -209,6 +212,7 @@ export function constructRemoteActions({
                   description: action.description,
                   parameters: JSON.parse(action.jsonSchema),
                 })),
+                metaEvents,
               }),
             });
 

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

@@ -16,6 +16,7 @@ import {
   ResolvedCopilotKitError,
   CopilotKitError,
 } from "@copilotkit/shared";
+import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
 
 export type EndpointDefinition = CopilotKitEndpoint | LangGraphPlatformEndpoint;
 
@@ -59,6 +60,7 @@ export type LangGraphAgentHandlerParams = {
   threadId?: string;
   nodeName?: string;
   additionalMessages?: Message[];
+  metaEvents?: MetaEventInput[];
 };
 
 export type LangGraphAgentAction = Action<any> & {

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

@@ -1,6 +1,6 @@
-import { Client } from "@langchain/langgraph-sdk";
+import { Client as LangGraphClient } from "@langchain/langgraph-sdk";
 import { createHash } from "node:crypto";
-import { randomUUID, isValidUUID } from "@copilotkit/shared";
+import { isValidUUID, randomUUID } from "@copilotkit/shared";
 import { parse as parsePartialJson } from "partial-json";
 import { Logger } from "pino";
 import { ActionInput } from "../../graphql/inputs/action.input";
@@ -10,6 +10,9 @@ import { ActionExecutionMessage, Message, MessageType } from "../../graphql/type
 import { MessageRole } from "../../graphql/types/enums";
 import { CustomEventNames, LangGraphEventTypes } from "../../agents/langgraph/events";
 import telemetry from "../telemetry-client";
+import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
+import { MetaEventName } from "../../graphql/types/meta-events.type";
+import { RunsStreamPayload } from "@langchain/langgraph-sdk/dist/types";
 
 type State = Record<string, any>;
 
@@ -24,6 +27,7 @@ interface ExecutionArgs extends Omit<LangGraphPlatformEndpoint, "agents"> {
   properties: CopilotRequestContextProperties;
   actions: ExecutionAction[];
   logger: Logger;
+  metaEvents?: MetaEventInput[];
 }
 
 // The following types are our own definition to the messages accepted by LangGraph Platform, enhanced with some of our extra data.
@@ -84,13 +88,23 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
     messages,
     actions,
     logger,
+    properties,
+    metaEvents,
   } = args;
 
   let nodeName = initialNodeName;
   let state = initialState;
   const { name, assistantId: initialAssistantId } = agent;
 
-  const client = new Client({ apiUrl: deploymentUrl, apiKey: langsmithApiKey });
+  const propertyHeaders = properties.authorization
+    ? { authorization: `Bearer ${properties.authorization}` }
+    : null;
+
+  const client = new LangGraphClient({
+    apiUrl: deploymentUrl,
+    apiKey: langsmithApiKey,
+    defaultHeaders: { ...propertyHeaders },
+  });
 
   let threadId = argsInitialThreadId ?? randomUUID();
   if (argsInitialThreadId && argsInitialThreadId.startsWith("ck-")) {
@@ -130,7 +144,11 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   }
   state = langGraphDefaultMergeState(state, formattedMessages, actions, name);
 
-  if (mode === "continue") {
+  const lgInterruptEvent = metaEvents?.find(
+    (ev) => ev.name === MetaEventName.LangGraphInterruptEvent,
+  );
+
+  if (mode === "continue" && !lgInterruptEvent) {
     await client.threads.updateState(threadId, { values: state, asNode: nodeName });
   }
 
@@ -171,10 +189,16 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   let shouldExit = false;
   let externalRunId = null;
 
-  const streamResponse = client.runs.stream(threadId, assistantId, {
+  const payload: RunsStreamPayload = {
     input: streamInput,
-    streamMode: ["events", "values"],
-  });
+    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));
 
@@ -189,12 +213,23 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
       hashedLgcKey: streamInfo.hashedLgcKey,
     });
     for await (const chunk of streamResponse) {
-      if (!["events", "values", "error"].includes(chunk.event)) continue;
+      if (!["events", "values", "error", "updates"].includes(chunk.event)) continue;
 
       if (chunk.event === "error") {
         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",
+        );
+        continue;
+      }
+      if (chunk.event === "updates") continue;
+
       if (chunk.event === "values") {
         latestStateValues = chunk.data;
         continue;
@@ -317,8 +352,9 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
     }
 
     state = await client.threads.getState(threadId);
-    const isEndNode = state.next.length === 0;
-    nodeName = Object.keys(state.metadata.writes)[0];
+    const interrupts = state.tasks?.[0]?.interrupts;
+    nodeName = interrupts ? nodeName : Object.keys(state.metadata.writes)[0];
+    const isEndNode = state.next.length === 0 && !interrupts;
 
     telemetry.capture("oss.runtime.agent_execution_stream_ended", streamInfo);
 

package/src/service-adapters/events.ts

@@ -28,8 +28,26 @@ export enum RuntimeEventTypes {
   ActionExecutionEnd = "ActionExecutionEnd",
   ActionExecutionResult = "ActionExecutionResult",
   AgentStateMessage = "AgentStateMessage",
+  MetaEvent = "MetaEvent",
 }
 
+export enum RuntimeMetaEventName {
+  LangGraphInterruptEvent = "LangGraphInterruptEvent",
+  LangGraphInterruptResumeEvent = "LangGraphInterruptResumeEvent",
+}
+
+export type RunTimeMetaEvent =
+  | {
+      type: RuntimeEventTypes.MetaEvent;
+      name: RuntimeMetaEventName.LangGraphInterruptEvent;
+      value: string;
+    }
+  | {
+      type: RuntimeEventTypes.MetaEvent;
+      name: RuntimeMetaEventName.LangGraphInterruptResumeEvent;
+      value: string;
+    };
+
 export type RuntimeEvent =
   | { type: RuntimeEventTypes.TextMessageStart; messageId: string; parentMessageId?: string }
   | {
@@ -62,7 +80,8 @@ export type RuntimeEvent =
       role: string;
       state: string;
       running: boolean;
-    };
+    }
+  | RunTimeMetaEvent;
 
 interface RuntimeEventWithState {
   event: RuntimeEvent | null;