mcp stdio support concurrent

V2.12

Author: writePerfectCode

README.md

@@ -161,14 +161,14 @@ API notes
 - `task_scheduler::KeyedTaskScheduler`: fixed-worker scheduler implementation that admits the next runnable task from an internal queue, allows `FreeReadOnly` work to run concurrently, serializes `ObjectExclusive` by `object_id`, serializes `FactoryLane` by `object_type`, serializes `ToolExclusive` by `tool_name`, and treats `SessionBarrier` as a stop-the-world session-wide exclusive operation.
 - `runtime::RuntimeFacadeThreadSafe`: protocol-neutral entry point above `task_scheduler`; `listTools()` returns normalized tool descriptors, `submitInvoke(...)` schedules one unary call and returns `std::future<runtime::InvokeResult>`, and `invoke(...)` gives the same normalized result synchronously.
 - `runtime::InvokeResult`: normalized invoke envelope with `ok`, `value`, optional `error`, and the original `raw_response`; classification-time failures such as unknown tools are converted into the same error shape instead of leaking exceptions to protocol adapters.
-- `mcp::McpStdioServerThreadSafe`: thin MCP adapter over `runtime::RuntimeFacadeThreadSafe`; it reads and writes `Content-Length` framed JSON-RPC messages and serves `initialize`, `ping`, `tools/list`, and `tools/call`.
+- `mcp::McpStdioServerThreadSafe`: thin MCP adapter over `runtime::RuntimeFacadeThreadSafe`; it reads and writes `Content-Length` framed JSON-RPC messages and `serveConcurrent(...)` keeps multiple `tools/call` requests in flight on one stdio session while `initialize`, `ping`, and `tools/list` remain ordered.
 - `mcp::McpStdioServerThreadSafe::handleMessage(...)`: useful when you want protocol handling without a real stdio loop, for example in tests or when embedding the MCP adapter into another transport shim.
 
 MCP stdio demo
 
 - Build `mcp_stdio_server_demo` when you want a real process that an MCP host can launch over stdio.
-- The demo server registers `sum`, `echo_text`, `create_counter`, `counter_add`, `counter_value`, and `destroy_counter`.
-- The process writes only framed MCP responses to stdout; fatal startup errors go to stderr.
+- The demo server registers `sum`, `slow_sum`, `echo_text`, `create_counter`, `counter_add`, `counter_value`, and `destroy_counter`.
+- The process writes only framed MCP responses to stdout; startup notes, `slow_sum` overlap logs, and fatal errors go to stderr.
 - `examples/mcp_stdio/test_mcp.ps1` now runs a fuller smoke test against the demo executable: initialize, tools/list, one stateless `sum` call, then a stateful `create_counter -> counter_add -> counter_value -> destroy_counter` flow.
 - The fluent builder also supports `.options(...)`, so object type selection and session object options can be expressed separately: `.stateful<T>("counter").options(opts)...`.
 - When `.stateful<T>("counter")` uses `.create(...)` without an explicit tool name, the builder defaults to `create_counter`.

examples/mcp_stdio/mcp_stdio_server_demo.cpp

@@ -1,13 +1,18 @@
+#include <atomic>
+#include <chrono>
 #include <exception>
 #include <iostream>
 #include <memory>
 #include <string>
+#include <thread>
 
 #include <json_session_invoke/json_session_invoke.hpp>
 #include <mcp/mcp_stdio_server.hpp>
 
 namespace {
 
+using namespace std::chrono_literals;
+
 struct Counter {
     int value{0};
 
@@ -27,13 +32,28 @@ struct Counter {
     }
 };
 
-void registerDemoTools(json_session_invoke::JsonSessionInvokeAdapterThreadSafe& adapter)
+void registerDemoTools(
+    json_session_invoke::JsonSessionInvokeAdapterThreadSafe& adapter,
+    std::atomic<int>& active_slow_jobs)
 {
     adapter.registerFunction(
         "sum",
         json_invoke::readOnly([](int left, int right) { return left + right; }),
         json_invoke::FunctionMetadata{{"left", "right"}, "Add two integers without session state."});
 
+    adapter.registerFunction(
+        "slow_sum",
+        json_invoke::readOnly([&active_slow_jobs](int left, int right, int delay_ms) {
+            const int active_now = active_slow_jobs.fetch_add(1) + 1;
+            std::cerr << "slow_sum start delay_ms=" << delay_ms << " active_jobs=" << active_now << std::endl;
+            std::this_thread::sleep_for(std::chrono::milliseconds(delay_ms));
+            const int remaining = active_slow_jobs.fetch_sub(1) - 1;
+            std::cerr << "slow_sum finish delay_ms=" << delay_ms << " active_jobs=" << remaining << std::endl;
+            return left + right;
+        }),
+        json_invoke::FunctionMetadata{{"left", "right", "delay_ms"},
+            "Add two integers after delay_ms; overlapping slow_sum calls log concurrent activity to stderr."});
+
     adapter.registerFunction(
         "echo_text",
         json_invoke::readOnly([](std::string text) { return text; }),
@@ -68,7 +88,8 @@ int main()
     try
     {
         json_session_invoke::JsonSessionInvokeAdapterThreadSafe adapter;
-        registerDemoTools(adapter);
+        std::atomic<int> active_slow_jobs{0};
+        registerDemoTools(adapter, active_slow_jobs);
 
         runtime::RuntimeFacadeThreadSafe runtime(adapter, 4);
         mcp::McpStdioServerThreadSafe server(
@@ -77,11 +98,12 @@ int main()
                 "llm_invoke_cpp_demo",
                 "0.1.0",
                 "2025-03-26",
-                "Demo MCP stdio server exposing sum, echo_text, and counter create/call/destroy tools.",
+                "Demo MCP stdio server exposing sum, slow_sum, echo_text, and counter create/call/destroy tools. slow_sum logs concurrent overlap to stderr.",
                 false,
             });
 
-        server.serve(std::cin, std::cout);
+        std::cerr << "mcp_stdio_server_demo ready; send overlapping slow_sum calls to observe concurrent jobs on stderr." << std::endl;
+        server.serveConcurrent(std::cin, std::cout);
         return 0;
     }
     catch (const std::exception& e)