@copilotkit/runtime 1.57.3 → 1.58.0-canary.thread-id-propagation

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

@@ -1,187 +0,0 @@
-import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
-import telemetry, {
-  getRuntimeInstanceTelemetryInfo,
-} from "../../telemetry-client";
-import { createCopilotEndpointSingleRoute } from "../../../v2/runtime";
-import type { IncomingMessage, ServerResponse } from "node:http";
-import {
-  getFullUrl,
-  IncomingWithBody,
-  isDisturbedOrLockedError,
-  isStreamConsumed,
-  nodeStreamToReadableStream,
-  readableStreamToNodeStream,
-  synthesizeBodyFromParsedBody,
-  toHeaders,
-} from "./request-handler";
-
-export function copilotRuntimeNodeHttpEndpoint(
-  options: CreateCopilotRuntimeServerOptions,
-) {
-  const commonConfig = getCommonConfig(options);
-
-  telemetry.setGlobalProperties({
-    runtime: {
-      framework: "node-http",
-    },
-  });
-
-  if (options.properties?._copilotkit) {
-    telemetry.setGlobalProperties({
-      _copilotkit: options.properties._copilotkit,
-    });
-  }
-
-  telemetry.capture(
-    "oss.runtime.instance_created",
-    getRuntimeInstanceTelemetryInfo(options),
-  );
-
-  const logger = commonConfig.logging;
-  logger.debug("Creating Node HTTP endpoint");
-
-  const serviceAdapter = options.serviceAdapter;
-  if (serviceAdapter) {
-    options.runtime.handleServiceAdapter(serviceAdapter);
-  }
-
-  // Note: cors option requires @copilotkit/runtime with credentials support
-  const honoApp = createCopilotEndpointSingleRoute({
-    runtime: options.runtime.instance,
-    basePath: options.baseUrl ?? options.endpoint,
-    ...(options.cors && { cors: options.cors }),
-  } as any);
-
-  const handle = async function handler(
-    req: IncomingWithBody,
-    res: ServerResponse,
-  ) {
-    const url = getFullUrl(req);
-    const hasBody = req.method !== "GET" && req.method !== "HEAD";
-
-    const baseHeaders = toHeaders(req.headers);
-    const parsedBody = req.body;
-
-    const streamConsumed = isStreamConsumed(req) || parsedBody !== undefined;
-    const canStream = hasBody && !streamConsumed;
-
-    let requestBody: BodyInit | null | undefined = undefined;
-    let useDuplex = false;
-
-    if (hasBody && canStream) {
-      requestBody = nodeStreamToReadableStream(req);
-      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) => {
-      res.setHeader(key, value);
-    });
-
-    if (response.body) {
-      readableStreamToNodeStream(response.body).pipe(res);
-    } else {
-      res.end();
-    }
-  };
-
-  // Duck-type check for Request-like objects (handles polyfilled Request from @hono/node-server)
-  function isRequestLike(obj: unknown): obj is Request {
-    return (
-      obj instanceof Request ||
-      (typeof obj === "object" &&
-        obj !== null &&
-        "url" in obj &&
-        "method" in obj &&
-        "headers" in obj &&
-        typeof (obj as any).url === "string" &&
-        typeof (obj as any).method === "string")
-    );
-  }
-
-  return function (
-    reqOrRequest: IncomingMessage | Request,
-    res?: ServerResponse,
-  ): Promise<void> | Promise<Response> | Response {
-    if (isRequestLike(reqOrRequest) && !res) {
-      return honoApp.fetch(reqOrRequest as Request);
-    }
-    if (!res) {
-      throw new TypeError("ServerResponse is required for Node HTTP requests");
-    }
-    return handle(reqOrRequest as IncomingMessage, res);
-  };
-}

package/src/lib/integrations/node-http/request-handler.ts

