chore: improve RequestMeta

zensh · zensh · commit 1e6ae8def09f · 2026-01-18T21:54:38.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -12,7 +12,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.9.2"
+version = "0.9.5"
 description = "Anda is an AI agent framework built with Rust, powered by ICP and TEEs."
 repository = "https://github.com/ldclabs/anda"
 homepage = "https://github.com/ldclabs/anda"
diff --git a/anda_core/src/model.rs b/anda_core/src/model.rs
@@ -10,7 +10,7 @@
 
 use candid::Principal;
 use serde::{Deserialize, Serialize};
-use serde_json::json;
+use serde_json::{Map, json};
 use std::collections::BTreeMap;
 
 use crate::Json;
@@ -291,6 +291,7 @@ impl<T> ToolOutput<T> {
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 pub struct RequestMeta {
     /// The target engine principal for the request.
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub engine: Option<Principal>,
 
     /// Gets the username from request context.
@@ -299,6 +300,11 @@ pub struct RequestMeta {
     /// of the user interacting with the bot.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub user: Option<String>,
+
+    /// Extra metadata key-value pairs.
+    #[serde(flatten)]
+    #[serde(skip_serializing_if = "Map::is_empty")]
+    pub extra: Map<String, Json>,
 }
 
 /// Represents the usage statistics for the agent or tool execution.
@@ -742,4 +748,65 @@ mod tests {
         assert_eq!(calls[1].name, "echo");
         assert_eq!(calls[1].args, serde_json::json!({"text":"hi"}));
     }
+
+    #[test]
+    fn test_request_meta_extra_flatten_serde() {
+        // empty extra should not serialize
+        let meta = RequestMeta {
+            engine: None,
+            user: None,
+            extra: Map::new(),
+        };
+        let v = serde_json::to_value(&meta).unwrap();
+        assert_eq!(v, serde_json::json!({}));
+
+        // extra should be flattened into the top-level object
+        let mut extra = Map::new();
+        extra.insert("foo".into(), serde_json::json!("bar"));
+        extra.insert("n".into(), serde_json::json!(1));
+        extra.insert("obj".into(), serde_json::json!({"x": true}));
+
+        let meta2 = RequestMeta {
+            engine: Some(Principal::from_text("aaaaa-aa").unwrap()),
+            user: Some("alice".into()),
+            extra,
+        };
+
+        let v2 = serde_json::to_value(&meta2).unwrap();
+        assert_eq!(v2.get("engine").unwrap(), "aaaaa-aa");
+        assert_eq!(v2.get("user").unwrap(), "alice");
+        assert_eq!(v2.get("foo").unwrap(), "bar");
+        assert_eq!(v2.get("n").unwrap(), 1);
+        assert_eq!(v2.get("obj").unwrap(), &serde_json::json!({"x": true}));
+        assert!(v2.get("extra").is_none());
+
+        // deserialization: unknown fields go into extra
+        let input = serde_json::json!({
+            "engine": "aaaaa-aa",
+            "user": "bob",
+            "k1": "v1",
+            "k2": 2,
+            "nested": {"a": 1}
+        });
+        let back: RequestMeta = serde_json::from_value(input).unwrap();
+        assert_eq!(back.engine.unwrap().to_text(), "aaaaa-aa");
+        assert_eq!(back.user.as_deref(), Some("bob"));
+        assert_eq!(back.extra.get("k1").unwrap(), "v1");
+        assert_eq!(back.extra.get("k2").unwrap(), 2);
+        assert_eq!(
+            back.extra.get("nested").unwrap(),
+            &serde_json::json!({"a": 1})
+        );
+
+        // round-trip (field-by-field)
+        let back2: RequestMeta = serde_json::from_value(v2).unwrap();
+        assert_eq!(back2.engine.unwrap().to_text(), "aaaaa-aa");
+        assert_eq!(back2.user.as_deref(), Some("alice"));
+        assert_eq!(back2.extra.get("foo").unwrap(), "bar");
+        assert_eq!(back2.extra.get("n").unwrap(), 1);
+        assert_eq!(
+            back2.extra.get("obj").unwrap(),
+            &serde_json::json!({"x": true})
+        );
+    }
 }
diff --git a/anda_engine/src/context/base.rs b/anda_engine/src/context/base.rs
@@ -194,6 +194,7 @@ impl BaseCtx {
         RequestMeta {
             engine: Some(target),
             user: Some(self.name.clone()),
+            extra: Default::default(),
         }
     }
 
diff --git a/anda_engine_server/Cargo.toml b/anda_engine_server/Cargo.toml
@@ -3,7 +3,7 @@ name = "anda_engine_server"
 description = "A http server to serve multiple Anda engines."
 repository = "https://github.com/ldclabs/anda/tree/main/anda_engine_server"
 publish = true
-version = "0.9.4"
+version = "0.9.5"
 edition.workspace = true
 keywords.workspace = true
 categories.workspace = true
@@ -16,6 +16,7 @@ axum = { workspace = true }
 candid = { workspace = true }
 ciborium = { workspace = true }
 serde = { workspace = true }
+serde_json = { workspace = true }
 http = { workspace = true }
 ic_cose_types = { workspace = true }
 ic_tee_agent = { workspace = true }
diff --git a/anda_engine_server/src/handler.rs b/anda_engine_server/src/handler.rs
@@ -130,16 +130,15 @@ pub async fn anda_engine(
         ANONYMOUS_PRINCIPAL
     };
 
-    log::info!(
-        method = req.method.as_str(),
-        agent = id.to_text(),
-        caller = caller.to_text();
-        "anda_engine",
-    );
-    let res = engine_run(req, &app, caller, id).await;
     match &ct {
-        ContentWithSHA3::CBOR(_, _) => Content::CBOR(res, None).into_response(),
-        ContentWithSHA3::JSON(_, _) => Content::JSON(res, None).into_response(),
+        ContentWithSHA3::CBOR(_, _) => {
+            let res = engine_run(req, &app, caller, id).await;
+            Content::CBOR(res, None).into_response()
+        }
+        ContentWithSHA3::JSON(_, _) => {
+            let res = engine_run_in_json(req, &app, caller, id).await;
+            Content::JSON(res, None).into_response()
+        }
     }
 }
 
