@fairyhunter13/ai-sdk 6.0.116-fork.1

package/docs/07-reference/01-ai-sdk-core/70-step-count-is.mdx

@@ -0,0 +1,84 @@
+---
+title: stepCountIs
+description: API Reference for stepCountIs.
+---
+
+# `stepCountIs()`
+
+Creates a stop condition that stops when the number of steps reaches a specified count.
+
+This function is used with `stopWhen` in `generateText` and `streamText` to control when a tool-calling loop should stop based on the number of steps executed.
+
+```ts
+import { generateText, stepCountIs } from 'ai';
+__PROVIDER_IMPORT__;
+
+const result = await generateText({
+  model: __MODEL__,
+  tools: {
+    // your tools
+  },
+  // Stop after 5 steps
+  stopWhen: stepCountIs(5),
+});
+```
+
+## Import
+
+<Snippet text={`import { stepCountIs } from "ai"`} prompt={false} />
+
+## API Signature
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'count',
+      type: 'number',
+      description:
+        'The maximum number of steps to execute before stopping the tool-calling loop.',
+    },
+  ]}
+/>
+
+### Returns
+
+A `StopCondition` function that returns `true` when the step count reaches the specified number. The function can be used with the `stopWhen` parameter in `generateText` and `streamText`.
+
+## Examples
+
+### Basic Usage
+
+Stop after 3 steps:
+
+```ts
+import { generateText, stepCountIs } from 'ai';
+
+const result = await generateText({
+  model: yourModel,
+  tools: yourTools,
+  stopWhen: stepCountIs(3),
+});
+```
+
+### Combining with Other Conditions
+
+You can combine multiple stop conditions in an array:
+
+```ts
+import { generateText, stepCountIs, hasToolCall } from 'ai';
+
+const result = await generateText({
+  model: yourModel,
+  tools: yourTools,
+  // Stop after 10 steps OR when finalAnswer tool is called
+  stopWhen: [stepCountIs(10), hasToolCall('finalAnswer')],
+});
+```
+
+## See also
+
+- [`hasToolCall()`](/docs/reference/ai-sdk-core/has-tool-call)
+- [`generateText()`](/docs/reference/ai-sdk-core/generate-text)
+- [`streamText()`](/docs/reference/ai-sdk-core/stream-text)

package/docs/07-reference/01-ai-sdk-core/71-has-tool-call.mdx

@@ -0,0 +1,120 @@
+---
+title: hasToolCall
+description: API Reference for hasToolCall.
+---
+
+# `hasToolCall()`
+
+Creates a stop condition that stops when a specific tool is called.
+
+This function is used with `stopWhen` in `generateText` and `streamText` to control when a tool-calling loop should stop based on whether a particular tool has been invoked.
+
+```ts
+import { generateText, hasToolCall } from 'ai';
+__PROVIDER_IMPORT__;
+
+const result = await generateText({
+  model: __MODEL__,
+  tools: {
+    weather: weatherTool,
+    finalAnswer: finalAnswerTool,
+  },
+  // Stop when the finalAnswer tool is called
+  stopWhen: hasToolCall('finalAnswer'),
+});
+```
+
+## Import
+
+<Snippet text={`import { hasToolCall } from "ai"`} prompt={false} />
+
+## API Signature
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'toolName',
+      type: 'string',
+      description:
+        'The name of the tool that should trigger the stop condition when called.',
+    },
+  ]}
+/>
+
+### Returns
+
+A `StopCondition` function that returns `true` when the specified tool is called in the current step. The function can be used with the `stopWhen` parameter in `generateText` and `streamText`.
+
+## Examples
+
+### Basic Usage
+
+Stop when a specific tool is called:
+
+```ts
+import { generateText, hasToolCall } from 'ai';
+
+const result = await generateText({
+  model: yourModel,
+  tools: {
+    submitAnswer: submitAnswerTool,
+    search: searchTool,
+  },
+  stopWhen: hasToolCall('submitAnswer'),
+});
+```
+
+### Combining with Other Conditions
+
+You can combine multiple stop conditions in an array:
+
+```ts
+import { generateText, hasToolCall, stepCountIs } from 'ai';
+
+const result = await generateText({
+  model: yourModel,
+  tools: {
+    weather: weatherTool,
+    search: searchTool,
+    finalAnswer: finalAnswerTool,
+  },
+  // Stop when weather tool is called OR finalAnswer is called OR after 5 steps
+  stopWhen: [
+    hasToolCall('weather'),
+    hasToolCall('finalAnswer'),
+    stepCountIs(5),
+  ],
+});
+```
+
+### Agent Pattern
+
+Common pattern for agents that run until they provide a final answer:
+
+```ts
+import { generateText, hasToolCall } from 'ai';
+
+const result = await generateText({
+  model: yourModel,
+  tools: {
+    search: searchTool,
+    calculate: calculateTool,
+    finalAnswer: {
+      description: 'Provide the final answer to the user',
+      parameters: z.object({
+        answer: z.string(),
+      }),
+      execute: async ({ answer }) => answer,
+    },
+  },
+  stopWhen: hasToolCall('finalAnswer'),
+});
+```
+
+## See also
+
+- [`stepCountIs()`](/docs/reference/ai-sdk-core/step-count-is)
+- [`generateText()`](/docs/reference/ai-sdk-core/generate-text)
+- [`streamText()`](/docs/reference/ai-sdk-core/stream-text)

