feat: extraction models

chore: extraction model api (no proxying implemented yet)
feat: timeout
2026-10-24 16:18:32 -04:00 · 2026-10-24 02:33:31 -04:00 · 2026-10-24 01:57:21 -04:00 · 2026-10-24 01:12:06 -04:00 · 2026-10-19 16:19:57 -04:00 · 2026-10-19 16:18:03 -04:00
24 changed files with 3712 additions and 699 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,3 @@
 /target
 .history/
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -32,6 +32,15 @@ dependencies = [
 "alloc-no-stdlib",
 ]
 [[package]]
 name = "android_system_properties"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc"
 dependencies = [
 "libc",
 ]
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -282,6 +291,12 @@ version = "0.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 [[package]]
 name = "bitflags"
 version = "2.13.2"
@@ -318,6 +333,15 @@ dependencies = [
 "alloc-stdlib",
 ]
 [[package]]
 name = "bs58"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
 dependencies = [
 "tinyvec",
 ]
 [[package]]
 name = "bumpalo"
 version = "3.20.3"
@@ -348,12 +372,6 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
 [[package]]
 name = "cfg_aliases"
 version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527"
 [[package]]
 name = "chacha20"
 version = "0.10.2"
@@ -365,6 +383,18 @@ dependencies = [
 "rand_core 0.10.1",
 ]
 [[package]]
 name = "chrono"
 version = "0.4.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
 dependencies = [
 "iana-time-zone",
 "num-traits",
 "serde",
 "windows-link",
 ]
 [[package]]
 name = "clap"
 version = "4.6.7"
@@ -405,35 +435,6 @@ version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486"
 [[package]]
 name = "cloud-llms"
 version = "0.1.0"
 dependencies = [
 "async-channel",
 "axum",
 "axum-extra",
 "clap",
 "ecow",
 "enum-map",
 "enumset",
 "futures",
 "headers",
 "indexmap",
 "mitsein",
 "rand 0.10.3",
 "reqwest",
 "reqwest-sse",
 "schemars",
 "secrecy",
 "serde",
 "serde_json",
 "tokio",
 "tracing",
 "tracing-subscriber",
 "typed-builder",
 "url",
 ]
 [[package]]
 name = "cmake"
 version = "0.1.58"
@@ -622,8 +623,18 @@ version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
 dependencies = [
- "darling_core",
+ "darling_core 0.21.3",
- "darling_macro",
+ "darling_macro 0.21.3",
 ]
 [[package]]
 name = "darling"
 version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed17f5901b6630b993ca003def43f2f8ef4014fc13b047b57aad617ff32bc2ec"
 dependencies = [
 "darling_core 0.24.1",
 "darling_macro 0.24.1",
 ]
 [[package]]
