@copilotkit/runtime 1.10.7-next.0 → 1.50.0-beta.0

package/src/lib/runtime/types.ts

@@ -0,0 +1,49 @@
+import { GraphQLContext } from "../integrations";
+import { ActionInput } from "../../graphql/inputs/action.input";
+import { Message } from "../../graphql/types/converted";
+import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
+
+export interface BaseEndpointDefinition<TActionType extends EndpointType> {
+  type?: TActionType;
+}
+
+export interface CopilotKitEndpoint extends BaseEndpointDefinition<EndpointType.CopilotKit> {
+  url: string;
+  onBeforeRequest?: ({ ctx }: { ctx: GraphQLContext }) => {
+    headers?: Record<string, string> | undefined;
+  };
+}
+
+export interface LangGraphPlatformAgent {
+  name: string;
+  description: string;
+  assistantId?: string;
+}
+
+export interface LangGraphPlatformEndpoint
+  extends BaseEndpointDefinition<EndpointType.LangGraphPlatform> {
+  deploymentUrl: string;
+  langsmithApiKey?: string | null;
+  agents: LangGraphPlatformAgent[];
+}
+
+export type RemoteActionInfoResponse = {
+  actions: any[];
+  agents: any[];
+};
+
+export type RemoteAgentHandlerParams = {
+  name: string;
+  actionInputsWithoutAgents: ActionInput[];
+  threadId?: string;
+  nodeName?: string;
+  additionalMessages?: Message[];
+  metaEvents?: MetaEventInput[];
+};
+
+export type EndpointDefinition = CopilotKitEndpoint | LangGraphPlatformEndpoint;
+
+export enum EndpointType {
+  CopilotKit = "copilotKit",
+  LangGraphPlatform = "langgraph-platform",
+}

package/src/lib/runtime/utils.ts

@@ -0,0 +1,87 @@
+import { GraphQLContext } from "../integrations";
+import { Logger } from "pino";
+import { CopilotKitEndpoint, RemoteActionInfoResponse } from "./types";
+import {
+  Action,
+  CopilotKitError,
+  CopilotKitLowLevelError,
+  ResolvedCopilotKitError,
+} from "@copilotkit/shared";
+
+async function fetchRemoteInfo({
+  url,
+  onBeforeRequest,
+  graphqlContext,
+  logger,
+  frontendUrl,
+}: {
+  url: string;
+  onBeforeRequest?: CopilotKitEndpoint["onBeforeRequest"];
+  graphqlContext: GraphQLContext;
+  logger: Logger;
+  frontendUrl?: string;
+}): Promise<RemoteActionInfoResponse> {
+  logger.debug({ url }, "Fetching actions from url");
+  const headers = createHeaders(onBeforeRequest, graphqlContext);
+
+  const fetchUrl = `${url}/info`;
+  try {
+    const response = await fetch(fetchUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ properties: graphqlContext.properties, frontendUrl }),
+    });
+
+    if (!response.ok) {
+      logger.error(
+        { url, status: response.status, body: await response.text() },
+        "Failed to fetch actions from url",
+      );
+      throw new ResolvedCopilotKitError({
+        status: response.status,
+        url: fetchUrl,
+        isRemoteEndpoint: true,
+      });
+    }
+
+    const json = await response.json();
+    logger.debug({ json }, "Fetched actions from url");
+    return json;
+  } catch (error) {
+    if (error instanceof CopilotKitError) {
+      throw error;
+    }
+    throw new CopilotKitLowLevelError({ error, url: fetchUrl });
+  }
+}
+
+// Utility to determine if an error is a user configuration issue vs system error
+export function isUserConfigurationError(error: any): boolean {
+  return (
+    (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) &&
+    (error.code === "NETWORK_ERROR" ||
+      error.code === "AUTHENTICATION_ERROR" ||
+      error.statusCode === 401 ||
+      error.statusCode === 403 ||
+      error.message?.toLowerCase().includes("authentication") ||
+      error.message?.toLowerCase().includes("api key"))
+  );
+}
+
+export function createHeaders(
+  onBeforeRequest: CopilotKitEndpoint["onBeforeRequest"],
+  graphqlContext: GraphQLContext,
+) {
+  const headers = {
+    "Content-Type": "application/json",
+  };
+
+  if (onBeforeRequest) {
+    const { headers: additionalHeaders } = onBeforeRequest({ ctx: graphqlContext });
+    if (additionalHeaders) {
+      Object.assign(headers, additionalHeaders);
+    }
+  }
+
+  return headers;
+}

