Struct HttpStreamingTool 

pub struct HttpStreamingTool { /* private fields */ }

HTTP tool with first-class streaming surface (Fase 34.e).

stream() drives a reqwest::Client::post(url) async request + drains response.bytes_stream() chunk-by-chunk. Content-Type header decides framing:

• text/event-stream → SSE per W3C spec. Each data: field from a complete SSE event emits as a ToolChunk::intermediate. event: / id: / retry: fields are dropped (the adopter sees only the data payload — the framing was for HTTP transport).
• application/x-ndjson / application/jsonl → one ToolChunk::intermediate per LF-delimited line. Empty lines are skipped.
• Other (application/json, text/plain, raw bytes) → single ToolChunk::intermediate with the full body accumulated, then a terminator. This is the D9 backwards-compat path for non-streaming HTTP endpoints — the same response shape dispatch_http returns synchronously, projected onto the single-chunk streaming surface.

Cancel discipline (D5)

ctx.cancel is polled between every bytes_stream().next().await boundary. When fired, the stream drops the reqwest::Response (closing the connection) + emits a single ToolFinishReason::Cancelled terminator chunk. Wall-clock budget is bounded by the network roundtrip latency to the next chunk arrival (typically ≤100ms for SSE streams with regular keepalive).

Error discipline

Every failure surface (URL invalid / client build / connect / timeout / non-2xx status / mid-stream byte error / I/O error) is captured as a ToolFinishReason::Error { message } terminator chunk — the consumer never sees a panic or a silently-truncated stream.

Implementations

impl HttpStreamingTool

pub fn from_entry(entry: &ToolEntry) -> Result<Self, String>

Construct from a registry ToolEntry. Validates the URL + extracts the timeout. Returns Err with adopter-facing diagnostic when the URL is missing or has an invalid scheme.

pub fn new(name: String, url: String, timeout: Duration) -> Self

Public new() ctor for tests + adopters who construct directly without a registry entry.

Trait Implementations

impl Tool for HttpStreamingTool

fn execute<'life0, 'async_trait>( &'life0 self, args: String, _ctx: ToolContext, ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute the tool synchronously. Returns a single materialized ToolResult. EVERY tool MUST implement this method (no default — there’s no sensible default execute).

fn stream<'life0, 'async_trait>( &'life0 self, args: String, ctx: ToolContext, ) -> Pin<Box<dyn Future<Output = ToolStream> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stream the tool’s output as a sequence of ToolChunks.

fn is_streaming(&self) -> bool

Whether this tool is a stream producer. Default: false.