@@ -639,28 +650,86 @@ dependencies = [
 "syn 2.0.119",
 ]
 [[package]]
 name = "darling_core"
 version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6837e2cf7485aaae18f86181d2f0e9a7ed297a025e220aeabf63fdebd3a2ddff"
 dependencies = [
 "ident_case",
 "proc-macro2",
 "quote",
 "strsim",
 "syn 3.0.6",
 ]
 [[package]]
 name = "darling_macro"
 version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
 dependencies = [
- "darling_core",
+ "darling_core 0.21.3",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "darling_macro"
 version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2ac7135c3ef02b2f7833bbeb1be5ba7f966dcde8a87c6b87f65a778d71a02785"
 dependencies = [
 "darling_core 0.24.1",
 "quote",
 "syn 3.0.6",
 ]
 [[package]]
 name = "data-encoding"
 version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06"
 [[package]]
 name = "defmt"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1"
 dependencies = [
 "bitflags 1.3.2",
 "defmt-macros",
 ]
 [[package]]
 name = "defmt-macros"
 version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8"
 dependencies = [
 "defmt-parser",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "defmt-parser"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e"
 dependencies = [
 "thiserror",
 ]
 [[package]]
 name = "deranged"
 version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 dependencies = [
 "serde_core",
 ]
 [[package]]
 name = "digest"
@@ -770,7 +839,7 @@ version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4bd536557b58c682b217b8fb199afdff47cd3eff260623f19e77074eb073d63a"
 dependencies = [
- "darling",
+ "darling 0.21.3",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
@@ -945,10 +1014,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
 dependencies = [
 "cfg-if",
 "js-sys",
 "libc",
 "wasi",
 "wasm-bindgen",
 ]
 [[package]]
@@ -970,11 +1037,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
 dependencies = [
 "cfg-if",
 "js-sys",
 "libc",
 "r-efi 6.0.0",
 "rand_core 0.10.1",
 "wasm-bindgen",
 ]
 [[package]]
@@ -989,13 +1054,19 @@ dependencies = [
 "futures-core",
 "futures-sink",
 "http",
- "indexmap",
+ "indexmap 2.14.2",
 "slab",
 "tokio",
 "tokio-util",
 "tracing",
 ]
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 [[package]]
 name = "hashbrown"
 version = "0.17.1"
@@ -1032,6 +1103,12 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 [[package]]
 name = "hex"
 version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 [[package]]
 name = "hickory-net"
 version = "0.26.3"
@@ -1203,11 +1280,33 @@ dependencies = [
 "percent-encoding",
 "pin-project-lite",
 "socket2",
 "system-configuration",
 "tokio",
 "tower-service",
 "tracing",
- "windows-registry",
+]
 [[package]]
 name = "iana-time-zone"
 version = "0.1.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
 dependencies = [
 "android_system_properties",
 "core-foundation-sys",
 "iana-time-zone-haiku",
 "js-sys",
 "log",
 "wasm-bindgen",
 "windows-core",
 ]
 [[package]]
 name = "iana-time-zone-haiku"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
 dependencies = [
 "cc",
 ]
 [[package]]
@@ -1320,6 +1419,17 @@ dependencies = [
 "icu_properties",
 ]
 [[package]]
 name = "indexmap"
 version = "1.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 dependencies = [
 "autocfg",
 "hashbrown 0.12.3",
 "serde",
 ]
 [[package]]
 name = "indexmap"
 version = "2.14.2"
@@ -1327,7 +1437,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
 dependencies = [
 "equivalent",
- "hashbrown",
+ "hashbrown 0.17.1",
 "serde",
 "serde_core",
 ]
 [[package]]
@@ -1367,12 +1479,75 @@ dependencies = [
 "either",
 ]
 [[package]]
 name = "itertools"
 version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
 dependencies = [
 "either",
 ]
 [[package]]
 name = "itoa"
 version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 [[package]]
 name = "jiff"
 version = "0.2.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2b005715dcbeb0089a3c0dab99f2ff1cc3b2525323552703d648585d342a383"
 dependencies = [
 "defmt",
 "jiff-core",
 "jiff-static",
 "jiff-tzdb-platform",
 "log",
 "portable-atomic",
 "portable-atomic-util",
 "serde_core",
 "windows-link",
 ]
 [[package]]
 name = "jiff-core"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e52fe76043ccecc9005d2305ebaadf7d7fc0cc89ca6baa10a94d6bc68c7128c"
 dependencies = [
 "defmt",
 "log",
 ]
 [[package]]
 name = "jiff-static"
 version = "0.2.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2cc9817253cf7c7ee4684451bd327e88d6f3658014e54a29198625590650695c"
 dependencies = [
 "jiff-core",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "jiff-tzdb"
 version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "142bd39932ad231f10513df9ab62661fead8719872150b7ad02a2df79f4e141e"
 [[package]]
 name = "jiff-tzdb-platform"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
 dependencies = [
 "jiff-tzdb",
 ]
 [[package]]
 name = "jni"
 version = "0.22.4"
@@ -1443,6 +1618,42 @@ dependencies = [
 "wasm-bindgen",
 ]
 [[package]]
 name = "katniss-ai"
 version = "0.1.0"
 dependencies = [
 "async-channel",
 "axum",
 "axum-extra",
 "clap",
 "ecow",
 "enum-map",
 "enumset",
 "futures",
 "headers",
 "indexmap 2.14.2",
 "itertools 0.15.0",
 "jiff",
 "mitsein",
 "rand 0.10.3",
 "reqwest",
 "reqwest-sse",
 "rustls",
 "schemars 1.2.2",
 "secrecy",
 "serde",
 "serde_json",
 "serde_with",
 "strum",
 "tokio",
 "tower-http 0.7.1",
 "tracing",
 "tracing-subscriber",
 "typed-builder",
 "url",
 "webpki-root-certs",
 ]
 [[package]]
 name = "lazy_static"
 version = "1.5.0"
@@ -1482,12 +1693,6 @@ version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f9f8bd3e56ce4dfc153cf470fffbfa98c7620958b312ca5c3a4b8d5181fd13c6"
 [[package]]
 name = "lru-slab"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4050469837a6ff301cd14c1f8f24f88549e6d548f24f64e2148eb0f72cebc51f"
 [[package]]
 name = "matchers"
 version = "0.2.0"
@@ -1553,9 +1758,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a49aef75c004fb496a23f175395415ecfe2a630e4c6175ae6f7d9cc1a19332e"
 dependencies = [
 "either",
- "indexmap",
+ "indexmap 2.14.2",
- "itertools",
+ "itertools 0.14.0",
- "schemars",
+ "schemars 1.2.2",
 "serde",
 "smallvec",
 ]
@@ -1705,6 +1910,15 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
 [[package]]
 name = "portable-atomic-util"
 version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715"
 dependencies = [
 "portable-atomic",
 ]
 [[package]]
 name = "potential_utf"
 version = "0.1.6"
@@ -1765,63 +1979,6 @@ dependencies = [
 "psl-types",
 ]
 [[package]]
 name = "quinn"
 version = "0.11.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4051e23e9185c255a7e33ef59cdbca87a22d359052eecd22fc6b901fb37d9d11"
 dependencies = [
 "bytes",
 "cfg_aliases",
 "pin-project-lite",
 "quinn-proto",
 "quinn-udp",
 "rustc-hash",
 "rustls",
 "socket2",
 "thiserror",
 "tokio",
 "tracing",
 "web-time",
 ]
 [[package]]
 name = "quinn-proto"
 version = "0.11.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9746dbde176634f4f2f1faf2404e30a31b2bc1e9cafb5329c95d8177a18c9fc"
 dependencies = [
 "aws-lc-rs",
 "bytes",
 "getrandom 0.4.3",
 "lru-slab",
 "rand 0.10.3",
 "rand_pcg",
 "ring",
 "rustc-hash",
 "rustls",
 "rustls-pki-types",
 "slab",
 "thiserror",
 "tinyvec",
 "tracing",
 "web-time",
 ]
 [[package]]
 name = "quinn-udp"
 version = "0.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "35a133f956daabe89a61a685c2649f13d82d5aa4bd5d12d1277e1072a21c0694"
 dependencies = [
 "cfg_aliases",
 "libc",
 "once_cell",
 "socket2",
 "tracing",
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "quote"
 version = "1.0.47"
@@ -1889,22 +2046,13 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
 [[package]]
 name = "rand_pcg"
 version = "0.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a"
 dependencies = [
 "rand_core 0.10.1",
 ]
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags",
+ "bitflags 2.13.2",
 ]
 [[package]]
@@ -1954,7 +2102,6 @@ dependencies = [
 "bytes",
 "cookie",
 "cookie_store",
 "encoding_rs",
 "futures-core",
 "futures-util",
 "h2",
@@ -1967,12 +2114,10 @@ dependencies = [
 "hyper-util",
 "js-sys",
 "log",
 "mime",
 "mime_guess",
 "once_cell",
 "percent-encoding",
 "pin-project-lite",
 "quinn",
 "rustls",
 "rustls-pki-types",
 "rustls-platform-verifier",
@@ -1984,7 +2129,7 @@ dependencies = [
 "tokio-rustls",
 "tokio-util",
 "tower",
- "tower-http",
+ "tower-http 0.6.11",
 "tower-service",
 "url",
 "wasm-bindgen",
@@ -2026,12 +2171,6 @@ dependencies = [
 "windows-sys 0.52.0",
 ]
 [[package]]
 name = "rustc-hash"
 version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -2048,6 +2187,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
 dependencies = [
 "aws-lc-rs",
 "log",
 "once_cell",
 "rustls-pki-types",
 "rustls-webpki",
@@ -2073,7 +2213,6 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
 dependencies = [
 "web-time",
 "zeroize",
 ]
@@ -2146,6 +2285,18 @@ dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "schemars"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
 dependencies = [
 "dyn-clone",
 "ref-cast",
 "serde",
 "serde_json",
 ]
 [[package]]
 name = "schemars"
 version = "1.2.2"
@@ -2153,7 +2304,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "687274d293b6cdc6e73e0fee520bf2049650090d7164f87672d212a3c530cf4a"
 dependencies = [
 "dyn-clone",
- "indexmap",
+ "indexmap 2.14.2",
 "ref-cast",
 "schemars_derive",
 "serde",
@@ -2194,7 +2345,7 @@ version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
- "bitflags",
+ "bitflags 2.13.2",
 "core-foundation 0.10.1",
 "core-foundation-sys",
 "libc",
@@ -2265,7 +2416,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b2f2d7ff8a2140333718bb329f5c40fc5f0865b84c426183ce14c97d2ab8154f"
 dependencies = [
 "form_urlencoded",
- "indexmap",
+ "indexmap 2.14.2",
 "itoa",
 "ryu",
 "serde_core",
@@ -2307,6 +2458,39 @@ dependencies = [
 "serde",
 ]
 [[package]]
 name = "serde_with"
 version = "3.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "df9adc193c780ef8f159aee8b61e2d5801aaa555e6eb0947fe45530ec506296f"
 dependencies = [
 "base64 0.23.1",
 "bs58",
 "chrono",
 "hex",
 "indexmap 1.9.3",
 "indexmap 2.14.2",
 "jiff",
 "schemars 0.9.0",
 "schemars 1.2.2",
 "serde_core",
 "serde_json",
 "serde_with_macros",
 "time",
 ]
 [[package]]
 name = "serde_with_macros"
 version = "3.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3e17bbc68e28663bbbb90df47e058aa7eda4fb445b89fe70457bb94fbccf6e49"
 dependencies = [
 "darling 0.24.1",
 "proc-macro2",
 "quote",
 "syn 3.0.6",
 ]
 [[package]]
 name = "sha1"
 version = "0.10.7"
@@ -2395,6 +2579,27 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 [[package]]
 name = "strum"
 version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
 dependencies = [
 "strum_macros",
 ]
 [[package]]
 name = "strum_macros"
 version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
 dependencies = [
 "heck",
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "subtle"
 version = "2.6.1"
@@ -2449,7 +2654,7 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
 dependencies = [
- "bitflags",
+ "bitflags 2.13.2",
 "core-foundation 0.9.4",
 "system-configuration-sys",
 ]
@@ -2641,7 +2846,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
 dependencies = [
 "async-compression",
- "bitflags",
+ "bitflags 2.13.2",
 "bytes",
 "futures-core",
 "futures-util",
@@ -2657,6 +2862,21 @@ dependencies = [
 "url",
 ]
 [[package]]
 name = "tower-http"
 version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08a05a66a4fdd61cbbe0a1d755ffe0ca6aba159dd4820936a0ff8a8278245b9c"
 dependencies = [
 "bitflags 2.13.2",
 "bytes",
 "http",
 "percent-encoding",
 "pin-project-lite",
 "tower-layer",
 "tower-service",
 ]
 [[package]]
 name = "tower-layer"
 version = "0.3.3"
@@ -2957,16 +3177,6 @@ dependencies = [
 "wasm-bindgen",
 ]
 [[package]]
 name = "web-time"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 dependencies = [
 "js-sys",
 "wasm-bindgen",
 ]
 [[package]]
 name = "webpki-root-certs"
 version = "1.0.9"
@@ -2991,6 +3201,41 @@ dependencies = [
 "windows-sys 0.61.2",
 ]
 [[package]]
 name = "windows-core"
 version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
 "windows-implement",
 "windows-interface",
 "windows-link",
 "windows-result",
 "windows-strings",
 ]
 [[package]]
 name = "windows-implement"
 version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "windows-interface"
 version = "0.59.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.119",
 ]
 [[package]]
 name = "windows-link"
 version = "0.2.1"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "cloud-llms"
+name = "katniss-ai"
 version = "0.1.0"
 edition = "2024"
 license = "Unlicense"
@@ -15,16 +15,23 @@ enumset = { version = "1.1.14", features = ["serde"] }
 futures = "0.3.34"
 headers = "0.4.2"
 indexmap = "2.14.2"
 itertools = "0.15.0"
 jiff = { version = "0.2.38", features = ["serde"] }
 mitsein = { version = "0.9.0", features = ["indexmap"] }
 rand = "0.10.3"
-reqwest = { version = "0.13.5", features = ["brotli", "cookies", "deflate", "form", "gzip", "hickory-dns", "json", "multipart", "query", "socks", "stream", "zstd"] }
+reqwest = { version = "0.13.5", features = ["brotli", "cookies", "deflate", "form", "gzip", "hickory-dns", "json", "multipart", "query", "rustls-no-provider", "socks", "stream", "zstd"], default-features = false }
 reqwest-sse = "0.2.0"
 rustls = "0.23.45"
 schemars = "1.2.2"
 secrecy = { version = "0.10.3", features = ["serde"] }
 serde = { version = "1.0.229", features = ["derive"] }
 serde_json = "1.0.151"
 serde_with = "3.24.0"
 strum = { version = "0.28.0", features = ["derive"] }
 tokio = { version = "1.53.1", features = ["macros", "rt-multi-thread"] }
 tower-http = { version = "0.7.1", features = ["cors"] }
 tracing = "0.1.44"
 tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
 typed-builder = "0.23.2"
 url = "2.5.8"
 webpki-root-certs = "1.0.9"
--- a/2
+++ b/2
@@ -16,7 +16,7 @@ RUN \
    --mount=type=cache,target=/usr/local/cargo/registry/ \
    cd /root/app && \
    cargo build --release && \
-    cp target/release/cloud-llms /root/program
+    cp target/release/katniss-ai /root/program
 FROM scratch AS runner
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -0,0 +1,99 @@
 use clap::Parser;
 use secrecy::SecretString;
 use std::{convert::Infallible, net::IpAddr, str::FromStr};
 use tracing_subscriber::EnvFilter;
 pub mod openai;
 pub mod server;
 #[derive(Debug, Clone)]
 pub struct CloudflareCredentials {
    pub account_id: String,
    pub api_key: SecretString,
 }
 impl FromStr for CloudflareCredentials {
    type Err = Infallible; // TODO
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let (account_id, api_key) = s.split_once(":").expect("TODO");
        let account_id = account_id.into();
        let api_key = api_key.into();
        Ok(Self {
            account_id,
            api_key,
        })
    }
 }
 #[derive(Debug, Clone, Parser)]
 pub struct AppArgs {
    #[arg(long, env, default_value_t = [127, 0, 0, 1].into())]
    pub ip: IpAddr,
    #[arg(long, env, default_value_t = 3126)]
    pub port: u16,
    #[arg(long)]
    pub cloudflare_workers_ai_credentials: Vec<CloudflareCredentials>,
    #[arg(long)]
    pub cohere_api_key: Vec<SecretString>,
    #[arg(long)]
    pub google_ai_studio_api_key: Vec<SecretString>,
    #[arg(long)]
    pub groq_api_key: Vec<SecretString>,
    #[arg(long)]
    pub hugging_face_api_key: Vec<SecretString>,
    #[arg(long)]
    pub kilo_api_key: Vec<SecretString>,
    #[arg(long)]
    pub liquid_ai_api_key: Vec<SecretString>,
    #[arg(long)]
    pub mistral_api_key: Vec<SecretString>,
    #[arg(long)]
    pub novita_ai_api_key: Vec<SecretString>,
    #[arg(long)]
    pub nvidia_nim_api_key: Vec<SecretString>,
    #[arg(long)]
    pub ollama_cloud_api_key: Vec<SecretString>,
    #[arg(long)]
    pub opencode_console_api_key: Vec<SecretString>,
    #[arg(long)]
    pub openrouter_api_key: Vec<SecretString>,
    #[arg(long)]
    pub poolside_api_key: Vec<SecretString>,
    #[arg(long)]
    pub vercel_ai_gateway_api_key: Vec<SecretString>,
    #[arg(long)]
    pub z_ai_api_key: Vec<SecretString>,
 }
 #[derive(Parser)]
 pub struct Args {
    #[arg(
        long = "tracing-directives",
        env = "RUST_LOG",
        default_value = "warn,katniss_ai=debug"
    )]
    pub env_filter: EnvFilter,
    #[command(flatten)]
    pub app_args: AppArgs,
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,55 +1,11 @@
 use std::net::{IpAddr, SocketAddr};
 use clap::Parser;
-use futures::StreamExt as _;
+use std::net::SocketAddr;
-use reqwest_sse::EventSource;
+use tracing_subscriber::fmt::format::FmtSpan;
 use secrecy::SecretString;
 use tokio::{join, pin, task::LocalSet};
 use tracing_subscriber::{EnvFilter, fmt::format::FmtSpan};
 mod openai;
 mod server;
 #[derive(Parser, Debug)]
 struct AppArgs {
    #[arg(long, env, default_value_t = [127, 0, 0, 1].into())]
    ip: IpAddr,
    #[arg(long, env, default_value_t = 3126)]
    port: u16,
    #[arg(long)]
    cloudflare_workers_ai_api_key: Vec<SecretString>,
    #[arg(long)]
    google_ai_studio_api_key: Vec<SecretString>,
    #[arg(long)]
    groq_api_key: Vec<SecretString>,
    #[arg(long)]
    hugging_face_api_key: Vec<SecretString>,
    #[arg(long)]
    mistral_api_key: Vec<SecretString>,
    #[arg(long)]
    openrouter_api_key: Vec<SecretString>,
 }
 #[derive(Parser)]
 struct Args {
    #[arg(long = "tracing-directives", env = "RUST_LOG", default_value_t = Default::default())]
    env_filter: EnvFilter,
    #[command(flatten)]
    app_args: AppArgs,
 }
 #[tokio::main]
 async fn main() {
    let args = Parser::parse();
-    let Args {
+    let katniss_ai::Args {
        env_filter,
        app_args,
    } = args;
@@ -61,52 +17,20 @@ async fn main() {
        .init();
    tracing::debug!(?app_args, "using");
    rustls::crypto::aws_lc_rs::default_provider()
        .install_default()
        .unwrap();
    let addr = SocketAddr::new(app_args.ip, app_args.port);
-    let (tx, rx) = async_channel::unbounded();
+    let app = katniss_ai::server::create_app(
-
+        katniss_ai::server::AppState::builder()
    let app = server::create_app(
        server::AppState::builder()
            .app_args(app_args.into())
            .stream_requester(tx)
            .build(),
    );
    let listener = tokio::net::TcpListener::bind(addr).await.expect("TODO");
-    let stream_responses = async move {
+    tracing::info!(?addr, "listening");
-        let local_set = LocalSet::new();
+    axum::serve(listener, app).await.expect("TODO");
        local_set
            .run_until(async {
                pin!(rx);
                while let Some((response, sse_sink)) = rx.next().await {
                    local_set.spawn_local(async move {
                        match response.events().await {
                            Ok(mut events) => {
                                while let Some(event_result) = events.next().await {
                                    let message = event_result
                                        .map(|event| {
                                            axum::response::sse::Event::default().data(event.data)
                                        })
                                        .map_err(Into::into);
                                    let _ = sse_sink.send(message).await;
                                }
                            }
                            Err(event_source_error) => {
                                let _ = sse_sink.send(Err(event_source_error.into())).await;
                            }
                        };
                    });
                }
            })
            .await;
    };
    join!(stream_responses, async move {
        tracing::info!(?addr, "listening");
        axum::serve(listener, app).await.expect("TODO");
    });
 }
--- a/src/openai/chat/completion.rs
+++ b/src/openai/chat/completion.rs
@@ -1,5 +1,7 @@
 use serde::{Deserialize, Serialize};
 use serde_with::{DeserializeFromStr, SerializeDisplay};
 use std::collections::HashMap;
 use strum::{EnumString, VariantArray};
 // ============================================================================
 // Request: Create Chat Completion
@@ -22,7 +24,7 @@ pub struct CreateChatCompletionRequest<Model> {
    /// Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing
    /// frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub frequency_penalty: Option<f32>,
+    pub frequency_penalty: Option<f64>,
    /// Deprecated in favor of `tool_choice`. Controls which (if any) function is called by the model.
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -35,7 +37,7 @@ pub struct CreateChatCompletionRequest<Model> {
    /// Modify the likelihood of specified tokens appearing in the completion. Accepts a JSON object
    /// that maps tokens (specified by their token ID in the tokenizer) to an associated bias value from -100 to 100.
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub logit_bias: Option<HashMap<String, f32>>,
+    pub logit_bias: Option<HashMap<String, f64>>,
    /// Whether to return log probabilities of the output tokens or not. If true, returns the log
    /// probabilities of each output token returned in the `content` of `message`.
@@ -81,7 +83,7 @@ pub struct CreateChatCompletionRequest<Model> {
    /// Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in
    /// the text so far, increasing the model's likelihood to talk about new topics.
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub presence_penalty: Option<f32>,
+    pub presence_penalty: Option<f64>,
    /// Used by OpenAI to cache responses for similar requests to optimize your cache hit rates. Replaces the `user` field.
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -135,7 +137,7 @@ pub struct CreateChatCompletionRequest<Model> {
    /// What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random.
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
+    pub temperature: Option<f64>,
    /// Controls which (if any) tool is called by the model.
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -153,7 +155,7 @@ pub struct CreateChatCompletionRequest<Model> {
    /// An alternative to sampling with temperature, called nucleus sampling, where the model considers the
    /// results of the tokens with top_p probability mass.
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub top_p: Option<f32>,
+    pub top_p: Option<f64>,
    /// Deprecated in favor of `safety_identifier` and `prompt_cache_key`. A stable identifier for your end-users.
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -916,8 +918,10 @@ pub enum PromptCacheRetention {
 }
 /// Constrains reasoning effort for reasoning models.
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(
-#[serde(rename_all = "lowercase")]
+    Clone, Debug, EnumString, DeserializeFromStr, strum::Display, SerializeDisplay, VariantArray,
 )]
 #[strum(serialize_all = "lowercase")]
 pub enum ReasoningEffort {
    /// Disable reasoning.
    None,
@@ -930,7 +934,8 @@ pub enum ReasoningEffort {
    /// High reasoning effort.
    High,
    /// Extra high reasoning effort.
-    Xhigh,
+    #[strum(serialize = "xhigh")]
    ExtraHigh,
    /// Maximum reasoning effort.
    Max,
 }
@@ -1087,7 +1092,7 @@ pub struct ApproximateLocation {
 /// Represents a chat completion response returned by model, based on the provided input.
 #[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct ChatCompletion {
+pub struct ChatCompletion<Model> {
    /// A unique identifier for the chat completion.
    pub id: String,
@@ -1098,7 +1103,7 @@ pub struct ChatCompletion {
    pub created: i64,
    /// The model used for the chat completion.
-    pub model: String,
+    pub model: Model,
    /// The object type, which is always `chat.completion`.
    pub object: String,
--- a/src/openai/decisions.rs
+++ b/src/openai/decisions.rs
@@ -0,0 +1,308 @@
 use serde::{Deserialize, Serialize};
 /// Represents the main request to the Decisions API
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct DecisionRequest<Model> {
    /// The model that evaluates the request. Currently, only `gpt-6-luna` is supported.
    pub model: Model,
    /// The text or images to evaluate for every question.
    /// Can be a simple string or an array of user messages containing text and images.
    pub input: DecisionInput,
    /// Array of questions to evaluate against the input
    #[serde(rename = "questions")]
    pub questions: Vec<DecisionQuestion>,
 }
 /// Represents the input to be evaluated, which can be either a string or an array of messages
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum DecisionInput {
    /// Simple text input
    Text(String),
    /// Array of user messages containing text and images
    Messages(Vec<DecisionInputMessage>),
 }
 /// Represents a message in the input, typically from a user
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct DecisionInputMessage {
    /// The role of the message sender (always "user" for decisions)
    pub role: String,
    /// The content of the message, which can be a string or an array of parts
    #[serde(flatten)]
    pub content: DecisionInputContent,
 }
 /// Represents the content of a message, which can be a string or an array of parts
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum DecisionInputContent {
    /// Simple text content
    Text(String),
    /// Array of text and image parts
    Parts(Vec<DecisionInputPart>),
 }
 /// Represents a part of a message, which can be text or an image
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(tag = "type")]
 pub enum DecisionInputPart {
    /// Text part of a message
    #[serde(rename = "input_text")]
    Text {
        /// The text content
        text: String,
    },
    /// Image part of a message
    #[serde(rename = "input_image")]
    Image {
        /// The image URL (base64 data URL or HTTP(S) URL)
        image_url: String,
        /// Optional detail level for the image
        #[serde(skip_serializing_if = "Option::is_none")]
        detail: Option<ImageDetail>,
    },
 }
 /// Represents the detail level for an image
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
 #[serde(rename_all = "lowercase")]
 pub enum ImageDetail {
    /// Low detail
    Low,
    /// High detail
    High,
    /// Auto detail (default)
    Auto,
    /// Original detail
    Original,
 }
 /// Represents a question in the Decisions API
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum DecisionQuestion {
    /// A predicate question checks a condition
    Predicate(PredicateQuestion),
    /// A choice question selects from fixed options
    Choice(ChoiceQuestion),
    /// A score question evaluates against ordered levels
    Score(ScoreQuestion),
 }
 /// A predicate question checks a condition and returns a probability
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct PredicateQuestion {
    /// Optional name to identify the question in the response
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Instructions for evaluating the condition
    pub instructions: String,
 }
 /// A choice question selects from fixed options
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ChoiceQuestion {
    /// Optional name to identify the question in the response
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Instructions for making the choice
    pub instructions: String,
    /// Array of available choices
    pub choices: Vec<ChoiceOption>,
 }
 /// Represents a single choice option
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ChoiceOption {
    /// The value of the choice
    pub value: Choice,
    /// Optional description of when this choice applies
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
 }
 /// A score question evaluates against ordered levels
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ScoreQuestion {
    /// Optional name to identify the question in the response
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Instructions for scoring
    pub instructions: String,
    /// Array of ordered levels for scoring
    pub levels: Vec<ScoreLevel>,
 }
 /// Represents a single score level
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ScoreLevel {
    /// The label for this level
    pub label: String,
    /// Optional description of this level
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
 }
 /// Represents the response from the Decisions API
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct DecisionResponse<Model> {
    /// Array of answers to the questions
    pub answers: Vec<DecisionAnswer>,
    /// The model used for the decision
    pub model: Model,
    /// Token usage information
    pub usage: TokenUsage,
 }
 /// Represents an answer to a question
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum DecisionAnswer {
    /// Answer to a predicate question
    Predicate(PredicateAnswer),
    /// Answer to a choice question
    Choice(ChoiceAnswer),
    /// Answer to a score question
    Score(ScoreAnswer),
    /// The model refused to answer this question
    Refusal(RefusalAnswer),
 }
 /// Answer to a predicate question
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct PredicateAnswer {
    /// Optional name of the question
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Probability that the condition is true (0.0 to 1.0)
    pub probability: f64,
 }
 /// Choice values are typed: a string and a boolean with the same text are distinct
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum Choice {
    /// String
    String(String),
    /// Boolean
    Boolean(bool),
 }
 /// Answer to a choice question
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ChoiceAnswer {
    /// Optional name of the question
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// The selected choice value
    pub choice: Choice,
    /// Confidence score (0.0 to 1.0)
    pub confidence: f64,
    /// Probabilities for each choice option
    pub probabilities: Vec<ChoiceProbability>,
 }
 /// Represents the probability distribution for a choice answer
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ChoiceProbability {
    /// The choice value
    pub value: Choice,
    /// Probability of this choice (0.0 to 1.0)
    pub probability: f64,
 }
 /// Answer to a score question
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ScoreAnswer {
    /// Optional name of the question
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// The computed score (can be between level indices)
    pub score: f64,
    /// Confidence score (0.0 to 1.0)
    pub confidence: f64,
    /// Probabilities for each score level
    pub probabilities: Vec<ScoreProbability>,
 }
 /// Represents the probability distribution for a score answer
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ScoreProbability {
    /// The level index
    pub value: i32,
    /// The level label
    pub label: String,
    /// Probability of this level (0.0 to 1.0)
    pub probability: f64,
 }
 /// Answer indicating the model refused to answer a question
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct RefusalAnswer {
    /// Optional name of the question
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
 }
 /// Represents token usage information
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct TokenUsage {
    /// Total number of input tokens
    pub input_tokens: i32,
    /// Details about input tokens
    pub input_tokens_details: TokenUsageDetails,
    /// Total number of output tokens
    pub output_tokens: i32,
    /// Details about output tokens
    pub output_tokens_details: OutputTokenDetails,
    /// Total number of tokens (input + output)
    pub total_tokens: i32,
 }
 /// Represents details about input tokens
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct TokenUsageDetails {
    /// Number of tokens written to cache
    pub cache_write_tokens: i32,
    /// Number of tokens read from cache
    pub cached_tokens: i32,
 }
 /// Represents details about output tokens
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct OutputTokenDetails {
    /// Number of reasoning tokens used
    pub reasoning_tokens: i32,
 }
 /// Optional safety identifier provided by the caller
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct SafetyIdentifier(pub String);
--- a/src/openai/embeddings.rs
+++ b/src/openai/embeddings.rs
@@ -0,0 +1,113 @@
 use serde::{Deserialize, Serialize};
 /// Represents the possible input types for embedding requests
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum EmbeddingInput {
    /// A single string input
    String(String),
    /// An array of string inputs
    StringArray(Vec<String>),
    /// An array of token IDs (numbers)
    NumberArray(Vec<i32>),
    /// An array of arrays of token IDs (numbers)
    NumberMatrix(Vec<Vec<i32>>),
 }
 /// Represents the encoding format for embeddings
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
 #[serde(rename_all = "lowercase")]
 pub enum EncodingFormat {
    /// Return embeddings as an array of floats
    Float,
    /// Return embeddings as a base64-encoded string
    Base64,
 }
 /// Request body for creating embeddings
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct CreateEmbeddingRequest<Model> {
    /// Input text to embed
    pub input: EmbeddingInput,
    /// ID of the model to use for generating embeddings
    pub model: Model,
    /// Optional number of dimensions for the output embeddings
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dimensions: Option<u32>,
    /// Format to return the embeddings in
    #[serde(skip_serializing_if = "Option::is_none")]
    pub encoding_format: Option<EncodingFormat>,
    /// Optional unique identifier for tracking end-user
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user: Option<String>,
 }
 /// Embedding object type
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum EmbeddingObject {
    /// Embedding
    Embedding,
 }
 /// Represents a single embedding in the response
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Embedding {
    /// The embedding vector, returned as an array of floats or a base64 string
    /// depending on the encoding_format parameter
    pub embedding: EmbeddingOutput,
    /// The index of this embedding in the list of embeddings
    pub index: u32,
    /// The object type, which is always "embedding"
    pub object: EmbeddingObject,
 }
 /// Represents the possible output formats for embeddings
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum EmbeddingOutput {
    /// Array of floats when encoding_format is "float"
    FloatArray(Vec<f64>),
    /// Base64-encoded string when encoding_format is "base64"
    Base64String(String),
 }
 /// Usage information for an embeddings request
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Usage {
    /// Number of tokens used by the prompt
    pub prompt_tokens: u32,
    /// Total number of tokens used by the request
    pub total_tokens: u32,
 }
 /// List object type
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "lowercase")]
 pub enum ListObject {
    /// List
    List,
 }
 /// Response from the embeddings API
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct CreateEmbeddingResponse<Model> {
    /// List of generated embeddings
    pub data: Vec<Embedding>,
    /// The name of the model used to generate the embeddings
    pub model: Model,
    /// The object type, which is always "list"
    pub object: ListObject,
    /// Usage information for the request
    pub usage: Usage,
 }
--- a/src/openai/extraction.rs
+++ b/src/openai/extraction.rs
@@ -0,0 +1,524 @@
 //! System One-style models that can extract, compute, estimate,
 //! and forecast values from inputs.
 //! They are strongly typed and output confidence scores and probabilities against their outputs.
 //!
 //! Request: [`ExtractionRequest`] · Response: [`ExtractionResponse`]
 use jiff::civil::{Date, DateTime, Time};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 /// The item type required for `list` fields.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 pub enum ListItems {
    /// List of text items.
    Text,
    /// List of numbers.
    Number,
    /// List of ISO dates.
    Date,
 }
 /// Scale for estimate/forecast grids.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(rename_all = "lowercase")]
 pub enum Scale {
    /// Linear scale (default).
    #[default]
    Linear,
    /// Logarithmic scale.
    Log,
 }
 /// Interval for forecast fields.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 pub enum ForecastInterval {
    /// One step of the grid.
    Step,
    /// Per minute.
    Minute,
    /// Per hour.
    Hour,
    /// Per day.
    Day,
    /// Per week.
    Week,
    /// Per month.
    Month,
    /// Per quarter.
    Quarter,
    /// Per year.
    Year,
 }
 /// A value that may be a number or an ISO date string. Used for the
 /// `min`/`max` bounds of estimate/forecast fields (ISO date for date
 /// estimates) and for the `step` grid.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(untagged)]
 pub enum NumberOrDate {
    /// A numeric bound or step size.
    Number(f64),
    /// An ISO date string (for date estimates).
    Date(Date),
 }
 /// A step size for estimate grids: a positive number (days for date
 /// estimates), or the strings `"month"` / `"year"`.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(untagged)]
 pub enum EstimateStep {
    /// A positive numeric step (days for date estimates).
    Number(f64),
    /// Calendar-aware step: `"month"`.
    Month,
    /// Calendar-aware step: `"year"`.
    Year,
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 pub enum DurationUnit {
    Seconds,
    Minutes,
    Hours,
    Days,
    Weeks,
    Months,
    Years,
 }
 /// A typed field specification
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum Field {
    /// A string extracted from the input.
    #[serde(rename = "text")]
    Text {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Probability of null above which the value is null (default 0.5).
        /// Must be in `(0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
    /// A numeric value.
    #[serde(rename = "number")]
    Number {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Unit label for the number (e.g. `USD`).
        #[serde(skip_serializing_if = "Option::is_none")]
        unit: Option<String>,
        /// Whether the number must be an integer. Numbers and durations only.
        #[serde(skip_serializing_if = "Option::is_none")]
        integer: Option<bool>,
        /// Number of decimal places (0–6). Numbers, durations and number
        /// lists only.
        #[serde(skip_serializing_if = "Option::is_none")]
        decimals: Option<u8>,
        /// Probability of null above which the value is null (default 0.5).
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
    /// An ISO date value.
    #[serde(rename = "date")]
    Date {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Probability of null above which the value is null (default 0.5).
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
    /// An ISO time value.
    #[serde(rename = "time")]
    Time {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Probability of null above which the value is null (default 0.5).
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
    /// An ISO date-time value.
    #[serde(rename = "datetime")]
    Datetime {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Probability of null above which the value is null (default 0.5).
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
    /// A duration value.
    #[serde(rename = "duration")]
    Duration {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Unit label
        #[serde(skip_serializing_if = "Option::is_none")]
        unit: Option<DurationUnit>,
        /// Whether the duration must be an integer. Numbers and durations only.
        #[serde(skip_serializing_if = "Option::is_none")]
        integer: Option<bool>,
        /// Number of decimal places (0–6). Numbers, durations and number
        /// lists only.
        #[serde(skip_serializing_if = "Option::is_none")]
        decimals: Option<u8>,
        /// Probability of null above which the value is null (default 0.5).
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
    /// A list of typed items.
    #[serde(rename = "list")]
    List {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Required for list fields: the type of each item.
        items: ListItems,
        /// Number of decimal places (0–6) for number lists.
        #[serde(skip_serializing_if = "Option::is_none")]
        decimals: Option<u8>,
        /// Probability of null above which the value is null (default 0.5).
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
    /// A probabilistic estimate over a bounded grid.
    #[serde(rename = "estimate")]
    Estimate {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Required for estimate/forecast: lower bound (a number, or an ISO
        /// date for date estimates).
        min: NumberOrDate,
        /// Required for estimate/forecast: upper bound (a number, or an ISO
        /// date for date estimates).
        max: NumberOrDate,
        /// Estimate grid: a positive number (days for date estimates), or
        /// `"month"` / `"year"`.
        #[serde(skip_serializing_if = "Option::is_none")]
        step: Option<EstimateStep>,
        /// Grid scale: `linear` (default) or `log`.
        #[serde(skip_serializing_if = "Option::is_none")]
        scale: Option<Scale>,
        /// Probability of null above which the value is null (default 0.5).
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
    /// A forecast: a sequence of estimates over a horizon.
    #[serde(rename = "forecast")]
    Forecast {
        /// What the field should contain.
        #[serde(skip_serializing_if = "Option::is_none")]
        instructions: Option<String>,
        /// Required for estimate/forecast: lower bound (a number, or an ISO
        /// date for date estimates).
        min: NumberOrDate,
        /// Required for estimate/forecast: upper bound (a number, or an ISO
        /// date for date estimates).
        max: NumberOrDate,
        /// Estimate grid: a positive number (days for date estimates), or
        /// `"month"` / `"year"`.
        #[serde(skip_serializing_if = "Option::is_none")]
        step: Option<EstimateStep>,
        /// Grid scale: `linear` (default) or `log`.
        #[serde(skip_serializing_if = "Option::is_none")]
        scale: Option<Scale>,
        /// Forecast only: number of steps (1–64).
        #[serde(skip_serializing_if = "Option::is_none")]
        horizon: Option<u32>,
        /// Forecast only: the interval between steps.
        #[serde(skip_serializing_if = "Option::is_none")]
        interval: Option<ForecastInterval>,
        /// Probability of null above which the value is null (default 0.5).
        #[serde(skip_serializing_if = "Option::is_none")]
        null_threshold: Option<f64>,
    },
 }
 /// An image input. Either a data URL string or an explicit base64 object.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(untagged)]
 pub enum Image {
    /// A data URL string (must start with `data:`, case-insensitive).
    DataUrl(
        /// The data URL, e.g. `data:image/png;base64,...`.
        String,
    ),
    /// An explicitly split base64 image.
    Base64 {
        /// MIME content type of the image (PNG, JPEG or WebP).
        content_type: String,
        /// Base64-encoded image bytes.
        base64: String,
    },
 }
 /// Optional request settings.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
 pub struct RequestOptions {
    /// Add 99 percentiles to estimates (default `false`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub include_quantiles: Option<bool>,
    /// Return the text that spans index into (default `false`).
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub return_state_text: Option<bool>,
 }
 /// The extraction request body.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct ExtractionRequest<Model> {
    /// The model selector
    pub model: Model,
    /// The text to read and predict from. Must be non-empty unless images
    /// are sent. Text answers are spans of this string.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// Required. Map of field name to a typed field spec. At least one
    /// field; no upper limit. Fields that do not fit next to the state in
    /// one 8,192-token pass are split across parallel passes. Field names
    /// must match `^[A-Za-z_][A-Za-z0-9_.\-]{0,63}$`.
    pub fields: HashMap<String, Field>,
    /// Optional embedded PNG, JPEG or WebP images placed before the state
    /// (max 4; 4 MiB each, 8 MiB total decoded; request body max 16 MiB).
    /// Remote URLs are not accepted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub images: Option<Vec<Image>>,
    /// ISO date that anchors dates written without a year.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reference_date: Option<Date>,
    /// Optional request settings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<RequestOptions>,
 }
 /// The value of an answer. Shape depends on the field type; `null` when the
 /// input does not determine it.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(untagged)]
 pub enum List {
    // A list of strings
    Strings(Vec<String>),
    // A list of numbers
    Numbers(Vec<f64>),
    // A list of dates
    Dates(Vec<Date>),
 }
 /// A forecast step: one estimate per step, with median and interval bounds.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct ForecastStep {
    /// The point (median) value for this step.
    pub value: f64,
    /// Mean of the distribution for this step.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mean: Option<f64>,
    /// Lower bound of the interval for this step.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub p10: Option<f64>,
    /// Upper bound of the interval for this step.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub p90: Option<f64>,
 }
 /// One answer per requested field, keyed by field name. Tagged by `type`,
 /// mirroring the field spec that produced it.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum Answer {
    /// Answer for a text field: an exact span of the state, with character
    /// offsets.
    #[serde(rename = "text")]
    Text {
        /// The extracted value, or null when the input does not determine it.
        value: Option<String>,
        /// The model's best guess before applying the null threshold.
        #[serde(skip_serializing_if = "Option::is_none")]
        guess: Option<String>,
        /// Probability that the field is null.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_null: Option<f64>,
        /// Confidence score in `[0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        confidence: Option<f64>,
        /// Character offsets `[start, end]` of the span into the state.
        #[serde(skip_serializing_if = "Option::is_none")]
        span: Option<[usize; 2]>,
    },
    /// Answer for a number field.
    #[serde(rename = "number")]
    Number {
        /// The extracted value, or null when the input does not determine it.
        value: Option<f64>,
        /// The model's best guess before applying the null threshold.
        #[serde(skip_serializing_if = "Option::is_none")]
        guess: Option<f64>,
        /// Probability that the field is null.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_null: Option<f64>,
        /// Confidence score in `[0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        confidence: Option<f64>,
    },
    /// Answer for a date field.
    #[serde(rename = "date")]
    Date {
        /// The computed/extracted ISO date, or null.
        value: Option<Date>,
        /// The model's best guess before applying the null threshold.
        #[serde(skip_serializing_if = "Option::is_none")]
        guess: Option<Date>,
        /// Probability that the field is null.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_null: Option<f64>,
        /// Confidence score in `[0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        confidence: Option<f64>,
    },
    /// Answer for a time field.
    #[serde(rename = "time")]
    Time {
        /// The extracted ISO time, or null.
        value: Option<Time>,
        /// The model's best guess before applying the null threshold.
        #[serde(skip_serializing_if = "Option::is_none")]
        guess: Option<Time>,
        /// Probability that the field is null.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_null: Option<f64>,
        /// Confidence score in `[0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        confidence: Option<f64>,
    },
    /// Answer for a datetime field.
    #[serde(rename = "datetime")]
    Datetime {
        /// The extracted ISO date-time, or null.
        value: Option<DateTime>,
        /// The model's best guess before applying the null threshold.
        #[serde(skip_serializing_if = "Option::is_none")]
        guess: Option<DateTime>,
        /// Probability that the field is null.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_null: Option<f64>,
        /// Confidence score in `[0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        confidence: Option<f64>,
    },
    /// Answer for a duration field.
    #[serde(rename = "duration")]
    Duration {
        /// The extracted duration, or null.
        value: Option<f64>,
        /// The model's best guess before applying the null threshold.
        #[serde(skip_serializing_if = "Option::is_none")]
        guess: Option<f64>,
        /// Probability that the field is null.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_null: Option<f64>,
        /// Confidence score in `[0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        confidence: Option<f64>,
    },
    /// Answer for a list field: values with per-item spans.
    #[serde(rename = "list")]
    List {
        /// The extracted items, or null.
        value: Option<List>,
        /// Per-item character offsets `[start, end]` into the state.
        #[serde(skip_serializing_if = "Option::is_none")]
        spans: Option<Vec<[usize; 2]>>,
        /// Probability that the field is null.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_null: Option<f64>,
        /// Confidence score in `[0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        confidence: Option<f64>,
    },
    /// Answer for an estimate field: a distribution summary.
    #[serde(rename = "estimate")]
    Estimate {
        /// The point estimate (median).
        value: NumberOrDate,
        /// Mean of the estimated distribution.
        #[serde(skip_serializing_if = "Option::is_none")]
        mean: Option<f64>,
        /// Median of the estimated distribution.
        #[serde(skip_serializing_if = "Option::is_none")]
        median: Option<f64>,
        /// 10th percentile of the estimated distribution.
        #[serde(skip_serializing_if = "Option::is_none")]
        p10: Option<f64>,
        /// 90th percentile of the estimated distribution.
        #[serde(skip_serializing_if = "Option::is_none")]
        p90: Option<f64>,
        /// Probability the true value is below the grid minimum.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_below: Option<f64>,
        /// Probability the true value is above the grid maximum.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_above: Option<f64>,
        /// 99 percentiles, when `options.include_quantiles` is set.
        #[serde(skip_serializing_if = "Option::is_none")]
        quantiles: Option<Vec<f64>>,
    },
    /// Answer for a forecast field: one estimate per step.
    #[serde(rename = "forecast")]
    Forecast {
        /// One estimate per step.
        #[serde(default)]
        steps: Vec<ForecastStep>,
        /// Probability that the field is null.
        #[serde(skip_serializing_if = "Option::is_none")]
        p_null: Option<f64>,
        /// Confidence score in `[0, 1]`.
        #[serde(skip_serializing_if = "Option::is_none")]
        confidence: Option<f64>,
    },
 }
 /// Token and pass accounting for a request.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Usage {
    /// Tokens consumed by the state text.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state_tokens: Option<u64>,
    /// Tokens consumed by images.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image_tokens: Option<u64>,
    /// Tokens consumed by the field schema.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub schema_tokens: Option<u64>,
    /// Total input tokens.
    pub input_tokens: u64,
    /// Total output tokens.
    pub output_tokens: u64,
    /// Number of parallel passes used.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub passes: Option<u64>,
 }
 /// The extraction response body.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct ExtractionResponse<Model> {
    /// The model that produced this response
    pub model: Model,
    /// One answer per field, keyed by field name. `value` is null when the
    /// input does not determine it.
    pub answers: HashMap<String, Answer>,
    /// Whether the input was truncated to fit the context window.
    pub truncated: bool,
    /// The text that spans index into, when `options.return_state_text` is set.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state_text: Option<String>,
    /// Token and pass accounting for the request.
    pub usage: Usage,
 }
--- a/src/openai/mod.rs
+++ b/src/openai/mod.rs
@@ -1 +1,6 @@
 pub mod chat;
 pub mod decisions;
 pub mod embeddings;
 pub mod extraction;
 pub mod models;
 pub mod system_one;
--- a/src/openai/models.rs
+++ b/src/openai/models.rs
@@ -0,0 +1,43 @@
 use serde::{Deserialize, Serialize};
 /// The object type, which is always "model".
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ModelObject {
    Model,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Model<Id> {
    /// The model identifier, which can be referenced in the API endpoints.
    pub id: Id,
    /// The Unix timestamp (in seconds) when the model was created.
    pub created: i64,
    /// The object type, which is always "model".
    pub object: ModelObject,
    /// The organization that owns the model.
    pub owned_by: String,
    /// The date when the model will shut down, or null if not announced.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub shutdown_date: Option<String>,
 }
 /// The object type, which is always "list".
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ListObject {
    List,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ListModelsResponse<Id> {
    /// The list of currently available models.
    pub data: Vec<Model<Id>>,
    /// The object type, which is always "list".
    pub object: ListObject,
 }
--- a/src/openai/system_one.rs
+++ b/src/openai/system_one.rs
@@ -0,0 +1,233 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 /// The top-level request structure for the system one endpoint.
 ///
 /// This represents the complete request body that can be sent to the API.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct SystemOneRequest<Model> {
    /// The model that handles the request.
    pub model: Model,
    /// The content to evaluate. Can be a string, object, or array.
    ///
    /// For text content, use a plain string. For structured data (like chat logs or application state),
    /// use an object or array.
    pub state: State,
    /// Optional file inputs (images, audio, etc.).
    ///
    /// Array of data URLs for input files.
    ///
    /// For images: data:image/...;base64,...
    /// For audio: data:audio/...;base64,...
    #[serde(skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<String>>,
    /// Alternative name for file inputs (alias for `files`).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub images: Option<Vec<String>>,
    /// A map of typed questions to evaluate against the state.
    ///
    /// Each key is a question ID you choose, and the value is a [Question] object.
    /// The answers will be returned under the same keys. The question ID is not sent to the model.
    pub questions: HashMap<String, Question>,
 }
 /// Represents the possible state formats that can be evaluated.
 ///
 /// This is a convenience enum that wraps the different possible state formats:
 /// - Plain text (String)
 /// - Structured data (Object/Array)
 /// - Null (for models that support it)
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum State {
    /// Plain text state
    Text(String),
    /// Structured state (object or array)
    Structured(serde_json::Value),
    /// Null state (for models that support it)
    Null,
 }
 /// The main question type enum that represents all possible question types.
 ///
 /// Each variant corresponds to a different question type (Noul, Choice, Score)
 /// and contains the appropriate fields for that type.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum Question {
    /// Yes/no question type
    Noul(NoulQuestion),
    /// Multiple choice question type
    Choice(ChoiceQuestion),
    /// Scoring question type
    Score(ScoreQuestion),
 }
 /// Represents a yes/no question (Noul = "no/yes/uncertain/likely" type)
 ///
 /// Returns the probability that the answer is yes (value near 1) or no (value near 0).
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct NoulQuestion {
    /// The yes/no question to evaluate.
    ///
    /// Can be a plain string, or a structured object containing the question and referenced data.
    pub instructions: QuestionInstructions,
    /// Optional descriptions of what a yes and no mean.
    ///
    /// Provides additional context for interpreting the yes/no answer.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub criteria: Option<NoulCriteria>,
 }
 /// Criteria for a Noul question, describing what true/false mean.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct NoulCriteria {
    /// What a yes (value near 1) means.
    pub r#true: QuestionInstructions,
    /// What a no (value near 0) means.
    pub r#false: QuestionInstructions,
 }
 /// Represents a multiple choice question.
 ///
 /// Returns the chosen option and the full probability distribution.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ChoiceQuestion {
    /// What the model should decide.
    ///
    /// Can be a plain string, or a structured object containing the question and referenced data.
    pub instructions: QuestionInstructions,
    /// A map of options to their descriptions.
    ///
    /// Each key is an option you define, and the value is its description.
    /// Use null for options that don't need additional description.
    /// Maximum of 255 options per Choice question.
    pub criteria: HashMap<String, Option<QuestionInstructions>>,
 }
 /// Represents a scoring question.
 ///
 /// Returns a probability-weighted value across the defined levels.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ScoreQuestion {
    /// What the model should rate.
    ///
    /// Can be a plain string, or a structured object containing the question and referenced data.
    pub instructions: QuestionInstructions,
    /// An ordered array of level descriptions.
    ///
    /// Must have at least 2 levels, maximum of 10. The first element is the lowest level,
    /// the last is the highest.
    pub criteria: Vec<QuestionInstructions>,
 }
 /// Represents the possible formats for question instructions and criteria.
 ///
 /// This is a convenience enum that wraps different possible formats:
 /// - Plain text (String)
 /// - Structured data (Object/Array)
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(untagged)]
 pub enum QuestionInstructions {
    /// Plain text instructions
    Text(String),
    /// Structured instructions (object or array)
    Structured(serde_json::Value),
 }
 /// The top-level response structure from the system one endpoint.
 ///
 /// This represents the complete response body returned by the API.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct SystemOneResponse<Model> {
    /// The model that performed the evaluation.
    pub model: Model,
    /// A map of answers, keyed by the same IDs used in the request questions.
    pub answers: HashMap<String, Answer>,
    /// Token usage information for the request.
    pub usage: Usage,
 }
 /// Represents the possible answer types that can be returned.
 ///
 /// Each variant corresponds to a different question type (Noul, Choice, Score)
 /// and contains the appropriate fields for that type.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum Answer {
    /// Answer to a Noul question
    Noul(NoulAnswer),
    /// Answer to a Choice question
    Choice(ChoiceAnswer),
    /// Answer to a Score question
    Score(ScoreAnswer),
 }
 /// Answer to a Noul question (yes/no question).
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct NoulAnswer {
    /// The yes/no answer on a scale from 0 (no) to 1 (yes).
    pub noul: f64,
 }
 /// Answer to a Choice question (multiple choice).
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ChoiceAnswer {
    /// The option with the highest probability.
    pub choice: String,
    /// The probability of each option, they sum to 1.
    pub probabilities: HashMap<String, f64>,
    /// How certain the model is (0 to 1).
    ///
    /// 0 means all options are equally likely, 1 means maximum certainty.
    pub confidence: f64,
 }
 /// Answer to a Score question.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ScoreAnswer {
    /// The expected level index, weighted by probability.
    ///
    /// Can be between two levels (e.g., 1.5 would be halfway between level 1 and 2).
    pub score: f64,
    /// The description of each level index.
    pub legend: HashMap<String, String>,
    /// The probability of each level index, they sum to 1.
    pub probabilities: HashMap<String, f64>,
    /// How certain the model is (0 to 1).
    ///
    /// Derived from the probabilities distribution.
    pub confidence: f64,
 }
 /// Token usage information for the request.
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Usage {
    /// Number of input tokens (prompt tokens for all questions).
    pub input_tokens: u32,
    /// Number of output tokens (always 0 for this API).
    pub output_tokens: u32,
 }
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,450 +0,0 @@
 use crate::AppArgs;
 use crate::openai;
 use axum::Json;
 use axum::Router;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::response::Response;
 use axum::response::Sse;
 use axum_extra::routing::RouterExt;
 use axum_extra::routing::TypedPath;
 use ecow::EcoString;
 use headers::Header;
 use headers::authorization::Bearer;
 use mitsein::vec1::Vec1;
 use rand::Rng;
 use rand::RngExt;
 use secrecy::ExposeSecret;
 use secrecy::SecretString;
 use serde::Deserialize;
 use serde::Serialize;
 use std::collections::VecDeque;
 use std::sync::Arc;
 use typed_builder::TypedBuilder;
 use url::Url;
 type SSEEventResult = Result<axum::response::sse::Event, Box<dyn std::error::Error + Sync + Send>>;
 type StreamRequest = (reqwest::Response, async_channel::Sender<SSEEventResult>);
 type StreamRequester = async_channel::Sender<StreamRequest>;
 #[derive(Debug, Clone, TypedBuilder)]
 pub struct AppState {
    app_args: Arc<AppArgs>,
    stream_requester: StreamRequester,
 }
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/v1/chat/completions")]
 struct V1ChatCompletionsPath;
 #[derive(Debug, Clone)]
 enum Provider {
    CloudflareWorkersAi,
    GoogleAiStudio,
    Groq,
    HuggingFace,
    Mistral,
    OpenRouter,
 }
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "lowercase")]
 enum Shortcut {
    XS,
    S,
    M,
    L,
    XL,
 }
 impl Shortcut {
    fn suggestions(&self) -> Vec<(Provider, EcoString)> {
        use Provider as P;
        use Shortcut as S;
        match self {
            S::XS => vec![
                (P::GoogleAiStudio, "gemini-3.5-flash-lite".into()),
                (P::OpenRouter, "poolside/laguna-xs-2.1:free".into()),
                (P::OpenRouter, "nex-agi/nex-n2.5-mini:free".into()),
                (P::OpenRouter, "cohere/north-mini-code:free".into()),
                (P::OpenRouter, "nvidia/nemotron-3.5-lightning:free".into()),
                (P::OpenRouter, "google/gemma-4-26b-a4b-it:free".into()),
                (P::OpenRouter, "poolside/laguna-xs.2:free".into()),
                (
                    P::OpenRouter,
                    "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free".into(),
                ),
                (P::CloudflareWorkersAi, "@cf/openai/gpt-oss-20b".into()),
                (P::OpenRouter, "openai/gpt-oss-20b:free".into()),
                (P::Groq, "openai/gpt-oss-20b".into()),
                (P::OpenRouter, "liquid/lfm-2.5-2.6b:free".into()),
                (P::Groq, "groq/compound-mini".into()),
                (P::OpenRouter, "openrouter/free".into()),
            ],
            S::S => vec![
                (P::CloudflareWorkersAi, "@cf/qwen/qwen3.8-27b".into()),
                (P::OpenRouter, "qwen/qwen3.8-27b:free".into()),
                (P::Groq, "qwen/qwen3.8-27b".into()),
                (P::HuggingFace, "Qwen/Qwen3.8-27B".into()),
                (P::HuggingFace, "meta-models/Muse-Glimmer-30B".into()),
                (P::OpenRouter, "google/gemma-4-31b-it:free".into()),
                (P::Mistral, "mistral-small-2603".into()),
                (P::Groq, "groq/compound".into()),
                (P::OpenRouter, "openrouter/fusion".into()),
            ],
            S::M => vec![
                (P::GoogleAiStudio, "gemini-3.8-flash".into()),
                (P::GoogleAiStudio, "gemini-3.7-flash".into()),
                (P::Mistral, "mistral-medium-3.5".into()),
                (P::OpenRouter, "inclusionai/ling-3.0-flash-vl:free".into()),
                (P::OpenRouter, "poolside/laguna-s-2.1:free".into()),
                (
                    P::OpenRouter,
                    "nvidia/nemotron-3-super-120b-a12b:free".into(),
                ),
                (P::CloudflareWorkersAi, "@cf/openai/gpt-oss-120b".into()),
                (P::OpenRouter, "openai/gpt-oss-120b:free".into()),
                (P::Groq, "openai/gpt-oss-120b".into()),
            ],
            S::L => vec![
                (P::CloudflareWorkersAi, "@cf/zai-org/glm-5.3-flash".into()),
                (P::HuggingFace, "zai-org/GLM-5.3-Flash".into()),
                (P::HuggingFace, "deepseek-ai/DeepSeek-V4.1-Flash".into()),
                (P::OpenRouter, "nex-agi/nex-n2.5-pro:free".into()),
                (P::HuggingFace, "MiniMaxAI/MiniMax-M3".into()),
                (P::OpenRouter, "thinkingmachines/inkling-small:free".into()),
                (P::HuggingFace, "thinkingmachines/Inkling-Small".into()),
            ],
            S::XL => vec![
                (P::CloudflareWorkersAi, "@cf/zai-org/glm-5.3".into()),
                (P::HuggingFace, "zai-org/GLM-5.3".into()),
                (P::Mistral, "zai-glm-5-3".into()),
                (P::HuggingFace, "moonshotai/Kimi-K3".into()),
                (P::HuggingFace, "Qwen/Qwen3.8-2.4T-A95B".into()),
                (P::OpenRouter, "thinkingmachines/inkling:free".into()),
                (P::HuggingFace, "thinkingmachines/Inkling".into()),
                (P::HuggingFace, "tencent/Hy4-preview".into()),
                (P::HuggingFace, "deepseek-ai/DeepSeek-V4-Pro".into()),
            ],
        }
    }
 }
 fn take_random_by_swapping<T>(mut vec1: Vec1<T>, mut rng: impl Rng) -> (T, Option<Vec1<T>>) {
    let end = vec1.len().get() - 1;
    let index = rng.random_range(0..=end);
    vec1.swap(index, end);
    let (body, element) = vec1.into_rtail_and_head();
    let body = body.try_into().ok();
    (element, body)
 }
 #[derive(Debug, TypedBuilder)]
 struct Upstream {
    base_url: Url,
    #[builder(setter(strip_option))]
    api_key: Option<SecretString>,
 }
 enum ChatCompletionResponse {
    Immediate(openai::chat::completion::ChatCompletion),
    Stream {
        response: reqwest::Response,
        stream_requester: StreamRequester,
    },
 }
 impl IntoResponse for ChatCompletionResponse {
    fn into_response(self) -> Response {
        match self {
            ChatCompletionResponse::Immediate(chat_completion) => {
                Json(chat_completion).into_response()
            }
            ChatCompletionResponse::Stream {
                response,
                stream_requester,
            } => {
                let (sse_sink, sse_stream) = async_channel::bounded(256);
                stream_requester
                    .try_send((response, sse_sink))
                    .expect("this is an unbounded channel");
                Sse::new(sse_stream).into_response()
            }
        }
    }
 }
 enum ChatCompletionError {
    NoneSucceeded,
 }
 impl IntoResponse for ChatCompletionError {
    fn into_response(self) -> Response {
        match self {
            ChatCompletionError::NoneSucceeded => StatusCode::SERVICE_UNAVAILABLE.into_response(),
        }
    }
 }
 #[axum::debug_handler]
 #[tracing::instrument(skip(state, request))]
 async fn create_chat_completion(
    _: V1ChatCompletionsPath,
    State(state): State<AppState>,
    Json(request): Json<openai::chat::completion::CreateChatCompletionRequest<Shortcut>>,
 ) -> Result<ChatCompletionResponse, ChatCompletionError> {
    let suggestions = request.model.suggestions();
    let mut model_upstreams = VecDeque::new();
    for (provider, model) in suggestions {
        let upstreams = match provider {
            Provider::CloudflareWorkersAi => vec![], // TODO
            Provider::GoogleAiStudio => state
                .app_args
                .google_ai_studio_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .base_url(
                            "https://generativelanguage.googleapis.com/v1beta/openai"
                                .parse()
                                .expect("TODO"),
                        )
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::Groq => state
                .app_args
                .groq_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .base_url("https://api.groq.com/openai".parse().expect("TODO"))
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::HuggingFace => state
                .app_args
                .hugging_face_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .base_url("https://router.huggingface.co".parse().expect("TODO"))
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::Mistral => state
                .app_args
                .mistral_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .base_url("https://api.mistral.ai".parse().expect("TODO"))
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::OpenRouter => state
                .app_args
                .openrouter_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .base_url("https://openrouter.ai/api".parse().expect("TODO"))
                        .api_key(api_key)
                        .build()
                })
                .collect(),
        };
        if let Ok(upstreams) = Vec1::try_from(upstreams) {
            model_upstreams.push_back((model, upstreams));
        }
    }
    while let Some((model, upstreams)) = model_upstreams.pop_front() {
        let (upstream, upstreams) = take_random_by_swapping(upstreams, &mut rand::rng());
        if let Some(upstreams) = upstreams {
            model_upstreams.push_back((model.clone(), upstreams));
        }
        tracing::info!(?model, ?upstream);
        let openai::chat::completion::CreateChatCompletionRequest {
            model: _shortcut,
            messages,
            audio,
            frequency_penalty,
            function_call,
            functions,
            logit_bias,
            logprobs,
            max_completion_tokens,
            max_tokens,
            metadata,
            modalities,
            moderation,
            n,
            parallel_tool_calls,
            prediction,
            presence_penalty,
            prompt_cache_key,
            prompt_cache_options,
            prompt_cache_retention,
            reasoning_effort,
            response_format,
            safety_identifier,
            seed,
            service_tier,
            stop,
            store,
            stream,
            stream_options,
            temperature,
            tool_choice,
            tools,
            top_logprobs,
            top_p,
            user,
            verbosity,
            web_search_options,
        } = request.clone();
        let request = openai::chat::completion::CreateChatCompletionRequest {
            model,
            messages,
            audio,
            frequency_penalty,
            function_call,
            functions,
            logit_bias,
            logprobs,
            max_completion_tokens,
            max_tokens,
            metadata,
            modalities,
            moderation,
            n,
            parallel_tool_calls,
            prediction,
            presence_penalty,
            prompt_cache_key,
            prompt_cache_options,
            prompt_cache_retention,
            reasoning_effort,
            response_format,
            safety_identifier,
            seed,
            service_tier,
            stop,
            store,
            stream,
            stream_options,
            temperature,
            tool_choice,
            tools,
            top_logprobs,
            top_p,
            user,
            verbosity,
            web_search_options,
        };
        let client = reqwest::Client::new();
        let mut upstream_request = client
            .post({
                let mut url = upstream.base_url;
                {
                    let mut path_segments = url.path_segments_mut().expect("TODO");
                    let s = V1ChatCompletionsPath.to_string();
                    let s = s.strip_prefix("/").unwrap_or(&s);
                    let s = s.strip_suffix("/").unwrap_or(&s);
                    path_segments.extend(s.split("/"));
                }
                tracing::info!(?url);
                url
            })
            .json(&request);
        if let Some(api_key) = upstream.api_key {
            let authorization =
                headers::Authorization::bearer(api_key.expose_secret()).expect("TODO");
            upstream_request = upstream_request.header(headers::Authorization::<Bearer>::name(), {
                let mut vec = vec![];
                authorization.encode(&mut vec);
                let [one] = vec.try_into().expect("TODO");
                one
            });
        }
        let upstream_response = match upstream_request.send().await {
            Ok(upstream_response) => upstream_response,
            Err(upstream_error) => {
                tracing::error!(?upstream_error);
                continue;
            }
        };
        if let Err(upstream_error) = upstream_response.error_for_status_ref() {
            tracing::error!(?upstream_error);
            match upstream_response.text().await {
                Ok(body) => tracing::error!(?body),
                Err(body_error) => tracing::error!(?body_error),
            };
            continue;
        };
        if request.stream.unwrap_or(false) {
            return Ok(ChatCompletionResponse::Stream {
                response: upstream_response,
                stream_requester: state.stream_requester,
            });
        } else {
            let response = match upstream_response.json().await {
                Ok(response) => response,
                Err(json_error) => {
                    tracing::error!(?json_error);
                    continue;
                }
            };
            return Ok(ChatCompletionResponse::Immediate(response));
        }
    }
    Err(ChatCompletionError::NoneSucceeded)
 }
 pub fn create_router() -> Router<AppState> {
    Router::new().typed_post(create_chat_completion)
 }
 pub fn create_app(state: AppState) -> Router<()> {
    create_router().with_state(state)
 }
--- a/src/server/chat/completions.rs
+++ b/src/server/chat/completions.rs
@@ -0,0 +1,738 @@
 use crate::CloudflareCredentials;
 use crate::openai;
 use crate::server::AppState;
 use crate::server::Upstream;
 use crate::server::take_random_by_swapping;
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::response::Response;
 use axum::response::Sse;
 use axum_extra::routing::TypedPath;
 use ecow::EcoString;
 use futures::StreamExt;
 use headers::Header;
 use headers::authorization::Bearer;
 use mitsein::vec1::Vec1;
 use reqwest::Certificate;
 use reqwest_sse::EventSource as _;
 use secrecy::ExposeSecret;
 use serde::Deserialize;
 use serde_with::DeserializeFromStr;
 use serde_with::SerializeDisplay;
 use std::collections::VecDeque;
 use std::convert::Infallible;
 use std::fmt::Display;
 use std::str::FromStr;
 use std::time::Duration;
 use strum::EnumString;
 use strum::VariantArray;
 use tokio::runtime::Handle;
 use tokio::select;
 use tokio::time::sleep;
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/v1/chat/completions")]
 pub struct V1ChatCompletionsPath;
 #[derive(
    Clone, Debug, EnumString, DeserializeFromStr, strum::Display, SerializeDisplay, VariantArray,
 )]
 #[strum(serialize_all = "lowercase")]
 pub enum Shortcut {
    XS,
    S,
    M,
    L,
    XL,
    Experimental,
 }
 #[derive(Debug, Clone, DeserializeFromStr, SerializeDisplay)]
 pub struct ShortcutAndMaybeReasoning(
    pub Shortcut,
    pub Option<openai::chat::completion::ReasoningEffort>,
 );
 impl FromStr for ShortcutAndMaybeReasoning {
    type Err = Infallible; // TODO
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if let Some((model, reasoning)) = s.split_once(":") {
            let model = model.parse().expect("TODO");
            let reasoning = reasoning.parse().expect("TODO");
            Ok(Self(model, Some(reasoning)))
        } else {
            let model = s.parse().expect("TODO");
            let reasoning = None;
            Ok(Self(model, reasoning))
        }
    }
 }
 impl Display for ShortcutAndMaybeReasoning {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let Self(model, reasoning) = self;
        write!(f, "{model}")?;
        if let Some(reasoning) = reasoning {
            write!(f, ":")?;
            write!(f, "{reasoning}")?;
        }
        Ok(())
    }
 }
 #[derive(Debug, Clone)]
 enum Provider {
    CloudflareWorkersAi,
    Cohere,
    GoogleAiStudio,
    Groq,
    HuggingFace,
    Kilo,
    Mistral,
    NovitaAi,
    NvidiaNim,
    Ollama,
    OpenCode,
    OpenRouter,
    Poolside,
    VercelAiGateway,
    ZAi,
 }
 impl Shortcut {
    fn suggestions(&self) -> Vec<(Provider, EcoString)> {
        use Provider as P;
        use Shortcut as S;
        match self {
            S::XS => vec![
                (P::GoogleAiStudio, "gemini-3.5-flash-lite".into()),
                (P::VercelAiGateway, "openai/gpt-5.4-nano".into()),
                (P::HuggingFace, "Qwen/Qwen3.6-35B-A3B".into()),
                (P::OpenRouter, "xingchen-agi/xing4.0-29b-a4b:free".into()),
                (P::NovitaAi, "apodex/apodex-1.1-mini".into()),
                (P::OpenRouter, "apodex/apodex-1.1-mini:free".into()),
                (P::VercelAiGateway, "liquid/lfm2.5-24b-a2b".into()),
                (P::GoogleAiStudio, "gemma-4-26b-a4b-it".into()),
                (P::OpenRouter, "google/gemma-4-26b-a4b-it:free".into()),
                (P::Kilo, "google-gemma-4-26b-a4b-it-free".into()),
                (P::HuggingFace, "google/gemma-4-26B-A4B-it".into()),
                (P::Poolside, "poolside/laguna-xs-2.1".into()),
                (P::NvidiaNim, "poolside/laguna-xs-2.1".into()),
                (P::OpenRouter, "poolside/laguna-xs-2.1:free".into()),
                (P::ZAi, "glm-4.7-flash".into()),
                (P::NvidiaNim, "google/diffusiongemma-26b-a4b-it".into()),
                (P::Cohere, "north-mini-code-1-0".into()),
                (P::OpenRouter, "cohere/north-mini-code:free".into()),
                (P::NvidiaNim, "nvidia/nemotron-3.5-lightning-30b-a3b".into()),
                (
                    P::VercelAiGateway,
                    "nvidia/nemotron-3.5-lightning-free".into(),
                ),
                (P::OpenRouter, "nvidia/nemotron-3.5-lightning:free".into()),
                (P::OpenCode, "nemotron-3.5-lightning-free".into()),
                (P::ZAi, "glm-4.6v-flash".into()),
                (P::ZAi, "glm-4.5-flash".into()),
                (P::OpenRouter, "poolside/laguna-xs.2:free".into()),
                (
                    P::NvidiaNim,
                    "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning".into(),
                ),
                (
                    P::OpenRouter,
                    "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free".into(),
                ),
                (P::Ollama, "nemotron-3-nano:30b".into()),
                (P::Groq, "openai/gpt-oss-20b".into()),
                (P::Ollama, "gpt-oss:20b".into()),
                (P::NvidiaNim, "openai/gpt-oss-20b".into()),
                (P::CloudflareWorkersAi, "@cf/openai/gpt-oss-20b".into()),
                (P::OpenRouter, "openai/gpt-oss-20b:free".into()),
                (P::HuggingFace, "openai/gpt-oss-20b".into()),
                (P::NvidiaNim, "meta/llama-3.2-11b-vision-instruct".into()),
                (P::OpenRouter, "liquid/lfm-2.5-2.6b:free".into()),
                (P::Groq, "groq/compound-mini".into()),
                (P::Kilo, "kilo-auto/free".into()),
                (P::OpenRouter, "openrouter/free".into()),
            ],
            S::S => vec![
                (P::Groq, "qwen/qwen3.8-27b".into()),
                (P::CloudflareWorkersAi, "@cf/qwen/qwen3.8-27b".into()),
                (P::OpenRouter, "qwen/qwen3.8-27b:free".into()),
                (P::HuggingFace, "Qwen/Qwen3.8-27B".into()),
                (P::NvidiaNim, "meta/muse-glimmer-30b".into()),
                (P::HuggingFace, "meta-models/Muse-Glimmer-30B".into()),
                (P::GoogleAiStudio, "gemma-4-31b-it".into()),
                (P::Ollama, "gemma4:31b".into()),
                (P::NvidiaNim, "google/gemma-4-31b-it".into()),
                (P::OpenRouter, "google/gemma-4-31b-it:free".into()),
                (P::HuggingFace, "google/gemma-4-31B-it".into()),
                (P::Mistral, "mistral-small-2603".into()),
                (P::Groq, "groq/compound".into()),
                (P::OpenRouter, "openrouter/fusion".into()),
            ],
            S::M => vec![
                (P::GoogleAiStudio, "gemini-3.8-flash".into()),
                (P::VercelAiGateway, "alibaba/qwen3.7-flash".into()),
                (P::VercelAiGateway, "alibaba/qwen3.8-omni-flash".into()),
                (
                    P::NvidiaNim,
                    "nvidia/nemotron-3.5-super-vl-120b-a12b".into(),
                ),
                (P::OpenRouter, "nvidia/nemotron-3.5-super-vl:free".into()),
                (P::OpenCode, "nemotron-3.5-super-vl-free".into()),
                (P::Mistral, "mistral-medium-3.5".into()),
                (P::Kilo, "inclusionai-ling-3-0-flash-free".into()),
                (P::Kilo, "inclusionai-ling-3-0-flash-vl-free".into()),
                (P::VercelAiGateway, "inclusionai/ling-3.0-flash-vl".into()),
                (P::VercelAiGateway, "poolside/laguna-s-2.1-free".into()),
                (P::Poolside, "poolside/laguna-s-2.1".into()),
                (P::Kilo, "poolside-laguna-s-2-1-free".into()),
                (P::OpenRouter, "poolside/laguna-s-2.1:free".into()),
                (P::VercelAiGateway, "stepfun/step-3.7-flash".into()),
                (P::VercelAiGateway, "inclusionai/ling-3.0-flash-fin".into()),
                (
                    P::VercelAiGateway,
                    "inclusionai/ling-3.0-flash-sante".into(),
                ),
                (P::VercelAiGateway, "mistral/mistral-large-3".into()),
                (P::Ollama, "nemotron-3-super".into()),
                (P::Cohere, "command-a-plus-05-2026".into()),
                (P::NvidiaNim, "nvidia/nemotron-3-super-120b-a12b".into()),
                (P::Kilo, "nvidia-nemotron-3-super-120b-a12b-free".into()),
                (
                    P::OpenRouter,
                    "nvidia/nemotron-3-super-120b-a12b:free".into(),
                ),
                (P::Groq, "openai/gpt-oss-120b".into()),
                (P::Ollama, "gpt-oss:120b".into()),
                (P::CloudflareWorkersAi, "@cf/openai/gpt-oss-120b".into()),
                (P::OpenRouter, "openai/gpt-oss-120b:free".into()),
                (P::HuggingFace, "openai/gpt-oss-120b".into()),
                (P::NvidiaNim, "meta/llama-3.2-90b-vision-instruct".into()),
            ],
            S::L => vec![
                (P::CloudflareWorkersAi, "@cf/zai-org/glm-5.3-flash".into()),
                (P::NvidiaNim, "z-ai/glm-5-3-flash".into()),
                (P::OpenCode, "glm-5.3-flash-free".into()),
                (P::HuggingFace, "zai-org/GLM-5.3-Flash".into()),
                (P::HuggingFace, "zai-org/GLM-5.3-Flash-BF16".into()),
                (P::Kilo, "step-5-preview-free".into()),
                (P::NvidiaNim, "stepfun-ai/step-5-preview".into()),
                (P::VercelAiGateway, "openai/gpt-5.2".into()),
                (P::NvidiaNim, "deepseek-ai/deepseek-v4.1-flash".into()),
                (P::HuggingFace, "deepseek-ai/DeepSeek-V4.1-Flash".into()),
                (P::OpenCode, "deepseek-v4.1-flash-free".into()),
                (P::VercelAiGateway, "minimax/minimax-m3.1-flash".into()),
                (P::OpenRouter, "minimax/minimax-m3.1-flash:free".into()),
                (P::VercelAiGateway, "inclusionai/ling-3.1-flash".into()),
                (P::HuggingFace, "inclusionAI/Ling-3.1-flash".into()),
                (P::VercelAiGateway, "reflection/beam-free".into()),
                (P::Ollama, "beam".into()),
                (P::OpenCode, "beam-free".into()),
                (P::VercelAiGateway, "xiaomi/mimo-v2.6-flash".into()),
                (P::OpenCode, "mimo-v2.6-flash-free".into()),
                (P::HuggingFace, "XiaomiMiMo/MiMo-V2.6-Flash-RL".into()),
                (P::Kilo, "nex-agi-nex-n2-5-pro-free".into()),
                (P::VercelAiGateway, "xiaomi/mimo-v2.5".into()),
                (P::Kilo, "dots-studio-dots-3-note-preview-free".into()),
                (P::OpenRouter, "dots-studio/dots-3-note-preview:free".into()),
                (P::Kilo, "minimax-minimax-m3-free".into()),
                (P::HuggingFace, "MiniMaxAI/MiniMax-M3".into()),
                (P::VercelAiGateway, "tencent/hy3".into()),
                (P::Kilo, "tencent-hy3-free".into()),
                (P::Kilo, "tencent-hy3-preview-free".into()),
                (P::OpenRouter, "thinkingmachines/inkling-small:free".into()),
                (P::HuggingFace, "thinkingmachines/Inkling-Small".into()),
                (P::Ollama, "nemotron-3-ultra".into()),
                (P::NvidiaNim, "nvidia/nemotron-3-ultra-550b-a55b".into()),
                (P::Kilo, "nvidia-nemotron-3-ultra-550b-a55b-free".into()),
                (
                    P::OpenRouter,
                    "nvidia/nemotron-3-ultra-550b-a55b:free".into(),
                ),
                (P::OpenCode, "nemotron-3-ultra-free".into()),
            ],
            S::XL => vec![
                (P::NvidiaNim, "z-ai/glm-5-3".into()),
                (P::HuggingFace, "zai-org/GLM-5.3".into()),
                (P::CloudflareWorkersAi, "@cf/zai-org/glm-5.3".into()),
                (P::Mistral, "zai-glm-5-3".into()),
                (
                    P::VercelAiGateway,
                    "deepseek/deepseek-v4.1-flash-1017".into(),
                ),
                (
                    P::CloudflareWorkersAi,
                    "@cf/deepseek-ai/deepseek-v4.1-flash-1017".into(),
                ),
                (P::OpenCode, "muse-spark-1.3-contributor-free".into()),
                (P::NvidiaNim, "moonshotai/kimi-k3".into()),
                (P::HuggingFace, "moonshotai/Kimi-K3".into()),
                (P::HuggingFace, "tencent/Hy4-preview".into()),
                (P::HuggingFace, "XiaomiMiMo/MiMo-V2.6-Pro-RL".into()),
                (P::Mistral, "mistral-large-4".into()),
                (P::HuggingFace, "Qwen/Qwen3.8-2.4T-A95B".into()),
                (P::VercelAiGateway, "xiaomi/mimo-v2.5-pro".into()),
                (P::OpenCode, "longcat-2.5-preview-free".into()),
                (P::OpenRouter, "thinkingmachines/inkling:free".into()),
                (P::HuggingFace, "thinkingmachines/Inkling".into()),
                (P::VercelAiGateway, "thinkingmachines/inkling".into()),
                (P::GoogleAiStudio, "gemini-3.1-pro-preview".into()),
                (P::VercelAiGateway, "moonshotai/kimi-k2.7-code".into()),
            ],
            S::Experimental => vec![
                (P::OpenRouter, "space-bunny-alpha".into()),
                (P::OpenCode, "space-bunny-free".into()),
                (P::OpenCode, "big-pickle".into()),
                (P::VercelAiGateway, "stealth/glyph-cluster".into()),
            ],
        }
    }
 }
 pub enum ChatCompletionResponse {
    Immediate(openai::chat::completion::ChatCompletion<String>),
    Stream(reqwest::Response),
 }
 impl IntoResponse for ChatCompletionResponse {
    fn into_response(self) -> Response {
        match self {
            ChatCompletionResponse::Immediate(chat_completion) => {
                Json(chat_completion).into_response()
            }
            ChatCompletionResponse::Stream(response) => {
                let (sink, stream) = async_channel::bounded(256);
                let handle = Handle::current();
                std::thread::spawn(move || {
                    handle.block_on(async move {
                        match response.events().await {
                            Ok(mut events) => {
                                while let Some(event_result) = events.next().await {
                                    let message = event_result
                                        .map(|event| {
                                            axum::response::sse::Event::default().data(event.data)
                                        })
                                        .map_err(Box::<dyn std::error::Error + Send + Sync>::from);
                                    let _ = sink.send(message).await;
                                }
                            }
                            Err(event_source_error) => {
                                let _ = sink.send(Err(event_source_error.into())).await;
                            }
                        };
                    });
                });
                Sse::new(stream).into_response()
            }
        }
    }
 }
 pub enum ChatCompletionError {
    NoneSucceeded,
 }
 impl IntoResponse for ChatCompletionError {
    fn into_response(self) -> Response {
        match self {
            ChatCompletionError::NoneSucceeded => StatusCode::SERVICE_UNAVAILABLE.into_response(),
        }
    }
 }
 #[axum::debug_handler]
 #[tracing::instrument(skip(state, request))]
 pub async fn create_chat_completion(
    _: V1ChatCompletionsPath,
    State(state): State<AppState>,
    Json(request): Json<
        openai::chat::completion::CreateChatCompletionRequest<ShortcutAndMaybeReasoning>,
    >,
 ) -> Result<ChatCompletionResponse, ChatCompletionError> {
    let ShortcutAndMaybeReasoning(shortcut, reasoning_in_id) = request.model.clone();
    let mut model_upstreams = VecDeque::new();
    for (provider, model) in shortcut.suggestions() {
        let upstreams: Vec<Upstream> =
            match provider {
                Provider::CloudflareWorkersAi => state
                    .app_args
                    .cloudflare_workers_ai_credentials
                    .iter()
                    .cloned()
                    .map(
                        |CloudflareCredentials {
                             account_id,
                             api_key,
                         }| {
                            Upstream::builder()
                        .url(
                            format!("https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/v1/chat/completions")
                                .parse()
                                .expect("TODO"),
                        )
                        .api_key(api_key)
                        .build()
                        },
                    )
                    .collect(),
                Provider::GoogleAiStudio => state
                    .app_args
                    .google_ai_studio_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url(
                                "https://generativelanguage.googleapis.com/v1beta/openai/v1/chat/completions"
                                    .parse()
                                    .expect("TODO"),
                            )
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::Cohere => state
                    .app_args
                    .cohere_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url(
                                "https://api.cohere.com/compatibility/v1/chat/completions"
                                    .parse()
                                    .expect("TODO"),
                            )
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::Groq => state
                    .app_args
                    .groq_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://api.groq.com/openai/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::HuggingFace => state
                    .app_args
                    .hugging_face_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://router.huggingface.co/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::Kilo => state
                    .app_args
                    .kilo_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://api.kilo.ai/api/gateway/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::Mistral => state
                    .app_args
                    .mistral_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://api.mistral.ai/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::NvidiaNim => state
                    .app_args
                    .nvidia_nim_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://integrate.api.nvidia.com/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::NovitaAi => state
                    .app_args
                    .novita_ai_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://api.novita.ai/openai/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::Ollama => state
                    .app_args
                    .ollama_cloud_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://ollama.com/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::OpenRouter => state
                    .app_args
                    .openrouter_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://openrouter.ai/api/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::OpenCode => state
                    .app_args
                    .opencode_console_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://opencode.ai/inference/openai/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::Poolside => state
                    .app_args
                    .poolside_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://inference.poolside.ai/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::VercelAiGateway => state
                    .app_args
                    .vercel_ai_gateway_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://ai-gateway.vercel.sh/v1/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::ZAi => state
                    .app_args
                    .z_ai_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://api.z.ai/api/paas/v4/chat/completions".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
            };
        if let Ok(upstreams) = Vec1::try_from(upstreams) {
            model_upstreams.push_back((model, upstreams));
        }
    }
    while let Some((model, upstreams)) = model_upstreams.pop_front() {
        let (upstream, upstreams) = take_random_by_swapping(upstreams, &mut rand::rng());
        if let Some(upstreams) = upstreams {
            model_upstreams.push_back((model.clone(), upstreams));
        }
        tracing::info!(?model, ?upstream);
        let openai::chat::completion::CreateChatCompletionRequest {
            model: _shortcut,
            messages,
            audio,
            frequency_penalty,
            function_call,
            functions,
            logit_bias,
            logprobs,
            max_completion_tokens,
            max_tokens,
            metadata,
            modalities,
            moderation,
            n,
            parallel_tool_calls,
            prediction,
            presence_penalty,
            prompt_cache_key,
            prompt_cache_options,
            prompt_cache_retention,
            reasoning_effort,
            response_format,
            safety_identifier,
            seed,
            service_tier,
            stop,
            store,
            stream,
            stream_options,
            temperature,
            tool_choice,
            tools,
            top_logprobs,
            top_p,
            user,
            verbosity,
            web_search_options,
        } = request.clone();
        let reasoning_effort = reasoning_effort.or(reasoning_in_id.clone());
        let request = openai::chat::completion::CreateChatCompletionRequest {
            model,
            messages,
            audio,
            frequency_penalty,
            function_call,
            functions,
            logit_bias,
            logprobs,
            max_completion_tokens,
            max_tokens,
            metadata,
            modalities,
            moderation,
            n,
            parallel_tool_calls,
            prediction,
            presence_penalty,
            prompt_cache_key,
            prompt_cache_options,
            prompt_cache_retention,
            reasoning_effort,
            response_format,
            safety_identifier,
            seed,
            service_tier,
            stop,
            store,
            stream,
            stream_options,
            temperature,
            tool_choice,
            tools,
            top_logprobs,
            top_p,
            user,
            verbosity,
            web_search_options,
        };
        let client = reqwest::Client::builder()
            .tls_certs_only(
                webpki_root_certs::TLS_SERVER_ROOT_CERTS
                    .iter()
                    .filter_map(|cert| Certificate::from_der(cert).ok()),
            )
            .build()
            .expect("TODO");
        let mut upstream_request = client.post(upstream.url).json(&request);
        if let Some(api_key) = upstream.api_key {
            let authorization =
                headers::Authorization::bearer(api_key.expose_secret()).expect("TODO");
            upstream_request = upstream_request.header(headers::Authorization::<Bearer>::name(), {
                let mut vec = vec![];
                authorization.encode(&mut vec);
                let [one] = vec.try_into().expect("TODO");
                one
            });
        }
        let upstream_response = select! {
            _ = sleep(Duration::from_secs(20)) => {
                tracing::error!("timed out");
                continue;
            }
            upstream_response_result = upstream_request.send() => {
                match upstream_response_result {
                    Ok(upstream_response) => upstream_response,
                    Err(upstream_error) => {
                        tracing::error!(?upstream_error);
                        continue;
                    }
                }
            }
        };
        if let Err(upstream_error) = upstream_response.error_for_status_ref() {
            tracing::error!(?upstream_error);
            match upstream_response.text().await {
                Ok(body) => tracing::error!(?body),
                Err(body_error) => tracing::error!(?body_error),
            };
            continue;
        };
        if request.stream.unwrap_or(false) {
            return Ok(ChatCompletionResponse::Stream(upstream_response));
        } else {
            let response = match upstream_response.json().await {
                Ok(response) => response,
                Err(json_error) => {
                    tracing::error!(?json_error);
                    continue;
                }
            };
            return Ok(ChatCompletionResponse::Immediate(response));
        }
    }
    Err(ChatCompletionError::NoneSucceeded)
 }
--- a/src/server/chat/mod.rs
+++ b/src/server/chat/mod.rs
@@ -0,0 +1 @@
 pub mod completions;
--- a/src/server/decisions.rs
+++ b/src/server/decisions.rs
@@ -0,0 +1,274 @@
 use crate::openai;
 use crate::server::AppState;
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::response::Response;
 use axum_extra::routing::TypedPath;
 use serde::Deserialize;
 use serde_with::DeserializeFromStr;
 use serde_with::SerializeDisplay;
 use std::collections::HashMap;
 use std::hash::RandomState;
 use strum::EnumString;
 use strum::VariantArray;
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/v1/decisions")]
 pub struct V1DecisionsPath;
 #[derive(
    Clone, Debug, EnumString, DeserializeFromStr, strum::Display, SerializeDisplay, VariantArray,
 )]
 #[strum(serialize_all = "lowercase")]
 pub enum Shortcut {
    S,
    M,
 }
 pub struct DecisionsResponse(openai::decisions::DecisionResponse<String>);
 impl IntoResponse for DecisionsResponse {
    fn into_response(self) -> Response {
        let Self(embeddings) = self;
        Json(embeddings).into_response()
    }
 }
 pub enum DecisionsError {
    NoneSucceeded,
 }
 impl IntoResponse for DecisionsError {
    fn into_response(self) -> Response {
        match self {
            DecisionsError::NoneSucceeded => StatusCode::SERVICE_UNAVAILABLE.into_response(),
        }
    }
 }
 #[tracing::instrument(skip(app_state, request))]
 pub async fn create_decision(
    _: V1DecisionsPath,
    State(app_state): State<AppState>,
    Json(request): Json<openai::decisions::DecisionRequest<Shortcut>>,
 ) -> Result<DecisionsResponse, DecisionsError> {
    use super::system_one;
    let openai::decisions::DecisionRequest {
        model,
        input,
        questions,
    } = request;
    let model = match model {
        Shortcut::S => system_one::Shortcut::S,
        Shortcut::M => system_one::Shortcut::M,
    };
    let (state, images, files) = match input {
        openai::decisions::DecisionInput::Messages(messages) => {
            let mut images = vec![];
            let mut texts = vec![];
            for openai::decisions::DecisionInputMessage { role, content } in messages {
                match content {
                    openai::decisions::DecisionInputContent::Text(text) => texts.push(text),
                    openai::decisions::DecisionInputContent::Parts(decision_input_parts) => {
                        for decision_input_part in decision_input_parts {
                            match decision_input_part {
                                openai::decisions::DecisionInputPart::Image {
                                    image_url,
                                    detail,
                                } => images.push(image_url),
                                openai::decisions::DecisionInputPart::Text { text } => {
                                    texts.push(text)
                                }
                            }
                        }
                    }
                }
            }
            let text = texts.join("\n\n");
            let files = images.clone();
            (
                openai::system_one::State::Text(text),
                Some(images),
                Some(files),
            )
        }
        openai::decisions::DecisionInput::Text(text) => {
            (openai::system_one::State::Text(text), None, None)
        }
    };
    let questions = questions
        .into_iter()
        .map(|question| match question {
            openai::decisions::DecisionQuestion::Predicate(
                openai::decisions::PredicateQuestion { name, instructions },
            ) => (
                name.expect("TODO"),
                openai::system_one::Question::Noul(openai::system_one::NoulQuestion {
                    instructions: openai::system_one::QuestionInstructions::Text(instructions),
                    criteria: None,
                }),
            ),
            openai::decisions::DecisionQuestion::Choice(openai::decisions::ChoiceQuestion {
                name,
                instructions,
                choices,
            }) => (
                name.expect("TODO"),
                openai::system_one::Question::Choice(openai::system_one::ChoiceQuestion {
                    instructions: openai::system_one::QuestionInstructions::Text(instructions),
                    criteria: choices
                        .into_iter()
                        .map(|openai::decisions::ChoiceOption { value, description }| {
                            (
                                match value {
                                    openai::decisions::Choice::String(s) => s,
                                    openai::decisions::Choice::Boolean(b) => b.to_string(),
                                },
                                description.map(|description| {
                                    openai::system_one::QuestionInstructions::Text(description)
                                }),
                            )
                        })
                        .collect(),
                }),
            ),
            openai::decisions::DecisionQuestion::Score(openai::decisions::ScoreQuestion {
                name,
                instructions,
                levels,
            }) => (
                name.expect("TODO"),
                openai::system_one::Question::Score(openai::system_one::ScoreQuestion {
                    instructions: openai::system_one::QuestionInstructions::Text(instructions),
                    criteria: levels
                        .into_iter()
                        .map(|openai::decisions::ScoreLevel { label, description }| {
                            openai::system_one::QuestionInstructions::Text(label)
                        })
                        .collect(),
                }),
            ),
        })
        .collect();
    let request = openai::system_one::SystemOneRequest {
        model,
        state,
        files,
        images,
        questions,
    };
    system_one::create_system_one(system_one::V1SystemOnePath, State(app_state), Json(request))
        .await
        .map(
            |system_one::SystemOneResponse(openai::system_one::SystemOneResponse {
                 model,
                 answers,
                 usage,
             })| {
                let answers = answers
                    .into_iter()
                    .map(|(id, answer)| match answer {
                        openai::system_one::Answer::Noul(openai::system_one::NoulAnswer {
                            noul,
                        }) => openai::decisions::DecisionAnswer::Predicate(
                            openai::decisions::PredicateAnswer {
                                name: Some(id),
                                probability: noul,
                            },
                        ),
                        openai::system_one::Answer::Choice(openai::system_one::ChoiceAnswer {
                            choice,
                            probabilities,
                            confidence,
                        }) => openai::decisions::DecisionAnswer::Choice(
                            openai::decisions::ChoiceAnswer {
                                name: Some(id),
                                choice: openai::decisions::Choice::String(choice),
                                confidence,
                                probabilities: probabilities
                                    .into_iter()
                                    .map(|(choice_id, probability)| {
                                        openai::decisions::ChoiceProbability {
                                            value: openai::decisions::Choice::String(choice_id),
                                            probability,
                                        }
                                    })
                                    .collect(),
                            },
                        ),
                        openai::system_one::Answer::Score(openai::system_one::ScoreAnswer {
                            score,
                            legend,
                            probabilities,
                            confidence,
                        }) => openai::decisions::DecisionAnswer::Score(
                            openai::decisions::ScoreAnswer {
                                name: Some(id),
                                score,
                                confidence,
                                probabilities: {
                                    probabilities
                                        .into_iter()
                                        .map(|(choice_id, probability)| {
                                            openai::decisions::ScoreProbability {
                                                value: choice_id
                                                    .parse()
                                                    .expect("it should be a number, I think"),
                                                label: legend
                                                    .get(&choice_id)
                                                    .expect("it should exist, I think")
                                                    .clone(),
                                                probability,
                                            }
                                        })
                                        .collect()
                                },
                            },
                        ),
                    })
                    .collect();
                let openai::system_one::Usage {
                    input_tokens,
                    output_tokens,
                } = usage;
                let input_tokens = input_tokens as i32;
                let output_tokens = output_tokens as i32;
                let total_tokens = input_tokens + output_tokens;
                let input_tokens_details = openai::decisions::TokenUsageDetails {
                    cache_write_tokens: 0,
                    cached_tokens: 0,
                };
                let output_tokens_details = openai::decisions::OutputTokenDetails {
                    reasoning_tokens: 0,
                };
                let usage = openai::decisions::TokenUsage {
                    input_tokens,
                    input_tokens_details,
                    output_tokens,
                    output_tokens_details,
                    total_tokens,
                };
                DecisionsResponse(openai::decisions::DecisionResponse {
                    model,
                    answers,
                    usage,
                })
            },
        )
        .map_err(|_| DecisionsError::NoneSucceeded)
 }
--- a/src/server/embeddings.rs
+++ b/src/server/embeddings.rs
@@ -0,0 +1,313 @@
 use crate::openai;
 use crate::server::AppState;
 use crate::server::Upstream;
 use crate::server::take_random_by_swapping;
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::response::Response;
 use axum_extra::routing::TypedPath;
 use ecow::EcoString;
 use headers::Header;
 use headers::authorization::Bearer;
 use mitsein::vec1::Vec1;
 use reqwest::Certificate;
 use secrecy::ExposeSecret;
 use serde::Deserialize;
 use serde_with::DeserializeFromStr;
 use serde_with::SerializeDisplay;
 use std::collections::VecDeque;
 use strum::EnumString;
 use strum::VariantArray;
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/v1/embeddings")]
 pub struct V1EmbeddingsPath;
 #[derive(
    Clone, Debug, EnumString, DeserializeFromStr, strum::Display, SerializeDisplay, VariantArray,
 )]
 #[strum(serialize_all = "lowercase")]
 pub enum Shortcut {
    #[strum(serialize = "codestral-embed-2505")]
    CodestralEmbed2505,
    #[strum(serialize = "cohere-embed-v4.0")]
    CohereEmbedV4_0,
    #[strum(serialize = "cohere-embed-v5.0-fast")]
    CohereEmbedV5_0Fast,
    #[strum(serialize = "cohere-embed-v5.0-pro")]
    CohereEmbedV5_0Pro,
    #[strum(serialize = "gemini-embedding-2")]
    GeminiEmbedding2,
    #[strum(serialize = "lfm2.5-embedding-350m")]
    Lfm2_5Embedding350M,
    #[strum(serialize = "mistral-embed-2312")]
    MistralEmbed2312,
    #[strum(serialize = "nemotron-3-embed-1b")]
    Nemotron3Embed1B,
 }
 #[derive(Debug, Clone)]
 enum Provider {
    Cohere,
    GoogleAiStudio,
    Mistral,
    NvidiaNim,
    OpenRouter,
    VercelAiGateway,
 }
 impl Shortcut {
    fn suggestions(&self) -> Vec<(Provider, EcoString)> {
        use Provider as P;
        use Shortcut as S;
        match self {
            S::CodestralEmbed2505 => vec![(P::Mistral, "codestral-embed-2505".into())],
            S::CohereEmbedV4_0 => vec![
                (P::Cohere, "embed-v4.0".into()),
                (P::VercelAiGateway, "cohere/embed-v4.0".into()),
            ],
            S::CohereEmbedV5_0Fast => vec![
                (P::Cohere, "embed-v5.0-fast".into()),
                (P::VercelAiGateway, "cohere/embed-v5.0-fast".into()),
            ],
            S::CohereEmbedV5_0Pro => vec![
                (P::Cohere, "embed-v5.0-pro".into()),
                (P::VercelAiGateway, "cohere/embed-v5.0-pro".into()),
            ],
            S::GeminiEmbedding2 => vec![(P::GoogleAiStudio, "gemini-embedding-2".into())],
            S::Lfm2_5Embedding350M => {
                vec![(P::OpenRouter, "liquid/lfm-2.5-embedding-350m:free".into())]
            }
            S::MistralEmbed2312 => vec![(P::Mistral, "mistral-embed-2312".into())],
            S::Nemotron3Embed1B => vec![
                (P::NvidiaNim, "nvidia/nemotron-3-embed-1b".into()),
                (P::OpenRouter, "nvidia/nemotron-3-embed-1b:free".into()),
            ],
        }
    }
 }
 pub struct EmbeddingsResponse(openai::embeddings::CreateEmbeddingResponse<String>);
 impl IntoResponse for EmbeddingsResponse {
    fn into_response(self) -> Response {
        let Self(embeddings) = self;
        Json(embeddings).into_response()
    }
 }
 pub enum EmbeddingsError {
    NoneSucceeded,
 }
 impl IntoResponse for EmbeddingsError {
    fn into_response(self) -> Response {
        match self {
            EmbeddingsError::NoneSucceeded => StatusCode::SERVICE_UNAVAILABLE.into_response(),
        }
    }
 }
 #[tracing::instrument(skip(state, request))]
 pub async fn create_embeddings(
    _: V1EmbeddingsPath,
    State(state): State<AppState>,
    Json(request): Json<openai::embeddings::CreateEmbeddingRequest<Shortcut>>,
 ) -> Result<EmbeddingsResponse, EmbeddingsError> {
    let shortcut = request.model.clone();
    let mut model_upstreams = VecDeque::new();
    for (provider, model) in shortcut.suggestions() {
        let upstreams: Vec<Upstream> = match provider {
            Provider::Cohere => state
                .app_args
                .cohere_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .url(
                            "https://api.cohere.com/compatibility/v1/embeddings"
                                .parse()
                                .expect("TODO"),
                        )
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::Mistral => state
                .app_args
                .mistral_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .url(
                            "https://api.mistral.ai/v1/embeddings"
                                .parse()
                                .expect("TODO"),
                        )
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::GoogleAiStudio => state
                .app_args
                .google_ai_studio_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .url(
                            "https://generativelanguage.googleapis.com/v1beta/openai/embeddings"
                                .parse()
                                .expect("TODO"),
                        )
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::NvidiaNim => state
                .app_args
                .nvidia_nim_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .url(
                            "https://integrate.api.nvidia.com/v1/embeddings"
                                .parse()
                                .expect("TODO"),
                        )
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::OpenRouter => state
                .app_args
                .openrouter_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .url(
                            "https://openrouter.ai/api/v1/embeddings"
                                .parse()
                                .expect("TODO"),
                        )
                        .api_key(api_key)
                        .build()
                })
                .collect(),
            Provider::VercelAiGateway => state
                .app_args
                .vercel_ai_gateway_api_key
                .iter()
                .cloned()
                .map(|api_key| {
                    Upstream::builder()
                        .url(
                            "https://ai-gateway.vercel.sh/v1/embeddings"
                                .parse()
                                .expect("TODO"),
                        )
                        .api_key(api_key)
                        .build()
                })
                .collect(),
        };
        if let Ok(upstreams) = Vec1::try_from(upstreams) {
            model_upstreams.push_back((model, upstreams));
        }
    }
    while let Some((model, upstreams)) = model_upstreams.pop_front() {
        let (upstream, upstreams) = take_random_by_swapping(upstreams, &mut rand::rng());
        if let Some(upstreams) = upstreams {
            model_upstreams.push_back((model.clone(), upstreams));
        }
        tracing::info!(?model, ?upstream);
        let openai::embeddings::CreateEmbeddingRequest {
            model: _shortcut,
            input,
            dimensions,
            encoding_format,
            user,
        } = request.clone();
        let request = openai::embeddings::CreateEmbeddingRequest {
            model,
            input,
            dimensions,
            encoding_format,
            user,
        };
        let client = reqwest::Client::builder()
            .tls_certs_only(
                webpki_root_certs::TLS_SERVER_ROOT_CERTS
                    .iter()
                    .filter_map(|cert| Certificate::from_der(cert).ok()),
            )
            .build()
            .expect("TODO");
        let mut upstream_request = client.post(upstream.url).json(&request);
        if let Some(api_key) = upstream.api_key {
            let authorization =
                headers::Authorization::bearer(api_key.expose_secret()).expect("TODO");
            upstream_request = upstream_request.header(headers::Authorization::<Bearer>::name(), {
                let mut vec = vec![];
                authorization.encode(&mut vec);
                let [one] = vec.try_into().expect("TODO");
                one
            });
        }
        let upstream_response = match upstream_request.send().await {
            Ok(upstream_response) => upstream_response,
            Err(upstream_error) => {
                tracing::error!(?upstream_error);
                continue;
            }
        };
        if let Err(upstream_error) = upstream_response.error_for_status_ref() {
            tracing::error!(?upstream_error);
            match upstream_response.text().await {
                Ok(body) => tracing::error!(?body),
                Err(body_error) => tracing::error!(?body_error),
            };
            continue;
        };
        let response = match upstream_response.json().await {
            Ok(response) => response,
            Err(json_error) => {
                tracing::error!(?json_error);
                continue;
            }
        };
        return Ok(EmbeddingsResponse(response));
    }
    Err(EmbeddingsError::NoneSucceeded)
 }