@@ -158,6 +157,13 @@ async fn engine_run(
         "agent_run" => {
             let args: (AgentInput,) = from_reader(req.params.as_slice())
                 .map_err(|err| format!("failed to decode params: {err:?}"))?;
+            log::info!(
+                method = req.method.as_str(),
+                agent = id.to_text(),
+                caller = caller.to_text(),
+                name = args.0.name;
+                "",
+            );
             let res = engine
                 .agent_run(caller, args.0)
                 .await
@@ -167,6 +173,13 @@ async fn engine_run(
         "tool_call" => {
             let args: (ToolInput<Json>,) = from_reader(req.params.as_slice())
                 .map_err(|err| format!("failed to decode params: {err:?}"))?;
+            log::info!(
+                method = req.method.as_str(),
+                agent = id.to_text(),
+                caller = caller.to_text(),
+                name = args.0.name;
+                "",
+            );
             let res = engine
                 .tool_call(caller, args.0)
                 .await
@@ -183,3 +196,64 @@ async fn engine_run(
         )),
     }
 }
+
+async fn engine_run_in_json(
+    req: &RPCRequest,
+    app: &AppState,
+    caller: Principal,
+    id: Principal,
+) -> RPCResponse {
+    let engine = app
+        .engines
+        .get(&id)
+        .ok_or_else(|| format!("engine {} not found", id.to_text()))?;
+
+    match req.method.as_str() {
+        "agent_run" => {
+            let args: (AgentInput,) = serde_json::from_slice(req.params.as_slice())
+                .map_err(|err| format!("failed to decode params: {err:?}"))?;
+            log::info!(
+                method = req.method.as_str(),
+                agent = id.to_text(),
+                caller = caller.to_text(),
+                name = args.0.name;
+                "",
+            );
+            let res = engine
+                .agent_run(caller, args.0)
+                .await
+                .map_err(|err| format!("failed to run agent: {err:?}"))?;
+            Ok(serde_json::to_vec(&res)
+                .map_err(|err| format!("{:?}", err))?
+                .into())
+        }
+        "tool_call" => {
+            let args: (ToolInput<Json>,) = serde_json::from_slice(req.params.as_slice())
+                .map_err(|err| format!("failed to decode params: {err:?}"))?;
+            log::info!(
+                method = req.method.as_str(),
+                agent = id.to_text(),
+                caller = caller.to_text(),
+                name = args.0.name;
+                "",
+            );
+            let res = engine
+                .tool_call(caller, args.0)
+                .await
+                .map_err(|err| format!("failed to call tool: {err:?}"))?;
+            Ok(serde_json::to_vec(&res)
+                .map_err(|err| format!("{:?}", err))?
+                .into())
+        }
+        "information" => {
+            let res = engine.information();
+            Ok(serde_json::to_vec(&res)
+                .map_err(|err| format!("{:?}", err))?
+                .into())
+        }
+        method => Err(format!(
+            "{method} on engine {} not implemented",
+            id.to_text()
+        )),
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ members = [`
`12`	`12`	`]`
`13`	`13`
`14`	`14`	`[workspace.package]`
`15`		`-version = "0.9.2"`
	`15`	`+version = "0.9.5"`
`16`	`16`	`description = "Anda is an AI agent framework built with Rust, powered by ICP and TEEs."`
`17`	`17`	`repository = "https://github.com/ldclabs/anda"`
`18`	`18`	`homepage = "https://github.com/ldclabs/anda"`
Original file line number	Diff line number	Diff line change
`@@ -194,6 +194,7 @@ impl BaseCtx {`
`194`	`194`	`RequestMeta {`
`195`	`195`	`engine: Some(target),`
`196`	`196`	`user: Some(self.name.clone()),`
	`197`	`+ extra: Default::default(),`
`197`	`198`	`}`
`198`	`199`	`}`
`199`	`200`