Merge pull request #604 from buster-so/dallin/bus-1488-try-switching-to-cloudflare-ai-gateway

feat: add Google Vertex AI and improve model handling

.github/workflows/ci.yml

@@ -30,7 +30,7 @@ jobs:
         uses: useblacksmith/setup-node@v5
         with:
           node-version: 22
-          cache: 'pnpm'
+          # Remove cache here since we're using stickydisk for pnpm store
           
       - name: Get pnpm store directory
         shell: bash
@@ -49,8 +49,21 @@ jobs:
           key: ${{ github.repository }}-turbo-cache
           path: ./.turbo
 
+      - name: Check if lockfile changed
+        id: lockfile-check
+        run: |
+          if git diff HEAD~1 HEAD --name-only | grep -q "pnpm-lock.yaml"; then
+            echo "changed=true" >> $GITHUB_OUTPUT
+          else
+            echo "changed=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Fetch dependencies (if lockfile changed)
+        if: steps.lockfile-check.outputs.changed == 'true'
+        run: pnpm fetch --frozen-lockfile
+
       - name: Install dependencies
-        run: pnpm install --frozen-lockfile
+        run: pnpm install --frozen-lockfile --prefer-offline
 
       - name: Build all packages (excluding web)
         run: pnpm build --filter='!@buster-app/web'

apps/api/libs/query_engine/src/data_source_query_routes/snowflake_query.rs

