open-standards/eoc/eoc-rs/crates/eoc-streaming/src/error.rs
Transaction Science 7ef14c2ea9 ingest wave B: 3 crates · op-payouts + smart-byte-nostr + eoc-streaming
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]>
2026-05-24 13:39:09 -04:00

58 lines
1.5 KiB
Rust

//! Typed errors for streaming primitives.
use thiserror::Error;
/// Errors emitted while parsing, transporting, or accounting a stream.
#[derive(Debug, Error)]
pub enum StreamError {
/// SSE / WS framing was malformed.
#[error("framing error: {0}")]
Framing(String),
/// JSON deserialization of an event payload failed.
#[error("parse error: {0}")]
Parse(String),
/// An unknown provider event type was observed.
#[error("unknown event: {0}")]
UnknownEvent(String),
/// The stream was cancelled.
#[error("stream cancelled")]
Cancelled,
/// The sink's bounded channel is closed.
#[error("sink closed")]
Closed,
/// The sink rejected a send because of backpressure (non-blocking path).
#[error("sink full (backpressure)")]
Backpressure,
/// The requested `Last-Event-ID` is no longer in the replay window.
#[error("event {0} no longer resumable")]
ResumeOutOfRange(String),
/// The joule meter could not be read.
#[error("meter error: {0}")]
Meter(String),
/// Generic backend / I/O.
#[error("backend error: {0}")]
Backend(String),
}
/// Convenience alias.
pub type StreamResult<T> = std::result::Result<T, StreamError>;
impl From<serde_json::Error> for StreamError {
fn from(e: serde_json::Error) -> Self {
StreamError::Parse(e.to_string())
}
}
impl From<eoc_core::Error> for StreamError {
fn from(e: eoc_core::Error) -> Self {
StreamError::Backend(e.to_string())
}
}