@copilotkit/runtime 1.9.2-next.0 → 1.9.2-next.10

package/src/service-adapters/events.ts

@@ -1,37 +1,32 @@
 import {
   Action,
-  randomId,
   CopilotKitError,
   CopilotKitErrorCode,
   CopilotKitLowLevelError,
+  ensureStructuredError,
+  randomId,
+  Severity,
 } from "@copilotkit/shared";
+import { plainToInstance } from "class-transformer";
 import {
-  of,
+  catchError,
   concat,
-  scan,
   concatMap,
-  ReplaySubject,
-  Subject,
+  EMPTY,
   firstValueFrom,
   from,
-  catchError,
-  EMPTY,
-  BehaviorSubject,
+  of,
+  ReplaySubject,
+  scan,
+  Subject,
 } from "rxjs";
-import { streamLangChainResponse } from "./langchain/utils";
+import { ActionInput } from "../graphql/inputs/action.input";
+import { ActionExecutionMessage, ResultMessage, TextMessage } from "../graphql/types/converted";
 import { GuardrailsResult } from "../graphql/types/guardrails-result.type";
-import telemetry from "../lib/telemetry-client";
 import { isRemoteAgentAction } from "../lib/runtime/remote-actions";
-import { ActionInput } from "../graphql/inputs/action.input";
-import {
-  ActionExecutionMessage,
-  ResultMessage,
-  TextMessage,
-  Message,
-} from "../graphql/types/converted";
-import { plainToInstance } from "class-transformer";
-import { MessageRole } from "../graphql/types/enums";
-import { parseJson, tryMap } from "@copilotkit/shared";
+import { generateHelpfulErrorMessage } from "../lib/streaming";
+import telemetry from "../lib/telemetry-client";
+import { streamLangChainResponse } from "./langchain/utils";
 
 export enum RuntimeEventTypes {
   TextMessageStart = "TextMessageStart",
@@ -273,10 +268,8 @@ export class RuntimeEventSource {
     threadId: string;
   }) {
     this.callback(this.eventStream$).catch((error) => {
-      console.error("Error in event source callback", error);
-
-      // Convert streaming errors to structured errors
-      const structuredError = convertStreamingErrorToStructured(error);
+      // Convert streaming errors to structured errors, but preserve already structured ones
+      const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
       this.eventStream$.error(structuredError);
       this.eventStream$.complete();
     });
@@ -330,17 +323,16 @@ export class RuntimeEventSource {
             eventWithState.actionExecutionId,
             actionInputsWithoutAgents,
             threadId,
-          ).catch((error) => {
-            console.error(error);
-          });
+          ).catch((error) => {});
 
           telemetry.capture("oss.runtime.server_action_executed", {});
           return concat(of(eventWithState.event!), toolCallEventStream$).pipe(
             catchError((error) => {
-              console.error("Error in tool call stream", error);
-
-              // Convert streaming errors to structured errors and send as action result
-              const structuredError = convertStreamingErrorToStructured(error);
+              // Convert streaming errors to structured errors and send as action result, but preserve already structured ones
+              const structuredError = ensureStructuredError(
+                error,
+                convertStreamingErrorToStructured,
+              );
               toolCallEventStream$.sendActionExecutionResult({
                 actionExecutionId: eventWithState.actionExecutionId!,
                 actionName: eventWithState.action!.name,
@@ -436,10 +428,8 @@ async function executeAction(
     from(stream).subscribe({
       next: (event) => eventStream$.next(event),
       error: (err) => {
-        console.error("Error in stream", err);
-
-        // Convert streaming errors to structured errors
-        const structuredError = convertStreamingErrorToStructured(err);
+        // Preserve already structured CopilotKit errors, only convert unstructured errors
+        const structuredError = ensureStructuredError(err, convertStreamingErrorToStructured);
         eventStream$.sendActionExecutionResult({
           actionExecutionId,
           actionName: action.name,
@@ -480,65 +470,31 @@ async function executeAction(
 }
 
 function convertStreamingErrorToStructured(error: any): CopilotKitError {
-  // Handle network termination errors
-  if (
-    error?.message?.includes("terminated") ||
-    error?.cause?.code === "UND_ERR_SOCKET" ||
-    error?.message?.includes("other side closed") ||
-    error?.code === "UND_ERR_SOCKET"
-  ) {
-    return new CopilotKitError({
-      message:
-        "Connection to agent was unexpectedly terminated. This may be due to the agent service being restarted or network issues. Please try again.",
-      code: CopilotKitErrorCode.NETWORK_ERROR,
-    });
-  }
+  // Determine a more helpful error message based on context
+  let helpfulMessage = generateHelpfulErrorMessage(error, "event streaming connection");
 
-  // Handle other network-related errors
+  // For network-related errors, use CopilotKitLowLevelError to preserve the original error
   if (
     error?.message?.includes("fetch failed") ||
     error?.message?.includes("ECONNREFUSED") ||
     error?.message?.includes("ENOTFOUND") ||
-    error?.message?.includes("ETIMEDOUT")
+    error?.message?.includes("ETIMEDOUT") ||
+    error?.message?.includes("terminated") ||
+    error?.cause?.code === "UND_ERR_SOCKET" ||
+    error?.message?.includes("other side closed") ||
+    error?.code === "UND_ERR_SOCKET"
   ) {
     return new CopilotKitLowLevelError({
       error: error instanceof Error ? error : new Error(String(error)),
       url: "event streaming connection",
-      message:
-        "Network error occurred during event streaming. Please check your connection and try again.",
-    });
-  }
-
-  // Handle abort/cancellation errors (these are usually normal)
-  if (
-    error?.message?.includes("aborted") ||
-    error?.message?.includes("canceled") ||
-    error?.message?.includes("signal is aborted")
-  ) {
-    return new CopilotKitError({
-      message: "Request was cancelled",
-      code: CopilotKitErrorCode.UNKNOWN,
-    });
-  }
-
-  // Handle API key errors (authentication/authorization issues)
-  const errorMessage = error?.message || String(error);
-  if (
-    errorMessage.includes("401") ||
-    errorMessage.toLowerCase().includes("api key") ||
-    errorMessage.toLowerCase().includes("unauthorized") ||
-    errorMessage.toLowerCase().includes("authentication") ||
-    errorMessage.toLowerCase().includes("incorrect api key")
-  ) {
-    return new CopilotKitError({
-      message: `Event streaming error: ${errorMessage}`,
-      code: CopilotKitErrorCode.MISSING_PUBLIC_API_KEY_ERROR,
+      message: helpfulMessage,
     });
   }
 
-  // Default: convert unknown streaming errors
+  // For all other errors, preserve the raw error in a basic CopilotKitError
   return new CopilotKitError({
-    message: `Event streaming error: ${errorMessage}`,
+    message: helpfulMessage,
     code: CopilotKitErrorCode.UNKNOWN,
+    severity: Severity.CRITICAL,
   });
 }

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

@@ -27,6 +27,7 @@ import {
   limitMessagesToTokenCount,
 } from "../openai/utils";
 import { randomUUID } from "@copilotkit/shared";
+import { convertServiceAdapterError } from "../shared";
 
 const DEFAULT_MODEL = "llama-3.3-70b-versatile";
 
@@ -94,76 +95,85 @@ export class GroqAdapter implements CopilotServiceAdapter {
         function: { name: forwardedParameters.toolChoiceFunctionName },
       };
     }
-    const stream = await this.groq.chat.completions.create({
-      model: model,
-      stream: true,
-      messages: openaiMessages as unknown as ChatCompletionMessageParam[],
-      ...(tools.length > 0 && { tools }),
-      ...(forwardedParameters?.maxTokens && {
-        max_tokens: forwardedParameters.maxTokens,
-      }),
-      ...(forwardedParameters?.stop && { stop: forwardedParameters.stop }),
-      ...(toolChoice && { tool_choice: toolChoice }),
-      ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
-      ...(forwardedParameters?.temperature && { temperature: forwardedParameters.temperature }),
-    });
+    let stream;
+    try {
+      stream = await this.groq.chat.completions.create({
+        model: model,
+        stream: true,
+        messages: openaiMessages as unknown as ChatCompletionMessageParam[],
+        ...(tools.length > 0 && { tools }),
+        ...(forwardedParameters?.maxTokens && {
+          max_tokens: forwardedParameters.maxTokens,
+        }),
+        ...(forwardedParameters?.stop && { stop: forwardedParameters.stop }),
+        ...(toolChoice && { tool_choice: toolChoice }),
+        ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
+        ...(forwardedParameters?.temperature && { temperature: forwardedParameters.temperature }),
+      });
+    } catch (error) {
+      throw convertServiceAdapterError(error, "Groq");
+    }
 
     eventSource.stream(async (eventStream$) => {
       let mode: "function" | "message" | null = null;
       let currentMessageId: string;
       let currentToolCallId: string;
 
-      for await (const chunk of stream) {
-        const toolCall = chunk.choices[0].delta.tool_calls?.[0];
-        const content = chunk.choices[0].delta.content;
+      try {
+        for await (const chunk of stream) {
+          const toolCall = chunk.choices[0].delta.tool_calls?.[0];
+          const content = chunk.choices[0].delta.content;
+
+          // When switching from message to function or vice versa,
+          // send the respective end event.
+          // If toolCall?.id is defined, it means a new tool call starts.
+          if (mode === "message" && toolCall?.id) {
+            mode = null;
+            eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+          } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
+            mode = null;
+            eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+          }
 
-        // When switching from message to function or vice versa,
-        // send the respective end event.
-        // If toolCall?.id is defined, it means a new tool call starts.
-        if (mode === "message" && toolCall?.id) {
-          mode = null;
-          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-        } else if (mode === "function" && (toolCall === undefined || toolCall?.id)) {
-          mode = null;
-          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
-        }
+          // If we send a new message type, send the appropriate start event.
+          if (mode === null) {
+            if (toolCall?.id) {
+              mode = "function";
+              currentToolCallId = toolCall!.id;
+              eventStream$.sendActionExecutionStart({
+                actionExecutionId: currentToolCallId,
+                actionName: toolCall!.function!.name,
+                parentMessageId: chunk.id,
+              });
+            } else if (content) {
+              mode = "message";
+              currentMessageId = chunk.id;
+              eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+            }
+          }
 
-        // If we send a new message type, send the appropriate start event.
-        if (mode === null) {
-          if (toolCall?.id) {
-            mode = "function";
-            currentToolCallId = toolCall!.id;
-            eventStream$.sendActionExecutionStart({
+          // send the content events
+          if (mode === "message" && content) {
+            eventStream$.sendTextMessageContent({
+              messageId: currentMessageId,
+              content,
+            });
+          } else if (mode === "function" && toolCall?.function?.arguments) {
+            eventStream$.sendActionExecutionArgs({
               actionExecutionId: currentToolCallId,
-              actionName: toolCall!.function!.name,
-              parentMessageId: chunk.id,
+              args: toolCall.function.arguments,
             });
-          } else if (content) {
-            mode = "message";
-            currentMessageId = chunk.id;
-            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
           }
         }
 
-        // send the content events
-        if (mode === "message" && content) {
-          eventStream$.sendTextMessageContent({
-            messageId: currentMessageId,
-            content,
-          });
-        } else if (mode === "function" && toolCall?.function?.arguments) {
-          eventStream$.sendActionExecutionArgs({
-            actionExecutionId: currentToolCallId,
-            args: toolCall.function.arguments,
-          });
+        // send the end events
+        if (mode === "message") {
+          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+        } else if (mode === "function") {
+          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
         }
-      }
-
-      // send the end events
-      if (mode === "message") {
-        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-      } else if (mode === "function") {
-        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+      } catch (error) {
+        throw convertServiceAdapterError(error, "Groq");
       }
 
       eventStream$.complete();

package/src/service-adapters/index.ts

@@ -5,6 +5,7 @@ export type {
 } from "./service-adapter";
 export type { RemoteChainParameters } from "./langchain/langserve";
 export { RemoteChain } from "./langchain/langserve";
+export * from "./shared";
 export * from "./openai/openai-adapter";
 export * from "./langchain/langchain-adapter";
 export * from "./google/google-genai-adapter";

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

@@ -60,6 +60,7 @@ import {
   limitMessagesToTokenCount,
 } from "./utils";
 import { randomUUID } from "@copilotkit/shared";
+import { convertServiceAdapterError } from "../shared";
 
 const DEFAULT_MODEL = "gpt-4o";
 
@@ -128,6 +129,8 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
     const tools = actions.map(convertActionInputToOpenAITool);
     const threadId = threadIdFromRequest ?? randomUUID();
 
+    console.log("messages", messages);
+
     // ALLOWLIST APPROACH: Only include tool_result messages that correspond to valid tool_calls
     // Step 1: Extract valid tool_call IDs
     const validToolUseIds = new Set<string>();
@@ -168,6 +171,18 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
       };
     }
 
+    console.log("INPUT", {
+      model: model,
+      stream: true,
+      messages: openaiMessages,
+      ...(tools.length > 0 && { tools }),
+      ...(forwardedParameters?.maxTokens && { max_tokens: forwardedParameters.maxTokens }),
+      ...(forwardedParameters?.stop && { stop: forwardedParameters.stop }),
+      ...(toolChoice && { tool_choice: toolChoice }),
+      ...(this.disableParallelToolCalls && { parallel_tool_calls: false }),
+      ...(forwardedParameters?.temperature && { temperature: forwardedParameters.temperature }),
+    });
+
     try {
       const stream = this.openai.beta.chat.completions.stream({
         model: model,
@@ -244,15 +259,15 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
             eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
           }
         } catch (error) {
-          console.error("[OpenAI] Error processing stream:", error);
-          throw error;
+          console.error("[OpenAI] Error during API call:", error);
+          throw convertServiceAdapterError(error, "OpenAI");
         }
 
         eventStream$.complete();
       });
     } catch (error) {
       console.error("[OpenAI] Error during API call:", error);
-      throw error;
+      throw convertServiceAdapterError(error, "OpenAI");
     }
 
     return {

package/src/service-adapters/shared/error-utils.ts

@@ -0,0 +1,61 @@
+import { CopilotKitLowLevelError, CopilotKitErrorCode } from "@copilotkit/shared";
+
+/**
+ * Converts service adapter errors to structured CopilotKitError format using HTTP status codes.
+ * This provides consistent error classification across all service adapters.
+ */
+export function convertServiceAdapterError(
+  error: any,
+  adapterName: string,
+): CopilotKitLowLevelError {
+  const errorName = error?.constructor?.name || error.name;
+  const errorMessage = error?.message || String(error);
+  const statusCode = error.status || error.statusCode || error.response?.status;
+  const responseData = error.error || error.response?.data || error.data;
+
+  // Create the base error with the constructor signature
+  const structuredError = new CopilotKitLowLevelError({
+    error: error instanceof Error ? error : new Error(errorMessage),
+    url: `${adapterName} service adapter`,
+    message: `${adapterName} API error: ${errorMessage}`,
+  });
+
+  // Add additional properties after construction
+  if (statusCode) {
+    (structuredError as any).statusCode = statusCode;
+  }
+  if (responseData) {
+    (structuredError as any).responseData = responseData;
+  }
+  if (errorName) {
+    (structuredError as any).originalErrorType = errorName;
+  }
+
+  // Classify error based on HTTP status codes (reliable and provider-agnostic)
+  let newCode: CopilotKitErrorCode;
+
+  if (statusCode === 401) {
+    // 401 = Authentication/API key issues
+    newCode = CopilotKitErrorCode.AUTHENTICATION_ERROR;
+  } else if (statusCode >= 400 && statusCode < 500) {
+    // 4xx = Client errors (bad request, invalid params, etc.) - these are configuration issues
+    newCode = CopilotKitErrorCode.CONFIGURATION_ERROR;
+  } else if (statusCode >= 500) {
+    // 5xx = Server errors - keep as NETWORK_ERROR since it's infrastructure related
+    newCode = CopilotKitErrorCode.NETWORK_ERROR;
+  } else if (statusCode) {
+    // Any other HTTP status with an error - likely configuration
+    newCode = CopilotKitErrorCode.CONFIGURATION_ERROR;
+  } else {
+    // No status code - likely a genuine network/connection error
+    newCode = CopilotKitErrorCode.NETWORK_ERROR;
+  }
+
+  // Update both the instance property and the extensions
+  (structuredError as any).code = newCode;
+  if ((structuredError as any).extensions) {
+    (structuredError as any).extensions.code = newCode;
+  }
+
+  return structuredError;
+}

package/src/service-adapters/shared/index.ts

@@ -0,0 +1 @@
+export * from "./error-utils";

package/src/utils/failed-response-status-reasons.ts

@@ -37,12 +37,34 @@ export class UnknownErrorResponse extends FailedResponseStatus {
   reason = FailedResponseStatusReason.UNKNOWN_ERROR;
   declare details: {
     description?: string;
+    originalError?: {
+      code?: string;
+      statusCode?: number;
+      severity?: string;
+      visibility?: string;
+      originalErrorType?: string;
+      extensions?: any;
+    };
   };
 
-  constructor({ description }: { description?: string }) {
+  constructor({
+    description,
+    originalError,
+  }: {
+    description?: string;
+    originalError?: {
+      code?: string;
+      statusCode?: number;
+      severity?: string;
+      visibility?: string;
+      originalErrorType?: string;
+      extensions?: any;
+    };
+  }) {
     super();
     this.details = {
       description,
+      originalError,
     };
   }
 }