--- a/src/server/extraction.rs
+++ b/src/server/extraction.rs
@@ -0,0 +1,217 @@
 use crate::CloudflareCredentials;
 use crate::openai;
 use crate::server::AppState;
 use crate::server::Upstream;
 use crate::server::take_random_by_swapping;
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::response::Response;
 use axum_extra::routing::TypedPath;
 use ecow::EcoString;
 use headers::Header;
 use headers::authorization::Bearer;
 use mitsein::vec1::Vec1;
 use reqwest::Certificate;
 use secrecy::ExposeSecret;
 use serde::Deserialize;
 use serde_with::DeserializeFromStr;
 use serde_with::SerializeDisplay;
 use std::collections::VecDeque;
 use strum::EnumString;
 use strum::VariantArray;
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/v1/extraction")]
 pub struct V1ExtractionPath;
 #[derive(
    Clone, Debug, EnumString, DeserializeFromStr, strum::Display, SerializeDisplay, VariantArray,
 )]
 #[strum(serialize_all = "lowercase")]
 pub enum Shortcut {
    M,
 }
 #[derive(Debug, Clone)]
 enum Provider {
    Cloudflare,
 }
 impl Shortcut {
    fn suggestions(&self) -> Vec<(Provider, EcoString)> {
        use Provider as P;
        use Shortcut as S;
        match self {
            S::M => {
                vec![(P::Cloudflare, "@cf/cloudflare/clairic".into())]
            }
        }
    }
 }
 pub struct ExtractionResponse(pub openai::extraction::ExtractionResponse<String>);
 impl IntoResponse for ExtractionResponse {
    fn into_response(self) -> Response {
        let Self(extraction) = self;
        Json(extraction).into_response()
    }
 }
 pub enum ExtractionError {
    NoneSucceeded,
 }
 impl IntoResponse for ExtractionError {
    fn into_response(self) -> Response {
        match self {
            ExtractionError::NoneSucceeded => StatusCode::SERVICE_UNAVAILABLE.into_response(),
        }
    }
 }
 #[tracing::instrument(skip(state, request))]
 pub async fn create_extraction(
    _: V1ExtractionPath,
    State(state): State<AppState>,
    Json(request): Json<openai::extraction::ExtractionRequest<Shortcut>>,
 ) -> Result<ExtractionResponse, ExtractionError> {
    let shortcut = request.model.clone();
    let mut model_upstreams = VecDeque::new();
    for (provider, model) in shortcut.suggestions() {
        let upstreams: Vec<Upstream> =
            match provider {
                Provider::Cloudflare => state
                    .app_args
                    .cloudflare_workers_ai_credentials
                    .iter()
                    .cloned()
                    .map(
                        |CloudflareCredentials {
                             account_id,
                             api_key,
                         }| {
                            Upstream::builder()
                                .url(
                                    format!("https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/run/{model}")
                                        .parse()
                                        .expect("TODO"),
                                )
                                .api_key(api_key)
                                .build()
                        },
                    )
                    .collect(),
            };
        if let Ok(upstreams) = Vec1::try_from(upstreams) {
            model_upstreams.push_back((model, upstreams));
        }
    }
    while let Some((model, upstreams)) = model_upstreams.pop_front() {
        let (upstream, upstreams) = take_random_by_swapping(upstreams, &mut rand::rng());
        if let Some(upstreams) = upstreams {
            model_upstreams.push_back((model.clone(), upstreams));
        }
        tracing::info!(?model, ?upstream);
        let openai::extraction::ExtractionRequest {
            model: _shortcut,
            state,
            fields,
            images,
            reference_date,
            options,
        } = request.clone();
        let request = openai::extraction::ExtractionRequest {
            model,
            state,
            fields,
            images,
            reference_date,
            options,
        };
        let client = reqwest::Client::builder()
            .tls_certs_only(
                webpki_root_certs::TLS_SERVER_ROOT_CERTS
                    .iter()
                    .filter_map(|cert| Certificate::from_der(cert).ok()),
            )
            .build()
            .expect("TODO");
        let mut upstream_request = client.post(upstream.url).json(&request);
        if let Some(api_key) = upstream.api_key {
            let authorization =
                headers::Authorization::bearer(api_key.expose_secret()).expect("TODO");
            upstream_request = upstream_request.header(headers::Authorization::<Bearer>::name(), {
                let mut vec = vec![];
                authorization.encode(&mut vec);
                let [one] = vec.try_into().expect("TODO");
                one
            });
        }
        let upstream_response = match upstream_request.send().await {
            Ok(upstream_response) => upstream_response,
            Err(upstream_error) => {
                tracing::error!(?upstream_error);
                continue;
            }
        };
        if let Err(upstream_error) = upstream_response.error_for_status_ref() {
            tracing::error!(?upstream_error);
            match upstream_response.text().await {
                Ok(body) => tracing::error!(?body),
                Err(body_error) => tracing::error!(?body_error),
            };
            continue;
        };
        let response: serde_json::Value = match upstream_response.json().await {
            Ok(response) => response,
            Err(json_error) => {
                tracing::error!(?json_error);
                continue;
            }
        };
        match openai::extraction::ExtractionResponse::deserialize(
            response.clone(), // TODO: not need to clone
        ) {
            Ok(response) => return Ok(ExtractionResponse(response)),
            Err(structure_error) => {
                #[derive(Deserialize)]
                struct CloudflareRunResponse {
                    result: openai::extraction::ExtractionResponse<String>,
                    success: bool,
                    errors: Vec<serde_json::Value>,   // TODO
                    messages: Vec<serde_json::Value>, // TODO
                }
                match CloudflareRunResponse::deserialize(response) {
                    Ok(response) => return Ok(ExtractionResponse(response.result)),
                    Err(cloudflare_structure_error) => {
                        tracing::error!(?structure_error);
                        tracing::error!(?cloudflare_structure_error);
                    }
                }
            }
        }
    }
    Err(ExtractionError::NoneSucceeded)
 }