@@ -1,128 +0,0 @@
-import type { IncomingMessage } from "http";
-import { Readable } from "node:stream";
-
-export type IncomingWithBody = IncomingMessage & {
-  body?: unknown;
-  complete?: boolean;
-};
-
-export function readableStreamToNodeStream(
-  webStream: ReadableStream,
-): Readable {
-  const reader = webStream.getReader();
-
-  return new Readable({
-    async read() {
-      try {
-        const { done, value } = await reader.read();
-        if (done) {
-          this.push(null);
-        } else {
-          this.push(Buffer.from(value));
-        }
-      } catch (err) {
-        this.destroy(err as Error);
-      }
-    },
-  });
-}
-
-export function nodeStreamToReadableStream(
-  nodeStream: Readable,
-): ReadableStream<Uint8Array> {
-  return new ReadableStream({
-    start(controller) {
-      nodeStream.on("data", (chunk) => {
-        controller.enqueue(
-          chunk instanceof Buffer ? new Uint8Array(chunk) : chunk,
-        );
-      });
-      nodeStream.on("end", () => {
-        controller.close();
-      });
-      nodeStream.on("error", (err) => {
-        controller.error(err);
-      });
-    },
-    cancel() {
-      nodeStream.destroy();
-    },
-  });
-}
-
-export function getFullUrl(req: IncomingMessage): string {
-  // Use req.url (path relative to mount point) for Hono routing to work correctly.
-  // Express sets req.url to the path after the mount point (e.g., "/" when mounted at "/copilotkit").
-  // Pure Node HTTP sets req.url to the full path.
-  const path = req.url || "/";
-  const host =
-    (req.headers["x-forwarded-host"] as string) ||
-    (req.headers.host as string) ||
-    "localhost";
-  const proto =
-    (req.headers["x-forwarded-proto"] as string) ||
-    ((req.socket as any).encrypted ? "https" : "http");
-
-  return `${proto}://${host}${path}`;
-}
-
-export 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;
-}
-
-export function isStreamConsumed(req: IncomingWithBody): boolean {
-  const readableState = (req as any)._readableState;
-
-  return Boolean(
-    req.readableEnded ||
-    req.complete ||
-    readableState?.ended ||
-    readableState?.endEmitted,
-  );
-}
-
-export 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",
-  };
-}
-
-export function isDisturbedOrLockedError(error: unknown): boolean {
-  return (
-    error instanceof TypeError &&
-    typeof error.message === "string" &&
-    (error.message.includes("disturbed") || error.message.includes("locked"))
-  );
-}

package/src/lib/integrations/shared.ts

