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

package/dist/lib/integrations/index.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lib/integrations/index.ts
@@ -31,10 +41,10 @@ __export(integrations_exports, {
 module.exports = __toCommonJS(integrations_exports);
 
 // 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
@@ -306,15 +316,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
@@ -335,16 +340,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)()
@@ -372,7 +378,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([
@@ -512,6 +520,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;
@@ -578,15 +587,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
@@ -766,7 +791,11 @@ var RuntimeEventTypes;
 })(RuntimeEventTypes || (RuntimeEventTypes = {}));
 
 // src/graphql/resolvers/copilot.resolver.ts
-var import_graphql_scalars = require("graphql-scalars");
+var import_graphql_scalars2 = require("graphql-scalars");
+var import_class_transformer = 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")
@@ -783,27 +812,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_nanoid.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_nanoid.nanoid)(), runId, actions } = await copilotRuntime.process({
       serviceAdapter,
       messages: data.messages,
       actions: data.frontend.actions,
@@ -811,17 +995,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:
@@ -832,23 +1054,59 @@ var CopilotResolver = class {
                   (0, import_rxjs2.takeWhile)((e) => e.type != RuntimeEventTypes.TextMessageEnd)
                 );
                 const streamingTextStatus = new import_rxjs2.Subject();
+                const messageId = (0, import_nanoid.nanoid)();
                 pushMessage({
-                  id: (0, import_nanoid.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_transformer.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({
@@ -858,17 +1116,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_transformer.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_nanoid.nanoid)(),
                   status: new SuccessMessageStatus(),
@@ -880,9 +1157,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();
           }
         });
@@ -892,78 +1185,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
     }
@@ -984,14 +1325,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;
 }
@@ -999,14 +1339,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;
 }