ai 6.0.33 → 6.0.34

package/src/generate-text/smooth-stream.ts

@@ -0,0 +1,162 @@
+import { delay as originalDelay } from '@ai-sdk/provider-utils';
+import { SharedV3ProviderMetadata } from '@ai-sdk/provider';
+import { TextStreamPart } from './stream-text-result';
+import { ToolSet } from './tool-set';
+import { InvalidArgumentError } from '@ai-sdk/provider';
+
+const CHUNKING_REGEXPS = {
+  word: /\S+\s+/m,
+  line: /\n+/m,
+};
+
+/**
+ * Detects the first chunk in a buffer.
+ *
+ * @param buffer - The buffer to detect the first chunk in.
+ *
+ * @returns The first detected chunk, or `undefined` if no chunk was detected.
+ */
+export type ChunkDetector = (buffer: string) => string | undefined | null;
+
+/**
+ * Smooths text and reasoning streaming output.
+ *
+ * @param delayInMs - The delay in milliseconds between each chunk. Defaults to 10ms. Can be set to `null` to skip the delay.
+ * @param chunking - Controls how the text is chunked for streaming. Use "word" to stream word by word (default), "line" to stream line by line, provide a custom RegExp pattern for custom chunking, provide an Intl.Segmenter for locale-aware word segmentation (recommended for CJK languages), or provide a custom ChunkDetector function.
+ *
+ * @returns A transform stream that smooths text streaming output.
+ */
+export function smoothStream<TOOLS extends ToolSet>({
+  delayInMs = 10,
+  chunking = 'word',
+  _internal: { delay = originalDelay } = {},
+}: {
+  delayInMs?: number | null;
+  chunking?: 'word' | 'line' | RegExp | ChunkDetector | Intl.Segmenter;
+  /**
+   * Internal. For test use only. May change without notice.
+   */
+  _internal?: {
+    delay?: (delayInMs: number | null) => Promise<void>;
+  };
+} = {}): (options: {
+  tools: TOOLS;
+}) => TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>> {
+  let detectChunk: ChunkDetector;
+
+  // Check if chunking is an Intl.Segmenter (duck-typing for segment method)
+  if (
+    chunking != null &&
+    typeof chunking === 'object' &&
+    'segment' in chunking &&
+    typeof chunking.segment === 'function'
+  ) {
+    const segmenter = chunking as Intl.Segmenter;
+    detectChunk = (buffer: string) => {
+      if (buffer.length === 0) return null;
+      const iterator = segmenter.segment(buffer)[Symbol.iterator]();
+      const first = iterator.next().value;
+      return first?.segment || null;
+    };
+  } else if (typeof chunking === 'function') {
+    detectChunk = buffer => {
+      const match = chunking(buffer);
+
+      if (match == null) {
+        return null;
+      }
+
+      if (!match.length) {
+        throw new Error(`Chunking function must return a non-empty string.`);
+      }
+
+      if (!buffer.startsWith(match)) {
+        throw new Error(
+          `Chunking function must return a match that is a prefix of the buffer. Received: "${match}" expected to start with "${buffer}"`,
+        );
+      }
+
+      return match;
+    };
+  } else {
+    const chunkingRegex =
+      typeof chunking === 'string'
+        ? CHUNKING_REGEXPS[chunking]
+        : chunking instanceof RegExp
+          ? chunking
+          : undefined;
+
+    if (chunkingRegex == null) {
+      throw new InvalidArgumentError({
+        argument: 'chunking',
+        message: `Chunking must be "word", "line", a RegExp, an Intl.Segmenter, or a ChunkDetector function. Received: ${chunking}`,
+      });
+    }
+
+    detectChunk = buffer => {
+      const match = chunkingRegex.exec(buffer);
+
+      if (!match) {
+        return null;
+      }
+
+      return buffer.slice(0, match.index) + match?.[0];
+    };
+  }
+
+  return () => {
+    let buffer = '';
+    let id = '';
+    let type: 'text-delta' | 'reasoning-delta' | undefined = undefined;
+    let providerMetadata: SharedV3ProviderMetadata | undefined = undefined;
+
+    function flushBuffer(
+      controller: TransformStreamDefaultController<TextStreamPart<TOOLS>>,
+    ) {
+      if (buffer.length > 0 && type !== undefined) {
+        controller.enqueue({
+          type,
+          text: buffer,
+          id,
+          ...(providerMetadata != null ? { providerMetadata } : {}),
+        });
+        buffer = '';
+        providerMetadata = undefined;
+      }
+    }
+
+    return new TransformStream<TextStreamPart<TOOLS>, TextStreamPart<TOOLS>>({
+      async transform(chunk, controller) {
+        // Handle non-smoothable chunks: flush buffer and pass through
+        if (chunk.type !== 'text-delta' && chunk.type !== 'reasoning-delta') {
+          flushBuffer(controller);
+          controller.enqueue(chunk);
+          return;
+        }
+
+        // Flush buffer when type or id changes
+        if ((chunk.type !== type || chunk.id !== id) && buffer.length > 0) {
+          flushBuffer(controller);
+        }
+
+        buffer += chunk.text;
+        id = chunk.id;
+        type = chunk.type;
+
+        // Preserve providerMetadata (e.g., Anthropic thinking signatures)
+        if (chunk.providerMetadata != null) {
+          providerMetadata = chunk.providerMetadata;
+        }
+
+        let match;
+
+        while ((match = detectChunk(buffer)) != null) {
+          controller.enqueue({ type, text: match, id });
+          buffer = buffer.slice(match.length);
+
+          await delay(delayInMs);
+        }
+      },
+    });
+  };
+}

