feat(ext-tasks): bilingual client task surface (slice B)

Opt-in ext-tasks feature on turul-mcp-client:
- declared_capabilities.ext_tasks declares io.modelcontextprotocol/tasks
  in every 2026 request's _meta clientCapabilities.extensions (unit
  tests pin both the declared shape and the no-opt-in absence)
- call_tool_or_task(name, args) -> ToolCallOutcome::Completed | Task —
  the server is the sole decider (SEP-2663), so the API is the honest
  union; plain call_tool keeps the strict BP-1 unknown-resultType
  rejection
- task_get / task_update / task_cancel bind the lifecycle; task_wait
  polls to a terminal status honoring pollIntervalMs (clamped 50ms-30s)

4 real-server e2e tests (ext_tasks_e2e_2026.rs; gates + CI step):
task→poll→completed, sync fallback for undeclared clients, task_update
resuming an input_required task, cancel-to-cancelled. Full client suite
162-passing under the feature. Revert-and-fail recorded: suppressing
the capability emission fails task_outcome_polls_to_completion with a
sync result (also live-proving the server's progressive enhancement).

Full ci-gates.sh all green.

Author: hortovanyi

.github/workflows/ci.yml

@@ -76,6 +76,8 @@ jobs:
         run: cargo test -p turul-mcp-server --no-default-features --features http,sse,ext-tasks --test ext_tasks_2026
       - name: Extension crates standalone
         run: cargo test -p turul-mcp-ext-tasks -p turul-mcp-ext-apps
+      - name: Tasks extension client e2e
+        run: cargo test -p turul-mcp-client --features ext-tasks --test ext_tasks_e2e_2026
 
   opt-in-2025:
     name: Opt-in lane (2025-11-25)

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **Tasks-extension client surface (2026-06-12, SEP-2663 — slice B).** New opt-in `ext-tasks` feature on `turul-mcp-client`: `declared_capabilities.ext_tasks = true` declares `io.modelcontextprotocol/tasks` in every 2026 request's `_meta` `clientCapabilities.extensions`; `call_tool_or_task(name, args)` returns `ToolCallOutcome::Completed | Task` (the server is the sole decider — the typed union replaces guessing); `task_get`/`task_update`/`task_cancel` bind the lifecycle methods; `task_wait` polls to a terminal status honoring the server's `pollIntervalMs` (clamped 50ms–30s). The strict BP-1 parser is untouched — plain `call_tool` still rejects unknown `resultType`s; only the ext-aware path accepts `"task"`. 4 real-server e2e tests (`ext_tasks_e2e_2026.rs`, gates + CI): task→poll→completed, sync fallback for undeclared clients, `task_update` resuming an `input_required` task, cancel-to-cancelled; revert-and-fail recorded (suppressing the capability emission fails the task-outcome test with a sync result).
 - **Tasks-extension server runtime (2026-06-12, SEP-2663 — closes driver gap G1).** New opt-in `ext-tasks` feature on `turul-mcp-server` (off by default per SEP-2133): `.with_ext_tasks(store)` advertises `io.modelcontextprotocol/tasks` in `server/discover`'s `capabilities.extensions` and registers `tasks/get`/`tasks/update`/`tasks/cancel`; `.ext_task_tool(tool)` / `.ext_task_tool_required(tool)` mark tools for task election — a request whose per-request `_meta` `clientCapabilities.extensions` declares the extension gets a durable `CreateTaskResult` (UUIDv4 bearer-grade id, store written BEFORE the response) with a spawned worker; undeclared requests run synchronously (progressive enhancement) or, for `_required` tools, get `-32003` with the upstream `data.requiredCapabilities.extensions` shape. **MRTR bridge**: a task tool returning `McpError::InputRequired` parks its task in `input_required`; `tasks/update` validates response keys against outstanding requests (partial delivery keeps it parked) and resumes the worker with the responses injected through the same session-extension keys as the sync retry leg — tool code is identical under both execution models. `tasks/cancel` is cooperative (aborts the worker, drops input waiters, acks terminal tasks). `notifications/tasks` rides `subscriptions/listen`: the transport honors a `taskIds` filter iff the extension is advertised (keyed off the capability map — no transport dependency on the ext crate), echoes it in the ack, and delivers per-taskId. `turul-mcp-ext-tasks` gains the `TaskStore` trait + `TaskState` + `InMemoryTaskStore` (no tokio in the public API). 9 wire e2e tests (`ext_tasks_2026.rs`, wired into gates + CI); revert-and-fail recorded. Dispatcher design recorded in ADR-028 (2026-06-12 entry).
 - **`turul-mcp-ext-apps` 0.1.0 scaffold (2026-06-12, SEP-1865).** Spec-neutral extension crate binding the MCP-side Apps surface: extension identifier `io.modelcontextprotocol/ui` (the ADR-028 table's `/apps` guess corrected against upstream), client capability (`UiClientCapabilities.mimeTypes` + the `text/html;profile=mcp-app` HTML-views gate), tool `_meta.ui` (`UiToolMeta`: `resourceUri`, `visibility` model/app), and UI-resource `_meta.ui` (`UiResourceMeta`: CSP domain lists, sandbox permissions, dedicated origin, `prefersBorder`). The host↔view iframe protocol is deliberately not bound (app/host SDK scope). Vendored spec pinned at `modelcontextprotocol/ext-apps@ca1d2989`; 5 wire-shape compliance tests.
 - **Versioning/cancellation/elicitation P2 trio (2026-06-12).** (1) **VER-4**: the headerless-`initialize` rejection (400 + `-32001`) now carries `error.data.supported` naming this build's protocol versions — a true legacy client's only diagnostic; wire test `headerless_initialize_rejection_names_supported_versions`, red-phase recorded. (2) **PAT/G10**: dedicated `CancelledNotificationHandler` extracts `requestId` + `reason` from inbound `notifications/cancelled` into a structured log line ("Both parties SHOULD log cancellation reasons"); accepted-and-ignored semantics unchanged. (3) **CF/GAP-CF-8**: new `turul_mcp_builders::validate_elicit_content(schema, content)` validates elicited form content against the requesting schema (required/unknown keys, primitive types, string-length/numeric bounds, integer-ness, enum membership across the 2026 enum-union shapes; format assertions annotation-only by design) — central enforcement is impossible on the stateless lane (leg-1 schema not retained), so tools call it on the MRTR retry; wired into `mrtr-elicitation-server` and live-verified. Plus **BP-5** (COMPLIANCE.md §"Supported JSON Schema dialects" — the documentation the SHOULD asks for) and **UTIL/COMP-3** (relevance/fuzzy/rate-limit completion SHOULDs dispositioned: provider semantics + middleware rate limiting). Driver summary now 305 ✅ / 68 🟡 / 5 ❌ / 12 🧪 / 100 ➖ — the 5 remaining ❌ all carry recorded dispositions.

crates/turul-mcp-client/Cargo.toml

@@ -20,6 +20,7 @@ description = "Comprehensive MCP client library with multi-transport support"
 # the alias's protocol features and trip the spec mutex (e.g. linking this
 # client and a 2026-default server into one test binary).
 turul-mcp-protocol-2025-11-25 = { workspace = true }
+turul-mcp-ext-tasks = { workspace = true, optional = true }
 turul-mcp-protocol-2026-07-28 = { workspace = true, optional = true }
 turul-rpc = { workspace = true }
 
@@ -62,6 +63,9 @@ all-transports = ["http", "sse", "stdio"]
 # Bilingual (default) links both protocol crates; one McpClient negotiates the
 # wire spec per connection at connect() time.
 client-bilingual = ["dep:turul-mcp-protocol-2026-07-28"]
+# Tasks extension (io.modelcontextprotocol/tasks, SEP-2663) client surface —
+# 2026-07-28 connections only; off by default per SEP-2133.
+ext-tasks = ["dep:turul-mcp-ext-tasks"]
 # Narrowing: each speaks exactly ONE wire spec. Requires --no-default-features
 # (otherwise client-bilingual is also active and the mutex fires). The frozen
 # 2025-11-25 protocol crate is always linked as the shared type vocabulary;
@@ -75,7 +79,7 @@ wiremock = "0.6"
 # Real-server e2e: bilingual client against an in-process 2026 stateless server.
 # Default features (http, sse -> protocol-2026-07-28); no alias-mutex conflict
 # because this crate links the versioned protocol crates directly, not the alias.
-turul-mcp-server = { path = "../turul-mcp-server", version = "0.4.0" }
+turul-mcp-server = { path = "../turul-mcp-server", version = "0.4.0", features = ["ext-tasks"] }
 turul-mcp-derive = { path = "../turul-mcp-derive", version = "0.4.0" }
 # The derive macros expand to `turul_mcp_protocol::` / `turul_mcp_builders::`
 # paths, so the e2e test target needs both (2026 default, matching the dev

crates/turul-mcp-client/src/client.rs

@@ -1379,6 +1379,99 @@ impl McpClient {
         .into())
     }
 
+    /// `tools/call` that accepts EITHER a synchronous completion or a
+    /// `CreateTaskResult` (`resultType: "task"`, SEP-2663). Requires a
+    /// 2026-07-28 connection and `declared_capabilities.ext_tasks = true`
+    /// (servers MUST NOT return task handles to clients that did not declare
+    /// the extension).
+    #[cfg(feature = "ext-tasks")]
+    pub async fn call_tool_or_task(
+        &self,
+        name: &str,
+        arguments: Value,
+    ) -> McpClientResult<ToolCallOutcome> {
+        if self.negotiated_version().await != Some(crate::version::McpVersion::V2026_07_28) {
+            return Err(crate::error::ProtocolError::MethodNotFound(
+                "the Tasks extension requires a 2026-07-28 connection".to_string(),
+            )
+            .into());
+        }
+        let extra = json!({ "name": name, "arguments": arguments });
+        self.send_2026_07_28_with_extra_headers(
+            "tools/call",
+            extra,
+            &[("Mcp-Name".to_string(), name.to_string())],
+            |result| {
+                if result.get("resultType").and_then(|v| v.as_str())
+                    == Some(turul_mcp_ext_tasks::RESULT_TYPE_TASK)
+                {
+                    let task: turul_mcp_ext_tasks::CreateTaskResult =
+                        serde_json::from_value(result.clone())?;
+                    return Ok(ToolCallOutcome::Task(task));
+                }
+                crate::protocol::v2026_07_28::parse_call_tool(result)
+                    .map(ToolCallOutcome::Completed)
+            },
+        )
+        .await
+    }
+
+    /// `tasks/get` — poll one task's state (SEP-2663).
+    #[cfg(feature = "ext-tasks")]
+    pub async fn task_get(
+        &self,
+        task_id: &str,
+    ) -> McpClientResult<turul_mcp_ext_tasks::DetailedTask> {
+        self.send_2026_07_28("tasks/get", json!({ "taskId": task_id }), |result| {
+            let r: turul_mcp_ext_tasks::GetTaskResult = serde_json::from_value(result.clone())?;
+            Ok(r.task)
+        })
+        .await
+    }
+
+    /// `tasks/update` — deliver input responses to an `input_required` task
+    /// (SEP-2663). `input_responses` is the `{key: InputResponse}` map whose
+    /// keys answer the task's outstanding `inputRequests`.
+    #[cfg(feature = "ext-tasks")]
+    pub async fn task_update(&self, task_id: &str, input_responses: Value) -> McpClientResult<()> {
+        self.send_2026_07_28(
+            "tasks/update",
+            json!({ "taskId": task_id, "inputResponses": input_responses }),
+            |_| Ok(()),
+        )
+        .await
+    }
+
+    /// `tasks/cancel` — cooperative cancellation (SEP-2663); the ack does not
+    /// guarantee a `cancelled` terminal status.
+    #[cfg(feature = "ext-tasks")]
+    pub async fn task_cancel(&self, task_id: &str) -> McpClientResult<()> {
+        self.send_2026_07_28("tasks/cancel", json!({ "taskId": task_id }), |_| Ok(()))
+            .await
+    }
+
+    /// Poll `tasks/get` until the task reaches a terminal status, honoring
+    /// the server's `pollIntervalMs` hint (clamped to [50ms, 30s]; default
+    /// 500ms when the server sends none).
+    #[cfg(feature = "ext-tasks")]
+    pub async fn task_wait(
+        &self,
+        task_id: &str,
+    ) -> McpClientResult<turul_mcp_ext_tasks::DetailedTask> {
+        loop {
+            let task = self.task_get(task_id).await?;
+            if task.status().is_terminal() {
+                return Ok(task);
+            }
+            let interval_ms = task
+                .fields()
+                .poll_interval_ms
+                .unwrap_or(500.0)
+                .clamp(50.0, 30_000.0);
+            tokio::time::sleep(std::time::Duration::from_millis(interval_ms as u64)).await;
+        }
+    }
+
     /// List available resources (returns cached result if available)
     ///
     /// Returns the FIRST page only — use
@@ -2123,6 +2216,18 @@ fn value_to_request_params(params: Value) -> Option<RequestParams> {
     }
 }
 
