어드바이저 도구

ant beta:messages create --beta advisor-tool-2026-03-01 <<'YAML'
model: claude-sonnet-5
max_tokens: 4096
tools:
  - type: advisor_20260301
    name: advisor
    model: claude-opus-5
messages:
  - role: user
    content: Build a concurrent worker pool in Go with graceful shutdown.
YAML

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-5",
    max_tokens=4096,
    betas=["advisor-tool-2026-03-01"],
    tools=[
        {
            "type": "advisor_20260301",
            "name": "advisor",
            "model": "claude-opus-5",
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Build a concurrent worker pool in Go with graceful shutdown.",
        }
    ],
)

print(response)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 4096,
  betas: ["advisor-tool-2026-03-01"],
  tools: [
    {
      type: "advisor_20260301",
      name: "advisor",
      model: "claude-opus-5"
    }
  ],
  messages: [
    {
      role: "user",
      content: "Build a concurrent worker pool in Go with graceful shutdown."
    }
  ]
});

console.log(response);

using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

var client = new AnthropicClient();

var parameters = new MessageCreateParams
{
    Model = Messages::Model.ClaudeSonnet5,
    MaxTokens = 4096,
    Tools = new BetaToolUnion[]
    {
        new BetaAdvisorTool20260301
        {
            Model = Messages::Model.ClaudeOpus5
        }
    },
    Messages =
    [
        new BetaMessageParam
        {
            Role = Role.User,
            Content = "Build a concurrent worker pool in Go with graceful shutdown."
        }
    ],
    Betas = ["advisor-tool-2026-03-01"]
};

var response = await client.Beta.Messages.Create(parameters);
Console.WriteLine(response);

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeSonnet5,
	MaxTokens: 4096,
	Tools: []anthropic.BetaToolUnionParam{
		{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
			Model: anthropic.ModelClaudeOpus5,
		}},
	},
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Build a concurrent worker pool in Go with graceful shutdown.")),
	},
	Betas: []anthropic.AnthropicBeta{
		anthropic.AnthropicBetaAdvisorTool2026_03_01,
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)

import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;

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

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_SONNET_5)
        .maxTokens(4096L)
        .addTool(BetaAdvisorTool20260301.builder()
            .model(Model.CLAUDE_OPUS_5)
            .build())
        .addUserMessage("Build a concurrent worker pool in Go with graceful shutdown.")
        .addBeta("advisor-tool-2026-03-01")
        .build();

    BetaMessage response = client.beta().messages().create(params);
    IO.println(response);
}

$client = new Client();

$response = $client->beta->messages->create(
    maxTokens: 4096,
    messages: [
        [
            'role' => 'user',
            'content' => 'Build a concurrent worker pool in Go with graceful shutdown.',
        ],
    ],
    model: 'claude-sonnet-5',
    tools: [
        [
            'type' => 'advisor_20260301',
            'name' => 'advisor',
            'model' => 'claude-opus-5',
        ],
    ],
    betas: ['advisor-tool-2026-03-01'],
);

echo $response;

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-sonnet-5",
  max_tokens: 4096,
  tools: [
    {
      type: "advisor_20260301",
      name: "advisor",
      model: "claude-opus-5"
    }
  ],
  messages: [
    {
      role: "user",
      content: "Build a concurrent worker pool in Go with graceful shutdown."
    }
  ],
  betas: ["advisor-tool-2026-03-01"]
)

puts response

tools = [ { "type": "advisor_20260301", "name": "advisor", "model": "claude-opus-5", } ]

messages = [ { "role": "user", "content": "Build a concurrent worker pool in Go with graceful shutdown.", } ]

response = client.beta.messages.create( model="claude-sonnet-5", max_tokens=1024, betas=["advisor-tool-2026-03-01"], tools=tools, messages=messages, )

Append the full response content, including any advisor_tool_result blocks

messages.append({"role": "assistant", "content": response.content})

Continue the conversation

messages.append({"role": "user", "content": "Now add a max-in-flight limit of 10."})

