Method handle_tools_call

src/mcp/server.rs:2343–2702

Handles the `tools/call` method, dispatching to the appropriate tool handler.

(
        &self,
        id: Value,
        params: Option<&Value>,
        timings_enabled: bool,
        route_cache: &HookProjectRouteCache,
        implicit_project_path: Option<&Path>,
    )

    /// Handles the `tools/call` method, dispatching to the appropriate tool handler.
    async fn handle_tools_call(
        &self,
        id: Value,
        params: Option<&Value>,
        timings_enabled: bool,
        route_cache: &HookProjectRouteCache,
        implicit_project_path: Option<&Path>,
    ) -> JsonRpcResponse {
        let Some(params) = params else {
            return JsonRpcResponse::error(
                id,
                ErrorCode::InvalidParams,
                "missing params for tools/call".to_string(),
            );
        };

        let Some(tool_name) = params.get("name").and_then(|v| v.as_str()) else {
            return JsonRpcResponse::error(
                id,
                ErrorCode::InvalidParams,
                "missing 'name' in tools/call params".to_string(),
            );
        };

        let arguments = params.get("arguments").cloned().unwrap_or(json!({}));
        let analytics_arguments = arguments.clone();
        let analytics_session_id = mcp_analytics_session_id(&arguments);

        // Branch-drift hot-swap: if the working tree switched branches since
        // the served instance opened, reopen onto the live branch's DB so
        // this call reads the right index. Cheap no-op check when no drift.
        let cg = self.reopen_if_branch_drifted().await;

        // Notification-free freshness is useful before tools that edit source
        // files in the index. Read-only graph queries should not block behind
        // a full project walk; on very large indexes (especially when
        // node_modules was intentionally included) that turns diagnostics and
        // search into sync operations.
        if needs_lazy_sync_before_dispatch(tool_name) {
            self.maybe_sync_if_stale().await;
        } else {
            // D4: sync-on-read (never blocking). Read tools serve the current
            // answer IMMEDIATELY and, when the read-refresh cooldown has
            // elapsed, kick a single-flighted background refresh so the *next*
            // read sees fresh data. This heals read-only sessions that never
            // touch an edit tool without ever making a query wait behind a
            // project walk.
            self.maybe_spawn_read_refresh(&cg);
        }

        self.stats.tool_calls.fetch_add(1, Ordering::Relaxed);
        eprintln!("[tracedecay] tool call: {tool_name}");
        if let Ok(mut counts) = self.tool_call_counts.lock() {
            *counts.entry(tool_name.to_string()).or_insert(0) += 1;
        }

        let server_stats = if tool_name == "tracedecay_status" {
            Some(self.server_stats_json().await)