@@ -1,112 +0,0 @@
-import { YogaInitialContext } from "graphql-yoga";
-import { buildSchemaSync } from "type-graphql";
-import { CopilotResolver } from "../../graphql/resolvers/copilot.resolver";
-import { CopilotRuntime } from "../runtime/copilot-runtime";
-import { CopilotServiceAdapter } from "../../service-adapters";
-import { CopilotCloudOptions } from "../cloud";
-import { LogLevel, createLogger } from "../../lib/logger";
-import telemetry from "../telemetry-client";
-import { StateResolver } from "../../graphql/resolvers/state.resolver";
-
-/**
- * CORS configuration for CopilotKit endpoints.
- */
-export interface CopilotEndpointCorsConfig {
-  /**
-   * Allowed origin(s). Can be a string, array of strings, or a function that returns the origin.
-   */
-  origin:
-    | string
-    | string[]
-    | ((origin: string, c: any) => string | undefined | null);
-  /**
-   * Whether to include credentials (cookies, authorization headers) in CORS requests.
-   * When true, origin cannot be "*" - must be an explicit origin.
-   */
-  credentials?: boolean;
-}
-
-const logger = createLogger();
-
-type AnyPrimitive = string | boolean | number | null;
-export type CopilotRequestContextProperties = Record<
-  string,
-  AnyPrimitive | Record<string, AnyPrimitive>
->;
-
-export type GraphQLContext = YogaInitialContext & {
-  _copilotkit: CreateCopilotRuntimeServerOptions;
-  properties: CopilotRequestContextProperties;
-  logger: typeof logger;
-};
-
-export interface CreateCopilotRuntimeServerOptions {
-  runtime: CopilotRuntime<any>;
-  serviceAdapter?: CopilotServiceAdapter;
-  endpoint: string;
-  baseUrl?: string;
-  cloud?: CopilotCloudOptions;
-  properties?: CopilotRequestContextProperties;
-  logLevel?: LogLevel;
-  /**
-   * Optional CORS configuration. When not provided, defaults to allowing all origins without credentials.
-   * To support HTTP-only cookies, provide cors config with credentials: true and explicit origin.
-   */
-  cors?: CopilotEndpointCorsConfig;
-}
-
-export function buildSchema(
-  options: {
-    emitSchemaFile?: string;
-  } = {},
-) {
-  logger.debug("Building GraphQL schema...");
-  const schema = buildSchemaSync({
-    resolvers: [CopilotResolver, StateResolver],
-    emitSchemaFile: options.emitSchemaFile,
-  });
-  logger.debug("GraphQL schema built successfully");
-  return schema;
-}
-
-export type CommonConfig = {
-  logging: typeof logger;
-};
-
-export function getCommonConfig(
-  options: CreateCopilotRuntimeServerOptions,
-): CommonConfig {
-  const logLevel =
-    (process.env.LOG_LEVEL as LogLevel) ||
-    (options.logLevel as LogLevel) ||
-    "error";
-  const logger = createLogger({
-    level: logLevel,
-    component: "getCommonConfig",
-  });
-
-  if (options.cloud) {
-    telemetry.setCloudConfiguration({
-      publicApiKey: options.cloud.publicApiKey,
-      baseUrl: options.cloud.baseUrl,
-    });
-  }
-
-  if (options.properties?._copilotkit) {
-    telemetry.setGlobalProperties({
-      _copilotkit: {
-        ...(options.properties._copilotkit as Record<string, any>),
-      },
-    });
-  }
-
-  telemetry.setGlobalProperties({
-    runtime: {
-      serviceAdapter: options.serviceAdapter?.constructor?.name ?? "none",
-    },
-  });
-
-  return {
-    logging: createLogger({ component: "CopilotKit Runtime", level: logLevel }),
-  };
-}

package/src/lib/logger.ts

@@ -1,31 +0,0 @@
-import createPinoLogger from "pino";
-import pretty from "pino-pretty";
-
-export type LogLevel = "debug" | "info" | "warn" | "error";
-
-export type CopilotRuntimeLogger = ReturnType<typeof createLogger>;
-
-export function createLogger(options?: {
-  level?: LogLevel;
-  component?: string;
-}) {
-  const { level, component } = options || {};
-  const stream = pretty({ colorize: true });
-
-  const logger = createPinoLogger(
-    {
-      level: process.env.LOG_LEVEL || level || "error",
-      redact: {
-        paths: ["pid", "hostname"],
-        remove: true,
-      },
-    },
-    stream,
-  );
-
-  if (component) {
-    return logger.child({ component });
-  } else {
-    return logger;
-  }
-}

package/src/lib/observability.ts

