@copilotkit/runtime 2.0.0-next.1 → 2.0.0-rc.0

package/src/service-adapters/conversion.ts

@@ -1,67 +0,0 @@
-import {
-  ActionExecutionMessage,
-  Message,
-  ResultMessage,
-  TextMessage,
-  AgentStateMessage,
-  ImageMessage,
-} from "../graphql/types/converted";
-import { MessageInput } from "../graphql/inputs/message.input";
-import { plainToInstance } from "class-transformer";
-import { tryMap } from "@copilotkit/shared";
-
-export function convertGqlInputToMessages(inputMessages: MessageInput[]): Message[] {
-  const messages = tryMap(inputMessages, (message) => {
-    if (message.textMessage) {
-      return plainToInstance(TextMessage, {
-        id: message.id,
-        createdAt: message.createdAt,
-        role: message.textMessage.role,
-        content: message.textMessage.content,
-        parentMessageId: message.textMessage.parentMessageId,
-      });
-    } else if (message.imageMessage) {
-      return plainToInstance(ImageMessage, {
-        id: message.id,
-        createdAt: message.createdAt,
-        role: message.imageMessage.role,
-        bytes: message.imageMessage.bytes,
-        format: message.imageMessage.format,
-        parentMessageId: message.imageMessage.parentMessageId,
-      });
-    } else if (message.actionExecutionMessage) {
-      return plainToInstance(ActionExecutionMessage, {
-        id: message.id,
-        createdAt: message.createdAt,
-        name: message.actionExecutionMessage.name,
-        arguments: JSON.parse(message.actionExecutionMessage.arguments),
-        parentMessageId: message.actionExecutionMessage.parentMessageId,
-      });
-    } else if (message.resultMessage) {
-      return plainToInstance(ResultMessage, {
-        id: message.id,
-        createdAt: message.createdAt,
-        actionExecutionId: message.resultMessage.actionExecutionId,
-        actionName: message.resultMessage.actionName,
-        result: message.resultMessage.result,
-      });
-    } else if (message.agentStateMessage) {
-      return plainToInstance(AgentStateMessage, {
-        id: message.id,
-        threadId: message.agentStateMessage.threadId,
-        createdAt: message.createdAt,
-        agentName: message.agentStateMessage.agentName,
-        nodeName: message.agentStateMessage.nodeName,
-        runId: message.agentStateMessage.runId,
-        active: message.agentStateMessage.active,
-        role: message.agentStateMessage.role,
-        state: JSON.parse(message.agentStateMessage.state),
-        running: message.agentStateMessage.running,
-      });
-    } else {
-      return null;
-    }
-  });
-
-  return messages.filter((m) => m);
-}

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

@@ -1,38 +0,0 @@
-/**
- * CopilotKit Empty Adapter
- *
- * This adapter is meant to preserve adherence to runtime requirements, while doing nothing
- * Ideal if you don't want to connect an LLM the to the runtime, and only use your LangGraph agent.
- * Be aware that Copilot Suggestions will not work if you use this adapter
- *
- * ## Example
- *
- * ```ts
- * import { CopilotRuntime, EmptyAdapter } from "@copilotkit/runtime";
- *
- * const copilotKit = new CopilotRuntime();
- *
- * return new EmptyAdapter();
- * ```
- */
-import {
-  CopilotServiceAdapter,
-  CopilotRuntimeChatCompletionRequest,
-  CopilotRuntimeChatCompletionResponse,
-} from "../service-adapter";
-import { randomUUID } from "@copilotkit/shared";
-
-export class EmptyAdapter implements CopilotServiceAdapter {
-  async process(
-    request: CopilotRuntimeChatCompletionRequest,
-  ): Promise<CopilotRuntimeChatCompletionResponse> {
-    return {
-      threadId: request.threadId || randomUUID(),
-    };
-  }
-  public get name() {
-    return "EmptyAdapter";
-  }
-}
-
-export const ExperimentalEmptyAdapter = EmptyAdapter;

package/src/service-adapters/events.ts

