@copilotkit/runtime 1.7.0-next.0 → 1.7.0-next.1

package/dist/{chunk-2BN7NZNC.mjs → chunk-QZ6X33MR.mjs}

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

package/dist/{chunk-ZYFN76KV.mjs → chunk-RQS3BGAT.mjs}

@@ -2,7 +2,7 @@ import {
   copilotRuntimeNodeHttpEndpoint,
   getRuntimeInstanceTelemetryInfo,
   telemetry_client_default
-} from "./chunk-34Y5DNNJ.mjs";
+} from "./chunk-QTRO3GPV.mjs";
 import {
   __name
 } from "./chunk-FHD4JECV.mjs";
@@ -22,4 +22,4 @@ __name(copilotRuntimeNodeExpressEndpoint, "copilotRuntimeNodeExpressEndpoint");
 export {
   copilotRuntimeNodeExpressEndpoint
 };
-//# sourceMappingURL=chunk-ZYFN76KV.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.7.0-next.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,
@@ -4008,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)) {
@@ -4024,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);
@@ -4043,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,
@@ -4055,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,
@@ -4086,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,
@@ -4098,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;
       }
@@ -4183,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}`
@@ -4369,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) {
@@ -6187,6 +6302,7 @@ __name(copilotRuntimeNestEndpoint, "copilotRuntimeNestEndpoint");
   copilotRuntimeNodeExpressEndpoint,
   copilotRuntimeNodeHttpEndpoint,
   createContext,
+  createLogger,
   flattenToolCallsNoDuplicates,
   getCommonConfig,
   langGraphPlatformEndpoint,