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

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

@@ -22,9 +22,6 @@ 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,
@@ -96,33 +93,11 @@ 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 CopilotKitLowLevelError({
-          error: error instanceof Error ? error : new Error(String(error)),
-          url: endpoint.deploymentUrl,
-          message: "Failed to execute LangGraph Platform agent",
-        });
+        throw new Error("Failed to execute LangGraph Platform agent");
       }
     },
   }));
@@ -205,7 +180,7 @@ export function constructRemoteActions({
         logger.debug({ actionName: action.name, result }, "Executed remote action");
         return result;
       } catch (error) {
-        if (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) {
+        if (error instanceof CopilotKitError) {
           throw error;
         }
         throw new CopilotKitLowLevelError({ error, url: fetchUrl });
@@ -300,7 +275,7 @@ export function constructRemoteActions({
               throw new Error("Unsupported agent type");
             }
           } catch (error) {
-            if (error instanceof CopilotKitError || error instanceof CopilotKitLowLevelError) {
+            if (error instanceof CopilotKitError) {
               throw error;
             }
             throw new CopilotKitLowLevelError({ error, url: fetchUrl });

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

@@ -2,9 +2,7 @@ import {
   Client as LangGraphClient,
   EventsStreamEvent,
   GraphSchema,
-  Interrupt,
   StreamMode,
-  ThreadState,
 } from "@langchain/langgraph-sdk";
 import { createHash } from "node:crypto";
 import { isValidUUID, randomUUID } from "@copilotkit/shared";
@@ -19,28 +17,9 @@ 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,
-  CopilotKitLowLevelError,
-  CopilotKitError,
-} from "@copilotkit/shared";
+import { parseJson, CopilotKitMisuseError } 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>;
 
@@ -105,6 +84,8 @@ type SchemaKeys = {
   config: string[] | null;
 } | null;
 
+let activeInterruptEvent = false;
+
 export async function execute(args: ExecutionArgs): Promise<ReadableStream<Uint8Array>> {
   return new ReadableStream({
     async start(controller) {
@@ -147,15 +128,6 @@ 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}.
@@ -216,7 +188,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
     await client.threads.create({ threadId });
   }
 
-  let agentState = { values: {} } as ThreadState;
+  let agentState = { values: {} };
   if (wasInitiatedWithExistingThread) {
     agentState = await client.threads.getState(threadId);
   }
@@ -246,14 +218,16 @@ 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) };
   }
 
-  const interrupts = (agentState.tasks?.[0]?.interrupts ?? []) as Interrupt[];
-  if (mode === "continue" && !interrupts.length) {
+  if (mode === "continue" && !activeInterruptEvent) {
     await client.threads.updateState(threadId, { values: state, asNode: nodeName });
   }
 
@@ -337,30 +311,17 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
   let shouldExit = false;
   let externalRunId = null;
 
-  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);
 
+  const emit = (message: string) => controller.enqueue(new TextEncoder().encode(message));
+
   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,
@@ -369,43 +330,7 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
       if (!["events", "values", "error", "updates"].includes(streamResponseChunk.event)) continue;
 
       if (streamResponseChunk.event === "error") {
-        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,
-        });
+        throw new Error(`Error event thrown: ${streamResponseChunk.data.message}`);
       }
 
       // Force event type, as data is not properly defined on the LG side.
@@ -420,8 +345,33 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
 
       const interruptEvents = chunk.data.__interrupt__;
       if (interruptEvents?.length) {
+        activeInterruptEvent = true;
         const interruptValue = interruptEvents?.[0].value;
-        emitInterrupt(interruptValue, emit);
+        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",
+          );
+        }
         continue;
       }
       if (streamResponseChunk.event === "updates") continue;
@@ -571,29 +521,11 @@ async function streamEvents(controller: ReadableStreamDefaultController, args: E
 
     return Promise.resolve();
   } catch (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);
-    }
-
+    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();
   }
 }
@@ -977,25 +909,3 @@ 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,11 +1,5 @@
 import { ReplaySubject } from "rxjs";
-import {
-  CopilotKitLowLevelError,
-  CopilotKitError,
-  CopilotKitErrorCode,
-  ensureStructuredError,
-} from "@copilotkit/shared";
-import { errorConfig, getFallbackMessage } from "./error-messages";
+import { CopilotKitLowLevelError, CopilotKitError, CopilotKitErrorCode } from "@copilotkit/shared";
 
 export async function writeJsonLineResponseToEventStream<T>(
   response: ReadableStream<Uint8Array>,
@@ -58,8 +52,10 @@ export async function writeJsonLineResponseToEventStream<T>(
       }
     }
   } catch (error) {
-    // Preserve already structured CopilotKit errors, only convert unstructured errors
-    const structuredError = ensureStructuredError(error, convertStreamingErrorToStructured);
+    console.error("Error in stream", error);
+
+    // Convert network termination errors to structured errors
+    const structuredError = convertStreamingErrorToStructured(error);
     eventStream$.error(structuredError);
     return;
   }
@@ -67,135 +63,50 @@ export async function writeJsonLineResponseToEventStream<T>(
 }
 
 function convertStreamingErrorToStructured(error: any): CopilotKitError {
-  // Determine a more helpful error message based on context
-  let helpfulMessage = generateHelpfulErrorMessage(error);
-
-  // 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 is likely due to the agent service being down or experiencing issues. Please check your agent logs and 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: "streaming connection",
-      message: helpfulMessage,
+      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,
     });
   }
 
-  // For all other errors, preserve the raw error in a basic CopilotKitError
+  // Default: convert unknown streaming errors
   return new CopilotKitError({
-    message: helpfulMessage,
+    message: `Streaming error: ${error?.message || String(error)}`,
     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,7 +29,6 @@ import {
 } from "./utils";
 
 import { randomId, randomUUID } from "@copilotkit/shared";
-import { convertServiceAdapterError } from "../shared";
 
 const DEFAULT_MODEL = "claude-3-5-sonnet-latest";
 
@@ -61,36 +60,6 @@ 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> {
@@ -125,30 +94,24 @@ 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 AND haven't been processed
+        // For tool results, only include if they match a valid tool_use ID
         if (message.isResultMessage()) {
           // Skip if there's no corresponding tool_use
           if (!validToolUseIds.has(message.actionExecutionId)) {
             return null; // Will be filtered out later
           }
 
-          // 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);
+          // Remove this ID from valid IDs so we don't process duplicates
+          validToolUseIds.delete(message.actionExecutionId);
 
           return {
             role: "user",
             content: [
               {
                 type: "tool_result",
-                content: message.result || "Action completed successfully",
+                content: message.result,
                 tool_use_id: message.actionExecutionId,
               },
             ],
@@ -176,7 +139,6 @@ 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;
@@ -209,14 +171,12 @@ 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();
@@ -260,34 +220,15 @@ export class AnthropicAdapter implements CopilotServiceAdapter {
             }
           }
         } catch (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 });
+          console.error("[Anthropic] Error processing stream:", error);
+          throw error;
         }
 
         eventStream$.complete();
       });
     } catch (error) {
-      throw convertServiceAdapterError(error, "Anthropic");
+      console.error("[Anthropic] Error during API call:", error);
+      throw error;
     }
 
     return {

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

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