@@ -1,294 +0,0 @@
-import {
-  Action,
-  CopilotKitError,
-  CopilotKitErrorCode,
-  CopilotKitLowLevelError,
-  ensureStructuredError,
-  randomId,
-  Severity,
-} from "@copilotkit/shared";
-import { plainToInstance } from "class-transformer";
-import {
-  catchError,
-  concat,
-  concatMap,
-  EMPTY,
-  firstValueFrom,
-  from,
-  of,
-  ReplaySubject,
-  scan,
-  Subject,
-} from "rxjs";
-import { ActionInput } from "../graphql/inputs/action.input";
-import { ActionExecutionMessage, ResultMessage, TextMessage } from "../graphql/types/converted";
-import { GuardrailsResult } from "../graphql/types/guardrails-result.type";
-import { generateHelpfulErrorMessage } from "../lib/streaming";
-import telemetry from "../lib/telemetry-client";
-import { streamLangChainResponse } from "./langchain/utils";
-
-export enum RuntimeEventTypes {
-  TextMessageStart = "TextMessageStart",
-  TextMessageContent = "TextMessageContent",
-  TextMessageEnd = "TextMessageEnd",
-  ActionExecutionStart = "ActionExecutionStart",
-  ActionExecutionArgs = "ActionExecutionArgs",
-  ActionExecutionEnd = "ActionExecutionEnd",
-  ActionExecutionResult = "ActionExecutionResult",
-  AgentStateMessage = "AgentStateMessage",
-  MetaEvent = "MetaEvent",
-  RunError = "RunError",
-}
-
-export enum RuntimeMetaEventName {
-  LangGraphInterruptEvent = "LangGraphInterruptEvent",
-  LangGraphInterruptResumeEvent = "LangGraphInterruptResumeEvent",
-  CopilotKitLangGraphInterruptEvent = "CopilotKitLangGraphInterruptEvent",
-}
-
-export type RunTimeMetaEvent =
-  | {
-      type: RuntimeEventTypes.MetaEvent;
-      name: RuntimeMetaEventName.LangGraphInterruptEvent;
-      value: string;
-    }
-  | {
-      type: RuntimeEventTypes.MetaEvent;
-      name: RuntimeMetaEventName.CopilotKitLangGraphInterruptEvent;
-      data: { value: string; messages: (TextMessage | ActionExecutionMessage | ResultMessage)[] };
-    }
-  | {
-      type: RuntimeEventTypes.MetaEvent;
-      name: RuntimeMetaEventName.LangGraphInterruptResumeEvent;
-      data: string;
-    };
-
-export type RuntimeErrorEvent = {
-  type: RuntimeEventTypes.RunError;
-  message: string;
-  code?: string;
-};
-
-export type RuntimeEvent =
-  | { type: RuntimeEventTypes.TextMessageStart; messageId: string; parentMessageId?: string }
-  | {
-      type: RuntimeEventTypes.TextMessageContent;
-      messageId: string;
-      content: string;
-    }
-  | { type: RuntimeEventTypes.TextMessageEnd; messageId: string }
-  | {
-      type: RuntimeEventTypes.ActionExecutionStart;
-      actionExecutionId: string;
-      actionName: string;
-      parentMessageId?: string;
-    }
-  | { type: RuntimeEventTypes.ActionExecutionArgs; actionExecutionId: string; args: string }
-  | { type: RuntimeEventTypes.ActionExecutionEnd; actionExecutionId: string }
-  | {
-      type: RuntimeEventTypes.ActionExecutionResult;
-      actionName: string;
-      actionExecutionId: string;
-      result: string;
-    }
-  | {
-      type: RuntimeEventTypes.AgentStateMessage;
-      threadId: string;
-      agentName: string;
-      nodeName: string;
-      runId: string;
-      active: boolean;
-      role: string;
-      state: string;
-      running: boolean;
-    }
-  | RunTimeMetaEvent
-  | RuntimeErrorEvent;
-
-interface RuntimeEventWithState {
-  event: RuntimeEvent | null;
-  callActionServerSide: boolean;
-  action: Action<any> | null;
-  actionExecutionId: string | null;
-  args: string;
-  actionExecutionParentMessageId: string | null;
-}
-
-type EventSourceCallback = (eventStream$: RuntimeEventSubject) => Promise<void>;
-
-export class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
-  constructor() {
-    super();
-  }
-
-  sendTextMessageStart({
-    messageId,
-    parentMessageId,
-  }: {
-    messageId: string;
-    parentMessageId?: string;
-  }) {
-    this.next({ type: RuntimeEventTypes.TextMessageStart, messageId, parentMessageId });
-  }
-
-  sendTextMessageContent({ messageId, content }: { messageId: string; content: string }) {
-    this.next({ type: RuntimeEventTypes.TextMessageContent, content, messageId });
-  }
-
-  sendTextMessageEnd({ messageId }: { messageId: string }) {
-    this.next({ type: RuntimeEventTypes.TextMessageEnd, messageId });
-  }
-
-  sendTextMessage(messageId: string, content: string) {
-    this.sendTextMessageStart({ messageId });
-    this.sendTextMessageContent({ messageId, content });
-    this.sendTextMessageEnd({ messageId });
-  }
-
-  sendActionExecutionStart({
-    actionExecutionId,
-    actionName,
-    parentMessageId,
-  }: {
-    actionExecutionId: string;
-    actionName: string;
-    parentMessageId?: string;
-  }) {
-    this.next({
-      type: RuntimeEventTypes.ActionExecutionStart,
-      actionExecutionId,
-      actionName,
-      parentMessageId,
-    });
-  }
-
-  sendActionExecutionArgs({
-    actionExecutionId,
-    args,
-  }: {
-    actionExecutionId: string;
-    args: string;
-  }) {
-    this.next({ type: RuntimeEventTypes.ActionExecutionArgs, args, actionExecutionId });
-  }
-
-  sendActionExecutionEnd({ actionExecutionId }: { actionExecutionId: string }) {
-    this.next({ type: RuntimeEventTypes.ActionExecutionEnd, actionExecutionId });
-  }
-
-  sendActionExecution({
-    actionExecutionId,
-    actionName,
-    args,
-    parentMessageId,
-  }: {
-    actionExecutionId: string;
-    actionName: string;
-    args: string;
-    parentMessageId?: string;
-  }) {
-    this.sendActionExecutionStart({ actionExecutionId, actionName, parentMessageId });
-    this.sendActionExecutionArgs({ actionExecutionId, args });
-    this.sendActionExecutionEnd({ actionExecutionId });
-  }
-
-  sendActionExecutionResult({
-    actionExecutionId,
-    actionName,
-    result,
-    error,
-  }: {
-    actionExecutionId: string;
-    actionName: string;
-    result?: string;
-    error?: { code: string; message: string };
-  }) {
-    this.next({
-      type: RuntimeEventTypes.ActionExecutionResult,
-      actionName,
-      actionExecutionId,
-      result: ResultMessage.encodeResult(result, error),
-    });
-  }
-
-  sendAgentStateMessage({
-    threadId,
-    agentName,
-    nodeName,
-    runId,
-    active,
-    role,
-    state,
-    running,
-  }: {
-    threadId: string;
-    agentName: string;
-    nodeName: string;
-    runId: string;
-    active: boolean;
-    role: string;
-    state: string;
-    running: boolean;
-  }) {
-    this.next({
-      type: RuntimeEventTypes.AgentStateMessage,
-      threadId,
-      agentName,
-      nodeName,
-      runId,
-      active,
-      role,
-      state,
-      running,
-    });
-  }
-}
-
-export class RuntimeEventSource {
-  private eventStream$ = new RuntimeEventSubject();
-  private callback!: EventSourceCallback;
-  private errorHandler?: (error: any, context: any) => Promise<void>;
-  private errorContext?: any;
-
-  constructor(params?: {
-    errorHandler?: (error: any, context: any) => Promise<void>;
-    errorContext?: any;
-  }) {
-    this.errorHandler = params?.errorHandler;
-    this.errorContext = params?.errorContext;
-  }
-
-  async stream(callback: EventSourceCallback): Promise<void> {
-    this.callback = callback;
-  }
-}
-
-function convertStreamingErrorToStructured(error: any): CopilotKitError {
-  // Determine a more helpful error message based on context
-  let helpfulMessage = generateHelpfulErrorMessage(error, "event streaming connection");
-
-  // For network-related errors, use CopilotKitLowLevelError to preserve the original error
-  if (
-    error?.message?.includes("fetch failed") ||
-    error?.message?.includes("ECONNREFUSED") ||
-    error?.message?.includes("ENOTFOUND") ||
-    error?.message?.includes("ETIMEDOUT") ||
-    error?.message?.includes("terminated") ||
-    error?.cause?.code === "UND_ERR_SOCKET" ||
-    error?.message?.includes("other side closed") ||
-    error?.code === "UND_ERR_SOCKET"
-  ) {
-    return new CopilotKitLowLevelError({
-      error: error instanceof Error ? error : new Error(String(error)),
-      url: "event streaming connection",
-      message: helpfulMessage,
-    });
-  }
-
-  // For all other errors, preserve the raw error in a basic CopilotKitError
-  return new CopilotKitError({
-    message: helpfulMessage,
-    code: CopilotKitErrorCode.UNKNOWN,
-    severity: Severity.CRITICAL,
-  });
-}

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