package/docs/07-reference/01-ai-sdk-core/75-simulate-readable-stream.mdx

@@ -0,0 +1,94 @@
+---
+title: simulateReadableStream
+description: Create a ReadableStream that emits values with configurable delays
+---
+
+# `simulateReadableStream()`
+
+`simulateReadableStream` is a utility function that creates a ReadableStream which emits provided values sequentially with configurable delays. This is particularly useful for testing streaming functionality or simulating time-delayed data streams.
+
+```ts
+import { simulateReadableStream } from 'ai';
+
+const stream = simulateReadableStream({
+  chunks: ['Hello', ' ', 'World'],
+  initialDelayInMs: 100,
+  chunkDelayInMs: 50,
+});
+```
+
+## Import
+
+<Snippet text={`import { simulateReadableStream } from "ai"`} prompt={false} />
+
+## API Signature
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'chunks',
+      type: 'T[]',
+      isOptional: false,
+      description: 'Array of values to be emitted by the stream',
+    },
+    {
+      name: 'initialDelayInMs',
+      type: 'number | null',
+      isOptional: true,
+      description:
+        'Initial delay in milliseconds before emitting the first value. Defaults to 0. Set to null to skip the initial delay entirely.',
+    },
+    {
+      name: 'chunkDelayInMs',
+      type: 'number | null',
+      isOptional: true,
+      description:
+        'Delay in milliseconds between emitting each value. Defaults to 0. Set to null to skip delays between chunks.',
+    },
+  ]}
+/>
+
+### Returns
+
+Returns a `ReadableStream<T>` that:
+
+- Emits each value from the provided `chunks` array sequentially
+- Waits for `initialDelayInMs` before emitting the first value (if not `null`)
+- Waits for `chunkDelayInMs` between emitting subsequent values (if not `null`)
+- Closes automatically after all chunks have been emitted
+
+### Type Parameters
+
+- `T`: The type of values contained in the chunks array and emitted by the stream
+
+## Examples
+
+### Basic Usage
+
+```ts
+const stream = simulateReadableStream({
+  chunks: ['Hello', ' ', 'World'],
+});
+```
+
+### With Delays
+
+```ts
+const stream = simulateReadableStream({
+  chunks: ['Hello', ' ', 'World'],
+  initialDelayInMs: 1000, // Wait 1 second before first chunk
+  chunkDelayInMs: 500, // Wait 0.5 seconds between chunks
+});
+```
+
+### Without Delays
+
+```ts
+const stream = simulateReadableStream({
+  chunks: ['Hello', ' ', 'World'],
+  initialDelayInMs: null, // No initial delay
+  chunkDelayInMs: null, // No delay between chunks
+});
+```

package/docs/07-reference/01-ai-sdk-core/80-smooth-stream.mdx

