@fondation-io/ai 7.0.0-beta.45

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

@@ -0,0 +1,90 @@
+import { JSONObject, LanguageModelV4FunctionTool } 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: 'v4',
+    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 LanguageModelV4FunctionTool;
+      });
+
+      return {
+        ...params,
+        tools: transformedTools,
+      };
+    },
+  };
+}

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

@@ -0,0 +1,22 @@
+import { EmbeddingModelV4CallOptions } 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?: EmbeddingModelV4CallOptions['headers'];
+    providerOptions?: EmbeddingModelV4CallOptions['providerOptions'];
+  }>;
+}): EmbeddingModelMiddleware {
+  return {
+    specificationVersion: 'v4',
+    transformParams: async ({ params }) => {
+      return mergeObjects(settings, params) as EmbeddingModelV4CallOptions;
+    },
+  };
+}

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

@@ -0,0 +1,33 @@
+import { LanguageModelV4CallOptions } 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?: LanguageModelV4CallOptions['maxOutputTokens'];
+    temperature?: LanguageModelV4CallOptions['temperature'];
+    stopSequences?: LanguageModelV4CallOptions['stopSequences'];
+    topP?: LanguageModelV4CallOptions['topP'];
+    topK?: LanguageModelV4CallOptions['topK'];
+    presencePenalty?: LanguageModelV4CallOptions['presencePenalty'];
+    frequencyPenalty?: LanguageModelV4CallOptions['frequencyPenalty'];
+    responseFormat?: LanguageModelV4CallOptions['responseFormat'];
+    seed?: LanguageModelV4CallOptions['seed'];
+    tools?: LanguageModelV4CallOptions['tools'];
+    toolChoice?: LanguageModelV4CallOptions['toolChoice'];
+    headers?: LanguageModelV4CallOptions['headers'];
+    providerOptions?: LanguageModelV4CallOptions['providerOptions'];
+  }>;
+}): LanguageModelMiddleware {
+  return {
+    specificationVersion: 'v4',
+    transformParams: async ({ params }) => {
+      return mergeObjects(settings, params) as LanguageModelV4CallOptions;
+    },
+  };
+}

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

@@ -0,0 +1,197 @@
+import type {
+  LanguageModelV4Content,
+  LanguageModelV4StreamPart,
+} 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: 'v4',
+
+    wrapGenerate: async ({ doGenerate }) => {
+      const { content, ...rest } = await doGenerate();
+
+      const transformedContent: LanguageModelV4Content[] = [];
+      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: LanguageModelV4StreamPart;
+          phase: 'prefix' | 'streaming' | 'buffering';
+          buffer: string;
+          prefixStripped: boolean;
+        }
+      > = {};
+
+      const SUFFIX_BUFFER_SIZE = 12;
+
+      return {
+        stream: stream.pipeThrough(
+          new TransformStream<
+            LanguageModelV4StreamPart,
+            LanguageModelV4StreamPart
+          >({
+            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/src/middleware/extract-reasoning-middleware.ts

@@ -0,0 +1,249 @@
+import type {
+  LanguageModelV4Content,
+  LanguageModelV4StreamPart,
+} 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: 'v4',
+    wrapGenerate: async ({ doGenerate }) => {
+      const { content, ...rest } = await doGenerate();
+
+      const transformedContent: LanguageModelV4Content[] = [];
+      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: LanguageModelV4StreamPart | undefined;
+
+      return {
+        stream: stream.pipeThrough(
+          new TransformStream<
+            LanguageModelV4StreamPart,
+            LanguageModelV4StreamPart
+          >({
+            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/src/middleware/index.ts

@@ -0,0 +1,10 @@
+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/src/middleware/simulate-streaming-middleware.ts

@@ -0,0 +1,79 @@
+import type { LanguageModelV4StreamPart } from '@ai-sdk/provider';
+import { LanguageModelMiddleware } from '../types';
+
+/**
+ * Simulates streaming chunks with the response from a generate call.
+ */
+export function simulateStreamingMiddleware(): LanguageModelMiddleware {
+  return {
+    specificationVersion: 'v4',
+    wrapStream: async ({ doGenerate }) => {
+      const result = await doGenerate();
+
+      let id = 0;
+
+      const simulatedStream = new ReadableStream<LanguageModelV4StreamPart>({
+        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,
+      };
+    },
+  };
+}