@copilotkit/runtime 1.4.0-pre-1-4-0.11 → 1.4.0-pre-1-4-0.12

package/dist/{chunk-VBGS6IWV.mjs → chunk-YZ3VKKSM.mjs}

@@ -1,6 +1,7 @@
 import {
+  RemoteChain,
   streamLangChainResponse
-} from "./chunk-MXXPWWBF.mjs";
+} from "./chunk-56IQ6PGC.mjs";
 import {
   GuardrailsValidationFailureResponse,
   MessageStreamInterruptedResponse,
@@ -36,7 +37,7 @@ var require_package = __commonJS({
       publishConfig: {
         access: "public"
       },
-      version: "1.4.0-pre-1-4-0.11",
+      version: "1.4.0-pre-1-4-0.12",
       sideEffects: false,
       main: "./dist/index.js",
       module: "./dist/index.mjs",
@@ -121,7 +122,7 @@ import { buildSchemaSync } from "type-graphql";
 
 // src/graphql/resolvers/copilot.resolver.ts
 import { Arg, Ctx, Mutation, Query, Resolver } from "type-graphql";
-import { ReplaySubject as ReplaySubject3, Subject, finalize, firstValueFrom as firstValueFrom2, shareReplay, skipWhile, take, takeWhile, tap } from "rxjs";
+import { ReplaySubject as ReplaySubject3, Subject, filter, finalize, firstValueFrom as firstValueFrom2, shareReplay, skipWhile, take, takeWhile, tap } from "rxjs";
 
 // src/graphql/inputs/generate-copilot-response.input.ts
 import { Field as Field9, InputType as InputType9 } from "type-graphql";
@@ -1023,16 +1024,14 @@ CopilotResponse = _ts_decorate11([
 import { Repeater } from "graphql-yoga";
 
 // src/service-adapters/events.ts
-import { of, concat, map, scan as scan2, concatMap, ReplaySubject as ReplaySubject2, firstValueFrom, from } from "rxjs";
+import { randomId as randomId3 } from "@copilotkit/shared";
+import { of, concat, map, scan as scan2, concatMap, ReplaySubject as ReplaySubject2, firstValueFrom, from as from2 } from "rxjs";
 
 // src/lib/telemetry-client.ts
 import { TelemetryClient } from "@copilotkit/shared";
-var packageJson = require_package();
-var telemetryClient = new TelemetryClient({
-  packageName: packageJson.name,
-  packageVersion: packageJson.version
-});
-var telemetry_client_default = telemetryClient;
+
+// src/lib/runtime/remote-action-constructors.ts
+import { createHash as createHash2 } from "crypto";
 
 // src/agents/langgraph/event-source.ts
 import { ReplaySubject, scan, mergeMap, catchError } from "rxjs";
@@ -1049,6 +1048,8 @@ var LangGraphEventTypes;
   LangGraphEventTypes2["OnToolStart"] = "on_tool_start";
   LangGraphEventTypes2["OnToolEnd"] = "on_tool_end";
   LangGraphEventTypes2["OnCopilotKitStateSync"] = "on_copilotkit_state_sync";
+  LangGraphEventTypes2["OnCopilotKitEmitMessage"] = "on_copilotkit_emit_message";
+  LangGraphEventTypes2["OnCopilotKitEmitToolCall"] = "on_copilotkit_emit_tool_call";
   LangGraphEventTypes2["OnCustomEvent"] = "on_custom_event";
 })(LangGraphEventTypes || (LangGraphEventTypes = {}));
 var CustomEventNames;
@@ -1142,12 +1143,14 @@ var RemoteLangGraphEventSource = class {
       }
       if (eventWithState.prevToolCallMessageId !== null && eventWithState.prevToolCallMessageId !== eventWithState.toolCallMessageId && this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)) {
         events.push({
-          type: RuntimeEventTypes.ActionExecutionEnd
+          type: RuntimeEventTypes.ActionExecutionEnd,
+          actionExecutionId: eventWithState.prevToolCallMessageId
         });
       }
       if (eventWithState.prevMessageId !== null && eventWithState.prevMessageId !== eventWithState.messageId && shouldEmitMessages) {
         events.push({
-          type: RuntimeEventTypes.TextMessageEnd
+          type: RuntimeEventTypes.TextMessageEnd,
+          messageId: eventWithState.prevMessageId
         });
       }
       switch (eventWithState.event.event) {
@@ -1159,10 +1162,12 @@ var RemoteLangGraphEventSource = class {
             });
             events.push({
               type: RuntimeEventTypes.TextMessageContent,
+              messageId: eventWithState.event.data.message_id,
               content: eventWithState.event.data.message
             });
             events.push({
-              type: RuntimeEventTypes.TextMessageEnd
+              type: RuntimeEventTypes.TextMessageEnd,
+              messageId: eventWithState.event.data.message_id
             });
           } else if (eventWithState.event.name === CustomEventNames.CopilotKitManuallyEmitToolCall) {
             events.push({
@@ -1172,10 +1177,12 @@ var RemoteLangGraphEventSource = class {
             });
             events.push({
               type: RuntimeEventTypes.ActionExecutionArgs,
+              actionExecutionId: eventWithState.event.data.id,
               args: JSON.stringify(eventWithState.event.data.args)
             });
             events.push({
-              type: RuntimeEventTypes.ActionExecutionEnd
+              type: RuntimeEventTypes.ActionExecutionEnd,
+              actionExecutionId: eventWithState.event.data.id
             });
           }
           break;
@@ -1219,6 +1226,7 @@ var RemoteLangGraphEventSource = class {
             if (this.shouldEmitToolCall(shouldEmitToolCalls, eventWithState.toolCallName)) {
               events.push({
                 type: RuntimeEventTypes.ActionExecutionArgs,
+                actionExecutionId: eventWithState.toolCallMessageId,
                 args
               });
             }
@@ -1226,6 +1234,7 @@ var RemoteLangGraphEventSource = class {
             if (shouldEmitMessages) {
               events.push({
                 type: RuntimeEventTypes.TextMessageContent,
+                messageId: eventWithState.messageId,
                 content
               });
             }
@@ -1238,12 +1247,14 @@ var RemoteLangGraphEventSource = class {
       const events = [];
       if (lastEventWithState == null ? void 0 : lastEventWithState.messageId) {
         events.push({
-          type: RuntimeEventTypes.TextMessageEnd
+          type: RuntimeEventTypes.TextMessageEnd,
+          messageId: lastEventWithState.messageId
         });
       }
       if (lastEventWithState == null ? void 0 : lastEventWithState.toolCallMessageId) {
         events.push({
-          type: RuntimeEventTypes.ActionExecutionEnd
+          type: RuntimeEventTypes.ActionExecutionEnd,
+          actionExecutionId: lastEventWithState.toolCallMessageId
         });
       }
       const messageId = randomId();
@@ -1253,10 +1264,12 @@ var RemoteLangGraphEventSource = class {
       });
       events.push({
         type: RuntimeEventTypes.TextMessageContent,
+        messageId,
         content: "\u274C An error occurred. Please try again."
       });
       events.push({
-        type: RuntimeEventTypes.TextMessageEnd
+        type: RuntimeEventTypes.TextMessageEnd,
+        messageId
       });
       return events;
     }));
@@ -1266,7 +1279,7 @@ __name(RemoteLangGraphEventSource, "RemoteLangGraphEventSource");
 
 // src/lib/runtime/remote-lg-cloud-action.ts
 import { Client } from "@langchain/langgraph-sdk";
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import { parse as parsePartialJson } from "partial-json";
 async function execute(args) {
   return new ReadableStream({
@@ -1281,6 +1294,7 @@ async function execute(args) {
 }
 __name(execute, "execute");
 async function streamEvents(controller, args) {
+  var _a, _b, _c, _d, _e, _f;
   const { deploymentUrl, langsmithApiKey, threadId: agrsInitialThreadId, agent, nodeName: initialNodeName, state: initialState, messages, actions, logger: logger2 } = args;
   let nodeName = initialNodeName;
   let state = initialState;
@@ -1354,7 +1368,14 @@ async function streamEvents(controller, args) {
   const emit = /* @__PURE__ */ __name((message) => controller.enqueue(new TextEncoder().encode(message)), "emit");
   let latestStateValues = {};
   let updatedState = state;
+  let manuallyEmittedState = null;
+  let streamInfo = {
+    hashedLgcKey: createHash("sha256").update(langsmithApiKey).digest("hex")
+  };
   try {
+    telemetry_client_default.capture("oss.runtime.agent_execution_stream_started", {
+      hashedLgcKey: streamInfo.hashedLgcKey
+    });
     for await (const chunk of streamResponse2) {
       if (![
         "events",
@@ -1376,26 +1397,37 @@ async function streamEvents(controller, args) {
       const runId = event.metadata.run_id;
       externalRunId = runId;
       const metadata = event.metadata;
+      if (((_b = (_a = event.data) == null ? void 0 : _a.output) == null ? void 0 : _b.model) != null && ((_d = (_c = event.data) == null ? void 0 : _c.output) == null ? void 0 : _d.model) != "") {
+        streamInfo.provider = (_f = (_e = event.data) == null ? void 0 : _e.output) == null ? void 0 : _f.model;
+      }
+      if (metadata.langgraph_host != null && metadata.langgraph_host != "") {
+        streamInfo.langGraphHost = metadata.langgraph_host;
+      }
+      if (metadata.langgraph_version != null && metadata.langgraph_version != "") {
+        streamInfo.langGraphVersion = metadata.langgraph_version;
+      }
       shouldExit = shouldExit || eventType === LangGraphEventTypes.OnCustomEvent && event.name === CustomEventNames.CopilotKitExit;
       const emitIntermediateState = metadata["copilotkit:emit-intermediate-state"];
       const manuallyEmitIntermediateState = eventType === LangGraphEventTypes.OnCustomEvent && event.name === CustomEventNames.CopilotKitManuallyEmitIntermediateState;
+      const exitingNode = nodeName === currentNodeName && eventType === LangGraphEventTypes.OnChainEnd;
+      if (exitingNode) {
+        manuallyEmittedState = null;
+      }
       if (graphInfo["nodes"].some((node) => node.id === currentNodeName)) {
         nodeName = currentNodeName;
-        if (eventType === LangGraphEventTypes.OnChainStart || eventType === LangGraphEventTypes.OnChainEnd) {
-          updatedState = latestStateValues;
-        }
       }
+      updatedState = manuallyEmittedState ?? latestStateValues;
       if (!nodeName) {
         continue;
       }
       if (manuallyEmitIntermediateState) {
-        updatedState = event.data;
+        manuallyEmittedState = event.data;
         emit(getStateSyncEvent({
           threadId,
           runId,
           agentName: agent.name,
           nodeName,
-          state: updatedState,
+          state: manuallyEmittedState,
           running: true,
           active: true
         }));
@@ -1419,7 +1451,6 @@ async function streamEvents(controller, args) {
       if (!emitIntermediateState && currentNodeName === emitIntermediateStateUntilEnd && eventType === LangGraphEventTypes.OnChainEnd) {
         emitIntermediateStateUntilEnd = null;
       }
-      const exitingNode = nodeName === currentNodeName && eventType === LangGraphEventTypes.OnChainEnd;
       if (JSON.stringify(updatedState) !== JSON.stringify(state) || prevNodeName != nodeName || exitingNode) {
         state = updatedState;
         prevNodeName = nodeName;
@@ -1438,6 +1469,7 @@ async function streamEvents(controller, args) {
     state = await client.threads.getState(threadId);
     const isEndNode = state.next.length === 0;
     nodeName = Object.keys(state.metadata.writes)[0];
+    telemetry_client_default.capture("oss.runtime.agent_execution_stream_ended", streamInfo);
     emit(getStateSyncEvent({
       threadId,
       runId: externalRunId,
@@ -1685,7 +1717,12 @@ function constructLGCRemoteAction({ endpoint, graphqlContext, logger: logger2, m
       logger2.debug({
         actionName: agent.name
       }, "Executing LangGraph Cloud agent");
-      telemetry_client_default.capture("oss.runtime.remote_action_executed", {});
+      telemetry_client_default.capture("oss.runtime.remote_action_executed", {
+        agentExecution: true,
+        type: "langgraph-cloud",
+        agentsAmount: endpoint.agents.length,
+        hashedLgcKey: createHash2("sha256").update(endpoint.langsmithApiKey).digest("hex")
+      });
       let state = {};
       if (agentStates) {
         const jsonState = (_a = agentStates.find((state2) => state2.agentName === name)) == null ? void 0 : _a.state;
@@ -1739,7 +1776,11 @@ function constructRemoteActions({ json, url, onBeforeRequest, graphqlContext, lo
         args
       }, "Executing remote action");
       const headers = createHeaders(onBeforeRequest, graphqlContext);
-      telemetry_client_default.capture("oss.runtime.remote_action_executed", {});
+      telemetry_client_default.capture("oss.runtime.remote_action_executed", {
+        agentExecution: false,
+        type: "self-hosted",
+        agentsAmount: json["agents"].length
+      });
       try {
         const response = await fetch(`${url}/actions/execute`, {
           method: "POST",
@@ -1785,7 +1826,11 @@ function constructRemoteActions({ json, url, onBeforeRequest, graphqlContext, lo
         actionName: agent.name
       }, "Executing remote agent");
       const headers = createHeaders(onBeforeRequest, graphqlContext);
-      telemetry_client_default.capture("oss.runtime.remote_action_executed", {});
+      telemetry_client_default.capture("oss.runtime.remote_action_executed", {
+        agentExecution: true,
+        type: "self-hosted",
+        agentsAmount: json["agents"].length
+      });
       let state = {};
       if (agentStates) {
         const jsonState = (_a = agentStates.find((state2) => state2.agentName === name)) == null ? void 0 : _a.state;
@@ -1996,6 +2041,329 @@ async function setupRemoteActions({ remoteEndpointDefinitions, graphqlContext, m
 }
 __name(setupRemoteActions, "setupRemoteActions");
 
+// src/lib/telemetry-client.ts
+import { createHash as createHash3 } from "crypto";
+
+// src/lib/runtime/copilot-runtime.ts
+import { actionParametersToJsonSchema, randomId as randomId2 } from "@copilotkit/shared";
+
+// src/service-adapters/conversion.ts
+import { plainToInstance } from "class-transformer";
+function convertGqlInputToMessages(inputMessages) {
+  const messages = [];
+  for (const message of inputMessages) {
+    if (message.textMessage) {
+      messages.push(plainToInstance(TextMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        role: message.textMessage.role,
+        content: message.textMessage.content
+      }));
+    } else if (message.actionExecutionMessage) {
+      messages.push(plainToInstance(ActionExecutionMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        name: message.actionExecutionMessage.name,
+        arguments: JSON.parse(message.actionExecutionMessage.arguments),
+        scope: message.actionExecutionMessage.scope
+      }));
+    } else if (message.resultMessage) {
+      messages.push(plainToInstance(ResultMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        actionExecutionId: message.resultMessage.actionExecutionId,
+        actionName: message.resultMessage.actionName,
+        result: message.resultMessage.result
+      }));
+    } else if (message.agentStateMessage) {
+      messages.push(plainToInstance(AgentStateMessage, {
+        id: message.id,
+        threadId: message.agentStateMessage.threadId,
+        createdAt: message.createdAt,
+        agentName: message.agentStateMessage.agentName,
+        nodeName: message.agentStateMessage.nodeName,
+        runId: message.agentStateMessage.runId,
+        active: message.agentStateMessage.active,
+        role: message.agentStateMessage.role,
+        state: JSON.parse(message.agentStateMessage.state),
+        running: message.agentStateMessage.running
+      }));
+    }
+  }
+  return messages;
+}
+__name(convertGqlInputToMessages, "convertGqlInputToMessages");
+
+// src/lib/runtime/copilot-runtime.ts
+import { from } from "rxjs";
+var CopilotRuntime = class {
+  actions;
+  remoteEndpointDefinitions;
+  langserve = [];
+  onBeforeRequest;
+  onAfterRequest;
+  constructor(params) {
+    var _a, _b;
+    this.actions = (params == null ? void 0 : params.actions) || [];
+    for (const chain of (params == null ? void 0 : params.langserve) || []) {
+      const remoteChain = new RemoteChain(chain);
+      this.langserve.push(remoteChain.toAction());
+    }
+    this.remoteEndpointDefinitions = (params == null ? void 0 : params.remoteEndpoints) ?? (params == null ? void 0 : params.remoteActions) ?? [];
+    this.onBeforeRequest = (_a = params == null ? void 0 : params.middleware) == null ? void 0 : _a.onBeforeRequest;
+    this.onAfterRequest = (_b = params == null ? void 0 : params.middleware) == null ? void 0 : _b.onAfterRequest;
+  }
+  async processRuntimeRequest(request) {
+    var _a;
+    const { serviceAdapter, messages: rawMessages, actions: clientSideActionsInput, threadId, runId, outputMessagesPromise, graphqlContext, forwardedParameters, agentSession, url } = request;
+    const eventSource = new RuntimeEventSource();
+    try {
+      if (agentSession) {
+        return await this.processAgentRequest(request);
+      }
+      const messages = rawMessages.filter((message) => !message.agentStateMessage);
+      const inputMessages = convertGqlInputToMessages(messages);
+      const serverSideActions = await this.getServerSideActions(request);
+      const serverSideActionsInput = serverSideActions.map((action) => ({
+        name: action.name,
+        description: action.description,
+        jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters))
+      }));
+      const actionInputs = flattenToolCallsNoDuplicates([
+        ...serverSideActionsInput,
+        ...clientSideActionsInput
+      ]);
+      await ((_a = this.onBeforeRequest) == null ? void 0 : _a.call(this, {
+        threadId,
+        runId,
+        inputMessages,
+        properties: graphqlContext.properties,
+        url
+      }));
+      const result = await serviceAdapter.process({
+        messages: inputMessages,
+        actions: actionInputs,
+        threadId,
+        runId,
+        eventSource,
+        forwardedParameters
+      });
+      outputMessagesPromise.then((outputMessages) => {
+        var _a2;
+        (_a2 = this.onAfterRequest) == null ? void 0 : _a2.call(this, {
+          threadId: result.threadId,
+          runId: result.runId,
+          inputMessages,
+          outputMessages,
+          properties: graphqlContext.properties,
+          url
+        });
+      }).catch((_error) => {
+      });
+      return {
+        threadId: result.threadId,
+        runId: result.runId,
+        eventSource,
+        serverSideActions,
+        actionInputsWithoutAgents: actionInputs.filter((action) => (
+          // TODO-AGENTS: do not exclude ALL server side actions
+          !serverSideActions.find((serverSideAction) => serverSideAction.name == action.name)
+        ))
+      };
+    } catch (error) {
+      console.error("Error getting response:", error);
+      eventSource.sendErrorMessageToChat();
+      return {
+        threadId: threadId || randomId2(),
+        runId: runId || randomId2(),
+        eventSource,
+        serverSideActions: [],
+        actionInputsWithoutAgents: []
+      };
+    }
+  }
+  async processAgentRequest(request) {
+    var _a;
+    const { messages: rawMessages, outputMessagesPromise, graphqlContext, agentSession } = request;
+    const { threadId, agentName, nodeName } = agentSession;
+    const serverSideActions = await this.getServerSideActions(request);
+    const messages = convertGqlInputToMessages(rawMessages);
+    const agent = serverSideActions.find((action) => action.name === agentName && isLangGraphAgentAction(action));
+    if (!agent) {
+      throw new Error(`Agent ${agentName} not found`);
+    }
+    const serverSideActionsInput = serverSideActions.filter((action) => !isLangGraphAgentAction(action)).map((action) => ({
+      name: action.name,
+      description: action.description,
+      jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters))
+    }));
+    const actionInputsWithoutAgents = flattenToolCallsNoDuplicates([
+      ...serverSideActionsInput,
+      ...request.actions
+    ]);
+    await ((_a = this.onBeforeRequest) == null ? void 0 : _a.call(this, {
+      threadId,
+      runId: void 0,
+      inputMessages: messages,
+      properties: graphqlContext.properties
+    }));
+    try {
+      const eventSource = new RuntimeEventSource();
+      const stream = await agent.langGraphAgentHandler({
+        name: agentName,
+        threadId,
+        nodeName,
+        actionInputsWithoutAgents
+      });
+      eventSource.stream(async (eventStream$) => {
+        from(stream).subscribe({
+          next: (event) => eventStream$.next(event),
+          error: (err) => console.error("Error in stream", err),
+          complete: () => eventStream$.complete()
+        });
+      });
+      outputMessagesPromise.then((outputMessages) => {
+        var _a2;
+        (_a2 = this.onAfterRequest) == null ? void 0 : _a2.call(this, {
+          threadId,
+          runId: void 0,
+          inputMessages: messages,
+          outputMessages,
+          properties: graphqlContext.properties
+        });
+      }).catch((_error) => {
+      });
+      return {
+        threadId,
+        runId: void 0,
+        eventSource,
+        serverSideActions: [],
+        actionInputsWithoutAgents
+      };
+    } catch (error) {
+      console.error("Error getting response:", error);
+      throw error;
+    }
+  }
+  async getServerSideActions(request) {
+    const { messages: rawMessages, graphqlContext, agentStates, url } = request;
+    const inputMessages = convertGqlInputToMessages(rawMessages);
+    const langserveFunctions = [];
+    for (const chainPromise of this.langserve) {
+      try {
+        const chain = await chainPromise;
+        langserveFunctions.push(chain);
+      } catch (error) {
+        console.error("Error loading langserve chain:", error);
+      }
+    }
+    const remoteEndpointDefinitions = this.remoteEndpointDefinitions.map((endpoint) => ({
+      ...endpoint,
+      type: resolveEndpointType(endpoint)
+    }));
+    const remoteActions = await setupRemoteActions({
+      remoteEndpointDefinitions,
+      graphqlContext,
+      messages: inputMessages,
+      agentStates,
+      frontendUrl: url
+    });
+    const configuredActions = typeof this.actions === "function" ? this.actions({
+      properties: graphqlContext.properties,
+      url
+    }) : this.actions;
+    return [
+      ...configuredActions,
+      ...langserveFunctions,
+      ...remoteActions
+    ];
+  }
+};
+__name(CopilotRuntime, "CopilotRuntime");
+function flattenToolCallsNoDuplicates(toolsByPriority) {
+  let allTools = [];
+  const allToolNames = [];
+  for (const tool of toolsByPriority) {
+    if (!allToolNames.includes(tool.name)) {
+      allTools.push(tool);
+      allToolNames.push(tool.name);
+    }
+  }
+  return allTools;
+}
+__name(flattenToolCallsNoDuplicates, "flattenToolCallsNoDuplicates");
+function copilotKitEndpoint(config) {
+  return {
+    ...config,
+    type: EndpointType.CopilotKit
+  };
+}
+__name(copilotKitEndpoint, "copilotKitEndpoint");
+function langGraphCloudEndpoint(config) {
+  return {
+    ...config,
+    type: EndpointType.LangGraphCloud
+  };
+}
+__name(langGraphCloudEndpoint, "langGraphCloudEndpoint");
+function resolveEndpointType(endpoint) {
+  if (!endpoint.type) {
+    if ("langsmithApiKey" in endpoint && "deploymentUrl" in endpoint && "agents" in endpoint) {
+      return EndpointType.LangGraphCloud;
+    } else {
+      return EndpointType.CopilotKit;
+    }
+  }
+  return endpoint.type;
+}
+__name(resolveEndpointType, "resolveEndpointType");
+
+// src/lib/telemetry-client.ts
+var packageJson = require_package();
+var telemetryClient = new TelemetryClient({
+  packageName: packageJson.name,
+  packageVersion: packageJson.version
+});
+function getRuntimeInstanceTelemetryInfo(runtime) {
+  const endpointsInfo = runtime.remoteEndpointDefinitions.reduce((acc, endpoint) => {
+    let info = {
+      ...acc
+    };
+    const endpointType = resolveEndpointType(endpoint);
+    if (!info.endpointTypes.includes(endpointType)) {
+      info = {
+        ...info,
+        endpointTypes: [
+          ...info.endpointTypes,
+          endpointType
+        ]
+      };
+    }
+    if (endpointType === EndpointType.LangGraphCloud) {
+      const ep = endpoint;
+      info = {
+        ...info,
+        agentsAmount: ep.agents.length,
+        hashedKey: createHash3("sha256").update(ep.langsmithApiKey).digest("hex")
+      };
+    }
+    return info;
+  }, {
+    endpointTypes: [],
+    agentsAmount: null,
+    hashedKey: null
+  });
+  return {
+    actionsAmount: runtime.actions.length,
+    endpointsAmount: runtime.remoteEndpointDefinitions.length,
+    endpointTypes: endpointsInfo.endpointTypes,
+    agentsAmount: endpointsInfo.agentsAmount,
+    hashedLgcKey: endpointsInfo.hashedKey
+  };
+}
+__name(getRuntimeInstanceTelemetryInfo, "getRuntimeInstanceTelemetryInfo");
+var telemetry_client_default = telemetryClient;
+
 // src/service-adapters/events.ts
 var RuntimeEventTypes;
 (function(RuntimeEventTypes2) {
@@ -2012,52 +2380,71 @@ var RuntimeEventSubject = class extends ReplaySubject2 {
   constructor() {
     super();
   }
-  sendTextMessageStart(messageId) {
+  sendTextMessageStart({ messageId }) {
     this.next({
       type: "TextMessageStart",
       messageId
     });
   }
-  sendTextMessageContent(content) {
+  sendTextMessageContent({ messageId, content }) {
     this.next({
       type: "TextMessageContent",
-      content
+      content,
+      messageId
     });
   }
-  sendTextMessageEnd() {
+  sendTextMessageEnd({ messageId }) {
     this.next({
-      type: "TextMessageEnd"
+      type: "TextMessageEnd",
+      messageId
     });
   }
   sendTextMessage(messageId, content) {
-    this.sendTextMessageStart(messageId);
-    this.sendTextMessageContent(content);
-    this.sendTextMessageEnd();
+    this.sendTextMessageStart({
+      messageId
+    });
+    this.sendTextMessageContent({
+      messageId,
+      content
+    });
+    this.sendTextMessageEnd({
+      messageId
+    });
   }
-  sendActionExecutionStart(actionExecutionId, actionName) {
+  sendActionExecutionStart({ actionExecutionId, actionName }) {
     this.next({
       type: "ActionExecutionStart",
       actionExecutionId,
       actionName
     });
   }
-  sendActionExecutionArgs(args) {
+  sendActionExecutionArgs({ actionExecutionId, args }) {
     this.next({
       type: "ActionExecutionArgs",
-      args
+      args,
+      actionExecutionId
     });
   }
-  sendActionExecutionEnd() {
+  sendActionExecutionEnd({ actionExecutionId }) {
     this.next({
-      type: "ActionExecutionEnd"
+      type: "ActionExecutionEnd",
+      actionExecutionId
     });
   }
-  sendActionExecution(actionExecutionId, toolName, args) {
-    this.sendActionExecutionStart(actionExecutionId, toolName);
-    this.sendActionExecutionArgs(args);
-    this.sendActionExecutionEnd();
+  sendActionExecution({ actionExecutionId, actionName, args }) {
+    this.sendActionExecutionStart({
+      actionExecutionId,
+      actionName
+    });
+    this.sendActionExecutionArgs({
+      actionExecutionId,
+      args
+    });
+    this.sendActionExecutionEnd({
+      actionExecutionId
+    });
   }
-  sendActionExecutionResult(actionExecutionId, actionName, result) {
+  sendActionExecutionResult({ actionExecutionId, actionName, result }) {
     this.next({
       type: "ActionExecutionResult",
       actionName,
@@ -2065,7 +2452,7 @@ var RuntimeEventSubject = class extends ReplaySubject2 {
       result
     });
   }
-  sendAgentStateMessage(threadId, agentName, nodeName, runId, active, role, state, running) {
+  sendAgentStateMessage({ threadId, agentName, nodeName, runId, active, role, state, running }) {
     this.next({
       type: "AgentStateMessage",
       threadId,
@@ -2086,9 +2473,20 @@ var RuntimeEventSource = class {
   async stream(callback) {
     this.callback = callback;
   }
+  sendErrorMessageToChat() {
+    const errorMessage = "\u274C An error occurred. Please try again.";
+    if (!this.callback) {
+      this.stream(async (eventStream$) => {
+        eventStream$.sendTextMessage(randomId3(), errorMessage);
+      });
+    } else {
+      this.eventStream$.sendTextMessage(randomId3(), errorMessage);
+    }
+  }
   processRuntimeEvents({ serverSideActions, guardrailsResult$, actionInputsWithoutAgents }) {
     this.callback(this.eventStream$).catch((error) => {
       console.error("Error in event source callback", error);
+      this.sendErrorMessageToChat();
     });
     return this.eventStream$.pipe(
       // mark tools for server side execution
@@ -2160,12 +2558,16 @@ async function executeAction(eventStream$, guardrailsResult$, action, actionArgu
     }
   }
   if (isLangGraphAgentAction(action)) {
-    eventStream$.sendActionExecutionResult(actionExecutionId, action.name, `${action.name} agent started`);
+    eventStream$.sendActionExecutionResult({
+      actionExecutionId,
+      actionName: action.name,
+      result: `${action.name} agent started`
+    });
     const stream = await action.langGraphAgentHandler({
       name: action.name,
       actionInputsWithoutAgents
     });
-    from(stream).subscribe({
+    from2(stream).subscribe({
       next: (event) => eventStream$.next(event),
       error: (err) => console.error("Error in stream", err),
       complete: () => eventStream$.complete()
@@ -2186,9 +2588,9 @@ __name(executeAction, "executeAction");
 
 // src/graphql/resolvers/copilot.resolver.ts
 import { GraphQLJSONObject } from "graphql-scalars";
-import { plainToInstance } from "class-transformer";
+import { plainToInstance as plainToInstance2 } from "class-transformer";
 import { GraphQLError } from "graphql";
-import { randomId as randomId2 } from "@copilotkit/shared";
+import { randomId as randomId4 } from "@copilotkit/shared";
 function _ts_decorate12(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -2305,7 +2707,7 @@ var CopilotResolver = class {
       rejectOutputMessagesPromise = reject;
     });
     logger2.debug("Processing");
-    const { eventSource, threadId = randomId2(), runId, serverSideActions, actionInputsWithoutAgents } = await copilotRuntime.processRuntimeRequest({
+    const { eventSource, threadId = randomId4(), runId, serverSideActions, actionInputsWithoutAgents } = await copilotRuntime.processRuntimeRequest({
       serviceAdapter,
       messages: data.messages,
       actions: data.frontend.actions,
@@ -2349,8 +2751,8 @@ var CopilotResolver = class {
                   reason: `Interrupted due to Guardrails validation failure. Reason: ${result.reason}`
                 });
                 outputMessages = [
-                  plainToInstance(TextMessage, {
-                    id: randomId2(),
+                  plainToInstance2(TextMessage, {
+                    id: randomId4(),
                     createdAt: /* @__PURE__ */ new Date(),
                     content: result.reason,
                     role: MessageRole.assistant
@@ -2398,7 +2800,9 @@ var CopilotResolver = class {
                   // skip until this message start event
                   skipWhile((e) => e !== event),
                   // take until the message end event
-                  takeWhile((e) => e.type != RuntimeEventTypes.TextMessageEnd)
+                  takeWhile((e) => !(e.type === RuntimeEventTypes.TextMessageEnd && e.messageId == event.messageId)),
+                  // filter out any other message events or message ids
+                  filter((e) => e.type == RuntimeEventTypes.TextMessageContent && e.messageId == event.messageId)
                 );
                 const streamingTextStatus = new Subject();
                 const messageId = event.messageId;
@@ -2416,7 +2820,7 @@ var CopilotResolver = class {
                         reason,
                         messageId: messageId2
                       }, "Text streaming interrupted");
-                      streamingTextStatus.next(plainToInstance(FailedMessageStatus, {
+                      streamingTextStatus.next(plainToInstance2(FailedMessageStatus, {
                         reason
                       }));
                       responseStatus$.next(new MessageStreamInterruptedResponse({
@@ -2449,7 +2853,7 @@ var CopilotResolver = class {
                         streamingTextStatus.next(new SuccessMessageStatus());
                         stopStreamingText();
                         textSubscription == null ? void 0 : textSubscription.unsubscribe();
-                        outputMessages.push(plainToInstance(TextMessage, {
+                        outputMessages.push(plainToInstance2(TextMessage, {
                           id: messageId,
                           createdAt: /* @__PURE__ */ new Date(),
                           content: textChunks.join(""),
@@ -2462,7 +2866,13 @@ var CopilotResolver = class {
                 break;
               case RuntimeEventTypes.ActionExecutionStart:
                 logger2.debug("Action execution start event received");
-                const actionExecutionArgumentStream = eventStream.pipe(skipWhile((e) => e !== event), takeWhile((e) => e.type != RuntimeEventTypes.ActionExecutionEnd));
+                const actionExecutionArgumentStream = eventStream.pipe(
+                  skipWhile((e) => e !== event),
+                  // take until the action execution end event
+                  takeWhile((e) => !(e.type === RuntimeEventTypes.ActionExecutionEnd && e.actionExecutionId == event.actionExecutionId)),
+                  // filter out any other action execution events or action execution ids
+                  filter((e) => e.type == RuntimeEventTypes.ActionExecutionArgs && e.actionExecutionId == event.actionExecutionId)
+                );
                 const streamingArgumentsStatus = new Subject();
                 pushMessage({
                   id: event.actionExecutionId,
@@ -2485,7 +2895,7 @@ var CopilotResolver = class {
                         logger2.error({
                           err
                         }, "Error in action execution argument stream");
-                        streamingArgumentsStatus.next(plainToInstance(FailedMessageStatus, {
+                        streamingArgumentsStatus.next(plainToInstance2(FailedMessageStatus, {
                           reason: "An unknown error has occurred in the action execution argument stream"
                         }));
                         stopStreamingArguments();
@@ -2496,7 +2906,7 @@ var CopilotResolver = class {
                         streamingArgumentsStatus.next(new SuccessMessageStatus());
                         stopStreamingArguments();
                         actionExecutionArgumentSubscription == null ? void 0 : actionExecutionArgumentSubscription.unsubscribe();
-                        outputMessages.push(plainToInstance(ActionExecutionMessage, {
+                        outputMessages.push(plainToInstance2(ActionExecutionMessage, {
                           id: event.actionExecutionId,
                           createdAt: /* @__PURE__ */ new Date(),
                           name: event.actionName,
@@ -2513,15 +2923,15 @@ var CopilotResolver = class {
                   result: event.result
                 }, "Action execution result event received");
                 pushMessage({
-                  id: randomId2(),
+                  id: randomId4(),
                   status: new SuccessMessageStatus(),
                   createdAt: /* @__PURE__ */ new Date(),
                   actionExecutionId: event.actionExecutionId,
                   actionName: event.actionName,
                   result: event.result
                 });
-                outputMessages.push(plainToInstance(ResultMessage, {
-                  id: randomId2(),
+                outputMessages.push(plainToInstance2(ResultMessage, {
+                  id: randomId4(),
                   createdAt: /* @__PURE__ */ new Date(),
                   actionExecutionId: event.actionExecutionId,
                   actionName: event.actionName,
@@ -2533,7 +2943,7 @@ var CopilotResolver = class {
                   event
                 }, "Agent message event received");
                 pushMessage({
-                  id: randomId2(),
+                  id: randomId4(),
                   status: new SuccessMessageStatus(),
                   threadId: event.threadId,
                   agentName: event.agentName,
@@ -2545,8 +2955,8 @@ var CopilotResolver = class {
                   role: MessageRole.assistant,
                   createdAt: /* @__PURE__ */ new Date()
                 });
-                outputMessages.push(plainToInstance(AgentStateMessage, {
-                  id: randomId2(),
+                outputMessages.push(plainToInstance2(AgentStateMessage, {
+                  id: randomId4(),
                   threadId: event.threadId,
                   agentName: event.agentName,
                   nodeName: event.nodeName,
@@ -2733,7 +3143,7 @@ function copilotRuntimeNodeHttpEndpoint(options) {
       _copilotkit: options.properties._copilotkit
     });
   }
-  telemetry_client_default.capture("oss.runtime.instance_created", {});
+  telemetry_client_default.capture("oss.runtime.instance_created", getRuntimeInstanceTelemetryInfo(options.runtime));
   const logger2 = commonConfig.logging;
   logger2.debug("Creating Node HTTP endpoint");
   const yoga = createYoga({
@@ -2745,14 +3155,16 @@ function copilotRuntimeNodeHttpEndpoint(options) {
 __name(copilotRuntimeNodeHttpEndpoint, "copilotRuntimeNodeHttpEndpoint");
 
 export {
+  getRuntimeInstanceTelemetryInfo,
   telemetry_client_default,
-  EndpointType,
-  isLangGraphAgentAction,
-  setupRemoteActions,
-  RuntimeEventSource,
+  CopilotRuntime,
+  flattenToolCallsNoDuplicates,
+  copilotKitEndpoint,
+  langGraphCloudEndpoint,
+  resolveEndpointType,
   createContext,
   buildSchema,
   getCommonConfig,
   copilotRuntimeNodeHttpEndpoint
 };
-//# sourceMappingURL=chunk-VBGS6IWV.mjs.map
+//# sourceMappingURL=chunk-YZ3VKKSM.mjs.map