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

package/src/lib/runtime/remote-action-constructors.ts

@@ -22,6 +22,9 @@ import { parseJson, tryMap } from "@copilotkit/shared";
 import { ActionInput } from "../../graphql/inputs/action.input";
 import { fetchWithRetry } from "./retry-utils";
 
+// Import the utility function from remote-lg-action
+import { isUserConfigurationError } from "./remote-lg-action";
+
 export function constructLGCRemoteAction({
   endpoint,
   graphqlContext,
@@ -93,11 +96,33 @@ export function constructLGCRemoteAction({
         writeJsonLineResponseToEventStream(response, eventSource.eventStream$);
         return eventSource.processLangGraphEvents();
       } catch (error) {
+        // Preserve structured CopilotKit errors with semantic information
+        if (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) {
+          // Distinguish between user errors and system errors for logging
+          if (isUserConfigurationError(error)) {
+            logger.debug(
+              { url: endpoint.deploymentUrl, error: error.message, code: error.code },
+              "User configuration error in LangGraph Platform agent",
+            );
+          } else {
+            logger.error(
+              { url: endpoint.deploymentUrl, error: error.message, type: error.constructor.name },
+              "LangGraph Platform agent error",
+            );
+          }
+          throw error; // Re-throw the structured error to preserve semantic information
+        }
+
+        // For other errors, log and wrap them
         logger.error(
           { url: endpoint.deploymentUrl, status: 500, body: error.message },
           "Failed to execute LangGraph Platform agent",
         );
-        throw new Error("Failed to execute LangGraph Platform agent");
+        throw new CopilotKitLowLevelError({
+          error: error instanceof Error ? error : new Error(String(error)),
+          url: endpoint.deploymentUrl,
+          message: "Failed to execute LangGraph Platform agent",
+        });
       }
     },
   }));
