ima2-gen 3.20.0 → 3.21.0

package/node_modules/ai/src/middleware/add-tool-input-examples-middleware.ts

@@ -1,90 +0,0 @@
-import { JSONObject, LanguageModelV3FunctionTool } from '@ai-sdk/provider';
-import { LanguageModelMiddleware } from '../types';
-
-function defaultFormatExample(example: { input: JSONObject }): string {
-  return JSON.stringify(example.input);
-}
-
-/**
- * Middleware that appends input examples to tool descriptions.
- *
- * This is useful for providers that don't natively support the `inputExamples`
- * property. The middleware serializes examples into the tool's description text.
- *
- * @param options - Configuration options for the middleware.
- * @param options.prefix - A prefix to prepend before the examples. Default: 'Input Examples:'
- * @param options.format - Optional custom formatter for each example.
- *   Receives the example object and its index. Default: JSON.stringify(example.input)
- * @param options.remove - Whether to remove the inputExamples property
- *   after adding them to the description. Default: true
- *
- * @example
- * ```ts
- * import { wrapLanguageModel, addToolInputExamplesMiddleware } from 'ai';
- *
- * const model = wrapLanguageModel({
- *   model: yourModel,
- *   middleware: addToolInputExamplesMiddleware(),
- * });
- * ```
- */
-export function addToolInputExamplesMiddleware({
-  prefix = 'Input Examples:',
-  format = defaultFormatExample,
-  remove = true,
-}: {
-  /**
-   * A prefix to prepend before the examples.
-   */
-  prefix?: string;
-
-  /**
-   * Optional custom formatter for each example.
-   * Receives the example object and its index.
-   * Default: JSON.stringify(example.input)
-   */
-  format?: (example: { input: JSONObject }, index: number) => string;
-
-  /**
-   * Whether to remove the inputExamples property after adding them to the description.
-   * Default: true
-   */
-  remove?: boolean;
-} = {}): LanguageModelMiddleware {
-  return {
-    specificationVersion: 'v3',
-    transformParams: async ({ params }) => {
-      if (!params.tools?.length) {
-        return params;
-      }
-
-      const transformedTools = params.tools.map(tool => {
-        // Only transform function tools that have inputExamples
-        if (tool.type !== 'function' || !tool.inputExamples?.length) {
-          return tool;
-        }
-
-        const formattedExamples = tool.inputExamples
-          .map((example, index) => format(example, index))
-          .join('\n');
-
-        const examplesSection = `${prefix}\n${formattedExamples}`;
-
-        const toolDescription = tool.description
-          ? `${tool.description}\n\n${examplesSection}`
-          : examplesSection;
-
-        return {
-          ...tool,
-          description: toolDescription,
-          inputExamples: remove ? undefined : tool.inputExamples,
-        } satisfies LanguageModelV3FunctionTool;
-      });
-
-      return {
-        ...params,
-        tools: transformedTools,
-      };
-    },
-  };
-}

package/node_modules/ai/src/middleware/default-embedding-settings-middleware.ts

@@ -1,22 +0,0 @@
-import { EmbeddingModelV3CallOptions } from '@ai-sdk/provider';
-import { EmbeddingModelMiddleware } from '../types';
-import { mergeObjects } from '../util/merge-objects';
-
-/**
- * Applies default settings for an embedding model.
- */
-export function defaultEmbeddingSettingsMiddleware({
-  settings,
-}: {
-  settings: Partial<{
-    headers?: EmbeddingModelV3CallOptions['headers'];
-    providerOptions?: EmbeddingModelV3CallOptions['providerOptions'];
-  }>;
-}): EmbeddingModelMiddleware {
-  return {
-    specificationVersion: 'v3',
-    transformParams: async ({ params }) => {
-      return mergeObjects(settings, params) as EmbeddingModelV3CallOptions;
-    },
-  };
-}

package/node_modules/ai/src/middleware/default-settings-middleware.ts

