@copilotkit/runtime 1.6.0 → 1.7.0-next.1

package/dist/{chunk-MPI4JZZR.mjs → chunk-QZ6X33MR.mjs}

@@ -2,7 +2,7 @@ import {
   copilotRuntimeNodeHttpEndpoint,
   getRuntimeInstanceTelemetryInfo,
   telemetry_client_default
-} from "./chunk-DUW72ZZB.mjs";
+} from "./chunk-QTRO3GPV.mjs";
 import {
   __name
 } from "./chunk-FHD4JECV.mjs";
@@ -22,4 +22,4 @@ __name(copilotRuntimeNestEndpoint, "copilotRuntimeNestEndpoint");
 export {
   copilotRuntimeNestEndpoint
 };
-//# sourceMappingURL=chunk-MPI4JZZR.mjs.map
+//# sourceMappingURL=chunk-QZ6X33MR.mjs.map

package/dist/{chunk-2RP2NR4F.mjs → chunk-RQS3BGAT.mjs}

@@ -2,7 +2,7 @@ import {
   copilotRuntimeNodeHttpEndpoint,
   getRuntimeInstanceTelemetryInfo,
   telemetry_client_default
-} from "./chunk-DUW72ZZB.mjs";
+} from "./chunk-QTRO3GPV.mjs";
 import {
   __name
 } from "./chunk-FHD4JECV.mjs";
@@ -22,4 +22,4 @@ __name(copilotRuntimeNodeExpressEndpoint, "copilotRuntimeNodeExpressEndpoint");
 export {
   copilotRuntimeNodeExpressEndpoint
 };
-//# sourceMappingURL=chunk-2RP2NR4F.mjs.map
+//# sourceMappingURL=chunk-RQS3BGAT.mjs.map

package/dist/{copilot-runtime-15bfc4f4.d.ts → copilot-runtime-5103c7e7.d.ts}

@@ -7,6 +7,53 @@ import { YogaInitialContext, createYoga } from 'graphql-yoga';
 import { CopilotCloudOptions } from './lib/cloud/index.js';
 
 type LogLevel = "debug" | "info" | "warn" | "error";
