7ef14c2ea9
OpenPay (1 crate, 2174 LOC, 14 tests)
op-payouts Multi-rail payout engine. Visa Direct, Mastercard Send,
ACH credits (NACHA), Fedwire + SWIFT MT103 + ISO 20022
pacs.008, SEPA SCT + SCT Inst (mod-97 IBAN), UK FPS,
FedNow, RTP, PayPal, Wise. Crypto: USDC/USDT on
ETH/Polygon/Base/Solana + BTC + Lightning with real
ERC-20 transfer(address,uint256) calldata. Offline-pure
drivers (emit wire payloads — operators transmit).
Smart Byte (1 crate, 2605 LOC, 38 tests)
smart-byte-nostr Nostr adapter. NIP-01 canonical event id + BIP-340
Schnorr sign/verify; from-scratch bech32 + NIP-19 TLV
(npub/nsec/note/nprofile/nevent/nrelay); NIP-04 legacy
AES-256-CBC DMs; NIP-44 v2 HKDF-SHA256→ChaCha20+HMAC
with bucketed padding; NIP-17 gift-wrap (kind 1059) +
seal (kind 13) + rumor (kind 14); NIP-05/11/13/26/65.
Relay client message vocabulary (REQ/EVENT/CLOSE/AUTH/
EOSE/OK/NOTICE/CLOSED) + in-memory router.
EOC (1 crate, 2024 LOC, 30 tests)
eoc-streaming Token-by-token + tool-call streaming primitives.
SSE framing (data: lines); Anthropic event mapper
(message_start/content_block_*/message_delta/stop/ping);
OpenAI delta mapper; Vercel AI SDK mapper. Bounded-channel
backpressure with watermarks; CancelToken propagation;
Last-Event-ID resumable streams; per-stream joule meter.
Co-Authored-By: Claude Opus 4.7 <[email protected]>
114 lines
3 KiB
Rust
114 lines
3 KiB
Rust
//! Anthropic SSE → normalized event mapping.
|
|
|
|
use eoc_streaming::anthropic::AnthropicMapper;
|
|
use eoc_streaming::sse::SseEvent;
|
|
use eoc_streaming::stream::{Event, FinishReason, Role};
|
|
|
|
fn sse(event: &str, data: &str) -> SseEvent {
|
|
SseEvent {
|
|
event: event.into(),
|
|
data: data.into(),
|
|
id: None,
|
|
retry_ms: None,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn full_text_message_lifecycle() {
|
|
let m = AnthropicMapper;
|
|
let frames = vec![
|
|
sse(
|
|
"message_start",
|
|
r#"{"message":{"id":"msg_01","role":"assistant"}}"#,
|
|
),
|
|
sse(
|
|
"content_block_start",
|
|
r#"{"index":0,"content_block":{"type":"text"}}"#,
|
|
),
|
|
sse(
|
|
"content_block_delta",
|
|
r#"{"index":0,"delta":{"type":"text_delta","text":"Hel"}}"#,
|
|
),
|
|
sse(
|
|
"content_block_delta",
|
|
r#"{"index":0,"delta":{"type":"text_delta","text":"lo"}}"#,
|
|
),
|
|
sse("content_block_stop", r#"{"index":0}"#),
|
|
sse(
|
|
"message_delta",
|
|
r#"{"delta":{"stop_reason":"end_turn"}}"#,
|
|
),
|
|
sse("message_stop", r#"{}"#),
|
|
];
|
|
|
|
let mut events: Vec<Event> = Vec::new();
|
|
for f in frames.iter() {
|
|
events.extend(m.map(f).expect("map"));
|
|
}
|
|
|
|
assert!(matches!(
|
|
events[0],
|
|
Event::MessageStart {
|
|
role: Role::Assistant,
|
|
..
|
|
}
|
|
));
|
|
let text: String = events
|
|
.iter()
|
|
.filter_map(|e| match e {
|
|
Event::TextDelta { delta, .. } => Some(delta.as_str()),
|
|
_ => None,
|
|
})
|
|
.collect();
|
|
assert_eq!(text, "Hello");
|
|
assert!(events.iter().any(|e| matches!(e, Event::ContentBlockStop { .. })));
|
|
assert!(events.iter().any(|e| matches!(
|
|
e,
|
|
Event::MessageDelta {
|
|
stop_reason: Some(FinishReason::EndTurn)
|
|
}
|
|
)));
|
|
assert!(events.iter().any(|e| matches!(e, Event::MessageStop { .. })));
|
|
}
|
|
|
|
#[test]
|
|
fn tool_use_block_emits_start_and_arg_deltas() {
|
|
let m = AnthropicMapper;
|
|
let start = sse(
|
|
"content_block_start",
|
|
r#"{"index":1,"content_block":{"type":"tool_use","id":"tool_01","name":"calc"}}"#,
|
|
);
|
|
let delta = sse(
|
|
"content_block_delta",
|
|
r#"{"index":1,"delta":{"type":"input_json_delta","partial_json":"{\"x\":"}}"#,
|
|
);
|
|
let out: Vec<Event> = m
|
|
.map(&start)
|
|
.unwrap()
|
|
.into_iter()
|
|
.chain(m.map(&delta).unwrap())
|
|
.collect();
|
|
assert!(matches!(
|
|
out[0],
|
|
Event::ToolCallStart { ref name, .. } if name == "calc"
|
|
));
|
|
assert!(matches!(out[1], Event::ToolCallDelta { .. }));
|
|
}
|
|
|
|
#[test]
|
|
fn ping_passes_through() {
|
|
let m = AnthropicMapper;
|
|
let ev = sse("ping", "{}");
|
|
assert_eq!(m.map(&ev).unwrap(), vec![Event::Ping]);
|
|
}
|
|
|
|
#[test]
|
|
fn unknown_event_errors() {
|
|
let m = AnthropicMapper;
|
|
let ev = sse("brand_new_event", "{}");
|
|
let err = m.map(&ev).unwrap_err();
|
|
assert!(matches!(
|
|
err,
|
|
eoc_streaming::error::StreamError::UnknownEvent(_)
|
|
));
|
|
}
|