@copilotkit/runtime 0.37.0

package/src/service-adapters/google/utils.ts

@@ -0,0 +1,94 @@
+import {
+  ActionExecutionMessage,
+  Message,
+  ResultMessage,
+  TextMessage,
+} from "../../graphql/types/converted";
+import { Tool } from "@google/generative-ai";
+import { ActionInput } from "../../graphql/inputs/action.input";
+
+export function convertMessageToGoogleGenAIMessage(message: Message) {
+  if (message instanceof TextMessage) {
+    const role = {
+      user: "user",
+      assistant: "model",
+      system: "user",
+    }[message.role];
+
+    const text =
+      message.role === "system"
+        ? "THE FOLLOWING MESSAGE IS A SYSTEM MESSAGE: " + message.content
+        : message.content;
+
+    return {
+      role,
+      parts: [{ text }],
+    };
+  } else if (message instanceof ActionExecutionMessage) {
+    return {
+      role: "model",
+      parts: [
+        {
+          functionCall: {
+            name: message.name,
+            args: message.arguments,
+          },
+        },
+      ],
+    };
+  } else if (message instanceof ResultMessage) {
+    return {
+      role: "model",
+      parts: [
+        {
+          functionResponse: {
+            name: message.actionName,
+            response: {
+              name: message.actionName,
+              content: tryParseJson(message.result),
+            },
+          },
+        },
+      ],
+    };
+  }
+}
+
+export function transformActionToGoogleGenAITool(action: ActionInput): Tool {
+  const name = action.name;
+  const description = action.description;
+  const parameters = JSON.parse(action.jsonSchema);
+
+  const transformProperties = (props: any) => {
+    for (const key in props) {
+      if (props[key].type) {
+        props[key].type = props[key].type.toUpperCase();
+      }
+      if (props[key].properties) {
+        transformProperties(props[key].properties);
+      }
+    }
+  };
+  transformProperties(parameters);
+
+  return {
+    functionDeclarations: [
+      {
+        name,
+        description,
+        parameters,
+      },
+    ],
+  };
+}
+
+function tryParseJson(str?: string) {
+  if (!str) {
+    return "";
+  }
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return str;
+  }
+}

package/src/service-adapters/index.ts

@@ -0,0 +1,6 @@
+export type { CopilotServiceAdapter } from "./service-adapter";
+export { OpenAIAdapter } from "./openai/openai-adapter";
+export { OpenAIAssistantAdapter } from "./openai/openai-assistant-adapter";
+export { GoogleGenerativeAIAdapter } from "./google/google-genai-adapter";
+export { LangChainAdapter } from "./langchain/langchain-adapter";
+export { RemoteChain } from "./langchain/langserve";

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

