@tanstack/ai 0.61.0 → 0.64.0

package/src/activities/chat/messages.ts

@@ -4,9 +4,14 @@ import {
 } 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 { isRedactedThinkingId } from '../../utilities/reasoning-encrypted-value'
 import {
   splitSubagentWire,
   subagentWireText,
@@ -29,6 +34,7 @@ import type {
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
+
 // ===========================
 // Message Converters
 // ===========================
@@ -67,6 +73,13 @@ function encryptedValueFrom(value: object): string | undefined {
   return nonEmptyString(tanstackMetadata(value)?.signature)
 }
 
+/** `{ redacted: true }` when a reasoning message's id marks a redacted block. */
+function redactedFrom(value: object) {
+  return 'id' in value && isRedactedThinkingId(value.id)
+    ? { redacted: true }
+    : {}
+}
+
 function toolCallFromWire(toolCall: ToolCall, bag: unknown): ToolCall {
   const fromBag =
     bag != null && typeof bag === 'object' && !Array.isArray(bag)
@@ -241,7 +254,7 @@ function convertOwnMessages(
   }
 
   const modelMessages: Array<ModelMessage> = []
-  let pendingThinking: Array<{ content: string; signature?: string }> = []
+  let pendingThinking: NonNullable<ModelMessage['thinking']> = []
   for (const msg of messages) {
     if ('parts' in msg) {
       modelMessages.push(...uiMessageToModelMessages(msg))
@@ -268,6 +281,7 @@ function convertOwnMessages(
         pendingThinking.push({
           content: typeof content === 'string' ? content : '',
           ...(signature !== undefined ? { signature } : {}),
+          ...redactedFrom(msg),
         })
       }
       continue
@@ -546,6 +560,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 }
@@ -657,7 +672,7 @@ function buildAssistantMessages(uiMessage: UIMessage): Array<ModelMessage> {
   // shared UI id on each one so persistence can retain the original identity.
   const messageList: Array<ModelMessage> = []
   let current = createSegment()
-  let pendingThinking: Array<{ content: string; signature?: string }> = []
+  let pendingThinking: NonNullable<ModelMessage['thinking']> = []
 
   // Track emitted tool result IDs to avoid duplicates.
   // A tool call can have BOTH an explicit tool-result part AND an output
@@ -729,6 +744,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),
@@ -736,7 +756,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)
@@ -753,6 +773,7 @@ function buildAssistantMessages(uiMessage: UIMessage): Array<ModelMessage> {
           pendingThinking.push({
             content: part.content,
             ...(part.signature && { signature: part.signature }),
+            ...(part.redacted && { redacted: true }),
           })
         }
         break
@@ -841,6 +862,9 @@ function buildAssistantMessages(uiMessage: UIMessage): Array<ModelMessage> {
             : 'User denied this action',
         }),
         toolCallId: part.id,
+        ...(approved === false && {
+          metadata: { tanstack: { toolResultOutcome: 'denied' } },
+        }),
       })
       emittedToolResultIds.add(part.id)
     }
@@ -884,6 +908,7 @@ export function modelMessageToUIMessage(
         type: 'thinking',
         content: thinking.content,
         ...(thinking.signature && { signature: thinking.signature }),
+        ...(thinking.redacted && { redacted: true }),
       })
     }
   }
@@ -908,11 +933,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 && {
@@ -1097,6 +1132,7 @@ export function aguiSnapshotMessageToUIMessage(
                   type: 'thinking' as const,
                   content,
                   ...(signature !== undefined ? { signature } : {}),
+                  ...redactedFrom(message),
                 },
               ]
             : [],
@@ -1228,6 +1264,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,
@@ -1238,14 +1282,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 }),

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

@@ -5,12 +5,14 @@
  * These are used by StreamProcessor to manage the message array.
  */
 
+import { isRedactedThinkingId } from '../../../utilities/reasoning-encrypted-value'
 import { parsePartialJSON } from './json-parser'
 import type {
   ContentPart,
   StructuredOutputPart,
   ThinkingPart,
   ToolCallPart,
+  ToolResultOutcome,
   ToolResultPart,
   UIMessage,
 } from '../../../types'