@@ -1686,7 +1686,7 @@ fn convert_array_to_datatype(
 // -------------------------
 
 // Define the row limit constant here or retrieve from config
-const PROCESSING_ROW_LIMIT: usize = 1000;
+const PROCESSING_ROW_LIMIT: usize = 5000;
 
 fn prepare_query(query: &str) -> String {
     // Note: This function currently doesn't apply a LIMIT to the query.

packages/ai/CLAUDE.md

@@ -133,14 +133,52 @@ utils/
 │   ├── types.ts             # Message/step data types
 │   └── index.ts
 └── models/
-    └── anthropic-cached.ts   # Model configuration
+    ├── ai-fallback.ts        # Fallback model wrapper with retry logic
+    ├── anthropic.ts          # Basic Anthropic model wrapper
+    ├── anthropic-cached.ts   # Anthropic with caching support
+    ├── vertex.ts             # Google Vertex AI model wrapper
+    ├── sonnet-4.ts           # Claude Sonnet 4 with fallback
+    └── haiku-3-5.ts          # Claude Haiku 3.5 with fallback
 ```
 
 **Pattern**: Utilities support core functionality:
 - **Memory**: Handles message history between agents in multi-step workflows
-- **Models**: Wraps AI models with caching and Braintrust integration
+- **Models**: Provides various AI model configurations with fallback support
 - **Message History**: Critical for multi-agent workflows - extracts and formats messages for passing between agents
 
+##### Model Configuration Pattern
+
+The models folder provides different AI model configurations with automatic fallback support:
+
+1. **Base Model Wrappers** (`anthropic.ts`, `vertex.ts`):
+   - Wrap AI SDK models with Braintrust tracing
+   - Handle authentication and configuration
+   - Provide consistent interface for model usage
+
+2. **Fallback Models** (`sonnet-4.ts`, `haiku-3-5.ts`):
+   - Use `createFallback()` to define multiple model providers
+   - Automatically switch between providers on errors
+   - Configure retry behavior and error handling
+   - Example: Sonnet4 tries Vertex first, falls back to Anthropic
+
+3. **Cached Model** (`anthropic-cached.ts`):
+   - Adds caching support to Anthropic models
+   - Automatically adds cache_control to system messages
+   - Includes connection pooling for better performance
+   - Used by agents requiring prompt caching
+
+**Usage Example**:
+```typescript
+// For general use with fallback support
+import { Sonnet4, Haiku35 } from '@buster/ai';
+
+// For agents with complex prompts needing caching
+import { anthropicCachedModel } from '@buster/ai';
+
+// Direct model usage (no fallback)
+import { anthropicModel, vertexModel } from '@buster/ai';
+```
+
 ### Testing Strategy (`tests/`)
 
 #### **Test Structure**
@@ -239,7 +277,7 @@ const formattedMessages = formatMessagesForAnalyst(
 export const agentName = new Agent({
   name: 'Agent Name',
   instructions: getInstructions,
-  model:  anthropicCachedModel('anthropic/claude-sonnet-4'),
+  model: Sonnet4,  // Can use Sonnet4, Haiku35, or anthropicCachedModel('model-id')
   tools: { tool1, tool2, tool3 },
   memory: getSharedMemory(),
   defaultGenerateOptions: DEFAULT_OPTIONS,

packages/ai/package.json

@@ -33,6 +33,7 @@
   },
   "dependencies": {
     "@ai-sdk/anthropic": "^1.2.12",
+    "@ai-sdk/google-vertex": "^2.2.27",
     "@ai-sdk/provider": "^1.1.3",
     "@buster/access-controls": "workspace:*",
     "@buster/data-source": "workspace:*",

packages/ai/src/agents/analyst-agent/analyst-agent.ts

@@ -7,8 +7,7 @@ import {
   modifyDashboards,
   modifyMetrics,
 } from '../../tools';
-import { anthropicCachedModel } from '../../utils/models/anthropic-cached';
-import { getAnalystInstructions } from './analyst-agent-instructions';
+import { Sonnet4 } from '../../utils/models/sonnet-4';
 
 const DEFAULT_OPTIONS = {
   maxSteps: 18,
@@ -24,7 +23,7 @@ const DEFAULT_OPTIONS = {
 export const analystAgent = new Agent({
   name: 'Analyst Agent',
   instructions: '', // We control the system messages in the step at stream instantiation
-  model: anthropicCachedModel('claude-sonnet-4-20250514'),
+  model: Sonnet4,
   tools: {
     createMetrics,
     modifyMetrics,

packages/ai/src/agents/think-and-prep-agent/think-and-prep-agent.ts

@@ -6,8 +6,7 @@ import {
   sequentialThinking,
   submitThoughts,
 } from '../../tools';
-import { anthropicCachedModel } from '../../utils/models/anthropic-cached';
-import { getThinkAndPrepInstructions } from './think-and-prep-instructions';
+import { Sonnet4 } from '../../utils/models/sonnet-4';
 
 const DEFAULT_OPTIONS = {
   maxSteps: 18,
@@ -23,7 +22,7 @@ const DEFAULT_OPTIONS = {
 export const thinkAndPrepAgent = new Agent({
   name: 'Think and Prep Agent',
   instructions: '', // We control the system messages in the step at stream instantiation
-  model: anthropicCachedModel('claude-sonnet-4-20250514'),
+  model: Sonnet4,
   tools: {
     sequentialThinking,
     executeSql,

packages/ai/src/steps/create-todos-step.ts

@@ -1,4 +1,3 @@
-import { updateMessageFields } from '@buster/database';
 import { Agent, createStep } from '@mastra/core';
 import type { RuntimeContext } from '@mastra/core/runtime-context';
 import type { CoreMessage } from 'ai';
@@ -8,18 +7,11 @@ import { z } from 'zod';
 import { thinkAndPrepWorkflowInputSchema } from '../schemas/workflow-schemas';
 import { createTodoList } from '../tools/planning-thinking-tools/create-todo-item-tool';
 import { ChunkProcessor } from '../utils/database/chunk-processor';
-import { createTodoReasoningMessage } from '../utils/memory/todos-to-messages';
-import type { BusterChatMessageReasoningSchema } from '../utils/memory/types';
 import { ReasoningHistorySchema } from '../utils/memory/types';
-import { anthropicCachedModel } from '../utils/models/anthropic-cached';
-import {
-  RetryWithHealingError,
-  detectRetryableError,
-  isRetryWithHealingError,
-} from '../utils/retry';
-import type { RetryableError, WorkflowContext } from '../utils/retry/types';
+import { Sonnet4 } from '../utils/models/sonnet-4';
+import { RetryWithHealingError, isRetryWithHealingError } from '../utils/retry';
 import { appendToConversation, standardizeMessages } from '../utils/standardizeMessages';
-import { createOnChunkHandler, handleStreamingError } from '../utils/streaming';
+import { createOnChunkHandler } from '../utils/streaming';
 import type { AnalystRuntimeContext } from '../workflows/analyst-workflow';
 
 const inputSchema = thinkAndPrepWorkflowInputSchema;
@@ -196,7 +188,7 @@ const DEFAULT_OPTIONS = {
 export const todosAgent = new Agent({
   name: 'Create Todos',
   instructions: todosInstructions,
-  model: anthropicCachedModel('claude-sonnet-4-20250514'),
+  model: Sonnet4,
   tools: {
     createTodoList,
   },

packages/ai/src/steps/extract-values-search-step.test.ts

@@ -1,7 +1,9 @@
-import { RuntimeContext } from '@mastra/core/runtime-context';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { AnalystRuntimeContext } from '../workflows/analyst-workflow';
-import { extractValuesSearchStep } from './extract-values-search-step';
+
+// Mock the AI models first, before any imports that might use them
+vi.mock('../utils/models/haiku-3-5', () => ({
+  Haiku35: 'mock-model',
+}));
 
 // Mock the stored-values package
 vi.mock('@buster/stored-values/search', () => {
@@ -11,26 +13,48 @@ vi.mock('@buster/stored-values/search', () => {
   };
 });
 
-// Mock the AI models
-vi.mock('../../../src/utils/models/anthropic-cached', () => ({
-  anthropicCachedModel: vi.fn(() => 'mock-model'),
-}));
-
 // Mock Braintrust
 vi.mock('braintrust', () => ({
   wrapTraced: vi.fn((fn) => fn),
   wrapAISDKModel: vi.fn((model) => model),
 }));
 
+// Create a ref object to hold the mock generate function
+const mockGenerateRef = { current: vi.fn() };
+
+// Mock the Agent class from Mastra with the generate function
+vi.mock('@mastra/core', async () => {
+  const actual = await vi.importActual('@mastra/core');
+  return {
+    ...actual,
+    Agent: vi.fn().mockImplementation(() => ({
+      generate: (...args: any[]) => mockGenerateRef.current(...args),
+    })),
+    createStep: actual.createStep,
+  };
+});
+
+// Now import after mocks are set up
+import { RuntimeContext } from '@mastra/core/runtime-context';
+import type { AnalystRuntimeContext } from '../workflows/analyst-workflow';
+import { extractValuesSearchStep } from './extract-values-search-step';
+
 // Import the mocked functions
 import { generateEmbedding, searchValuesByEmbedding } from '@buster/stored-values/search';
 
 const mockGenerateEmbedding = generateEmbedding as ReturnType<typeof vi.fn>;
 const mockSearchValuesByEmbedding = searchValuesByEmbedding as ReturnType<typeof vi.fn>;
 
-describe.skip('extractValuesSearchStep', () => {
+// Access the mock generate function through the ref
+const mockGenerate = mockGenerateRef.current;
+
+describe('extractValuesSearchStep', () => {
   beforeEach(() => {
     vi.clearAllMocks();
+    // Set default mock behavior
+    mockGenerate.mockResolvedValue({
+      object: { values: [] },
+    });
   });
 
   afterEach(() => {
@@ -48,19 +72,10 @@ describe.skip('extractValuesSearchStep', () => {
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
       // Mock the LLM response for keyword extraction
-      const mockAgentGenerate = vi.fn().mockResolvedValue({
+      mockGenerate.mockResolvedValue({
         object: { values: ['Red Bull', 'California'] },
       });
 
-      // Mock the values agent
-      vi.doMock('../../../src/steps/extract-values-search-step', async () => {
-        const actual = await vi.importActual('../../../src/steps/extract-values-search-step');
-        return {
-          ...actual,
-          valuesAgent: { generate: mockAgentGenerate },
-        };
-      });
-
       mockGenerateEmbedding.mockResolvedValue([1, 2, 3]);
       mockSearchValuesByEmbedding.mockResolvedValue([]);
 
@@ -126,7 +141,7 @@ describe.skip('extractValuesSearchStep', () => {
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
       // Mock empty keyword extraction
-      const mockAgentGenerate = vi.fn().mockResolvedValue({
+      mockGenerate.mockResolvedValue({
         object: { values: [] },
       });
 
@@ -179,6 +194,11 @@ describe.skip('extractValuesSearchStep', () => {
       const runtimeContext = new RuntimeContext<AnalystRuntimeContext>();
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
+      // Mock successful keyword extraction
+      mockGenerate.mockResolvedValue({
+        object: { values: ['Red Bull'] },
+      });
+
       // Mock successful search
       mockGenerateEmbedding.mockResolvedValue([1, 2, 3]);
       mockSearchValuesByEmbedding.mockResolvedValue(mockSearchResults);
@@ -206,7 +226,7 @@ describe.skip('extractValuesSearchStep', () => {
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
       // Mock LLM extraction success but embedding failure
-      const mockAgentGenerate = vi.fn().mockResolvedValue({
+      mockGenerate.mockResolvedValue({
         object: { values: ['test keyword'] },
       });
 
@@ -233,6 +253,11 @@ describe.skip('extractValuesSearchStep', () => {
       const runtimeContext = new RuntimeContext<AnalystRuntimeContext>();
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
+      // Mock successful keyword extraction
+      mockGenerate.mockResolvedValue({
+        object: { values: ['test keyword'] },
+      });
+
       // Mock successful embedding but database failure
       mockGenerateEmbedding.mockResolvedValue([1, 2, 3]);
       mockSearchValuesByEmbedding.mockRejectedValue(new Error('Database connection failed'));
@@ -259,7 +284,7 @@ describe.skip('extractValuesSearchStep', () => {
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
       // Mock two keywords: one succeeds, one fails
-      const mockAgentGenerate = vi.fn().mockResolvedValue({
+      mockGenerate.mockResolvedValue({
         object: { values: ['keyword1', 'keyword2'] },
       });
 
@@ -302,7 +327,7 @@ describe.skip('extractValuesSearchStep', () => {
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
       // Mock everything to fail
-      const mockAgentGenerate = vi.fn().mockRejectedValue(new Error('LLM failure'));
+      mockGenerate.mockRejectedValue(new Error('LLM failure'));
       mockGenerateEmbedding.mockRejectedValue(new Error('Embedding failure'));
       mockSearchValuesByEmbedding.mockRejectedValue(new Error('Database failure'));
 
@@ -344,9 +369,6 @@ describe.skip('extractValuesSearchStep', () => {
         },
       ];
 
-      mockGenerateEmbedding.mockResolvedValue([1, 2, 3]);
-      mockSearchValuesByEmbedding.mockResolvedValue(mockSearchResults);
-
       const inputData = {
         prompt: 'Test prompt',
         conversationHistory: [],
@@ -355,6 +377,14 @@ describe.skip('extractValuesSearchStep', () => {
       const runtimeContext = new RuntimeContext<AnalystRuntimeContext>();
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
+      // Mock successful keyword extraction
+      mockGenerate.mockResolvedValue({
+        object: { values: ['Red Bull'] },
+      });
+
+      mockGenerateEmbedding.mockResolvedValue([1, 2, 3]);
+      mockSearchValuesByEmbedding.mockResolvedValue(mockSearchResults);
+
       const result = await extractValuesSearchStep.execute({
         inputData,
         runtimeContext,
@@ -398,9 +428,6 @@ describe.skip('extractValuesSearchStep', () => {
         },
       ];
 
-      mockGenerateEmbedding.mockResolvedValue([1, 2, 3]);
-      mockSearchValuesByEmbedding.mockResolvedValue(mockSearchResults);
-
       const inputData = {
         prompt: 'Test prompt',
         conversationHistory: [],
@@ -409,6 +436,14 @@ describe.skip('extractValuesSearchStep', () => {
       const runtimeContext = new RuntimeContext<AnalystRuntimeContext>();
       runtimeContext.set('dataSourceId', 'test-datasource-id');
 
+      // Mock successful keyword extraction
+      mockGenerate.mockResolvedValue({
+        object: { values: ['test'] },
+      });
+
+      mockGenerateEmbedding.mockResolvedValue([1, 2, 3]);
+      mockSearchValuesByEmbedding.mockResolvedValue(mockSearchResults);
+
       const result = await extractValuesSearchStep.execute({
         inputData,
         runtimeContext,

packages/ai/src/steps/extract-values-search-step.ts

@@ -6,7 +6,7 @@ import type { CoreMessage } from 'ai';
 import { wrapTraced } from 'braintrust';
 import { z } from 'zod';
 import { thinkAndPrepWorkflowInputSchema } from '../schemas/workflow-schemas';
-import { anthropicCachedModel } from '../utils/models/anthropic-cached';
+import { Haiku35 } from '../utils/models/haiku-3-5';
 import { appendToConversation, standardizeMessages } from '../utils/standardizeMessages';
 import type { AnalystRuntimeContext } from '../workflows/analyst-workflow';
 
@@ -234,7 +234,7 @@ async function searchStoredValues(
 const valuesAgent = new Agent({
   name: 'Extract Values',
   instructions: extractValuesInstructions,
-  model: anthropicCachedModel('claude-3-5-haiku-20241022'),
+  model: Haiku35,
 });
 
 const extractValuesSearchStepExecution = async ({

packages/ai/src/steps/generate-chat-title-step.ts

@@ -5,7 +5,7 @@ import type { CoreMessage } from 'ai';
 import { wrapTraced } from 'braintrust';
 import { z } from 'zod';
 import { thinkAndPrepWorkflowInputSchema } from '../schemas/workflow-schemas';
-import { anthropicCachedModel } from '../utils/models/anthropic-cached';
+import { Haiku35 } from '../utils/models/haiku-3-5';
 import { appendToConversation, standardizeMessages } from '../utils/standardizeMessages';
 import type { AnalystRuntimeContext } from '../workflows/analyst-workflow';
 
@@ -33,7 +33,7 @@ I am a chat title generator that is responsible for generating a title for the c
 const todosAgent = new Agent({
   name: 'Extract Values',
   instructions: generateChatTitleInstructions,
-  model: anthropicCachedModel('claude-3-5-haiku-20241022'),
+  model: Haiku35,
 });
 
 const generateChatTitleExecution = async ({

packages/ai/src/steps/post-processing/flag-chat-step.ts

@@ -5,7 +5,7 @@ import { z } from 'zod';
 import { flagChat } from '../../tools/post-processing/flag-chat';
 import { noIssuesFound } from '../../tools/post-processing/no-issues-found';
 import { MessageHistorySchema } from '../../utils/memory/types';
-import { anthropicCachedModel } from '../../utils/models/anthropic-cached';
+import { Sonnet4 } from '../../utils/models/sonnet-4';
 import { standardizeMessages } from '../../utils/standardizeMessages';
 
 const inputSchema = z.object({
@@ -171,7 +171,7 @@ export const flagChatStepExecution = async ({
     const flagChatAgentWithContext = new Agent({
       name: 'Flag Chat Review',
       instructions: '', // We control the system messages below at stream instantiation
-      model: anthropicCachedModel('claude-sonnet-4-20250514'),
+      model: Sonnet4,
       tools: {
         flagChat,
         noIssuesFound,

packages/ai/src/steps/post-processing/format-follow-up-message-step.test.ts

@@ -24,8 +24,8 @@ vi.mock('braintrust', () => ({
   wrapTraced: vi.fn((fn) => fn),
 }));
 
-vi.mock('../../../src/utils/models/anthropic-cached', () => ({
-  anthropicCachedModel: vi.fn(() => 'mocked-model'),
+vi.mock('../../utils/models/sonnet-4', () => ({
+  Sonnet4: 'mocked-model',
 }));
 
 vi.mock('../../../src/utils/standardizeMessages', () => ({

packages/ai/src/steps/post-processing/format-follow-up-message-step.ts

@@ -3,11 +3,10 @@ import type { CoreMessage } from 'ai';
 import { wrapTraced } from 'braintrust';
 import type { z } from 'zod';
 import { generateUpdateMessage } from '../../tools/post-processing/generate-update-message';
-import { MessageHistorySchema } from '../../utils/memory/types';
-import { anthropicCachedModel } from '../../utils/models/anthropic-cached';
 import { standardizeMessages } from '../../utils/standardizeMessages';
 import { postProcessingWorkflowOutputSchema } from './schemas';
 
+import { Sonnet4 } from '../../utils/models/sonnet-4';
 // Import the schema from combine-parallel-results step
 import { combineParallelResultsOutputSchema } from './combine-parallel-results-step';
 
@@ -78,7 +77,7 @@ const DEFAULT_OPTIONS = {
 export const followUpMessageAgent = new Agent({
   name: 'Format Follow-up Message',
   instructions: followUpMessageInstructions,
-  model: anthropicCachedModel('claude-sonnet-4-20250514'),
+  model: Sonnet4,
   tools: {
     generateUpdateMessage,
   },

packages/ai/src/steps/post-processing/format-initial-message-step.test.ts

@@ -24,8 +24,8 @@ vi.mock('braintrust', () => ({
   wrapTraced: vi.fn((fn) => fn),
 }));
 
-vi.mock('../../../src/utils/models/anthropic-cached', () => ({
-  anthropicCachedModel: vi.fn(() => 'mocked-model'),
+vi.mock('../../utils/models/sonnet-4', () => ({
+  Sonnet4: 'mocked-model',
 }));
 
 vi.mock('../../../src/utils/standardizeMessages', () => ({

packages/ai/src/steps/post-processing/format-initial-message-step.ts

@@ -3,11 +3,10 @@ import type { CoreMessage } from 'ai';
 import { wrapTraced } from 'braintrust';
 import type { z } from 'zod';
 import { generateSummary } from '../../tools/post-processing/generate-summary';
-import { MessageHistorySchema } from '../../utils/memory/types';
-import { anthropicCachedModel } from '../../utils/models/anthropic-cached';
 import { standardizeMessages } from '../../utils/standardizeMessages';
 import { postProcessingWorkflowOutputSchema } from './schemas';
 
+import { Sonnet4 } from '../../utils/models/sonnet-4';
 // Import the schema from combine-parallel-results step
 import { combineParallelResultsOutputSchema } from './combine-parallel-results-step';
 
@@ -104,7 +103,7 @@ const DEFAULT_OPTIONS = {
 export const initialMessageAgent = new Agent({
   name: 'Format Initial Message',
   instructions: initialMessageInstructions,
-  model: anthropicCachedModel('claude-sonnet-4-20250514'),
+  model: Sonnet4,
   tools: {
     generateSummary,
   },

packages/ai/src/steps/post-processing/identify-assumptions-step.ts

@@ -8,7 +8,7 @@ import {
 } from '../../tools/post-processing/list-assumptions-response';
 import { noAssumptionsIdentified } from '../../tools/post-processing/no-assumptions-identified';
 import { MessageHistorySchema } from '../../utils/memory/types';
-import { anthropicCachedModel } from '../../utils/models/anthropic-cached';
+import { Sonnet4 } from '../../utils/models/sonnet-4';
 
 const inputSchema = z.object({
   conversationHistory: MessageHistorySchema.optional(),
@@ -409,7 +409,7 @@ export const identifyAssumptionsStepExecution = async ({
     const identifyAssumptionsAgentWithContext = new Agent({
       name: 'Identify Assumptions',
       instructions: '', // We control the system messages below at stream instantiation
-      model: anthropicCachedModel('claude-sonnet-4-20250514'),
+      model: Sonnet4,
       tools: {
         listAssumptionsResponse,
         noAssumptionsIdentified,

packages/ai/src/utils/index.ts

@@ -10,7 +10,12 @@ export * from './convertToCoreMessages';
 export * from './standardizeMessages';
 
 // Model utilities
+export * from './models/ai-fallback';
+export * from './models/providers/anthropic';
 export * from './models/anthropic-cached';
+export * from './models/providers/vertex';
+export * from './models/sonnet-4';
+export * from './models/haiku-3-5';
 
 // Streaming utilities
 export * from './streaming';

packages/ai/src/utils/models/ai-fallback-memory-safe.test.ts

@@ -0,0 +1,141 @@
+import type {
+  LanguageModelV1,
+  LanguageModelV1CallOptions,
+  LanguageModelV1FinishReason,
+  LanguageModelV1StreamPart,
+} from '@ai-sdk/provider';
+import { describe, expect, it, vi } from 'vitest';
+import { createFallback } from './ai-fallback';
+
+// Memory-safe mock that avoids ReadableStream complexity
+function createMemorySafeMockModel(
+  id: string,
+  shouldFail = false,
+  failureError?: Error
+): LanguageModelV1 {
+  return {
+    specificationVersion: 'v1' as const,
+    modelId: id,
+    provider: `provider-${id}`,
+    defaultObjectGenerationMode: undefined,
+
+    doGenerate: vi.fn().mockImplementation(async () => {
+      if (shouldFail) {
+        throw failureError || new Error(`Model ${id} failed`);
+      }
+      return {
+        text: `Response from ${id}`,
+        finishReason: 'stop' as LanguageModelV1FinishReason,
+        usage: { promptTokens: 10, completionTokens: 20 },
+        rawCall: { rawPrompt: 'test', rawSettings: {} },
+      };
+    }),
+
+    doStream: vi.fn().mockImplementation(async () => {
+      if (shouldFail) {
+        throw failureError || new Error(`Model ${id} failed`);
+      }
+
+      // Return a mock stream that doesn't actually create a ReadableStream
+      return {
+        stream: {
+          getReader: () => ({
+            read: vi
+              .fn()
+              .mockResolvedValueOnce({
+                done: false,
+                value: { type: 'text-delta', textDelta: `Stream from ${id}` },
+              })
+              .mockResolvedValueOnce({
+                done: false,
+                value: {
+                  type: 'finish',
+                  finishReason: 'stop',
+                  usage: { promptTokens: 10, completionTokens: 20 },
+                },
+              })
+              .mockResolvedValueOnce({ done: true }),
+            releaseLock: vi.fn(),
+          }),
+        } as any,
+        rawCall: { rawPrompt: 'test', rawSettings: {} },
+      };
+    }),
+  };
+}
+
+describe('FallbackModel - Memory Safe Streaming Tests', () => {
+  it('should successfully stream from the first model', async () => {
+    const model1 = createMemorySafeMockModel('model1');
+    const model2 = createMemorySafeMockModel('model2');
+    const fallback = createFallback({ models: [model1, model2] });
+
+    const options: LanguageModelV1CallOptions = {
+      inputFormat: 'prompt',
+      prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+      mode: { type: 'regular' },
+    };
+
+    await fallback.doStream(options);
+
+    expect(model1.doStream).toHaveBeenCalledWith(options);
+    expect(model2.doStream).not.toHaveBeenCalled();
+  });
+
+  it('should fallback on retryable error', async () => {
+    const error = Object.assign(new Error('Rate limited'), { statusCode: 429 });
+    const model1 = createMemorySafeMockModel('model1', true, error);
+    const model2 = createMemorySafeMockModel('model2');
+    const fallback = createFallback({ models: [model1, model2] });
+
+    const options: LanguageModelV1CallOptions = {
+      inputFormat: 'prompt',
+      prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+      mode: { type: 'regular' },
+    };
+
+    await fallback.doStream(options);
+
+    expect(model1.doStream).toHaveBeenCalled();
+    expect(model2.doStream).toHaveBeenCalled();
+  });
+
+  it('should call onError callback', async () => {
+    const error = Object.assign(new Error('Server error'), { statusCode: 500 });
+    const model1 = createMemorySafeMockModel('model1', true, error);
+    const model2 = createMemorySafeMockModel('model2');
+    const onError = vi.fn();
+
+    const fallback = createFallback({
+      models: [model1, model2],
+      onError,
+    });
+
+    const options: LanguageModelV1CallOptions = {
+      inputFormat: 'prompt',
+      prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+      mode: { type: 'regular' },
+    };
+
+    await fallback.doStream(options);
+
+    expect(onError).toHaveBeenCalledWith(error, 'model1');
+  });
+
+  it('should throw non-retryable errors', async () => {
+    const error = new Error('Invalid API key');
+    const model1 = createMemorySafeMockModel('model1', true, error);
+    const model2 = createMemorySafeMockModel('model2');
+
+    const fallback = createFallback({ models: [model1, model2] });
+
+    const options: LanguageModelV1CallOptions = {
+      inputFormat: 'prompt',
+      prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+      mode: { type: 'regular' },
+    };
+
+    await expect(fallback.doStream(options)).rejects.toThrow('Invalid API key');
+    expect(model2.doStream).not.toHaveBeenCalled();
+  });
+});

packages/ai/src/utils/models/ai-fallback-streaming.test.ts

@@ -0,0 +1,308 @@
+import type {
+  LanguageModelV1,
+  LanguageModelV1CallOptions,
+  LanguageModelV1FinishReason,
+  LanguageModelV1StreamPart,
+} from '@ai-sdk/provider';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createFallback } from './ai-fallback';
+
+// Mock model factory - using synchronous operations to avoid memory issues
+function createMockModel(id: string, shouldFail = false, failureError?: Error): LanguageModelV1 {
+  const mockModel: LanguageModelV1 = {
+    specificationVersion: 'v1' as const,
+    modelId: id,
+    provider: `provider-${id}`,
+    defaultObjectGenerationMode: undefined,
+
+    doGenerate: vi.fn().mockImplementation(async () => {
+      if (shouldFail) {
+        throw failureError || new Error(`Model ${id} failed`);
+      }
+      return {
+        text: `Response from ${id}`,
+        finishReason: 'stop' as LanguageModelV1FinishReason,
+        usage: { promptTokens: 10, completionTokens: 20 },
+        rawCall: { rawPrompt: 'test', rawSettings: {} },
+      };
+    }),
+
+    doStream: vi.fn().mockImplementation(async () => {
+      if (shouldFail) {
+        throw failureError || new Error(`Model ${id} failed`);
+      }
+
+      const chunks: LanguageModelV1StreamPart[] = [
+        { type: 'text-delta', textDelta: `Stream from ${id}` },
+        { type: 'finish', finishReason: 'stop', usage: { promptTokens: 10, completionTokens: 20 } },
+      ];
+
+      const stream = new ReadableStream<LanguageModelV1StreamPart>({
+        start(controller) {
+          // Enqueue all chunks synchronously to avoid async complexity
+          chunks.forEach((chunk) => controller.enqueue(chunk));
+          controller.close();
+        },
+      });
+
+      return {
+        stream,
+        rawCall: { rawPrompt: 'test', rawSettings: {} },
+      };
+    }),
+  };
+
+  return mockModel;
+}
+
+// Helper to create a failing stream that errors mid-stream
+function createFailingStreamModel(id: string, errorAfterChunks = 1): LanguageModelV1 {
+  const mockModel: LanguageModelV1 = {
+    specificationVersion: 'v1' as const,
+    modelId: id,
+    provider: `provider-${id}`,
+    defaultObjectGenerationMode: undefined,
+
+    doGenerate: vi.fn(),
+
+    doStream: vi.fn().mockImplementation(async () => {
+      const chunks: LanguageModelV1StreamPart[] = [
+        { type: 'text-delta', textDelta: `Partial stream from ${id}` },
+        { type: 'text-delta', textDelta: ' more text' },
+        { type: 'finish', finishReason: 'stop', usage: { promptTokens: 10, completionTokens: 20 } },
+      ];
+
+      const stream = new ReadableStream<LanguageModelV1StreamPart>({
+        start(controller) {
+          let chunkCount = 0;
+          // Enqueue chunks up to the error point synchronously
+          for (const chunk of chunks) {
+            if (chunkCount >= errorAfterChunks) {
+              // Use setTimeout to error asynchronously after chunks are enqueued
+              setTimeout(() => controller.error(new Error(`Stream error in ${id}`)), 0);
+              return;
+            }
+            controller.enqueue(chunk);
+            chunkCount++;
+          }
+          controller.close();
+        },
+      });
+
+      return {
+        stream,
+        rawCall: { rawPrompt: 'test', rawSettings: {} },
+      };
+    }),
+  };
+
+  return mockModel;
+}
+
+// NOTE: These streaming tests are temporarily disabled due to memory issues
+// with ReadableStream in the test environment. See ai-fallback-memory-safe.test.ts
+// for alternative streaming tests that avoid memory issues.
+describe.skip('FallbackModel - Streaming', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('doStream', () => {
+    it('should successfully stream from the first model', async () => {
+      const model1 = createMockModel('model1');
+      const model2 = createMockModel('model2');
+      const fallback = createFallback({ models: [model1, model2] });
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      const result = await fallback.doStream(options);
+      const reader = result.stream.getReader();
+      const chunks: LanguageModelV1StreamPart[] = [];
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(value);
+      }
+
+      expect(model1.doStream).toHaveBeenCalledWith(options);
+      expect(model2.doStream).not.toHaveBeenCalled();
+      expect(chunks).toHaveLength(2);
+      expect(chunks[0]).toEqual({ type: 'text-delta', textDelta: 'Stream from model1' });
+    });
+
+    describe('streaming error handling', () => {
+      it('should fallback if stream fails before any output', async () => {
+        const model1 = createFailingStreamModel('model1', 0); // Fails immediately
+        const model2 = createMockModel('model2');
+        const fallback = createFallback({ models: [model1, model2] });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doStream(options);
+        const reader = result.stream.getReader();
+        const chunks: LanguageModelV1StreamPart[] = [];
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(value);
+        }
+
+        expect(chunks).toHaveLength(2);
+        expect(chunks[0]).toEqual({ type: 'text-delta', textDelta: 'Stream from model2' });
+      });
+
+      it('should not fallback if stream fails after output (default behavior)', async () => {
+        const model1 = createFailingStreamModel('model1', 1); // Fails after first chunk
+        const model2 = createMockModel('model2');
+        const fallback = createFallback({ models: [model1, model2] });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doStream(options);
+        const reader = result.stream.getReader();
+        const chunks: LanguageModelV1StreamPart[] = [];
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            chunks.push(value);
+          }
+        } catch (error) {
+          expect(error).toMatchObject({ message: 'Stream error in model1' });
+        }
+
+        expect(chunks).toHaveLength(1);
+        expect(chunks[0]).toEqual({ type: 'text-delta', textDelta: 'Partial stream from model1' });
+        expect(model2.doStream).not.toHaveBeenCalled();
+      });
+
+      it('should fallback even after output if retryAfterOutput is true', async () => {
+        const model1 = createFailingStreamModel('model1', 1); // Fails after first chunk
+        const model2 = createMockModel('model2');
+        const fallback = createFallback({
+          models: [model1, model2],
+          retryAfterOutput: true,
+        });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doStream(options);
+        const reader = result.stream.getReader();
+        const chunks: LanguageModelV1StreamPart[] = [];
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(value);
+        }
+
+        // Should have chunks from both models
+        expect(chunks).toHaveLength(3); // 1 from model1, 2 from model2
+        expect(chunks[0]).toEqual({ type: 'text-delta', textDelta: 'Partial stream from model1' });
+        expect(chunks[1]).toEqual({ type: 'text-delta', textDelta: 'Stream from model2' });
+        expect(model2.doStream).toHaveBeenCalled();
+      });
+
+      it('should handle onError callback in streaming', async () => {
+        const model1 = createFailingStreamModel('model1', 0);
+        const model2 = createMockModel('model2');
+        const onError = vi.fn();
+        const fallback = createFallback({
+          models: [model1, model2],
+          onError,
+        });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doStream(options);
+        const reader = result.stream.getReader();
+        const chunks: LanguageModelV1StreamPart[] = [];
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(value);
+        }
+
+        expect(onError).toHaveBeenCalledWith(
+          expect.objectContaining({ message: 'Stream error in model1' }),
+          'model1'
+        );
+      });
+
+      it('should handle errors in fallback stream', async () => {
+        const model1 = createFailingStreamModel('model1', 0);
+        const model2 = createFailingStreamModel('model2', 0);
+        const fallback = createFallback({ models: [model1, model2] });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doStream(options);
+        const reader = result.stream.getReader();
+
+        await expect(async () => {
+          while (true) {
+            const { done } = await reader.read();
+            if (done) break;
+          }
+        }).rejects.toThrow('Stream error in model2');
+      });
+    });
+
+    describe('stream retry with status codes', () => {
+      it('should retry streaming on retryable status code', async () => {
+        const error = Object.assign(new Error('Rate limited'), { statusCode: 429 });
+        const model1 = createMockModel('model1', true, error);
+        const model2 = createMockModel('model2');
+        const fallback = createFallback({ models: [model1, model2] });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doStream(options);
+        const reader = result.stream.getReader();
+        const chunks: LanguageModelV1StreamPart[] = [];
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(value);
+        }
+
+        expect(model1.doStream).toHaveBeenCalled();
+        expect(model2.doStream).toHaveBeenCalled();
+        expect(chunks[0]).toEqual({ type: 'text-delta', textDelta: 'Stream from model2' });
+      });
+    });
+  });
+});

packages/ai/src/utils/models/ai-fallback.test.ts

@@ -0,0 +1,480 @@
+import type {
+  LanguageModelV1,
+  LanguageModelV1CallOptions,
+  LanguageModelV1FinishReason,
+  LanguageModelV1StreamPart,
+} from '@ai-sdk/provider';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { FallbackModel, createFallback } from './ai-fallback';
+
+// Mock model factory
+function createMockModel(id: string, shouldFail = false, failureError?: Error): LanguageModelV1 {
+  const mockModel: LanguageModelV1 = {
+    specificationVersion: 'v1' as const,
+    modelId: id,
+    provider: `provider-${id}`,
+    defaultObjectGenerationMode: undefined,
+
+    doGenerate: vi.fn().mockImplementation(async () => {
+      if (shouldFail) {
+        throw failureError || new Error(`Model ${id} failed`);
+      }
+      return {
+        text: `Response from ${id}`,
+        finishReason: 'stop' as LanguageModelV1FinishReason,
+        usage: { promptTokens: 10, completionTokens: 20 },
+        rawCall: { rawPrompt: 'test', rawSettings: {} },
+      };
+    }),
+
+    doStream: vi.fn().mockImplementation(async () => {
+      if (shouldFail) {
+        throw failureError || new Error(`Model ${id} failed`);
+      }
+
+      const chunks: LanguageModelV1StreamPart[] = [
+        { type: 'text-delta', textDelta: `Stream from ${id}` },
+        { type: 'finish', finishReason: 'stop', usage: { promptTokens: 10, completionTokens: 20 } },
+      ];
+
+      const stream = new ReadableStream<LanguageModelV1StreamPart>({
+        async start(controller) {
+          for (const chunk of chunks) {
+            controller.enqueue(chunk);
+          }
+          controller.close();
+        },
+      });
+
+      return {
+        stream,
+        rawCall: { rawPrompt: 'test', rawSettings: {} },
+      };
+    }),
+  };
+
+  return mockModel;
+}
+
+// Streaming helper moved to ai-fallback-streaming.test.ts to reduce memory usage
+
+describe('FallbackModel', () => {
+  // Disable fake timers to prevent memory issues with ReadableStreams
+  // Tests that need time manipulation will use manual date mocking
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should initialize with provided settings', () => {
+      const models = [createMockModel('model1'), createMockModel('model2')];
+      const fallback = createFallback({ models });
+
+      expect(fallback.modelId).toBe('model1');
+      expect(fallback.provider).toBe('provider-model1');
+    });
+
+    it('should throw error if no models provided', () => {
+      expect(() => createFallback({ models: [] })).toThrow('No models available in settings');
+    });
+
+    it('should use custom modelResetInterval', () => {
+      const models = [createMockModel('model1')];
+      const fallback = new FallbackModel({ models, modelResetInterval: 120000 });
+
+      expect(fallback).toBeDefined();
+    });
+
+    it('should use custom retryAfterOutput setting', () => {
+      const models = [createMockModel('model1')];
+      const fallback = new FallbackModel({ models, retryAfterOutput: true });
+
+      expect(fallback.retryAfterOutput).toBe(true);
+    });
+  });
+
+  describe('doGenerate', () => {
+    it('should successfully call the first model', async () => {
+      const model1 = createMockModel('model1');
+      const model2 = createMockModel('model2');
+      const fallback = createFallback({ models: [model1, model2] });
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      const result = await fallback.doGenerate(options);
+
+      expect(model1.doGenerate).toHaveBeenCalledWith(options);
+      expect(model2.doGenerate).not.toHaveBeenCalled();
+      expect(result.text).toEqual('Response from model1');
+    });
+
+    it('should not retry on non-retryable error', async () => {
+      const nonRetryableError = new Error('Invalid API key');
+      const model1 = createMockModel('model1', true, nonRetryableError);
+      const model2 = createMockModel('model2');
+      const fallback = createFallback({
+        models: [model1, model2],
+        shouldRetryThisError: () => false,
+      });
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      await expect(fallback.doGenerate(options)).rejects.toThrow('Invalid API key');
+      expect(model1.doGenerate).toHaveBeenCalledWith(options);
+      expect(model2.doGenerate).not.toHaveBeenCalled();
+    });
+
+    describe('retryable status codes', () => {
+      // Testing a subset of status codes to reduce memory usage
+      const retryableStatusCodes = [429, 500, 503];
+
+      retryableStatusCodes.forEach((statusCode) => {
+        it(`should retry on ${statusCode} status code error`, async () => {
+          const error = Object.assign(new Error(`Error with status ${statusCode}`), { statusCode });
+          const model1 = createMockModel('model1', true, error);
+          const model2 = createMockModel('model2');
+          const fallback = createFallback({ models: [model1, model2] });
+
+          const options: LanguageModelV1CallOptions = {
+            inputFormat: 'prompt',
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+            mode: { type: 'regular' },
+          };
+
+          const result = await fallback.doGenerate(options);
+
+          expect(model1.doGenerate).toHaveBeenCalledWith(options);
+          expect(model2.doGenerate).toHaveBeenCalledWith(options);
+          expect(result.text).toEqual('Response from model2');
+        });
+      });
+
+      it('should retry on any status code above 500', async () => {
+        const error = Object.assign(new Error('Server error'), { statusCode: 507 });
+        const model1 = createMockModel('model1', true, error);
+        const model2 = createMockModel('model2');
+        const fallback = createFallback({ models: [model1, model2] });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doGenerate(options);
+
+        expect(model1.doGenerate).toHaveBeenCalled();
+        expect(model2.doGenerate).toHaveBeenCalled();
+        expect(result.text).toEqual('Response from model2');
+      });
+    });
+
+    describe('retryable error messages', () => {
+      // Testing a subset of messages to reduce memory usage
+      const retryableMessages = ['overloaded', 'rate_limit', 'capacity', '429', '503'];
+
+      retryableMessages.forEach((message) => {
+        it(`should retry on error message containing "${message}"`, async () => {
+          const error = new Error(`System is ${message} right now`);
+          const model1 = createMockModel('model1', true, error);
+          const model2 = createMockModel('model2');
+          const fallback = createFallback({ models: [model1, model2] });
+
+          const options: LanguageModelV1CallOptions = {
+            inputFormat: 'prompt',
+            prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+            mode: { type: 'regular' },
+          };
+
+          const result = await fallback.doGenerate(options);
+
+          expect(model1.doGenerate).toHaveBeenCalled();
+          expect(model2.doGenerate).toHaveBeenCalled();
+          expect(result.text).toEqual('Response from model2');
+        });
+      });
+
+      it('should retry on error object with retryable message in JSON', async () => {
+        const errorObj = { code: 'CAPACITY', details: 'System at capacity' };
+        const model1 = createMockModel('model1', true, errorObj as any);
+        const model2 = createMockModel('model2');
+        const fallback = createFallback({ models: [model1, model2] });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doGenerate(options);
+
+        expect(model1.doGenerate).toHaveBeenCalled();
+        expect(model2.doGenerate).toHaveBeenCalled();
+        expect(result.text).toEqual('Response from model2');
+      });
+    });
+
+    describe('multiple model fallback', () => {
+      it('should try all models before failing', async () => {
+        const error = new Error('Service overloaded');
+        const model1 = createMockModel('model1', true, error);
+        const model2 = createMockModel('model2', true, error);
+        const model3 = createMockModel('model3', true, error);
+        const fallback = createFallback({ models: [model1, model2, model3] });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        await expect(fallback.doGenerate(options)).rejects.toThrow('Service overloaded');
+        expect(model1.doGenerate).toHaveBeenCalled();
+        expect(model2.doGenerate).toHaveBeenCalled();
+        expect(model3.doGenerate).toHaveBeenCalled();
+      });
+
+      it('should succeed with third model after two failures', async () => {
+        const error = new Error('rate_limit exceeded');
+        const model1 = createMockModel('model1', true, error);
+        const model2 = createMockModel('model2', true, error);
+        const model3 = createMockModel('model3');
+        const fallback = createFallback({ models: [model1, model2, model3] });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        const result = await fallback.doGenerate(options);
+
+        expect(model1.doGenerate).toHaveBeenCalled();
+        expect(model2.doGenerate).toHaveBeenCalled();
+        expect(model3.doGenerate).toHaveBeenCalled();
+        expect(result.text).toEqual('Response from model3');
+      });
+    });
+
+    describe('onError callback', () => {
+      it('should call onError for each retry', async () => {
+        const error = new Error('Server overloaded');
+        const model1 = createMockModel('model1', true, error);
+        const model2 = createMockModel('model2');
+        const onError = vi.fn();
+        const fallback = createFallback({
+          models: [model1, model2],
+          onError,
+        });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        await fallback.doGenerate(options);
+
+        expect(onError).toHaveBeenCalledWith(error, 'model1');
+        expect(onError).toHaveBeenCalledTimes(1);
+      });
+
+      it('should handle async onError callback', async () => {
+        const error = new Error('Service unavailable');
+        const model1 = createMockModel('model1', true, error);
+        const model2 = createMockModel('model2');
+        const onError = vi.fn().mockImplementation(async () => {
+          await Promise.resolve();
+        });
+        const fallback = createFallback({
+          models: [model1, model2],
+          onError,
+        });
+
+        const options: LanguageModelV1CallOptions = {
+          inputFormat: 'prompt',
+          prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+          mode: { type: 'regular' },
+        };
+
+        await fallback.doGenerate(options);
+
+        expect(onError).toHaveBeenCalledWith(error, 'model1');
+      });
+    });
+  });
+
+  // Streaming tests moved to ai-fallback-streaming.test.ts to reduce memory usage
+
+  describe('model reset interval', () => {
+    it('should use default 3-minute interval if not specified', () => {
+      const models = [createMockModel('model1')];
+      const fallback = new FallbackModel({ models });
+
+      // Default should be 3 minutes (180000ms)
+      expect(fallback).toBeDefined();
+    });
+
+    // Other timer-based tests removed due to memory issues with fake timers
+  });
+
+  describe('edge cases', () => {
+    it('should handle model without provider gracefully', () => {
+      const model = createMockModel('model1');
+      (model as any).provider = undefined;
+      const fallback = createFallback({ models: [model] });
+
+      expect(fallback.provider).toBe(undefined);
+    });
+
+    it('should handle model without defaultObjectGenerationMode', () => {
+      const model = createMockModel('model1');
+      // Model already has defaultObjectGenerationMode as undefined by default
+      const fallback = createFallback({ models: [model] });
+
+      expect(fallback.defaultObjectGenerationMode).toBe(undefined);
+    });
+
+    it('should handle custom shouldRetryThisError function', async () => {
+      const customError = new Error('Custom error');
+      const model1 = createMockModel('model1', true, customError);
+      const model2 = createMockModel('model2');
+      const shouldRetryThisError = vi.fn().mockReturnValue(true);
+      const fallback = createFallback({
+        models: [model1, model2],
+        shouldRetryThisError,
+      });
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      await fallback.doGenerate(options);
+
+      expect(shouldRetryThisError).toHaveBeenCalledWith(customError);
+      expect(model2.doGenerate).toHaveBeenCalled();
+    });
+
+    it('should cycle through all models and wrap around', async () => {
+      const error = new Error('Server overloaded');
+      const model1 = createMockModel('model1'); // First model should succeed
+      const model2 = createMockModel('model2', true, error);
+      const model3 = createMockModel('model3', true, error);
+
+      const fallback = new FallbackModel({ models: [model1, model2, model3] });
+
+      // Start at model 3 (index 2)
+      fallback.currentModelIndex = 2;
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      const result = await fallback.doGenerate(options);
+
+      expect(model3.doGenerate).toHaveBeenCalled();
+      expect(model1.doGenerate).toHaveBeenCalled();
+      expect(result.text).toEqual('Response from model1');
+      expect(fallback.currentModelIndex).toBe(0);
+    });
+
+    it('should handle non-Error objects in catch', async () => {
+      const stringError = 'String error';
+      const model1 = createMockModel('model1');
+      model1.doGenerate = vi.fn().mockRejectedValue(stringError);
+      const model2 = createMockModel('model2');
+      const fallback = createFallback({ models: [model1, model2] });
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      await expect(fallback.doGenerate(options)).rejects.toBe(stringError);
+    });
+
+    it('should handle errors without message property', async () => {
+      const errorObj = { code: 'TIMEOUT', statusCode: 408 };
+      const model1 = createMockModel('model1');
+      model1.doGenerate = vi.fn().mockRejectedValue(errorObj);
+      const model2 = createMockModel('model2');
+      const fallback = createFallback({ models: [model1, model2] });
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      const result = await fallback.doGenerate(options);
+
+      expect(model1.doGenerate).toHaveBeenCalled();
+      expect(model2.doGenerate).toHaveBeenCalled();
+      expect(result.text).toEqual('Response from model2');
+    });
+
+    it('should handle null/undefined errors', async () => {
+      const model1 = createMockModel('model1');
+      model1.doGenerate = vi.fn().mockRejectedValue(null);
+      const model2 = createMockModel('model2');
+      const fallback = createFallback({ models: [model1, model2] });
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      await expect(fallback.doGenerate(options)).rejects.toBe(null);
+      expect(model2.doGenerate).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('no model available edge case', () => {
+    it('should throw error if current model becomes unavailable', async () => {
+      const models = [createMockModel('model1')];
+      const fallback = new FallbackModel({ models });
+
+      // Simulate model becoming unavailable
+      fallback.settings.models[0] = undefined as any;
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      await expect(fallback.doGenerate(options)).rejects.toThrow('No model available');
+    });
+
+    it('should throw error if current model becomes unavailable in stream', async () => {
+      const models = [createMockModel('model1')];
+      const fallback = new FallbackModel({ models });
+
+      // Simulate model becoming unavailable
+      fallback.settings.models[0] = undefined as any;
+
+      const options: LanguageModelV1CallOptions = {
+        inputFormat: 'prompt',
+        prompt: [{ role: 'user', content: [{ type: 'text', text: 'Test prompt' }] }],
+        mode: { type: 'regular' },
+      };
+
+      await expect(fallback.doStream(options)).rejects.toThrow('No model available');
+    });
+  });
+});

packages/ai/src/utils/models/ai-fallback.ts

@@ -0,0 +1,229 @@
+import type {
+  LanguageModelV1,
+  LanguageModelV1CallOptions,
+  LanguageModelV1CallWarning,
+  LanguageModelV1FinishReason,
+  LanguageModelV1FunctionToolCall,
+  LanguageModelV1StreamPart,
+} from '@ai-sdk/provider';
+
+interface Settings {
+  models: LanguageModelV1[];
+  retryAfterOutput?: boolean;
+  modelResetInterval?: number;
+  shouldRetryThisError?: (error: Error) => boolean;
+  onError?: (error: Error, modelId: string) => void | Promise<void>;
+}
+
+export function createFallback(settings: Settings): FallbackModel {
+  return new FallbackModel(settings);
+}
+
+const retryableStatusCodes = [
+  401, // wrong API key
+  403, // permission error, like cannot access model or from a non accessible region
+  408, // request timeout
+  409, // conflict
+  413, // payload too large
+  429, // too many requests/rate limits
+  500, // server error (and above)
+];
+// Common error messages/codes that indicate server overload or temporary issues
+const retryableErrors = [
+  'overloaded',
+  'service unavailable',
+  'bad gateway',
+  'too many requests',
+  'internal server error',
+  'gateway timeout',
+  'rate_limit',
+  'wrong-key',
+  'unexpected',
+  'capacity',
+  'timeout',
+  'server_error',
+  '429', // Too Many Requests
+  '500', // Internal Server Error
+  '502', // Bad Gateway
+  '503', // Service Unavailable
+  '504', // Gateway Timeout
+];
+
+function defaultShouldRetryThisError(error: unknown): boolean {
+  const statusCode = (error as { statusCode?: number })?.statusCode;
+
+  if (statusCode && (retryableStatusCodes.includes(statusCode) || statusCode > 500)) {
+    return true;
+  }
+
+  if (error && typeof error === 'object' && 'message' in error) {
+    const errorString = (error as Error).message.toLowerCase() || '';
+    return retryableErrors.some((errType) => errorString.includes(errType));
+  }
+  if (error && typeof error === 'object') {
+    const errorString = JSON.stringify(error).toLowerCase() || '';
+    return retryableErrors.some((errType) => errorString.includes(errType));
+  }
+  return false;
+}
+
+export class FallbackModel implements LanguageModelV1 {
+  readonly specificationVersion = 'v1' as const;
+
+  get modelId(): string {
+    const currentModel = this.settings.models[this.currentModelIndex];
+    return currentModel ? currentModel.modelId : 'fallback-model';
+  }
+
+  get provider(): string {
+    const currentModel = this.settings.models[this.currentModelIndex];
+    return currentModel ? currentModel.provider : 'fallback';
+  }
+
+  get defaultObjectGenerationMode(): 'json' | 'tool' | undefined {
+    const currentModel = this.settings.models[this.currentModelIndex];
+    return currentModel?.defaultObjectGenerationMode;
+  }
+
+  readonly settings: Settings;
+  currentModelIndex = 0;
+  private lastModelReset: number = Date.now();
+  private readonly modelResetInterval: number;
+  retryAfterOutput: boolean;
+
+  constructor(settings: Settings) {
+    this.settings = settings;
+    this.modelResetInterval = settings.modelResetInterval ?? 3 * 60 * 1000; // Default 3 minutes in ms
+    this.retryAfterOutput = settings.retryAfterOutput ?? false;
+
+    if (!this.settings.models[this.currentModelIndex]) {
+      throw new Error('No models available in settings');
+    }
+  }
+
+  private checkAndResetModel() {
+    const now = Date.now();
+    if (now - this.lastModelReset >= this.modelResetInterval && this.currentModelIndex !== 0) {
+      this.currentModelIndex = 0;
+      this.lastModelReset = now;
+    }
+  }
+
+  private switchToNextModel() {
+    this.currentModelIndex = (this.currentModelIndex + 1) % this.settings.models.length;
+  }
+
+  private async retry<T>(fn: () => PromiseLike<T>): Promise<T> {
+    let lastError: Error | undefined;
+    let attempts = 0;
+    const maxAttempts = this.settings.models.length;
+
+    while (attempts < maxAttempts) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error as Error;
+        attempts++;
+
+        // Only retry if it's a server/capacity error
+        const shouldRetry = this.settings.shouldRetryThisError || defaultShouldRetryThisError;
+        if (!shouldRetry(lastError)) {
+          throw lastError;
+        }
+
+        if (this.settings.onError) {
+          await this.settings.onError(lastError, this.modelId);
+        }
+
+        // If we've tried all models, throw the last error
+        if (attempts >= maxAttempts) {
+          throw lastError;
+        }
+
+        this.switchToNextModel();
+      }
+    }
+
+    // This should never be reached
+    throw lastError || new Error('Unexpected retry state');
+  }
+
+  doGenerate(
+    options: LanguageModelV1CallOptions
+  ): PromiseLike<Awaited<ReturnType<LanguageModelV1['doGenerate']>>> {
+    this.checkAndResetModel();
+    return this.retry(() => {
+      const currentModel = this.settings.models[this.currentModelIndex];
+      if (!currentModel) {
+        throw new Error('No model available');
+      }
+      return currentModel.doGenerate(options);
+    });
+  }
+
+  doStream(
+    options: LanguageModelV1CallOptions
+  ): PromiseLike<Awaited<ReturnType<LanguageModelV1['doStream']>>> {
+    this.checkAndResetModel();
+    const self = this;
+    return this.retry(async () => {
+      const currentModel = self.settings.models[self.currentModelIndex];
+      if (!currentModel) {
+        throw new Error('No model available');
+      }
+      const result = await currentModel.doStream(options);
+
+      let hasStreamedAny = false;
+      let streamRetryAttempts = 0;
+      const maxStreamRetries = self.settings.models.length - 1; // -1 because we already tried one
+
+      // Wrap the stream to handle errors and switch providers if needed
+      const wrappedStream = new ReadableStream<LanguageModelV1StreamPart>({
+        async start(controller) {
+          try {
+            const reader = result.stream.getReader();
+
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) break;
+              controller.enqueue(value);
+              hasStreamedAny = true;
+            }
+            controller.close();
+          } catch (error) {
+            if (self.settings.onError) {
+              await self.settings.onError(error as Error, self.modelId);
+            }
+            if (
+              (!hasStreamedAny || self.retryAfterOutput) &&
+              streamRetryAttempts < maxStreamRetries
+            ) {
+              // If nothing was streamed yet and we haven't exhausted retries, switch models and retry
+              self.switchToNextModel();
+              streamRetryAttempts++;
+              try {
+                const nextResult = await self.doStream(options);
+                const nextReader = nextResult.stream.getReader();
+                while (true) {
+                  const { done, value } = await nextReader.read();
+                  if (done) break;
+                  controller.enqueue(value);
+                }
+                controller.close();
+              } catch (nextError) {
+                controller.error(nextError);
+              }
+              return;
+            }
+            controller.error(error);
+          }
+        },
+      });
+
+      return {
+        ...result,
+        stream: wrappedStream,
+      };
+    });
+  }
+}

packages/ai/src/utils/models/haiku-3-5.ts

@@ -0,0 +1,74 @@
+import type { LanguageModelV1 } from '@ai-sdk/provider';
+import { createFallback } from './ai-fallback';
+import { anthropicModel } from './providers/anthropic';
+import { vertexModel } from './providers/vertex';
+
+// Lazy initialization to allow mocking in tests
+let _haiku35Instance: ReturnType<typeof createFallback> | null = null;
+
+function initializeHaiku35() {
+  if (_haiku35Instance) {
+    return _haiku35Instance;
+  }
+
+  // Build models array based on available credentials
+  const models: LanguageModelV1[] = [];
+
+  // Only include Anthropic if API key is available
+  if (process.env.ANTHROPIC_API_KEY) {
+    try {
+      models.push(anthropicModel('claude-3-5-haiku-20241022'));
+      console.info('Haiku35: Anthropic model added to fallback chain');
+    } catch (error) {
+      console.warn('Haiku35: Failed to initialize Anthropic model:', error);
+    }
+  }
+
+  // Only include Vertex if credentials are available
+  if (process.env.VERTEX_CLIENT_EMAIL && process.env.VERTEX_PRIVATE_KEY) {
+    try {
+      models.push(vertexModel('claude-3-5-haiku@20241022'));
+      console.info('Haiku35: Vertex AI model added to fallback chain');
+    } catch (error) {
+      console.warn('Haiku35: Failed to initialize Vertex AI model:', error);
+    }
+  }
+
+  // Ensure we have at least one model
+  if (models.length === 0) {
+    throw new Error(
+      'No AI models available. Please set either Vertex AI (VERTEX_CLIENT_EMAIL and VERTEX_PRIVATE_KEY) or Anthropic (ANTHROPIC_API_KEY) credentials.'
+    );
+  }
+
+  console.info(`Haiku35: Initialized with ${models.length} model(s) in fallback chain`);
+
+  _haiku35Instance = createFallback({
+    models,
+    modelResetInterval: 60000,
+    retryAfterOutput: true,
+    onError: (err) => console.error(`FALLBACK.  Here is the error: ${err}`),
+  });
+
+  return _haiku35Instance;
+}
+
+// Export a proxy that initializes on first use
+export const Haiku35 = new Proxy({} as ReturnType<typeof createFallback>, {
+  get(_target, prop, receiver) {
+    const instance = initializeHaiku35();
+    return Reflect.get(instance, prop, receiver);
+  },
+  has(_target, prop) {
+    const instance = initializeHaiku35();
+    return Reflect.has(instance, prop);
+  },
+  ownKeys(_target) {
+    const instance = initializeHaiku35();
+    return Reflect.ownKeys(instance);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    const instance = initializeHaiku35();
+    return Reflect.getOwnPropertyDescriptor(instance, prop);
+  },
+});

packages/ai/src/utils/models/providers/anthropic.ts

@@ -0,0 +1,13 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { wrapAISDKModel } from 'braintrust';
+
+export const anthropicModel = (modelId: string) => {
+  const anthropic = createAnthropic({
+    headers: {
+      'anthropic-beta': 'fine-grained-tool-streaming-2025-05-14',
+    },
+  });
+
+  // Wrap the model with Braintrust tracing and return it
+  return wrapAISDKModel(anthropic(modelId));
+};

packages/ai/src/utils/models/providers/vertex.ts

@@ -0,0 +1,52 @@
+import { createVertexAnthropic } from '@ai-sdk/google-vertex/anthropic';
+import type { LanguageModelV1 } from '@ai-sdk/provider';
+import { wrapAISDKModel } from 'braintrust';
+
+export const vertexModel = (modelId: string): LanguageModelV1 => {
+  // Create a proxy that validates credentials on first use
+  let actualModel: LanguageModelV1 | null = null;
+
+  const getActualModel = () => {
+    if (!actualModel) {
+      const clientEmail = process.env.VERTEX_CLIENT_EMAIL;
+      let privateKey = process.env.VERTEX_PRIVATE_KEY;
+      const project = process.env.VERTEX_PROJECT;
+
+      if (!clientEmail || !privateKey || !project) {
+        throw new Error(
+          'Missing required environment variables: VERTEX_CLIENT_EMAIL or VERTEX_PRIVATE_KEY'
+        );
+      }
+
+      // Handle escaped newlines in private key
+      privateKey = privateKey.replace(/\\n/g, '\n');
+
+      const vertex = createVertexAnthropic({
+        baseURL: `https://aiplatform.googleapis.com/v1/projects/${project}/locations/global/publishers/anthropic/models`,
+        location: 'global',
+        project,
+        googleAuthOptions: {
+          credentials: {
+            client_email: clientEmail,
+            private_key: privateKey,
+          },
+        },
+        headers: {
+          'anthropic-beta': 'fine-grained-tool-streaming-2025-05-14',
+        },
+      });
+
+      // Wrap the model with Braintrust tracing
+      actualModel = wrapAISDKModel(vertex(modelId));
+    }
+    return actualModel;
+  };
+
+  // Create a proxy that delegates all calls to the actual model
+  return new Proxy({} as LanguageModelV1, {
+    get(_target, prop) {
+      const model = getActualModel();
+      return Reflect.get(model, prop);
+    },
+  });
+};

