@copilotkit/runtime 0.0.0-0.0.0-max-changeset-10101010101010-20260109191632

package/src/service-adapters/conversion.ts

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,38 @@
+/**
+ * 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

@@ -0,0 +1,294 @@
+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

@@ -0,0 +1,84 @@
+/**
+ * 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

@@ -0,0 +1,104 @@
+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

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