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

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";
@@ -33,7 +32,11 @@ interface OllamaAdapterOptions {
 }
 
 export class ExperimentalOllamaAdapter implements CopilotServiceAdapter {
-  private model: string;
+  public model: string;
+  public provider = "ollama";
+  public get name() {
+    return "OllamaAdapter";
+  }
 
   constructor(options?: OllamaAdapterOptions) {
     if (options?.model) {
@@ -49,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

@@ -11,28 +11,52 @@
  *
  * const copilotKit = new CopilotRuntime();
  *
- * return new GoogleGenerativeAIAdapter({ model: "gemini-1.5-pro" });
+ * return new GoogleGenerativeAIAdapter({ model: "gemini-2.5-flash", apiVersion: "v1" });
  * ```
  */
-import { ChatGoogle } from "@langchain/google-gauth";
 import { LangChainAdapter } from "../langchain/langchain-adapter";
-import { AIMessage } from "@langchain/core/messages";
 
 interface GoogleGenerativeAIAdapterOptions {
   /**
    * A custom Google Generative AI model to use.
    */
   model?: string;
+  /**
+   * The API version to use (e.g. "v1" or "v1beta"). Defaults to "v1".
+   */
+  apiVersion?: "v1" | "v1beta";
   /**
    * The API key to use.
    */
   apiKey?: string;
 }
 
+const DEFAULT_MODEL = "gemini-2.5-flash";
+const DEFAULT_API_VERSION: GoogleGenerativeAIAdapterOptions["apiVersion"] = "v1";
+let hasWarnedDefaultGoogleModel = false;
+
 export class GoogleGenerativeAIAdapter extends LangChainAdapter {
+  public provider = "google";
+  public model: string = DEFAULT_MODEL;
+
   constructor(options?: GoogleGenerativeAIAdapterOptions) {
+    if (!hasWarnedDefaultGoogleModel && !options?.model && !options?.apiVersion) {
+      console.warn(
+        `You are using the GoogleGenerativeAIAdapter without explicitly setting a model or apiVersion. ` +
+          `CopilotKit will default to apiVersion="v1" and model="${DEFAULT_MODEL}". ` +
+          `To silence this warning, pass model and apiVersion when constructing the adapter.`,
+      );
+      hasWarnedDefaultGoogleModel = true;
+    }
+
     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) => {
@@ -43,16 +67,18 @@ 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)
           );
         });
 
+        this.model = options?.model ?? DEFAULT_MODEL;
         const model = new ChatGoogle({
           apiKey: options?.apiKey ?? process.env.GOOGLE_API_KEY,
-          modelName: options?.model ?? "gemini-1.5-pro",
-          apiVersion: "v1beta",
+          modelName: this.model,
+          apiVersion: options?.apiVersion ?? DEFAULT_API_VERSION,
         }).bindTools(tools);
 
         return model.stream(filteredMessages, { metadata: { conversation_id: threadId } });

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

@@ -14,7 +14,7 @@
  * return new GroqAdapter({ groq, model: "<model-name>" });
  * ```
  */
-import { Groq } from "groq-sdk";
+import type { Groq } from "groq-sdk";
 import type { ChatCompletionMessageParam } from "groq-sdk/resources/chat";
 import {
   CopilotServiceAdapter,
@@ -54,22 +54,38 @@ export interface GroqAdapterParams {
 }
 
 export class GroqAdapter implements CopilotServiceAdapter {
-  private model: string = DEFAULT_MODEL;
+  public model: string = DEFAULT_MODEL;
+  public provider = "groq";
 
   private disableParallelToolCalls: boolean = false;
   private _groq: Groq;
   public get groq(): Groq {
     return this._groq;
   }
+  public get name() {
+    return "GroqAdapter";
+  }
 
   constructor(params?: GroqAdapterParams) {
-    this._groq = params?.groq || new Groq({});
+    if (params?.groq) {
+      this._groq = params.groq;
+    }
+    // If no instance provided, we'll lazy-load in ensureGroq()
     if (params?.model) {
       this.model = params.model;
     }
     this.disableParallelToolCalls = params?.disableParallelToolCalls || false;
   }
 
+  private ensureGroq(): Groq {
+    if (!this._groq) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const { Groq } = require("groq-sdk");
+      this._groq = new Groq({});
+    }
+    return this._groq;
+  }
+
   async process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
@@ -97,7 +113,8 @@ export class GroqAdapter implements CopilotServiceAdapter {
     }
     let stream;
     try {
-      stream = await this.groq.chat.completions.create({
+      const groq = this.ensureGroq();
+      stream = await groq.chat.completions.create({
         model: model,
         stream: true,
         messages: openaiMessages as unknown as ChatCompletionMessageParam[],

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

@@ -31,7 +31,7 @@
  * - A LangChain `AIMessage` object
  */
 
-import { BaseMessage } from "@langchain/core/messages";
+import type { BaseMessage } from "@langchain/core/messages";
 import { CopilotServiceAdapter } from "../service-adapter";
 import {
   CopilotRuntimeChatCompletionRequest,
@@ -42,10 +42,9 @@ import {
   convertMessageToLangChainMessage,
   streamLangChainResponse,
 } from "./utils";
-import { DynamicStructuredTool } from "@langchain/core/tools";
+import type { DynamicStructuredTool } from "@langchain/core/tools";
 import { LangChainReturnType } from "./types";
 import { randomUUID } from "@copilotkit/shared";
-import { awaitAllCallbacks } from "@langchain/core/callbacks/promises";
 
 interface ChainFnParameters {
   model: string;
@@ -66,6 +65,9 @@ export class LangChainAdapter implements CopilotServiceAdapter {
   /**
    * To use LangChain as a backend, provide a handler function to the adapter with your custom LangChain logic.
    */
+  public get name() {
+    return "LangChainAdapter";
+  }
   constructor(private options: LangChainAdapterOptions) {}
 
   async process(
@@ -100,6 +102,9 @@ export class LangChainAdapter implements CopilotServiceAdapter {
         threadId,
       };
     } finally {
+      // Lazy require for optional peer dependency
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const { awaitAllCallbacks } = require("@langchain/core/callbacks/promises");
       await awaitAllCallbacks();
     }
   }

package/src/service-adapters/langchain/langserve.ts

@@ -1,5 +1,4 @@
 import { Parameter, Action } from "@copilotkit/shared";
-import { RemoteRunnable } from "langchain/runnables/remote";
 
 export interface RemoteChainParameters {
   name: string;
@@ -34,6 +33,8 @@ export class RemoteChain {
       description: this.description,
       parameters: this.parameters!,
       handler: async (args: any) => {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { RemoteRunnable } = require("langchain/runnables/remote");
         const runnable = new RemoteRunnable({ url: this.chainUrl });
         let input: any;
         if (this.parameterType === "single") {

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

@@ -48,7 +48,7 @@
  * return new OpenAIAdapter({ openai });
  * ```
  */
-import OpenAI from "openai";
+import type OpenAI from "openai";
 import {
   CopilotServiceAdapter,
   CopilotRuntimeChatCompletionRequest,
@@ -96,7 +96,8 @@ export interface OpenAIAdapterParams {
 }
 
 export class OpenAIAdapter implements CopilotServiceAdapter {
-  private model: string = DEFAULT_MODEL;
+  public model: string = DEFAULT_MODEL;
+  public provider = "openai";
 
   private disableParallelToolCalls: boolean = false;
   private _openai: OpenAI;
@@ -105,9 +106,16 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
   public get openai(): OpenAI {
     return this._openai;
   }
+  public get name() {
+    return "OpenAIAdapter";
+  }
 
   constructor(params?: OpenAIAdapterParams) {
-    this._openai = params?.openai || new OpenAI({});
+    if (params?.openai) {
+      this._openai = params.openai;
+    }
+    // If no instance provided, we'll lazy-load in ensureOpenAI()
+
     if (params?.model) {
       this.model = params.model;
     }
@@ -115,6 +123,15 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     this.keepSystemRole = params?.keepSystemRole ?? false;
   }
 
+  private ensureOpenAI(): OpenAI {
+    if (!this._openai) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const OpenAI = require("openai").default;
+      this._openai = new OpenAI();
+    }
+    return this._openai;
+  }
+
   async process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
@@ -170,7 +187,8 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     }
 
     try {
-      const stream = this.openai.beta.chat.completions.stream({
+      const openai = this.ensureOpenAI();
+      const stream = openai.beta.chat.completions.stream({
         model: model,
         stream: true,
         messages: openaiMessages,

package/src/service-adapters/openai/openai-assistant-adapter.ts

@@ -22,7 +22,10 @@
  * });
  * ```
  */
-import OpenAI from "openai";
+import type OpenAI from "openai";
+import type { RunSubmitToolOutputsStreamParams } from "openai/resources/beta/threads/runs/runs";
+import type { AssistantStream } from "openai/lib/AssistantStream";
+import type { AssistantStreamEvent, AssistantTool } from "openai/resources/beta/assistants";
 import {
   CopilotServiceAdapter,
   CopilotRuntimeChatCompletionRequest,
@@ -34,11 +37,8 @@ import {
   convertMessageToOpenAIMessage,
   convertSystemMessageToAssistantAPI,
 } from "./utils";
-import { RunSubmitToolOutputsStreamParams } from "openai/resources/beta/threads/runs/runs";
-import { AssistantStream } from "openai/lib/AssistantStream";
 import { RuntimeEventSource } from "../events";
 import { ActionInput } from "../../graphql/inputs/action.input";
-import { AssistantStreamEvent, AssistantTool } from "openai/resources/beta/assistants";
 import { ForwardedParametersInput } from "../../graphql/inputs/forwarded-parameters.input";
 
 export interface OpenAIAssistantAdapterParams {
@@ -84,15 +84,22 @@ export interface OpenAIAssistantAdapterParams {
 }
 
 export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
-  private openai: OpenAI;
+  private _openai: OpenAI;
   private codeInterpreterEnabled: boolean;
   private assistantId: string;
   private fileSearchEnabled: boolean;
   private disableParallelToolCalls: boolean;
   private keepSystemRole: boolean = false;
 
+  public get name() {
+    return "OpenAIAssistantAdapter";
+  }
+
   constructor(params: OpenAIAssistantAdapterParams) {
-    this.openai = params.openai || new OpenAI({});
+    if (params.openai) {
+      this._openai = params.openai;
+    }
+    // If no instance provided, we'll lazy-load in ensureOpenAI()
     this.codeInterpreterEnabled = params.codeInterpreterEnabled === false || true;
     this.fileSearchEnabled = params.fileSearchEnabled === false || true;
     this.assistantId = params.assistantId;
@@ -100,6 +107,15 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
     this.keepSystemRole = params?.keepSystemRole ?? false;
   }
 
+  private ensureOpenAI(): OpenAI {
+    if (!this._openai) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const OpenAI = require("openai").default;
+      this._openai = new OpenAI({});
+    }
+    return this._openai;
+  }
+
   async process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
@@ -107,9 +123,10 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
 
     // if we don't have a threadId, create a new thread
     let threadId = request.extensions?.openaiAssistantAPI?.threadId;
+    const openai = this.ensureOpenAI();
 
     if (!threadId) {
-      threadId = (await this.openai.beta.threads.create()).id;
+      threadId = (await openai.beta.threads.create()).id;
     }
 
     const lastMessage = messages.at(-1);
@@ -154,7 +171,8 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
     messages: Message[],
     eventSource: RuntimeEventSource,
   ) {
-    let run = await this.openai.beta.threads.runs.retrieve(threadId, runId);
+    const openai = this.ensureOpenAI();
+    let run = await openai.beta.threads.runs.retrieve(threadId, runId);
 
     if (!run.required_action) {
       throw new Error("No tool outputs required");
@@ -184,7 +202,7 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
       },
     );
 
-    const stream = this.openai.beta.threads.runs.submitToolOutputsStream(threadId, runId, {
+    const stream = openai.beta.threads.runs.submitToolOutputsStream(threadId, runId, {
       tool_outputs: toolOutputs,
       ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
     });
@@ -200,6 +218,7 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
     eventSource: RuntimeEventSource,
     forwardedParameters: ForwardedParametersInput,
   ) {
+    const openai = this.ensureOpenAI();
     messages = [...messages];
 
     // get the instruction message
@@ -216,7 +235,7 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
       throw new Error("No user message found");
     }
 
-    await this.openai.beta.threads.messages.create(threadId, {
+    await openai.beta.threads.messages.create(threadId, {
       role: "user",
       content: userMessage.content,
     });
@@ -229,7 +248,7 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
       ...(this.fileSearchEnabled ? [{ type: "file_search" } as AssistantTool] : []),
     ];
 
-    let stream = this.openai.beta.threads.runs.stream(threadId, {
+    let stream = openai.beta.threads.runs.stream(threadId, {
       assistant_id: this.assistantId,
       instructions,
       tools: tools,

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

@@ -32,7 +32,10 @@ export interface CopilotRuntimeChatCompletionResponse {
 }
 
 export interface CopilotServiceAdapter {
+  provider?: string;
+  model?: string;
   process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse>;
+  name?: string;
 }

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

@@ -22,7 +22,6 @@ import {
   CopilotRuntimeChatCompletionResponse,
   CopilotServiceAdapter,
 } from "../service-adapter";
-import OpenAI from "openai";
 import { randomId, randomUUID } from "@copilotkit/shared";
 import { convertActionInputToOpenAITool, convertMessageToOpenAIMessage } from "../openai/utils";
 
@@ -33,8 +32,13 @@ export interface UnifyAdapterParams {
 
 export class UnifyAdapter implements CopilotServiceAdapter {
   private apiKey: string;
-  private model: string;
+  public model: string;
   private start: boolean;
+  public provider = "unify";
+
+  public get name() {
+    return "UnifyAdapter";
+  }
 
   constructor(options?: UnifyAdapterParams) {
     if (options?.apiKey) {
@@ -50,6 +54,9 @@ export class UnifyAdapter implements CopilotServiceAdapter {
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
     const tools = request.actions.map(convertActionInputToOpenAITool);
+    // Lazy require for optional peer dependency
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const OpenAI = require("openai").default;
     const openai = new OpenAI({
       apiKey: this.apiKey,
       baseURL: "https://api.unify.ai/v0/",

package/src/v2/index.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+export * from "@copilotkitnext/runtime";
+export * from "@copilotkitnext/agent";

package/tsup.config.ts

@@ -2,15 +2,19 @@ import { defineConfig, Options } from "tsup";
 
 export default defineConfig((options: Options) => ({
   ...options,
-  entry: ["src/**/index.ts"],
+  entry: ["src/index.ts", "src/v2/index.ts", "src/langgraph.ts"],
   format: ["esm", "cjs"],
   dts: true,
   minify: false,
-  external: [],
+  external: ["@ag-ui/langgraph"],
   sourcemap: true,
   exclude: [
     "**/*.test.ts", // Exclude TypeScript test files
     "**/*.test.tsx", // Exclude TypeScript React test files
     "**/__tests__/*", // Exclude any files inside a __tests__ directory
   ],
+  treeshake: true,
+  // Disable code splitting so each entry point is fully independent
+  // This prevents @ag-ui/langgraph from being pulled into index.mjs via shared chunks
+  splitting: false,
 }));