ai 6.0.141 → 6.0.142

package/dist/internal/index.js

@@ -153,7 +153,7 @@ var import_provider_utils2 = require("@ai-sdk/provider-utils");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "6.0.141" : "0.0.0-test";
+var VERSION = true ? "6.0.142" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/dist/internal/index.mjs

@@ -133,7 +133,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "6.0.141" : "0.0.0-test";
+var VERSION = true ? "6.0.142" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

package/docs/03-agents/01-overview.mdx

@@ -20,7 +20,7 @@ These components work together:
 The ToolLoopAgent class handles these three components. Here's an agent that uses multiple tools in a loop to accomplish a task:
 
 ```ts
-import { ToolLoopAgent, stepCountIs, tool } from 'ai';
+import { ToolLoopAgent, tool } from 'ai';
 __PROVIDER_IMPORT__;
 import { z } from 'zod';
 
@@ -48,8 +48,6 @@ const weatherAgent = new ToolLoopAgent({
       },
     }),
   },
-  // Agent's default behavior is to stop after a maximum of 20 steps
-  // stopWhen: stepCountIs(20),
 });
 
 const result = await weatherAgent.generate({

package/docs/03-agents/02-building-agents.mdx

@@ -81,7 +81,7 @@ const codeAgent = new ToolLoopAgent({
 
 By default, agents run for 20 steps (`stopWhen: stepCountIs(20)`). In each step, the model either generates text or calls a tool. If it generates text, the agent completes. If it calls a tool, the AI SDK executes that tool.
 
-To let agents call multiple tools in sequence, configure `stopWhen` to allow more steps. After each tool execution, the agent triggers a new generation where the model can call another tool or generate text:
+You can configure `stopWhen` differently to allow more steps. After each tool execution, the agent triggers a new generation where the model can call another tool or generate text:
 
 ```ts
 import { ToolLoopAgent, stepCountIs } from 'ai';
@@ -89,7 +89,7 @@ __PROVIDER_IMPORT__;
 
 const agent = new ToolLoopAgent({
   model: __MODEL__,
-  stopWhen: stepCountIs(20), // Allow up to 20 steps
+  stopWhen: stepCountIs(50), // Increase default from 20 to 50.
 });
 ```
 
@@ -160,7 +160,7 @@ const agent = new ToolLoopAgent({
 Define structured output schemas:
 
 ```ts
-import { ToolLoopAgent, Output, stepCountIs } from 'ai';
+import { ToolLoopAgent, Output } from 'ai';
 __PROVIDER_IMPORT__;
 import { z } from 'zod';
 
@@ -173,7 +173,6 @@ const analysisAgent = new ToolLoopAgent({
       keyPoints: z.array(z.string()),
     }),
   }),
