@tanstack/ai 0.47.2 → 0.47.3

package/src/activities/chat/stream/processor.ts

@@ -22,8 +22,9 @@ import {
   generateMessageId,
   uiMessageToModelMessages,
 } from '../messages.js'
-import { normalizeToolResult } from '../../../utilities/tool-result'
+import { runErrorEventToError } from '../../../utilities/errors'
 import { isProviderExecutedToolCall } from '../../../utilities/provider-executed'
+import { normalizeToolResult } from '../../../utilities/tool-result'
 import { defaultJSONParser } from './json-parser'
 import {
   appendStructuredOutputDelta,
@@ -819,6 +820,15 @@ export class StreamProcessor {
         // Update activeMessageIds
         this.activeMessageIds.delete(pendingId)
         this.activeMessageIds.add(messageId)
+
+        // TOOL_CALL_ARGS/END route through toolCallToMessage. Keep those
+        // entries on the remapped id so later args still accumulate
+        // (interleaved text can arrive as a full START/CONTENT/END block).
+        for (const [toolCallId, mappedMessageId] of this.toolCallToMessage) {
+          if (mappedMessageId === pendingId) {
+            this.toolCallToMessage.set(toolCallId, messageId)
+          }
+        }
       }
 
       // Ensure state exists
@@ -886,9 +896,6 @@ export class StreamProcessor {
     if (state.currentSegmentText !== state.lastEmittedText) {
       this.emitTextUpdateForMessage(messageId)
     }
-
-    // Complete all tool calls for this message
-    this.completeAllToolCallsForMessage(messageId)
   }
 
   /**
@@ -1139,9 +1146,6 @@ export class StreamProcessor {
   ): void {
     const { messageId, state } = this.ensureAssistantMessage(chunk.messageId)
 
-    // Content arriving means all current tool calls for this message are complete
-    this.completeAllToolCallsForMessage(messageId)
-
     if (this.structuredMessageIds.has(messageId)) {
       // `chunk.delta` is incremental; `chunk.content` is sometimes cumulative
       // (mirrors what the plain-text branch handles below). Reconcile against
@@ -1681,15 +1685,7 @@ export class StreamProcessor {
     // the surfaced Error so consumers can recover the upstream detail that the
     // RUN_ERROR's `message` alone discards. Both are optional and added only
     // when present, keeping the Error backward compatible.
-    const error = new Error(errorMessage)
-    const code = chunk.code ?? chunk.error?.code
-    if (code !== undefined) {
-      Object.assign(error, { code })
-    }
-    if (chunk.rawEvent !== undefined) {
-      Object.assign(error, { rawEvent: chunk.rawEvent })
-    }
-    this.events.onError?.(error)
+    this.events.onError?.(runErrorEventToError(chunk))
   }
 
   /**
@@ -2087,8 +2083,17 @@ export class StreamProcessor {
     // counts as a completed tool call in getCompletedToolCalls()/getState().
     toolCall.state = 'input-complete'
 
-    // Try final parse
-    toolCall.parsedArguments = this.jsonParser.parse(toolCall.arguments)
+    // Only surface `input` from a strict parse. The streaming partial-JSON
+    // parser closes unterminated strings, so truncated arguments would become
+    // a plausible but wrong object (GitHub issue #1017). If parse fails,
+    // `input` stays unset and consumers use the raw `arguments` string.
+    let strictParseSucceeded = false
+    try {
+      toolCall.parsedArguments = JSON.parse(toolCall.arguments)
+      strictParseSucceeded = true
+    } catch {
+      toolCall.parsedArguments = undefined
+    }
 
     // Don't downgrade the rendered part of a call that already reached the
     // terminal 'error' state (e.g. an output-error TOOL_CALL_RESULT arrived
@@ -2116,9 +2121,7 @@ export class StreamProcessor {
       name: toolCall.name,
       arguments: toolCall.arguments,
       state: 'input-complete',
-      ...(toolCall.parsedArguments !== undefined && {
-        input: toolCall.parsedArguments,
-      }),
+      ...(strictParseSucceeded && { input: toolCall.parsedArguments }),
       ...(toolCall.metadata !== undefined && { metadata: toolCall.metadata }),
     })
     this.emitMessagesChange()

package/src/activities/summarize/chat-stream-summarize.ts

@@ -38,6 +38,7 @@ export interface ChatStreamCapable {
  * - Groq: `max_completion_tokens`
  * - Gemini: `maxOutputTokens`
  * - OpenRouter: `maxCompletionTokens`
+ * - LLM Gateway: `max_tokens`
  * - Ollama: nested `options.num_predict` (no entry — see `applyMaxLength`)
  */
 const MAX_TOKENS_KEY_BY_ADAPTER: Record<string, string> = {
@@ -47,6 +48,9 @@ const MAX_TOKENS_KEY_BY_ADAPTER: Record<string, string> = {
   groq: 'max_completion_tokens',
   gemini: 'maxOutputTokens',
   openrouter: 'maxCompletionTokens',
+  // LLM Gateway exposes an OpenAI-compatible Chat Completions surface whose
+  // only output cap is `max_tokens` — it does not read `max_completion_tokens`.
+  llmgateway: 'max_tokens',
 }
 
 /**

package/src/stream-to-response.ts

@@ -9,6 +9,7 @@ import { notifyRunDisconnected } from './delivery-disconnect'
 import { resolveResumeRunId } from './stream-durability'
 import { EventType } from './types'
 import { resolveDebugOption } from './logger/resolve'
+import { runErrorEventToError } from './utilities/errors'
 import type { LockStore } from './activities/chat/middleware/locks'
 import type {
   RunRecord,
@@ -46,6 +47,10 @@ export async function streamToText(
   let accumulatedContent = ''
 
   for await (const chunk of stream) {
+    if (chunk.type === 'RUN_ERROR') {
+      throw runErrorEventToError(chunk)
+    }
+
     if (chunk.type === 'TEXT_MESSAGE_CONTENT' && chunk.delta) {
       accumulatedContent += chunk.delta
     }

package/src/utilities/errors.ts

@@ -1,3 +1,5 @@
+import type { StreamChunk } from '../types'
+
 /**
  * Best-effort extraction of a human-readable message from an unknown thrown
  * value, returning `undefined` when none can be found.
@@ -27,3 +29,24 @@ export function errorTypeName(err: unknown): string {
   }
   return 'Error'
 }
+
+/**
+ * Convert an AG-UI RUN_ERROR event to the Error shape exposed to consumers.
+ * Preserves the provider code and sanitized raw event when available, while
+ * accepting the deprecated nested error payload for backward compatibility.
+ */
+export function runErrorEventToError(
+  chunk: Extract<StreamChunk, { type: 'RUN_ERROR' }>,
+): Error {
+  const error = new Error(
+    chunk.message || chunk.error?.message || 'An error occurred',
+  )
+  const code = chunk.code ?? chunk.error?.code
+  if (code !== undefined) {
+    Object.assign(error, { code })
+  }
+  if (chunk.rawEvent !== undefined) {
+    Object.assign(error, { rawEvent: chunk.rawEvent })
+  }
+  return error
+}