Struct Event

Source

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>,
}

Expand description

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§

Source §

impl Event

Source

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

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

Source

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

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

Source

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>, ) -> Self

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);

Source

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

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

Source

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

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"));

Source

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

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);

Source

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

Convenience method to access content directly.

Source

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

Convenience method to set content directly.

Source

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

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"));

Source

pub fn is_final_response(&self) -> bool

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.

Source