feat: add goose-client crate for programmatic goose-server access

Author: wpfleger96

Cargo.lock

@@ -0,0 +1,37 @@
+[package]
+name = "goose-client"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+description = "HTTP client for the goose agent server"
+
+[lints]
+workspace = true
+
+[dependencies]
+goose = { path = "../goose", default-features = false }
+reqwest = { workspace = true, features = ["rustls", "json", "stream", "query"] }
+rmcp = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
+tokio-stream = { workspace = true }
+futures = { workspace = true }
+tracing = { workspace = true }
+bytes = { workspace = true }
+
+[dev-dependencies]
+wiremock = { workspace = true }
+tokio = { workspace = true }
+anyhow = { workspace = true }
+dotenvy = { workspace = true }
+futures = { workspace = true }
+
+[[example]]
+name = "smoke_test"
+
+[[example]]
+name = "chat_stream"

crates/goose-client/Cargo.toml

@@ -0,0 +1,59 @@
+//! Streaming chat: verify SSE streaming against a running goose-server.
+//!
+//! Requires a configured LLM provider. Start goosed first:
+//!   GOOSE_SERVER__SECRET_KEY=test cargo run -p goose-server --bin goosed -- agent
+//!
+//! Then run:
+//!   cargo run -p goose-client --example chat_stream
+
+use futures::StreamExt;
+use goose_client::{GooseClient, GooseClientConfig, MessageEvent, StartAgentRequest};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let _ = dotenvy::dotenv();
+
+    let url =
+        std::env::var("GOOSE_SERVER_URL").unwrap_or_else(|_| "https://127.0.0.1:3000".to_string());
+    let secret = std::env::var("GOOSE_SERVER_SECRET_KEY").unwrap_or_else(|_| "test".to_string());
+
+    let client = GooseClient::new(GooseClientConfig::new(&url, &secret))?;
+    println!("Connecting to {url}");
+
+    let dir = std::env::temp_dir().join("goose-client-chat-test");
+    std::fs::create_dir_all(&dir)?;
+    let session = client
+        .start_agent(StartAgentRequest::new(dir.to_string_lossy()))
+        .await?;
+    println!("Started session {}\n", session.id);
+
+    let mut stream = client
+        .send_message(&session.id, "Say exactly: hello world")
+        .await?;
+
+    let mut got_message = false;
+    let mut got_finish = false;
+
+    while let Some(event) = stream.next().await {
+        match event? {
+            MessageEvent::Message { message, .. } => {
+                got_message = true;
+                println!("[message] {:?}", message);
+            }
+            MessageEvent::Finish { reason, .. } => {
+                got_finish = true;
+                println!("[finish] reason={reason}");
+            }
+            MessageEvent::Ping => {}
+            other => println!("[event] {:?}", other),
+        }
+    }
+
+    assert!(got_message, "expected at least one Message event");
+    assert!(got_finish, "expected a Finish event");
+
+    client.stop_agent(&session.id).await?;
+    client.delete_session(&session.id).await?;
+    println!("\nStreaming test passed.");
+    Ok(())
+}

crates/goose-client/examples/chat_stream.rs

@@ -0,0 +1,60 @@
+//! Smoke test: verify goose-client against a running goose-server.
+//!
+//! Start goosed first:
+//!   GOOSE_SERVER__SECRET_KEY=test cargo run -p goose-server --bin goosed -- agent
+//!
+//! Then run:
+//!   cargo run -p goose-client --example smoke_test
+
+use goose_client::{GooseClient, GooseClientConfig, StartAgentRequest};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let _ = dotenvy::dotenv();
+
+    let url =
+        std::env::var("GOOSE_SERVER_URL").unwrap_or_else(|_| "https://127.0.0.1:3000".to_string());
+    let secret = std::env::var("GOOSE_SERVER_SECRET_KEY").unwrap_or_else(|_| "test".to_string());
+
+    let client = GooseClient::new(GooseClientConfig::new(&url, &secret))?;
+    println!("Connecting to {url}");
+
+    let status = client.status().await?;
+    assert_eq!(status, "ok");
+    println!("[ok] status");
+
+    let dir = std::env::temp_dir().join("goose-client-smoke-test");
+    std::fs::create_dir_all(&dir)?;
+    let session = client
+        .start_agent(StartAgentRequest::new(dir.to_string_lossy()))
+        .await?;
+    println!("[ok] start_agent -> session {}", session.id);
+
+    let list = client.list_sessions().await?;
+    println!("[ok] list_sessions ({} total)", list.sessions.len());
+
+    let fetched = client.get_session(&session.id).await?;
+    assert_eq!(fetched.id, session.id);
+    println!("[ok] get_session");
+
+    client.rename_session(&session.id, "smoke-test").await?;
+    println!("[ok] rename_session");
+
+    let insights = client.get_session_insights().await?;
+    println!(
+        "[ok] get_session_insights -> {} sessions, {} tokens",
+        insights.total_sessions, insights.total_tokens
+    );
+
+    let info = client.system_info().await?;
+    println!("[ok] system_info -> {} {}", info.os, info.os_version);
+
+    client.stop_agent(&session.id).await?;
+    println!("[ok] stop_agent");
+
+    client.delete_session(&session.id).await?;
+    println!("[ok] delete_session");
+
+    println!("\nAll smoke tests passed.");
+    Ok(())
+}

crates/goose-client/examples/smoke_test.rs

