Enum MessageBlock 

pub enum MessageBlock {
    Text(String),
    Code {
        code: String,
        language: Option<String>,
    },
    ToolUse {
        name: String,
        input: Option<String>,
        output: Option<String>,
    },
    Thinking(String),
    Error(String),
}

A block of content within a conversation message.

Messages are composed of one or more blocks, each representing a different type of content (text, code, tool use, etc.).

Variants

Text(String)

Plain text content.

Code

A code block with optional language identifier.

Fields

code: String

The code content.

language: Option<String>

Optional programming language for syntax indication.

ToolUse

A tool/function use block.

Fields

name: String

The name of the tool being invoked.

input: Option<String>

A textual representation of the tool input, if any.

output: Option<String>

A textual representation of the tool output, if any.

Thinking(String)

A thinking/reasoning block (e.g., chain-of-thought).

Error(String)

An error block.

Implementations

impl MessageBlock

pub fn text(content: impl Into<String>) -> Self

Creates a text block.

Example

use envision::component::MessageBlock;

let block = MessageBlock::text("Hello, world!");
assert!(matches!(block, MessageBlock::Text(ref s) if s == "Hello, world!"));

pub fn code(code: impl Into<String>, language: Option<&str>) -> Self

Creates a code block with a language.

Example

use envision::component::MessageBlock;

let block = MessageBlock::code("fn main() {}", Some("rust"));
if let MessageBlock::Code { code, language } = &block {
    assert_eq!(code, "fn main() {}");
    assert_eq!(language.as_deref(), Some("rust"));
}

pub fn tool_use(name: impl Into<String>) -> Self

Creates a tool use block with only a name.

Use with_input and with_output to attach input and output data via the builder pattern.

Example

use envision::component::MessageBlock;

let block = MessageBlock::tool_use("search");
if let MessageBlock::ToolUse { name, input, output } = &block {
    assert_eq!(name, "search");
    assert!(input.is_none());
    assert!(output.is_none());
}

pub fn with_input(self, input: impl Into<String>) -> Self

Sets the input for a tool use block (builder pattern).

Has no effect on non-ToolUse variants.

Example

use envision::component::MessageBlock;

let block = MessageBlock::tool_use("search")
    .with_input("query: rust TUI");
if let MessageBlock::ToolUse { name, input, .. } = &block {
    assert_eq!(name, "search");
    assert_eq!(input.as_deref(), Some("query: rust TUI"));
}

pub fn with_output(self, output: impl Into<String>) -> Self

Sets the output for a tool use block (builder pattern).

Has no effect on non-ToolUse variants.

Example

use envision::component::MessageBlock;

let block = MessageBlock::tool_use("search")
    .with_input("query: rust TUI")
    .with_output("Found 5 results");
if let MessageBlock::ToolUse { name, input, output } = &block {
    assert_eq!(name, "search");
    assert_eq!(input.as_deref(), Some("query: rust TUI"));
    assert_eq!(output.as_deref(), Some("Found 5 results"));
}

pub fn thinking(content: impl Into<String>) -> Self

Creates a thinking block.

Example

use envision::component::MessageBlock;

let block = MessageBlock::thinking("Let me reason about this...");
assert!(matches!(block, MessageBlock::Thinking(ref s) if s == "Let me reason about this..."));

pub fn error(content: impl Into<String>) -> Self

Creates an error block.

Example

use envision::component::MessageBlock;

let block = MessageBlock::error("Connection timeout");
assert!(matches!(block, MessageBlock::Error(ref s) if s == "Connection timeout"));

pub fn is_text(&self) -> bool

Returns true if this is a text block.

Example

use envision::component::MessageBlock;

assert!(MessageBlock::text("hello").is_text());
assert!(!MessageBlock::thinking("thoughts").is_text());

pub fn is_code(&self) -> bool

Returns true if this is a code block.

Example

use envision::component::MessageBlock;

assert!(MessageBlock::code("let x = 1;", Some("rust")).is_code());
assert!(!MessageBlock::text("hello").is_code());

pub fn is_tool_use(&self) -> bool

Returns true if this is a tool use block.

Example

use envision::component::MessageBlock;

assert!(MessageBlock::tool_use("search").is_tool_use());
assert!(!MessageBlock::text("hello").is_tool_use());

pub fn is_thinking(&self) -> bool

Returns true if this is a thinking block.

Example

use envision::component::MessageBlock;

assert!(MessageBlock::thinking("reasoning...").is_thinking());
assert!(!MessageBlock::text("hello").is_thinking());

pub fn is_error(&self) -> bool

Returns true if this is an error block.

Example

use envision::component::MessageBlock;

assert!(MessageBlock::error("timeout").is_error());
assert!(!MessageBlock::text("hello").is_error());

Trait Implementations

impl Clone for MessageBlock

fn clone(&self) -> MessageBlock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MessageBlock

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MessageBlock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MessageBlock

fn eq(&self, other: &MessageBlock) -> 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 MessageBlock

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for MessageBlock

impl StructuralPartialEq for MessageBlock