--- a/src/server/frontend/index.html
+++ b/src/server/frontend/index.html
@@ -0,0 +1,12 @@
 <!doctype html>
 <html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Basic Page</title>
  </head>
  <body>
    <h1>Hello, world!</h1>
    <p>This is a basic HTML page.</p>
  </body>
 </html>
--- a/src/server/frontend/mod.rs
+++ b/src/server/frontend/mod.rs
@@ -0,0 +1,11 @@
 use axum::response::Html;
 use axum_extra::routing::TypedPath;
 use serde::Deserialize;
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/")]
 pub struct IndexPath;
 pub async fn spa(_: IndexPath) -> Html<&'static str> {
    Html(include_str!("index.html"))
 }
--- a/src/server/mod.rs
+++ b/src/server/mod.rs
@@ -0,0 +1,59 @@
 use crate::AppArgs;
 use axum::Router;
 use axum_extra::routing::RouterExt;
 use mitsein::vec1::Vec1;
 use rand::Rng;
 use rand::RngExt;
 use secrecy::SecretString;
 use std::sync::Arc;
 use tower_http::cors::CorsLayer;
 use typed_builder::TypedBuilder;
 use url::Url;
 mod chat;
 mod decisions;
 mod embeddings;
 mod extraction;
 mod frontend;
 mod models;
 mod system_one;
 #[derive(Debug, Clone, TypedBuilder)]
 pub struct AppState {
    app_args: Arc<AppArgs>,
 }
 fn take_random_by_swapping<T>(mut vec1: Vec1<T>, mut rng: impl Rng) -> (T, Option<Vec1<T>>) {
    let end = vec1.len().get() - 1;
    let index = rng.random_range(0..=end);
    vec1.swap(index, end);
    let (body, element) = vec1.into_rtail_and_head();
    let body = body.try_into().ok();
    (element, body)
 }
 #[derive(Debug, TypedBuilder)]
 struct Upstream {
    url: Url,
    #[builder(setter(strip_option))]
    api_key: Option<SecretString>,
 }
 pub fn create_router() -> Router<AppState> {
    Router::new()
        .typed_post(chat::completions::create_chat_completion)
        .typed_post(decisions::create_decision)
        .typed_post(embeddings::create_embeddings)
        .typed_post(extraction::create_extraction)
        .typed_post(system_one::create_system_one)
        .typed_get(models::list_models)
        .typed_get(frontend::spa)
        .layer(CorsLayer::new())
 }
 pub fn create_app(state: AppState) -> Router<()> {
    create_router().with_state(state)
 }
