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

package/src/graphql/message-conversion/roundtrip-conversion.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, vi } from "vitest";
+import { describe, test, expect } from "@jest/globals";
 import * as gql from "../types/converted/index";
 import agui from "@copilotkit/shared";
 import { aguiToGQL } from "./agui-to-gql";
@@ -131,7 +131,7 @@ describe("roundtrip message conversion", () => {
   });
 
   test("action execution with render function roundtrip", () => {
-    const mockRender = vi.fn();
+    const mockRender = jest.fn();
     const aguiMsg: agui.Message = {
       id: "assistant-1",
       role: "assistant",
@@ -211,7 +211,7 @@ describe("roundtrip message conversion", () => {
   });
 
   test("wild card action roundtrip conversion", () => {
-    const mockRender = vi.fn((props) => `Wildcard rendered: ${props.args.test}`);
+    const mockRender = jest.fn((props) => `Wildcard rendered: ${props.args.test}`);
     const aguiMsg: agui.Message = {
       id: "assistant-wildcard-1",
       role: "assistant",
@@ -256,7 +256,7 @@ describe("roundtrip message conversion", () => {
   });
 
   test("wild card action with specific action priority roundtrip", () => {
-    const mockRender = vi.fn((props) => `Specific action rendered: ${props.args.test}`);
+    const mockRender = jest.fn((props) => `Specific action rendered: ${props.args.test}`);
     const aguiMsg: agui.Message = {
       id: "assistant-priority-1",
       role: "assistant",
@@ -313,7 +313,7 @@ describe("roundtrip message conversion", () => {
     const actions: Record<string, any> = {
       "*": {
         name: "*",
-        render: vi.fn((props) => `GQL wildcard rendered: ${props.args.test}`),
+        render: jest.fn((props) => `GQL wildcard rendered: ${props.args.test}`),
       },
     };
 
@@ -379,7 +379,7 @@ describe("roundtrip message conversion", () => {
   });
 
   test("roundtrip conversion with action execution and result parsing", () => {
-    const mockRender = vi.fn((props) => `Rendered: ${JSON.stringify(props.result)}`);
+    const mockRender = jest.fn((props) => `Rendered: ${JSON.stringify(props.result)}`);
 
     // Create action execution message
     const actionExecMsg = new gql.ActionExecutionMessage({
@@ -439,7 +439,7 @@ describe("roundtrip message conversion", () => {
   });
 
   test("roundtrip conversion verifies correct property distribution for regular actions", () => {
-    const mockRender = vi.fn((props) => `Regular action: ${JSON.stringify(props.args)}`);
+    const mockRender = jest.fn((props) => `Regular action: ${JSON.stringify(props.args)}`);
 
     const actionExecMsg = new gql.ActionExecutionMessage({
       id: "regular-action-test",
@@ -481,7 +481,7 @@ describe("roundtrip message conversion", () => {
   });
 
   test("roundtrip conversion verifies correct property distribution for wildcard actions", () => {
-    const mockRender = vi.fn(
+    const mockRender = jest.fn(
       (props) => `Wildcard action: ${props.name} with ${JSON.stringify(props.args)}`,
     );
 

package/src/langgraph.ts

@@ -0,0 +1 @@
+export * from "./lib/runtime/agent-integrations/langgraph";

package/src/lib/index.ts

@@ -8,4 +8,44 @@ export * from "./integrations";
 export * from "./logger";
 export * from "./runtime/copilot-runtime";
 export * from "./runtime/mcp-tools-utils";
-export * from "./runtime/agent-integrations/langgraph.agent";
+
+// The below re-exports "dummy" classes and types, to get a deprecation warning redirecting the users to import these from the correct, new route
+
+/**
+ * @deprecated LangGraphAgent import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ */
+export class LangGraphAgent {
+  constructor() {
+    throw new Error(
+      "LangGraphAgent import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead",
+    );
+  }
+}
+
+/**
+ * @deprecated LangGraphHttpAgent import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ */
+export class LangGraphHttpAgent {
+  constructor() {
+    throw new Error(
+      "LangGraphHttpAgent import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead",
+    );
+  }
+}
+
+/**
+ * @deprecated TextMessageEvents import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ */
+export type TextMessageEvents = any;
+/**
+ * @deprecated ToolCallEvents import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ */
+export type ToolCallEvents = any;
+/**
+ * @deprecated CustomEventNames import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ */
+export type CustomEventNames = any;
+/**
+ * @deprecated PredictStateTool import from @copilotkit/runtime is deprecated. Please import it from @copilotkit/runtime/langgraph instead
+ */
+export type PredictStateTool = any;

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

@@ -24,7 +24,9 @@ export function copilotRuntimeNextJSAppRouterEndpoint(options: CreateCopilotRunt
   logger.debug("Creating NextJS App Router endpoint");
 
   const serviceAdapter = options.serviceAdapter;
-  options.runtime.handleServiceAdapter(serviceAdapter);
+  if (serviceAdapter) {
+    options.runtime.handleServiceAdapter(serviceAdapter);
+  }
 
   const copilotRoute = createCopilotEndpointSingleRoute({
     runtime: options.runtime.instance,

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

@@ -34,10 +34,7 @@ import {
 } from "@copilotkitnext/runtime";
 
 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 {
   EndpointType,
@@ -46,19 +43,7 @@ import {
   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 { CopilotObservabilityConfig, LLMRequestData, LLMResponseData } from "../observability";
 import { AbstractAgent } from "@ag-ui/client";
 
 // +++ MCP Imports +++
@@ -67,10 +52,7 @@ import {
   MCPEndpointConfig,
   MCPTool,
   extractParametersFromSchema,
-  convertMCPToolsToActions,
-  generateMcpToolInstructions,
 } from "./mcp-tools-utils";
-import { LangGraphAgent } from "./agent-integrations/langgraph.agent";
 import { BasicAgent, BasicAgentConfiguration } from "@copilotkitnext/agent";
 // Define the function type alias here or import if defined elsewhere
 type CreateMCPClientFunction = (config: MCPEndpointConfig) => Promise<MCPClient>;
@@ -312,8 +294,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,11 +303,13 @@ 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 ?? []);
+
     this.runtimeArgs = {
-      agents: { ...this.assignEndpointsToAgents(params?.remoteEndpoints ?? []), ...agents },
+      agents: { ...endpointAgents, ...agents },
       runner: params?.runner ?? new InMemoryAgentRunnerVNext(),
       // TODO: add support for transcriptionService from CopilotRuntimeOptionsVNext once it is ready
       // transcriptionService: params?.transcriptionService,
@@ -345,28 +329,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 +372,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),
@@ -454,7 +433,7 @@ export class CopilotRuntime {
   }
 
   private createOnBeforeRequestHandler(
-    params?: CopilotRuntimeConstructorParams & PartialBy<CopilotRuntimeOptions, "agents">,
+    params?: CopilotRuntimeConstructorParams<T> & PartialBy<CopilotRuntimeOptions, "agents">,
   ) {
     return async (hookParams: BeforeRequestMiddlewareFnParameters[0]) => {
       // TODO: get public api key and run with expected data
@@ -492,7 +471,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

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,
@@ -84,13 +84,25 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
   }
 
   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
    */
@@ -306,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 {
@@ -52,6 +51,10 @@ export class BedrockAdapter extends LangChainAdapter {
   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: this.model,

package/src/service-adapters/experimental/ollama/ollama-adapter.ts

@@ -23,7 +23,6 @@ import {
   CopilotRuntimeChatCompletionRequest,
   CopilotRuntimeChatCompletionResponse,
 } from "../../service-adapter";
-import { Ollama } from "@langchain/community/llms/ollama";
 import { randomId, randomUUID } from "@copilotkit/shared";
 
 const DEFAULT_MODEL = "llama3:latest";
@@ -53,6 +52,8 @@ export class ExperimentalOllamaAdapter implements CopilotServiceAdapter {
     const { messages, actions, eventSource } = request;
     // const messages = this.transformMessages(forwardedProps.messages);
 
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { Ollama } = require("@langchain/community/llms/ollama");
     const ollama = new Ollama({
       model: this.model,
     });

package/src/service-adapters/google/google-genai-adapter.ts

@@ -14,9 +14,7 @@
  * return new GoogleGenerativeAIAdapter({ model: "gemini-1.5-pro" });
  * ```
  */
-import { ChatGoogle } from "@langchain/google-gauth";
 import { LangChainAdapter } from "../langchain/langchain-adapter";
-import { AIMessage } from "@langchain/core/messages";
 
 interface GoogleGenerativeAIAdapterOptions {
   /**
@@ -38,6 +36,12 @@ export class GoogleGenerativeAIAdapter extends LangChainAdapter {
   constructor(options?: GoogleGenerativeAIAdapterOptions) {
     super({
       chainFn: async ({ messages, tools, threadId }) => {
+        // Lazy require for optional peer dependencies
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { ChatGoogle } = require("@langchain/google-gauth");
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { AIMessage } = require("@langchain/core/messages");
+
         // Filter out empty assistant messages to prevent Gemini validation errors
         // Gemini specifically rejects conversations containing AIMessages with empty content
         const filteredMessages = messages.filter((message) => {
@@ -48,9 +52,10 @@ export class GoogleGenerativeAIAdapter extends LangChainAdapter {
 
           // For AIMessages, only keep those with non-empty content
           // Also keep AIMessages with tool_calls even if content is empty
+          const aiMsg = message as any;
           return (
-            (message.content && String(message.content).trim().length > 0) ||
-            (message.tool_calls && message.tool_calls.length > 0)
+            (aiMsg.content && String(aiMsg.content).trim().length > 0) ||
+            (aiMsg.tool_calls && aiMsg.tool_calls.length > 0)
           );
         });