ai 7.0.152 → 7.0.154

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

@@ -67,7 +67,7 @@ export function extractJsonMiddleware(options?: {
     specificationVersion: 'v4',
 
     wrapGenerate: async ({ doGenerate }) => {
-      const { content, ...rest } = await doGenerate();
+      const { content, structuredOutputText, ...rest } = await doGenerate();
 
       const transformedContent: LanguageModelV4Content[] = [];
       for (const part of content) {
@@ -82,7 +82,13 @@ export function extractJsonMiddleware(options?: {
         });
       }
 
-      return { content: transformedContent, ...rest };
+      return {
+        content: transformedContent,
+        ...rest,
+        ...(structuredOutputText != null && {
+          structuredOutputText: transform(structuredOutputText),
+        }),
+      };
     },
     wrapStream: async ({ doStream }) => {
       const { stream, ...rest } = await doStream();

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

@@ -42,10 +42,40 @@ export function extractReasoningMiddleware({
   const escapedOpeningTag = openingTag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const escapedClosingTag = closingTag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
+  function extractReasoning(input: string) {
+    const text = startWithReasoning ? openingTag + input : input;
+    const regexp = new RegExp(
+      `${escapedOpeningTag}(.*?)${escapedClosingTag}`,
+      'gs',
+    );
+    const matches = Array.from(text.matchAll(regexp));
+
+    if (!matches.length) {
+      return { text: input, reasoning: undefined };
+    }
+
+    const reasoning = 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;
+    }
+
+    return { text: textWithoutReasoning, reasoning };
+  }
+
   return {
     specificationVersion: 'v4',
     wrapGenerate: async ({ doGenerate }) => {
-      const { content, ...rest } = await doGenerate();
+      const { content, structuredOutputText, ...rest } = await doGenerate();
 
       const transformedContent: LanguageModelV4Content[] = [];
       for (const part of content) {
@@ -54,48 +84,30 @@ export function extractReasoningMiddleware({
           continue;
         }
 
-        const text = startWithReasoning ? openingTag + part.text : part.text;
-
-        const regexp = new RegExp(
-          `${escapedOpeningTag}(.*?)${escapedClosingTag}`,
-          'gs',
-        );
-        const matches = Array.from(text.matchAll(regexp));
-
-        if (!matches.length) {
+        const { text, reasoning } = extractReasoning(part.text);
+        if (reasoning === undefined) {
           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,
+          text: reasoning,
         });
 
         transformedContent.push({
           type: 'text',
-          text: textWithoutReasoning,
+          text,
         });
       }
 
-      return { content: transformedContent, ...rest };
+      return {
+        content: transformedContent,
+        ...rest,
+        ...(structuredOutputText != null && {
+          structuredOutputText: extractReasoning(structuredOutputText).text,
+        }),
+      };
     },
 
     wrapStream: async ({ doStream }) => {

package/src/telemetry/create-telemetry-dispatcher.ts

@@ -1,5 +1,6 @@
 import { asArray, type Context } from '@ai-sdk/provider-utils';
 import type { Callback } from '../util/callback';
+import { VERSION } from '../version';
 import {
   filterIncludedContext,
   filterToolContext,
@@ -61,6 +62,7 @@ function augmentEvent<EVENT>(
       recordInputs: telemetry.recordInputs,
       recordOutputs: telemetry.recordOutputs,
       functionId: telemetry.functionId,
+      aiVersion: VERSION,
     },
   );
 
@@ -224,6 +226,7 @@ export function createTelemetryDispatcher({
       onStepEnd == null && onStepFinish == null
         ? undefined
         : mergeCallbacks(onStepEnd, onStepFinish),
+    onStepError: mergeTelemetryCallback('onStepError'),
     onObjectStepStart: mergeTelemetryCallback('onObjectStepStart'),
     onObjectStepEnd: mergeTelemetryCallback('onObjectStepEnd'),
     onEmbedStart: mergeTelemetryCallback('onEmbedStart'),

package/src/telemetry/telemetry.ts

@@ -22,6 +22,7 @@ import type {
   GenerateTextEndEvent,
   GenerateTextStartEvent,
   GenerateTextStepEndEvent,
+  GenerateTextStepErrorEvent,
   GenerateTextStepStartEvent,
 } from '../generate-text/generate-text-events';
 import type {
@@ -59,7 +60,13 @@ export type InferTelemetryEvent<EVENT> = EVENT &
   Omit<
     TelemetryOptions,
     'integrations' | 'isEnabled' | 'includeRuntimeContext'
-  >;
+  > & {
+    /**
+     * The version of the `ai` package that emitted this event.
+     * Absent in older releases.
+     */
+    readonly aiVersion?: string;
+  };
 
 type BivariantCallback<EVENT> = {
   bivarianceHack(event: EVENT): PromiseLike<void> | void;
@@ -110,6 +117,7 @@ export interface TelemetryDispatcher {
   onStepEnd?: Callback<GenerateTextStepEndEvent>;
   /** @deprecated Use `onStepEnd` instead. */
   onStepFinish?: Callback<GenerateTextStepEndEvent>;
+  onStepError?: Callback<GenerateTextStepErrorEvent>;
   onObjectStepStart?: Callback<GenerateObjectStepStartEvent>;
   onObjectStepEnd?: Callback<GenerateObjectStepEndEvent>;
   onEmbedStart?: Callback<EmbeddingModelCallStartEvent>;
@@ -202,6 +210,12 @@ export interface Telemetry {
    */
   onStepFinish?: Callback<InferTelemetryEvent<GenerateTextStepEndEvent>>;
 
+  /**
+   * Called when a step that started fails before it produces a step result.
+   * Use it to close step-level spans. The call then ends with `onError`.
+   */
+  onStepError?: Callback<InferTelemetryEvent<GenerateTextStepErrorEvent>>;
+
   /**
    * Called when an object generation step (single LLM invocation) begins.
    * For generateObject/streamObject there is always exactly one step.

package/src/util/is-caused-by-abort.ts

@@ -0,0 +1,20 @@
+import { isAbortError } from '@ai-sdk/provider-utils';
+
+/**
+ * Checks if the error is an abort or timeout error, or is caused by one.
+ * Providers can wrap the abort or timeout error, e.g. as the cause of an
+ * API call error.
+ */
+export function isCausedByAbort(error: unknown): boolean {
+  let current = error;
+
+  for (let depth = 0; current != null && depth < 5; depth++) {
+    if (isAbortError(current)) {
+      return true;
+    }
+
+    current = (current as { cause?: unknown }).cause;
+  }
+
+  return false;
+}