@@ -1,167 +0,0 @@
-import {
-  RuntimeEventSource,
-  RuntimeEventTypes,
-} from "../service-adapters/events";
-
-export interface LLMRequestData {
-  threadId?: string;
-  runId?: string;
-  model?: string;
-  messages: any[];
-  actions?: any[];
-  forwardedParameters?: any;
-  timestamp: number;
-  provider?: string;
-  [key: string]: any;
-}
-
-export interface LLMResponseData {
-  threadId: string;
-  runId?: string;
-  model?: string;
-  output: any;
-  latency: number;
-  timestamp: number;
-  provider?: string;
-  isProgressiveChunk?: boolean;
-  isFinalResponse?: boolean;
-  [key: string]: any;
-}
-
-export interface LLMErrorData {
-  threadId?: string;
-  runId?: string;
-  model?: string;
-  error: Error | string;
-  timestamp: number;
-  provider?: string;
-  [key: string]: any;
-}
-
-export interface CopilotObservabilityHooks {
-  handleRequest: (data: LLMRequestData) => void | Promise<void>;
-  handleResponse: (data: LLMResponseData) => void | Promise<void>;
-  handleError: (data: LLMErrorData) => void | Promise<void>;
-}
-
-/**
- * Configuration for CopilotKit logging functionality.
- *
- * @remarks
- * Custom logging handlers require a valid CopilotKit public API key.
- * Sign up at https://docs.copilotkit.ai/quickstart#get-a-copilot-cloud-public-api-key to get your key.
- */
-export interface CopilotObservabilityConfig {
-  /**
-   * Enable or disable logging functionality.
-   *
-   * @default false
-   */
-  enabled: boolean;
-
-  /**
-   * Controls whether logs are streamed progressively or buffered.
-   * - When true: Each token and update is logged as it's generated (real-time)
-   * - When false: Complete responses are logged after completion (batched)
-   *
-   * @default true
-   */
-  progressive: boolean;
-
-  /**
-   * Custom observability hooks for request, response, and error events.
-   *
-   * @remarks
-   * Using custom observability hooks requires a valid CopilotKit public API key.
-   */
-  hooks: CopilotObservabilityHooks;
-}
-
-/**
- * Setup progressive logging by wrapping the event stream
- */
-function setupProgressiveLogging(
-  eventSource: RuntimeEventSource,
-  streamedChunks: any[],
-  requestStartTime: number,
-  context: {
-    threadId?: string;
-    runId?: string;
-    model?: string;
-    provider?: string;
-    agentName?: string;
-    nodeName?: string;
-  },
-  publicApiKey?: string,
-): void {
-  if (
-    this.observability?.enabled &&
-    this.observability.progressive &&
-    publicApiKey
-  ) {
-    // Keep reference to original stream function
-    const originalStream = eventSource.stream.bind(eventSource);
-
-    // Wrap the stream function to intercept events
-    eventSource.stream = async (callback) => {
-      await originalStream(async (eventStream$) => {
-        // Create subscription to capture streaming events
-        eventStream$.subscribe({
-          next: (event) => {
-            // Only log content chunks
-            if (event.type === RuntimeEventTypes.TextMessageContent) {
-              // Store the chunk
-              streamedChunks.push(event.content);
-
-              // Log each chunk separately for progressive mode
-              try {
-                const progressiveData: LLMResponseData = {
-                  threadId: context.threadId || "",
-                  runId: context.runId,
-                  model: context.model,
-                  output: event.content,
-                  latency: Date.now() - requestStartTime,
-                  timestamp: Date.now(),
-                  provider: context.provider,
-                  isProgressiveChunk: true,
-                  agentName: context.agentName,
-                  nodeName: context.nodeName,
-                };
-
-                // Use Promise to handle async logger without awaiting
-                Promise.resolve()
-                  .then(() => {
-                    this.observability.hooks.handleResponse(progressiveData);
-                  })
-                  .catch((error) => {
-                    console.error("Error in progressive logging:", error);
-                  });
-              } catch (error) {
-                console.error("Error preparing progressive log data:", error);
-              }
-            }
-          },
-        });
-
-        // Call the original callback with the event stream
-        await callback(eventStream$);
-      });
-    };
-  }
-}
-
-/**
- * Log error if observability is enabled
- */
-async function logObservabilityError(
-  errorData: LLMErrorData,
-  publicApiKey?: string,
-): Promise<void> {
-  if (this.observability?.enabled && publicApiKey) {
-    try {
-      await this.observability.hooks.handleError(errorData);
-    } catch (logError) {
-      console.error("Error logging LLM error:", logError);
-    }
-  }
-}