Merge remote-tracking branch 'remotes/origin/main'

Author: octogonz

.github/copilot-instructions.md

@@ -34,8 +34,8 @@
 - Async/await misuse or blocking operations in async contexts
 - Improper trait implementations
 
-### No Prerelease Docs
-- If the PR contains both code changes to features/functionality AND updates in `/documentation`: Documentation updates must be separated to keep public docs in sync with released versions. Either mark new topics with `unlisted: true` or remove/hide the documentation.
+### No Doc Updates with Code Changes
+- PRs with code changes shouldn't update `/documentation` - docs deploy on merge, code on release. Use `unlisted: true` or remove/hide docs.
 
 ## Project-Specific Context
 

CUSTOM_DISTROS.md

@@ -46,7 +46,7 @@ goose's architecture is designed for extensibility. Organizations can create "re
 |---------------|---------------|------------|
 | Preconfigure a model/provider | `config.yaml`, `init-config.yaml`, environment variables | Low |
 | Add custom AI providers | `crates/goose/src/providers/declarative/` | Low |
-| Bundle custom MCP extensions | `config.yaml` extensions section, `ui/desktop/src/built-in-extensions.json` | Medium |
+| Bundle custom MCP extensions | `config.yaml` extensions section, `ui/desktop/src/built-in-extensions.json`, `ui/desktop/src/components/settings/extensions/bundled-extensions.json` | Medium |
 | Modify system prompts | `crates/goose/src/prompts/` | Low |
 | Customize desktop branding | `ui/desktop/` (icons, names, colors) | Medium |
 | Build a new UI (web, mobile) | Integrate with `goose-server` REST API | High |