+/// Outcome of [`McpClient::call_tool_or_task`] (SEP-2663): the server is the
+/// sole decider of task materialization.
+#[cfg(feature = "ext-tasks")]
+#[derive(Debug)]
+pub enum ToolCallOutcome {
+    /// The call completed synchronously with an ordinary tool result.
+    Completed(CallToolResult),
+    /// The server elected a task — poll with
+    /// [`McpClient::task_wait`]/[`McpClient::task_get`].
+    Task(turul_mcp_ext_tasks::CreateTaskResult),
+}
+
 /// A live `subscriptions/listen` stream: the acknowledged filter subset, the
 /// server-assigned subscription id, and the ordered notification feed.
 /// Dropping this closes the stream (= cancels the subscription).

crates/turul-mcp-client/src/config.rs

@@ -60,6 +60,12 @@ pub struct DeclaredCapabilities {
     pub sampling_context: bool,
     /// Can answer `roots/list` input requests (deprecated per SEP-2577).
     pub roots: bool,
+    /// Declares the Tasks extension (`io.modelcontextprotocol/tasks`,
+    /// SEP-2663) in every 2026 request's `_meta` `clientCapabilities.extensions`
+    /// — servers may then answer task-electing calls with a `CreateTaskResult`
+    /// instead of the normal result. Use the `call_tool_or_task`/`task_*`
+    /// client APIs (requires the `ext-tasks` cargo feature).
+    pub ext_tasks: bool,
 }
 
 /// Client identification information