-  stopWhen: stepCountIs(10),
 });
 
 const { output } = await analysisAgent.generate({

package/docs/03-agents/04-loop-control.mdx

@@ -16,7 +16,7 @@ The AI SDK provides built-in loop control through two parameters: `stopWhen` for
 
 ## Stop Conditions
 
-The `stopWhen` parameter controls when to stop execution when there are tool results in the last step. By default, agents stop after 20 steps using `stepCountIs(20)`.
+The `stopWhen` parameter controls when to stop execution when there are tool results in the last step. By default, agents stop after 20 steps using `stepCountIs(20)`. This default is a safety measure to prevent runaway loops that could result in excessive API calls and costs.
 
 When you provide `stopWhen`, the agent continues executing after tool calls until a stopping condition is met. When the condition is an array, execution stops when any of the conditions are met.
 
@@ -24,6 +24,12 @@ When you provide `stopWhen`, the agent continues executing after tool calls unti
 
 The AI SDK provides several built-in stopping conditions:
 
+- `stepCountIs(count)` — stops after a specified number of steps
+- `hasToolCall(toolName)` — stops when a specific tool is called
+- `isLoopFinished()` — never triggers, letting the loop run until the agent is naturally finished
+
+### Run Up to a Maximum Number of Steps
+
 ```ts
 import { ToolLoopAgent, stepCountIs } from 'ai';
 __PROVIDER_IMPORT__;
@@ -33,7 +39,28 @@ const agent = new ToolLoopAgent({
   tools: {
     // your tools
   },
-  stopWhen: stepCountIs(20), // Default state: stop after 20 steps maximum
+  stopWhen: stepCountIs(50), // Increasing the default of 20 to 50.
+});
+
+const result = await agent.generate({
+  prompt: 'Analyze this dataset and create a summary report',
+});
+```
+
+### Run Until Finished
+
+If you want the agent to run until the model naturally stops making tool calls, use `isLoopFinished()`. This removes the default step limit:
+
+```ts
+import { ToolLoopAgent, isLoopFinished } from 'ai';
+__PROVIDER_IMPORT__;
+
+const agent = new ToolLoopAgent({
+  model: __MODEL__,
+  tools: {
+    // your tools
+  },
+  stopWhen: isLoopFinished(), // No maximum step limit.
 });
 
 const result = await agent.generate({
@@ -41,6 +68,12 @@ const result = await agent.generate({
 });
 ```
 
+<Note>
+  Use `isLoopFinished()` with caution. Without a step limit, the agent could
+  potentially run indefinitely or incur significant costs if the model keeps
+  making tool calls.
+</Note>
+
 ### Combine Multiple Conditions
 
 Combine multiple stopping conditions. The loop stops when it meets any condition:

package/docs/03-agents/06-memory.mdx

@@ -187,7 +187,7 @@ pnpm add @vectorize-io/hindsight-ai-sdk @vectorize-io/hindsight-client
 __PROVIDER_IMPORT__;
 import { HindsightClient } from '@vectorize-io/hindsight-client';
 import { createHindsightTools } from '@vectorize-io/hindsight-ai-sdk';
-import { ToolLoopAgent, stepCountIs } from 'ai';
+import { ToolLoopAgent } from 'ai';
 import { openai } from '@ai-sdk/openai';
 
 const client = new HindsightClient({ baseUrl: process.env.HINDSIGHT_API_URL });
@@ -195,7 +195,6 @@ const client = new HindsightClient({ baseUrl: process.env.HINDSIGHT_API_URL });
 const agent = new ToolLoopAgent({
   model: __MODEL__,
   tools: createHindsightTools({ client, bankId: 'user-123' }),
-  stopWhen: stepCountIs(10),
   instructions: 'You are a helpful assistant with long-term memory.',
 });
 

package/docs/03-ai-sdk-core/15-tools-and-tool-calling.mdx

@@ -226,6 +226,14 @@ When using `useChat`, the approval flow is handled through UI state. See [Chatbo
 
 With the `stopWhen` setting, you can enable multi-step calls in `generateText` and `streamText`. When `stopWhen` is set and the model generates a tool call, the AI SDK will trigger a new generation passing in the tool result until there are no further tool calls or the stopping condition is met.
 
+The AI SDK provides several built-in stopping conditions:
+
+- `stepCountIs(count)` — stops after a specified number of steps (default: `stepCountIs(20)`)
+- `hasToolCall(toolName)` — stops when a specific tool is called
+- `isLoopFinished()` — never triggers, letting the loop run until naturally finished
+
+You can also combine multiple conditions in an array or create custom conditions. See [Loop Control](/docs/agents/loop-control) for more details.
+
 <Note>
   The `stopWhen` conditions are only evaluated when the last step contains tool
   results.

package/docs/03-ai-sdk-core/35-image-generation.mdx

@@ -10,10 +10,10 @@ function to generate images based on a given prompt using an image model.
 
 ```tsx
 import { generateImage } from 'ai';
-import { openai } from '@ai-sdk/openai';
+__PROVIDER_IMPORT__;
 
 const { image } = await generateImage({
-  model: openai.image('dall-e-3'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
 });
 ```
@@ -38,10 +38,10 @@ Models only support a few sizes, and the supported sizes are different for each
 
 ```tsx highlight={"7"}
 import { generateImage } from 'ai';
-import { openai } from '@ai-sdk/openai';
+__PROVIDER_IMPORT__;
 
 const { image } = await generateImage({
-  model: openai.image('dall-e-3'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
   size: '1024x1024',
 });
@@ -54,10 +54,10 @@ Models only support a few aspect ratios, and the supported aspect ratios are dif
 
 ```tsx highlight={"7"}
 import { generateImage } from 'ai';
-import { vertex } from '@ai-sdk/google-vertex';
+__PROVIDER_IMPORT__;
 
 const { image } = await generateImage({
-  model: vertex.image('imagen-4.0-generate-001'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
   aspectRatio: '16:9',
 });
@@ -69,10 +69,10 @@ const { image } = await generateImage({
 
 ```tsx highlight={"7"}
 import { generateImage } from 'ai';
-import { openai } from '@ai-sdk/openai';
+__PROVIDER_IMPORT__;
 
 const { images } = await generateImage({
-  model: openai.image('dall-e-2'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
   n: 4, // number of images to generate
 });
@@ -89,7 +89,7 @@ If needed, you can override this behavior using the `maxImagesPerCall` setting w
 
 ```tsx
 const { images } = await generateImage({
-  model: openai.image('dall-e-2'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
   maxImagesPerCall: 5, // Override the default batch size
   n: 10, // Will make 2 calls of 5 images each
@@ -103,10 +103,10 @@ If supported by the model, the same seed will always produce the same image.
 
 ```tsx highlight={"7"}
 import { generateImage } from 'ai';
-import { openai } from '@ai-sdk/openai';
+__PROVIDER_IMPORT__;
 
 const { image } = await generateImage({
-  model: openai.image('dall-e-3'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
   seed: 1234567890,
 });
@@ -140,11 +140,11 @@ type [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSigna
 that you can use to abort the image generation process or set a timeout.
 
 ```ts highlight={"7"}
-import { openai } from '@ai-sdk/openai';
 import { generateImage } from 'ai';
+__PROVIDER_IMPORT__;
 
 const { image } = await generateImage({
-  model: openai.image('dall-e-3'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
   abortSignal: AbortSignal.timeout(1000), // Abort after 1 second
 });
@@ -156,11 +156,11 @@ const { image } = await generateImage({
 that you can use to add custom headers to the image generation request.
 
 ```ts highlight={"7"}
-import { openai } from '@ai-sdk/openai';
 import { generateImage } from 'ai';
+__PROVIDER_IMPORT__;
 
 const { image } = await generateImage({
-  model: openai.image('dall-e-3'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
   headers: { 'X-Custom-Header': 'custom-value' },
 });
@@ -172,7 +172,7 @@ If the model returns warnings, e.g. for unsupported parameters, they will be ava
 
 ```tsx
 const { image, warnings } = await generateImage({
-  model: openai.image('dall-e-3'),
+  model: __IMAGE_MODEL__,
   prompt: 'Santa Claus driving a Cadillac',
 });
 ```
@@ -236,10 +236,10 @@ Here is an example that sets a default size when none is provided:
 
 ```ts
 import { generateImage, wrapImageModel } from 'ai';
-import { openai } from '@ai-sdk/openai';
+__PROVIDER_IMPORT__;
 
 const model = wrapImageModel({
-  model: openai.image('gpt-image-1'),
+  model: __IMAGE_MODEL__,
   middleware: {
     specificationVersion: 'v3',
     transformParams: async ({ params }) => ({

package/docs/03-ai-sdk-core/38-video-generation.mdx

@@ -15,10 +15,10 @@ function to generate videos based on a given prompt using a video model.
 
 ```tsx
 import { experimental_generateVideo as generateVideo } from 'ai';
-import { fal } from '@ai-sdk/fal';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A cat walking on a treadmill',
 });
 ```
@@ -39,10 +39,10 @@ Models only support a few aspect ratios, and the supported aspect ratios are dif
 
 ```tsx highlight={"7"}
 import { experimental_generateVideo as generateVideo } from 'ai';
-import { fal } from '@ai-sdk/fal';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A cat walking on a treadmill',
   aspectRatio: '16:9',
 });
@@ -55,10 +55,10 @@ Models only support specific resolutions, and the supported resolutions are diff
 
 ```tsx highlight={"7"}
 import { experimental_generateVideo as generateVideo } from 'ai';
-import { google } from '@ai-sdk/google';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: google.video('veo-2.0-generate-001'),
+  model: __VIDEO_MODEL__,
   prompt: 'A serene mountain landscape at sunset',
   resolution: '1280x720',
 });
@@ -70,10 +70,10 @@ Some video models support specifying the duration of the generated video in seco
 
 ```tsx highlight={"7"}
 import { experimental_generateVideo as generateVideo } from 'ai';
-import { fal } from '@ai-sdk/fal';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A timelapse of clouds moving across the sky',
   duration: 5,
 });
@@ -85,10 +85,10 @@ Some video models allow you to specify the frames per second for the generated v
 
 ```tsx highlight={"7"}
 import { experimental_generateVideo as generateVideo } from 'ai';
-import { fal } from '@ai-sdk/fal';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A hummingbird in slow motion',
   fps: 24,
 });
@@ -100,10 +100,10 @@ const { video } = await generateVideo({
 
 ```tsx highlight={"7"}
 import { experimental_generateVideo as generateVideo } from 'ai';
-import { google } from '@ai-sdk/google';
+__PROVIDER_IMPORT__;
 
 const { videos } = await generateVideo({
-  model: google.video('veo-2.0-generate-001'),
+  model: __VIDEO_MODEL__,
   prompt: 'A rocket launching into space',
   n: 3, // number of videos to generate
 });
@@ -120,7 +120,7 @@ If needed, you can override this behavior using the `maxVideosPerCall` setting:
 
 ```tsx
 const { videos } = await generateVideo({
-  model: google.video('veo-2.0-generate-001'),
+  model: __VIDEO_MODEL__,
   prompt: 'A rocket launching into space',
   maxVideosPerCall: 2, // Override the default batch size
   n: 4, // Will make 2 calls of 2 videos each
@@ -133,10 +133,10 @@ Some video models support generating videos from an input image. You can provide
 
 ```tsx highlight={"7-10"}
 import { experimental_generateVideo as generateVideo } from 'ai';
-import { fal } from '@ai-sdk/fal';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: fal.video('hunyuan-video'),
+  model: __VIDEO_MODEL__,
   prompt: {
     image: 'https://example.com/my-image.png',
     text: 'Animate this image with gentle motion',
@@ -148,7 +148,7 @@ You can also provide the image as a base64-encoded string or `Uint8Array`:
 
 ```tsx
 const { video } = await generateVideo({
-  model: fal.video('hunyuan-video'),
+  model: __VIDEO_MODEL__,
   prompt: {
     image: imageBase64String, // or imageUint8Array
     text: 'Animate this image',
@@ -163,10 +163,10 @@ If supported by the model, the same seed will always produce the same video.
 
 ```tsx highlight={"7"}
 import { experimental_generateVideo as generateVideo } from 'ai';
-import { fal } from '@ai-sdk/fal';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A cat walking on a treadmill',
   seed: 1234567890,
 });
@@ -200,11 +200,11 @@ type [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSigna
 that you can use to abort the video generation process or set a timeout.
 
 ```ts highlight={"7"}
-import { fal } from '@ai-sdk/fal';
 import { experimental_generateVideo as generateVideo } from 'ai';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A cat walking on a treadmill',
   abortSignal: AbortSignal.timeout(60000), // Abort after 60 seconds
 });
@@ -249,11 +249,11 @@ const { video } = await generateVideo({
 that you can use to add custom headers to the video generation request.
 
 ```ts highlight={"7"}
-import { fal } from '@ai-sdk/fal';
 import { experimental_generateVideo as generateVideo } from 'ai';
+__PROVIDER_IMPORT__;
 
 const { video } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A cat walking on a treadmill',
   headers: { 'X-Custom-Header': 'custom-value' },
 });
@@ -265,7 +265,7 @@ If the model returns warnings, e.g. for unsupported parameters, they will be ava
 
 ```tsx
 const { video, warnings } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A cat walking on a treadmill',
 });
 ```
@@ -298,7 +298,7 @@ When generating multiple videos with `n > 1`, you can also access per-call metad
 
 ```tsx
 const { videos, responses } = await generateVideo({
-  model: google.video('veo-2.0-generate-001'),
+  model: __VIDEO_MODEL__,
   prompt: 'A rocket launching into space',
   n: 5, // May require multiple API calls
 });

package/docs/07-reference/01-ai-sdk-core/10-generate-image.mdx

@@ -12,9 +12,10 @@ such as creating visual content or generating images for data augmentation.
 
 ```ts
 import { generateImage } from 'ai';
+__PROVIDER_IMPORT__;
 
 const { images } = await generateImage({
-  model: openai.image('dall-e-3'),
+  model: __IMAGE_MODEL__,
   prompt: 'A futuristic cityscape at sunset',
   n: 3,
   size: '1024x1024',

package/docs/07-reference/01-ai-sdk-core/13-generate-video.mdx

@@ -17,9 +17,10 @@ such as creating visual content, animations, or generating videos from images.
 
 ```ts
 import { experimental_generateVideo as generateVideo } from 'ai';
+__PROVIDER_IMPORT__;
 
 const { videos } = await generateVideo({
-  model: fal.video('luma-dream-machine/ray-2'),
+  model: __VIDEO_MODEL__,
   prompt: 'A cat walking on a treadmill',
   aspectRatio: '16:9',
 });

package/docs/07-reference/01-ai-sdk-core/72-loop-finished.mdx

@@ -0,0 +1,83 @@
+---
+title: isLoopFinished
+description: API Reference for isLoopFinished.
+---
+
+# `isLoopFinished()`
+
+Creates a stop condition that never triggers, letting the agent loop run until it naturally finishes (i.e., the model stops making tool calls).
+
+By default, `ToolLoopAgent` uses `stepCountIs(20)` as a safety measure to prevent runaway loops that could result in excessive API calls and costs. If you are confident that your agent will terminate naturally or you are less concerned about costs, `isLoopFinished()` removes that limit and lets the agent run until the model is truly done.
+
+```ts
+import { ToolLoopAgent, isLoopFinished } from 'ai';
+__PROVIDER_IMPORT__;
+
+const agent = new ToolLoopAgent({
+  model: __MODEL__,
+  tools: {
+    // your tools
+  },
+  stopWhen: isLoopFinished(),
+});
+
+const result = await agent.generate({
+  prompt: 'Analyze this dataset and create a summary report',
+});
+```
+
+## Import
+
+<Snippet text={`import { isLoopFinished } from "ai"`} prompt={false} />
+
+## API Signature
+
+### Parameters
+
+This function takes no parameters.
+
+### Returns
+
+A `StopCondition` function that always returns `false`, meaning it never triggers the stop condition. The agent loop will only stop through its natural termination conditions:
+
+- The model stops making tool calls, or
+- A tool without an `execute` function is called, or
+- A tool call needs approval
+
+## Examples
+
+### Basic Usage
+
+Let the agent run until it's finished:
+
+```ts
+import { ToolLoopAgent, isLoopFinished } from 'ai';
+
+const agent = new ToolLoopAgent({
+  model: yourModel,
+  tools: yourTools,
+  stopWhen: isLoopFinished(),
+});
+```
+
+### Combining with Other Conditions
+
+You can combine `isLoopFinished()` with other conditions. Since `isLoopFinished()` never triggers, the other conditions still apply:
+
+```ts
+import { ToolLoopAgent, isLoopFinished, hasToolCall } from 'ai';
+
+const agent = new ToolLoopAgent({
+  model: yourModel,
+  tools: yourTools,
+  stopWhen: [isLoopFinished(), hasToolCall('finalAnswer')],
+});
+```
+
+In practice, this does not make much sense in this context, since you could just omit `isLoopFinished()`.
+
+## See also
+
+- [`stepCountIs()`](/docs/reference/ai-sdk-core/step-count-is)
+- [`hasToolCall()`](/docs/reference/ai-sdk-core/has-tool-call)
+- [`ToolLoopAgent`](/docs/reference/ai-sdk-core/tool-loop-agent)

package/docs/07-reference/01-ai-sdk-core/index.mdx

@@ -130,6 +130,24 @@ It also contains the following helper functions:
         'Extracts JSON from text content by stripping markdown code fences.',
       href: '/docs/reference/ai-sdk-core/extract-json-middleware',
     },
+    {
+      title: 'stepCountIs()',
+      description:
+        'Creates a stop condition that triggers after a specified number of steps.',
+      href: '/docs/reference/ai-sdk-core/step-count-is',
+    },
+    {
+      title: 'hasToolCall()',
+      description:
+        'Creates a stop condition that triggers when a specific tool is called.',
+      href: '/docs/reference/ai-sdk-core/has-tool-call',
+    },
+    {
+      title: 'isLoopFinished()',
+      description:
+        'Creates a stop condition that lets the agent loop run until it naturally finishes.',
+      href: '/docs/reference/ai-sdk-core/loop-finished',
+    },
     {
       title: 'simulateStreamingMiddleware()',
       description:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "6.0.141",
+  "version": "6.0.142",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "1.9.0",
-    "@ai-sdk/gateway": "3.0.83",
+    "@ai-sdk/gateway": "3.0.84",
     "@ai-sdk/provider": "3.0.8",
     "@ai-sdk/provider-utils": "4.0.21"
   },

package/src/generate-text/index.ts

@@ -24,7 +24,12 @@ export { pruneMessages } from './prune-messages';
 export type { ReasoningOutput } from './reasoning-output';
 export { smoothStream, type ChunkDetector } from './smooth-stream';
 export type { StepResult } from './step-result';
-export { hasToolCall, stepCountIs, type StopCondition } from './stop-condition';
+export {
+  hasToolCall,
+  isLoopFinished,
+  stepCountIs,
+  type StopCondition,
+} from './stop-condition';
 export {
   streamText,
   type StreamTextOnChunkCallback,

package/src/generate-text/stop-condition.ts

@@ -9,6 +9,10 @@ export function stepCountIs(stepCount: number): StopCondition<any> {
   return ({ steps }) => steps.length === stepCount;
 }
 
+export function isLoopFinished(): StopCondition<any> {
+  return () => false;
+}
+
 export function hasToolCall(toolName: string): StopCondition<any> {
   return ({ steps }) =>
     steps[steps.length - 1]?.toolCalls?.some(