Claude Fable 5.1 프롬프팅

client = anthropic.Anthropic()

BATCH_NUDGE = ( "First privately list what you need next; then request every item " "that doesn't depend on another's result in this one response." )

In-memory files stand in for a working directory so the sample runs anywhere.

FILES = { "pyproject.toml": """
[project] name = "demo" version = "0.1.0" description = "Demo project for the batching example" """, "README.md": """\

demo

A small demo project. Run demo --help for usage. """, } tools: list[BetaToolParam] = [ { "name": "read_file", "description": "Read a UTF-8 text file from the working directory.", "input_schema": { "type": "object", "properties": {"path": {"type": "string"}}, "required": ["path"], }, } ] messages: list[BetaMessageParam] = [ {"role": "user", "content": "Summarize pyproject.toml and README.md."} ]

while True: response = client.beta.messages.create( model="claude-fable-5-1", max_tokens=16000, betas=["mid-conversation-system-clear-at-2026-08-21"], tools=tools, messages=messages, ) # Append the assistant turn exactly as returned, thinking blocks included. messages.append({"role": "assistant", "content": response.content}) if response.stop_reason != "tool_use": break tool_results: list[BetaToolResultBlockParam] = [] for block in response.content: if block.type == "tool_use": raw_path = block.input.get("path") path = raw_path if isinstance(raw_path, str) else "" if path in FILES: tool_results.append( { "type": "tool_result", "tool_use_id": block.id, "content": FILES[path], } ) else: tool_results.append( { "type": "tool_result", "tool_use_id": block.id, "content": f"File not found: {path}", "is_error": True, } ) # Send the tool results as the user turn, then a fresh copy of the nudge as a # turn-scoped system message. Leave earlier copies in place: the API clears them, # so the model sees only the newest one. messages.append({"role": "user", "content": tool_results}) messages.append( {"role": "system", "content": BATCH_NUDGE, "clear_at": "next_user_message"} )

print(next((block.text for block in response.content if block.type == "text"), ""))

```typescript TypeScript
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const BATCH_NUDGE =
  "First privately list what you need next; then request every item " +
  "that doesn't depend on another's result in this one response.";
// In-memory files stand in for a working directory so the sample runs anywhere.
const FILES = new Map<string, string>([
  [
    "pyproject.toml",
    `[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
`,
  ],
  [
    "README.md",
    `# demo

A small demo project. Run \`demo --help\` for usage.
`,
  ],
]);
const tools: Anthropic.Beta.Messages.BetaTool[] = [
  {
    name: "read_file",
    description: "Read a UTF-8 text file from the working directory.",
    input_schema: {
      type: "object",
      properties: { path: { type: "string" } },
      required: ["path"],
    },
  },
];
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
  { role: "user", content: "Summarize pyproject.toml and README.md." },
];

let response: Anthropic.Beta.Messages.BetaMessage;
while (true) {
  response = await client.beta.messages.create({
    model: "claude-fable-5-1",
    max_tokens: 16000,
    betas: ["mid-conversation-system-clear-at-2026-08-21"],
    tools,
    messages,
  });
  // Append the assistant turn exactly as returned, thinking blocks included.
  messages.push({ role: "assistant", content: response.content });
  if (response.stop_reason !== "tool_use") {
    break;
  }
  const toolResults: Anthropic.Beta.Messages.BetaToolResultBlockParam[] = [];
  for (const block of response.content) {
    if (block.type !== "tool_use") {
      continue;
    }
    const { input } = block;
    const path =
      typeof input === "object" &&
      input !== null &&
      "path" in input &&
      typeof input.path === "string"
        ? input.path
        : "";
    const text = FILES.get(path);
    if (text === undefined) {
      toolResults.push({
        type: "tool_result",
        tool_use_id: block.id,
        content: `File not found: ${path}`,
        is_error: true,
      });
      continue;
    }
    toolResults.push({
      type: "tool_result",
      tool_use_id: block.id,
      content: text,
    });
  }
  // Send the tool results as the user turn, then a fresh copy of the nudge as a
  // turn-scoped system message. Leave earlier copies in place: the API clears them,
  // so the model sees only the newest one.
  messages.push({ role: "user", content: toolResults });
  messages.push({
    role: "system",
    content: BATCH_NUDGE,
    clear_at: "next_user_message",
  });
}

const finalText = response.content.find((block) => block.type === "text");
console.log(finalText?.text ?? "");

using System.Text.Json;
using Anthropic;
using Anthropic.Models.Beta.Messages;

AnthropicClient client = new();

const string BatchNudge =
    "First privately list what you need next; then request every item "
    + "that doesn't depend on another's result in this one response.";

