Merge pull request #12 from nikomatsakis/main

You only prompt once!

Author: nikomatsakis

Cargo.lock

@@ -5,7 +5,7 @@ members = [
     "src/sacp",
     "src/sacp-tokio",
     "src/elizacp",
-    "src/sacp-test",
+    "src/sacp-test", "src/yopo",
 ]
 resolver = "2"
 

Cargo.toml

@@ -21,8 +21,9 @@ tracing.workspace = true
 uuid.workspace = true
 
 [dev-dependencies]
+clap = { workspace = true, features = ["derive"] }
 expect-test.workspace = true
-sacp-tokio = { version = "1.0.0-alpha", path = "../sacp-tokio" }
-tokio = { workspace = true, features = ["macros", "rt-multi-thread", "io-util", "time"] }
+shell-words = "1.1"
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "io-util", "time", "process"] }
 tokio-util.workspace = true
 sacp-test = { path = "../sacp-test" }

src/sacp/Cargo.toml

@@ -1,64 +1,91 @@
 //! YOLO one-shot client: A simple ACP client that runs a single prompt against an agent.
 //!
-//! This client:
-//! - Takes a prompt and agent configuration as arguments
-//! - Spawns the agent
-//! - Sends the prompt
-//! - Auto-approves all permission requests
-//! - Prints all session updates to stdout
-//! - Runs until the agent completes
+//! This is a simplified example showing basic ACP client usage. It only supports
+//! simple command strings (not JSON configs or environment variables).
 //!
-//! # Usage
+//! For a more full-featured client with JSON config support, see the `yopo` binary crate.
 //!
-//! With a command:
-//! ```bash
-//! cargo run --example yolo_one_shot_client -- "What is 2+2?" "python my_agent.py"
-//! ```
+//! # Usage
 //!
-//! With JSON config:
 //! ```bash
-//! cargo run --example yolo_one_shot_client -- "Hello!" '{"type":"stdio","name":"my-agent","command":"python","args":["agent.py"],"env":[]}'
+//! cargo run --example yolo_one_shot_client -- --command "python my_agent.py" "What is 2+2?"
 //! ```
 
+use clap::Parser;
 use sacp::JrConnection;
 use sacp::schema::{
     ContentBlock, InitializeRequest, NewSessionRequest, PromptRequest, RequestPermissionOutcome,
     RequestPermissionRequest, RequestPermissionResponse, SessionNotification, TextContent,
     VERSION as PROTOCOL_VERSION,
 };
-use sacp_tokio::{AcpAgent, JrConnectionExt};
 use std::path::PathBuf;
-use std::str::FromStr;
+use tokio::process::Child;
+use tokio_util::compat::{TokioAsyncReadCompatExt, TokioAsyncWriteCompatExt};
+
+#[derive(Parser)]
+#[command(name = "yolo-one-shot-client")]
+#[command(about = "A simple ACP client for one-shot prompts", long_about = None)]
+struct Cli {
+    /// The command to run the agent (e.g., "python my_agent.py")
+    #[arg(short, long)]
+    command: String,
+
+    /// The prompt to send to the agent
+    prompt: String,
+}
+
+/// Parse a command string into command and args
+fn parse_command_string(s: &str) -> Result<(PathBuf, Vec<String>), Box<dyn std::error::Error>> {
+    let parts = shell_words::split(s)?;
+    if parts.is_empty() {
+        return Err("Command string cannot be empty".into());
+    }
+    let command = PathBuf::from(&parts[0]);
+    let args = parts[1..].to_vec();
+    Ok((command, args))
+}
+
+/// Spawn a process for the agent and get stdio streams.
+fn spawn_agent_process(
+    command: PathBuf,
+    args: Vec<String>,
+) -> Result<
+    (
+        tokio::process::ChildStdin,
+        tokio::process::ChildStdout,
+        Child,
+    ),
+    Box<dyn std::error::Error>,
+> {
+    let mut cmd = tokio::process::Command::new(&command);
+    cmd.args(&args);
+    cmd.stdin(std::process::Stdio::piped())
+        .stdout(std::process::Stdio::piped());
+
+    let mut child = cmd.spawn()?;
+    let child_stdin = child.stdin.take().ok_or("Failed to open stdin")?;
+    let child_stdout = child.stdout.take().ok_or("Failed to open stdout")?;
+
+    Ok((child_stdin, child_stdout, child))
+}
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Parse command line arguments
-    let args: Vec<String> = std::env::args().collect();
-    if args.len() != 3 {
-        eprintln!("Usage: {} <prompt> <agent-config>", args[0]);
-        eprintln!();
-        eprintln!("  <prompt>       - The prompt to send to the agent");
-        eprintln!("  <agent-config> - Either a command string or JSON (starting with '{{')");
-        eprintln!();
-        eprintln!("Examples:");
-        eprintln!("  {} \"What is 2+2?\" \"python my_agent.py\"", args[0]);
-        eprintln!(
-            "  {} \"Hello!\" '{{\"type\":\"stdio\",\"name\":\"agent\",\"command\":\"python\",\"args\":[\"agent.py\"],\"env\":[]}}'",
-            args[0]
-        );
-        std::process::exit(1);
-    }
+    let cli = Cli::parse();
 
