@tanstack/ai 0.10.2 → 0.11.0

package/src/activities/chat/tools/tool-calls.ts

@@ -93,11 +93,12 @@ export class ToolCallManager {
    */
   addToolCallStartEvent(event: ToolCallStartEvent): void {
     const index = event.index ?? this.toolCallsMap.size
+    const name = event.toolCallName
     this.toolCallsMap.set(index, {
       id: event.toolCallId,
       type: 'function',
       function: {
-        name: event.toolName,
+        name,
         arguments: '',
       },
       ...(event.providerMetadata && {
@@ -127,7 +128,10 @@ export class ToolCallManager {
     for (const [, toolCall] of this.toolCallsMap.entries()) {
       if (toolCall.id === event.toolCallId) {
         if (event.input !== undefined) {
-          toolCall.function.arguments = JSON.stringify(event.input)
+          // Normalize null/non-object to {} (e.g. Anthropic empty tool_use blocks)
+          const normalized =
+            event.input && typeof event.input === 'object' ? event.input : {}
+          toolCall.function.arguments = JSON.stringify(normalized)
         }
         break
       }
@@ -167,11 +171,12 @@ export class ToolCallManager {
       let toolResultContent: string
       if (tool?.execute) {
         try {
-          // Parse arguments (normalize "null" to "{}" for empty tool_use blocks)
+          // Parse arguments (normalize null/non-object to {} for empty tool_use blocks)
           let args: unknown
           try {
             const argsString = toolCall.function.arguments.trim() || '{}'
-            args = JSON.parse(argsString === 'null' ? '{}' : argsString)
+            const parsed = JSON.parse(argsString)
+            args = parsed && typeof parsed === 'object' ? parsed : {}
           } catch (parseError) {
             throw new Error(
               `Failed to parse tool arguments as JSON: ${toolCall.function.arguments}`,
@@ -233,11 +238,12 @@ export class ToolCallManager {
       yield {
         type: 'TOOL_CALL_END',
         toolCallId: toolCall.id,
+        toolCallName: toolCall.function.name,
         toolName: toolCall.function.name,
         model: finishEvent.model,
         timestamp: Date.now(),
         result: toolResultContent,
-      }
+      } as ToolCallEndEvent
 
       // Add tool result message
       toolResults.push({
@@ -543,7 +549,9 @@ export async function* executeToolCalls(
     const argsStr = toolCall.function.arguments.trim() || '{}'
     if (argsStr) {
       try {
-        input = JSON.parse(argsStr)
+        const parsed = JSON.parse(argsStr)
+        // Normalize null/non-object to {} (e.g. Anthropic empty tool_use blocks)
+        input = parsed && typeof parsed === 'object' ? parsed : {}
       } catch (parseError) {
         // If parsing fails, throw error to fail fast
         throw new Error(`Failed to parse tool arguments as JSON: ${argsStr}`)

package/src/activities/generateVideo/index.ts

@@ -268,11 +268,14 @@ async function* runStreamingVideoGeneration<
   const pollingInterval = options.pollingInterval ?? 2000
   const maxDuration = options.maxDuration ?? 600_000
 
+  const threadId = createId('thread')
+
   yield {
     type: 'RUN_STARTED',
     runId,
+    threadId,
     timestamp: Date.now(),
-  }
+  } as StreamChunk
 
   try {
     // Create the video generation job
@@ -289,7 +292,7 @@ async function* runStreamingVideoGeneration<
       name: 'video:job:created',
       value: { jobId: jobResult.jobId },
       timestamp: Date.now(),
-    }
+    } as StreamChunk
 
     // Poll for completion
     const startTime = Date.now()
@@ -308,7 +311,7 @@ async function* runStreamingVideoGeneration<
           error: statusResult.error,
         },
         timestamp: Date.now(),
-      }
+      } as StreamChunk
 
       if (statusResult.status === 'completed') {
         const urlResult = await adapter.getVideoUrl(jobResult.jobId)
@@ -323,14 +326,15 @@ async function* runStreamingVideoGeneration<
             expiresAt: urlResult.expiresAt,
           },
           timestamp: Date.now(),
-        }
+        } as StreamChunk
 
         yield {
           type: 'RUN_FINISHED',
           runId,
+          threadId,
           finishReason: 'stop',
           timestamp: Date.now(),
-        }
+        } as StreamChunk
         return
       }
 
@@ -344,12 +348,15 @@ async function* runStreamingVideoGeneration<
     yield {
       type: 'RUN_ERROR',
       runId,
+      threadId,
+      message: error.message || 'Video generation failed',
+      code: error.code,
       error: {
         message: error.message || 'Video generation failed',
         code: error.code,
       },
       timestamp: Date.now(),
-    }
+    } as StreamChunk
   }
 }
 

package/src/activities/stream-generation-result.ts

@@ -4,6 +4,7 @@
  * implementations to support `stream: true`.
  */
 
+import { EventType } from '@ag-ui/core'
 import type { StreamChunk } from '../types'
 
 function createId(prefix: string): string {
@@ -17,46 +18,53 @@ function createId(prefix: string): string {
  * to be sent over the same streaming transport as chat.
  *
  * @param generator - An async function that performs the generation and returns the result
- * @param options - Optional configuration (runId)
- * @returns An AsyncIterable of StreamChunks with RUN_STARTED, CUSTOM(generation:result), and RUN_FINISHED events
+ * @param options - Optional configuration (runId, threadId)
+ * @returns An AsyncIterable of StreamChunks with RUN_STARTED, CUSTOM(generation:result), and RUN_FINISHED events on success, or RUN_STARTED and RUN_ERROR on failure
  */
 export async function* streamGenerationResult<TResult>(
   generator: () => Promise<TResult>,
-  options?: { runId?: string },
+  options?: { runId?: string; threadId?: string },
 ): AsyncIterable<StreamChunk> {
   const runId = options?.runId ?? createId('run')
+  const threadId = options?.threadId ?? createId('thread')
 
   yield {
-    type: 'RUN_STARTED',
+    type: EventType.RUN_STARTED,
     runId,
+    threadId,
     timestamp: Date.now(),
-  }
+  } as StreamChunk
 
   try {
     const result = await generator()
 
     yield {
-      type: 'CUSTOM',
+      type: EventType.CUSTOM,
       name: 'generation:result',
       value: result as unknown,
       timestamp: Date.now(),
-    }
+    } as StreamChunk
 
     yield {
-      type: 'RUN_FINISHED',
+      type: EventType.RUN_FINISHED,
       runId,
+      threadId,
       finishReason: 'stop',
       timestamp: Date.now(),
-    }
+    } as StreamChunk
   } catch (error: any) {
     yield {
-      type: 'RUN_ERROR',
+      type: EventType.RUN_ERROR,
       runId,
+      threadId,
+      message: error.message || 'Generation failed',
+      code: error.code,
+      // Deprecated nested form for backward compatibility
       error: {
         message: error.message || 'Generation failed',
         code: error.code,
       },
       timestamp: Date.now(),
-    }
+    } as StreamChunk
   }
 }

package/src/stream-to-response.ts

@@ -40,7 +40,7 @@ export async function streamToText(
  * This creates a ReadableStream that emits chunks in SSE format:
  * - Each chunk is prefixed with "data: "
  * - Each chunk is followed by "\n\n"
- * - Stream ends with "data: [DONE]\n\n"
+ * - Stream ends when the underlying iterable is exhausted (RUN_FINISHED is the terminal event)
  *
  * @param stream - AsyncIterable of StreamChunks from chat()
  * @param abortController - Optional AbortController to abort when stream is cancelled
@@ -67,8 +67,6 @@ export function toServerSentEventsStream(
           )
         }
 
-        // Send completion marker
-        controller.enqueue(encoder.encode('data: [DONE]\n\n'))
         controller.close()
       } catch (error: any) {
         // Don't send error if aborted
@@ -109,7 +107,7 @@ export function toServerSentEventsStream(
  * This creates a Response that emits chunks in SSE format:
  * - Each chunk is prefixed with "data: "
  * - Each chunk is followed by "\n\n"
- * - Stream ends with "data: [DONE]\n\n"
+ * - Stream ends when the underlying iterable is exhausted (RUN_FINISHED is the terminal event)
  *
  * @param stream - AsyncIterable of StreamChunks from chat()
  * @param init - Optional Response initialization options (including `abortController`)

package/src/strip-to-spec-middleware.ts

@@ -0,0 +1,37 @@
+import type { ChatMiddleware } from './activities/chat/middleware/types'
+import type { StreamChunk } from './types'
+
+/**
+ * Strip only the deprecated nested `error` object from RUN_ERROR events.
+ * The flat `message`/`code` fields are the spec-compliant form.
+ *
+ * All other fields pass through unchanged. @ag-ui/core's BaseEventSchema
+ * uses `.passthrough()`, so extra fields (model, content, usage,
+ * finishReason, toolName, stepId, etc.) are allowed and won't break
+ * spec validation or verifyEvents.
+ */
+export function stripToSpec(chunk: StreamChunk): StreamChunk {
+  // Only strip the deprecated nested error object from RUN_ERROR
+  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
+  }
+  return chunk
+}
+
+/**
+ * Middleware that ensures events are AG-UI spec compliant.
+ * Currently only strips the deprecated nested `error` object from RUN_ERROR.
+ * All other fields pass through unchanged (passthrough allowed by spec).
+ */
+export function stripToSpecMiddleware(): ChatMiddleware {
+  return {
+    name: 'strip-to-spec',
+    onChunk(_ctx, chunk) {
+      return stripToSpec(chunk)
+    },
+  }
+}