response = client.beta.messages.create( model="claude-sonnet-5", max_tokens=1024, betas=["advisor-tool-2026-03-01"], tools=tools, messages=messages, )

```typescript TypeScript
const client = new Anthropic();

const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
  {
    type: "advisor_20260301",
    name: "advisor",
    model: "claude-opus-5"
  }
];

const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
  {
    role: "user",
    content: "Build a concurrent worker pool in Go with graceful shutdown."
  }
];

const response = await client.beta.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  betas: ["advisor-tool-2026-03-01"],
  tools,
  messages
});

// Append the full response content, including any advisor_tool_result blocks
messages.push({ role: "assistant", content: response.content });

// Continue the conversation
messages.push({ role: "user", content: "Now add a max-in-flight limit of 10." });

const followUp = await client.beta.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  betas: ["advisor-tool-2026-03-01"],
  tools,
  messages
});

using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

var client = new AnthropicClient();

var tools = new BetaToolUnion[]
{
    new BetaAdvisorTool20260301 { Model = Messages::Model.ClaudeOpus5 }
};

var messages = new List<BetaMessageParam>
{
    new() { Role = Role.User, Content = "Build a concurrent worker pool in Go with graceful shutdown." }
};

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Messages::Model.ClaudeSonnet5,
    MaxTokens = 1024,
    Tools = tools,
    Messages = messages,
    Betas = ["advisor-tool-2026-03-01"]
});

// Append the full response content, including any advisor_tool_result blocks
messages.Add(new BetaMessageParam
{
    Role = Role.Assistant,
    Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
});

// Continue the conversation
messages.Add(new BetaMessageParam { Role = Role.User, Content = "Now add a max-in-flight limit of 10." });

var followUp = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Messages::Model.ClaudeSonnet5,
    MaxTokens = 1024,
    Tools = tools,
    Messages = messages,
    Betas = ["advisor-tool-2026-03-01"]
});

client := anthropic.NewClient()

tools := []anthropic.BetaToolUnionParam{
	{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
		Model: anthropic.ModelClaudeOpus5,
	}},
}

messages := []anthropic.BetaMessageParam{
	anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Build a concurrent worker pool in Go with graceful shutdown.")),
}

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeSonnet5,
	MaxTokens: 1024,
	Tools:     tools,
	Messages:  messages,
	Betas: []anthropic.AnthropicBeta{
		anthropic.AnthropicBetaAdvisorTool2026_03_01,
	},
})
if err != nil {
	log.Fatal(err)
}

// Append the full response content, including any advisor_tool_result blocks.
messages = append(messages, response.ToParam())

// Continue the conversation
messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Now add a max-in-flight limit of 10.")))

response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeSonnet5,
	MaxTokens: 1024,
	Tools:     tools,
	Messages:  messages,
	Betas: []anthropic.AnthropicBeta{
		anthropic.AnthropicBetaAdvisorTool2026_03_01,
	},
})
if err != nil {
	log.Fatal(err)
}

import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaContentBlock;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;

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

    List<BetaToolUnion> tools = List.of(
        BetaToolUnion.ofAdvisorTool20260301(
            BetaAdvisorTool20260301.builder().model(Model.CLAUDE_OPUS_5).build()));

    List<BetaMessageParam> messages = new ArrayList<>();
    messages.add(BetaMessageParam.builder()
        .role(BetaMessageParam.Role.USER)
        .content("Build a concurrent worker pool in Go with graceful shutdown.")
        .build());

    BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
        .model(Model.CLAUDE_SONNET_5)
        .maxTokens(1024L)
        .tools(tools)
        .messages(messages)
        .addBeta("advisor-tool-2026-03-01")
        .build());

    // Append the full response content, including any advisor_tool_result blocks
    messages.add(BetaMessageParam.builder()
        .role(BetaMessageParam.Role.ASSISTANT)
        .contentOfBetaContentBlockParams(
            response.content().stream().map(BetaContentBlock::toParam).toList())
        .build());

    // Continue the conversation
    messages.add(BetaMessageParam.builder()
        .role(BetaMessageParam.Role.USER)
        .content("Now add a max-in-flight limit of 10.")
        .build());

    BetaMessage followUp = client.beta().messages().create(MessageCreateParams.builder()
        .model(Model.CLAUDE_SONNET_5)
        .maxTokens(1024L)
        .tools(tools)
        .messages(messages)
        .addBeta("advisor-tool-2026-03-01")
        .build());
}

$client = new Client();

$tools = [
    [
        'type' => 'advisor_20260301',
        'name' => 'advisor',
        'model' => 'claude-opus-5',
    ],
];

$messages = [
    [
        'role' => 'user',
        'content' => 'Build a concurrent worker pool in Go with graceful shutdown.',
    ],
];

$response = $client->beta->messages->create(
    maxTokens: 1024,
    messages: $messages,
    model: 'claude-sonnet-5',
    tools: $tools,
    betas: ['advisor-tool-2026-03-01'],
);

// Append the full response content, including any advisor_tool_result blocks
$messages[] = ['role' => 'assistant', 'content' => $response->content];

// Continue the conversation
$messages[] = ['role' => 'user', 'content' => 'Now add a max-in-flight limit of 10.'];

$response = $client->beta->messages->create(
    maxTokens: 1024,
    messages: $messages,
    model: 'claude-sonnet-5',
    tools: $tools,
    betas: ['advisor-tool-2026-03-01'],
);

client = Anthropic::Client.new

tools = [
  {
    type: "advisor_20260301",
    name: "advisor",
    model: "claude-opus-5"
  }
]

messages = [
  {
    role: "user",
    content: "Build a concurrent worker pool in Go with graceful shutdown."
  }
]

response = client.beta.messages.create(
  model: "claude-sonnet-5",
  max_tokens: 1024,
  tools: tools,
  messages: messages,
  betas: ["advisor-tool-2026-03-01"]
)

# Append the full response content, including any advisor_tool_result blocks
messages << { role: "assistant", content: response.content }

# Continue the conversation
messages << { role: "user", content: "Now add a max-in-flight limit of 10." }

response = client.beta.messages.create(
  model: "claude-sonnet-5",
  max_tokens: 1024,
  tools: tools,
  messages: messages,
  betas: ["advisor-tool-2026-03-01"]
)

NUDGE_TURN = 2 # inject before this assistant turn if no advisor call yet NUDGE_TEXT = ( "You have not consulted the advisor yet. If the task has a non-obvious " "design decision or a failure mode you haven't ruled out, call advisor " "now before committing to an approach." ) MAX_TURNS = 10 # agent loop cap

def run_your_tools(content): # Replace with your tool dispatch. Returns one tool_result block per tool_use block. return [ { "type": "tool_result", "tool_use_id": block.id, "content": "Replace with your tool output.", } for block in content if block.type == "tool_use" ]

tools = [ {"type": "advisor_20260301", "name": "advisor", "model": "claude-opus-5"}, # ... your other tools ] task = "Build a concurrent worker pool in Go with graceful shutdown." messages = [{"role": "user", "content": task}] advisor_called = False

for turn in range(1, MAX_TURNS + 1): response = client.beta.messages.create( model="claude-haiku-4-5", max_tokens=4096, betas=["advisor-tool-2026-03-01"], tools=tools, messages=messages, ) messages.append({"role": "assistant", "content": response.content}) advisor_called = advisor_called or any( block.type == "server_tool_use" and block.name == "advisor" for block in response.content ) if response.stop_reason == "end_turn": break if response.stop_reason == "pause_turn": continue # server tool pending; re-send to let the API complete it

  results = run_your_tools(response.content)  # list of tool_result blocks
  if results:
      messages.append({"role": "user", "content": results})
  # Skip this if your system prompt already tells the model to call sparingly.
  if turn == NUDGE_TURN - 1 and not advisor_called:
      messages.append({"role": "user", "content": NUDGE_TEXT})

```typescript TypeScript
const client = new Anthropic();