@@ -0,0 +1,145 @@
+---
+title: smoothStream
+description: Stream transformer for smoothing text and reasoning output
+---
+
+# `smoothStream()`
+
+`smoothStream` is a utility function that creates a TransformStream
+for the `streamText` `transform` option
+to smooth out text and reasoning streaming by buffering and releasing complete chunks with configurable delays.
+This creates a more natural reading experience when streaming text and reasoning responses.
+
+```ts highlight={"6-9"}
+import { smoothStream, streamText } from 'ai';
+
+const result = streamText({
+  model,
+  prompt,
+  experimental_transform: smoothStream({
+    delayInMs: 20, // optional: defaults to 10ms
+    chunking: 'line', // optional: defaults to 'word'
+  }),
+});
+```
+
+## Import
+
+<Snippet text={`import { smoothStream } from "ai"`} prompt={false} />
+
+## API Signature
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'delayInMs',
+      type: 'number | null',
+      isOptional: true,
+      description:
+        'The delay in milliseconds between outputting each chunk. Defaults to 10ms. Set to `null` to disable delays.',
+    },
+    {
+      name: 'chunking',
+      type: '"word" | "line" | RegExp | Intl.Segmenter | (buffer: string) => string | undefined | null',
+      isOptional: true,
+      description:
+        'Controls how text and reasoning content is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, an Intl.Segmenter for locale-aware word segmentation (recommended for CJK languages), or provide a custom callback or RegExp pattern for custom chunking.',
+    },
+  ]}
+/>
+
+#### Word chunking caveats with non-latin languages
+
+The word based chunking **does not work well** with the following languages that do not delimit words with spaces:
+
+- Chinese
+- Japanese
+- Korean
+- Vietnamese
+- Thai
+
+#### Using Intl.Segmenter (recommended)
+
+For these languages, we recommend using `Intl.Segmenter` for proper locale-aware word segmentation.
+This is the preferred approach as it provides accurate word boundaries for CJK and other languages.
+
+<Note>
+  `Intl.Segmenter` is available in Node.js 16+ and all modern browsers (Chrome
+  87+, Firefox 125+, Safari 14.1+).
+</Note>
+
+```tsx filename="Japanese example with Intl.Segmenter"
+import { smoothStream, streamText } from 'ai';
+__PROVIDER_IMPORT__;
+
+const segmenter = new Intl.Segmenter('ja', { granularity: 'word' });
+
+const result = streamText({
+  model: __MODEL__,
+  prompt: 'Your prompt here',
+  experimental_transform: smoothStream({
+    chunking: segmenter,
+  }),
+});
+```
+
+```tsx filename="Chinese example with Intl.Segmenter"
+import { smoothStream, streamText } from 'ai';
+__PROVIDER_IMPORT__;
+
+const segmenter = new Intl.Segmenter('zh', { granularity: 'word' });
+
+const result = streamText({
+  model: __MODEL__,
+  prompt: 'Your prompt here',
+  experimental_transform: smoothStream({
+    chunking: segmenter,
+  }),
+});
+```
+
+#### Regex based chunking
+
+To use regex based chunking, pass a `RegExp` to the `chunking` option.
+
+```ts
+// To split on underscores:
+smoothStream({
+  chunking: /_+/,
+});
+
+// Also can do it like this, same behavior
+smoothStream({
+  chunking: /[^_]*_/,
+});
+```
+
+#### Custom callback chunking
+
+To use a custom callback for chunking, pass a function to the `chunking` option.
+
+```ts
+smoothStream({
+  chunking: text => {
+    const findString = 'some string';
+    const index = text.indexOf(findString);
+
+    if (index === -1) {
+      return null;
+    }
+
+    return text.slice(0, index) + findString;
+  },
+});
+```
+
+### Returns
+
+Returns a `TransformStream` that:
+
+- Buffers incoming text and reasoning chunks
+- Releases content when the chunking pattern is encountered
+- Adds configurable delays between chunks for smooth output
+- Passes through non-text/reasoning chunks (like tool calls, step-finish events) immediately

package/docs/07-reference/01-ai-sdk-core/90-generate-id.mdx

@@ -0,0 +1,30 @@
+---
+title: generateId
+description: Generate a unique identifier (API Reference)
+---
+
+# `generateId()`
+
+Generates a unique identifier.
+
+This is the same id generator used by the AI SDK.
+
+```ts
+import { generateId } from 'ai';
+
+const id = generateId();
+```
+
+## Import
+
+<Snippet text={`import { generateId } from "ai"`} prompt={false} />
+
+## API Signature
+
+### Returns
+
+A string representing the generated ID.
+
+## See also
+
+- [`createIdGenerator()`](/docs/reference/ai-sdk-core/create-id-generator)

