fix(ai): skip stringifying text when streaming partial text (#14123)

## Background

#13839

streamText with the default text output called JSON.stringify on the
full accumulated text on every single streaming chunk that creates
increasingly large string copies per stream casuing memory issues

## Summary

- skip `JSON.stringify` when the partial output is already a string
- structured outputs still go through stringify as before since they
need serialization to compare.
- compare the text directly
- no extra full-string serialization per chunk

## Manual Verification

tried reproducing via 
<details>
<summary>repro</summary>

```ts
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';
import { run } from '../../lib/run';

run(async () => {
  const result = streamText({
    model: openai.responses('gpt-4o-mini'),
    prompt:
      'Write an extremely detailed 5000-word essay about the history of computing. Include every detail you can.',
  });

  let chunks = 0;
  for await (const textPart of result.textStream) {
    chunks++;
    if (chunks % 100 === 0) {
      const mb = (process.memoryUsage().heapUsed / 1024 / 1024).toFixed(1);
      console.log(`chunk ${chunks} — heap: ${mb}MB`);
    }
  }

  console.log(`\nTotal chunks: ${chunks}`);
  console.log(
    `Final heap: ${(process.memoryUsage().heapUsed / 1024 / 1024).toFixed(1)}MB`,
  );
});
```
</details>

## Checklist

- [x] Tests have been added / updated (for bug fixes / features)
- [ ] Documentation has been added / updated (for bug fixes / features)
- [x] A _patch_ changeset for relevant packages has been added (for bug
fixes / features - run `pnpm changeset` in the project root)
- [x] I have reviewed this pull request (self-review)

## Related Issues

fixes #13839

Author: aayush-kapoor

.changeset/empty-cups-love.md

@@ -0,0 +1,5 @@
+---
+"ai": patch
+---
+
+fix(ai): skip stringifying text when streaming partial text

packages/ai/src/generate-text/stream-text.test.ts

@@ -15190,6 +15190,50 @@ describe('streamText', () => {
         `);
       });
 
+      it('should not call JSON.stringify for string partial outputs', async () => {
+        const originalStringify = JSON.stringify;
+        const stringifySpy = vi.spyOn(JSON, 'stringify').mockImplementation(((
+          ...args: Parameters<typeof JSON.stringify>
+        ) => {
+          if (typeof args[0] === 'string') {
+            throw new Error(
+              'JSON.stringify should not be called for string partial outputs',
+            );
+          }
+          return originalStringify.call(JSON, ...args);
+        }) as typeof JSON.stringify);
+
+        try {
+          const result = streamText({
+            model: createTestModel({
+              stream: convertArrayToReadableStream([
+                { type: 'text-start', id: '1' },
+                { type: 'text-delta', id: '1', delta: 'Hello, ' },
+                { type: 'text-delta', id: '1', delta: 'world!' },
+                { type: 'text-end', id: '1' },
+                {
+                  type: 'finish',
+                  finishReason: { unified: 'stop', raw: 'stop' },
+                  usage: testUsage,
+                },
+              ]),
+            }),
+            prompt: 'prompt',
+            output: Output.text(),
+          });
+
+          expect(await convertAsyncIterableToArray(result.partialOutputStream))
+            .toMatchInlineSnapshot(`
+            [
+              "Hello, ",
+              "Hello, world!",
+            ]
+          `);
+        } finally {
+          stringifySpy.mockRestore();
+        }
+      });
+
       it('should resolve output promise with the correct content', async () => {
         const result = streamText({
           model: createTestModel({

packages/ai/src/generate-text/stream-text.ts

@@ -600,7 +600,7 @@ function createOutputTransformStream<
   let text = '';
   let textChunk = '';
   let textProviderMetadata: ProviderMetadata | undefined = undefined;
-  let lastPublishedJson = '';
+  let lastPublishedValue = '';
 
   function publishTextChunk({
     controller,
@@ -673,11 +673,15 @@ function createOutputTransformStream<
 
       // null should be allowed (valid JSON value) but undefined should not:
       if (result !== undefined) {
-        // only send new json if it has changed:
-        const currentJson = JSON.stringify(result.partial);
-        if (currentJson !== lastPublishedJson) {
+        // only send new value if it has changed:
+        // For string partials (text output), compare directly to avoid unnecessary JSON.stringify overhead
+        const currentValue =
+          typeof result.partial === 'string'
+            ? result.partial
+            : JSON.stringify(result.partial);
+        if (currentValue !== lastPublishedValue) {
           publishTextChunk({ controller, partialOutput: result.partial });
-          lastPublishedJson = currentJson;
+          lastPublishedValue = currentValue;
         }
       }
     },