const NUDGE_TURN = 2; // inject before this assistant turn if no advisor call yet
const NUDGE_TEXT =
  "You have not consulted the advisor yet. If the task has a non-obvious " +
  "design decision or a failure mode you haven't ruled out, call advisor " +
  "now before committing to an approach.";
const MAX_TURNS = 10; // agent loop cap

function runYourTools(
  content: Anthropic.Beta.Messages.BetaContentBlock[]
): Anthropic.Beta.Messages.BetaToolResultBlockParam[] {
  // Replace with your tool dispatch. Returns one tool_result block per tool_use block.
  return content
    .filter((block) => block.type === "tool_use")
    .map((block) => ({
      type: "tool_result" as const,
      tool_use_id: block.id,
      content: "Replace with your tool output."
    }));
}

const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
  { type: "advisor_20260301", name: "advisor", model: "claude-opus-5" }
  // ... your other tools
];
const task = "Build a concurrent worker pool in Go with graceful shutdown.";
const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [{ role: "user", content: task }];
let advisorCalled = false;

for (let turn = 1; turn <= MAX_TURNS; turn++) {
  const response = await client.beta.messages.create({
    model: "claude-haiku-4-5",
    max_tokens: 4096,
    betas: ["advisor-tool-2026-03-01"],
    tools,
    messages
  });
  messages.push({ role: "assistant", content: response.content });
  advisorCalled =
    advisorCalled ||
    response.content.some(
      (block) => block.type === "server_tool_use" && block.name === "advisor"
    );
  if (response.stop_reason === "end_turn") {
    break;
  }
  if (response.stop_reason === "pause_turn") {
    continue; // server tool pending; re-send to let the API complete it
  }

  const results = runYourTools(response.content); // list of tool_result blocks
  if (results.length > 0) {
    messages.push({ role: "user", content: results });
  }
  // Skip this if your system prompt already tells the model to call sparingly.
  if (turn === NUDGE_TURN - 1 && !advisorCalled) {
    messages.push({ role: "user", content: NUDGE_TEXT });
  }
}

