chore: release v1.3.5

## New Features

### Skill Tool Mechanism (#8)
- Implement callable Skill tool with permission isolation
- Skills can be invoked as `Skill("skill-name")` with temporary permission grants
- Enforces skill-based access patterns - agents cannot bypass skills
- RAII pattern ensures automatic permission revocation after execution
- Tested with Kimi K2.5 model

### Session Cancellation API
- Add `session.cancel()` method to interrupt ongoing operations
- Cooperative cancellation at LLM streaming chunk boundaries
- Exposed in Python and Node.js SDKs
- Returns partial results when cancelled

## Documentation
- Add Skill Tool documentation (English and Chinese)
- Add cancellation API documentation (English and Chinese)
- Add comprehensive examples and test results

## Version Updates
- Core: 1.3.4 → 1.3.5
- Python SDK: 1.3.4 → 1.3.5
- Node.js SDK: 1.3.4 → 1.3.5

Closes #8

Author: RoyLin

core/Cargo.toml

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

core/src/agent.rs

@@ -1448,7 +1448,14 @@ impl AgentLoop {
             .unwrap_or_default();
 
         let result = self
-            .execute_loop_inner(&messages, "", &effective_prompt, session_id, event_tx, token)
+            .execute_loop_inner(
+                &messages,
+                "",
+                &effective_prompt,
+                session_id,
+                event_tx,
+                token,
+            )
             .await;
 
         match &result {
@@ -1773,7 +1780,12 @@ impl AgentLoop {
                 loop {
                     attempt += 1;
                     let result = self
-                        .call_llm(&messages, augmented_system.as_deref(), &event_tx, cancel_token)
+                        .call_llm(
+                            &messages,
+                            augmented_system.as_deref(),
+                            &event_tx,
+                            cancel_token,
+                        )
                         .await;
                     match result {
                         Ok(r) => {
@@ -2586,7 +2598,9 @@ impl AgentLoop {
             if let Some(queue) = command_queue {
                 agent = agent.with_queue(queue);
             }
-            agent.execute_with_session(&history, &prompt, None, Some(tx), Some(&token_clone)).await
+            agent
+                .execute_with_session(&history, &prompt, None, Some(tx), Some(&token_clone))
+                .await
         });
 
         Ok((rx, handle, cancel_token))
@@ -2764,7 +2778,13 @@ impl AgentLoop {
                 );
 
                 match self
-                    .execute_loop(&current_history, &step_prompt, None, event_tx.clone(), &tokio_util::sync::CancellationToken::new())
+                    .execute_loop(
+                        &current_history,
+                        &step_prompt,
+                        None,
+                        event_tx.clone(),
+                        &tokio_util::sync::CancellationToken::new(),
+                    )
                     .await
                 {
                     Ok(result) => {
@@ -2852,7 +2872,13 @@ impl AgentLoop {
                             ],
                         );
                         let result = agent_clone
-                            .execute_loop(&base_history, &prompt, None, tx, &tokio_util::sync::CancellationToken::new())
+                            .execute_loop(
+                                &base_history,
+                                &prompt,
+                                None,
+                                tx,
+                                &tokio_util::sync::CancellationToken::new(),
+                            )
                             .await;
                         (step_clone.id, sn, result)
                     });
@@ -3300,7 +3326,7 @@ mod tests {
         let config = AgentConfig::default();
 
         let agent = AgentLoop::new(mock_client, tool_executor, test_tool_context(), config);
-        let (mut rx, handle) = agent.execute_streaming(&[], "Hi").await.unwrap();
+        let (mut rx, handle, _cancel_token) = agent.execute_streaming(&[], "Hi").await.unwrap();
 
         // Collect events
         let mut events = Vec::new();
@@ -4309,7 +4335,7 @@ mod tests {
 
         // Execute with session ID
         let result = agent
-            .execute_with_session(&[], "User prompt", Some("sess-123"), None)
+            .execute_with_session(&[], "User prompt", Some("sess-123"), None, None)
             .await
             .unwrap();
 

core/src/agent_api.rs

@@ -1315,6 +1315,7 @@ impl Agent {
             cron_rx: tokio::sync::Mutex::new(cron_rx),
             is_processing_cron: AtomicBool::new(false),
             cron_started: AtomicBool::new(false),
+            cancel_token: Arc::new(tokio::sync::Mutex::new(None)),
         })
     }
 }
@@ -1371,6 +1372,9 @@ pub struct AgentSession {
     /// The ticker is started lazily on the first `send()` call so that
     /// `tokio::spawn` is always called from within an async runtime context.
     cron_started: AtomicBool,
+    /// Cancellation token for the current operation (send/stream).
+    /// Stored so that cancel() can abort ongoing LLM calls.
+    cancel_token: Arc<tokio::sync::Mutex<Option<tokio_util::sync::CancellationToken>>>,
 }
 
 impl std::fmt::Debug for AgentSession {
@@ -1515,7 +1519,19 @@ impl AgentSession {
             None => read_or_recover(&self.history).clone(),
         };
 
-        let result = agent_loop.execute(&effective_history, prompt, None).await?;
+        let cancel_token = tokio_util::sync::CancellationToken::new();
+        *self.cancel_token.lock().await = Some(cancel_token.clone());
+        let result = agent_loop
+            .execute_with_session(
+                &effective_history,
+                prompt,
+                Some(&self.session_id),
+                None,
+                Some(&cancel_token),
+            )
+            .await;
+        *self.cancel_token.lock().await = None;
+        let result = result?;
 
         // Auto-accumulate: only update internal history when no custom
         // history was provided.
@@ -1670,14 +1686,50 @@ impl AgentSession {
             None => read_or_recover(&self.history).clone(),
         };
         let prompt = prompt.to_string();
+        let session_id = self.session_id.clone();
+
+        let cancel_token = tokio_util::sync::CancellationToken::new();
+        *self.cancel_token.lock().await = Some(cancel_token.clone());
+        let token_clone = cancel_token.clone();
 
         let handle = tokio::spawn(async move {
             let _ = agent_loop
-                .execute(&effective_history, &prompt, Some(tx))
+                .execute_with_session(
+                    &effective_history,
+                    &prompt,
+                    Some(&session_id),
+                    Some(tx),
+                    Some(&token_clone),
+                )
                 .await;
         });
 
-        Ok((rx, handle))
+        // Wrap the handle to clear the cancel token when done
+        let cancel_token_ref = self.cancel_token.clone();
+        let wrapped_handle = tokio::spawn(async move {
+            let _ = handle.await;
+            *cancel_token_ref.lock().await = None;
+        });
+
+        Ok((rx, wrapped_handle))
+    }
+
+    /// Cancel the current ongoing operation (send/stream).
+    ///
+    /// If an operation is in progress, this will trigger cancellation of the LLM streaming
+    /// and tool execution. The operation will terminate as soon as possible.
+    ///
+    /// Returns `true` if an operation was cancelled, `false` if no operation was in progress.
+    pub async fn cancel(&self) -> bool {
+        let token = self.cancel_token.lock().await.clone();
+        if let Some(token) = token {
+            token.cancel();
+            tracing::info!(session_id = %self.session_id, "Cancelled ongoing operation");
+            true
+        } else {
+            tracing::debug!(session_id = %self.session_id, "No ongoing operation to cancel");
+            false
+        }
     }
 
     /// Return a snapshot of the session's conversation history.

core/src/session/manager.rs

@@ -31,7 +31,8 @@ pub struct SessionManager {
     /// LLM configurations for sessions (stored separately for persistence)
     pub(crate) llm_configs: Arc<RwLock<HashMap<String, LlmConfigData>>>,
     /// Ongoing operations (session_id -> CancellationToken)
-    pub(crate) ongoing_operations: Arc<RwLock<HashMap<String, tokio_util::sync::CancellationToken>>>,
+    pub(crate) ongoing_operations:
+        Arc<RwLock<HashMap<String, tokio_util::sync::CancellationToken>>>,
     /// Skill registry for runtime skill management
     pub(crate) skill_registry: Arc<RwLock<Option<Arc<SkillRegistry>>>>,
     /// Shared memory store for agent long-term memory.
@@ -877,7 +878,8 @@ impl SessionManager {
             .with_tool_metrics(tool_metrics);
 
         // Execute with streaming
-        let (rx, handle, cancel_token) = agent.execute_streaming(&history, &effective_prompt).await?;
+        let (rx, handle, cancel_token) =
+            agent.execute_streaming(&history, &effective_prompt).await?;
 
         // Store the cancellation token for cancellation support
         let cancel_token_clone = cancel_token.clone();

core/src/tools/skill.rs

@@ -17,7 +17,7 @@ use crate::agent::{AgentConfig, AgentLoop};
 use crate::llm::LlmClient;
 use crate::permissions::{PermissionDecision, PermissionPolicy, PermissionRule};
 use crate::skills::{Skill, SkillRegistry};
-use crate::tools::{Tool, ToolContext, ToolOutput, ToolExecutor};
+use crate::tools::{Tool, ToolContext, ToolExecutor, ToolOutput};
 use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
@@ -114,7 +114,8 @@ impl Tool for SkillTool {
         let args: SkillArgs = serde_json::from_value(args.clone())?;
 
         // Get the skill
-        let skill = self.skill_registry
+        let skill = self
+            .skill_registry
             .get(&args.skill_name)
             .ok_or_else(|| anyhow!("Skill '{}' not found", args.skill_name))?;
 
@@ -135,9 +136,7 @@ impl Tool for SkillTool {
         // Build the system prompt with skill content
         skill_config.prompt_slots.role = Some(format!(
             "You are executing the '{}' skill.\n\n{}\n\n{}",
-            skill.name,
-            skill.description,
-            skill.content
+            skill.name, skill.description, skill.content
         ));
 
         // Create agent loop with skill permissions
@@ -149,9 +148,9 @@ impl Tool for SkillTool {
         );
 
         // Execute the skill with the prompt
-        let prompt = args.prompt.unwrap_or_else(|| {
-            format!("Execute the '{}' skill", skill.name)
-        });
+        let prompt = args
+            .prompt
+            .unwrap_or_else(|| format!("Execute the '{}' skill", skill.name));
 
         // Execute the agent loop with skill permissions
         let result = agent_loop.execute(&[], &prompt, None).await?;