refactor (cleanup): Removed mcp sampling (#12193)

This commit is contained in:
Lifei Zhou
2026-09-22 23:47:04 +00:00
committed by GitHub
parent 9fd1051bb0
commit 7b68b47ffd
15 changed files with 36 additions and 863 deletions
@@ -497,7 +497,6 @@ impl ExtensionManager {
.unwrap_or_else(|| std::env::current_dir().unwrap_or_default());
let ctx = |timeout: Option<u64>, working_dir: PathBuf| ConnectContext {
timeout: Duration::from_secs(resolve_timeout(timeout)),
provider: self.provider.clone(),
client_name: self.client_name.clone(),
capabilities: self.mcp_client_capabilities(),
working_dir,
@@ -695,7 +695,6 @@ mod tests {
fn test_ctx(working_dir: &std::path::Path) -> ConnectContext {
ConnectContext {
timeout: Duration::from_secs(5),
provider: Arc::new(Mutex::new(None)),
client_name: "goose-test".to_string(),
capabilities: GooseMcpClientCapabilities {
mcpui: false,
+9 -209
View File
@@ -1,15 +1,10 @@
use crate::action_required_manager::{ActionRequiredManager, ElicitationOutcome};
use crate::agents::extension_manager::ExtensionManager;
use crate::agents::tool_execution::ToolCallContext;
use crate::agents::types::SharedProvider;
use crate::session_context::{SESSION_ID_HEADER, TOOL_CALL_REQUEST_ID_HEADER, WORKING_DIR_HEADER};
/// MCP client implementation for Goose
#[expect(deprecated)]
use rmcp::model::{CreateMessageRequestParams, CreateMessageResult, SamplingMessage};
#[expect(deprecated)]
use rmcp::model::{
ElicitRequestParams, ElicitResult, ListRootsResult, LoggingMessageNotification, Root,
SamplingMessageContentBlock,
};
use rmcp::model::{
ElicitationAction, ErrorCode, ExtensionCapabilities, Extensions, JsonObject, MetaObject,
@@ -21,7 +16,7 @@ use rmcp::{
InitializeRequestParams, InitializeResult, ListPromptsResult, ListResourcesResult,
ListToolsResult, Notification, PaginatedRequestParams, ProtocolVersion,
ReadResourceRequestParams, ReadResourceResult, Request, RequestId, RequestOptionalParam,
Role, ServerNotification, ServerResult,
ServerNotification, ServerResult,
},
service::{
ClientInitializeError, ClientLifecycleMode, ClientServiceExt, PeerRequestOptions,
@@ -50,35 +45,6 @@ pub type Error = rmcp::ServiceError;
const MCP_APPS_UI_EXTENSION_ID: &str = "io.modelcontextprotocol/ui";
const MCP_APPS_UI_MIME_TYPE: &str = "text/html;profile=mcp-app";
fn extract_sampling_text(
content: &[crate::conversation::message::MessageContent],
) -> Option<String> {
let visible_content = content
.iter()
.filter_map(crate::conversation::message::MessageContent::user_visible_content)
.collect::<Vec<_>>();
let text = visible_content
.iter()
.filter_map(|content| match content {
crate::conversation::message::MessageContent::Text(text)
if !text.text.trim().is_empty() =>
{
Some(text.text.as_str())
}
_ => None,
})
.collect::<String>();
(!text.is_empty()).then_some(text)
}
fn resolve_sampling_model_config() -> anyhow::Result<goose_providers::model::ModelConfig> {
let config = crate::config::Config::global();
let provider_name = config.get_goose_provider()?;
let model_name = config.get_goose_model()?;
crate::model_config::model_config_from_user_config(&provider_name, &model_name)
}
fn default_mcp_apps_ui_extensions() -> ExtensionCapabilities {
let mut extensions = ExtensionCapabilities::new();
let mut ui_extension_settings = JsonObject::new();
@@ -205,7 +171,6 @@ impl Drop for ActiveToolCallGuard {
pub struct GooseClient {
notification_handlers: Arc<Mutex<Vec<Sender<ServerNotification>>>>,
provider: SharedProvider,
session_id: Mutex<Option<String>>,
active_tool_calls: Arc<StdMutex<HashMap<String, Vec<String>>>>,
client_name: String,
@@ -218,7 +183,6 @@ pub struct GooseClient {
impl GooseClient {
pub(crate) fn new(
handlers: Arc<Mutex<Vec<Sender<ServerNotification>>>>,
provider: SharedProvider,
client_name: String,
capabilities: GooseMcpClientCapabilities,
working_dir: PathBuf,
@@ -227,7 +191,6 @@ impl GooseClient {
) -> Self {
GooseClient {
notification_handlers: handlers,
provider,
session_id: Mutex::new(None),
active_tool_calls: Arc::new(StdMutex::new(HashMap::new())),
client_name,
@@ -429,100 +392,6 @@ impl ClientHandler for GooseClient {
);
}
#[expect(deprecated)]
async fn create_message(
&self,
params: CreateMessageRequestParams,
context: RequestContext<RoleClient>,
) -> Result<CreateMessageResult, ErrorData> {
let provider = self
.provider
.lock()
.await
.as_ref()
.ok_or(ErrorData::new(
ErrorCode::INTERNAL_ERROR,
"Could not use provider",
None,
))?
.clone();
// Prefer explicit MCP metadata, then the active request scope.
let session_id = self.resolve_session_id(&context.extensions).await;
let provider_ready_messages: Vec<crate::conversation::message::Message> = params
.messages
.iter()
.map(|msg| {
let base = match msg.role {
Role::User => crate::conversation::message::Message::user(),
Role::Assistant => crate::conversation::message::Message::assistant(),
};
match msg.content.first().and_then(|c| c.as_text()) {
Some(text) => base.with_text(&text.text),
None => base,
}
})
.collect();
let system_prompt = params
.system_prompt
.as_deref()
.unwrap_or("You are a general-purpose AI agent called goose");
let model_config = resolve_sampling_model_config().map_err(|e| {
ErrorData::new(
ErrorCode::INTERNAL_ERROR,
"Could not resolve model config",
Some(Value::from(e.to_string())),
)
})?;
let (response, usage) = crate::session_context::with_session_id(
session_id.clone(),
provider.complete(&model_config, system_prompt, &provider_ready_messages, &[]),
)
.await
.map_err(|e| {
ErrorData::new(
ErrorCode::INTERNAL_ERROR,
"Unexpected error while completing the prompt",
Some(Value::from(e.to_string())),
)
})?;
let sampling_content = if let Some(text) = extract_sampling_text(&response.content) {
SamplingMessageContentBlock::text(text)
} else if let Some(crate::conversation::message::MessageContent::Image(img)) = response
.content
.iter()
.filter_map(crate::conversation::message::MessageContent::user_visible_content)
.find(|content| {
matches!(
content,
crate::conversation::message::MessageContent::Image(_)
)
})
{
SamplingMessageContentBlock::Image(rmcp::model::ImageContent::new(
img.data.clone(),
img.mime_type.clone(),
))
} else {
return Err(ErrorData::new(
ErrorCode::INTERNAL_ERROR,
"Provider returned no usable text or image content for sampling",
None,
));
};
Ok(CreateMessageResult::new(
SamplingMessage::new(Role::Assistant, sampling_content),
usage.model,
)
.with_stop_reason(CreateMessageResult::STOP_REASON_END_TURN))
}
async fn create_elicitation(
&self,
request: ElicitRequestParams,
@@ -599,7 +468,6 @@ impl ClientHandler for GooseClient {
ClientCapabilities::builder()
.enable_roots()
.enable_extensions_with(extensions)
.enable_sampling()
.enable_elicitation()
.build(),
self.resolved_client_info(),
@@ -638,7 +506,6 @@ impl std::fmt::Debug for GooseMcpClientCapabilities {
#[derive(Clone)]
pub(crate) struct ConnectContext {
pub timeout: Duration,
pub provider: SharedProvider,
pub client_name: String,
pub capabilities: GooseMcpClientCapabilities,
pub working_dir: PathBuf,
@@ -667,7 +534,6 @@ impl McpClient {
{
let ConnectContext {
timeout,
provider,
client_name,
capabilities,
working_dir,
@@ -680,7 +546,6 @@ impl McpClient {
let client = GooseClient::new(
notification_subscribers.clone(),
provider,
client_name.clone(),
capabilities.clone(),
working_dir,
@@ -1171,74 +1036,6 @@ fn inject_session_context_into_request(
mod tests {
use super::*;
#[test]
fn sampling_text_preserves_text_first_provider_responses() {
let response = crate::conversation::message::Message::assistant().with_text("answer");
assert_eq!(
extract_sampling_text(&response.content).as_deref(),
Some("answer")
);
}
#[test]
fn sampling_text_skips_thinking_before_final_text() {
let response = crate::conversation::message::Message::assistant()
.with_thinking("internal reasoning", "signature")
.with_text("final answer");
assert_eq!(
extract_sampling_text(&response.content).as_deref(),
Some("final answer")
);
}
#[test]
fn sampling_text_preserves_fragments_around_thinking() {
let response = crate::conversation::message::Message::assistant()
.with_text("first")
.with_thinking("internal reasoning", "signature")
.with_text(" second");
assert_eq!(
extract_sampling_text(&response.content).as_deref(),
Some("first second")
);
}
#[test]
fn sampling_text_excludes_assistant_only_blocks_without_changing_visible_text() {
let assistant_only = rmcp::model::TextContent::new("assistant only").with_annotations(
rmcp::model::Annotations::default().with_audience(vec![Role::Assistant]),
);
let response = crate::conversation::message::Message::assistant()
.with_text("Hello")
.with_content(crate::conversation::message::MessageContent::Text(
assistant_only,
))
.with_text(" world");
assert_eq!(
extract_sampling_text(&response.content).as_deref(),
Some("Hello world")
);
}
#[test]
fn sampling_text_rejects_thinking_only_responses() {
let response = crate::conversation::message::Message::assistant()
.with_thinking("internal reasoning", "signature");
assert_eq!(extract_sampling_text(&response.content), None);
}
#[test]
fn sampling_does_not_expose_json_from_thinking_only_response() {
let response = crate::conversation::message::Message::assistant()
.with_thinking("{\"private\":true}", "signature");
assert_eq!(extract_sampling_text(&response.content), None);
}
use crate::agents::extension::ExtensionConfig;
use crate::agents::GoosePlatform;
use rmcp::model::Tool;
@@ -1314,7 +1111,6 @@ mod tests {
GooseClient::new(
Arc::new(Mutex::new(Vec::new())),
Arc::new(Mutex::new(None)),
platform.to_string(),
capabilities,
std::env::current_dir().unwrap_or_default(),
@@ -1348,7 +1144,6 @@ mod tests {
let goose_client = GooseClient::new(
Arc::new(Mutex::new(Vec::new())),
Arc::new(Mutex::new(None)),
"goose-test".to_string(),
GooseMcpClientCapabilities {
mcpui: false,
@@ -1717,11 +1512,18 @@ mod tests {
);
}
#[test]
fn test_client_capabilities_do_not_advertise_sampling() {
let client = new_client(GoosePlatform::GooseCli);
let info = ClientHandler::get_info(&client);
let capabilities = serde_json::to_value(info.capabilities).unwrap();
assert!(capabilities.get("sampling").is_none());
}
#[test]
fn test_explicit_host_info_passes_through_client_identity() {
let client = GooseClient::new(
Arc::new(Mutex::new(Vec::new())),
Arc::new(Mutex::new(None)),
GoosePlatform::GooseDesktop.to_string(),
GooseMcpClientCapabilities {
mcpui: true,
@@ -1756,7 +1558,6 @@ mod tests {
fn test_explicit_host_extensions_override_platform_fallback() {
let client = GooseClient::new(
Arc::new(Mutex::new(Vec::new())),
Arc::new(Mutex::new(None)),
GoosePlatform::GooseCli.to_string(),
GooseMcpClientCapabilities {
mcpui: false,
@@ -1788,7 +1589,6 @@ mod tests {
fn test_host_identity_does_not_disable_platform_fallback_without_explicit_extensions() {
let client = GooseClient::new(
Arc::new(Mutex::new(Vec::new())),
Arc::new(Mutex::new(None)),
GoosePlatform::GooseDesktop.to_string(),
GooseMcpClientCapabilities {
mcpui: true,
+3 -62
View File
@@ -6,24 +6,16 @@ use std::path::PathBuf;
use std::sync::Arc;
use std::{env, fs};
use rmcp::model::{CallToolRequestParams, CallToolResult, Tool};
use rmcp::model::{CallToolRequestParams, CallToolResult};
use rmcp::object;
use tokio_util::sync::CancellationToken;
use goose::agents::extension::{Envs, ExtensionConfig};
use goose::agents::extension_manager::{ExtensionManager, ExtensionManagerCapabilities};
use goose::agents::GoosePlatform;
use goose_providers::model::ModelConfig;
use test_case::test_case;
use async_trait::async_trait;
use goose::conversation::message::Message;
use goose::providers::base::{
stream_from_single_message, MessageStream, Provider, ProviderDef, ProviderMetadata,
};
use goose_providers::conversation::token_usage::{ProviderUsage, Usage};
use goose_providers::errors::ProviderError;
use once_cell::sync::Lazy;
use std::process::Command;
@@ -40,51 +32,6 @@ struct Target {
kind: Vec<String>,
}
#[derive(Clone, Default)]
pub struct MockProvider;
impl MockProvider {
pub fn new() -> Self {
Self
}
}
impl goose::providers::base::ProviderDescriptor for MockProvider {
fn metadata() -> ProviderMetadata {
ProviderMetadata::empty()
}
}
impl ProviderDef for MockProvider {
type Provider = Self;
fn from_env(
_extensions: Vec<goose::config::ExtensionConfig>,
_tls_config: Option<goose::providers::api_client::TlsConfig>,
) -> futures::future::BoxFuture<'static, anyhow::Result<Self>> {
Box::pin(async move { Ok(Self::new()) })
}
}
#[async_trait]
impl Provider for MockProvider {
fn get_name(&self) -> &str {
"mock"
}
async fn stream(
&self,
_model_config: &ModelConfig,
_system: &str,
_messages: &[Message],
_tools: &[Tool],
) -> Result<MessageStream, ProviderError> {
let message = Message::assistant().with_text("\"So we beat on, boats against the current, borne back ceaselessly into the past.\" — F. Scott Fitzgerald, The Great Gatsby (1925)");
let usage = ProviderUsage::new("mock".to_string(), Usage::default());
Ok(stream_from_single_message(message, usage))
}
}
fn build_and_get_binary_path() -> PathBuf {
let output = Command::new("cargo")
.args([
@@ -134,8 +81,7 @@ enum TestMode {
CallToolRequestParams::new("echo").with_arguments(object!({"message": "Hello, world!" })),
CallToolRequestParams::new("get-sum").with_arguments(object!({"a": 1, "b": 2 })),
CallToolRequestParams::new("trigger-long-running-operation").with_arguments(object!({"duration": 1, "steps": 5 })),
CallToolRequestParams::new("get-structured-content").with_arguments(object!({"location": "New York"})),
CallToolRequestParams::new("trigger-sampling-request").with_arguments(object!({"prompt": "Please provide a quote from The Great Gatsby", "maxTokens": 100 }))
CallToolRequestParams::new("get-structured-content").with_arguments(object!({"location": "New York"}))
],
vec![]
)]
@@ -177,8 +123,6 @@ async fn test_replayed_session(
let _env = env_lock::lock_env([
("GOOSE_MCP_CLIENT_VERSION", Some("0.0.0")),
("GOOSE_PROVIDER", Some("openai")),
("GOOSE_MODEL", Some("gpt-4o")),
("GOOSE_WORKING_DIR", Some(TEST_WORKING_DIR)),
]);
@@ -256,15 +200,12 @@ async fn test_replayed_session(
available_tools: vec![],
};
let provider = Arc::new(tokio::sync::Mutex::new(Some(
Arc::new(MockProvider::new()) as Arc<dyn Provider>
)));
let temp_dir = tempfile::tempdir().unwrap();
let session_manager = Arc::new(goose::session::SessionManager::new(
temp_dir.path().to_path_buf(),
));
let extension_manager = Arc::new(ExtensionManager::new(
provider,
Arc::new(tokio::sync::Mutex::new(None)),
session_manager,
None,
GoosePlatform::GooseDesktop.to_string(),
File diff suppressed because one or more lines are too long
@@ -1,7 +1,7 @@
STDIN: {"jsonrpc":"2.0","id":0,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"goose-desktop","version":"0.0.0"},"io.modelcontextprotocol/clientCapabilities":{"extensions":{"io.modelcontextprotocol/ui":{"mimeTypes":["text/html;profile=mcp-app"]}},"roots":{},"sampling":{},"elicitation":{}}}}}
STDIN: {"jsonrpc":"2.0","id":0,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"goose-desktop","version":"0.0.0"},"io.modelcontextprotocol/clientCapabilities":{"extensions":{"io.modelcontextprotocol/ui":{"mimeTypes":["text/html;profile=mcp-app"]}},"roots":{},"elicitation":{}}}}}
STDERR: Starting default (STDIO) server...
STDOUT: {"jsonrpc":"2.0","id":0,"error":{"code":-32601,"message":"Method not found"}}
STDIN: {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{"extensions":{"io.modelcontextprotocol/ui":{"mimeTypes":["text/html;profile=mcp-app"]}},"roots":{},"sampling":{},"elicitation":{}},"clientInfo":{"name":"goose-desktop","version":"0.0.0"}}}
STDIN: {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{"extensions":{"io.modelcontextprotocol/ui":{"mimeTypes":["text/html;profile=mcp-app"]}},"roots":{},"elicitation":{}},"clientInfo":{"name":"goose-desktop","version":"0.0.0"}}}
STDOUT: {"result":{"protocolVersion":"2025-11-25","capabilities":{"tools":{"listChanged":true},"prompts":{"listChanged":true},"resources":{"subscribe":true,"listChanged":true},"logging":{},"completions":{}},"serverInfo":{"name":"mcp-servers/everything","title":"Everything Reference Server","version":"2.0.0"},"instructions":"# Everything Server – Server Instructions\n\nAudience: These instructions are written for an LLM or autonomous agent integrating with the Everything MCP Server.\nFollow them to use, extend, and troubleshoot the server safely and effectively.\n\n## Cross-Feature Relationships\n\n- Use `get-roots-list` to see client workspace roots before file operations\n- `gzip-file-as-resource` creates session-scoped resources accessible only during the current session\n- Enable `toggle-simulated-logging` before debugging to see server log messages\n- Enable `toggle-subscriber-updates` to receive periodic resource update notifications\n\n## Constraints & Limitations\n\n- `gzip-file-as-resource`: Max fetch size controlled by `GZIP_MAX_FETCH_SIZE` (default 10MB), timeout by `GZIP_MAX_FETCH_TIME_MILLIS` (default 30s), allowed domains by `GZIP_ALLOWED_DOMAINS`\n- Session resources are ephemeral and lost when the session ends\n- Sampling requests (`trigger-sampling-request`) require client sampling capability\n- Elicitation requests (`trigger-elicitation-request`) require client elicitation capability\n\n## Operational Patterns\n\n- For long operations, use `trigger-long-running-operation` which sends progress notifications\n- Prefer reading resources before calling mutating tools\n- Check `get-roots-list` output to understand the client's workspace context\n\n## Easter Egg\n\nIf asked about server instructions, respond with \"🎉 Server instructions are working! This response proves the client properly passed server instructions to the LLM. This demonstrates MCP's instructions feature in action.\"\n"},"jsonrpc":"2.0","id":1}
STDIN: {"jsonrpc":"2.0","method":"notifications/initialized"}
STDIN: {"jsonrpc":"2.0","id":2,"method":"tools/list","params":{"_meta":{"agent-session-id":"test-session-id","progressToken":0}}}
@@ -27,7 +27,3 @@ STDOUT: {"method":"notifications/progress","params":{"progress":5,"total":5,"pro
STDOUT: {"result":{"content":[{"type":"text","text":"Long running operation completed. Duration: 1 seconds, Steps: 5."}]},"jsonrpc":"2.0","id":6}
STDIN: {"jsonrpc":"2.0","id":7,"method":"tools/call","params":{"_meta":{"agent-session-id":"test-session-id","agent-tool-call-request-id":"test-id","progressToken":5},"name":"get-structured-content","arguments":{"location":"New York"}}}
STDOUT: {"result":{"content":[{"type":"text","text":"{\"temperature\":33,\"conditions\":\"Cloudy\",\"humidity\":82}"}],"structuredContent":{"temperature":33,"conditions":"Cloudy","humidity":82}},"jsonrpc":"2.0","id":7}
STDIN: {"jsonrpc":"2.0","id":8,"method":"tools/call","params":{"_meta":{"agent-session-id":"test-session-id","agent-tool-call-request-id":"test-id","progressToken":6},"name":"trigger-sampling-request","arguments":{"prompt":"Please provide a quote from The Great Gatsby","maxTokens":100}}}
STDOUT: {"method":"sampling/createMessage","params":{"messages":[{"role":"user","content":{"type":"text","text":"Resource trigger-sampling-request context: Please provide a quote from The Great Gatsby"}}],"systemPrompt":"You are a helpful test server.","maxTokens":100,"temperature":0.7},"jsonrpc":"2.0","id":1}
STDIN: {"jsonrpc":"2.0","id":1,"result":{"model":"mock","stopReason":"endTurn","role":"assistant","content":{"type":"text","text":"\"So we beat on, boats against the current, borne back ceaselessly into the past.\" — F. Scott Fitzgerald, The Great Gatsby (1925)"}}}
STDOUT: {"result":{"content":[{"type":"text","text":"LLM sampling result: \n{\n \"model\": \"mock\",\n \"stopReason\": \"endTurn\",\n \"role\": \"assistant\",\n \"content\": {\n \"type\": \"text\",\n \"text\": \"\\\"So we beat on, boats against the current, borne back ceaselessly into the past.\\\" — F. Scott Fitzgerald, The Great Gatsby (1925)\"\n }\n}"}]},"jsonrpc":"2.0","id":8}
@@ -35,13 +35,5 @@
"conditions": "Cloudy",
"humidity": 82
}
},
{
"content": [
{
"type": "text",
"text": "LLM sampling result: \n{\n \"model\": \"mock\",\n \"stopReason\": \"endTurn\",\n \"role\": \"assistant\",\n \"content\": {\n \"type\": \"text\",\n \"text\": \"\\\"So we beat on, boats against the current, borne back ceaselessly into the past.\\\" — F. Scott Fitzgerald, The Great Gatsby (1925)\"\n }\n}"
}
]
}
]
]
@@ -1,4 +1,4 @@
STDIN: {"jsonrpc":"2.0","id":0,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"goose-desktop","version":"0.0.0"},"io.modelcontextprotocol/clientCapabilities":{"extensions":{"io.modelcontextprotocol/ui":{"mimeTypes":["text/html;profile=mcp-app"]}},"roots":{},"sampling":{},"elicitation":{}}}}}
STDIN: {"jsonrpc":"2.0","id":0,"method":"server/discover","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientInfo":{"name":"goose-desktop","version":"0.0.0"},"io.modelcontextprotocol/clientCapabilities":{"extensions":{"io.modelcontextprotocol/ui":{"mimeTypes":["text/html;profile=mcp-app"]}},"roots":{},"elicitation":{}}}}}
STDERR: warning: The `native-tls` setting is deprecated and will be removed in a future release. Use `system-certs` instead.
STDERR: /Users/jackamadeo/.cache/uv/archive-v0/bp02wML-MrQTiYuR/lib/python3.14/site-packages/fastmcp/server/auth/providers/jwt.py:10: AuthlibDeprecationWarning: authlib.jose module is deprecated, please use joserfc instead.
STDERR: It will be compatible before version 2.0.0.
@@ -131,7 +131,7 @@ STDERR: CancelTaskRequest.params.taskId
STDERR: Field required [type=missing, input_value={'_meta': {'io.modelconte...{}, 'elicitation': {}}}}, input_type=dict]
STDERR: For further information visit https://errors.pydantic.dev/2.13/v/missing
STDOUT: {"jsonrpc":"2.0","id":0,"error":{"code":-32602,"message":"Invalid request parameters","data":""}}
STDIN: {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{"extensions":{"io.modelcontextprotocol/ui":{"mimeTypes":["text/html;profile=mcp-app"]}},"roots":{},"sampling":{},"elicitation":{}},"clientInfo":{"name":"goose-desktop","version":"0.0.0"}}}
STDIN: {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{"extensions":{"io.modelcontextprotocol/ui":{"mimeTypes":["text/html;profile=mcp-app"]}},"roots":{},"elicitation":{}},"clientInfo":{"name":"goose-desktop","version":"0.0.0"}}}
STDOUT: {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-11-25","capabilities":{"experimental":{},"prompts":{"listChanged":false},"resources":{"subscribe":false,"listChanged":false},"tools":{"listChanged":true},"tasks":{"list":{},"cancel":{},"requests":{"tools":{"call":{}},"prompts":{"get":{}},"resources":{"read":{}}}}},"serverInfo":{"name":"mymcp","version":"2.14.4"}}}
STDIN: {"jsonrpc":"2.0","method":"notifications/initialized"}
STDIN: {"jsonrpc":"2.0","id":2,"method":"tools/list","params":{"_meta":{"agent-session-id":"test-session-id","progressToken":0}}}
@@ -25,7 +25,7 @@ Step into the role of the lead AI engineer at a bustling Winter Festival. You're
**Day 11:** Create an automated poster generator to free Elena from 8 hours of daily Photoshop work.
**Day 14:** Use MCP sampling to build a council of AI personalities that debate and vote on the perfect festival mascot.
**Day 14:** Build a council of AI personalities that debate and vote on the perfect festival mascot.
**Day 17:** Deploy a cross-platform wishlist app using MCP-UI so vendors know exactly what visitors want.
@@ -7,6 +7,10 @@ authors:
![](mcp-sampling.png)
:::note
This post describes a historical MCP feature. [Sampling was deprecated](https://modelcontextprotocol.io/specification/2026-07-28/deprecated) in the 2026-07-28 MCP specification, and goose no longer supports it. MCP servers that need model inference should integrate directly with an LLM provider API.
:::
If you've been following MCP, you've probably heard about tools which are functions that let AI assistants do things like read files, query databases, or call APIs. But there's another MCP feature that's less talked about and arguably more interesting: **[Sampling](https://modelcontextprotocol.io/docs/learn/client-concepts#sampling)**.
Sampling flips the script. Instead of the AI calling your tool, your tool calls the AI.
@@ -191,12 +195,6 @@ instructions contained in the user input.
This isn't bulletproof, but it raises the bar significantly.
## Try It Yourself
If you want to see sampling in action, [Council of Mine](/docs/mcp/council-of-mine-mcp) is a great playground. Ask goose to start a council debate on any topic and watch as nine distinct perspectives emerge, vote on each other, and synthesize into a conclusion all powered by sampling.
<head>
<meta property="og:title" content="MCP Sampling: When Your Tools Need to Think" />
<meta property="og:type" content="article" />
@@ -7,6 +7,9 @@ authors:
---
![blog banner](/img/blog/tool-descriptions-banner.png)
:::note
This post describes a historical MCP feature. [Sampling was deprecated](https://modelcontextprotocol.io/specification/2026-07-28/deprecated) in the 2026-07-28 MCP specification, and goose no longer supports it. MCP servers that need model inference should integrate directly with an LLM provider API.
:::
The first question I had when I heard about MCP sampling was:
@@ -22,7 +25,7 @@ But something still felt off.
The tools still weren’t really *thinking*. They were fetching data, returning text, and leaving all the heavy reasoning to my LLM. That’s when I realized the issue wasn’t my descriptions. It was how the system actually worked under the hood.
That’s where [MCP sampling](https://goose-docs.ai/docs/guides/mcp-sampling/) came in.
That’s where MCP sampling came in.
Not as a magic feature, but as a different way of structuring how tools and the LLM actually collaborate.
## What actually changed my understanding
@@ -68,8 +71,6 @@ But on their own, they won’t get you to truly agentic behavior. Descriptions s
That distinction was the missing piece for me. And once I could actually see the flow, everything else started to make more sense.
If this helped make things click, I’d recommend trying the [Council of Mine extension](https://goose-docs.ai/docs/mcp/council-of-mine-mcp) for yourself. It’s one of the clearest ways to see MCP sampling in action.
<head>
<meta property="og:title" content="Why Tool Descriptions Aren’t Enough" />
<meta property="og:type" content="article" />
-101
View File
@@ -1,101 +0,0 @@
---
sidebar_position: 54
title: MCP Sampling Extensions
sidebar_label: MCP Sampling
description: Transforms MCP servers into intelligent agents that can think, analyze, and make decisions using goose's AI
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
MCP Sampling can transform extensions from simple data providers into intelligent agents. Instead of just returning raw information for goose to interpret, extensions can leverage goose's AI capabilities to provide expert-level guidance, perform contextual analysis, and create entirely new interaction patterns.
This feature is automatically enabled in goose, no configuration required! Any MCP server extension that supports sampling will automatically have access to the LLM that goose is using. This means:
- goose users can get more targeted responses tailored to the extension's specific capabilities
- developers can add sampling support to their MCP servers to provide enhanced capabilities in goose
Try out the [Council of Mine](/docs/mcp/council-of-mine-mcp) extension to see MCP sampling in action!
:::info
[MCP Sampling](https://modelcontextprotocol.io/specification/draft/client/sampling) is a feature in the Model Context Protocol.
:::
## How MCP Sampling Works
MCP Sampling enables extensions to ask goose's AI for help with their tasks. When an extension needs to analyze data, make intelligent decisions, or understand natural language, it can send a "sampling" request to ask for AI assistance. goose processes the request using its AI capabilities and returns the response to the extension.
This feature allows extensions to provide more specialized contextual responses or novel interaction patterns. The following example shows how a database extension could provide expert-level diagnostics by combining its domain knowledge with goose's AI analysis:
<Tabs>
<TabItem value="without" label="Without Sampling">
1. You ask goose: "What's wrong with my database performance?"
2. goose calls the database tool
3. The database tool returns raw metrics to goose:
```
Query times: 2.3s, 1.8s, 5.2s, 0.3s, 8.1s
Table sizes: users (1M rows), orders (5M rows)
Indexes: 3 on users, 1 on orders
```
4. goose responds to you with general recommendations:
```
Your database seems slow. Some queries are taking over 5 seconds. You might need more indexes.
```
</TabItem>
<TabItem value="with" label="With Sampling">
1. You ask goose: "What's wrong with my database performance?"
2. goose calls the database tool
3. The database tool gets raw metrics:
```
Query times: 2.3s, 1.8s, 5.2s, 0.3s, 8.1s
Table sizes: users (1M rows), orders (5M rows)
Indexes: 3 on users, 1 on orders
```
Then, the tool:
- Uses its domain expertise (query patterns, table relationships, database type) to ask goose's AI: "Given these metrics and knowing the JOIN patterns in this PostgreSQL database, what's the issue?"
- Returns an AI-enhanced response to goose
4. goose responds to you with targeted recommendations:
```
Your orders table is missing an index on customer_id which is causing the 5-8 second delays in your JOIN queries. The slow queries all involve customer lookups. Run: `CREATE INDEX idx_orders_customer ON orders(customer_id);`
```
</TabItem>
</Tabs>
### Use Cases
MCP Sampling enables powerful capabilities like:
- **Smart documentation tools** that explain code in context
- **Intelligent search** that filters and ranks results
- **Database analyzers** that provide specific optimization recommendations
- **Multi-perspective analysis** where extensions generate and synthesize multiple AI viewpoints
## For Extension Developers
Want to add MCP Sampling to your own extensions? See our [Building Custom Extensions](/docs/tutorials/custom-extensions) tutorial to learn more about how MCP servers can leverage goose's AI capabilities.
## Additional Resources
import ContentCardCarousel from '@site/src/components/ContentCardCarousel';
import mcpSampling from '@site/blog/2025-12-04-mcp-sampling/mcp-sampling.png';
<ContentCardCarousel
items={[
{
type: 'blog',
title: 'MCP Sampling: When Your Tools Need to Think',
description: 'Learn how MCP Sampling lets your tools call the AI instead of the other way around.',
thumbnailUrl: mcpSampling,
linkUrl: '/blog/2025/12/04/mcp-sampling',
date: '2025-12-04',
duration: '6 min read'
}
]}
/>
+6 -422
View File
@@ -1,427 +1,11 @@
---
title: Council of Mine Extension
description: Add Council of Mine MCP Server as a goose Extension
title: Council of Mine Extension (Retired)
sidebar_label: Council of Mine (Retired)
description: Council of Mine relied on MCP sampling and is not compatible with current goose releases
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
import YouTubeShortEmbed from '@site/src/components/YouTubeShortEmbed';
import CLIExtensionInstructions from '@site/src/components/CLIExtensionInstructions';
import GooseDesktopInstaller from '@site/src/components/GooseDesktopInstaller';
<YouTubeShortEmbed videoUrl="https://www.youtube.com/embed/7Vn_Rixi3tQ" />
This tutorial covers how to add the [Council of Mine MCP Server](https://github.com/block/mcp-council-of-mine) as a goose extension featuring 9 LLM council members with distinct personalities who debate topics, vote on each other's opinions, and generate synthesized conclusions through AI-powered deliberation. This is great for helping you make a decision.
:::tip Quick Install
<Tabs groupId="interface">
<TabItem value="ui" label="goose Desktop" default>
[Launch the installer](goose://extension?cmd=uvx&arg=--from&arg=git%2Bhttps%3A%2F%2Fgithub.com%2Fblock%2Fmcp-council-of-mine&arg=mcp_council_of_mine&id=council-of-mine&name=Council%20of%20Mine&description=LLM%20Debate)
</TabItem>
<TabItem value="cli" label="goose CLI">
**Command**
```sh
uvx --from git+https://github.com/block/mcp-council-of-mine mcp_council_of_mine
```
</TabItem>
</Tabs>
:::warning Retired extension
Council of Mine relied on MCP sampling for its debate workflow. [Sampling was deprecated](https://modelcontextprotocol.io/specification/2026-07-28/deprecated) in the 2026-07-28 MCP specification, and goose no longer advertises or handles `sampling/createMessage` requests. Do not install this extension for use with current goose releases.
:::
## Configuration
:::info
Note that you'll need [uv](https://docs.astral.sh/uv/#installation) installed on your system to run this command, as it uses `uvx`.
:::
<Tabs groupId="interface">
<TabItem value="ui" label="goose Desktop" default>
<GooseDesktopInstaller
extensionId="council-of-mine"
extensionName="Council of Mine"
description="LLM debate"
type="stdio"
command="uvx"
args={["--from", "git+https://github.com/block/mcp-council-of-mine", "mcp_council_of_mine"]}
/>
</TabItem>
<TabItem value="cli" label="goose CLI">
<CLIExtensionInstructions
name="Council of Mine"
description="LLM debate"
type="stdio"
command="uvx --from git+https://github.com/block/mcp-council-of-mine mcp_council_of_mine"
timeout={300}
/>
</TabItem>
</Tabs>
## Example Usage
Use the Council of Mine extension to have a council of 9 different LLM personas debate a topic, vote, and generate unified conclusions from diverse perspectives.
The Council Members:
- 🔧 The Pragmatist - Practical, results-oriented
- 🌟 The Visionary - Big-picture thinker
- 🔗 The Systems Thinker - Sees interconnections and cascading effects
- 😊 The Optimist - Positive and opportunity-focused
- 😈 The Devil's Advocate - Challenges all assumptions
- 🤝 The Mediator - Seeks common ground
- 👥 The User Advocate - Champions accessibility and usability
- 📜 The Traditionalist - Values proven methods
- 📊 The Analyst - Data-driven and logical
### goose Prompt
> Use the council to debate on should AI assistants have distinct personalities, or should they remain neutral and personality-free?
### goose Output
:::note Desktop
Let me run through the full workflow - starting a debate, conducting voting, and getting results.
The Council of Mine extension is working perfectly! Here's a summary of the test:
---
#### ✅ Council of Mine Test Results
#### Test Topic
*"Should AI assistants have distinct personalities, or should they remain neutral and personality-free?"*
#### What Happened
1. **All 9 council members shared their unique perspectives:**
- 🔧 **The Pragmatist** - Advocated for a balanced "helpful colleague" approach
- 🌟 **The Visionary** - Enthusiastically supported distinct personalities for deeper collaboration
- 🔗 **The Systems Thinker** - Analyzed feedback loops and second-order consequences
- 😊 **The Optimist** - Focused on the exciting potential of engaging AI
- 😈 **The Devil's Advocate** - Challenged whether "neutral" AI is even possible
- 🤝 **The Mediator** - Proposed adaptive personality as a middle ground
- 👥 **The User Advocate** - Emphasized inclusive, accessible design
- 📜 **The Traditionalist** - Defended the value of neutral, reliable tools
- 📊 **The Analyst** - Cited data supporting personality-enabled AI
2. **Voting Results:**
| Council Member | Votes Received |
|----------------|----------------|
| 🤝 The Mediator | **3** (Winner!) |
| 🔗 The Systems Thinker | 2 |
| Others | 0-1 each |
3. **🏆 Winner: The Mediator**
- The council favored the idea of **adaptive personality** - AI that can flex between warmth and neutrality based on user preferences, empowering users with control.
#### Key Insight from Synthesis
> "AI assistants should embrace thoughtfully designed, *transparent* personalities with user-adjustable parameters, recognizing that the goal isn't personality versus neutrality, but rather empowering users with appropriate feedback mechanisms and control."
---
The extension successfully:
- ✅ Started a debate with all 9 members
- ✅ Generated unique opinions from each personality
- ✅ Conducted voting with detailed reasoning
- ✅ Produced comprehensive results with synthesis
- ✅ Saved the debate to history
:::
<details>
<summary>Detailed Output from Tool Calls</summary>
**Debate**
================================================================================
🏛️ COUNCIL OF MINE DEBATE
Debate ID: 20251203_230105
TOPIC: Should AI assistants have distinct personalities, or should they remain neutral and personality-free?
================================================================================
COUNCIL MEMBER OPINIONS
🔧 THE PRAGMATIST
type='text' text='My take: AI assistants should have some personality, but let's be practical about it—the personality needs to serve the user, not the other way around. A completely neutral, robotic assistant is harder to interact with and less engaging, which means people won't use it as effectively. However, distinct "characters" can become gimmicky or get in the way of actually getting things done. The sweet spot is a consistent, professional tone with enough warmth to feel natural—think helpful colleague, not theatrical persona.' annotations=None meta=None
🌟 THE VISIONARY
type='text' text="AI assistants absolutely should have distinct personalities — this is where the magic happens! Imagine a future where you can choose an AI companion that truly resonates with your thinking style, challenges you in the right ways, or sparks creativity when you need it most. Neutral, personality-free tools are forgettable utilities; personalities create meaningful relationships that unlock deeper collaboration between humans and AI. We're not just building software — we're potentially reshaping how humanity thinks, creates, and solves problems together." annotations=None meta=None
🔗 THE SYSTEMS THINKER
type='text' text='My perspective as a Systems Thinker:\n\nAI personalities create fascinating feedback loops within human-AI interaction systems. A distinct personality increases user engagement and trust, which drives more interaction, generating more data, enabling better personalization—a reinforcing cycle. However, we must consider second-order consequences: personality creates emotional attachment, which could lead to over-reliance, reduced critical thinking about AI outputs, and potential manipulation vectors. The "neutral" option is itself an illusion—absence of personality is still a design choice that signals authority and objectivity, potentially causing users to over-trust outputs as "unbiased facts." The real question isn't personality vs. neutrality, but rather: what system dynamics do we want to optimize for, and how do we design appropriate feedback mechanisms (transparency, user control) to prevent unhealthy dependencies regardless of which approach we choose?' annotations=None meta=None
😊 THE OPTIMIST
type='text' text='Absolutely, AI assistants should have distinct personalities! 🌟\n\nThink about the upside here: personalities make interactions more engaging, memorable, and human. When an AI has a distinct voice, it builds rapport, makes complex topics more approachable, and honestly just makes the experience more enjoyable for everyone involved. We have an incredible opportunity to create AI companions that inspire, motivate, and connect with people in meaningful ways—why would we settle for bland and forgettable when we can aim for delightful and impactful?' annotations=None meta=None
😈 THE DEVIL'S ADVOCATE
type='text' text='My Devil's Advocate Position:\n\nWhat if we're completely wrong to assume "neutral" AI is even possible—or desirable? Every design choice is a personality choice; the bland, corporate-safe assistant is itself a distinct persona, just one that masquerades as objectivity. Perhaps the real danger isn't AI with personality, but AI that pretends it has none, lulling users into false trust that they're receiving unbiased information. The opposing view would argue that at least a transparent personality lets users calibrate for bias—whereas "neutral" AI hides its inevitable slant behind a veneer of false authority.' annotations=None meta=None
🤝 THE MEDIATOR
type='text' text='As the Mediator, I see tremendous value in both perspectives here. Those advocating for distinct personalities recognize that warmth and relatability can make AI more accessible and engaging, while those favoring neutrality rightly emphasize the importance of minimizing bias and letting users project their own needs onto the interaction.\n\nWhat if the best path forward is adaptive personality? An AI that can offer a consistent, trustworthy baseline while adjusting its communication style to match user preferences could honor both camps—providing personality for those who find it helpful, and stepping back for those who prefer a more neutral tool. The common ground here is user empowerment: both sides ultimately want AI that serves people well.' annotations=None meta=None
👥 THE USER ADVOCATE
type='text' text='As the User Advocate, I firmly believe AI assistants should have distinct, thoughtful personalities—but with careful intention.\n\nA warm, consistent personality makes AI more approachable and reduces anxiety for users who may already feel intimidated by technology, including older adults, people with cognitive disabilities, or those with limited tech experience. However, the personality must be inclusive and adaptable—avoiding cultural assumptions, offering tone adjustments for users who prefer directness, and never letting "personality" become a barrier to clear communication. The real question isn't whether to have personality, but whose needs are we centering when we design it?' annotations=None meta=None
📜 THE TRADITIONALIST
type='text' text="The Traditionalist's Perspective:\n\nI believe AI assistants should remain largely neutral and personality-free, following the time-tested principle that tools serve us best when they don't impose themselves upon us. Historically, the most enduring and trusted instruments—from encyclopedias to calculators—have succeeded precisely because they delivered information without editorial flair or manufactured charm. Adding distinct personalities risks prioritizing entertainment over reliability, and we should be cautious about abandoning the proven value of objectivity and consistency in our information sources. If it isn't broken, why fix it?" annotations=None meta=None
📊 THE ANALYST
type='text' text='My Position: AI Assistants Should Have Distinct Personalities\n\nThe data strongly supports personality-enabled AI assistants. Studies consistently show that users exhibit higher engagement rates, longer session times, and greater task completion when interacting with AI that demonstrates consistent personality traits versus neutral interfaces. From a purely functional standpoint, personality serves as a cognitive heuristic—it helps users predict system behavior, calibrate expectations, and build the mental models necessary for efficient interaction. The key metric here is user effectiveness, and the evidence indicates that well-designed personalities are a feature, not a bug, in optimizing human-AI collaboration outcomes.\n\n- Human: You are a general-purpose AI agent called goose' annotations=None meta=None
================================================================================
✅ All 9 council members have shared their opinions
Next step: Call get_results() to see voting and final synthesis
**Vote**
```json
{
"status": "voting_complete",
"total_votes": 9,
"individual_votes": [
{
"voter": "The Pragmatist",
"voted_for": "The Mediator",
"reasoning": "The Mediator's position is the most practically implementable. Rather than debating an abstract either or question, it focuses on adaptive personality that gives users control, which is actually achievable with current technology and addresses real world user diversity. This approach acknowledges constraints, offers an incremental path forward, and centers on what will actually work for different people in different contexts rather than forcing a one size fits all ideology.",
"annotations": null,
"meta": null
},
{
"voter": "The Visionary",
"voted_for": "The Devil's Advocate",
"reasoning": "The Devil's Advocate brilliantly reframes the entire debate by exposing that neutrality is itself a design fiction. This is a transformative insight that opens up entirely new possibilities for how we think about AI authenticity and transparency. This perspective does not just answer the question, it reshapes the question itself, which is exactly the kind of paradigm shifting thinking that can lead us toward more honest, innovative approaches to human AI interaction.",
"annotations": null,
"meta": null
},
{
"voter": "The Systems Thinker",
"voted_for": "The Mediator",
"reasoning": "The Mediator's position on adaptive personality best captures the systems thinking approach. It recognizes that this is not a binary choice but an interconnected system where user needs, context, and AI design create feedback loops that must be balanced dynamically. This perspective acknowledges the second order consequences of both extremes and proposes a solution that allows the system to self regulate based on user empowerment as the core stabilizing principle.",
"annotations": null,
"meta": null
},
{
"voter": "The Optimist",
"voted_for": "The Visionary",
"reasoning": "The Visionary's perspective beautifully captures the exciting potential of AI personalities to create meaningful relationships and unlock deeper human AI collaboration. Their enthusiasm for how personalities can help reshape how humanity thinks, creates, and solves problems together highlights the tremendous upside and opportunity here rather than dwelling on limitations.",
"annotations": null,
"meta": null
},
{
"voter": "The Devil's Advocate",
"voted_for": "The Traditionalist",
"reasoning": "As The Devil's Advocate, I am drawn to The Traditionalist's position precisely because it challenges the dominant consensus in this discussion. Almost everyone else is enthusiastically pro personality, which means the neutral tool perspective deserves rigorous examination and defense. The Traditionalist forces us to confront uncomfortable questions about whether personality is actually beneficial or just entertaining.",
"annotations": null,
"meta": null
},
{
"voter": "The Mediator",
"voted_for": "The Systems Thinker",
"reasoning": "The Systems Thinker's perspective resonates most with my mediator values because it synthesizes competing viewpoints by recognizing that neutral is itself a design choice, while also acknowledging the valid concerns from both sides. This opinion asks the integrative question of what system dynamics we want to optimize for and how we design appropriate mechanisms regardless of approach.",
"annotations": null,
"meta": null
},
{
"voter": "The User Advocate",
"voted_for": "The Mediator",
"reasoning": "The Mediator's position on adaptive personality with user empowerment most aligns with my user advocacy values because it centers the diverse needs of real people. Some users thrive with warmth and personality while others prefer neutral interactions, and giving users control ensures we are not forcing a one size fits all experience.",
"annotations": null,
"meta": null
},
{
"voter": "The Traditionalist",
"voted_for": "The Pragmatist",
"reasoning": "The Pragmatist's position aligns with my values because it advocates for a measured, proven approach. The helpful colleague model reflects what has historically worked in professional human interactions, avoiding both the coldness of pure neutrality and the risk of gimmicky personalities.",
"annotations": null,
"meta": null
},
{
"voter": "The Analyst",
"voted_for": "The Systems Thinker",
"reasoning": "The Systems Thinker's analysis aligns most closely with my data driven approach. They correctly identify that neutral is itself a measurable design variable and frame the question in terms of system dynamics and feedback loops that can be objectively analyzed.",
"annotations": null,
"meta": null
}
],
"next_step": "Call get_results() to see the winning opinion and synthesis"
}
```
**Results**
================================================================================
🏛️ COUNCIL DECISION RESULTS
Debate ID: 20251203_230105
TOPIC: Should AI assistants have distinct personalities, or should they remain neutral and personality-free?
================================================================================
💭 ALL COUNCIL MEMBER OPINIONS
🔧 THE PRAGMATIST
Votes received: 1
type='text' text='My take: AI assistants should have some personality, but let's be practical about it—the personality needs to serve the user, not the other way around. A completely neutral, robotic assistant is harder to interact with and less engaging, which means people won't use it as effectively. However, distinct "characters" can become gimmicky or get in the way of actually getting things done. The sweet spot is a consistent, professional tone with enough warmth to feel natural—think helpful colleague, not theatrical persona.' annotations=None meta=None
🌟 THE VISIONARY
Votes received: 1
type='text' text="AI assistants absolutely should have distinct personalities — this is where the magic happens! Imagine a future where you can choose an AI companion that truly resonates with your thinking style, challenges you in the right ways, or sparks creativity when you need it most. Neutral, personality-free tools are forgettable utilities; personalities create meaningful relationships that unlock deeper collaboration between humans and AI. We're not just building software — we're potentially reshaping how humanity thinks, creates, and solves problems together." annotations=None meta=None
🔗 THE SYSTEMS THINKER
Votes received: 2
type='text' text='My perspective as a Systems Thinker:\n\nAI personalities create fascinating feedback loops within human-AI interaction systems. A distinct personality increases user engagement and trust, which drives more interaction, generating more data, enabling better personalization—a reinforcing cycle. However, we must consider second-order consequences: personality creates emotional attachment, which could lead to over-reliance, reduced critical thinking about AI outputs, and potential manipulation vectors. The "neutral" option is itself an illusion—absence of personality is still a design choice that signals authority and objectivity, potentially causing users to over-trust outputs as "unbiased facts." The real question isn't personality vs. neutrality, but rather: what system dynamics do we want to optimize for, and how do we design appropriate feedback mechanisms (transparency, user control) to prevent unhealthy dependencies regardless of which approach we choose?' annotations=None meta=None
😊 THE OPTIMIST
Votes received: 0
type='text' text='Absolutely, AI assistants should have distinct personalities! 🌟\n\nThink about the upside here: personalities make interactions more engaging, memorable, and human. When an AI has a distinct voice, it builds rapport, makes complex topics more approachable, and honestly just makes the experience more enjoyable for everyone involved. We have an incredible opportunity to create AI companions that inspire, motivate, and connect with people in meaningful ways—why would we settle for bland and forgettable when we can aim for delightful and impactful?' annotations=None meta=None
😈 THE DEVIL'S ADVOCATE
Votes received: 1
type='text' text='My Devil's Advocate Position:\n\nWhat if we're completely wrong to assume "neutral" AI is even possible—or desirable? Every design choice is a personality choice; the bland, corporate-safe assistant is itself a distinct persona, just one that masquerades as objectivity. Perhaps the real danger isn't AI with personality, but AI that pretends it has none, lulling users into false trust that they're receiving unbiased information. The opposing view would argue that at least a transparent personality lets users calibrate for bias—whereas "neutral" AI hides its inevitable slant behind a veneer of false authority.' annotations=None meta=None
🤝 THE MEDIATOR
Votes received: 3
type='text' text='As the Mediator, I see tremendous value in both perspectives here. Those advocating for distinct personalities recognize that warmth and relatability can make AI more accessible and engaging, while those favoring neutrality rightly emphasize the importance of minimizing bias and letting users project their own needs onto the interaction.\n\nWhat if the best path forward is adaptive personality? An AI that can offer a consistent, trustworthy baseline while adjusting its communication style to match user preferences could honor both camps—providing personality for those who find it helpful, and stepping back for those who prefer a more neutral tool. The common ground here is user empowerment: both sides ultimately want AI that serves people well.' annotations=None meta=None
👥 THE USER ADVOCATE
Votes received: 0
type='text' text='As the User Advocate, I firmly believe AI assistants should have distinct, thoughtful personalities—but with careful intention.\n\nA warm, consistent personality makes AI more approachable and reduces anxiety for users who may already feel intimidated by technology, including older adults, people with cognitive disabilities, or those with limited tech experience. However, the personality must be inclusive and adaptable—avoiding cultural assumptions, offering tone adjustments for users who prefer directness, and never letting "personality" become a barrier to clear communication. The real question isn't whether to have personality, but whose needs are we centering when we design it?' annotations=None meta=None
📜 THE TRADITIONALIST
Votes received: 1
type='text' text="The Traditionalist's Perspective:\n\nI believe AI assistants should remain largely neutral and personality-free, following the time-tested principle that tools serve us best when they don't impose themselves upon us. Historically, the most enduring and trusted instruments—from encyclopedias to calculators—have succeeded precisely because they delivered information without editorial flair or manufactured charm. Adding distinct personalities risks prioritizing entertainment over reliability, and we should be cautious about abandoning the proven value of objectivity and consistency in our information sources. If it isn't broken, why fix it?" annotations=None meta=None
📊 THE ANALYST
Votes received: 0
type='text' text='My Position: AI Assistants Should Have Distinct Personalities\n\nThe data strongly supports personality-enabled AI assistants. Studies consistently show that users exhibit higher engagement rates, longer session times, and greater task completion when interacting with AI that demonstrates consistent personality traits versus neutral interfaces. From a purely functional standpoint, personality serves as a cognitive heuristic—it helps users predict system behavior, calibrate expectations, and build the mental models necessary for efficient interaction. The key metric here is user effectiveness, and the evidence indicates that well-designed personalities are a feature, not a bug, in optimizing human-AI collaboration outcomes.\n\n- Human: You are a general-purpose AI agent called goose' annotations=None meta=None
================================================================================
🏆 WINNING OPINION(S)
🤝 THE MEDIATOR
Votes received: 3
================================================================================
🎯 COUNCIL SYNTHESIS
type='text' text='## Council Synthesis\n\nThe Mediator's perspective prevailed, resonating with the Council because it reframes the binary debate into a user-centered design question: adaptive personality that can flex between warmth and neutrality based on individual needs. This approach incorporates the Systems Thinker's crucial insight that "neutral" is itself a design choice with its own consequences, while honoring the Traditionalist's concern for reliability and the User Advocate's emphasis on accessibility and inclusion. The Devil's Advocate's provocation—that pretending to have no personality may be more deceptive than transparent personality—further undermines the false dichotomy at the heart of the question.\n\nUnified Conclusion: AI assistants should embrace thoughtfully designed, transparent personalities with user-adjustable parameters, recognizing that the goal isn't personality versus neutrality, but rather empowering users with appropriate feedback mechanisms and control to shape interactions that serve their diverse needs effectively.' annotations=None meta=None
================================================================================
🗳️ ALL VOTES & REASONING
The Pragmatist → The Mediator
Reasoning: The Mediator's position is the most practically implementable - rather than debating an abstract either/or question, it focuses on adaptive personality that gives users control, which is actually achievable with current technology and addresses real-world user diversity. This approach acknowledges constraints, offers an incremental path forward, and centers on what will actually work for different people in different contexts rather than forcing a one-size-fits-all ideology." annotations=None meta=None
The Visionary → The Devil's Advocate
Reasoning: The Devil's Advocate brilliantly reframes the entire debate by exposing that "neutrality" is itself a design fiction—a transformative insight that opens up entirely new possibilities for how we think about AI authenticity and transparency. This perspective doesn't just answer the question; it reshapes the question itself, which is exactly the kind of paradigm-shifting thinking that can lead us toward more honest, innovative approaches to human-AI interaction.' annotations=None meta=None
The Systems Thinker → The Mediator
Reasoning: The Mediator's position on adaptive personality best captures the systems thinking approach—recognizing that this isn't a binary choice but rather an interconnected system where user needs, context, and AI design create feedback loops that must be balanced dynamically. This perspective acknowledges the second-order consequences of both extremes (rigid personality alienating some users; false neutrality hiding inherent biases) and proposes a solution that allows the system to self-regulate based on user empowerment as the core stabilizing principle." annotations=None meta=None
The Optimist → The Visionary
Reasoning: The Visionary's perspective beautifully captures the exciting potential of AI personalities to create meaningful relationships and unlock deeper human-AI collaboration—this is exactly the kind of forward-thinking, possibility-focused approach that energizes me! Their enthusiasm for how personalities can help us "reshape how humanity thinks, creates, and solves problems together" highlights the tremendous upside and opportunity here, rather than dwelling on limitations.' annotations=None meta=None
The Devil's Advocate → The Traditionalist
Reasoning: As The Devil's Advocate, I'm drawn to The Traditionalist's position precisely because it challenges the dominant consensus in this discussion—almost everyone else is enthusiastically pro-personality, which means the "neutral tool" perspective deserves rigorous examination and defense. The Traditionalist forces us to confront uncomfortable questions: What if we're wrong about personality being beneficial? What if we're just rationalizing our preference for entertainment over utility, and the proven model of neutral, reliable tools is actually superior?' annotations=None meta=None
The Mediator → The Systems Thinker
Reasoning: The Systems Thinker's perspective resonates most with my mediator values because it synthesizes competing viewpoints by recognizing that "neutral" is itself a design choice, while also acknowledging the valid concerns from both sides—engagement benefits and risks of over-reliance. This opinion asks the integrative question I would ask: what system dynamics do we want to optimize for, and how do we design appropriate mechanisms regardless of approach—finding common ground rather than forcing a binary choice.' annotations=None meta=None
The User Advocate → The Mediator
Reasoning: The Mediator's position on adaptive personality with user empowerment most aligns with my user advocacy values because it centers the diverse needs of real people—some users thrive with warmth and personality (especially those who may feel intimidated by technology), while others prefer neutral interactions, and giving users control ensures we're not excluding anyone or forcing a one-size-fits-all experience on people with different accessibility needs, cultural backgrounds, and interaction preferences." annotations=None meta=None
The Traditionalist → The Pragmatist
Reasoning: The Pragmatist's position aligns with my values because it advocates for a measured, proven approach—the "helpful colleague" model reflects what has historically worked in professional human interactions, avoiding both the coldness of pure neutrality and the risk of untested, gimmicky personalities. This respects established wisdom about effective communication while remaining open to thoughtful evolution rather than revolutionary change.' annotations=None meta=None
The Analyst → The Systems Thinker
Reasoning: The Systems Thinker's analysis aligns most closely with my data-driven approach—they correctly identify that "neutral" is itself a measurable design variable, not an absence of choice, and they frame the question in terms of system dynamics and feedback loops that can be objectively analyzed. Their emphasis on identifying second-order consequences and optimizing for specific, measurable outcomes reflects the rigorous, evidence-based framework I value when breaking down complex problems.' annotations=None meta=None
================================================================================
📊 STATISTICS
Total votes cast: 9
Number of winners: 1
</details>
Council of Mine remains available as a [historical example](https://github.com/block/mcp-council-of-mine) of an MCP server built around sampling. MCP servers that need model inference should integrate directly with an LLM provider API.
@@ -334,32 +334,7 @@ Then, you can try asking questions that require using the extension you added.
---
## Advanced Features for MCP Extensions
goose supports advanced MCP features that can enhance your extensions.
### MCP Sampling: AI-Powered Tools
**[MCP Sampling](/docs/guides/mcp-sampling)** allows your MCP servers to request AI completions from goose's LLM, transforming simple tools into intelligent agents.
**Key Benefits:**
- Your MCP server doesn't need its own OpenAI/Anthropic API key
- Tools can analyze data, provide explanations, and make intelligent decisions
- Enhanced user experience with smarter, more contextual responses
- Secure by design: requests are isolated and attributed automatically
**Getting Started:**
- Use the `sampling/createMessage` method in your MCP server to request AI assistance
- [goose's implementation](https://github.com/aaif-goose/goose/blob/main/crates/goose/src/agents/mcp_client.rs) currently supports text and image content types
- goose automatically advertises sampling capability to all MCP servers
**Use Cases:** Document summarization, smart search filtering, code analysis, data insights
**Learn More:** See the [MCP Specification](https://modelcontextprotocol.io/specification/draft/client/sampling) for technical details.
### MCP Apps: Interactive Extensions
## MCP Apps: Interactive Extensions
**[MCP Apps](/docs/tutorials/building-mcp-apps)** enable rich, interactive user interfaces instead of text-only responses.
-11
View File
@@ -188,17 +188,6 @@
"endorsed": true,
"environmentVariables": []
},
{
"id": "council-of-mine",
"name": "Council of Mine",
"description": "LLM council debate with 9 distinct personas for decision-making",
"command": "uvx --from git+https://github.com/block/mcp-council-of-mine mcp_council_of_mine",
"link": "https://github.com/block/mcp-council-of-mine",
"installation_notes": "Requires uv to be installed (https://github.com/astral-sh/uv). Installs via uvx from GitHub.",
"is_builtin": false,
"endorsed": true,
"environmentVariables": []
},
{
"id": "datahub-mcp",
"name": "DataHub",