@@ -180,7 +205,7 @@ export function constructRemoteActions({
         logger.debug({ actionName: action.name, result }, "Executed remote action");
         return result;
       } catch (error) {
-        if (error instanceof CopilotKitError) {
+        if (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) {
           throw error;
         }
         throw new CopilotKitLowLevelError({ error, url: fetchUrl });
@@ -275,7 +300,7 @@ export function constructRemoteActions({
               throw new Error("Unsupported agent type");
             }
           } catch (error) {
-            if (error instanceof CopilotKitError) {
+            if (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) {
               throw error;
             }
             throw new CopilotKitLowLevelError({ error, url: fetchUrl });

package/src/lib/runtime/remote-lg-action.ts

@@ -2,7 +2,9 @@ import {
   Client as LangGraphClient,
   EventsStreamEvent,
   GraphSchema,
+  Interrupt,
   StreamMode,
+  ThreadState,
 } from "@langchain/langgraph-sdk";
 import { createHash } from "node:crypto";
 import { isValidUUID, randomUUID } from "@copilotkit/shared";
@@ -17,9 +19,28 @@ import { CustomEventNames, LangGraphEventTypes } from "../../agents/langgraph/ev
 import telemetry from "../telemetry-client";
 import { MetaEventInput } from "../../graphql/inputs/meta-event.input";
 import { MetaEventName } from "../../graphql/types/meta-events.type";
-import { parseJson, CopilotKitMisuseError } from "@copilotkit/shared";
+import {
+  parseJson,
+  CopilotKitMisuseError,
+  CopilotKitLowLevelError,
+  CopilotKitError,
+} from "@copilotkit/shared";
 import { RemoveMessage } from "@langchain/core/messages";
 import { RETRY_CONFIG, isRetryableError, sleep, calculateDelay } from "./retry-utils";
+import { generateHelpfulErrorMessage } from "../streaming";
+
+// 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"))
+  );
+}
 
 type State = Record<string, any>;
 
@@ -84,8 +105,6 @@ type SchemaKeys = {
   config: string[] | null;
 } | null;
 
-let activeInterruptEvent = false;
-
 export async function execute(args: ExecutionArgs): Promise<ReadableStream<Uint8Array>> {
   return new ReadableStream({
     async start(controller) {
@@ -128,6 +147,15 @@ export async function execute(args: ExecutionArgs): Promise<ReadableStream<Uint8
             See more: https://docs.copilotkit.ai/troubleshooting/common-issues`,
         });
       } else {
+        // Preserve already structured CopilotKit errors with semantic information
+        if (
+          lastError instanceof CopilotKitError ||
+          lastError instanceof CopilotKitLowLevelError ||
+          (lastError instanceof Error && lastError.name && lastError.name.includes("CopilotKit"))
+        ) {
+          throw lastError; // Re-throw to preserve semantic information and visibility settings
+        }
+
         throw new CopilotKitMisuseError({
           message: `
             The LangGraph client threw unhandled error ${lastError}.
@@ -188,7 +216,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
     await client.threads.create({ threadId });
   }
 
-  let agentState = { values: {} };
+  let agentState = { values: {} } as ThreadState;
   if (wasInitiatedWithExistingThread) {
     agentState = await client.threads.getState(threadId);
   }
@@ -218,16 +246,14 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   const lgInterruptMetaEvent = metaEvents?.find(
     (ev) => ev.name === MetaEventName.LangGraphInterruptEvent,
   );
-  if (activeInterruptEvent && !lgInterruptMetaEvent) {
-    // state.messages includes only messages that were not processed by the agent, which are the interrupt messages
-    payload.command = { resume: state.messages };
-  }
+
   if (lgInterruptMetaEvent?.response) {
     let response = lgInterruptMetaEvent.response;
     payload.command = { resume: parseJson(response, response) };
   }
 
-  if (mode === "continue" && !activeInterruptEvent) {
+  const interrupts = (agentState.tasks?.[0]?.interrupts ?? []) as Interrupt[];
+  if (mode === "continue" && !interrupts.length) {
     await client.threads.updateState(threadId, { values: state, asNode: nodeName });
   }
 
@@ -311,17 +337,30 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   let shouldExit = false;
   let externalRunId = null;
 
-  const streamResponse = client.runs.stream(threadId, assistantId, payload);
-
   const emit = (message: string) => controller.enqueue(new TextEncoder().encode(message));
 
+  // If there are still outstanding unresolved interrupts, we must force resolution of them before moving forward
+  if (interrupts?.length && !payload.command?.resume) {
+    // If the interrupt is "by message" we assume the upcoming user message is a resoluton for the interrupt
+    if (!lgInterruptMetaEvent) {
+      // state.messages includes only messages that were not processed by the agent, which are the interrupt messages
+      payload.command = { resume: state.messages };
+    } else {
+      interrupts.forEach((interrupt) => {
+        emitInterrupt(interrupt.value, emit);
+      });
+      return Promise.resolve();
+    }
+  }
+
+  const streamResponse = client.runs.stream(threadId, assistantId, payload);
+
   let latestStateValues = {};
   let updatedState = state;
   // If a manual emittance happens, it is the ultimate source of truth of state, unless a node has exited.
   // Therefore, this value should either hold null, or the only edition of state that should be used.
   let manuallyEmittedState = null;
 
-  activeInterruptEvent = false;
   try {
     telemetry.capture("oss.runtime.agent_execution_stream_started", {
       hashedLgcKey: streamInfo.hashedLgcKey,
@@ -330,7 +369,43 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
       if (!["events", "values", "error", "updates"].includes(streamResponseChunk.event)) continue;
 
       if (streamResponseChunk.event === "error") {
-        throw new Error(`Error event thrown: ${streamResponseChunk.data.message}`);
+        const errorData = streamResponseChunk.data;
+
+        // Check if this is a structured error from our Python agent
+        if (errorData && typeof errorData === "object" && "error_details" in errorData) {
+          const errorDetails = (errorData as any).error_details;
+
+          // Create a structured error with preserved semantic information
+          const preservedError = new CopilotKitLowLevelError({
+            error: new Error(errorDetails.message),
+            url: "langgraph platform agent",
+            message: `${errorDetails.type}: ${errorDetails.message}`,
+          });
+
+          // Add additional error context
+          if (errorDetails.status_code) {
+            (preservedError as any).statusCode = errorDetails.status_code;
+          }
+          if (errorDetails.response_data) {
+            (preservedError as any).responseData = errorDetails.response_data;
+          }
+          (preservedError as any).agentName = errorDetails.agent_name;
+          (preservedError as any).originalErrorType = errorDetails.type;
+
+          throw preservedError;
+        }
+
+        // Fallback for generic error messages
+        const helpfulMessage = generateHelpfulErrorMessage(
+          new Error(errorData.message),
+          "LangGraph Platform agent",
+        );
+
+        throw new CopilotKitLowLevelError({
+          error: new Error(errorData.message),
+          url: "langgraph platform agent",
+          message: helpfulMessage,
+        });
       }
 
       // Force event type, as data is not properly defined on the LG side.
@@ -345,33 +420,8 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
 
       const interruptEvents = chunk.data.__interrupt__;
       if (interruptEvents?.length) {
-        activeInterruptEvent = true;
         const interruptValue = interruptEvents?.[0].value;
-        if (
-          typeof interruptValue != "string" &&
-          "__copilotkit_interrupt_value__" in interruptValue
-        ) {
-          const evValue = interruptValue.__copilotkit_interrupt_value__;
-          emit(
-            JSON.stringify({
-              event: LangGraphEventTypes.OnCopilotKitInterrupt,
-              data: {
-                value: typeof evValue === "string" ? evValue : JSON.stringify(evValue),
-                messages: langchainMessagesToCopilotKit(interruptValue.__copilotkit_messages__),
-              },
-            }) + "\n",
-          );
-        } else {
-          emit(
-            JSON.stringify({
-              event: LangGraphEventTypes.OnInterrupt,
-              value:
-                typeof interruptValue === "string"
-                  ? interruptValue
-                  : JSON.stringify(interruptValue),
-            }) + "\n",
-          );
-        }
+        emitInterrupt(interruptValue, emit);
         continue;
       }
       if (streamResponseChunk.event === "updates") continue;
@@ -521,11 +571,29 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
 
     return Promise.resolve();
   } catch (e) {
-    logger.error(e);
+    // Distinguish between user errors and system errors for logging
+    if (isUserConfigurationError(e)) {
+      // Log user errors at debug level to reduce noise
+      logger.debug({ error: e.message, code: e.code }, "User configuration error");
+    } else {
+      // Log actual system errors at error level
+      logger.error(e);
+    }
+
     telemetry.capture("oss.runtime.agent_execution_stream_errored", {
       ...streamInfo,
       error: e.message,
     });
+
+    // Re-throw CopilotKit errors so they can be handled properly at higher levels
+    if (
+      e instanceof CopilotKitError ||
+      e instanceof CopilotKitLowLevelError ||
+      (e instanceof Error && e.name && e.name.includes("CopilotKit"))
+    ) {
+      throw e;
+    }
+
     return Promise.resolve();
   }
 }
@@ -909,3 +977,25 @@ function getSchemaKeys(graphSchema: GraphSchema): SchemaKeys {
 function filterObjectBySchemaKeys(obj: Record<string, any>, schemaKeys: string[]) {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => schemaKeys.includes(key)));
 }
+
+function emitInterrupt(interruptValue: any, emit: (data: string) => void) {
+  if (typeof interruptValue != "string" && "__copilotkit_interrupt_value__" in interruptValue) {
+    const evValue = interruptValue.__copilotkit_interrupt_value__;
+    emit(
+      JSON.stringify({
+        event: LangGraphEventTypes.OnCopilotKitInterrupt,
+        data: {
+          value: typeof evValue === "string" ? evValue : JSON.stringify(evValue),
+          messages: langchainMessagesToCopilotKit(interruptValue.__copilotkit_messages__),
+        },
+      }) + "\n",
+    );
+  } else {
+    emit(
+      JSON.stringify({
+        event: LangGraphEventTypes.OnInterrupt,
+        value: typeof interruptValue === "string" ? interruptValue : JSON.stringify(interruptValue),
+      }) + "\n",
+    );
+  }
+}

package/src/lib/streaming.ts

@@ -1,5 +1,11 @@
 import { ReplaySubject } from "rxjs";
-import { CopilotKitLowLevelError, CopilotKitError, CopilotKitErrorCode } from "@copilotkit/shared";
+import {
+  CopilotKitLowLevelError,
+  CopilotKitError,
+  CopilotKitErrorCode,
+  ensureStructuredError,
+} from "@copilotkit/shared";
+import { errorConfig, getFallbackMessage } from "./error-messages";
 
 export async function writeJsonLineResponseToEventStream<T>(
   response: ReadableStream<Uint8Array>,
@@ -52,10 +58,8 @@ export async function writeJsonLineResponseToEventStream<T>(
       }
     }
   } catch (error) {
-    console.error("Error in stream", error);
-
-    // Convert network termination errors to structured errors
-    const structuredError = convertStreamingErrorToStructured(error);
+    // Preserve already structured CopilotKit errors, only convert unstructured errors
+    const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
     eventStream$.error(structuredError);
     return;
   }
@@ -63,50 +67,135 @@ export async function writeJsonLineResponseToEventStream<T>(
 }
 
 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 is likely due to the agent service being down or experiencing issues. Please check your agent logs and try again.",
-      code: CopilotKitErrorCode.NETWORK_ERROR,
-    });
-  }
+  // Determine a more helpful error message based on context
+  let helpfulMessage = generateHelpfulErrorMessage(error);
 
-  // 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: "streaming connection",
-      message:
-        "Network error occurred during 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,
+      message: helpfulMessage,
     });
   }
 
-  // Default: convert unknown streaming errors
+  // For all other errors, preserve the raw error in a basic CopilotKitError
   return new CopilotKitError({
-    message: `Streaming error: ${error?.message || String(error)}`,
+    message: helpfulMessage,
     code: CopilotKitErrorCode.UNKNOWN,
   });
 }
+
+/**
+ * Generates a helpful error message based on error patterns and context
+ */
+export function generateHelpfulErrorMessage(error: any, context: string = "connection"): string {
+  const baseMessage = error?.message || String(error);
+
+  // Check for preserved error information from Python agent
+  const originalErrorType = error?.originalErrorType || error?.extensions?.originalErrorType;
+  const statusCode = error?.statusCode || error?.extensions?.statusCode;
+  const responseData = error?.responseData || error?.extensions?.responseData;
+
+  // First, try to match by original error type if available (more specific)
+  if (originalErrorType) {
+    const typeConfig = errorConfig.errorPatterns[originalErrorType];
+    if (typeConfig) {
+      return typeConfig.message.replace("{context}", context);
+    }
+  }
+
+  // Check for specific error patterns from configuration
+  for (const [pattern, config] of Object.entries(errorConfig.errorPatterns)) {
+    const shouldMatch =
+      baseMessage?.includes(pattern) ||
+      error?.cause?.code === pattern ||
+      error?.code === pattern ||
+      statusCode === parseInt(pattern) ||
+      (pattern === "other_side_closed" && baseMessage?.includes("other side closed")) ||
+      (pattern === "fetch_failed" && baseMessage?.includes("fetch failed")) ||
+      (responseData && JSON.stringify(responseData).includes(pattern));
+
+    if (shouldMatch) {
+      // Replace {context} placeholder with actual context
+      return config.message.replace("{context}", context);
+    }
+  }
+
+  // Try to match by category for fallback messages
+  if (isNetworkError(error)) {
+    return getFallbackMessage("network");
+  }
+
+  if (isConnectionError(error)) {
+    return getFallbackMessage("connection");
+  }
+
+  if (isAuthenticationError(error)) {
+    return getFallbackMessage("authentication");
+  }
+
+  // Default fallback
+  return getFallbackMessage("default");
+}
+
+/**
+ * Determines if an error is network-related
+ */
+function isNetworkError(error: any): boolean {
+  const networkPatterns = ["ECONNREFUSED", "ENOTFOUND", "ETIMEDOUT", "fetch_failed"];
+  return networkPatterns.some(
+    (pattern) =>
+      error?.message?.includes(pattern) ||
+      error?.cause?.code === pattern ||
+      error?.code === pattern,
+  );
+}
+
+/**
+ * Determines if an error is connection-related
+ */
+function isConnectionError(error: any): boolean {
+  const connectionPatterns = ["terminated", "UND_ERR_SOCKET", "other side closed"];
+  return connectionPatterns.some(
+    (pattern) =>
+      error?.message?.includes(pattern) ||
+      error?.cause?.code === pattern ||
+      error?.code === pattern,
+  );
+}
+
+/**
+ * Determines if an error is authentication-related
+ */
+function isAuthenticationError(error: any): boolean {
+  const authPatterns = [
+    "401",
+    "api key",
+    "unauthorized",
+    "authentication",
+    "AuthenticationError",
+    "PermissionDeniedError",
+  ];
+  const baseMessage = error?.message || String(error);
+  const originalErrorType = error?.originalErrorType || error?.extensions?.originalErrorType;
+  const statusCode = error?.statusCode || error?.extensions?.statusCode;
+
+  return authPatterns.some(
+    (pattern) =>
+      baseMessage?.toLowerCase().includes(pattern.toLowerCase()) ||
+      originalErrorType === pattern ||
+      statusCode === 401 ||
+      error?.status === 401 ||
+      error?.statusCode === 401,
+  );
+}

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