crates/turul-mcp-client/src/lib.rs

@@ -242,6 +242,8 @@ pub mod transport;
 pub mod version;
 
 // Re-export main types
+#[cfg(feature = "ext-tasks")]
+pub use client::ToolCallOutcome;
 /// High-level MCP client with session management and automatic reconnection
 pub use client::{
     McpClient, McpClientBuilder, NotificationCallback, SubscriptionStream, ToolCallResponse,

crates/turul-mcp-client/src/protocol/v2026_07_28.rs

@@ -39,6 +39,12 @@ pub(crate) fn request_meta(
             },
         ),
         roots: declared.roots.then(Default::default),
+        extensions: declared.ext_tasks.then(|| {
+            std::collections::HashMap::from([(
+                "io.modelcontextprotocol/tasks".to_string(),
+                serde_json::json!({}),
+            )])
+        }),
         ..Default::default()
     };
     p::meta::RequestMetaObject::new(
@@ -284,6 +290,29 @@ mod tests {
 
     /// Sub-capability declarations reach the wire shapes the gating servers
     /// check: elicitation.url and sampling.tools/.context.
+    #[test]
+    fn ext_tasks_declaration_rides_request_meta_extensions() {
+        let declared = crate::config::DeclaredCapabilities {
+            ext_tasks: true,
+            ..Default::default()
+        };
+        let meta = request_meta("t", "1", &declared);
+        let v = serde_json::to_value(&meta).unwrap();
+        assert_eq!(
+            v["io.modelcontextprotocol/clientCapabilities"]["extensions"]["io.modelcontextprotocol/tasks"],
+            serde_json::json!({})
+        );
+
+        let none = request_meta("t", "1", &Default::default());
+        let v = serde_json::to_value(&none).unwrap();
+        assert!(
+            v["io.modelcontextprotocol/clientCapabilities"]
+                .get("extensions")
+                .is_none(),
+            "no declaration without the opt-in: {v}"
+        );
+    }
+
     #[test]
     fn sub_capabilities_map_into_request_meta() {
         let declared = crate::config::DeclaredCapabilities {
@@ -293,6 +322,7 @@ mod tests {
             sampling_tools: true,
             sampling_context: false,
             roots: false,
+            ext_tasks: false,
         };
         let meta = request_meta("t", "1", &declared);
         let v = serde_json::to_value(&meta).unwrap();