winx_code_agent/server/
handler.rs

1use rmcp::{
2    model::{
3        CacheScope, CallToolRequestParams, CallToolResponse, CancelTaskParams,
4        GetPromptRequestParams, GetPromptResponse, GetPromptResult, GetTaskParams, GetTaskResult,
5        Icon, Implementation, ListPromptsResult, ListResourcesResult, ListToolsResult,
6        PaginatedRequestParams, PromptMessage, ProtocolVersion, ReadResourceRequestParams,
7        ReadResourceResponse, ReadResourceResult, Resource, ResourceContents, Role,
8        ServerCapabilities, ServerInfo, Tool, UpdateTaskParams,
9    },
10    service::{NotificationContext, RequestContext, RoleServer},
11    ErrorData as McpError, ServerHandler,
12};
13
14use super::catalog::{server_icon_data_uri, winx_prompts, winx_tools, winx_tools_for_policy};
15use super::outcomes;
16use super::principal::{
17    conversation_identity_from_context, principal_from_context, scope_tool_request,
18    session_affinity_from_context, task_belongs_to_principal,
19};
20use super::usage::UsageEvent;
21use super::WinxService;
22use crate::runtime::ShellActionOptions;
23use crate::tool_policy::ToolPolicy;
24use crate::tool_registry::ToolKind;
25use crate::tools::edit_files::EditSurface;
26use crate::types::{BashCommand, BashWaitPolicy};
27
28pub(crate) const COMPACT_BASH_OUTPUT_EXTENSION: &str = "io.winx/compact-bash-output";
29const ADAPTIVE_TASK_INLINE_SECONDS: f32 = 2.0;
30const RETURN_EARLY_DEFAULT_SECONDS: f32 = 0.25;
31const RETURN_EARLY_MAX_SECONDS: f32 = 5.0;
32const SYNCHRONOUS_MAX_SECONDS: f32 = 60.0;
33
34#[derive(Clone, Copy, Debug, Eq, PartialEq)]
35enum BashTaskRoute {
36    Synchronous,
37    Adaptive,
38    Immediate,
39}
40
41fn bash_task_route(
42    client_tasks: bool,
43    generation_bound_runtime: bool,
44    eligible: bool,
45    policy: BashWaitPolicy,
46) -> BashTaskRoute {
47    if !client_tasks || !generation_bound_runtime || !eligible {
48        return BashTaskRoute::Synchronous;
49    }
50    match policy {
51        BashWaitPolicy::Adaptive => BashTaskRoute::Adaptive,
52        BashWaitPolicy::UntilComplete => BashTaskRoute::Immediate,
53        BashWaitPolicy::ReturnEarly => BashTaskRoute::Synchronous,
54    }
55}
56
57fn adaptive_action_options(compact_output: bool) -> ShellActionOptions {
58    ShellActionOptions {
59        compact_output,
60        // Adaptive promotion is already backed by a Task reservation. Require
61        // the effective guardian epoch to be checked live before this first
62        // action so a recreated guardian cannot launch an untracked process
63        // under a stale adapter cache.
64        require_generation_binding: true,
65        ..ShellActionOptions::default()
66    }
67}
68
69/// Emit the cache fields required by MCP 2026-07-28 without changing the wire
70/// shape for clients that negotiated an older protocol revision.
71fn cache_hints_for_protocol(
72    protocol_version: Option<ProtocolVersion>,
73    cache_scope: CacheScope,
74) -> (Option<u64>, Option<CacheScope>) {
75    if protocol_version.is_some_and(|version| version >= ProtocolVersion::V_2026_07_28) {
76        (Some(0), Some(cache_scope))
77    } else {
78        (None, None)
79    }
80}
81
82fn supports_compact_bash_output(context: &RequestContext<RoleServer>) -> bool {
83    context.client_capabilities().is_some_and(|capabilities| {
84        capabilities
85            .extensions
86            .as_ref()
87            .is_some_and(|extensions| extensions.contains_key(COMPACT_BASH_OUTPUT_EXTENSION))
88    })
89}
90
91fn normalized_wait_request(
92    mut request: CallToolRequestParams,
93    policy: BashWaitPolicy,
94    task_inline: bool,
95) -> Result<CallToolRequestParams, McpError> {
96    let mut arguments = request
97        .arguments
98        .clone()
99        .ok_or_else(|| McpError::invalid_request("Missing BashCommand arguments", None))?;
100    let requested = arguments
101        .get("wait_for_seconds")
102        .cloned()
103        .map(serde_json::from_value::<f32>)
104        .transpose()
105        .map_err(|error| {
106            McpError::invalid_request(format!("Invalid wait_for_seconds: {error}"), None)
107        })?;
108    let (default, maximum) = match (policy, task_inline) {
109        (BashWaitPolicy::Adaptive, true) => {
110            (ADAPTIVE_TASK_INLINE_SECONDS, ADAPTIVE_TASK_INLINE_SECONDS)
111        }
112        (BashWaitPolicy::ReturnEarly, _) => {
113            (RETURN_EARLY_DEFAULT_SECONDS, RETURN_EARLY_MAX_SECONDS)
114        }
115        (BashWaitPolicy::Adaptive, false) => (15.0, SYNCHRONOUS_MAX_SECONDS),
116        (BashWaitPolicy::UntilComplete, false) => {
117            (SYNCHRONOUS_MAX_SECONDS, SYNCHRONOUS_MAX_SECONDS)
118        }
119        (BashWaitPolicy::UntilComplete, true) => unreachable!("until_complete starts a Task"),
120    };
121    arguments.insert(
122        "wait_for_seconds".to_string(),
123        serde_json::Value::from(requested.unwrap_or(default).clamp(0.0, maximum)),
124    );
125    request.arguments = Some(arguments);
126    Ok(request)
127}
128
129#[allow(clippy::unused_async_trait_impl)] // rmcp's trait requires these async signatures
130impl ServerHandler for WinxService {
131    fn get_info(&self) -> ServerInfo {
132        let mut capabilities = ServerCapabilities::builder()
133            .enable_tools()
134            .enable_resources()
135            .enable_prompts()
136            .enable_tasks()
137            .build();
138        capabilities
139            .extensions
140            .get_or_insert_default()
141            .insert(COMPACT_BASH_OUTPUT_EXTENSION.to_string(), rmcp::model::JsonObject::new());
142        ServerInfo::new(capabilities)
143            .with_server_info(
144                Implementation::new("winx-mcp-server", self.version.clone())
145                    .with_title("Winx High-Performance MCP")
146                    .with_icons(vec![Icon::new(server_icon_data_uri())
147                        .with_mime_type("image/png")
148                        .with_sizes(vec!["96x96".to_string()])]),
149            )
150            .with_protocol_version(ProtocolVersion::V_2026_07_28)
151            .with_instructions(crate::utils::orchestration::server_instructions())
152    }
153
154    async fn on_initialized(&self, context: NotificationContext<RoleServer>) {
155        self.initialize_from_client_roots(context).await;
156    }
157
158    async fn on_roots_list_changed(&self, context: NotificationContext<RoleServer>) {
159        // A changed Roots list is only used as a retry if Winx is still
160        // uninitialized. Never switch an active shell's workspace implicitly.
161        self.initialize_from_client_roots(context).await;
162    }
163
164    fn get_tool(&self, name: &str) -> Option<Tool> {
165        winx_tools().into_iter().find(|tool| tool.name == name)
166    }
167
168    async fn get_task(
169        &self,
170        request: GetTaskParams,
171        context: RequestContext<RoleServer>,
172    ) -> Result<GetTaskResult, McpError> {
173        let principal = principal_from_context(&context);
174        if !task_belongs_to_principal(&request.task_id, principal.as_ref()) {
175            return Err(McpError::invalid_request(
176                format!("Unknown or expired task: {}", request.task_id),
177                None,
178            ));
179        }
180        let mut tasks = self.tasks.lock().await;
181        let entry = tasks.get(&request.task_id).ok_or_else(|| {
182            McpError::invalid_request(format!("Unknown or expired task: {}", request.task_id), None)
183        })?;
184        Ok(GetTaskResult::new(entry.detailed()))
185    }
186
187    async fn update_task(
188        &self,
189        request: UpdateTaskParams,
190        context: RequestContext<RoleServer>,
191    ) -> Result<(), McpError> {
192        let principal = principal_from_context(&context);
193        if !task_belongs_to_principal(&request.task_id, principal.as_ref()) {
194            return Err(McpError::invalid_request(
195                format!("Unknown or expired task: {}", request.task_id),
196                None,
197            ));
198        }
199        let mut tasks = self.tasks.lock().await;
200        tasks.get(&request.task_id).ok_or_else(|| {
201            McpError::invalid_request(format!("Unknown or expired task: {}", request.task_id), None)
202        })?;
203        Ok(())
204    }
205
206    async fn cancel_task(
207        &self,
208        request: CancelTaskParams,
209        context: RequestContext<RoleServer>,
210    ) -> Result<(), McpError> {
211        let principal = principal_from_context(&context);
212        if !task_belongs_to_principal(&request.task_id, principal.as_ref()) {
213            return Err(McpError::invalid_request(
214                format!("Unknown or expired task: {}", request.task_id),
215                None,
216            ));
217        }
218        self.cancel_bash_task(&request.task_id).await
219    }
220
221    async fn list_tools(
222        &self,
223        _request: Option<PaginatedRequestParams>,
224        ctx: RequestContext<RoleServer>,
225    ) -> Result<ListToolsResult, McpError> {
226        let principal = principal_from_context(&ctx);
227        let (tools, scope) = principal.as_ref().map_or_else(
228            || (winx_tools(), CacheScope::Public),
229            |principal| {
230                let policy = principal.tool_policy();
231                let scope = if policy == crate::tool_policy::ToolPolicy::default() {
232                    CacheScope::Public
233                } else {
234                    CacheScope::Private
235                };
236                (winx_tools_for_policy(policy), scope)
237            },
238        );
239        let (ttl_ms, cache_scope) = cache_hints_for_protocol(ctx.protocol_version(), scope);
240        let mut result = ListToolsResult::with_all_items(tools);
241        result.ttl_ms = ttl_ms;
242        result.cache_scope = cache_scope;
243        Ok(result)
244    }
245
246    async fn list_resources(
247        &self,
248        _request: Option<PaginatedRequestParams>,
249        ctx: RequestContext<RoleServer>,
250    ) -> Result<ListResourcesResult, McpError> {
251        let (ttl_ms, cache_scope) =
252            cache_hints_for_protocol(ctx.protocol_version(), CacheScope::Public);
253        let mut result =
254            ListResourcesResult::with_all_items(vec![Resource::new("file://readme", "README")
255                .with_description("Project README documentation")
256                .with_mime_type("text/markdown")]);
257        result.ttl_ms = ttl_ms;
258        result.cache_scope = cache_scope;
259        Ok(result)
260    }
261
262    async fn list_prompts(
263        &self,
264        _request: Option<PaginatedRequestParams>,
265        ctx: RequestContext<RoleServer>,
266    ) -> Result<ListPromptsResult, McpError> {
267        let (ttl_ms, cache_scope) =
268            cache_hints_for_protocol(ctx.protocol_version(), CacheScope::Public);
269        let mut result = ListPromptsResult::with_all_items(winx_prompts());
270        result.ttl_ms = ttl_ms;
271        result.cache_scope = cache_scope;
272        Ok(result)
273    }
274
275    async fn get_prompt(
276        &self,
277        request: GetPromptRequestParams,
278        context: RequestContext<RoleServer>,
279    ) -> Result<GetPromptResponse, McpError> {
280        if request.name != "KnowledgeTransfer" {
281            return Err(McpError::invalid_request(
282                format!("Unknown prompt: {}", request.name),
283                None,
284            ));
285        }
286
287        let principal = principal_from_context(&context);
288        let session_prefix = principal.as_ref().map(crate::config::HttpPrincipal::session_prefix);
289        let text = crate::utils::redact::redact(
290            &self.knowledge_transfer_prompt_text(session_prefix.as_deref()).await,
291        )
292        .into_owned();
293        Ok(GetPromptResult::new(vec![PromptMessage::new_text(Role::User, text)])
294            .with_description("Knowledge transfer handoff prompt")
295            .into())
296    }
297
298    async fn read_resource(
299        &self,
300        request: ReadResourceRequestParams,
301        ctx: RequestContext<RoleServer>,
302    ) -> Result<ReadResourceResponse, McpError> {
303        let content = match request.uri.as_ref() {
304            "file://readme" => match tokio::fs::read_to_string("README.md").await {
305                Ok(content) => vec![ResourceContents::text(
306                    crate::utils::redact::redact(&content).into_owned(),
307                    request.uri.clone(),
308                )],
309                Err(_) => vec![ResourceContents::text(
310                    "README.md not found".to_string(),
311                    request.uri.clone(),
312                )],
313            },
314            _ => {
315                return Err(McpError::invalid_request(
316                    format!("Unknown resource URI: {}", request.uri),
317                    None,
318                ));
319            }
320        };
321        let (ttl_ms, cache_scope) =
322            cache_hints_for_protocol(ctx.protocol_version(), CacheScope::Private);
323        let mut result = ReadResourceResult::new(content);
324        result.ttl_ms = ttl_ms;
325        result.cache_scope = cache_scope;
326        Ok(result.into())
327    }
328
329    #[allow(clippy::too_many_lines)] // request scoping, negotiated routing, execution, and telemetry
330    async fn call_tool(
331        &self,
332        request: CallToolRequestParams,
333        context: RequestContext<RoleServer>,
334    ) -> Result<CallToolResponse, McpError> {
335        let tool_kind = ToolKind::parse(request.name.as_ref());
336        if tool_kind.is_none() {
337            return Err(McpError::invalid_request(format!("Unknown tool: {}", request.name), None));
338        }
339        let principal = principal_from_context(&context);
340        let effective_tool_policy = principal
341            .as_ref()
342            .map_or_else(ToolPolicy::default, super::super::config::HttpPrincipal::tool_policy);
343
344        // Parse edit arguments once into the typed domain before any capability
345        // decision. This avoids policy decisions based on loosely typed/raw
346        // JSON fields and makes malformed edit calls recoverable tool results,
347        // even when another gate (workspace or capability) would also reject
348        // the request.
349        let edit_surface = tool_kind.and_then(EditSurface::from_public_tool);
350        let normalized_edit = if let Some(surface) = edit_surface {
351            let arguments = request
352                .arguments
353                .clone()
354                .map_or(serde_json::Value::Null, serde_json::Value::Object);
355            match crate::tools::edit_files::normalize_edit_call(surface, arguments.clone()) {
356                Ok(normalized) => Some(normalized),
357                Err(error) => {
358                    let mut result =
359                        outcomes::tool_failure(request.name.as_ref(), &error, Some(&arguments))?;
360                    outcomes::enforce_next_action_policy(&mut result, effective_tool_policy);
361                    return Ok(result.into());
362                }
363            }
364        } else {
365            None
366        };
367        let policy_allows_call =
368            tool_kind.is_some_and(|kind| effective_tool_policy.allows_call_kind(kind));
369        if !policy_allows_call {
370            return Err(McpError::invalid_request(
371                format!("Tool is not available for this principal: {}", request.name),
372                None,
373            ));
374        }
375        if normalized_edit.as_ref().is_some_and(|edit| edit.verification.is_some())
376            && !effective_tool_policy.edit_permissions().allows_verification()
377        {
378            return Err(McpError::invalid_request(
379                format!("{} verification requires BashCommand authority", request.name),
380                None,
381            ));
382        }
383        let affinity = session_affinity_from_context(&context);
384        let conversation_identity = conversation_identity_from_context(&context);
385        let (request, scope) =
386            scope_tool_request(request, principal, affinity, conversation_identity.as_deref())
387                .map_err(|error| {
388                    McpError::invalid_request(format!("Cannot scope remote request: {error}"), None)
389                })?;
390        let mut usage = UsageEvent::start(&request, &scope, &context);
391        match self
392            .validate_workspace_coherence(
393                &request,
394                &scope,
395                affinity,
396                conversation_identity.as_deref(),
397            )
398            .await
399        {
400            Ok(coherence) => usage.set_workspace_coherence(coherence.as_str()),
401            Err(error) => {
402                usage.set_workspace_coherence("rejected");
403                let arguments = request.arguments.clone().map(serde_json::Value::Object);
404                let mut result =
405                    outcomes::tool_failure(request.name.as_ref(), &error, arguments.as_ref())?;
406                outcomes::enforce_next_action_policy(&mut result, effective_tool_policy);
407                scope.unscope_result(&mut result);
408                let status = outcomes::result_status(&result);
409                usage.emit(
410                    "tool_error",
411                    &status,
412                    outcomes::result_size_bytes(&result),
413                    Some(&result),
414                );
415                return Ok(result.into());
416            }
417        }
418        let compact_bash_output = supports_compact_bash_output(&context);
419        let supports_tasks =
420            context.client_capabilities().is_some_and(|capabilities| capabilities.supports_tasks());
421        let wait_policy = if tool_kind == Some(ToolKind::BashCommand) {
422            Some(Self::bash_wait_policy(&request)?)
423        } else {
424            None
425        };
426        if wait_policy == Some(BashWaitPolicy::UntilComplete) {
427            let parsed_bash = request.arguments.clone().and_then(|arguments| {
428                serde_json::from_value::<BashCommand>(serde_json::Value::Object(arguments)).ok()
429            });
430            if let Some(bash) = parsed_bash.as_ref() {
431                let is_foreground_command = matches!(
432                    bash.action_json,
433                    crate::types::BashCommandAction::Command { is_background: false, .. }
434                );
435                if !is_foreground_command {
436                    let action = match &bash.action_json {
437                        crate::types::BashCommandAction::Command {
438                            is_background: true, ..
439                        } => "background_command",
440                        crate::types::BashCommandAction::Command { .. } => "foreground_command",
441                        crate::types::BashCommandAction::StatusCheck { .. } => "status_check",
442                        crate::types::BashCommandAction::SendText { .. } => "send_text",
443                        crate::types::BashCommandAction::SendSpecials { .. } => "send_specials",
444                        crate::types::BashCommandAction::SendAscii { .. } => "send_ascii",
445                        crate::types::BashCommandAction::Screen { .. } => "screen",
446                        crate::types::BashCommandAction::WaitForTurn { .. } => "wait_for_turn",
447                    };
448                    let error = crate::errors::WinxError::InvalidWaitPolicyForAction {
449                        wait_policy: "until_complete".to_string(),
450                        action: action.to_string(),
451                    };
452                    let arguments = request.arguments.clone().map(serde_json::Value::Object);
453                    let mut result =
454                        outcomes::tool_failure("BashCommand", &error, arguments.as_ref())?;
455                    outcomes::enforce_next_action_policy(&mut result, effective_tool_policy);
456                    scope.unscope_result(&mut result);
457                    let status = outcomes::result_status(&result);
458                    usage.emit(
459                        "tool_error",
460                        &status,
461                        outcomes::result_size_bytes(&result),
462                        Some(&result),
463                    );
464                    return Ok(result.into());
465                }
466            }
467        }
468
469        let eligible = Self::bash_task_is_eligible(&request);
470        let generation_bound_runtime = if supports_tasks && eligible {
471            let thread_id = request
472                .arguments
473                .as_ref()
474                .and_then(|arguments| arguments.get("thread_id"))
475                .and_then(serde_json::Value::as_str)
476                .unwrap_or_default();
477            let (slot, session_guard) = self.tool_session_for(thread_id).await;
478            let supported = self
479                .shell_runtime
480                .supports_generation_bound_actions_for(&slot)
481                .await
482                .unwrap_or(false);
483            drop(session_guard);
484            supported
485        } else {
486            false
487        };
488        let route = wait_policy.map_or(BashTaskRoute::Synchronous, |policy| {
489            bash_task_route(supports_tasks, generation_bound_runtime, eligible, policy)
490        });
491
492        match route {
493            BashTaskRoute::Immediate => {
494                let reservation = self.reserve_bash_task(&request, &scope).await?;
495                return match self
496                    .start_reserved_bash_task(
497                        reservation,
498                        request,
499                        scope,
500                        None,
501                        compact_bash_output,
502                    )
503                    .await
504                {
505                    Ok(task) => {
506                        usage.emit("task", "working", 0, None);
507                        Ok(CallToolResponse::Task(task))
508                    }
509                    Err(error) => {
510                        usage.emit("protocol_error", "failed", 0, None);
511                        Err(error)
512                    }
513                };
514            }
515            BashTaskRoute::Adaptive => {
516                let reservation = self.reserve_bash_task(&request, &scope).await?;
517                let task_request = request.clone();
518                let inline_request =
519                    normalized_wait_request(request, BashWaitPolicy::Adaptive, true)?;
520                match self
521                    .execute_tool_call(
522                        inline_request,
523                        adaptive_action_options(compact_bash_output),
524                        effective_tool_policy.edit_permissions(),
525                    )
526                    .await
527                {
528                    Ok(execution) if outcomes::result_status(&execution.result) == "running" => {
529                        return match self
530                            .start_reserved_bash_task(
531                                reservation,
532                                task_request,
533                                scope,
534                                Some(execution),
535                                compact_bash_output,
536                            )
537                            .await
538                        {
539                            Ok(task) => {
540                                usage.emit("task", "working", 0, None);
541                                Ok(CallToolResponse::Task(task))
542                            }
543                            Err(error) => {
544                                usage.emit("protocol_error", "failed", 0, None);
545                                Err(error)
546                            }
547                        };
548                    }
549                    Ok(mut execution) => {
550                        self.release_bash_task(&reservation).await;
551                        outcomes::enforce_next_action_policy(
552                            &mut execution.result,
553                            effective_tool_policy,
554                        );
555                        scope.unscope_result(&mut execution.result);
556                        let status = outcomes::result_status(&execution.result);
557                        let outcome = if execution.result.is_error == Some(true) {
558                            "tool_error"
559                        } else {
560                            "ok"
561                        };
562                        usage.emit(
563                            outcome,
564                            &status,
565                            outcomes::result_size_bytes(&execution.result),
566                            Some(&execution.result),
567                        );
568                        return Ok(execution.result.into());
569                    }
570                    Err(mut error) => {
571                        self.release_bash_task(&reservation).await;
572                        scope.unscope_error(&mut error);
573                        usage.emit("protocol_error", "failed", 0, None);
574                        return Err(error);
575                    }
576                }
577            }
578            BashTaskRoute::Synchronous => {}
579        }
580
581        let request = match wait_policy {
582            Some(policy) => normalized_wait_request(request, policy, false)?,
583            None => request,
584        };
585        match self
586            .execute_tool_call(
587                request,
588                ShellActionOptions {
589                    compact_output: compact_bash_output,
590                    ..ShellActionOptions::default()
591                },
592                effective_tool_policy.edit_permissions(),
593            )
594            .await
595        {
596            Ok(mut execution) => {
597                let result = &mut execution.result;
598                outcomes::enforce_next_action_policy(result, effective_tool_policy);
599                scope.unscope_result(result);
600                let status = outcomes::result_status(result);
601                let outcome = if result.is_error == Some(true) { "tool_error" } else { "ok" };
602                usage.emit(outcome, &status, outcomes::result_size_bytes(result), Some(result));
603                Ok(execution.result.into())
604            }
605            Err(mut error) => {
606                scope.unscope_error(&mut error);
607                usage.emit("protocol_error", "failed", 0, None);
608                Err(error)
609            }
610        }
611    }
612}
613
614#[cfg(test)]
615mod tests {
616    use super::super::usage::usage_result_metadata;
617    use super::*;
618    use rmcp::model::CallToolResult;
619
620    #[test]
621    fn cache_hints_follow_negotiated_protocol_version() {
622        assert_eq!(
623            cache_hints_for_protocol(Some(ProtocolVersion::V_2026_07_28), CacheScope::Private,),
624            (Some(0), Some(CacheScope::Private))
625        );
626        assert_eq!(
627            cache_hints_for_protocol(Some(ProtocolVersion::V_2026_07_28), CacheScope::Public),
628            (Some(0), Some(CacheScope::Public))
629        );
630        assert_eq!(
631            cache_hints_for_protocol(Some(ProtocolVersion::V_2025_11_25), CacheScope::Private,),
632            (None, None)
633        );
634        assert_eq!(cache_hints_for_protocol(None, CacheScope::Private), (None, None));
635    }
636
637    #[test]
638    fn guardian_1_4_uses_synchronous_policy_fallback_even_for_task_clients() {
639        assert_eq!(
640            bash_task_route(true, false, true, BashWaitPolicy::Adaptive),
641            BashTaskRoute::Synchronous
642        );
643        assert_eq!(
644            bash_task_route(true, false, true, BashWaitPolicy::UntilComplete),
645            BashTaskRoute::Synchronous
646        );
647    }
648
649    #[test]
650    fn task_routing_requires_client_runtime_and_foreground_eligibility() {
651        assert_eq!(
652            bash_task_route(true, true, true, BashWaitPolicy::Adaptive),
653            BashTaskRoute::Adaptive
654        );
655        assert_eq!(
656            bash_task_route(true, true, true, BashWaitPolicy::UntilComplete),
657            BashTaskRoute::Immediate
658        );
659        assert_eq!(
660            bash_task_route(true, true, true, BashWaitPolicy::ReturnEarly),
661            BashTaskRoute::Synchronous
662        );
663        assert_eq!(
664            bash_task_route(false, true, true, BashWaitPolicy::UntilComplete),
665            BashTaskRoute::Synchronous
666        );
667        assert_eq!(
668            bash_task_route(true, true, false, BashWaitPolicy::UntilComplete),
669            BashTaskRoute::Synchronous
670        );
671    }
672
673    #[test]
674    #[allow(clippy::expect_used)]
675    fn receipt_bound_verify_is_not_task_promotable() {
676        let arguments = serde_json::json!({
677            "action_json": {
678                "type": "verify",
679                "verification_id": "verify_123",
680                "command": "cargo test"
681            },
682            "thread_id": "thread"
683        });
684        let request = CallToolRequestParams::new("BashCommand")
685            .with_arguments(arguments.as_object().expect("arguments object").clone());
686        assert!(!WinxService::bash_task_is_eligible(&request));
687    }
688
689    #[test]
690    fn adaptive_action_requires_live_generation_binding() {
691        let options = adaptive_action_options(true);
692        assert!(options.compact_output);
693        assert!(options.require_generation_binding);
694    }
695
696    #[test]
697    fn usage_metadata_reads_image_code_map_and_temp_envelopes() {
698        let result_with = |structured| {
699            let mut result = CallToolResult::success(Vec::new());
700            result.structured_content = Some(structured);
701            result
702        };
703        let image = result_with(serde_json::json!({
704            "data": {"result": {
705                "source_bytes": 17_000_000,
706                "delivered_bytes": 2_000_000,
707                "transcoded": true,
708                "deduplicated": false
709            }}
710        }));
711        let metadata = usage_result_metadata(Some(&image));
712        assert_eq!(metadata.source_bytes, 17_000_000);
713        assert_eq!(metadata.payload_bytes, 2_000_000);
714        assert!(metadata.image_transcoded);
715        assert!(!metadata.image_deduplicated);
716
717        let code_map = result_with(serde_json::json!({
718            "source_kind": "canonical",
719            "payload_bytes": 12_345
720        }));
721        let metadata = usage_result_metadata(Some(&code_map));
722        assert_eq!(metadata.source_kind, "canonical");
723        assert_eq!(metadata.payload_bytes, 12_345);
724
725        let temporary = result_with(serde_json::json!({
726            "data": {
727                "session_files": 129,
728                "session_bytes": 4096,
729                "stale_pruned_files": 32,
730                "stale_pruned_bytes": 2048,
731                "temporary_artifact_cleanup_required": true
732            }
733        }));
734        let metadata = usage_result_metadata(Some(&temporary));
735        assert_eq!(metadata.temporary_session_files, 129);
736        assert_eq!(metadata.temporary_session_bytes, 4096);
737        assert_eq!(metadata.temporary_stale_pruned_files, 32);
738        assert_eq!(metadata.temporary_stale_pruned_bytes, 2048);
739        assert!(metadata.temporary_over_budget);
740
741        let edit_follow_up = result_with(serde_json::json!({
742            "errorCode": "verification_failed",
743            "retrySameCall": false,
744            "nextAction": {"tool": "VerifyEdit"},
745            "requiredReads": [],
746            "data": {
747                "edit_applied": true,
748                "verification_status": "failed",
749                "mutation_transition": "committed",
750                "mutation_replayed": false,
751                "mutation_receipt_persisted": true
752            }
753        }));
754        let metadata = usage_result_metadata(Some(&edit_follow_up));
755        assert_eq!(metadata.error_code, "verification_failed");
756        assert_eq!(metadata.recovery.next_action_tool, "VerifyEdit");
757        assert_eq!(metadata.recovery.required_read_count, 0);
758        assert!(!metadata.recovery.retry_same_call);
759        assert!(metadata.recovery.edit_applied);
760        assert!(!metadata.recovery.fresh_read_required);
761        assert_eq!(metadata.recovery.verification_status, "failed");
762        assert_eq!(metadata.recovery.mutation_transition, "committed");
763        assert_eq!(metadata.recovery.mutation_receipt_state, "persisted");
764
765        let edit_conflict = result_with(serde_json::json!({
766            "errorCode": "search_block_not_found",
767            "retrySameCall": false,
768            "nextAction": {"tool": "ReadFiles"},
769            "requiredReads": [{"path": "/workspace/lib.rs", "ranges": []}],
770            "data": {
771                "edit_applied": false,
772                "fresh_read_required": true,
773                "recovery_attempt": 2,
774                "recovery_escalated": true
775            }
776        }));
777        let metadata = usage_result_metadata(Some(&edit_conflict));
778        assert_eq!(metadata.error_code, "search_block_not_found");
779        assert_eq!(metadata.recovery.next_action_tool, "ReadFiles");
780        assert_eq!(metadata.recovery.required_read_count, 1);
781        assert!(!metadata.recovery.retry_same_call);
782        assert!(!metadata.recovery.edit_applied);
783        assert!(metadata.recovery.fresh_read_required);
784        assert_eq!(metadata.recovery.verification_status, "");
785        assert_eq!(metadata.recovery.recovery_attempt, 2);
786        assert_eq!(metadata.recovery.recovery_level, "escalated");
787    }
788
789    #[test]
790    #[allow(clippy::expect_used, clippy::float_cmp)]
791    fn synchronous_wait_policies_have_explicit_upper_bounds() {
792        let request = |wait_for_seconds: Option<f32>| {
793            let mut arguments = serde_json::Map::new();
794            arguments.insert("command".to_string(), serde_json::Value::String("pwd".to_string()));
795            if let Some(wait) = wait_for_seconds {
796                arguments.insert("wait_for_seconds".to_string(), serde_json::json!(wait));
797            }
798            CallToolRequestParams::new("BashCommand").with_arguments(arguments)
799        };
800        let normalized = |policy, wait| {
801            normalized_wait_request(request(wait), policy, false)
802                .expect("valid wait request")
803                .arguments
804                .and_then(|arguments| arguments.get("wait_for_seconds").cloned())
805                .and_then(|value| value.as_f64())
806                .expect("normalized wait")
807        };
808
809        assert_eq!(normalized(BashWaitPolicy::Adaptive, Some(500.0)), 60.0);
810        assert_eq!(normalized(BashWaitPolicy::UntilComplete, None), 60.0);
811        assert_eq!(normalized(BashWaitPolicy::ReturnEarly, Some(500.0)), 5.0);
812        assert_eq!(normalized(BashWaitPolicy::ReturnEarly, None), 0.25);
813    }
814}
winx_code_agent/server/handler.rs

winx_code_agent/server/
handler.rs
