@copilotkit/runtime 1.6.0 → 1.7.0-next.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @copilotkit/runtime
 
+## 1.7.0-next.1
+
+### Patch Changes
+
+- 1e934e4: - feat(runtime): Add LangFuse logging integration
+  - @copilotkit/shared@1.7.0-next.1
+
+## 1.7.0-next.0
+
+### Minor Changes
+
+- 082db7a: - CrewAI support
+
+### Patch Changes
+
+- 082db7a: - Added RemoteAgentAdapter and implemented CopilotKit (protocol & events).
+  - Integrated CrewAI (with a prototype, HITL, event system, and chat/demo tweaks).
+  - Updated docs and cleaned up code (fixing stdout issues, restricting Python version, and streamlining demos).
+  - @copilotkit/shared@1.7.0-next.0
+
 ## 1.6.0
 
 ### Minor Changes
@@ -24,6 +44,14 @@
 - Updated dependencies [090203d]
   - @copilotkit/shared@1.6.0
 
+## 1.6.0-next.12
+
+### Patch Changes
+
+- 1bb9ca2: - fix(coagents): don't fail when LangSmith API key is missing
+  - fix(coagents): don't check for langsmithApiKey in resolveEndpointType
+  - @copilotkit/shared@1.6.0-next.12
+
 ## 1.6.0-next.11
 
 ### Patch Changes

package/README.md

@@ -44,3 +44,78 @@
 # Documentation
 
 To get started with CopilotKit, please check out the [documentation](https://docs.copilotkit.ai).
+
+## LangFuse Logging Integration
+
+CopilotKit now supports LangFuse logging integration to help you monitor, analyze, and debug your LLM requests and responses.
+
+### Setup
+
+To enable LangFuse logging, you can configure it when initializing the CopilotRuntime:
+
+```typescript
+import { CopilotRuntime, OpenAIAdapter } from "@copilotkit/runtime";
+import { LangfuseClient } from "langfuse";
+
+// Initialize your LangFuse client
+const langfuse = new LangfuseClient({
+  publicKey: process.env.LANGFUSE_PUBLIC_KEY!,
+  secretKey: process.env.LANGFUSE_SECRET_KEY!,
+  baseUrl: process.env.LANGFUSE_BASE_URL,
+});
+
+// Create a CopilotRuntime with LangFuse logging enabled
+const runtime = new CopilotRuntime({
+  adapter: new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY }),
+  logging: {
+    enabled: true,
+    progressive: true, // Set to false for buffered logging
+    logger: {
+      logRequest: (data) => langfuse.trace({ name: "LLM Request", input: data }),
+      logResponse: (data) => langfuse.trace({ name: "LLM Response", output: data }),
+      logError: (errorData) => langfuse.trace({ name: "LLM Error", metadata: errorData }),
+    },
+  },
+});
+```
+
+### Configuration Options
+
+The logging configuration accepts the following options:
+
+- `enabled` (boolean): Enable or disable logging (default: false)
+- `progressive` (boolean): When true, logs each chunk as it's streamed. When false, logs the complete response (default: true)
+- `logger` (object): Contains callback functions for logging:
+  - `logRequest`: Called when an LLM request is made
+  - `logResponse`: Called when an LLM response is received
+  - `logError`: Called when an error occurs during an LLM request
+
+### Custom Logging Integrations
+
+You can integrate with any logging service by implementing the logger interface:
+
+```typescript
+const runtime = new CopilotRuntime({
+  adapter: new OpenAIAdapter({ apiKey: "YOUR_API_KEY" }),
+  logging: {
+    enabled: true,
+    progressive: false,
+    logger: {
+      logRequest: (data) => {
+        // Implement your custom logging logic
+        console.log("LLM Request:", JSON.stringify(data));
+      },
+      logResponse: (data) => {
+        // Implement your custom logging logic
+        console.log("LLM Response:", JSON.stringify(data));
+      },
+      logError: (error) => {
+        // Implement your custom error logging
+        console.error("LLM Error:", error);
+      },
+    },
+  },
+});
+```
+
+This allows you to send your logs to any system or service that you prefer.

package/dist/{chunk-WUMAYJP3.mjs → chunk-D6YNY2XB.mjs}

@@ -2,7 +2,7 @@ import {
   getCommonConfig,
   getRuntimeInstanceTelemetryInfo,
   telemetry_client_default
-} from "./chunk-DUW72ZZB.mjs";
+} from "./chunk-QTRO3GPV.mjs";
 import {
   __name
 } from "./chunk-FHD4JECV.mjs";
