@copilotkit/runtime 1.50.0-beta.1 → 1.50.0-beta.11

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

@@ -4,6 +4,8 @@ import { createCopilotEndpointSingleRoute } from "@copilotkitnext/runtime";
 import { IncomingMessage, ServerResponse } from "http";
 import { Readable } from "node:stream";
 
+type IncomingWithBody = IncomingMessage & { body?: unknown; complete?: boolean };
+
 export function readableStreamToNodeStream(webStream: ReadableStream): Readable {
   const reader = webStream.getReader();
 
@@ -24,7 +26,10 @@ export function readableStreamToNodeStream(webStream: ReadableStream): Readable
 }
 
 function getFullUrl(req: IncomingMessage): string {
-  const path = req.url || "/";
+  const expressPath =
+    (req as any).originalUrl ??
+    ((req as any).baseUrl ? `${(req as any).baseUrl}${req.url ?? ""}` : undefined);
+  const path = expressPath || req.url || "/";
   const host =
     (req.headers["x-forwarded-host"] as string) || (req.headers.host as string) || "localhost";
   const proto =
@@ -34,6 +39,61 @@ function getFullUrl(req: IncomingMessage): string {
   return `${proto}://${host}${path}`;
 }
 
+function toHeaders(rawHeaders: IncomingMessage["headers"]): Headers {
+  const headers = new Headers();
+
+  for (const [key, value] of Object.entries(rawHeaders)) {
+    if (value === undefined) continue;
+
+    if (Array.isArray(value)) {
+      value.forEach((entry) => headers.append(key, entry));
+      continue;
+    }
+
+    headers.append(key, value);
+  }
+
+  return headers;
+}
+
+function isStreamConsumed(req: IncomingWithBody): boolean {
+  const readableState = (req as any)._readableState;
+
+  return Boolean(
+    req.readableEnded || req.complete || readableState?.ended || readableState?.endEmitted,
+  );
+}
+
+function synthesizeBodyFromParsedBody(
+  parsedBody: unknown,
+  headers: Headers,
+): { body: BodyInit | null; contentType?: string } {
+  if (parsedBody === null || parsedBody === undefined) {
+    return { body: null };
+  }
+
+  if (parsedBody instanceof Buffer || parsedBody instanceof Uint8Array) {
+    return { body: parsedBody };
+  }
+
+  if (typeof parsedBody === "string") {
+    return { body: parsedBody, contentType: headers.get("content-type") ?? "text/plain" };
+  }
+
+  return {
+    body: JSON.stringify(parsedBody),
+    contentType: "application/json",
+  };
+}
+
+function isDisturbedOrLockedError(error: unknown): boolean {
+  return (
+    error instanceof TypeError &&
+    typeof error.message === "string" &&
+    (error.message.includes("disturbed") || error.message.includes("locked"))
+  );
+}
+
 export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServerOptions) {
   const commonConfig = getCommonConfig(options);
 
@@ -55,26 +115,87 @@ export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServ
   logger.debug("Creating Node HTTP endpoint");
 
   const serviceAdapter = options.serviceAdapter;
-  options.runtime.handleServiceAdapter(serviceAdapter);
+  if (serviceAdapter) {
+    options.runtime.handleServiceAdapter(serviceAdapter);
+  }
 
   const honoApp = createCopilotEndpointSingleRoute({
     runtime: options.runtime.instance,
     basePath: options.baseUrl ?? options.endpoint,
   });
 
-  return async function handler(req: IncomingMessage, res: ServerResponse) {
+  return async function handler(req: IncomingWithBody, res: ServerResponse) {
     const url = getFullUrl(req);
     const hasBody = req.method !== "GET" && req.method !== "HEAD";
 
-    const request = new Request(url, {
-      method: req.method,
-      headers: req.headers as any,
-      body: hasBody ? (req as any) : undefined,
-      // Node/undici extension
-      duplex: hasBody ? "half" : undefined,
-    } as any);
+    const baseHeaders = toHeaders(req.headers);
+    const parsedBody = req.body;
+
+    const streamConsumed = isStreamConsumed(req) || parsedBody !== undefined;
+    const canStream = hasBody && !streamConsumed;
 
-    const response = await honoApp.fetch(request);
+    let requestBody: BodyInit | null | undefined = undefined;
+    let useDuplex = false;
+
+    if (hasBody && canStream) {
+      requestBody = req as unknown as BodyInit;
+      useDuplex = true;
+    }
+
+    if (hasBody && streamConsumed) {
+      if (parsedBody !== undefined) {
+        const synthesized = synthesizeBodyFromParsedBody(parsedBody, baseHeaders);
+        requestBody = synthesized.body ?? undefined;
+        baseHeaders.delete("content-length");
+
+        if (synthesized.contentType) {
+          baseHeaders.set("content-type", synthesized.contentType);
+        }
+
+        logger.debug("Request stream already consumed; using parsed req.body to rebuild request.");
+      } else {
+        logger.warn("Request stream consumed with no available body; sending empty payload.");
+        requestBody = undefined;
+      }
+    }
+
+    const buildRequest = (body: BodyInit | null | undefined, headers: Headers, duplex: boolean) =>
+      new Request(url, {
+        method: req.method,
+        headers,
+        body,
+        duplex: duplex ? "half" : undefined,
+      } as RequestInit);
+
+    let response: Response;
+    try {
+      response = await honoApp.fetch(buildRequest(requestBody, baseHeaders, useDuplex));
+    } catch (error) {
+      if (isDisturbedOrLockedError(error) && hasBody) {
+        logger.warn(
+          "Encountered disturbed/locked request body; rebuilding request using parsed body or empty payload.",
+        );
+
+        const fallbackHeaders = new Headers(baseHeaders);
+        let fallbackBody: BodyInit | null | undefined;
+
+        if (parsedBody !== undefined) {
+          const synthesized = synthesizeBodyFromParsedBody(parsedBody, fallbackHeaders);
+          fallbackBody = synthesized.body ?? undefined;
+          fallbackHeaders.delete("content-length");
+
+          if (synthesized.contentType) {
+            fallbackHeaders.set("content-type", synthesized.contentType);
+          }
+        } else {
+          fallbackBody = undefined;
+        }
+
+        response = await honoApp.fetch(buildRequest(fallbackBody, fallbackHeaders, false));
+      } else {
+        throw error;
+      }
+    }
 
     res.statusCode = response.status;
     response.headers.forEach((value, key) => {

package/src/lib/integrations/shared.ts

@@ -34,8 +34,8 @@ export type GraphQLContext = YogaInitialContext & {
 };
 
 export interface CreateCopilotRuntimeServerOptions {
-  runtime: CopilotRuntime;
-  serviceAdapter: CopilotServiceAdapter;
+  runtime: CopilotRuntime<any>;
+  serviceAdapter?: CopilotServiceAdapter;
   endpoint: string;
   baseUrl?: string;
   cloud?: CopilotCloudOptions;

package/src/lib/runtime/agent-integrations/{langgraph.agent.ts → langgraph/agent.ts}

@@ -1,16 +1,5 @@
-import {
-  RunAgentInput,
-  EventType,
-  CustomEvent,
-  TextMessageStartEvent,
-  TextMessageContentEvent,
-  TextMessageEndEvent,
-  ToolCallStartEvent,
-  ToolCallArgsEvent,
-  ToolCallEndEvent,
-} from "@ag-ui/client";
 import { map } from "rxjs";
-import { LangGraphEventTypes } from "../../../agents/langgraph/events";
+import { LangGraphEventTypes } from "../../../../agents/langgraph/events";
 import { RawEvent } from "@ag-ui/core";
 import {
   LangGraphAgent as AGUILangGraphAgent,
@@ -31,25 +20,11 @@ interface CopilotKitStateEnrichment {
   };
 }
 
-export interface PredictStateTool {
-  tool: string;
-  state_key: string;
-  tool_argument: string;
-}
-
-export type TextMessageEvents =
-  | TextMessageStartEvent
-  | TextMessageContentEvent
-  | TextMessageEndEvent;
+import { RunAgentInput, EventType, CustomEvent } from "@ag-ui/client";
 
-export type ToolCallEvents = ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent;
-
-export enum CustomEventNames {
-  CopilotKitManuallyEmitMessage = "copilotkit_manually_emit_message",
-  CopilotKitManuallyEmitToolCall = "copilotkit_manually_emit_tool_call",
-  CopilotKitManuallyEmitIntermediateState = "copilotkit_manually_emit_intermediate_state",
-  CopilotKitExit = "copilotkit_exit",
-}
+// Import and re-export from separate file to maintain API compatibility
+import { CustomEventNames, TextMessageEvents, ToolCallEvents, PredictStateTool } from "./consts";
+export { CustomEventNames };
 
 export class LangGraphAgent extends AGUILangGraphAgent {
   constructor(config: LangGraphAgentConfig) {

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

@@ -0,0 +1,34 @@
+/**
+ * Constants for LangGraph integration.
+ * This file is separate from langgraph.agent.ts to avoid pulling in @ag-ui/langgraph
+ * when only these constants are needed.
+ */
+
+import {
+  TextMessageStartEvent,
+  TextMessageContentEvent,
+  TextMessageEndEvent,
+  ToolCallStartEvent,
+  ToolCallArgsEvent,
+  ToolCallEndEvent,
+} from "@ag-ui/client";
+
+export type TextMessageEvents =
+  | TextMessageStartEvent
+  | TextMessageContentEvent
+  | TextMessageEndEvent;
+
+export type ToolCallEvents = ToolCallStartEvent | ToolCallArgsEvent | ToolCallEndEvent;
+
+export enum CustomEventNames {
+  CopilotKitManuallyEmitMessage = "copilotkit_manually_emit_message",
+  CopilotKitManuallyEmitToolCall = "copilotkit_manually_emit_tool_call",
+  CopilotKitManuallyEmitIntermediateState = "copilotkit_manually_emit_intermediate_state",
+  CopilotKitExit = "copilotkit_exit",
+}
+
+export interface PredictStateTool {
+  tool: string;
+  state_key: string;
+  tool_argument: string;
+}

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

@@ -0,0 +1,2 @@
+export * from "./consts";
+export * from "./agent";

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

@@ -13,65 +13,50 @@
  */
 
 import {
-  Action,
-  CopilotErrorHandler,
+  type Action,
+  type CopilotErrorHandler,
   CopilotKitMisuseError,
-  MaybePromise,
-  NonEmptyRecord,
-  Parameter,
+  type MaybePromise,
+  type NonEmptyRecord,
+  type Parameter,
   readBody,
   getZodParameters,
-  PartialBy,
+  type PartialBy,
+  isTelemetryDisabled,
 } from "@copilotkit/shared";
-import { type RunAgentInput } from "@ag-ui/core";
+import type { RunAgentInput } from "@ag-ui/core";
 import { aguiToGQL } from "../../graphql/message-conversion/agui-to-gql";
-import { CopilotServiceAdapter, RemoteChainParameters } from "../../service-adapters";
+import type { CopilotServiceAdapter, RemoteChainParameters } from "../../service-adapters";
 import {
   CopilotRuntime as CopilotRuntimeVNext,
-  CopilotRuntimeOptions,
-  CopilotRuntimeOptions as CopilotRuntimeOptionsVNext,
-  InMemoryAgentRunner as InMemoryAgentRunnerVNext,
+  type CopilotRuntimeOptions,
+  type CopilotRuntimeOptions as CopilotRuntimeOptionsVNext,
+  InMemoryAgentRunner,
 } from "@copilotkitnext/runtime";
+import { TelemetryAgentRunner } from "./telemetry-agent-runner";
+import telemetry from "../telemetry-client";
 
-import { MessageInput } from "../../graphql/inputs/message.input";
-import { ActionInput } from "../../graphql/inputs/action.input";
-import { RuntimeEventSource } from "../../service-adapters/events";
-import { Message } from "../../graphql/types/converted";
-import { ForwardedParametersInput } from "../../graphql/inputs/forwarded-parameters.input";
+import type { MessageInput } from "../../graphql/inputs/message.input";
+import type { Message } from "../../graphql/types/converted";
 
 import {
   EndpointType,
-  EndpointDefinition,
-  CopilotKitEndpoint,
-  LangGraphPlatformEndpoint,
+  type EndpointDefinition,
+  type CopilotKitEndpoint,
+  type LangGraphPlatformEndpoint,
 } from "./types";
 
-import { GraphQLContext } from "../integrations/shared";
-import { AgentSessionInput } from "../../graphql/inputs/agent-session.input";
-import { AgentStateInput } from "../../graphql/inputs/agent-state.input";
-import { Agent } from "../../graphql/types/agents-response.type";
-import { ExtensionsInput } from "../../graphql/inputs/extensions.input";
-import { ExtensionsResponse } from "../../graphql/types/extensions-response.type";
-import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
-import {
-  CopilotObservabilityConfig,
-  LLMRequestData,
-  LLMResponseData,
-  LLMErrorData,
-} from "../observability";
-import { AbstractAgent } from "@ag-ui/client";
+import type { CopilotObservabilityConfig, LLMRequestData, LLMResponseData } from "../observability";
+import type { AbstractAgent } from "@ag-ui/client";
 
 // +++ MCP Imports +++
 import {
-  MCPClient,
-  MCPEndpointConfig,
-  MCPTool,
+  type MCPClient,
+  type MCPEndpointConfig,
+  type MCPTool,
   extractParametersFromSchema,
-  convertMCPToolsToActions,
-  generateMcpToolInstructions,
 } from "./mcp-tools-utils";
-import { LangGraphAgent } from "./agent-integrations/langgraph.agent";
-import { BasicAgent, BasicAgentConfiguration } from "@copilotkitnext/agent";
+import { BasicAgent, type BasicAgentConfiguration } from "@copilotkitnext/agent";
 // Define the function type alias here or import if defined elsewhere
 type CreateMCPClientFunction = (config: MCPEndpointConfig) => Promise<MCPClient>;
 
@@ -312,8 +297,8 @@ interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []>
 /**
  * Central runtime object passed to all request handlers.
  */
-export class CopilotRuntime {
-  params?: CopilotRuntimeConstructorParams;
+export class CopilotRuntime<const T extends Parameter[] | [] = []> {
+  params?: CopilotRuntimeConstructorParams<T>;
   private observability?: CopilotObservabilityConfig;
   // Cache MCP tools per endpoint to avoid re-fetching repeatedly
   private mcpToolsCache: Map<string, BasicAgentConfiguration["tools"]> = new Map();
@@ -321,12 +306,24 @@ export class CopilotRuntime {
   private _instance: CopilotRuntimeVNext;
 
   constructor(
-    params?: CopilotRuntimeConstructorParams & PartialBy<CopilotRuntimeOptions, "agents">,
+    params?: CopilotRuntimeConstructorParams<T> & PartialBy<CopilotRuntimeOptions, "agents">,
   ) {
     const agents = params?.agents ?? {};
+    const endpointAgents = this.assignEndpointsToAgents(params?.remoteEndpoints ?? []);
+
+    // Determine the base runner (user-provided or default)
+    const baseRunner = params?.runner ?? new InMemoryAgentRunner();
+
+    // Wrap with TelemetryAgentRunner unless telemetry is disabled
+    // This ensures we always capture agent execution telemetry when enabled,
+    // even if the user provides their own custom runner
+    const runner = isTelemetryDisabled()
+      ? baseRunner
+      : new TelemetryAgentRunner({ runner: baseRunner });
+
     this.runtimeArgs = {
-      agents: { ...this.assignEndpointsToAgents(params?.remoteEndpoints ?? []), ...agents },
-      runner: params?.runner ?? new InMemoryAgentRunnerVNext(),
+      agents: { ...endpointAgents, ...agents },
+      runner,
       // TODO: add support for transcriptionService from CopilotRuntimeOptionsVNext once it is ready
       // transcriptionService: params?.transcriptionService,
 
@@ -345,28 +342,23 @@ export class CopilotRuntime {
     return this._instance;
   }
 
-  private assignEndpointsToAgents(endpoints: CopilotRuntimeConstructorParams["remoteEndpoints"]) {
-    return endpoints.reduce((acc, endpoint) => {
-      if (resolveEndpointType(endpoint) == EndpointType.LangGraphPlatform) {
-        let lgAgents = {};
-        const lgEndpoint = endpoint as LangGraphPlatformEndpoint;
-        lgEndpoint.agents.forEach((agent) => {
-          const graphId = agent.assistantId ?? agent.name;
-          lgAgents[graphId] = new LangGraphAgent({
-            deploymentUrl: lgEndpoint.deploymentUrl,
-            langsmithApiKey: lgEndpoint.langsmithApiKey,
-            graphId,
-          });
-        });
+  private assignEndpointsToAgents(
+    endpoints: CopilotRuntimeConstructorParams<T>["remoteEndpoints"],
+  ): Record<string, AbstractAgent> {
+    let result: Record<string, AbstractAgent> = {};
 
-        return {
-          ...acc,
-          ...lgAgents,
-        };
-      }
+    if (
+      endpoints.some((endpoint) => resolveEndpointType(endpoint) == EndpointType.LangGraphPlatform)
+    ) {
+      throw new CopilotKitMisuseError({
+        message:
+          "LangGraphPlatformEndpoint in remoteEndpoints is deprecated. " +
+          'Please use the "agents" option instead with LangGraphAgent from "@copilotkit/runtime/langgraph". ' +
+          'Example: agents: { myAgent: new LangGraphAgent({ deploymentUrl: "...", graphId: "..." }) }',
+      });
+    }
 
-      return acc;
-    }, {});
+    return result;
   }
 
   handleServiceAdapter(serviceAdapter: CopilotServiceAdapter) {
@@ -393,7 +385,7 @@ export class CopilotRuntime {
           });
         }
 
-        if (this.params.actions?.length) {
+        if (this.params.actions) {
           const mcpTools = await this.getToolsFromMCP();
           agentsList = this.assignToolsToAgents(agents, [
             ...this.getToolsFromActions(this.params.actions),
@@ -423,6 +415,7 @@ export class CopilotRuntime {
         name: action.name,
         description: action.description || "",
         parameters: zodSchema,
+        execute: () => Promise.resolve(),
       };
     });
   }
@@ -454,9 +447,33 @@ export class CopilotRuntime {
   }
 
   private createOnBeforeRequestHandler(
-    params?: CopilotRuntimeConstructorParams & PartialBy<CopilotRuntimeOptions, "agents">,
+    params?: CopilotRuntimeConstructorParams<T> & PartialBy<CopilotRuntimeOptions, "agents">,
   ) {
     return async (hookParams: BeforeRequestMiddlewareFnParameters[0]) => {
+      const { request } = hookParams;
+
+      // Capture telemetry for copilot request creation
+      const publicApiKey = request.headers.get("x-copilotcloud-public-api-key");
+      const body = (await readBody(request)) as RunAgentInput;
+      const forwardedProps = body.forwardedProps as
+        | {
+            cloud?: { guardrails?: unknown };
+            metadata?: { requestType?: string };
+          }
+        | undefined;
+
+      // Get cloud base URL from environment or default
+      const cloudBaseUrl =
+        process.env.COPILOT_CLOUD_BASE_URL || "https://api.cloud.copilotkit.ai";
+
+      telemetry.capture("oss.runtime.copilot_request_created", {
+        "cloud.guardrails.enabled": forwardedProps?.cloud?.guardrails !== undefined,
+        requestType: forwardedProps?.metadata?.requestType ?? "unknown",
+        "cloud.api_key_provided": !!publicApiKey,
+        ...(publicApiKey ? { "cloud.public_api_key": publicApiKey } : {}),
+        "cloud.base_url": cloudBaseUrl,
+      });
+
       // TODO: get public api key and run with expected data
       // if (this.observability?.enabled && this.params.publicApiKey) {
       //   this.logObservabilityBeforeRequest()
@@ -467,7 +484,6 @@ export class CopilotRuntime {
 
       if (params?.middleware?.onBeforeRequest) {
         const { request, runtime, path } = hookParams;
-        const body = (await readBody(request)) as RunAgentInput;
         const gqlMessages = (aguiToGQL(body.messages) as Message[]).reduce(
           (acc, msg) => {
             if ("role" in msg && msg.role === "user") {
@@ -492,7 +508,7 @@ export class CopilotRuntime {
   }
 
   private createOnAfterRequestHandler(
-    params?: CopilotRuntimeConstructorParams & PartialBy<CopilotRuntimeOptions, "agents">,
+    params?: CopilotRuntimeConstructorParams<T> & PartialBy<CopilotRuntimeOptions, "agents">,
   ) {
     return async (hookParams: AfterRequestMiddlewareFnParameters[0]) => {
       // TODO: get public api key and run with expected data
@@ -636,6 +652,7 @@ export class CopilotRuntime {
               name: toolName,
               description: tool.description || `MCP tool: ${toolName} (from ${endpointUrl})`,
               parameters: zodSchema,
+              execute: () => Promise.resolve(),
             };
           },
         );

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

@@ -0,0 +1,134 @@
+/**
+ * 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);
+  }
+}