@tanstack/ai 0.59.0 → 0.63.0

package/src/activities/chat/messages.ts

@@ -1,9 +1,16 @@
-import { isProviderExecutedToolCall } from '../../utilities/provider-executed'
+import {
+  isAssistantSegmentOf,
+  isProviderExecutedToolCall,
+} from '../../utilities/provider-executed'
 import {
   isContentPartArray,
+  isToolResultOutcome,
   normalizeToolResult,
 } from '../../utilities/tool-result'
-import { tanstackMetadata } from '../../utilities/merge-metadata'
+import {
+  tanstackMetadata,
+  withTanstackMetadata,
+} from '../../utilities/merge-metadata'
 import {
   splitSubagentWire,
   subagentWireText,
@@ -26,6 +33,7 @@ import type {
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
+
 // ===========================
 // Message Converters
 // ===========================
@@ -543,6 +551,7 @@ function assistantMetadata(
   const tanstack: TanStackMessageMetadata = {}
   if (previous?.model !== undefined) tanstack.model = previous.model
   if (previous?.runId !== undefined) tanstack.runId = previous.runId
+  if (previous?.run?.id !== undefined) tanstack.run = { id: previous.run.id }
   if (previous?.signature !== undefined) tanstack.signature = previous.signature
   if (fromParts.length > 0) tanstack.uiResources = fromParts
   const result = { ...current }
@@ -726,6 +735,11 @@ function buildAssistantMessages(uiMessage: UIMessage): Array<ModelMessage> {
           (part.state === 'complete' || part.state === 'error') &&
           !emittedToolResultIds.has(part.toolCallId)
         ) {
+          const metadata =
+            part.outcome === undefined
+              ? part.metadata
+              : withTanstackMetadata(part, { toolResultOutcome: part.outcome })
+                  .metadata
           messageList.push({
             ...(part.id !== undefined && { id: part.id }),
             ...optionalCreatedAt(part),
@@ -733,7 +747,7 @@ function buildAssistantMessages(uiMessage: UIMessage): Array<ModelMessage> {
             content: part.content,
             toolCallId: part.toolCallId,
             ...(part.name !== undefined && { name: part.name }),
-            ...(part.metadata !== undefined && { metadata: part.metadata }),
+            ...(metadata !== undefined && { metadata }),
             ...(part.error !== undefined && { error: part.error }),
           })
           emittedToolResultIds.add(part.toolCallId)
@@ -838,6 +852,9 @@ function buildAssistantMessages(uiMessage: UIMessage): Array<ModelMessage> {
             : 'User denied this action',
         }),
         toolCallId: part.id,
+        ...(approved === false && {
+          metadata: { tanstack: { toolResultOutcome: 'denied' } },
+        }),
       })
       emittedToolResultIds.add(part.id)
     }
@@ -905,11 +922,21 @@ export function modelMessageToUIMessage(
     }
     parts.push(structuredOutput)
   } else if (modelMessage.role === 'tool' && modelMessage.toolCallId) {
+    const rawToolResultOutcome =
+      tanstackMetadata(modelMessage)?.toolResultOutcome
+    const toolResultOutcome = isToolResultOutcome(rawToolResultOutcome)
+      ? rawToolResultOutcome
+      : undefined
+    const resultState =
+      modelMessage.error === undefined && toolResultOutcome === undefined
+        ? 'complete'
+        : 'error'
     parts.push({
       type: 'tool-result',
       toolCallId: modelMessage.toolCallId,
       content: toolResultContent(modelMessage.content),
-      state: modelMessage.error === undefined ? 'complete' : 'error',
+      state: resultState,
+      ...(toolResultOutcome !== undefined && { outcome: toolResultOutcome }),
       ...(modelMessage.id !== undefined && { id: modelMessage.id }),
       ...(modelMessage.name !== undefined && { name: modelMessage.name }),
       ...(modelMessage.metadata !== undefined && {
@@ -1225,6 +1252,14 @@ export function modelMessagesToUIMessages(
         currentAssistantMessage.role === 'assistant'
       ) {
         const content = toolResultContent(msg.content)
+        const rawToolResultOutcome = tanstackMetadata(msg)?.toolResultOutcome
+        const toolResultOutcome = isToolResultOutcome(rawToolResultOutcome)
+          ? rawToolResultOutcome
+          : undefined
+        const resultState =
+          msg.error === undefined && toolResultOutcome === undefined
+            ? 'complete'
+            : 'error'
         const toolCallPart = currentAssistantMessage.parts.find(
           (part): part is ToolCallPart =>
             part.type === 'tool-call' && part.id === msg.toolCallId,
@@ -1235,14 +1270,17 @@ export function modelMessagesToUIMessages(
             typeof content === 'string'
               ? parseToolResultContent(content)
               : content
-          toolCallPart.state = msg.error === undefined ? 'complete' : 'error'
+          toolCallPart.state = resultState
         }
 
         currentAssistantMessage.parts.push({
           type: 'tool-result',
           toolCallId: msg.toolCallId,
           content,
-          state: msg.error === undefined ? 'complete' : 'error',
+          state: resultState,
+          ...(toolResultOutcome !== undefined && {
+            outcome: toolResultOutcome,
+          }),
           ...(msg.id !== undefined &&
             msg.id !== currentAssistantMessage.id && { id: msg.id }),
           ...(msg.name !== undefined && { name: msg.name }),
@@ -1259,6 +1297,14 @@ export function modelMessagesToUIMessages(
       // Regular message. Preserve a persisted stable id so a hydrated message
       // keeps the same identity as its live stream (enables in-place resume).
       const uiMessage = modelMessageToUIMessage(msg, msg.id)
+      if (
+        msg.role === 'assistant' &&
+        currentAssistantMessage &&
+        isAssistantSegmentOf(msg.id, currentAssistantMessage.id)
+      ) {
+        currentAssistantMessage.parts.push(...uiMessage.parts)
+        continue
+      }
       uiMessages.push(uiMessage)
 
       // Track assistant messages for potential tool result merging

package/src/activities/chat/middleware/types.ts

@@ -344,6 +344,7 @@ export interface ChatMiddlewareConfig {
 export interface ChatResumeToolState {
   approvals?: ReadonlyMap<string, ToolApprovalResolution> | undefined
   clientToolResults?: ReadonlyMap<string, unknown> | undefined
+  clientToolErrors?: ReadonlyMap<string, string> | undefined
   genericInterrupts?:
     | ReadonlyMap<string, ChatResumeGenericResolution>
     | undefined

package/src/activities/chat/stream/message-updaters.ts

@@ -11,6 +11,7 @@ import type {
   StructuredOutputPart,
   ThinkingPart,
   ToolCallPart,
+  ToolResultOutcome,
   ToolResultPart,
   UIMessage,
 } from '../../../types'
@@ -117,6 +118,7 @@ export function updateToolResultPart(
   content: string | Array<ContentPart>,
   state: ToolResultState,
   error?: string,
+  outcome?: ToolResultOutcome,
 ): Array<UIMessage> {
   return messages.map((msg) => {
     if (msg.id !== messageId) {
@@ -134,6 +136,7 @@ export function updateToolResultPart(
       toolCallId,
       content,
       state,
+      ...(outcome !== undefined && { outcome }),
       ...(error && { error }),
     }
 
@@ -455,15 +458,37 @@ export function updateThinkingPart(
     }
 
     const parts = [...msg.parts]
-    const thinkingPartIndex = parts.findIndex(
+    let thinkingPartIndex = parts.findIndex(
       (p) => p.type === 'thinking' && p.stepId === stepId,
     )
 
+    // A hydrated message carries its thinking without a stepId: the stored form
+    // has no field for one, so `modelMessageToUIMessage` cannot put it back.
+    // When a run is rejoined mid-stream the replayed reasoning is keyed by
+    // stepId, matches nothing, and gets appended -- leaving a second thinking
+    // part sitting after the answer text. Adopt the first stepId-less thinking
+    // part instead, so the replay lands on the part it belongs to. Live
+    // streaming always writes a stepId, so the only parts this can match are
+    // hydrated ones.
+    let adopted: ThinkingPart | undefined
+    if (thinkingPartIndex < 0) {
+      thinkingPartIndex = parts.findIndex(
+        (p) => p.type === 'thinking' && p.stepId === undefined,
+      )
+      const candidate = parts[thinkingPartIndex]
+      if (candidate?.type === 'thinking') adopted = candidate
+    }
+
+    // Keep the signature the hydrated part already had when this update does
+    // not carry one; losing it would strip the provider's encrypted reasoning
+    // from a message that is about to be sent back.
+    const nextSignature = signature ?? adopted?.signature
+
     const thinkingPart: ThinkingPart = {
       type: 'thinking',
       content,
       stepId,
-      ...(signature && { signature }),
+      ...(nextSignature && { signature: nextSignature }),
     }
 
     if (thinkingPartIndex >= 0) {

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

@@ -25,14 +25,22 @@ import {
   uiMessageToModelMessages,
 } from '../messages.js'
 import { runErrorEventToError } from '../../../utilities/errors'
-import { isProviderExecutedToolCall } from '../../../utilities/provider-executed'
+import {
+  isAssistantSegmentOf,
+  isProviderExecutedToolCall,
+} from '../../../utilities/provider-executed'
 import {
   mergeMetadata,
   tanstackMetadata,
 } from '../../../utilities/merge-metadata'
 import { getChunkRunId } from '../../../utilities/chunk-ids'
 import type { AdapterYieldChunk } from '../../../utilities/adapter-yield-chunk'
-import { normalizeToolResult } from '../../../utilities/tool-result'
+import {
+  isContentPartArray,
+  isToolResultOutcome,
+  normalizeToolResult,
+  toolResultErrorText,
+} from '../../../utilities/tool-result'
 import { defaultJSONParser } from './json-parser'
 import {
   appendStructuredOutputDelta,
@@ -175,6 +183,23 @@ function interruptBatchHasGeneric(interrupts: Array<Interrupt>): boolean {
   })
 }
 
+/**
+ * The canonical arguments string for a `TOOL_CALL_END.input`, or `undefined`
+ * when JSON cannot carry it: `JSON.stringify` returns `undefined` (despite
+ * its declared type) for a top-level function or symbol and throws on BigInt
+ * and circular references. `null` is not tool arguments either, so it also
+ * keeps the streamed value instead of writing `arguments = "null"`.
+ */
+function serializeToolInput(input: unknown): string | undefined {
+  if (input === undefined || input === null) return undefined
+  try {
+    const serialized: unknown = JSON.stringify(input)
+    return typeof serialized === 'string' ? serialized : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * StreamProcessor - State machine for processing AI response streams
  *
@@ -1518,20 +1543,30 @@ export class StreamProcessor {
         pending.push(msg)
         continue
       }
+      let next = msg
       if (
         msg.role === 'assistant' &&
         pending.length > 0 &&
         !isToolResultOnly(msg)
       ) {
-        out.push({
+        next = {
           ...msg,
           parts: [...pending.flatMap(thinkingParts), ...msg.parts],
-        })
+        }
         pending = []
+      } else {
+        flushPending()
+      }
+      const prev = out.at(-1)
+      if (
+        prev?.role === 'assistant' &&
+        next.role === 'assistant' &&
+        isAssistantSegmentOf(next.id, prev.id)
+      ) {
+        out[out.length - 1] = { ...prev, parts: [...prev.parts, ...next.parts] }
         continue
       }
-      flushPending()
-      out.push(msg)
+      out.push(next)
     }
     flushPending()
     return out
@@ -1705,9 +1740,7 @@ export class StreamProcessor {
             }
           }
           const errorText =
-            result.state === 'error'
-              ? this.extractToolResultError(output)
-              : undefined
+            result.state === 'error' ? toolResultErrorText(output) : undefined
           next = {
             ...next,
             output: errorText ? { error: errorText } : output,
@@ -1939,11 +1972,13 @@ export class StreamProcessor {
    * Handle TOOL_CALL_END event — arguments are finalized (input-complete).
    * Tool output arrives on TOOL_CALL_RESULT, not on this event.
    *
-   * If TOOL_CALL_END carries parsed `input`, use it as the canonical arguments:
-   * back-fill the accumulated string when no TOOL_CALL_ARGS deltas were seen
-   * (adapters that deliver the whole input on END — e.g. Anthropic
-   * server_tool_use / web_search — issue #839) and override the rendered part's
-   * `input` with the canonical value.
+   * If TOOL_CALL_END carries parsed `input`, it is the canonical arguments:
+   * write it into the accumulated string and override the rendered part's
+   * `input` with it. That covers adapters that deliver the whole input on END
+   * (e.g. Anthropic server_tool_use / web_search — issue #839) and adapters
+   * that stream the wire arguments and then normalize them (OpenAI strict-mode
+   * null widening, undone by the adapter after #939), so `arguments` and
+   * `input` never disagree on the persisted part.
    *
    * @see docs/chat-architecture.md#single-shot-tool-call-response — End-to-end flow
    */
@@ -1966,16 +2001,15 @@ export class StreamProcessor {
     // Transition the tool call to input-complete (the authoritative completion signal)
     const existingToolCall = msgState.toolCalls.get(chunk.toolCallId)
     if (existingToolCall && existingToolCall.state !== 'input-complete') {
-      // Back-fill the arguments string from the parsed input when no
-      // TOOL_CALL_ARGS deltas were received, so completeToolCall's strict parse
-      // surfaces the correct value on the ToolCallPart.
-      if (input !== undefined && !existingToolCall.arguments) {
-        try {
-          existingToolCall.arguments = JSON.stringify(input)
-        } catch {
-          // circular refs, BigInt, etc. — leave arguments empty rather than
-          // aborting stream processing
-        }
+      // The parsed input replaces the accumulated arguments string, so
+      // completeToolCall's strict parse surfaces the canonical value on the
+      // ToolCallPart even when the streamed deltas carried a provider-side
+      // reshaping of it. An input JSON cannot carry is not canonical: both
+      // `arguments` and `input` then stay with the streamed value, so the
+      // two never disagree.
+      const serializedInput = serializeToolInput(input)
+      if (serializedInput !== undefined) {
+        existingToolCall.arguments = serializedInput
       }
 
       const index = msgState.toolCallOrder.indexOf(chunk.toolCallId)
@@ -1984,7 +2018,7 @@ export class StreamProcessor {
       // Canonicalize on the parsed input: overrides the accumulated-args parse
       // that completeToolCall wrote (adapters may coerce values differently
       // between streamed args and the final structured input).
-      if (input !== undefined) {
+      if (serializedInput !== undefined) {
         existingToolCall.parsedArguments = input
         this.messages = updateToolCallPart(this.messages, messageId, {
           id: existingToolCall.id,
@@ -2001,18 +2035,6 @@ export class StreamProcessor {
     }
   }
 
-  private extractToolResultError(output: unknown): string {
-    if (
-      output &&
-      typeof output === 'object' &&
-      'error' in output &&
-      typeof output.error === 'string'
-    ) {
-      return output.error
-    }
-    return typeof output === 'string' ? output : 'Tool execution failed'
-  }
-
   /**
    * Handle TOOL_CALL_RESULT event (AG-UI spec).
    *
@@ -2040,9 +2062,14 @@ export class StreamProcessor {
     if (!messageId) return
 
     const extra = chunk as AdapterYieldChunk
+    const rawToolResultOutcome = tanstackMetadata(chunk)?.toolResultOutcome
+    const toolResultOutcome = isToolResultOutcome(rawToolResultOutcome)
+      ? rawToolResultOutcome
+      : undefined
     const isOutputError =
       extra.state === 'output-error' ||
-      tanstackMetadata(chunk)?.state === 'output-error'
+      tanstackMetadata(chunk)?.state === 'output-error' ||
+      toolResultOutcome !== undefined
 
     // Step 1: Update the tool-call part's output field
     let output: unknown
@@ -2067,9 +2094,14 @@ export class StreamProcessor {
       this.messages,
       messageId,
       chunk.toolCallId,
-      aguiContentToContentParts(chunk.content),
+      // The server sends a ContentPart[] result as a JSON string. Keep the
+      // parsed array so uiMessagesToWire can carry it in metadata.
+      isContentPartArray(output)
+        ? output
+        : aguiContentToContentParts(chunk.content),
       resultState,
-      resultState === 'error' ? this.extractToolResultError(output) : undefined,
+      resultState === 'error' ? toolResultErrorText(output) : undefined,
+      toolResultOutcome,
     )
     this.emitMessagesChange()
   }
@@ -2676,11 +2708,11 @@ export class StreamProcessor {
       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
+    // Don't downgrade the rendered part of a call that already reached a
+    // terminal 'error' or 'complete' state (e.g. a tool result arrived
     // without a preceding TOOL_CALL_END). The RUN_FINISHED / finalizeStream
-    // safety net must not clobber a failed call back to 'input-complete'.
-    if (this.isToolCallPartErrored(toolCall.id)) {
+    // safety net must not clobber a finished call back to 'input-complete'.
+    if (this.isToolCallPartTerminal(toolCall.id)) {
       return
     }
 
@@ -2726,11 +2758,11 @@ export class StreamProcessor {
   }
 
   /**
-   * Whether the rendered tool-call part for the given id has reached the
-   * terminal 'error' state. Used to prevent the completion safety net from
-   * downgrading a failed call back to 'input-complete'.
+   * Whether the rendered tool-call part for the given id has reached a
+   * terminal 'error' or 'complete' state. Used to prevent the completion
+   * safety net from downgrading a finished call back to 'input-complete'.
    */
-  private isToolCallPartErrored(toolCallId: string): boolean {
+  private isToolCallPartTerminal(toolCallId: string): boolean {
     // `initialMessages` may be ModelMessage-shaped (no `parts`) — e.g. the
     // common pattern of seeding a processor with the same messages passed to
     // `chat()`. Guard the access so iterating them never throws.
@@ -2740,7 +2772,7 @@ export class StreamProcessor {
         (part) =>
           part.type === 'tool-call' &&
           part.id === toolCallId &&
-          part.state === 'error',
+          (part.state === 'error' || part.state === 'complete'),
       ),
     )
   }