package/src/generate-text/step-result.ts

@@ -0,0 +1,238 @@
+import { ReasoningPart } from '@ai-sdk/provider-utils';
+import {
+  CallWarning,
+  FinishReason,
+  LanguageModelRequestMetadata,
+  LanguageModelResponseMetadata,
+  ProviderMetadata,
+} from '../types';
+import { Source } from '../types/language-model';
+import { LanguageModelUsage } from '../types/usage';
+import { ContentPart } from './content-part';
+import { GeneratedFile } from './generated-file';
+import { ResponseMessage } from './response-message';
+import { DynamicToolCall, StaticToolCall, TypedToolCall } from './tool-call';
+import {
+  DynamicToolResult,
+  StaticToolResult,
+  TypedToolResult,
+} from './tool-result';
+import { ToolSet } from './tool-set';
+
+/**
+ * The result of a single step in the generation process.
+ */
+export type StepResult<TOOLS extends ToolSet> = {
+  /**
+The content that was generated in the last step.
+   */
+  readonly content: Array<ContentPart<TOOLS>>;
+
+  /**
+The generated text.
+*/
+  readonly text: string;
+
+  /**
+The reasoning that was generated during the generation.
+*/
+  readonly reasoning: Array<ReasoningPart>;
+
+  /**
+The reasoning text that was generated during the generation.
+*/
+  readonly reasoningText: string | undefined;
+
+  /**
+The files that were generated during the generation.
+*/
+  readonly files: Array<GeneratedFile>;
+
+  /**
+The sources that were used to generate the text.
+*/
+  readonly sources: Array<Source>;
+
+  /**
+The tool calls that were made during the generation.
+*/
+  readonly toolCalls: Array<TypedToolCall<TOOLS>>;
+
+  /**
+The static tool calls that were made in the last step.
+*/
+  readonly staticToolCalls: Array<StaticToolCall<TOOLS>>;
+
+  /**
+The dynamic tool calls that were made in the last step.
+*/
+  readonly dynamicToolCalls: Array<DynamicToolCall>;
+
+  /**
+The results of the tool calls.
+*/
+  readonly toolResults: Array<TypedToolResult<TOOLS>>;
+
+  /**
+The static tool results that were made in the last step.
+*/
+  readonly staticToolResults: Array<StaticToolResult<TOOLS>>;
+
+  /**
+The dynamic tool results that were made in the last step.
+*/
+  readonly dynamicToolResults: Array<DynamicToolResult>;
+
+  /**
+   * The unified reason why the generation finished.
+   */
+  readonly finishReason: FinishReason;
+
+  /**
+   * The raw reason why the generation finished (from the provider).
+   */
+  readonly rawFinishReason: string | undefined;
+
+  /**
+The token usage of the generated text.
+*/
+  readonly usage: LanguageModelUsage;
+
+  /**
+Warnings from the model provider (e.g. unsupported settings).
+*/
+  readonly warnings: CallWarning[] | undefined;
+
+  /**
+Additional request information.
+   */
+  readonly request: LanguageModelRequestMetadata;
+
+  /**
+Additional response information.
+*/
+  readonly response: LanguageModelResponseMetadata & {
+    /**
+The response messages that were generated during the call.
+Response messages can be either assistant messages or tool messages.
+They contain a generated id.
+*/
+    readonly messages: Array<ResponseMessage>;
+
+    /**
+Response body (available only for providers that use HTTP requests).
+     */
+    body?: unknown;
+  };
+
+  /**
+Additional provider-specific metadata. They are passed through
+from the provider to the AI SDK and enable provider-specific
+results that can be fully encapsulated in the provider.
+   */
+  readonly providerMetadata: ProviderMetadata | undefined;
+};
+
+export class DefaultStepResult<TOOLS extends ToolSet>
+  implements StepResult<TOOLS>
+{
+  readonly content: StepResult<TOOLS>['content'];
+  readonly finishReason: StepResult<TOOLS>['finishReason'];
+  readonly rawFinishReason: StepResult<TOOLS>['rawFinishReason'];
+  readonly usage: StepResult<TOOLS>['usage'];
+  readonly warnings: StepResult<TOOLS>['warnings'];
+  readonly request: StepResult<TOOLS>['request'];
+  readonly response: StepResult<TOOLS>['response'];
+  readonly providerMetadata: StepResult<TOOLS>['providerMetadata'];
+
+  constructor({
+    content,
+    finishReason,
+    rawFinishReason,
+    usage,
+    warnings,
+    request,
+    response,
+    providerMetadata,
+  }: {
+    content: StepResult<TOOLS>['content'];
+    finishReason: StepResult<TOOLS>['finishReason'];
+    rawFinishReason: StepResult<TOOLS>['rawFinishReason'];
+    usage: StepResult<TOOLS>['usage'];
+    warnings: StepResult<TOOLS>['warnings'];
+    request: StepResult<TOOLS>['request'];
+    response: StepResult<TOOLS>['response'];
+    providerMetadata: StepResult<TOOLS>['providerMetadata'];
+  }) {
+    this.content = content;
+    this.finishReason = finishReason;
+    this.rawFinishReason = rawFinishReason;
+    this.usage = usage;
+    this.warnings = warnings;
+    this.request = request;
+    this.response = response;
+    this.providerMetadata = providerMetadata;
+  }
+
+  get text() {
+    return this.content
+      .filter(part => part.type === 'text')
+      .map(part => part.text)
+      .join('');
+  }
+
+  get reasoning() {
+    return this.content.filter(part => part.type === 'reasoning');
+  }
+
+  get reasoningText() {
+    return this.reasoning.length === 0
+      ? undefined
+      : this.reasoning.map(part => part.text).join('');
+  }
+
+  get files() {
+    return this.content
+      .filter(part => part.type === 'file')
+      .map(part => part.file);
+  }
+
+  get sources() {
+    return this.content.filter(part => part.type === 'source');
+  }
+
+  get toolCalls() {
+    return this.content.filter(part => part.type === 'tool-call');
+  }
+
+  get staticToolCalls() {
+    return this.toolCalls.filter(
+      (toolCall): toolCall is StaticToolCall<TOOLS> =>
+        toolCall.dynamic !== true,
+    );
+  }
+
+  get dynamicToolCalls() {
+    return this.toolCalls.filter(
+      (toolCall): toolCall is DynamicToolCall => toolCall.dynamic === true,
+    );
+  }
+
+  get toolResults() {
+    return this.content.filter(part => part.type === 'tool-result');
+  }
+
+  get staticToolResults() {
+    return this.toolResults.filter(
+      (toolResult): toolResult is StaticToolResult<TOOLS> =>
+        toolResult.dynamic !== true,
+    );
+  }
+
+  get dynamicToolResults() {
+    return this.toolResults.filter(
+      (toolResult): toolResult is DynamicToolResult =>
+        toolResult.dynamic === true,
+    );
+  }
+}

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

@@ -0,0 +1,29 @@
+import { StepResult } from './step-result';
+import { ToolSet } from './tool-set';
+
+export type StopCondition<TOOLS extends ToolSet> = (options: {
+  steps: Array<StepResult<TOOLS>>;
+}) => PromiseLike<boolean> | boolean;
+
+export function stepCountIs(stepCount: number): StopCondition<any> {
+  return ({ steps }) => steps.length === stepCount;
+}
+
+export function hasToolCall(toolName: string): StopCondition<any> {
+  return ({ steps }) =>
+    steps[steps.length - 1]?.toolCalls?.some(
+      toolCall => toolCall.toolName === toolName,
+    ) ?? false;
+}
+
+export async function isStopConditionMet<TOOLS extends ToolSet>({
+  stopConditions,
+  steps,
+}: {
+  stopConditions: Array<StopCondition<TOOLS>>;
+  steps: Array<StepResult<TOOLS>>;
+}): Promise<boolean> {
+  return (
+    await Promise.all(stopConditions.map(condition => condition({ steps })))
+  ).some(result => result);
+}