@@ -117,6 +119,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 +137,7 @@ export function updateToolResultPart(
       toolCallId,
       content,
       state,
+      ...(outcome !== undefined && { outcome }),
       ...(error && { error }),
     }
 
@@ -480,12 +484,16 @@ export function updateThinkingPart(
     // 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
+    // A hydrated part has no stepId to carry the redacted marker, so it keeps
+    // its own flag.
+    const redacted = isRedactedThinkingId(stepId) || adopted?.redacted === true
 
     const thinkingPart: ThinkingPart = {
       type: 'thinking',
       content,
       stepId,
       ...(nextSignature && { signature: nextSignature }),
+      ...(redacted && { redacted: true }),
     }
 
     if (thinkingPartIndex >= 0) {

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

@@ -36,6 +36,8 @@ import {
 import { getChunkRunId } from '../../../utilities/chunk-ids'
 import type { AdapterYieldChunk } from '../../../utilities/adapter-yield-chunk'
 import {
+  isContentPartArray,
+  isToolResultOutcome,
   normalizeToolResult,
   toolResultErrorText,
 } from '../../../utilities/tool-result'
@@ -181,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
  *
@@ -1953,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
    */
@@ -1980,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)
@@ -1998,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,
@@ -2042,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
@@ -2069,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' ? toolResultErrorText(output) : undefined,
+      toolResultOutcome,
     )
     this.emitMessagesChange()
   }
@@ -2678,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
     }
 
@@ -2728,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.
@@ -2742,7 +2772,7 @@ export class StreamProcessor {
         (part) =>
           part.type === 'tool-call' &&
           part.id === toolCallId &&
-          part.state === 'error',
+          (part.state === 'error' || part.state === 'complete'),
       ),
     )
   }

package/src/activities/chat/tools/schema-converter.ts

@@ -230,6 +230,14 @@ export interface ConvertSchemaOptions {
    * @default false
    */
   forStructuredOutput?: boolean
+  /**
+   * Which view of a Standard JSON Schema to convert. A schema with a
+   * transform or a pipe has a different `output` view. Use `'output'` to
+   * describe the value that parsing returns.
+   *
+   * @default 'input'
+   */
+  io?: 'input' | 'output'
 }
 
 /**
@@ -238,16 +246,20 @@ export interface ConvertSchemaOptions {
  *
  * - Standard JSON Schemas are rebuilt structurally (dropping `$schema`, which
  *   LLM providers ignore) and given the explicit `type`/`properties`/`required`
- *   defaults object shapes need downstream.
+ *   defaults object shapes need downstream. `io` picks the `input` (default)
+ *   or `output` view.
  * - Plain `JSONSchema` inputs are rebuilt into the typed view; non-object inputs
  *   are surfaced untouched (they can't be widened).
  * - Standard Schema validators lacking a `~standard.jsonSchema` converter throw
  *   with actionable guidance, rather than shipping `{ '~standard': … }` to the
  *   provider and producing an opaque downstream error.
  */
-function toTypedJsonSchema(schema: SchemaInput): JSONSchema | undefined {
+function toTypedJsonSchema(
+  schema: SchemaInput,
+  io: 'input' | 'output' = 'input',
+): JSONSchema | undefined {
   if (isStandardJSONSchema(schema)) {
-    const jsonSchema = schema['~standard'].jsonSchema.input({
+    const jsonSchema = schema['~standard'].jsonSchema[io]({
       target: 'draft-07',
     })
     const result: JSONSchema = toJsonSchema(jsonSchema)
@@ -340,7 +352,7 @@ export function convertSchemaToJsonSchema(
 ): JSONSchema | undefined {
   if (!schema) return undefined
 
-  const { forStructuredOutput = false } = options
+  const { forStructuredOutput = false, io } = options
 
   // Plain-JSONSchema passthrough: with no widening requested, return the schema
   // by reference so callers comparing via `===` keep identity. Only the widening
@@ -353,7 +365,7 @@ export function convertSchemaToJsonSchema(
     return schema
   }
 
-  const base = toTypedJsonSchema(schema)
+  const base = toTypedJsonSchema(schema, io)
   // Non-object inputs can't be widened; surface them untouched.
   if (!base || typeof base !== 'object') return base
   if (!forStructuredOutput) return base