{"record":{"id":"8b3852c05370260d","repo":"vllm-project/vllm","slug":"cannot-use-in-process-coordinator-with-bootstrappe","errorCode":null,"errorMessage":"cannot use in-process coordinator with bootstrapped transport mode","messagePattern":"cannot use in-process coordinator with bootstrapped transport mode","errorType":"panic","errorClass":null,"httpStatus":null,"severity":"critical","filePath":"rust/src/engine-core-client/src/client.rs","lineNumber":266,"sourceCode":"                    *engine_count,\n                    advertised_host,\n                    local_input_address.as_deref(),\n                    local_output_address.as_deref(),\n                    enable_inproc_coordinator,\n                    *ready_timeout,\n                )\n                .await?\n            }\n\n            TransportMode::Bootstrapped {\n                input_address,\n                output_address,\n                engine_start_index,\n                engine_count,\n                ready_timeout,\n            } => {\n                if let Some(CoordinatorMode::InProc) = config.coordinator_mode {\n                    panic!(\"cannot use in-process coordinator with bootstrapped transport mode\")\n                }\n\n                transport::connect_bootstrapped(\n                    input_address,\n                    output_address,\n                    *engine_start_index,\n                    *engine_count,\n                    *ready_timeout,\n                )\n                .await?\n            }\n        };\n\n        Self::from_connected(config, connected).await\n    }\n\n    /// Create a new client instance from the connected transport state after\n    /// the startup handshake completes.","sourceCodeStart":248,"sourceCodeEnd":284,"githubUrl":"https://github.com/vllm-project/vllm/blob/c794754062d49a8fdb63ab3c5215b488b865030c/rust/src/engine-core-client/src/client.rs#L248-L284","documentation":"This is a hard panic in EngineCoreClient::connect (rust/src/engine-core-client/src/client.rs:266). It fires when the caller supplies TransportMode::Bootstrapped (addresses and engine indices already fixed by an external supervisor) together with coordinator_mode = Some(CoordinatorMode::InProc). The in-process coordinator is only wired into the handshake-owned transport path (connect_handshake), so the combination is a programming/configuration error and the client aborts instead of continuing in a broken state.","triggerScenarios":"Calling EngineCoreClient::connect(config) where config.transport_mode is TransportMode::Bootstrapped { .. } and config.coordinator_mode is Some(CoordinatorMode::InProc). Note that CoordinatorMode::External is silently accepted here (coordinator is simply None on this path), but InProc panics immediately during connect.","commonSituations":"Building a config from a supervisor or CLI where transport mode defaults to bootstrapped while a coordinator flag (e.g. --coordinator inproc / data-parallel coordinator enable) is still set. Copy-pasting a HandshakeOwner config and only swapping the transport variant. Migrating from the handshake-owned bootstrap to Python-managed AsyncMPClient-style bootstrap without clearing the coordinator option.","solutions":["Set coordinator_mode to None (or Some(CoordinatorMode::External { .. }), which is tolerated but unimplemented elsewhere) when using TransportMode::Bootstrapped","If you need the in-process coordinator, switch transport_mode to TransportMode::HandshakeOwner { handshake_address, advertised_host, engine_count, ready_timeout, .. }","Fix the config builder/CLI parsing so these two fields cannot disagree, and add a unit test asserting connect rejects (rather than panics on) the combination"],"exampleFix":"// before\nlet config = EngineCoreClientConfig {\n    transport_mode: TransportMode::Bootstrapped { input_address, output_address, engine_start_index, engine_count, ready_timeout },\n    coordinator_mode: Some(CoordinatorMode::InProc),\n};\nlet client = EngineCoreClient::connect(config).await?; // panics\n\n// after\nlet config = EngineCoreClientConfig {\n    transport_mode: TransportMode::Bootstrapped { input_address, output_address, engine_start_index, engine_count, ready_timeout },\n    coordinator_mode: None,\n};\nlet client = EngineCoreClient::connect(config).await?;","handlingStrategy":"validation","validationCode":"fn assert_config_compatible(config: &EngineCoreClientConfig) -> Result<()> {\n    if matches!(config.transport_mode, TransportMode::Bootstrapped { .. })\n        && matches!(config.coordinator_mode, Some(CoordinatorMode::InProc))\n    {\n        return Err(anyhow::anyhow!(\"in-process coordinator requires HandshakeOwner transport\"));\n    }\n    Ok(())\n}","typeGuard":"fn is_bad_coordinator_combo(c: &EngineCoreClientConfig) -> bool {\n    matches!(c.transport_mode, TransportMode::Bootstrapped { .. })\n        && matches!(c.coordinator_mode, Some(CoordinatorMode::InProc))\n}","tryCatchPattern":null,"preventionTips":["Validate transport_mode/coordinator_mode pairs in the config builder so invalid states are unrepresentable","Add a unit test that asserts connect never panics for any mode combination","Document the valid matrix: Bootstrapped→None only; HandshakeOwner→None|InProc"],"tags":["rust","config","coordinator","transport","startup"],"backgroundTag":null,"analyzedSha":"c794754062d49a8fdb63ab3c5215b488b865030c","analyzedAt":"2026-08-14T21:17:39.825Z","schemaVersion":2},"datasetVersion":"2026-08-15T22:17:37.221Z"}