using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

var client = new AnthropicClient();

const int NudgeTurn = 2; // inject before this assistant turn if no advisor call yet
const string NudgeText =
    "You have not consulted the advisor yet. If the task has a non-obvious "
    + "design decision or a failure mode you haven't ruled out, call advisor "
    + "now before committing to an approach.";
const int MaxTurns = 10; // agent loop cap

// Replace with your tool dispatch. Returns one tool_result block per tool_use block.
List<BetaContentBlockParam> RunYourTools(IReadOnlyList<BetaContentBlock> content)
{
    List<BetaContentBlockParam> results = [];
    foreach (var block in content)
    {
        if (block.TryPickToolUse(out var toolUse))
        {
            results.Add(new BetaToolResultBlockParam
            {
                ToolUseID = toolUse.ID,
                Content = "Replace with your tool output."
            });
        }
    }
    return results;
}

var tools = new BetaToolUnion[]
{
    new BetaAdvisorTool20260301 { Model = Messages::Model.ClaudeOpus5 }
    // ... your other tools
};
var task = "Build a concurrent worker pool in Go with graceful shutdown.";
var messages = new List<BetaMessageParam> { new() { Role = Role.User, Content = task } };
var advisorCalled = false;

for (var turn = 1; turn <= MaxTurns; turn++)
{
    var response = await client.Beta.Messages.Create(new MessageCreateParams
    {
        Model = Messages::Model.ClaudeHaiku4_5,
        MaxTokens = 4096,
        Tools = tools,
        Messages = messages,
        Betas = ["advisor-tool-2026-03-01"]
    });
    messages.Add(new BetaMessageParam
    {
        Role = Role.Assistant,
        Content = response.Content.Select(block => new BetaContentBlockParam(block.Json)).ToList()
    });
    advisorCalled =
        advisorCalled
        || response.Content.Any(block =>
            block.TryPickServerToolUse(out var serverToolUse)
            && serverToolUse.Name.Value() == Name.Advisor
        );
    if (response.StopReason == BetaStopReason.EndTurn)
    {
        break;
    }
    if (response.StopReason == BetaStopReason.PauseTurn)
    {
        continue; // server tool pending; re-send to let the API complete it
    }

    var results = RunYourTools(response.Content); // list of tool_result blocks
    if (results.Count > 0)
    {
        messages.Add(new BetaMessageParam { Role = Role.User, Content = results });
    }
    // Skip this if your system prompt already tells the model to call sparingly.
    if (turn == NudgeTurn - 1 && !advisorCalled)
    {
        messages.Add(new BetaMessageParam { Role = Role.User, Content = NudgeText });
    }
}