// In-memory files stand in for a working directory so the sample runs anywhere.
Dictionary<string, string> files = new()
{
    ["pyproject.toml"] = """
        [project]
        name = "demo"
        version = "0.1.0"
        description = "Demo project for the batching example"
        """,
    ["README.md"] = """
        # demo

        A small demo project. Run `demo --help` for usage.
        """,
};

List<BetaToolUnion> tools =
[
    new BetaTool
    {
        Name = "read_file",
        Description = "Read a UTF-8 text file from the working directory.",
        InputSchema = new InputSchema
        {
            Properties = new Dictionary<string, JsonElement>
            {
                ["path"] = JsonSerializer.SerializeToElement(new { type = "string" }),
            },
            Required = ["path"],
        },
    },
];

List<BetaMessageParam> messages =
[
    new() { Role = Role.User, Content = "Summarize pyproject.toml and README.md." },
];

BetaMessage response;
while (true)
{
    response = await client.Beta.Messages.Create(new MessageCreateParams
    {
        Model = "claude-fable-5-1",
        MaxTokens = 16000,
        Betas = ["mid-conversation-system-clear-at-2026-08-21"],
        Tools = tools,
        Messages = messages,
    });
    // Append the assistant turn exactly as returned, thinking blocks included.
    messages.Add(new()
    {
        Role = Role.Assistant,
        Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList(),
    });
    if (response.StopReason != BetaStopReason.ToolUse)
    {
        break;
    }
    List<BetaContentBlockParam> toolResults = [];
    foreach (var block in response.Content)
    {
        if (block.TryPickToolUse(out var toolUse))
        {
            var path = toolUse.Input.TryGetValue("path", out var pathValue)
                && pathValue.ValueKind == JsonValueKind.String
                ? pathValue.GetString()!
                : "";
            if (files.TryGetValue(path, out var fileText))
            {
                toolResults.Add(new BetaToolResultBlockParam { ToolUseID = toolUse.ID, Content = fileText });
            }
            else
            {
                toolResults.Add(new BetaToolResultBlockParam
                {
                    ToolUseID = toolUse.ID,
                    Content = $"File not found: {path}",
                    IsError = true,
                });
            }
        }
    }
    // Send the tool results as the user turn, then a fresh copy of the nudge as a
    // turn-scoped system message. Leave earlier copies in place: the API clears them,
    // so the model sees only the newest one.
    messages.Add(new() { Role = Role.User, Content = toolResults });
    messages.Add(new()
    {
        Role = Role.System,
        Content = BatchNudge,
        ClearAt = ClearAt.NextUserMessage,
    });
}

foreach (var block in response.Content)
{
    if (block.TryPickText(out var text))
    {
        Console.WriteLine(text.Text);
        break;
    }
}

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log"

	"github.com/anthropics/anthropic-sdk-go"
)

const batchNudge = "First privately list what you need next; then request every item " +
	"that doesn't depend on another's result in this one response."

// In-memory files stand in for a working directory so the sample runs anywhere.
var files = map[string]string{
	"pyproject.toml": `[project]
name = "demo"
version = "0.1.0"
description = "Demo project for the batching example"
`,
	"README.md": `# demo

A small demo project. Run "demo --help" for usage.
`,
}

func main() {
	client := anthropic.NewClient()
	ctx := context.Background()

	tools := []anthropic.BetaToolUnionParam{
		{OfTool: &anthropic.BetaToolParam{
			Name:        "read_file",
			Description: anthropic.String("Read a UTF-8 text file from the working directory."),
			InputSchema: anthropic.BetaToolInputSchemaParam{
				Properties: map[string]any{
					"path": map[string]any{"type": "string"},
				},
				Required: []string{"path"},
			},
		}},
	}
	messages := []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Summarize pyproject.toml and README.md.")),
	}

	var response *anthropic.BetaMessage
	for {
		var err error
		response, err = client.Beta.Messages.New(ctx, anthropic.BetaMessageNewParams{
			Model:     "claude-fable-5-1",
			MaxTokens: 16000,
			Betas:     []anthropic.AnthropicBeta{"mid-conversation-system-clear-at-2026-08-21"},
			Tools:     tools,
			Messages:  messages,
		})
		if err != nil {
			log.Fatal(err)
		}
		// Append the assistant turn exactly as returned, thinking blocks included.
		messages = append(messages, response.ToParam())
		if response.StopReason != anthropic.BetaStopReasonToolUse {
			break
		}
		var toolResults []anthropic.BetaContentBlockParamUnion
		for _, block := range response.Content {
			toolUse, ok := block.AsAny().(anthropic.BetaToolUseBlock)
			if !ok {
				continue
			}
			var input struct {
				Path string `json:"path"`
			}
			// A missing or non-string path leaves input.Path empty, which takes the error-result branch.
			if err := json.Unmarshal([]byte(toolUse.JSON.Input.Raw()), &input); err != nil {
				input.Path = ""
			}
			text, found := files[input.Path]
			if !found {
				text = "File not found: " + input.Path
			}
			toolResults = append(toolResults, anthropic.NewBetaToolResultBlock(toolUse.ID, text, !found))
		}
		// Send the tool results as the user turn, then a fresh copy of the nudge as a
		// turn-scoped system message. Leave earlier copies in place: the API clears them,
		// so the model sees only the newest one.
		messages = append(messages, anthropic.NewBetaUserMessage(toolResults...))
		messages = append(messages, anthropic.BetaMessageParam{
			Role:    anthropic.BetaMessageParamRoleSystem,
			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock(batchNudge)},
			ClearAt: anthropic.BetaMessageParamClearAtNextUserMessage,
		})
	}

	for _, block := range response.Content {
		if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
			fmt.Println(textBlock.Text)
			break
		}
	}
}

