작업 예산

ant beta:messages create --beta task-budgets-2026-03-13 \
  --stream --format jsonl <<'YAML' | jq 'select(.type == "message_delta").usage'
model: claude-opus-5-5
max_tokens: 128000
messages:
  - role: user
    content: Review the codebase and propose a refactor plan.
output_config:
  effort: high
  task_budget:
    type: tokens
    total: 64000
YAML

client = anthropic.Anthropic()

with client.beta.messages.stream(
    model="claude-opus-5-5",
    max_tokens=128000,
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 64000},
    },
    messages=[
        {"role": "user", "content": "Review the codebase and propose a refactor plan."}
    ],
    betas=["task-budgets-2026-03-13"],
) as stream:
    response = stream.get_final_message()

print(response.usage)

const client = new Anthropic();

const stream = client.beta.messages.stream({
  model: "claude-opus-5-5",
  max_tokens: 128000,
  output_config: {
    effort: "high",
    task_budget: { type: "tokens", total: 64000 }
  },
  messages: [{ role: "user", content: "Review the codebase and propose a refactor plan." }],
  betas: ["task-budgets-2026-03-13"]
});

const response = await stream.finalMessage();
console.log(response.usage);

var client = new AnthropicClient();

var responseUpdates = client.Beta.Messages.CreateStreaming(new MessageCreateParams
{
    Model = Messages::Model.ClaudeOpus5_5,
    MaxTokens = 128000,
    Messages = [new() { Role = Role.User, Content = "Review the codebase and propose a refactor plan." }],
    OutputConfig = new BetaOutputConfig
    {
        Effort = Effort.High,
        TaskBudget = new BetaTokenTaskBudget { Total = 64000 },
    },
    Betas = ["task-budgets-2026-03-13"],
});

var response = await responseUpdates.Aggregate();
Console.WriteLine(response.Usage);

client := anthropic.NewClient()

stream := client.Beta.Messages.NewStreaming(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 128000,
	Betas:     []anthropic.AnthropicBeta{"task-budgets-2026-03-13"},
	Messages: []anthropic.BetaMessageParam{{
		Role: anthropic.BetaMessageParamRoleUser,
		Content: []anthropic.BetaContentBlockParamUnion{{
			OfText: &anthropic.BetaTextBlockParam{Text: "Review the codebase and propose a refactor plan."},
		}},
	}},
	OutputConfig: anthropic.BetaOutputConfigParam{
		Effort: anthropic.BetaOutputConfigEffortHigh,
		TaskBudget: anthropic.BetaTokenTaskBudgetParam{
			Total: 64000,
		},
	},
})

message := anthropic.BetaMessage{}
for stream.Next() {
	event := stream.Current()
	if err := message.Accumulate(event); err != nil {
		panic(err)
	}
}
if stream.Err() != nil {
	panic(stream.Err())
}

fmt.Printf("Usage: input_tokens=%d, output_tokens=%d\n", message.Usage.InputTokens, message.Usage.OutputTokens)

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(128000L)
    .addUserMessage("Review the codebase and propose a refactor plan.")
    .outputConfig(BetaOutputConfig.builder()
        .effort(BetaOutputConfig.Effort.HIGH)
        .taskBudget(BetaTokenTaskBudget.builder().total(64000L).build())
        .build())
    .addBeta("task-budgets-2026-03-13")
    .build();

BetaMessageAccumulator accumulator = BetaMessageAccumulator.create();
try (StreamResponse<BetaRawMessageStreamEvent> stream =
        client.beta().messages().createStreaming(params)) {
    stream.stream().forEach(accumulator::accumulate);
}

BetaMessage response = accumulator.message();
IO.println(response.usage());

use Anthropic\Beta\Messages\BetaRawMessageDeltaEvent;

$client = new Client();

$stream = $client->beta->messages->createStream(
    model: 'claude-opus-5-5',
    maxTokens: 128000,
    messages: [
        ['role' => 'user', 'content' => 'Review the codebase and propose a refactor plan.'],
    ],
    outputConfig: [
        'effort' => 'high',
        'taskBudget' => ['type' => 'tokens', 'total' => 64000],
    ],
    betas: ['task-budgets-2026-03-13'],
);

// The final message_delta event carries the cumulative token usage for the request.
$usage = null;
foreach ($stream as $event) {
    if ($event instanceof BetaRawMessageDeltaEvent) {
        $usage = $event->usage;
    }
}

