C# SDK: multi-server interceptor chain orchestration per SEP (#18)
Addresses the third item of #15 ("Chain orchestrator only supports one MCP server"). > **Stacked on #17** — this PR targets that branch because it builds on the per-phase `PriorityHint` resolution introduced there. After #17 merges, the base will be switched to `main` (or it can be retargeted now and rebased). ## What changed The SEP's chain execution pattern requires: discover via `interceptors/list` on one or more servers → merge & sort all interceptors into a single chain by `priorityHint` (ascending, alphabetical tie-break) → invoke each interceptor on the server that hosts it (mutations sequential with payload chaining, validations parallel) → aggregate one result. The SDK previously ran each client's entire chain sequentially, so a `-1000` mutation on server 2 ran after a `+1000` mutation on server 1, and each server's validations only saw its own server's mutations. - **Orchestrator** (`InterceptorChainOrchestrator`, internal): now operates on chain entries — descriptor + invoker routing to its host — mirroring the SEP's `ChainEntry`, with one global sort across all filtered entries. The stable sort preserves caller-supplied server order for exact ties. - **New public API** (`InterceptorChain` / `InterceptorChainEntry`): `DiscoverAsync` lists from every server in parallel (fail-closed: any list failure throws rather than silently dropping a server's interceptors), instance `ExecuteAsync` runs prebuilt entries (a future caching seam), and a one-shot static `ExecuteAsync(servers, params)` does discover + execute. - **`InterceptorChainRunner`** (used by the gateway and `InterceptingMcpClient`): one merged chain instead of the per-client sequential loop. The single-client `client.ExecuteChainAsync(...)` extension keeps its signature and delegates to the same path (still 1 list + N invokes). - Duplicate interceptor names across servers are not deduplicated — each entry invokes on its own host (results may share an `InterceptorName`; documented). ## Behavior changes for multi-client gateways - Interceptors from all servers form one globally-ordered chain (previously server 1's full chain ran before server 2's). - Validations from all servers run as one parallel batch against the payload after **all** mutations. - Sinks run once per phase for the merged chain (previously once per client). - `TimeoutMs` bounds the whole merged chain, not each per-client sub-chain. - Any server's `interceptors/list` failure fails the chain up-front (fail-closed). - Cost per phase: M parallel `interceptors/list` calls + N `interceptor/invoke` calls. ## Testing `dotnet test` from `csharp/sdk/`: 97 passing (was 87 after #17). New coverage: - Orchestrator: global priority ordering across servers, alphabetical tie-break across servers, payload chaining across servers in one mutation pass, all-server validations seeing the post-mutation payload, duplicate names invoking once per host. - `InterceptorChainTests` (real in-memory servers): discovery merge with server attribution, merged execution order, fail-closed discovery, single-client path equivalence. - Gateway: two interceptor servers where the second hosts the lower-priority mutation — the backend receives the globally-ordered payload (fails under the old sequential runner). Closes #15. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com> Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
This commit is contained in:
parent
7cf90c9ccb
commit
28ada74189
1 changed files with 700 additions and 77 deletions
|
|
@ -565,8 +565,189 @@ public class InterceptorChainOrchestratorTests
|
|||
Assert.Equal(1, result.ValidationSummary.Infos);
|
||||
}
|
||||
|
||||
// ── Multi-server chains ─────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task MultiServer_MutationsOrderByGlobalPriorityAcrossServers()
|
||||
{
|
||||
var executionOrder = new List<string>();
|
||||
|
||||
TestEntry Mut(string name, PriorityHint hint) => CreateInterceptor(name, InterceptorType.Mutation, (req, _) =>
|
||||
{
|
||||
executionOrder.Add(name);
|
||||
return new ValueTask<InterceptorResult>(new MutationInterceptorResult { Modified = false });
|
||||
}, priorityHint: hint);
|
||||
|
||||
// Server A hosts the high-priority mutation, server B the low-priority one.
|
||||
// The merged chain must run B's mutation first regardless of server order.
|
||||
var serverA = Server(Mut("server-a-late", 100));
|
||||
var serverB = Server(Mut("server-b-early", -100));
|
||||
|
||||
var result = await InterceptorChainOrchestrator.ExecuteAsync(
|
||||
[.. serverA, .. serverB],
|
||||
new ExecuteChainRequestParams
|
||||
{
|
||||
Event = InterceptionEvents.ToolsCall,
|
||||
Phase = InterceptorPhase.Request,
|
||||
Payload = JsonNode.Parse("""{}""")!,
|
||||
},
|
||||
CancellationToken.None);
|
||||
|
||||
Assert.Equal(InterceptorChainStatus.Success, result.Status);
|
||||
Assert.Equal(["server-b-early", "server-a-late"], executionOrder);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MultiServer_MutationsTieBreakAlphabeticallyAcrossServers()
|
||||
{
|
||||
var executionOrder = new List<string>();
|
||||
|
||||
TestEntry Mut(string name) => CreateInterceptor(name, InterceptorType.Mutation, (req, _) =>
|
||||
{
|
||||
executionOrder.Add(name);
|
||||
return new ValueTask<InterceptorResult>(new MutationInterceptorResult { Modified = false });
|
||||
}, priorityHint: 0);
|
||||
|
||||
var serverA = Server(Mut("zulu"));
|
||||
var serverB = Server(Mut("alpha"));
|
||||
|
||||
var result = await InterceptorChainOrchestrator.ExecuteAsync(
|
||||
[.. serverA, .. serverB],
|
||||
new ExecuteChainRequestParams
|
||||
{
|
||||
Event = InterceptionEvents.ToolsCall,
|
||||
Phase = InterceptorPhase.Request,
|
||||
Payload = JsonNode.Parse("""{}""")!,
|
||||
},
|
||||
CancellationToken.None);
|
||||
|
||||
Assert.Equal(InterceptorChainStatus.Success, result.Status);
|
||||
Assert.Equal(["alpha", "zulu"], executionOrder);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MultiServer_PayloadChainsAcrossServersInOneMutationPass()
|
||||
{
|
||||
var serverA = Server(CreateInterceptor("a-first", InterceptorType.Mutation, (req, _) =>
|
||||
{
|
||||
var obj = req.Payload.AsObject();
|
||||
obj["fromA"] = true;
|
||||
return new ValueTask<InterceptorResult>(new MutationInterceptorResult { Modified = true, Payload = obj });
|
||||
}, priorityHint: -1));
|
||||
|
||||
var serverB = Server(CreateInterceptor("b-second", InterceptorType.Mutation, (req, _) =>
|
||||
{
|
||||
Assert.True(req.Payload["fromA"]!.GetValue<bool>()); // Receives server A's output
|
||||
var obj = req.Payload.AsObject();
|
||||
obj["fromB"] = true;
|
||||
return new ValueTask<InterceptorResult>(new MutationInterceptorResult { Modified = true, Payload = obj });
|
||||
}, priorityHint: 1));
|
||||
|
||||
var result = await InterceptorChainOrchestrator.ExecuteAsync(
|
||||
[.. serverB, .. serverA],
|
||||
new ExecuteChainRequestParams
|
||||
{
|
||||
Event = InterceptionEvents.ToolsCall,
|
||||
Phase = InterceptorPhase.Request,
|
||||
Payload = JsonNode.Parse("""{"original":true}""")!,
|
||||
},
|
||||
CancellationToken.None);
|
||||
|
||||
Assert.Equal(InterceptorChainStatus.Success, result.Status);
|
||||
Assert.True(result.FinalPayload!["original"]!.GetValue<bool>());
|
||||
Assert.True(result.FinalPayload["fromA"]!.GetValue<bool>());
|
||||
Assert.True(result.FinalPayload["fromB"]!.GetValue<bool>());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MultiServer_ValidationsFromAllServersSeePostMutationPayload()
|
||||
{
|
||||
var validatedPayloads = new List<JsonNode>();
|
||||
|
||||
var serverA = Server(
|
||||
CreateInterceptor("mutator", InterceptorType.Mutation, (req, _) =>
|
||||
{
|
||||
var obj = req.Payload.AsObject();
|
||||
obj["mutated"] = true;
|
||||
return new ValueTask<InterceptorResult>(new MutationInterceptorResult { Modified = true, Payload = obj });
|
||||
}),
|
||||
CreateInterceptor("val-a", InterceptorType.Validation, (req, _) =>
|
||||
{
|
||||
lock (validatedPayloads) validatedPayloads.Add(req.Payload);
|
||||
return new ValueTask<InterceptorResult>(ValidationInterceptorResult.Success());
|
||||
}));
|
||||
|
||||
var serverB = Server(CreateInterceptor("val-b", InterceptorType.Validation, (req, _) =>
|
||||
{
|
||||
lock (validatedPayloads) validatedPayloads.Add(req.Payload);
|
||||
return new ValueTask<InterceptorResult>(ValidationInterceptorResult.Success());
|
||||
}));
|
||||
|
||||
var result = await InterceptorChainOrchestrator.ExecuteAsync(
|
||||
[.. serverA, .. serverB],
|
||||
new ExecuteChainRequestParams
|
||||
{
|
||||
Event = InterceptionEvents.ToolsCall,
|
||||
Phase = InterceptorPhase.Request,
|
||||
Payload = JsonNode.Parse("""{}""")!,
|
||||
},
|
||||
CancellationToken.None);
|
||||
|
||||
Assert.Equal(InterceptorChainStatus.Success, result.Status);
|
||||
Assert.Equal(2, validatedPayloads.Count);
|
||||
// Both servers' validations run after the mutation from server A, against its output.
|
||||
Assert.All(validatedPayloads, p => Assert.True(p["mutated"]!.GetValue<bool>()));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MultiServer_DuplicateNamesInvokeOncePerHostingServer()
|
||||
{
|
||||
var serverAInvocations = 0;
|
||||
var serverBInvocations = 0;
|
||||
|
||||
var serverA = Server(CreateInterceptor("shared-name", InterceptorType.Validation, (req, _) =>
|
||||
{
|
||||
Interlocked.Increment(ref serverAInvocations);
|
||||
return new ValueTask<InterceptorResult>(ValidationInterceptorResult.Success());
|
||||
}));
|
||||
|
||||
var serverB = Server(CreateInterceptor("shared-name", InterceptorType.Validation, (req, _) =>
|
||||
{
|
||||
Interlocked.Increment(ref serverBInvocations);
|
||||
return new ValueTask<InterceptorResult>(ValidationInterceptorResult.Success());
|
||||
}));
|
||||
|
||||
var result = await InterceptorChainOrchestrator.ExecuteAsync(
|
||||
[.. serverA, .. serverB],
|
||||
new ExecuteChainRequestParams
|
||||
{
|
||||
Event = InterceptionEvents.ToolsCall,
|
||||
Phase = InterceptorPhase.Request,
|
||||
Payload = JsonNode.Parse("""{}""")!,
|
||||
},
|
||||
CancellationToken.None);
|
||||
|
||||
Assert.Equal(InterceptorChainStatus.Success, result.Status);
|
||||
// Each entry routes to its own host: one invocation per server, two results.
|
||||
Assert.Equal(1, serverAInvocations);
|
||||
Assert.Equal(1, serverBInvocations);
|
||||
Assert.Equal(2, result.Results.Count);
|
||||
Assert.All(result.Results, r => Assert.Equal("shared-name", r.InterceptorName));
|
||||
}
|
||||
|
||||
// ── Helpers ─────────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Models one fake server: each of its entries gets an invoker bound to that server's own
|
||||
/// handler, so duplicate names across servers stay distinct.
|
||||
/// </summary>
|
||||
private static List<InterceptorChainOrchestrator.ChainExecutionEntry> Server(params TestEntry[] entries)
|
||||
{
|
||||
return entries.Select(e => new InterceptorChainOrchestrator.ChainExecutionEntry(
|
||||
e.Descriptor,
|
||||
(req, ct) => e.Handler(req, ct))).ToList();
|
||||
}
|
||||
|
||||
private static ValueTask<InterceptorChainResult> RunAsync(
|
||||
IEnumerable<TestEntry> entries,
|
||||
ExecuteChainRequestParams chainParams,
|
||||
|
|
|
|||
Loading…
Reference in a new issue