@copilotkit/runtime 1.4.0-pre-1-4-0.11 → 1.4.0-pre-1-4-0-alpha.10

package/src/agents/langgraph/events.ts

@@ -8,6 +8,8 @@ export enum LangGraphEventTypes {
   OnToolStart = "on_tool_start",
   OnToolEnd = "on_tool_end",
   OnCopilotKitStateSync = "on_copilotkit_state_sync",
+  OnCopilotKitEmitMessage = "on_copilotkit_emit_message",
+  OnCopilotKitEmitToolCall = "on_copilotkit_emit_tool_call",
   OnCustomEvent = "on_custom_event",
 }
 

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

@@ -3,6 +3,7 @@ import {
   ReplaySubject,
   Subject,
   Subscription,
+  filter,
   finalize,
   firstValueFrom,
   shareReplay,
@@ -286,7 +287,19 @@ export class CopilotResolver {
                   // 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,
+                  ),
                 );
 
                 // signal when we are done streaming
@@ -367,7 +380,20 @@ export class CopilotResolver {
                 logger.debug("Action execution start event received");
                 const actionExecutionArgumentStream = eventStream.pipe(
                   skipWhile((e) => e !== event),
-                  takeWhile((e) => e.type != RuntimeEventTypes.ActionExecutionEnd),
+                  // 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<typeof MessageStatusUnion>();
                 pushMessage({

package/src/lib/integrations/nest/index.ts

@@ -1,6 +1,6 @@
 import { CreateCopilotRuntimeServerOptions } from "../shared";
 import { copilotRuntimeNodeHttpEndpoint } from "../node-http";
-import telemetry from "../../telemetry-client";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
 
 export function copilotRuntimeNestEndpoint(options: CreateCopilotRuntimeServerOptions) {
   telemetry.setGlobalProperties({
@@ -9,6 +9,9 @@ export function copilotRuntimeNestEndpoint(options: CreateCopilotRuntimeServerOp
     },
   });
 
-  telemetry.capture("oss.runtime.instance_created", {});
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
   return copilotRuntimeNodeHttpEndpoint(options);
 }

package/src/lib/integrations/nextjs/app-router.ts

@@ -1,6 +1,6 @@
 import { createYoga } from "graphql-yoga";
 import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
-import telemetry from "../../telemetry-client";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
 
 export function copilotRuntimeNextJSAppRouterEndpoint(options: CreateCopilotRuntimeServerOptions) {
   const commonConfig = getCommonConfig(options);
@@ -17,7 +17,10 @@ export function copilotRuntimeNextJSAppRouterEndpoint(options: CreateCopilotRunt
     });
   }
 
-  telemetry.capture("oss.runtime.instance_created", {});
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
 
   const logger = commonConfig.logging;
   logger.debug("Creating NextJS App Router endpoint");

package/src/lib/integrations/nextjs/pages-router.ts

@@ -1,6 +1,6 @@
 import { YogaServerInstance, createYoga } from "graphql-yoga";
 import { CreateCopilotRuntimeServerOptions, GraphQLContext, getCommonConfig } from "../shared";
-import telemetry from "../../telemetry-client";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
 
 export const config = {
   api: {
@@ -32,7 +32,10 @@ export function copilotRuntimeNextJSPagesRouterEndpoint(
     });
   }
 
-  telemetry.capture("oss.runtime.instance_created", {});
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
 
   const logger = commonConfig.logging;
   logger.debug("Creating NextJS Pages Router endpoint");

package/src/lib/integrations/node-express/index.ts

@@ -1,6 +1,6 @@
 import { CreateCopilotRuntimeServerOptions } from "../shared";
 import { copilotRuntimeNodeHttpEndpoint } from "../node-http";
-import telemetry from "../../telemetry-client";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
 
 export function copilotRuntimeNodeExpressEndpoint(options: CreateCopilotRuntimeServerOptions) {
   telemetry.setGlobalProperties({
@@ -9,6 +9,9 @@ export function copilotRuntimeNodeExpressEndpoint(options: CreateCopilotRuntimeS
     },
   });
 
-  telemetry.capture("oss.runtime.instance_created", {});
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
   return copilotRuntimeNodeHttpEndpoint(options);
 }

package/src/lib/integrations/node-http/index.ts

@@ -1,6 +1,6 @@
 import { createYoga } from "graphql-yoga";
 import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
-import telemetry from "../../telemetry-client";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
 
 export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServerOptions) {
   const commonConfig = getCommonConfig(options);
@@ -17,7 +17,10 @@ export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServ
     });
   }
 
-  telemetry.capture("oss.runtime.instance_created", {});
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
 
   const logger = commonConfig.logging;
   logger.debug("Creating Node HTTP endpoint");

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

