@copilotkit/runtime 0.37.0 → 0.38.0-beta.0

package/dist/lib/integrations/node-http/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/node-http/index.ts
@@ -301,15 +311,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
@@ -330,16 +335,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)()
@@ -367,7 +373,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([
@@ -507,6 +515,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;
@@ -573,15 +582,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
@@ -749,6 +774,27 @@ var import_nanoid = require("nanoid");
 
 // src/service-adapters/events.ts
 var import_rxjs = require("rxjs");
+
+// src/graphql/types/converted/index.ts
+var TextMessage = class extends BaseMessage {
+  content;
+  role;
+};
+__name(TextMessage, "TextMessage");
+var ActionExecutionMessage = class extends BaseMessage {
+  name;
+  arguments;
+  scope;
+};
+__name(ActionExecutionMessage, "ActionExecutionMessage");
+var ResultMessage = class extends BaseMessage {
+  actionExecutionId;
+  actionName;
+  result;
+};
+__name(ResultMessage, "ResultMessage");
+
+// src/service-adapters/events.ts
 var RuntimeEventTypes;
 (function(RuntimeEventTypes2) {
   RuntimeEventTypes2["TextMessageStart"] = "TextMessageStart";
@@ -761,7 +807,44 @@ 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");
+var import_graphql = require("graphql");
+
+// src/utils/failed-response-status-reasons.ts
+var GuardrailsValidationFailureResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.GUARDRAILS_VALIDATION_FAILED;
+  constructor({ guardrailsReason }) {
+    super();
+    this.details = {
+      guardrailsReason
+    };
+  }
+};
+__name(GuardrailsValidationFailureResponse, "GuardrailsValidationFailureResponse");
+var MessageStreamInterruptedResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.MESSAGE_STREAM_INTERRUPTED;
+  constructor({ messageId }) {
+    super();
+    this.details = {
+      messageId,
+      description: "Check the message for mode details"
+    };
+  }
+};
+__name(MessageStreamInterruptedResponse, "MessageStreamInterruptedResponse");
+var UnknownErrorResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.UNKNOWN_ERROR;
+  constructor({ description }) {
+    super();
+    this.details = {
+      description
+    };
+  }
+};
+__name(UnknownErrorResponse, "UnknownErrorResponse");
+
+// src/graphql/resolvers/copilot.resolver.ts
 function _ts_decorate11(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -784,39 +867,173 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
+var invokeGuardrails = /* @__PURE__ */ __name(async ({ baseUrl, copilotCloudPublicApiKey, data, onResult, onError }) => {
+  var _a;
+  if (data.messages.length && ((_a = data.messages[data.messages.length - 1].textMessage) == null ? void 0 : _a.role) === MessageRole.user) {
+    const messages = data.messages.filter((m) => m.textMessage !== void 0 && (m.textMessage.role === MessageRole.user || m.textMessage.role === MessageRole.assistant)).map((m) => ({
+      role: m.textMessage.role,
+      content: m.textMessage.content
+    }));
+    const lastMessage = messages[messages.length - 1];
+    const restOfMessages = messages.slice(0, -1);
+    const body = {
+      input: lastMessage.content,
+      validTopics: data.cloud.guardrails.inputValidationRules.allowList,
+      invalidTopics: data.cloud.guardrails.inputValidationRules.denyList,
+      messages: restOfMessages
+    };
+    const guardrailsResult = await fetch(`${baseUrl}/guardrails/validate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-CopilotCloud-Public-API-Key": copilotCloudPublicApiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (guardrailsResult.ok) {
+      const resultJson = await guardrailsResult.json();
+      onResult(resultJson);
+    } else {
+      onError(await guardrailsResult.json());
+    }
+  }
+}, "invokeGuardrails");
 var CopilotResolver = class {
   async hello() {
     return "Hello World";
   }
   async generateCopilotResponse(ctx, data, properties) {
+    let logger2 = ctx.logger.child({
+      component: "CopilotResolver.generateCopilotResponse"
+    });
+    logger2.debug({
+      data
+    }, "Generating Copilot response");
+    const copilotRuntime = ctx._copilotkit.runtime;
+    const serviceAdapter = ctx._copilotkit.serviceAdapter;
     if (properties) {
-      ctx._copilotkit.properties = {
-        ...ctx._copilotkit.properties,
+      logger2.debug("Properties provided, merging with context properties");
+      ctx.properties = {
+        ...ctx.properties,
         ...properties
       };
     }
-    const copilotRuntime = ctx._copilotkit.runtime;
-    const serviceAdapter = ctx._copilotkit.serviceAdapter;
-    const responseStatus = new import_rxjs2.Subject();
-    const { eventSource, threadId = (0, import_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();
+    let outputMessages = [];
+    let resolveOutputMessagesPromise;
+    let rejectOutputMessagesPromise;
+    const outputMessagesPromise = new Promise((resolve, reject) => {
+      resolveOutputMessagesPromise = resolve;
+      rejectOutputMessagesPromise = reject;
+    });
+    logger2.debug("Processing");
+    const { eventSource, threadId = (0, import_nanoid.nanoid)(), runId, actions } = await copilotRuntime.process({
       serviceAdapter,
       messages: data.messages,
       actions: data.frontend.actions,
       threadId: data.threadId,
       runId: data.runId,
-      publicApiKey: void 0
+      publicApiKey: void 0,
+      properties: ctx.properties || {},
+      outputMessagesPromise
     });
+    logger2.debug("Event source created, creating response");
     const response = {
       threadId,
       runId,
-      status: (0, import_rxjs2.firstValueFrom)(responseStatus),
+      status: (0, import_rxjs2.firstValueFrom)(responseStatus$),
       messages: new import_graphql_yoga.Repeater(async (pushMessage, stopStreamingMessages) => {
-        const eventStream = eventSource.process(copilotRuntime.actions).pipe(
+        var _a, _b;
+        logger2.debug("Messages repeater created");
+        if ((_a = data.cloud) == null ? void 0 : _a.guardrails) {
+          logger2 = logger2.child({
+            guardrails: true
+          });
+          logger2.debug("Guardrails is enabled, validating input");
+          invokeGuardrails({
+            baseUrl: copilotCloudBaseUrl,
+            copilotCloudPublicApiKey,
+            data,
+            onResult: (result) => {
+              logger2.debug({
+                status: result.status
+              }, "Guardrails validation done");
+              guardrailsResult$.next(result);
+              if (result.status === "denied") {
+                responseStatus$.next(new GuardrailsValidationFailureResponse({
+                  guardrailsReason: result.reason
+                }));
+                interruptStreaming$.next({
+                  reason: `Interrupted due to Guardrails validation failure. Reason: ${result.reason}`
+                });
+                outputMessages = [
+                  (0, import_class_transformer.plainToInstance)(TextMessage, {
+                    id: (0, import_nanoid.nanoid)(),
+                    createdAt: /* @__PURE__ */ new Date(),
+                    content: result.reason,
+                    role: MessageRole.assistant
+                  })
+                ];
+                resolveOutputMessagesPromise(outputMessages);
+              }
+            },
+            onError: (err) => {
+              logger2.error({
+                err
+              }, "Error in guardrails validation");
+              responseStatus$.next(new UnknownErrorResponse({
+                description: `An unknown error has occurred in the guardrails validation`
+              }));
+              interruptStreaming$.next({
+                reason: `Interrupted due to unknown error in guardrails validation`
+              });
+              rejectOutputMessagesPromise(err);
+            }
+          });
+        }
+        let eventStreamSubscription;
+        const eventStream = eventSource.process({
+          serversideActions: actions,
+          guardrailsResult$: ((_b = data.cloud) == null ? void 0 : _b.guardrails) ? guardrailsResult$ : null
+        }).pipe(
           // shareReplay() ensures that later subscribers will see the whole stream instead of
           // just the events that were emitted after the subscriber was added.
-          (0, import_rxjs2.shareReplay)()
+          (0, import_rxjs2.shareReplay)(),
+          (0, import_rxjs2.finalize)(() => {
+            logger2.debug("Event stream finalized");
+          })
         );
-        eventStream.subscribe({
+        logger2.debug("Event stream created, subscribing to event stream");
+        eventStreamSubscription = eventStream.subscribe({
           next: async (event) => {
             switch (event.type) {
               case RuntimeEventTypes.TextMessageStart:
@@ -827,23 +1044,67 @@ 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");
+                    const textChunks = [];
+                    let textSubscription;
+                    interruptStreaming$.pipe((0, import_rxjs2.shareReplay)(), (0, import_rxjs2.take)(1), (0, import_rxjs2.tap)(({ reason, messageId: messageId2 }) => {
+                      logger2.debug({
+                        reason,
+                        messageId: messageId2
+                      }, "Text streaming interrupted");
+                      streamingTextStatus.next((0, import_class_transformer.plainToInstance)(FailedMessageStatus, {
+                        reason
+                      }));
+                      responseStatus$.next(new MessageStreamInterruptedResponse({
+                        messageId: messageId2
+                      }));
+                      stopStreamingText();
+                      textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                    })).subscribe();
+                    logger2.debug("Subscribing to text message content stream");
+                    textSubscription = textMessageContentStream.subscribe({
+                      next: async (e) => {
+                        if (e.type == RuntimeEventTypes.TextMessageContent) {
+                          await pushTextChunk(e.content);
+                          textChunks.push(e.content);
+                        }
+                      },
+                      error: (err) => {
+                        logger2.error({
+                          err
+                        }, "Error in text message content stream");
+                        interruptStreaming$.next({
+                          reason: "Error streaming message content",
+                          messageId
+                        });
+                        stopStreamingText();
+                        textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                      },
+                      complete: () => {
+                        logger2.debug("Text message content stream completed");
+                        streamingTextStatus.next(new SuccessMessageStatus());
+                        stopStreamingText();
+                        textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                        outputMessages.push((0, import_class_transformer.plainToInstance)(TextMessage, {
+                          id: messageId,
+                          createdAt: /* @__PURE__ */ new Date(),
+                          content: textChunks.join(""),
+                          role: MessageRole.assistant
+                        }));
                       }
                     });
-                    stopStreamingText();
-                    streamingTextStatus.next(new SuccessMessageStatus());
                   })
                 });
                 break;
               case RuntimeEventTypes.ActionExecutionStart:
+                logger2.debug("Action execution start event received");
                 const actionExecutionArgumentStream = eventStream.pipe((0, import_rxjs2.skipWhile)((e) => e !== event), (0, import_rxjs2.takeWhile)((e) => e.type != RuntimeEventTypes.ActionExecutionEnd));
                 const streamingArgumentsStatus = new import_rxjs2.Subject();
                 pushMessage({
@@ -853,17 +1114,47 @@ var CopilotResolver = class {
                   name: event.actionName,
                   scope: event.scope,
                   arguments: new import_graphql_yoga.Repeater(async (pushArgumentsChunk, stopStreamingArguments) => {
-                    await actionExecutionArgumentStream.forEach(async (e) => {
-                      if (e.type == RuntimeEventTypes.ActionExecutionArgs) {
-                        await pushArgumentsChunk(e.args);
+                    logger2.debug("Action execution argument stream created");
+                    const argumentChunks = [];
+                    let actionExecutionArgumentSubscription;
+                    actionExecutionArgumentSubscription = actionExecutionArgumentStream.subscribe({
+                      next: async (e) => {
+                        if (e.type == RuntimeEventTypes.ActionExecutionArgs) {
+                          await pushArgumentsChunk(e.args);
+                          argumentChunks.push(e.args);
+                        }
+                      },
+                      error: (err) => {
+                        logger2.error({
+                          err
+                        }, "Error in action execution argument stream");
+                        streamingArgumentsStatus.next((0, import_class_transformer.plainToInstance)(FailedMessageStatus, {
+                          reason: "An unknown error has occurred in the action execution argument stream"
+                        }));
+                        stopStreamingArguments();
+                        actionExecutionArgumentSubscription == null ? void 0 : actionExecutionArgumentSubscription.unsubscribe();
+                      },
+                      complete: () => {
+                        logger2.debug("Action execution argument stream completed");
+                        streamingArgumentsStatus.next(new SuccessMessageStatus());
+                        stopStreamingArguments();
+                        actionExecutionArgumentSubscription == null ? void 0 : actionExecutionArgumentSubscription.unsubscribe();
+                        outputMessages.push((0, import_class_transformer.plainToInstance)(ActionExecutionMessage, {
+                          id: event.actionExecutionId,
+                          createdAt: /* @__PURE__ */ new Date(),
+                          name: event.actionName,
+                          scope: event.scope,
+                          arguments: argumentChunks.join("")
+                        }));
                       }
                     });
-                    stopStreamingArguments();
-                    streamingArgumentsStatus.next(new SuccessMessageStatus());
                   })
                 });
                 break;
               case RuntimeEventTypes.ActionExecutionResult:
+                logger2.debug({
+                  result: event.result
+                }, "Action execution result event received");
                 pushMessage({
                   id: (0, import_nanoid.nanoid)(),
                   status: new SuccessMessageStatus(),
@@ -872,13 +1163,38 @@ var CopilotResolver = class {
                   actionName: event.actionName,
                   result: event.result
                 });
+                outputMessages.push((0, import_class_transformer.plainToInstance)(ResultMessage, {
+                  id: (0, import_nanoid.nanoid)(),
+                  createdAt: /* @__PURE__ */ new Date(),
+                  actionExecutionId: event.actionExecutionId,
+                  actionName: event.actionName,
+                  result: event.result
+                }));
                 break;
             }
           },
-          error: (err) => console.error("Error in event source", err),
-          complete: () => {
-            responseStatus.next(new SuccessResponseStatus());
+          error: (err) => {
+            logger2.error({
+              err
+            }, "Error in event stream");
+            responseStatus$.next(new UnknownErrorResponse({
+              description: `An unknown error has occurred in the event stream`
+            }));
+            eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
+            stopStreamingMessages();
+            rejectOutputMessagesPromise(err);
+          },
+          complete: async () => {
+            var _a2;
+            logger2.debug("Event stream completed");
+            if ((_a2 = data.cloud) == null ? void 0 : _a2.guardrails) {
+              logger2.debug("Guardrails is enabled, waiting for guardrails result");
+              await (0, import_rxjs2.firstValueFrom)(guardrailsResult$);
+            }
+            responseStatus$.next(new SuccessResponseStatus());
+            eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
             stopStreamingMessages();
+            resolveOutputMessagesPromise(outputMessages);
           }
         });
       })
@@ -897,7 +1213,7 @@ _ts_decorate11([
   (0, import_type_graphql12.Mutation)(() => CopilotResponse),
   _ts_param(0, (0, import_type_graphql12.Ctx)()),
   _ts_param(1, (0, import_type_graphql12.Arg)("data")),
-  _ts_param(2, (0, import_type_graphql12.Arg)("properties", () => import_graphql_scalars.GraphQLJSONObject, {
+  _ts_param(2, (0, import_type_graphql12.Arg)("properties", () => import_graphql_scalars2.GraphQLJSONObject, {
     nullable: true
   })),
   _ts_metadata11("design:type", Function),
@@ -914,50 +1230,98 @@ CopilotResolver = _ts_decorate11([
 
 // src/lib/integrations/shared.ts
 var import_plugin_defer_stream = require("@graphql-yoga/plugin-defer-stream");
-async function createContext(initialContext, copilotKitContext) {
+
+// src/lib/logger.ts
+var import_pino = __toESM(require("pino"));
+var import_pino_pretty = __toESM(require("pino-pretty"));
+function createLogger(options) {
+  const { level, component } = options || {};
+  const stream = (0, import_pino_pretty.default)({
+    colorize: true
+  });
+  const logger2 = (0, import_pino.default)({
+    level: process.env.LOG_LEVEL || level || "error",
+    redact: {
+      paths: [
+        "pid",
+        "hostname"
+      ],
+      remove: true
+    }
+  }, stream);
+  if (component) {
+    return logger2.child({
+      component
+    });
+  } else {
+    return logger2;
+  }
+}
+__name(createLogger, "createLogger");
+
+// src/lib/integrations/shared.ts
+var logger = createLogger();
+async function createContext(initialContext, copilotKitContext, contextLogger, properties = {}) {
+  logger.debug({
+    copilotKitContext
+  }, "Creating GraphQL context");
   const ctx = {
     ...initialContext,
     _copilotkit: {
       ...copilotKitContext
-    }
+    },
+    properties: {
+      ...properties
+    },
+    logger: contextLogger
   };
   return ctx;
 }
 __name(createContext, "createContext");
 function buildSchema(options = {}) {
+  logger.debug("Building GraphQL schema...");
   const schema = (0, import_type_graphql13.buildSchemaSync)({
     resolvers: [
       CopilotResolver
     ],
     emitSchemaFile: options.emitSchemaFile
   });
+  logger.debug("GraphQL schema built successfully");
   return schema;
 }
 __name(buildSchema, "buildSchema");
 function getCommonConfig(options) {
+  const logLevel = process.env.LOG_LEVEL || options.logLevel || "error";
+  const logger2 = createLogger({
+    level: logLevel,
+    component: "getCommonConfig"
+  });
+  logger2.debug("Getting common config");
+  const contextLogger = createLogger({
+    level: logLevel
+  });
   return {
+    logging: createLogger({
+      component: "Yoga GraphQL",
+      level: logLevel
+    }),
     schema: buildSchema(),
     plugins: [
       (0, import_plugin_defer_stream.useDeferStream)()
     ],
-    context: (ctx) => createContext(ctx, {
-      runtime: options.runtime,
-      serviceAdapter: options.serviceAdapter,
-      properties: {}
-    })
+    context: (ctx) => createContext(ctx, options, contextLogger, options.properties)
   };
 }
 __name(getCommonConfig, "getCommonConfig");
 
 // src/lib/integrations/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 = (0, import_graphql_yoga2.createYoga)({
     ...commonConfig,
-    graphqlEndpoint: endpoint
+    graphqlEndpoint: options.endpoint
   });
   return yoga;
 }