Skip to content

Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.

fix(proxy): PR-D1 native Bedrock InvokeModel route + SigV4

chopratejasf2d4fe39cb9f
diff --git a/Cargo.lock b/Cargo.lock
index c2261c95e..f8dd61b8e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -240,6 +240,321 @@ dependencies = [
"arrayvec",
]
+[[package]]
+name = "aws-config"
+version = "1.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50f156acdd2cf55f5aa53ee416c4ac851cf1222694506c0b1f78c85695e9ca9d"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-sdk-sts",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "fastrand",
+ "http 1.4.0",
+ "time",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "aws-credential-types"
+version = "1.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f20799b373a1be121fe3005fba0c2090af9411573878f224df44b42727fcaf7"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-rs"
+version = "1.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec6fb3fe69024a75fa7e1bfb48aa6cf59706a101658ea01bfd33b2b248a038f"
+dependencies = [
+ "aws-lc-sys",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-sys"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f50037ee5e1e41e7b8f9d161680a725bd1626cb6f8c7e901f91f942850852fe7"
+dependencies = [
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+]
+
+[[package]]
+name = "aws-runtime"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dcd93c82209ac7413532388067dce79be5a8780c1786e5fae3df22e4dee2864"
+dependencies = [
+ "aws-credential-types",
+ "aws-sigv4",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-types",
+ "bytes",
+ "bytes-utils",
+ "fastrand",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "percent-encoding",
+ "pin-project-lite",
+ "tracing",
+ "uuid",
+]
+
+[[package]]
+name = "aws-sdk-sts"
+version = "1.103.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2249b81a2e73a8027c41c378463a81ec39b8510f184f2caab87de912af0f49b"
+dependencies = [
+ "aws-credential-types",
+ "aws-runtime",
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-json",
+ "aws-smithy-observability",
+ "aws-smithy-query",
+ "aws-smithy-runtime",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "aws-smithy-xml",
+ "aws-types",
+ "fastrand",
+ "http 0.2.12",
+ "http 1.4.0",
+ "regex-lite",
+ "tracing",
+]
+
+[[package]]
+name = "aws-sigv4"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68dc0b907359b120170613b5c09ccc61304eac3998ff6274b97d93ee6490115a"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-http",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "form_urlencoded",
+ "hex",
+ "hmac",
+ "http 0.2.12",
+ "http 1.4.0",
+ "percent-encoding",
+ "sha2 0.11.0",
+ "time",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-async"
+version = "1.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ffcaf626bdda484571968400c326a244598634dc75fd451325a54ad1a59acfc"
+dependencies = [
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "aws-smithy-http"
+version = "0.63.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba1ab2dc1c2c3749ead27180d333c42f11be8b0e934058fb4b2258ee8dbe5231"
+dependencies = [
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "bytes-utils",
+ "futures-core",
+ "futures-util",
+ "http 1.4.0",
+ "http-body 1.0.1",
+ "http-body-util",
+ "percent-encoding",
+ "pin-project-lite",
+ "pin-utils",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-http-client"
+version = "1.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a2f165a7feee6f263028b899d0a181987f4fa7179a6411a32a439fba7c5f769"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "h2",
+ "http 1.4.0",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "pin-project-lite",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tower",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-json"
+version = "0.62.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9648b0bb82a2eedd844052c6ad2a1a822d1f8e3adee5fbf668366717e428856a"
+dependencies = [
+ "aws-smithy-types",
+]
+
+[[package]]
+name = "aws-smithy-observability"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06c2315d173edbf1920da8ba3a7189695827002e4c0fc961973ab1c54abca9c"
+dependencies = [
+ "aws-smithy-runtime-api",
+]
+
+[[package]]
+name = "aws-smithy-query"
+version = "0.60.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a56d79744fb3edb5d722ef79d86081e121d3b9422cb209eb03aea6aa4f21ebd"
+dependencies = [
+ "aws-smithy-types",
+ "urlencoding",
+]
+
+[[package]]
+name = "aws-smithy-runtime"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0504b1ab12debb5959e5165ee5fe97dd387e7aa7ea6a477bfd7635dfe769a4f5"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-http",
+ "aws-smithy-http-client",
+ "aws-smithy-observability",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "bytes",
+ "fastrand",
+ "http 0.2.12",
+ "http 1.4.0",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "http-body-util",
+ "pin-project-lite",
+ "pin-utils",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "aws-smithy-runtime-api"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b71a13df6ada0aafbf21a73bdfcdf9324cfa9df77d96b8446045be3cde61b42e"
+dependencies = [
+ "aws-smithy-async",
+ "aws-smithy-runtime-api-macros",
+ "aws-smithy-types",
+ "bytes",
+ "http 0.2.12",
+ "http 1.4.0",
+ "pin-project-lite",
+ "tokio",
+ "tracing",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-smithy-runtime-api-macros"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d7396fd9500589e62e460e987ecb671bad374934e55ec3b5f498cc7a8a8a7b7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "aws-smithy-types"
+version = "1.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d73dbfbaa8e4bc57b9045137680b958d274823509a360abfd8e1d514d40c95c"
+dependencies = [
+ "base64-simd",
+ "bytes",
+ "bytes-utils",
+ "http 0.2.12",
+ "http 1.4.0",
+ "http-body 0.4.6",
+ "http-body 1.0.1",
+ "http-body-util",
+ "itoa",
+ "num-integer",
+ "pin-project-lite",
+ "pin-utils",
+ "ryu",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "aws-smithy-xml"
+version = "0.60.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce02add1aa3677d022f8adf81dcbe3046a95f17a1b1e8979c145cd21d3d22b3"
+dependencies = [
+ "xmlparser",
+]
+
+[[package]]
+name = "aws-types"
+version = "1.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4bbcaa9304ea40902d3d5f42a0428d1bd895a2b0f6999436fb279ffddc58ac"
+dependencies = [
+ "aws-credential-types",
+ "aws-smithy-async",
+ "aws-smithy-runtime-api",
+ "aws-smithy-types",
+ "rustc_version",
+ "tracing",
+]
+
[[package]]
name = "axum"
version = "0.7.9"
@@ -252,8 +567,8 @@ dependencies = [
"base64 0.22.1",
"bytes",
"futures-util",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
"http-body-util",
"hyper",
"hyper-util",
@@ -287,8 +602,8 @@ dependencies = [
"async-trait",
"bytes",
"futures-util",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
"http-body-util",
"mime",
"pin-project-lite",
@@ -322,6 +637,16 @@ version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+[[package]]
+name = "base64-simd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195"
+dependencies = [
+ "outref",
+ "vsimd",
+]
+
[[package]]
name = "base64ct"
version = "1.8.3"
@@ -387,6 +712,15 @@ dependencies = [
"generic-array",
]
+[[package]]
+name = "block-buffer"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be"
+dependencies = [
+ "hybrid-array",
+]
+
[[package]]
name = "bstr"
version = "1.12.1"
@@ -434,6 +768,16 @@ version = "1.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+[[package]]
+name = "bytes-utils"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35"
+dependencies = [
+ "bytes",
+ "either",
+]
+
[[package]]
name = "bytesize"
version = "1.3.3"
@@ -546,6 +890,21 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9"
+[[package]]
+name = "cmake"
+version = "0.1.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "cmov"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f88a43d011fc4a6876cb7344703e297c71dda42494fee094d5f7c76bf13f746"
+
[[package]]
name = "color_quant"
version = "1.1.0"
@@ -608,6 +967,12 @@ dependencies = [
"windows-sys 0.61.2",
]
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
[[package]]
name = "constant_time_eq"
version = "0.4.2"
@@ -773,6 +1138,24 @@ dependencies = [
"typenum",
]
+[[package]]
+name = "crypto-common"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77727bb15fa921304124b128af125e7e3b968275d1b108b379190264f4423710"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "ctutils"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e"
+dependencies = [
+ "cmov",
+]
+
[[package]]
name = "darling"
version = "0.20.11"
@@ -911,8 +1294,20 @@ version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
dependencies = [
- "block-buffer",
- "crypto-common",
+ "block-buffer 0.10.4",
+ "crypto-common 0.1.7",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer 0.12.0",
+ "const-oid",
+ "crypto-common 0.2.1",
+ "ctutils",
]
[[package]]
@@ -956,6 +1351,12 @@ dependencies = [
"litrs",
]
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
[[package]]
name = "either"
version = "1.15.0"
@@ -1170,6 +1571,12 @@ dependencies = [
"percent-encoding",
]
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
[[package]]
name = "futures"
version = "0.3.32"
@@ -1329,7 +1736,7 @@ dependencies = [
"fnv",
"futures-core",
"futures-sink",
- "http",
+ "http 1.4.0",
"indexmap",
"slab",
"tokio",
@@ -1415,7 +1822,7 @@ dependencies = [
"rusqlite",
"serde",
"serde_json",
- "sha2",
+ "sha2 0.10.9",
"tempfile",
"thiserror 1.0.69",
"tiktoken-rs",
@@ -1441,6 +1848,10 @@ dependencies = [
name = "headroom-proxy"
version = "0.1.0"
dependencies = [
+ "aws-config",
+ "aws-credential-types",
+ "aws-sigv4",
+ "aws-smithy-runtime-api",
"axum",
"bytes",
"bytesize",
@@ -1448,7 +1859,7 @@ dependencies = [
"futures",
"futures-util",
"headroom-core",
- "http",
+ "http 1.4.0",
"http-body-util",
"humantime",
"hyper",
@@ -1458,7 +1869,7 @@ dependencies = [
"reqwest",
"serde",
"serde_json",
- "sha2",
+ "sha2 0.10.9",
"thiserror 1.0.69",
"tokio",
"tokio-stream",
@@ -1494,6 +1905,12 @@ version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
[[package]]
name = "hf-hub"
version = "0.4.3"
@@ -1501,7 +1918,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "629d8f3bbeda9d148036d6b0de0a3ab947abd08ce90626327fc3547a49d59d97"
dependencies = [
"dirs",
- "http",
+ "http 1.4.0",
"indicatif 0.17.11",
"libc",
"log",
@@ -1521,7 +1938,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aef3982638978efa195ff11b305f51f1f22f4f0a6cabee7af79b383ebee6a213"
dependencies = [
"dirs",
- "http",
+ "http 1.4.0",
"indicatif 0.18.4",
"libc",
"log",
@@ -1535,12 +1952,32 @@ dependencies = [
"windows-sys 0.61.2",
]
+[[package]]
+name = "hmac"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"
+dependencies = [
+ "digest 0.11.3",
+]
+
[[package]]
name = "hmac-sha256"
version = "1.1.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec9d92d097f4749b64e8cc33d924d9f40a2d4eb91402b458014b781f5733d60f"
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
[[package]]
name = "http"
version = "1.4.0"
@@ -1551,6 +1988,17 @@ dependencies = [
"itoa",
]
+[[package]]
+name = "http-body"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes",
+ "http 0.2.12",
+ "pin-project-lite",
+]
+
[[package]]
name = "http-body"
version = "1.0.1"
@@ -1558,7 +2006,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
dependencies = [
"bytes",
- "http",
+ "http 1.4.0",
]
[[package]]
@@ -1569,8 +2017,8 @@ checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
dependencies = [
"bytes",
"futures-core",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
"pin-project-lite",
]
@@ -1592,6 +2040,15 @@ version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+[[package]]
+name = "hybrid-array"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d46837a0ed51fe95bd3b05de33cd64a1ee88fc797477ca48446872504507c5"
+dependencies = [
+ "typenum",
+]
+
[[package]]
name = "hyper"
version = "1.9.0"
@@ -1603,8 +2060,8 @@ dependencies = [
"futures-channel",
"futures-core",
"h2",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
"httparse",
"httpdate",
"itoa",
@@ -1620,10 +2077,11 @@ version = "0.27.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
dependencies = [
- "http",
+ "http 1.4.0",
"hyper",
"hyper-util",
"rustls",
+ "rustls-native-certs",
"tokio",
"tokio-rustls",
"tower-service",
@@ -1656,8 +2114,8 @@ dependencies = [
"bytes",
"futures-channel",
"futures-util",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
"hyper",
"ipnet",
"libc",
@@ -2150,7 +2608,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
dependencies = [
"cfg-if",
- "digest",
+ "digest 0.10.7",
]
[[package]]
@@ -2509,6 +2967,12 @@ dependencies = [
"ureq 3.3.0",
]
+[[package]]
+name = "outref"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e"
+
[[package]]
name = "parking_lot_core"
version = "0.9.12"
@@ -2555,6 +3019,12 @@ version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
[[package]]
name = "pkg-config"
version = "0.3.33"
@@ -3078,6 +3548,12 @@ dependencies = [
"regex-syntax",
]
+[[package]]
+name = "regex-lite"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
+
[[package]]
name = "regex-syntax"
version = "0.8.10"
@@ -3096,8 +3572,8 @@ dependencies = [
"futures-core",
"futures-util",
"h2",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
"http-body-util",
"hyper",
"hyper-rustls",
@@ -3177,6 +3653,15 @@ version = "2.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
[[package]]
name = "rustix"
version = "1.1.4"
@@ -3196,6 +3681,7 @@ version = "0.23.39"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c2c118cb077cca2822033836dfb1b975355dfb784b5e8da48f7b6c5db74e60e"
dependencies = [
+ "aws-lc-rs",
"log",
"once_cell",
"ring",
@@ -3205,6 +3691,18 @@ dependencies = [
"zeroize",
]
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
[[package]]
name = "rustls-pki-types"
version = "1.14.0"
@@ -3221,6 +3719,7 @@ version = "0.103.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
dependencies = [
+ "aws-lc-rs",
"ring",
"rustls-pki-types",
"untrusted",
@@ -3398,7 +3897,7 @@ checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
dependencies = [
"cfg-if",
"cpufeatures 0.2.17",
- "digest",
+ "digest 0.10.7",
]
[[package]]
@@ -3409,7 +3908,18 @@ checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
dependencies = [
"cfg-if",
"cpufeatures 0.2.17",
- "digest",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.3",
]
[[package]]
@@ -3923,8 +4433,8 @@ dependencies = [
"bitflags",
"bytes",
"futures-util",
- "http",
- "http-body",
+ "http 1.4.0",
+ "http-body 1.0.1",
"iri-string",
"pin-project-lite",
"tower",
@@ -4036,7 +4546,7 @@ dependencies = [
"byteorder",
"bytes",
"data-encoding",
- "http",
+ "http 1.4.0",
"httparse",
"log",
"rand 0.8.6",
@@ -4176,7 +4686,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e994ba84b0bd1b1b0cf92878b7ef898a5c1760108fe7b6010327e274917a808c"
dependencies = [
"base64 0.22.1",
- "http",
+ "http 1.4.0",
"httparse",
"log",
]
@@ -4193,6 +4703,12 @@ dependencies = [
"serde",
]
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
[[package]]
name = "utf-8"
version = "0.7.6"
@@ -4257,6 +4773,12 @@ version = "0.9.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+[[package]]
+name = "vsimd"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64"
+
[[package]]
name = "wait-timeout"
version = "0.2.1"
@@ -4714,7 +5236,7 @@ dependencies = [
"base64 0.22.1",
"deadpool",
"futures",
- "http",
+ "http 1.4.0",
"http-body-util",
"hyper",
"hyper-util",
@@ -4827,6 +5349,12 @@ version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+[[package]]
+name = "xmlparser"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
+
[[package]]
name = "y4m"
version = "0.8.0"
diff --git a/Cargo.toml b/Cargo.toml
index 4b472ef6d..98a4d251a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -56,3 +56,15 @@ axum = "0.7"
tower = "0.5"
reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
pyo3 = "0.22"
+# Phase D PR-D1: AWS SigV4 signing for native Bedrock InvokeModel route.
+# `aws-sigv4` provides the canonical-request + signing-key implementation;
+# `aws-config` resolves credentials from the standard provider chain
+# (env vars, profiles, IMDS, ECS task role, etc); `aws-credential-types`
+# exposes `Credentials` so the signer accepts whatever the chain returned.
+aws-sigv4 = { version = "1", default-features = false, features = ["sign-http", "http1"] }
+aws-config = { version = "1", default-features = false, features = ["behavior-version-latest", "rustls", "rt-tokio"] }
+aws-credential-types = { version = "1", default-features = false }
+# `Identity` lives in aws-smithy-runtime-api; the SigV4 builder
+# accepts `&Identity`. Pinning the version explicitly avoids a
+# silent semver bump from the transitive dep tree.
+aws-smithy-runtime-api = { version = "1", default-features = false, features = ["client"] }
diff --git a/crates/headroom-proxy/Cargo.toml b/crates/headroom-proxy/Cargo.toml
index 61e507661..ff0c21358 100644
--- a/crates/headroom-proxy/Cargo.toml
+++ b/crates/headroom-proxy/Cargo.toml
@@ -41,6 +41,12 @@ humantime = "2"
bytesize = "1"
tokio-util = { version = "0.7" }
headroom-core = { path = "../headroom-core" }
+# Phase D PR-D1: native Bedrock InvokeModel route. SigV4 + AWS
+# default credential chain.
+aws-sigv4 = { workspace = true }
+aws-config = { workspace = true }
+aws-credential-types = { workspace = true }
+aws-smithy-runtime-api = { workspace = true }
[dev-dependencies]
tower = { workspace = true, features = ["util"] }
diff --git a/crates/headroom-proxy/src/bedrock/envelope.rs b/crates/headroom-proxy/src/bedrock/envelope.rs
new file mode 100644
index 000000000..3f2b9a26f
--- /dev/null
+++ b/crates/headroom-proxy/src/bedrock/envelope.rs
@@ -0,0 +1,239 @@
+//! Bedrock envelope: parse the body shape Bedrock expects, hand the
+//! Anthropic-shape sub-body to the compressor, and re-emit with
+//! `anthropic_version` preserved as the FIRST key.
+//!
+//! # Wire shape
+//!
+//! Bedrock InvokeModel for any `anthropic.claude-*` model expects:
+//!
+//! ```json
+//! {
+//! "anthropic_version": "bedrock-2023-05-31",
+//! "messages": [...],
+//! "max_tokens": 1024,
+//! ...rest_of_anthropic_body
+//! }
+//! ```
+//!
+//! `model` is in the URL path (`/model/{model}/invoke`), NOT the body
+//! — the opposite of direct-Anthropic `/v1/messages`. `anthropic_version`
+//! is REQUIRED and must be a literal Bedrock-recognized version
+//! string (e.g. `"bedrock-2023-05-31"`).
+//!
+//! # Why key order matters
+//!
+//! Bedrock's request validator does NOT depend on key order, but our
+//! cache-safety contract (`I1` in REALIGNMENT/02-architecture.md) is
+//! that *unmodified* bytes round-trip byte-equal. If the compressor
+//! returns `NoChange` we forward the original buffered bytes
+//! verbatim — we never re-serialize. If the compressor returns
+//! `Modified`, the byte slice it produced already preserves
+//! key order from the input via the `preserve_order` feature on
+//! `serde_json` (the workspace turns this on by default).
+//!
+//! This module's [`BedrockEnvelope`] is used ONLY for re-emitting
+//! the envelope shape after compression. It calls the compressor
+//! against the body bytes directly — there is no decode-then-encode
+//! round trip on the no-change path.
+
+use bytes::Bytes;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use thiserror::Error;
+
+/// The literal `anthropic_version` field name. Bedrock-strict.
+const ANTHROPIC_VERSION_KEY: &str = "anthropic_version";
+
+/// Parsed Bedrock InvokeModel envelope. Holds the literal
+/// `anthropic_version` string plus the rest of the body as a parsed
+/// `serde_json::Value` (so callers can inspect / route it). The
+/// original byte-equal body is also stashed for the no-change
+/// passthrough path.
+#[derive(Debug, Clone)]
+pub struct BedrockEnvelope {
+ /// The literal `anthropic_version` string, e.g.
+ /// `"bedrock-2023-05-31"`. Required.
+ pub anthropic_version: String,
+ /// The full parsed body, including `anthropic_version`. Useful
+ /// for tests + logs; the compressor takes raw bytes.
+ pub body: Value,
+}
+
+/// Errors surfaced when parsing a Bedrock envelope.
+#[derive(Debug, Error)]
+pub enum EnvelopeError {
+ /// Body was not valid JSON.
+ #[error("body is not valid JSON: {0}")]
+ NotJson(serde_json::Error),
+ /// Body was JSON but not a top-level object.
+ #[error("body is not a JSON object")]
+ NotObject,
+ /// `anthropic_version` field missing.
+ #[error("missing required `anthropic_version` field")]
+ MissingAnthropicVersion,
+ /// `anthropic_version` was present but not a string.
+ #[error("`anthropic_version` is not a string")]
+ AnthropicVersionNotString,
+}
+
+impl BedrockEnvelope {
+ /// Parse a Bedrock envelope from raw JSON bytes.
+ ///
+ /// This does NOT mutate the bytes. Compression dispatch happens
+ /// elsewhere (the handler hands the same byte slice to
+ /// `compress_anthropic_request`).
+ pub fn parse(body: &[u8]) -> Result<Self, EnvelopeError> {
+ let value: Value = serde_json::from_slice(body).map_err(EnvelopeError::NotJson)?;
+ let obj = value.as_object().ok_or(EnvelopeError::NotObject)?;
+ let av = obj
+ .get(ANTHROPIC_VERSION_KEY)
+ .ok_or(EnvelopeError::MissingAnthropicVersion)?;
+ let av_str = av
+ .as_str()
+ .ok_or(EnvelopeError::AnthropicVersionNotString)?
+ .to_string();
+ Ok(Self {
+ anthropic_version: av_str,
+ body: value,
+ })
+ }
+
+ /// Re-emit the envelope as JSON bytes with `anthropic_version`
+ /// preserved as the FIRST key.
+ ///
+ /// Used only after the compressor returns `Modified` and we need
+ /// to reassemble the body. With `serde_json`'s `preserve_order`
+ /// feature (workspace default), the parsed object already preserves
+ /// insertion order; we just need to make sure `anthropic_version`
+ /// is the first key. If the compressor's output already has it
+ /// first (which it will — the compressor only mutates the
+ /// `messages` content slot, not key ordering), we hand the bytes
+ /// back unchanged.
+ ///
+ /// `body` is the (possibly-compressed) JSON bytes returned by the
+ /// compression dispatcher.
+ ///
+ /// Returns `Ok(bytes)` on success. On any structural error, returns
+ /// the input bytes unchanged so the byte-fidelity contract is
+ /// preserved (the caller will surface the error).
+ pub fn ensure_anthropic_version_first(body: &[u8]) -> Result<Bytes, EnvelopeError> {
+ // Parse with preserve_order (workspace serde_json default).
+ let mut value: Value = serde_json::from_slice(body).map_err(EnvelopeError::NotJson)?;
+ let map = value.as_object_mut().ok_or(EnvelopeError::NotObject)?;
+
+ // If `anthropic_version` is missing, that's a logical error
+ // for the Bedrock surface — surface it loudly.
+ if !map.contains_key(ANTHROPIC_VERSION_KEY) {
+ return Err(EnvelopeError::MissingAnthropicVersion);
+ }
+
+ // Already first? Then `body` round-trips byte-equal — no work.
+ // Note: serde_json::Map iteration order, with preserve_order,
+ // is insertion order. We check the first key directly.
+ if map
+ .keys()
+ .next()
+ .map(|k| k.as_str() == ANTHROPIC_VERSION_KEY)
+ .unwrap_or(false)
+ {
+ return Ok(Bytes::copy_from_slice(body));
+ }
+
+ // Reorder: pull anthropic_version, drain rest, rebuild with
+ // anthropic_version first. This only runs when the compressor
+ // moved the field (it shouldn't, but if it ever does we
+ // reassert the invariant rather than ship a Bedrock-rejecting
+ // body).
+ let av = map
+ .remove(ANTHROPIC_VERSION_KEY)
+ .expect("contains_key guard above");
+ let mut new_map = serde_json::Map::with_capacity(map.len() + 1);
+ new_map.insert(ANTHROPIC_VERSION_KEY.to_string(), av);
+ for (k, v) in std::mem::take(map) {
+ new_map.insert(k, v);
+ }
+ let rebuilt = Value::Object(new_map);
+ let bytes = serde_json::to_vec(&rebuilt).map_err(EnvelopeError::NotJson)?;
+ Ok(Bytes::from(bytes))
+ }
+}
+
+/// Helper for reading just the model id from a Bedrock URL path.
+///
+/// Bedrock paths look like `/model/{model_id}/invoke`. The `{model_id}`
+/// segment can contain dots (`anthropic.claude-3-haiku-20240307-v1:0`),
+/// hyphens, colons, and digits — all of which are allowed in URL path
+/// segments. We use Axum's `:model_id` capture; this helper exists for
+/// callers who only have the raw path.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ModelPath {
+ pub model_id: String,
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use serde_json::json;
+
+ #[test]
+ fn parses_minimal_envelope() {
+ let body = json!({
+ "anthropic_version": "bedrock-2023-05-31",
+ "max_tokens": 16,
+ "messages": [{"role": "user", "content": "hi"}]
+ });
+ let bytes = serde_json::to_vec(&body).unwrap();
+ let env = BedrockEnvelope::parse(&bytes).expect("parses");
+ assert_eq!(env.anthropic_version, "bedrock-2023-05-31");
+ }
+
+ #[test]
+ fn missing_anthropic_version_errors() {
+ let body = json!({"max_tokens": 16, "messages": []});
+ let bytes = serde_json::to_vec(&body).unwrap();
+ let err = BedrockEnvelope::parse(&bytes).expect_err("must error");
+ assert!(matches!(err, EnvelopeError::MissingAnthropicVersion));
+ }
+
+ #[test]
+ fn anthropic_version_not_string_errors() {
+ let body = json!({"anthropic_version": 123, "max_tokens": 16});
+ let bytes = serde_json::to_vec(&body).unwrap();
+ let err = BedrockEnvelope::parse(&bytes).expect_err("must error");
+ assert!(matches!(err, EnvelopeError::AnthropicVersionNotString));
+ }
+
+ #[test]
+ fn not_an_object_errors() {
+ let bytes = b"[1,2,3]";
+ let err = BedrockEnvelope::parse(bytes).expect_err("must error");
+ assert!(matches!(err, EnvelopeError::NotObject));
+ }
+
+ #[test]
+ fn invalid_json_errors() {
+ let bytes = b"not json";
+ let err = BedrockEnvelope::parse(bytes).expect_err("must error");
+ assert!(matches!(err, EnvelopeError::NotJson(_)));
+ }
+
+ #[test]
+ fn ensure_first_no_op_when_already_first() {
+ let body = br#"{"anthropic_version":"bedrock-2023-05-31","max_tokens":16}"#;
+ let out = BedrockEnvelope::ensure_anthropic_version_first(body).unwrap();
+ assert_eq!(&out[..], &body[..]);
+ }
+
+ #[test]
+ fn ensure_first_reorders_when_not_first() {
+ // anthropic_version comes second.
+ let body = br#"{"max_tokens":16,"anthropic_version":"bedrock-2023-05-31"}"#;
+ let out = BedrockEnvelope::ensure_anthropic_version_first(body).unwrap();
+ let out_str = std::str::from_utf8(&out).unwrap();
+ // First key after `{"` must be `anthropic_version`.
+ assert!(
+ out_str.starts_with(r#"{"anthropic_version":"bedrock-2023-05-31""#),
+ "got {out_str}"
+ );
+ }
+}
diff --git a/crates/headroom-proxy/src/bedrock/invoke.rs b/crates/headroom-proxy/src/bedrock/invoke.rs
new file mode 100644
index 000000000..afa03b8f1
--- /dev/null
+++ b/crates/headroom-proxy/src/bedrock/invoke.rs
@@ -0,0 +1,555 @@
+//! POST `/model/{model_id}/invoke` handler — Phase D PR-D1.
+//!
+//! # Pipeline
+//!
+//! 1. Extract `{model_id}` from the path. The Bedrock convention is
+//! `anthropic.claude-3-haiku-20240307-v1:0` — dot-separated
+//! `<vendor>.<model>-<date>-<rev>`.
+//! 2. If the vendor is `anthropic`, parse the body as a Bedrock
+//! envelope (`{"anthropic_version": "...", ...rest}`) and run the
+//! live-zone Anthropic compression dispatcher over the body bytes.
+//! The dispatcher is the SAME one `/v1/messages` uses; Bedrock's
+//! body shape is just Anthropic-without-the-`model`-field.
+//! 3. Re-emit the (possibly compressed) body with `anthropic_version`
+//! preserved as the first key.
+//! 4. Build the upstream URL (`https://bedrock-runtime.{region}.amazonaws.com/model/{model}/invoke`
+//! or operator override).
+//! 5. Sign the (post-compression) body bytes with AWS SigV4. Sign
+//! over `host`, `x-amz-date`, `x-amz-content-sha256` plus any
+//! extra headers (`content-type`, `accept`).
+//! 6. Forward to Bedrock; stream the response back to the client.
+//!
+//! # Failure modes
+//!
+//! - **Missing credentials**: log
+//! `event=bedrock_credentials_missing` at WARN, return `500` with
+//! a JSON error body. NEVER forwards an unsigned request.
+//! - **Envelope parse failure**: log `event=bedrock_envelope_parse_error`,
+//! pass the bytes through unchanged. Bedrock will reject anyway,
+//! but the failure is the customer's, not ours — we just route.
+//! This matches the Anthropic compression path's
+//! `Outcome::Passthrough` behaviour.
+//! - **Non-anthropic model**: skip compression, but still sign +
+//! forward. Other vendors (Amazon Titan, Cohere, AI21, Meta) have
+//! different body shapes that the proxy doesn't yet understand;
+//! we pass them through opaquely.
+//! - **SigV4 signing failure**: log
+//! `event=bedrock_sigv4_failed`, return `500`. NEVER forwards
+//! unsigned.
+
+use std::net::SocketAddr;
+use std::time::SystemTime;
+
+use axum::body::Body;
+use axum::extract::{ConnectInfo, Path, State};
+use axum::http::{HeaderMap, Method, StatusCode, Uri};
+use axum::response::{IntoResponse, Response};
+use bytes::Bytes;
+use futures_util::StreamExt as _;
+use http::HeaderName;
+use url::Url;
+
+use crate::bedrock::envelope::BedrockEnvelope;
+use crate::bedrock::sigv4::{sign_request, SigningInputs};
+use crate::compression::{
+ compress_anthropic_request, Outcome as AnthropicOutcome, PassthroughReason,
+};
+use crate::headers::filter_response_headers;
+use crate::proxy::AppState;
+
+/// Anthropic vendor prefix as encoded in Bedrock model ids
+/// (`anthropic.claude-3-haiku-...`). Literal-match per project rule
+/// "no regexes for parsing the model ID".
+const ANTHROPIC_VENDOR_PREFIX: &str = "anthropic.";
+
+/// AWS Bedrock Runtime DNS template. The `{}` placeholder is the
+/// region. Only used when `Config::bedrock_endpoint` is `None`.
+const BEDROCK_RUNTIME_HOST_TEMPLATE: &str = "bedrock-runtime.{region}.amazonaws.com";
+
+/// Axum POST handler for `/model/{model_id}/invoke`.
+///
+/// Buffers the body so the live-zone compressor + SigV4 signer can
+/// inspect it. Both are required to be applied to the SAME byte slice
+/// — the signer hashes whatever the forwarder will actually send.
+pub async fn handle_invoke(
+ State(state): State<AppState>,
+ ConnectInfo(client_addr): ConnectInfo<SocketAddr>,
+ Path(model_id): Path<String>,
+ method: Method,
+ uri: Uri,
+ headers: HeaderMap,
+ body: Bytes,
+) -> Response {
+ let _ = client_addr; // accepted for ConnectInfo extractor; not used directly today
+ let request_id = headers
+ .get("x-request-id")
+ .and_then(|v| v.to_str().ok())
+ .map(|s| s.to_string())
+ .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
+
+ tracing::info!(
+ event = "bedrock_invoke_received",
+ request_id = %request_id,
+ method = %method,
+ model_id = %model_id,
+ body_bytes = body.len(),
+ "bedrock invoke route received request"
+ );
+
+ let is_anthropic = model_id.starts_with(ANTHROPIC_VENDOR_PREFIX);
+ let outbound_body: Bytes = if is_anthropic {
+ run_anthropic_compression(&body, &state, &request_id)
+ } else {
+ tracing::info!(
+ event = "bedrock_compression_skipped",
+ request_id = %request_id,
+ model_id = %model_id,
+ reason = "non_anthropic_vendor",
+ "bedrock invoke: skipping live-zone compression for non-anthropic vendor"
+ );
+ body.clone()
+ };
+
+ // Build the upstream URL based on configured endpoint or
+ // region-derived default.
+ let upstream_url = match build_bedrock_upstream(&state, &model_id, &uri, "invoke") {
+ Ok(u) => u,
+ Err(msg) => {
+ tracing::error!(
+ event = "bedrock_endpoint_invalid",
+ request_id = %request_id,
+ error = %msg,
+ "bedrock invoke: failed to construct upstream URL"
+ );
+ return error_response(
+ StatusCode::INTERNAL_SERVER_ERROR,
+ "bedrock_endpoint_invalid",
+ &msg,
+ );
+ }
+ };
+
+ // Resolve credentials. No silent fallback: missing creds → 5xx.
+ let creds = match state.bedrock_credentials.as_ref() {
+ Some(c) => c.clone(),
+ None => {
+ tracing::warn!(
+ event = "bedrock_credentials_missing",
+ request_id = %request_id,
+ model_id = %model_id,
+ "bedrock invoke: refusing to forward without AWS credentials"
+ );
+ return error_response(
+ StatusCode::INTERNAL_SERVER_ERROR,
+ "bedrock_credentials_missing",
+ "AWS credentials not configured; refusing to forward unsigned",
+ );
+ }
+ };
+
+ // Build the headers we sign + forward. Start from the inbound
+ // headers, drop the ones the upstream client manages, then sign.
+ let extra_signed: Vec<(String, String)> = collect_signed_headers(&headers, &upstream_url);
+ let extra_signed_refs: Vec<(&str, &str)> = extra_signed
+ .iter()
+ .map(|(k, v)| (k.as_str(), v.as_str()))
+ .collect();
+
+ let sign_inputs = SigningInputs {
+ method: method.as_str(),
+ url: &upstream_url,
+ region: &state.config.bedrock_region,
+ credentials: creds.as_ref(),
+ body: &outbound_body,
+ extra_signed_headers: &extra_signed_refs,
+ time: SystemTime::now(),
+ };
+ let signed = match sign_request(&sign_inputs) {
+ Ok(s) => s,
+ Err(e) => {
+ tracing::error!(
+ event = "bedrock_sigv4_failed",
+ request_id = %request_id,
+ model_id = %model_id,
+ error = %e,
+ "bedrock invoke: SigV4 signing failed; refusing to forward"
+ );
+ return error_response(
+ StatusCode::INTERNAL_SERVER_ERROR,
+ "bedrock_sigv4_failed",
+ &e.to_string(),
+ );
+ }
+ };
+
+ // Compose the outgoing header map. Start with the headers we'll
+ // forward (filter out hop-by-hop / Host / Content-Length;
+ // reqwest sets those itself), then layer the SigV4 outputs on
+ // top — they replace any pre-existing copies of the same name.
+ let mut outbound_headers = HeaderMap::new();
+ for (name, value) in extra_signed.iter() {
+ if let (Ok(n), Ok(v)) = (
+ HeaderName::from_bytes(name.as_bytes()),
+ http::HeaderValue::from_str(value),
+ ) {
+ outbound_headers.insert(n, v);
+ }
+ }
+ for (name, value) in signed.entries.iter() {
+ if let (Ok(n), Ok(v)) = (
+ HeaderName::from_bytes(name.as_bytes()),
+ http::HeaderValue::from_str(value),
+ ) {
+ outbound_headers.insert(n, v);
+ }
+ }
+
+ // Forward. We surface upstream errors as 502; the byte path
+ // streams the response back to the client.
+ let reqwest_method = match reqwest::Method::from_bytes(method.as_str().as_bytes()) {
+ Ok(m) => m,
+ Err(e) => {
+ tracing::error!(
+ event = "bedrock_invalid_method",
+ request_id = %request_id,
+ error = %e,
+ "bedrock invoke: invalid HTTP method"
+ );
+ return error_response(
+ StatusCode::BAD_REQUEST,
+ "bedrock_invalid_method",
+ &e.to_string(),
+ );
+ }
+ };
+
+ let upstream_resp = state
+ .client
+ .request(reqwest_method, upstream_url.clone())
+ .headers(outbound_headers)
+ .body(outbound_body.clone())
+ .send()
+ .await;
+
+ let upstream_resp = match upstream_resp {
+ Ok(r) => r,
+ Err(e) => {
+ tracing::warn!(
+ event = "bedrock_upstream_error",
+ request_id = %request_id,
+ error = %e,
+ "bedrock invoke: upstream request failed"
+ );
+ let status = if e.is_timeout() {
+ StatusCode::GATEWAY_TIMEOUT
+ } else {
+ StatusCode::BAD_GATEWAY
+ };
+ return error_response(status, "bedrock_upstream_error", &e.to_string());
+ }
+ };
+
+ let status =
+ StatusCode::from_u16(upstream_resp.status().as_u16()).unwrap_or(StatusCode::BAD_GATEWAY);
+ let resp_headers = filter_response_headers(upstream_resp.headers());
+
+ tracing::info!(
+ event = "bedrock_invoke_forwarded",
+ request_id = %request_id,
+ model_id = %model_id,
+ upstream_status = status.as_u16(),
+ upstream_url = %upstream_url,
+ "bedrock invoke: response forwarded"
+ );
+
+ // Stream the response body back without buffering.
+ let stream = upstream_resp
+ .bytes_stream()
+ .map(|r| r.map_err(std::io::Error::other));
+ let body_out = Body::from_stream(stream);
+
+ let mut builder = Response::builder().status(status);
+ if let Some(h) = builder.headers_mut() {
+ h.extend(resp_headers);
+ if let Ok(v) = http::HeaderValue::from_str(&request_id) {
+ h.insert(HeaderName::from_static("x-request-id"), v);
+ }
+ }
+ builder.body(body_out).unwrap_or_else(|e| {
+ tracing::error!(
+ event = "bedrock_response_build_failed",
+ request_id = %request_id,
+ error = %e,
+ "bedrock invoke: failed to build response"
+ );
+ Response::builder()
+ .status(StatusCode::INTERNAL_SERVER_ERROR)
+ .body(Body::from("internal handler error"))
+ .expect("static response")
+ })
+}
+
+/// Run the live-zone Anthropic compressor over a Bedrock-shape body.
+///
+/// The compressor only inspects `messages` — it doesn't care that the
+/// Bedrock body has `anthropic_version` instead of `model`. The
+/// `Outcome::Compressed` body bytes still preserve key order via
+/// `serde_json`'s `preserve_order` feature, so the caller's
+/// re-emission step (`ensure_anthropic_version_first`) almost always
+/// no-ops. We still call it as a defence-in-depth assertion that
+/// the byte order is correct before signing.
+fn run_anthropic_compression(body: &Bytes, state: &AppState, request_id: &str) -> Bytes {
+ // Validate envelope shape. If the body isn't a valid Bedrock
+ // envelope we still forward verbatim — the compressor would have
+ // refused too — but log loudly.
+ if let Err(e) = BedrockEnvelope::parse(body) {
+ tracing::warn!(
+ event = "bedrock_envelope_parse_error",
+ request_id = %request_id,
+ error = %e,
+ "bedrock invoke: envelope parse failed; passing body through unchanged"
+ );
+ return body.clone();
+ }
+ tracing::info!(
+ event = "bedrock_envelope_parsed",
+ request_id = %request_id,
+ body_bytes = body.len(),
+ "bedrock invoke: envelope validated; dispatching to live-zone compressor"
+ );
+
+ let outcome = compress_anthropic_request(
+ body,
+ state.config.compression_mode,
+ state.config.cache_control_auto_frozen,
+ request_id,
+ );
+ match outcome {
+ AnthropicOutcome::NoCompression => body.clone(),
+ AnthropicOutcome::Passthrough { reason } => {
+ tracing::info!(
+ event = "bedrock_compression_passthrough",
+ request_id = %request_id,
+ reason = ?reason,
+ "bedrock invoke: live-zone dispatcher fell through to passthrough"
+ );
+ // The compressor's passthrough variants all leave bytes
+ // unchanged. Forward the original.
+ let _ = (PassthroughReason::ModeOff, PassthroughReason::NoMessages); // pin types
+ body.clone()
+ }
+ AnthropicOutcome::Compressed { body: new_body, .. } => {
+ // Defence-in-depth: re-emit so anthropic_version is the
+ // first key. With preserve_order this is a no-op on the
+ // happy path.
+ match BedrockEnvelope::ensure_anthropic_version_first(&new_body) {
+ Ok(b) => b,
+ Err(e) => {
+ tracing::error!(
+ event = "bedrock_envelope_reemit_failed",
+ request_id = %request_id,
+ error = %e,
+ "bedrock invoke: failed to re-emit envelope; falling back to original body"
+ );
+ body.clone()
+ }
+ }
+ }
+ }
+}
+
+/// Build the upstream URL for the Bedrock route. Honours the
+/// operator-supplied `bedrock_endpoint` first, falling back to the
+/// region-derived default. The path/query portion is taken from the
+/// original URI verbatim — Bedrock's path schema (`/model/{id}/{action}`)
+/// is identical to the proxy's external path.
+fn build_bedrock_upstream(
+ state: &AppState,
+ model_id: &str,
+ uri: &Uri,
+ action: &str,
+) -> Result<Url, String> {
+ let base = match state.config.bedrock_endpoint.as_ref() {
+ Some(u) => u.clone(),
+ None => {
+ let host =
+ BEDROCK_RUNTIME_HOST_TEMPLATE.replace("{region}", &state.config.bedrock_region);
+ Url::parse(&format!("https://{host}/"))
+ .map_err(|e| format!("bedrock derived base URL parse error: {e}"))?
+ }
+ };
+ // Compose the path. We trust the captured `model_id` (Axum
+ // already URL-decoded it) and append `/{action}`.
+ let path = format!(
+ "/model/{model_id}/{action}",
+ model_id = model_id,
+ action = action,
+ );
+ let mut joined = base;
+ joined.set_path(&path);
+ if let Some(q) = uri.query() {
+ joined.set_query(Some(q));
+ }
+ Ok(joined)
+}
+
+/// Build the list of headers to sign + forward. Drops hop-by-hop,
+/// `host`, `content-length` (reqwest manages those), `authorization`
+/// (we replace it with the SigV4 output). Lower-cases names for
+/// canonical-request consistency.
+fn collect_signed_headers(headers: &HeaderMap, upstream_url: &Url) -> Vec<(String, String)> {
+ let mut out: Vec<(String, String)> = Vec::with_capacity(headers.len() + 1);
+ for (name, value) in headers.iter() {
+ let n = name.as_str().to_ascii_lowercase();
+ if matches!(
+ n.as_str(),
+ "host"
+ | "content-length"
+ | "connection"
+ | "keep-alive"
+ | "proxy-authenticate"
+ | "proxy-authorization"
+ | "te"
+ | "trailers"
+ | "transfer-encoding"
+ | "upgrade"
+ | "authorization"
+ | "x-amz-date"
+ | "x-amz-content-sha256"
+ ) {
+ // Drop client-managed + signer-managed headers.
+ continue;
+ }
+ if n.starts_with("x-headroom-") {
+ // Internal headers are stripped from upstream traffic
+ // (PR-A5). The Bedrock route inherits the same default.
+ continue;
+ }
+ if let Ok(v) = value.to_str() {
+ out.push((n, v.to_string()));
+ }
+ }
+ // Signer requires `host` in the canonical request. Add it
+ // explicitly from the upstream URL — the inbound `host` header
+ // (the proxy's listening hostname) is wrong for the canonical
+ // request.
+ if let Some(host) = upstream_url.host_str() {
+ let host_value = match upstream_url.port() {
+ Some(p) => format!("{host}:{p}"),
+ None => host.to_string(),
+ };
+ out.push(("host".to_string(), host_value));
+ }
+ out
+}
+
+fn error_response(status: StatusCode, event: &str, msg: &str) -> Response {
+ let body = serde_json::json!({
+ "error": {
+ "type": event,
+ "message": msg,
+ }
+ })
+ .to_string();
+ let _ = event;
+ let mut resp = Response::builder()
+ .status(status)
+ .body(Body::from(body))
+ .expect("static error response");
+ resp.headers_mut().insert(
+ http::header::CONTENT_TYPE,
+ http::HeaderValue::from_static("application/json"),
+ );
+ resp.into_response()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn anthropic_vendor_prefix_match() {
+ assert!("anthropic.claude-3-haiku-20240307-v1:0".starts_with(ANTHROPIC_VENDOR_PREFIX));
+ assert!("anthropic.claude-3-5-sonnet-20241022-v2:0".starts_with(ANTHROPIC_VENDOR_PREFIX));
+ assert!(!"amazon.titan-text-express-v1".starts_with(ANTHROPIC_VENDOR_PREFIX));
+ assert!(!"meta.llama3-70b-instruct-v1:0".starts_with(ANTHROPIC_VENDOR_PREFIX));
+ }
+
+ #[test]
+ fn build_upstream_uses_region_default() {
+ use crate::config::Config;
+ let mut config = Config::for_test(Url::parse("http://up:8080").unwrap());
+ config.bedrock_region = "us-west-2".to_string();
+ let state = AppState {
+ config: std::sync::Arc::new(config),
+ client: reqwest::Client::new(),
+ bedrock_credentials: None,
+ };
+ let uri: Uri = "/model/anthropic.claude-3-haiku-20240307-v1:0/invoke"
+ .parse()
+ .unwrap();
+ let url = build_bedrock_upstream(
+ &state,
+ "anthropic.claude-3-haiku-20240307-v1:0",
+ &uri,
+ "invoke",
+ )
+ .unwrap();
+ assert_eq!(
+ url.as_str(),
+ "https://bedrock-runtime.us-west-2.amazonaws.com/model/anthropic.claude-3-haiku-20240307-v1:0/invoke"
+ );
+ }
+
+ #[test]
+ fn build_upstream_honors_explicit_endpoint() {
+ use crate::config::Config;
+ let mut config = Config::for_test(Url::parse("http://up:8080").unwrap());
+ config.bedrock_endpoint = Some(Url::parse("http://127.0.0.1:9999").unwrap());
+ let state = AppState {
+ config: std::sync::Arc::new(config),
+ client: reqwest::Client::new(),
+ bedrock_credentials: None,
+ };
+ let uri: Uri = "/model/anthropic.claude-3-haiku-20240307-v1:0/invoke"
+ .parse()
+ .unwrap();
+ let url = build_bedrock_upstream(
+ &state,
+ "anthropic.claude-3-haiku-20240307-v1:0",
+ &uri,
+ "invoke",
+ )
+ .unwrap();
+ assert_eq!(
+ url.as_str(),
+ "http://127.0.0.1:9999/model/anthropic.claude-3-haiku-20240307-v1:0/invoke"
+ );
+ }
+
+ #[test]
+ fn collect_signed_headers_strips_client_managed() {
+ let mut headers = HeaderMap::new();
+ headers.insert("content-type", "application/json".parse().unwrap());
+ headers.insert("host", "proxy.example".parse().unwrap());
+ headers.insert("authorization", "Bearer x".parse().unwrap());
+ headers.insert("x-headroom-mode", "live".parse().unwrap());
+ headers.insert("accept", "application/json".parse().unwrap());
+ let upstream =
+ Url::parse("https://bedrock-runtime.us-east-1.amazonaws.com/model/x/invoke").unwrap();
+ let out = collect_signed_headers(&headers, &upstream);
+ let names: Vec<&str> = out.iter().map(|(k, _)| k.as_str()).collect();
+ assert!(names.contains(&"content-type"));
+ assert!(names.contains(&"accept"));
+ assert!(names.contains(&"host"));
+ assert!(!names.contains(&"authorization"));
+ assert!(!names.contains(&"x-headroom-mode"));
+ // host must be the upstream host, not the proxy host.
+ let host = out
+ .iter()
+ .find(|(k, _)| k == "host")
+ .map(|(_, v)| v.as_str())
+ .unwrap();
+ assert_eq!(host, "bedrock-runtime.us-east-1.amazonaws.com");
+ }
+}
diff --git a/crates/headroom-proxy/src/bedrock/mod.rs b/crates/headroom-proxy/src/bedrock/mod.rs
new file mode 100644
index 000000000..cf0be6cac
--- /dev/null
+++ b/crates/headroom-proxy/src/bedrock/mod.rs
@@ -0,0 +1,52 @@
+//! Native AWS Bedrock InvokeModel route — Phase D PR-D1.
+//!
+//! # Why a separate module?
+//!
+//! The Python proxy currently routes Anthropic-on-Bedrock through the
+//! `litellm` shim (`headroom/backends/litellm.py`). That shim
+//! lossy-converts every request and response between Anthropic and
+//! OpenAI shapes, dropping `thinking`, `redacted_thinking`,
+//! `document`, `search_result`, `image`, `server_tool_use`, and
+//! `mcp_tool_use` blocks (P4-37). It also hardcodes
+//! `stop_sequence: null` (§11.1 violation) and re-wraps
+//! `function_call.arguments` as a parsed JSON object (§4.4 — P4-43).
+//!
+//! Phase D rebuilds the Bedrock surface natively in Rust. PR-D1
+//! handles the **non-streaming** `POST /model/{model}/invoke` route:
+//!
+//! 1. Parse the Bedrock envelope (`{"anthropic_version": "...",
+//! ...rest_of_anthropic_body}`).
+//! 2. Route Anthropic-shape bodies through the live-zone compression
+//! path (the same one `/v1/messages` uses).
+//! 3. Re-emit the envelope with `anthropic_version` preserved as the
+//! first key — Bedrock is strict about schema validation.
+//! 4. Sign the **outgoing** body bytes with AWS SigV4 (after
+//! compression) and forward to the configured Bedrock endpoint.
+//!
+//! # Cache safety
+//!
+//! The signed bytes are exactly the bytes Bedrock receives. If the
+//! compressor mutated the body, the SigV4 signature is computed
+//! against the post-compression bytes; the upstream verifier will
+//! accept them. There is no "sign before compress" path — that would
+//! produce a signature that doesn't match the wire payload.
+//!
+//! # Module layout
+//!
+//! - [`envelope`] — `BedrockEnvelope` parse + emit (preserves
+//! `anthropic_version` ordering byte-equal).
+//! - [`sigv4`] — AWS SigV4 signing helper. Wraps the `aws-sigv4`
+//! crate with the project's no-fallback / structured-logging
+//! policy.
+//! - [`invoke`] — POST handler for `/model/{model}/invoke`.
+//!
+//! Streaming (`/model/{model}/invoke-with-response-stream`) is
+//! Phase D PR-D2.
+
+pub mod envelope;
+pub mod invoke;
+pub mod sigv4;
+
+pub use envelope::{BedrockEnvelope, EnvelopeError};
+pub use invoke::handle_invoke;
+pub use sigv4::{sign_request, SigV4Error, SigningInputs};
diff --git a/crates/headroom-proxy/src/bedrock/sigv4.rs b/crates/headroom-proxy/src/bedrock/sigv4.rs
new file mode 100644
index 000000000..6fc23c5cf
--- /dev/null
+++ b/crates/headroom-proxy/src/bedrock/sigv4.rs
@@ -0,0 +1,324 @@
+//! AWS SigV4 request signing for the Bedrock InvokeModel route.
+//!
+//! # What this module does
+//!
+//! Wraps the `aws-sigv4` crate with the project's policies:
+//!
+//! - **No silent fallbacks.** A failed sign-attempt returns a
+//! structured error; the handler surfaces 5xx and logs an event.
+//! We NEVER forward an unsigned request to Bedrock, because the
+//! AWS endpoint will reject anyway and the user would see an
+//! opaque 403.
+//! - **Body bytes are hashed AFTER compression.** The signing
+//! inputs include a `&[u8]` that is the EXACT byte slice the
+//! forwarder will send upstream. There is no separate "hash the
+//! pre-compression body" code path.
+//! - **Structured logs at every decision point.** Every code path
+//! emits `tracing::info!`/`warn!` with an `event = ...` field so
+//! operators can confirm signing happened.
+//!
+//! # What this module deliberately does NOT do
+//!
+//! - It does not resolve credentials — that's `aws-config`'s job and
+//! happens at app-startup time so per-request signing is cheap.
+//! The handler holds the resolved [`aws_credential_types::Credentials`]
+//! in `AppState` and passes them in.
+//! - It does not buffer the body — callers buffer the body in the
+//! compression gate (it's the same byte slice).
+//! - It does not handle SigV4a (the cross-region variant). Bedrock
+//! uses standard SigV4 per region.
+
+use std::time::SystemTime;
+
+use aws_credential_types::Credentials;
+use aws_sigv4::http_request::{
+ sign, PayloadChecksumKind, SignableBody, SignableRequest, SigningSettings,
+};
+use aws_sigv4::sign::v4;
+use aws_smithy_runtime_api::client::identity::Identity;
+use thiserror::Error;
+use url::Url;
+
+/// AWS service name used in the SigV4 string-to-sign for Bedrock.
+/// Documented at
+/// <https://docs.aws.amazon.com/bedrock/latest/userguide/security-iam.html>
+pub const BEDROCK_SERVICE_NAME: &str = "bedrock";
+
+/// Inputs needed to sign a Bedrock request. Borrows the body so we
+/// avoid a copy on the hot path.
+#[derive(Debug)]
+pub struct SigningInputs<'a> {
+ /// HTTP method (always `"POST"` for InvokeModel today, but we
+ /// keep this explicit so a future GET-shaped surface doesn't
+ /// require redoing the call site).
+ pub method: &'a str,
+ /// Fully-qualified upstream URL (scheme + host + path + query).
+ /// Used for canonical-request URI normalization.
+ pub url: &'a Url,
+ /// AWS region the upstream endpoint lives in.
+ pub region: &'a str,
+ /// AWS credentials (resolved from the `aws-config` default chain
+ /// at app-startup time).
+ pub credentials: &'a Credentials,
+ /// Body bytes to sign. MUST be the exact bytes the forwarder
+ /// will send to Bedrock (post-compression).
+ pub body: &'a [u8],
+ /// Extra headers the canonical request must include in the
+ /// signed-headers list. The signer always includes `host`,
+ /// `x-amz-date`, and `x-amz-content-sha256`; callers add
+ /// anything else they want covered (e.g. `accept-encoding`,
+ /// `content-type`).
+ pub extra_signed_headers: &'a [(&'a str, &'a str)],
+ /// Time to use in the signature. Production uses
+ /// `SystemTime::now()`; tests pin a known time to make the
+ /// canonical request deterministic.
+ pub time: SystemTime,
+}
+
+/// Headers that the signer will write into the outbound request.
+/// The handler must add every entry to the upstream-bound HeaderMap
+/// before sending — Bedrock validates each header against the
+/// canonical request.
+#[derive(Debug, Clone)]
+pub struct SignedHeaders {
+ pub entries: Vec<(String, String)>,
+ /// Lowercase hex SHA-256 of the body. Surfaced for tests + logs.
+ pub signature: String,
+}
+
+/// Errors surfaced by the signing path.
+#[derive(Debug, Error)]
+pub enum SigV4Error {
+ /// `aws-sigv4` rejected the request (URL parse, malformed header,
+ /// etc).
+ #[error("sigv4 signing failed: {0}")]
+ Sign(String),
+ /// The signing-params builder rejected the inputs (e.g. missing
+ /// region — should never happen because we validate at startup).
+ #[error("sigv4 builder error: {0}")]
+ Builder(String),
+}
+
+/// Sign a Bedrock request and return the headers the handler must add
+/// to the outbound request.
+///
+/// # Cache safety
+///
+/// The body bytes passed in MUST be the bytes the proxy is about to
+/// send upstream. If the compressor mutated the body, those mutated
+/// bytes are what get signed — Bedrock will accept because the
+/// signature covers the wire payload, not the original.
+///
+/// # Errors
+///
+/// Returns [`SigV4Error::Sign`] when `aws-sigv4` rejects the request
+/// (malformed URL, etc). Returns [`SigV4Error::Builder`] when the
+/// signing-params builder rejects the inputs.
+pub fn sign_request(inputs: &SigningInputs<'_>) -> Result<SignedHeaders, SigV4Error> {
+ // Build the identity wrapper around the credentials. Identity is
+ // the type the SigV4 signer accepts; it can in principle hold
+ // alternative auth schemes (Bearer, etc) but we only ever use it
+ // for AWS creds.
+ let identity: Identity = Identity::new(inputs.credentials.clone(), None);
+
+ // Default settings + force `x-amz-content-sha256` into the
+ // canonical request. Bedrock validates the content hash to
+ // catch any in-flight body mutation; with `NoHeader` (the
+ // crate-level default) the signer would skip the header,
+ // which means a downstream gateway that DOES check it would
+ // 403.
+ let mut settings = SigningSettings::default();
+ settings.payload_checksum_kind = PayloadChecksumKind::XAmzSha256;
+
+ let signing_params = v4::SigningParams::builder()
+ .identity(&identity)
+ .region(inputs.region)
+ .name(BEDROCK_SERVICE_NAME)
+ .time(inputs.time)
+ .settings(settings)
+ .build()
+ .map_err(|e| SigV4Error::Builder(e.to_string()))?
+ .into();
+
+ // The signer needs the URL as a string; Url's Display impl is
+ // canonical RFC 3986 form which is what aws-sigv4 expects.
+ let url_string = inputs.url.to_string();
+
+ let signable = SignableRequest::new(
+ inputs.method,
+ url_string,
+ inputs.extra_signed_headers.iter().copied(),
+ SignableBody::Bytes(inputs.body),
+ )
+ .map_err(|e| SigV4Error::Sign(e.to_string()))?;
+
+ let signing_output =
+ sign(signable, &signing_params).map_err(|e| SigV4Error::Sign(e.to_string()))?;
+
+ let signature = signing_output.signature().to_string();
+ let (instructions, _signature) = signing_output.into_parts();
+ let (header_entries, _query_params) = instructions.into_parts();
+ let entries = header_entries
+ .into_iter()
+ .map(|h| (h.name().to_string(), h.value().to_string()))
+ .collect::<Vec<_>>();
+
+ tracing::info!(
+ event = "sigv4_signed",
+ forwarder = "rust_proxy",
+ region = inputs.region,
+ service = BEDROCK_SERVICE_NAME,
+ method = inputs.method,
+ host = inputs.url.host_str().unwrap_or(""),
+ body_bytes = inputs.body.len(),
+ headers_added = entries.len(),
+ "bedrock request signed with sigv4"
+ );
+
+ Ok(SignedHeaders { entries, signature })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::time::Duration;
+
+ fn fixed_time() -> SystemTime {
+ // 2026-05-03T12:00:00Z — pinned so canonical request is
+ // deterministic across runs.
+ SystemTime::UNIX_EPOCH + Duration::from_secs(1_777_910_400)
+ }
+
+ fn fixture_credentials() -> Credentials {
+ Credentials::new("AKIA_TEST", "secret_test", None, None, "test")
+ }
+
+ #[test]
+ fn signs_minimal_request_produces_expected_headers() {
+ let url = Url::parse(
+ "https://bedrock-runtime.us-east-1.amazonaws.com/model/anthropic.claude-3-haiku-20240307-v1:0/invoke",
+ )
+ .unwrap();
+ let creds = fixture_credentials();
+ let body = br#"{"anthropic_version":"bedrock-2023-05-31","max_tokens":16,"messages":[]}"#;
+ let inputs = SigningInputs {
+ method: "POST",
+ url: &url,
+ region: "us-east-1",
+ credentials: &creds,
+ body,
+ extra_signed_headers: &[("content-type", "application/json")],
+ time: fixed_time(),
+ };
+ let signed = sign_request(&inputs).expect("sigv4 sign");
+ // The signer always emits `authorization`, `x-amz-date`, and
+ // `x-amz-content-sha256`. Confirm all three are present.
+ let names: Vec<String> = signed
+ .entries
+ .iter()
+ .map(|(k, _)| k.to_ascii_lowercase())
+ .collect();
+ assert!(
+ names.iter().any(|n| n == "authorization"),
+ "must add authorization; got {names:?}"
+ );
+ assert!(
+ names.iter().any(|n| n == "x-amz-date"),
+ "must add x-amz-date"
+ );
+ assert!(
+ names.iter().any(|n| n == "x-amz-content-sha256"),
+ "must add x-amz-content-sha256"
+ );
+ assert_eq!(signed.signature.len(), 64, "sigv4 signature is 32-byte hex");
+ }
+
+ #[test]
+ fn signature_is_deterministic_for_fixed_inputs() {
+ let url = Url::parse(
+ "https://bedrock-runtime.us-east-1.amazonaws.com/model/anthropic.claude-3-haiku-20240307-v1:0/invoke",
+ )
+ .unwrap();
+ let creds = fixture_credentials();
+ let body = br#"{"anthropic_version":"bedrock-2023-05-31","max_tokens":16}"#;
+ let mk = || SigningInputs {
+ method: "POST",
+ url: &url,
+ region: "us-east-1",
+ credentials: &creds,
+ body,
+ extra_signed_headers: &[("content-type", "application/json")],
+ time: fixed_time(),
+ };
+ let a = sign_request(&mk()).unwrap();
+ let b = sign_request(&mk()).unwrap();
+ assert_eq!(a.signature, b.signature);
+ }
+
+ #[test]
+ fn changing_body_changes_signature() {
+ let url = Url::parse(
+ "https://bedrock-runtime.us-east-1.amazonaws.com/model/anthropic.claude-3-haiku-20240307-v1:0/invoke",
+ )
+ .unwrap();
+ let creds = fixture_credentials();
+ let inputs_a = SigningInputs {
+ method: "POST",
+ url: &url,
+ region: "us-east-1",
+ credentials: &creds,
+ body: br#"{"anthropic_version":"bedrock-2023-05-31","max_tokens":16}"#,
+ extra_signed_headers: &[("content-type", "application/json")],
+ time: fixed_time(),
+ };
+ let inputs_b = SigningInputs {
+ body: br#"{"anthropic_version":"bedrock-2023-05-31","max_tokens":32}"#,
+ ..SigningInputs {
+ method: "POST",
+ url: &url,
+ region: "us-east-1",
+ credentials: &creds,
+ body: &[],
+ extra_signed_headers: &[("content-type", "application/json")],
+ time: fixed_time(),
+ }
+ };
+ let a = sign_request(&inputs_a).unwrap();
+ let b = sign_request(&inputs_b).unwrap();
+ assert_ne!(
+ a.signature, b.signature,
+ "different body bytes must yield different signatures"
+ );
+ }
+
+ #[test]
+ fn changing_region_changes_signature() {
+ let url = Url::parse(
+ "https://bedrock-runtime.us-east-1.amazonaws.com/model/anthropic.claude-3-haiku-20240307-v1:0/invoke",
+ )
+ .unwrap();
+ let creds = fixture_credentials();
+ let body = br#"{"anthropic_version":"bedrock-2023-05-31"}"#;
+ let east = SigningInputs {
+ method: "POST",
+ url: &url,
+ region: "us-east-1",
+ credentials: &creds,
+ body,
+ extra_signed_headers: &[],
+ time: fixed_time(),
+ };
+ let west = SigningInputs {
+ method: "POST",
+ url: &url,
+ region: "us-west-2",
+ credentials: &creds,
+ body,
+ extra_signed_headers: &[],
+ time: fixed_time(),
+ };
+ let a = sign_request(&east).unwrap();
+ let b = sign_request(&west).unwrap();
+ assert_ne!(a.signature, b.signature);
+ }
+}
diff --git a/crates/headroom-proxy/src/config.rs b/crates/headroom-proxy/src/config.rs
index 85076ca98..fee143c91 100644
--- a/crates/headroom-proxy/src/config.rs
+++ b/crates/headroom-proxy/src/config.rs
@@ -296,6 +296,61 @@ pub struct CliArgs {
action = clap::ArgAction::Set,
)]
pub enable_conversations_passthrough: bool,
+
+ /// Phase D PR-D1: enable the native Bedrock InvokeModel route.
+ /// When `true` (default), `POST /model/{model_id}/invoke` is
+ /// handled by the Rust `bedrock::invoke` handler — Anthropic-shape
+ /// bodies run through the live-zone compression path and the
+ /// proxy re-signs the request with SigV4 before forwarding to
+ /// the configured Bedrock endpoint. When `false`, the routes are
+ /// not mounted and requests fall through to the catch-all
+ /// (which forwards to `--upstream` byte-equal but does NOT
+ /// re-sign — operators MUST run an unsigned upstream that
+ /// happens to know what to do, otherwise this fails closed).
+ ///
+ /// Source priority: CLI flag → `HEADROOM_PROXY_ENABLE_BEDROCK_NATIVE`
+ /// env var → default (`true`).
+ #[arg(
+ long = "enable-bedrock-native",
+ env = "HEADROOM_PROXY_ENABLE_BEDROCK_NATIVE",
+ default_value_t = true,
+ action = clap::ArgAction::Set,
+ )]
+ pub enable_bedrock_native: bool,
+
+ /// AWS region to use when signing Bedrock requests. Default
+ /// `us-east-1`. The Bedrock endpoint URL derived from this
+ /// region is `https://bedrock-runtime.{region}.amazonaws.com`
+ /// (override via `--bedrock-endpoint` for FIPS or VPC endpoints).
+ ///
+ /// Source priority: CLI flag → `HEADROOM_PROXY_BEDROCK_REGION`
+ /// env var → `AWS_REGION` env var → default (`us-east-1`).
+ #[arg(
+ long = "bedrock-region",
+ env = "HEADROOM_PROXY_BEDROCK_REGION",
+ default_value = "us-east-1"
+ )]
+ pub bedrock_region: String,
+
+ /// Bedrock endpoint base URL. When unset (the common case), the
+ /// proxy derives `https://bedrock-runtime.{bedrock_region}.amazonaws.com`
+ /// from the configured region. Override for FIPS endpoints
+ /// (`bedrock-runtime-fips.{region}.amazonaws.com`), VPC endpoints,
+ /// or local-mock test setups.
+ ///
+ /// Source priority: CLI flag → `HEADROOM_PROXY_BEDROCK_ENDPOINT`
+ /// env var → derived-from-region.
+ #[arg(long = "bedrock-endpoint", env = "HEADROOM_PROXY_BEDROCK_ENDPOINT")]
+ pub bedrock_endpoint: Option<Url>,
+
+ /// AWS profile name passed to the `aws-config` default credential
+ /// chain. When unset, the chain uses the default behaviour
+ /// (env vars → `[default]` profile → IMDS / ECS task role).
+ ///
+ /// Source priority: CLI flag → `HEADROOM_PROXY_AWS_PROFILE`
+ /// env var → `AWS_PROFILE` env var → default chain.
+ #[arg(long = "aws-profile", env = "HEADROOM_PROXY_AWS_PROFILE")]
+ pub aws_profile: Option<String>,
}
fn parse_duration(s: &str) -> Result<Duration, String> {
@@ -350,6 +405,20 @@ pub struct Config {
/// NOT gate compression of conversation items (that's
/// C5+/B-phase territory).
pub enable_conversations_passthrough: bool,
+ /// PR-D1: enable the native Bedrock InvokeModel route. Default
+ /// `true`. When disabled, the explicit Rust handlers are not
+ /// mounted; operators relying on the Python LiteLLM converter
+ /// keep their existing path.
+ pub enable_bedrock_native: bool,
+ /// PR-D1: AWS region used to sign Bedrock requests + (when no
+ /// explicit endpoint is set) derive the Bedrock endpoint URL.
+ pub bedrock_region: String,
+ /// PR-D1: Bedrock endpoint base URL. `None` means
+ /// "derive from region" (`https://bedrock-runtime.{region}.amazonaws.com`).
+ pub bedrock_endpoint: Option<Url>,
+ /// PR-D1: optional AWS profile name. When `None`, the default
+ /// credential chain (env → `[default]` profile → IMDS) is used.
+ pub aws_profile: Option<String>,
}
impl Config {
@@ -378,6 +447,10 @@ impl Config {
strip_internal_headers: args.strip_internal_headers,
enable_responses_streaming: args.enable_responses_streaming,
enable_conversations_passthrough: args.enable_conversations_passthrough,
+ enable_bedrock_native: args.enable_bedrock_native,
+ bedrock_region: args.bedrock_region,
+ bedrock_endpoint: args.bedrock_endpoint,
+ aws_profile: args.aws_profile,
}
}
@@ -408,6 +481,14 @@ impl Config {
// production traffic will hit.
enable_responses_streaming: true,
enable_conversations_passthrough: true,
+ // PR-D1: bedrock route default-on so tests exercise
+ // it without per-test opt-in. Tests that set
+ // `bedrock_endpoint` to a wiremock URL get the full
+ // sign-and-forward path.
+ enable_bedrock_native: true,
+ bedrock_region: "us-east-1".to_string(),
+ bedrock_endpoint: None,
+ aws_profile: None,
}
}
}
diff --git a/crates/headroom-proxy/src/lib.rs b/crates/headroom-proxy/src/lib.rs
index d5f094ece..f6f152891 100644
--- a/crates/headroom-proxy/src/lib.rs
+++ b/crates/headroom-proxy/src/lib.rs
@@ -1,6 +1,7 @@
//! headroom-proxy library: transparent reverse proxy in front of the Python
//! Headroom proxy. Used by both `main.rs` and the integration tests.
+pub mod bedrock;
pub mod compression;
pub mod config;
pub mod error;
diff --git a/crates/headroom-proxy/src/main.rs b/crates/headroom-proxy/src/main.rs
index b9d8b57b1..19e748522 100644
--- a/crates/headroom-proxy/src/main.rs
+++ b/crates/headroom-proxy/src/main.rs
@@ -31,7 +31,37 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
"headroom-proxy starting"
);
- let state = AppState::new(config.clone())?;
+ let mut state = AppState::new(config.clone())?;
+
+ // PR-D1: resolve AWS credentials at startup via the `aws-config`
+ // default chain. Loaded once so per-request signing is cheap.
+ // Failure is NOT fatal — the proxy may run in front of a non-AWS
+ // upstream — but the Bedrock invoke handler refuses to forward
+ // unsigned requests when `bedrock_credentials` is `None`
+ // (see `bedrock::invoke::handle_invoke`).
+ if config.enable_bedrock_native {
+ match load_bedrock_credentials(&config).await {
+ Ok(creds) => {
+ state = state.with_bedrock_credentials(creds);
+ tracing::info!(
+ event = "bedrock_credentials_loaded",
+ region = %config.bedrock_region,
+ profile = ?config.aws_profile,
+ "AWS credentials resolved for Bedrock SigV4 signing"
+ );
+ }
+ Err(e) => {
+ tracing::warn!(
+ event = "bedrock_credentials_unavailable",
+ region = %config.bedrock_region,
+ profile = ?config.aws_profile,
+ error = %e,
+ "AWS credentials not available at startup; Bedrock invoke will 5xx until creds are configured"
+ );
+ }
+ }
+ }
+
let app = build_app(state).into_make_service_with_connect_info::<SocketAddr>();
let listener = tokio::net::TcpListener::bind(config.listen).await?;
@@ -64,6 +94,31 @@ fn init_tracing(level: &str) {
.try_init();
}
+/// PR-D1: resolve AWS credentials for Bedrock SigV4 signing.
+///
+/// Uses the `aws-config` default chain (env vars → shared profile
+/// file → IMDS / ECS task role). Honours `Config::aws_profile` when
+/// set; otherwise the chain picks up `AWS_PROFILE` from the
+/// environment automatically.
+async fn load_bedrock_credentials(
+ config: &Config,
+) -> Result<aws_credential_types::Credentials, Box<dyn std::error::Error + Send + Sync>> {
+ use aws_config::BehaviorVersion;
+ use aws_credential_types::provider::ProvideCredentials;
+
+ let mut loader = aws_config::defaults(BehaviorVersion::latest())
+ .region(aws_config::Region::new(config.bedrock_region.clone()));
+ if let Some(profile) = config.aws_profile.as_deref() {
+ loader = loader.profile_name(profile);
+ }
+ let aws_config = loader.load().await;
+ let creds_provider = aws_config
+ .credentials_provider()
+ .ok_or("no credentials provider configured")?;
+ let creds = creds_provider.provide_credentials().await?;
+ Ok(creds)
+}
+
async fn shutdown_signal() {
let ctrl_c = async {
let _ = tokio::signal::ctrl_c().await;
diff --git a/crates/headroom-proxy/src/proxy.rs b/crates/headroom-proxy/src/proxy.rs
index 056e9a9af..c60ac631c 100644
--- a/crates/headroom-proxy/src/proxy.rs
+++ b/crates/headroom-proxy/src/proxy.rs
@@ -34,6 +34,14 @@ use crate::websocket::ws_handler;
pub struct AppState {
pub config: Arc<Config>,
pub client: reqwest::Client,
+ /// PR-D1: AWS credentials resolved at startup via the
+ /// `aws-config` default chain. `None` when the proxy boots
+ /// without AWS creds available (operator running locally
+ /// against a non-Bedrock upstream); the Bedrock invoke handler
+ /// returns 5xx with a structured `event=bedrock_credentials_missing`
+ /// log so failures are LOUD — no silent fallback to unsigned
+ /// requests.
+ pub bedrock_credentials: Option<Arc<aws_credential_types::Credentials>>,
}
impl AppState {
@@ -52,8 +60,19 @@ impl AppState {
Ok(Self {
config: Arc::new(config),
client,
+ bedrock_credentials: None,
})
}
+
+ /// PR-D1: attach AWS credentials resolved out-of-band (via
+ /// `aws-config`'s default chain at startup). Returns the
+ /// modified state; intended to be chained off `AppState::new`.
+ /// Tests that don't exercise the Bedrock route can leave
+ /// credentials unset (the catch-all paths never read them).
+ pub fn with_bedrock_credentials(mut self, creds: aws_credential_types::Credentials) -> Self {
+ self.bedrock_credentials = Some(Arc::new(creds));
+ self
+ }
}
/// Build the axum app. `/healthz` and `/healthz/upstream` are intercepted;
@@ -84,6 +103,32 @@ pub fn build_app(state: AppState) -> Router {
post(crate::handlers::responses::handle_responses),
);
+ // PR-D1: native AWS Bedrock InvokeModel route. Mounts only when
+ // `enable_bedrock_native` is on (default). The handler runs the
+ // live-zone compressor over Anthropic-shape bodies, signs with
+ // SigV4, and forwards to the configured Bedrock endpoint. The
+ // `/converse` route mounts the same handler — the wire shape is
+ // identical for `anthropic.claude-*` model IDs (Bedrock just
+ // accepts both legacy `invoke` and modern `converse` paths).
+ if state.config.enable_bedrock_native {
+ router = router
+ .route(
+ "/model/:model_id/invoke",
+ post(crate::bedrock::invoke::handle_invoke),
+ )
+ .route(
+ "/model/:model_id/converse",
+ post(crate::bedrock::invoke::handle_invoke),
+ );
+ } else {
+ tracing::warn!(
+ event = "bedrock_native_disabled",
+ "Bedrock native InvokeModel route disabled by \
+ --enable-bedrock-native=false; Bedrock requests will fall \
+ through to the catch-all (no SigV4 re-signing — fails closed)"
+ );
+ }
+
// PR-C4: Conversations API (passthrough-with-instrumentation).
// The flag is read once at app-build time so router shape
// matches the configured policy. When disabled, requests still
diff --git a/crates/headroom-proxy/tests/common/mod.rs b/crates/headroom-proxy/tests/common/mod.rs
index 96b41c4b2..4f8976e8e 100644
--- a/crates/headroom-proxy/tests/common/mod.rs
+++ b/crates/headroom-proxy/tests/common/mod.rs
@@ -44,11 +44,28 @@ pub async fn start_proxy(upstream: &str) -> ProxyHandle {
pub async fn start_proxy_with<F>(upstream: &str, customize: F) -> ProxyHandle
where
F: FnOnce(&mut Config),
+{
+ start_proxy_with_state(upstream, customize, |s| s).await
+}
+
+/// Start a proxy with both a Config customizer and an AppState
+/// post-processor. PR-D1: tests that exercise the Bedrock route
+/// inject credentials via `with_bedrock_credentials` here.
+#[allow(dead_code)]
+pub async fn start_proxy_with_state<F, G>(
+ upstream: &str,
+ customize: F,
+ customize_state: G,
+) -> ProxyHandle
+where
+ F: FnOnce(&mut Config),
+ G: FnOnce(AppState) -> AppState,
{
let upstream_url: Url = upstream.parse().expect("valid upstream url");
let mut config = Config::for_test(upstream_url);
customize(&mut config);
let state = AppState::new(config.clone()).expect("app state");
+ let state = customize_state(state);
let app = build_app(state).into_make_service_with_connect_info::<SocketAddr>();
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
diff --git a/crates/headroom-proxy/tests/integration_bedrock_invoke.rs b/crates/headroom-proxy/tests/integration_bedrock_invoke.rs
new file mode 100644
index 000000000..449c0c832
--- /dev/null
+++ b/crates/headroom-proxy/tests/integration_bedrock_invoke.rs
@@ -0,0 +1,563 @@
+//! Integration tests for the native Bedrock InvokeModel route
+//! (Phase D PR-D1).
+//!
+//! These tests boot the real Rust proxy in front of a wiremock
+//! upstream that pretends to be the Bedrock runtime endpoint
+//! (`https://bedrock-runtime.{region}.amazonaws.com`). The proxy is
+//! configured with `bedrock_endpoint = wiremock_url` so SigV4-signed
+//! requests are routed to the mock instead of real AWS — no live
+//! AWS dependency.
+//!
+//! Coverage matrix (per PR-D1 spec, REALIGNMENT/06-phase-D-bedrock-vertex.md):
+//!
+//! 1. `native_envelope_round_trip_byte_equal` — small body,
+//! compression-mode off; bytes round-trip byte-equal upstream.
+//! 2. `sigv4_signed_correctly_after_compression` — confirms the
+//! `authorization` header arrives at upstream and the
+//! `x-amz-content-sha256` matches the (post-compression) body.
+//! 3. `thinking_block_preserved_through_bedrock` — Anthropic
+//! `thinking` block round-trips byte-equal with compression off.
+//! Validates the live-zone dispatcher doesn't strip the block.
+//! 4. `redacted_thinking_preserved` — `redacted_thinking` block
+//! round-trips byte-equal.
+//! 5. `document_block_preserved` — `document` block round-trips.
+//! 6. `tool_result_array_with_image_preserved` — `tool_result` content
+//! array containing a base64 `image` block round-trips byte-equal
+//! when compression is off.
+//! 7. `stop_sequence_null_only_when_present` — mock the upstream to
+//! return a Bedrock-shape response that does NOT include
+//! `stop_sequence`; the proxy must not inject a `null` value for
+//! it. (This is an end-to-end check that Phase D doesn't regress
+//! P4-37's hardcoded null.)
+//! 8. `tool_use_input_byte_equal_preserves_key_order` — `tool_use.input`
+//! object keys must arrive in the same order they were sent
+//! (the `serde_json::preserve_order` feature backs this).
+
+mod common;
+
+use aws_credential_types::Credentials;
+use common::start_proxy_with_state;
+use serde_json::{json, Value};
+use sha2::{Digest, Sha256};
+use std::sync::{Arc, Mutex};
+use url::Url;
+use wiremock::matchers::{method, path};
+use wiremock::{Mock, MockServer, ResponseTemplate};
+
+/// What we capture from each upstream request — body + the
+/// authorization-shaped headers we care about.
+#[derive(Default, Clone, Debug)]
+struct CapturedRequest {
+ body: Option<Vec<u8>>,
+ authorization: Option<String>,
+ x_amz_date: Option<String>,
+ x_amz_content_sha256: Option<String>,
+ host: Option<String>,
+ content_type: Option<String>,
+}
+
+type Capture = Arc<Mutex<CapturedRequest>>;
+
+const TEST_MODEL: &str = "anthropic.claude-3-haiku-20240307-v1:0";
+
+async fn mount_capture_invoke(upstream: &MockServer, response_body: &str) -> Capture {
+ let captured: Capture = Arc::new(Mutex::new(CapturedRequest::default()));
+ let captured_clone = captured.clone();
+ let response_body = response_body.to_string();
+ let model = TEST_MODEL.to_string();
+ Mock::given(method("POST"))
+ .and(path(format!("/model/{model}/invoke")))
+ .respond_with(move |req: &wiremock::Request| {
+ let mut c = captured_clone.lock().unwrap();
+ c.body = Some(req.body.clone());
+ c.authorization = req
+ .headers
+ .get("authorization")
+ .and_then(|v| v.to_str().ok())
+ .map(str::to_string);
+ c.x_amz_date = req
+ .headers
+ .get("x-amz-date")
+ .and_then(|v| v.to_str().ok())
+ .map(str::to_string);
+ c.x_amz_content_sha256 = req
+ .headers
+ .get("x-amz-content-sha256")
+ .and_then(|v| v.to_str().ok())
+ .map(str::to_string);
+ c.host = req
+ .headers
+ .get("host")
+ .and_then(|v| v.to_str().ok())
+ .map(str::to_string);
+ c.content_type = req
+ .headers
+ .get("content-type")
+ .and_then(|v| v.to_str().ok())
+ .map(str::to_string);
+ ResponseTemplate::new(200).set_body_string(response_body.clone())
+ })
+ .mount(upstream)
+ .await;
+ captured
+}
+
+fn sha256_hex(bytes: &[u8]) -> String {
+ let mut hasher = Sha256::new();
+ hasher.update(bytes);
+ hasher
+ .finalize()
+ .iter()
+ .fold(String::with_capacity(64), |mut acc, b| {
+ use std::fmt::Write as _;
+ let _ = write!(acc, "{b:02x}");
+ acc
+ })
+}
+
+#[track_caller]
+fn assert_byte_equal_sha256(inbound: &[u8], received: &[u8]) {
+ let inbound_hash = sha256_hex(inbound);
+ let received_hash = sha256_hex(received);
+ assert_eq!(
+ inbound.len(),
+ received.len(),
+ "byte length mismatch: inbound={}, upstream-received={}",
+ inbound.len(),
+ received.len(),
+ );
+ assert_eq!(
+ inbound_hash, received_hash,
+ "SHA-256 mismatch: inbound={inbound_hash}, upstream-received={received_hash}",
+ );
+}
+
+fn test_credentials() -> Credentials {
+ Credentials::new(
+ "AKIAEXAMPLEAKIDFORTEST",
+ "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+ None,
+ None,
+ "test",
+ )
+}
+
+/// Boot a proxy pointed at the wiremock upstream as the Bedrock
+/// endpoint. The fake-upstream URL goes into `bedrock_endpoint`;
+/// the regular `upstream` field is set to a sentinel because the
+/// Bedrock route bypasses `forward_http`.
+async fn bedrock_proxy(
+ upstream: &MockServer,
+ customize: impl FnOnce(&mut headroom_proxy::Config),
+) -> common::ProxyHandle {
+ let endpoint: Url = upstream.uri().parse().unwrap();
+ start_proxy_with_state(
+ &upstream.uri(),
+ |c| {
+ c.bedrock_endpoint = Some(endpoint);
+ customize(c);
+ },
+ |s| s.with_bedrock_credentials(test_credentials()),
+ )
+ .await
+}
+
+#[tokio::test]
+async fn native_envelope_round_trip_byte_equal() {
+ // Compression off → body must arrive byte-equal at upstream.
+ let upstream = MockServer::start().await;
+ let captured = mount_capture_invoke(&upstream, r#"{"id":"msg_x","content":[]}"#).await;
+ let proxy = bedrock_proxy(&upstream, |c| {
+ c.compression = true;
+ c.compression_mode = headroom_proxy::config::CompressionMode::Off;
+ })
+ .await;
+
+ let payload = json!({
+ "anthropic_version": "bedrock-2023-05-31",
+ "max_tokens": 64,
+ "messages": [
+ {"role": "user", "content": "hi"}
+ ]
+ });
+ let body = serde_json::to_vec(&payload).unwrap();
+ let resp = reqwest::Client::new()
+ .post(format!("{}/model/{TEST_MODEL}/invoke", proxy.url()))
+ .header("content-type", "application/json")
+ .body(body.clone())
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), 200);
+
+ let got = captured.lock().unwrap().clone();
+ assert_byte_equal_sha256(&body, got.body.as_deref().unwrap());
+ proxy.shutdown().await;
+}
+
+#[tokio::test]
+async fn sigv4_signed_correctly_after_compression() {
+ // The signature must cover the bytes that actually hit upstream.
+ // We confirm: (a) `authorization` is present, (b)
+ // `x-amz-content-sha256` matches sha256(body received by upstream).
+ let upstream = MockServer::start().await;
+ let captured = mount_capture_invoke(&upstream, r#"{"id":"msg_x","content":[]}"#).await;
+ let proxy = bedrock_proxy(&upstream, |c| {
+ c.compression = true;
+ c.compression_mode = headroom_proxy::config::CompressionMode::LiveZone;
+ })
+ .await;
+
+ let payload = json!({
+ "anthropic_version": "bedrock-2023-05-31",
+ "max_tokens": 64,
+ "messages": [{"role": "user", "content": "hi"}]
+ });
+ let body = serde_json::to_vec(&payload).unwrap();
+ let resp = reqwest::Client::new()
+ .post(format!("{}/model/{TEST_MODEL}/invoke", proxy.url()))
+ .header("content-type", "application/json")
+ .body(body)
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), 200);
+
+ let got = captured.lock().unwrap().clone();
+ let auth = got.authorization.expect("authorization header present");
+ assert!(
+ auth.starts_with("AWS4-HMAC-SHA256 "),
+ "authorization must be SigV4-shape; got {auth}"
+ );
+ assert!(
+ auth.contains("Credential=AKIAEXAMPLEAKIDFORTEST/"),
+ "authorization must reference the test access key id; got {auth}"
+ );
+ assert!(
+ auth.contains("/bedrock/aws4_request"),
+ "authorization scope must reference the bedrock service; got {auth}"
+ );
+ assert!(got.x_amz_date.is_some(), "x-amz-date must be present");
+ let body_received = got.body.expect("upstream got body");
+ let expected_sha = sha256_hex(&body_received);
+ assert_eq!(
+ got.x_amz_content_sha256.as_deref(),
+ Some(expected_sha.as_str()),
+ "x-amz-content-sha256 must match sha256 of bytes the upstream received"
+ );
+ proxy.shutdown().await;
+}
+
+#[tokio::test]
+async fn thinking_block_preserved_through_bedrock() {
+ // Anthropic `thinking` block: cache hot zone item. With
+ // compression OFF, body round-trips byte-equal upstream. (The
+ // dispatcher only mutates the live zone — the latest user
+ // message — so even with compression on, an assistant `thinking`
+ // block is left alone. We pin the byte-equal contract to the
+ // off-mode path because that's what the litellm Python shim
+ // would have lost — P4-37 evidence.)
+ let upstream = MockServer::start().await;
+ let captured = mount_capture_invoke(&upstream, r#"{"id":"msg_x","content":[]}"#).await;
+ let proxy = bedrock_proxy(&upstream, |c| {
+ c.compression_mode = headroom_proxy::config::CompressionMode::Off;
+ })
+ .await;
+
+ let payload = json!({
+ "anthropic_version": "bedrock-2023-05-31",
+ "max_tokens": 1024,
+ "messages": [
+ {"role": "user", "content": "What's 2+2?"},
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "thinking",
+ "thinking": "The user is asking a basic arithmetic question. 2+2=4.",
+ "signature": "EpYBCkYIBRgCKkAhello_world_signature_payload="
+ },
+ {"type": "text", "text": "4"}
+ ]
+ }
+ ]
+ });
+ let body = serde_json::to_vec(&payload).unwrap();
+ let resp = reqwest::Client::new()
+ .post(format!("{}/model/{TEST_MODEL}/invoke", proxy.url()))
+ .header("content-type", "application/json")
+ .body(body.clone())
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), 200);
+
+ let got = captured.lock().unwrap().clone();
+ assert_byte_equal_sha256(&body, got.body.as_deref().unwrap());
+ let parsed: Value = serde_json::from_slice(got.body.as_deref().unwrap()).unwrap();
+ assert_eq!(parsed["messages"][1]["content"][0]["type"], "thinking");
+ assert_eq!(
+ parsed["messages"][1]["content"][0]["signature"],
+ "EpYBCkYIBRgCKkAhello_world_signature_payload="
+ );
+ proxy.shutdown().await;
+}
+
+#[tokio::test]
+async fn redacted_thinking_preserved() {
+ // `redacted_thinking` blocks: opaque encrypted payloads from
+ // the model. Must round-trip BYTE-EQUAL — the proxy never
+ // inspects them.
+ let upstream = MockServer::start().await;
+ let captured = mount_capture_invoke(&upstream, r#"{"id":"msg_x","content":[]}"#).await;
+ let proxy = bedrock_proxy(&upstream, |c| {
+ c.compression_mode = headroom_proxy::config::CompressionMode::Off;
+ })
+ .await;
+
+ let payload = json!({
+ "anthropic_version": "bedrock-2023-05-31",
+ "max_tokens": 1024,
+ "messages": [
+ {"role": "user", "content": "Hi"},
+ {
+ "role": "assistant",
+ "content": [
+ {
+ "type": "redacted_thinking",
+ "data": "EuYBCogBAaR_o9XJEnEx_3Q9d5z9_redacted_payload"
+ },
+ {"type": "text", "text": "Hello!"}
+ ]
+ }
+ ]
+ });
+ let body = serde_json::to_vec(&payload).unwrap();
+ let resp = reqwest::Client::new()
+ .post(format!("{}/model/{TEST_MODEL}/invoke", proxy.url()))
+ .header("content-type", "application/json")
+ .body(body.clone())
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), 200);
+
+ let got = captured.lock().unwrap().clone();
+ assert_byte_equal_sha256(&body, got.body.as_deref().unwrap());
+ let parsed: Value = serde_json::from_slice(got.body.as_deref().unwrap()).unwrap();
+ assert_eq!(
+ parsed["messages"][1]["content"][0]["type"],
+ "redacted_thinking"
+ );
+ assert_eq!(
+ parsed["messages"][1]["content"][0]["data"],
+ "EuYBCogBAaR_o9XJEnEx_3Q9d5z9_redacted_payload"
+ );
+ proxy.shutdown().await;
+}
+
+#[tokio::test]
+async fn document_block_preserved() {
+ // `document` block (PDF or text-document attachment). Has nested
+ // `source.media_type` + `source.data` (base64). The litellm
+ // Python shim drops these silently; the Rust route must NOT.
+ let upstream = MockServer::start().await;
+ let captured = mount_capture_invoke(&upstream, r#"{"id":"msg_x","content":[]}"#).await;
+ let proxy = bedrock_proxy(&upstream, |c| {
+ c.compression_mode = headroom_proxy::config::CompressionMode::Off;
+ })
+ .await;
+
+ let payload = json!({
+ "anthropic_version": "bedrock-2023-05-31",
+ "max_tokens": 256,
+ "messages": [{
+ "role": "user",
+ "content": [
+ {
+ "type": "document",
+ "source": {
+ "type": "base64",
+ "media_type": "application/pdf",
+ "data": "JVBERi0xLjQKJfbk/N8KMSAwIG9iago8PAovVHlwZSAvQ2F0YWxvZwo+PgplbmRvYmoK"
+ },
+ "title": "Quarterly Report",
+ "context": "Q4 2025 financial summary"
+ },
+ {"type": "text", "text": "Summarize."}
+ ]
+ }]
+ });
+ let body = serde_json::to_vec(&payload).unwrap();
+ let resp = reqwest::Client::new()
+ .post(format!("{}/model/{TEST_MODEL}/invoke", proxy.url()))
+ .header("content-type", "application/json")
+ .body(body.clone())
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), 200);
+
+ let got = captured.lock().unwrap().clone();
+ assert_byte_equal_sha256(&body, got.body.as_deref().unwrap());
+ let parsed: Value = serde_json::from_slice(got.body.as_deref().unwrap()).unwrap();
+ let doc = &parsed["messages"][0]["content"][0];
+ assert_eq!(doc["type"], "document");
+ assert_eq!(doc["source"]["media_type"], "application/pdf");
+ assert_eq!(doc["title"], "Quarterly Report");
+ proxy.shutdown().await;
+}
+
+#[tokio::test]
+async fn tool_result_array_with_image_preserved() {
+ // `tool_result.content` is an array; one element is an `image`
+ // block with base64 source. The litellm shim flattened these
+ // to a single string (P4-37). The Rust route must keep the
+ // array shape verbatim.
+ let upstream = MockServer::start().await;
+ let captured = mount_capture_invoke(&upstream, r#"{"id":"msg_x","content":[]}"#).await;
+ let proxy = bedrock_proxy(&upstream, |c| {
+ c.compression_mode = headroom_proxy::config::CompressionMode::Off;
+ })
+ .await;
+
+ let payload = json!({
+ "anthropic_version": "bedrock-2023-05-31",
+ "max_tokens": 256,
+ "messages": [
+ {"role": "user", "content": "Take a screenshot"},
+ {
+ "role": "assistant",
+ "content": [{
+ "type": "tool_use",
+ "id": "toolu_xyz",
+ "name": "screenshot",
+ "input": {"region": "full"}
+ }]
+ },
+ {
+ "role": "user",
+ "content": [{
+ "type": "tool_result",
+ "tool_use_id": "toolu_xyz",
+ "content": [
+ {"type": "text", "text": "Captured at 2026-05-03T12:00:00Z"},
+ {
+ "type": "image",
+ "source": {
+ "type": "base64",
+ "media_type": "image/png",
+ "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP8z8DwHwAFAQH/9zJEHwAAAABJRU5ErkJggg=="
+ }
+ }
+ ]
+ }]
+ }
+ ]
+ });
+ let body = serde_json::to_vec(&payload).unwrap();
+ let resp = reqwest::Client::new()
+ .post(format!("{}/model/{TEST_MODEL}/invoke", proxy.url()))
+ .header("content-type", "application/json")
+ .body(body.clone())
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), 200);
+
+ let got = captured.lock().unwrap().clone();
+ assert_byte_equal_sha256(&body, got.body.as_deref().unwrap());
+ let parsed: Value = serde_json::from_slice(got.body.as_deref().unwrap()).unwrap();
+ let tool_result = &parsed["messages"][2]["content"][0];
+ assert_eq!(tool_result["type"], "tool_result");
+ let inner = &tool_result["content"];
+ assert!(inner.is_array(), "tool_result.content must remain an array");
+ assert_eq!(inner[1]["type"], "image");
+ assert_eq!(inner[1]["source"]["media_type"], "image/png");
+ proxy.shutdown().await;
+}
+
+#[tokio::test]
+async fn stop_sequence_null_only_when_present() {
+ // Synthesise a Bedrock-shape response that does NOT include
+ // `stop_sequence` and confirm the proxy doesn't add `null` for
+ // it. P4-37: the litellm Python shim hardcoded `stop_sequence:
+ // null` in the converted response shape; the Rust path must not
+ // do that — Bedrock's response is forwarded verbatim.
+ let upstream = MockServer::start().await;
+ let response_no_stop_sequence = r#"{"id":"msg_a","type":"message","role":"assistant","model":"claude-3-haiku-20240307","content":[{"type":"text","text":"hi"}],"stop_reason":"end_turn","usage":{"input_tokens":3,"output_tokens":1}}"#;
+ let _captured = mount_capture_invoke(&upstream, response_no_stop_sequence).await;
+ let proxy = bedrock_proxy(&upstream, |c| {
+ c.compression_mode = headroom_proxy::config::CompressionMode::Off;
+ })
+ .await;
+
+ let payload = json!({
+ "anthropic_version": "bedrock-2023-05-31",
+ "max_tokens": 16,
+ "messages": [{"role": "user", "content": "hi"}]
+ });
+ let body = serde_json::to_vec(&payload).unwrap();
+ let resp = reqwest::Client::new()
+ .post(format!("{}/model/{TEST_MODEL}/invoke", proxy.url()))
+ .header("content-type", "application/json")
+ .body(body)
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), 200);
+ let resp_text = resp.text().await.unwrap();
+ let resp_parsed: Value = serde_json::from_str(&resp_text).unwrap();
+ assert!(
+ resp_parsed.get("stop_sequence").is_none(),
+ "stop_sequence must NOT be present on the response when upstream omitted it; got {resp_text}"
+ );
+ assert_eq!(resp_parsed["stop_reason"], "end_turn");
+ proxy.shutdown().await;
+}
+
+#[tokio::test]
+async fn tool_use_input_byte_equal_preserves_key_order() {
+ // `tool_use.input` is a JSON object whose key order must
+ // round-trip exactly. P4-43: the litellm shim parsed
+ // `function.arguments` into a dict and re-stringified, breaking
+ // key order. The Rust path uses serde_json's preserve_order
+ // feature throughout — confirm the bytes arrive byte-equal.
+ let upstream = MockServer::start().await;
+ let captured = mount_capture_invoke(&upstream, r#"{"id":"msg_x","content":[]}"#).await;
+ let proxy = bedrock_proxy(&upstream, |c| {
+ c.compression_mode = headroom_proxy::config::CompressionMode::Off;
+ })
+ .await;
+
+ // Hand-craft the body bytes so we can pin exact key order.
+ // BTreeMap-default serialization would alphabetize the keys
+ // (city < country < units); we send the opposite so any
+ // accidental re-encode shows up as a byte mismatch.
+ let body = br#"{"anthropic_version":"bedrock-2023-05-31","max_tokens":64,"messages":[{"role":"assistant","content":[{"type":"tool_use","id":"toolu_zoom","name":"get_weather","input":{"units":"metric","country":"FR","city":"Paris"}}]}]}"#;
+
+ let resp = reqwest::Client::new()
+ .post(format!("{}/model/{TEST_MODEL}/invoke", proxy.url()))
+ .header("content-type", "application/json")
+ .body(body.to_vec())
+ .send()
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), 200);
+
+ let got = captured.lock().unwrap().clone();
+ let received = got.body.expect("upstream got body");
+ assert_byte_equal_sha256(body, &received);
+
+ // Defensive: sanity-check the input key order by looking at the
+ // raw substring.
+ let received_str = std::str::from_utf8(&received).unwrap();
+ let units_pos = received_str.find("\"units\"").expect("units present");
+ let country_pos = received_str.find("\"country\"").expect("country present");
+ let city_pos = received_str.find("\"city\"").expect("city present");
+ assert!(
+ units_pos < country_pos && country_pos < city_pos,
+ "tool_use.input key order must be units→country→city; got: {received_str}"
+ );
+ proxy.shutdown().await;
+}