@@ -0,0 +1,82 @@
+/**
+ * CopilotKit Adapter for LangChain
+ *
+ * Use this adapter to use LangChain as a backend.
+ *
+ * ```typescript
+ * return copilotKit.response(
+ *   req,
+ *   new LangChainAdapter(async (forwardedProps) => {
+ *     const model = new ChatOpenAI({ modelName: "gpt-4o" });
+ *     return model.stream(forwardedProps.messages, {
+ *       tools: forwardedProps.tools,
+ *     });
+ *   })
+ * );
+ * ```
+ * The async handler function can return:
+ *
+ * - a simple `string` response
+ * - a LangChain stream `IterableReadableStream`
+ * - a LangChain `BaseMessageChunk` object
+ * - a LangChain `AIMessage` object
+ */
+
+import { BaseMessage } from "@langchain/core/messages";
+import { CopilotServiceAdapter } from "../service-adapter";
+import {
+  CopilotRuntimeChatCompletionRequest,
+  CopilotRuntimeChatCompletionResponse,
+} from "../service-adapter";
+import {
+  convertActionInputToLangChainTool,
+  convertMessageToLangChainMessage,
+  streamLangChainResponse,
+} from "./utils";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { LangChainReturnType } from "./types";
+
+interface ChainFnParameters {
+  model: string;
+  messages: BaseMessage[];
+  tools: DynamicStructuredTool[];
+  threadId?: string;
+  runId?: string;
+}
+
+interface LangChainAdapterOptions {
+  chainFn: (parameters: ChainFnParameters) => Promise<LangChainReturnType>;
+}
+
+export class LangChainAdapter implements CopilotServiceAdapter {
+  /**
+   * To use LangChain as a backend, provide a handler function to the adapter with your custom LangChain logic.
+   */
+  constructor(private options: LangChainAdapterOptions) {}
+
+  async process({
+    eventSource,
+    model,
+    actions,
+    messages,
+    threadId,
+    runId,
+  }: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse> {
+    const result = await this.options.chainFn({
+      messages: messages.map(convertMessageToLangChainMessage),
+      tools: actions.map(convertActionInputToLangChainTool),
+      model,
+      threadId,
+      runId,
+    });
+
+    eventSource.stream(async (eventStream$) => {
+      await streamLangChainResponse({
+        result,
+        eventStream$,
+      });
+    });
+
+    return {};
+  }
+}

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

@@ -0,0 +1,81 @@
+import { Parameter, Action } from "@copilotkit/shared";
+import { RemoteRunnable } from "langchain/runnables/remote";
+
+export interface RemoteChain {
+  name: string;
+  description: string;
+  chainUrl: string;
+  parameters?: Parameter[];
+  parameterType: "single" | "multi";
+}
+
+export class RemoteChain implements RemoteChain {
+  constructor(options: RemoteChain) {
+    this.name = options.name;
+    this.description = options.description;
+    this.chainUrl = options.chainUrl;
+    this.parameters = options.parameters;
+    this.parameterType = options.parameterType || "multi";
+  }
+
+  async toAction(): Promise<Action<any>> {
+    if (!this.parameters) {
+      await this.inferLangServeParameters();
+    }
+
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: this.parameters!,
+      handler: async (args: any) => {
+        const runnable = new RemoteRunnable({ url: this.chainUrl });
+        let input: any;
+        if (this.parameterType === "single") {
+          input = args[Object.keys(args)[0]];
+        } else {
+          input = args;
+        }
+        return await runnable.invoke(input);
+      },
+    };
+  }
+
+  async inferLangServeParameters() {
+    const supportedTypes = ["string", "number", "boolean"];
+
+    let schemaUrl = this.chainUrl.replace(/\/+$/, "") + "/input_schema";
+    let schema = await fetch(schemaUrl)
+      .then((res) => res.json())
+      .catch(() => {
+        throw new Error("Failed to fetch langserve schema at " + schemaUrl);
+      });
+    // for now, don't use json schema, just do a simple conversion
+
+    if (supportedTypes.includes(schema.type)) {
+      this.parameterType = "single";
+      this.parameters = [
+        {
+          name: "input",
+          type: schema.type,
+          description: "The input to the chain",
+        },
+      ];
+    } else if (schema.type === "object") {
+      this.parameterType = "multi";
+      this.parameters = Object.keys(schema.properties).map((key) => {
+        let property = schema.properties[key];
+        if (!supportedTypes.includes(property.type)) {
+          throw new Error("Unsupported schema type");
+        }
+        return {
+          name: key,
+          type: property.type,
+          description: property.description || "",
+          required: schema.required?.includes(key) || false,
+        };
+      });
+    } else {
+      throw new Error("Unsupported schema type");
+    }
+  }
+}

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

@@ -0,0 +1,14 @@
+import { AIMessage, AIMessageChunk, BaseMessageChunk } from "@langchain/core/messages";
+import {
+  IterableReadableStream,
+  IterableReadableStreamInterface,
+} from "@langchain/core/utils/stream";
+
+export type LangChainBaseMessageChunkStream = IterableReadableStream<BaseMessageChunk>;
+export type LangChainAIMessageChunkStream = IterableReadableStreamInterface<AIMessageChunk>;
+export type LangChainReturnType =
+  | LangChainBaseMessageChunkStream
+  | LangChainAIMessageChunkStream
+  | BaseMessageChunk
+  | string
+  | AIMessage;

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