@@ -0,0 +1,25 @@
+use crate::error::Result;
+use crate::types::requests::ConfirmToolActionRequest;
+use crate::GooseClient;
+use goose::permission::permission_confirmation::Permission;
+
+impl GooseClient {
+    /// Confirm or deny a pending tool action request.
+    ///
+    /// `id` is the tool request ID received in the SSE stream's `MessageEvent::Message`
+    /// content as a `ToolRequest`. `action` is typically `Permission::AllowOnce`,
+    /// `Permission::DenyOnce`, or `Permission::AlwaysAllow`.
+    pub async fn confirm_tool_action(
+        &self,
+        id: impl Into<String>,
+        action: Permission,
+        session_id: impl Into<String>,
+    ) -> Result<()> {
+        self.http
+            .post_empty(
+                "/action-required/tool-confirmation",
+                &ConfirmToolActionRequest::new(id, action, session_id),
+            )
+            .await
+    }
+}

crates/goose-client/src/api/action_required.rs

@@ -0,0 +1,171 @@
+use crate::error::Result;
+use crate::types::requests::{
+    AddExtensionRequest, ImportAppRequest, ReadResourceRequest, RemoveExtensionRequest,
+    RestartAgentRequest, ResumeAgentRequest, SetContainerRequest, StartAgentRequest,
+    StopAgentRequest, UpdateFromSessionRequest, UpdateProviderRequest, UpdateWorkingDirRequest,
+};
+use crate::types::responses::{
+    ImportAppResponse, ListAppsResponse, ReadResourceResponse, RestartAgentResponse,
+    ResumeAgentResponse,
+};
+use crate::GooseClient;
+use goose::agents::ExtensionConfig;
+use goose::session::Session;
+
+impl GooseClient {
+    pub async fn start_agent(&self, request: StartAgentRequest) -> Result<Session> {
+        self.http.post("/agent/start", &request).await
+    }
+
+    pub async fn resume_agent(
+        &self,
+        session_id: impl Into<String>,
+        load_model_and_extensions: bool,
+    ) -> Result<ResumeAgentResponse> {
+        self.http
+            .post(
+                "/agent/resume",
+                &ResumeAgentRequest {
+                    session_id: session_id.into(),
+                    load_model_and_extensions,
+                },
+            )
+            .await
+    }
+
+    pub async fn stop_agent(&self, session_id: impl Into<String>) -> Result<()> {
+        self.http
+            .post_empty(
+                "/agent/stop",
+                &StopAgentRequest {
+                    session_id: session_id.into(),
+                },
+            )
+            .await
+    }
+
+    pub async fn restart_agent(
+        &self,
+        session_id: impl Into<String>,
+    ) -> Result<RestartAgentResponse> {
+        self.http
+            .post(
+                "/agent/restart",
+                &RestartAgentRequest {
+                    session_id: session_id.into(),
+                },
+            )
+            .await
+    }
+
+    pub async fn update_working_dir(
+        &self,
+        session_id: impl Into<String>,
+        working_dir: impl Into<String>,
+    ) -> Result<()> {
+        self.http
+            .post_empty(
+                "/agent/update_working_dir",
+                &UpdateWorkingDirRequest {
+                    session_id: session_id.into(),
+                    working_dir: working_dir.into(),
+                },
+            )
+            .await
+    }
+
+    pub async fn update_from_session(&self, session_id: impl Into<String>) -> Result<()> {
+        self.http
+            .post_empty(
+                "/agent/update_from_session",
+                &UpdateFromSessionRequest {
+                    session_id: session_id.into(),
+                },
+            )
+            .await
+    }
+
+    pub async fn update_provider(&self, request: UpdateProviderRequest) -> Result<()> {
+        self.http
+            .post_empty("/agent/update_provider", &request)
+            .await
+    }
+
+    pub async fn add_extension(
+        &self,
+        session_id: impl Into<String>,
+        config: ExtensionConfig,
+    ) -> Result<()> {
+        self.http
+            .post_empty(
+                "/agent/add_extension",
+                &AddExtensionRequest {
+                    session_id: session_id.into(),
+                    config,
+                },
+            )
+            .await
+    }
+
+    pub async fn remove_extension(
+        &self,
+        session_id: impl Into<String>,
+        name: impl Into<String>,
+    ) -> Result<()> {
+        self.http
+            .post_empty(
+                "/agent/remove_extension",
+                &RemoveExtensionRequest {
+                    session_id: session_id.into(),
+                    name: name.into(),
+                },
+            )
+            .await
+    }
+
+    pub async fn read_resource(
+        &self,
+        request: ReadResourceRequest,
+    ) -> Result<ReadResourceResponse> {
+        self.http.post("/agent/read_resource", &request).await
+    }
+
+    pub async fn list_apps(&self, session_id: Option<&str>) -> Result<ListAppsResponse> {
+        match session_id {
+            Some(id) => {
+                self.http
+                    .get_with_query("/agent/list_apps", &[("session_id", id)])
+                    .await
+            }
+            None => self.http.get("/agent/list_apps").await,
+        }
+    }
+
+    pub async fn export_app(&self, name: impl AsRef<str>) -> Result<String> {
+        self.http
+            .get_text(&format!("/agent/export_app/{}", name.as_ref()))
+            .await
+    }
+
+    pub async fn import_app(&self, html: impl Into<String>) -> Result<ImportAppResponse> {
+        self.http
+            .post("/agent/import_app", &ImportAppRequest { html: html.into() })
+            .await
+    }
+
+    pub async fn set_container(
+        &self,
+        session_id: impl Into<String>,
+        container_id: Option<String>,
+    ) -> Result<()> {
+        self.http
+            .post_empty(
+                "/agent/set_container",
+                &SetContainerRequest {
+                    session_id: session_id.into(),
+                    container_id,
+                },
+            )
+            .await
+    }
+}