@copilotkit/runtime 0.37.0 → 0.38.0-beta.0

package/dist/lib/index.js

@@ -30,14 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/lib/index.ts
 var lib_exports = {};
 __export(lib_exports, {
-  CopilotBackend: () => CopilotBackend,
-  CopilotCloud: () => CopilotCloud,
   CopilotRuntime: () => CopilotRuntime,
   GoogleGenerativeAIAdapter: () => GoogleGenerativeAIAdapter,
   LangChainAdapter: () => LangChainAdapter,
   OpenAIAdapter: () => OpenAIAdapter,
   OpenAIAssistantAdapter: () => OpenAIAssistantAdapter,
-  RemoteCopilotCloud: () => RemoteCopilotCloud,
   buildSchema: () => buildSchema,
   config: () => config,
   copilotRuntimeNextJSAppRouterEndpoint: () => copilotRuntimeNextJSAppRouterEndpoint,
@@ -50,7 +47,7 @@ __export(lib_exports, {
 module.exports = __toCommonJS(lib_exports);
 
 // src/lib/copilot-runtime.ts
-var import_shared2 = require("@copilotkit/shared");
+var import_shared = require("@copilotkit/shared");
 
 // src/service-adapters/openai/openai-adapter.ts
 var import_openai = __toESM(require("openai"));
@@ -256,6 +253,7 @@ function convertSystemMessageToAssistantAPI(message) {
 __name(convertSystemMessageToAssistantAPI, "convertSystemMessageToAssistantAPI");
 
 // src/service-adapters/openai/openai-adapter.ts
+var import_nanoid = require("nanoid");
 var DEFAULT_MODEL = "gpt-4o";
 var OpenAIAdapter = class {
   model = DEFAULT_MODEL;
@@ -269,7 +267,8 @@ var OpenAIAdapter = class {
       this.model = params.model;
     }
   }
-  async process({ model = this.model, messages, actions, eventSource }) {
+  async process(request) {
+    const { threadId, model = this.model, messages, actions, eventSource } = request;
     const tools = actions.map(convertActionInputToOpenAITool);
     let openaiMessages = messages.map(convertMessageToOpenAIMessage);
     openaiMessages = limitMessagesToTokenCount(openaiMessages, tools, model);
@@ -316,7 +315,9 @@ var OpenAIAdapter = class {
       }
       eventStream$.complete();
     });
-    return {};
+    return {
+      threadId: threadId || (0, import_nanoid.nanoid)()
+    };
   }
 };
 __name(OpenAIAdapter, "OpenAIAdapter");
@@ -334,8 +335,9 @@ var OpenAIAssistantAdapter = class {
     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);
+  async process(request) {
+    const { messages, actions, eventSource, runId } = request;
+    let threadId = request.threadId || (await this.openai.beta.threads.create()).id;
     const lastMessage = messages.at(-1);
     let nextRunId = void 0;
     if (lastMessage instanceof ResultMessage && runId) {
@@ -505,7 +507,7 @@ function convertMessageToGoogleGenAIMessage(message) {
     };
   } else if (message instanceof ResultMessage) {
     return {
-      role: "model",
+      role: "function",
       parts: [
         {
           functionResponse: {
@@ -560,7 +562,7 @@ function tryParseJson(str) {
 __name(tryParseJson, "tryParseJson");
 
 // src/service-adapters/google/google-genai-adapter.ts
-var import_nanoid = require("nanoid");
+var import_nanoid2 = require("nanoid");
 var GoogleGenerativeAIAdapter = class {
   model;
   constructor(options) {
@@ -622,9 +624,12 @@ var GoogleGenerativeAIAdapter = class {
       let isTextMessage = false;
       for await (const chunk of result.stream) {
         const chunkText = chunk.text();
+        if (chunkText === "") {
+          continue;
+        }
         if (!isTextMessage) {
           isTextMessage = true;
-          eventStream$.sendTextMessageStart((0, import_nanoid.nanoid)());
+          eventStream$.sendTextMessageStart((0, import_nanoid2.nanoid)());
         }
         eventStream$.sendTextMessageContent(chunkText);
       }
@@ -634,12 +639,14 @@ var GoogleGenerativeAIAdapter = class {
       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$.sendActionExecution((0, import_nanoid2.nanoid)(), call.name, JSON.stringify(replaceNewlinesInObject(call.args)));
         }
       }
       eventStream$.complete();
     });
-    return {};
+    return {
+      threadId: request.threadId || (0, import_nanoid2.nanoid)()
+    };
   }
 };
 __name(GoogleGenerativeAIAdapter, "GoogleGenerativeAIAdapter");
@@ -665,7 +672,7 @@ __name(replaceNewlinesInObject, "replaceNewlinesInObject");
 var import_messages = require("@langchain/core/messages");
 var import_tools = require("@langchain/core/tools");
 var import_zod = require("zod");
-var import_nanoid2 = require("nanoid");
+var import_nanoid3 = require("nanoid");
 function convertMessageToLangChainMessage(message) {
   if (message instanceof TextMessage) {
     if (message.role == "user") {
@@ -729,31 +736,59 @@ function convertActionInputToLangChainTool(actionInput) {
   });
 }
 __name(convertActionInputToLangChainTool, "convertActionInputToLangChainTool");
+function getConstructorName(object) {
+  if (object && typeof object === "object" && object.constructor && object.constructor.name) {
+    return object.constructor.name;
+  }
+  return "";
+}
+__name(getConstructorName, "getConstructorName");
+function isAIMessage(message) {
+  return getConstructorName(message) === "AIMessage";
+}
+__name(isAIMessage, "isAIMessage");
+function isAIMessageChunk(message) {
+  return getConstructorName(message) === "AIMessageChunk";
+}
+__name(isAIMessageChunk, "isAIMessageChunk");
+function isBaseMessageChunk(message) {
+  return getConstructorName(message) === "BaseMessageChunk";
+}
+__name(isBaseMessageChunk, "isBaseMessageChunk");
+function maybeSendActionExecutionResultIsMessage(eventStream$, actionExecution) {
+  if (actionExecution) {
+    eventStream$.sendActionExecutionResult(actionExecution.id, actionExecution.name, "Sending a message");
+  }
+}
+__name(maybeSendActionExecutionResultIsMessage, "maybeSendActionExecutionResultIsMessage");
 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);
+      eventStream$.sendTextMessage((0, import_nanoid3.nanoid)(), result);
     } else {
       eventStream$.sendActionExecutionResult(actionExecution.id, actionExecution.name, result);
     }
-  } else if (result instanceof import_messages.AIMessage) {
+  } else if (isAIMessage(result)) {
+    maybeSendActionExecutionResultIsMessage(eventStream$, actionExecution);
     if (result.content) {
-      eventStream$.sendTextMessage((0, import_nanoid2.nanoid)(), result.content);
+      eventStream$.sendTextMessage((0, import_nanoid3.nanoid)(), result.content);
     }
     for (const toolCall of result.tool_calls) {
-      eventStream$.sendActionExecution(toolCall.id || (0, import_nanoid2.nanoid)(), toolCall.name, JSON.stringify(toolCall.args));
+      eventStream$.sendActionExecution(toolCall.id || (0, import_nanoid3.nanoid)(), toolCall.name, JSON.stringify(toolCall.args));
     }
-  } else if (result instanceof import_messages.BaseMessageChunk) {
+  } else if (isBaseMessageChunk(result)) {
+    maybeSendActionExecutionResultIsMessage(eventStream$, actionExecution);
     if ((_a = result.lc_kwargs) == null ? void 0 : _a.content) {
-      eventStream$.sendTextMessage((0, import_nanoid2.nanoid)(), result.content);
+      eventStream$.sendTextMessage((0, import_nanoid3.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));
+        eventStream$.sendActionExecution(toolCall.id || (0, import_nanoid3.nanoid)(), toolCall.name, JSON.stringify(toolCall.args));
       }
     }
-  } else if ("getReader" in result) {
+  } else if (result && "getReader" in result) {
+    maybeSendActionExecutionResultIsMessage(eventStream$, actionExecution);
     let reader = result.getReader();
     let mode = null;
     while (true) {
@@ -763,14 +798,14 @@ async function streamLangChainResponse({ result, eventStream$, actionExecution }
         let toolCallId = void 0;
         let toolCallArgs = void 0;
         let hasToolCall = false;
-        let content = value.content;
-        if (value instanceof import_messages.AIMessageChunk) {
+        let content = value == null ? void 0 : value.content;
+        if (isAIMessageChunk(value)) {
           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) {
+        } else if (isBaseMessageChunk(value)) {
           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;
@@ -793,7 +828,7 @@ async function streamLangChainResponse({ result, eventStream$, actionExecution }
             eventStream$.sendActionExecutionStart(toolCallId, toolCallName);
           } else if (content) {
             mode = "message";
-            eventStream$.sendTextMessageStart((0, import_nanoid2.nanoid)());
+            eventStream$.sendTextMessageStart((0, import_nanoid3.nanoid)());
           }
         }
         if (mode === "message" && content) {
@@ -807,15 +842,26 @@ async function streamLangChainResponse({ result, eventStream$, actionExecution }
       }
     }
   } else if (actionExecution) {
-    eventStream$.sendActionExecutionResult(actionExecution.id, actionExecution.name, JSON.stringify(result));
+    eventStream$.sendActionExecutionResult(actionExecution.id, actionExecution.name, encodeResult(result));
   } else {
     throw new Error("Invalid return type from LangChain function.");
   }
   eventStream$.complete();
 }
 __name(streamLangChainResponse, "streamLangChainResponse");
+function encodeResult(result) {
+  if (result === void 0) {
+    return "";
+  } else if (typeof result === "string") {
+    return result;
+  } else {
+    return JSON.stringify(result);
+  }
+}
+__name(encodeResult, "encodeResult");
 
 // src/service-adapters/langchain/langchain-adapter.ts
+var import_nanoid4 = require("nanoid");
 var LangChainAdapter = class {
   options;
   /**
@@ -824,7 +870,8 @@ var LangChainAdapter = class {
   constructor(options) {
     this.options = options;
   }
-  async process({ eventSource, model, actions, messages, threadId, runId }) {
+  async process(request) {
+    const { eventSource, model, actions, messages, threadId, runId } = request;
     const result = await this.options.chainFn({
       messages: messages.map(convertMessageToLangChainMessage),
       tools: actions.map(convertActionInputToLangChainTool),
@@ -838,7 +885,9 @@ var LangChainAdapter = class {
         eventStream$
       });
     });
-    return {};
+    return {
+      threadId: threadId || (0, import_nanoid4.nanoid)()
+    };
   }
 };
 __name(LangChainAdapter, "LangChainAdapter");
@@ -846,6 +895,11 @@ __name(LangChainAdapter, "LangChainAdapter");
 // src/service-adapters/langchain/langserve.ts
 var import_remote = require("langchain/runnables/remote");
 var RemoteChain = class {
+  name;
+  description;
+  chainUrl;
+  parameters;
+  parameterType;
   constructor(options) {
     this.name = options.name;
     this.description = options.description;
@@ -916,50 +970,6 @@ var RemoteChain = class {
 };
 __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;
@@ -1037,7 +1047,7 @@ var RuntimeEventSource = class {
   async stream(callback) {
     this.callback = callback;
   }
-  process(serversideActions) {
+  process({ serversideActions, guardrailsResult$ }) {
     this.callback(this.eventStream$).catch((error) => {
       console.error("Error in event source callback", error);
     });
@@ -1073,7 +1083,7 @@ var RuntimeEventSource = class {
       (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) => {
+          executeAction(toolCallEventStream$, guardrailsResult$ ? guardrailsResult$ : null, eventWithState.action, eventWithState.args, eventWithState.actionExecutionId).catch((error) => {
             console.error(error);
           });
           return (0, import_rxjs.concat)((0, import_rxjs.of)(eventWithState.event), toolCallEventStream$);
@@ -1085,7 +1095,14 @@ var RuntimeEventSource = class {
   }
 };
 __name(RuntimeEventSource, "RuntimeEventSource");
-async function executeAction(eventStream$, action, actionArguments, actionExecutionId) {
+async function executeAction(eventStream$, guardrailsResult$, action, actionArguments, actionExecutionId) {
+  if (guardrailsResult$) {
+    const { status } = await (0, import_rxjs.firstValueFrom)(guardrailsResult$);
+    if (status === "denied") {
+      eventStream$.complete();
+      return;
+    }
+  }
   let args = [];
   if (actionArguments) {
     args = JSON.parse(actionArguments);
@@ -1138,27 +1155,23 @@ __name(convertGqlInputToMessages, "convertGqlInputToMessages");
 
 // src/lib/copilot-runtime.ts
 var CopilotRuntime = class {
-  actions = [];
+  actions;
   langserve = [];
-  debug = false;
-  copilotCloud;
+  onBeforeRequest;
+  onAfterRequest;
   constructor(params) {
+    var _a, _b;
     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);
+    this.onBeforeRequest = (_a = params == null ? void 0 : params.middleware) == null ? void 0 : _a.onBeforeRequest;
+    this.onAfterRequest = (_b = params == null ? void 0 : params.middleware) == null ? void 0 : _b.onAfterRequest;
   }
-  async process({ serviceAdapter, messages, actions: clientSideActionsInput, threadId, runId, publicApiKey }) {
+  async process(request) {
+    var _a;
+    const { serviceAdapter, messages, actions: clientSideActionsInput, threadId, runId, properties, outputMessagesPromise } = request;
     const langserveFunctions = [];
     for (const chainPromise of this.langserve) {
       try {
@@ -1168,31 +1181,54 @@ var CopilotRuntime = class {
         console.error("Error loading langserve chain:", error);
       }
     }
-    const serverSideActionsInput = [
-      ...this.actions,
+    const configuredActions = typeof this.actions === "function" ? this.actions({
+      properties
+    }) : this.actions;
+    const actions = [
+      ...configuredActions,
       ...langserveFunctions
-    ].map((action) => ({
+    ];
+    const serverSideActionsInput = actions.map((action) => ({
       name: action.name,
       description: action.description,
-      jsonSchema: JSON.stringify((0, import_shared2.actionParametersToJsonSchema)(action.parameters))
+      jsonSchema: JSON.stringify((0, import_shared.actionParametersToJsonSchema)(action.parameters))
     }));
-    const actions = flattenToolCallsNoDuplicates([
+    const actionInputs = flattenToolCallsNoDuplicates([
       ...serverSideActionsInput,
       ...clientSideActionsInput
     ]);
+    const inputMessages = convertGqlInputToMessages(messages);
+    await ((_a = this.onBeforeRequest) == null ? void 0 : _a.call(this, {
+      threadId,
+      runId,
+      inputMessages,
+      properties
+    }));
     try {
       const eventSource = new RuntimeEventSource();
       const result = await serviceAdapter.process({
-        messages: convertGqlInputToMessages(messages),
-        actions,
+        messages: inputMessages,
+        actions: actionInputs,
         threadId,
         runId,
         eventSource
       });
+      outputMessagesPromise.then((outputMessages) => {
+        var _a2;
+        (_a2 = this.onAfterRequest) == null ? void 0 : _a2.call(this, {
+          threadId: result.threadId,
+          runId: result.runId,
+          inputMessages,
+          outputMessages,
+          properties
+        });
+      }).catch((_error) => {
+      });
       return {
         threadId: result.threadId,
         runId: result.runId,
-        eventSource
+        eventSource,
+        actions
       };
     } catch (error) {
       console.error("Error getting response:", error);
@@ -1213,9 +1249,6 @@ function flattenToolCallsNoDuplicates(toolsByPriority) {
   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");
@@ -1458,15 +1491,10 @@ function _ts_metadata5(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
@@ -1487,16 +1515,17 @@ GuardrailsRuleInput = _ts_decorate5([
   (0, import_type_graphql6.InputType)()
 ], GuardrailsRuleInput);
 var GuardrailsInput = class {
-  inputValidationRules = [];
+  inputValidationRules = {
+    allowList: [],
+    denyList: []
+  };
 };
 __name(GuardrailsInput, "GuardrailsInput");
 _ts_decorate5([
-  (0, import_type_graphql6.Field)(() => [
-    GuardrailsRuleInput
-  ], {
+  (0, import_type_graphql6.Field)(() => GuardrailsRuleInput, {
     nullable: true
   }),
-  _ts_metadata5("design:type", Array)
+  _ts_metadata5("design:type", typeof GuardrailsRuleInput === "undefined" ? Object : GuardrailsRuleInput)
 ], GuardrailsInput.prototype, "inputValidationRules", void 0);
 GuardrailsInput = _ts_decorate5([
   (0, import_type_graphql6.InputType)()
@@ -1524,7 +1553,9 @@ var CloudInput = class {
 };
 __name(CloudInput, "CloudInput");
 _ts_decorate6([
-  (0, import_type_graphql7.Field)(() => GuardrailsInput),
+  (0, import_type_graphql7.Field)(() => GuardrailsInput, {
+    nullable: true
+  }),
   _ts_metadata6("design:type", typeof GuardrailsInput === "undefined" ? Object : GuardrailsInput)
 ], CloudInput.prototype, "guardrails", void 0);
 CloudInput = _ts_decorate6([
@@ -1664,6 +1695,7 @@ var MessageStatusUnion = (0, import_type_graphql9.createUnionType)({
 });
 
 // src/graphql/types/response-status.type.ts
+var import_graphql_scalars = require("graphql-scalars");
 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;
@@ -1730,15 +1762,31 @@ SuccessResponseStatus = _ts_decorate9([
     implements: BaseResponseStatus
   })
 ], SuccessResponseStatus);
+var FailedResponseStatusReason;
+(function(FailedResponseStatusReason2) {
+  FailedResponseStatusReason2["GUARDRAILS_VALIDATION_FAILED"] = "GUARDRAILS_VALIDATION_FAILED";
+  FailedResponseStatusReason2["MESSAGE_STREAM_INTERRUPTED"] = "MESSAGE_STREAM_INTERRUPTED";
+  FailedResponseStatusReason2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(FailedResponseStatusReason || (FailedResponseStatusReason = {}));
+(0, import_type_graphql10.registerEnumType)(FailedResponseStatusReason, {
+  name: "FailedResponseStatusReason"
+});
 var FailedResponseStatus = class extends BaseResponseStatus {
   code = "failed";
   reason;
+  details = null;
 };
 __name(FailedResponseStatus, "FailedResponseStatus");
 _ts_decorate9([
-  (0, import_type_graphql10.Field)(() => String),
+  (0, import_type_graphql10.Field)(() => FailedResponseStatusReason),
   _ts_metadata9("design:type", String)
 ], FailedResponseStatus.prototype, "reason", void 0);
+_ts_decorate9([
+  (0, import_type_graphql10.Field)(() => import_graphql_scalars.GraphQLJSON, {
+    nullable: true
+  }),
+  _ts_metadata9("design:type", typeof Record === "undefined" ? Object : Record)
+], FailedResponseStatus.prototype, "details", void 0);
 FailedResponseStatus = _ts_decorate9([
   (0, import_type_graphql10.ObjectType)({
     implements: BaseResponseStatus
@@ -1902,8 +1950,45 @@ CopilotResponse = _ts_decorate10([
 
 // 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");
+var import_nanoid5 = require("nanoid");
+var import_graphql_scalars2 = require("graphql-scalars");
+var import_class_transformer2 = require("class-transformer");
+var import_graphql = require("graphql");
+
+// src/utils/failed-response-status-reasons.ts
+var GuardrailsValidationFailureResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.GUARDRAILS_VALIDATION_FAILED;
+  constructor({ guardrailsReason }) {
+    super();
+    this.details = {
+      guardrailsReason
+    };
+  }
+};
+__name(GuardrailsValidationFailureResponse, "GuardrailsValidationFailureResponse");
+var MessageStreamInterruptedResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.MESSAGE_STREAM_INTERRUPTED;
+  constructor({ messageId }) {
+    super();
+    this.details = {
+      messageId,
+      description: "Check the message for mode details"
+    };
+  }
+};
+__name(MessageStreamInterruptedResponse, "MessageStreamInterruptedResponse");
+var UnknownErrorResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.UNKNOWN_ERROR;
+  constructor({ description }) {
+    super();
+    this.details = {
+      description
+    };
+  }
+};
+__name(UnknownErrorResponse, "UnknownErrorResponse");
+
+// src/graphql/resolvers/copilot.resolver.ts
 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")
@@ -1926,39 +2011,173 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
+var invokeGuardrails = /* @__PURE__ */ __name(async ({ baseUrl, copilotCloudPublicApiKey, data, onResult, onError }) => {
+  var _a;
+  if (data.messages.length && ((_a = data.messages[data.messages.length - 1].textMessage) == null ? void 0 : _a.role) === MessageRole.user) {
+    const messages = data.messages.filter((m) => m.textMessage !== void 0 && (m.textMessage.role === MessageRole.user || m.textMessage.role === MessageRole.assistant)).map((m) => ({
+      role: m.textMessage.role,
+      content: m.textMessage.content
+    }));
+    const lastMessage = messages[messages.length - 1];
+    const restOfMessages = messages.slice(0, -1);
+    const body = {
+      input: lastMessage.content,
+      validTopics: data.cloud.guardrails.inputValidationRules.allowList,
+      invalidTopics: data.cloud.guardrails.inputValidationRules.denyList,
+      messages: restOfMessages
+    };
+    const guardrailsResult = await fetch(`${baseUrl}/guardrails/validate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-CopilotCloud-Public-API-Key": copilotCloudPublicApiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (guardrailsResult.ok) {
+      const resultJson = await guardrailsResult.json();
+      onResult(resultJson);
+    } else {
+      onError(await guardrailsResult.json());
+    }
+  }
+}, "invokeGuardrails");
 var CopilotResolver = class {
   async hello() {
     return "Hello World";
   }
   async generateCopilotResponse(ctx, data, properties) {
+    let logger2 = ctx.logger.child({
+      component: "CopilotResolver.generateCopilotResponse"
+    });
+    logger2.debug({
+      data
+    }, "Generating Copilot response");
+    const copilotRuntime = ctx._copilotkit.runtime;
+    const serviceAdapter = ctx._copilotkit.serviceAdapter;
     if (properties) {
-      ctx._copilotkit.properties = {
-        ...ctx._copilotkit.properties,
+      logger2.debug("Properties provided, merging with context properties");
+      ctx.properties = {
+        ...ctx.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({
+    let copilotCloudPublicApiKey = null;
+    let copilotCloudBaseUrl;
+    if (data.cloud) {
+      logger2 = logger2.child({
+        cloud: true
+      });
+      logger2.debug("Cloud configuration provided, checking for public API key in headers");
+      const key = ctx.request.headers.get("x-copilotcloud-public-api-key");
+      if (key) {
+        logger2.debug("Public API key found in headers");
+        copilotCloudPublicApiKey = key;
+      } else {
+        logger2.error("Public API key not found in headers");
+        throw new import_graphql.GraphQLError("X-CopilotCloud-Public-API-Key header is required");
+      }
+      if (process.env.COPILOT_CLOUD_BASE_URL) {
+        copilotCloudBaseUrl = process.env.COPILOT_CLOUD_BASE_URL;
+      } else if (ctx._copilotkit.baseUrl) {
+        copilotCloudBaseUrl = ctx._copilotkit.baseUrl;
+      } else {
+        copilotCloudBaseUrl = "https://api.cloud.copilotkit.ai";
+      }
+      logger2 = logger2.child({
+        copilotCloudBaseUrl
+      });
+    }
+    logger2.debug("Setting up subjects");
+    const responseStatus$ = new import_rxjs2.ReplaySubject();
+    const interruptStreaming$ = new import_rxjs2.ReplaySubject();
+    const guardrailsResult$ = new import_rxjs2.ReplaySubject();
+    let outputMessages = [];
+    let resolveOutputMessagesPromise;
+    let rejectOutputMessagesPromise;
+    const outputMessagesPromise = new Promise((resolve, reject) => {
+      resolveOutputMessagesPromise = resolve;
+      rejectOutputMessagesPromise = reject;
+    });
+    logger2.debug("Processing");
+    const { eventSource, threadId = (0, import_nanoid5.nanoid)(), runId, actions } = await copilotRuntime.process({
       serviceAdapter,
       messages: data.messages,
       actions: data.frontend.actions,
       threadId: data.threadId,
       runId: data.runId,
-      publicApiKey: void 0
+      publicApiKey: void 0,
+      properties: ctx.properties || {},
+      outputMessagesPromise
     });
+    logger2.debug("Event source created, creating response");
     const response = {
       threadId,
       runId,
-      status: (0, import_rxjs2.firstValueFrom)(responseStatus),
+      status: (0, import_rxjs2.firstValueFrom)(responseStatus$),
       messages: new import_graphql_yoga.Repeater(async (pushMessage, stopStreamingMessages) => {
-        const eventStream = eventSource.process(copilotRuntime.actions).pipe(
+        var _a, _b;
+        logger2.debug("Messages repeater created");
+        if ((_a = data.cloud) == null ? void 0 : _a.guardrails) {
+          logger2 = logger2.child({
+            guardrails: true
+          });
+          logger2.debug("Guardrails is enabled, validating input");
+          invokeGuardrails({
+            baseUrl: copilotCloudBaseUrl,
+            copilotCloudPublicApiKey,
+            data,
+            onResult: (result) => {
+              logger2.debug({
+                status: result.status
+              }, "Guardrails validation done");
+              guardrailsResult$.next(result);
+              if (result.status === "denied") {
+                responseStatus$.next(new GuardrailsValidationFailureResponse({
+                  guardrailsReason: result.reason
+                }));
+                interruptStreaming$.next({
+                  reason: `Interrupted due to Guardrails validation failure. Reason: ${result.reason}`
+                });
+                outputMessages = [
+                  (0, import_class_transformer2.plainToInstance)(TextMessage, {
+                    id: (0, import_nanoid5.nanoid)(),
+                    createdAt: /* @__PURE__ */ new Date(),
+                    content: result.reason,
+                    role: MessageRole.assistant
+                  })
+                ];
+                resolveOutputMessagesPromise(outputMessages);
+              }
+            },
+            onError: (err) => {
+              logger2.error({
+                err
+              }, "Error in guardrails validation");
+              responseStatus$.next(new UnknownErrorResponse({
+                description: `An unknown error has occurred in the guardrails validation`
+              }));
+              interruptStreaming$.next({
+                reason: `Interrupted due to unknown error in guardrails validation`
+              });
+              rejectOutputMessagesPromise(err);
+            }
+          });
+        }
+        let eventStreamSubscription;
+        const eventStream = eventSource.process({
+          serversideActions: actions,
+          guardrailsResult$: ((_b = data.cloud) == null ? void 0 : _b.guardrails) ? guardrailsResult$ : null
+        }).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)()
+          (0, import_rxjs2.shareReplay)(),
+          (0, import_rxjs2.finalize)(() => {
+            logger2.debug("Event stream finalized");
+          })
         );
-        eventStream.subscribe({
+        logger2.debug("Event stream created, subscribing to event stream");
+        eventStreamSubscription = eventStream.subscribe({
           next: async (event) => {
             switch (event.type) {
               case RuntimeEventTypes.TextMessageStart:
@@ -1969,23 +2188,67 @@ var CopilotResolver = class {
                   (0, import_rxjs2.takeWhile)((e) => e.type != RuntimeEventTypes.TextMessageEnd)
                 );
                 const streamingTextStatus = new import_rxjs2.Subject();
+                const messageId = (0, import_nanoid5.nanoid)();
                 pushMessage({
-                  id: (0, import_nanoid3.nanoid)(),
+                  id: messageId,
                   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);
+                    logger2.debug("Text message content repeater created");
+                    const textChunks = [];
+                    let textSubscription;
+                    interruptStreaming$.pipe((0, import_rxjs2.shareReplay)(), (0, import_rxjs2.take)(1), (0, import_rxjs2.tap)(({ reason, messageId: messageId2 }) => {
+                      logger2.debug({
+                        reason,
+                        messageId: messageId2
+                      }, "Text streaming interrupted");
+                      streamingTextStatus.next((0, import_class_transformer2.plainToInstance)(FailedMessageStatus, {
+                        reason
+                      }));
+                      responseStatus$.next(new MessageStreamInterruptedResponse({
+                        messageId: messageId2
+                      }));
+                      stopStreamingText();
+                      textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                    })).subscribe();
+                    logger2.debug("Subscribing to text message content stream");
+                    textSubscription = textMessageContentStream.subscribe({
+                      next: async (e) => {
+                        if (e.type == RuntimeEventTypes.TextMessageContent) {
+                          await pushTextChunk(e.content);
+                          textChunks.push(e.content);
+                        }
+                      },
+                      error: (err) => {
+                        logger2.error({
+                          err
+                        }, "Error in text message content stream");
+                        interruptStreaming$.next({
+                          reason: "Error streaming message content",
+                          messageId
+                        });
+                        stopStreamingText();
+                        textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                      },
+                      complete: () => {
+                        logger2.debug("Text message content stream completed");
+                        streamingTextStatus.next(new SuccessMessageStatus());
+                        stopStreamingText();
+                        textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                        outputMessages.push((0, import_class_transformer2.plainToInstance)(TextMessage, {
+                          id: messageId,
+                          createdAt: /* @__PURE__ */ new Date(),
+                          content: textChunks.join(""),
+                          role: MessageRole.assistant
+                        }));
                       }
                     });
-                    stopStreamingText();
-                    streamingTextStatus.next(new SuccessMessageStatus());
                   })
                 });
                 break;
               case RuntimeEventTypes.ActionExecutionStart:
+                logger2.debug("Action execution start event received");
                 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({
@@ -1995,32 +2258,87 @@ var CopilotResolver = class {
                   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);
+                    logger2.debug("Action execution argument stream created");
+                    const argumentChunks = [];
+                    let actionExecutionArgumentSubscription;
+                    actionExecutionArgumentSubscription = actionExecutionArgumentStream.subscribe({
+                      next: async (e) => {
+                        if (e.type == RuntimeEventTypes.ActionExecutionArgs) {
+                          await pushArgumentsChunk(e.args);
+                          argumentChunks.push(e.args);
+                        }
+                      },
+                      error: (err) => {
+                        logger2.error({
+                          err
+                        }, "Error in action execution argument stream");
+                        streamingArgumentsStatus.next((0, import_class_transformer2.plainToInstance)(FailedMessageStatus, {
+                          reason: "An unknown error has occurred in the action execution argument stream"
+                        }));
+                        stopStreamingArguments();
+                        actionExecutionArgumentSubscription == null ? void 0 : actionExecutionArgumentSubscription.unsubscribe();
+                      },
+                      complete: () => {
+                        logger2.debug("Action execution argument stream completed");
+                        streamingArgumentsStatus.next(new SuccessMessageStatus());
+                        stopStreamingArguments();
+                        actionExecutionArgumentSubscription == null ? void 0 : actionExecutionArgumentSubscription.unsubscribe();
+                        outputMessages.push((0, import_class_transformer2.plainToInstance)(ActionExecutionMessage, {
+                          id: event.actionExecutionId,
+                          createdAt: /* @__PURE__ */ new Date(),
+                          name: event.actionName,
+                          scope: event.scope,
+                          arguments: argumentChunks.join("")
+                        }));
                       }
                     });
-                    stopStreamingArguments();
-                    streamingArgumentsStatus.next(new SuccessMessageStatus());
                   })
                 });
                 break;
               case RuntimeEventTypes.ActionExecutionResult:
+                logger2.debug({
+                  result: event.result
+                }, "Action execution result event received");
                 pushMessage({
-                  id: (0, import_nanoid3.nanoid)(),
+                  id: (0, import_nanoid5.nanoid)(),
                   status: new SuccessMessageStatus(),
                   createdAt: /* @__PURE__ */ new Date(),
                   actionExecutionId: event.actionExecutionId,
                   actionName: event.actionName,
                   result: event.result
                 });
+                outputMessages.push((0, import_class_transformer2.plainToInstance)(ResultMessage, {
+                  id: (0, import_nanoid5.nanoid)(),
+                  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());
+          error: (err) => {
+            logger2.error({
+              err
+            }, "Error in event stream");
+            responseStatus$.next(new UnknownErrorResponse({
+              description: `An unknown error has occurred in the event stream`
+            }));
+            eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
+            stopStreamingMessages();
+            rejectOutputMessagesPromise(err);
+          },
+          complete: async () => {
+            var _a2;
+            logger2.debug("Event stream completed");
+            if ((_a2 = data.cloud) == null ? void 0 : _a2.guardrails) {
+              logger2.debug("Guardrails is enabled, waiting for guardrails result");
+              await (0, import_rxjs2.firstValueFrom)(guardrailsResult$);
+            }
+            responseStatus$.next(new SuccessResponseStatus());
+            eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
             stopStreamingMessages();
+            resolveOutputMessagesPromise(outputMessages);
           }
         });
       })
@@ -2039,7 +2357,7 @@ _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, {
+  _ts_param(2, (0, import_type_graphql12.Arg)("properties", () => import_graphql_scalars2.GraphQLJSONObject, {
     nullable: true
   })),
   _ts_metadata11("design:type", Function),
@@ -2056,51 +2374,99 @@ CopilotResolver = _ts_decorate11([
 
 // src/lib/integrations/shared.ts
 var import_plugin_defer_stream = require("@graphql-yoga/plugin-defer-stream");
-async function createContext(initialContext, copilotKitContext) {
+
+// src/lib/logger.ts
+var import_pino = __toESM(require("pino"));
+var import_pino_pretty = __toESM(require("pino-pretty"));
+function createLogger(options) {
+  const { level, component } = options || {};
+  const stream = (0, import_pino_pretty.default)({
+    colorize: true
+  });
+  const logger2 = (0, import_pino.default)({
+    level: process.env.LOG_LEVEL || level || "error",
+    redact: {
+      paths: [
+        "pid",
+        "hostname"
+      ],
+      remove: true
+    }
+  }, stream);
+  if (component) {
+    return logger2.child({
+      component
+    });
+  } else {
+    return logger2;
+  }
+}
+__name(createLogger, "createLogger");
+
+// src/lib/integrations/shared.ts
+var logger = createLogger();
+async function createContext(initialContext, copilotKitContext, contextLogger, properties = {}) {
+  logger.debug({
+    copilotKitContext
+  }, "Creating GraphQL context");
   const ctx = {
     ...initialContext,
     _copilotkit: {
       ...copilotKitContext
-    }
+    },
+    properties: {
+      ...properties
+    },
+    logger: contextLogger
   };
   return ctx;
 }
 __name(createContext, "createContext");
 function buildSchema(options = {}) {
+  logger.debug("Building GraphQL schema...");
   const schema = (0, import_type_graphql13.buildSchemaSync)({
     resolvers: [
       CopilotResolver
     ],
     emitSchemaFile: options.emitSchemaFile
   });
+  logger.debug("GraphQL schema built successfully");
   return schema;
 }
 __name(buildSchema, "buildSchema");
 function getCommonConfig(options) {
+  const logLevel = process.env.LOG_LEVEL || options.logLevel || "error";
+  const logger2 = createLogger({
+    level: logLevel,
+    component: "getCommonConfig"
+  });
+  logger2.debug("Getting common config");
+  const contextLogger = createLogger({
+    level: logLevel
+  });
   return {
+    logging: createLogger({
+      component: "Yoga GraphQL",
+      level: logLevel
+    }),
     schema: buildSchema(),
     plugins: [
       (0, import_plugin_defer_stream.useDeferStream)()
     ],
-    context: (ctx) => createContext(ctx, {
-      runtime: options.runtime,
-      serviceAdapter: options.serviceAdapter,
-      properties: {}
-    })
+    context: (ctx) => createContext(ctx, options, contextLogger, options.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
-  });
+function copilotRuntimeNextJSAppRouterEndpoint(options) {
+  const commonConfig = getCommonConfig(options);
+  const logger2 = commonConfig.logging;
+  logger2.debug("Creating NextJS App Router endpoint");
   const yoga = (0, import_graphql_yoga2.createYoga)({
     ...commonConfig,
-    graphqlEndpoint: endpoint,
+    graphqlEndpoint: options.endpoint,
     fetchAPI: {
       Response: globalThis.Response
     }
@@ -2121,14 +2487,13 @@ var config = {
     bodyParser: false
   }
 };
-function copilotRuntimeNextJSPagesRouterEndpoint({ runtime, endpoint, serviceAdapter }) {
-  const commonConfig = getCommonConfig({
-    runtime,
-    serviceAdapter
-  });
+function copilotRuntimeNextJSPagesRouterEndpoint(options) {
+  const commonConfig = getCommonConfig(options);
+  const logger2 = commonConfig.logging;
+  logger2.debug("Creating NextJS Pages Router endpoint");
   const yoga = (0, import_graphql_yoga3.createYoga)({
     ...commonConfig,
-    graphqlEndpoint: endpoint
+    graphqlEndpoint: options.endpoint
   });
   return yoga;
 }
@@ -2136,28 +2501,24 @@ __name(copilotRuntimeNextJSPagesRouterEndpoint, "copilotRuntimeNextJSPagesRouter
 
 // src/lib/integrations/node-http/index.ts
 var import_graphql_yoga4 = require("graphql-yoga");
-function copilotRuntimeNodeHttpEndpoint({ runtime, endpoint, serviceAdapter }) {
-  const commonConfig = getCommonConfig({
-    runtime,
-    serviceAdapter
-  });
+function copilotRuntimeNodeHttpEndpoint(options) {
+  const commonConfig = getCommonConfig(options);
+  const logger2 = commonConfig.logging;
+  logger2.debug("Creating Node HTTP endpoint");
   const yoga = (0, import_graphql_yoga4.createYoga)({
     ...commonConfig,
-    graphqlEndpoint: endpoint
+    graphqlEndpoint: options.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,