fix(core,node-sdk): harden tool schemas and restore slash command output

Author: RoyLin

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "a3s-code-core"
-version = "1.5.3"
+version = "1.5.4"
 edition = "2021"
 authors = ["A3S Lab Team"]
 license = "MIT"

core/Cargo.toml

@@ -227,7 +227,12 @@ pub enum AgentEvent {
 
     /// Agent completed
     #[serde(rename = "agent_end")]
-    End { text: String, usage: TokenUsage },
+    End {
+        text: String,
+        usage: TokenUsage,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        meta: Option<crate::llm::LlmResponseMeta>,
+    },
 
     /// Error occurred
     #[serde(rename = "error")]
@@ -1856,7 +1861,6 @@ impl AgentLoop {
             total_usage.prompt_tokens += response.usage.prompt_tokens;
             total_usage.completion_tokens += response.usage.completion_tokens;
             total_usage.total_tokens += response.usage.total_tokens;
-
             // Record LLM completion telemetry
             let llm_duration = llm_start.elapsed();
             tracing::info!(
@@ -2002,6 +2006,7 @@ impl AgentLoop {
                     tx.send(AgentEvent::End {
                         text: final_text.clone(),
                         usage: total_usage.clone(),
+                        meta: response.meta.clone(),
                     })
                     .await
                     .ok();
@@ -3113,6 +3118,7 @@ mod tests {
                     cache_write_tokens: None,
                 },
                 stop_reason: Some("end_turn".to_string()),
+                meta: None,
             }
         }
 
@@ -3140,6 +3146,7 @@ mod tests {
                     cache_write_tokens: None,
                 },
                 stop_reason: Some("tool_use".to_string()),
+                meta: None,
             }
         }
     }
@@ -3887,6 +3894,7 @@ mod tests {
                     cache_write_tokens: None,
                 },
                 stop_reason: Some("tool_use".to_string()),
+                meta: None,
             },
             MockLlmClient::text_response("Both executed!"),
         ]));
@@ -3959,6 +3967,7 @@ mod tests {
                     cache_write_tokens: None,
                 },
                 stop_reason: Some("tool_use".to_string()),
+                meta: None,
             },
             MockLlmClient::text_response("First worked, second rejected."),
         ]));
@@ -4611,6 +4620,7 @@ mod tests {
                     cache_write_tokens: None,
                 },
                 stop_reason: Some("tool_use".to_string()),
+                meta: None,
             },
             MockLlmClient::text_response("Both commands ran"),
         ]));
@@ -4747,7 +4757,7 @@ mod tests {
         let end_event = events.iter().find(|e| matches!(e, AgentEvent::End { .. }));
         assert!(end_event.is_some());
 
-        if let AgentEvent::End { text, usage } = end_event.unwrap() {
+        if let AgentEvent::End { text, usage, .. } = end_event.unwrap() {
             assert_eq!(text, "Final answer here");
             assert_eq!(usage.total_tokens, 15);
         }
@@ -4985,6 +4995,7 @@ mod extra_agent_tests {
                 cache_read_tokens: None,
                 cache_write_tokens: None,
             },
+            meta: None,
         };
         let json = serde_json::to_string(&event).unwrap();
         assert!(json.contains("agent_end"));

core/src/agent.rs

@@ -2104,6 +2104,7 @@ impl AgentSession {
                                     .send(AgentEvent::End {
                                         text: answer,
                                         usage: crate::llm::TokenUsage::default(),
+                                        meta: None,
                                     })
                                     .await;
                             }
@@ -2129,6 +2130,7 @@ impl AgentSession {
                         .send(AgentEvent::End {
                             text: output.text.clone(),
                             usage: crate::llm::TokenUsage::default(),
+                            meta: None,
                         })
                         .await;
                 });

core/src/agent_api.rs

@@ -383,6 +383,7 @@ mod tests {
                 cache_write_tokens: None,
             },
             stop_reason: Some("end_turn".to_string()),
+            meta: None,
         };
         assert_eq!(response.text(), "Hello!");
         assert!(response.tool_calls().is_empty());
