Add dynamic workflow runtime

Author: claude

Cargo.lock

@@ -17,6 +17,7 @@ a3s-common = { version = "0.1.1", path = "../../common" }
 a3s-memory = { version = "0.1.2", path = "../../memory" }
 a3s-lane = { version = "0.4", path = "../../lane" }
 a3s-search = { version = "1.2.3", path = "../../search", default-features = false, features = ["lightpanda"] }
+a3s-flow = { version = "0.1.0", path = "../../flow" }
 
 # Async runtime
 tokio = { version = "1.35", features = [

core/Cargo.toml

@@ -1360,6 +1360,16 @@ impl AgentSession {
         self.tool_executor.register_dynamic_tool(tool);
     }
 
+    /// Register the A3S Flow-backed dynamic workflow tool for this live session.
+    ///
+    /// The tool is named `dynamic_workflow`. It accepts a sandboxed JavaScript
+    /// PTC workflow script and executes it through
+    /// [`crate::DynamicWorkflowRuntime`], so A3S Flow owns workflow replay while
+    /// the script can still call A3S Code tools.
+    pub fn register_dynamic_workflow_runtime(&self) {
+        crate::tools::register_dynamic_workflow(self.tool_executor.registry());
+    }
+
     /// Remove a previously host-registered dynamic tool by name (e.g. on logout).
     /// No-op if no tool of that name is registered.
     pub fn unregister_dynamic_tool(&self, name: &str) {

core/src/agent_api.rs

@@ -101,7 +101,10 @@ impl DirectToolRuntime {
     }
 
     pub(super) async fn call(&self, name: &str, args: serde_json::Value) -> Result<ToolCallResult> {
-        let result = self.tool_executor.execute(name, &args).await?;
+        let result = self
+            .tool_executor
+            .execute_with_context(name, &args, &self.tool_context)
+            .await?;
         Ok(ToolCallResult {
             name: name.to_string(),
             output: result.output,
@@ -123,6 +126,36 @@ fn parse_glob_output(output: &str) -> Vec<String> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::tools::{Tool, ToolOutput};
+    use anyhow::Result;
+    use async_trait::async_trait;
+
+    struct ContextProbeTool;
+
+    #[async_trait]
+    impl Tool for ContextProbeTool {
+        fn name(&self) -> &str {
+            "context_probe"
+        }
+
+        fn description(&self) -> &str {
+            "Reports direct tool context for tests."
+        }
+
+        fn parameters(&self) -> serde_json::Value {
+            serde_json::json!({ "type": "object" })
+        }
+
+        async fn execute(
+            &self,
+            _args: &serde_json::Value,
+            ctx: &ToolContext,
+        ) -> Result<ToolOutput> {
+            Ok(ToolOutput::success(
+                ctx.session_id.as_deref().unwrap_or("missing-session"),
+            ))
+        }
+    }
 
     #[test]
     fn parse_glob_output_ignores_empty_lines() {
@@ -131,4 +164,22 @@ mod tests {
             vec!["src/lib.rs".to_string(), "src/main.rs".to_string()]
         );
     }
+
+    #[tokio::test]
+    async fn direct_tool_call_uses_session_tool_context() {
+        let dir = tempfile::tempdir().unwrap();
+        let tool_executor = Arc::new(ToolExecutor::new(dir.path().to_string_lossy().to_string()));
+        tool_executor.register_dynamic_tool(Arc::new(ContextProbeTool));
+        let runtime = DirectToolRuntime {
+            tool_executor,
+            tool_context: ToolContext::new(dir.path().to_path_buf()).with_session_id("session-123"),
+        };
+
+        let output = runtime
+            .call("context_probe", serde_json::json!({}))
+            .await
+            .unwrap();
+
+        assert_eq!(output.output, "session-123");
+    }
 }