@copilotkit/runtime 0.37.0

package/dist/index.js

@@ -0,0 +1,2171 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CopilotBackend: () => CopilotBackend,
+  CopilotCloud: () => CopilotCloud,
+  CopilotRuntime: () => CopilotRuntime,
+  GoogleGenerativeAIAdapter: () => GoogleGenerativeAIAdapter,
+  LangChainAdapter: () => LangChainAdapter,
+  OpenAIAdapter: () => OpenAIAdapter,
+  OpenAIAssistantAdapter: () => OpenAIAssistantAdapter,
+  RemoteCopilotCloud: () => RemoteCopilotCloud,
+  buildSchema: () => buildSchema,
+  config: () => config,
+  copilotRuntimeNextJSAppRouterEndpoint: () => copilotRuntimeNextJSAppRouterEndpoint,
+  copilotRuntimeNextJSPagesRouterEndpoint: () => copilotRuntimeNextJSPagesRouterEndpoint,
+  copilotRuntimeNodeHttpEndpoint: () => copilotRuntimeNodeHttpEndpoint,
+  createContext: () => createContext,
+  flattenToolCallsNoDuplicates: () => flattenToolCallsNoDuplicates,
+  getCommonConfig: () => getCommonConfig
+});
+module.exports = __toCommonJS(src_exports);
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/lib/copilot-runtime.ts
+var import_shared2 = require("@copilotkit/shared");
+
+// src/service-adapters/openai/openai-adapter.ts
+var import_openai = __toESM(require("openai"));
+
+// src/graphql/types/base/index.ts
+var import_type_graphql = require("type-graphql");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var BaseMessage = class {
+  id;
+  createdAt;
+};
+__name(BaseMessage, "BaseMessage");
+_ts_decorate([
+  (0, import_type_graphql.Field)(() => String),
+  _ts_metadata("design:type", String)
+], BaseMessage.prototype, "id", void 0);
+_ts_decorate([
+  (0, import_type_graphql.Field)(() => Date),
+  _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+], BaseMessage.prototype, "createdAt", void 0);
+BaseMessage = _ts_decorate([
+  (0, import_type_graphql.InputType)()
+], BaseMessage);
+
+// src/graphql/types/converted/index.ts
+var TextMessage = class extends BaseMessage {
+  content;
+  role;
+};
+__name(TextMessage, "TextMessage");
+var ActionExecutionMessage = class extends BaseMessage {
+  name;
+  arguments;
+  scope;
+};
+__name(ActionExecutionMessage, "ActionExecutionMessage");
+var ResultMessage = class extends BaseMessage {
+  actionExecutionId;
+  actionName;
+  result;
+};
+__name(ResultMessage, "ResultMessage");
+
+// src/service-adapters/openai/utils.ts
+var import_js_tiktoken = require("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 = (0, import_js_tiktoken.encodingForModel)(model);
+  } catch (e) {
+    enc = (0, import_js_tiktoken.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 import_openai.default({});
+    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
+var import_openai2 = __toESM(require("openai"));
+var OpenAIAssistantAdapter = class {
+  openai;
+  codeInterpreterEnabled;
+  assistantId;
+  fileSearchEnabled;
+  constructor(params) {
+    this.openai = params.openai || new import_openai2.default({});
+    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
+var import_generative_ai = require("@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
+var import_nanoid = require("nanoid");
+var GoogleGenerativeAIAdapter = class {
+  model;
+  constructor(options) {
+    if (options == null ? void 0 : options.model) {
+      this.model = options.model;
+    } else {
+      const genAI = new import_generative_ai.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((0, import_nanoid.nanoid)());
+        }
+        eventStream$.sendTextMessageContent(chunkText);
+      }
+      if (isTextMessage) {
+        eventStream$.sendTextMessageEnd();
+      }
+      let calls = (await result.response).functionCalls();
+      if (calls) {
+        for (let call of calls) {
+          eventStream$.sendActionExecution((0, import_nanoid.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/utils.ts
+var import_messages = require("@langchain/core/messages");
+var import_tools = require("@langchain/core/tools");
+var import_zod = require("zod");
+var import_nanoid2 = require("nanoid");
+function convertMessageToLangChainMessage(message) {
+  if (message instanceof TextMessage) {
+    if (message.role == "user") {
+      return new import_messages.HumanMessage(message.content);
+    } else if (message.role == "assistant") {
+      return new import_messages.AIMessage(message.content);
+    } else if (message.role === "system") {
+      return new import_messages.SystemMessage(message.content);
+    }
+  } else if (message instanceof ActionExecutionMessage) {
+    return new import_messages.AIMessage({
+      content: "",
+      tool_calls: [
+        {
+          id: message.id,
+          args: message.arguments,
+          name: message.name
+        }
+      ]
+    });
+  } else if (message instanceof ResultMessage) {
+    return new import_messages.ToolMessage({
+      content: message.result,
+      tool_call_id: message.actionExecutionId
+    });
+  }
+}
+__name(convertMessageToLangChainMessage, "convertMessageToLangChainMessage");
+function convertJsonSchemaToZodSchema(jsonSchema, required) {
+  if (jsonSchema.type === "object") {
+    const spec = {};
+    for (const [key, value] of Object.entries(jsonSchema.properties)) {
+      spec[key] = convertJsonSchemaToZodSchema(value, jsonSchema.required ? jsonSchema.required.includes(key) : false);
+    }
+    let schema = import_zod.z.object(spec);
+    return !required ? schema.optional() : schema;
+  } else if (jsonSchema.type === "string") {
+    let schema = import_zod.z.string().describe(jsonSchema.description);
+    return !required ? schema.optional() : schema;
+  } else if (jsonSchema.type === "number") {
+    let schema = import_zod.z.number().describe(jsonSchema.description);
+    return !required ? schema.optional() : schema;
+  } else if (jsonSchema.type === "boolean") {
+    let schema = import_zod.z.boolean().describe(jsonSchema.description);
+    return !required ? schema.optional() : schema;
+  } else if (jsonSchema.type === "array") {
+    let itemSchema = convertJsonSchemaToZodSchema(jsonSchema.items, false);
+    let schema = import_zod.z.array(itemSchema);
+    return !required ? schema.optional() : schema;
+  }
+}
+__name(convertJsonSchemaToZodSchema, "convertJsonSchemaToZodSchema");
+function convertActionInputToLangChainTool(actionInput) {
+  return new import_tools.DynamicStructuredTool({
+    name: actionInput.name,
+    description: actionInput.description,
+    schema: convertJsonSchemaToZodSchema(JSON.parse(actionInput.jsonSchema), true),
+    func: async () => {
+      return "";
+    }
+  });
+}
+__name(convertActionInputToLangChainTool, "convertActionInputToLangChainTool");
+async function streamLangChainResponse({ result, eventStream$, actionExecution }) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  if (typeof result === "string") {
+    if (!actionExecution) {
+      eventStream$.sendTextMessage((0, import_nanoid2.nanoid)(), result);
+    } else {
+      eventStream$.sendActionExecutionResult(actionExecution.id, actionExecution.name, result);
+    }
+  } else if (result instanceof import_messages.AIMessage) {
+    if (result.content) {
+      eventStream$.sendTextMessage((0, import_nanoid2.nanoid)(), result.content);
+    }
+    for (const toolCall of result.tool_calls) {
+      eventStream$.sendActionExecution(toolCall.id || (0, import_nanoid2.nanoid)(), toolCall.name, JSON.stringify(toolCall.args));
+    }
+  } else if (result instanceof import_messages.BaseMessageChunk) {
+    if ((_a = result.lc_kwargs) == null ? void 0 : _a.content) {
+      eventStream$.sendTextMessage((0, import_nanoid2.nanoid)(), result.content);
+    }
+    if ((_b = result.lc_kwargs) == null ? void 0 : _b.tool_calls) {
+      for (const toolCall of (_c = result.lc_kwargs) == null ? void 0 : _c.tool_calls) {
+        eventStream$.sendActionExecution(toolCall.id || (0, import_nanoid2.nanoid)(), toolCall.name, JSON.stringify(toolCall.args));
+      }
+    }
+  } else if ("getReader" in result) {
+    let reader = result.getReader();
+    let mode = null;
+    while (true) {
+      try {
+        const { done, value } = await reader.read();
+        let toolCallName = void 0;
+        let toolCallId = void 0;
+        let toolCallArgs = void 0;
+        let hasToolCall = false;
+        let content = value.content;
+        if (value instanceof import_messages.AIMessageChunk) {
+          let chunk = (_d = value.tool_call_chunks) == null ? void 0 : _d[0];
+          toolCallName = chunk == null ? void 0 : chunk.name;
+          toolCallId = chunk == null ? void 0 : chunk.id;
+          toolCallArgs = chunk == null ? void 0 : chunk.args;
+          hasToolCall = chunk != void 0;
+        } else if (value instanceof import_messages.BaseMessageChunk) {
+          let chunk = (_f = (_e = value.additional_kwargs) == null ? void 0 : _e.tool_calls) == null ? void 0 : _f[0];
+          toolCallName = (_g = chunk == null ? void 0 : chunk.function) == null ? void 0 : _g.name;
+          toolCallId = chunk == null ? void 0 : chunk.id;
+          toolCallArgs = (_h = chunk == null ? void 0 : chunk.function) == null ? void 0 : _h.arguments;
+          hasToolCall = (chunk == null ? void 0 : chunk.function) != void 0;
+        }
+        if (mode === "message" && (toolCallId || done)) {
+          mode = null;
+          eventStream$.sendTextMessageEnd();
+        } else if (mode === "function" && (!hasToolCall || done)) {
+          mode = null;
+          eventStream$.sendActionExecutionEnd();
+        }
+        if (done) {
+          break;
+        }
+        if (mode === null) {
+          if (hasToolCall) {
+            mode = "function";
+            eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
+          } else if (content) {
+            mode = "message";
+            eventStream$.sendTextMessageStart((0, import_nanoid2.nanoid)());
+          }
+        }
+        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));
+  } else {
+    throw new Error("Invalid return type from LangChain function.");
+  }
+  eventStream$.complete();
+}
+__name(streamLangChainResponse, "streamLangChainResponse");
+
+// 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
+var import_remote = require("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 import_remote.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");
+
+// src/lib/copilot-cloud.ts
+var import_shared = require("@copilotkit/shared");
+var CopilotCloud = class {
+};
+__name(CopilotCloud, "CopilotCloud");
+var RemoteCopilotCloud = class extends CopilotCloud {
+  cloudApiUrl;
+  constructor(cloudApiUrl = import_shared.COPILOT_CLOUD_API_URL) {
+    super();
+    this.cloudApiUrl = cloudApiUrl;
+  }
+  async checkGuardrailsInput({ cloud, publicApiKey, messages }) {
+    const url = `${this.cloudApiUrl}/${import_shared.COPILOT_CLOUD_VERSION}/copilotkit/guardrails/input`;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/json",
+        [import_shared.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey
+      },
+      body: JSON.stringify({
+        messages,
+        cloud
+      })
+    });
+    if (!response.ok) {
+      let message = response.statusText;
+      try {
+        const json2 = await response.json();
+        if (json2.message) {
+          message = json2.message;
+        }
+      } catch (error) {
+      }
+      throw new Error("Failed to check input guardrails: " + message);
+    }
+    const json = await response.json();
+    return {
+      status: json.status,
+      reason: json.reason
+    };
+  }
+};
+__name(RemoteCopilotCloud, "RemoteCopilotCloud");
+
+// src/service-adapters/events.ts
+var import_rxjs = require("rxjs");
+var RuntimeEventTypes;
+(function(RuntimeEventTypes2) {
+  RuntimeEventTypes2["TextMessageStart"] = "TextMessageStart";
+  RuntimeEventTypes2["TextMessageContent"] = "TextMessageContent";
+  RuntimeEventTypes2["TextMessageEnd"] = "TextMessageEnd";
+  RuntimeEventTypes2["ActionExecutionStart"] = "ActionExecutionStart";
+  RuntimeEventTypes2["ActionExecutionArgs"] = "ActionExecutionArgs";
+  RuntimeEventTypes2["ActionExecutionEnd"] = "ActionExecutionEnd";
+  RuntimeEventTypes2["ActionExecutionResult"] = "ActionExecutionResult";
+})(RuntimeEventTypes || (RuntimeEventTypes = {}));
+var RuntimeEventSubject = class extends import_rxjs.ReplaySubject {
+  constructor() {
+    super();
+  }
+  sendTextMessageStart(messageId) {
+    this.next({
+      type: "TextMessageStart",
+      messageId
+    });
+  }
+  sendTextMessageContent(content) {
+    this.next({
+      type: "TextMessageContent",
+      content
+    });
+  }
+  sendTextMessageEnd() {
+    this.next({
+      type: "TextMessageEnd"
+    });
+  }
+  sendTextMessage(messageId, content) {
+    this.sendTextMessageStart(messageId);
+    this.sendTextMessageContent(content);
+    this.sendTextMessageEnd();
+  }
+  sendActionExecutionStart(actionExecutionId, actionName) {
+    this.next({
+      type: "ActionExecutionStart",
+      actionExecutionId,
+      actionName
+    });
+  }
+  sendActionExecutionArgs(args) {
+    this.next({
+      type: "ActionExecutionArgs",
+      args
+    });
+  }
+  sendActionExecutionEnd() {
+    this.next({
+      type: "ActionExecutionEnd"
+    });
+  }
+  sendActionExecution(actionExecutionId, toolName, args) {
+    this.sendActionExecutionStart(actionExecutionId, toolName);
+    this.sendActionExecutionArgs(args);
+    this.sendActionExecutionEnd();
+  }
+  sendActionExecutionResult(actionExecutionId, actionName, result) {
+    this.next({
+      type: "ActionExecutionResult",
+      actionName,
+      actionExecutionId,
+      result
+    });
+  }
+};
+__name(RuntimeEventSubject, "RuntimeEventSubject");
+var RuntimeEventSource = class {
+  eventStream$ = new RuntimeEventSubject();
+  callback;
+  async stream(callback) {
+    this.callback = callback;
+  }
+  process(serversideActions) {
+    this.callback(this.eventStream$).catch((error) => {
+      console.error("Error in event source callback", error);
+    });
+    return this.eventStream$.pipe(
+      // mark tools for server side execution
+      (0, import_rxjs.map)((event) => {
+        if (event.type === "ActionExecutionStart") {
+          event.scope = serversideActions.find((action) => action.name === event.actionName) ? "server" : "client";
+        }
+        return event;
+      }),
+      // track state
+      (0, import_rxjs.scan)((acc, event) => {
+        if (event.type === "ActionExecutionStart") {
+          acc.callActionServerSide = event.scope === "server";
+          acc.args = "";
+          acc.actionExecutionId = event.actionExecutionId;
+          if (acc.callActionServerSide) {
+            acc.action = serversideActions.find((action) => action.name === event.actionName);
+          }
+        } else if (event.type === "ActionExecutionArgs") {
+          acc.args += event.args;
+        }
+        acc.event = event;
+        return acc;
+      }, {
+        event: null,
+        callActionServerSide: false,
+        args: "",
+        actionExecutionId: null,
+        action: null
+      }),
+      (0, import_rxjs.concatMap)((eventWithState) => {
+        if (eventWithState.event.type === "ActionExecutionEnd" && eventWithState.callActionServerSide) {
+          const toolCallEventStream$ = new RuntimeEventSubject();
+          executeAction(toolCallEventStream$, eventWithState.action, eventWithState.args, eventWithState.actionExecutionId).catch((error) => {
+            console.error(error);
+          });
+          return (0, import_rxjs.concat)((0, import_rxjs.of)(eventWithState.event), toolCallEventStream$);
+        } else {
+          return (0, import_rxjs.of)(eventWithState.event);
+        }
+      })
+    );
+  }
+};
+__name(RuntimeEventSource, "RuntimeEventSource");
+async function executeAction(eventStream$, action, actionArguments, actionExecutionId) {
+  let args = [];
+  if (actionArguments) {
+    args = JSON.parse(actionArguments);
+  }
+  const result = await action.handler(args);
+  await streamLangChainResponse({
+    result,
+    eventStream$,
+    actionExecution: {
+      name: action.name,
+      id: actionExecutionId
+    }
+  });
+}
+__name(executeAction, "executeAction");
+
+// src/service-adapters/conversion.ts
+var import_class_transformer = require("class-transformer");
+function convertGqlInputToMessages(inputMessages) {
+  const messages = [];
+  for (const message of inputMessages) {
+    if (message.textMessage) {
+      messages.push((0, import_class_transformer.plainToInstance)(TextMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        role: message.textMessage.role,
+        content: message.textMessage.content
+      }));
+    } else if (message.actionExecutionMessage) {
+      messages.push((0, import_class_transformer.plainToInstance)(ActionExecutionMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        name: message.actionExecutionMessage.name,
+        arguments: JSON.parse(message.actionExecutionMessage.arguments),
+        scope: message.actionExecutionMessage.scope
+      }));
+    } else if (message.resultMessage) {
+      messages.push((0, import_class_transformer.plainToInstance)(ResultMessage, {
+        id: message.id,
+        createdAt: message.createdAt,
+        actionExecutionId: message.resultMessage.actionExecutionId,
+        actionName: message.resultMessage.actionName,
+        result: message.resultMessage.result
+      }));
+    }
+  }
+  return messages;
+}
+__name(convertGqlInputToMessages, "convertGqlInputToMessages");
+
+// src/lib/copilot-runtime.ts
+var CopilotRuntime = class {
+  actions = [];
+  langserve = [];
+  debug = false;
+  copilotCloud;
+  constructor(params) {
+    this.actions = (params == null ? void 0 : params.actions) || [];
+    for (const chain of (params == null ? void 0 : params.langserve) || []) {
+      const remoteChain = new RemoteChain(chain);
+      this.langserve.push(remoteChain.toAction());
+    }
+    this.debug = (params == null ? void 0 : params.debug) || false;
+    this.copilotCloud = (params == null ? void 0 : params.copilotCloud) || new RemoteCopilotCloud();
+  }
+  addAction(action) {
+    this.removeAction(action.name);
+    this.actions.push(action);
+  }
+  removeAction(actionName) {
+    this.actions = this.actions.filter((f) => f.name !== actionName);
+  }
+  async process({ serviceAdapter, messages, actions: clientSideActionsInput, threadId, runId, publicApiKey }) {
+    const langserveFunctions = [];
+    for (const chainPromise of this.langserve) {
+      try {
+        const chain = await chainPromise;
+        langserveFunctions.push(chain);
+      } catch (error) {
+        console.error("Error loading langserve chain:", error);
+      }
+    }
+    const serverSideActionsInput = [
+      ...this.actions,
+      ...langserveFunctions
+    ].map((action) => ({
+      name: action.name,
+      description: action.description,
+      jsonSchema: JSON.stringify((0, import_shared2.actionParametersToJsonSchema)(action.parameters))
+    }));
+    const actions = flattenToolCallsNoDuplicates([
+      ...serverSideActionsInput,
+      ...clientSideActionsInput
+    ]);
+    try {
+      const eventSource = new RuntimeEventSource();
+      const result = await serviceAdapter.process({
+        messages: convertGqlInputToMessages(messages),
+        actions,
+        threadId,
+        runId,
+        eventSource
+      });
+      return {
+        threadId: result.threadId,
+        runId: result.runId,
+        eventSource
+      };
+    } catch (error) {
+      console.error("Error getting response:", error);
+      throw error;
+    }
+  }
+};
+__name(CopilotRuntime, "CopilotRuntime");
+function flattenToolCallsNoDuplicates(toolsByPriority) {
+  let allTools = [];
+  const allToolNames = [];
+  for (const tool of toolsByPriority) {
+    if (!allToolNames.includes(tool.name)) {
+      allTools.push(tool);
+      allToolNames.push(tool.name);
+    }
+  }
+  return allTools;
+}
+__name(flattenToolCallsNoDuplicates, "flattenToolCallsNoDuplicates");
+var CopilotBackend = class extends CopilotRuntime {
+};
+__name(CopilotBackend, "CopilotBackend");
+
+// src/lib/integrations/shared.ts
+var import_type_graphql13 = require("type-graphql");
+
+// src/graphql/resolvers/copilot.resolver.ts
+var import_type_graphql12 = require("type-graphql");
+var import_rxjs2 = require("rxjs");
+
+// src/graphql/inputs/generate-copilot-response.input.ts
+var import_type_graphql8 = require("type-graphql");
+
+// src/graphql/inputs/message.input.ts
+var import_type_graphql3 = require("type-graphql");
+
+// src/graphql/types/enums.ts
+var import_type_graphql2 = require("type-graphql");
+var MessageRole;
+(function(MessageRole2) {
+  MessageRole2["user"] = "user";
+  MessageRole2["assistant"] = "assistant";
+  MessageRole2["system"] = "system";
+})(MessageRole || (MessageRole = {}));
+var ActionExecutionScope;
+(function(ActionExecutionScope2) {
+  ActionExecutionScope2["server"] = "server";
+  ActionExecutionScope2["client"] = "client";
+})(ActionExecutionScope || (ActionExecutionScope = {}));
+(0, import_type_graphql2.registerEnumType)(MessageRole, {
+  name: "MessageRole",
+  description: "The role of the message"
+});
+(0, import_type_graphql2.registerEnumType)(ActionExecutionScope, {
+  name: "ActionExecutionScope",
+  description: "The scope of the action"
+});
+
+// src/graphql/inputs/message.input.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var MessageInput = class extends BaseMessage {
+  textMessage;
+  actionExecutionMessage;
+  resultMessage;
+};
+__name(MessageInput, "MessageInput");
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => TextMessageInput, {
+    nullable: true
+  }),
+  _ts_metadata2("design:type", typeof TextMessageInput === "undefined" ? Object : TextMessageInput)
+], MessageInput.prototype, "textMessage", void 0);
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => ActionExecutionMessageInput, {
+    nullable: true
+  }),
+  _ts_metadata2("design:type", typeof ActionExecutionMessageInput === "undefined" ? Object : ActionExecutionMessageInput)
+], MessageInput.prototype, "actionExecutionMessage", void 0);
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => ResultMessageInput, {
+    nullable: true
+  }),
+  _ts_metadata2("design:type", typeof ResultMessageInput === "undefined" ? Object : ResultMessageInput)
+], MessageInput.prototype, "resultMessage", void 0);
+MessageInput = _ts_decorate2([
+  (0, import_type_graphql3.InputType)()
+], MessageInput);
+var TextMessageInput = class {
+  content;
+  role;
+};
+__name(TextMessageInput, "TextMessageInput");
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => String),
+  _ts_metadata2("design:type", String)
+], TextMessageInput.prototype, "content", void 0);
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => MessageRole),
+  _ts_metadata2("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+], TextMessageInput.prototype, "role", void 0);
+TextMessageInput = _ts_decorate2([
+  (0, import_type_graphql3.InputType)()
+], TextMessageInput);
+var ActionExecutionMessageInput = class {
+  name;
+  arguments;
+  scope;
+};
+__name(ActionExecutionMessageInput, "ActionExecutionMessageInput");
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => String),
+  _ts_metadata2("design:type", String)
+], ActionExecutionMessageInput.prototype, "name", void 0);
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => String),
+  _ts_metadata2("design:type", String)
+], ActionExecutionMessageInput.prototype, "arguments", void 0);
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => ActionExecutionScope),
+  _ts_metadata2("design:type", typeof ActionExecutionScope === "undefined" ? Object : ActionExecutionScope)
+], ActionExecutionMessageInput.prototype, "scope", void 0);
+ActionExecutionMessageInput = _ts_decorate2([
+  (0, import_type_graphql3.InputType)()
+], ActionExecutionMessageInput);
+var ResultMessageInput = class {
+  actionExecutionId;
+  actionName;
+  result;
+};
+__name(ResultMessageInput, "ResultMessageInput");
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => String),
+  _ts_metadata2("design:type", String)
+], ResultMessageInput.prototype, "actionExecutionId", void 0);
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => String),
+  _ts_metadata2("design:type", String)
+], ResultMessageInput.prototype, "actionName", void 0);
+_ts_decorate2([
+  (0, import_type_graphql3.Field)(() => String),
+  _ts_metadata2("design:type", String)
+], ResultMessageInput.prototype, "result", void 0);
+ResultMessageInput = _ts_decorate2([
+  (0, import_type_graphql3.InputType)()
+], ResultMessageInput);
+
+// src/graphql/inputs/frontend.input.ts
+var import_type_graphql5 = require("type-graphql");
+
+// src/graphql/inputs/action.input.ts
+var import_type_graphql4 = require("type-graphql");
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var ActionInput = class {
+  name;
+  description;
+  jsonSchema;
+};
+__name(ActionInput, "ActionInput");
+_ts_decorate3([
+  (0, import_type_graphql4.Field)(() => String),
+  _ts_metadata3("design:type", String)
+], ActionInput.prototype, "name", void 0);
+_ts_decorate3([
+  (0, import_type_graphql4.Field)(() => String),
+  _ts_metadata3("design:type", String)
+], ActionInput.prototype, "description", void 0);
+_ts_decorate3([
+  (0, import_type_graphql4.Field)(() => String),
+  _ts_metadata3("design:type", String)
+], ActionInput.prototype, "jsonSchema", void 0);
+ActionInput = _ts_decorate3([
+  (0, import_type_graphql4.InputType)()
+], ActionInput);
+
+// src/graphql/inputs/frontend.input.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var FrontendInput = class {
+  toDeprecate_fullContext;
+  actions;
+};
+__name(FrontendInput, "FrontendInput");
+_ts_decorate4([
+  (0, import_type_graphql5.Field)(() => String, {
+    nullable: true
+  }),
+  _ts_metadata4("design:type", String)
+], FrontendInput.prototype, "toDeprecate_fullContext", void 0);
+_ts_decorate4([
+  (0, import_type_graphql5.Field)(() => [
+    ActionInput
+  ]),
+  _ts_metadata4("design:type", Array)
+], FrontendInput.prototype, "actions", void 0);
+FrontendInput = _ts_decorate4([
+  (0, import_type_graphql5.InputType)()
+], FrontendInput);
+
+// src/graphql/inputs/cloud.input.ts
+var import_type_graphql7 = require("type-graphql");
+
+// src/graphql/inputs/cloud-guardrails.input.ts
+var import_type_graphql6 = require("type-graphql");
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var GuardrailsRuleInput = class {
+  id;
+  allowList = [];
+  denyList = [];
+};
+__name(GuardrailsRuleInput, "GuardrailsRuleInput");
+_ts_decorate5([
+  (0, import_type_graphql6.Field)(() => String),
+  _ts_metadata5("design:type", String)
+], GuardrailsRuleInput.prototype, "id", void 0);
+_ts_decorate5([
+  (0, import_type_graphql6.Field)(() => [
+    String
+  ], {
+    nullable: true
+  }),
+  _ts_metadata5("design:type", Array)
+], GuardrailsRuleInput.prototype, "allowList", void 0);
+_ts_decorate5([
+  (0, import_type_graphql6.Field)(() => [
+    String
+  ], {
+    nullable: true
+  }),
+  _ts_metadata5("design:type", Array)
+], GuardrailsRuleInput.prototype, "denyList", void 0);
+GuardrailsRuleInput = _ts_decorate5([
+  (0, import_type_graphql6.InputType)()
+], GuardrailsRuleInput);
+var GuardrailsInput = class {
+  inputValidationRules = [];
+};
+__name(GuardrailsInput, "GuardrailsInput");
+_ts_decorate5([
+  (0, import_type_graphql6.Field)(() => [
+    GuardrailsRuleInput
+  ], {
+    nullable: true
+  }),
+  _ts_metadata5("design:type", Array)
+], GuardrailsInput.prototype, "inputValidationRules", void 0);
+GuardrailsInput = _ts_decorate5([
+  (0, import_type_graphql6.InputType)()
+], GuardrailsInput);
+
+// src/graphql/inputs/cloud.input.ts
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+var CloudInput = class {
+  guardrails;
+};
+__name(CloudInput, "CloudInput");
+_ts_decorate6([
+  (0, import_type_graphql7.Field)(() => GuardrailsInput),
+  _ts_metadata6("design:type", typeof GuardrailsInput === "undefined" ? Object : GuardrailsInput)
+], CloudInput.prototype, "guardrails", void 0);
+CloudInput = _ts_decorate6([
+  (0, import_type_graphql7.InputType)()
+], CloudInput);
+
+// src/graphql/inputs/generate-copilot-response.input.ts
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+var GenerateCopilotResponseInput = class {
+  threadId;
+  runId;
+  messages;
+  frontend;
+  cloud;
+};
+__name(GenerateCopilotResponseInput, "GenerateCopilotResponseInput");
+_ts_decorate7([
+  (0, import_type_graphql8.Field)(() => String, {
+    nullable: true
+  }),
+  _ts_metadata7("design:type", String)
+], GenerateCopilotResponseInput.prototype, "threadId", void 0);
+_ts_decorate7([
+  (0, import_type_graphql8.Field)(() => String, {
+    nullable: true
+  }),
+  _ts_metadata7("design:type", String)
+], GenerateCopilotResponseInput.prototype, "runId", void 0);
+_ts_decorate7([
+  (0, import_type_graphql8.Field)(() => [
+    MessageInput
+  ]),
+  _ts_metadata7("design:type", Array)
+], GenerateCopilotResponseInput.prototype, "messages", void 0);
+_ts_decorate7([
+  (0, import_type_graphql8.Field)(() => FrontendInput),
+  _ts_metadata7("design:type", typeof FrontendInput === "undefined" ? Object : FrontendInput)
+], GenerateCopilotResponseInput.prototype, "frontend", void 0);
+_ts_decorate7([
+  (0, import_type_graphql8.Field)(() => CloudInput, {
+    nullable: true
+  }),
+  _ts_metadata7("design:type", typeof CloudInput === "undefined" ? Object : CloudInput)
+], GenerateCopilotResponseInput.prototype, "cloud", void 0);
+GenerateCopilotResponseInput = _ts_decorate7([
+  (0, import_type_graphql8.InputType)()
+], GenerateCopilotResponseInput);
+
+// src/graphql/types/copilot-response.type.ts
+var import_type_graphql11 = require("type-graphql");
+
+// src/graphql/types/message-status.type.ts
+var import_type_graphql9 = require("type-graphql");
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+var MessageStatusCode;
+(function(MessageStatusCode2) {
+  MessageStatusCode2["Pending"] = "pending";
+  MessageStatusCode2["Success"] = "success";
+  MessageStatusCode2["Failed"] = "failed";
+})(MessageStatusCode || (MessageStatusCode = {}));
+(0, import_type_graphql9.registerEnumType)(MessageStatusCode, {
+  name: "MessageStatusCode"
+});
+var BaseMessageStatus = /* @__PURE__ */ __name(class BaseMessageStatus2 {
+  code;
+}, "BaseMessageStatus");
+_ts_decorate8([
+  (0, import_type_graphql9.Field)(() => MessageStatusCode),
+  _ts_metadata8("design:type", String)
+], BaseMessageStatus.prototype, "code", void 0);
+BaseMessageStatus = _ts_decorate8([
+  (0, import_type_graphql9.ObjectType)()
+], BaseMessageStatus);
+var PendingMessageStatus = class extends BaseMessageStatus {
+  code = "pending";
+};
+__name(PendingMessageStatus, "PendingMessageStatus");
+PendingMessageStatus = _ts_decorate8([
+  (0, import_type_graphql9.ObjectType)()
+], PendingMessageStatus);
+var SuccessMessageStatus = class extends BaseMessageStatus {
+  code = "success";
+};
+__name(SuccessMessageStatus, "SuccessMessageStatus");
+SuccessMessageStatus = _ts_decorate8([
+  (0, import_type_graphql9.ObjectType)()
+], SuccessMessageStatus);
+var FailedMessageStatus = class extends BaseMessageStatus {
+  code = "failed";
+  reason;
+};
+__name(FailedMessageStatus, "FailedMessageStatus");
+_ts_decorate8([
+  (0, import_type_graphql9.Field)(() => String),
+  _ts_metadata8("design:type", String)
+], FailedMessageStatus.prototype, "reason", void 0);
+FailedMessageStatus = _ts_decorate8([
+  (0, import_type_graphql9.ObjectType)()
+], FailedMessageStatus);
+var MessageStatusUnion = (0, import_type_graphql9.createUnionType)({
+  name: "MessageStatus",
+  types: () => [
+    PendingMessageStatus,
+    SuccessMessageStatus,
+    FailedMessageStatus
+  ]
+});
+
+// src/graphql/types/response-status.type.ts
+var import_type_graphql10 = require("type-graphql");
+function _ts_decorate9(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+var ResponseStatusCode;
+(function(ResponseStatusCode2) {
+  ResponseStatusCode2["Pending"] = "pending";
+  ResponseStatusCode2["Success"] = "success";
+  ResponseStatusCode2["Failed"] = "failed";
+})(ResponseStatusCode || (ResponseStatusCode = {}));
+(0, import_type_graphql10.registerEnumType)(ResponseStatusCode, {
+  name: "ResponseStatusCode"
+});
+var BaseResponseStatus = /* @__PURE__ */ __name(class BaseResponseStatus2 {
+  code;
+}, "BaseResponseStatus");
+_ts_decorate9([
+  (0, import_type_graphql10.Field)(() => ResponseStatusCode),
+  _ts_metadata9("design:type", String)
+], BaseResponseStatus.prototype, "code", void 0);
+BaseResponseStatus = _ts_decorate9([
+  (0, import_type_graphql10.InterfaceType)({
+    resolveType(value) {
+      if (value.code === "success") {
+        return SuccessResponseStatus;
+      } else if (value.code === "failed") {
+        return FailedResponseStatus;
+      } else if (value.code === "pending") {
+        return PendingResponseStatus;
+      }
+      return void 0;
+    }
+  }),
+  (0, import_type_graphql10.ObjectType)()
+], BaseResponseStatus);
+var PendingResponseStatus = class extends BaseResponseStatus {
+  code = "pending";
+};
+__name(PendingResponseStatus, "PendingResponseStatus");
+PendingResponseStatus = _ts_decorate9([
+  (0, import_type_graphql10.ObjectType)({
+    implements: BaseResponseStatus
+  })
+], PendingResponseStatus);
+var SuccessResponseStatus = class extends BaseResponseStatus {
+  code = "success";
+};
+__name(SuccessResponseStatus, "SuccessResponseStatus");
+SuccessResponseStatus = _ts_decorate9([
+  (0, import_type_graphql10.ObjectType)({
+    implements: BaseResponseStatus
+  })
+], SuccessResponseStatus);
+var FailedResponseStatus = class extends BaseResponseStatus {
+  code = "failed";
+  reason;
+};
+__name(FailedResponseStatus, "FailedResponseStatus");
+_ts_decorate9([
+  (0, import_type_graphql10.Field)(() => String),
+  _ts_metadata9("design:type", String)
+], FailedResponseStatus.prototype, "reason", void 0);
+FailedResponseStatus = _ts_decorate9([
+  (0, import_type_graphql10.ObjectType)({
+    implements: BaseResponseStatus
+  })
+], FailedResponseStatus);
+var ResponseStatusUnion = (0, import_type_graphql10.createUnionType)({
+  name: "ResponseStatus",
+  types: () => [
+    PendingResponseStatus,
+    SuccessResponseStatus,
+    FailedResponseStatus
+  ]
+});
+
+// src/graphql/types/copilot-response.type.ts
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+var BaseMessageOutput = /* @__PURE__ */ __name(class BaseMessageOutput2 {
+  id;
+  createdAt;
+  status;
+}, "BaseMessageOutput");
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => String),
+  _ts_metadata10("design:type", String)
+], BaseMessageOutput.prototype, "id", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => Date),
+  _ts_metadata10("design:type", typeof Date === "undefined" ? Object : Date)
+], BaseMessageOutput.prototype, "createdAt", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => MessageStatusUnion),
+  _ts_metadata10("design:type", Object)
+], BaseMessageOutput.prototype, "status", void 0);
+BaseMessageOutput = _ts_decorate10([
+  (0, import_type_graphql11.InterfaceType)({
+    resolveType(value) {
+      if (value.hasOwnProperty("content")) {
+        return TextMessageOutput;
+      } else if (value.hasOwnProperty("name")) {
+        return ActionExecutionMessageOutput;
+      } else if (value.hasOwnProperty("result")) {
+        return ResultMessageOutput;
+      }
+      return void 0;
+    }
+  })
+], BaseMessageOutput);
+var TextMessageOutput = class {
+  role;
+  content;
+};
+__name(TextMessageOutput, "TextMessageOutput");
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => MessageRole),
+  _ts_metadata10("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+], TextMessageOutput.prototype, "role", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => [
+    String
+  ]),
+  _ts_metadata10("design:type", Array)
+], TextMessageOutput.prototype, "content", void 0);
+TextMessageOutput = _ts_decorate10([
+  (0, import_type_graphql11.ObjectType)({
+    implements: BaseMessageOutput
+  })
+], TextMessageOutput);
+var ActionExecutionMessageOutput = class {
+  name;
+  scope;
+  arguments;
+};
+__name(ActionExecutionMessageOutput, "ActionExecutionMessageOutput");
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => String),
+  _ts_metadata10("design:type", String)
+], ActionExecutionMessageOutput.prototype, "name", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => ActionExecutionScope),
+  _ts_metadata10("design:type", typeof ActionExecutionScope === "undefined" ? Object : ActionExecutionScope)
+], ActionExecutionMessageOutput.prototype, "scope", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => [
+    String
+  ]),
+  _ts_metadata10("design:type", Array)
+], ActionExecutionMessageOutput.prototype, "arguments", void 0);
+ActionExecutionMessageOutput = _ts_decorate10([
+  (0, import_type_graphql11.ObjectType)({
+    implements: BaseMessageOutput
+  })
+], ActionExecutionMessageOutput);
+var ResultMessageOutput = class {
+  actionExecutionId;
+  actionName;
+  result;
+};
+__name(ResultMessageOutput, "ResultMessageOutput");
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => String),
+  _ts_metadata10("design:type", String)
+], ResultMessageOutput.prototype, "actionExecutionId", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => String),
+  _ts_metadata10("design:type", String)
+], ResultMessageOutput.prototype, "actionName", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => String),
+  _ts_metadata10("design:type", String)
+], ResultMessageOutput.prototype, "result", void 0);
+ResultMessageOutput = _ts_decorate10([
+  (0, import_type_graphql11.ObjectType)({
+    implements: BaseMessageOutput
+  })
+], ResultMessageOutput);
+var CopilotResponse = class {
+  threadId;
+  status;
+  runId;
+  messages;
+};
+__name(CopilotResponse, "CopilotResponse");
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => String),
+  _ts_metadata10("design:type", String)
+], CopilotResponse.prototype, "threadId", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => ResponseStatusUnion),
+  _ts_metadata10("design:type", Object)
+], CopilotResponse.prototype, "status", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)({
+    nullable: true
+  }),
+  _ts_metadata10("design:type", String)
+], CopilotResponse.prototype, "runId", void 0);
+_ts_decorate10([
+  (0, import_type_graphql11.Field)(() => [
+    BaseMessageOutput
+  ]),
+  _ts_metadata10("design:type", Array)
+], CopilotResponse.prototype, "messages", void 0);
+CopilotResponse = _ts_decorate10([
+  (0, import_type_graphql11.ObjectType)()
+], CopilotResponse);
+
+// src/graphql/resolvers/copilot.resolver.ts
+var import_graphql_yoga = require("graphql-yoga");
+var import_nanoid3 = require("nanoid");
+var import_graphql_scalars = require("graphql-scalars");
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var CopilotResolver = class {
+  async hello() {
+    return "Hello World";
+  }
+  async generateCopilotResponse(ctx, data, properties) {
+    if (properties) {
+      ctx._copilotkit.properties = {
+        ...ctx._copilotkit.properties,
+        ...properties
+      };
+    }
+    const copilotRuntime = ctx._copilotkit.runtime;
+    const serviceAdapter = ctx._copilotkit.serviceAdapter;
+    const responseStatus = new import_rxjs2.Subject();
+    const { eventSource, threadId = (0, import_nanoid3.nanoid)(), runId } = await copilotRuntime.process({
+      serviceAdapter,
+      messages: data.messages,
+      actions: data.frontend.actions,
+      threadId: data.threadId,
+      runId: data.runId,
+      publicApiKey: void 0
+    });
+    const response = {
+      threadId,
+      runId,
+      status: (0, import_rxjs2.firstValueFrom)(responseStatus),
+      messages: new import_graphql_yoga.Repeater(async (pushMessage, stopStreamingMessages) => {
+        const eventStream = eventSource.process(copilotRuntime.actions).pipe(
+          // shareReplay() ensures that later subscribers will see the whole stream instead of
+          // just the events that were emitted after the subscriber was added.
+          (0, import_rxjs2.shareReplay)()
+        );
+        eventStream.subscribe({
+          next: async (event) => {
+            switch (event.type) {
+              case RuntimeEventTypes.TextMessageStart:
+                const textMessageContentStream = eventStream.pipe(
+                  // skip until this message start event
+                  (0, import_rxjs2.skipWhile)((e) => e !== event),
+                  // take until the message end event
+                  (0, import_rxjs2.takeWhile)((e) => e.type != RuntimeEventTypes.TextMessageEnd)
+                );
+                const streamingTextStatus = new import_rxjs2.Subject();
+                pushMessage({
+                  id: (0, import_nanoid3.nanoid)(),
+                  status: (0, import_rxjs2.firstValueFrom)(streamingTextStatus),
+                  createdAt: /* @__PURE__ */ new Date(),
+                  role: MessageRole.assistant,
+                  content: new import_graphql_yoga.Repeater(async (pushTextChunk, stopStreamingText) => {
+                    await textMessageContentStream.forEach(async (e) => {
+                      if (e.type == RuntimeEventTypes.TextMessageContent) {
+                        await pushTextChunk(e.content);
+                      }
+                    });
+                    stopStreamingText();
+                    streamingTextStatus.next(new SuccessMessageStatus());
+                  })
+                });
+                break;
+              case RuntimeEventTypes.ActionExecutionStart:
+                const actionExecutionArgumentStream = eventStream.pipe((0, import_rxjs2.skipWhile)((e) => e !== event), (0, import_rxjs2.takeWhile)((e) => e.type != RuntimeEventTypes.ActionExecutionEnd));
+                const streamingArgumentsStatus = new import_rxjs2.Subject();
+                pushMessage({
+                  id: event.actionExecutionId,
+                  status: (0, import_rxjs2.firstValueFrom)(streamingArgumentsStatus),
+                  createdAt: /* @__PURE__ */ new Date(),
+                  name: event.actionName,
+                  scope: event.scope,
+                  arguments: new import_graphql_yoga.Repeater(async (pushArgumentsChunk, stopStreamingArguments) => {
+                    await actionExecutionArgumentStream.forEach(async (e) => {
+                      if (e.type == RuntimeEventTypes.ActionExecutionArgs) {
+                        await pushArgumentsChunk(e.args);
+                      }
+                    });
+                    stopStreamingArguments();
+                    streamingArgumentsStatus.next(new SuccessMessageStatus());
+                  })
+                });
+                break;
+              case RuntimeEventTypes.ActionExecutionResult:
+                pushMessage({
+                  id: (0, import_nanoid3.nanoid)(),
+                  status: new SuccessMessageStatus(),
+                  createdAt: /* @__PURE__ */ new Date(),
+                  actionExecutionId: event.actionExecutionId,
+                  actionName: event.actionName,
+                  result: event.result
+                });
+                break;
+            }
+          },
+          error: (err) => console.error("Error in event source", err),
+          complete: () => {
+            responseStatus.next(new SuccessResponseStatus());
+            stopStreamingMessages();
+          }
+        });
+      })
+    };
+    return response;
+  }
+};
+__name(CopilotResolver, "CopilotResolver");
+_ts_decorate11([
+  (0, import_type_graphql12.Query)(() => String),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", []),
+  _ts_metadata11("design:returntype", Promise)
+], CopilotResolver.prototype, "hello", null);
+_ts_decorate11([
+  (0, import_type_graphql12.Mutation)(() => CopilotResponse),
+  _ts_param(0, (0, import_type_graphql12.Ctx)()),
+  _ts_param(1, (0, import_type_graphql12.Arg)("data")),
+  _ts_param(2, (0, import_type_graphql12.Arg)("properties", () => import_graphql_scalars.GraphQLJSONObject, {
+    nullable: true
+  })),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof GraphQLContext === "undefined" ? Object : GraphQLContext,
+    typeof GenerateCopilotResponseInput === "undefined" ? Object : GenerateCopilotResponseInput,
+    typeof CopilotRequestContextProperties === "undefined" ? Object : CopilotRequestContextProperties
+  ]),
+  _ts_metadata11("design:returntype", Promise)
+], CopilotResolver.prototype, "generateCopilotResponse", null);
+CopilotResolver = _ts_decorate11([
+  (0, import_type_graphql12.Resolver)(() => CopilotResponse)
+], CopilotResolver);
+
+// src/lib/integrations/shared.ts
+var import_plugin_defer_stream = require("@graphql-yoga/plugin-defer-stream");
+async function createContext(initialContext, copilotKitContext) {
+  const ctx = {
+    ...initialContext,
+    _copilotkit: {
+      ...copilotKitContext
+    }
+  };
+  return ctx;
+}
+__name(createContext, "createContext");
+function buildSchema(options = {}) {
+  const schema = (0, import_type_graphql13.buildSchemaSync)({
+    resolvers: [
+      CopilotResolver
+    ],
+    emitSchemaFile: options.emitSchemaFile
+  });
+  return schema;
+}
+__name(buildSchema, "buildSchema");
+function getCommonConfig(options) {
+  return {
+    schema: buildSchema(),
+    plugins: [
+      (0, import_plugin_defer_stream.useDeferStream)()
+    ],
+    context: (ctx) => createContext(ctx, {
+      runtime: options.runtime,
+      serviceAdapter: options.serviceAdapter,
+      properties: {}
+    })
+  };
+}
+__name(getCommonConfig, "getCommonConfig");
+
+// src/lib/integrations/nextjs/app-router.ts
+var import_graphql_yoga2 = require("graphql-yoga");
+function copilotRuntimeNextJSAppRouterEndpoint({ runtime, endpoint, serviceAdapter }) {
+  const commonConfig = getCommonConfig({
+    runtime,
+    serviceAdapter
+  });
+  const yoga = (0, import_graphql_yoga2.createYoga)({
+    ...commonConfig,
+    graphqlEndpoint: endpoint,
+    fetchAPI: {
+      Response: globalThis.Response
+    }
+  });
+  return {
+    handleRequest: yoga,
+    GET: yoga,
+    POST: yoga,
+    OPTIONS: yoga
+  };
+}
+__name(copilotRuntimeNextJSAppRouterEndpoint, "copilotRuntimeNextJSAppRouterEndpoint");
+
+// src/lib/integrations/nextjs/pages-router.ts
+var import_graphql_yoga3 = require("graphql-yoga");
+var config = {
+  api: {
+    bodyParser: false
+  }
+};
+function copilotRuntimeNextJSPagesRouterEndpoint({ runtime, endpoint, serviceAdapter }) {
+  const commonConfig = getCommonConfig({
+    runtime,
+    serviceAdapter
+  });
+  const yoga = (0, import_graphql_yoga3.createYoga)({
+    ...commonConfig,
+    graphqlEndpoint: endpoint
+  });
+  return yoga;
+}
+__name(copilotRuntimeNextJSPagesRouterEndpoint, "copilotRuntimeNextJSPagesRouterEndpoint");
+
+// src/lib/integrations/node-http/index.ts
+var import_graphql_yoga4 = require("graphql-yoga");
+function copilotRuntimeNodeHttpEndpoint({ runtime, endpoint, serviceAdapter }) {
+  const commonConfig = getCommonConfig({
+    runtime,
+    serviceAdapter
+  });
+  const yoga = (0, import_graphql_yoga4.createYoga)({
+    ...commonConfig,
+    graphqlEndpoint: endpoint
+  });
+  return yoga;
+}
+__name(copilotRuntimeNodeHttpEndpoint, "copilotRuntimeNodeHttpEndpoint");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CopilotBackend,
+  CopilotCloud,
+  CopilotRuntime,
+  GoogleGenerativeAIAdapter,
+  LangChainAdapter,
+  OpenAIAdapter,
+  OpenAIAssistantAdapter,
+  RemoteCopilotCloud,
+  buildSchema,
+  config,
+  copilotRuntimeNextJSAppRouterEndpoint,
+  copilotRuntimeNextJSPagesRouterEndpoint,
+  copilotRuntimeNodeHttpEndpoint,
+  createContext,
+  flattenToolCallsNoDuplicates,
+  getCommonConfig
+});
+//# sourceMappingURL=index.js.map