@@ -77,4 +77,4 @@ export {
   config,
   copilotRuntimeNextJSPagesRouterEndpoint
 };
-//# sourceMappingURL=chunk-WUMAYJP3.mjs.map
+//# sourceMappingURL=chunk-D6YNY2XB.mjs.map

package/dist/chunk-PTC5JN3P.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-PTC5JN3P.mjs.map

package/dist/{chunk-DUW72ZZB.mjs → chunk-QTRO3GPV.mjs}

@@ -39,7 +39,7 @@ var require_package = __commonJS({
       publishConfig: {
         access: "public"
       },
-      version: "1.6.0",
+      version: "1.7.0-next.1",
       sideEffects: false,
       main: "./dist/index.js",
       module: "./dist/index.mjs",
@@ -1815,7 +1815,7 @@ async function streamEvents(controller, args) {
   let emitIntermediateStateUntilEnd = null;
   let shouldExit = false;
   let externalRunId = null;
-  const streamResponse2 = client.runs.stream(threadId, assistantId, payload);
+  const streamResponse = client.runs.stream(threadId, assistantId, payload);
   const emit = /* @__PURE__ */ __name((message) => controller.enqueue(new TextEncoder().encode(message)), "emit");
   let latestStateValues = {};
   let updatedState = state;
@@ -1825,7 +1825,7 @@ async function streamEvents(controller, args) {
     telemetry_client_default.capture("oss.runtime.agent_execution_stream_started", {
       hashedLgcKey: streamInfo.hashedLgcKey
     });
-    for await (const chunk of streamResponse2) {
+    for await (const chunk of streamResponse) {
       if (![
         "events",
         "values",
@@ -2240,6 +2240,54 @@ __name(getSchemaKeys, "getSchemaKeys");
 
 // src/lib/runtime/remote-action-constructors.ts
 import { CopilotKitError, CopilotKitLowLevelError } from "@copilotkit/shared";
+
+// src/lib/streaming.ts
+async function writeJsonLineResponseToEventStream(response, eventStream$) {
+  const reader = response.getReader();
+  const decoder = new TextDecoder();
+  let buffer = [];
+  function flushBuffer() {
+    const currentBuffer = buffer.join("");
+    if (currentBuffer.trim().length === 0) {
+      return;
+    }
+    const parts = currentBuffer.split("\n");
+    if (parts.length === 0) {
+      return;
+    }
+    const lastPartIsComplete = currentBuffer.endsWith("\n");
+    buffer = [];
+    if (!lastPartIsComplete) {
+      buffer.push(parts.pop());
+    }
+    parts.map((part) => part.trim()).filter((part) => part != "").forEach((part) => {
+      eventStream$.next(JSON.parse(part));
+    });
+  }
+  __name(flushBuffer, "flushBuffer");
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (!done) {
+        buffer.push(decoder.decode(value, {
+          stream: true
+        }));
+      }
+      flushBuffer();
+      if (done) {
+        break;
+      }
+    }
+  } catch (error) {
+    console.error("Error in stream", error);
+    eventStream$.error(error);
+    return;
+  }
+  eventStream$.complete();
+}
+__name(writeJsonLineResponseToEventStream, "writeJsonLineResponseToEventStream");
+
+// src/lib/runtime/remote-action-constructors.ts
 import { CopilotKitApiDiscoveryError, ResolvedCopilotKitError } from "@copilotkit/shared";
 import { parseJson as parseJson2, tryMap } from "@copilotkit/shared";
 function constructLGCRemoteAction({ endpoint, graphqlContext, logger: logger2, messages, agentStates }) {
@@ -2249,7 +2297,7 @@ function constructLGCRemoteAction({ endpoint, graphqlContext, logger: logger2, m
     parameters: [],
     handler: async (_args) => {
     },
-    langGraphAgentHandler: async ({ name, actionInputsWithoutAgents, threadId, nodeName, additionalMessages = [], metaEvents }) => {
+    remoteAgentHandler: async ({ name, actionInputsWithoutAgents, threadId, nodeName, additionalMessages = [], metaEvents }) => {
       logger2.debug({
         actionName: agent.name
       }, "Executing LangGraph Platform agent");
@@ -2293,7 +2341,7 @@ function constructLGCRemoteAction({ endpoint, graphqlContext, logger: logger2, m
           metaEvents
         });
         const eventSource = new RemoteLangGraphEventSource();
-        streamResponse(response, eventSource.eventStream$);
+        writeJsonLineResponseToEventStream(response, eventSource.eventStream$);
         return eventSource.processLangGraphEvents();
       } catch (error) {
         logger2.error({
@@ -2310,6 +2358,11 @@ function constructLGCRemoteAction({ endpoint, graphqlContext, logger: logger2, m
   ];
 }
 __name(constructLGCRemoteAction, "constructLGCRemoteAction");
+var RemoteAgentType;
+(function(RemoteAgentType2) {
+  RemoteAgentType2["LangGraph"] = "langgraph";
+  RemoteAgentType2["CrewAI"] = "crewai";
+})(RemoteAgentType || (RemoteAgentType = {}));
 function constructRemoteActions({ json, url, onBeforeRequest, graphqlContext, logger: logger2, messages, agentStates }) {
   const totalAgents = Array.isArray(json["agents"]) ? json["agents"].length : 0;
   const actions = json["actions"].map((action) => ({
@@ -2379,7 +2432,7 @@ function constructRemoteActions({ json, url, onBeforeRequest, graphqlContext, lo
     parameters: [],
     handler: async (_args) => {
     },
-    langGraphAgentHandler: async ({ name, actionInputsWithoutAgents, threadId, nodeName, additionalMessages = [], metaEvents }) => {
+    remoteAgentHandler: async ({ name, actionInputsWithoutAgents, threadId, nodeName, additionalMessages = [], metaEvents }) => {
       logger2.debug({
         actionName: agent.name
       }, "Executing remote agent");
@@ -2439,9 +2492,17 @@ function constructRemoteActions({ json, url, onBeforeRequest, graphqlContext, lo
             isRemoteEndpoint: true
           });
         }
-        const eventSource = new RemoteLangGraphEventSource();
-        streamResponse(response.body, eventSource.eventStream$);
-        return eventSource.processLangGraphEvents();
+        if (agent.type === "langgraph") {
+          const eventSource = new RemoteLangGraphEventSource();
+          writeJsonLineResponseToEventStream(response.body, eventSource.eventStream$);
+          return eventSource.processLangGraphEvents();
+        } else if (agent.type === "crewai") {
+          const eventStream$ = new RuntimeEventSubject();
+          writeJsonLineResponseToEventStream(response.body, eventStream$);
+          return eventStream$;
+        } else {
+          throw new Error("Unsupported agent type");
+        }
       } catch (error) {
         if (error instanceof CopilotKitError) {
           throw error;
@@ -2459,50 +2520,6 @@ function constructRemoteActions({ json, url, onBeforeRequest, graphqlContext, lo
   ];
 }
 __name(constructRemoteActions, "constructRemoteActions");
-async function streamResponse(response, eventStream$) {
-  const reader = response.getReader();
-  const decoder = new TextDecoder();
-  let buffer = [];
-  function flushBuffer() {
-    const currentBuffer = buffer.join("");
-    if (currentBuffer.trim().length === 0) {
-      return;
-    }
-    const parts = currentBuffer.split("\n");
-    if (parts.length === 0) {
-      return;
-    }
-    const lastPartIsComplete = currentBuffer.endsWith("\n");
-    buffer = [];
-    if (!lastPartIsComplete) {
-      buffer.push(parts.pop());
-    }
-    parts.map((part) => part.trim()).filter((part) => part != "").forEach((part) => {
-      eventStream$.next(JSON.parse(part));
-    });
-  }
-  __name(flushBuffer, "flushBuffer");
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (!done) {
-        buffer.push(decoder.decode(value, {
-          stream: true
-        }));
-      }
-      flushBuffer();
-      if (done) {
-        break;
-      }
-    }
-  } catch (error) {
-    console.error("Error in stream", error);
-    eventStream$.error(error);
-    return;
-  }
-  eventStream$.complete();
-}
-__name(streamResponse, "streamResponse");
 function createHeaders(onBeforeRequest, graphqlContext) {
   const headers = {
     "Content-Type": "application/json"
@@ -2526,13 +2543,13 @@ var EndpointType;
   EndpointType2["CopilotKit"] = "copilotKit";
   EndpointType2["LangGraphPlatform"] = "langgraph-platform";
 })(EndpointType || (EndpointType = {}));
-function isLangGraphAgentAction(action) {
+function isRemoteAgentAction(action) {
   if (!action) {
     return false;
   }
-  return typeof action.langGraphAgentHandler === "function";
+  return typeof action.remoteAgentHandler === "function";
 }
-__name(isLangGraphAgentAction, "isLangGraphAgentAction");
+__name(isRemoteAgentAction, "isRemoteAgentAction");
 async function fetchRemoteInfo({ url, onBeforeRequest, graphqlContext, logger: logger2, frontendUrl }) {
   logger2.debug({
     url
@@ -2695,6 +2712,7 @@ var CopilotRuntime = class {
   onBeforeRequest;
   onAfterRequest;
   delegateAgentProcessingToServiceAdapter;
+  logging;
   constructor(params) {
     var _a, _b;
     if ((params == null ? void 0 : params.actions) && (params == null ? void 0 : params.remoteEndpoints)) {
@@ -2711,11 +2729,14 @@ var CopilotRuntime = class {
     this.onBeforeRequest = (_a = params == null ? void 0 : params.middleware) == null ? void 0 : _a.onBeforeRequest;
     this.onAfterRequest = (_b = params == null ? void 0 : params.middleware) == null ? void 0 : _b.onAfterRequest;
     this.delegateAgentProcessingToServiceAdapter = (params == null ? void 0 : params.delegateAgentProcessingToServiceAdapter) || false;
+    this.logging = params == null ? void 0 : params.logging;
   }
   async processRuntimeRequest(request) {
-    var _a;
+    var _a, _b, _c, _d, _e;
     const { serviceAdapter, messages: rawMessages, actions: clientSideActionsInput, threadId, runId, outputMessagesPromise, graphqlContext, forwardedParameters, url, extensions, agentSession, agentStates } = request;
     const eventSource = new RuntimeEventSource();
+    const requestStartTime = Date.now();
+    const streamedChunks = [];
     try {
       if (agentSession && !this.delegateAgentProcessingToServiceAdapter) {
         return await this.processAgentRequest(request);
@@ -2730,6 +2751,23 @@ please use an LLM adapter instead.`
       const messages = rawMessages.filter((message) => !message.agentStateMessage);
       const inputMessages = convertGqlInputToMessages(messages);
       const serverSideActions = await this.getServerSideActions(request);
+      if ((_a = this.logging) == null ? void 0 : _a.enabled) {
+        try {
+          const requestData = {
+            threadId,
+            runId,
+            model: forwardedParameters == null ? void 0 : forwardedParameters.model,
+            messages: inputMessages,
+            actions: clientSideActionsInput,
+            forwardedParameters,
+            timestamp: requestStartTime,
+            provider: this.detectProvider(serviceAdapter)
+          };
+          await this.logging.logger.logRequest(requestData);
+        } catch (error) {
+          console.error("Error logging LLM request:", error);
+        }
+      }
       const serverSideActionsInput = serverSideActions.map((action) => ({
         name: action.name,
         description: action.description,
@@ -2742,7 +2780,7 @@ please use an LLM adapter instead.`
           (action) => action.available !== ActionInputAvailability.remote
         )
       ]);
-      await ((_a = this.onBeforeRequest) == null ? void 0 : _a.call(this, {
+      await ((_b = this.onBeforeRequest) == null ? void 0 : _b.call(this, {
         threadId,
         runId,
         inputMessages,
@@ -2773,6 +2811,69 @@ please use an LLM adapter instead.`
         });
       }).catch((_error) => {
       });
+      if ((_c = this.logging) == null ? void 0 : _c.enabled) {
+        try {
+          outputMessagesPromise.then((outputMessages) => {
+            var _a2;
+            const responseData = {
+              threadId: result.threadId,
+              runId: result.runId,
+              model: forwardedParameters == null ? void 0 : forwardedParameters.model,
+              // Use collected chunks for progressive mode or outputMessages for regular mode
+              output: this.logging.progressive ? streamedChunks : outputMessages,
+              latency: Date.now() - requestStartTime,
+              timestamp: Date.now(),
+              provider: this.detectProvider(serviceAdapter),
+              // Indicate this is the final response
+              isFinalResponse: true
+            };
+            try {
+              (_a2 = this.logging) == null ? void 0 : _a2.logger.logResponse(responseData);
+            } catch (logError) {
+              console.error("Error logging LLM response:", logError);
+            }
+          }).catch((error) => {
+            console.error("Failed to get output messages for logging:", error);
+          });
+        } catch (error) {
+          console.error("Error setting up logging for LLM response:", error);
+        }
+      }
+      if (((_d = this.logging) == null ? void 0 : _d.enabled) && this.logging.progressive) {
+        const originalStream = eventSource.stream.bind(eventSource);
+        eventSource.stream = async (callback) => {
+          await originalStream(async (eventStream$) => {
+            eventStream$.subscribe({
+              next: (event) => {
+                if (event.type === RuntimeEventTypes.TextMessageContent) {
+                  streamedChunks.push(event.content);
+                  try {
+                    const progressiveData = {
+                      threadId: threadId || "",
+                      runId,
+                      model: forwardedParameters == null ? void 0 : forwardedParameters.model,
+                      output: event.content,
+                      latency: Date.now() - requestStartTime,
+                      timestamp: Date.now(),
+                      provider: this.detectProvider(serviceAdapter),
+                      isProgressiveChunk: true
+                    };
+                    Promise.resolve().then(() => {
+                      var _a2;
+                      (_a2 = this.logging) == null ? void 0 : _a2.logger.logResponse(progressiveData);
+                    }).catch((error) => {
+                      console.error("Error in progressive logging:", error);
+                    });
+                  } catch (error) {
+                    console.error("Error preparing progressive log data:", error);
+                  }
+                }
+              }
+            });
+            await callback(eventStream$);
+          });
+        };
+      }
       return {
         threadId: nonEmptyThreadId,
         runId: result.runId,
@@ -2785,6 +2886,22 @@ please use an LLM adapter instead.`
         extensions: result.extensions
       };
     } catch (error) {
+      if ((_e = this.logging) == null ? void 0 : _e.enabled) {
+        try {
+          const errorData = {
+            threadId,
+            runId,
+            model: forwardedParameters == null ? void 0 : forwardedParameters.model,
+            error: error instanceof Error ? error : String(error),
+            timestamp: Date.now(),
+            latency: Date.now() - requestStartTime,
+            provider: this.detectProvider(serviceAdapter)
+          };
+          await this.logging.logger.logError(errorData);
+        } catch (logError) {
+          console.error("Error logging LLM error:", logError);
+        }
+      }
       if (error instanceof CopilotKitError3) {
         throw error;
       }
@@ -2794,7 +2911,6 @@ please use an LLM adapter instead.`
     }
   }
   async discoverAgentsFromEndpoints(graphqlContext) {
-    const headers = createHeaders(null, graphqlContext);
     const agents = this.remoteEndpointDefinitions.reduce(async (acc, endpoint) => {
       const agents2 = await acc;
       if (endpoint.type === EndpointType.LangGraphPlatform) {
@@ -2820,11 +2936,12 @@ please use an LLM adapter instead.`
           ...endpointAgents
         ];
       }
+      const cpkEndpoint = endpoint;
       const fetchUrl = `${endpoint.url}/info`;
       try {
         const response = await fetch(fetchUrl, {
           method: "POST",
-          headers,
+          headers: createHeaders(cpkEndpoint.onBeforeRequest, graphqlContext),
           body: JSON.stringify({
             properties: graphqlContext.properties
           })
@@ -2870,7 +2987,6 @@ please use an LLM adapter instead.`
     if (!agentWithEndpoint) {
       throw new Error("Agent not found");
     }
-    const headers = createHeaders(null, graphqlContext);
     if (agentWithEndpoint.endpoint.type === EndpointType.LangGraphPlatform) {
       const propertyHeaders = graphqlContext.properties.authorization ? {
         authorization: `Bearer ${graphqlContext.properties.authorization}`
@@ -2905,11 +3021,12 @@ please use an LLM adapter instead.`
         };
       }
     } else if (agentWithEndpoint.endpoint.type === EndpointType.CopilotKit || !("type" in agentWithEndpoint.endpoint)) {
-      const fetchUrl = `${agentWithEndpoint.endpoint.url}/agents/state`;
+      const cpkEndpoint = agentWithEndpoint.endpoint;
+      const fetchUrl = `${cpkEndpoint.url}/agents/state`;
       try {
         const response = await fetch(fetchUrl, {
           method: "POST",
-          headers,
+          headers: createHeaders(cpkEndpoint.onBeforeRequest, graphqlContext),
           body: JSON.stringify({
             properties: graphqlContext.properties,
             threadId,
@@ -2954,7 +3071,7 @@ please use an LLM adapter instead.`
     const threadId = threadIdFromRequest ?? agentSession.threadId;
     const serverSideActions = await this.getServerSideActions(request);
     const messages = convertGqlInputToMessages(rawMessages);
-    const currentAgent = serverSideActions.find((action) => action.name === agentName && isLangGraphAgentAction(action));
+    const currentAgent = serverSideActions.find((action) => action.name === agentName && isRemoteAgentAction(action));
     if (!currentAgent) {
       throw new CopilotKitAgentDiscoveryError({
         agentName
@@ -2962,8 +3079,8 @@ please use an LLM adapter instead.`
     }
     const availableActionsForCurrentAgent = serverSideActions.filter((action) => (
       // Case 1: Keep all regular (non-agent) actions
-      !isLangGraphAgentAction(action) || // Case 2: For agent actions, keep all except self (prevent infinite loops)
-      isLangGraphAgentAction(action) && action.name !== agentName
+      !isRemoteAgentAction(action) || // Case 2: For agent actions, keep all except self (prevent infinite loops)
+      isRemoteAgentAction(action) && action.name !== agentName
     )).map((action) => ({
       name: action.name,
       description: action.description,
@@ -2981,7 +3098,7 @@ please use an LLM adapter instead.`
     }));
     try {
       const eventSource = new RuntimeEventSource();
-      const stream = await currentAgent.langGraphAgentHandler({
+      const stream = await currentAgent.remoteAgentHandler({
         name: agentName,
         threadId,
         nodeName,
@@ -3055,6 +3172,21 @@ please use an LLM adapter instead.`
       ...remoteActions
     ];
   }
+  // Add helper method to detect provider
+  detectProvider(serviceAdapter) {
+    const adapterName = serviceAdapter.constructor.name;
+    if (adapterName.includes("OpenAI"))
+      return "openai";
+    if (adapterName.includes("Anthropic"))
+      return "anthropic";
+    if (adapterName.includes("Google"))
+      return "google";
+    if (adapterName.includes("Groq"))
+      return "groq";
+    if (adapterName.includes("LangChain"))
+      return "langchain";
+    return void 0;
+  }
 };
 __name(CopilotRuntime, "CopilotRuntime");
 function flattenToolCallsNoDuplicates(toolsByPriority) {
@@ -3352,7 +3484,7 @@ async function executeAction(eventStream$, guardrailsResult$, action, actionArgu
       return;
     }
   }
-  if (isLangGraphAgentAction(action)) {
+  if (isRemoteAgentAction(action)) {
     const result = `${action.name} agent started`;
     const agentExecution = plainToInstance2(ActionExecutionMessage, {
       id: actionExecutionId,
@@ -3373,7 +3505,7 @@ async function executeAction(eventStream$, guardrailsResult$, action, actionArgu
       actionName: action.name,
       result
     });
-    const stream = await action.langGraphAgentHandler({
+    const stream = await action.remoteAgentHandler({
       name: action.name,
       threadId,
       actionInputsWithoutAgents,
@@ -3611,6 +3743,9 @@ var CopilotResolver = class {
       resolveOutputMessagesPromise = resolve;
       rejectOutputMessagesPromise = reject;
     });
+    if (copilotCloudPublicApiKey) {
+      ctx.properties["copilotCloudPublicApiKey"] = copilotCloudPublicApiKey;
+    }
     logger2.debug("Processing");
     const { eventSource, threadId = randomId4(), runId, serverSideActions, actionInputsWithoutAgents, extensions } = await copilotRuntime.processRuntimeRequest({
       serviceAdapter,
@@ -4299,10 +4434,11 @@ export {
   copilotKitEndpoint,
   langGraphPlatformEndpoint,
   resolveEndpointType,
+  createLogger,
   addCustomHeaderPlugin,
   createContext,
   buildSchema,
   getCommonConfig,
   copilotRuntimeNodeHttpEndpoint
 };
-//# sourceMappingURL=chunk-DUW72ZZB.mjs.map
+//# sourceMappingURL=chunk-QTRO3GPV.mjs.map