@copilotkit/runtime 1.6.0 → 1.7.0-next.1

package/dist/lib/integrations/node-http/index.mjs

@@ -1,6 +1,6 @@
 import {
   copilotRuntimeNodeHttpEndpoint
-} from "../../../chunk-DUW72ZZB.mjs";
+} from "../../../chunk-QTRO3GPV.mjs";
 import "../../../chunk-FZJAYGIR.mjs";
 import "../../../chunk-5BIEM2UU.mjs";
 import "../../../chunk-RTFJTJMA.mjs";

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.6.0",
+  "version": "1.7.0-next.1",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -59,7 +59,7 @@
     "rxjs": "^7.8.1",
     "type-graphql": "2.0.0-rc.1",
     "zod": "^3.23.3",
-    "@copilotkit/shared": "1.6.0"
+    "@copilotkit/shared": "1.7.0-next.1"
   },
   "keywords": [
     "copilotkit",

package/src/graphql/resolvers/copilot.resolver.ts

@@ -196,6 +196,10 @@ export class CopilotResolver {
       rejectOutputMessagesPromise = reject;
     });
 
+    if (copilotCloudPublicApiKey) {
+      ctx.properties["copilotCloudPublicApiKey"] = copilotCloudPublicApiKey;
+    }
+
     logger.debug("Processing");
     const {
       eventSource,

package/src/lib/index.ts

@@ -6,3 +6,4 @@ export * from "../service-adapters/openai/openai-assistant-adapter";
 export * from "../service-adapters/unify/unify-adapter";
 export * from "../service-adapters/groq/groq-adapter";
 export * from "./integrations";
+export * from "./logger";

package/src/lib/logger.ts

@@ -26,3 +26,51 @@ export function createLogger(options?: { level?: LogLevel; component?: string })
     return logger;
   }
 }
+
+// LangFuse Logging Integration
+export interface LogLLMRequestData {
+  threadId?: string;
+  runId?: string;
+  model?: string;
+  messages: any[];
+  actions?: any[];
+  forwardedParameters?: any;
+  timestamp: number;
+  provider?: string;
+  [key: string]: any;
+}
+
+export interface LogLLMResponseData {
+  threadId: string;
+  runId?: string;
+  model?: string;
+  output: any;
+  latency: number;
+  timestamp: number;
+  provider?: string;
+  isProgressiveChunk?: boolean;
+  isFinalResponse?: boolean;
+  [key: string]: any;
+}
+
+export interface LogLLMErrorData {
+  threadId?: string;
+  runId?: string;
+  model?: string;
+  error: Error | string;
+  timestamp: number;
+  provider?: string;
+  [key: string]: any;
+}
+
+export interface CopilotLoggerHooks {
+  logRequest: (data: LogLLMRequestData) => void | Promise<void>;
+  logResponse: (data: LogLLMResponseData) => void | Promise<void>;
+  logError: (data: LogLLMErrorData) => void | Promise<void>;
+}
+
+export interface CopilotLoggingConfig {
+  enabled: boolean;
+  progressive: boolean;
+  logger: CopilotLoggerHooks;
+}

package/src/lib/runtime/__tests__/remote-action-constructors.test.ts

@@ -1,3 +1,4 @@
+import "reflect-metadata";
 import { TextEncoder } from "util";
 import { RemoteLangGraphEventSource } from "../../../agents/langgraph/event-source";
 import telemetry from "../../telemetry-client";
@@ -7,6 +8,7 @@ import {
   createHeaders,
 } from "../remote-action-constructors";
 import { execute } from "../remote-lg-action";
