Struct Event 

pub struct Event {
    pub id: String,
    pub timestamp: DateTime<Utc>,
    pub invocation_id: String,
    pub branch: String,
    pub author: String,
    pub llm_response: LlmResponse,
    pub actions: EventActions,
    pub long_running_tool_ids: Vec<String>,
    pub llm_request: Option<String>,
    pub provider_metadata: HashMap<String, String>,
}

Event represents a single interaction in a conversation. This struct embeds LlmResponse to match ADK-Go’s design pattern.

Fields

id: String

Unique identifier for this event.

timestamp: DateTime<Utc>

When this event was created.

invocation_id: String

The invocation that produced this event.

branch: String

The conversation branch this event belongs to.

author: String

The agent or role that authored this event.

llm_response: LlmResponse

The LLM response containing content and metadata. Access content via event.llm_response.content.

actions: EventActions

Actions to apply (state changes, transfers, confirmations).

long_running_tool_ids: Vec<String>

IDs of long-running tools associated with this event.

llm_request: Option<String>

LLM request data for UI display (JSON string)

provider_metadata: HashMap<String, String>

Provider-specific metadata (e.g., GCP Vertex, Azure OpenAI). Keeps the core Event struct provider-agnostic. Serialized as "event_metadata" to avoid collision with LlmResponse::provider_metadata when flattened.

Implementations

impl Event

pub fn new(invocation_id: impl Into<String>) -> Event

Available on crate feature sessions only.

Creates a new event with a generated UUID and current timestamp.

pub fn with_id(id: impl Into<String>, invocation_id: impl Into<String>) -> Event

Available on crate feature sessions only.

Create an event with a specific ID. Use this for streaming events where all chunks should share the same event ID.

pub fn tool_progress( invocation_id: impl Into<String>, author: impl Into<String>, function_call_id: impl Into<String>, stream: impl Into<String>, chunk: impl Into<String>, ) -> Event

Available on crate feature sessions only.

Creates a streaming tool-progress event.

Tools emit these via ToolContext::emit_progress to push intermediate stdout/stderr to the client while the tool is still running. The event carries the chunk as partial text content (role "tool") and is tagged with TOOL_PROGRESS_STREAM_KEY / TOOL_PROGRESS_CALL_ID_KEY so consumers can distinguish it from a final tool result and route it to the right terminal widget.

Example

use adk_core::Event;

let event = Event::tool_progress("inv-1", "agent", "call-7", "stdout", "compiling...\n");
assert_eq!(event.tool_progress_stream(), Some("stdout"));
assert!(event.llm_response.partial);

pub fn tool_progress_stream(&self) -> Option<&str>

Available on crate feature sessions only.

Returns the progress stream name ("stdout", "stderr", …) if this is a tool-progress event produced by ToolContext::emit_progress, otherwise None.

pub fn tool_calls(&self) -> Vec<ToolCallView<'_>>

Available on crate feature sessions only.

Returns the tool calls carried by this event, as a typed, render-ready view.

A UI consuming the agent’s EventStream can call this on every event to detect when the model requested one or more tools, without matching on Part::FunctionCall internals. Pair it with tool_results and tool_progress_stream to render a complete tool lifecycle (call → live progress → result).

Returns an empty vector for events that contain no tool calls.

Correlation

Use ToolCallView::call_id to correlate a call with its progress chunks and final result. For providers that omit call ids (e.g. Gemini), fall back to ToolCallView::name.

Example

use adk_core::{Content, Event, Part};

let mut event = Event::new("inv-1");
event.llm_response.content = Some(Content {
    role: "model".to_string(),
    parts: vec![Part::FunctionCall {
        name: "bash".to_string(),
        args: serde_json::json!({ "command": "ls" }),
        id: Some("call_1".to_string()),
        thought_signature: None,
    }],
});

let calls = event.tool_calls();
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].name, "bash");
assert_eq!(calls[0].call_id, Some("call_1"));

pub fn tool_results(&self) -> Vec<ToolResultView<'_>>

Available on crate feature sessions only.

Returns the tool results carried by this event, as a typed, render-ready view.

After a tool executes, the agent yields its result on the same EventStream as everything else, as a function-role event holding a Part::FunctionResponse. This accessor surfaces those results generically so a UI can render the output of any tool — streaming or not — without walking part internals.

Returns an empty vector for events that contain no tool results.

Correlation

Use ToolResultView::call_id to attach a result to the originating tool_calls entry and its progress chunks. For providers that omit call ids, fall back to ToolResultView::name.

Example

use adk_core::{Content, Event, FunctionResponseData, Part};

let mut event = Event::new("inv-1");
event.llm_response.content = Some(Content {
    role: "function".to_string(),
    parts: vec![Part::FunctionResponse {
        function_response: FunctionResponseData::new(
            "bash",
            serde_json::json!({ "stdout": "ok\n", "exit_code": 0 }),
        ),
        id: Some("call_1".to_string()),
        annotations: None,
    }],
});

let results = event.tool_results();
assert_eq!(results.len(), 1);
assert_eq!(results[0].name, "bash");
assert_eq!(results[0].call_id, Some("call_1"));
assert_eq!(results[0].response["exit_code"], 0);

pub fn content(&self) -> Option<&Content>

Available on crate feature sessions only.

Convenience method to access content directly.

pub fn set_content(&mut self, content: Content)

Available on crate feature sessions only.

Convenience method to set content directly.

pub fn interaction_id(&self) -> Option<&str>

Available on crate feature sessions only.

Returns the Interactions API interaction id for this event, if present.

Reads the id from the flattened LlmResponse, mirroring ADK-Python’s event.interaction_id. Returns None for events produced by the generateContent transport and non-Gemini providers.

Example

use adk_core::Event;

let mut event = Event::new("inv-123");
assert_eq!(event.interaction_id(), None);

event.llm_response.interaction_id = Some("v1_abc".to_string());
assert_eq!(event.interaction_id(), Some("v1_abc"));

pub fn is_final_response(&self) -> bool

Available on crate feature sessions only.

Returns whether the event is the final response of an agent.

An event is considered final if:

• It has skip_summarization set, OR
• It has long_running_tool_ids (indicating async operations), OR
• It has no function calls, no function responses, is not partial, and has no trailing code execution results.

Note: When multiple agents participate in one invocation, there could be multiple events with is_final_response() as true, for each participating agent.

pub fn function_call_ids(&self) -> Vec<String>

Available on crate feature sessions only.

Extracts function call IDs from this event’s content. Used to identify which function calls are associated with long-running tools.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

fn deserialize<__D>( __deserializer: __D, ) -> Result<Event, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Event

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

where __S: Serializer,

Serialize this value into the given Serde serializer.