@@ -1,33 +0,0 @@
-import { LanguageModelV3CallOptions } from '@ai-sdk/provider';
-import { LanguageModelMiddleware } from '../types';
-import { mergeObjects } from '../util/merge-objects';
-
-/**
- * Applies default settings for a language model.
- */
-export function defaultSettingsMiddleware({
-  settings,
-}: {
-  settings: Partial<{
-    maxOutputTokens?: LanguageModelV3CallOptions['maxOutputTokens'];
-    temperature?: LanguageModelV3CallOptions['temperature'];
-    stopSequences?: LanguageModelV3CallOptions['stopSequences'];
-    topP?: LanguageModelV3CallOptions['topP'];
-    topK?: LanguageModelV3CallOptions['topK'];
-    presencePenalty?: LanguageModelV3CallOptions['presencePenalty'];
-    frequencyPenalty?: LanguageModelV3CallOptions['frequencyPenalty'];
-    responseFormat?: LanguageModelV3CallOptions['responseFormat'];
-    seed?: LanguageModelV3CallOptions['seed'];
-    tools?: LanguageModelV3CallOptions['tools'];
-    toolChoice?: LanguageModelV3CallOptions['toolChoice'];
-    headers?: LanguageModelV3CallOptions['headers'];
-    providerOptions?: LanguageModelV3CallOptions['providerOptions'];
-  }>;
-}): LanguageModelMiddleware {
-  return {
-    specificationVersion: 'v3',
-    transformParams: async ({ params }) => {
-      return mergeObjects(settings, params) as LanguageModelV3CallOptions;
-    },
-  };
-}

package/node_modules/ai/src/middleware/extract-json-middleware.ts

