@copilotkit/runtime 0.37.0

package/dist/chunk-5HGYI6EG.mjs

@@ -0,0 +1,678 @@
+import {
+  convertActionInputToLangChainTool,
+  convertMessageToLangChainMessage,
+  streamLangChainResponse
+} from "./chunk-7IFP53C6.mjs";
+import {
+  ActionExecutionMessage,
+  ResultMessage,
+  TextMessage
+} from "./chunk-BLTAUVRP.mjs";
+import {
+  __name
+} from "./chunk-NFCPM5AM.mjs";
+
+// src/service-adapters/openai/openai-adapter.ts
+import OpenAI from "openai";
+
+// src/service-adapters/openai/utils.ts
+import { encodingForModel } from "js-tiktoken";
+function limitMessagesToTokenCount(messages, tools, model, maxTokens) {
+  maxTokens || (maxTokens = maxTokensForOpenAIModel(model));
+  const result = [];
+  const toolsNumTokens = countToolsTokens(model, tools);
+  if (toolsNumTokens > maxTokens) {
+    throw new Error(`Too many tokens in function definitions: ${toolsNumTokens} > ${maxTokens}`);
+  }
+  maxTokens -= toolsNumTokens;
+  for (const message of messages) {
+    if (message.role === "system") {
+      const numTokens = countMessageTokens(model, message);
+      maxTokens -= numTokens;
+      if (maxTokens < 0) {
+        throw new Error("Not enough tokens for system message.");
+      }
+    }
+  }
+  let cutoff = false;
+  const reversedMessages = [
+    ...messages
+  ].reverse();
+  for (const message of reversedMessages) {
+    if (message.role === "system") {
+      result.unshift(message);
+      continue;
+    } else if (cutoff) {
+      continue;
+    }
+    let numTokens = countMessageTokens(model, message);
+    if (maxTokens < numTokens) {
+      cutoff = true;
+      continue;
+    }
+    result.unshift(message);
+    maxTokens -= numTokens;
+  }
+  return result;
+}
+__name(limitMessagesToTokenCount, "limitMessagesToTokenCount");
+function maxTokensForOpenAIModel(model) {
+  return maxTokensByModel[model] || DEFAULT_MAX_TOKENS;
+}
+__name(maxTokensForOpenAIModel, "maxTokensForOpenAIModel");
+var DEFAULT_MAX_TOKENS = 128e3;
+var maxTokensByModel = {
+  // GPT-4
+  "gpt-4o": 128e3,
+  "gpt-4o-2024-05-13": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gpt-4-turbo-2024-04-09": 128e3,
+  "gpt-4-0125-preview": 128e3,
+  "gpt-4-turbo-preview": 128e3,
+  "gpt-4-1106-preview": 128e3,
+  "gpt-4-vision-preview": 128e3,
+  "gpt-4-1106-vision-preview": 128e3,
+  "gpt-4-32k": 32768,
+  "gpt-4-32k-0613": 32768,
+  "gpt-4-32k-0314": 32768,
+  "gpt-4": 8192,
+  "gpt-4-0613": 8192,
+  "gpt-4-0314": 8192,
+  // GPT-3.5
+  "gpt-3.5-turbo-0125": 16385,
+  "gpt-3.5-turbo": 16385,
+  "gpt-3.5-turbo-1106": 16385,
+  "gpt-3.5-turbo-instruct": 4096,
+  "gpt-3.5-turbo-16k": 16385,
+  "gpt-3.5-turbo-0613": 4096,
+  "gpt-3.5-turbo-16k-0613": 16385,
+  "gpt-3.5-turbo-0301": 4097
+};
+function countToolsTokens(model, tools) {
+  if (tools.length === 0) {
+    return 0;
+  }
+  const json = JSON.stringify(tools);
+  return countTokens(model, json);
+}
+__name(countToolsTokens, "countToolsTokens");
+function countMessageTokens(model, message) {
+  return countTokens(model, message.content || "");
+}
+__name(countMessageTokens, "countMessageTokens");
+function countTokens(model, text) {
+  let enc;
+  try {
+    enc = encodingForModel(model);
+  } catch (e) {
+    enc = encodingForModel("gpt-4");
+  }
+  return enc.encode(text).length;
+}
+__name(countTokens, "countTokens");
+function convertActionInputToOpenAITool(action) {
+  return {
+    type: "function",
+    function: {
+      name: action.name,
+      description: action.description,
+      parameters: JSON.parse(action.jsonSchema)
+    }
+  };
+}
+__name(convertActionInputToOpenAITool, "convertActionInputToOpenAITool");
+function convertMessageToOpenAIMessage(message) {
+  if (message instanceof TextMessage) {
+    return {
+      role: message.role,
+      content: message.content
+    };
+  } else if (message instanceof ActionExecutionMessage) {
+    return {
+      role: "assistant",
+      tool_calls: [
+        {
+          id: message.id,
+          type: "function",
+          function: {
+            name: message.name,
+            arguments: JSON.stringify(message.arguments)
+          }
+        }
+      ]
+    };
+  } else if (message instanceof ResultMessage) {
+    return {
+      role: "tool",
+      content: message.result,
+      tool_call_id: message.actionExecutionId
+    };
+  }
+}
+__name(convertMessageToOpenAIMessage, "convertMessageToOpenAIMessage");
+function convertSystemMessageToAssistantAPI(message) {
+  return {
+    ...message,
+    ...message.role === "system" && {
+      role: "assistant",
+      content: "THE FOLLOWING MESSAGE IS A SYSTEM MESSAGE: " + message.content
+    }
+  };
+}
+__name(convertSystemMessageToAssistantAPI, "convertSystemMessageToAssistantAPI");
+
+// src/service-adapters/openai/openai-adapter.ts
+var DEFAULT_MODEL = "gpt-4o";
+var OpenAIAdapter = class {
+  model = DEFAULT_MODEL;
+  _openai;
+  get openai() {
+    return this._openai;
+  }
+  constructor(params) {
+    this._openai = (params == null ? void 0 : params.openai) || new OpenAI({});
+    if (params == null ? void 0 : params.model) {
+      this.model = params.model;
+    }
+  }
+  async process({ model = this.model, messages, actions, eventSource }) {
+    const tools = actions.map(convertActionInputToOpenAITool);
+    let openaiMessages = messages.map(convertMessageToOpenAIMessage);
+    openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
+    const stream = this.openai.beta.chat.completions.stream({
+      model,
+      stream: true,
+      messages: openaiMessages,
+      ...tools.length > 0 && {
+        tools
+      }
+    });
+    eventSource.stream(async (eventStream$) => {
+      var _a, _b;
+      let mode = null;
+      for await (const chunk of stream) {
+        const toolCall = (_a = chunk.choices[0].delta.tool_calls) == null ? void 0 : _a[0];
+        const content = chunk.choices[0].delta.content;
+        if (mode === "message" && (toolCall == null ? void 0 : toolCall.id)) {
+          mode = null;
+          eventStream$.sendTextMessageEnd();
+        } else if (mode === "function" && (toolCall === void 0 || (toolCall == null ? void 0 : toolCall.id))) {
+          mode = null;
+          eventStream$.sendActionExecutionEnd();
+        }
+        if (mode === null) {
+          if (toolCall == null ? void 0 : toolCall.id) {
+            mode = "function";
+            eventStream$.sendActionExecutionStart(toolCall.id, toolCall.function.name);
+          } else if (content) {
+            mode = "message";
+            eventStream$.sendTextMessageStart(chunk.id);
+          }
+        }
+        if (mode === "message" && content) {
+          eventStream$.sendTextMessageContent(content);
+        } else if (mode === "function" && ((_b = toolCall == null ? void 0 : toolCall.function) == null ? void 0 : _b.arguments)) {
+          eventStream$.sendActionExecutionArgs(toolCall.function.arguments);
+        }
+      }
+      if (mode === "message") {
+        eventStream$.sendTextMessageEnd();
+      } else if (mode === "function") {
+        eventStream$.sendActionExecutionEnd();
+      }
+      eventStream$.complete();
+    });
+    return {};
+  }
+};
+__name(OpenAIAdapter, "OpenAIAdapter");
+
+// src/service-adapters/openai/openai-assistant-adapter.ts
+import OpenAI2 from "openai";
+var OpenAIAssistantAdapter = class {
+  openai;
+  codeInterpreterEnabled;
+  assistantId;
+  fileSearchEnabled;
+  constructor(params) {
+    this.openai = params.openai || new OpenAI2({});
+    this.codeInterpreterEnabled = params.codeInterpreterEnabled === false || true;
+    this.fileSearchEnabled = params.fileSearchEnabled === false || true;
+    this.assistantId = params.assistantId;
+  }
+  async process({ messages, actions, eventSource, threadId, runId }) {
+    threadId || (threadId = (await this.openai.beta.threads.create()).id);
+    const lastMessage = messages.at(-1);
+    let nextRunId = void 0;
+    if (lastMessage instanceof ResultMessage && runId) {
+      nextRunId = await this.submitToolOutputs(threadId, runId, messages, eventSource);
+    } else if (lastMessage instanceof TextMessage) {
+      nextRunId = await this.submitUserMessage(threadId, messages, actions, eventSource);
+    } else {
+      throw new Error("No actionable message found in the messages");
+    }
+    return {
+      threadId,
+      runId: nextRunId
+    };
+  }
+  async submitToolOutputs(threadId, runId, messages, eventSource) {
+    let run = await this.openai.beta.threads.runs.retrieve(threadId, runId);
+    if (!run.required_action) {
+      throw new Error("No tool outputs required");
+    }
+    const toolCallsIds = run.required_action.submit_tool_outputs.tool_calls.map((toolCall) => toolCall.id);
+    const resultMessages = messages.filter((message) => message instanceof ResultMessage && toolCallsIds.includes(message.actionExecutionId));
+    if (toolCallsIds.length != resultMessages.length) {
+      throw new Error("Number of function results does not match the number of tool calls");
+    }
+    const toolOutputs = resultMessages.map((message) => {
+      return {
+        tool_call_id: message.actionExecutionId,
+        output: message.result
+      };
+    });
+    const stream = this.openai.beta.threads.runs.submitToolOutputsStream(threadId, runId, {
+      tool_outputs: toolOutputs
+    });
+    await this.streamResponse(stream, eventSource);
+    return runId;
+  }
+  async submitUserMessage(threadId, messages, actions, eventSource) {
+    messages = [
+      ...messages
+    ];
+    const instructionsMessage = messages.shift();
+    const instructions = instructionsMessage instanceof TextMessage ? instructionsMessage.content : "";
+    const userMessage = messages.map(convertMessageToOpenAIMessage).map(convertSystemMessageToAssistantAPI).at(-1);
+    if (userMessage.role !== "user") {
+      throw new Error("No user message found");
+    }
+    await this.openai.beta.threads.messages.create(threadId, {
+      role: "user",
+      content: userMessage.content
+    });
+    const openaiTools = actions.map(convertActionInputToOpenAITool);
+    const tools = [
+      ...openaiTools,
+      ...this.codeInterpreterEnabled ? [
+        {
+          type: "code_interpreter"
+        }
+      ] : [],
+      ...this.fileSearchEnabled ? [
+        {
+          type: "file_search"
+        }
+      ] : []
+    ];
+    let stream = this.openai.beta.threads.runs.stream(threadId, {
+      assistant_id: this.assistantId,
+      instructions,
+      tools
+    });
+    await this.streamResponse(stream, eventSource);
+    return getRunIdFromStream(stream);
+  }
+  async streamResponse(stream, eventSource) {
+    eventSource.stream(async (eventStream$) => {
+      var _a, _b, _c, _d, _e, _f;
+      let inFunctionCall = false;
+      for await (const chunk of stream) {
+        switch (chunk.event) {
+          case "thread.message.created":
+            if (inFunctionCall) {
+              eventStream$.sendActionExecutionEnd();
+            }
+            eventStream$.sendTextMessageStart(chunk.data.id);
+            break;
+          case "thread.message.delta":
+            if (((_a = chunk.data.delta.content) == null ? void 0 : _a[0].type) === "text") {
+              eventStream$.sendTextMessageContent((_b = chunk.data.delta.content) == null ? void 0 : _b[0].text.value);
+            }
+            break;
+          case "thread.message.completed":
+            eventStream$.sendTextMessageEnd();
+            break;
+          case "thread.run.step.delta":
+            let toolCallId;
+            let toolCallName;
+            let toolCallArgs;
+            if (chunk.data.delta.step_details.type === "tool_calls" && ((_c = chunk.data.delta.step_details.tool_calls) == null ? void 0 : _c[0].type) === "function") {
+              toolCallId = (_d = chunk.data.delta.step_details.tool_calls) == null ? void 0 : _d[0].id;
+              toolCallName = (_e = chunk.data.delta.step_details.tool_calls) == null ? void 0 : _e[0].function.name;
+              toolCallArgs = (_f = chunk.data.delta.step_details.tool_calls) == null ? void 0 : _f[0].function.arguments;
+            }
+            if (toolCallName && toolCallId) {
+              if (inFunctionCall) {
+                eventStream$.sendActionExecutionEnd();
+              }
+              inFunctionCall = true;
+              eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
+            } else if (toolCallArgs) {
+              eventStream$.sendActionExecutionArgs(toolCallArgs);
+            }
+            break;
+        }
+      }
+      if (inFunctionCall) {
+        eventStream$.sendActionExecutionEnd();
+      }
+      eventStream$.complete();
+    });
+  }
+};
+__name(OpenAIAssistantAdapter, "OpenAIAssistantAdapter");
+function getRunIdFromStream(stream) {
+  return new Promise((resolve, reject) => {
+    let runIdGetter = /* @__PURE__ */ __name((event) => {
+      if (event.event === "thread.run.created") {
+        const runId = event.data.id;
+        stream.off("event", runIdGetter);
+        resolve(runId);
+      }
+    }, "runIdGetter");
+    stream.on("event", runIdGetter);
+  });
+}
+__name(getRunIdFromStream, "getRunIdFromStream");
+
+// src/service-adapters/google/google-genai-adapter.ts
+import { GoogleGenerativeAI } from "@google/generative-ai";
+
+// src/service-adapters/google/utils.ts
+function convertMessageToGoogleGenAIMessage(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)
+            }
+          }
+        }
+      ]
+    };
+  }
+}
+__name(convertMessageToGoogleGenAIMessage, "convertMessageToGoogleGenAIMessage");
+function transformActionToGoogleGenAITool(action) {
+  const name = action.name;
+  const description = action.description;
+  const parameters = JSON.parse(action.jsonSchema);
+  const transformProperties = /* @__PURE__ */ __name((props) => {
+    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");
+  transformProperties(parameters);
+  return {
+    functionDeclarations: [
+      {
+        name,
+        description,
+        parameters
+      }
+    ]
+  };
+}
+__name(transformActionToGoogleGenAITool, "transformActionToGoogleGenAITool");
+function tryParseJson(str) {
+  if (!str) {
+    return "";
+  }
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return str;
+  }
+}
+__name(tryParseJson, "tryParseJson");
+
+// src/service-adapters/google/google-genai-adapter.ts
+import { nanoid } from "nanoid";
+var GoogleGenerativeAIAdapter = class {
+  model;
+  constructor(options) {
+    if (options == null ? void 0 : options.model) {
+      this.model = options.model;
+    } else {
+      const genAI = new GoogleGenerativeAI(process.env["GOOGLE_API_KEY"]);
+      this.model = genAI.getGenerativeModel({
+        model: "gemini-pro"
+      });
+    }
+  }
+  async process(request) {
+    const { messages, actions, eventSource } = request;
+    const history = messages.slice(1, -1).map(convertMessageToGoogleGenAIMessage);
+    const currentMessage = convertMessageToGoogleGenAIMessage(messages.at(-1));
+    if (!currentMessage) {
+      throw new Error("No current message");
+    }
+    let systemMessage;
+    const firstMessage = messages.at(0);
+    if (firstMessage instanceof TextMessage && firstMessage.role === "system") {
+      systemMessage = firstMessage.content.trim();
+    } else {
+      throw new Error("First message is not a system message");
+    }
+    const tools = actions.map(transformActionToGoogleGenAITool);
+    const isFirstGenGeminiPro = this.model.model === "gemini-pro" || this.model.model === "models/gemini-pro";
+    const chat = this.model.startChat({
+      history: [
+        ...history,
+        // gemini-pro does not support system instructions, so we need to add them to the history
+        ...isFirstGenGeminiPro ? [
+          {
+            role: "user",
+            parts: [
+              {
+                text: systemMessage
+              }
+            ]
+          }
+        ] : []
+      ],
+      // only gemini-1.5-pro-latest and later supports setting system instructions
+      ...isFirstGenGeminiPro ? {} : {
+        systemInstruction: {
+          role: "user",
+          parts: [
+            {
+              text: systemMessage
+            }
+          ]
+        }
+      },
+      tools
+    });
+    const result = await chat.sendMessageStream(currentMessage.parts);
+    eventSource.stream(async (eventStream$) => {
+      let isTextMessage = false;
+      for await (const chunk of result.stream) {
+        const chunkText = chunk.text();
+        if (!isTextMessage) {
+          isTextMessage = true;
+          eventStream$.sendTextMessageStart(nanoid());
+        }
+        eventStream$.sendTextMessageContent(chunkText);
+      }
+      if (isTextMessage) {
+        eventStream$.sendTextMessageEnd();
+      }
+      let calls = (await result.response).functionCalls();
+      if (calls) {
+        for (let call of calls) {
+          eventStream$.sendActionExecution(nanoid(), call.name, JSON.stringify(replaceNewlinesInObject(call.args)));
+        }
+      }
+      eventStream$.complete();
+    });
+    return {};
+  }
+};
+__name(GoogleGenerativeAIAdapter, "GoogleGenerativeAIAdapter");
+function replaceNewlinesInObject(obj) {
+  if (typeof obj === "string") {
+    return obj.replace(/\\\\n/g, "\n");
+  } else if (Array.isArray(obj)) {
+    return obj.map(replaceNewlinesInObject);
+  } else if (typeof obj === "object" && obj !== null) {
+    const newObj = {};
+    for (const key in obj) {
+      if (obj.hasOwnProperty(key)) {
+        newObj[key] = replaceNewlinesInObject(obj[key]);
+      }
+    }
+    return newObj;
+  }
+  return obj;
+}
+__name(replaceNewlinesInObject, "replaceNewlinesInObject");
+
+// src/service-adapters/langchain/langchain-adapter.ts
+var LangChainAdapter = class {
+  options;
+  /**
+  * To use LangChain as a backend, provide a handler function to the adapter with your custom LangChain logic.
+  */
+  constructor(options) {
+    this.options = options;
+  }
+  async process({ eventSource, model, actions, messages, threadId, runId }) {
+    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 {};
+  }
+};
+__name(LangChainAdapter, "LangChainAdapter");
+
+// src/service-adapters/langchain/langserve.ts
+import { RemoteRunnable } from "langchain/runnables/remote";
+var RemoteChain = class {
+  constructor(options) {
+    this.name = options.name;
+    this.description = options.description;
+    this.chainUrl = options.chainUrl;
+    this.parameters = options.parameters;
+    this.parameterType = options.parameterType || "multi";
+  }
+  async toAction() {
+    if (!this.parameters) {
+      await this.inferLangServeParameters();
+    }
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: this.parameters,
+      handler: async (args) => {
+        const runnable = new RemoteRunnable({
+          url: this.chainUrl
+        });
+        let input;
+        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);
+    });
+    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) => {
+        var _a;
+        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: ((_a = schema.required) == null ? void 0 : _a.includes(key)) || false
+        };
+      });
+    } else {
+      throw new Error("Unsupported schema type");
+    }
+  }
+};
+__name(RemoteChain, "RemoteChain");
+
+export {
+  OpenAIAdapter,
+  OpenAIAssistantAdapter,
+  GoogleGenerativeAIAdapter,
+  LangChainAdapter,
+  RemoteChain
+};
+//# sourceMappingURL=chunk-5HGYI6EG.mjs.map