+import { ReplaySubject } from "rxjs";
 
 // Mock external dependencies
 jest.mock("../remote-lg-action", () => ({
@@ -49,7 +51,7 @@ beforeEach(() => {
 
 describe("remote action constructors", () => {
   describe("constructLGCRemoteAction", () => {
-    it("should create an agent with langGraphAgentHandler that processes events", async () => {
+    it("should create an agent with remoteAgentHandler that processes events", async () => {
       // Arrange: simulate execute returning a dummy ReadableStream
       const dummyEncodedEvent = new TextEncoder().encode(JSON.stringify({ event: "test" }) + "\n");
       const readerMock = {
@@ -72,7 +74,7 @@ describe("remote action constructors", () => {
         processLangGraphEvents: processLangGraphEventsMock,
       }));
 
-      // Act: build the action and call langGraphAgentHandler
+      // Act: build the action and call remoteAgentHandler
       const actions = constructLGCRemoteAction({
         endpoint,
         graphqlContext,
@@ -84,7 +86,7 @@ describe("remote action constructors", () => {
       const action = actions[0];
       expect(action.name).toEqual(dummyAgent.name);
 
-      const result = await action.langGraphAgentHandler({
+      const result = await action.remoteAgentHandler({
         name: dummyAgent.name,
         actionInputsWithoutAgents: [],
         threadId: "thread1",
@@ -160,26 +162,46 @@ describe("remote action constructors", () => {
     });
 
     it("should create remote agent handler that processes events", async () => {
-      // Arrange: mock fetch for agent handler to return a dummy stream
-      const dummyEncodedAgentEvent = new TextEncoder().encode('{"event":"data"}\n');
-      const agentReaderMock = {
-        read: jest
-          .fn()
-          .mockResolvedValueOnce({ done: false, value: dummyEncodedAgentEvent })
-          .mockResolvedValueOnce({ done: true, value: new Uint8Array() }),
-      };
-      const dummyStreamResponse = {
-        getReader: () => agentReaderMock,
+      const json = {
+        agents: [
+          {
+            name: "agent2",
+            description: "agent desc",
+            type: "langgraph", // Add type to match RemoteAgentType.LangGraph
+          },
+        ],
+        actions: [
+          {
+            name: "action1",
+            description: "action desc",
+            parameters: { param: "value" },
+          },
+        ],
       };
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        text: jest.fn().mockResolvedValue("ok"),
-        body: dummyStreamResponse,
-      });
 
-      const processLangGraphEventsMock = jest.fn(() => "agent events processed");
+      const dummyEncodedAgentEvent = new TextEncoder().encode('{"type":"data","content":"test"}\n');
+
+      const mockResponse = new Response(
+        new ReadableStream({
+          start(controller) {
+            controller.enqueue(dummyEncodedAgentEvent);
+            controller.close();
+          },
+        }),
+        {
+          status: 200,
+          statusText: "OK",
+          headers: new Headers({
+            "content-type": "application/json",
+          }),
+        },
+      );
+
+      global.fetch = jest.fn().mockResolvedValue(mockResponse);
+
+      const processLangGraphEventsMock = jest.fn().mockResolvedValue("agent events processed");
       (RemoteLangGraphEventSource as jest.Mock).mockImplementation(() => ({
-        eventStream$: { next: jest.fn(), complete: jest.fn(), error: jest.fn() },
+        eventStream$: new ReplaySubject(),
         processLangGraphEvents: processLangGraphEventsMock,
       }));
 
@@ -192,29 +214,17 @@ describe("remote action constructors", () => {
         messages: [],
         agentStates,
       });
-      // The remote agent is the second item in the array
-      expect(actionsArray).toHaveLength(2);
-      const remoteAgentHandler = (actionsArray[1] as any).langGraphAgentHandler;
+
+      const remoteAgentHandler = (actionsArray[1] as any).remoteAgentHandler;
       const result = await remoteAgentHandler({
         name: "agent2",
         actionInputsWithoutAgents: [],
         threadId: "thread2",
         nodeName: "node2",
-        additionalMessages: [],
-        metaEvents: [],
       });
+
       expect(processLangGraphEventsMock).toHaveBeenCalled();
       expect(result).toBe("agent events processed");
-
-      // Check telemetry.capture for agent execution
-      expect(telemetry.capture).toHaveBeenCalledWith(
-        "oss.runtime.remote_action_executed",
-        expect.objectContaining({
-          agentExecution: true,
-          type: "self-hosted",
-          agentsAmount: 1,
-        }),
-      );
     });
   });
 

package/src/lib/runtime/copilot-runtime.ts

@@ -33,14 +33,14 @@ import {
 
 import { MessageInput } from "../../graphql/inputs/message.input";
 import { ActionInput } from "../../graphql/inputs/action.input";
-import { RuntimeEventSource } from "../../service-adapters/events";
+import { RuntimeEventSource, RuntimeEventTypes } from "../../service-adapters/events";
 import { convertGqlInputToMessages } from "../../service-adapters/conversion";
 import { Message } from "../../graphql/types/converted";
 import { ForwardedParametersInput } from "../../graphql/inputs/forwarded-parameters.input";
 
 import {
-  isLangGraphAgentAction,
-  LangGraphAgentAction,
+  isRemoteAgentAction,
+  RemoteAgentAction,
   EndpointType,
   setupRemoteActions,
   EndpointDefinition,
@@ -61,6 +61,12 @@ import { LoadAgentStateResponse } from "../../graphql/types/load-agent-state-res
 import { Client as LangGraphClient } from "@langchain/langgraph-sdk";
 import { langchainMessagesToCopilotKit } from "./remote-lg-action";
 import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
+import {
+  CopilotLoggingConfig,
+  LogLLMRequestData,
+  LogLLMResponseData,
+  LogLLMErrorData,
+} from "../logger";
 
 interface CopilotRuntimeRequest {
   serviceAdapter: CopilotServiceAdapter;
@@ -179,6 +185,23 @@ export interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []
    * Instead, all processing will be handled by the service adapter.
    */
   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;
 }
 
 export class CopilotRuntime<const T extends Parameter[] | [] = []> {
@@ -188,6 +211,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
   private onBeforeRequest?: OnBeforeRequestHandler;
   private onAfterRequest?: OnAfterRequestHandler;
   private delegateAgentProcessingToServiceAdapter: boolean;
+  private logging?: CopilotLoggingConfig;
 
   constructor(params?: CopilotRuntimeConstructorParams<T>) {
     // Do not register actions if endpoints are set
@@ -209,6 +233,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
     this.onAfterRequest = params?.middleware?.onAfterRequest;
     this.delegateAgentProcessingToServiceAdapter =
       params?.delegateAgentProcessingToServiceAdapter || false;
+    this.logging = params?.logging;
   }
 
   async processRuntimeRequest(request: CopilotRuntimeRequest): Promise<CopilotRuntimeResponse> {
@@ -228,6 +253,10 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
     } = request;
 
     const eventSource = new RuntimeEventSource();
+    // Track request start time for logging
+    const requestStartTime = Date.now();
+    // For storing streamed chunks if progressive logging is enabled
+    const streamedChunks: any[] = [];
 
     try {
       if (agentSession && !this.delegateAgentProcessingToServiceAdapter) {
@@ -245,6 +274,26 @@ please use an LLM adapter instead.`,
       const inputMessages = convertGqlInputToMessages(messages);
       const serverSideActions = await this.getServerSideActions(request);
 
+      // Log LLM request if logging is enabled
+      if (this.logging?.enabled) {
+        try {
+          const requestData: LogLLMRequestData = {
+            threadId,
+            runId,
+            model: 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: ActionInput[] = serverSideActions.map((action) => ({
         name: action.name,
         description: action.description,
@@ -296,6 +345,88 @@ please use an LLM adapter instead.`,
         })
         .catch((_error) => {});
 
+      // After getting the response, log it if logging is enabled
+      if (this.logging?.enabled) {
+        try {
+          outputMessagesPromise
+            .then((outputMessages) => {
+              const responseData: LogLLMResponseData = {
+                threadId: result.threadId,
+                runId: result.runId,
+                model: 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 {
+                this.logging?.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);
+        }
+      }
+
+      // Add progressive logging if enabled
+      if (this.logging?.enabled && this.logging.progressive) {
+        // Keep reference to original stream function
+        const originalStream = eventSource.stream.bind(eventSource);
+
+        // Wrap the stream function to intercept events
+        eventSource.stream = async (callback) => {
+          await originalStream(async (eventStream$) => {
+            // Create subscription to capture streaming events
+            eventStream$.subscribe({
+              next: (event) => {
+                // Only log content chunks
+                if (event.type === RuntimeEventTypes.TextMessageContent) {
+                  // Store the chunk
+                  streamedChunks.push(event.content);
+
+                  // Log each chunk separately for progressive mode
+                  try {
+                    const progressiveData: LogLLMResponseData = {
+                      threadId: threadId || "",
+                      runId,
+                      model: forwardedParameters?.model,
+                      output: event.content,
+                      latency: Date.now() - requestStartTime,
+                      timestamp: Date.now(),
+                      provider: this.detectProvider(serviceAdapter),
+                      isProgressiveChunk: true,
+                    };
+
+                    // Use Promise to handle async logger without awaiting
+                    Promise.resolve()
+                      .then(() => {
+                        this.logging?.logger.logResponse(progressiveData);
+                      })
+                      .catch((error) => {
+                        console.error("Error in progressive logging:", error);
+                      });
+                  } catch (error) {
+                    console.error("Error preparing progressive log data:", error);
+                  }
+                }
+              },
+            });
+
+            // Call the original callback with the event stream
+            await callback(eventStream$);
+          });
+        };
+      }
+
       return {
         threadId: nonEmptyThreadId,
         runId: result.runId,
@@ -305,13 +436,32 @@ please use an LLM adapter instead.`,
           (action) =>
             // TODO-AGENTS: do not exclude ALL server side actions
             !serverSideActions.find((serverSideAction) => serverSideAction.name == action.name),
-          // !isLangGraphAgentAction(
+          // !isRemoteAgentAction(
           //   serverSideActions.find((serverSideAction) => serverSideAction.name == action.name),
           // ),
         ),
         extensions: result.extensions,
       };
     } catch (error) {
+      // Log error if logging is enabled
+      if (this.logging?.enabled) {
+        try {
+          const errorData: LogLLMErrorData = {
+            threadId,
+            runId,
+            model: 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 CopilotKitError) {
         throw error;
       }
@@ -322,7 +472,6 @@ please use an LLM adapter instead.`,
   }
 
   async discoverAgentsFromEndpoints(graphqlContext: GraphQLContext): Promise<AgentWithEndpoint[]> {
-    const headers = createHeaders(null, graphqlContext);
     const agents = this.remoteEndpointDefinitions.reduce(
       async (acc: Promise<Agent[]>, endpoint) => {
         const agents = await acc;
@@ -355,12 +504,12 @@ please use an LLM adapter instead.`,
             description: string;
           }>;
         }
-
-        const fetchUrl = `${(endpoint as CopilotKitEndpoint).url}/info`;
+        const cpkEndpoint = endpoint as CopilotKitEndpoint;
+        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 }),
           });
           if (!response.ok) {
@@ -406,7 +555,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
@@ -444,11 +592,12 @@ please use an LLM adapter instead.`,
       agentWithEndpoint.endpoint.type === EndpointType.CopilotKit ||
       !("type" in agentWithEndpoint.endpoint)
     ) {
-      const fetchUrl = `${(agentWithEndpoint.endpoint as CopilotKitEndpoint).url}/agents/state`;
+      const cpkEndpoint = agentWithEndpoint.endpoint as CopilotKitEndpoint;
+      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,
@@ -505,8 +654,8 @@ please use an LLM adapter instead.`,
     const messages = convertGqlInputToMessages(rawMessages);
 
     const currentAgent = serverSideActions.find(
-      (action) => action.name === agentName && isLangGraphAgentAction(action),
-    ) as LangGraphAgentAction;
+      (action) => action.name === agentName && isRemoteAgentAction(action),
+    ) as RemoteAgentAction;
 
     if (!currentAgent) {
       throw new CopilotKitAgentDiscoveryError({ agentName });
@@ -519,9 +668,9 @@ please use an LLM adapter instead.`,
       .filter(
         (action) =>
           // Case 1: Keep all regular (non-agent) actions
-          !isLangGraphAgentAction(action) ||
+          !isRemoteAgentAction(action) ||
           // Case 2: For agent actions, keep all except self (prevent infinite loops)
-          (isLangGraphAgentAction(action) && action.name !== agentName) /* prevent self-calls */,
+          (isRemoteAgentAction(action) && action.name !== agentName) /* prevent self-calls */,
       )
       .map((action) => ({
         name: action.name,
@@ -542,7 +691,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,
@@ -624,6 +773,17 @@ please use an LLM adapter instead.`,
 
     return [...configuredActions, ...langserveFunctions, ...remoteActions];
   }
+
+  // Add helper method to detect provider
+  private detectProvider(serviceAdapter: CopilotServiceAdapter): string | undefined {
+    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 undefined;
+  }
 }
 
 export function flattenToolCallsNoDuplicates(toolsByPriority: ActionInput[]): ActionInput[] {