@copilotkit/runtime 1.9.2-next.8 → 1.9.2

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

@@ -29,6 +29,7 @@ import {
 } from "./utils";
 
 import { randomId, randomUUID } from "@copilotkit/shared";
+import { convertServiceAdapterError } from "../shared";
 
 const DEFAULT_MODEL = "claude-3-5-sonnet-latest";
 
@@ -60,6 +61,36 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
     }
   }
 
+  private shouldGenerateFallbackResponse(messages: Anthropic.Messages.MessageParam[]): boolean {
+    if (messages.length === 0) return false;
+
+    const lastMessage = messages[messages.length - 1];
+
+    // Check if the last message is a tool result
+    const endsWithToolResult =
+      lastMessage.role === "user" &&
+      Array.isArray(lastMessage.content) &&
+      lastMessage.content.some((content: any) => content.type === "tool_result");
+
+    // Also check if we have a recent pattern of user message -> assistant tool use -> user tool result
+    // This indicates a completed action that might not need a response
+    if (messages.length >= 3 && endsWithToolResult) {
+      const lastThree = messages.slice(-3);
+      const hasRecentToolPattern =
+        lastThree[0]?.role === "user" && // Initial user message
+        lastThree[1]?.role === "assistant" && // Assistant tool use
+        Array.isArray(lastThree[1].content) &&
+        lastThree[1].content.some((content: any) => content.type === "tool_use") &&
+        lastThree[2]?.role === "user" && // Tool result
+        Array.isArray(lastThree[2].content) &&
+        lastThree[2].content.some((content: any) => content.type === "tool_result");
+
+      return hasRecentToolPattern;
+    }
+
+    return endsWithToolResult;
+  }
+
   async process(
     request: CopilotRuntimeChatCompletionRequest,
   ): Promise<CopilotRuntimeChatCompletionResponse> {
@@ -94,24 +125,30 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
     }
 
     // Step 2: Map each message to an Anthropic message, eliminating invalid tool_results