const (
	nudgeTurn = 2 // inject before this assistant turn if no advisor call yet
	nudgeText = "You have not consulted the advisor yet. If the task has a non-obvious " +
		"design decision or a failure mode you haven't ruled out, call advisor " +
		"now before committing to an approach."
	maxTurns = 10 // agent loop cap
)

// Replace with your tool dispatch. Returns one tool_result block per tool_use block.
func runYourTools(content []anthropic.BetaContentBlockUnion) []anthropic.BetaContentBlockParamUnion {
	var results []anthropic.BetaContentBlockParamUnion
	for _, block := range content {
		if block.Type == "tool_use" {
			results = append(results, anthropic.NewBetaToolResultBlock(block.ID, "Replace with your tool output.", false))
		}
	}
	return results
}

func main() {
	client := anthropic.NewClient()

	tools := []anthropic.BetaToolUnionParam{
		{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
			Model: anthropic.ModelClaudeOpus5,
		}},
		// ... your other tools
	}
	task := "Build a concurrent worker pool in Go with graceful shutdown."
	messages := []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(task)),
	}
	advisorCalled := false

	for turn := 1; turn <= maxTurns; turn++ {
		response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
			Model:     anthropic.ModelClaudeHaiku4_5,
			MaxTokens: 4096,
			Tools:     tools,
			Messages:  messages,
			Betas: []anthropic.AnthropicBeta{
				anthropic.AnthropicBetaAdvisorTool2026_03_01,
			},
		})
		if err != nil {
			log.Fatal(err)
		}

		messages = append(messages, response.ToParam())

		for _, block := range response.Content {
			if block.Type == "server_tool_use" && block.Name == "advisor" {
				advisorCalled = true
			}
		}
		if response.StopReason == anthropic.BetaStopReasonEndTurn {
			break
		}
		if response.StopReason == anthropic.BetaStopReasonPauseTurn {
			continue // server tool pending; re-send to let the API complete it
		}

		results := runYourTools(response.Content) // list of tool_result blocks
		if len(results) > 0 {
			messages = append(messages, anthropic.BetaMessageParam{
				Role:    anthropic.BetaMessageParamRoleUser,
				Content: results,
			})
		}
		// Skip this if your system prompt already tells the model to call sparingly.
		if turn == nudgeTurn-1 && !advisorCalled {
			messages = append(messages, anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock(nudgeText)))
		}
	}
}

import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaContentBlock;
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.BetaServerToolUseBlock;
import com.anthropic.models.beta.messages.BetaStopReason;
import com.anthropic.models.beta.messages.BetaToolResultBlockParam;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.beta.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;

static final int NUDGE_TURN = 2; // inject before this assistant turn if no advisor call yet
static final String NUDGE_TEXT =
    "You have not consulted the advisor yet. If the task has a non-obvious "
        + "design decision or a failure mode you haven't ruled out, call advisor "
        + "now before committing to an approach.";
static final int MAX_TURNS = 10; // agent loop cap

