Goose
从源码学会它怎么工作

 1930          let inner = Box::pin(async_stream::try_stream! {
 1931              let mut turns_taken = 0u32;
 1932              let max_turns = session_config.max_turns.unwrap_or_else(|| {
 1933                  Config::global()
 1934                      .get_param::<u32>("GOOSE_MAX_TURNS")
 1935                      .unwrap_or(DEFAULT_MAX_TURNS)
 1936              });
 1937              let mut compaction_attempts = 0;
 1938              let mut empty_turn_retries = 0u32;
 1939              let mut retrying_after_empty_turn = false;
 1940              let mut last_assistant_text = String::new();
 1941              let mut goal_check_pending = false;
 1942              let mut tool_pair_summarization_done = false;
 1943              let mut stop_hook_handled_for_exit = false;
 1944              let mut retrying_after_stop_hook_denial = false;
 1945              let mut consecutive_stop_hook_blocks = 0u32;
 1946              let stop_hook_block_cap = self.stop_hook_block_cap();
 1947              let mut can_drain_pending_steers = false;
 1948  
 1949              loop {
 1950                  if is_token_cancelled(&cancel_token) {
 1951                      break;
 1952                  }
 1953  
 1954                  if can_drain_pending_steers {
      … 78 lines omitted; exact range 1930–2043 …
 2033                  ).await;
 2034  
 2035                  let mut stream = Self::stream_response_from_provider(
 2036                      self.provider().await?,
 2037                      model_config.clone(),
 2038                      &session_config.id,
 2039                      &system_prompt,
 2040                      conversation_with_moim.messages(),
 2041                      &tools,
 2042                      &toolshim_tools,
 2043                  ).await?;

   67  use tracing::{debug, error, info, instrument, warn};
   68  
   69  const DEFAULT_MAX_TURNS: u32 = 1000;
   70  const DEFAULT_STOP_HOOK_BLOCK_CAP: u32 = 8;
   71  const COMPACTION_PROGRESS_TEXT: &str = "goose is compacting the conversation...";
   72  const MAX_TURNS_MESSAGE: &str = "I've reached the maximum number of actions I can do without user input. Would you like me to continue?";
   73  const MAX_EMPTY_TURN_RETRIES: u32 = 3;
   74  const EMPTY_TURN_MESSAGE: &str =
   75      "The model returned an empty response. Please resend your message to continue.";
   76  const DEFAULT_FRONTEND_INSTRUCTIONS: &str = "The following tools are provided directly by the frontend and will be executed by the frontend when called.";
   77  
   78  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
   79  enum ToolCategory {

  281  /// A message stream yields partial text content but complete tool calls, all within the Message object
  282  /// So a message with text will contain potentially just a word of a longer response, but tool calls
  283  /// messages will only be yielded once concatenated.
  284  pub type MessageStream = Pin<
  285      Box<dyn Stream<Item = Result<(Option<Message>, Option<ProviderUsage>), ProviderError>> + Send>,
  286  >;

 2210                                      // Run all tool inspectors
 2211                                      let inspection_results = self.tool_inspection_manager
 2212                                          .inspect_tools(
 2213                                              &session_config.id,
 2214                                              &remaining_requests,
 2215                                              conversation.messages(),
 2216                                              goose_mode,
 2217                                          )
 2218                                          .await?;
 2219  
 2220                                      let permission_check_result = self.tool_inspection_manager
 2221                                          .process_inspection_results_with_permission_inspector(
 2222                                              &remaining_requests,
 2223                                              &inspection_results,
 2224                                          )
 2225                                          .unwrap_or_else(|| {
 2226                                              let mut result = PermissionCheckResult {
 2227                                                  approved: vec![],
 2228                                                  needs_approval: vec![],
 2229                                                  denied: vec![],
 2230                                              };
 2231                                              result.needs_approval.extend(remaining_requests.iter().cloned());
 2232                                              result
 2233                                          });
 2234  
      … 20 lines omitted; exact range 2210–2265 …
 2255                                              &mut tool_futures,
 2256                                              &mut request_to_response_map,
 2257                                              cancel_token.clone(),
 2258                                              &session,
 2259                                              &inspection_results,
 2260                                          );
 2261  
 2262                                          while let Some(msg) = tool_approval_stream.try_next().await? {
 2263                                              yield AgentEvent::Message(msg);
 2264                                          }
 2265                                      }

   26  pub const DEFAULT_COMPACTION_THRESHOLD: f64 = 0.8;
   27  
   28  const TOOLCALL_SUMMARIZATION_BATCH_SIZE: usize = 10;
   29  
   30  fn tool_pair_summarization_enabled() -> bool {
   31      Config::global()
   32          .get_param::<bool>("GOOSE_TOOL_PAIR_SUMMARIZATION")
   33          .unwrap_or(true)
   34  }
   35  
   36  const CONVERSATION_CONTINUATION_TEXT: &str =
   37      "Your context was compacted. The previous message contains a summary of the conversation so far.
   38  Do not mention that you read a summary or that conversation summarization occurred.
   39  Just continue the conversation naturally based on the summarized context.";
   40  
   41  const TOOL_LOOP_CONTINUATION_TEXT: &str =
   42      "Your context was compacted. The previous message contains a summary of the conversation so far.
   43  Do not mention that you read a summary or that conversation summarization occurred.
   44  Continue calling tools as necessary to complete the task.";
   45  
   46  const MANUAL_COMPACT_CONTINUATION_TEXT: &str =
   47      "Your context was compacted at the user's request. The previous message contains a summary of the conversation so far.
   48  Do not mention that you read a summary or that conversation summarization occurred.
   49  Just continue the conversation naturally based on the summarized context.";

  319  async fn do_compact(
  320      provider: &dyn Provider,
  321      model_config: &ModelConfig,
  322      session_id: &str,
  323      messages: &[Message],
  324  ) -> Result<(Message, ProviderUsage), anyhow::Error> {
  325      let agent_visible_messages =
  326          Conversation::new_unvalidated(messages.iter().cloned()).agent_visible_messages();
  327  
  328      // Try progressively removing more tool response messages from the middle to reduce context length
  329      let removal_percentages = [0, 10, 20, 50, 100];
  330  
  331      for (attempt, &remove_percent) in removal_percentages.iter().enumerate() {
  332          let filtered_messages = filter_tool_responses(&agent_visible_messages, remove_percent);
  333  
  334          let messages_text = filtered_messages
  335              .iter()
  336              .map(|&msg| format_message_for_compacting(msg))
  337              .collect::<Vec<_>>()
  338              .join("\n");
  339  
  340          let context = SummarizeContext {
  341              messages: messages_text,
  342          };
  343  
      … 44 lines omitted; exact range 319–398 …
  388                      }
  389                  }
  390                  return Err(e.into());
  391              }
  392          }
  393      }
  394  
  395      Err(anyhow::anyhow!(
  396          "Unexpected: exhausted all attempts without returning"
  397      ))
  398  }

  659      /// Create a tool inspection manager with default inspectors
  660      fn create_tool_inspection_manager(
  661          permission_manager: Arc<PermissionManager>,
  662          provider: SharedProvider,
  663          session_manager: Arc<SessionManager>,
  664      ) -> ToolInspectionManager {
  665          let mut tool_inspection_manager = ToolInspectionManager::new();
  666  
  667          // Add security inspector (highest priority - runs first)
  668          tool_inspection_manager.add_inspector(Box::new(SecurityInspector::new()));
  669          tool_inspection_manager.add_inspector(Box::new(EgressInspector::new()));
  670  
  671          // Add adversary inspector (LLM-based review, enabled by ~/.config/goose/adversary.md)
  672          tool_inspection_manager.add_inspector(Box::new(AdversaryInspector::new(
  673              provider.clone(),
  674              session_manager.clone(),
  675          )));
  676  
  677          // Add permission inspector (medium-high priority)
  678          tool_inspection_manager.add_inspector(Box::new(PermissionInspector::new(
  679              permission_manager,
  680              provider,
  681              session_manager,
  682          )));
  683  
  684          // Add repetition inspector (lower priority - basic repetition checking)
  685          tool_inspection_manager.add_inspector(Box::new(RepetitionInspector::new(None)));
  686  
  687          tool_inspection_manager
  688      }

  159                  let action = match goose_mode {
  160                      GooseMode::Chat => continue,
  161                      GooseMode::Auto => InspectionAction::Allow,
  162                      GooseMode::Approve | GooseMode::SmartApprove => {
  163                          // 1. Check user-defined permission first
  164                          if let Some(level) = permission_manager.get_user_permission(tool_name) {
  165                              match level {
  166                                  PermissionLevel::AlwaysAllow => InspectionAction::Allow,
  167                                  PermissionLevel::NeverAllow => InspectionAction::Deny,
  168                                  PermissionLevel::AskBefore => {
  169                                      InspectionAction::RequireApproval(None)
  170                                  }
  171                              }
  172                          // 2. Check for a read-only annotation in SmartApprove mode
  173                          } else if goose_mode == GooseMode::SmartApprove
  174                              && self.is_readonly_annotated_tool(tool_name)
  175                          {
  176                              InspectionAction::Allow
  177                          // 3. Special case for extension management
  178                          } else if tool_name == MANAGE_EXTENSIONS_TOOL_NAME_COMPLETE {
  179                              InspectionAction::RequireApproval(Some(
  180                                  "Extension management requires approval for security".to_string(),
  181                              ))
  182                          // 4. Defer to LLM detection (SmartApprove, uncached or legacy cached allow)
  183                          } else if goose_mode == GooseMode::SmartApprove
      … 74 lines omitted; exact range 159–268 …
  258                      } else {
  259                          "Tool requires user approval".to_string()
  260                      },
  261                      confidence: 1.0, // Permission decisions are definitive
  262                      inspector_name: self.name().to_string(),
  263                      finding_id: None,
  264                  });
  265              }
  266          }
  267  
  268          Ok(results)

   25  /// Check if the current process is running inside a Flatpak sandbox.
   26  ///
   27  /// When inside Flatpak, shell commands must be wrapped with `flatpak-spawn --host`
   28  /// to execute on the host system rather than inside the sandbox.
   29  #[cfg(not(windows))]
   30  pub(crate) fn is_flatpak() -> bool {
   31      std::path::Path::new("/.flatpak-info").exists()
   32  }
   33  
   34  #[cfg(not(windows))]
   35  const FLATPAK_HOST_ARGS: [&str; 2] = ["--host", "--watch-bus"];
   36  
   37  #[cfg(not(windows))]
   38  pub(crate) fn flatpak_spawn_command() -> tokio::process::Command {
   39      let mut command = tokio::process::Command::new("flatpak-spawn");
   40      command.args(FLATPAK_HOST_ARGS);
   41      command
   42  }
   43  
   44  #[cfg(not(windows))]
   45  fn flatpak_spawn_process() -> std::process::Command {
   46      let mut command = std::process::Command::new("flatpak-spawn");
   47      command.args(FLATPAK_HOST_ARGS);
   48      command
   49  }

 1271      /// Get all tools from all clients with proper prefixing
 1272      pub async fn get_prefixed_tools(
 1273          &self,
 1274          session_id: &str,
 1275          extension_name: Option<String>,
 1276      ) -> ExtensionResult<Vec<Tool>> {
 1277          let all_tools = self.get_all_tools_cached(session_id).await?;
 1278          Ok(self.filter_tools(&all_tools, extension_name.as_deref(), None))
 1279      }
 1280  
 1281      pub async fn get_prefixed_tools_excluding(
 1282          &self,
 1283          session_id: &str,
 1284          exclude: &str,
 1285      ) -> ExtensionResult<Vec<Tool>> {
 1286          let all_tools = self.get_all_tools_cached(session_id).await?;
 1287          Ok(self.filter_tools(&all_tools, None, Some(exclude)))
 1288      }
 1289  
 1290      fn filter_tools(
 1291          &self,
 1292          tools: &[Tool],
 1293          extension_name: Option<&str>,
 1294          exclude: Option<&str>,
 1295      ) -> Vec<Tool> {
      … 36 lines omitted; exact range 1271–1342 …
 1332  
 1333          {
 1334              let mut cache = self.tools_cache.lock().await;
 1335              let version_after = self.tools_cache_version.load(Ordering::SeqCst);
 1336              if version_after == version_before && cache.is_none() {
 1337                  *cache = Some(Arc::clone(&tools));
 1338              }
 1339          }
 1340  
 1341          Ok(tools)
 1342      }

  612  async fn connect_with_auth(
  613      auth_manager: rmcp::transport::AuthorizationManager,
  614      uri: &str,
  615      timeout: Duration,
  616      headers: &HashMap<String, String>,
  617      provider: SharedProvider,
  618      client_name: String,
  619      capabilities: GooseMcpClientCapabilities,
  620      roots_dir: &std::path::Path,
  621  ) -> ExtensionResult<Box<dyn McpClientTrait>> {
  622      let mut auth_headers = HeaderMap::new();
  623      auth_headers.insert(reqwest::header::USER_AGENT, GOOSE_USER_AGENT);
  624      for (key, value) in headers {
  625          auth_headers.insert(
  626              HeaderName::try_from(key)
  627                  .map_err(|_| ExtensionError::ConfigError(format!("invalid header: {}", key)))?,
  628              value.parse().map_err(|_| {
  629                  ExtensionError::ConfigError(format!("invalid header value: {}", key))
  630              })?,
  631          );
  632      }
  633      #[allow(unused_mut)]
  634      let mut auth_client_builder = reqwest::Client::builder().default_headers(auth_headers);
  635      #[cfg(target_os = "linux")]
  636      {
      … 83 lines omitted; exact range 612–730 …
  720  
  721      let transport = StreamableHttpClientTransport::with_client(
  722          http_client,
  723          StreamableHttpClientTransportConfig::with_uri(uri),
  724      );
  725  
  726      // If we have stored OAuth credentials, try refreshing and connecting directly.
  727      // This avoids the unnecessary 401 → browser re-auth cycle on every new session.
  728      if credential_store.load().await.is_ok_and(|c| c.is_some()) {
  729          match oauth_flow(&uri.to_string(), &name.to_string()).await {
  730              Ok(auth_manager) => {

  322  fn remove_untrusted_mcp_app_meta(result: &mut CallToolResult) {
  323      let Some(meta) = result.meta.as_mut() else {
  324          return;
  325      };
  326  
  327      meta.0.remove(TRUSTED_TOOL_UPDATE_META_KEY);
  328  
  329      let remove_goose = meta
  330          .0
  331          .get_mut("goose")
  332          .and_then(Value::as_object_mut)
  333          .map(|goose_meta| {
  334              goose_meta.remove("mcpApp");
  335              goose_meta.is_empty()
  336          })
  337          .unwrap_or(false);
  338  
  339      if remove_goose {
  340          meta.0.remove("goose");
  341      }
  342  
  343      if meta.0.is_empty() {
  344          result.meta = None;
  345      }
  346  }

   95      pub fn with_hints(mut self, working_dir: &Path) -> Self {
   96          let hints_filenames = get_context_filenames();
   97          let ignore_patterns = build_gitignore(working_dir);
   98  
   99          let hints = load_hint_files(working_dir, &hints_filenames, &ignore_patterns);
  100  
  101          if !hints.is_empty() {
  102              self.hints = Some(hints);
  103          }
  104          self
  105      }
  106  
  107      pub fn with_enable_subagents(mut self, subagents_enabled: bool) -> Self {
  108          self.subagents_enabled = subagents_enabled;
  109          self
  110      }
  111  
  112      pub fn with_goose_mode(mut self, mode: GooseMode) -> Self {
  113          self.goose_mode = Some(mode);
  114          self
  115      }
  116  
  117      pub fn build(self) -> String {
  118          let mut extensions_info = self.extensions_info;
  119  
      … 35 lines omitted; exact range 95–165 …
  155              max_tools: MAX_TOOLS,
  156              code_execution_mode: self.code_execution_mode,
  157              moim_system_prompt_block: moim::system_prompt_block(),
  158          };
  159  
  160          let base_prompt = if let Some(override_prompt) = &self.manager.system_prompt_override {
  161              let sanitized_override_prompt = sanitize_unicode_tags(override_prompt);
  162              prompt_template::render_string(&sanitized_override_prompt, &context)
  163          } else {
  164              prompt_template::render_template("system.md", &context)
  165          }

  313  /// Every directory the agent reads skills from, paired with whether each is a
  314  /// global (home-rooted) location. Order matches discovery precedence: project
  315  /// dirs first, then global dirs.
  316  pub fn all_skill_dirs(working_dir: Option<&Path>) -> Vec<(PathBuf, bool)> {
  317      let mut dirs: Vec<(PathBuf, bool)> = Vec::new();
  318  
  319      if let Some(wd) = working_dir {
  320          dirs.push((wd.join(".agents").join("skills"), false));
  321          dirs.push((wd.join(".goose").join("skills"), false));
  322          dirs.push((wd.join(".claude").join("skills"), false));
  323      }
  324  
  325      let home = dirs::home_dir();
  326      if let Some(h) = home.as_ref() {
  327          dirs.push((h.join(".agents").join("skills"), true));
  328      }
  329      dirs.push((Paths::config_dir().join("skills"), true));
  330      if let Some(h) = home.as_ref() {
  331          dirs.push((h.join(".claude").join("skills"), true));
  332          dirs.push((h.join(".config").join("agents").join("skills"), true));
  333      }
  334  
  335      dirs.extend(
  336          installed_plugin_skill_dirs()
  337              .into_iter()
  338              .map(|dir| (dir, true)),
  339      );
  340  
  341      dirs

   64  impl HookEvent {
   65      fn name(&self) -> &'static str {
   66          match self {
   67              HookEvent::PreToolUse => "PreToolUse",
   68              HookEvent::PostToolUse => "PostToolUse",
   69              HookEvent::PostToolUseFailure => "PostToolUseFailure",
   70              HookEvent::SessionStart => "SessionStart",
   71              HookEvent::SessionEnd => "SessionEnd",
   72              HookEvent::UserPromptSubmit => "UserPromptSubmit",
   73              HookEvent::BeforeReadFile => "BeforeReadFile",
   74              HookEvent::AfterFileEdit => "AfterFileEdit",
   75              HookEvent::BeforeShellExecution => "BeforeShellExecution",
   76              HookEvent::AfterShellExecution => "AfterShellExecution",
   77              HookEvent::Stop => "Stop",
   78          }
   79      }
   80  
   81      fn from_name(name: &str) -> Option<Self> {
   82          Some(match name {
   83              "PreToolUse" => HookEvent::PreToolUse,
   84              "PostToolUse" => HookEvent::PostToolUse,
   85              "PostToolUseFailure" => HookEvent::PostToolUseFailure,
   86              "SessionStart" => HookEvent::SessionStart,
   87              "SessionEnd" => HookEvent::SessionEnd,
   88              "UserPromptSubmit" => HookEvent::UserPromptSubmit,
   89              "BeforeReadFile" => HookEvent::BeforeReadFile,
   90              "AfterFileEdit" => HookEvent::AfterFileEdit,
   91              "BeforeShellExecution" => HookEvent::BeforeShellExecution,
   92              "AfterShellExecution" => HookEvent::AfterShellExecution,
   93              "Stop" => HookEvent::Stop,
   94              _ => return None,
   95          })

  121  fn get_agent_messages(params: SubagentRunParams) -> AgentMessagesFuture {
  122      Box::pin(async move {
  123          let SubagentRunParams {
  124              config,
  125              recipe,
  126              task_config,
  127              session_id,
  128              cancellation_token,
  129              on_message,
  130              notification_tx,
  131              ..
  132          } = params;
  133  
  134          let system_instructions = recipe.instructions.clone().unwrap_or_default();
  135          let user_task = recipe
  136              .prompt
  137              .clone()
  138              .unwrap_or_else(|| "Begin.".to_string());
  139  
  140          let agent = Arc::new(Agent::with_config(config));
  141  
  142          agent
  143              .update_provider(
  144                  task_config.provider.clone(),
  145                  task_config.model_config.clone(),
      … 74 lines omitted; exact range 121–230 …
  220                  Err(e) => {
  221                      tracing::error!("Error receiving message from subagent: {}", e);
  222                      break;
  223                  }
  224              }
  225          }
  226  
  227          let final_output = get_final_output(&agent, has_response_schema).await;
  228  
  229          Ok((conversation, final_output))
  230      })

   45  pub enum SessionType {
   46      #[default]
   47      User,
   48      Scheduled,
   49      SubAgent,
   50      Hidden,
   51      Terminal,
   52      Gateway,
   53      Acp,
   54  }
   55  
   56  static SESSION_STORAGE: LazyLock<Arc<SessionStorage>> =
   57      LazyLock::new(|| Arc::new(SessionStorage::new(Paths::data_dir())));
   58  
   59  #[derive(Debug, Clone, Serialize, Deserialize)]
   60  pub struct Session {
   61      pub id: String,
   62      pub working_dir: PathBuf,
   63      #[serde(alias = "description")]
   64      pub name: String,
   65      #[serde(default)]
   66      pub user_set_name: bool,
   67      #[serde(default)]
   68      pub session_type: SessionType,
   69      pub created_at: DateTime<Utc>,
      … 16 lines omitted; exact range 45–96 …
   86      #[serde(default)]
   87      pub goose_mode: GooseMode,
   88      #[serde(default)]
   89      pub archived_at: Option<DateTime<Utc>>,
   90      #[serde(default)]
   91      pub project_id: Option<String>,
   92      #[serde(default)]
   93      pub parent_session_id: Option<String>,
   94      #[serde(default)]
   95      pub last_message_snippet: Option<String>,
   96  }

  103  impl ObservationLayer {
  104      pub async fn handle_span(&self, span_id: u64, span_data: SpanData) {
  105          let observation_id = span_data.observation_id.clone();
  106  
  107          {
  108              let mut spans = self.span_tracker.lock().await;
  109              spans.add_span(span_id, observation_id.clone());
  110          }
  111  
  112          // Get parent ID if it exists
  113          let parent_id = if let Some(parent_span_id) = span_data.parent_span_id {
  114              let spans = self.span_tracker.lock().await;
  115              spans.get_span(parent_span_id).cloned()
  116          } else {
  117              None
  118          };
  119  
  120          let trace_id = self.ensure_trace_id().await;
  121  
  122          // Create the span observation
  123          let mut batch = self.batch_manager.lock().await;
  124          batch.add_event(
  125              "observation-create",
  126              json!({
  127                  "id": observation_id,
      … 46 lines omitted; exact range 103–184 …
  174                  "name": Utc::now().timestamp().to_string(),
  175                  "timestamp": Utc::now().to_rfc3339(),
  176                  "input": {},
  177                  "metadata": {},
  178                  "tags": [],
  179                  "public": false
  180              }),
  181          );
  182  
  183          trace_id
  184      }