@copilotkit/runtime 1.8.15-next.1 → 1.9.0

package/dist/index.mjs

@@ -1,15 +1,18 @@
-import "./chunk-Q6JA6YY3.mjs";
+import {
+  CustomEventNames,
+  LangGraphAgent
+} from "./chunk-M3JAEGRU.mjs";
 import {
   config,
   copilotRuntimeNextJSAppRouterEndpoint,
   copilotRuntimeNextJSPagesRouterEndpoint
-} from "./chunk-2DM4G7DN.mjs";
+} from "./chunk-U74GJORZ.mjs";
 import {
   copilotRuntimeNestEndpoint
-} from "./chunk-76QVO5FK.mjs";
+} from "./chunk-FK4NZL4G.mjs";
 import {
   copilotRuntimeNodeExpressEndpoint
-} from "./chunk-XRKKSNLV.mjs";
+} from "./chunk-GI32PQX6.mjs";
 import {
   CopilotRuntime,
   addCustomHeaderPlugin,
@@ -25,7 +28,7 @@ import {
   getCommonConfig,
   langGraphPlatformEndpoint,
   resolveEndpointType
-} from "./chunk-WPALAYGE.mjs";
+} from "./chunk-YCN5NOAP.mjs";
 import {
   AnthropicAdapter,
   BedrockAdapter,
@@ -55,6 +58,7 @@ export {
   AnthropicAdapter,
   BedrockAdapter,
   CopilotRuntime,
+  CustomEventNames,
   EmptyAdapter,
   ExperimentalEmptyAdapter,
   ExperimentalOllamaAdapter,
@@ -62,6 +66,7 @@ export {
   GroqAdapter,
   GuardrailsValidationFailureResponse,
   LangChainAdapter,
+  LangGraphAgent,
   MessageStreamInterruptedResponse,
   OpenAIAdapter,
   OpenAIAssistantAdapter,

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import \"reflect-metadata\";\nexport * from \"./lib\";\nexport * from \"./utils\";\nexport * from \"./service-adapters\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO;","names":[]}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import \"reflect-metadata\";\nexport * from \"./lib\";\nexport * from \"./utils\";\nexport * from \"./service-adapters\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO;","names":[]}

package/dist/lib/index.d.ts

@@ -4,11 +4,14 @@ export { CopilotRuntimeServerInstance, config, copilotRuntimeNextJSAppRouterEndp
 export { copilotRuntimeNodeHttpEndpoint } from './integrations/node-http/index.js';
 export { copilotRuntimeNodeExpressEndpoint } from './integrations/node-express/index.js';
 export { copilotRuntimeNestEndpoint } from './integrations/nest/index.js';
+import * as rxjs from 'rxjs';
+import { TextMessageStartEvent, TextMessageContentEvent, TextMessageEndEvent, ToolCallStartEvent, ToolCallArgsEvent, ToolCallEndEvent, RunAgentInput, EventType } from '@ag-ui/client';
+import { LangGraphAgent as LangGraphAgent$1, LangGraphAgentConfig, ProcessedEvents } from '@ag-ui/langgraph';
+import { Message } from '@langchain/langgraph-sdk/dist/types.messages';
 import 'openai';
 import '../langserve-4a5c9217.js';
 import '../index-d4614f9b.js';
 import '../graphql/types/base/index.js';
-import 'rxjs';
 import '@copilotkit/shared';
 import '@langchain/core/messages';
 import '@langchain/core/tools';
@@ -18,4 +21,153 @@ import 'graphql';
 import 'pino';
 import 'graphql-yoga';
 import './cloud/index.js';
-import '@ag-ui/client';
+
+interface PredictStateTool {
+    tool: string;
+    state_key: string;
+    tool_argument: string;
+}
+type State = Record<string, any>;
+type TextMessageEvents = TextMessageStartEvent | TextMessageContentEvent | TextMessageEndEvent;
+type ToolCallEvents = ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent;
+declare enum CustomEventNames {
+    CopilotKitManuallyEmitMessage = "copilotkit_manually_emit_message",
+    CopilotKitManuallyEmitToolCall = "copilotkit_manually_emit_tool_call",
+    CopilotKitManuallyEmitIntermediateState = "copilotkit_manually_emit_intermediate_state",
+    CopilotKitExit = "copilotkit_exit"
+}
+declare class LangGraphAgent extends LangGraphAgent$1 {
+    constructor(config: LangGraphAgentConfig);
+    dispatchEvent(event: ProcessedEvents): boolean;
+    run(input: RunAgentInput): rxjs.Observable<{
+        type: EventType.TEXT_MESSAGE_START;
+        role: "assistant";
+        messageId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TEXT_MESSAGE_CONTENT;
+        messageId: string;
+        delta: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TEXT_MESSAGE_END;
+        messageId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TOOL_CALL_START;
+        toolCallId: string;
+        toolCallName: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+        parentMessageId?: string | undefined;
+    } | {
+        type: EventType.TOOL_CALL_ARGS;
+        toolCallId: string;
+        delta: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.TOOL_CALL_END;
+        toolCallId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.STATE_SNAPSHOT;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+        snapshot?: any;
+    } | {
+        type: EventType.STATE_DELTA;
+        delta: any[];
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.MESSAGES_SNAPSHOT;
+        messages: ({
+            id: string;
+            role: "developer";
+            content: string;
+            name?: string | undefined;
+        } | {
+            id: string;
+            role: "system";
+            content: string;
+            name?: string | undefined;
+        } | {
+            id: string;
+            role: "assistant";
+            name?: string | undefined;
+            content?: string | undefined;
+            toolCalls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        } | {
+            id: string;
+            role: "user";
+            content: string;
+            name?: string | undefined;
+        } | {
+            id: string;
+            role: "tool";
+            content: string;
+            toolCallId: string;
+        })[];
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.RAW;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+        event?: any;
+        source?: string | undefined;
+    } | {
+        name: string;
+        type: EventType.CUSTOM;
+        value?: any;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.RUN_STARTED;
+        threadId: string;
+        runId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.RUN_FINISHED;
+        threadId: string;
+        runId: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        message: string;
+        type: EventType.RUN_ERROR;
+        code?: string | undefined;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.STEP_STARTED;
+        stepName: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType.STEP_FINISHED;
+        stepName: string;
+        timestamp?: number | undefined;
+        rawEvent?: any;
+    } | {
+        type: EventType;
+        name: string;
+        value: any;
+    }>;
+    langGraphDefaultMergeState(state: State, messages: Message[], tools: any): State;
+}
+
+export { CustomEventNames, LangGraphAgent, PredictStateTool, State, TextMessageEvents, ToolCallEvents };

package/dist/lib/index.js

@@ -44,7 +44,7 @@ var require_package = __commonJS({
       publishConfig: {
         access: "public"
       },
-      version: "1.8.15-next.1",
+      version: "1.9.0",
       sideEffects: false,
       main: "./dist/index.js",
       module: "./dist/index.mjs",
@@ -85,6 +85,7 @@ var require_package = __commonJS({
         "@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",
         "@copilotkit/shared": "workspace:*",
@@ -138,9 +139,11 @@ var require_package = __commonJS({
 var lib_exports = {};
 __export(lib_exports, {
   CopilotRuntime: () => CopilotRuntime,
+  CustomEventNames: () => CustomEventNames2,
   GoogleGenerativeAIAdapter: () => GoogleGenerativeAIAdapter,
   GroqAdapter: () => GroqAdapter,
   LangChainAdapter: () => LangChainAdapter,
+  LangGraphAgent: () => LangGraphAgent,
   OpenAIAdapter: () => OpenAIAdapter,
   OpenAIAssistantAdapter: () => OpenAIAssistantAdapter,
   UnifyAdapter: () => UnifyAdapter,
@@ -2770,11 +2773,11 @@ var MetaEventNames;
   MetaEventNames2["CopilotKitLangGraphInterruptEvent"] = "CopilotKitLangGraphInterruptEvent";
 })(MetaEventNames || (MetaEventNames = {}));
 var CustomEventNames;
-(function(CustomEventNames2) {
-  CustomEventNames2["CopilotKitManuallyEmitMessage"] = "copilotkit_manually_emit_message";
-  CustomEventNames2["CopilotKitManuallyEmitToolCall"] = "copilotkit_manually_emit_tool_call";
-  CustomEventNames2["CopilotKitManuallyEmitIntermediateState"] = "copilotkit_manually_emit_intermediate_state";
-  CustomEventNames2["CopilotKitExit"] = "copilotkit_exit";
+(function(CustomEventNames3) {
+  CustomEventNames3["CopilotKitManuallyEmitMessage"] = "copilotkit_manually_emit_message";
+  CustomEventNames3["CopilotKitManuallyEmitToolCall"] = "copilotkit_manually_emit_tool_call";
+  CustomEventNames3["CopilotKitManuallyEmitIntermediateState"] = "copilotkit_manually_emit_intermediate_state";
+  CustomEventNames3["CopilotKitExit"] = "copilotkit_exit";
 })(CustomEventNames || (CustomEventNames = {}));
 
 // src/agents/langgraph/event-source.ts
@@ -6666,12 +6669,143 @@ function copilotRuntimeNestEndpoint(options) {
   return copilotRuntimeNodeHttpEndpoint(options);
 }
 __name(copilotRuntimeNestEndpoint, "copilotRuntimeNestEndpoint");
+
+// src/lib/runtime/langgraph/langgraph-agent.ts
+var import_client = require("@ag-ui/client");
+var import_rxjs5 = require("rxjs");
+var import_langgraph = require("@ag-ui/langgraph");
+var CustomEventNames2;
+(function(CustomEventNames3) {
+  CustomEventNames3["CopilotKitManuallyEmitMessage"] = "copilotkit_manually_emit_message";
+  CustomEventNames3["CopilotKitManuallyEmitToolCall"] = "copilotkit_manually_emit_tool_call";
+  CustomEventNames3["CopilotKitManuallyEmitIntermediateState"] = "copilotkit_manually_emit_intermediate_state";
+  CustomEventNames3["CopilotKitExit"] = "copilotkit_exit";
+})(CustomEventNames2 || (CustomEventNames2 = {}));
+var LangGraphAgent = class extends import_langgraph.LangGraphAgent {
+  constructor(config2) {
+    super(config2);
+  }
+  dispatchEvent(event) {
+    if (event.type === import_client.EventType.CUSTOM) {
+      const customEvent = event;
+      if (customEvent.name === "copilotkit_manually_emit_message") {
+        this.subscriber.next({
+          type: import_client.EventType.TEXT_MESSAGE_START,
+          role: "assistant",
+          messageId: customEvent.value.message_id,
+          rawEvent: event
+        });
+        this.subscriber.next({
+          type: import_client.EventType.TEXT_MESSAGE_CONTENT,
+          messageId: customEvent.value.message_id,
+          delta: customEvent.value.message,
+          rawEvent: event
+        });
+        this.subscriber.next({
+          type: import_client.EventType.TEXT_MESSAGE_END,
+          messageId: customEvent.value.message_id,
+          rawEvent: event
+        });
+        return true;
+      }
+      if (customEvent.name === "copilotkit_manually_emit_tool_call") {
+        this.subscriber.next({
+          type: import_client.EventType.TOOL_CALL_START,
+          toolCallId: customEvent.value.id,
+          toolCallName: customEvent.value.name,
+          parentMessageId: customEvent.value.id,
+          rawEvent: event
+        });
+        this.subscriber.next({
+          type: import_client.EventType.TOOL_CALL_ARGS,
+          toolCallId: customEvent.value.id,
+          delta: customEvent.value.args,
+          rawEvent: event
+        });
+        this.subscriber.next({
+          type: import_client.EventType.TOOL_CALL_END,
+          toolCallId: customEvent.value.id,
+          rawEvent: event
+        });
+        return true;
+      }
+      if (customEvent.name === "copilotkit_manually_emit_intermediate_state") {
+        this.activeRun.manuallyEmittedState = customEvent.value;
+        this.dispatchEvent({
+          type: import_client.EventType.STATE_SNAPSHOT,
+          snapshot: this.getStateSnapshot(this.activeRun.manuallyEmittedState),
+          rawEvent: event
+        });
+        return true;
+      }
+      if (customEvent.name === "copilotkit_exit") {
+        this.subscriber.next({
+          type: import_client.EventType.CUSTOM,
+          name: "Exit",
+          value: true
+        });
+        return true;
+      }
+    }
+    const rawEvent = event.rawEvent;
+    if (!rawEvent) {
+      this.subscriber.next(event);
+      return true;
+    }
+    const isMessageEvent = event.type === import_client.EventType.TEXT_MESSAGE_START || event.type === import_client.EventType.TEXT_MESSAGE_CONTENT || event.type === import_client.EventType.TEXT_MESSAGE_END;
+    const isToolEvent = event.type === import_client.EventType.TOOL_CALL_START || event.type === import_client.EventType.TOOL_CALL_ARGS || event.type === import_client.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) {
+    return super.run(input).pipe((0, import_rxjs5.map)((processedEvent) => {
+      var _a, _b, _c, _d, _e;
+      if (processedEvent.type === import_client.EventType.RAW) {
+        const event = processedEvent.event ?? processedEvent.rawEvent;
+        const eventType = event.event;
+        const toolCallData = (_c = (_b = (_a = event.data) == null ? void 0 : _a.chunk) == null ? void 0 : _b.tool_call_chunks) == null ? void 0 : _c[0];
+        const toolCallUsedToPredictState = (_e = (_d = event.metadata) == null ? void 0 : _d["copilotkit:emit-intermediate-state"]) == null ? void 0 : _e.some((predictStateTool) => predictStateTool.tool === (toolCallData == null ? void 0 : toolCallData.name));
+        if (eventType === LangGraphEventTypes.OnChatModelStream && toolCallUsedToPredictState) {
+          return {
+            type: import_client.EventType.CUSTOM,
+            name: "PredictState",
+            value: event.metadata["copilotkit:emit-intermediate-state"]
+          };
+        }
+      }
+      return processedEvent;
+    }));
+  }
+  langGraphDefaultMergeState(state, messages, tools) {
+    const { tools: returnedTools, ...rest } = super.langGraphDefaultMergeState(state, messages, tools);
+    return {
+      ...rest,
+      copilotkit: {
+        actions: returnedTools
+      }
+    };
+  }
+};
+__name(LangGraphAgent, "LangGraphAgent");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CopilotRuntime,
+  CustomEventNames,
   GoogleGenerativeAIAdapter,
   GroqAdapter,
   LangChainAdapter,
+  LangGraphAgent,
   OpenAIAdapter,
   OpenAIAssistantAdapter,
   UnifyAdapter,