// Replace with your tool dispatch. Returns one tool_result block per tool_use block.
List<BetaContentBlockParam> runYourTools(List<BetaContentBlock> content) {
    List<BetaContentBlockParam> results = new ArrayList<>();
    for (BetaContentBlock block : content) {
        if (block.isToolUse()) {
            results.add(BetaContentBlockParam.ofToolResult(
                BetaToolResultBlockParam.builder()
                    .toolUseId(block.asToolUse().id())
                    .content("Replace with your tool output.")
                    .build()));
        }
    }
    return results;
}

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

    List<BetaToolUnion> tools = List.of(
        BetaToolUnion.ofAdvisorTool20260301(
            BetaAdvisorTool20260301.builder().model(Model.CLAUDE_OPUS_5).build())
        // ... your other tools
    );
    String task = "Build a concurrent worker pool in Go with graceful shutdown.";
    List<BetaMessageParam> messages = new ArrayList<>();
    messages.add(BetaMessageParam.builder()
        .role(BetaMessageParam.Role.USER)
        .content(task)
        .build());
    boolean advisorCalled = false;

    for (int turn = 1; turn <= MAX_TURNS; turn++) {
        BetaMessage response = client.beta().messages().create(MessageCreateParams.builder()
            .model(Model.CLAUDE_HAIKU_4_5)
            .maxTokens(4096L)
            .tools(tools)
            .messages(messages)
            .addBeta("advisor-tool-2026-03-01")
            .build());
        messages.add(BetaMessageParam.builder()
            .role(BetaMessageParam.Role.ASSISTANT)
            .contentOfBetaContentBlockParams(
                response.content().stream().map(BetaContentBlock::toParam).toList())
            .build());
        advisorCalled = advisorCalled
            || response.content().stream().anyMatch(block ->
                block.isServerToolUse()
                    && block.asServerToolUse().name().equals(BetaServerToolUseBlock.Name.ADVISOR));
        BetaStopReason stopReason = response.stopReason().orElse(null);
        if (BetaStopReason.END_TURN.equals(stopReason)) {
            break;
        }
        if (BetaStopReason.PAUSE_TURN.equals(stopReason)) {
            continue; // server tool pending; re-send to let the API complete it
        }

        List<BetaContentBlockParam> results = runYourTools(response.content()); // list of tool_result blocks
        if (!results.isEmpty()) {
            messages.add(BetaMessageParam.builder()
                .role(BetaMessageParam.Role.USER)
                .contentOfBetaContentBlockParams(results)
                .build());
        }
        // Skip this if your system prompt already tells the model to call sparingly.
        if (turn == NUDGE_TURN - 1 && !advisorCalled) {
            messages.add(BetaMessageParam.builder()
                .role(BetaMessageParam.Role.USER)
                .content(NUDGE_TEXT)
                .build());
        }
    }
}

$client = new Client();

const NUDGE_TURN = 2; // inject before this assistant turn if no advisor call yet
const NUDGE_TEXT = "You have not consulted the advisor yet. If the task has a non-obvious "
    . "design decision or a failure mode you haven't ruled out, call advisor "
    . "now before committing to an approach.";
const MAX_TURNS = 10; // agent loop cap

// Replace with your tool dispatch. Returns one tool_result block per tool_use block.
function runYourTools(array $content): array
{
    $results = [];
    foreach ($content as $block) {
        if ($block->type === 'tool_use') {
            $results[] = [
                'type' => 'tool_result',
                'tool_use_id' => $block->id,
                'content' => 'Replace with your tool output.',
            ];
        }
    }
    return $results;
}

$tools = [
    ['type' => 'advisor_20260301', 'name' => 'advisor', 'model' => 'claude-opus-5'],
    // ... your other tools
];
$task = 'Build a concurrent worker pool in Go with graceful shutdown.';
$messages = [['role' => 'user', 'content' => $task]];
$advisorCalled = false;

for ($turn = 1; $turn <= MAX_TURNS; $turn++) {
    $response = $client->beta->messages->create(
        maxTokens: 4096,
        messages: $messages,
        model: 'claude-haiku-4-5',
        tools: $tools,
        betas: ['advisor-tool-2026-03-01'],
    );
    $messages[] = ['role' => 'assistant', 'content' => $response->content];
    foreach ($response->content as $block) {
        if ($block->type === 'server_tool_use' && $block->name === 'advisor') {
            $advisorCalled = true;
        }
    }
    if ($response->stopReason === 'end_turn') {
        break;
    }
    if ($response->stopReason === 'pause_turn') {
        continue; // server tool pending; re-send to let the API complete it
    }

    $results = runYourTools($response->content); // list of tool_result blocks
    if ($results !== []) {
        $messages[] = ['role' => 'user', 'content' => $results];
    }
    // Skip this if your system prompt already tells the model to call sparingly.
    if ($turn === NUDGE_TURN - 1 && !$advisorCalled) {
        $messages[] = ['role' => 'user', 'content' => NUDGE_TEXT];
    }
}