@@ -1,84 +0,0 @@
-/**
- * CopilotKit Adapter for Ollama
- *
- * <RequestExample>
- * ```jsx CopilotRuntime Example
- * const copilotKit = new CopilotRuntime();
- * return copilotKit.response(req, new OllamaAdapter());
- * ```
- * </RequestExample>
- *
- * You can easily set the model to use by passing it to the constructor.
- * ```jsx
- * const copilotKit = new CopilotRuntime();
- * return copilotKit.response(
- *   req,
- *   new OllamaAdapter({ model: "llama3-70b-8192" }),
- * );
- * ```
- */
-import { TextMessage } from "../../../graphql/types/converted";
-import {
-  CopilotServiceAdapter,
-  CopilotRuntimeChatCompletionRequest,
-  CopilotRuntimeChatCompletionResponse,
-} from "../../service-adapter";
-import { randomId, randomUUID } from "@copilotkit/shared";
-
-const DEFAULT_MODEL = "llama3:latest";
-
-interface OllamaAdapterOptions {
-  model?: string;
-}
-
-export class ExperimentalOllamaAdapter implements CopilotServiceAdapter {
-  public model: string;
-  public provider = "ollama";
-  public get name() {
-    return "OllamaAdapter";
-  }
-
-  constructor(options?: OllamaAdapterOptions) {
-    if (options?.model) {
-      this.model = options.model;
-    } else {
-      this.model = DEFAULT_MODEL;
-    }
-  }
-
-  async process(
-    request: CopilotRuntimeChatCompletionRequest,
-  ): Promise<CopilotRuntimeChatCompletionResponse> {
-    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,
-    });
-    const contents = (messages.filter((m) => m.isTextMessage()) as TextMessage[]).map(
-      (m) => m.content,
-    );
-    const _stream = await ollama.stream(contents); // [TODO] role info is dropped...
-
-    eventSource.stream(async (eventStream$) => {
-      const currentMessageId = randomId();
-      eventStream$.sendTextMessageStart({ messageId: currentMessageId });
-      for await (const chunkText of _stream) {
-        eventStream$.sendTextMessageContent({
-          messageId: currentMessageId,
-          content: chunkText,
-        });
-      }
-      eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-      // we may need to add this later.. [nc]
-      // let calls = (await result.response).functionCalls();
-
-      eventStream$.complete();
-    });
-    return {
-      threadId: request.threadId || randomUUID(),
-    };
-  }
-}

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

