adk-code 0.6.0

Code execution substrate for ADK-Rust — typed executor abstraction, sandbox policy model, and built-in execution backends
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! Integration tests for `CodeTool`.
//!
//! These tests require `rustc` and a discoverable `serde_json` rlib.
//! Run with:
//!
//! ```bash
//! cargo test -p adk-code --test code_tool_integration -- --ignored
//! ```

use adk_code::{CodeTool, RustExecutor, RustExecutorConfig};
use adk_core::{CallbackContext, Content, EventActions, ReadonlyContext, Tool, ToolContext};
use adk_sandbox::ProcessBackend;
use async_trait::async_trait;
use serde_json::json;
use std::sync::{Arc, Mutex};

// ---------------------------------------------------------------------------
// Mock ToolContext (required by Tool::execute)
// ---------------------------------------------------------------------------

struct TestToolContext {
    content: Content,
    actions: Mutex<EventActions>,
}

impl TestToolContext {
    fn new() -> Self {
        Self { content: Content::new("user"), actions: Mutex::new(EventActions::default()) }
    }
}

#[async_trait]
impl ReadonlyContext for TestToolContext {
    fn invocation_id(&self) -> &str {
        "inv-integration"
    }
    fn agent_name(&self) -> &str {
        "test-agent"
    }
    fn user_id(&self) -> &str {
        "user"
    }
    fn app_name(&self) -> &str {
        "app"
    }
    fn session_id(&self) -> &str {
        "session"
    }
    fn branch(&self) -> &str {
        ""
    }
    fn user_content(&self) -> &Content {
        &self.content
    }
}

#[async_trait]
impl CallbackContext for TestToolContext {
    fn artifacts(&self) -> Option<Arc<dyn adk_core::Artifacts>> {
        None
    }
}

#[async_trait]
impl ToolContext for TestToolContext {
    fn function_call_id(&self) -> &str {
        "call-integration"
    }
    fn actions(&self) -> EventActions {
        self.actions.lock().unwrap().clone()
    }
    fn set_actions(&self, actions: EventActions) {
        *self.actions.lock().unwrap() = actions;
    }
    async fn search_memory(&self, _query: &str) -> adk_core::Result<Vec<adk_core::MemoryEntry>> {
        Ok(vec![])
    }
}

fn ctx() -> Arc<dyn ToolContext> {
    Arc::new(TestToolContext::new())
}

fn make_tool() -> CodeTool {
    let backend = Arc::new(ProcessBackend::default());
    let executor = RustExecutor::new(backend, RustExecutorConfig::default());
    CodeTool::new(executor)
}

// ---------------------------------------------------------------------------
// Valid Rust code → success
// ---------------------------------------------------------------------------

#[tokio::test]
#[ignore]
async fn code_tool_valid_rust_returns_success() {
    let tool = make_tool();
    let args = json!({
        "code": r#"
fn run(input: serde_json::Value) -> serde_json::Value {
    serde_json::json!({ "result": 42 })
}
"#,
        "timeout_secs": 60
    });

    let result = tool.execute(ctx(), args).await.expect("Tool::execute never returns Err");
    assert_eq!(result["status"], "success", "result: {result}");
    assert_eq!(result["exit_code"], 0);
}

// ---------------------------------------------------------------------------
// Compile error → structured diagnostics (not ToolError)
// ---------------------------------------------------------------------------

#[tokio::test]
#[ignore]
async fn code_tool_compile_error_returns_diagnostics() {
    let tool = make_tool();
    let args = json!({
        "code": r#"
fn run(input: serde_json::Value) -> serde_json::Value {
    let x: i32 = "oops";
    input
}
"#,
        "timeout_secs": 60
    });

    let result = tool.execute(ctx(), args).await.expect("Tool::execute never returns Err");
    assert_eq!(
        result["status"], "compile_error",
        "compile errors should be returned as information, not ToolError: {result}"
    );
    assert!(result["diagnostics"].is_array(), "should include diagnostics array");
}

// ---------------------------------------------------------------------------
// Runtime error (panic) → non-zero exit code
// ---------------------------------------------------------------------------

#[tokio::test]
#[ignore]
async fn code_tool_runtime_panic_returns_nonzero_exit_code() {
    let tool = make_tool();
    let args = json!({
        "code": r#"
fn run(_input: serde_json::Value) -> serde_json::Value {
    panic!("intentional panic");
}
"#,
        "timeout_secs": 60
    });

    let result = tool.execute(ctx(), args).await.expect("Tool::execute never returns Err");
    // A panic produces a non-zero exit code. The status may be "success"
    // (the pipeline succeeded) but exit_code will be non-zero.
    let exit_code = result["exit_code"].as_i64().unwrap_or(-1);
    assert_ne!(exit_code, 0, "panic should produce non-zero exit code: {result}");
}