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

package/src/service-adapters/events.ts

@@ -1,32 +1,37 @@
 import {
   Action,
+  randomId,
   CopilotKitError,
   CopilotKitErrorCode,
   CopilotKitLowLevelError,
-  ensureStructuredError,
-  randomId,
-  Severity,
 } from "@copilotkit/shared";
-import { plainToInstance } from "class-transformer";
 import {
-  catchError,
+  of,
   concat,
+  scan,
   concatMap,
-  EMPTY,
-  firstValueFrom,
-  from,
-  of,
   ReplaySubject,
-  scan,
   Subject,
+  firstValueFrom,
+  from,
+  catchError,
+  EMPTY,
+  BehaviorSubject,
 } from "rxjs";
-import { ActionInput } from "../graphql/inputs/action.input";
-import { ActionExecutionMessage, ResultMessage, TextMessage } from "../graphql/types/converted";
+import { streamLangChainResponse } from "./langchain/utils";
 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";
+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";
 
 export enum RuntimeEventTypes {
   TextMessageStart = "TextMessageStart",
@@ -268,8 +273,10 @@ export class RuntimeEventSource {
     threadId: string;
   }) {
     this.callback(this.eventStream$).catch((error) => {
-      // Convert streaming errors to structured errors, but preserve already structured ones
-      const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
+      console.error("Error in event source callback", error);
+
+      // Convert streaming errors to structured errors
+      const structuredError = convertStreamingErrorToStructured(error);
       this.eventStream$.error(structuredError);
       this.eventStream$.complete();
     });
@@ -323,16 +330,17 @@ export class RuntimeEventSource {
             eventWithState.actionExecutionId,
             actionInputsWithoutAgents,
             threadId,
-          ).catch((error) => {});
+          ).catch((error) => {
+            console.error(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,
-              );
+              console.error("Error in tool call stream", error);
+
+              // Convert streaming errors to structured errors and send as action result
+              const structuredError = convertStreamingErrorToStructured(error);
               toolCallEventStream$.sendActionExecutionResult({
                 actionExecutionId: eventWithState.actionExecutionId!,
                 actionName: eventWithState.action!.name,
@@ -428,8 +436,10 @@ async function executeAction(
     from(stream).subscribe({
       next: (event) => eventStream$.next(event),
       error: (err) => {
-        // Preserve already structured CopilotKit errors, only convert unstructured errors
-        const structuredError = ensureStructuredError(err, convertStreamingErrorToStructured);
+        console.error("Error in stream", err);
+
+        // Convert streaming errors to structured errors
+        const structuredError = convertStreamingErrorToStructured(err);
         eventStream$.sendActionExecutionResult({
           actionExecutionId,
           actionName: action.name,
@@ -470,31 +480,65 @@ async function executeAction(
 }
 
 function convertStreamingErrorToStructured(error: any): CopilotKitError {
-  // Determine a more helpful error message based on context
-  let helpfulMessage = generateHelpfulErrorMessage(error, "event streaming connection");
-
-  // For network-related errors, use CopilotKitLowLevelError to preserve the original error
+  // Handle network termination errors
   if (
-    error?.message?.includes("fetch failed") ||
-    error?.message?.includes("ECONNREFUSED") ||
-    error?.message?.includes("ENOTFOUND") ||
-    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 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,
+    });
+  }
+
+  // Handle other network-related errors
+  if (
+    error?.message?.includes("fetch failed") ||
+    error?.message?.includes("ECONNREFUSED") ||
+    error?.message?.includes("ENOTFOUND") ||
+    error?.message?.includes("ETIMEDOUT")
   ) {
     return new CopilotKitLowLevelError({
       error: error instanceof Error ? error : new Error(String(error)),
       url: "event streaming connection",
-      message: helpfulMessage,
+      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,
     });
   }
 
-  // For all other errors, preserve the raw error in a basic CopilotKitError
+  // Default: convert unknown streaming errors
   return new CopilotKitError({
-    message: helpfulMessage,
+    message: `Event streaming error: ${errorMessage}`,
     code: CopilotKitErrorCode.UNKNOWN,
-    severity: Severity.CRITICAL,
   });
 }

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

@@ -27,7 +27,6 @@ import {
   limitMessagesToTokenCount,
 } from "../openai/utils";
 import { randomUUID } from "@copilotkit/shared";
-import { convertServiceAdapterError } from "../shared";
 
 const DEFAULT_MODEL = "llama-3.3-70b-versatile";
 
@@ -95,85 +94,76 @@ export class GroqAdapter implements CopilotServiceAdapter {
         function: { name: forwardedParameters.toolChoiceFunctionName },
       };
     }
-    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");
-    }
+    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 }),
+    });
 
     eventSource.stream(async (eventStream$) => {
       let mode: "function" | "message" | null = null;
       let currentMessageId: string;
       let currentToolCallId: string;
 
-      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 });
-          }
+      for await (const chunk of stream) {
+        const toolCall = chunk.choices[0].delta.tool_calls?.[0];
+        const content = chunk.choices[0].delta.content;
 
-          // 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 });
-            }
-          }
+        // 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 });
+        }
 
-          // send the content events
-          if (mode === "message" && content) {
-            eventStream$.sendTextMessageContent({
-              messageId: currentMessageId,
-              content,
-            });
-          } else if (mode === "function" && toolCall?.function?.arguments) {
-            eventStream$.sendActionExecutionArgs({
+        // 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,
-              args: toolCall.function.arguments,
+              actionName: toolCall!.function!.name,
+              parentMessageId: chunk.id,
             });
+          } else if (content) {
+            mode = "message";
+            currentMessageId = chunk.id;
+            eventStream$.sendTextMessageStart({ messageId: currentMessageId });
           }
         }
 
-        // send the end events
-        if (mode === "message") {
-          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
-        } else if (mode === "function") {
-          eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
+        // 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,
+          });
         }
-      } catch (error) {
-        throw convertServiceAdapterError(error, "Groq");
+      }
+
+      // send the end events
+      if (mode === "message") {
+        eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
+      } else if (mode === "function") {
+        eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
       }
 
       eventStream$.complete();

package/src/service-adapters/index.ts

@@ -5,7 +5,6 @@ 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,7 +60,6 @@ import {
   limitMessagesToTokenCount,
 } from "./utils";
 import { randomUUID } from "@copilotkit/shared";
-import { convertServiceAdapterError } from "../shared";
 
 const DEFAULT_MODEL = "gpt-4o";
 
@@ -129,8 +128,6 @@ 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>();
@@ -171,18 +168,6 @@ 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,
@@ -259,15 +244,15 @@ export class OpenAIAdapter implements CopilotServiceAdapter {
             eventStream$.sendActionExecutionEnd({ actionExecutionId: currentToolCallId });
           }
         } catch (error) {
-          console.error("[OpenAI] Error during API call:", error);
-          throw convertServiceAdapterError(error, "OpenAI");
+          console.error("[OpenAI] Error processing stream:", error);
+          throw error;
         }
 
         eventStream$.complete();
       });
     } catch (error) {
       console.error("[OpenAI] Error during API call:", error);
-      throw convertServiceAdapterError(error, "OpenAI");
+      throw error;
     }
 
     return {

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

@@ -37,34 +37,12 @@ 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,
-    originalError,
-  }: {
-    description?: string;
-    originalError?: {
-      code?: string;
-      statusCode?: number;
-      severity?: string;
-      visibility?: string;
-      originalErrorType?: string;
-      extensions?: any;
-    };
-  }) {
+  constructor({ description }: { description?: string }) {
     super();
     this.details = {
       description,
-      originalError,
     };
   }
 }