-    let prompt = &args[1];
-    let agent_config = &args[2];
+    // Parse the command string
+    let (command, args) = parse_command_string(&cli.command)?;
 
-    // Parse the agent configuration
-    let agent = AcpAgent::from_str(agent_config)?;
+    eprintln!("🚀 Spawning agent: {} {:?}", command.display(), args);
 
-    eprintln!("🚀 Spawning agent and connecting...");
+    // Spawn the agent process
+    let (child_stdin, child_stdout, mut child) = spawn_agent_process(command, args)?;
+
+    // Create a JrConnection with the agent's stdio streams
+    let connection = JrConnection::new(child_stdin.compat_write(), child_stdout.compat());
 
     // Run the client
-    JrConnection::to_agent(agent)?
+    connection
         .on_receive_notification(async move |notification: SessionNotification, _cx| {
             // Print session updates to stdout (so 2>/dev/null shows only agent output)
             println!("{:?}", notification.update);
@@ -112,12 +139,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             eprintln!("✓ Session created: {}", session_id);
 
             // Send the prompt
-            eprintln!("💬 Sending prompt: \"{}\"", prompt);
+            eprintln!("💬 Sending prompt: \"{}\"", cli.prompt);
             let prompt_response = cx
                 .send_request(PromptRequest {
                     session_id: session_id.clone(),
                     prompt: vec![ContentBlock::Text(TextContent {
-                        text: prompt.to_string(),
+                        text: cli.prompt.clone(),
                         annotations: None,
                         meta: None,
                     })],
@@ -133,5 +160,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         })
         .await?;
 
+    // Kill the child process when done
+    let _ = child.kill().await;
+
     Ok(())
 }

src/sacp/examples/yolo_one_shot_client.rs

@@ -0,0 +1,12 @@
+[package]
+name = "yopo"
+version = "1.0.0-alpha"
+edition = "2024"
+description = "YOPO (You Only Prompt Once) - A simple ACP client for one-shot prompts"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/symposium-dev/symposium-acp"
+
+[dependencies]
+sacp = { version = "1.0.0-alpha", path = "../sacp" }
+sacp-tokio = { version = "1.0.0-alpha", path = "../sacp-tokio" }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

src/yopo/Cargo.toml

@@ -0,0 +1,137 @@
+//! YOPO (You Only Prompt Once) - A simple ACP client for one-shot prompts
+//!
+//! This client:
+//! - Takes a prompt and agent configuration as arguments
+//! - Spawns the agent
+//! - Sends the prompt
+//! - Auto-approves all permission requests
+//! - Prints all session updates to stdout
+//! - Runs until the agent completes
+//!
+//! # Usage
+//!
+//! With a command:
+//! ```bash
+//! yopo "What is 2+2?" "python my_agent.py"
+//! ```
+//!
+//! With JSON config:
+//! ```bash
+//! yopo "Hello!" '{"type":"stdio","name":"my-agent","command":"python","args":["agent.py"],"env":[]}'
+//! ```
+
+use sacp::JrConnection;
+use sacp::schema::{
+    ContentBlock, InitializeRequest, NewSessionRequest, PromptRequest, RequestPermissionOutcome,
+    RequestPermissionRequest, RequestPermissionResponse, SessionNotification, TextContent,
+    VERSION as PROTOCOL_VERSION,
+};
+use sacp_tokio::{AcpAgent, JrConnectionExt};
+use std::path::PathBuf;
+use std::str::FromStr;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Parse command line arguments
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() != 3 {
+        eprintln!("Usage: {} <prompt> <agent-config>", args[0]);
+        eprintln!();
+        eprintln!("  <prompt>       - The prompt to send to the agent");
+        eprintln!("  <agent-config> - Either a command string or JSON (starting with '{{')");
+        eprintln!();
+        eprintln!("Examples:");
+        eprintln!("  {} \"What is 2+2?\" \"python my_agent.py\"", args[0]);
+        eprintln!(
+            "  {} \"Hello!\" '{{\"type\":\"stdio\",\"name\":\"agent\",\"command\":\"python\",\"args\":[\"agent.py\"],\"env\":[]}}'",
+            args[0]
+        );
+        std::process::exit(1);
+    }
+
+    let prompt = &args[1];
+    let agent_config = &args[2];
+
+    // Parse the agent configuration
+    let agent = AcpAgent::from_str(agent_config)?;
+
+    eprintln!("🚀 Spawning agent and connecting...");
+
+    // Run the client
+    JrConnection::to_agent(agent)?
+        .on_receive_notification(async move |notification: SessionNotification, _cx| {
+            // Print session updates to stdout (so 2>/dev/null shows only agent output)
+            println!("{:?}", notification.update);
+            Ok(())
+        })
+        .on_receive_request(async move |request: RequestPermissionRequest, request_cx| {
+            // YOPO: Auto-approve all permission requests by selecting the first option
+            eprintln!("✅ Auto-approving permission request: {:?}", request);
+            let option_id = request.options.first().map(|opt| opt.id.clone());
+            match option_id {
+                Some(id) => request_cx.respond(RequestPermissionResponse {
+                    outcome: RequestPermissionOutcome::Selected { option_id: id },
+                    meta: None,
+                }),
+                None => {
+                    eprintln!("⚠️ No options provided in permission request, cancelling");
+                    request_cx.respond(RequestPermissionResponse {
+                        outcome: RequestPermissionOutcome::Cancelled,
+                        meta: None,
+                    })
+                }
+            }
+        })
+        .with_client(|cx: sacp::JrConnectionCx| async move {
+            // Initialize the agent
+            eprintln!("🤝 Initializing agent...");
+            let init_response = cx
+                .send_request(InitializeRequest {
+                    protocol_version: PROTOCOL_VERSION,
+                    client_capabilities: Default::default(),
+                    client_info: Default::default(),
+                    meta: None,
+                })
+                .block_task()
+                .await?;
+
+            eprintln!("✓ Agent initialized: {:?}", init_response.agent_info);
+
+            // Create a new session
+            eprintln!("📝 Creating new session...");
+            let new_session_response = cx
+                .send_request(NewSessionRequest {
+                    mcp_servers: vec![],
+                    cwd: std::env::current_dir().unwrap_or_else(|_| PathBuf::from("/")),
+                    meta: None,
+                })
+                .block_task()
+                .await?;
+
+            let session_id = new_session_response.session_id;
+            eprintln!("✓ Session created: {}", session_id);
+
+            // Send the prompt
+            eprintln!("💬 Sending prompt: \"{}\"", prompt);
+            let prompt_response = cx
+                .send_request(PromptRequest {
+                    session_id: session_id.clone(),
+                    prompt: vec![ContentBlock::Text(TextContent {
+                        text: prompt.to_string(),
+                        annotations: None,
+                        meta: None,
+                    })],
+                    meta: None,
+                })
+                .block_task()
+                .await?;
+
+            eprintln!("✅ Agent completed!");
+            eprintln!("Stop reason: {:?}", prompt_response.stop_reason);
+
+            Ok(())
+        })
+        .await?;
+
+    Ok(())
+}