packages/ai/src/utils/models/sonnet-4.ts

@@ -0,0 +1,74 @@
+import type { LanguageModelV1 } from '@ai-sdk/provider';
+import { createFallback } from './ai-fallback';
+import { anthropicModel } from './providers/anthropic';
+import { vertexModel } from './providers/vertex';
+
+// Lazy initialization to allow mocking in tests
+let _sonnet4Instance: ReturnType<typeof createFallback> | null = null;
+
+function initializeSonnet4() {
+  if (_sonnet4Instance) {
+    return _sonnet4Instance;
+  }
+
+  // Build models array based on available credentials
+  const models: LanguageModelV1[] = [];
+
+  // Only include Anthropic if API key is available
+  if (process.env.ANTHROPIC_API_KEY) {
+    try {
+      models.push(anthropicModel('claude-4-sonnet-20250514'));
+      console.info('Sonnet4: Anthropic model added to fallback chain');
+    } catch (error) {
+      console.warn('Sonnet4: Failed to initialize Anthropic model:', error);
+    }
+  }
+
+  // Only include Vertex if credentials are available
+  if (process.env.VERTEX_CLIENT_EMAIL && process.env.VERTEX_PRIVATE_KEY) {
+    try {
+      models.push(vertexModel('claude-sonnet-4@20250514'));
+      console.info('Sonnet4: Vertex AI model added to fallback chain');
+    } catch (error) {
+      console.warn('Sonnet4: Failed to initialize Vertex AI model:', error);
+    }
+  }
+
+  // Ensure we have at least one model
+  if (models.length === 0) {
+    throw new Error(
+      'No AI models available. Please set either Vertex AI (VERTEX_CLIENT_EMAIL and VERTEX_PRIVATE_KEY) or Anthropic (ANTHROPIC_API_KEY) credentials.'
+    );
+  }
+
+  console.info(`Sonnet4: Initialized with ${models.length} model(s) in fallback chain`);
+
+  _sonnet4Instance = createFallback({
+    models,
+    modelResetInterval: 60000,
+    retryAfterOutput: true,
+    onError: (err) => console.error(`FALLBACK.  Here is the error: ${err}`),
+  });
+
+  return _sonnet4Instance;
+}
+
+// Export a proxy that initializes on first use
+export const Sonnet4 = new Proxy({} as ReturnType<typeof createFallback>, {
+  get(_target, prop, receiver) {
+    const instance = initializeSonnet4();
+    return Reflect.get(instance, prop, receiver);
+  },
+  has(_target, prop) {
+    const instance = initializeSonnet4();
+    return Reflect.has(instance, prop);
+  },
+  ownKeys(_target) {
+    const instance = initializeSonnet4();
+    return Reflect.ownKeys(instance);
+  },
+  getOwnPropertyDescriptor(_target, prop) {
+    const instance = initializeSonnet4();
+    return Reflect.getOwnPropertyDescriptor(instance, prop);
+  },
+});