@@ -0,0 +1,235 @@
+import {
+  ActionExecutionMessage,
+  Message,
+  ResultMessage,
+  TextMessage,
+} from "../../graphql/types/converted";
+import {
+  AIMessage,
+  AIMessageChunk,
+  BaseMessage,
+  BaseMessageChunk,
+  HumanMessage,
+  SystemMessage,
+  ToolMessage,
+} from "@langchain/core/messages";
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import { ActionInput } from "../../graphql/inputs/action.input";
+import { LangChainReturnType } from "./types";
+import { RuntimeEventSubject } from "../events";
+import { nanoid } from "nanoid";
+
+export function convertMessageToLangChainMessage(message: Message): BaseMessage {
+  if (message instanceof TextMessage) {
+    if (message.role == "user") {
+      return new HumanMessage(message.content);
+    } else if (message.role == "assistant") {
+      return new AIMessage(message.content);
+    } else if (message.role === "system") {
+      return new SystemMessage(message.content);
+    }
+  } else if (message instanceof ActionExecutionMessage) {
+    return new AIMessage({
+      content: "",
+      tool_calls: [
+        {
+          id: message.id,
+          args: message.arguments,
+          name: message.name,
+        },
+      ],
+    });
+  } else if (message instanceof ResultMessage) {
+    return new ToolMessage({
+      content: message.result,
+      tool_call_id: message.actionExecutionId,
+    });
+  }
+}
+
+export function convertJsonSchemaToZodSchema(jsonSchema: any, required: boolean): z.ZodSchema {
+  if (jsonSchema.type === "object") {
+    const spec: { [key: string]: z.ZodSchema } = {};
+    for (const [key, value] of Object.entries(jsonSchema.properties)) {
+      spec[key] = convertJsonSchemaToZodSchema(
+        value,
+        jsonSchema.required ? jsonSchema.required.includes(key) : false,
+      );
+    }
+    let schema = z.object(spec);
+    return !required ? schema.optional() : schema;
+  } else if (jsonSchema.type === "string") {
+    let schema = z.string().describe(jsonSchema.description);
+    return !required ? schema.optional() : schema;
+  } else if (jsonSchema.type === "number") {
+    let schema = z.number().describe(jsonSchema.description);
+    return !required ? schema.optional() : schema;
+  } else if (jsonSchema.type === "boolean") {
+    let schema = z.boolean().describe(jsonSchema.description);
+    return !required ? schema.optional() : schema;
+  } else if (jsonSchema.type === "array") {
+    let itemSchema = convertJsonSchemaToZodSchema(jsonSchema.items, false);
+    let schema = z.array(itemSchema);
+    return !required ? schema.optional() : schema;
+  }
+}
+
+export function convertActionInputToLangChainTool(actionInput: ActionInput): DynamicStructuredTool {
+  return new DynamicStructuredTool({
+    name: actionInput.name,
+    description: actionInput.description,
+    schema: convertJsonSchemaToZodSchema(
+      JSON.parse(actionInput.jsonSchema),
+      true,
+    ) as z.ZodObject<any>,
+    func: async () => {
+      return "";
+    },
+  });
+}
+
+interface StreamLangChainResponseParams {
+  result: LangChainReturnType;
+  eventStream$: RuntimeEventSubject;
+  actionExecution?: {
+    id: string;
+    name: string;
+  };
+}
+
+export async function streamLangChainResponse({
+  result,
+  eventStream$,
+  actionExecution,
+}: StreamLangChainResponseParams) {
+  // We support several types of return values from LangChain functions:
+
+  // 1. string
+
+  if (typeof result === "string") {
+    if (!actionExecution) {
+      // Just send one chunk with the string as the content.
+      eventStream$.sendTextMessage(nanoid(), result);
+    } else {
+      // Send as a result
+      eventStream$.sendActionExecutionResult(actionExecution.id, actionExecution.name, result);
+    }
+  }
+
+  // 2. AIMessage
+  // Send the content and function call of the AIMessage as the content of the chunk.
+  // else if ("content" in result && typeof result.content === "string") {
+  else if (result instanceof AIMessage) {
+    if (result.content) {
+      eventStream$.sendTextMessage(nanoid(), result.content as string);
+    }
+    for (const toolCall of result.tool_calls) {
+      eventStream$.sendActionExecution(
+        toolCall.id || nanoid(),
+        toolCall.name,
+        JSON.stringify(toolCall.args),
+      );
+    }
+  }
+
+  // 3. BaseMessageChunk
+  // Send the content and function call of the AIMessage as the content of the chunk.
+  else if (result instanceof BaseMessageChunk) {
+    if (result.lc_kwargs?.content) {
+      eventStream$.sendTextMessage(nanoid(), result.content as string);
+    }
+    if (result.lc_kwargs?.tool_calls) {
+      for (const toolCall of result.lc_kwargs?.tool_calls) {
+        eventStream$.sendActionExecution(
+          toolCall.id || nanoid(),
+          toolCall.name,
+          JSON.stringify(toolCall.args),
+        );
+      }
+    }
+  }
+
+  // 4. IterableReadableStream
+  // Stream the result of the LangChain function.
+  else if ("getReader" in result) {
+    let reader = result.getReader();
+
+    let mode: "function" | "message" | null = null;
+
+    while (true) {
+      try {
+        const { done, value } = await reader.read();
+
+        let toolCallName: string | undefined = undefined;
+        let toolCallId: string | undefined = undefined;
+        let toolCallArgs: string | undefined = undefined;
+        let hasToolCall: boolean = false;
+        let content = value.content as string;
+
+        if (value instanceof AIMessageChunk) {
+          let chunk = value.tool_call_chunks?.[0];
+          toolCallName = chunk?.name;
+          toolCallId = chunk?.id;
+          toolCallArgs = chunk?.args;
+          hasToolCall = chunk != undefined;
+        } else if (value instanceof BaseMessageChunk) {
+          let chunk = value.additional_kwargs?.tool_calls?.[0];
+          toolCallName = chunk?.function?.name;
+          toolCallId = chunk?.id;
+          toolCallArgs = chunk?.function?.arguments;
+          hasToolCall = chunk?.function != undefined;
+        }
+
+        // When switching from message to function or vice versa,
+        // send the respective end event.
+        // If toolCallName is defined, it means a new tool call starts.
+        if (mode === "message" && (toolCallId || done)) {
+          mode = null;
+          eventStream$.sendTextMessageEnd();
+        } else if (mode === "function" && (!hasToolCall || done)) {
+          mode = null;
+          eventStream$.sendActionExecutionEnd();
+        }
+
+        if (done) {
+          break;
+        }
+
+        // If we send a new message type, send the appropriate start event.
+        if (mode === null) {
+          if (hasToolCall) {
+            mode = "function";
+            eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
+          } else if (content) {
+            mode = "message";
+            eventStream$.sendTextMessageStart(nanoid());
+          }
+        }
+
+        // send the content events
+        if (mode === "message" && content) {
+          eventStream$.sendTextMessageContent(content);
+        } else if (mode === "function" && toolCallArgs) {
+          eventStream$.sendActionExecutionArgs(toolCallArgs);
+        }
+      } catch (error) {
+        console.error("Error reading from stream", error);
+        break;
+      }
+    }
+  } else if (actionExecution) {
+    eventStream$.sendActionExecutionResult(
+      actionExecution.id,
+      actionExecution.name,
+      JSON.stringify(result),
+    );
+  }
+
+  // unsupported type
+  else {
+    throw new Error("Invalid return type from LangChain function.");
+  }
+
+  eventStream$.complete();
+}

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

