@copilotkit/runtime 0.0.0-fix-debug-infosys-20251107151227 → 0.0.0-fix-restore-handle-method-node-http-20251222114321

package/src/lib/runtime/telemetry-agent-runner.ts

@@ -0,0 +1,139 @@
+/**
+ * TelemetryAgentRunner - A wrapper around AgentRunner that adds telemetry
+ * for agent execution streams.
+ *
+ * This captures the following telemetry events:
+ * - oss.runtime.agent_execution_stream_started - when an agent execution starts
+ * - oss.runtime.agent_execution_stream_ended - when an agent execution completes
+ * - oss.runtime.agent_execution_stream_errored - when an agent execution fails
+ */
+
+import { type AgentRunner, InMemoryAgentRunner } from "@copilotkitnext/runtime";
+import { createHash } from "node:crypto";
+import { tap, catchError, finalize } from "rxjs";
+import telemetry from "../telemetry-client";
+import type { AgentExecutionResponseInfo } from "@copilotkit/shared/src/telemetry/events";
+
+/**
+ * Configuration options for TelemetryAgentRunner
+ */
+export interface TelemetryAgentRunnerConfig {
+  /**
+   * The underlying runner to delegate to
+   * If not provided, defaults to InMemoryAgentRunner
+   */
+  runner?: AgentRunner;
+
+  /**
+   * Optional LangSmith API key (will be hashed for telemetry)
+   */
+  langsmithApiKey?: string;
+}
+
+/**
+ * An AgentRunner wrapper that adds telemetry tracking for agent executions.
+ *
+ * Usage:
+ * ```ts
+ * const runtime = new CopilotRuntime({
+ *   runner: new TelemetryAgentRunner(),
+ *   // or with custom runner:
+ *   runner: new TelemetryAgentRunner({ runner: customRunner }),
+ * });
+ * ```
+ */
+export class TelemetryAgentRunner implements AgentRunner {
+  private readonly _runner: AgentRunner;
+  private readonly hashedLgcKey: string | undefined;
+
+  constructor(config?: TelemetryAgentRunnerConfig) {
+    this._runner = config?.runner ?? new InMemoryAgentRunner();
+    this.hashedLgcKey = config?.langsmithApiKey
+      ? createHash("sha256").update(config.langsmithApiKey).digest("hex")
+      : undefined;
+  }
+
+  /**
+   * Runs an agent with telemetry tracking.
+   * Wraps the underlying runner's Observable stream with telemetry events.
+   */
+  run(...args: Parameters<AgentRunner["run"]>): ReturnType<AgentRunner["run"]> {
+    const streamInfo: AgentExecutionResponseInfo = {
+      hashedLgcKey: this.hashedLgcKey,
+    };
+    let streamErrored = false;
+
+    // Capture stream started event
+    telemetry.capture("oss.runtime.agent_execution_stream_started", {
+      hashedLgcKey: this.hashedLgcKey,
+    });
+
+    // Delegate to the underlying runner and wrap with telemetry
+    return this._runner.run(...args).pipe(
+      // Extract metadata from events if available
+      tap((event) => {
+        // Try to extract provider/model info from raw events
+        const rawEvent = (
+          event as {
+            rawEvent?: { metadata?: Record<string, unknown>; data?: Record<string, unknown> };
+          }
+        ).rawEvent;
+        if (rawEvent?.data) {
+          const data = rawEvent.data as { output?: { model?: string } };
+          if (data?.output?.model) {
+            streamInfo.model = data.output.model;
+            streamInfo.provider = data.output.model;
+          }
+        }
+        if (rawEvent?.metadata) {
+          const metadata = rawEvent.metadata as {
+            langgraph_host?: string;
+            langgraph_version?: string;
+          };
+          if (metadata?.langgraph_host) {
+            streamInfo.langGraphHost = metadata.langgraph_host;
+          }
+          if (metadata?.langgraph_version) {
+            streamInfo.langGraphVersion = metadata.langgraph_version;
+          }
+        }
+      }),
+      catchError((error) => {
+        // Capture stream error event
+        streamErrored = true;
+        telemetry.capture("oss.runtime.agent_execution_stream_errored", {
+          ...streamInfo,
+          error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+      }),
+      finalize(() => {
+        // Capture stream ended event (only if not errored)
+        if (!streamErrored) {
+          telemetry.capture("oss.runtime.agent_execution_stream_ended", streamInfo);
+        }
+      }),
+    );
+  }
+
+  /**
+   * Delegates to the underlying runner's connect method
+   */
+  connect(...args: Parameters<AgentRunner["connect"]>): ReturnType<AgentRunner["connect"]> {
+    return this._runner.connect(...args);
+  }
+
+  /**
+   * Delegates to the underlying runner's isRunning method
+   */
+  isRunning(...args: Parameters<AgentRunner["isRunning"]>): ReturnType<AgentRunner["isRunning"]> {
+    return this._runner.isRunning(...args);
+  }
+
+  /**
+   * Delegates to the underlying runner's stop method
+   */
+  stop(...args: Parameters<AgentRunner["stop"]>): ReturnType<AgentRunner["stop"]> {
+    return this._runner.stop(...args);
+  }
+}

package/src/lib/runtime/types.ts

@@ -0,0 +1,49 @@
+import { GraphQLContext } from "../integrations";
+import { ActionInput } from "../../graphql/inputs/action.input";
+import { Message } from "../../graphql/types/converted";
+import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
+
+export interface BaseEndpointDefinition<TActionType extends EndpointType> {
+  type?: TActionType;
+}
+
+export interface CopilotKitEndpoint extends BaseEndpointDefinition<EndpointType.CopilotKit> {
+  url: string;
+  onBeforeRequest?: ({ ctx }: { ctx: GraphQLContext }) => {
+    headers?: Record<string, string> | undefined;
+  };
+}
+
+export interface LangGraphPlatformAgent {
+  name: string;
+  description: string;
+  assistantId?: string;
+}
+
+export interface LangGraphPlatformEndpoint
+  extends BaseEndpointDefinition<EndpointType.LangGraphPlatform> {
+  deploymentUrl: string;
+  langsmithApiKey?: string | null;
+  agents: LangGraphPlatformAgent[];
+}
+
+export type RemoteActionInfoResponse = {
+  actions: any[];
+  agents: any[];
+};
+
+export type RemoteAgentHandlerParams = {
+  name: string;
+  actionInputsWithoutAgents: ActionInput[];
+  threadId?: string;
+  nodeName?: string;
+  additionalMessages?: Message[];
+  metaEvents?: MetaEventInput[];
+};
+
+export type EndpointDefinition = CopilotKitEndpoint | LangGraphPlatformEndpoint;
+
+export enum EndpointType {
+  CopilotKit = "copilotKit",
+  LangGraphPlatform = "langgraph-platform",
+}

package/src/lib/runtime/utils.ts

@@ -0,0 +1,87 @@
+import { GraphQLContext } from "../integrations";
+import { Logger } from "pino";
+import { CopilotKitEndpoint, RemoteActionInfoResponse } from "./types";
+import {
+  Action,
+  CopilotKitError,
+  CopilotKitLowLevelError,
+  ResolvedCopilotKitError,
+} from "@copilotkit/shared";
+
+async function fetchRemoteInfo({
+  url,
+  onBeforeRequest,
+  graphqlContext,
+  logger,
+  frontendUrl,
+}: {
+  url: string;
+  onBeforeRequest?: CopilotKitEndpoint["onBeforeRequest"];
+  graphqlContext: GraphQLContext;
+  logger: Logger;
+  frontendUrl?: string;
+}): Promise<RemoteActionInfoResponse> {
+  logger.debug({ url }, "Fetching actions from url");
+  const headers = createHeaders(onBeforeRequest, graphqlContext);
+
+  const fetchUrl = `${url}/info`;
+  try {
+    const response = await fetch(fetchUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ properties: graphqlContext.properties, frontendUrl }),
+    });
+
+    if (!response.ok) {
+      logger.error(
+        { url, status: response.status, body: await response.text() },
+        "Failed to fetch actions from url",
+      );
+      throw new ResolvedCopilotKitError({
+        status: response.status,
+        url: fetchUrl,
+        isRemoteEndpoint: true,
+      });
+    }
+
+    const json = await response.json();
+    logger.debug({ json }, "Fetched actions from url");
+    return json;
+  } catch (error) {
+    if (error instanceof CopilotKitError) {
+      throw error;
+    }
+    throw new CopilotKitLowLevelError({ error, url: fetchUrl });
+  }
+}
+
+// Utility to determine if an error is a user configuration issue vs system error
+export function isUserConfigurationError(error: any): boolean {
+  return (
+    (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) &&
+    (error.code === "NETWORK_ERROR" ||
+      error.code === "AUTHENTICATION_ERROR" ||
+      error.statusCode === 401 ||
+      error.statusCode === 403 ||
+      error.message?.toLowerCase().includes("authentication") ||
+      error.message?.toLowerCase().includes("api key"))
+  );
+}
+
+export function createHeaders(
+  onBeforeRequest: CopilotKitEndpoint["onBeforeRequest"],
+  graphqlContext: GraphQLContext,
+) {
+  const headers = {
+    "Content-Type": "application/json",
+  };
+
+  if (onBeforeRequest) {
+    const { headers: additionalHeaders } = onBeforeRequest({ ctx: graphqlContext });
+    if (additionalHeaders) {
+      Object.assign(headers, additionalHeaders);
+    }
+  }
+
+  return headers;
+}