package/src/lib/telemetry-client.ts

@@ -1,9 +1,9 @@
 import { TelemetryClient } from "@copilotkit/shared";
-import { EndpointType, LangGraphPlatformEndpoint } from "./runtime/remote-actions";
 import { createHash } from "node:crypto";
 import { CopilotRuntime, resolveEndpointType } from "./runtime/copilot-runtime";
 import { RuntimeInstanceCreatedInfo } from "@copilotkit/shared/src/telemetry/events";
 import { CreateCopilotRuntimeServerOptions } from "./integrations/shared";
+import { EndpointType, LangGraphPlatformEndpoint } from "./runtime/types";
 const packageJson = require("../../package.json");
 
 const telemetryClient = new TelemetryClient({
@@ -15,7 +15,8 @@ export function getRuntimeInstanceTelemetryInfo(
   options: CreateCopilotRuntimeServerOptions,
 ): RuntimeInstanceCreatedInfo {
   const runtime = options.runtime;
-  const endpointsInfo = runtime.remoteEndpointDefinitions.reduce(
+  const remoteEndpoints = runtime.params?.remoteEndpoints ?? [];
+  const endpointsInfo = remoteEndpoints.reduce(
     (acc, endpoint) => {
       let info = { ...acc };
 
@@ -49,10 +50,10 @@ export function getRuntimeInstanceTelemetryInfo(
   const apiKeyProvided = !!publicApiKey && publicApiKey.trim().length > 0;
 
   return {
-    actionsAmount: runtime.actions.length,
-    endpointsAmount: runtime.remoteEndpointDefinitions.length,
+    actionsAmount: runtime.params?.actions?.length ?? 0,
+    endpointsAmount: remoteEndpoints.length,
     endpointTypes: endpointsInfo.endpointTypes,
-    agentsAmount: endpointsInfo.agentsAmount,
+    agentsAmount: Object.keys(runtime.instance.agents).length,
     hashedLgcKey: endpointsInfo.hashedKey,
     "cloud.api_key_provided": apiKeyProvided,
     ...(apiKeyProvided ? { "cloud.public_api_key": publicApiKey } : {}),

package/src/service-adapters/anthropic/anthropic-adapter.ts

@@ -71,13 +71,17 @@ export interface AnthropicAdapterParams {
 }
 
 export class AnthropicAdapter implements CopilotServiceAdapter {
-  private model: string = DEFAULT_MODEL;
+  public model: string = DEFAULT_MODEL;
+  public provider = "anthropic";
   private promptCaching: AnthropicPromptCachingConfig;
 
   private _anthropic: Anthropic;
   public get anthropic(): Anthropic {
     return this._anthropic;
   }
+  public get name() {
+    return "AnthropicAdapter";
+  }
 
   constructor(params?: AnthropicAdapterParams) {
     this._anthropic = params?.anthropic || new Anthropic({});

package/src/service-adapters/bedrock/bedrock-adapter.ts

@@ -44,12 +44,17 @@ export interface BedrockAdapterParams {
   };
 }
 
+const DEFAULT_MODEL = "amazon.nova-lite-v1:0";
+
 export class BedrockAdapter extends LangChainAdapter {
+  public provider = "bedrock";
+  public model: string = DEFAULT_MODEL;
   constructor(options?: BedrockAdapterParams) {
     super({
       chainFn: async ({ messages, tools, threadId }) => {
+        this.model = options?.model ?? "amazon.nova-lite-v1:0";
         const model = new ChatBedrockConverse({
-          model: options?.model ?? "amazon.nova-lite-v1:0",
+          model: this.model,
           region: options?.region ?? "us-east-1",
           credentials: options?.credentials
             ? {

package/src/service-adapters/empty/empty-adapter.ts

@@ -30,6 +30,9 @@ export class EmptyAdapter implements CopilotServiceAdapter {
       threadId: request.threadId || randomUUID(),
     };
   }
+  public get name() {
+    return "EmptyAdapter";
+  }
 }
 
 export const ExperimentalEmptyAdapter = EmptyAdapter;

package/src/service-adapters/events.ts

@@ -23,7 +23,6 @@ import {
 import { ActionInput } from "../graphql/inputs/action.input";
 import { ActionExecutionMessage, ResultMessage, TextMessage } from "../graphql/types/converted";
 import { GuardrailsResult } from "../graphql/types/guardrails-result.type";
-import { isRemoteAgentAction } from "../lib/runtime/remote-actions";
 import { generateHelpfulErrorMessage } from "../lib/streaming";
 import telemetry from "../lib/telemetry-client";
 import { streamLangChainResponse } from "./langchain/utils";
@@ -262,259 +261,6 @@ export class RuntimeEventSource {
   async stream(callback: EventSourceCallback): Promise<void> {
     this.callback = callback;
   }
-
-  sendErrorMessageToChat(message = "An error occurred. Please try again.") {
-    const errorMessage = `❌ ${message}`;
-    if (!this.callback) {
-      this.stream(async (eventStream$) => {
-        eventStream$.sendTextMessage(randomId(), errorMessage);
-      });
-    } else {
-      this.eventStream$.sendTextMessage(randomId(), errorMessage);
-    }
-  }
-
-  processRuntimeEvents({
-    serverSideActions,
-    guardrailsResult$,
-    actionInputsWithoutAgents,
-    threadId,
-  }: {
-    serverSideActions: Action<any>[];
-    guardrailsResult$?: Subject<GuardrailsResult>;
-    actionInputsWithoutAgents: ActionInput[];
-    threadId: string;
-  }) {
-    this.callback(this.eventStream$).catch(async (error) => {
-      // Convert streaming errors to structured errors, but preserve already structured ones
-      const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
-
-      // Call the runtime error handler if provided
-      if (this.errorHandler && this.errorContext) {
-        try {
-          await this.errorHandler(structuredError, this.errorContext);
-        } catch (errorHandlerError) {
-          console.error("Error in streaming error handler:", errorHandlerError);
-        }
-      }
-
-      this.eventStream$.error(structuredError);
-      this.eventStream$.complete();
-    });
-    return this.eventStream$.pipe(
-      // track state
-      scan(
-        (acc, event) => {
-          // It seems like this is needed so that rxjs recognizes the object has changed
-          // This fixes an issue where action were executed multiple times
-          // Not investigating further for now (Markus)
-          acc = { ...acc };
-
-          if (event.type === RuntimeEventTypes.ActionExecutionStart) {
-            acc.callActionServerSide =
-              serverSideActions.find((action) => action.name === event.actionName) !== undefined;
-            acc.args = "";
-            acc.actionExecutionId = event.actionExecutionId;
-            if (acc.callActionServerSide) {
-              acc.action = serverSideActions.find((action) => action.name === event.actionName);
-            }
-            acc.actionExecutionParentMessageId = event.parentMessageId;
-          } else if (event.type === RuntimeEventTypes.ActionExecutionArgs) {
-            acc.args += event.args;
-          }
-
-          acc.event = event;
-
-          return acc;
-        },
-        {
-          event: null,
-          callActionServerSide: false,
-          args: "",
-          actionExecutionId: null,
-          action: null,
-          actionExecutionParentMessageId: null,
-        } as RuntimeEventWithState,
-      ),
-      concatMap((eventWithState) => {
-        if (
-          eventWithState.event!.type === RuntimeEventTypes.ActionExecutionEnd &&
-          eventWithState.callActionServerSide
-        ) {
-          const toolCallEventStream$ = new RuntimeEventSubject();
-          executeAction(
-            toolCallEventStream$,
-            guardrailsResult$ ? guardrailsResult$ : null,
-            eventWithState.action!,
-            eventWithState.args,
-            eventWithState.actionExecutionParentMessageId,
-            eventWithState.actionExecutionId,
-            actionInputsWithoutAgents,
-            threadId,
-          ).catch((error) => {});
-
-          telemetry.capture("oss.runtime.server_action_executed", {});
-          return concat(of(eventWithState.event!), toolCallEventStream$).pipe(
-            catchError((error) => {
-              // Convert streaming errors to structured errors and send as action result, but preserve already structured ones
-              const structuredError = ensureStructuredError(
-                error,
-                convertStreamingErrorToStructured,
-              );
-
-              // Call the runtime error handler if provided
-              if (this.errorHandler && this.errorContext) {
-                // Use from() to handle async error handler
-                from(
-                  this.errorHandler(structuredError, {
-                    ...this.errorContext,
-                    action: {
-                      name: eventWithState.action!.name,
-                      executionId: eventWithState.actionExecutionId,
-                    },
-                  }),
-                ).subscribe({
-                  error: (errorHandlerError) => {
-                    console.error("Error in action execution error handler:", errorHandlerError);
-                  },
-                });
-              }
-
-              toolCallEventStream$.sendActionExecutionResult({
-                actionExecutionId: eventWithState.actionExecutionId!,
-                actionName: eventWithState.action!.name,
-                error: {
-                  code: structuredError.code,
-                  message: structuredError.message,
-                },
-              });
-
-              return EMPTY;
-            }),
-          );
-        } else {
-          return of(eventWithState.event!);
-        }
-      }),
-    );
-  }
-}
-
-async function executeAction(
-  eventStream$: RuntimeEventSubject,
-  guardrailsResult$: Subject<GuardrailsResult> | null,
-  action: Action<any>,
-  actionArguments: string,
-  actionExecutionParentMessageId: string | null,
-  actionExecutionId: string,
-  actionInputsWithoutAgents: ActionInput[],
-  threadId: string,
-) {
-  if (guardrailsResult$) {
-    const { status } = await firstValueFrom(guardrailsResult$);
-
-    if (status === "denied") {
-      eventStream$.complete();
-      return;
-    }
-  }
-
-  // Prepare arguments for function calling
-  let args: Record<string, any>[] = [];
-  if (actionArguments) {
-    try {
-      args = JSON.parse(actionArguments);
-    } catch (e) {
-      console.error("Action argument unparsable", { actionArguments });
-      eventStream$.sendActionExecutionResult({
-        actionExecutionId,
-        actionName: action.name,
-        error: {
-          code: "INVALID_ARGUMENTS",
-          message: "Failed to parse action arguments",
-        },
-      });
-      return;
-    }
-  }
-
-  // handle LangGraph agents
-  if (isRemoteAgentAction(action)) {
-    const result = `${action.name} agent started`;
-
-    const agentExecution = plainToInstance(ActionExecutionMessage, {
-      id: actionExecutionId,
-      createdAt: new Date(),
-      name: action.name,
-      arguments: JSON.parse(actionArguments),
-      parentMessageId: actionExecutionParentMessageId ?? actionExecutionId,
-    });
-
-    const agentExecutionResult = plainToInstance(ResultMessage, {
-      id: "result-" + actionExecutionId,
-      createdAt: new Date(),
-      actionExecutionId,
-      actionName: action.name,
-      result,
-    });
-
-    eventStream$.sendActionExecutionResult({
-      actionExecutionId,
-      actionName: action.name,
-      result,
-    });
-
-    const stream = await action.remoteAgentHandler({
-      name: action.name,
-      threadId,
-      actionInputsWithoutAgents,
-      additionalMessages: [agentExecution, agentExecutionResult],
-    });
-
-    // forward to eventStream$
-    from(stream).subscribe({
-      next: (event) => eventStream$.next(event),
-      error: (err) => {
-        // Preserve already structured CopilotKit errors, only convert unstructured errors
-        const structuredError = ensureStructuredError(err, convertStreamingErrorToStructured);
-        eventStream$.sendActionExecutionResult({
-          actionExecutionId,
-          actionName: action.name,
-          error: {
-            code: structuredError.code,
-            message: structuredError.message,
-          },
-        });
-        eventStream$.complete();
-      },
-      complete: () => eventStream$.complete(),
-    });
-  } else {
-    // call the function
-    try {
-      const result = await action.handler?.(args);
-      await streamLangChainResponse({
-        result,
-        eventStream$,
-        actionExecution: {
-          name: action.name,
-          id: actionExecutionId,
-          returnDirect: action.additionalConfig?.returnDirect,
-        },
-      });
-    } catch (e) {
-      console.error("Error in action handler", e);
-      eventStream$.sendActionExecutionResult({
-        actionExecutionId,
-        actionName: action.name,
-        error: {
-          code: "HANDLER_ERROR",
-          message: e.message,
-        },
-      });
-      eventStream$.complete();
-    }
-  }
 }
 
 function convertStreamingErrorToStructured(error: any): CopilotKitError {

package/src/service-adapters/experimental/ollama/ollama-adapter.ts

@@ -33,7 +33,11 @@ interface OllamaAdapterOptions {
 }
 
 export class ExperimentalOllamaAdapter implements CopilotServiceAdapter {
-  private model: string;
+  public model: string;
+  public provider = "ollama";
+  public get name() {
+    return "OllamaAdapter";
+  }
 
   constructor(options?: OllamaAdapterOptions) {
     if (options?.model) {

package/src/service-adapters/google/google-genai-adapter.ts

@@ -29,7 +29,12 @@ interface GoogleGenerativeAIAdapterOptions {
   apiKey?: string;
 }
 
+const DEFAULT_MODEL = "gemini-1.5-pro";
+
 export class GoogleGenerativeAIAdapter extends LangChainAdapter {
+  public provider = "google";
+  public model: string = DEFAULT_MODEL;
+
   constructor(options?: GoogleGenerativeAIAdapterOptions) {
     super({
       chainFn: async ({ messages, tools, threadId }) => {
@@ -49,9 +54,10 @@ export class GoogleGenerativeAIAdapter extends LangChainAdapter {
           );
         });
 
+        this.model = options?.model ?? "gemini-1.5-pro";
         const model = new ChatGoogle({
           apiKey: options?.apiKey ?? process.env.GOOGLE_API_KEY,
-          modelName: options?.model ?? "gemini-1.5-pro",
+          modelName: this.model,
           apiVersion: "v1beta",
         }).bindTools(tools);
 

package/src/service-adapters/groq/groq-adapter.ts

@@ -54,13 +54,17 @@ export interface GroqAdapterParams {
 }
 
 export class GroqAdapter implements CopilotServiceAdapter {
-  private model: string = DEFAULT_MODEL;
+  public model: string = DEFAULT_MODEL;
+  public provider = "groq";
 
   private disableParallelToolCalls: boolean = false;
   private _groq: Groq;
   public get groq(): Groq {
     return this._groq;
   }
+  public get name() {
+    return "GroqAdapter";
+  }
 
   constructor(params?: GroqAdapterParams) {
     this._groq = params?.groq || new Groq({});

package/src/service-adapters/langchain/langchain-adapter.ts

@@ -66,6 +66,9 @@ export class LangChainAdapter implements CopilotServiceAdapter {
   /**
    * To use LangChain as a backend, provide a handler function to the adapter with your custom LangChain logic.
    */
+  public get name() {
+    return "LangChainAdapter";
+  }
   constructor(private options: LangChainAdapterOptions) {}
 
   async process(

package/src/service-adapters/openai/openai-adapter.ts

@@ -96,7 +96,8 @@ export interface OpenAIAdapterParams {
 }
 
 export class OpenAIAdapter implements CopilotServiceAdapter {
-  private model: string = DEFAULT_MODEL;
+  public model: string = DEFAULT_MODEL;
+  public provider = "openai";
 
   private disableParallelToolCalls: boolean = false;
   private _openai: OpenAI;
@@ -105,6 +106,9 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
   public get openai(): OpenAI {
     return this._openai;
   }
+  public get name() {
+    return "OpenAIAdapter";
+  }
 
   constructor(params?: OpenAIAdapterParams) {
     this._openai = params?.openai || new OpenAI({});

package/src/service-adapters/openai/openai-assistant-adapter.ts

@@ -91,6 +91,10 @@ export class OpenAIAssistantAdapter implements CopilotServiceAdapter {
   private disableParallelToolCalls: boolean;
   private keepSystemRole: boolean = false;
 
+  public get name() {
+    return "OpenAIAssistantAdapter";
+  }
+
   constructor(params: OpenAIAssistantAdapterParams) {
     this.openai = params.openai || new OpenAI({});
     this.codeInterpreterEnabled = params.codeInterpreterEnabled === false || true;

package/src/service-adapters/service-adapter.ts

@@ -32,7 +32,10 @@ export interface CopilotRuntimeChatCompletionResponse {
 }
 
 export interface CopilotServiceAdapter {
+  provider?: string;
+  model?: string;
   process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse>;
+  name?: string;
 }

package/src/service-adapters/unify/unify-adapter.ts

@@ -33,8 +33,13 @@ export interface UnifyAdapterParams {
 
 export class UnifyAdapter implements CopilotServiceAdapter {
   private apiKey: string;
-  private model: string;
+  public model: string;
   private start: boolean;
+  public provider = "unify";
+
+  public get name() {
+    return "UnifyAdapter";
+  }
 
   constructor(options?: UnifyAdapterParams) {
     if (options?.apiKey) {

package/src/v2/index.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+export * from "@copilotkitnext/runtime";

package/tsup.config.ts

@@ -2,7 +2,7 @@ import { defineConfig, Options } from "tsup";
 
 export default defineConfig((options: Options) => ({
   ...options,
-  entry: ["src/**/index.ts"],
+  entry: ["src/index.ts", "src/v2/index.ts"],
   format: ["esm", "cjs"],
   dts: true,
   minify: false,
@@ -13,4 +13,5 @@ export default defineConfig((options: Options) => ({
     "**/*.test.tsx", // Exclude TypeScript React test files
     "**/__tests__/*", // Exclude any files inside a __tests__ directory
   ],
+  treeshake: true,
 }));