--- a/src/server/models.rs
+++ b/src/server/models.rs
@@ -0,0 +1,36 @@
 use crate::openai;
 use axum::Json;
 use axum_extra::routing::TypedPath;
 use itertools::iproduct;
 use serde::Deserialize;
 use strum::VariantArray;
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/v1/models")]
 pub struct V1ModelsPath;
 #[tracing::instrument]
 pub async fn list_models(_: V1ModelsPath) -> Json<openai::models::ListModelsResponse<String>> {
    let shortcuts = super::chat::completions::Shortcut::VARIANTS.iter().cloned();
    let reasoning_efforts = openai::chat::completion::ReasoningEffort::VARIANTS
        .iter()
        .cloned()
        .map(Some)
        .chain(None);
    let models = iproduct!(shortcuts, reasoning_efforts).map(|(shortcut, reasoning)| {
        openai::models::Model {
            id: super::chat::completions::ShortcutAndMaybeReasoning(shortcut, reasoning)
                .to_string(),
            created: 0,
            object: openai::models::ModelObject::Model,
            owned_by: "nobody".into(),
            shutdown_date: None,
        }
    });
    Json(openai::models::ListModelsResponse {
        data: models.collect(),
        object: openai::models::ListObject::List,
    })
 }
--- a/src/server/system_one.rs
+++ b/src/server/system_one.rs
@@ -0,0 +1,294 @@
 use crate::CloudflareCredentials;
 use crate::openai;
 use crate::server::AppState;
 use crate::server::Upstream;
 use crate::server::take_random_by_swapping;
 use axum::Json;
 use axum::extract::State;
 use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::response::Response;
 use axum_extra::routing::TypedPath;
 use ecow::EcoString;
 use headers::Header;
 use headers::authorization::Bearer;
 use mitsein::vec1::Vec1;
 use reqwest::Certificate;
 use secrecy::ExposeSecret;
 use serde::Deserialize;
 use serde_with::DeserializeFromStr;
 use serde_with::SerializeDisplay;
 use std::collections::VecDeque;
 use strum::EnumString;
 use strum::VariantArray;
 #[derive(Deserialize, TypedPath)]
 #[typed_path("/v1/systemone")]
 pub struct V1SystemOnePath;
 #[derive(
    Clone, Debug, EnumString, DeserializeFromStr, strum::Display, SerializeDisplay, VariantArray,
 )]
 #[strum(serialize_all = "lowercase")]
 pub enum Shortcut {
    S,
    M,
    L,
 }
 #[derive(Debug, Clone)]
 enum Provider {
    CloudflareWorkersAi,
    LiquidAi,
    OpenCode,
    OpenRouter,
    VercelAiGateway,
 }
 impl Shortcut {
    fn suggestions(&self) -> Vec<(Provider, EcoString)> {
        use Provider as P;
        use Shortcut as S;
        match self {
            S::S => {
                vec![
                    (
                        P::VercelAiGateway,
                        "perplexity/pplx-decider-flash-v1.2".into(),
                    ),
                    (P::LiquidAi, "d1:free".into()),
                    (P::CloudflareWorkersAi, "clef-omni".into()),
                    (P::CloudflareWorkersAi, "clef-flash".into()),
                    (P::OpenRouter, "respan/span-01-lite:free".into()),
                    (P::OpenRouter, "respan/span-01-lite".into()),
                    (P::VercelAiGateway, "convaiinnovations/laya-free".into()),
                    (P::VercelAiGateway, "convaiinnovations/laya".into()),
                ]
            }
            S::M => {
                vec![
                    (P::OpenCode, "jev-1.13-free".into()),
                    (P::VercelAiGateway, "perplexity/pplx-decider-v1.2".into()),
                    (P::CloudflareWorkersAi, "clef".into()),
                    (P::OpenRouter, "inception/mercury-decide:free".into()),
                ]
            }
            S::L => {
                vec![(P::VercelAiGateway, "liquid/d1-ultra".into())]
            }
        }
    }
 }
 pub struct SystemOneResponse(pub openai::system_one::SystemOneResponse<String>);
 impl IntoResponse for SystemOneResponse {
    fn into_response(self) -> Response {
        let Self(system_one) = self;
        Json(system_one).into_response()
    }
 }
 pub enum SystemOneError {
    NoneSucceeded,
 }
 impl IntoResponse for SystemOneError {
    fn into_response(self) -> Response {
        match self {
            SystemOneError::NoneSucceeded => StatusCode::SERVICE_UNAVAILABLE.into_response(),
        }
    }
 }
 #[tracing::instrument(skip(state, request))]
 pub async fn create_system_one(
    _: V1SystemOnePath,
    State(state): State<AppState>,
    Json(request): Json<openai::system_one::SystemOneRequest<Shortcut>>,
 ) -> Result<SystemOneResponse, SystemOneError> {
    let shortcut = request.model.clone();
    let mut model_upstreams = VecDeque::new();
    for (provider, model) in shortcut.suggestions() {
        let upstreams: Vec<Upstream> =
            match provider {
                Provider::CloudflareWorkersAi => state
                    .app_args
                    .cloudflare_workers_ai_credentials
                    .iter()
                    .cloned()
                    .map(
                        |CloudflareCredentials {
                             account_id,
                             api_key,
                         }| {
                            Upstream::builder()
                                .url(
                                    format!("https://api.cloudflare.com/client/v4/accounts/{account_id}/ai/run/@cf/cloudflare/{model}")
                                        .parse()
                                        .expect("TODO"),
                                )
                                .api_key(api_key)
                                .build()
                        },
                    )
                    .collect(),
                Provider::LiquidAi => state
                    .app_args
                    .liquid_ai_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://api.liquid.ai/decisions/v1/systemone".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::OpenCode => state
                    .app_args
                    .opencode_console_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://opencode.ai/inference/systemone/v1/systemone".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::OpenRouter => state
                    .app_args
                    .openrouter_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://openrouter.ai/api/v1/systemone".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
                Provider::VercelAiGateway => state
                    .app_args
                    .vercel_ai_gateway_api_key
                    .iter()
                    .cloned()
                    .map(|api_key| {
                        Upstream::builder()
                            .url("https://ai-gateway.vercel.sh/typesafe/v1/systemone".parse().expect("TODO"))
                            .api_key(api_key)
                            .build()
                    })
                    .collect(),
            };
        if let Ok(upstreams) = Vec1::try_from(upstreams) {
            model_upstreams.push_back((model, upstreams));
        }
    }
    while let Some((model, upstreams)) = model_upstreams.pop_front() {
        let (upstream, upstreams) = take_random_by_swapping(upstreams, &mut rand::rng());
        if let Some(upstreams) = upstreams {
            model_upstreams.push_back((model.clone(), upstreams));
        }
        tracing::info!(?model, ?upstream);
        let openai::system_one::SystemOneRequest {
            model: _shortcut,
            state,
            files,
            images,
            questions,
        } = request.clone();
        let request = openai::system_one::SystemOneRequest {
            model,
            state,
            files,
            images,
            questions,
        };
        let client = reqwest::Client::builder()
            .tls_certs_only(
                webpki_root_certs::TLS_SERVER_ROOT_CERTS
                    .iter()
                    .filter_map(|cert| Certificate::from_der(cert).ok()),
            )
            .build()
            .expect("TODO");
        let mut upstream_request = client.post(upstream.url).json(&request);
        if let Some(api_key) = upstream.api_key {
            let authorization =
                headers::Authorization::bearer(api_key.expose_secret()).expect("TODO");
            upstream_request = upstream_request.header(headers::Authorization::<Bearer>::name(), {
                let mut vec = vec![];
                authorization.encode(&mut vec);
                let [one] = vec.try_into().expect("TODO");
                one
            });
        }
        let upstream_response = match upstream_request.send().await {
            Ok(upstream_response) => upstream_response,
            Err(upstream_error) => {
                tracing::error!(?upstream_error);
                continue;
            }
        };
        if let Err(upstream_error) = upstream_response.error_for_status_ref() {
            tracing::error!(?upstream_error);
            match upstream_response.text().await {
                Ok(body) => tracing::error!(?body),
                Err(body_error) => tracing::error!(?body_error),
            };
            continue;
        };
        let response: serde_json::Value = match upstream_response.json().await {
            Ok(response) => response,
            Err(json_error) => {
                tracing::error!(?json_error);
                continue;
            }
        };
        match openai::system_one::SystemOneResponse::deserialize(
            response.clone(), // TODO: not need to clone
        ) {
            Ok(response) => return Ok(SystemOneResponse(response)),
            Err(structure_error) => {
                #[derive(Deserialize)]
                struct CloudflareRunResponse {
                    result: openai::system_one::SystemOneResponse<String>,
                    success: bool,
                    errors: Vec<serde_json::Value>,   // TODO
                    messages: Vec<serde_json::Value>, // TODO
                }
                match CloudflareRunResponse::deserialize(response) {
                    Ok(response) => return Ok(SystemOneResponse(response.result)),
                    Err(cloudflare_structure_error) => {
                        tracing::error!(?structure_error);
                        tracing::error!(?cloudflare_structure_error);
                    }
                }
            }
        }
    }
    Err(SystemOneError::NoneSucceeded)
 }