import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.messages.BetaContentBlockParam;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaStopReason;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.BetaTool.InputSchema;
import com.anthropic.models.beta.messages.BetaToolResultBlockParam;
import com.anthropic.models.beta.messages.BetaToolUseBlock;
import com.anthropic.models.beta.messages.MessageCreateParams;

static final String BATCH_NUDGE =
    "First privately list what you need next; then request every item "
        + "that doesn't depend on another's result in this one response.";

// In-memory files stand in for a working directory so the sample runs anywhere.
static final Map<String, String> FILES = Map.of(
    "pyproject.toml", """
        [project]
        name = "demo"
        version = "0.1.0"
        description = "Demo project for the batching example"
        """,
    "README.md", """
        # demo

        A small demo project. Run `demo --help` for usage.
        """);

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    BetaTool readFileTool = BetaTool.builder()
        .name("read_file")
        .description("Read a UTF-8 text file from the working directory.")
        .inputSchema(InputSchema.builder()
            .properties(JsonValue.from(Map.of("path", Map.of("type", "string"))))
            .required(List.of("path"))
            .build())
        .build();
    List<BetaMessageParam> messages = new ArrayList<>();
    messages.add(BetaMessageParam.builder()
        .role(BetaMessageParam.Role.USER)
        .content("Summarize pyproject.toml and README.md.")
        .build());

    BetaMessage response;
    while (true) {
        response = client.beta().messages().create(MessageCreateParams.builder()
            .model("claude-fable-5-1")
            .maxTokens(16000)
            .addBeta("mid-conversation-system-clear-at-2026-08-21")
            .addTool(readFileTool)
            .messages(messages)
            .build());
        // Append the assistant turn exactly as returned, thinking blocks included.
        messages.add(response.toParam());
        boolean requestedTools = response.stopReason()
            .map(BetaStopReason.TOOL_USE::equals)
            .orElse(false);
        if (!requestedTools) {
            break;
        }
        List<BetaToolUseBlock> toolUses = response.content().stream()
            .flatMap(block -> block.toolUse().stream())
            .toList();
        List<BetaContentBlockParam> toolResults = new ArrayList<>();
        for (BetaToolUseBlock toolUse : toolUses) {
            Map<String, JsonValue> input =
                (Map<String, JsonValue>) toolUse._input().asObject().orElseThrow();
            JsonValue pathValue = input.get("path");
            String path = pathValue != null && pathValue.asString().isPresent()
                ? pathValue.asStringOrThrow()
                : "";
            String fileText = FILES.get(path);
            BetaToolResultBlockParam.Builder result = BetaToolResultBlockParam.builder()
                .toolUseId(toolUse.id());
            if (fileText != null) {
                result.content(fileText);
            } else {
                result.content("File not found: " + path).isError(true);
            }
            toolResults.add(BetaContentBlockParam.ofToolResult(result.build()));
        }
        // Send the tool results as the user turn, then a fresh copy of the nudge as a
        // turn-scoped system message. Leave earlier copies in place: the API clears them,
        // so the model sees only the newest one.
        messages.add(BetaMessageParam.builder()
            .role(BetaMessageParam.Role.USER)
            .contentOfBetaContentBlockParams(toolResults)
            .build());
        messages.add(BetaMessageParam.builder()
            .role(BetaMessageParam.Role.SYSTEM)
            .content(BATCH_NUDGE)
            .clearAt(BetaMessageParam.ClearAt.NEXT_USER_MESSAGE)
            .build());
    }

    String finalText = response.content().stream()
        .flatMap(block -> block.text().stream())
        .map(textBlock -> textBlock.text())
        .findFirst()
        .orElse("");
    IO.println(finalText);
}