package/docs/07-reference/01-ai-sdk-core/91-create-id-generator.mdx

@@ -0,0 +1,89 @@
+---
+title: createIdGenerator
+description: Create a customizable unique identifier generator (API Reference)
+---
+
+# `createIdGenerator()`
+
+Creates a customizable ID generator function. You can configure the alphabet, prefix, separator, and default size of the generated IDs.
+
+```ts
+import { createIdGenerator } from 'ai';
+
+const generateCustomId = createIdGenerator({
+  prefix: 'user',
+  separator: '_',
+});
+
+const id = generateCustomId(); // Example: "user_1a2b3c4d5e6f7g8h"
+```
+
+## Import
+
+<Snippet text={`import { createIdGenerator } from "ai"`} prompt={false} />
+
+## API Signature
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'options',
+      type: 'object',
+      description:
+        'Optional configuration object with the following properties:',
+    },
+    {
+      name: 'options.alphabet',
+      type: 'string',
+      description:
+        'The characters to use for generating the random part of the ID. Defaults to alphanumeric characters (0-9, A-Z, a-z).',
+    },
+    {
+      name: 'options.prefix',
+      type: 'string',
+      description:
+        'A string to prepend to all generated IDs. Defaults to none.',
+    },
+    {
+      name: 'options.separator',
+      type: 'string',
+      description:
+        'The character(s) to use between the prefix and the random part. Defaults to "-".',
+    },
+    {
+      name: 'options.size',
+      type: 'number',
+      description:
+        'The default length of the random part of the ID. Defaults to 16.',
+    },
+  ]}
+/>
+
+### Returns
+
+Returns a function that generates IDs based on the configured options.
+
+### Notes
+
+- The generator uses non-secure random generation and should not be used for security-critical purposes.
+- The separator character must not be part of the alphabet to ensure reliable prefix checking.
+
+## Example
+
+```ts
+// Create a custom ID generator for user IDs
+const generateUserId = createIdGenerator({
+  prefix: 'user',
+  separator: '_',
+  size: 8,
+});
+
+// Generate IDs
+const id1 = generateUserId(); // e.g., "user_1a2b3c4d"
+```
+
+## See also
+
+- [`generateId()`](/docs/reference/ai-sdk-core/generate-id)

package/docs/07-reference/01-ai-sdk-core/92-default-generated-file.mdx

@@ -0,0 +1,68 @@
+---
+title: DefaultGeneratedFile
+description: API Reference for DefaultGeneratedFile.
+---
+
+# `DefaultGeneratedFile`
+
+A concrete implementation of the `GeneratedFile` interface that provides lazy conversion between base64 and Uint8Array formats.
+
+```ts
+import { DefaultGeneratedFile } from 'ai';
+
+const file = new DefaultGeneratedFile({
+  data: uint8ArrayData,
+  mediaType: 'image/png',
+});
+
+console.log(file.base64); // Automatically converted to base64
+console.log(file.uint8Array); // Original Uint8Array
+```
+
+## Import
+
+<Snippet text={`import { DefaultGeneratedFile } from "ai"`} prompt={false} />
+
+## Constructor
+
+### Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: 'data',
+      type: 'string | Uint8Array',
+      description:
+        'The file data as either a base64 encoded string or Uint8Array.',
+    },
+    {
+      name: 'mediaType',
+      type: 'string',
+      description: 'The IANA media type of the file.',
+    },
+  ]}
+/>
+
+## Properties
+
+<PropertiesTable
+  content={[
+    {
+      name: 'base64',
+      type: 'string',
+      description:
+        'File as a base64 encoded string. Lazily converted from Uint8Array if needed.',
+    },
+    {
+      name: 'uint8Array',
+      type: 'Uint8Array',
+      description:
+        'File as a Uint8Array. Lazily converted from base64 if needed.',
+    },
+    {
+      name: 'mediaType',
+      type: 'string',
+      description: 'The IANA media type of the file.',
+    },
+  ]}
+/>