client = Anthropic::Client.new

NUDGE_TURN = 2 # inject before this assistant turn if no advisor call yet
NUDGE_TEXT =
  "You have not consulted the advisor yet. If the task has a non-obvious " \
  "design decision or a failure mode you haven't ruled out, call advisor " \
  "now before committing to an approach."
MAX_TURNS = 10 # agent loop cap

# Replace with your tool dispatch. Returns one tool_result block per tool_use block.
def run_your_tools(content)
  content.filter_map do |block|
    next unless block.type == :tool_use
    { type: "tool_result", tool_use_id: block.id, content: "Replace with your tool output." }
  end
end

tools = [
  { type: "advisor_20260301", name: "advisor", model: "claude-opus-5" }
  # ... your other tools
]
task = "Build a concurrent worker pool in Go with graceful shutdown."
messages = [{ role: "user", content: task }]
advisor_called = false

(1..MAX_TURNS).each do |turn|
  response = client.beta.messages.create(
    model: "claude-haiku-4-5",
    max_tokens: 4096,
    tools: tools,
    messages: messages,
    betas: ["advisor-tool-2026-03-01"]
  )
  messages << { role: "assistant", content: response.content }
  advisor_called ||= response.content.any? do |block|
    block.type == :server_tool_use && block.name == :advisor
  end
  break if response.stop_reason == :end_turn
  next if response.stop_reason == :pause_turn # server tool pending; re-send to let the API complete it

  results = run_your_tools(response.content) # list of tool_result blocks
  messages << { role: "user", content: results } unless results.empty?
  # Skip this if your system prompt already tells the model to call sparingly.
  messages << { role: "user", content: NUDGE_TEXT } if turn == NUDGE_TURN - 1 && !advisor_called
end

const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
  {
    type: "advisor_20260301",
    name: "advisor",
    model: "claude-opus-5",
    caching: { type: "ephemeral", ttl: "5m" }
  }
];

using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

var tools = new BetaToolUnion[]
{
    new BetaAdvisorTool20260301
    {
        Model = Messages::Model.ClaudeOpus5,
        Caching = new BetaCacheControlEphemeral { Ttl = Ttl.Ttl5m }
    }
};

tools := []anthropic.BetaToolUnionParam{
	{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
		Model:   anthropic.ModelClaudeOpus5,
		Caching: anthropic.BetaCacheControlEphemeralParam{TTL: anthropic.BetaCacheControlEphemeralTTLTTL5m},
	}},
}

import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaCacheControlEphemeral;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.messages.Model;

List<BetaToolUnion> tools = List.of(
    BetaToolUnion.ofAdvisorTool20260301(BetaAdvisorTool20260301.builder()
        .model(Model.CLAUDE_OPUS_5)
        .caching(BetaCacheControlEphemeral.builder()
            .ttl(BetaCacheControlEphemeral.Ttl.TTL_5M)
            .build())
        .build()));

$tools = [
    [
        'type' => 'advisor_20260301',
        'name' => 'advisor',
        'model' => 'claude-opus-5',
        'caching' => ['type' => 'ephemeral', 'ttl' => '5m'],
    ],
];

tools = [
  {
    type: "advisor_20260301",
    name: "advisor",
    model: "claude-opus-5",
    caching: { type: "ephemeral", ttl: "5m" }
  }
]

const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
  {
    type: "web_search_20250305",
    name: "web_search",
    max_uses: 5
  },
  {
    type: "advisor_20260301",
    name: "advisor",
    model: "claude-opus-5"
  },
  {
    name: "run_bash",
    description: "Run a bash command",
    input_schema: {
      type: "object",
      properties: { command: { type: "string" } }
    }
  }
];

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