echo $usage;

client = Anthropic::Client.new

stream = client.beta.messages.stream(
  model: "claude-opus-5-5",
  max_tokens: 128_000,
  messages: [
    { role: "user", content: "Review the codebase and propose a refactor plan." }
  ],
  output_config: {
    effort: :high,
    task_budget: { type: :tokens, total: 64_000 }
  },
  betas: ["task-budgets-2026-03-13"]
)

response = stream.accumulated_message

puts response.usage

output_config = { "effort": "high", "task_budget": { "type": "tokens", "total": 128000, "remaining": 128000 - tokens_spent_so_far, }, }

```typescript TypeScript
// Tokens spent before compaction, tracked client-side
const tokensSpentSoFar = 45000;

const outputConfig = {
  effort: "high",
  task_budget: {
    type: "tokens",
    total: 128000,
    remaining: 128000 - tokensSpentSoFar
  }
};

// Tokens spent before compaction, tracked client-side
var tokensSpentSoFar = 45000;

var outputConfig = new BetaOutputConfig
{
    Effort = Effort.High,
    TaskBudget = new BetaTokenTaskBudget
    {
        Total = 128000,
        Remaining = 128000 - tokensSpentSoFar,
    },
};

// Tokens spent before compaction, tracked client-side
tokensSpentSoFar := int64(45000)

outputConfig := anthropic.BetaOutputConfigParam{
	Effort: anthropic.BetaOutputConfigEffortHigh,
	TaskBudget: anthropic.BetaTokenTaskBudgetParam{
		Total:     128000,
		Remaining: anthropic.Int(128000 - tokensSpentSoFar),
	},
}

// Tokens spent before compaction, tracked client-side
long tokensSpentSoFar = 45000;

BetaOutputConfig outputConfig = BetaOutputConfig.builder()
    .effort(BetaOutputConfig.Effort.HIGH)
    .taskBudget(BetaTokenTaskBudget.builder()
        .total(128000L)
        .remaining(128000L - tokensSpentSoFar)
        .build())
    .build();

// Tokens spent before compaction, tracked client-side
$tokensSpentSoFar = 45000;

$outputConfig = [
    'effort' => 'high',
    'taskBudget' => [
        'type' => 'tokens',
        'total' => 128000,
        'remaining' => 128000 - $tokensSpentSoFar,
    ],
];

# Tokens spent before compaction, tracked client-side
tokens_spent_so_far = 45_000

output_config = {
  effort: :high,
  task_budget: {
    type: :tokens,
    total: 128_000,
    remaining: 128_000 - tokens_spent_so_far
  }
}

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Review the codebase and propose a refactor plan."}
    ],
)

# Sum output_tokens (text + thinking + tool calls) across every request in your loop.
print(response.usage.output_tokens)

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [{ role: "user", content: "Review the codebase and propose a refactor plan." }]
});

// Sum output_tokens (text + thinking + tool calls) across every request in your loop.
console.log(response.usage.output_tokens);

var client = new AnthropicClient();

var response = await client.Messages.Create(new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    Messages = [new() { Role = Role.User, Content = "Review the codebase and propose a refactor plan." }],
});

// Sum OutputTokens (text + thinking + tool calls) across every request in your loop.
Console.WriteLine(response.Usage.OutputTokens);

client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 4096,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Review the codebase and propose a refactor plan.")),
	},
})
if err != nil {
	log.Fatal(err)
}

// Sum OutputTokens (text + thinking + tool calls) across every request in your loop.
fmt.Println(response.Usage.OutputTokens)

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(4096L)
    .addUserMessage("Review the codebase and propose a refactor plan.")
    .build();

Message response = client.messages().create(params);
// Sum outputTokens (text + thinking + tool calls) across every request in your loop.
IO.println(response.usage().outputTokens());

$client = new Client();

$response = $client->messages->create(
    model: 'claude-opus-5-5',
    maxTokens: 4096,
    messages: [
        ['role' => 'user', 'content' => 'Review the codebase and propose a refactor plan.'],
    ],
);

// Sum outputTokens (text + thinking + tool calls) across every request in your loop.
echo $response->usage->outputTokens . "\n";

client = Anthropic::Client.new

response = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Review the codebase and propose a refactor plan." }
  ]
)

# Sum output_tokens (text + thinking + tool calls) across every request in your loop.
puts response.usage.output_tokens