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, ServerConfig, 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) -> ServerConfig {
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        ServerConfig::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                    outcomes::finalize_tool_result(&mut result);
362                    return Ok(result.into());
363                }
364            }
365        } else {
366            None
367        };
368        let policy_allows_call =
369            tool_kind.is_some_and(|kind| effective_tool_policy.allows_call_kind(kind));
370        if !policy_allows_call {
371            return Err(McpError::invalid_request(
372                format!("Tool is not available for this principal: {}", request.name),
373                None,
374            ));
375        }
376        if normalized_edit.as_ref().is_some_and(|edit| edit.verification.is_some())
377            && !effective_tool_policy.edit_permissions().allows_verification()
378        {
379            return Err(McpError::invalid_request(
380                format!("{} verification requires BashCommand authority", request.name),
381                None,
382            ));
383        }
384        let affinity = session_affinity_from_context(&context);
385        let conversation_identity = conversation_identity_from_context(&context);
386        let (request, scope) =
387            scope_tool_request(request, principal, affinity, conversation_identity.as_deref())
388                .map_err(|error| {
389                    McpError::invalid_request(format!("Cannot scope remote request: {error}"), None)
390                })?;
391        let mut usage = UsageEvent::start(&request, &scope, &context);
392        match self
393            .validate_workspace_coherence(
394                &request,
395                &scope,
396                affinity,
397                conversation_identity.as_deref(),
398            )
399            .await
400        {
401            Ok(coherence) => usage.set_workspace_coherence(coherence.as_str()),
402            Err(error) => {
403                usage.set_workspace_coherence("rejected");
404                let arguments = request.arguments.clone().map(serde_json::Value::Object);
405                let mut result =
406                    outcomes::tool_failure(request.name.as_ref(), &error, arguments.as_ref())?;
407                outcomes::enforce_next_action_policy(&mut result, effective_tool_policy);
408                outcomes::finalize_tool_result(&mut result);
409                scope.unscope_result(&mut result);
410                let status = outcomes::result_status(&result);
411                usage.emit(
412                    "tool_error",
413                    &status,
414                    outcomes::result_size_bytes(&result),
415                    Some(&result),
416                );
417                return Ok(result.into());
418            }
419        }
420        let compact_bash_output = supports_compact_bash_output(&context);
421        let supports_tasks =
422            context.client_capabilities().is_some_and(|capabilities| capabilities.supports_tasks());
423        let wait_policy = if tool_kind == Some(ToolKind::BashCommand) {
424            Some(Self::bash_wait_policy(&request)?)
425        } else {
426            None
427        };
428        if wait_policy == Some(BashWaitPolicy::UntilComplete) {
429            let parsed_bash = request.arguments.clone().and_then(|arguments| {
430                serde_json::from_value::<BashCommand>(serde_json::Value::Object(arguments)).ok()
431            });
432            if let Some(bash) = parsed_bash.as_ref() {
433                let is_foreground_command = matches!(
434                    bash.action_json,
435                    crate::types::BashCommandAction::Command { is_background: false, .. }
436                );
437                if !is_foreground_command {
438                    let action = match &bash.action_json {
439                        crate::types::BashCommandAction::Command {
440                            is_background: true, ..
441                        } => "background_command",
442                        crate::types::BashCommandAction::Command { .. } => "foreground_command",
443                        crate::types::BashCommandAction::StatusCheck { .. } => "status_check",
444                        crate::types::BashCommandAction::SendText { .. } => "send_text",
445                        crate::types::BashCommandAction::SendSpecials { .. } => "send_specials",
446                        crate::types::BashCommandAction::SendAscii { .. } => "send_ascii",
447                        crate::types::BashCommandAction::Screen { .. } => "screen",
448                        crate::types::BashCommandAction::WaitForTurn { .. } => "wait_for_turn",
449                    };
450                    let error = crate::errors::WinxError::InvalidWaitPolicyForAction {
451                        wait_policy: "until_complete".to_string(),
452                        action: action.to_string(),
453                    };
454                    let arguments = request.arguments.clone().map(serde_json::Value::Object);
455                    let mut result =
456                        outcomes::tool_failure("BashCommand", &error, arguments.as_ref())?;
457                    outcomes::enforce_next_action_policy(&mut result, effective_tool_policy);
458                    outcomes::finalize_tool_result(&mut result);
459                    scope.unscope_result(&mut result);
460                    let status = outcomes::result_status(&result);
461                    usage.emit(
462                        "tool_error",
463                        &status,
464                        outcomes::result_size_bytes(&result),
465                        Some(&result),
466                    );
467                    return Ok(result.into());
468                }
469            }
470        }
471
472        let eligible = Self::bash_task_is_eligible(&request);
473        let generation_bound_runtime = if supports_tasks && eligible {
474            let thread_id = request
475                .arguments
476                .as_ref()
477                .and_then(|arguments| arguments.get("thread_id"))
478                .and_then(serde_json::Value::as_str)
479                .unwrap_or_default();
480            let (slot, session_guard) = self.tool_session_for(thread_id).await;
481            let supported = self
482                .shell_runtime
483                .supports_generation_bound_actions_for(&slot)
484                .await
485                .unwrap_or(false);
486            drop(session_guard);
487            supported
488        } else {
489            false
490        };
491        let route = wait_policy.map_or(BashTaskRoute::Synchronous, |policy| {
492            bash_task_route(supports_tasks, generation_bound_runtime, eligible, policy)
493        });
494
495        match route {
496            BashTaskRoute::Immediate => {
497                let reservation = self.reserve_bash_task(&request, &scope).await?;
498                return match self
499                    .start_reserved_bash_task(
500                        reservation,
501                        request,
502                        scope,
503                        None,
504                        compact_bash_output,
505                    )
506                    .await
507                {
508                    Ok(task) => {
509                        usage.emit("task", "working", 0, None);
510                        Ok(CallToolResponse::Task(task))
511                    }
512                    Err(error) => {
513                        usage.emit("protocol_error", "failed", 0, None);
514                        Err(error)
515                    }
516                };
517            }
518            BashTaskRoute::Adaptive => {
519                let reservation = self.reserve_bash_task(&request, &scope).await?;
520                let task_request = request.clone();
521                let inline_request =
522                    normalized_wait_request(request, BashWaitPolicy::Adaptive, true)?;
523                match self
524                    .execute_tool_call(
525                        inline_request,
526                        adaptive_action_options(compact_bash_output),
527                        effective_tool_policy.edit_permissions(),
528                    )
529                    .await
530                {
531                    Ok(execution) if outcomes::result_status(&execution.result) == "running" => {
532                        return match self
533                            .start_reserved_bash_task(
534                                reservation,
535                                task_request,
536                                scope,
537                                Some(execution),
538                                compact_bash_output,
539                            )
540                            .await
541                        {
542                            Ok(task) => {
543                                usage.emit("task", "working", 0, None);
544                                Ok(CallToolResponse::Task(task))
545                            }
546                            Err(error) => {
547                                usage.emit("protocol_error", "failed", 0, None);
548                                Err(error)
549                            }
550                        };
551                    }
552                    Ok(mut execution) => {
553                        self.release_bash_task(&reservation).await;
554                        outcomes::enforce_next_action_policy(
555                            &mut execution.result,
556                            effective_tool_policy,
557                        );
558                        scope.unscope_result(&mut execution.result);
559                        let status = outcomes::result_status(&execution.result);
560                        let outcome = if execution.result.is_error == Some(true) {
561                            "tool_error"
562                        } else {
563                            "ok"
564                        };
565                        usage.emit(
566                            outcome,
567                            &status,
568                            outcomes::result_size_bytes(&execution.result),
569                            Some(&execution.result),
570                        );
571                        return Ok(execution.result.into());
572                    }
573                    Err(mut error) => {
574                        self.release_bash_task(&reservation).await;
575                        scope.unscope_error(&mut error);
576                        usage.emit("protocol_error", "failed", 0, None);
577                        return Err(error);
578                    }
579                }
580            }
581            BashTaskRoute::Synchronous => {}
582        }
583
584        let request = match wait_policy {
585            Some(policy) => normalized_wait_request(request, policy, false)?,
586            None => request,
587        };
588        match self
589            .execute_tool_call(
590                request,
591                ShellActionOptions {
592                    compact_output: compact_bash_output,
593                    ..ShellActionOptions::default()
594                },
595                effective_tool_policy.edit_permissions(),
596            )
597            .await
598        {
599            Ok(mut execution) => {
600                let result = &mut execution.result;
601                outcomes::enforce_next_action_policy(result, effective_tool_policy);
602                scope.unscope_result(result);
603                let status = outcomes::result_status(result);
604                let outcome = if result.is_error == Some(true) { "tool_error" } else { "ok" };
605                usage.emit(outcome, &status, outcomes::result_size_bytes(result), Some(result));
606                Ok(execution.result.into())
607            }
608            Err(mut error) => {
609                scope.unscope_error(&mut error);
610                usage.emit("protocol_error", "failed", 0, None);
611                Err(error)
612            }
613        }
614    }
615}
616
617#[cfg(test)]
618mod tests {
619    use super::super::usage::usage_result_metadata;
620    use super::*;
621    use rmcp::model::CallToolResult;
622
623    #[test]
624    fn cache_hints_follow_negotiated_protocol_version() {
625        assert_eq!(
626            cache_hints_for_protocol(Some(ProtocolVersion::V_2026_07_28), CacheScope::Private,),
627            (Some(0), Some(CacheScope::Private))
628        );
629        assert_eq!(
630            cache_hints_for_protocol(Some(ProtocolVersion::V_2026_07_28), CacheScope::Public),
631            (Some(0), Some(CacheScope::Public))
632        );
633        assert_eq!(
634            cache_hints_for_protocol(Some(ProtocolVersion::V_2025_11_25), CacheScope::Private,),
635            (None, None)
636        );
637        assert_eq!(cache_hints_for_protocol(None, CacheScope::Private), (None, None));
638    }
639
640    #[test]
641    fn guardian_1_4_uses_synchronous_policy_fallback_even_for_task_clients() {
642        assert_eq!(
643            bash_task_route(true, false, true, BashWaitPolicy::Adaptive),
644            BashTaskRoute::Synchronous
645        );
646        assert_eq!(
647            bash_task_route(true, false, true, BashWaitPolicy::UntilComplete),
648            BashTaskRoute::Synchronous
649        );
650    }
651
652    #[test]
653    fn task_routing_requires_client_runtime_and_foreground_eligibility() {
654        assert_eq!(
655            bash_task_route(true, true, true, BashWaitPolicy::Adaptive),
656            BashTaskRoute::Adaptive
657        );
658        assert_eq!(
659            bash_task_route(true, true, true, BashWaitPolicy::UntilComplete),
660            BashTaskRoute::Immediate
661        );
662        assert_eq!(
663            bash_task_route(true, true, true, BashWaitPolicy::ReturnEarly),
664            BashTaskRoute::Synchronous
665        );
666        assert_eq!(
667            bash_task_route(false, true, true, BashWaitPolicy::UntilComplete),
668            BashTaskRoute::Synchronous
669        );
670        assert_eq!(
671            bash_task_route(true, true, false, BashWaitPolicy::UntilComplete),
672            BashTaskRoute::Synchronous
673        );
674    }
675
676    #[test]
677    #[allow(clippy::expect_used)]
678    fn receipt_bound_verify_is_not_task_promotable() {
679        let arguments = serde_json::json!({
680            "action_json": {
681                "type": "verify",
682                "verification_id": "verify_123",
683                "command": "cargo test"
684            },
685            "thread_id": "thread"
686        });
687        let request = CallToolRequestParams::new("BashCommand")
688            .with_arguments(arguments.as_object().expect("arguments object").clone());
689        assert!(!WinxService::bash_task_is_eligible(&request));
690    }
691
692    #[test]
693    fn adaptive_action_requires_live_generation_binding() {
694        let options = adaptive_action_options(true);
695        assert!(options.compact_output);
696        assert!(options.require_generation_binding);
697    }
698
699    #[test]
700    fn usage_metadata_reads_image_code_map_and_temp_envelopes() {
701        let result_with = |structured| {
702            let mut result = CallToolResult::success(Vec::new());
703            result.structured_content = Some(structured);
704            result
705        };
706        let image = result_with(serde_json::json!({
707            "data": {"result": {
708                "source_bytes": 17_000_000,
709                "delivered_bytes": 2_000_000,
710                "transcoded": true,
711                "deduplicated": false
712            }}
713        }));
714        let metadata = usage_result_metadata(Some(&image));
715        assert_eq!(metadata.source_bytes, 17_000_000);
716        assert_eq!(metadata.payload_bytes, 2_000_000);
717        assert!(metadata.image_transcoded);
718        assert!(!metadata.image_deduplicated);
719
720        let code_map = result_with(serde_json::json!({
721            "source_kind": "canonical",
722            "payload_bytes": 12_345
723        }));
724        let metadata = usage_result_metadata(Some(&code_map));
725        assert_eq!(metadata.source_kind, "canonical");
726        assert_eq!(metadata.payload_bytes, 12_345);
727
728        let temporary = result_with(serde_json::json!({
729            "data": {
730                "session_files": 129,
731                "session_bytes": 4096,
732                "stale_pruned_files": 32,
733                "stale_pruned_bytes": 2048,
734                "temporary_artifact_cleanup_required": true
735            }
736        }));
737        let metadata = usage_result_metadata(Some(&temporary));
738        assert_eq!(metadata.temporary_session_files, 129);
739        assert_eq!(metadata.temporary_session_bytes, 4096);
740        assert_eq!(metadata.temporary_stale_pruned_files, 32);
741        assert_eq!(metadata.temporary_stale_pruned_bytes, 2048);
742        assert!(metadata.temporary_over_budget);
743
744        let edit_follow_up = result_with(serde_json::json!({
745            "errorCode": "verification_failed",
746            "retrySameCall": false,
747            "nextAction": {"tool": "VerifyEdit"},
748            "requiredReads": [],
749            "data": {
750                "edit_applied": true,
751                "verification_status": "failed",
752                "mutation_transition": "committed",
753                "mutation_replayed": false,
754                "mutation_receipt_persisted": true
755            }
756        }));
757        let metadata = usage_result_metadata(Some(&edit_follow_up));
758        assert_eq!(metadata.error_code, "verification_failed");
759        assert_eq!(metadata.recovery.next_action_tool, "VerifyEdit");
760        assert_eq!(metadata.recovery.required_read_count, 0);
761        assert!(!metadata.recovery.retry_same_call);
762        assert!(metadata.recovery.edit_applied);
763        assert!(!metadata.recovery.fresh_read_required);
764        assert_eq!(metadata.recovery.verification_status, "failed");
765        assert_eq!(metadata.recovery.mutation_transition, "committed");
766        assert_eq!(metadata.recovery.mutation_receipt_state, "persisted");
767
768        let edit_conflict = result_with(serde_json::json!({
769            "errorCode": "search_block_not_found",
770            "retrySameCall": false,
771            "nextAction": {"tool": "ReadFiles"},
772            "requiredReads": [{"path": "/workspace/lib.rs", "ranges": []}],
773            "data": {
774                "edit_applied": false,
775                "fresh_read_required": true,
776                "recovery_attempt": 2,
777                "recovery_escalated": true
778            }
779        }));
780        let metadata = usage_result_metadata(Some(&edit_conflict));
781        assert_eq!(metadata.error_code, "search_block_not_found");
782        assert_eq!(metadata.recovery.next_action_tool, "ReadFiles");
783        assert_eq!(metadata.recovery.required_read_count, 1);
784        assert!(!metadata.recovery.retry_same_call);
785        assert!(!metadata.recovery.edit_applied);
786        assert!(metadata.recovery.fresh_read_required);
787        assert_eq!(metadata.recovery.verification_status, "");
788        assert_eq!(metadata.recovery.recovery_attempt, 2);
789        assert_eq!(metadata.recovery.recovery_level, "escalated");
790    }
791
792    #[test]
793    #[allow(clippy::expect_used, clippy::float_cmp)]
794    fn synchronous_wait_policies_have_explicit_upper_bounds() {
795        let request = |wait_for_seconds: Option<f32>| {
796            let mut arguments = serde_json::Map::new();
797            arguments.insert("command".to_string(), serde_json::Value::String("pwd".to_string()));
798            if let Some(wait) = wait_for_seconds {
799                arguments.insert("wait_for_seconds".to_string(), serde_json::json!(wait));
800            }
801            CallToolRequestParams::new("BashCommand").with_arguments(arguments)
802        };
803        let normalized = |policy, wait| {
804            normalized_wait_request(request(wait), policy, false)
805                .expect("valid wait request")
806                .arguments
807                .and_then(|arguments| arguments.get("wait_for_seconds").cloned())
808                .and_then(|value| value.as_f64())
809                .expect("normalized wait")
810        };
811
812        assert_eq!(normalized(BashWaitPolicy::Adaptive, Some(500.0)), 60.0);
813        assert_eq!(normalized(BashWaitPolicy::UntilComplete, None), 60.0);
814        assert_eq!(normalized(BashWaitPolicy::ReturnEarly, Some(500.0)), 5.0);
815        assert_eq!(normalized(BashWaitPolicy::ReturnEarly, None), 0.25);
816    }
817}
winx_code_agent/server/handler.rs

winx_code_agent/server/
handler.rs