packages/ai/vitest.config.ts

@@ -1,3 +1,26 @@
 import { baseConfig } from '@buster/vitest-config';
+import { defineConfig } from 'vitest/config';
 
-export default baseConfig;
+export default defineConfig(async (env) => {
+  const base = await baseConfig(env);
+
+  return {
+    ...base,
+    test: {
+      ...base.test,
+      // Run tests sequentially for streaming tests to avoid memory issues
+      pool: 'forks',
+      poolOptions: {
+        forks: {
+          maxForks: 1,
+          minForks: 1,
+          singleFork: true,
+        },
+      },
+      // Increase timeout for streaming tests
+      testTimeout: 30000,
+      // Isolate tests that use ReadableStreams
+      isolate: true,
+    },
+  };
+});

pnpm-lock.yaml

@@ -675,6 +675,9 @@ importers:
       '@ai-sdk/anthropic':
         specifier: ^1.2.12
         version: 1.2.12(zod@3.25.1)
+      '@ai-sdk/google-vertex':
+        specifier: ^2.2.27
+        version: 2.2.27(zod@3.25.1)
       '@ai-sdk/provider':
         specifier: ^1.1.3
         version: 1.1.3
@@ -1003,6 +1006,18 @@ packages:
     peerDependencies:
       zod: ^3.0.0
 