+type CopilotRuntimeLogger = ReturnType<typeof createLogger>;
+declare function createLogger(options?: {
+    level?: LogLevel;
+    component?: string;
+}): pino.Logger<never>;
+interface LogLLMRequestData {
+    threadId?: string;
+    runId?: string;
+    model?: string;
+    messages: any[];
+    actions?: any[];
+    forwardedParameters?: any;
+    timestamp: number;
+    provider?: string;
+    [key: string]: any;
+}
+interface LogLLMResponseData {
+    threadId: string;
+    runId?: string;
+    model?: string;
+    output: any;
+    latency: number;
+    timestamp: number;
+    provider?: string;
+    isProgressiveChunk?: boolean;
+    isFinalResponse?: boolean;
+    [key: string]: any;
+}
+interface LogLLMErrorData {
+    threadId?: string;
+    runId?: string;
+    model?: string;
+    error: Error | string;
+    timestamp: number;
+    provider?: string;
+    [key: string]: any;
+}
+interface CopilotLoggerHooks {
+    logRequest: (data: LogLLMRequestData) => void | Promise<void>;
+    logResponse: (data: LogLLMResponseData) => void | Promise<void>;
+    logError: (data: LogLLMErrorData) => void | Promise<void>;
+}
+interface CopilotLoggingConfig {
+    enabled: boolean;
+    progressive: boolean;
+    logger: CopilotLoggerHooks;
+}
 
 declare const logger: pino.Logger<never>;
 declare const addCustomHeaderPlugin: {
@@ -195,6 +242,22 @@ interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []> {
     remoteEndpoints?: EndpointDefinition[];
     langserve?: RemoteChainParameters[];
     delegateAgentProcessingToServiceAdapter?: boolean;
+    /**
+     * Configuration for LLM request/response logging
+     *
+     * ```ts
+     * logging: {
+     *   enabled: true, // Enable or disable logging
+     *   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 }),
+     *   },
+     * }
+     * ```
+     */
+    logging?: CopilotLoggingConfig;
 }
 declare class CopilotRuntime<const T extends Parameter[] | [] = []> {
     actions: ActionsConfiguration<T>;
@@ -203,16 +266,18 @@ declare class CopilotRuntime<const T extends Parameter[] | [] = []> {
     private onBeforeRequest?;
     private onAfterRequest?;
     private delegateAgentProcessingToServiceAdapter;
+    private logging?;
     constructor(params?: CopilotRuntimeConstructorParams<T>);
     processRuntimeRequest(request: CopilotRuntimeRequest): Promise<CopilotRuntimeResponse>;
     discoverAgentsFromEndpoints(graphqlContext: GraphQLContext): Promise<AgentWithEndpoint[]>;
     loadAgentState(graphqlContext: GraphQLContext, threadId: string, agentName: string): Promise<LoadAgentStateResponse>;
     private processAgentRequest;
     private getServerSideActions;
+    private detectProvider;
 }
 declare function flattenToolCallsNoDuplicates(toolsByPriority: ActionInput[]): ActionInput[];
 declare function copilotKitEndpoint(config: Omit<CopilotKitEndpoint, "type">): CopilotKitEndpoint;
 declare function langGraphPlatformEndpoint(config: Omit<LangGraphPlatformEndpoint, "type">): LangGraphPlatformEndpoint;
 declare function resolveEndpointType(endpoint: EndpointDefinition): EndpointType;
 
-export { CopilotRuntimeConstructorParams as C, GraphQLContext as G, CopilotRuntime as a, addCustomHeaderPlugin as b, copilotKitEndpoint as c, CopilotRequestContextProperties as d, CreateCopilotRuntimeServerOptions as e, flattenToolCallsNoDuplicates as f, createContext as g, buildSchema as h, CommonConfig as i, getCommonConfig as j, langGraphPlatformEndpoint as l, resolveEndpointType as r };
+export { CopilotRuntimeConstructorParams as C, GraphQLContext as G, LogLevel as L, CopilotRuntime as a, addCustomHeaderPlugin as b, copilotKitEndpoint as c, CopilotRequestContextProperties as d, CreateCopilotRuntimeServerOptions as e, flattenToolCallsNoDuplicates as f, createContext as g, buildSchema as h, CommonConfig as i, getCommonConfig as j, CopilotRuntimeLogger as k, langGraphPlatformEndpoint as l, createLogger as m, LogLLMRequestData as n, LogLLMResponseData as o, LogLLMErrorData as p, CopilotLoggerHooks as q, resolveEndpointType as r, CopilotLoggingConfig as s };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { i as CommonConfig, d as CopilotRequestContextProperties, a as CopilotRuntime, C as CopilotRuntimeConstructorParams, e as CreateCopilotRuntimeServerOptions, G as GraphQLContext, b as addCustomHeaderPlugin, h as buildSchema, c as copilotKitEndpoint, g as createContext, f as flattenToolCallsNoDuplicates, j as getCommonConfig, l as langGraphPlatformEndpoint, r as resolveEndpointType } from './copilot-runtime-15bfc4f4.js';
+export { i as CommonConfig, q as CopilotLoggerHooks, s as CopilotLoggingConfig, d as CopilotRequestContextProperties, a as CopilotRuntime, C as CopilotRuntimeConstructorParams, k as CopilotRuntimeLogger, e as CreateCopilotRuntimeServerOptions, G as GraphQLContext, p as LogLLMErrorData, n as LogLLMRequestData, o as LogLLMResponseData, L as LogLevel, b as addCustomHeaderPlugin, h as buildSchema, c as copilotKitEndpoint, g as createContext, m as createLogger, f as flattenToolCallsNoDuplicates, j as getCommonConfig, l as langGraphPlatformEndpoint, r as resolveEndpointType } from './copilot-runtime-5103c7e7.js';
 export { G as GoogleGenerativeAIAdapter, f as GroqAdapter, e as GroqAdapterParams, L as LangChainAdapter, a as OpenAIAdapter, O as OpenAIAdapterParams, c as OpenAIAssistantAdapter, b as OpenAIAssistantAdapterParams, d as UnifyAdapter, U as UnifyAdapterParams } from './groq-adapter-fb9aa3ab.js';
 export { CopilotRuntimeServerInstance, config, copilotRuntimeNextJSAppRouterEndpoint, copilotRuntimeNextJSPagesRouterEndpoint } from './lib/integrations/index.js';
 export { copilotRuntimeNodeHttpEndpoint } from './lib/integrations/node-http/index.js';

package/dist/index.js

@@ -44,7 +44,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",
@@ -150,6 +150,7 @@ __export(src_exports, {
   copilotRuntimeNodeExpressEndpoint: () => copilotRuntimeNodeExpressEndpoint,
   copilotRuntimeNodeHttpEndpoint: () => copilotRuntimeNodeHttpEndpoint,
   createContext: () => createContext,
+  createLogger: () => createLogger,
   flattenToolCallsNoDuplicates: () => flattenToolCallsNoDuplicates,
   getCommonConfig: () => getCommonConfig,
   langGraphPlatformEndpoint: () => langGraphPlatformEndpoint,
@@ -2637,7 +2638,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;
@@ -2647,7 +2648,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",
@@ -3062,6 +3063,54 @@ __name(getSchemaKeys, "getSchemaKeys");
 
 // src/lib/runtime/remote-action-constructors.ts
 var import_shared13 = require("@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
 var import_shared14 = require("@copilotkit/shared");
 var import_shared15 = require("@copilotkit/shared");
 function constructLGCRemoteAction({ endpoint, graphqlContext, logger: logger2, messages, agentStates }) {
@@ -3071,7 +3120,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");
@@ -3115,7 +3164,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({
@@ -3132,6 +3181,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) => ({
@@ -3201,7 +3255,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");
@@ -3261,9 +3315,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 import_shared13.CopilotKitError) {
           throw error;
@@ -3281,50 +3343,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"
@@ -3348,13 +3366,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
@@ -3858,7 +3876,7 @@ async function executeAction(eventStream$, guardrailsResult$, action, actionArgu
       return;
     }
   }
-  if (isLangGraphAgentAction(action)) {
+  if (isRemoteAgentAction(action)) {
     const result = `${action.name} agent started`;
     const agentExecution = (0, import_class_transformer.plainToInstance)(ActionExecutionMessage, {
       id: actionExecutionId,
@@ -3879,7 +3897,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,
@@ -3991,6 +4009,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)) {
@@ -4007,11 +4026,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);
@@ -4026,6 +4048,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,
@@ -4038,7 +4077,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,
@@ -4069,6 +4108,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,
@@ -4081,6 +4183,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 import_shared20.CopilotKitError) {
         throw error;
       }
@@ -4090,7 +4208,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) {
@@ -4116,11 +4233,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
           })
@@ -4166,7 +4284,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}`
@@ -4201,11 +4318,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,
@@ -4250,7 +4368,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 import_shared20.CopilotKitAgentDiscoveryError({
         agentName
@@ -4258,8 +4376,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,
@@ -4277,7 +4395,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,
@@ -4351,6 +4469,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) {
@@ -5370,6 +5503,9 @@ var CopilotResolver = class {
       resolveOutputMessagesPromise = resolve;
       rejectOutputMessagesPromise = reject;
     });
+    if (copilotCloudPublicApiKey) {
+      ctx.properties["copilotCloudPublicApiKey"] = copilotCloudPublicApiKey;
+    }
     logger2.debug("Processing");
     const { eventSource, threadId = (0, import_shared21.randomId)(), runId, serverSideActions, actionInputsWithoutAgents, extensions } = await copilotRuntime.processRuntimeRequest({
       serviceAdapter,
@@ -6166,6 +6302,7 @@ __name(copilotRuntimeNestEndpoint, "copilotRuntimeNestEndpoint");
   copilotRuntimeNodeExpressEndpoint,
   copilotRuntimeNodeHttpEndpoint,
   createContext,
+  createLogger,
   flattenToolCallsNoDuplicates,
   getCommonConfig,
   langGraphPlatformEndpoint,