Claude Fable 5.1 in Next.js 16: Messages API, Tool Use, and Preserved Thinking (2026)

4. Tool Use That Survives Fable 5.1

Describe tools with JSON Schema. Leave tool_choice at auto. Tell the model in the system prompt when a tool is appropriate. Do not force a named tool.

import type Anthropic from '@anthropic-ai/sdk'
import { z } from 'zod'
import { anthropic, MODEL } from '@/lib/anthropic'
import { listOrdersForTenant } from '@/data/orders'

const listOrdersSchema = z.object({
  status: z.enum(['open', 'paid', 'cancelled']).optional(),
  limit: z.number().int().min(1).max(50).default(20),
})

const tools: Anthropic.Tool[] = [
  {
    name: 'list_orders',
    description:
      'List orders for the signed-in workspace. Never pass a tenant or user id.',
    input_schema: {
      type: 'object',
      properties: {
        status: { type: 'string', enum: ['open', 'paid', 'cancelled'] },
        limit: { type: 'integer', minimum: 1, maximum: 50 },
      },
    },
  },
]

async function runListOrders(
  tenantId: string,
  raw: unknown
) {
  const input = listOrdersSchema.parse(raw)
  const rows = await listOrdersForTenant(tenantId, input)
  return JSON.stringify(rows)
}

export async function runAgentTurn(opts: {
  tenantId: string
  history: Anthropic.MessageParam[]
}) {
  const messages: Anthropic.MessageParam[] = [...opts.history]
  let message = await anthropic.messages.create({
    model: MODEL,
    max_tokens: 2048,
    tools,
    messages,
    system:
      'Use list_orders when the user asks about order status. Do not invent order ids.',
  })

  let steps = 0
  while (message.stop_reason === 'tool_use' && steps < 6) {
    steps += 1
    const toolBlocks = message.content.filter(
      (b): b is Anthropic.ToolUseBlock => b.type === 'tool_use'
    )

    const results: Anthropic.ToolResultBlockParam[] = []
    for (const block of toolBlocks) {
      if (block.name === 'list_orders') {
        const content = await runListOrders(opts.tenantId, block.input)
        results.push({
          type: 'tool_result',
          tool_use_id: block.id,
          content,
        })
      } else {
        results.push({
          type: 'tool_result',
          tool_use_id: block.id,
          content: 'Unknown tool',
          is_error: true,
        })
      }
    }

    messages.push({ role: 'assistant', content: message.content })
    messages.push({ role: 'user', content: results })

    message = await anthropic.messages.create({
      model: MODEL,
      max_tokens: 2048,
      tools,
      messages,
    })
  }

  return message
}

Two rules that keep this production-safe:

• The model never receives tenantId. The session layer injects it into the handler.
• You push the full assistant message (including thinking and tool_use blocks) back unchanged, then append tool_result turns. That is how preserved thinking stays valid.