@tanstack/ai 0.44.1 → 0.45.0

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

@@ -1854,9 +1854,10 @@ export class StreamProcessor {
 
     if (chunk.name === 'structured-output.start' && chunk.value) {
       const v = chunk.value as { messageId?: string }
-      const targetId = v.messageId ?? messageId
+      const { messageId: targetId } = this.ensureAssistantMessage(
+        v.messageId ?? messageId ?? undefined,
+      )
       if (targetId) {
-        this.ensureAssistantMessage(targetId)
         this.structuredMessageIds.add(targetId)
         this.structuredOutputUpdateBatches.delete(targetId)
         this.events.onStructuredOutputChange?.({
@@ -1876,7 +1877,9 @@ export class StreamProcessor {
         reasoning?: string
         messageId?: string
       }
-      const targetId = v.messageId ?? messageId
+      const { messageId: targetId } = this.ensureAssistantMessage(
+        v.messageId ?? messageId ?? undefined,
+      )
       if (targetId) {
         this.flushStructuredOutputUpdate(targetId)
         this.messages = completeStructuredOutputPart(

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

@@ -813,7 +813,7 @@ export async function* executeToolCalls<TContext = unknown>(
       continue
     }
 
-    // Parse arguments, throwing error if invalid JSON
+    // Parse arguments
     let input: unknown = {}
     const argsStr = toolCall.function.arguments.trim() || '{}'
     if (argsStr) {
@@ -821,9 +821,17 @@ export async function* executeToolCalls<TContext = unknown>(
         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}`)
+      } catch {
+        results.push({
+          toolCallId: toolCall.id,
+          toolName,
+          result: {
+            error: `Failed to parse tool arguments as JSON: ${argsStr}`,
+          },
+          input,
+          state: 'output-error',
+        })
+        continue
       }
     }
 

package/src/adapter-internals.ts

@@ -25,3 +25,11 @@ export {
   PendingTurnCapability,
   providePendingTurn,
 } from './activities/chat/middleware/pending-turn'
+export {
+  appendOutputSchemaInstruction,
+  parseJsonFromAssistantText,
+} from './utilities/structured-output-text'
+export {
+  structuredOutputCompleteChunk,
+  structuredOutputStartChunk,
+} from './utilities/structured-output-events'

package/src/types.ts

@@ -958,10 +958,13 @@ export interface TextOptions<
    *    `supportsCombinedToolsAndSchema(modelOptions) === true`. The adapter
    *    should then wire the schema into the upstream request (e.g.
    *    `response_format: { type: 'json_schema', ... }`, `text.format`,
-   *    `output_format`) alongside any `tools`. The model's natural final
-   *    turn carries the schema-constrained JSON text and the engine
-   *    harvests it from the agent loop without a separate finalization
-   *    round-trip.
+   *    `output_format`, `--json-schema`) alongside any `tools`.
+   *
+   *    How the engine then takes the object depends on
+   *    `combinedStructuredOutputSource()`:
+   *    - `'text'` (default): the final-turn assistant text is the JSON.
+   *    - `'event'`: the adapter emits `structured-output.complete` during
+   *      `chatStream`. Accumulated prose is not parsed.
    *
    *    Adapters that did NOT declare the capability never see this field
    *    populated — the engine instead invokes `structuredOutput` /
@@ -1555,20 +1558,25 @@ export interface CodeModeExternalErrorEvent extends CustomEvent {
   name: 'code_mode:external_error'
   value: { function: string; error: string; duration: number }
 }
-export interface CodeModeSkillCallEvent extends CustomEvent {
-  name: 'code_mode:skill_call'
-  value: { skill: string; input: unknown; timestamp: number }
+export interface CodeModeSnippetCallEvent extends CustomEvent {
+  name: 'code_mode:snippet_call'
+  value: { snippet: string; input: unknown; timestamp: number }
 }
-export interface CodeModeSkillResultEvent extends CustomEvent {
-  name: 'code_mode:skill_result'
-  value: { skill: string; result: unknown; duration: number; timestamp: number }
+export interface CodeModeSnippetResultEvent extends CustomEvent {
+  name: 'code_mode:snippet_result'
+  value: {
+    snippet: string
+    result: unknown
+    duration: number
+    timestamp: number
+  }
 }
-export interface CodeModeSkillErrorEvent extends CustomEvent {
-  name: 'code_mode:skill_error'
-  value: { skill: string; error: string; duration: number; timestamp: number }
+export interface CodeModeSnippetErrorEvent extends CustomEvent {
+  name: 'code_mode:snippet_error'
+  value: { snippet: string; error: string; duration: number; timestamp: number }
 }
-export interface SkillRegisteredEvent extends CustomEvent {
-  name: 'skill:registered'
+export interface SnippetRegisteredEvent extends CustomEvent {
+  name: 'snippet:registered'
   value: { id: string; name: string; description: string; timestamp: number }
 }
 
@@ -1587,10 +1595,10 @@ export type KnownCustomEvent =
   | CodeModeExternalCallEvent
   | CodeModeExternalResultEvent
   | CodeModeExternalErrorEvent
-  | CodeModeSkillCallEvent
-  | CodeModeSkillResultEvent
-  | CodeModeSkillErrorEvent
-  | SkillRegisteredEvent
+  | CodeModeSnippetCallEvent
+  | CodeModeSnippetResultEvent
+  | CodeModeSnippetErrorEvent
+  | SnippetRegisteredEvent
   | StructuredOutputStartEvent
   | StructuredOutputCompleteEvent
   | ApprovalRequestedEvent

package/src/utilities/structured-output-events.ts

@@ -0,0 +1,44 @@
+import { EventType } from '../types'
+import type { StreamChunk } from '../types'
+
+export function structuredOutputStartChunk(args: {
+  messageId: string
+  model: string
+  threadId: string
+  runId: string
+  timestamp?: number
+}): StreamChunk {
+  return {
+    type: EventType.CUSTOM,
+    name: 'structured-output.start',
+    value: { messageId: args.messageId },
+    model: args.model,
+    timestamp: args.timestamp ?? Date.now(),
+    threadId: args.threadId,
+    runId: args.runId,
+  }
+}
+
+export function structuredOutputCompleteChunk(args: {
+  messageId: string
+  model: string
+  threadId: string
+  runId: string
+  object: unknown
+  raw: string
+  timestamp?: number
+}): StreamChunk {
+  return {
+    type: EventType.CUSTOM,
+    name: 'structured-output.complete',
+    value: {
+      object: args.object,
+      raw: args.raw,
+      messageId: args.messageId,
+    },
+    model: args.model,
+    timestamp: args.timestamp ?? Date.now(),
+    threadId: args.threadId,
+    runId: args.runId,
+  }
+}

package/src/utilities/structured-output-text.ts

@@ -0,0 +1,63 @@
+/**
+ * Parse JSON from a model/harness assistant string.
+ * Strips a wrapping markdown fence when the whole payload is fenced.
+ * If the model wrote prose first, take the last JSON object or array.
+ */
+export function parseJsonFromAssistantText(raw: string): unknown {
+  const trimmed = raw.trim()
+  if (trimmed === '') {
+    throw new SyntaxError('Assistant text is empty')
+  }
+
+  const candidates: Array<string> = []
+  const wholeFence = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/)
+  if (wholeFence?.[1]) candidates.push(wholeFence[1].trim())
+  candidates.push(trimmed)
+  const lastFence = [
+    ...trimmed.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/g),
+  ].at(-1)
+  if (lastFence?.[1]) candidates.push(lastFence[1].trim())
+  const extracted = extractLastJsonSlice(trimmed)
+  if (extracted !== undefined) candidates.push(extracted)
+
+  let lastError: unknown
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate)
+    } catch (error) {
+      lastError = error
+    }
+  }
+  throw lastError instanceof Error
+    ? lastError
+    : new SyntaxError('No JSON object found in assistant text')
+}
+
+function extractLastJsonSlice(text: string): string | undefined {
+  for (let end = text.length - 1; end >= 0; end--) {
+    if (text[end] !== '}' && text[end] !== ']') continue
+    for (let start = end; start >= 0; start--) {
+      const opener = text[start]
+      if (opener !== '{' && opener !== '[') continue
+      const slice = text.slice(start, end + 1)
+      try {
+        JSON.parse(slice)
+        return slice
+      } catch {
+        // Try an earlier opener, then an earlier closer.
+      }
+    }
+  }
+  return undefined
+}
+
+export function appendOutputSchemaInstruction(
+  prompt: string,
+  schema: unknown,
+): string {
+  return `${prompt}
+
+Respond with a single JSON object that matches this JSON Schema. Do not wrap the object in markdown unless you must.
+
+${JSON.stringify(schema)}`
+}