MCP Tasks: interrupt in-flight queries on tasks/cancel (duckdb_interrupt)

[jrosskopf]

Follow-up from PR #107 (Codex review finding #5). tasks/cancel is currently cooperative: it cancels a queued task and marks a running one for cancellation, but cannot interrupt a SQL statement already executing — the query runs to completion (and a write tool may commit) before the task is marked cancelled.

To make cancellation preemptive, plumb a per-task DuckDB connection through the worker so tasks/cancel can call duckdb_interrupt on it. Until then, consider defaulting mcp-tool.async to read-only tools, or documenting that async write tools cannot be cancelled mid-statement (currently documented in MCP_REFERENCE §11.7).

[jrosskopf]

Second review round also flagged the shutdown angle: because worker threads run executeTool to completion and shutdown() joins them unbounded, a genuinely long in-flight async query can block graceful shutdown until it returns. The same duckdb_interrupt plumbing that makes tasks/cancel preemptive would also let shutdown interrupt in-flight queries with a bounded join deadline. Tracking both here.

[jrosskopf]

Implementation plan (scoped against the current code)

Goal: make tasks/cancel (and graceful shutdown) interrupt an in-flight DuckDB query, instead of only flipping a cooperative flag.

What the code looks like today

• duckdb_interrupt(duckdb_connection) is available in the C API (duckdb/src/include/duckdb.h:1014).
• The async task work calls MCPToolHandler::executeTool → executeQueryWithEndpoint → DatabaseManager::executeQuery(endpoint, params, true), which builds a QueryExecutor(db). QueryExecutor mints its own duckdb_connection (src/query_executor.cpp:18) and disconnects it when done (:28). The connection is never exposed, so nothing outside can interrupt it.
• QueryExecutor is shared with the REST path — so changing its connection lifetime is not a low-risk change and must not regress REST.

Proposed change (incremental, review-gated)

1. Task-manager interrupt hook (safe scaffolding). Give each running task an optional std::function<void()> interrupt that the worker registers before it starts executing and clears when done; cancel() calls it under the lock. No DuckDB coupling — pure plumbing.
2. Expose the connection for the cancellable path. Add a DatabaseManager execute variant that surfaces the live duckdb_connection to a callback before the query runs (or hand back a QueryExecutor whose connection is a member with a public interrupt()), used only by the async task path. REST keeps the existing call unchanged.
3. Wire it: the worker registers interrupt = [conn]{ duckdb_interrupt(conn); }; tasks/cancel triggers it. A query killed by interrupt returns a DuckDB error — the worker maps (cancelled flag set) + (interrupt error) to task status cancelled (not failed).
4. Shutdown: on stop, interrupt every running task's connection, then join workers with a bounded deadline; anything still running is marked failed{server_shutdown} durably.

Tests

• C++: task-manager interrupt-hook unit test (cancel triggers the registered hook; terminal state is cancelled).
• Integration: an async tool running a deliberately long query (SELECT count(*) FROM range(...)), tasks/cancel mid-flight, assert the task reaches cancelled quickly and the query stopped; a kill-mid-task shutdown test.

Risk

Step 2 touches connection ownership near the shared QueryExecutor; it lands on a branch with its own review, not directly on the just-released path. Steps 1/3/4 are contained to the MCP Tasks code.