@falai/agent 2.4.2 → 2.5.0

package/src/core/ToolLoopExecutor.ts

@@ -26,7 +26,7 @@ import type { Flow } from "./Flow";
 import type { Step } from "./Step";
 import type { ToolManager } from "./ToolManager";
 import { ResponseGenerationError } from "./ResponseGenerationError";
-import { historyToEvents, logger, serializeToolResult } from "../utils";
+import { historyToEvents, logger, serializeToolResult, assistantMessage, toolMessage } from "../utils";
 
 export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
     constructor(
@@ -72,7 +72,10 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
     }> {
         try {
             const { context, history, selectedFlow, responsePrompt, availableTools, responseSchema, signal } = params;
-            let { toolCalls, session } = params;
+            // The follow-up loop (which reassigned toolCalls) now lives in
+            // runFollowUpLoop; here toolCalls is only read.
+            const { toolCalls } = params;
+            let { session } = params;
 
             // Convert HistoryItem[] to Event[] for internal processing
             const historyEvents = historyToEvents(history);
@@ -146,8 +149,70 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
                 }
             }
 
+            // Hand off to the multi-round follow-up loop shared with the
+            // streaming path. The initial batch above already executed
+            // sequentially and populated the result maps.
+            return await this.runFollowUpLoop({
+                toolCalls,
+                session,
+                toolResultsMap,
+                toolArgsMap,
+                context,
+                history,
+                selectedFlow,
+                responsePrompt,
+                availableTools,
+                responseSchema,
+                signal,
+            });
+        } catch (error) {
+            throw ResponseGenerationError.fromError(error, 'tool_execution', params, {
+                toolCallsCount: params.toolCalls?.length || 0,
+                availableToolsCount: params.availableTools.length
+            });
+        }
+    }
+
+    /**
+     * The multi-round follow-up loop shared by the non-streaming (`runLoop`) and
+     * streaming (`runStreamingBatch`) tool paths: re-prompt the model with the
+     * tool results (tools available on the first round so it can chain further
+     * calls), execute any further tool calls, repeat up to `maxToolLoops`, then
+     * force a result-aware closing message if the model never produced one.
+     * Callers run the *initial* batch — sequentially for `runLoop`, concurrently
+     * (with progress) for `runStreamingBatch` — and pass the populated result
+     * maps; from here both paths behave identically.
+     */
+    private async runFollowUpLoop(params: {
+        toolCalls?: Array<{ toolName: string; arguments: Record<string, unknown> }>;
+        session: SessionState<TData>;
+        toolResultsMap: Map<string, string>;
+        toolArgsMap: Map<string, Record<string, unknown>>;
+        context: TContext;
+        history: HistoryItem[];
+        selectedFlow?: Flow<TContext, TData>;
+        responsePrompt: string;
+        availableTools: Array<{
+            id: string;
+            name: string;
+            description?: string;
+            parameters?: unknown;
+        }>;
+        responseSchema?: Record<string, unknown>;
+        signal?: AbortSignal;
+    }): Promise<{
+        session: SessionState<TData>;
+        finalToolCalls?: Array<{ toolName: string; arguments: Record<string, unknown> }>;
+        finalMessage?: string;
+        structured?: AgentStructuredResponse;
+    }> {
+        const { context, history, selectedFlow, responsePrompt, availableTools, responseSchema, signal, toolResultsMap, toolArgsMap } = params;
+        let { toolCalls, session } = params;
+        try {
             // TOOL LOOP: Allow AI to make follow-up tool calls after initial tool execution
-            const MAX_TOOL_LOOPS = this.deps.maxToolLoops || 5;
+            // `??` so an explicit `maxToolLoops: 0` is honored instead of being
+            // clobbered to the default by a falsy-zero check.
+            const MAX_TOOL_LOOPS = this.deps.maxToolLoops ?? 5;
             let toolLoopCount = 0;
             let hasToolCalls = toolCalls && toolCalls.length > 0;
             let finalMessage: string | undefined;
@@ -162,24 +227,18 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
                 for (const toolCall of toolCalls || []) {
                     const tool = this.findAvailableTool(toolCall.toolName, selectedFlow);
                     if (tool) {
-                        // Create HistoryItem format for tool results
-                        // Add assistant message with tool_calls
-                        toolResultHistoryItems.push({
-                            role: "assistant" as const,
-                            content: null,
-                            tool_calls: [{
-                                id: toolCall.toolName,
-                                name: toolCall.toolName,
-                                arguments: toolCall.arguments,
-                            }],
-                        });
-                        // Add tool result
-                        toolResultHistoryItems.push({
-                            role: "tool" as const,
-                            tool_call_id: toolCall.toolName,
-                            name: toolCall.toolName,
-                            content: toolResultsMap.get(toolCall.toolName) || "Tool executed successfully",
-                        });
+                        // assistant tool_call + tool result pair, via the shared
+                        // history factories (same as forceFinalTextFromTools).
+                        toolResultHistoryItems.push(
+                            assistantMessage(null, [
+                                { id: toolCall.toolName, name: toolCall.toolName, arguments: toolCall.arguments },
+                            ]),
+                            toolMessage(
+                                toolCall.toolName,
+                                toolCall.toolName,
+                                toolResultsMap.get(toolCall.toolName) || "Tool executed successfully",
+                            ),
+                        );
                     }
                 }
 
@@ -296,63 +355,26 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
             }
 
             // If tools were executed but no final text message was produced,
-            // make one more LLM call to generate a proper text response from tool results.
-            // This prevents the original tool-invocation message (e.g. "Let me check...")
-            // from being returned as the final user-facing response.
+            // make one more LLM call to generate a proper text response from tool
+            // results. This prevents the original tool-invocation message (e.g.
+            // "Let me check...") from being returned as the final user-facing
+            // response. Shared with the streaming path via forceFinalTextFromTools.
             if (!finalMessage && toolLoopCount > 0) {
                 logger.debug(`[ToolLoopExecutor] No final message after tool loop, making additional LLM call for text response`);
-
-                // Build tool result history from toolResultsMap which contains ALL
-                // tool executions (initial + follow-up). We can't use `toolCalls` here
-                // because it was reassigned to the (empty) follow-up tool calls when
-                // the while loop broke out.
-                const finalToolResultHistoryItems: HistoryItem[] = [];
-                for (const [toolName, toolResult] of toolResultsMap) {
-                    finalToolResultHistoryItems.push({
-                        role: "assistant" as const,
-                        content: null,
-                        tool_calls: [{
-                            id: toolName,
-                            name: toolName,
-                            arguments: toolArgsMap.get(toolName) || {},
-                        }],
-                    });
-                    finalToolResultHistoryItems.push({
-                        role: "tool" as const,
-                        tool_call_id: toolName,
-                        name: toolName,
-                        content: toolResult,
-                    });
+                const forced = await this.forceFinalTextFromTools({
+                    history,
+                    toolResultsMap,
+                    toolArgsMap,
+                    responsePrompt,
+                    responseSchema,
+                    context,
+                    signal,
+                });
+                if (forced.finalMessage) {
+                    finalMessage = forced.finalMessage;
                 }
-
-                const finalHistory = [...history, ...finalToolResultHistoryItems];
-                const agentOptions = this.deps.getAgentOptions();
-
-                try {
-                    const textResult = await agentOptions.provider.generateMessage({
-                        prompt: responsePrompt + "\n\nProvide a text response to the user based on the tool results. Do not call any tools.",
-                        history: finalHistory,
-                        context,
-                        tools: [], // No tools - force text response
-                        parameters: responseSchema ? {
-                            jsonSchema: responseSchema,
-                            schemaName: "tool_final_text",
-                        } : undefined,
-                        signal,
-                    });
-
-                    finalMessage = textResult.structured?.message || textResult.message;
-                    if (textResult.structured) {
-                        followUpStructured = textResult.structured;
-                    }
-
-                    logger.debug(`[ToolLoopExecutor] Generated final text response after tool loop:`, {
-                        hasMessage: !!finalMessage,
-                        messageLength: finalMessage?.length || 0,
-                    });
-                } catch (error) {
-                    logger.error(`[ToolLoopExecutor] Failed to generate final text response after tool loop:`, error);
-                    // finalMessage remains undefined; caller will use original message as fallback
+                if (forced.structured) {
+                    followUpStructured = forced.structured;
                 }
             }
 
@@ -377,12 +399,74 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
         }
     }
 
+    /**
+     * After tools have executed but the model produced no closing text, make one
+     * more LLM call (no tools) that turns the tool results into a user-facing
+     * message. Shared by the non-streaming tool loop and the streaming batch so
+     * both paths behave identically. Returns an empty object if the call fails
+     * or yields nothing, leaving the caller to fall back to its prior message.
+     */
+    private async forceFinalTextFromTools(params: {
+        history: HistoryItem[];
+        toolResultsMap: Map<string, string>;
+        toolArgsMap: Map<string, Record<string, unknown>>;
+        responsePrompt: string;
+        responseSchema?: Record<string, unknown>;
+        context: TContext;
+        signal?: AbortSignal;
+    }): Promise<{ finalMessage?: string; structured?: AgentStructuredResponse }> {
+        const { history, toolResultsMap, toolArgsMap, responsePrompt, responseSchema, context, signal } = params;
+
+        // Reconstruct assistant tool_call + tool result pairs so the follow-up
+        // call can see what the tools returned.
+        const finalToolResultHistoryItems: HistoryItem[] = [];
+        for (const [toolName, toolResult] of toolResultsMap) {
+            finalToolResultHistoryItems.push(
+                assistantMessage(null, [
+                    { id: toolName, name: toolName, arguments: toolArgsMap.get(toolName) || {} },
+                ]),
+                toolMessage(toolName, toolName, toolResult),
+            );
+        }
+
+        const finalHistory = [...history, ...finalToolResultHistoryItems];
+        const agentOptions = this.deps.getAgentOptions();
+
+        try {
+            const textResult = await agentOptions.provider.generateMessage({
+                prompt: responsePrompt + "\n\nProvide a text response to the user based on the tool results. Do not call any tools.",
+                history: finalHistory,
+                context,
+                tools: [], // No tools - force text response
+                parameters: responseSchema ? {
+                    jsonSchema: responseSchema,
+                    schemaName: "tool_final_text",
+                } : undefined,
+                signal,
+            });
+
+            const finalMessage = textResult.structured?.message || textResult.message;
+            logger.debug(`[ToolLoopExecutor] Generated final text response from tool results:`, {
+                hasMessage: !!finalMessage,
+                messageLength: finalMessage?.length || 0,
+            });
+            return { finalMessage, structured: textResult.structured };
+        } catch (error) {
+            logger.error(`[ToolLoopExecutor] Failed to generate final text response from tool results:`, error);
+            // Leave the caller to fall back to its prior message.
+            return {};
+        }
+    }
+
     /**
      * Execute the streaming path's initial batch of tool calls concurrently
      * via ToolManager.executeWithConcurrency, yielding tool-progress chunks.
-     * Falls back to `runLoop()` when concurrent execution fails.
+     * When tools ran but the model produced no closing text, forces a final
+     * text response from the tool results (mirroring `runLoop()`). Falls back
+     * to `runLoop()` when concurrent execution fails.
      *
-     * Returns the updated session and the final tool calls.
+     * Returns the updated session, final tool calls, and any forced closing
+     * message/structured response.
      */
     async *runStreamingBatch(params: {
         toolCalls: Array<{ toolName: string; arguments: Record<string, unknown> }>;
@@ -407,6 +491,9 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
         {
             session: SessionState<TData>;
             toolCalls: Array<{ toolName: string; arguments: Record<string, unknown> }> | undefined;
+            /** Closing message forced from the tool results, if one was generated. */
+            finalMessage?: string;
+            structured?: AgentStructuredResponse;
         }
     > {
         const { context, history, selectedFlow, step, accumulated, responsePrompt, availableTools, responseSchema, signal } = params;
@@ -419,9 +506,17 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
             toolName: tc.toolName,
             arguments: tc.arguments,
         }));
+        // Map request id -> request so completed results can be attributed back
+        // to their tool name/arguments for the forced final-text call.
+        const requestById = new Map(toolCallRequests.map((r) => [r.id, r]));
+        const toolResultsMap = new Map<string, string>();
+        const toolArgsMap = new Map<string, Record<string, unknown>>();
 
         const historyEvents = historyToEvents(history);
 
+        let finalMessage: string | undefined;
+        let structured: AgentStructuredResponse | undefined;
+
         try {
             for await (const update of this.deps.toolManager.executeWithConcurrency({
                 toolCalls: toolCallRequests,
@@ -450,6 +545,15 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
                     }
                 }
 
+                // Capture tool results for the forced final-text call
+                if (update.result) {
+                    const req = requestById.get(update.toolCallId);
+                    if (req) {
+                        toolResultsMap.set(req.toolName, serializeToolResult(update.result));
+                        toolArgsMap.set(req.toolName, req.arguments);
+                    }
+                }
+
                 // Yield progress updates immediately
                 if (update.progress) {
                     yield {
@@ -465,18 +569,45 @@ export class ToolLoopExecutor<TContext = unknown, TData = unknown> {
             }
 
             logger.debug(`[ToolLoopExecutor] Concurrent tool execution completed for ${toolCallRequests.length} tools`);
+
+            // Multi-round follow-up shared with the non-streaming path: re-prompt
+            // with the tool results so the model can chain further tool calls,
+            // then produce result-aware closing text (forced if it never does).
+            // Previously a single forced-text call — streaming now loops to parity
+            // with runLoop, so a streamed turn can chain tools across rounds.
+            const followUp = await this.runFollowUpLoop({
+                toolCalls,
+                session,
+                toolResultsMap,
+                toolArgsMap,
+                context,
+                history,
+                selectedFlow,
+                responsePrompt,
+                availableTools,
+                responseSchema,
+                signal,
+            });
+            session = followUp.session;
+            toolCalls = followUp.finalToolCalls;
+            finalMessage = followUp.finalMessage;
+            structured = followUp.structured;
         } catch (error) {
             logger.error(`[ToolLoopExecutor] Concurrent tool execution failed, falling back to sequential:`, error);
-            // Fall back to the unified tool loop on failure
+            // Fall back to the unified tool loop on failure. runLoop re-executes
+            // the tools from scratch, so any partial results collected above are
+            // intentionally discarded (it builds and forces its own).
             const toolResult = await this.runLoop({
                 toolCalls, context, session, history, selectedFlow,
                 responsePrompt, availableTools, responseSchema, signal,
             });
             session = toolResult.session;
             toolCalls = toolResult.finalToolCalls;
+            finalMessage = toolResult.finalMessage;
+            structured = toolResult.structured;
         }
 
-        return { session, toolCalls };
+        return { session, toolCalls, finalMessage, structured };
     }
 
     /**

package/src/core/ToolManager.ts

@@ -24,6 +24,7 @@ import type { Agent } from "./Agent";
 import { Flow } from "./Flow";
 import { Step } from "./Step";
 import { StreamingToolExecutor } from "./StreamingToolExecutor";
+import { evaluateToolGates } from "./toolGates";
 
 /**
  * Error thrown when tool creation fails
@@ -715,38 +716,13 @@ export class ToolManager<TContext = unknown, TData = unknown> {
 
       logger.debug(`[ToolManager] Executing tool: ${tool.id} with args:`, toolArguments);
 
-      // Tool validation gate (Req 6.1, 6.7)
-      if (typeof tool.validateInput === 'function' && toolArguments) {
-        const validation = await tool.validateInput(toolArguments, toolContext);
-        if (!validation.valid) {
-          const executionTime = Date.now() - startTime;
-          logger.warn(`[DataValidationError] Tool "${tool.id}" input validation failed: ${validation.error}. Fix the tool call arguments to match the expected schema.`);
-          return {
-            success: false,
-            error: `Validation failed: ${validation.error || 'Invalid input'}`,
-            metadata: { toolId: tool.id, executionTime, gate: 'validateInput' }
-          };
-        }
-      }
-
-      // Tool permission gate (Req 6.7, 6.8)
-      // When denied: do not invoke handler, do not process directives, do not apply state writes
-      if (typeof tool.checkPermissions === 'function' && toolArguments) {
-        const permission = await tool.checkPermissions(toolArguments, toolContext);
-        if (!permission.allowed) {
-          const executionTime = Date.now() - startTime;
-          logger.warn(`[ToolExecutionError] Tool "${tool.id}" permission denied: ${permission.reason}. The tool's checkPermissions hook rejected this call.`);
-          return {
-            success: false,
-            error: `Permission denied: ${permission.reason || 'Not allowed'}`,
-            metadata: {
-              toolId: tool.id,
-              executionTime,
-              gate: 'checkPermissions',
-              canOverride: permission.canOverride
-            }
-          };
-        }
+      // Pre-execution gates (validateInput → checkPermissions). Shared with the
+      // streaming executor (StreamingToolExecutor) so authorization/validation
+      // behave identically on every transport. When a gate denies, the handler
+      // is NOT invoked.
+      const gateDenial = await evaluateToolGates(tool, toolArguments, toolContext, startTime);
+      if (gateDenial) {
+        return gateDenial;
       }
 
       // Execute tool with timeout protection

package/src/core/toolGates.ts

@@ -0,0 +1,72 @@
+/**
+ * Shared pre-execution gates for tool calls.
+ *
+ * A tool's `validateInput` and `checkPermissions` hooks must be applied
+ * identically regardless of how the call is executed. Previously the gates
+ * lived only in `ToolManager.executeTool` (the sequential `generate()`/
+ * `respond()` path), so the streaming path (`StreamingToolExecutor`, used by
+ * `stream()`) invoked handlers without them — a documented authorization gate
+ * ("when denied, handler is NOT invoked") was silently a no-op on one
+ * transport. Centralizing the logic here keeps both executors in lockstep.
+ */
+import type { Tool, ToolContext, ToolExecutionResult } from "../types/tool";
+import { logger } from "../utils";
+
+/**
+ * Run a tool's pre-execution gates in order: `validateInput`, then
+ * `checkPermissions`. Returns a failed `ToolExecutionResult` when a gate
+ * blocks the call (the handler must NOT be invoked), or `null` when both
+ * gates pass.
+ *
+ * @param startTime - optional execution start time (ms from `Date.now()`).
+ *   When provided, denial metadata includes `executionTime`, matching the
+ *   sequential executor's result shape; omit it on the streaming path.
+ */
+export async function evaluateToolGates<TContext, TData>(
+  tool: Tool<TContext, TData>,
+  toolArguments: Record<string, unknown> | undefined,
+  toolContext: ToolContext<TContext, TData>,
+  startTime?: number
+): Promise<ToolExecutionResult | null> {
+  // Tool validation gate (Req 6.1, 6.7)
+  if (typeof tool.validateInput === "function" && toolArguments) {
+    const validation = await tool.validateInput(toolArguments, toolContext);
+    if (!validation.valid) {
+      logger.warn(
+        `[DataValidationError] Tool "${tool.id}" input validation failed: ${validation.error}. Fix the tool call arguments to match the expected schema.`
+      );
+      return {
+        success: false,
+        error: `Validation failed: ${validation.error || "Invalid input"}`,
+        metadata: {
+          toolId: tool.id,
+          ...(startTime !== undefined ? { executionTime: Date.now() - startTime } : {}),
+          gate: "validateInput",
+        },
+      };
+    }
+  }
+
+  // Tool permission gate (Req 6.7, 6.8)
+  // When denied: do not invoke handler, do not process directives, do not apply state writes
+  if (typeof tool.checkPermissions === "function" && toolArguments) {
+    const permission = await tool.checkPermissions(toolArguments, toolContext);
+    if (!permission.allowed) {
+      logger.warn(
+        `[ToolExecutionError] Tool "${tool.id}" permission denied: ${permission.reason}. The tool's checkPermissions hook rejected this call.`
+      );
+      return {
+        success: false,
+        error: `Permission denied: ${permission.reason || "Not allowed"}`,
+        metadata: {
+          toolId: tool.id,
+          ...(startTime !== undefined ? { executionTime: Date.now() - startTime } : {}),
+          gate: "checkPermissions",
+          canOverride: permission.canOverride,
+        },
+      };
+    }
+  }
+
+  return null;
+}

package/src/index.ts

@@ -32,6 +32,9 @@ export { DeepSeekProvider } from "./providers/DeepSeekProvider";
 export type { DeepSeekProviderOptions } from "./providers/DeepSeekProvider";
 // Base class for building OpenAI-compatible providers (Groq, Together, etc.)
 export { OpenAICompatibleProvider } from "./providers/OpenAICompatibleProvider";
+export type { StructuredOutputMode } from "./providers/OpenAICompatibleProvider";
+export { createOpenAICompatibleProvider } from "./providers/GenericOpenAICompatibleProvider";
+export type { OpenAICompatibleOptions } from "./providers/GenericOpenAICompatibleProvider";
 
 // Adapters
 export { PrismaAdapter } from "./adapters/PrismaAdapter";

package/src/providers/AnthropicProvider.ts

@@ -17,7 +17,7 @@ import type {
 } from "../types";
 import type { ProviderCapabilities } from "../types/ai";
 import type { HistoryItem } from "../types/history";
-import { withTimeoutAndRetry, logger } from "../utils";
+import { withTimeoutAndRetry, withStreamRetry, resolveRetryConfig, logger, assertUsableCompletion, combineAbortSignals } from "../utils";
 import {
   classifyProviderError,
   getErrorMessage,
@@ -26,11 +26,6 @@ import {
   type ErrorClassificationOptions,
 } from "./errorClassification";
 
-const DEFAULT_RETRY_CONFIG = {
-  timeout: 60000,
-  retries: 3,
-};
-
 /**
  * Configuration options for Anthropic provider
  * Uses types from @anthropic-ai/sdk package
@@ -105,10 +100,7 @@ export class AnthropicProvider implements AiProvider {
     this.primaryModel = model;
     this.backupModels = backupModels;
     this.config = config;
-    this.retryConfig = {
-      timeout: retryConfig?.timeout || DEFAULT_RETRY_CONFIG.timeout,
-      retries: retryConfig?.retries || DEFAULT_RETRY_CONFIG.retries,
-    };
+    this.retryConfig = resolveRetryConfig(retryConfig);
   }
 
   /**
@@ -264,7 +256,7 @@ export class AnthropicProvider implements AiProvider {
     model: string,
     input: GenerateMessageInput<TContext>
   ): Promise<GenerateMessageOutput<TStructured>> {
-    const operation = async (): Promise<GenerateMessageOutput> => {
+    const operation = async (signal: AbortSignal): Promise<GenerateMessageOutput> => {
       // Anthropic requires max_tokens to be specified
       const maxTokens = input.parameters?.maxOutputTokens || 4096;
 
@@ -328,7 +320,9 @@ export class AnthropicProvider implements AiProvider {
         }
       }
 
-      const response = await this.client.messages.create(params);
+      const response = await this.client.messages.create(params, {
+        signal: combineAbortSignals(input.signal, signal),
+      });
 
       // Extract text and tool calls from response
       const textContent = response.content.find(
@@ -377,6 +371,11 @@ export class AnthropicProvider implements AiProvider {
         } as AgentStructuredResponse;
       }
 
+      // A parsed-but-blank message with no tool calls is as empty as no text;
+      // the shared guard throws so withTimeoutAndRetry retries instead of
+      // returning {"message":""}.
+      assertUsableCompletion(structured, message, toolCalls.length, "Anthropic");
+
       return {
         message,
         metadata: {
@@ -407,9 +406,9 @@ export class AnthropicProvider implements AiProvider {
   ): AsyncGenerator<GenerateMessageStreamChunk<TStructured>> {
     // Try primary model first
     try {
-      yield* this.generateStreamWithModel<TContext, TStructured>(
-        this.primaryModel,
-        input
+      yield* withStreamRetry(
+        (signal) => this.generateStreamWithModel<TContext, TStructured>(this.primaryModel, input, signal),
+        { maxRetries: this.retryConfig.retries, firstChunkTimeoutMs: this.retryConfig.timeout, operationName: `Anthropic ${this.primaryModel} stream` }
       );
     } catch (primaryError: unknown) {
       const primaryErrMsg = getErrorMessage(primaryError);
@@ -433,9 +432,9 @@ export class AnthropicProvider implements AiProvider {
         );
 
         try {
-          yield* this.generateStreamWithModel<TContext, TStructured>(
-            backupModel,
-            input
+          yield* withStreamRetry(
+            (signal) => this.generateStreamWithModel<TContext, TStructured>(backupModel, input, signal),
+            { maxRetries: this.retryConfig.retries, firstChunkTimeoutMs: this.retryConfig.timeout, operationName: `Anthropic ${backupModel} stream` }
           );
           logger.debug(`[ANTHROPIC] Backup model ${backupModel} succeeded`);
           return;
@@ -471,7 +470,8 @@ export class AnthropicProvider implements AiProvider {
     TStructured = AgentStructuredResponse
   >(
     model: string,
-    input: GenerateMessageInput<TContext>
+    input: GenerateMessageInput<TContext>,
+    attemptSignal?: AbortSignal
   ): AsyncGenerator<GenerateMessageStreamChunk<TStructured>> {
     // Anthropic requires max_tokens to be specified
     const maxTokens = input.parameters?.maxOutputTokens || 4096;
@@ -536,7 +536,9 @@ export class AnthropicProvider implements AiProvider {
       }
     }
 
-    const stream = this.client.messages.stream(params);
+    const stream = this.client.messages.stream(params, {
+      signal: combineAbortSignals(input.signal, attemptSignal),
+    });
 
     let accumulated = "";
     let currentModel = model;
@@ -597,6 +599,10 @@ export class AnthropicProvider implements AiProvider {
       } as AgentStructuredResponse;
     }
 
+    // Empty-completion guard — same definition as the non-streaming path, so the
+    // stream retries / falls back to backup instead of emitting an empty message.
+    assertUsableCompletion(structured, accumulated, toolCalls.length, "Anthropic");
+
     // Yield final chunk
     yield {
       delta: "",