fix: resolve type errors from @ag-ui/core Zod passthrough types

Zod passthrough adds `& { [k: string]: unknown }` to inferred types,
preventing TypeScript from narrowing the `type` discriminant in switch
statements. Add explicit casts where needed. Also fix toolCallName ->
toolName rename in realtime types to match consumer code.

Author: AlemTuzlak

packages/typescript/ai-openai/src/realtime/adapter.ts

@@ -284,11 +284,11 @@ async function createWebRTCConnection(
         }
         try {
           const input = JSON.parse(args)
-          emit('tool_call', { toolCallId: callId, toolCallName: name, input })
+          emit('tool_call', { toolCallId: callId, toolName: name, input })
         } catch {
           emit('tool_call', {
             toolCallId: callId,
-            toolCallName: name,
+            toolName: name,
             input: args,
           })
         }

packages/typescript/ai/src/activities/chat/middleware/compose.ts

@@ -132,14 +132,16 @@ export class MiddlewareRunner {
 
       const nextChunks: Array<StreamChunk> = []
       for (const c of chunks) {
+        // Cast: @ag-ui/core Zod passthrough types prevent direct `.type` access
+        const chunkType = (c as StreamChunk & { type: string }).type
         const result = await mw.onChunk(ctx, c)
         if (result === null) {
           // Drop this chunk
           if (!skip) {
             aiEventClient.emit('middleware:chunk:transformed', {
               ...instrumentCtx(ctx),
               middlewareName: mw.name || 'unnamed',
-              originalChunkType: c.type,
+              originalChunkType: chunkType,
               resultCount: 0,
               wasDropped: true,
             })
@@ -155,7 +157,7 @@ export class MiddlewareRunner {
             aiEventClient.emit('middleware:chunk:transformed', {
               ...instrumentCtx(ctx),
               middlewareName: mw.name || 'unnamed',
-              originalChunkType: c.type,
+              originalChunkType: chunkType,
               resultCount: result.length,
               wasDropped: false,
             })
@@ -167,7 +169,7 @@ export class MiddlewareRunner {
             aiEventClient.emit('middleware:chunk:transformed', {
               ...instrumentCtx(ctx),
               middlewareName: mw.name || 'unnamed',
-              originalChunkType: c.type,
+              originalChunkType: chunkType,
               resultCount: 1,
               wasDropped: false,
             })

packages/typescript/ai/src/activities/chat/stream/processor.ts

@@ -445,54 +445,57 @@ export class StreamProcessor {
       })
     }
 
-    switch (chunk.type) {
+    // Cast needed: @ag-ui/core Zod passthrough types add `& { [k: string]: unknown }`
+    // which prevents TypeScript from narrowing the `type` discriminant in switch.
+    const c = chunk as StreamChunk & { type: string }
+    switch (c.type) {
       // AG-UI Events
       case 'TEXT_MESSAGE_START':
-        this.handleTextMessageStartEvent(chunk)
+        this.handleTextMessageStartEvent(chunk as Extract<StreamChunk, { type: 'TEXT_MESSAGE_START' }>)
         break
 
       case 'TEXT_MESSAGE_CONTENT':
-        this.handleTextMessageContentEvent(chunk)
+        this.handleTextMessageContentEvent(chunk as Extract<StreamChunk, { type: 'TEXT_MESSAGE_CONTENT' }>)
         break
 
       case 'TEXT_MESSAGE_END':
-        this.handleTextMessageEndEvent(chunk)
+        this.handleTextMessageEndEvent(chunk as Extract<StreamChunk, { type: 'TEXT_MESSAGE_END' }>)
         break
 
       case 'TOOL_CALL_START':
-        this.handleToolCallStartEvent(chunk)
+        this.handleToolCallStartEvent(chunk as Extract<StreamChunk, { type: 'TOOL_CALL_START' }>)
         break
 
       case 'TOOL_CALL_ARGS':
-        this.handleToolCallArgsEvent(chunk)
+        this.handleToolCallArgsEvent(chunk as Extract<StreamChunk, { type: 'TOOL_CALL_ARGS' }>)
         break
 
       case 'TOOL_CALL_END':
-        this.handleToolCallEndEvent(chunk)
+        this.handleToolCallEndEvent(chunk as Extract<StreamChunk, { type: 'TOOL_CALL_END' }>)
         break
 
       case 'RUN_FINISHED':
-        this.handleRunFinishedEvent(chunk)
+        this.handleRunFinishedEvent(chunk as Extract<StreamChunk, { type: 'RUN_FINISHED' }>)
         break
 
       case 'RUN_ERROR':
-        this.handleRunErrorEvent(chunk)
+        this.handleRunErrorEvent(chunk as Extract<StreamChunk, { type: 'RUN_ERROR' }>)
         break
 
       case 'STEP_FINISHED':
-        this.handleStepFinishedEvent(chunk)
+        this.handleStepFinishedEvent(chunk as Extract<StreamChunk, { type: 'STEP_FINISHED' }>)
         break
 
       case 'MESSAGES_SNAPSHOT':
-        this.handleMessagesSnapshotEvent(chunk)
+        this.handleMessagesSnapshotEvent(chunk as Extract<StreamChunk, { type: 'MESSAGES_SNAPSHOT' }>)
         break
 
       case 'CUSTOM':
-        this.handleCustomEvent(chunk)
+        this.handleCustomEvent(chunk as Extract<StreamChunk, { type: 'CUSTOM' }>)
         break
 
       case 'RUN_STARTED':
-        this.handleRunStartedEvent(chunk)
+        this.handleRunStartedEvent(chunk as Extract<StreamChunk, { type: 'RUN_STARTED' }>)
         break
 
       case 'REASONING_START':
@@ -503,11 +506,11 @@ export class StreamProcessor {
         break
 
       case 'REASONING_MESSAGE_CONTENT':
-        this.handleReasoningMessageContentEvent(chunk)
+        this.handleReasoningMessageContentEvent(chunk as Extract<StreamChunk, { type: 'REASONING_MESSAGE_CONTENT' }>)
         break
 
       case 'TOOL_CALL_RESULT':
-        this.handleToolCallResultEvent(chunk)
+        this.handleToolCallResultEvent(chunk as Extract<StreamChunk, { type: 'TOOL_CALL_RESULT' }>)
         break
 
       default:

packages/typescript/ai/src/realtime/types.ts

@@ -257,7 +257,7 @@ export interface RealtimeEventPayloads {
     isFinal: boolean
   }
   audio_chunk: { data: ArrayBuffer; sampleRate: number }
-  tool_call: { toolCallId: string; toolCallName: string; input: unknown }
+  tool_call: { toolCallId: string; toolName: string; input: unknown }
   message_complete: { message: RealtimeMessage }
   interrupted: { messageId?: string }
   error: { error: Error }

packages/typescript/ai/src/strip-to-spec-middleware.ts

@@ -12,7 +12,7 @@ import type { StreamChunk } from './types'
  */
 export function stripToSpec(chunk: StreamChunk): StreamChunk {
   // Only strip the deprecated nested error object from RUN_ERROR
-  if (chunk.type === 'RUN_ERROR' && 'error' in chunk) {
+  if ((chunk as StreamChunk & { type: string }).type === 'RUN_ERROR' && 'error' in chunk) {
     const { error: _deprecated, ...rest } = chunk as Record<string, unknown>
     return rest as StreamChunk
   }