@copilotkit/runtime 0.0.0-mme-load-agent-state-20250117154700

package/src/service-adapters/events.ts

@@ -0,0 +1,424 @@
+import { Action, randomId } from "@copilotkit/shared";
+import {
+  of,
+  concat,
+  scan,
+  concatMap,
+  ReplaySubject,
+  Subject,
+  firstValueFrom,
+  from,
+  catchError,
+  EMPTY,
+} from "rxjs";
+import { streamLangChainResponse } from "./langchain/utils";
+import { GuardrailsResult } from "../graphql/types/guardrails-result.type";
+import telemetry from "../lib/telemetry-client";
+import { isLangGraphAgentAction } from "../lib/runtime/remote-actions";
+import { ActionInput } from "../graphql/inputs/action.input";
+import { ActionExecutionMessage, ResultMessage } from "../graphql/types/converted";
+import { plainToInstance } from "class-transformer";
+
+export enum RuntimeEventTypes {
+  TextMessageStart = "TextMessageStart",
+  TextMessageContent = "TextMessageContent",
+  TextMessageEnd = "TextMessageEnd",
+  ActionExecutionStart = "ActionExecutionStart",
+  ActionExecutionArgs = "ActionExecutionArgs",
+  ActionExecutionEnd = "ActionExecutionEnd",
+  ActionExecutionResult = "ActionExecutionResult",
+  AgentStateMessage = "AgentStateMessage",
+}
+
+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;
+    };
+
+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;
+
+  async stream(callback: EventSourceCallback): Promise<void> {
+    this.callback = callback;
+  }
+
+  sendErrorMessageToChat(message = "An error occurred. Please try again.") {
+    const errorMessage = `❌ ${message}`;
+    if (!this.callback) {
+      this.stream(async (eventStream$) => {
+        eventStream$.sendTextMessage(randomId(), errorMessage);
+      });
+    } else {
+      this.eventStream$.sendTextMessage(randomId(), errorMessage);
+    }
+  }
+
+  processRuntimeEvents({
+    serverSideActions,
+    guardrailsResult$,
+    actionInputsWithoutAgents,
+    threadId,
+  }: {
+    serverSideActions: Action<any>[];
+    guardrailsResult$?: Subject<GuardrailsResult>;
+    actionInputsWithoutAgents: ActionInput[];
+    threadId: string;
+  }) {
+    this.callback(this.eventStream$).catch((error) => {
+      console.error("Error in event source callback", error);
+      this.sendErrorMessageToChat();
+      this.eventStream$.complete();
+    });
+    return this.eventStream$.pipe(
+      // track state
+      scan(
+        (acc, event) => {
+          // It seems like this is needed so that rxjs recognizes the object has changed
+          // This fixes an issue where action were executed multiple times
+          // Not investigating further for now (Markus)
+          acc = { ...acc };
+
+          if (event.type === RuntimeEventTypes.ActionExecutionStart) {
+            acc.callActionServerSide =
+              serverSideActions.find((action) => action.name === event.actionName) !== undefined;
+            acc.args = "";
+            acc.actionExecutionId = event.actionExecutionId;
+            if (acc.callActionServerSide) {
+              acc.action = serverSideActions.find((action) => action.name === event.actionName);
+            }
+            acc.actionExecutionParentMessageId = event.parentMessageId;
+          } else if (event.type === RuntimeEventTypes.ActionExecutionArgs) {
+            acc.args += event.args;
+          }
+
+          acc.event = event;
+
+          return acc;
+        },
+        {
+          event: null,
+          callActionServerSide: false,
+          args: "",
+          actionExecutionId: null,
+          action: null,
+          actionExecutionParentMessageId: null,
+        } as RuntimeEventWithState,
+      ),
+      concatMap((eventWithState) => {
+        if (
+          eventWithState.event!.type === RuntimeEventTypes.ActionExecutionEnd &&
+          eventWithState.callActionServerSide
+        ) {
+          const toolCallEventStream$ = new RuntimeEventSubject();
+          executeAction(
+            toolCallEventStream$,
+            guardrailsResult$ ? guardrailsResult$ : null,
+            eventWithState.action!,
+            eventWithState.args,
+            eventWithState.actionExecutionParentMessageId,
+            eventWithState.actionExecutionId,
+            actionInputsWithoutAgents,
+            threadId,
+          ).catch((error) => {
+            console.error(error);
+          });
+
+          telemetry.capture("oss.runtime.server_action_executed", {});
+          return concat(of(eventWithState.event!), toolCallEventStream$).pipe(
+            catchError((error) => {
+              console.error("Error in tool call stream", error);
+              this.sendErrorMessageToChat();
+              return EMPTY;
+            }),
+          );
+        } else {
+          return of(eventWithState.event!);
+        }
+      }),
+    );
+  }
+}
+
+async function executeAction(
+  eventStream$: RuntimeEventSubject,
+  guardrailsResult$: Subject<GuardrailsResult> | null,
+  action: Action<any>,
+  actionArguments: string,
+  actionExecutionParentMessageId: string | null,
+  actionExecutionId: string,
+  actionInputsWithoutAgents: ActionInput[],
+  threadId: string,
+) {
+  if (guardrailsResult$) {
+    const { status } = await firstValueFrom(guardrailsResult$);
+
+    if (status === "denied") {
+      eventStream$.complete();
+      return;
+    }
+  }
+
+  // Prepare arguments for function calling
+  let args: Record<string, any>[] = [];
+  if (actionArguments) {
+    try {
+      args = JSON.parse(actionArguments);
+    } catch (e) {
+      console.error("Action argument unparsable", { actionArguments });
+      eventStream$.sendActionExecutionResult({
+        actionExecutionId,
+        actionName: action.name,
+        error: {
+          code: "INVALID_ARGUMENTS",
+          message: "Failed to parse action arguments",
+        },
+      });
+      return;
+    }
+  }
+
+  // handle LangGraph agents
+  if (isLangGraphAgentAction(action)) {
+    const result = `${action.name} agent started`;
+
+    const agentExecution = plainToInstance(ActionExecutionMessage, {
+      id: actionExecutionId,
+      createdAt: new Date(),
+      name: action.name,
+      arguments: JSON.parse(actionArguments),
+      parentMessageId: actionExecutionParentMessageId ?? actionExecutionId,
+    });
+
+    const agentExecutionResult = plainToInstance(ResultMessage, {
+      id: "result-" + actionExecutionId,
+      createdAt: new Date(),
+      actionExecutionId,
+      actionName: action.name,
+      result,
+    });
+
+    eventStream$.sendActionExecutionResult({
+      actionExecutionId,
+      actionName: action.name,
+      result,
+    });
+
+    const stream = await action.langGraphAgentHandler({
+      name: action.name,
+      threadId,
+      actionInputsWithoutAgents,
+      additionalMessages: [agentExecution, agentExecutionResult],
+    });
+
+    // forward to eventStream$
+    from(stream).subscribe({
+      next: (event) => eventStream$.next(event),
+      error: (err) => {
+        console.error("Error in stream", err);
+        eventStream$.sendActionExecutionResult({
+          actionExecutionId,
+          actionName: action.name,
+          error: {
+            code: "STREAM_ERROR",
+            message: err.message,
+          },
+        });
+        eventStream$.complete();
+      },
+      complete: () => eventStream$.complete(),
+    });
+  } else {
+    // call the function
+    try {
+      const result = await action.handler?.(args);
+      await streamLangChainResponse({
+        result,
+        eventStream$,
+        actionExecution: {
+          name: action.name,
+          id: actionExecutionId,
+        },
+      });
+    } catch (e) {
+      console.error("Error in action handler", e);
+      eventStream$.sendActionExecutionResult({
+        actionExecutionId,
+        actionName: action.name,
+        error: {
+          code: "HANDLER_ERROR",
+          message: e.message,
+        },
+      });
+      eventStream$.complete();
+    }
+  }
+}

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

@@ -0,0 +1,33 @@
+/**
+ * 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, ExperimentalEmptyAdapter } from "@copilotkit/runtime";
+ *
+ * const copilotKit = new CopilotRuntime();
+ *
+ * return new ExperimentalEmptyAdapter();
+ * ```
+ */
+import {
+  CopilotServiceAdapter,
+  CopilotRuntimeChatCompletionRequest,
+  CopilotRuntimeChatCompletionResponse,
+} from "../../service-adapter";
+import { randomUUID } from "@copilotkit/shared";
+
+export class ExperimentalEmptyAdapter implements CopilotServiceAdapter {
+  async process(
+    request: CopilotRuntimeChatCompletionRequest,
+  ): Promise<CopilotRuntimeChatCompletionResponse> {
+    return {
+      threadId: request.threadId || randomUUID(),
+    };
+  }
+}

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

@@ -0,0 +1,79 @@
+/**
+ * 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 { Ollama } from "@langchain/community/llms/ollama";
+import { randomId, randomUUID } from "@copilotkit/shared";
+
+const DEFAULT_MODEL = "llama3:latest";
+
+interface OllamaAdapterOptions {
+  model?: string;
+}
+
+export class ExperimentalOllamaAdapter implements CopilotServiceAdapter {
+  private model: string;
+
+  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);
+
+    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.ts

@@ -0,0 +1,39 @@
+/**
+ * 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-1.5-pro" });
+ * ```
+ */
+import { ChatGoogle } from "@langchain/google-gauth";
+import { LangChainAdapter } from "../langchain/langchain-adapter";
+
+interface GoogleGenerativeAIAdapterOptions {
+  /**
+   * A custom Google Generative AI model to use.
+   */
+  model?: string;
+}
+
+export class GoogleGenerativeAIAdapter extends LangChainAdapter {
+  constructor(options?: GoogleGenerativeAIAdapterOptions) {
+    super({
+      chainFn: async ({ messages, tools, threadId }) => {
+        const model = new ChatGoogle({
+          modelName: options?.model ?? "gemini-1.5-pro",
+          apiVersion: "v1beta",
+        }).bindTools(tools);
+        return model.stream(messages, { metadata: { conversation_id: threadId } });
+      },
+    });
+  }
+}