brazen 0.0.20

A stateless, swiss-army-knife adapter for every LLM provider and protocol.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! The `anthropic_messages` Protocol impl (anthropic-messages spec). `encode`
//! projects a `CanonicalRequest` onto `POST /v1/messages` (body + non-auth
//! headers); `decode` is a pure `(frame, &mut DecodeState)` state machine over the
//! SSE stream, dispatching on `data.type`. No IO, no clock, no creds — all
//! cross-frame state lives in the caller-owned `DecodeState`, so `&AnthropicMessages`
//! is shareable as `&'static dyn Protocol`. Vendor-blind: it reads only
//! `ProviderCtx`, never the string `"anthropic"` (that was spent on the lookup).
//! The two directions split across `encode`/`decode` so each file stays small.

mod decode;
mod encode;

use crate::canonical::{CanonicalError, CanonicalRequest, Event};
use crate::protocol::{
    Collection, CountRequest, DecodeState, Frame, Framing, Method, ModelKeys, ModelsShape,
    Protocol, ProviderCtx, Shapes, Tuning, WireRequest,
};

/// The one shared, stateless instance (arch §4.4) — registered as `&'static dyn`.
pub struct AnthropicMessages;

impl Protocol for AnthropicMessages {
    fn encode(
        &self,
        req: &CanonicalRequest,
        ctx: &ProviderCtx,
    ) -> Result<WireRequest, CanonicalError> {
        encode::encode(req, ctx)
    }

    fn path(&self, _ctx: &ProviderCtx) -> String {
        encode::REQUEST_PATH.to_string()
    }

    fn content_type(&self) -> &str {
        "application/json"
    }

    fn decode(&self, frame: Frame, state: &mut DecodeState) -> Result<Vec<Event>, CanonicalError> {
        decode::decode(frame, state)
    }

    fn decode_full(
        &self,
        body: &[u8],
        state: &mut DecodeState,
    ) -> Result<Vec<Event>, CanonicalError> {
        decode::decode_full(body, state)
    }

    fn framing(&self) -> Framing {
        Framing::Sse
    }

    /// both: `thinking.budget_tokens` and the asymmetric `service_tier` pair (providers §6, §6.2).
    fn tuning(&self) -> Tuning {
        Tuning {
            effort: true,
            budget: true,
            priority: true,
            image: false,
        }
    }

    fn shapes(&self) -> Shapes {
        // `tools`/`tool_choice` and a `messages` transcript of alternating turns
        // (anthropic-messages §3) — the row a tool-bearing or replayed session takes.
        Shapes {
            tools: true,
            multi_turn: true,
        }
    }

    fn models_shape(&self) -> Option<ModelsShape> {
        // `data[].id` (newest-first), as-is; base is bare (no /v1) so the path
        // carries it, unlike openai_chat (§3.1). Anthropic's list serves `display_name`
        // (and `created_at`, unlifted) but NO token limits, so only the label is carried
        // — the rest stay `None` (§3, empty-set rule).
        Some(ModelsShape {
            method: Method::Get,
            path: "/v1/models",
            keys: ModelKeys {
                collection: Collection::Array {
                    key: "data",
                    id_key: "id",
                },
                strip: "",
                context_key: "",
                max_output_key: "",
                display_name_key: "display_name",
                default_key: "",
            },
        })
    }

    fn count_tokens(
        &self,
        req: &CanonicalRequest,
        ctx: &ProviderCtx,
    ) -> Option<Result<CountRequest, CanonicalError>> {
        // `POST /v1/messages/count_tokens`, response `{"input_tokens": N}` (§2.11).
        Some(encode::count_body(req, ctx).map(|wire| CountRequest {
            wire,
            token_key: "input_tokens",
        }))
    }
}