@@ -1,104 +0,0 @@
-import { GoogleGenerativeAIAdapter } from "./google-genai-adapter";
-import { AIMessage, HumanMessage, SystemMessage } from "@langchain/core/messages";
-
-// Mock ChatGoogle to capture what messages are passed to it
-jest.mock("@langchain/google-gauth", () => ({
-  ChatGoogle: jest.fn().mockImplementation(() => ({
-    bindTools: jest.fn().mockReturnThis(),
-    stream: jest.fn().mockImplementation((messages) => {
-      // Return the messages so we can verify filtering
-      return Promise.resolve({ filteredMessages: messages });
-    }),
-  })),
-}));
-
-describe("GoogleGenerativeAIAdapter", () => {
-  it("should filter out empty AIMessages to prevent Gemini validation errors", async () => {
-    const adapter = new GoogleGenerativeAIAdapter();
-
-    // Create a mix of messages including an empty AIMessage (the problematic case)
-    const messages = [
-      new HumanMessage("Hello"),
-      new AIMessage(""), // This should be filtered out
-      new HumanMessage("How are you?"),
-      new AIMessage("I'm doing well!"), // This should be kept
-      new SystemMessage("You are a helpful assistant"), // This should be kept
-      new AIMessage(""), // Another empty one to filter out
-    ];
-
-    // Access the internal chainFn to test the filtering logic
-    const chainFnResult = await (adapter as any).options.chainFn({
-      messages,
-      tools: [],
-      threadId: "test-thread",
-    });
-
-    // The result should be filtered messages passed to ChatGoogle.stream()
-    const { filteredMessages } = chainFnResult;
-
-    // Should only contain non-empty messages
-    expect(filteredMessages).toHaveLength(4);
-    expect(filteredMessages[0]).toBeInstanceOf(HumanMessage);
-    expect(filteredMessages[0].content).toBe("Hello");
-    expect(filteredMessages[1]).toBeInstanceOf(HumanMessage);
-    expect(filteredMessages[1].content).toBe("How are you?");
-    expect(filteredMessages[2]).toBeInstanceOf(AIMessage);
-    expect(filteredMessages[2].content).toBe("I'm doing well!");
-    expect(filteredMessages[3]).toBeInstanceOf(SystemMessage);
-    expect(filteredMessages[3].content).toBe("You are a helpful assistant");
-  });
-
-  it("should keep AIMessages with tool_calls even if content is empty", async () => {
-    const adapter = new GoogleGenerativeAIAdapter();
-
-    const messagesWithToolCalls = [
-      new HumanMessage("Execute a function"),
-      new AIMessage({
-        content: "", // Empty content but has tool calls
-        tool_calls: [
-          {
-            id: "call_123",
-            name: "test_function",
-            args: { param: "value" },
-          },
-        ],
-      }),
-    ];
-
-    const chainFnResult = await (adapter as any).options.chainFn({
-      messages: messagesWithToolCalls,
-      tools: [],
-      threadId: "test-thread",
-    });
-
-    const { filteredMessages } = chainFnResult;
-
-    // Should keep both messages - the AIMessage has tool_calls so it's valid
-    expect(filteredMessages).toHaveLength(2);
-    expect(filteredMessages[1]).toBeInstanceOf(AIMessage);
-    expect(filteredMessages[1].tool_calls).toHaveLength(1);
-  });
-
-  it("should keep all non-AIMessage types regardless of content", async () => {
-    const adapter = new GoogleGenerativeAIAdapter();
-
-    const messages = [
-      new HumanMessage(""), // Empty human message should be kept
-      new SystemMessage(""), // Empty system message should be kept
-      new AIMessage(""), // Empty AI message should be filtered
-    ];
-
-    const chainFnResult = await (adapter as any).options.chainFn({
-      messages,
-      tools: [],
-      threadId: "test-thread",
-    });
-
-    const { filteredMessages } = chainFnResult;
-
-    // Should keep HumanMessage and SystemMessage, filter out empty AIMessage
-    expect(filteredMessages).toHaveLength(2);
-    expect(filteredMessages[0]).toBeInstanceOf(HumanMessage);
-    expect(filteredMessages[1]).toBeInstanceOf(SystemMessage);
-  });
-});

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

@@ -1,88 +0,0 @@
-/**
- * Copilot Runtime adapter for Google Generative AI (e.g. Gemini).
- *
- * ## Example
- *
- * ```ts
- * import { CopilotRuntime, GoogleGenerativeAIAdapter } from "@copilotkit/runtime";
- * const { GoogleGenerativeAI } = require("@google/generative-ai");
- *
- * const genAI = new GoogleGenerativeAI(process.env["GOOGLE_API_KEY"]);
- *
- * const copilotKit = new CopilotRuntime();
- *
- * return new GoogleGenerativeAIAdapter({ model: "gemini-2.5-flash", apiVersion: "v1" });
- * ```
- */
-import { LangChainAdapter } from "../langchain/langchain-adapter";
-
-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) => {
-          // Keep all non-AI messages (HumanMessage, SystemMessage, ToolMessage, etc.)
-          if (!(message instanceof AIMessage)) {
-            return true;
-          }
-
-          // 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 (
-            (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: this.model,
-          apiVersion: options?.apiVersion ?? DEFAULT_API_VERSION,
-        }).bindTools(tools);
-
-        return model.stream(filteredMessages, { metadata: { conversation_id: threadId } });
-      },
-    });
-  }
-}