Author	SHA1	Message	Date
Jacob	7f1290a86a	feat: extraction models	2026-10-24 16:18:32 -04:00
Jacob	566cc56896	chore: extraction model api (no proxying implemented yet)	2026-10-24 02:33:31 -04:00
Jacob	302496c12c	feat: timeout	2026-10-24 01:57:21 -04:00
Jacob	1b0ca23448	feat: add cloudflare as a provider for deepseek v4.1 flash 1017	2026-10-24 01:12:06 -04:00
Jacob	94803c699a	feat: nemotron 3 ultra on openrouter free	2026-10-19 16:19:57 -04:00
Jacob	bc0223539c	chore: remove no longer available (or free) ling 3.0 openrouter models	2026-10-19 16:18:03 -04:00
Jacob	69789fbd87	fix: remove models on novita that are no longer free	2026-10-19 16:16:10 -04:00
Jacob	5dedf5fa07	feat: more models	2026-10-19 16:12:49 -04:00
Jacob	b9daf9d6bf	feat: poolside	2026-10-19 15:59:24 -04:00
Jacob	d11c2d2589	feat: cohere + more models	2026-10-19 15:56:06 -04:00
Jacob	94a9594130	chore: move glm 5.3 flash above step 5 preview	2026-10-18 15:35:29 -04:00
Jacob	692a1a56a7	feat: frontend routes (just the index html file for now)	2026-10-18 15:31:19 -04:00
Jacob	3be16d3d58	feat: opencode console support	2026-10-16 19:05:02 -04:00
J / Jacob Babich	6e3a283d81	feat: ollama cloud support	2026-10-16 12:57:27 -04:00
Jacob	e74b5f6a4b	feat: kilo gateway	2026-10-15 14:40:14 -04:00
J / Jacob Babich	831b6f568b	feat+fix: add huggingface as a provider for ling 3.1 flash and remove openrouter now that it's no longer free on there	2026-10-15 14:09:57 -04:00
J / Jacob Babich	12eb6f2aee	feat: new models	2026-10-15 13:49:18 -04:00
J / Jacob Babich	59e9d3648a	chore: move groq to the top of its available models	2026-10-15 13:43:40 -04:00
Jacob	f4f657c219	feat: novita, nvidia nim, vercel ai gateway	2026-10-13 23:37:24 -04:00
Jacob	a0d95d52e4	fix: decisions from system one correctly	2026-10-13 21:25:25 -04:00
Jacob	f778fae70c	fix: parse cloudflare run results	2026-10-10 20:15:25 -04:00
Jacob	c88874948a	fix: correct cloudflare system one url	2026-10-10 19:28:15 -04:00
Jacob	154cbac120	feat: finish implementation of decisions -> system one	2026-10-10 19:23:40 -04:00
Jacob	e0e1f0781e	feat: more models, make decisions a wrapper for system one	2026-10-10 19:06:02 -04:00
Jacob	9a848e2c78	feat: LiquidAI and decisions and system one implementations	2026-10-09 22:58:34 -04:00
Jacob	8452bb9088	chore: remove unused types	2026-10-09 02:53:57 -04:00
Jacob	d869809768	chore: system one api types	2026-10-09 02:45:29 -04:00
Jacob	0a111172f5	feat: openai decisions types	2026-10-09 02:28:26 -04:00
Jacob	f2108ae35a	feat: z.ai + more models	2026-10-09 02:19:53 -04:00
Jacob	9dd13f374f	feat: implement embeddings	2026-10-09 01:52:29 -04:00
Jacob	226e0fb0ff	chore: make some stuff in embeddings less stringly typed	2026-10-09 01:02:44 -04:00
Jacob	da04b5dd62	feat: add qwen3.6 35b-a3b as an xs model	2026-10-09 00:48:52 -04:00
J / Jacob Babich	ff621d759c	chore: groundwork for embeddings	2026-10-08 22:58:07 -04:00
Jacob	0521a264dc	chore: more	2026-10-08 01:48:13 -04:00
Jacob	5ce36e3b8c	feat: stuff	2026-10-08 01:24:23 -04:00
Jacob	e161693587	chore: update default reasoning levels and slightly update shortcut model lists	2026-09-30 02:51:15 -04:00
Jacob	0974f640bb	feat: specify reasoning effort in model ID, or use a default	2026-09-30 02:34:36 -04:00
Jacob	91ac1145ce	chore: rename project to Katniss AI	2026-09-30 01:43:17 -04:00
Jacob	f0e8516d7a	feat: implement models endpoint	2026-09-30 00:56:09 -04:00
Jacob	c6c0849cf5	fix: use correct webpki roots crate	2026-09-30 00:25:36 -04:00
Jacob	7b3ac7acbb	chore: improve default tracing directives	2026-09-30 00:03:15 -04:00
Jacob	e49befb03f	fix: use webpki roots	2026-09-30 00:02:30 -04:00