+  '@ai-sdk/google-vertex@2.2.27':
+    resolution: {integrity: sha512-iDGX/2yrU4OOL1p/ENpfl3MWxuqp9/bE22Z8Ip4DtLCUx6ismUNtrKO357igM1/3jrM6t9C6egCPniHqBsHOJA==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.0.0
+
+  '@ai-sdk/google@1.2.22':
+    resolution: {integrity: sha512-Ppxu3DIieF1G9pyQ5O1Z646GYR0gkC57YdBqXJ82qvCdhEhZHu0TWhmnOoeIWe2olSbuDeoOY+MfJrW8dzS3Hw==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      zod: ^3.0.0
+
   '@ai-sdk/openai@1.3.23':
     resolution: {integrity: sha512-86U7rFp8yacUAOE/Jz8WbGcwMCqWvjK33wk5DXkfnAOEn3mx2r7tNSJdjukQFZbAK97VMXGPPHxF+aEARDXRXQ==}
     engines: {node: '>=18'}
@@ -11559,6 +11574,24 @@ snapshots:
       '@ai-sdk/provider-utils': 2.2.8(zod@3.25.1)
       zod: 3.25.1
 
+  '@ai-sdk/google-vertex@2.2.27(zod@3.25.1)':
+    dependencies:
+      '@ai-sdk/anthropic': 1.2.12(zod@3.25.1)
+      '@ai-sdk/google': 1.2.22(zod@3.25.1)
+      '@ai-sdk/provider': 1.1.3
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.25.1)
+      google-auth-library: 9.15.1
+      zod: 3.25.1
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+
+  '@ai-sdk/google@1.2.22(zod@3.25.1)':
+    dependencies:
+      '@ai-sdk/provider': 1.1.3
+      '@ai-sdk/provider-utils': 2.2.8(zod@3.25.1)
+      zod: 3.25.1
+
   '@ai-sdk/openai@1.3.23(zod@3.25.1)':
     dependencies:
       '@ai-sdk/provider': 1.1.3