@@ -404,6 +405,7 @@ mod tests {
             },
             usage: TokenUsage::default(),
             stop_reason: Some("tool_use".to_string()),
+            meta: None,
         };
         let calls = response.tool_calls();
         assert_eq!(calls.len(), 1);
@@ -618,6 +620,7 @@ mod extra_llm_tests {
             },
             usage: TokenUsage::default(),
             stop_reason: None,
+            meta: None,
         };
         assert_eq!(r.text(), "resp");
     }
@@ -636,6 +639,7 @@ mod extra_llm_tests {
             },
             usage: TokenUsage::default(),
             stop_reason: None,
+            meta: None,
         };
         assert_eq!(r.tool_calls().len(), 1);
     }
@@ -1529,6 +1533,7 @@ mod extra_llm_tests2 {
             },
             usage: TokenUsage::default(),
             stop_reason: None,
+            meta: None,
         };
         assert_eq!(response.text(), "response text");
     }
@@ -1547,6 +1552,7 @@ mod extra_llm_tests2 {
             },
             usage: TokenUsage::default(),
             stop_reason: Some("tool_use".to_string()),
+            meta: None,
         };
         let calls = response.tool_calls();
         assert_eq!(calls.len(), 1);
@@ -1941,6 +1947,7 @@ mod extra_llm_tests2 {
             message: Message::user("test"),
             usage: TokenUsage::default(),
             stop_reason: Some("end_turn".to_string()),
+            meta: None,
         };
         let json = serde_json::to_string(&response).unwrap();
         assert!(json.contains("\"stop_reason\":\"end_turn\""));
@@ -2170,6 +2177,17 @@ mod extra_llm_tests3 {
         assert_eq!(tool_calls[0].function.arguments, "invalid json");
     }
 
+    #[test]
+    fn test_openai_parse_tool_arguments_preserves_parse_error() {
+        let parsed = OpenAiClient::parse_tool_arguments("Skill", "invalid json");
+        let err = parsed
+            .get("__parse_error")
+            .and_then(|v| v.as_str())
+            .unwrap_or_default();
+        assert!(err.contains("Malformed tool arguments"));
+        assert!(err.contains("invalid json"));
+    }
+
     // ========================================================================
     // Anthropic Response Parsing
     // ========================================================================

core/src/llm/tests.rs

