Struct ProgressParams 

pub struct ProgressParams {
    pub channel: Uri,
    pub progress_token: String,
    pub progress: i64,
    pub total: Option<i64>,
    pub message: Option<String>,
}

Generic progress notification for a long-running operation.

A client opts in to progress for a request by including a progressToken in that request (today: the progressToken field on createSession). If the server does long-running work to service the request — e.g. lazily downloading an agent’s native SDK the first time a session of that provider is materialized — it emits progress notifications carrying the same token.

The notification is operation-agnostic: it says nothing about what is progressing. The client correlates progressToken back to the request it originated from (and thus the UI surface awaiting it) and renders its own localized indicator. The same channel serves any future long-running operation without a new method.

Semantics:

• progress is monotonically non-decreasing for a given progressToken.
• total is present only when the server knows the magnitude up front (e.g. a Content-Length); when absent the client SHOULD show an indeterminate indicator.
• The operation is complete when progress === total. The server MUST emit a final frame satisfying progress === total; when the total was never known, it sets total to the final progress on that frame. No further frames reference the token afterwards.
• The server MAY emit no progress at all (e.g. the work was already done); the client then never shows an indicator.
• Like all notifications this is ephemeral and is not replayed on reconnect. A client that never receives the terminal frame SHOULD expire the indicator after an idle timeout.

Fields

channel: Uri

Channel URI this notification belongs to (the root channel).

progress_token: String

Echoes the progressToken the client supplied on the originating request (e.g. the progressToken field of createSession), correlating this frame to that call. Unique across the client’s active requests.

progress: i64

Progress so far, in operation-defined units (e.g. bytes received). Monotonically non-decreasing for a given progressToken.

total: Option<i64>

Total when known up front (e.g. from a Content-Length); omitted ⇒ indeterminate. The operation is complete once progress === total.

message: Option<String>

Optional human-readable progress message. The client owns its own (localized) presentation derived from the originating request; generic clients that don’t track the token MAY display this instead.

Trait Implementations

impl Clone for ProgressParams

fn clone(&self) -> ProgressParams

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ProgressParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProgressParams

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProgressParams

fn eq(&self, other: &ProgressParams) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ProgressParams

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ProgressParams