@@ -12,7 +12,7 @@
  * ```
  */
 
-import { Action, actionParametersToJsonSchema, Parameter } from "@copilotkit/shared";
+import { Action, actionParametersToJsonSchema, Parameter, randomId } from "@copilotkit/shared";
 import { CopilotServiceAdapter, RemoteChain, RemoteChainParameters } from "../../service-adapters";
 import { MessageInput } from "../../graphql/inputs/message.input";
 import { ActionInput } from "../../graphql/inputs/action.input";
@@ -142,7 +142,7 @@ export interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []
 
 export class CopilotRuntime<const T extends Parameter[] | [] = []> {
   public actions: ActionsConfiguration<T>;
-  private remoteEndpointDefinitions: EndpointDefinition[];
+  public remoteEndpointDefinitions: EndpointDefinition[];
   private langserve: Promise<Action<any>>[] = [];
   private onBeforeRequest?: OnBeforeRequestHandler;
   private onAfterRequest?: OnAfterRequestHandler;
@@ -155,7 +155,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       this.langserve.push(remoteChain.toAction());
     }
 
-    this.remoteEndpointDefinitions = params?.remoteEndpoints || [];
+    this.remoteEndpointDefinitions = params?.remoteEndpoints ?? params?.remoteActions ?? [];
 
     this.onBeforeRequest = params?.middleware?.onBeforeRequest;
     this.onAfterRequest = params?.middleware?.onAfterRequest;
@@ -175,36 +175,36 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       url,
     } = request;
 
-    if (agentSession) {
-      return this.processAgentRequest(request);
-    }
+    const eventSource = new RuntimeEventSource();
 
-    const messages = rawMessages.filter((message) => !message.agentStateMessage);
+    try {
+      if (agentSession) {
+        return await this.processAgentRequest(request);
+      }
 
-    const inputMessages = convertGqlInputToMessages(messages);
-    const serverSideActions = await this.getServerSideActions(request);
+      const messages = rawMessages.filter((message) => !message.agentStateMessage);
 
-    const serverSideActionsInput: ActionInput[] = serverSideActions.map((action) => ({
-      name: action.name,
-      description: action.description,
-      jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters)),
-    }));
+      const inputMessages = convertGqlInputToMessages(messages);
+      const serverSideActions = await this.getServerSideActions(request);
 
-    const actionInputs = flattenToolCallsNoDuplicates([
-      ...serverSideActionsInput,
-      ...clientSideActionsInput,
-    ]);
+      const serverSideActionsInput: ActionInput[] = serverSideActions.map((action) => ({
+        name: action.name,
+        description: action.description,
+        jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters)),
+      }));
 
-    await this.onBeforeRequest?.({
-      threadId,
-      runId,
-      inputMessages,
-      properties: graphqlContext.properties,
-      url,
-    });
+      const actionInputs = flattenToolCallsNoDuplicates([
+        ...serverSideActionsInput,
+        ...clientSideActionsInput,
+      ]);
 
-    try {
-      const eventSource = new RuntimeEventSource();
+      await this.onBeforeRequest?.({
+        threadId,
+        runId,
+        inputMessages,
+        properties: graphqlContext.properties,
+        url,
+      });
 
       const result = await serviceAdapter.process({
         messages: inputMessages,
@@ -244,7 +244,14 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       };
     } catch (error) {
       console.error("Error getting response:", error);
-      throw error;
+      eventSource.sendErrorMessageToChat();
+      return {
+        threadId: threadId || randomId(),
+        runId: runId || randomId(),
+        eventSource,
+        serverSideActions: [],
+        actionInputsWithoutAgents: [],
+      };
     }
   }
 
@@ -344,7 +351,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       (endpoint) =>
         ({
           ...endpoint,
-          type: this.resolveEndpointType(endpoint),
+          type: resolveEndpointType(endpoint),
         }) as EndpointDefinition,
     );
 
@@ -363,19 +370,6 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
 
     return [...configuredActions, ...langserveFunctions, ...remoteActions];
   }
-
-  private resolveEndpointType(endpoint: EndpointDefinition) {
-    if (
-      !endpoint.type &&
-      "langsmithApiKey" in endpoint &&
-      "deploymentUrl" in endpoint &&
-      "agents" in endpoint
-    ) {
-      return EndpointType.LangGraphCloud;
-    }
-
-    return endpoint.type;
-  }
 }
 
 export function flattenToolCallsNoDuplicates(toolsByPriority: ActionInput[]): ActionInput[] {
@@ -406,3 +400,15 @@ export function langGraphCloudEndpoint(
     type: EndpointType.LangGraphCloud,
   };
 }
+
+export function resolveEndpointType(endpoint: EndpointDefinition) {
+  if (!endpoint.type) {
+    if ("langsmithApiKey" in endpoint && "deploymentUrl" in endpoint && "agents" in endpoint) {
+      return EndpointType.LangGraphCloud;
+    } else {
+      return EndpointType.CopilotKit;
+    }
+  }
+
+  return endpoint.type;
+}

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

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import {
   CopilotKitEndpoint,
   LangGraphAgentHandlerParams,
@@ -42,7 +43,12 @@ export function constructLGCRemoteAction({
     }: LangGraphAgentHandlerParams): Promise<Observable<RuntimeEvent>> => {
       logger.debug({ actionName: agent.name }, "Executing LangGraph Cloud agent");
 
-      telemetry.capture("oss.runtime.remote_action_executed", {});
+      telemetry.capture("oss.runtime.remote_action_executed", {
+        agentExecution: true,
+        type: "langgraph-cloud",
+        agentsAmount: endpoint.agents.length,
+        hashedLgcKey: createHash("sha256").update(endpoint.langsmithApiKey).digest("hex"),
+      });
 
       let state = {};
       if (agentStates) {
@@ -111,7 +117,11 @@ export function constructRemoteActions({
       logger.debug({ actionName: action.name, args }, "Executing remote action");
 
       const headers = createHeaders(onBeforeRequest, graphqlContext);
-      telemetry.capture("oss.runtime.remote_action_executed", {});
+      telemetry.capture("oss.runtime.remote_action_executed", {
+        agentExecution: false,
+        type: "self-hosted",
+        agentsAmount: json["agents"].length,
+      });
 
       try {
         const response = await fetch(`${url}/actions/execute`, {
@@ -162,7 +172,11 @@ export function constructRemoteActions({
       logger.debug({ actionName: agent.name }, "Executing remote agent");
 
       const headers = createHeaders(onBeforeRequest, graphqlContext);
-      telemetry.capture("oss.runtime.remote_action_executed", {});
+      telemetry.capture("oss.runtime.remote_action_executed", {
+        agentExecution: true,
+        type: "self-hosted",
+        agentsAmount: json["agents"].length,
+      });
 
       let state = {};
       if (agentStates) {

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

@@ -1,5 +1,5 @@
 import { Client } from "@langchain/langgraph-sdk";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { parse as parsePartialJson } from "partial-json";
 import { Logger } from "pino";
 import { ActionInput } from "../../graphql/inputs/action.input";
@@ -8,6 +8,7 @@ import { CopilotRequestContextProperties } from "../integrations";
 import { Message, MessageType } from "../../graphql/types/converted";
 import { MessageRole } from "../../graphql/types/enums";
 import { CustomEventNames, LangGraphEventTypes } from "../../agents/langgraph/events";
+import telemetry from "../telemetry-client";
 
 type State = Record<string, any>;
 
@@ -88,7 +89,6 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   let state = initialState;
   const { name, assistantId: initialAssistantId } = agent;
 
-  // TODO: deploymentUrl is not required in local development
   const client = new Client({ apiUrl: deploymentUrl, apiKey: langsmithApiKey });
   let initialThreadId = agrsInitialThreadId;
   const wasInitiatedWithExistingThread = !!initialThreadId;
@@ -152,8 +152,22 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
 
   let latestStateValues = {};
   let updatedState = state;
+  // If a manual emittance happens, it is the ultimate source of truth of state, unless a node has exited.
+  // Therefore, this value should either hold null, or the only edition of state that should be used.
+  let manuallyEmittedState = null;
+  let streamInfo: {
+    provider?: string;
+    langGraphHost?: string;
+    langGraphVersion?: string;
+    hashedLgcKey: string;
+  } = {
+    hashedLgcKey: createHash("sha256").update(langsmithApiKey).digest("hex"),
+  };
 
   try {
+    telemetry.capture("oss.runtime.agent_execution_stream_started", {
+      hashedLgcKey: streamInfo.hashedLgcKey,
+    });
     for await (const chunk of streamResponse) {
       if (!["events", "values", "error"].includes(chunk.event)) continue;
 
@@ -174,6 +188,16 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
       externalRunId = runId;
       const metadata = event.metadata;
 
+      if (event.data?.output?.model != null && event.data?.output?.model != "") {
+        streamInfo.provider = event.data?.output?.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 &&
@@ -184,33 +208,36 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
         eventType === LangGraphEventTypes.OnCustomEvent &&
         event.name === CustomEventNames.CopilotKitManuallyEmitIntermediateState;
 
+      const exitingNode =
+        nodeName === currentNodeName && eventType === LangGraphEventTypes.OnChainEnd;
+
+      // See manuallyEmittedState for explanation
+      if (exitingNode) {
+        manuallyEmittedState = null;
+      }
+
       // we only want to update the node name under certain conditions
       // since we don't need any internal node names to be sent to the frontend
       if (graphInfo["nodes"].some((node) => node.id === currentNodeName)) {
         nodeName = currentNodeName;
-
-        // only update state from values when entering or exiting a known node
-        if (
-          eventType === LangGraphEventTypes.OnChainStart ||
-          eventType === LangGraphEventTypes.OnChainEnd
-        ) {
-          updatedState = latestStateValues;
-        }
       }
 
+      updatedState = manuallyEmittedState ?? latestStateValues;
+
       if (!nodeName) {
         continue;
       }
 
       if (manuallyEmitIntermediateState) {
-        updatedState = event.data;
+        // See manuallyEmittedState for explanation
+        manuallyEmittedState = event.data;
         emit(
           getStateSyncEvent({
             threadId,
             runId,
             agentName: agent.name,
             nodeName,
-            state: updatedState,
+            state: manuallyEmittedState,
             running: true,
             active: true,
           }),
@@ -247,9 +274,6 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
         emitIntermediateStateUntilEnd = null;
       }
 
-      const exitingNode =
-        nodeName === currentNodeName && eventType === LangGraphEventTypes.OnChainEnd;
-
       if (
         JSON.stringify(updatedState) !== JSON.stringify(state) ||
         prevNodeName != nodeName ||
@@ -277,6 +301,8 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
     const isEndNode = state.next.length === 0;
     nodeName = Object.keys(state.metadata.writes)[0];
 
+    telemetry.capture("oss.runtime.agent_execution_stream_ended", streamInfo);
+
     emit(
       getStateSyncEvent({
         threadId,

package/src/lib/telemetry-client.ts

@@ -1,4 +1,8 @@
 import { TelemetryClient } from "@copilotkit/shared";
+import { EndpointType, LangGraphCloudEndpoint } from "./runtime/remote-actions";
+import { createHash } from "node:crypto";
+import { CopilotRuntime, resolveEndpointType } from "./runtime/copilot-runtime";
+import { RuntimeInstanceCreatedInfo } from "@copilotkit/shared/src/telemetry/events";
 const packageJson = require("../../package.json");
 
 const telemetryClient = new TelemetryClient({
@@ -6,4 +10,43 @@ const telemetryClient = new TelemetryClient({
   packageVersion: packageJson.version,
 });
 
+export function getRuntimeInstanceTelemetryInfo(
+  runtime: CopilotRuntime,
+): RuntimeInstanceCreatedInfo {
+  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) {
+        // When type is resolved, recreating a const with casting of type
+        const ep = endpoint as LangGraphCloudEndpoint;
+        info = {
+          ...info,
+          agentsAmount: ep.agents.length,
+          hashedKey: createHash("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,
+  };
+}
+
 export default telemetryClient;

package/src/service-adapters/anthropic/anthropic-adapter.ts

@@ -122,7 +122,10 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
             mode = "message";
           } else if (chunk.content_block.type === "tool_use") {
             currentToolCallId = chunk.content_block.id;
-            eventStream$.sendActionExecutionStart(currentToolCallId, chunk.content_block.name);
+            eventStream$.sendActionExecutionStart({
+              actionExecutionId: currentToolCallId,
+              actionName: chunk.content_block.name,
+            });
             mode = "function";
           }
         } else if (chunk.type === "content_block_delta") {
@@ -130,21 +133,27 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
             const text = filterThinkingTextBuffer.onTextChunk(chunk.delta.text);
             if (text.length > 0) {
               if (!didOutputText) {
-                eventStream$.sendTextMessageStart(currentMessageId);
+                eventStream$.sendTextMessageStart({ messageId: currentMessageId });
                 didOutputText = true;
               }
-              eventStream$.sendTextMessageContent(text);
+              eventStream$.sendTextMessageContent({
+                messageId: currentMessageId,
+                content: text,
+              });
             }
           } else if (chunk.delta.type === "input_json_delta") {
-            eventStream$.sendActionExecutionArgs(chunk.delta.partial_json);
+            eventStream$.sendActionExecutionArgs({
+              actionExecutionId: currentToolCallId,
+              args: chunk.delta.partial_json,
+            });
           }
         } else if (chunk.type === "content_block_stop") {
           if (mode === "message") {
             if (didOutputText) {
-              eventStream$.sendTextMessageEnd();
+              eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
             }
           } else if (mode === "function") {
-            eventStream$.sendActionExecutionEnd();
+            eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
           }
         }
       }