@copilotkit/runtime 1.8.15-next.1 → 1.9.0-next.2

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

@@ -1,6 +1,6 @@
 import {
   copilotRuntimeNodeHttpEndpoint
-} from "../../../chunk-WPALAYGE.mjs";
+} from "../../../chunk-6A27R7IP.mjs";
 import "../../../chunk-IIXJVVTV.mjs";
 import "../../../chunk-5BIEM2UU.mjs";
 import "../../../chunk-SHBDMA63.mjs";

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.8.15-next.1",
+  "version": "1.9.0-next.2",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -40,6 +40,7 @@
     "@ag-ui/client": "0.0.28",
     "@ag-ui/core": "0.0.28",
     "@ag-ui/encoder": "0.0.28",
+    "@ag-ui/langgraph": "0.0.3",
     "@ag-ui/proto": "0.0.28",
     "@anthropic-ai/sdk": "^0.27.3",
     "@graphql-yoga/plugin-defer-stream": "^3.3.1",
@@ -65,7 +66,7 @@
     "rxjs": "^7.8.1",
     "type-graphql": "2.0.0-rc.1",
     "zod": "^3.23.3",
-    "@copilotkit/shared": "1.8.15-next.1"
+    "@copilotkit/shared": "1.9.0-next.2"
   },
   "peerDependencies": {
     "@ag-ui/client": ">=0.0.28",

package/src/lib/index.ts

@@ -8,3 +8,4 @@ export * from "./integrations";
 export * from "./logger";
 export * from "./runtime/copilot-runtime";
 export * from "./runtime/mcp-tools-utils";
+export * from "./runtime/langgraph/langgraph-agent";

package/src/lib/runtime/langgraph/langgraph-agent.ts

@@ -0,0 +1,190 @@
+import {
+  RunAgentInput,
+  EventType,
+  CustomEvent,
+  TextMessageStartEvent,
+  TextMessageContentEvent,
+  TextMessageEndEvent,
+  ToolCallStartEvent,
+  ToolCallArgsEvent,
+  ToolCallEndEvent,
+} from "@ag-ui/client";
+import { map } from "rxjs";
+import { LangGraphEventTypes } from "../../../agents/langgraph/events";
+import { RawEvent } from "@ag-ui/core";
+import {
+  LangGraphAgent as AGUILangGraphAgent,
+  type LangGraphAgentConfig,
+  ProcessedEvents,
+} from "@ag-ui/langgraph";
+import { Message as LangGraphMessage } from "@langchain/langgraph-sdk/dist/types.messages";
+
+export interface PredictStateTool {
+  tool: string;
+  state_key: string;
+  tool_argument: string;
+}
+export type State = Record<string, any>;
+
+export type TextMessageEvents =
+  | TextMessageStartEvent
+  | TextMessageContentEvent
+  | TextMessageEndEvent;
+
+export type ToolCallEvents = ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent;
+
+export enum CustomEventNames {
+  CopilotKitManuallyEmitMessage = "copilotkit_manually_emit_message",
+  CopilotKitManuallyEmitToolCall = "copilotkit_manually_emit_tool_call",
+  CopilotKitManuallyEmitIntermediateState = "copilotkit_manually_emit_intermediate_state",
+  CopilotKitExit = "copilotkit_exit",
+}
+
+export class LangGraphAgent extends AGUILangGraphAgent {
+  constructor(config: LangGraphAgentConfig) {
+    super(config);
+  }
+
+  dispatchEvent(event: ProcessedEvents) {
+    if (event.type === EventType.CUSTOM) {
+      // const event = processedEvent as unknown as CustomEvent;
+      const customEvent = event as unknown as CustomEvent;
+
+      if (customEvent.name === CustomEventNames.CopilotKitManuallyEmitMessage) {
+        this.subscriber.next({
+          type: EventType.TEXT_MESSAGE_START,
+          role: "assistant",
+          messageId: customEvent.value.message_id,
+          rawEvent: event,
+        });
+        this.subscriber.next({
+          type: EventType.TEXT_MESSAGE_CONTENT,
+          messageId: customEvent.value.message_id,
+          delta: customEvent.value.message,
+          rawEvent: event,
+        });
+        this.subscriber.next({
+          type: EventType.TEXT_MESSAGE_END,
+          messageId: customEvent.value.message_id,
+          rawEvent: event,
+        });
+        return true;
+      }
+
+      if (customEvent.name === CustomEventNames.CopilotKitManuallyEmitToolCall) {
+        this.subscriber.next({
+          type: EventType.TOOL_CALL_START,
+          toolCallId: customEvent.value.id,
+          toolCallName: customEvent.value.name,
+          parentMessageId: customEvent.value.id,
+          rawEvent: event,
+        });
+        this.subscriber.next({
+          type: EventType.TOOL_CALL_ARGS,
+          toolCallId: customEvent.value.id,
+          delta: customEvent.value.args,
+          rawEvent: event,
+        });
+        this.subscriber.next({
+          type: EventType.TOOL_CALL_END,
+          toolCallId: customEvent.value.id,
+          rawEvent: event,
+        });
+        return true;
+      }
+
+      if (customEvent.name === CustomEventNames.CopilotKitManuallyEmitIntermediateState) {
+        this.activeRun.manuallyEmittedState = customEvent.value;
+        this.dispatchEvent({
+          type: EventType.STATE_SNAPSHOT,
+          snapshot: this.getStateSnapshot(this.activeRun.manuallyEmittedState),
+          rawEvent: event,
+        });
+        return true;
+      }
+
+      if (customEvent.name === CustomEventNames.CopilotKitExit) {
+        this.subscriber.next({
+          type: EventType.CUSTOM,
+          name: "Exit",
+          value: true,
+        });
+        return true;
+      }
+    }
+
+    // Intercept all text message and tool call events and check if should disable
+    const rawEvent = (event as ToolCallEvents | TextMessageEvents).rawEvent;
+    if (!rawEvent) {
+      this.subscriber.next(event);
+      return true;
+    }
+
+    const isMessageEvent =
+      event.type === EventType.TEXT_MESSAGE_START ||
+      event.type === EventType.TEXT_MESSAGE_CONTENT ||
+      event.type === EventType.TEXT_MESSAGE_END;
+    const isToolEvent =
+      event.type === EventType.TOOL_CALL_START ||
+      event.type === EventType.TOOL_CALL_ARGS ||
+      event.type === EventType.TOOL_CALL_END;
+    if ("copilotkit:emit-tool-calls" in (rawEvent.metadata || {})) {
+      if (rawEvent.metadata["copilotkit:emit-tool-calls"] === false && isToolEvent) {
+        return false;
+      }
+    }
+    if ("copilotkit:emit-messages" in (rawEvent.metadata || {})) {
+      if (rawEvent.metadata["copilotkit:emit-messages"] === false && isMessageEvent) {
+        return false;
+      }
+    }
+
+    this.subscriber.next(event);
+    return true;
+  }
+
+  // @ts-ignore
+  run(input: RunAgentInput) {
+    return super.run(input).pipe(
+      map((processedEvent) => {
+        // Turn raw event into emit state snapshot from tool call event
+        if (processedEvent.type === EventType.RAW) {
+          // Get the LangGraph event from the AGUI event.
+          const event = (processedEvent as RawEvent).event ?? (processedEvent as RawEvent).rawEvent;
+
+          const eventType = event.event;
+          const toolCallData = event.data?.chunk?.tool_call_chunks?.[0];
+          const toolCallUsedToPredictState = event.metadata?.[
+            "copilotkit:emit-intermediate-state"
+          ]?.some(
+            (predictStateTool: PredictStateTool) => predictStateTool.tool === toolCallData?.name,
+          );
+
+          if (eventType === LangGraphEventTypes.OnChatModelStream && toolCallUsedToPredictState) {
+            return {
+              type: EventType.CUSTOM,
+              name: "PredictState",
+              value: event.metadata["copilotkit:emit-intermediate-state"],
+            };
+          }
+        }
+
+        return processedEvent;
+      }),
+    );
+  }
+
+  langGraphDefaultMergeState(state: State, messages: LangGraphMessage[], tools: any): State {
+    const { tools: returnedTools, ...rest } = super.langGraphDefaultMergeState(
+      state,
+      messages,
+      tools,
+    );
+    return {
+      ...rest,
+      copilotkit: {
+        actions: returnedTools,
+      },
+    };
+  }
+}

package/dist/chunk-Q6JA6YY3.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-Q6JA6YY3.mjs.map

package/dist/chunk-Q6JA6YY3.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}