adk-ui 2.2.0

Dynamic UI generation for ADK-Rust agents - render forms, cards, tables, charts and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use crate::compat::ToolContext;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use std::collections::HashMap;
use std::sync::{Arc, Mutex, OnceLock};

pub const ACTIVE_SURFACE_STATE_KEY: &str = "adk_ui.active_surface";
pub const SURFACE_REFS_STATE_KEY: &str = "adk_ui.surface_refs";

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
pub struct SurfaceRef {
    pub id: String,
    pub version: u64,
}

impl SurfaceRef {
    pub fn new(id: impl Into<String>, version: u64) -> Self {
        Self {
            id: id.into(),
            version,
        }
    }
}

fn revisions() -> &'static Mutex<HashMap<String, u64>> {
    static REVISIONS: OnceLock<Mutex<HashMap<String, u64>>> = OnceLock::new();
    REVISIONS.get_or_init(|| Mutex::new(HashMap::new()))
}

fn revision_key(ctx: &dyn ToolContext, surface_id: &str) -> String {
    format!(
        "{}\u{1f}{}\u{1f}{}\u{1f}{}",
        ctx.app_name(),
        ctx.user_id(),
        ctx.session_id(),
        surface_id
    )
}

pub(crate) fn next_surface_ref(
    ctx: &Arc<dyn ToolContext>,
    surface_id: impl Into<String>,
) -> SurfaceRef {
    let surface_id = surface_id.into();
    let key = revision_key(ctx.as_ref(), &surface_id);
    let mut values = revisions()
        .lock()
        .unwrap_or_else(|poisoned| poisoned.into_inner());
    let version = values
        .entry(key)
        .and_modify(|value| *value += 1)
        .or_insert(1);
    SurfaceRef::new(surface_id, *version)
}

pub(crate) fn observe_surface_version(
    ctx: &Arc<dyn ToolContext>,
    surface_id: impl Into<String>,
    version: u64,
) -> SurfaceRef {
    let surface_id = surface_id.into();
    let key = revision_key(ctx.as_ref(), &surface_id);
    let mut values = revisions()
        .lock()
        .unwrap_or_else(|poisoned| poisoned.into_inner());
    values
        .entry(key)
        .and_modify(|current| *current = (*current).max(version))
        .or_insert(version);
    SurfaceRef::new(surface_id, version)
}

pub(crate) fn record_surface_ref(ctx: &Arc<dyn ToolContext>, surface_ref: &SurfaceRef) {
    let mut actions = ctx.actions();
    actions.state_delta.insert(
        ACTIVE_SURFACE_STATE_KEY.to_string(),
        serde_json::to_value(surface_ref).unwrap_or_else(|_| {
            json!({
                "id": surface_ref.id,
                "version": surface_ref.version,
            })
        }),
    );
    ctx.set_actions(actions);
}

pub(crate) fn record_surface_refs(
    ctx: &Arc<dyn ToolContext>,
    active: &SurfaceRef,
    refs: &[SurfaceRef],
) {
    let mut actions = ctx.actions();
    actions.state_delta.insert(
        ACTIVE_SURFACE_STATE_KEY.to_string(),
        serde_json::to_value(active).unwrap_or(Value::Null),
    );
    actions.state_delta.insert(
        SURFACE_REFS_STATE_KEY.to_string(),
        serde_json::to_value(refs).unwrap_or(Value::Array(vec![])),
    );
    ctx.set_actions(actions);
}

pub(crate) fn surface_owner(ctx: &dyn ToolContext) -> String {
    let agent = ctx.agent_name().trim();
    if !agent.is_empty() {
        agent.to_string()
    } else {
        ctx.user_id().to_string()
    }
}