+    const processedToolResultIds = new Set<string>();
     const anthropicMessages = messages
       .map((message) => {
-        // For tool results, only include if they match a valid tool_use ID
+        // For tool results, only include if they match a valid tool_use ID AND haven't been processed
         if (message.isResultMessage()) {
           // Skip if there's no corresponding tool_use
           if (!validToolUseIds.has(message.actionExecutionId)) {
             return null; // Will be filtered out later
           }
 
-          // Remove this ID from valid IDs so we don't process duplicates
-          validToolUseIds.delete(message.actionExecutionId);
+          // Skip if we've already processed a result for this tool_use ID
+          if (processedToolResultIds.has(message.actionExecutionId)) {
+            return null; // Will be filtered out later
+          }
+
+          // Mark this tool result as processed
+          processedToolResultIds.add(message.actionExecutionId);
 
           return {
             role: "user",
             content: [
               {
                 type: "tool_result",
-                content: message.result,
+                content: message.result || "Action completed successfully",
                 tool_use_id: message.actionExecutionId,
               },
             ],
@@ -139,6 +176,7 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
     // Apply token limits
     const limitedMessages = limitMessagesToTokenCount(anthropicMessages, tools, model);
 
+    // We'll check if we need a fallback response after seeing what Anthropic returns
     // We skip grouping by role since we've already ensured uniqueness of tool_results
 
     let toolChoice: any = forwardedParameters?.toolChoice;
@@ -171,12 +209,14 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
         let currentMessageId = randomId();
         let currentToolCallId = randomId();
         let filterThinkingTextBuffer = new FilterThinkingTextBuffer();
+        let hasReceivedContent = false;
 
         try {
           for await (const chunk of stream as AsyncIterable<any>) {
             if (chunk.type === "message_start") {
               currentMessageId = chunk.message.id;
             } else if (chunk.type === "content_block_start") {
+              hasReceivedContent = true;
               if (chunk.content_block.type === "text") {
                 didOutputText = false;
                 filterThinkingTextBuffer.reset();
@@ -220,15 +260,34 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
             }
           }
         } catch (error) {
-          console.error("[Anthropic] Error processing stream:", error);
-          throw error;
+          throw convertServiceAdapterError(error, "Anthropic");
+        }
+
+        // Generate fallback response only if Anthropic produced no content
+        if (!hasReceivedContent && this.shouldGenerateFallbackResponse(limitedMessages)) {
+          // Extract the tool result content for a more contextual response
+          let fallbackContent = "Task completed successfully.";
+          const lastMessage = limitedMessages[limitedMessages.length - 1];
+          if (lastMessage?.role === "user" && Array.isArray(lastMessage.content)) {
+            const toolResult = lastMessage.content.find((c: any) => c.type === "tool_result");
+            if (toolResult?.content && toolResult.content !== "Action completed successfully") {
+              fallbackContent = toolResult.content;
+            }
+          }
+
+          currentMessageId = randomId();
+          eventStream$.sendTextMessageStart({ messageId: currentMessageId });
+          eventStream$.sendTextMessageContent({
+            messageId: currentMessageId,
+            content: fallbackContent,
+          });
+          eventStream$.sendTextMessageEnd({ messageId: currentMessageId });
         }
 
         eventStream$.complete();
       });
     } catch (error) {
-      console.error("[Anthropic] Error during API call:", error);
-      throw error;
+      throw convertServiceAdapterError(error, "Anthropic");
     }
 
     return {

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

@@ -1,11 +1,6 @@
-import {
-  ActionExecutionMessage,
-  Message,
-  ResultMessage,
-  TextMessage,
-} from "../../graphql/types/converted";
-import { ActionInput } from "../../graphql/inputs/action.input";
 import { Anthropic } from "@anthropic-ai/sdk";
+import { ActionInput } from "../../graphql/inputs/action.input";
+import { Message } from "../../graphql/types/converted";
 
 export function limitMessagesToTokenCount(
   messages: any[],
@@ -148,7 +143,7 @@ export function convertMessageToAnthropicMessage(
       content: [
         {
           type: "tool_result",
-          content: message.result,
+          content: message.result || "Action completed successfully",
           tool_use_id: message.actionExecutionId,
         },
       ],

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",
@@ -245,6 +240,16 @@ export class RuntimeEventSubject extends ReplaySubject<RuntimeEvent> {
 export class RuntimeEventSource {
   private eventStream$ = new RuntimeEventSubject();
   private callback!: EventSourceCallback;
+  private errorHandler?: (error: any, context: any) => Promise<void>;
+  private errorContext?: any;
+
+  constructor(params?: {
+    errorHandler?: (error: any, context: any) => Promise<void>;
+    errorContext?: any;
+  }) {
+    this.errorHandler = params?.errorHandler;
+    this.errorContext = params?.errorContext;
+  }
 
   async stream(callback: EventSourceCallback): Promise<void> {
     this.callback = callback;
@@ -272,11 +277,19 @@ export class RuntimeEventSource {
     actionInputsWithoutAgents: ActionInput[];
     threadId: string;
   }) {
-    this.callback(this.eventStream$).catch((error) => {
-      console.error("Error in event source callback", error);
+    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);
+        }
+      }
 
-      // Convert streaming errors to structured errors
-      const structuredError = convertStreamingErrorToStructured(error);
       this.eventStream$.error(structuredError);
       this.eventStream$.complete();
     });
@@ -330,17 +343,35 @@ 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, 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);
+                  },
+                });
+              }
 
-              // Convert streaming errors to structured errors and send as action result
-              const structuredError = convertStreamingErrorToStructured(error);
               toolCallEventStream$.sendActionExecutionResult({
                 actionExecutionId: eventWithState.actionExecutionId!,
                 actionName: eventWithState.action!.name,
@@ -436,10 +467,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 +509,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/google/google-genai-adapter.ts

@@ -23,6 +23,10 @@ interface GoogleGenerativeAIAdapterOptions {
    * A custom Google Generative AI model to use.
    */
   model?: string;
+  /**
+   * The API key to use.
+   */
+  apiKey?: string;
 }
 
 export class GoogleGenerativeAIAdapter extends LangChainAdapter {
@@ -46,6 +50,7 @@ export class GoogleGenerativeAIAdapter extends LangChainAdapter {
         });
 
         const model = new ChatGoogle({
+          apiKey: options?.apiKey ?? process.env.GOOGLE_API_KEY,
           modelName: options?.model ?? "gemini-1.5-pro",
           apiVersion: "v1beta",
         }).bindTools(tools);

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";
 
@@ -244,15 +245,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";