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

package/dist/{chunk-XPAUPJMW.mjs → chunk-EWS5TMDA.mjs}

@@ -1,10 +1,19 @@
 import {
   streamLangChainResponse
-} from "./chunk-7IFP53C6.mjs";
+} from "./chunk-FRK6BXXV.mjs";
+import {
+  GuardrailsValidationFailureResponse,
+  MessageStreamInterruptedResponse,
+  ResponseStatusUnion,
+  SuccessResponseStatus,
+  UnknownErrorResponse
+} from "./chunk-BYB2LNMK.mjs";
+import {
+  BaseMessage
+} from "./chunk-6NZ4UMOD.mjs";
 import {
-  BaseMessage,
   __name
-} from "./chunk-NFCPM5AM.mjs";
+} from "./chunk-RHQLCJGG.mjs";
 
 // src/lib/integrations/node-http/index.ts
 import { createYoga } from "graphql-yoga";
@@ -14,7 +23,7 @@ import { buildSchemaSync } from "type-graphql";
 
 // src/graphql/resolvers/copilot.resolver.ts
 import { Arg, Ctx, Mutation, Query, Resolver } from "type-graphql";
-import { Subject, firstValueFrom, shareReplay, skipWhile, takeWhile } from "rxjs";
+import { ReplaySubject as ReplaySubject2, Subject, finalize, firstValueFrom as firstValueFrom2, shareReplay, skipWhile, take, takeWhile, tap } from "rxjs";
 
 // src/graphql/inputs/generate-copilot-response.input.ts
 import { Field as Field6, InputType as InputType6 } from "type-graphql";
@@ -250,15 +259,10 @@ function _ts_metadata4(k, v) {
 }
 __name(_ts_metadata4, "_ts_metadata");
 var GuardrailsRuleInput = class {
-  id;
   allowList = [];
   denyList = [];
 };
 __name(GuardrailsRuleInput, "GuardrailsRuleInput");