<?php

use Anthropic\Beta\Messages\BetaStopReason;
use Anthropic\Client;

$client = new Client();

const BATCH_NUDGE = 'First privately list what you need next; then request every item '
    . "that doesn't depend on another's result in this one response.";
// In-memory files stand in for a working directory so the sample runs anywhere.
const FILES = [
    'pyproject.toml' => <<<'TOML'
        [project]
        name = "demo"
        version = "0.1.0"
        description = "Demo project for the batching example"
        TOML,
    'README.md' => <<<'MD'
        # demo

        A small demo project. Run `demo --help` for usage.
        MD,
];
$tools = [
    [
        'name' => 'read_file',
        'description' => 'Read a UTF-8 text file from the working directory.',
        'input_schema' => [
            'type' => 'object',
            'properties' => ['path' => ['type' => 'string']],
            'required' => ['path'],
        ],
    ],
];
$messages = [
    ['role' => 'user', 'content' => 'Summarize pyproject.toml and README.md.'],
];

while (true) {
    $response = $client->beta->messages->create(
        model: 'claude-fable-5-1',
        maxTokens: 16000,
        betas: ['mid-conversation-system-clear-at-2026-08-21'],
        tools: $tools,
        messages: $messages,
    );
    // Append the assistant turn exactly as returned, thinking blocks included.
    $messages[] = ['role' => 'assistant', 'content' => $response->content];
    if ($response->stopReason !== BetaStopReason::TOOL_USE->value) {
        break;
    }
    $toolResults = [];
    foreach ($response->content as $block) {
        if ($block->type === 'tool_use') {
            $path = is_string($block->input['path'] ?? null) ? $block->input['path'] : '';
            if (array_key_exists($path, FILES)) {
                $toolResults[] = [
                    'type' => 'tool_result',
                    'tool_use_id' => $block->id,
                    'content' => FILES[$path],
                ];
            } else {
                $toolResults[] = [
                    'type' => 'tool_result',
                    'tool_use_id' => $block->id,
                    'content' => "File not found: {$path}",
                    'is_error' => true,
                ];
            }
        }
    }
    // Send the tool results as the user turn, then a fresh copy of the nudge as a
    // turn-scoped system message. Leave earlier copies in place: the API clears them,
    // so the model sees only the newest one.
    $messages[] = ['role' => 'user', 'content' => $toolResults];
    $messages[] = [
        'role' => 'system',
        'content' => BATCH_NUDGE,
        'clear_at' => 'next_user_message',
    ];
}

$textBlock = array_find($response->content, fn ($block) => $block->type === 'text');
echo $textBlock?->text ?? '', PHP_EOL;

require "anthropic"

client = Anthropic::Client.new

BATCH_NUDGE =
  "First privately list what you need next; then request every item " \
  "that doesn't depend on another's result in this one response."
# In-memory files stand in for a working directory so the sample runs anywhere.
FILES = {
  "pyproject.toml" => <<~TOML,
    [project]
    name = "demo"
    version = "0.1.0"
    description = "Demo project for the batching example"
  TOML
  "README.md" => <<~MD
    # demo

    A small demo project. Run `demo --help` for usage.
  MD
}
tools = [
  {
    name: "read_file",
    description: "Read a UTF-8 text file from the working directory.",
    input_schema: {
      type: "object",
      properties: {path: {type: "string"}},
      required: ["path"]
    }
  }
]
messages = [{role: "user", content: "Summarize pyproject.toml and README.md."}]

response = nil
loop do
  response = client.beta.messages.create(
    model: "claude-fable-5-1",
    max_tokens: 16000,
    betas: ["mid-conversation-system-clear-at-2026-08-21"],
    tools: tools,
    messages: messages
  )
  # Append the assistant turn exactly as returned, thinking blocks included.
  messages << {role: "assistant", content: response.content}
  break unless response.stop_reason == :tool_use

  tool_results = response.content.filter_map do |block|
    next unless block.type == :tool_use

    path = block.input[:path]
    if FILES.key?(path)
      {type: "tool_result", tool_use_id: block.id, content: FILES[path]}
    else
      {
        type: "tool_result",
        tool_use_id: block.id,
        content: "File not found: #{path}",
        is_error: true
      }
    end
  end
  # Send the tool results as the user turn, then a fresh copy of the nudge as a
  # turn-scoped system message. Leave earlier copies in place: the API clears them,
  # so the model sees only the newest one.
  messages << {role: "user", content: tool_results}
  messages << {role: "system", content: BATCH_NUDGE, clear_at: "next_user_message"}
end

puts response.content.find { it.type == :text }&.text