package/src/lib/telemetry-client.ts

@@ -1,9 +1,9 @@
 import { TelemetryClient } from "@copilotkit/shared";
-import { EndpointType, LangGraphPlatformEndpoint } from "./runtime/remote-actions";
 import { createHash } from "node:crypto";
 import { CopilotRuntime, resolveEndpointType } from "./runtime/copilot-runtime";
 import { RuntimeInstanceCreatedInfo } from "@copilotkit/shared/src/telemetry/events";
 import { CreateCopilotRuntimeServerOptions } from "./integrations/shared";
+import { EndpointType, LangGraphPlatformEndpoint } from "./runtime/types";
 const packageJson = require("../../package.json");
 
 const telemetryClient = new TelemetryClient({
@@ -15,7 +15,8 @@ export function getRuntimeInstanceTelemetryInfo(
   options: CreateCopilotRuntimeServerOptions,
 ): RuntimeInstanceCreatedInfo {
   const runtime = options.runtime;
-  const endpointsInfo = runtime.remoteEndpointDefinitions.reduce(
+  const remoteEndpoints = runtime.params?.remoteEndpoints ?? [];
+  const endpointsInfo = remoteEndpoints.reduce(
     (acc, endpoint) => {
       let info = { ...acc };
 
@@ -49,10 +50,10 @@ export function getRuntimeInstanceTelemetryInfo(
   const apiKeyProvided = !!publicApiKey && publicApiKey.trim().length > 0;
 
   return {
-    actionsAmount: runtime.actions.length,
-    endpointsAmount: runtime.remoteEndpointDefinitions.length,
+    actionsAmount: runtime.params?.actions?.length ?? 0,
+    endpointsAmount: remoteEndpoints.length,
     endpointTypes: endpointsInfo.endpointTypes,
-    agentsAmount: endpointsInfo.agentsAmount,
+    agentsAmount: Object.keys(runtime.instance.agents).length,
     hashedLgcKey: endpointsInfo.hashedKey,
     "cloud.api_key_provided": apiKeyProvided,
     ...(apiKeyProvided ? { "cloud.public_api_key": publicApiKey } : {}),

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

@@ -22,7 +22,7 @@
  * });
  * ```
  */
-import Anthropic from "@anthropic-ai/sdk";
+import type Anthropic from "@anthropic-ai/sdk";
 import {
   CopilotServiceAdapter,
   CopilotRuntimeChatCompletionRequest,
@@ -71,22 +71,38 @@ export interface AnthropicAdapterParams {
 }
 
 export class AnthropicAdapter implements CopilotServiceAdapter {
-  private model: string = DEFAULT_MODEL;
+  public model: string = DEFAULT_MODEL;
+  public provider = "anthropic";
   private promptCaching: AnthropicPromptCachingConfig;
 
   private _anthropic: Anthropic;
   public get anthropic(): Anthropic {
     return this._anthropic;
   }
+  public get name() {
+    return "AnthropicAdapter";
+  }
 
   constructor(params?: AnthropicAdapterParams) {
-    this._anthropic = params?.anthropic || new Anthropic({});
+    if (params?.anthropic) {
+      this._anthropic = params.anthropic;
+    }
+    // If no instance provided, we'll lazy-load in ensureAnthropic()
     if (params?.model) {
       this.model = params.model;
     }
     this.promptCaching = params?.promptCaching || { enabled: false };
   }
 
+  private ensureAnthropic(): Anthropic {
+    if (!this._anthropic) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const Anthropic = require("@anthropic-ai/sdk").default;
+      this._anthropic = new Anthropic({});
+    }
+    return this._anthropic;
+  }
+
   /**
    * Adds cache control to system prompt
    */
@@ -302,7 +318,8 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
         stream: true,
       };
 
-      const stream = await this.anthropic.messages.create(createParams);
+      const anthropic = this.ensureAnthropic();
+      const stream = await anthropic.messages.create(createParams);
 
       eventSource.stream(async (eventStream$) => {
         let mode: "function" | "message" | null = null;

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

@@ -19,7 +19,6 @@
  * ```
  */
 
-import { ChatBedrockConverse } from "@langchain/aws";
 import { LangChainAdapter } from "../langchain/langchain-adapter";
 
 export interface BedrockAdapterParams {
@@ -44,12 +43,21 @@ export interface BedrockAdapterParams {
   };
 }
 
+const DEFAULT_MODEL = "amazon.nova-lite-v1:0";
+
 export class BedrockAdapter extends LangChainAdapter {
+  public provider = "bedrock";
+  public model: string = DEFAULT_MODEL;
   constructor(options?: BedrockAdapterParams) {
     super({
       chainFn: async ({ messages, tools, threadId }) => {
+        // Lazy require for optional peer dependency
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { ChatBedrockConverse } = require("@langchain/aws");
+
+        this.model = options?.model ?? "amazon.nova-lite-v1:0";
         const model = new ChatBedrockConverse({
-          model: options?.model ?? "amazon.nova-lite-v1:0",
+          model: this.model,
           region: options?.region ?? "us-east-1",
           credentials: options?.credentials
             ? {

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

@@ -30,6 +30,9 @@ export class EmptyAdapter implements CopilotServiceAdapter {
       threadId: request.threadId || randomUUID(),
     };
   }
+  public get name() {
+    return "EmptyAdapter";
+  }
 }
 
 export const ExperimentalEmptyAdapter = EmptyAdapter;

package/src/service-adapters/events.ts

@@ -23,7 +23,6 @@ import {
 import { ActionInput } from "../graphql/inputs/action.input";
 import { ActionExecutionMessage, ResultMessage, TextMessage } from "../graphql/types/converted";
 import { GuardrailsResult } from "../graphql/types/guardrails-result.type";
-import { isRemoteAgentAction } from "../lib/runtime/remote-actions";
 import { generateHelpfulErrorMessage } from "../lib/streaming";
 import telemetry from "../lib/telemetry-client";
 import { streamLangChainResponse } from "./langchain/utils";
@@ -262,259 +261,6 @@ export class RuntimeEventSource {
   async stream(callback: EventSourceCallback): Promise<void> {
     this.callback = callback;
   }
-
-  sendErrorMessageToChat(message = "An error occurred. Please try again.") {
-    const errorMessage = `❌ ${message}`;
-    if (!this.callback) {
-      this.stream(async (eventStream$) => {
-        eventStream$.sendTextMessage(randomId(), errorMessage);
-      });
-    } else {
-      this.eventStream$.sendTextMessage(randomId(), errorMessage);
-    }
-  }
-
-  processRuntimeEvents({
-    serverSideActions,
-    guardrailsResult$,
-    actionInputsWithoutAgents,
-    threadId,
-  }: {
-    serverSideActions: Action<any>[];
-    guardrailsResult$?: Subject<GuardrailsResult>;
-    actionInputsWithoutAgents: ActionInput[];
-    threadId: string;
-  }) {
-    this.callback(this.eventStream$).catch(async (error) => {
-      // Convert streaming errors to structured errors, but preserve already structured ones
-      const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
-
-      // Call the runtime error handler if provided
-      if (this.errorHandler && this.errorContext) {
-        try {
-          await this.errorHandler(structuredError, this.errorContext);
-        } catch (errorHandlerError) {
-          console.error("Error in streaming error handler:", errorHandlerError);
-        }
-      }
-
-      this.eventStream$.error(structuredError);
-      this.eventStream$.complete();
-    });
-    return this.eventStream$.pipe(
-      // track state
-      scan(
-        (acc, event) => {
-          // It seems like this is needed so that rxjs recognizes the object has changed
-          // This fixes an issue where action were executed multiple times
-          // Not investigating further for now (Markus)
-          acc = { ...acc };
-
-          if (event.type === RuntimeEventTypes.ActionExecutionStart) {
-            acc.callActionServerSide =
-              serverSideActions.find((action) => action.name === event.actionName) !== undefined;
-            acc.args = "";
-            acc.actionExecutionId = event.actionExecutionId;
-            if (acc.callActionServerSide) {
-              acc.action = serverSideActions.find((action) => action.name === event.actionName);
-            }
-            acc.actionExecutionParentMessageId = event.parentMessageId;
-          } else if (event.type === RuntimeEventTypes.ActionExecutionArgs) {
-            acc.args += event.args;
-          }
-
-          acc.event = event;
-
-          return acc;
-        },
-        {
-          event: null,
-          callActionServerSide: false,
-          args: "",
-          actionExecutionId: null,
-          action: null,
-          actionExecutionParentMessageId: null,
-        } as RuntimeEventWithState,
-      ),
-      concatMap((eventWithState) => {
-        if (
-          eventWithState.event!.type === RuntimeEventTypes.ActionExecutionEnd &&
-          eventWithState.callActionServerSide
-        ) {
-          const toolCallEventStream$ = new RuntimeEventSubject();
-          executeAction(
-            toolCallEventStream$,
-            guardrailsResult$ ? guardrailsResult$ : null,
-            eventWithState.action!,
-            eventWithState.args,
-            eventWithState.actionExecutionParentMessageId,
-            eventWithState.actionExecutionId,
-            actionInputsWithoutAgents,
-            threadId,
-          ).catch((error) => {});
-
-          telemetry.capture("oss.runtime.server_action_executed", {});
-          return concat(of(eventWithState.event!), toolCallEventStream$).pipe(
-            catchError((error) => {
-              // Convert streaming errors to structured errors and send as action result, but preserve already structured ones
-              const structuredError = ensureStructuredError(
-                error,
-                convertStreamingErrorToStructured,
-              );
-
-              // Call the runtime error handler if provided
-              if (this.errorHandler && this.errorContext) {
-                // Use from() to handle async error handler
-                from(
-                  this.errorHandler(structuredError, {
-                    ...this.errorContext,
-                    action: {
-                      name: eventWithState.action!.name,
-                      executionId: eventWithState.actionExecutionId,
-                    },
-                  }),
-                ).subscribe({
-                  error: (errorHandlerError) => {
-                    console.error("Error in action execution error handler:", errorHandlerError);
-                  },
-                });
-              }
-
-              toolCallEventStream$.sendActionExecutionResult({
-                actionExecutionId: eventWithState.actionExecutionId!,
-                actionName: eventWithState.action!.name,
-                error: {
-                  code: structuredError.code,
-                  message: structuredError.message,
-                },
-              });
-
-              return EMPTY;
-            }),
-          );
-        } else {
-          return of(eventWithState.event!);
-        }
-      }),
-    );
-  }
-}
-
-async function executeAction(
-  eventStream$: RuntimeEventSubject,
-  guardrailsResult$: Subject<GuardrailsResult> | null,
-  action: Action<any>,
-  actionArguments: string,
-  actionExecutionParentMessageId: string | null,
-  actionExecutionId: string,
-  actionInputsWithoutAgents: ActionInput[],
-  threadId: string,
-) {
-  if (guardrailsResult$) {
-    const { status } = await firstValueFrom(guardrailsResult$);
-
-    if (status === "denied") {
-      eventStream$.complete();
-      return;
-    }
-  }
-
-  // Prepare arguments for function calling
-  let args: Record<string, any>[] = [];
-  if (actionArguments) {
-    try {
-      args = JSON.parse(actionArguments);
-    } catch (e) {
-      console.error("Action argument unparsable", { actionArguments });
-      eventStream$.sendActionExecutionResult({
-        actionExecutionId,
-        actionName: action.name,
-        error: {
-          code: "INVALID_ARGUMENTS",
-          message: "Failed to parse action arguments",
-        },
-      });
-      return;
-    }
-  }
-
-  // handle LangGraph agents
-  if (isRemoteAgentAction(action)) {
-    const result = `${action.name} agent started`;
-
-    const agentExecution = plainToInstance(ActionExecutionMessage, {
-      id: actionExecutionId,
-      createdAt: new Date(),
-      name: action.name,
-      arguments: JSON.parse(actionArguments),
-      parentMessageId: actionExecutionParentMessageId ?? actionExecutionId,
-    });
-
-    const agentExecutionResult = plainToInstance(ResultMessage, {
-      id: "result-" + actionExecutionId,
-      createdAt: new Date(),
-      actionExecutionId,
-      actionName: action.name,
-      result,
-    });
-
-    eventStream$.sendActionExecutionResult({
-      actionExecutionId,
-      actionName: action.name,
-      result,
-    });
-
-    const stream = await action.remoteAgentHandler({
-      name: action.name,
-      threadId,
-      actionInputsWithoutAgents,
-      additionalMessages: [agentExecution, agentExecutionResult],
-    });
-
-    // forward to eventStream$
-    from(stream).subscribe({
-      next: (event) => eventStream$.next(event),
-      error: (err) => {
-        // Preserve already structured CopilotKit errors, only convert unstructured errors
-        const structuredError = ensureStructuredError(err, convertStreamingErrorToStructured);
-        eventStream$.sendActionExecutionResult({
-          actionExecutionId,
-          actionName: action.name,
-          error: {
-            code: structuredError.code,
-            message: structuredError.message,
-          },
-        });
-        eventStream$.complete();
-      },
-      complete: () => eventStream$.complete(),
-    });
-  } else {
-    // call the function
-    try {
-      const result = await action.handler?.(args);
-      await streamLangChainResponse({
-        result,
-        eventStream$,
-        actionExecution: {
-          name: action.name,
-          id: actionExecutionId,
-          returnDirect: action.additionalConfig?.returnDirect,
-        },
-      });
-    } catch (e) {
-      console.error("Error in action handler", e);
-      eventStream$.sendActionExecutionResult({
-        actionExecutionId,
-        actionName: action.name,
-        error: {
-          code: "HANDLER_ERROR",
-          message: e.message,
-        },
-      });
-      eventStream$.complete();
-    }
-  }
 }
 
 function convertStreamingErrorToStructured(error: any): CopilotKitError {