@@ -191,7 +191,11 @@ async def query_data_lake(query: str) -> str:
     return results
 ```
 
-2. **Bundle as a built-in extension** by adding to `ui/desktop/src/built-in-extensions.json`:
+2. **Bundle as a built-in extension** by adding to either:
+   - `ui/desktop/src/built-in-extensions.json` (core built-ins surfaced in extension UI)
+   - `ui/desktop/src/components/settings/extensions/bundled-extensions.json` (bundled extension catalog in Settings)
+
+Example:
 
 ```json
 {
@@ -268,6 +272,26 @@ You are an AI assistant called [YourName], created by [YourCompany].
    - Component text and labels
    - Feature visibility
 
+5. **Align packaging and updater names** when rebranding:
+   - Update static branding metadata in `ui/desktop/package.json` (`productName`, description) and Linux desktop templates (`ui/desktop/forge.deb.desktop`, `ui/desktop/forge.rpm.desktop`)
+
+   - Set build/release environment variables consistently:
+     - `GITHUB_OWNER` and `GITHUB_REPO` for publisher + updater repository lookup
+     - `GOOSE_BUNDLE_NAME` for bundle/debug scripts and updater asset naming (defaults to `Goose`)
+
+Example:
+
+```bash
+export GITHUB_OWNER="your-org"
+export GITHUB_REPO="your-goose-fork"
+export GOOSE_BUNDLE_NAME="InsightStream-goose"
+```
+
+6. **Use this branding consistency checklist** before release:
+   - Application metadata (`forge.config.ts`, `package.json`, `index.html`) uses your distro name
+   - Release artifact names and updater lookup names are consistent
+   - Desktop launchers (Linux `.desktop` templates) point to the same executable name produced by packaging
+
 ### Technical Details
 
 - Electron config: `ui/desktop/forge.config.ts`

Cargo.lock

@@ -35,7 +35,7 @@ Designed for maximum flexibility, goose works with any LLM and supports multi-mo
 - [Diagnostics & Reporting](https://block.github.io/goose/docs/troubleshooting/diagnostics-and-reporting)
 - [Known Issues](https://block.github.io/goose/docs/troubleshooting/known-issues)
 
-# a little goose humor 🦢
+# a little goose humor 🪿
 
 > Why did the developer choose goose as their AI agent?
 > 

README.md

@@ -23,7 +23,7 @@ goose = { path = "../goose" }
 goose-mcp = { path = "../goose-mcp" }
 rmcp = { workspace = true }
 sacp = "10.1.0"
-agent-client-protocol-schema = { version = "0.10", features = ["unstable_session_model"] }
+agent-client-protocol-schema = { version = "0.10", features = ["unstable_session_model", "unstable_session_list"] }
 anyhow = { workspace = true }
 tokio = { workspace = true }
 tokio-util = { workspace = true, features = ["compat", "rt"] }

crates/goose-acp/Cargo.toml

@@ -82,12 +82,6 @@ pub struct GetSessionResponse {
     pub session: serde_json::Value,
 }
 
-/// List all sessions.
-#[derive(Debug, Serialize, JsonSchema)]
-pub struct ListSessionsResponse {
-    pub sessions: Vec<serde_json::Value>,
-}
-
 /// Delete a session.
 #[derive(Debug, Deserialize, JsonSchema)]
 pub struct DeleteSessionRequest {

crates/goose-acp/src/custom_requests.rs

@@ -24,10 +24,11 @@ use sacp::schema::{
     AgentCapabilities, AuthMethod, AuthenticateRequest, AuthenticateResponse, BlobResourceContents,
     CancelNotification, Content, ContentBlock, ContentChunk, EmbeddedResource,
     EmbeddedResourceResource, ImageContent, InitializeRequest, InitializeResponse,
-    LoadSessionRequest, LoadSessionResponse, McpCapabilities, McpServer, ModelId, ModelInfo,
-    NewSessionRequest, NewSessionResponse, PermissionOption, PermissionOptionKind,
-    PromptCapabilities, PromptRequest, PromptResponse, RequestPermissionOutcome,
-    RequestPermissionRequest, ResourceLink, SessionId, SessionModelState, SessionNotification,
+    ListSessionsResponse, LoadSessionRequest, LoadSessionResponse, McpCapabilities, McpServer,
+    ModelId, ModelInfo, NewSessionRequest, NewSessionResponse, PermissionOption,
+    PermissionOptionKind, PromptCapabilities, PromptRequest, PromptResponse,
+    RequestPermissionOutcome, RequestPermissionRequest, ResourceLink, SessionCapabilities,
+    SessionId, SessionInfo, SessionListCapabilities, SessionModelState, SessionNotification,
     SessionUpdate, SetSessionModelRequest, SetSessionModelResponse, StopReason, TextContent,
     TextResourceContents, ToolCall, ToolCallContent, ToolCallId, ToolCallLocation, ToolCallStatus,
     ToolCallUpdate, ToolCallUpdateFields, ToolKind,
@@ -102,24 +103,34 @@ fn create_tool_location(path: &str, line: Option<u32>) -> ToolCallLocation {
     loc
 }
 
+fn is_developer_file_tool(tool_name: &str) -> bool {
+    matches!(tool_name, "write" | "edit")
+}
+
 fn extract_tool_locations(
     tool_request: &goose::conversation::message::ToolRequest,
     tool_response: &goose::conversation::message::ToolResponse,
 ) -> Vec<ToolCallLocation> {
     let mut locations = Vec::new();
 
     if let Ok(tool_call) = &tool_request.tool_call {
-        if tool_call.name != "developer__text_editor" {
+        if !is_developer_file_tool(tool_call.name.as_ref()) {
             return locations;
         }
 
+        let tool_name = tool_call.name.as_ref();
         let path_str = tool_call
             .arguments
             .as_ref()
             .and_then(|args| args.get("path"))
             .and_then(|p| p.as_str());
 
         if let Some(path_str) = path_str {
+            if matches!(tool_name, "write" | "edit") {
+                locations.push(create_tool_location(path_str, Some(1)));
+                return locations;
+            }
+
             let command = tool_call
                 .arguments
                 .as_ref()
@@ -276,20 +287,21 @@ async fn add_extensions(agent: &Agent, extensions: Vec<ExtensionConfig>) {
     }
 }
 
-async fn build_model_state(
-    provider: &dyn Provider,
-    current_model: &str,
-) -> Result<SessionModelState, sacp::Error> {
-    let models = provider.fetch_recommended_models().await.map_err(|e| {
-        sacp::Error::internal_error().data(format!("Failed to fetch models: {}", e))
-    })?;
-    Ok(SessionModelState::new(
+async fn build_model_state(provider: &dyn Provider, current_model: &str) -> SessionModelState {
+    let models = match provider.fetch_recommended_models().await {
+        Ok(models) => models,
+        Err(e) => {
+            warn!(error = %e, "failed to fetch models, model selection will be unavailable");
+            vec![]
+        }
+    };
+    SessionModelState::new(
         ModelId::new(current_model),
         models
             .iter()
             .map(|name| ModelInfo::new(ModelId::new(&**name), &**name))
             .collect(),
-    ))
+    )
 }
 
 impl GooseAcpAgent {
@@ -653,6 +665,7 @@ impl GooseAcpAgent {
 
         let capabilities = AgentCapabilities::new()
             .load_session(true)
+            .session_capabilities(SessionCapabilities::new().list(SessionListCapabilities::new()))
             .prompt_capabilities(
                 PromptCapabilities::new()
                     .image(true)
@@ -728,7 +741,7 @@ impl GooseAcpAgent {
         );
 
         let model_state =
-            build_model_state(&*provider, &provider.get_model_config().model_name).await?;
+            build_model_state(&*provider, &provider.get_model_config().model_name).await;
 
         Ok(NewSessionResponse::new(SessionId::new(goose_session.id)).models(model_state))
     }
@@ -853,7 +866,7 @@ impl GooseAcpAgent {
         );
 
         let model_state =
-            build_model_state(&*provider, &provider.get_model_config().model_name).await?;
+            build_model_state(&*provider, &provider.get_model_config().model_name).await;
 
         Ok(LoadSessionResponse::new().models(model_state))
     }
@@ -1086,14 +1099,15 @@ impl GooseAcpAgent {
             .list_sessions()
             .await
             .map_err(|e| sacp::Error::internal_error().data(e.to_string()))?;
-        let sessions_json = sessions
+        let session_infos: Vec<SessionInfo> = sessions
             .into_iter()
-            .map(|s| serde_json::to_value(&s))
-            .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| sacp::Error::internal_error().data(e.to_string()))?;
-        Ok(ListSessionsResponse {
-            sessions: sessions_json,
-        })
+            .map(|s| {
+                SessionInfo::new(SessionId::new(s.id), s.working_dir)
+                    .title(s.name)
+                    .updated_at(s.updated_at.to_rfc3339())
+            })
+            .collect();
+        Ok(ListSessionsResponse::new(session_infos))
     }
 
     #[custom_method("session/get")]
@@ -1275,6 +1289,14 @@ impl JrMessageHandler for GooseAcpHandler {
                                 request_cx.respond(json)?;
                                 Ok(())
                             }
+                            MessageCx::Request(req, request_cx) if req.method == "session/list" => {
+                                let resp = agent.on_list_sessions().await?;
+                                let json = serde_json::to_value(resp).map_err(|e| {
+                                    sacp::Error::internal_error().data(e.to_string())
+                                })?;
+                                request_cx.respond(json)?;
+                                Ok(())
+                            }
                             MessageCx::Request(req, request_cx) if req.method.starts_with('_') => {
                                 match agent.handle_custom_request(&req.method, req.params).await {
                                     Ok(json) => request_cx.respond(json)?,
@@ -1432,10 +1454,7 @@ print(\"hello, world\")
 
     #[test]
     fn test_format_tool_name_with_extension() {
-        assert_eq!(
-            format_tool_name("developer__text_editor"),
-            "Developer: Text Editor"
-        );
+        assert_eq!(format_tool_name("developer__edit"), "Developer: Edit");
         assert_eq!(
             format_tool_name("platform__manage_extensions"),
             "Platform: Manage Extensions"
@@ -1521,37 +1540,37 @@ print(\"hello, world\")
 
     #[test_case(
         "model-a", Ok(vec!["model-a".into(), "model-b".into()])
-        => Ok(SessionModelState::new(
+        => SessionModelState::new(
             ModelId::new("model-a"),
             vec![ModelInfo::new(ModelId::new("model-a"), "model-a"),
                  ModelInfo::new(ModelId::new("model-b"), "model-b")],
-        ))
+        )
         ; "returns current and available models"
     )]
     #[test_case(
         "model-a", Ok(vec![])
-        => Ok(SessionModelState::new(ModelId::new("model-a"), vec![]))
+        => SessionModelState::new(ModelId::new("model-a"), vec![])
         ; "empty model list"
     )]
     #[test_case(
         "model-a", Err(ProviderError::ExecutionError("fail".into()))
-        => matches Err(_)
-        ; "fetch error propagates"
+        => SessionModelState::new(ModelId::new("model-a"), vec![])
+        ; "fetch error falls back to current model only"
     )]
     #[test_case(
         "switched-model", Ok(vec!["model-a".into(), "switched-model".into()])
-        => Ok(SessionModelState::new(
+        => SessionModelState::new(
             ModelId::new("switched-model"),
             vec![ModelInfo::new(ModelId::new("model-a"), "model-a"),
                  ModelInfo::new(ModelId::new("switched-model"), "switched-model")],
-        ))
+        )
         ; "current model reflects switched model"
     )]
     #[tokio::test]
     async fn test_build_model_state(
         current_model: &str,
         models: Result<Vec<String>, ProviderError>,
-    ) -> Result<SessionModelState, sacp::Error> {
+    ) -> SessionModelState {
         let provider = MockModelProvider { models };
         build_model_state(&provider, current_model).await
     }

crates/goose-acp/src/server.rs

@@ -313,7 +313,7 @@ pub async fn run_prompt_basic<C: Connection>() {
 pub async fn run_prompt_codemode<C: Connection>() {
     let expected_session_id = ExpectedSessionId::default();
     let prompt =
-        "Search for getCode and textEditor tools. Use them to save the code to /tmp/result.txt.";
+        "Search for getCode and write tools. Use them to save the code to /tmp/result.txt.";
     let mcp = McpFixture::new(Some(expected_session_id.clone())).await;
     let openai = OpenAiFixture::new(
         vec![
@@ -326,7 +326,7 @@ pub async fn run_prompt_codemode<C: Connection>() {
                 include_str!("../test_data/openai_builtin_execute.txt"),
             ),
             (
-                r#"Successfully wrote to /tmp/result.txt"#.into(),
+                r#"Created /tmp/result.txt"#.into(),
                 include_str!("../test_data/openai_builtin_final.txt"),
             ),
         ],
@@ -352,7 +352,7 @@ pub async fn run_prompt_codemode<C: Connection>() {
     }
 
     let result = fs::read_to_string("/tmp/result.txt").unwrap_or_default();
-    assert_eq!(result, format!("{FAKE_CODE}\n"));
+    assert_eq!(result, FAKE_CODE);
     expected_session_id.assert_matches(&session.session_id().0);
 }