Struct Item 

pub struct Item {
    pub id: Option<MessageId>,
    pub kind: ItemKind,
    pub parts: Vec<Part>,
    pub metadata: MetadataMap,
    pub usage: Option<Usage>,
    pub finish_reason: Option<FinishReason>,
    pub created_at: Option<Timestamp>,
}

A single entry in the agent transcript.

An Item represents one message or event in the conversation between the system, user, assistant, and tools. Each item has a kind that determines its role and a vector of Parts that carry its content.

Items are the primary unit of data flowing through the agentkit loop: callers submit user and system items, the loop appends assistant and tool items, and compaction strategies operate on the full Vec<Item> transcript.

Example

use agentkit_core::{Item, ItemKind};

let user_msg = Item::text(ItemKind::User, "List the workspace crates.");

assert_eq!(user_msg.kind, ItemKind::User);
assert_eq!(user_msg.parts.len(), 1);

Fields

id: Option<MessageId>

Optional provider-assigned or user-supplied message identifier.

kind: ItemKind

The role of this item in the transcript.

parts: Vec<Part>

The content parts that make up this item.

metadata: MetadataMap

Arbitrary key-value metadata for this item.

usage: Option<Usage>

Token / cost usage produced by the model turn that emitted this item. Populated by the loop on assistant items when the provider reports it.

finish_reason: Option<FinishReason>

Why the model turn that produced this item ended. Populated by the loop on assistant items.

created_at: Option<Timestamp>

When this item was appended to the transcript. Populated by the loop for every appended item.

Implementations

impl Item

pub fn new(kind: ItemKind, parts: Vec<Part>) -> Self

Builds an item with the given role and parts.

pub fn text(kind: ItemKind, text: impl Into<String>) -> Self

Builds a single-text-part item.

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

Builds a ItemKind::Notification item carrying free-form text. Adapters wrap the content in <system-reminder> and deliver it as a user-role message so the model can react to the notification on its next turn without violating tool_use/tool_result pairing.

pub fn with_id(self, id: impl Into<MessageId>) -> Self

Sets the item identifier.

pub fn with_metadata(self, metadata: MetadataMap) -> Self

Replaces the item metadata.

pub fn push_part(self, part: Part) -> Self

Appends one part to the item.

pub fn with_usage(self, usage: Usage) -> Self

Sets the model usage that produced this item.

pub fn with_finish_reason(self, reason: FinishReason) -> Self

Sets the finish reason for the model turn that produced this item.

pub fn with_created_at(self, ts: Timestamp) -> Self

Sets when this item was created.

Trait Implementations

impl Clone for Item

fn clone(&self) -> Item

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Item

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Item

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Item

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

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 Item