@copilotkit/runtime 0.37.0 → 0.38.0-mme-alpha.0

package/dist/lib/index.js

@@ -505,7 +505,7 @@ function convertMessageToGoogleGenAIMessage(message) {
     };
   } else if (message instanceof ResultMessage) {
     return {
-      role: "model",
+      role: "function",
       parts: [
         {
           functionResponse: {
@@ -622,6 +622,9 @@ 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)());
@@ -729,6 +732,31 @@ 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") {
@@ -737,14 +765,16 @@ async function streamLangChainResponse({ result, eventStream$, actionExecution }
     } 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);
     }
     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) {
+  } 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);
     }
@@ -753,7 +783,8 @@ async function streamLangChainResponse({ result, eventStream$, actionExecution }
         eventStream$.sendActionExecution(toolCall.id || (0, import_nanoid2.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 +794,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;
@@ -807,13 +838,23 @@ 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 LangChainAdapter = class {
@@ -846,6 +887,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;
@@ -1037,7 +1083,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 +1119,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 +1131,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);
@@ -1168,15 +1221,16 @@ var CopilotRuntime = class {
         console.error("Error loading langserve chain:", error);
       }
     }
-    const serverSideActionsInput = [
+    const actions = [
       ...this.actions,
       ...langserveFunctions
-    ].map((action) => ({
+    ];
+    const serverSideActionsInput = actions.map((action) => ({
       name: action.name,
       description: action.description,
       jsonSchema: JSON.stringify((0, import_shared2.actionParametersToJsonSchema)(action.parameters))
     }));
-    const actions = flattenToolCallsNoDuplicates([
+    const actionInputs = flattenToolCallsNoDuplicates([
       ...serverSideActionsInput,
       ...clientSideActionsInput
     ]);
@@ -1184,7 +1238,7 @@ var CopilotRuntime = class {
       const eventSource = new RuntimeEventSource();
       const result = await serviceAdapter.process({
         messages: convertGqlInputToMessages(messages),
-        actions,
+        actions: actionInputs,
         threadId,
         runId,
         eventSource
@@ -1192,7 +1246,8 @@ var CopilotRuntime = class {
       return {
         threadId: result.threadId,
         runId: result.runId,
-        eventSource
+        eventSource,
+        actions
       };
     } catch (error) {
       console.error("Error getting response:", error);
@@ -1218,10 +1273,10 @@ var CopilotBackend = class extends CopilotRuntime {
 __name(CopilotBackend, "CopilotBackend");
 
 // src/lib/integrations/shared.ts
-var import_type_graphql13 = require("type-graphql");
+var import_type_graphql14 = require("type-graphql");
 
 // src/graphql/resolvers/copilot.resolver.ts
-var import_type_graphql12 = require("type-graphql");
+var import_type_graphql13 = require("type-graphql");
 var import_rxjs2 = require("rxjs");
 
 // src/graphql/inputs/generate-copilot-response.input.ts
@@ -1458,15 +1513,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 +1537,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 +1575,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 +1717,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 +1784,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
@@ -1903,7 +1973,11 @@ 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_graphql_scalars2 = require("graphql-scalars");
+var import_class_transformer2 = require("class-transformer");
+
+// src/graphql/types/guardrails-result.type.ts
+var import_type_graphql12 = require("type-graphql");
 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")
@@ -1920,27 +1994,182 @@ function _ts_metadata11(k, v) {
     return Reflect.metadata(k, v);
 }
 __name(_ts_metadata11, "_ts_metadata");
+var GuardrailsResultStatus;
+(function(GuardrailsResultStatus2) {
+  GuardrailsResultStatus2["ALLOWED"] = "allowed";
+  GuardrailsResultStatus2["DENIED"] = "denied";
+})(GuardrailsResultStatus || (GuardrailsResultStatus = {}));
+(0, import_type_graphql12.registerEnumType)(GuardrailsResultStatus, {
+  name: "GuardrailsResultStatus",
+  description: "The status of the guardrails check"
+});
+var GuardrailsResult = class {
+  status;
+  reason;
+};
+__name(GuardrailsResult, "GuardrailsResult");
+_ts_decorate11([
+  (0, import_type_graphql12.Field)(() => GuardrailsResultStatus),
+  _ts_metadata11("design:type", String)
+], GuardrailsResult.prototype, "status", void 0);
+_ts_decorate11([
+  (0, import_type_graphql12.Field)(() => String, {
+    nullable: true
+  }),
+  _ts_metadata11("design:type", String)
+], GuardrailsResult.prototype, "reason", void 0);
+GuardrailsResult = _ts_decorate11([
+  (0, import_type_graphql12.ObjectType)()
+], GuardrailsResult);
+
+// src/graphql/resolvers/copilot.resolver.ts
+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_decorate12(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_decorate12, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
 function _ts_param(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
 __name(_ts_param, "_ts_param");
+var invokeGuardrails = /* @__PURE__ */ __name(async ({ baseUrl, copilotCloudPublicApiKey, data, logger: logger2, onResult }) => {
+  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)
+    });
+    const responseBody = await guardrailsResult.json();
+    if (!guardrailsResult.ok) {
+      logger2.error({
+        error: responseBody
+      }, "Failed to invoke guardrails");
+      throw new import_graphql.GraphQLError("Failed to invoke guardrails");
+    }
+    onResult(responseBody);
+  } else {
+    onResult({
+      status: GuardrailsResultStatus.ALLOWED
+    });
+  }
+}, "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();
+    logger2.debug("Processing");
+    const { eventSource, threadId = (0, import_nanoid3.nanoid)(), runId, actions } = await copilotRuntime.process({
       serviceAdapter,
       messages: data.messages,
       actions: data.frontend.actions,
@@ -1948,17 +2177,55 @@ var CopilotResolver = class {
       runId: data.runId,
       publicApiKey: void 0
     });
+    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,
+            logger: logger2,
+            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}`
+                });
+              }
+            }
+          });
+        }
+        let eventStreamSubscription;
+        const eventStream = eventSource.process({
+          serversideActions: copilotRuntime.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, stopping streaming messages");
+            stopStreamingMessages();
+          })
         );
-        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 +2236,59 @@ var CopilotResolver = class {
                   (0, import_rxjs2.takeWhile)((e) => e.type != RuntimeEventTypes.TextMessageEnd)
                 );
                 const streamingTextStatus = new import_rxjs2.Subject();
+                const messageId = (0, import_nanoid3.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");
+                    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.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);
+                        }
+                      },
+                      error: (err) => {
+                        logger2.error({
+                          err
+                        }, "Error in text message content stream");
+                        interruptStreaming$.next({
+                          reason: "Error streaming message content",
+                          messageId
+                        });
+                        stopStreamingText();
+                        textSubscription.unsubscribe();
+                      },
+                      complete: () => {
+                        logger2.debug("Text message content stream completed");
+                        streamingTextStatus.next(new SuccessMessageStatus());
+                        stopStreamingText();
+                        textSubscription.unsubscribe();
                       }
                     });
-                    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,17 +2298,36 @@ 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");
+                    let actionExecutionArgumentSubscription;
+                    actionExecutionArgumentSubscription = actionExecutionArgumentStream.subscribe({
+                      next: async (e) => {
+                        if (e.type == RuntimeEventTypes.ActionExecutionArgs) {
+                          await pushArgumentsChunk(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.unsubscribe();
+                      },
+                      complete: () => {
+                        logger2.debug("Action execution argument stream completed");
+                        streamingArgumentsStatus.next(new SuccessMessageStatus());
+                        stopStreamingArguments();
+                        actionExecutionArgumentSubscription.unsubscribe();
                       }
                     });
-                    stopStreamingArguments();
-                    streamingArgumentsStatus.next(new SuccessMessageStatus());
                   })
                 });
                 break;
               case RuntimeEventTypes.ActionExecutionResult:
+                logger2.debug("Action execution result event received");
                 pushMessage({
                   id: (0, import_nanoid3.nanoid)(),
                   status: new SuccessMessageStatus(),
@@ -2017,9 +2339,25 @@ var CopilotResolver = class {
                 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.unsubscribe();
+            stopStreamingMessages();
+          },
+          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.unsubscribe();
             stopStreamingMessages();
           }
         });
@@ -2029,78 +2367,126 @@ var CopilotResolver = class {
   }
 };
 __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)
+_ts_decorate12([
+  (0, import_type_graphql13.Query)(() => String),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", []),
+  _ts_metadata12("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, {
+_ts_decorate12([
+  (0, import_type_graphql13.Mutation)(() => CopilotResponse),
+  _ts_param(0, (0, import_type_graphql13.Ctx)()),
+  _ts_param(1, (0, import_type_graphql13.Arg)("data")),
+  _ts_param(2, (0, import_type_graphql13.Arg)("properties", () => import_graphql_scalars2.GraphQLJSONObject, {
     nullable: true
   })),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof GraphQLContext === "undefined" ? Object : GraphQLContext,
     typeof GenerateCopilotResponseInput === "undefined" ? Object : GenerateCopilotResponseInput,
     typeof CopilotRequestContextProperties === "undefined" ? Object : CopilotRequestContextProperties
   ]),
-  _ts_metadata11("design:returntype", Promise)
+  _ts_metadata12("design:returntype", Promise)
 ], CopilotResolver.prototype, "generateCopilotResponse", null);
-CopilotResolver = _ts_decorate11([
-  (0, import_type_graphql12.Resolver)(() => CopilotResponse)
+CopilotResolver = _ts_decorate12([
+  (0, import_type_graphql13.Resolver)(() => CopilotResponse)
 ], CopilotResolver);
 
 // 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 = {}) {
-  const schema = (0, import_type_graphql13.buildSchemaSync)({
+  logger.debug("Building GraphQL schema...");
+  const schema = (0, import_type_graphql14.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 +2507,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,14 +2521,13 @@ __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;
 }