@@ -1,197 +0,0 @@
-import type {
-  LanguageModelV3Content,
-  LanguageModelV3StreamPart,
-} from '@ai-sdk/provider';
-import { LanguageModelMiddleware } from '../types/language-model-middleware';
-
-/**
- * Default transform function that strips markdown code fences from text.
- */
-function defaultTransform(text: string): string {
-  return text
-    .replace(/^```(?:json)?\s*\n?/, '')
-    .replace(/\n?```\s*$/, '')
-    .trim();
-}
-
-/**
- * Middleware that extracts JSON from text content by stripping
- * markdown code fences and other formatting.
- *
- * This is useful when using Output.object() with models that wrap
- * JSON responses in markdown code blocks.
- *
- * @param options - Configuration options for the middleware.
- * @param options.transform - Custom transform function. If provided, this will be
- * used instead of the default markdown fence stripping.
- */
-export function extractJsonMiddleware(options?: {
-  /**
-   * Custom transform function to apply to text content.
-   * Receives the raw text and should return the transformed text.
-   * If not provided, the default transform strips markdown code fences.
-   */
-  transform?: (text: string) => string;
-}): LanguageModelMiddleware {
-  const transform = options?.transform ?? defaultTransform;
-  const hasCustomTransform = options?.transform !== undefined;
-
-  return {
-    specificationVersion: 'v3',
-
-    wrapGenerate: async ({ doGenerate }) => {
-      const { content, ...rest } = await doGenerate();
-
-      const transformedContent: LanguageModelV3Content[] = [];
-      for (const part of content) {
-        if (part.type !== 'text') {
-          transformedContent.push(part);
-          continue;
-        }
-
-        transformedContent.push({
-          ...part,
-          text: transform(part.text),
-        });
-      }
-
-      return { content: transformedContent, ...rest };
-    },
-    wrapStream: async ({ doStream }) => {
-      const { stream, ...rest } = await doStream();
-
-      const textBlocks: Record<
-        string,
-        {
-          startEvent: LanguageModelV3StreamPart;
-          phase: 'prefix' | 'streaming' | 'buffering';
-          buffer: string;
-          prefixStripped: boolean;
-        }
-      > = {};
-
-      const SUFFIX_BUFFER_SIZE = 12;
-
-      return {
-        stream: stream.pipeThrough(
-          new TransformStream<
-            LanguageModelV3StreamPart,
-            LanguageModelV3StreamPart
-          >({
-            transform: (chunk, controller) => {
-              if (chunk.type === 'text-start') {
-                textBlocks[chunk.id] = {
-                  startEvent: chunk,
-                  // Custom transforms need to buffer all content
-                  phase: hasCustomTransform ? 'buffering' : 'prefix',
-                  buffer: '',
-                  prefixStripped: false,
-                };
-                return;
-              }
-
-              if (chunk.type === 'text-delta') {
-                const block = textBlocks[chunk.id];
-                if (!block) {
-                  controller.enqueue(chunk);
-                  return;
-                }
-
-                block.buffer += chunk.delta;
-
-                // Custom transform: buffer everything, transform at end
-                if (block.phase === 'buffering') {
-                  return;
-                }
-
-                if (block.phase === 'prefix') {
-                  // Check if we can determine prefix status
-                  if (
-                    block.buffer.length > 0 &&
-                    !block.buffer.startsWith('`')
-                  ) {
-                    block.phase = 'streaming';
-                    controller.enqueue(block.startEvent);
-                  } else if (block.buffer.startsWith('```')) {
-                    // Only strip prefix when we have a newline (fence is complete)
-                    if (block.buffer.includes('\n')) {
-                      const prefixMatch =
-                        block.buffer.match(/^```(?:json)?\s*\n/);
-                      if (prefixMatch) {
-                        block.buffer = block.buffer.slice(
-                          prefixMatch[0].length,
-                        );
-                        block.prefixStripped = true;
-                        block.phase = 'streaming';
-                        controller.enqueue(block.startEvent);
-                      } else {
-                        // Has newline but doesn't match fence pattern
-                        block.phase = 'streaming';
-                        controller.enqueue(block.startEvent);
-                      }
-                    }
-                    // else keep buffering until we see a newline
-                  } else if (
-                    block.buffer.length >= 3 &&
-                    !block.buffer.startsWith('```')
-                  ) {
-                    block.phase = 'streaming';
-                    controller.enqueue(block.startEvent);
-                  }
-                }
-
-                // Stream content
-                if (
-                  block.phase === 'streaming' &&
-                  block.buffer.length > SUFFIX_BUFFER_SIZE
-                ) {
-                  const toStream = block.buffer.slice(0, -SUFFIX_BUFFER_SIZE);
-                  block.buffer = block.buffer.slice(-SUFFIX_BUFFER_SIZE);
-                  controller.enqueue({
-                    type: 'text-delta',
-                    id: chunk.id,
-                    delta: toStream,
-                  });
-                }
-                return;
-              }
-
-              if (chunk.type === 'text-end') {
-                const block = textBlocks[chunk.id];
-                if (block) {
-                  if (block.phase === 'prefix' || block.phase === 'buffering') {
-                    controller.enqueue(block.startEvent);
-                  }
-
-                  let remaining = block.buffer;
-                  if (block.phase === 'buffering') {
-                    remaining = transform(remaining);
-                  } else if (block.prefixStripped) {
-                    // strip suffix since prefix already handled
-                    remaining = remaining.replace(/\n?```\s*$/, '').trimEnd();
-                  } else {
-                    // Apply full transform (handles both prefix and suffix)
-                    remaining = transform(remaining);
-                  }
-
-                  if (remaining.length > 0) {
-                    controller.enqueue({
-                      type: 'text-delta',
-                      id: chunk.id,
-                      delta: remaining,
-                    });
-                  }
-                  controller.enqueue(chunk);
-                  delete textBlocks[chunk.id];
-                  return;
-                }
-              }
-              controller.enqueue(chunk);
-            },
-          }),
-        ),
-        ...rest,
-      };
-    },
-  };
-}

package/node_modules/ai/src/middleware/extract-reasoning-middleware.ts

@@ -1,249 +0,0 @@
-import type {
-  LanguageModelV3Content,
-  LanguageModelV3StreamPart,
-} from '@ai-sdk/provider';
-import { LanguageModelMiddleware } from '../types/language-model-middleware';
-import { getPotentialStartIndex } from '../util/get-potential-start-index';
-
-/**
- * Extracts an XML-tagged reasoning section from the generated text and exposes it
- * as a `reasoning` property on the result.
- *
- * @param tagName - The name of the XML tag to extract reasoning from.
- * @param separator - The separator to use between reasoning and text sections.
- * @param startWithReasoning - Whether to start with reasoning tokens.
- */
-export function extractReasoningMiddleware({
-  tagName,
-  separator = '\n',
-  startWithReasoning = false,
-}: {
-  tagName: string;
-  separator?: string;
-  startWithReasoning?: boolean;
-}): LanguageModelMiddleware {
-  const openingTag = `<${tagName}>`;
-  const closingTag = `<\/${tagName}>`;
-
-  return {
-    specificationVersion: 'v3',
-    wrapGenerate: async ({ doGenerate }) => {
-      const { content, ...rest } = await doGenerate();
-
-      const transformedContent: LanguageModelV3Content[] = [];
-      for (const part of content) {
-        if (part.type !== 'text') {
-          transformedContent.push(part);
-          continue;
-        }
-
-        const text = startWithReasoning ? openingTag + part.text : part.text;
-
-        const regexp = new RegExp(`${openingTag}(.*?)${closingTag}`, 'gs');
-        const matches = Array.from(text.matchAll(regexp));
-
-        if (!matches.length) {
-          transformedContent.push(part);
-          continue;
-        }
-
-        const reasoningText = matches.map(match => match[1]).join(separator);
-
-        let textWithoutReasoning = text;
-        for (let i = matches.length - 1; i >= 0; i--) {
-          const match = matches[i];
-
-          const beforeMatch = textWithoutReasoning.slice(0, match.index);
-          const afterMatch = textWithoutReasoning.slice(
-            match.index! + match[0].length,
-          );
-
-          textWithoutReasoning =
-            beforeMatch +
-            (beforeMatch.length > 0 && afterMatch.length > 0 ? separator : '') +
-            afterMatch;
-        }
-
-        transformedContent.push({
-          type: 'reasoning',
-          text: reasoningText,
-        });
-
-        transformedContent.push({
-          type: 'text',
-          text: textWithoutReasoning,
-        });
-      }
-
-      return { content: transformedContent, ...rest };
-    },
-
-    wrapStream: async ({ doStream }) => {
-      const { stream, ...rest } = await doStream();
-
-      const reasoningExtractions: Record<
-        string,
-        {
-          isFirstReasoning: boolean;
-          isFirstText: boolean;
-          afterSwitch: boolean;
-          isReasoning: boolean;
-          buffer: string;
-          idCounter: number;
-          textId: string;
-        }
-      > = {};
-
-      let delayedTextStart: LanguageModelV3StreamPart | undefined;
-
-      return {
-        stream: stream.pipeThrough(
-          new TransformStream<
-            LanguageModelV3StreamPart,
-            LanguageModelV3StreamPart
-          >({
-            transform: (chunk, controller) => {
-              // do not send `text-start` before `reasoning-start`
-              // https://github.com/vercel/ai/issues/7774
-              if (chunk.type === 'text-start') {
-                delayedTextStart = chunk;
-                return;
-              }
-
-              if (chunk.type === 'text-end' && delayedTextStart) {
-                controller.enqueue(delayedTextStart);
-                delayedTextStart = undefined;
-              }
-
-              if (chunk.type !== 'text-delta') {
-                controller.enqueue(chunk);
-                return;
-              }
-
-              if (reasoningExtractions[chunk.id] == null) {
-                reasoningExtractions[chunk.id] = {
-                  isFirstReasoning: true,
-                  isFirstText: true,
-                  afterSwitch: false,
-                  isReasoning: startWithReasoning,
-                  buffer: '',
-                  idCounter: 0,
-                  textId: chunk.id,
-                };
-              }
-
-              const activeExtraction = reasoningExtractions[chunk.id];
-
-              activeExtraction.buffer += chunk.delta;
-
-              function publish(text: string) {
-                if (text.length > 0) {
-                  const prefix =
-                    activeExtraction.afterSwitch &&
-                    (activeExtraction.isReasoning
-                      ? !activeExtraction.isFirstReasoning
-                      : !activeExtraction.isFirstText)
-                      ? separator
-                      : '';
-
-                  if (
-                    activeExtraction.isReasoning &&
-                    (activeExtraction.afterSwitch ||
-                      activeExtraction.isFirstReasoning)
-                  ) {
-                    controller.enqueue({
-                      type: 'reasoning-start',
-                      id: `reasoning-${activeExtraction.idCounter}`,
-                    });
-                  }
-
-                  if (activeExtraction.isReasoning) {
-                    controller.enqueue({
-                      type: 'reasoning-delta',
-                      delta: prefix + text,
-                      id: `reasoning-${activeExtraction.idCounter}`,
-                    });
-                  } else {
-                    if (delayedTextStart) {
-                      controller.enqueue(delayedTextStart);
-                      delayedTextStart = undefined;
-                    }
-                    controller.enqueue({
-                      type: 'text-delta',
-                      delta: prefix + text,
-                      id: activeExtraction.textId,
-                    });
-                  }
-                  activeExtraction.afterSwitch = false;
-
-                  if (activeExtraction.isReasoning) {
-                    activeExtraction.isFirstReasoning = false;
-                  } else {
-                    activeExtraction.isFirstText = false;
-                  }
-                }
-              }
-
-              do {
-                const nextTag = activeExtraction.isReasoning
-                  ? closingTag
-                  : openingTag;
-
-                const startIndex = getPotentialStartIndex(
-                  activeExtraction.buffer,
-                  nextTag,
-                );
-
-                // no opening or closing tag found, publish the buffer
-                if (startIndex == null) {
-                  publish(activeExtraction.buffer);
-                  activeExtraction.buffer = '';
-                  break;
-                }
-
-                // publish text before the tag
-                publish(activeExtraction.buffer.slice(0, startIndex));
-
-                const foundFullMatch =
-                  startIndex + nextTag.length <= activeExtraction.buffer.length;
-
-                if (foundFullMatch) {
-                  activeExtraction.buffer = activeExtraction.buffer.slice(
-                    startIndex + nextTag.length,
-                  );
-
-                  if (activeExtraction.isReasoning) {
-                    // Emit reasoning-start for empty reasoning blocks (no delta was published).
-                    // This handles both cases:
-                    // - startWithReasoning=false: <think></think> (afterSwitch=true)
-                    // - startWithReasoning=true: immediate </think> (afterSwitch=false)
-                    if (activeExtraction.isFirstReasoning) {
-                      controller.enqueue({
-                        type: 'reasoning-start',
-                        id: `reasoning-${activeExtraction.idCounter}`,
-                      });
-                    }
-
-                    // reasoning part finished:
-                    controller.enqueue({
-                      type: 'reasoning-end',
-                      id: `reasoning-${activeExtraction.idCounter++}`,
-                    });
-                  }
-
-                  activeExtraction.isReasoning = !activeExtraction.isReasoning;
-                  activeExtraction.afterSwitch = true;
-                } else {
-                  activeExtraction.buffer =
-                    activeExtraction.buffer.slice(startIndex);
-                  break;
-                }
-              } while (true);
-            },
-          }),
-        ),
-        ...rest,
-      };
-    },
-  };
-}

package/node_modules/ai/src/middleware/index.ts

@@ -1,10 +0,0 @@
-export { defaultEmbeddingSettingsMiddleware } from './default-embedding-settings-middleware';
-export { defaultSettingsMiddleware } from './default-settings-middleware';
-export { extractJsonMiddleware } from './extract-json-middleware';
-export { extractReasoningMiddleware } from './extract-reasoning-middleware';
-export { simulateStreamingMiddleware } from './simulate-streaming-middleware';
-export { addToolInputExamplesMiddleware } from './add-tool-input-examples-middleware';
-export { wrapLanguageModel } from './wrap-language-model';
-export { wrapEmbeddingModel } from './wrap-embedding-model';
-export { wrapImageModel } from './wrap-image-model';
-export { wrapProvider } from './wrap-provider';

package/node_modules/ai/src/middleware/simulate-streaming-middleware.ts

@@ -1,79 +0,0 @@
-import type { LanguageModelV3StreamPart } from '@ai-sdk/provider';
-import { LanguageModelMiddleware } from '../types';
-
-/**
- * Simulates streaming chunks with the response from a generate call.
- */
-export function simulateStreamingMiddleware(): LanguageModelMiddleware {
-  return {
-    specificationVersion: 'v3',
-    wrapStream: async ({ doGenerate }) => {
-      const result = await doGenerate();
-
-      let id = 0;
-
-      const simulatedStream = new ReadableStream<LanguageModelV3StreamPart>({
-        start(controller) {
-          controller.enqueue({
-            type: 'stream-start',
-            warnings: result.warnings,
-          });
-
-          controller.enqueue({ type: 'response-metadata', ...result.response });
-
-          for (const part of result.content) {
-            switch (part.type) {
-              case 'text': {
-                if (part.text.length > 0) {
-                  controller.enqueue({ type: 'text-start', id: String(id) });
-                  controller.enqueue({
-                    type: 'text-delta',
-                    id: String(id),
-                    delta: part.text,
-                  });
-                  controller.enqueue({ type: 'text-end', id: String(id) });
-                  id++;
-                }
-                break;
-              }
-              case 'reasoning': {
-                controller.enqueue({
-                  type: 'reasoning-start',
-                  id: String(id),
-                  providerMetadata: part.providerMetadata,
-                });
-                controller.enqueue({
-                  type: 'reasoning-delta',
-                  id: String(id),
-                  delta: part.text,
-                });
-                controller.enqueue({ type: 'reasoning-end', id: String(id) });
-                id++;
-                break;
-              }
-              default: {
-                controller.enqueue(part);
-                break;
-              }
-            }
-          }
-
-          controller.enqueue({
-            type: 'finish',
-            finishReason: result.finishReason,
-            usage: result.usage,
-            providerMetadata: result.providerMetadata,
-          });
-
-          controller.close();
-        },
-      });
-
-      return {
-        stream: simulatedStream,
-        request: result.request,
-        response: result.response,
-      };
-    },
-  };
-}