@copilotkit/runtime 1.9.2-next.7 → 1.9.2-next.9

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,
     };
   }
 }