[BUG] Opus 4.7 doesn't work with bedrock

[otayemre]

Preflight Checklist

• I have searched existing issues and this hasn't been reported yet
• This is a single bug report (please file separate reports for different bugs)
• I am using the latest version of Claude Code

What's Wrong?

(26-04-16 15:28:52) <1> [~]
dev-dsk-fotay-1d-35fa9bb2 % claude
╭─── Claude Code v2.1.111 ──────────────────────────────────────────────────────────────────────────────────────────────╮
│ │ Tips for getting started │
│ Welcome back! │ Run /init to create a CLAUDE.md file with instructions for Claude │
│ │ ───────────────────────────────────────────────────────────────── │
│ ▐▛███▜▌ │ Recent activity │
│ ▝▜█████▛▘ │ No recent activity │
│ ▘▘ ▝▝ │ │
│ │ │
│ Opus 4.7 with high effort · API Usage Billing │ │
│ /local/home/fotay │ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

❯ hi
⎿  API Error: 400 {"type":"error","request_id":"req_kp45ka3ga5m7upqi6w4r6i3vta2n3lvkx724eynqh2kt6qxiw4xa","error":{"type":"invalid_request_er
ror","message":"invalid beta flag"}}

❯ /model
⎿ Set model to Opus 4.7

❯ hi
⎿  API Error: 400 {"type":"error","request_id":"req_mo2t5pnuqx7mpk4ggz527bgxxpccd7nk2yth5hvcgxlhtydugihq","error":{"type":"invalid_request_er
ror","message":"invalid beta flag"}}

What Should Happen?

it should work

Error Messages/Logs

Steps to Reproduce

use bedrock as provider and set model to opus 4.7

Claude Model

Opus

Is this a regression?

Yes, this worked in a previous version

Last Working Version

No response

Claude Code Version

v2.1.111

Platform

AWS Bedrock

Operating System

Ubuntu/Debian Linux

Terminal/Shell

Terminal.app (macOS)

Additional Information

No response

[github-actions]

Found 3 possible duplicate issues:

1. [BUG] [JetBrains] Invalid beta flag error when using Opus 4.6 (1M context) model #43010
2. [BUG] 2.1.69 sends advanced-tool-use-2025-11-20 beta flag that Bedrock/LiteLLM rejects (regression from 2.1.68) #30926
3. /model claude-opus-4-7 fails with "thinking.type.enabled" not supported error #49219

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

🤖 Generated with Claude Code

[XinRanZh]

Root cause analysis

I dug into this and found the precise cause. TL;DR: Claude Code sends anthropic_beta in the request body when talking to Bedrock, but Bedrock only accepts it as the anthropic-beta HTTP header. Bedrock returns 400 "invalid beta flag" for anything it sees in the body.

Evidence

With ANTHROPIC_LOG=debug on Claude Code 2.1.111 pointed at Bedrock (us.anthropic.claude-opus-4-7), the outbound request looks like:

POST https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-opus-4-7/invoke-with-response-stream

headers:
  anthropic-beta: claude-code-20250219,effort-2025-11-24
  anthropic-version: 2023-06-01
  authorization: Bearer <AWS_BEARER_TOKEN_BEDROCK>
  ...

body:
  {
    "anthropic_version": "bedrock-2023-05-31",
    "anthropic_beta": ["interleaved-thinking-2025-05-14", "tool-search-tool-2025-10-19"],
    "messages": [...],
    "tools": [...],
    "thinking": {...},
    ...
  }

Bedrock rejects this with 400 "invalid beta flag".

Minimal repro against Bedrock directly (no Claude Code)

import requests

KEY = "<AWS_BEARER_TOKEN_BEDROCK>"
URL = "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-opus-4-7/invoke"
H = {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"}

# ✗ Fails (body.anthropic_beta) — this is what Claude Code sends
r = requests.post(URL, headers=H, json={
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 16,
    "messages": [{"role": "user", "content": "hi"}],
    "anthropic_beta": ["interleaved-thinking-2025-05-14"],
})
print(r.status_code, r.text)
# 400  {"message":"{\"type\":\"error\",\"error\":{\"type\":\"invalid_request_error\",\"message\":\"invalid beta flag\"}}"}

# ✓ Works — same flag, moved to header
r = requests.post(URL, headers={**H, "anthropic-beta": "interleaved-thinking-2025-05-14"}, json={
    "anthropic_version": "bedrock-2023-05-31",
    "max_tokens": 16,
    "messages": [{"role": "user", "content": "hi"}],
})
print(r.status_code)  # 200

I also tested every individual beta flag Claude Code uses (interleaved-thinking-2025-05-14, tool-search-tool-2025-10-19, effort-2025-11-24, etc.) in the anthropic-beta header — all of them are accepted by Bedrock on us.anthropic.claude-opus-4-7. The problem is purely the placement (body vs. header).

Why Opus 4.6 works but Opus 4.7 doesn't

Looking at the minified source (search for opus-4-7), Claude Code appears to route Opus 4 calls through client.beta.messages.create and adds interleaved-thinking-2025-05-14 + (for 4.7) extra flags like tool-search-tool-2025-10-19 and effort-2025-11-24. The SDK path for client.beta.messages.create serializes betas into body.anthropic_beta instead of the anthropic-beta header when the target is Bedrock. Opus 4.6 historically accepted (or didn't receive) the specific flags that now fail on 4.7, so the bug only surfaces now.

Why CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1 does not fully fix it

That flag removes some header-level experimental betas (e.g. tool-search-tool-2025-10-19), but interleaved-thinking-2025-05-14 is still emitted in body.anthropic_beta and still gets rejected. Related: #22893.

Suggested fix

In the Bedrock transport, after constructing the JSON body:

if (body.anthropic_beta?.length) {
  const betas = Array.isArray(body.anthropic_beta)
    ? body.anthropic_beta.join(",")
    : String(body.anthropic_beta);
  headers["anthropic-beta"] = [headers["anthropic-beta"], betas]
    .filter(Boolean)
    .join(",");
  delete body.anthropic_beta;
}

This mirrors what the first-party Anthropic API does server-side (accepting both shapes) and what Bedrock requires (header only).

Workaround for anyone blocked today

A ~100 line local HTTP shim that moves body.anthropic_beta → anthropic-beta header and forwards to bedrock-runtime.<region>.amazonaws.com makes Claude Code 2.1.111 + Opus 4.7 work end-to-end. Point Claude Code at it with ANTHROPIC_BEDROCK_BASE_URL=http://127.0.0.1:8765. Happy to share the script if useful.

Environment

• Claude Code 2.1.111
• macOS 26.2 arm64, Node v22.22.2
• Bedrock us-east-1, model us.anthropic.claude-opus-4-7 (also repro'd on global.anthropic.claude-opus-4-7)
• Auth: AWS_BEARER_TOKEN_BEDROCK

[otayemre]

doing this worked:

# Claude Code + Bedrock Opus 4.7: Beta Flag Fix

Claude Code 2.1.111 sends `anthropic_beta` flags that Bedrock's Opus 4.7 endpoint rejects with `invalid beta flag`. This guide fixes it.

## Problem

Bedrock Opus 4.7 rejects ALL beta flags — even an empty `anthropic_beta: []` array causes a 400 error. The field must be completely absent from the request body. Claude Code injects betas through two paths:

1. **SDK `betas:` parameter** → converted to `anthropic-beta` header → copied to `body.anthropic_beta` by the Bedrock adapter
2. **`St()` extra body function** → sets `anthropic_beta` directly in the request body for bedrock-specific betas

## Prerequisites

- Claude Code 2.1.111 (`claude --version` to check)
- Binary location: run `readlink -f $(which claude)` to find it

## Step 1: Settings

Edit `~/.claude/settings.json` and add/merge these into the `env` block:

```json
{
  "env": {
    "CLAUDE_CODE_USE_BEDROCK": "1",
    "ENABLE_TOOL_SEARCH": "false",
    "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1",
    "CLAUDE_CODE_SIMULATE_PROXY_USAGE": "1"
  },
  "model": "us.anthropic.claude-opus-4-7"
}

Key env vars:

• ENABLE_TOOL_SEARCH=false — prevents a separate defer_loading: Extra inputs are not permitted error
• CLAUDE_CODE_SIMULATE_PROXY_USAGE=1 — built-in flag that strips the betas: SDK parameter from API requests (handles injection path 1)
• CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1 — reduces beta count (not sufficient alone)

Step 2: Binary Patch

SIMULATE_PROXY_USAGE only blocks path 1. Path 2 (the St() function) still injects anthropic_beta directly into the request body. We fix this with a 2-byte binary patch.

What we're changing

The function St() in the bundled code has this logic:

if(H&&H.length>0)
  // ...sets q.anthropic_beta = H

We change > to < so the condition is never true (H.length<0 is always false for arrays):

if(H&&H.length<0)
  // ...never executes

Find the patch offsets

BINARY=$(readlink -f $(which claude))

# Back up first
cp "$BINARY" "${BINARY}.backup"

# Find the St() function — look for the CLAUDE_CODE_EXTRA_BODY string
grep -boa "CLAUDE_CODE_EXTRA_BODY" "$BINARY"

You'll see ~5 offsets. The ones that matter are the first two that appear in actual code (not binary data sections). To identify them, check context around each:

# For each offset from grep, check if it's inside the St() function:
dd if="$BINARY" bs=1 skip=<OFFSET-100> count=250 2>/dev/null | cat -v | tr -d '\0'

Look for output containing:

}if(H&&H.length>0)if(q.anthropic_beta&&Array.isArray(q.anthropic_beta

Apply the patch

Once you find the two code copies of St(), locate the > in H&&H.length>0 and change it to <.

Automated method (for 2.1.111 specifically — offsets may differ on other versions):

BINARY=$(readlink -f $(which claude))
cp "$BINARY" "${BINARY}.backup"

# Find exact offsets of St()'s "H&&H.length>0" pattern
# Search near CLAUDE_CODE_EXTRA_BODY for the pattern
python3 << 'PYEOF'
import sys

binary_path = sys.argv[1] if len(sys.argv) > 1 else ""
if not binary_path:
    # Find binary
    import subprocess
    binary_path = subprocess.check_output(
        ["readlink", "-f", subprocess.check_output(["which", "claude"]).decode().strip()]
    ).decode().strip()

with open(binary_path, "rb") as f:
    data = f.read()

# Find CLAUDE_CODE_EXTRA_BODY occurrences
marker = b"CLAUDE_CODE_EXTRA_BODY"
target = b"H&&H.length>0)if(q.anthropic_beta"
patch_offsets = []

pos = 0
while True:
    idx = data.find(marker, pos)
    if idx == -1:
        break
    # Search nearby (within 400 bytes after) for the target pattern
    region_start = idx
    region_end = min(idx + 400, len(data))
    region = data[region_start:region_end]
    target_pos = region.find(target)
    if target_pos != -1:
        # The '>' is at offset 11 within "H&&H.length>0"
        abs_offset = region_start + target_pos + 11
        patch_offsets.append(abs_offset)
        print(f"Found St() at offset {abs_offset} (near EXTRA_BODY at {idx})")
    pos = idx + 1

if not patch_offsets:
    print("ERROR: Could not find St() function pattern. Binary may be a different version.")
    sys.exit(1)

print(f"\nFound {len(patch_offsets)} patch location(s)")
for offset in patch_offsets:
    assert data[offset:offset+1] == b">", f"Expected '>' at offset {offset}, got {data[offset:offset+1]}"

# Apply patches
with open(binary_path, "r+b") as f:
    for offset in patch_offsets:
        f.seek(offset)
        f.write(b"<")
        print(f"Patched offset {offset}: '>' -> '<'")

print("\nDone. Verify with: claude --version")
PYEOF

Manual method (if Python script doesn't work)

BINARY=$(readlink -f $(which claude))

# Find the byte offsets
grep -boa 'H&&H.length>0)if(q.anthropic_beta' "$BINARY"
# Note the offset(s) — add 11 to each to get the '>' position

# Verify before patching (should output 0x3e which is '>')
dd if="$BINARY" bs=1 skip=<OFFSET+11> count=1 2>/dev/null | xxd -p

# Patch each occurrence
printf '<' | dd of="$BINARY" bs=1 seek=<OFFSET+11> count=1 conv=notrunc 2>/dev/null

# Verify after patching (should output 0x3c which is '<')
dd if="$BINARY" bs=1 skip=<OFFSET+11> count=1 2>/dev/null | xxd -p

Step 3: Test

Exit any running Claude Code sessions, then:

claude

It should connect to Opus 4.7 without the invalid beta flag error.

Reverting

BINARY=$(readlink -f $(which claude))
cp "${BINARY}.backup" "$BINARY"

Remove CLAUDE_CODE_SIMULATE_PROXY_USAGE from ~/.claude/settings.json.

Note: If Claude Code is running, the binary is locked. Either stop all sessions first, or copy the backup to a new name and update the symlink:

cp "${BINARY}.backup" "${BINARY}.reverted"
ln -sf "${BINARY}.reverted" $(which claude)

Known Trade-offs

• CLAUDE_CODE_SIMULATE_PROXY_USAGE also strips the context-hint beta body. This is a minor feature loss — context hints help with prompt caching optimization but aren't required for functionality.
• The St() patch prevents any CLAUDE_CODE_EXTRA_BODY env var from adding anthropic_beta. If you don't use that env var (most people don't), this has zero impact.

Why other approaches don't work

Approach	Result
CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1 alone	Reduces beta count but doesn't remove all
SIMULATE_PROXY_USAGE alone	Blocks SDK betas path but not the St() extra body path
Binary patch alone (without env var)	Too many code paths to patch — betas flow through SDK headers, extra body, and duplicate code copies
Renaming anthropic_beta → anthropic_betX	Bedrock rejects unknown fields too: "Extra inputs are not permitted"

[osulli]

Caution

Please don't use either of those two slop comments suggesting binary patches or shims, lol.

E: Now fixed.

[otayemre]

Caution

Please don't use either of those two slop comments suggesting binary patches or shims, lol.

i assume in this case you have a fix? or is your plan to wait?, ah your based in uk. you should go comply with gdpr

[XinRanZh]

It's monkey patch, yes, but at least a solution

[Menci]

A quick fix without patching the binary:

CLAUDE_CODE_EXTRA_BODY='{"thinking":{"type":"adaptive"}}' claude hello

[guicheffer]

A quick fix without patching the binary:

CLAUDE_CODE_EXTRA_BODY='{"thinking":{"type":"adaptive"}}' claude hello

@Menci yeah nice find! but we should keep in mind this would probably break once they ship a proper fix/update right? 🙃

[Menci]

@guicheffer It won't break once they ship a proper fix/update. A proper fix/update will exactly adds these to the request body. But it's always better to remove the workaround once it's not necessary.

[otayemre]

A quick fix without patching the binary:

CLAUDE_CODE_EXTRA_BODY='{"thinking":{"type":"adaptive"}}' claude hello

didn't work due to :

● Menci's thinking is that setting thinking in the body somehow prevents the beta flags. But that's not how the code works. Here's the St()    
  function:                                                                                                                                    
                                                                                                                                               
  function St(H) {                           // H = ["interleaved-thinking-...", ...] (beta flags array)
    let $ = process.env.CLAUDE_CODE_EXTRA_BODY;                                                                                                
    let q = {};                                                                                                                                
    if ($) q = {...JSON.parse($)};           // q = {"thinking":{"type":"adaptive"}}
                                                                                                                                               
    if (H && H.length > 0)                   // H has 20+ betas, so TRUE                                                                       
      if (q.anthropic_beta && Array.isArray(q.anthropic_beta))                                                                                 
        q.anthropic_beta = [...q.anthropic_beta, ...H];                                                                                        
      else                                                                                                                                     
        q.anthropic_beta = H;               // ← this runs. q.thinking doesn't prevent it                                                      
                                                                                                                                               
    return q;  // {"thinking":{"type":"adaptive"}, "anthropic_beta":["interleaved-thinking-...", ...]}                                         
  }                                                                                                                                            
                                                                                                                                               
  The thinking key and anthropic_beta key are completely independent fields in the object. Setting one has zero effect on the other. The       
  function always adds anthropic_beta as long as H (the betas array) has items — which it always does.
                                                                                                                                               
  And that's only one of the two injection paths. The other path (SDK betas: parameter → anthropic-beta header → copied to body.anthropic_beta 
  by the Bedrock adapter) is completely untouched by CLAUDE_CODE_EXTRA_BODY.

[amiramm]

+1 - also affected on macOS arm64, Bedrock us-west-1, Claude Code 2.1.111. The CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1 workaround does not fix it.