var tools = new BetaToolUnion[]
{
    new BetaWebSearchTool20250305 { MaxUses = 5 },
    new BetaAdvisorTool20260301 { Model = Messages::Model.ClaudeOpus5 },
    new BetaTool
    {
        Name = "run_bash",
        Description = "Run a bash command",
        InputSchema = new()
        {
            Properties = new Dictionary<string, JsonElement>
            {
                ["command"] = JsonSerializer.SerializeToElement(new { type = "string" })
            }
        }
    }
};

tools := []anthropic.BetaToolUnionParam{
	{OfWebSearchTool20250305: &anthropic.BetaWebSearchTool20250305Param{
		MaxUses: anthropic.Int(5),
	}},
	{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
		Model: anthropic.ModelClaudeOpus5,
	}},
	{OfTool: &anthropic.BetaToolParam{
		Name:        "run_bash",
		Description: anthropic.String("Run a bash command"),
		InputSchema: anthropic.BetaToolInputSchemaParam{
			Properties: map[string]any{
				"command": map[string]any{"type": "string"},
			},
		},
	}},
}

import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.beta.messages.BetaWebSearchTool20250305;
import com.anthropic.models.messages.Model;

List<BetaToolUnion> tools = List.of(
    BetaToolUnion.ofWebSearchTool20250305(BetaWebSearchTool20250305.builder()
        .maxUses(5L)
        .build()),
    BetaToolUnion.ofAdvisorTool20260301(BetaAdvisorTool20260301.builder()
        .model(Model.CLAUDE_OPUS_5)
        .build()),
    BetaToolUnion.ofBetaTool(BetaTool.builder()
        .name("run_bash")
        .description("Run a bash command")
        .inputSchema(BetaTool.InputSchema.builder()
            .properties(JsonValue.from(Map.of(
                "command", Map.of("type", "string"))))
            .build())
        .build()));

$tools = [
    [
        'type' => 'web_search_20250305',
        'name' => 'web_search',
        'max_uses' => 5,
    ],
    [
        'type' => 'advisor_20260301',
        'name' => 'advisor',
        'model' => 'claude-opus-5',
    ],
    [
        'name' => 'run_bash',
        'description' => 'Run a bash command',
        'input_schema' => [
            'type' => 'object',
            'properties' => ['command' => ['type' => 'string']],
        ],
    ],
];

tools = [
  {
    type: "web_search_20250305",
    name: "web_search",
    max_uses: 5
  },
  {
    type: "advisor_20260301",
    name: "advisor",
    model: "claude-opus-5"
  },
  {
    name: "run_bash",
    description: "Run a bash command",
    input_schema: {
      type: "object",
      properties: { command: { type: "string" } }
    }
  }
]

const tools: Anthropic.Beta.Messages.BetaToolUnion[] = [
  {
    type: "advisor_20260301",
    name: "advisor",
    model: "claude-opus-5",
    max_tokens: 2048
  }
];

using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

var tools = new BetaToolUnion[]
{
    new BetaAdvisorTool20260301
    {
        Model = Messages::Model.ClaudeOpus5,
        MaxTokens = 2048
    }
};

tools := []anthropic.BetaToolUnionParam{
	{OfAdvisorTool20260301: &anthropic.BetaAdvisorTool20260301Param{
		Model:     anthropic.ModelClaudeOpus5,
		MaxTokens: anthropic.Int(2048),
	}},
}

import com.anthropic.models.beta.messages.BetaAdvisorTool20260301;
import com.anthropic.models.beta.messages.BetaToolUnion;
import com.anthropic.models.messages.Model;

List<BetaToolUnion> tools = List.of(
    BetaToolUnion.ofAdvisorTool20260301(BetaAdvisorTool20260301.builder()
        .model(Model.CLAUDE_OPUS_5)
        .maxTokens(2048L)
        .build()));

$tools = [
    [
        'type' => 'advisor_20260301',
        'name' => 'advisor',
        'model' => 'claude-opus-5',
        'max_tokens' => 2048,
    ],
];

tools = [
  {
    type: "advisor_20260301",
    name: "advisor",
    model: "claude-opus-5",
    max_tokens: 2048
  }
]