@@ -357,11 +357,33 @@ impl Message {
 }
 
 /// LLM response
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct LlmResponseMeta {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub provider: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub request_model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub request_url: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub response_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub response_model: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub response_object: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub first_token_ms: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub duration_ms: Option<u64>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LlmResponse {
     pub message: Message,
     pub usage: TokenUsage,
     pub stop_reason: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub meta: Option<LlmResponseMeta>,
 }
 
 impl LlmResponse {
@@ -395,6 +417,7 @@ pub struct ToolCall {
 }
 
 /// Streaming event from LLM
+#[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone)]
 pub enum StreamEvent {
     /// Text content delta

core/src/llm/types.rs

@@ -569,8 +569,6 @@ mod tests {
 
     #[test]
     fn plugin_skills_not_registered_when_no_skill_registry_in_ctx() {
-        use crate::skills::SkillRegistry;
-
         let mut mgr = PluginManager::new();
         mgr.register(AgenticSearchPlugin::new());
 

core/src/plugin.rs

@@ -40,6 +40,7 @@ mod tests {
                 },
                 usage: crate::llm::TokenUsage::default(),
                 stop_reason: Some("end_turn".to_string()),
+                meta: None,
             })
         }
 
@@ -1903,6 +1904,7 @@ mod extra_session_tests {
                     },
                     usage: crate::llm::TokenUsage::default(),
                     stop_reason: None,
+                    meta: None,
                 })
             }
             async fn complete_streaming(

core/src/session/tests.rs

@@ -47,50 +47,77 @@ impl Tool for ManageSkillTool {
     }
 
     fn description(&self) -> &str {
-        "Create, list, remove, or get skills at runtime. Provide feedback on skill effectiveness to improve future behavior. Skills are instruction sets injected into the system prompt. Created skills persist across sessions."
+        "Create, list, remove, get, or score skills at runtime. \
+Use a single JSON object with the canonical field names defined in this schema. \
+Always provide the exact 'action' string first, then only the fields relevant to that action. \
+Do not invent alias fields or wrapper objects. Skills are instruction sets injected into the system prompt and created skills persist across sessions."
     }
 
     fn parameters(&self) -> serde_json::Value {
         serde_json::json!({
             "type": "object",
+            "additionalProperties": false,
             "properties": {
                 "action": {
                     "type": "string",
                     "enum": ["create", "list", "remove", "get", "feedback", "scores"],
-                    "description": "Action to perform"
+                    "description": "Required. Action to perform. Use exactly one of: create, list, remove, get, feedback, scores."
                 },
                 "name": {
                     "type": "string",
-                    "description": "Skill name (kebab-case, required for create/remove/get/feedback)"
+                    "description": "Canonical skill name in kebab-case. Required for create, remove, get, and feedback."
                 },
                 "description": {
                     "type": "string",
-                    "description": "Skill description (required for create)"
+                    "description": "Skill description. Required only when action='create'."
                 },
                 "content": {
                     "type": "string",
-                    "description": "Skill instructions in markdown (required for create)"
+                    "description": "Skill instructions in markdown. Required only when action='create'."
                 },
                 "tags": {
                     "type": "array",
                     "items": { "type": "string" },
-                    "description": "Optional tags for categorization"
+                    "description": "Optional tags for categorization when action='create'."
                 },
                 "outcome": {
                     "type": "string",
                     "enum": ["success", "failure", "partial"],
-                    "description": "Skill usage outcome (required for feedback)"
+                    "description": "Skill usage outcome. Required only when action='feedback'."
                 },
                 "score_delta": {
                     "type": "number",
-                    "description": "Score adjustment from -1.0 to 1.0 (required for feedback)"
+                    "description": "Score adjustment from -1.0 to 1.0. Required only when action='feedback'."
                 },
                 "reason": {
                     "type": "string",
-                    "description": "Reason for the feedback (required for feedback)"
+                    "description": "Reason for the feedback. Required only when action='feedback'."
                 }
             },
-            "required": ["action"]
+            "required": ["action"],
+            "examples": [
+                {
+                    "action": "list"
+                },
+                {
+                    "action": "get",
+                    "name": "code-review"
+                },
+                {
+                    "action": "create",
+                    "name": "code-review",
+                    "description": "Review code changes for bugs and regressions.",
+                    "content": "# Code Review\n\nReview the supplied patch for correctness and regressions.",
+                    "tags": ["review", "quality"]
+                },
+                {
+                    "action": "feedback",
+                    "name": "code-review",
+                    "outcome": "success",
+                    "score_delta": 0.5,
+                    "reason": "The skill found the regression quickly."
+                }
+            ]
         })
     }
 
@@ -404,11 +431,21 @@ mod tests {
         assert!(!tool.description().is_empty());
         let params = tool.parameters();
         assert_eq!(params["type"], "object");
+        assert_eq!(params["additionalProperties"], false);
         assert!(params["properties"]["action"].is_object());
         // Verify new actions are in enum
         let actions = params["properties"]["action"]["enum"].as_array().unwrap();
         assert!(actions.iter().any(|a| a == "feedback"));
         assert!(actions.iter().any(|a| a == "scores"));
+
+        let examples = params["examples"].as_array().unwrap();
+        assert_eq!(examples[0]["action"], "list");
+        assert_eq!(examples[1]["action"], "get");
+        assert_eq!(examples[1]["name"], "code-review");
+        assert_eq!(examples[2]["action"], "create");
+        assert!(examples[2].get("skill_name").is_none());
+        assert_eq!(examples[3]["action"], "feedback");
+        assert_eq!(examples[3]["outcome"], "success");
     }
 
     #[tokio::test]