@@ -0,0 +1,142 @@
+/**
+ * CopilotRuntime Adapter for OpenAI.
+ *
+ * <RequestExample>
+ * ```jsx CopilotRuntime Example
+ * const copilotKit = new CopilotRuntime();
+ * return copilotKit.response(req, new OpenAIAdapter());
+ * ```
+ * </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 OpenAIAdapter({ model: "gpt-4o" }),
+ * );
+ * ```
+ *
+ * To use your custom OpenAI instance, pass the `openai` property.
+ * ```jsx
+ * const openai = new OpenAI({
+ *   organization: "your-organization-id",
+ *   apiKey: "your-api-key"
+ * });
+ *
+ * const copilotKit = new CopilotRuntime();
+ * return copilotKit.response(
+ *   req,
+ *   new OpenAIAdapter({ openai }),
+ * );
+ * ```
+ *
+ */
+import OpenAI from "openai";
+import {
+  CopilotServiceAdapter,
+  CopilotRuntimeChatCompletionRequest,
+  CopilotRuntimeChatCompletionResponse,
+} from "../service-adapter";
+import {
+  convertActionInputToOpenAITool,
+  convertMessageToOpenAIMessage,
+  limitMessagesToTokenCount,
+} from "./utils";
+
+const DEFAULT_MODEL = "gpt-4o";
+
+export interface OpenAIAdapterParams {
+  /**
+   * An optional OpenAI instance to use.
+   */
+  openai?: OpenAI;
+
+  /**
+   * The model to use.
+   */
+  model?: string;
+}
+
+export class OpenAIAdapter implements CopilotServiceAdapter {
+  private model: string = DEFAULT_MODEL;
+
+  private _openai: OpenAI;
+  public get openai(): OpenAI {
+    return this._openai;
+  }
+
+  constructor(params?: OpenAIAdapterParams) {
+    this._openai = params?.openai || new OpenAI({});
+    if (params?.model) {
+      this.model = params.model;
+    }
+  }
+
+  async process({
+    model = this.model,
+    messages,
+    actions,
+    eventSource,
+  }: CopilotRuntimeChatCompletionRequest): Promise<CopilotRuntimeChatCompletionResponse> {
+    const tools = actions.map(convertActionInputToOpenAITool);
+
+    let openaiMessages = messages.map(convertMessageToOpenAIMessage);
+    openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
+
+    const stream = this.openai.beta.chat.completions.stream({
+      model: model,
+      stream: true,
+      messages: openaiMessages,
+      ...(tools.length > 0 && { tools }),
+    });
+
+    eventSource.stream(async (eventStream$) => {
+      let mode: "function" | "message" | null = null;
+      for await (const chunk of stream) {
+        const toolCall = chunk.choices[0].delta.tool_calls?.[0];
+        const content = chunk.choices[0].delta.content;
+
+        // When switching from message to function or vice versa,
+        // send the respective end event.
+        // If toolCall?.id is defined, it means a new tool call starts.
+        if (mode === "message" && toolCall?.id) {
+          mode = null;
+          eventStream$.sendTextMessageEnd();
+        } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
+          mode = null;
+          eventStream$.sendActionExecutionEnd();
+        }
+
+        // If we send a new message type, send the appropriate start event.
+        if (mode === null) {
+          if (toolCall?.id) {
+            mode = "function";
+            eventStream$.sendActionExecutionStart(toolCall!.id, toolCall!.function!.name);
+          } else if (content) {
+            mode = "message";
+            eventStream$.sendTextMessageStart(chunk.id);
+          }
+        }
+
+        // send the content events
+        if (mode === "message" && content) {
+          eventStream$.sendTextMessageContent(content);
+        } else if (mode === "function" && toolCall?.function?.arguments) {
+          eventStream$.sendActionExecutionArgs(toolCall.function.arguments);
+        }
+      }
+
+      // send the end events
+      if (mode === "message") {
+        eventStream$.sendTextMessageEnd();
+      } else if (mode === "function") {
+        eventStream$.sendActionExecutionEnd();
+      }
+
+      eventStream$.complete();
+    });
+
+    return {};
+  }
+}