feat(ai): emit streaming chunks throught the onChunk callback (#14331)

## Background

added as work for #14207

when using the streaming functions and logging telemetry via devtools,
the raw chunks couldn't be seen in the viewer.
and that's because the event types weren't being passed through
callbacks

## Summary

dispatch content chunk types through the global onChunk so that
telemetry integrations receive the full stream.

## Manual Verification

verified as a part of #14207

## 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)

Author: aayush-kapoor

.changeset/cyan-wolves-visit.md

@@ -0,0 +1,5 @@
+---
+"ai": patch
+---
+
+feat(ai): emit streaming chunks throught the onChunk callback

packages/ai/src/generate-text/core-events.ts

@@ -342,20 +342,7 @@ export type OnToolCallFinishEvent<TOOLS extends ToolSet = ToolSet> = {
  */
 export interface OnChunkEvent<TOOLS extends ToolSet = ToolSet> {
   readonly chunk:
-    | Extract<
-        TextStreamPart<TOOLS>,
-        {
-          type:
-            | 'text-delta'
-            | 'reasoning-delta'
-            | 'source'
-            | 'tool-call'
-            | 'tool-input-start'
-            | 'tool-input-delta'
-            | 'tool-result'
-            | 'raw';
-        }
-      >
+    | TextStreamPart<TOOLS>
     | {
         readonly type: 'ai.stream.firstChunk' | 'ai.stream.finish';
         readonly callId: string;

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

@@ -23170,6 +23170,187 @@ describe('streamText', () => {
       expect(await result.text).toBe('Hello, world!');
     });
 
+    it('should call integration onChunk with content stream chunks', async () => {
+      const chunks: Array<Record<string, unknown>> = [];
+
+      const result = streamText({
+        model: new MockLanguageModelV4({
+          doStream: async () => ({
+            stream: convertArrayToReadableStream([
+              {
+                type: 'response-metadata',
+                id: 'id-0',
+                modelId: 'mock-model-id',
+                timestamp: new Date(0),
+              },
+              { 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: 'tool-call',
+                toolCallId: 'call-1',
+                toolName: 'testTool',
+                input: '{ "value": "test" }',
+              },
+              {
+                type: 'finish',
+                finishReason: { unified: 'tool-calls', raw: undefined },
+                usage: testUsage,
+              },
+            ]),
+          }),
+        }),
+        tools: {
+          testTool: tool({
+            inputSchema: z.object({ value: z.string() }),
+            execute: async ({ value }) => `${value}-result`,
+          }),
+        },
+        prompt: 'test-input',
+        onError: () => {},
+        experimental_telemetry: {
+          integrations: {
+            onChunk: async event => {
+              chunks.push(event.chunk as Record<string, unknown>);
+            },
+          },
+        },
+      });
+
+      await result.consumeStream();
+
+      expect(chunks.map(c => c.type)).toMatchInlineSnapshot(`
+        [
+          "ai.stream.firstChunk",
+          "text-start",
+          "text-delta",
+          "text-delta",
+          "text-end",
+          "tool-call",
+          "ai.stream.finish",
+          "tool-result",
+        ]
+      `);
+
+      const contentChunks = chunks.filter(
+        c => c.type !== 'ai.stream.firstChunk' && c.type !== 'ai.stream.finish',
+      );
+      expect(contentChunks).toMatchInlineSnapshot(`
+        [
+          {
+            "id": "1",
+            "type": "text-start",
+          },
+          {
+            "id": "1",
+            "providerMetadata": undefined,
+            "text": "Hello",
+            "type": "text-delta",
+          },
+          {
+            "id": "1",
+            "providerMetadata": undefined,
+            "text": ", world!",
+            "type": "text-delta",
+          },
+          {
+            "id": "1",
+            "type": "text-end",
+          },
+          {
+            "input": {
+              "value": "test",
+            },
+            "providerExecuted": undefined,
+            "providerMetadata": undefined,
+            "title": undefined,
+            "toolCallId": "call-1",
+            "toolName": "testTool",
+            "type": "tool-call",
+          },
+          {
+            "dynamic": false,
+            "input": {
+              "value": "test",
+            },
+            "output": "test-result",
+            "toolCallId": "call-1",
+            "toolName": "testTool",
+            "type": "tool-result",
+          },
+        ]
+      `);
+    });
+
+    it('should call integration onChunk with raw chunks when includeRawChunks is enabled', async () => {
+      const chunks: Array<Record<string, unknown>> = [];
+
+      const result = streamText({
+        model: new MockLanguageModelV4({
+          doStream: async () => ({
+            stream: convertArrayToReadableStream([
+              {
+                type: 'response-metadata',
+                id: 'id-0',
+                modelId: 'mock-model-id',
+                timestamp: new Date(0),
+              },
+              { type: 'text-start', id: '1' },
+              {
+                type: 'raw',
+                rawValue: { type: 'content_block_delta', delta: 'Hello' },
+              },
+              { type: 'text-delta', id: '1', delta: 'Hello' },
+              { type: 'text-end', id: '1' },
+              {
+                type: 'finish',
+                finishReason: { unified: 'stop', raw: 'stop' },
+                usage: testUsage,
+              },
+            ]),
+          }),
+        }),
+        prompt: 'test-input',
+        includeRawChunks: true,
+        onError: () => {},
+        experimental_telemetry: {
+          integrations: {
+            onChunk: async event => {
+              chunks.push(event.chunk as Record<string, unknown>);
+            },
+          },
+        },
+      });
+
+      await result.consumeStream();
+
+      const rawChunks = chunks.filter(c => c.type === 'raw');
+      const textChunks = chunks.filter(c => c.type === 'text-delta');
+
+      expect(rawChunks).toMatchInlineSnapshot(`
+        [
+          {
+            "rawValue": {
+              "delta": "Hello",
+              "type": "content_block_delta",
+            },
+            "type": "raw",
+          },
+        ]
+      `);
+      expect(textChunks).toMatchInlineSnapshot(`
+        [
+          {
+            "id": "1",
+            "providerMetadata": undefined,
+            "text": "Hello",
+            "type": "text-delta",
+          },
+        ]
+      `);
+    });
+
     it('should support multiple per-call integrations as an array', async () => {
       const events: string[] = [];
 

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

@@ -1733,10 +1733,6 @@ class DefaultStreamTextResult<
                       warnings: warnings ?? [],
                     });
 
-                    // TODO considering changing to onStreamPart listener
-                    // which receives all stream parts as they are
-                    // (and add necessary information to the stream parts
-                    // where needed)
                     void globalTelemetry.onChunk?.({
                       chunk: {
                         type: 'ai.stream.firstChunk',
@@ -1874,6 +1870,13 @@ class DefaultStreamTextResult<
                       throw new Error(`Unknown chunk type: ${exhaustiveCheck}`);
                     }
                   }
+
+                  if (
+                    chunkType !== 'model-call-end' &&
+                    chunkType !== 'model-call-response-metadata'
+                  ) {
+                    void globalTelemetry.onChunk?.({ chunk });
+                  }
                 },
 
                 // invoke onFinish callback and resolve toolResults promise when the stream is about to close: