Enum EffectKind 

pub enum EffectKind {
    Completion {
        request: CompletionRequest,
        stream: bool,
    },
    ToolCall {
        name: String,
        args: String,
    },
    Embed {
        inputs: EmbedInputs,
    },
    Rerank {
        request: RerankRequest,
    },
    Memory {
        op: MemoryOp,
    },
    Retrieve {
        query: RetrieveQuery,
    },
    Custom {
        kind: Arc<str>,
        payload: Value,
    },
}

One effect: what a handler is asked to do.

Variants

Completion

A completion request.

Fields

request: CompletionRequest

The prepared request.

stream: bool

Whether the response streams (dispatch_stream) or is unary.

ToolCall

A tool call. The context the tool runs with is not on the wire: see ToolCallRequest.

Fields

name: String

The tool’s name.

args: String

The raw JSON arguments as the model produced them.

Embed

An embedding request.

Fields

inputs: EmbedInputs

The inputs to embed.

Rerank

A reranking request.

Fields

request: RerankRequest

The query and the documents.

Memory

A conversation-memory operation.

Fields

op: MemoryOp

The operation.

Retrieve

A retrieval.

Fields

query: RetrieveQuery

The query.

Custom

An out-of-tree effect.

Fields

kind: Arc<str>

The host-defined kind label.

payload: Value

The host-defined payload.

Implementations

impl EffectKind

pub const fn family(&self) -> EffectFamily

The family of this effect.

pub fn name(&self) -> &str

Classification label without payload data. Custom effects return their host-defined kind label.

pub const fn streams(&self) -> bool

Whether this effect answers as a stream. Only a streaming completion does; every other kind is unary.

Trait Implementations

impl Clone for EffectKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EffectKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EffectKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EffectKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.