-_ts_decorate4([
-  Field4(() => String),
-  _ts_metadata4("design:type", String)
-], GuardrailsRuleInput.prototype, "id", void 0);
 _ts_decorate4([
   Field4(() => [
     String
@@ -279,16 +283,17 @@ GuardrailsRuleInput = _ts_decorate4([
   InputType4()
 ], GuardrailsRuleInput);
 var GuardrailsInput = class {
-  inputValidationRules = [];
+  inputValidationRules = {
+    allowList: [],
+    denyList: []
+  };
 };
 __name(GuardrailsInput, "GuardrailsInput");
 _ts_decorate4([
-  Field4(() => [
-    GuardrailsRuleInput
-  ], {
+  Field4(() => GuardrailsRuleInput, {
     nullable: true
   }),
-  _ts_metadata4("design:type", Array)
+  _ts_metadata4("design:type", typeof GuardrailsRuleInput === "undefined" ? Object : GuardrailsRuleInput)
 ], GuardrailsInput.prototype, "inputValidationRules", void 0);
 GuardrailsInput = _ts_decorate4([
   InputType4()
@@ -316,7 +321,9 @@ var CloudInput = class {
 };
 __name(CloudInput, "CloudInput");
 _ts_decorate5([
-  Field5(() => GuardrailsInput),
+  Field5(() => GuardrailsInput, {
+    nullable: true
+  }),
   _ts_metadata5("design:type", typeof GuardrailsInput === "undefined" ? Object : GuardrailsInput)
 ], CloudInput.prototype, "guardrails", void 0);
 CloudInput = _ts_decorate5([
@@ -381,7 +388,7 @@ GenerateCopilotResponseInput = _ts_decorate6([
 ], GenerateCopilotResponseInput);
 
 // src/graphql/types/copilot-response.type.ts
-import { Field as Field9, InterfaceType as InterfaceType2, ObjectType as ObjectType3 } from "type-graphql";
+import { Field as Field8, InterfaceType, ObjectType as ObjectType2 } from "type-graphql";
 
 // src/graphql/types/message-status.type.ts
 import { Field as Field7, ObjectType, createUnionType, registerEnumType as registerEnumType2 } from "type-graphql";
@@ -455,8 +462,7 @@ var MessageStatusUnion = createUnionType({
   ]
 });
 
-// src/graphql/types/response-status.type.ts
-import { Field as Field8, InterfaceType, ObjectType as ObjectType2, createUnionType as createUnionType2, registerEnumType as registerEnumType3 } from "type-graphql";
+// src/graphql/types/copilot-response.type.ts
 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")
@@ -473,114 +479,25 @@ function _ts_metadata8(k, v) {
     return Reflect.metadata(k, v);
 }
 __name(_ts_metadata8, "_ts_metadata");
-var ResponseStatusCode;
-(function(ResponseStatusCode2) {
-  ResponseStatusCode2["Pending"] = "pending";
-  ResponseStatusCode2["Success"] = "success";
-  ResponseStatusCode2["Failed"] = "failed";
-})(ResponseStatusCode || (ResponseStatusCode = {}));
-registerEnumType3(ResponseStatusCode, {
-  name: "ResponseStatusCode"
-});
-var BaseResponseStatus = /* @__PURE__ */ __name(class BaseResponseStatus2 {
-  code;
-}, "BaseResponseStatus");
-_ts_decorate8([
-  Field8(() => ResponseStatusCode),
-  _ts_metadata8("design:type", String)
-], BaseResponseStatus.prototype, "code", void 0);
-BaseResponseStatus = _ts_decorate8([
-  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;
-    }
-  }),
-  ObjectType2()
-], BaseResponseStatus);
-var PendingResponseStatus = class extends BaseResponseStatus {
-  code = "pending";
-};
-__name(PendingResponseStatus, "PendingResponseStatus");
-PendingResponseStatus = _ts_decorate8([
-  ObjectType2({
-    implements: BaseResponseStatus
-  })
-], PendingResponseStatus);
-var SuccessResponseStatus = class extends BaseResponseStatus {
-  code = "success";
-};
-__name(SuccessResponseStatus, "SuccessResponseStatus");
-SuccessResponseStatus = _ts_decorate8([
-  ObjectType2({
-    implements: BaseResponseStatus
-  })
-], SuccessResponseStatus);
-var FailedResponseStatus = class extends BaseResponseStatus {
-  code = "failed";
-  reason;
-};
-__name(FailedResponseStatus, "FailedResponseStatus");
-_ts_decorate8([
-  Field8(() => String),
-  _ts_metadata8("design:type", String)
-], FailedResponseStatus.prototype, "reason", void 0);
-FailedResponseStatus = _ts_decorate8([
-  ObjectType2({
-    implements: BaseResponseStatus
-  })
-], FailedResponseStatus);
-var ResponseStatusUnion = createUnionType2({
-  name: "ResponseStatus",
-  types: () => [
-    PendingResponseStatus,
-    SuccessResponseStatus,
-    FailedResponseStatus
-  ]
-});
-
-// src/graphql/types/copilot-response.type.ts
-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 BaseMessageOutput = /* @__PURE__ */ __name(class BaseMessageOutput2 {
   id;
   createdAt;
   status;
 }, "BaseMessageOutput");
-_ts_decorate9([
-  Field9(() => String),
-  _ts_metadata9("design:type", String)
+_ts_decorate8([
+  Field8(() => String),
+  _ts_metadata8("design:type", String)
 ], BaseMessageOutput.prototype, "id", void 0);
-_ts_decorate9([
-  Field9(() => Date),
-  _ts_metadata9("design:type", typeof Date === "undefined" ? Object : Date)
+_ts_decorate8([
+  Field8(() => Date),
+  _ts_metadata8("design:type", typeof Date === "undefined" ? Object : Date)
 ], BaseMessageOutput.prototype, "createdAt", void 0);
-_ts_decorate9([
-  Field9(() => MessageStatusUnion),
-  _ts_metadata9("design:type", Object)
+_ts_decorate8([
+  Field8(() => MessageStatusUnion),
+  _ts_metadata8("design:type", Object)
 ], BaseMessageOutput.prototype, "status", void 0);
-BaseMessageOutput = _ts_decorate9([
-  InterfaceType2({
+BaseMessageOutput = _ts_decorate8([
+  InterfaceType({
     resolveType(value) {
       if (value.hasOwnProperty("content")) {
         return TextMessageOutput;
@@ -598,18 +515,18 @@ var TextMessageOutput = class {
   content;
 };
 __name(TextMessageOutput, "TextMessageOutput");
-_ts_decorate9([
-  Field9(() => MessageRole),
-  _ts_metadata9("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+_ts_decorate8([
+  Field8(() => MessageRole),
+  _ts_metadata8("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
 ], TextMessageOutput.prototype, "role", void 0);
-_ts_decorate9([
-  Field9(() => [
+_ts_decorate8([
+  Field8(() => [
     String
   ]),
-  _ts_metadata9("design:type", Array)
+  _ts_metadata8("design:type", Array)
 ], TextMessageOutput.prototype, "content", void 0);
-TextMessageOutput = _ts_decorate9([
-  ObjectType3({
+TextMessageOutput = _ts_decorate8([
+  ObjectType2({
     implements: BaseMessageOutput
   })
 ], TextMessageOutput);
@@ -619,22 +536,22 @@ var ActionExecutionMessageOutput = class {
   arguments;
 };
 __name(ActionExecutionMessageOutput, "ActionExecutionMessageOutput");
-_ts_decorate9([
-  Field9(() => String),
-  _ts_metadata9("design:type", String)
+_ts_decorate8([
+  Field8(() => String),
+  _ts_metadata8("design:type", String)
 ], ActionExecutionMessageOutput.prototype, "name", void 0);
-_ts_decorate9([
-  Field9(() => ActionExecutionScope),
-  _ts_metadata9("design:type", typeof ActionExecutionScope === "undefined" ? Object : ActionExecutionScope)
+_ts_decorate8([
+  Field8(() => ActionExecutionScope),
+  _ts_metadata8("design:type", typeof ActionExecutionScope === "undefined" ? Object : ActionExecutionScope)
 ], ActionExecutionMessageOutput.prototype, "scope", void 0);
-_ts_decorate9([
-  Field9(() => [
+_ts_decorate8([
+  Field8(() => [
     String
   ]),
-  _ts_metadata9("design:type", Array)
+  _ts_metadata8("design:type", Array)
 ], ActionExecutionMessageOutput.prototype, "arguments", void 0);
-ActionExecutionMessageOutput = _ts_decorate9([
-  ObjectType3({
+ActionExecutionMessageOutput = _ts_decorate8([
+  ObjectType2({
     implements: BaseMessageOutput
   })
 ], ActionExecutionMessageOutput);
@@ -644,20 +561,20 @@ var ResultMessageOutput = class {
   result;
 };
 __name(ResultMessageOutput, "ResultMessageOutput");
-_ts_decorate9([
-  Field9(() => String),
-  _ts_metadata9("design:type", String)
+_ts_decorate8([
+  Field8(() => String),
+  _ts_metadata8("design:type", String)
 ], ResultMessageOutput.prototype, "actionExecutionId", void 0);
-_ts_decorate9([
-  Field9(() => String),
-  _ts_metadata9("design:type", String)
+_ts_decorate8([
+  Field8(() => String),
+  _ts_metadata8("design:type", String)
 ], ResultMessageOutput.prototype, "actionName", void 0);
-_ts_decorate9([
-  Field9(() => String),
-  _ts_metadata9("design:type", String)
+_ts_decorate8([
+  Field8(() => String),
+  _ts_metadata8("design:type", String)
 ], ResultMessageOutput.prototype, "result", void 0);
-ResultMessageOutput = _ts_decorate9([
-  ObjectType3({
+ResultMessageOutput = _ts_decorate8([
+  ObjectType2({
     implements: BaseMessageOutput
   })
 ], ResultMessageOutput);
@@ -668,28 +585,28 @@ var CopilotResponse = class {
   messages;
 };
 __name(CopilotResponse, "CopilotResponse");
-_ts_decorate9([
-  Field9(() => String),
-  _ts_metadata9("design:type", String)
+_ts_decorate8([
+  Field8(() => String),
+  _ts_metadata8("design:type", String)
 ], CopilotResponse.prototype, "threadId", void 0);
-_ts_decorate9([
-  Field9(() => ResponseStatusUnion),
-  _ts_metadata9("design:type", Object)
+_ts_decorate8([
+  Field8(() => ResponseStatusUnion),
+  _ts_metadata8("design:type", Object)
 ], CopilotResponse.prototype, "status", void 0);
-_ts_decorate9([
-  Field9({
+_ts_decorate8([
+  Field8({
     nullable: true
   }),
-  _ts_metadata9("design:type", String)
+  _ts_metadata8("design:type", String)
 ], CopilotResponse.prototype, "runId", void 0);
-_ts_decorate9([
-  Field9(() => [
+_ts_decorate8([
+  Field8(() => [
     BaseMessageOutput
   ]),
-  _ts_metadata9("design:type", Array)
+  _ts_metadata8("design:type", Array)
 ], CopilotResponse.prototype, "messages", void 0);
-CopilotResponse = _ts_decorate9([
-  ObjectType3()
+CopilotResponse = _ts_decorate8([
+  ObjectType2()
 ], CopilotResponse);
 
 // src/graphql/resolvers/copilot.resolver.ts
@@ -697,7 +614,7 @@ import { Repeater } from "graphql-yoga";
 import { nanoid } from "nanoid";
 
 // src/service-adapters/events.ts
-import { of, concat, map, scan, concatMap, ReplaySubject } from "rxjs";
+import { of, concat, map, scan, concatMap, ReplaySubject, firstValueFrom } from "rxjs";
 var RuntimeEventTypes;
 (function(RuntimeEventTypes2) {
   RuntimeEventTypes2["TextMessageStart"] = "TextMessageStart";
@@ -773,7 +690,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);
     });
@@ -809,7 +726,7 @@ var RuntimeEventSource = class {
       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 concat(of(eventWithState.event), toolCallEventStream$);
@@ -821,7 +738,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 firstValueFrom(guardrailsResult$);
+    if (status === "denied") {
+      eventStream$.complete();
+      return;
+    }
+  }
   let args = [];
   if (actionArguments) {
     args = JSON.parse(actionArguments);
@@ -840,6 +764,56 @@ __name(executeAction, "executeAction");
 
 // src/graphql/resolvers/copilot.resolver.ts
 import { GraphQLJSONObject } from "graphql-scalars";
+import { plainToInstance } from "class-transformer";
+
+// src/graphql/types/guardrails-result.type.ts
+import { Field as Field9, ObjectType as ObjectType3, registerEnumType as registerEnumType3 } from "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 GuardrailsResultStatus;
+(function(GuardrailsResultStatus2) {
+  GuardrailsResultStatus2["ALLOWED"] = "allowed";
+  GuardrailsResultStatus2["DENIED"] = "denied";
+})(GuardrailsResultStatus || (GuardrailsResultStatus = {}));
+registerEnumType3(GuardrailsResultStatus, {
+  name: "GuardrailsResultStatus",
+  description: "The status of the guardrails check"
+});
+var GuardrailsResult = class {
+  status;
+  reason;
+};
+__name(GuardrailsResult, "GuardrailsResult");
+_ts_decorate9([
+  Field9(() => GuardrailsResultStatus),
+  _ts_metadata9("design:type", String)
+], GuardrailsResult.prototype, "status", void 0);
+_ts_decorate9([
+  Field9(() => String, {
+    nullable: true
+  }),
+  _ts_metadata9("design:type", String)
+], GuardrailsResult.prototype, "reason", void 0);
+GuardrailsResult = _ts_decorate9([
+  ObjectType3()
+], GuardrailsResult);
+
+// src/graphql/resolvers/copilot.resolver.ts
+import { GraphQLError } from "graphql";
 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")
@@ -862,21 +836,95 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __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 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 Subject();
-    const { eventSource, threadId = 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 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 ReplaySubject2();
+    const interruptStreaming$ = new ReplaySubject2();
+    const guardrailsResult$ = new ReplaySubject2();
+    logger2.debug("Processing");
+    const { eventSource, threadId = nanoid(), runId, actions } = await copilotRuntime.process({
       serviceAdapter,
       messages: data.messages,
       actions: data.frontend.actions,
@@ -884,17 +932,55 @@ var CopilotResolver = class {
       runId: data.runId,
       publicApiKey: void 0
     });
+    logger2.debug("Event source created, creating response");
     const response = {
       threadId,
       runId,
-      status: firstValueFrom(responseStatus),
+      status: firstValueFrom2(responseStatus$),
       messages: new 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.
-          shareReplay()
+          shareReplay(),
+          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:
@@ -905,43 +991,98 @@ var CopilotResolver = class {
                   takeWhile((e) => e.type != RuntimeEventTypes.TextMessageEnd)
                 );
                 const streamingTextStatus = new Subject();
+                const messageId = nanoid();
                 pushMessage({
-                  id: nanoid(),
-                  status: firstValueFrom(streamingTextStatus),
+                  id: messageId,
+                  status: firstValueFrom2(streamingTextStatus),
                   createdAt: /* @__PURE__ */ new Date(),
                   role: MessageRole.assistant,
                   content: new 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(shareReplay(), take(1), tap(({ reason, messageId: messageId2 }) => {
+                      logger2.debug({
+                        reason,
+                        messageId: messageId2
+                      }, "Text streaming interrupted");
+                      streamingTextStatus.next(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(skipWhile((e) => e !== event), takeWhile((e) => e.type != RuntimeEventTypes.ActionExecutionEnd));
                 const streamingArgumentsStatus = new Subject();
                 pushMessage({
                   id: event.actionExecutionId,
-                  status: firstValueFrom(streamingArgumentsStatus),
+                  status: firstValueFrom2(streamingArgumentsStatus),
                   createdAt: /* @__PURE__ */ new Date(),
                   name: event.actionName,
                   scope: event.scope,
                   arguments: new 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(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: nanoid(),
                   status: new SuccessMessageStatus(),
@@ -953,9 +1094,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 firstValueFrom2(guardrailsResult$);
+            }
+            responseStatus$.next(new SuccessResponseStatus());
+            eventStreamSubscription.unsubscribe();
             stopStreamingMessages();
           }
         });
@@ -992,50 +1149,98 @@ CopilotResolver = _ts_decorate10([
 
 // src/lib/integrations/shared.ts
 import { useDeferStream } from "@graphql-yoga/plugin-defer-stream";
-async function createContext(initialContext, copilotKitContext) {
+
+// src/lib/logger.ts
+import createPinoLogger from "pino";
+import pretty from "pino-pretty";
+function createLogger(options) {
+  const { level, component } = options || {};
+  const stream = pretty({
+    colorize: true
+  });
+  const logger2 = createPinoLogger({
+    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 = 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: [
       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/node-http/index.ts
-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 = createYoga({
     ...commonConfig,
-    graphqlEndpoint: endpoint
+    graphqlEndpoint: options.endpoint
   });
   return yoga;
 }
@@ -1048,4 +1253,4 @@ export {
   getCommonConfig,
   copilotRuntimeNodeHttpEndpoint
 };
-//# sourceMappingURL=chunk-XPAUPJMW.mjs.map
+//# sourceMappingURL=chunk-EWS5TMDA.mjs.map