extractReasoningMiddleware loses text when text blocks overlap

[brennanbutler01]

Description

extractReasoningMiddleware loses a text block's start event when a provider opens two text blocks before emitting their deltas. The final text then omits the earlier block, and fullStream contains text part a not found errors.

The same stream works without the middleware. There are no reasoning tags in this reproduction, so adding the middleware should preserve both blocks.

The cause appears to be delayedTextStart in packages/ai/src/middleware/extract-reasoning-middleware.ts: it stores one event for the whole stream, while the rest of the extraction state is keyed by text ID. text-start(b) overwrites the saved text-start(a). When a's delta arrives, the middleware emits b's start followed by a's delta.

Reproduction

No API key or network calls needed. Install ai@7.0.101 and zod@4.4.3, save as repro.mts, and run node repro.mts with Node 24:

import { extractReasoningMiddleware, streamText, wrapLanguageModel } from 'ai';
import { MockLanguageModelV4 } from 'ai/test';

for (const wrapped of [false, true]) {
  const model = new MockLanguageModelV4({ doStream: { stream: new ReadableStream({ start(controller) {
    controller.enqueue({ type: 'stream-start', warnings: [] });
    controller.enqueue({ type: 'text-start', id: 'a' });
    controller.enqueue({ type: 'text-start', id: 'b' });
    controller.enqueue({ type: 'text-delta', id: 'a', delta: 'Alpha.' });
    controller.enqueue({ type: 'text-delta', id: 'b', delta: 'Beta.' });
    controller.enqueue({ type: 'text-end', id: 'a' });
    controller.enqueue({ type: 'text-end', id: 'b' });
    controller.enqueue({ type: 'finish', finishReason: { unified: 'stop', raw: 'stop' }, usage: {
      inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
      outputTokens: { total: 1, text: 1, reasoning: 0 },
    } });
    controller.close();
  } }) } });
  const errors: unknown[] = [];
  const result = streamText({
    model: wrapped ? wrapLanguageModel({ model, middleware: extractReasoningMiddleware({ tagName: 'think' }) }) : model,
    prompt: 'Synthetic prompt.',
    maxRetries: 0,
  });
  for await (const event of result.fullStream) {
    if (event.type === 'error') errors.push(event.error);
  }
  console.log({ wrapped, text: await result.text, errors });
}

Actual output:

{ wrapped: false, text: 'Alpha.Beta.', errors: [] }
{
  wrapped: true,
  text: 'Beta.',
  errors: [ 'text part a not found', 'text part a not found' ]
}

Expected: both runs return Alpha.Beta. with no error chunks.

I reproduced this on Node 22.20.0 and 24.13.0. Sequential text blocks pass with or without the middleware, and overlapping blocks pass without it. The reproduction passes strict TypeScript checking. The middleware source is unchanged on main at 12845693d7a6a517dc633d6b6a2e4f5bfd24d2ec (source comparison; runtime tests used the published package).

I checked #7774 / #8036, which introduced the delayed start, and #7305. This case concerns distinct text IDs losing their start event, rather than when reasoning is displayed. PR #15583 concerns unfinished tag buffering.

I used AI assistance to investigate and prepare the reproduction and tests.

AI SDK Version

• ai: 7.0.101
• zod: 4.4.3
• Node.js: 22.20.0 and 24.13.0

Code of Conduct

• I agree to follow this project's Code of Conduct

[ai-sdk-factory]

Identify issue type

Identified as Bug
Confidence: High

Rationale

This is a concrete, reproducible failure in existing middleware behavior: enabling reasoning extraction incorrectly drops text and generates errors even when no reasoning tags are present.

Evidence

• With extractReasoningMiddleware enabled, overlapping text blocks produce only Beta. instead of Alpha.Beta. and emit text part a not found errors.
• The same synthetic provider stream works correctly without the middleware.
• The report identifies a likely state-handling defect: a stream-wide delayedTextStart allows text-start(b) to overwrite text-start(a).

[ai-sdk-factory]

Bug Reproduction - AI SDK 7

Bug was reproduced.

Branch: main
PR: successful reproduction pull request

Details

• On main at 12845693d7, the unwrapped stream returned Alpha.Beta. with no errors, while extractReasoningMiddleware returned only Beta. and emitted two text part a not found errors.
• Expected behavior is for middleware to preserve both overlapping text blocks when the stream contains no reasoning tags.
• packages/ai/src/middleware/extract-reasoning-middleware.ts stores only one stream-wide delayedTextStart, allowing block b to replace block a before their deltas arrive.
• The checked-out ai version is 7.0.105, so the failure reported with 7.0.101 remains present on the target branch.
• Runnable reproduction examples/ai-functions/src/reproduction/extract-reasoning-overlapping-text-blocks.ts asserts the final text and absence of error chunks.

[ai-sdk-factory]

Bugfix - AI SDK 7

Created bugfix and opened PR: #21059

Root Cause

The middleware stored one stream-wide delayed text-start event, so text-start(b) overwrote text-start(a) before a's delta arrived. The original reproduction confirmed this ordering caused the missing text and errors.

Summary

Stored delayed text-start events by text ID, emitted and removed the matching event when its delta or end arrived, removed reproduction-only artifacts, and added an ai patch changeset.

Testing

Added a regression test with two concurrently open text parts that verifies the complete Alpha.Beta. output and absence of error chunks.