From 320daf2f675c91bac89b4b676ab67b36c3106554 Mon Sep 17 00:00:00 2001 From: Cliff Hall Date: Mon, 20 Jul 2026 19:33:40 -0400 Subject: [PATCH] Resources: subscriptions/listen model on modern servers (era fork) (#1630) (#1730) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fork resource subscriptions by protocol era: legacy keeps resources/subscribe; modern (2026-07-28) models subscriptions as a filter over one long-lived subscriptions/listen stream with reconnect-by-re-listen (capped backoff), an optimistic Connecting→Listening header badge, and a fix so the browser proxy no longer blocks listen() ~60s. Closes #1630. --- README.md | 2 + clients/web/src/App.tsx | 6 +- .../SubscriptionStreamBadge.stories.tsx | 26 + .../SubscriptionStreamBadge.test.tsx | 55 ++ .../SubscriptionStreamBadge.tsx | 27 + .../subscriptionStreamUtils.ts | 53 ++ .../ProtocolEntry/ProtocolEntry.stories.tsx | 24 +- .../ProtocolEntry/ProtocolEntry.test.tsx | 19 +- .../groups/ProtocolEntry/ProtocolEntry.tsx | 22 +- .../ResourceControls.test.tsx | 62 +++ .../ResourceControls/ResourceControls.tsx | 50 +- .../components/groups/protocolUtils.test.ts | 17 - .../src/components/groups/protocolUtils.ts | 15 - .../ResourcesScreen.stories.tsx | 21 + .../ResourcesScreen/ResourcesScreen.tsx | 18 +- .../views/InspectorView/InspectorView.tsx | 10 + .../state/resourceSubscriptionsState.test.ts | 67 +++ .../react/useResourceSubscriptions.test.tsx | 53 ++ .../inspectorClient-subscriptions-era.test.ts | 527 ++++++++++++++++++ .../remote/remoteClientTransport-unit.test.ts | 24 + .../mcp/remote/server-extra-coverage.test.ts | 33 +- core/mcp/__tests__/fakeInspectorClient.ts | 9 + core/mcp/inspectorClient.ts | 356 +++++++++++- core/mcp/inspectorClientEventTarget.ts | 8 + core/mcp/inspectorClientProtocol.ts | 2 + core/mcp/remote/node/server.ts | 14 +- core/mcp/remote/remoteClientTransport.ts | 9 + core/mcp/state/resourceSubscriptionsState.ts | 45 +- core/mcp/types.ts | 48 ++ core/react/useResourceSubscriptions.ts | 35 +- pr-screenshots/README.md | 61 ++ .../subscriptions-legacy-live-update.png | Bin 0 -> 113750 bytes ...bscriptions-legacy-resources-subscribe.png | Bin 0 -> 105011 bytes .../subscriptions-modern-header-badge.png | Bin 0 -> 50257 bytes ...bscriptions-modern-listen-acknowledged.png | Bin 0 -> 103705 bytes .../configs/subscriptions-legacy-http.json | 14 + .../configs/subscriptions-modern-http.json | 14 + 37 files changed, 1656 insertions(+), 90 deletions(-) create mode 100644 clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.stories.tsx create mode 100644 clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.test.tsx create mode 100644 clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.tsx create mode 100644 clients/web/src/components/elements/SubscriptionStreamBadge/subscriptionStreamUtils.ts create mode 100644 clients/web/src/test/integration/mcp/inspectorClient-subscriptions-era.test.ts create mode 100644 pr-screenshots/README.md create mode 100644 pr-screenshots/subscriptions-legacy-live-update.png create mode 100644 pr-screenshots/subscriptions-legacy-resources-subscribe.png create mode 100644 pr-screenshots/subscriptions-modern-header-badge.png create mode 100644 pr-screenshots/subscriptions-modern-listen-acknowledged.png create mode 100644 test-servers/configs/subscriptions-legacy-http.json create mode 100644 test-servers/configs/subscriptions-modern-http.json diff --git a/README.md b/README.md index a413e47f..12c41b95 100644 --- a/README.md +++ b/README.md @@ -118,6 +118,8 @@ A streamable-HTTP server can also serve the **modern (2026-07-28) protocol era** `test-servers/configs/logging-legacy-http.json` and `test-servers/configs/logging-modern-http.json` are the **logging era-fork showcase** (#1629). Both serve `logging: true` plus a `send_notification` tool that emits a `notifications/message` at a chosen level; the legacy one is a plain streamable-HTTP server (`logging/setLevel` era) and the modern one sets `transport.modern: true`. Connect to the legacy server and open the **Logs** tab to get the session-scoped **Set Active Level** selector + **Set** button; calling `send_notification` streams the log into the panel. Connect to the modern one with **Protocol Era = Modern** and the same tab instead shows the **Log Level per Request** control — pick a level to opt in and the client stamps `_meta["io.modelcontextprotocol/logLevel"]` on every subsequent request (verify in the Network tab's request body); calling `send_notification` then streams the log into the panel over the request's SSE response. Set the control back to **Off** and the same call is silently gated — the request omits the `logLevel` key, so the log never arrives. That gating is faithful to the spec ("a server MUST NOT emit `notifications/message` for a request that didn't opt in") because `send_notification` emits through the SDK's request-scoped, threshold-aware `extra.log` (`ctx.mcpReq.log`): on the modern leg it reads the per-request `logLevel` opt-in from the request envelope and drops the message when the client didn't opt in or the level is below the requested severity; on legacy it honors the session level from `logging/setLevel`. Because it emits through the request's `notify`, the modern response upgrades to SSE and the log rides the originating request's stream. +`test-servers/configs/subscriptions-legacy-http.json` and `test-servers/configs/subscriptions-modern-http.json` are the **resource-subscription era-fork showcase** (#1630). Both serve three `numbered_resources` with `subscriptions: true`; the legacy one also serves an `update_resource` tool, and the modern one sets `transport.modern: true`. Connect to the **legacy** server, open a resource in the **Resources** tab and click **Subscribe** — the client sends `resources/subscribe` (Network/Protocol view) and the Subscriptions section lists the URI with no stream chrome; call `update_resource` with that URI and the server updates the content and emits `notifications/resources/updated`, stamping the subscribed tile's last-updated time. Connect to the **modern** server with **Protocol Era = Modern** and the same Subscribe instead sends **`subscriptions/listen`** (its filter carries `resourceSubscriptions` + the `resourcesListChanged` opt-in) and resolves on `notifications/subscriptions/acknowledged`; the Subscriptions section then shows the stream-status badge (`Connecting…` → `Listening`) in its header, and if the long-lived stream drops it reconnects by re-listing. The modern config deliberately **omits** `update_resource`: the SDK's modern leg is stateless/per-request (`createMcpHandler(() => createMcpServer(config))`), so the tool would run against a throwaway server instance — the content change wouldn't persist for the next `resources/read`, and its `resources/updated` wouldn't reach the (separate) listen stream — which is more confusing than useful. The live update-notification round-trip is therefore demonstrated on the legacy (stateful-session) server; the modern server is for the subscribe/listen/badge behavior. (The Inspector's *receive* path is era-transparent, so a real stateful modern server that routes `resources/updated` onto the listen stream drives the subscribed tile the same way.) + ## Building ```bash diff --git a/clients/web/src/App.tsx b/clients/web/src/App.tsx index 60b1e814..e9aaa44e 100644 --- a/clients/web/src/App.tsx +++ b/clients/web/src/App.tsx @@ -1030,9 +1030,8 @@ function App() { refresh: refreshTasks, clearCompleted: clearCompletedTasks, } = useManagedRequestorTasks(inspectorClient, managedRequestorTasksState); - const { subscriptions } = useResourceSubscriptions( - resourceSubscriptionsState, - ); + const { subscriptions, streamState: subscriptionStreamState } = + useResourceSubscriptions(resourceSubscriptionsState); const { messages } = useMessageLog(messageLogState); const { fetchRequests } = useFetchRequestLog(fetchRequestLogState); const { stderrLogs } = useStderrLog(stderrLogState); @@ -4182,6 +4181,7 @@ function App() { promptsListChanged={promptsListChanged} resourcesListChanged={resourcesListChanged} subscriptions={subscriptions} + subscriptionStreamState={subscriptionStreamState} logs={logs} tasks={tasks} progressByTaskId={progressByTaskId} diff --git a/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.stories.tsx b/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.stories.tsx new file mode 100644 index 00000000..314870a1 --- /dev/null +++ b/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.stories.tsx @@ -0,0 +1,26 @@ +import type { Meta, StoryObj } from "@storybook/react-vite"; +import { SubscriptionStreamBadge } from "./SubscriptionStreamBadge"; + +const meta: Meta = { + title: "Elements/SubscriptionStreamBadge", + component: SubscriptionStreamBadge, +}; + +export default meta; +type Story = StoryObj; + +export const Connecting: Story = { + args: { status: "connecting" }, +}; + +export const Acknowledged: Story = { + args: { status: "acknowledged" }, +}; + +export const Reconnecting: Story = { + args: { status: "reconnecting" }, +}; + +export const Ended: Story = { + args: { status: "ended" }, +}; diff --git a/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.test.tsx b/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.test.tsx new file mode 100644 index 00000000..873549fd --- /dev/null +++ b/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.test.tsx @@ -0,0 +1,55 @@ +import { describe, it, expect } from "vitest"; +import { renderWithMantine, screen } from "../../../test/renderWithMantine"; +import { SubscriptionStreamBadge } from "./SubscriptionStreamBadge"; +import { subscriptionStreamPresentation } from "./subscriptionStreamUtils"; + +describe("subscriptionStreamPresentation", () => { + it("maps each status to a color and label", () => { + expect(subscriptionStreamPresentation("connecting")).toMatchObject({ + color: "blue", + label: "Connecting…", + }); + expect(subscriptionStreamPresentation("acknowledged")).toMatchObject({ + color: "green", + label: "Listening", + }); + expect(subscriptionStreamPresentation("reconnecting")).toMatchObject({ + color: "yellow", + label: "Reconnecting…", + }); + expect(subscriptionStreamPresentation("ended")).toMatchObject({ + color: "gray", + label: "Stream ended", + }); + }); + + it("explains the listen stream in every tooltip", () => { + for (const status of [ + "connecting", + "acknowledged", + "reconnecting", + "ended", + ] as const) { + expect(subscriptionStreamPresentation(status).tooltip).toContain( + "subscriptions/listen stream", + ); + } + }); +}); + +describe("SubscriptionStreamBadge", () => { + it("renders a labelled badge by default", () => { + renderWithMantine(); + expect(screen.getByText("Listening")).toBeInTheDocument(); + }); + + it("renders a labelled reconnecting badge", () => { + renderWithMantine(); + expect(screen.getByText("Reconnecting…")).toBeInTheDocument(); + }); + + it("renders a labelled ended badge", () => { + renderWithMantine(); + expect(screen.getByText("Stream ended")).toBeInTheDocument(); + }); +}); diff --git a/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.tsx b/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.tsx new file mode 100644 index 00000000..5c0eb2b4 --- /dev/null +++ b/clients/web/src/components/elements/SubscriptionStreamBadge/SubscriptionStreamBadge.tsx @@ -0,0 +1,27 @@ +import { Badge, Tooltip } from "@mantine/core"; +import type { ResourceSubscriptionStreamStatus } from "../../../../../../core/mcp/types.js"; +import { subscriptionStreamPresentation } from "./subscriptionStreamUtils"; + +export interface SubscriptionStreamBadgeProps { + /** Lifecycle status of the modern `subscriptions/listen` stream. */ + status: ResourceSubscriptionStreamStatus; +} + +/** + * Status indicator for the modern-era resource-subscription listen stream + * (#1630). Only meaningful on the modern era — the caller gates rendering on + * `streamState.active`. Renders a labelled dot badge (green/yellow/gray) in the + * Subscriptions section header, explaining the stream in a tooltip. + */ +export function SubscriptionStreamBadge({ + status, +}: SubscriptionStreamBadgeProps) { + const { color, label, tooltip } = subscriptionStreamPresentation(status); + return ( + + + {label} + + + ); +} diff --git a/clients/web/src/components/elements/SubscriptionStreamBadge/subscriptionStreamUtils.ts b/clients/web/src/components/elements/SubscriptionStreamBadge/subscriptionStreamUtils.ts new file mode 100644 index 00000000..c2c52536 --- /dev/null +++ b/clients/web/src/components/elements/SubscriptionStreamBadge/subscriptionStreamUtils.ts @@ -0,0 +1,53 @@ +import type { ResourceSubscriptionStreamStatus } from "../../../../../../core/mcp/types.js"; + +export interface StreamPresentation { + /** Mantine palette color name conveying the status. */ + color: string; + /** Short label shown on the panel badge. */ + label: string; + /** Full explanation shown in the tooltip (both variants). */ + tooltip: string; +} + +const STREAM_INTRO = + "On modern (2026-07-28) servers, resource subscriptions are a filter over one long-lived subscriptions/listen stream."; + +// Keyed by status so it's exhaustive at compile time: a new +// `ResourceSubscriptionStreamStatus` that isn't handled here is a type error +// (no unreachable `default` needed, so it stays fully covered). +const PRESENTATION: Record< + ResourceSubscriptionStreamStatus, + StreamPresentation +> = { + connecting: { + color: "blue", + label: "Connecting…", + tooltip: `${STREAM_INTRO} Opening the stream — waiting for the server to acknowledge the subscription.`, + }, + acknowledged: { + color: "green", + label: "Listening", + tooltip: `${STREAM_INTRO} The server acknowledged the subscription and the stream is open, carrying resources/updated notifications.`, + }, + reconnecting: { + color: "yellow", + label: "Reconnecting…", + tooltip: `${STREAM_INTRO} The stream dropped unexpectedly; re-listening to re-establish it (there is no resumability, so the full filter is re-sent).`, + }, + ended: { + color: "gray", + label: "Stream ended", + tooltip: `${STREAM_INTRO} The stream is closed and won't reconnect on its own — either the server ended it (for example, on shutdown) or reconnection was abandoned after repeated failures. Re-subscribe to try again.`, + }, +}; + +/** + * Maps a modern listen-stream status to its badge color, label, and tooltip + * copy (#1630). Kept in its own module so the badge component file exports only + * a component (react-refresh rule). + */ +export function subscriptionStreamPresentation( + status: ResourceSubscriptionStreamStatus, +): StreamPresentation { + return PRESENTATION[status]; +} diff --git a/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.stories.tsx b/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.stories.tsx index 1366bcbf..13f7bf94 100644 --- a/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.stories.tsx +++ b/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.stories.tsx @@ -176,7 +176,7 @@ const subscriptionNotificationEntry: MessageEntry = { jsonrpc: "2.0", method: "notifications/resources/list_changed", params: { - _meta: { "io.modelcontextprotocol/subscriptionId": "sub-abc123" }, + _meta: { "io.modelcontextprotocol/subscriptionId": "listen:0" }, }, }, }; @@ -231,7 +231,8 @@ export const ModernInputRequired: Story = { }, }; -// Modern-era: a `server/discover` probe, flagged with the "modern" frame badge. +// Modern-era: a `server/discover` probe (a modern-only method). The connection +// era is shown once in the panel header, not per entry. export const ModernDiscoverFrame: Story = { args: { entry: discoverEntry, @@ -249,6 +250,25 @@ export const ModernSubscriptionNotification: Story = { }, }; +// Embedded (monitoring-sidebar) layout of a subscription notification: the +// `sub … listen-id` tag rides the top line (beside the direction) so the method +// badge on the line below gets the full narrow-column width (#1630). +export const EmbeddedSubscriptionNotification: Story = { + args: { + entry: subscriptionNotificationEntry, + isPinned: false, + isListExpanded: false, + embedded: true, + }, + decorators: [ + (Story) => ( + + + + ), + ], +}; + // Embedded (monitoring-sidebar) layout with a long resource URI: the target sits // in a horizontal scroll area rather than truncating with an ellipsis. Wrapped // in the pinned column's width so the overflow is visible. diff --git a/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.test.tsx b/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.test.tsx index 19511e2a..070e769b 100644 --- a/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.test.tsx +++ b/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.test.tsx @@ -471,14 +471,10 @@ describe("ProtocolEntry — modern vocabulary", () => { expect(screen.queryByText("complete")).not.toBeInTheDocument(); }); - it("flags a modern-only frame with a 'modern' badge", () => { + it("renders a modern-only frame's method (no per-frame era badge)", () => { renderWithMantine(); expect(screen.getByText("server/discover")).toBeInTheDocument(); - expect(screen.getByText("modern")).toBeInTheDocument(); - }); - - it("does not flag an ordinary frame as modern", () => { - renderWithMantine(); + // The connection era is shown once in the panel header, not per entry. expect(screen.queryByText("modern")).not.toBeInTheDocument(); }); @@ -494,6 +490,17 @@ describe("ProtocolEntry — modern vocabulary", () => { ).toBeGreaterThanOrEqual(1); }); + it("shows the subscriptionId in the embedded compact layout", () => { + renderWithMantine( + , + ); + expect(screen.getByText("sub-abc")).toBeInTheDocument(); + }); + it("shows the modern badges in the embedded compact layout", () => { renderWithMantine( , diff --git a/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.tsx b/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.tsx index 2853ffdc..9cd6ee81 100644 --- a/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.tsx +++ b/clients/web/src/components/groups/ProtocolEntry/ProtocolEntry.tsx @@ -29,7 +29,6 @@ import { extractMethod, extractResultType, extractSubscriptionId, - isModernFrame, isReplayableProtocolMethod, } from "../protocolUtils.js"; @@ -109,15 +108,6 @@ const DurationText = Text.withProps({ c: "dimmed", }); -// Flags a frame whose method only exists in the modern (2026-07-28) era -// (`server/discover`, `subscriptions/listen`, its acknowledgement). This labels -// the *frame*, not the connection's negotiated era (see the transcript caveat in -// protocolUtils) — those methods genuinely cannot occur on a legacy connection. -const ModernFrameBadge = Badge.withProps({ - color: "blue", - variant: "outline", -}); - // The `subscriptionId` tag on a modern push notification (spec §7.4). Shown with // a copy button so the id can be correlated against the `subscriptions/listen` // stream that opened it. @@ -280,7 +270,6 @@ export function ProtocolEntry({ const canReplay = isReplayableProtocolMethod(method); const resultType = extractResultType(entry); const subscriptionId = extractSubscriptionId(entry); - const isModern = isModernFrame(method); useEffect(() => { setIsExpanded(isListExpanded); @@ -319,9 +308,6 @@ export function ProtocolEntry({ {statusLabel(status)} ); - const modernFrameBadge = isModern && ( - modern - ); const subscriptionBadge = subscriptionId && ( sub @@ -350,13 +336,16 @@ export function ProtocolEntry({ {durationText} {resultTypeBadge} {statusBadge} + {/* The subscription-id tag rides the top line's trailing edge + (a notification row's duration/status slots are empty) so the + method badge on the line below gets the full column width and + doesn't truncate against the pin control (#1630). */} + {subscriptionBadge} - {modernFrameBadge} - {subscriptionBadge} {target && ( <> {resourceUri && } @@ -395,7 +384,6 @@ export function ProtocolEntry({ {directionBadge} {specErrorBadge} - {modernFrameBadge} {subscriptionBadge} {target && ( <> diff --git a/clients/web/src/components/groups/ResourceControls/ResourceControls.test.tsx b/clients/web/src/components/groups/ResourceControls/ResourceControls.test.tsx index df72686b..c920fb32 100644 --- a/clients/web/src/components/groups/ResourceControls/ResourceControls.test.tsx +++ b/clients/web/src/components/groups/ResourceControls/ResourceControls.test.tsx @@ -333,4 +333,66 @@ describe("ResourceControls", () => { await user.type(screen.getByPlaceholderText("Search..."), "special"); expect(screen.getByText("URIs (1)")).toBeInTheDocument(); }); + + describe("modern listen-stream chrome (#1630)", () => { + const activeAck = { + active: true as const, + status: "acknowledged" as const, + honoredUris: ["file:///config.json"], + }; + + it("shows the stream badge in the section header on the modern era", () => { + renderWithMantine( + , + ); + // The labelled badge sits in the accordion header (next to the count). + expect(screen.getByText("Listening")).toBeInTheDocument(); + }); + + it("renders no stream chrome on the legacy era even when a stream is active", () => { + renderWithMantine( + , + ); + expect(screen.queryByText("Listening")).not.toBeInTheDocument(); + }); + + it("renders no stream chrome on the modern era when the stream is inactive", () => { + renderWithMantine( + , + ); + expect( + screen.queryByText(/Listening|Stream ended/), + ).not.toBeInTheDocument(); + }); + + it("hides the stream badge when a search filters out all subscriptions", async () => { + const user = userEvent.setup(); + renderWithMantine( + , + ); + expect(screen.getByText("Listening")).toBeInTheDocument(); + + // A query matching none of the (live) subscriptions empties the section; + // the badge hides with it rather than sitting next to "Subscriptions (0)". + await user.type( + screen.getByPlaceholderText("Search..."), + "no-such-resource", + ); + expect(screen.getByText("Subscriptions (0)")).toBeInTheDocument(); + expect(screen.queryByText("Listening")).not.toBeInTheDocument(); + }); + }); }); diff --git a/clients/web/src/components/groups/ResourceControls/ResourceControls.tsx b/clients/web/src/components/groups/ResourceControls/ResourceControls.tsx index fea2e518..3e63ca4c 100644 --- a/clients/web/src/components/groups/ResourceControls/ResourceControls.tsx +++ b/clients/web/src/components/groups/ResourceControls/ResourceControls.tsx @@ -1,11 +1,17 @@ -import { Accordion, Group, Stack, TextInput, Title } from "@mantine/core"; +import { Accordion, Group, Stack, Text, TextInput, Title } from "@mantine/core"; import { ClearButton } from "../../elements/ClearButton/ClearButton"; import { RiArrowRightSLine } from "react-icons/ri"; import type { + ProtocolEra, Resource, ResourceTemplateType as ResourceTemplate, } from "@modelcontextprotocol/client"; -import type { InspectorResourceSubscription } from "../../../../../../core/mcp/types.js"; +import type { + InspectorResourceSubscription, + ResourceSubscriptionStreamState, +} from "../../../../../../core/mcp/types.js"; +import { isModernEra } from "../../elements/EraBadge/eraUtils"; +import { SubscriptionStreamBadge } from "../../elements/SubscriptionStreamBadge/SubscriptionStreamBadge"; import { ListChangedIndicator } from "../../elements/ListChangedIndicator/ListChangedIndicator"; import { ListPaginationControls, @@ -26,6 +32,15 @@ export interface ResourceControlsProps { * explicitly marks subscriptions unsupported. */ subscriptionsSupported?: boolean; + /** + * Modern-era `subscriptions/listen` stream state (#1630). When `active` + * (modern era with at least one subscription) the Subscriptions section shows + * a stream-status badge in its panel and a status dot in its header. Legacy + * connections pass `active: false` (or omit it) and see neither. + */ + subscriptionStreamState?: ResourceSubscriptionStreamState; + /** Negotiated protocol era; gates the modern subscription stream chrome. */ + protocolEra?: ProtocolEra; selectedUri?: string; selectedTemplateUri?: string; // Search text + accordion open-sections are controlled by the parent (App, @@ -71,6 +86,8 @@ export function ResourceControls({ templates, subscriptions, subscriptionsSupported = true, + subscriptionStreamState, + protocolEra, selectedUri, selectedTemplateUri, searchText = "", @@ -106,6 +123,20 @@ export function ResourceControls({ s.resource.uri.toLowerCase().includes(query), ); + // Modern-era chrome for the single `subscriptions/listen` stream (#1630): + // a status badge in the section header (so it stays visible while the section + // is collapsed). Only shown on the modern era while the stream is active + // (≥1 subscription); the legacy per-URI `resources/subscribe` model has no + // persistent stream. Also gated on the *filtered* count so the badge hides + // alongside the section when a search matches none of the live subscriptions + // (rather than sitting next to a disabled "Subscriptions (0)" header). + const streamStatus = + isModernEra(protocolEra) && + subscriptionStreamState?.active === true && + filteredSubscriptions.length > 0 + ? subscriptionStreamState.status + : undefined; + // Subscriptions are only meaningful when the server advertises the // `resources.subscribe` capability; otherwise the section is omitted // entirely (no header, no panel) — see #1478. @@ -271,10 +302,17 @@ export function ResourceControls({ )} > - {formatSectionCount( - "Subscriptions", - filteredSubscriptions.length, - )} + + + {formatSectionCount( + "Subscriptions", + filteredSubscriptions.length, + )} + + {streamStatus && ( + + )} + diff --git a/clients/web/src/components/groups/protocolUtils.test.ts b/clients/web/src/components/groups/protocolUtils.test.ts index a6187090..fff5c5e6 100644 --- a/clients/web/src/components/groups/protocolUtils.test.ts +++ b/clients/web/src/components/groups/protocolUtils.test.ts @@ -7,7 +7,6 @@ import { extractResultType, extractSubscriptionId, groupProtocolEntries, - isModernFrame, } from "./protocolUtils"; // A tools/call request entry whose paired response is the given result. `at` @@ -86,22 +85,6 @@ describe("extractMethod", () => { }); }); -describe("isModernFrame", () => { - it.each([ - "server/discover", - "subscriptions/listen", - "notifications/subscriptions/acknowledged", - ])("recognizes the modern frame %s", (method) => { - expect(isModernFrame(method)).toBe(true); - }); - - it("returns false for legacy/ordinary methods", () => { - expect(isModernFrame("tools/call")).toBe(false); - expect(isModernFrame("notifications/initialized")).toBe(false); - expect(isModernFrame("response")).toBe(false); - }); -}); - describe("extractResultType", () => { it("returns 'input_required' when the result carries the discriminator", () => { const entry = callEntry( diff --git a/clients/web/src/components/groups/protocolUtils.ts b/clients/web/src/components/groups/protocolUtils.ts index 3b3f11fa..845f3921 100644 --- a/clients/web/src/components/groups/protocolUtils.ts +++ b/clients/web/src/components/groups/protocolUtils.ts @@ -50,21 +50,6 @@ export function isReplayableProtocolMethod(method: string): boolean { // envelope/resultType" ≠ "modern negotiated" (spec §8.3). Era labeling comes // from the negotiated `protocolEra` connection state, threaded in as a prop. -/** - * Frame methods that only exist in the modern era: the discovery probe, the - * push-notification listen stream, and its acknowledgement. Generic viewers - * already display them; this set drives the small "modern frame" affordance. - */ -export const MODERN_METHODS: ReadonlySet = new Set([ - "server/discover", - "subscriptions/listen", - "notifications/subscriptions/acknowledged", -]); - -export function isModernFrame(method: string): boolean { - return MODERN_METHODS.has(method); -} - // The successful `result` object of a request entry's paired response, or // undefined when there is no response or it was an error. (messageLogState folds // a request's response onto the request entry by JSON-RPC id.) diff --git a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.stories.tsx b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.stories.tsx index aee4edbf..b1de0328 100644 --- a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.stories.tsx +++ b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.stories.tsx @@ -239,6 +239,27 @@ export const SubscriptionsUnsupported: Story = { }, }; +// Modern (2026-07-28) era: subscriptions ride one `subscriptions/listen` +// stream, so the Subscriptions section shows a stream-status badge in its panel +// and a status dot in its header (#1630). +export const ModernSubscriptionStream: Story = { + args: { + resources: sampleResources, + templates: sampleTemplates, + subscriptions: sampleSubscriptions, + protocolEra: "modern", + subscriptionStreamState: { + active: true, + status: "acknowledged", + honoredUris: sampleSubscriptions.map((s) => s.resource.uri), + }, + }, + play: async ({ canvasElement }) => { + const canvas = within(canvasElement); + expect(await canvas.findByText("Listening")).toBeInTheDocument(); + }, +}; + const manyResources: Resource[] = Array.from({ length: 40 }, (_, i) => ({ name: `resource-${String(i + 1).padStart(2, "0")}.wav`, uri: `file:///kit/resource-${i + 1}.wav`, diff --git a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.tsx b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.tsx index 95ddd220..1a8040b4 100644 --- a/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.tsx +++ b/clients/web/src/components/screens/ResourcesScreen/ResourcesScreen.tsx @@ -9,11 +9,15 @@ import { Text, } from "@mantine/core"; import type { + ProtocolEra, ReadResourceResult, Resource, ResourceTemplateType as ResourceTemplate, } from "@modelcontextprotocol/client"; -import type { InspectorResourceSubscription } from "../../../../../../core/mcp/types.js"; +import type { + InspectorResourceSubscription, + ResourceSubscriptionStreamState, +} from "../../../../../../core/mcp/types.js"; import { ResourceControls } from "../../groups/ResourceControls/ResourceControls"; import type { ListPaginationControlsProps } from "../../elements/ListPaginationControls/ListPaginationControls"; import { ResourcePreviewPanel } from "../../groups/ResourcePreviewPanel/ResourcePreviewPanel"; @@ -32,6 +36,14 @@ export interface ResourcesScreenProps { resources: Resource[]; templates: ResourceTemplate[]; subscriptions: InspectorResourceSubscription[]; + /** + * Modern-era `subscriptions/listen` stream state (#1630). On the modern era + * the Subscriptions section shows a stream-status badge and a header dot; + * `active: false` (the legacy default) renders neither. + */ + subscriptionStreamState?: ResourceSubscriptionStreamState; + /** Negotiated protocol era; gates the modern subscription stream chrome. */ + protocolEra?: ProtocolEra; readState?: ReadResourceState; ui: ResourcesUiState; listChanged: boolean; @@ -137,6 +149,8 @@ export function ResourcesScreen({ resources, templates, subscriptions, + subscriptionStreamState, + protocolEra, readState, ui, listChanged, @@ -291,6 +305,8 @@ export function ResourcesScreen({ templates={templates} subscriptions={subscriptions} subscriptionsSupported={subscriptionsSupported} + subscriptionStreamState={subscriptionStreamState} + protocolEra={protocolEra} selectedUri={selectedResourceUri} selectedTemplateUri={selectedTemplateUri} searchText={search} diff --git a/clients/web/src/components/views/InspectorView/InspectorView.tsx b/clients/web/src/components/views/InspectorView/InspectorView.tsx index a15260e7..8a4b3a77 100644 --- a/clients/web/src/components/views/InspectorView/InspectorView.tsx +++ b/clients/web/src/components/views/InspectorView/InspectorView.tsx @@ -32,6 +32,7 @@ import type { FetchRequestEntry, InspectorResourceSubscription, MessageEntry, + ResourceSubscriptionStreamState, ServerEntry, StderrLogEntry, } from "@inspector/core/mcp/types.js"; @@ -394,6 +395,12 @@ export interface InspectorViewProps { resources: Resource[]; resourceTemplates: ResourceTemplate[]; subscriptions: InspectorResourceSubscription[]; + /** + * Modern-era `subscriptions/listen` stream state (#1630). Drives the + * Resources screen's stream badge/dot; `active: false` (or omitted) on the + * legacy era. + */ + subscriptionStreamState?: ResourceSubscriptionStreamState; // "List changed since last refresh" flags, sourced from the managed-state // layer (#1402). They light the per-screen list-changed indicator. Apps is a @@ -593,6 +600,7 @@ export function InspectorView({ promptsListChanged, resourcesListChanged, subscriptions, + subscriptionStreamState, logs, tasks, progressByTaskId, @@ -1352,6 +1360,8 @@ export function InspectorView({ resources={resources} templates={resourceTemplates} subscriptions={subscriptions} + subscriptionStreamState={subscriptionStreamState} + protocolEra={protocolEra} readState={readResourceState} ui={resourcesUi} listChanged={resourcesListChanged} diff --git a/clients/web/src/test/core/mcp/state/resourceSubscriptionsState.test.ts b/clients/web/src/test/core/mcp/state/resourceSubscriptionsState.test.ts index a328ceb0..c9cc3a5c 100644 --- a/clients/web/src/test/core/mcp/state/resourceSubscriptionsState.test.ts +++ b/clients/web/src/test/core/mcp/state/resourceSubscriptionsState.test.ts @@ -236,4 +236,71 @@ describe("ResourceSubscriptionsState", () => { state.destroy(); expect(() => state.destroy()).not.toThrow(); }); + + describe("modern listen-stream state (#1630)", () => { + it("starts inactive and seeds from the client", () => { + const state = new ResourceSubscriptionsState(client); + expect(state.getStreamState()).toEqual({ + active: false, + status: "ended", + honoredUris: [], + }); + + client.resourceSubscriptionStreamState = { + active: true, + status: "acknowledged", + honoredUris: ["file:///a"], + }; + const seeded = new ResourceSubscriptionsState(client); + expect(seeded.getStreamState().active).toBe(true); + expect(seeded.getStreamState().honoredUris).toEqual(["file:///a"]); + }); + + it("forwards resourceSubscriptionStreamChange as streamStateChange", async () => { + const state = new ResourceSubscriptionsState(client); + const next = await new Promise((resolve) => { + state.addEventListener("streamStateChange", (e) => resolve(e.detail), { + once: true, + }); + client.dispatchTypedEvent("resourceSubscriptionStreamChange", { + active: true, + status: "reconnecting", + honoredUris: [], + }); + }); + expect(next).toEqual({ + active: true, + status: "reconnecting", + honoredUris: [], + }); + expect(state.getStreamState().status).toBe("reconnecting"); + }); + + it("resets stream state to inactive on a terminal status change", () => { + const state = new ResourceSubscriptionsState(client); + client.dispatchTypedEvent("resourceSubscriptionStreamChange", { + active: true, + status: "acknowledged", + honoredUris: ["file:///a"], + }); + expect(state.getStreamState().active).toBe(true); + + const handler = vi.fn(); + state.addEventListener("streamStateChange", handler); + client.setStatus("disconnected"); + expect(state.getStreamState().active).toBe(false); + expect(handler).toHaveBeenCalled(); + }); + + it("resets stream state on destroy", () => { + const state = new ResourceSubscriptionsState(client); + client.dispatchTypedEvent("resourceSubscriptionStreamChange", { + active: true, + status: "acknowledged", + honoredUris: ["file:///a"], + }); + state.destroy(); + expect(state.getStreamState().active).toBe(false); + }); + }); }); diff --git a/clients/web/src/test/core/react/useResourceSubscriptions.test.tsx b/clients/web/src/test/core/react/useResourceSubscriptions.test.tsx index 164444fc..e11ff519 100644 --- a/clients/web/src/test/core/react/useResourceSubscriptions.test.tsx +++ b/clients/web/src/test/core/react/useResourceSubscriptions.test.tsx @@ -66,4 +66,57 @@ describe("useResourceSubscriptions", () => { client.dispatchTypedEvent("resourceSubscriptionsChange", ["file:///a"]); expect(result.current.subscriptions).toEqual([]); }); + + it("returns an inactive stream state by default and when null", () => { + const { result: nullResult } = renderHook(() => + useResourceSubscriptions(null), + ); + expect(nullResult.current.streamState.active).toBe(false); + + const { result } = renderHook(() => useResourceSubscriptions(state)); + expect(result.current.streamState.active).toBe(false); + }); + + it("updates streamState when the store dispatches streamStateChange", async () => { + const { result } = renderHook(() => useResourceSubscriptions(state)); + + act(() => { + client.dispatchTypedEvent("resourceSubscriptionStreamChange", { + active: true, + status: "acknowledged", + honoredUris: ["file:///a"], + }); + }); + + await waitFor(() => { + expect(result.current.streamState).toEqual({ + active: true, + status: "acknowledged", + honoredUris: ["file:///a"], + }); + }); + }); + + it("resets streamState when the state prop becomes null", async () => { + const { result, rerender } = renderHook( + ({ s }: { s: ResourceSubscriptionsState | null }) => + useResourceSubscriptions(s), + { initialProps: { s: state as ResourceSubscriptionsState | null } }, + ); + act(() => { + client.dispatchTypedEvent("resourceSubscriptionStreamChange", { + active: true, + status: "acknowledged", + honoredUris: [], + }); + }); + await waitFor(() => { + expect(result.current.streamState.active).toBe(true); + }); + + rerender({ s: null }); + await waitFor(() => { + expect(result.current.streamState.active).toBe(false); + }); + }); }); diff --git a/clients/web/src/test/integration/mcp/inspectorClient-subscriptions-era.test.ts b/clients/web/src/test/integration/mcp/inspectorClient-subscriptions-era.test.ts new file mode 100644 index 00000000..a0ba4100 --- /dev/null +++ b/clients/web/src/test/integration/mcp/inspectorClient-subscriptions-era.test.ts @@ -0,0 +1,527 @@ +import { describe, it, expect, afterEach, vi } from "vitest"; +import { InspectorClient } from "@inspector/core/mcp/inspectorClient.js"; +import { createTransportNode } from "@inspector/core/mcp/node/transport.js"; +import { eraToVersionNegotiation } from "@inspector/core/mcp/types.js"; +import type { McpSubscription } from "@modelcontextprotocol/client"; +import { + createTestServerHttp, + type TestServerHttp, + createTestServerInfo, + createNumberedResources, +} from "@modelcontextprotocol/inspector-test-server"; +import type { ServerConfig } from "@modelcontextprotocol/inspector-test-server"; +import type { MessageEntry } from "@inspector/core/mcp/types.js"; + +/** + * Live coverage of the resource-subscription era fork (#1630). On the legacy era + * each subscription is a `resources/subscribe` request; on the modern + * (2026-07-28) era subscriptions are a filter over one `subscriptions/listen` + * stream. Both are exercised against a real server over a real transport. + */ +describe("resource subscriptions era fork (#1630)", () => { + let client: InspectorClient | null = null; + let server: TestServerHttp | null = null; + + const RESOURCE_URI = "test://resource_0"; + const RESOURCE_URI_2 = "test://resource_1"; + + afterEach(async () => { + if (client) { + try { + await client.disconnect(); + } catch { + // ignore + } + client = null; + } + if (server) { + try { + await server.stop(); + } catch { + // ignore + } + server = null; + } + }); + + async function startServer( + modern: ServerConfig["modern"] | undefined, + ): Promise { + const started = createTestServerHttp({ + serverInfo: createTestServerInfo("subscriptions-era-test", "1.0.0"), + resources: createNumberedResources(2), + listChanged: { resources: true }, + subscriptions: true, + ...(modern ? { modern } : {}), + }); + await started.start(); + server = started; + return started; + } + + async function connect( + url: string, + era: "legacy" | "modern", + ): Promise<{ connected: InspectorClient; messages: MessageEntry[] }> { + const connected = new InspectorClient( + { type: "streamable-http", url }, + { + environment: { transport: createTransportNode }, + versionNegotiation: eraToVersionNegotiation(era), + }, + ); + const messages: MessageEntry[] = []; + connected.addEventListener("message", (event) => { + messages.push(event.detail); + }); + await connected.connect(); + client = connected; + return { connected, messages }; + } + + function methodsSent(messages: MessageEntry[]): string[] { + return messages + .filter((m) => m.direction === "request") + .map((m) => ("method" in m.message ? m.message.method : "")) + .filter(Boolean); + } + + /** Params of the last `subscriptions/listen` request captured in the log. */ + function lastListenFilter( + messages: MessageEntry[], + ): Record | undefined { + const listen = messages + .filter( + (m) => + m.direction === "request" && + "method" in m.message && + m.message.method === "subscriptions/listen", + ) + .at(-1); + if (!listen || !("params" in listen.message)) return undefined; + const params = listen.message.params as { notifications?: unknown }; + return params.notifications as Record | undefined; + } + + describe("modern era", () => { + it("opens an acknowledged listen stream on subscribe (no resources/subscribe)", async () => { + const started = await startServer({}); + const { connected, messages } = await connect(started.url, "modern"); + expect(connected.getProtocolEra()).toBe("modern"); + expect(connected.supportsResourceSubscriptions()).toBe(true); + + messages.length = 0; + await connected.subscribeToResource(RESOURCE_URI); + + const streamState = connected.getResourceSubscriptionStreamState(); + expect(streamState.active).toBe(true); + expect(streamState.status).toBe("acknowledged"); + expect(streamState.honoredUris).toContain(RESOURCE_URI); + expect(connected.getSubscribedResources()).toEqual([RESOURCE_URI]); + + const methods = methodsSent(messages); + expect(methods).toContain("subscriptions/listen"); + expect(methods).not.toContain("resources/subscribe"); + }); + + it("closes the stream when the last subscription is removed", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + expect(connected.getResourceSubscriptionStreamState().active).toBe(true); + + await connected.unsubscribeFromResource(RESOURCE_URI); + const streamState = connected.getResourceSubscriptionStreamState(); + expect(streamState.active).toBe(false); + expect(connected.getSubscribedResources()).toEqual([]); + }); + + it("re-lists (stream stays open) when one of several URIs is removed", async () => { + const started = await startServer({}); + const { connected, messages } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + await connected.subscribeToResource(RESOURCE_URI_2); + expect(connected.getSubscribedResources()).toEqual([ + RESOURCE_URI, + RESOURCE_URI_2, + ]); + + messages.length = 0; + await connected.unsubscribeFromResource(RESOURCE_URI); + + // A fresh listen re-established the reduced filter; the stream is still up. + const streamState = connected.getResourceSubscriptionStreamState(); + expect(streamState.active).toBe(true); + expect(streamState.status).toBe("acknowledged"); + expect(streamState.honoredUris).toEqual([RESOURCE_URI_2]); + expect(methodsSent(messages)).toContain("subscriptions/listen"); + }); + + it("folds the subscribed URIs and listChanged opt-ins into the listen filter", async () => { + const started = await startServer({}); + const { connected, messages } = await connect(started.url, "modern"); + messages.length = 0; + await connected.subscribeToResource(RESOURCE_URI); + + const filter = lastListenFilter(messages); + expect(filter?.resourceSubscriptions).toEqual([RESOURCE_URI]); + // The server advertises resources.listChanged, so the single stream also + // opts into it (one listen stream carries every opted-in type). + expect(filter?.resourcesListChanged).toBe(true); + }); + + it("skips a redundant re-list when re-subscribing an already-subscribed URI", async () => { + const started = await startServer({}); + const { connected, messages } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + + // A second subscribe of the same URI leaves the filter unchanged, so it + // must not re-list (which would needlessly churn the server stream). + messages.length = 0; + await connected.subscribeToResource(RESOURCE_URI); + expect(methodsSent(messages)).not.toContain("subscriptions/listen"); + expect(connected.getSubscribedResources()).toEqual([RESOURCE_URI]); + expect(connected.getResourceSubscriptionStreamState().active).toBe(true); + }); + + it("skips a re-list when unsubscribing a URI that isn't subscribed", async () => { + const started = await startServer({}); + const { connected, messages } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + + messages.length = 0; + await connected.unsubscribeFromResource("test://not-subscribed"); + expect(methodsSent(messages)).not.toContain("subscriptions/listen"); + // The real subscription is untouched. + expect(connected.getSubscribedResources()).toEqual([RESOURCE_URI]); + }); + }); + + describe("legacy era", () => { + it("subscribes via resources/subscribe with no listen stream", async () => { + const started = await startServer(undefined); + const { connected, messages } = await connect(started.url, "legacy"); + expect(connected.getProtocolEra()).toBe("legacy"); + expect(connected.supportsResourceSubscriptions()).toBe(true); + + messages.length = 0; + await connected.subscribeToResource(RESOURCE_URI); + + const methods = methodsSent(messages); + expect(methods).toContain("resources/subscribe"); + expect(methods).not.toContain("subscriptions/listen"); + + // No persistent stream on the legacy era. + expect(connected.getResourceSubscriptionStreamState().active).toBe(false); + expect(connected.getSubscribedResources()).toEqual([RESOURCE_URI]); + + messages.length = 0; + await connected.unsubscribeFromResource(RESOURCE_URI); + expect(methodsSent(messages)).toContain("resources/unsubscribe"); + expect(connected.getSubscribedResources()).toEqual([]); + }); + }); + + describe("guards", () => { + it("rejects subscribe when the server does not support subscriptions", async () => { + const started = createTestServerHttp({ + serverInfo: createTestServerInfo("no-subscribe-test", "1.0.0"), + resources: createNumberedResources(1), + // subscriptions omitted → capability not advertised + modern: {}, + }); + await started.start(); + server = started; + const { connected } = await connect(started.url, "modern"); + expect(connected.supportsResourceSubscriptions()).toBe(false); + await expect(connected.subscribeToResource(RESOURCE_URI)).rejects.toThrow( + /does not support resource subscriptions/, + ); + }); + }); + + // Modern stream lifecycle branches that the public surface can't reach against + // a healthy server (an unexpected drop, a failed `listen()`). These reach into + // the client's private state — the pattern used across the InspectorClient + // coverage-backfill suite — to drive them deterministically. + describe("modern stream internals", () => { + interface StreamInternals { + client: { listen: (...args: unknown[]) => Promise }; + modernSubscription: McpSubscription | null; + modernListenGeneration: number; + modernReconnectAttempts: number; + subscribedResources: Set; + onModernSubscriptionClosed( + subscription: McpSubscription, + reason: "local" | "graceful" | "remote", + generation: number, + ): void; + } + + function internals(c: InspectorClient): StreamInternals { + return c as unknown as StreamInternals; + } + + /** A controllable fake `McpSubscription` whose `closed` we resolve on demand. */ + function makeFakeSub(): { + sub: McpSubscription; + drop: (reason: "local" | "graceful" | "remote") => void; + } { + let drop: (reason: "local" | "graceful" | "remote") => void = () => {}; + const closed = new Promise<"local" | "graceful" | "remote">((resolve) => { + drop = resolve; + }); + const sub = { + honoredFilter: { resourceSubscriptions: [RESOURCE_URI] }, + close: async () => {}, + closed, + } as McpSubscription; + return { sub, drop }; + } + + /** + * Replace the client's live listen stream with a controllable fake and close + * the real one, so tests that drive `onModernSubscriptionClosed` by hand + * don't leave a real stream open (which would reject "Connection closed" on + * teardown). Returns the installed fake. + */ + async function installFakeSubscription( + int: StreamInternals, + ): Promise> { + const real = int.modernSubscription; + const fake = makeFakeSub(); + int.modernSubscription = fake.sub; + // real.closed fires onModernSubscriptionClosed, but modernSubscription is + // now the fake, so it's a no-op guard-wise; this just tears down the wire. + await real?.close().catch(() => {}); + return fake; + } + + it("rolls back the optimistic add when listen() fails", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + const real = internals(connected).client.listen; + internals(connected).client.listen = () => + Promise.reject(new Error("listen boom")); + + await expect(connected.subscribeToResource(RESOURCE_URI)).rejects.toThrow( + /listen boom/, + ); + expect(connected.getSubscribedResources()).toEqual([]); + expect(connected.getResourceSubscriptionStreamState().active).toBe(false); + + internals(connected).client.listen = real; + }); + + it("reflects the subscription optimistically as 'connecting' before the ack", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + const int = internals(connected); + + // Hold the listen ack so we can observe the pre-ack (optimistic) state. + let ack: (sub: McpSubscription) => void = () => {}; + int.client.listen = () => + new Promise((resolve) => { + ack = resolve; + }); + + const pending = connected.subscribeToResource(RESOURCE_URI); + // The URI and a "connecting" stream state are visible immediately, without + // waiting for the round-trip. + expect(connected.getSubscribedResources()).toEqual([RESOURCE_URI]); + const connecting = connected.getResourceSubscriptionStreamState(); + expect(connecting.active).toBe(true); + expect(connecting.status).toBe("connecting"); + + // The ack lands → acknowledged. + ack(makeFakeSub().sub); + await pending; + expect(connected.getResourceSubscriptionStreamState().status).toBe( + "acknowledged", + ); + }); + + it("reconnects by re-listing after an unexpected 'remote' drop", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + + const int = internals(connected); + const fake = await installFakeSubscription(int); + int.onModernSubscriptionClosed( + fake.sub, + "remote", + int.modernListenGeneration, + ); + + // Synchronously flips to reconnecting, then re-lists and re-acknowledges. + expect(connected.getResourceSubscriptionStreamState().status).toBe( + "reconnecting", + ); + await vi.waitFor(() => { + const s = connected.getResourceSubscriptionStreamState(); + expect(s.active).toBe(true); + expect(s.status).toBe("acknowledged"); + }); + }); + + it("retries a failing re-listen with backoff and gives up past the cap", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + const int = internals(connected); + const fake = await installFakeSubscription(int); + + vi.useFakeTimers(); + try { + // Every re-listen fails, so the failure count climbs each retry. + int.client.listen = () => Promise.reject(new Error("re-listen boom")); + + int.onModernSubscriptionClosed( + fake.sub, + "remote", + int.modernListenGeneration, + ); + // A single failure retries (not ended yet). + await vi.advanceTimersByTimeAsync(20_000); + expect(connected.getResourceSubscriptionStreamState().status).toBe( + "reconnecting", + ); + + // Keep failing until the consecutive-failure cap gives up. + for (let i = 0; i < 12; i++) { + if (connected.getResourceSubscriptionStreamState().status === "ended") + break; + await vi.advanceTimersByTimeAsync(20_000); + } + const state = connected.getResourceSubscriptionStreamState(); + expect(state.status).toBe("ended"); + // Subscriptions remain, so the ended badge stays visible. + expect(state.active).toBe(true); + } finally { + vi.useRealTimers(); + } + }); + + it("resets the failure count after a successful reconnect", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + const int = internals(connected); + const fake = await installFakeSubscription(int); + + vi.useFakeTimers(); + try { + // The first two re-lists fail (count climbs), the third acknowledges. + let failures = 0; + int.client.listen = () => { + if (failures < 2) { + failures += 1; + return Promise.reject(new Error("re-listen boom")); + } + return Promise.resolve(makeFakeSub().sub); + }; + + int.onModernSubscriptionClosed( + fake.sub, + "remote", + int.modernListenGeneration, + ); + // Advance through the two failures and the successful ack. + for (let i = 0; i < 4; i++) { + await vi.advanceTimersByTimeAsync(20_000); + } + // A successful ack resets the run, so a subsequent drop starts fresh. + expect(int.modernReconnectAttempts).toBe(0); + expect(connected.getResourceSubscriptionStreamState().status).toBe( + "acknowledged", + ); + } finally { + vi.useRealTimers(); + } + }); + + it("does not reconnect when the subscription set empties before the timer fires", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + const int = internals(connected); + const fake = await installFakeSubscription(int); + + vi.useFakeTimers(); + try { + int.client.listen = () => { + throw new Error("re-listen should not run once the set is empty"); + }; + int.onModernSubscriptionClosed( + fake.sub, + "remote", + int.modernListenGeneration, + ); + expect(connected.getResourceSubscriptionStreamState().status).toBe( + "reconnecting", + ); + // Empty the set without going through unsubscribe (which would clear the + // timer), then fire it: the guard bails instead of re-listing. + int.subscribedResources.clear(); + await vi.advanceTimersByTimeAsync(20_000); + expect(int.modernSubscription).toBeNull(); + } finally { + vi.useRealTimers(); + } + }); + + it("keeps the ended badge active on a graceful close while subscriptions remain", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + + const int = internals(connected); + const fake = await installFakeSubscription(int); + int.onModernSubscriptionClosed( + fake.sub, + "graceful", + int.modernListenGeneration, + ); + const state = connected.getResourceSubscriptionStreamState(); + expect(state.status).toBe("ended"); + // Subscriptions remain, so the ended badge stays visible (parity with the + // reconnect give-up state). + expect(state.active).toBe(true); + }); + + it("goes inactive on a graceful close once no subscriptions remain", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + + const int = internals(connected); + const fake = await installFakeSubscription(int); + // No URIs left → the ended state is inactive (no badge). + int.subscribedResources.clear(); + int.onModernSubscriptionClosed( + fake.sub, + "graceful", + int.modernListenGeneration, + ); + expect(connected.getResourceSubscriptionStreamState().active).toBe(false); + }); + + it("ignores a close callback from a superseded generation", async () => { + const started = await startServer({}); + const { connected } = await connect(started.url, "modern"); + await connected.subscribeToResource(RESOURCE_URI); + + const int = internals(connected); + const fake = await installFakeSubscription(int); + const before = connected.getResourceSubscriptionStreamState(); + // A stale generation → the callback is a no-op (no reconnect, no change). + int.onModernSubscriptionClosed( + fake.sub, + "remote", + int.modernListenGeneration - 1, + ); + expect(connected.getResourceSubscriptionStreamState()).toEqual(before); + }); + }); +}); diff --git a/clients/web/src/test/integration/mcp/remote/remoteClientTransport-unit.test.ts b/clients/web/src/test/integration/mcp/remote/remoteClientTransport-unit.test.ts index 24ecc814..05b8346d 100644 --- a/clients/web/src/test/integration/mcp/remote/remoteClientTransport-unit.test.ts +++ b/clients/web/src/test/integration/mcp/remote/remoteClientTransport-unit.test.ts @@ -562,6 +562,30 @@ describe("RemoteClientTransport (focused branch coverage)", () => { ).rejects.toThrow(/Transport is closed/); }); + it("does not wait for an SSE response on subscriptions/listen (long-lived stream)", async () => { + // A `subscriptions/listen` never yields a JSON-RPC response — only an + // acknowledged notification over the event channel — so send() must + // resolve promptly instead of hanging on the SSE response wait (#1630). + // With a short response timeout, a request that *did* wait would reject. + const t = makeTransport( + { + events: () => openEventsResponse(), + send: () => jsonResponse({ ok: true }), + }, + { sseResponseTimeoutMs: 50 }, + ); + await t.start(); + await expect( + t.send({ + jsonrpc: "2.0", + id: "listen:0", + method: "subscriptions/listen", + params: {}, + }), + ).resolves.toBeUndefined(); + await t.close(); + }); + it("posts a message including relatedRequestId and succeeds", async () => { let sentBody: { relatedRequestId?: unknown } | undefined; const encoder = new TextEncoder(); diff --git a/clients/web/src/test/integration/mcp/remote/server-extra-coverage.test.ts b/clients/web/src/test/integration/mcp/remote/server-extra-coverage.test.ts index e6b99812..ee0182ae 100644 --- a/clients/web/src/test/integration/mcp/remote/server-extra-coverage.test.ts +++ b/clients/web/src/test/integration/mcp/remote/server-extra-coverage.test.ts @@ -19,7 +19,10 @@ import { join } from "node:path"; import { serve } from "@hono/node-server"; import type { ServerType } from "@hono/node-server"; import type pinoType from "pino"; -import { createRemoteApp } from "@inspector/core/mcp/remote/node/server.js"; +import { + createRemoteApp, + requestIdForSendWait, +} from "@inspector/core/mcp/remote/node/server.js"; import { InMemorySecretStore, KeychainUnavailableError, @@ -108,6 +111,34 @@ function makeCapturingLogger(): { } describe("server.ts supplemental coverage", () => { + describe("requestIdForSendWait (#1630)", () => { + it("returns the id for an ordinary request", () => { + expect( + requestIdForSendWait({ jsonrpc: "2.0", id: 7, method: "tools/list" }), + ).toBe(7); + }); + + it("does not wait for a response on subscriptions/listen (long-lived stream)", () => { + expect( + requestIdForSendWait({ + jsonrpc: "2.0", + id: "listen:0", + method: "subscriptions/listen", + params: {}, + }), + ).toBeUndefined(); + }); + + it("returns undefined for a notification (no id)", () => { + expect( + requestIdForSendWait({ + jsonrpc: "2.0", + method: "notifications/initialized", + }), + ).toBeUndefined(); + }); + }); + describe("/api/log forwardLogEvent shapes", () => { let h: Harness; let records: Array<{ level: string; args: unknown[] }>; diff --git a/core/mcp/__tests__/fakeInspectorClient.ts b/core/mcp/__tests__/fakeInspectorClient.ts index 3934b5f0..166665ba 100644 --- a/core/mcp/__tests__/fakeInspectorClient.ts +++ b/core/mcp/__tests__/fakeInspectorClient.ts @@ -33,8 +33,10 @@ import type { PromptGetInvocation, ResourceReadInvocation, ResourceTemplateReadInvocation, + ResourceSubscriptionStreamState, ToolCallInvocation, } from "../types.js"; +import { INACTIVE_SUBSCRIPTION_STREAM_STATE } from "../types.js"; import type { JsonValue } from "../../json/jsonUtils.js"; type ListResult = { @@ -249,6 +251,13 @@ export class FakeInspectorClient return this.discoverResult; } + resourceSubscriptionStreamState: ResourceSubscriptionStreamState = + INACTIVE_SUBSCRIPTION_STREAM_STATE; + + getResourceSubscriptionStreamState(): ResourceSubscriptionStreamState { + return this.resourceSubscriptionStreamState; + } + getServerSettings(): InspectorServerSettings | undefined { return this.serverSettings; } diff --git a/core/mcp/inspectorClient.ts b/core/mcp/inspectorClient.ts index e9d8033c..e385dfc5 100644 --- a/core/mcp/inspectorClient.ts +++ b/core/mcp/inspectorClient.ts @@ -15,6 +15,7 @@ import type { AppRendererClient, InspectorClientOptions, PendingRequestOrigin, + ResourceSubscriptionStreamState, } from "./types.js"; // Re-export so v1.5 tests that do `import { InspectorClientOptions } from // "@inspector/core/mcp/inspectorClient.js"` keep resolving. @@ -27,7 +28,11 @@ export type { AppRendererClient, } from "./types.js"; import { getServerType as getServerTypeFromConfig } from "./config.js"; -import { DEFAULT_MODERN_LOG_LEVEL } from "./types.js"; +import { + DEFAULT_MODERN_LOG_LEVEL, + INACTIVE_SUBSCRIPTION_STREAM_STATE, + isTerminalStatus, +} from "./types.js"; // Fallback client identity, used ONLY when a caller doesn't pass // `clientIdentity`. Real clients supply their own: the Node clients (CLI, TUI) // read the single-source version from the root package.json via @@ -94,6 +99,8 @@ import type { InputRequests, InputRequiredOptions, StandardSchemaV1, + McpSubscription, + SubscriptionFilter, } from "@modelcontextprotocol/client"; import { ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/client"; import { @@ -247,6 +254,16 @@ interface ToolCallRequest { options?: { skipOutputValidation?: boolean }; } +// Backoff for reconnect-by-re-listen on the modern `subscriptions/listen` stream +// (#1630). A `"remote"` drop schedules a re-listen after a capped exponential +// delay (based on the count of *consecutive failed* re-lists) so a flapping +// server can't spin a tight zero-delay loop; a successful acknowledgement resets +// the count, and past the cap we give up (mark the stream ended) rather than +// retry a persistently-failing re-list forever. +const MODERN_RECONNECT_BASE_MS = 500; +const MODERN_RECONNECT_MAX_MS = 15_000; +const MODERN_RECONNECT_MAX_ATTEMPTS = 8; + /** * InspectorClient wraps an MCP Client and provides: * - Message tracking and storage @@ -326,8 +343,31 @@ export class InspectorClient extends InspectorClientEventTarget { resources: boolean; prompts: boolean; }; - // Resource subscriptions + // Resource subscriptions. The set of subscribed URIs is the era-agnostic + // source of truth for the UI (the `resourceSubscriptionsChange` list). How a + // subscription reaches the wire forks by era: legacy sends one + // `resources/subscribe` per URI; modern (2026-07-28) has no such method — all + // subscriptions are a filter over one long-lived `subscriptions/listen` stream + // (#1630, SEP §7.4). private subscribedResources: Set = new Set(); + // Modern-era listen stream backing the subscriptions above. A single + // `McpSubscription` whose filter's `resourceSubscriptions` mirrors + // `subscribedResources`; mutating the set re-lists (close old, open new), and + // an unexpected `"remote"` close re-lists (reconnect-by-re-listen — the stream + // is not resumable). `null` when no URI is subscribed or on the legacy era. + private modernSubscription: McpSubscription | null = null; + // Monotonic guard so a stale re-list/reconnect (whose `listen()` or `closed` + // resolves after a newer refresh already started) can detect it lost the race + // and bail without clobbering the current stream. + private modernListenGeneration = 0; + // Last dispatched modern stream state; `active: false` on the legacy era. + private modernStreamState: ResourceSubscriptionStreamState = + INACTIVE_SUBSCRIPTION_STREAM_STATE; + // Reconnect-by-re-listen backoff state (#1630): the count of consecutive + // *failed* re-lists (reset to 0 on any successful acknowledgement) and the + // pending re-listen timer. + private modernReconnectAttempts = 0; + private modernReconnectTimer: ReturnType | undefined; // Task ids the user explicitly cancelled. A cancel makes the in-flight // `callToolStream` reject with a generic -32603 error, which the stream's // error path would otherwise report as a *failed* task — flashing "failed" @@ -1524,8 +1564,21 @@ export class InspectorClient extends InspectorClientEventTarget { elicitation.cancel(); } this.pendingElicitations = []; - // Clear resource subscriptions on disconnect + // Clear resource subscriptions on disconnect. Tear down the modern listen + // stream (best-effort — the transport is already going away) and bump the + // generation so any in-flight re-listen/reconnect bails (#1630). this.subscribedResources.clear(); + this.modernListenGeneration++; + this.clearModernReconnectTimer(); + this.modernReconnectAttempts = 0; + const closingSubscription = this.modernSubscription; + this.modernSubscription = null; + closingSubscription?.close().catch(() => {}); + this.modernStreamState = INACTIVE_SUBSCRIPTION_STREAM_STATE; + this.dispatchTypedEvent( + "resourceSubscriptionStreamChange", + INACTIVE_SUBSCRIPTION_STREAM_STATE, + ); this.cancelledTaskIds.clear(); // Abort any in-flight ordinary tool call so its promise settles instead of // hanging past teardown; drop the controller reference either way. @@ -3527,7 +3580,240 @@ export class InspectorClient extends InspectorClientEventTarget { } /** - * Subscribe to a resource to receive update notifications + * The negotiated protocol era once connected (SEP §7.8). Modern (2026-07-28) + * connections manage resource subscriptions through a `subscriptions/listen` + * stream instead of `resources/subscribe`; every other era is legacy. + */ + private isModernEra(): boolean { + return this.protocolEra === "modern"; + } + + /** + * Current state of the modern-era `subscriptions/listen` stream (#1630). + * `active: false` on the legacy era (there is no persistent stream). + */ + getResourceSubscriptionStreamState(): ResourceSubscriptionStreamState { + return this.modernStreamState; + } + + private setModernStreamState(next: ResourceSubscriptionStreamState): void { + this.modernStreamState = next; + this.dispatchTypedEvent("resourceSubscriptionStreamChange", next); + } + + private dispatchSubscriptionsChange(): void { + this.dispatchTypedEvent( + "resourceSubscriptionsChange", + Array.from(this.subscribedResources), + ); + } + + /** + * The `subscriptions/listen` filter for the current modern subscriptions: + * the subscribed URIs, plus the list-change opt-ins the Inspector already + * tracks (config ∩ server capability) so the single stream also carries + * list-change notifications — the spec models one listen stream for every + * opted-in notification type (SEP §7.4). + */ + private buildSubscriptionFilter(): SubscriptionFilter { + const filter: SubscriptionFilter = { + resourceSubscriptions: Array.from(this.subscribedResources), + }; + if ( + this.listChangedNotifications.tools && + this.capabilities?.tools?.listChanged + ) { + filter.toolsListChanged = true; + } + if ( + this.listChangedNotifications.resources && + this.capabilities?.resources?.listChanged + ) { + filter.resourcesListChanged = true; + } + if ( + this.listChangedNotifications.prompts && + this.capabilities?.prompts?.listChanged + ) { + filter.promptsListChanged = true; + } + return filter; + } + + /** + * (Re-)establish the modern `subscriptions/listen` stream to match the current + * `subscribedResources` set (#1630). Because the stream is not resumable, + * every filter change re-lists: the existing stream is closed and a fresh + * `listen()` opened. With no subscribed URIs the stream is left closed. + * + * `modernListenGeneration` guards against races — if a newer refresh starts + * while this one awaits its acknowledgement, the just-opened stream is + * discarded rather than overwriting the newer one. + */ + /** Cancel a pending reconnect re-listen, if any (#1630). */ + private clearModernReconnectTimer(): void { + if (this.modernReconnectTimer !== undefined) { + clearTimeout(this.modernReconnectTimer); + this.modernReconnectTimer = undefined; + } + } + + private async refreshModernSubscription( + fromReconnect = false, + ): Promise { + if (!this.client) return; + // A user-initiated (subscribe/unsubscribe) refresh is a clean slate: clear + // any pending reconnect and reset the backoff run so the next drop starts + // from the base delay. + if (!fromReconnect) { + this.clearModernReconnectTimer(); + this.modernReconnectAttempts = 0; + } + const generation = ++this.modernListenGeneration; + + // Tear down the current stream before opening a replacement (re-listen). + const previous = this.modernSubscription; + this.modernSubscription = null; + if (previous) { + await previous.close().catch(() => {}); + } + + // Nothing subscribed → keep the stream closed. + if (this.subscribedResources.size === 0) { + this.setModernStreamState(INACTIVE_SUBSCRIPTION_STREAM_STATE); + return; + } + + const subscription = await this.client.listen( + this.buildSubscriptionFilter(), + this.getRequestOptions(), + ); + + // A newer refresh superseded us while awaiting the ack — discard this one. + if (generation !== this.modernListenGeneration) { + await subscription.close().catch(() => {}); + return; + } + + this.modernSubscription = subscription; + // A successful acknowledgement ends any reconnect run: the backoff counts + // only *consecutive* failed re-lists, so a stream that recovers and holds + // starts fresh next time (#1630). + this.modernReconnectAttempts = 0; + this.setModernStreamState({ + active: true, + status: "acknowledged", + honoredUris: subscription.honoredFilter.resourceSubscriptions ?? [], + }); + + // Observe termination; an unexpected drop reconnects by re-listing. + void subscription.closed.then((reason) => + this.onModernSubscriptionClosed(subscription, reason, generation), + ); + } + + /** + * Handle termination of a modern listen stream (#1630). `"remote"` is an + * unexpected drop — reconnect by re-listing (no resumability, so the re-listen + * re-establishes the full filter). `"local"` (we closed it) and `"graceful"` + * (server shutdown) are expected and leave the stream ended. + */ + private onModernSubscriptionClosed( + subscription: McpSubscription, + reason: "local" | "graceful" | "remote", + generation: number, + ): void { + // Ignore a superseded stream (a newer refresh already replaced it). + if ( + generation !== this.modernListenGeneration || + this.modernSubscription !== subscription + ) { + return; + } + this.modernSubscription = null; + + const shouldReconnect = + reason === "remote" && + !isTerminalStatus(this.status) && + this.subscribedResources.size > 0; + if (!shouldReconnect) { + // "stream gone but subscriptions remain" renders the same whether we gave + // up after failed reconnects or the server closed it gracefully: keep the + // ended badge while URIs are still subscribed. (On a terminal-status drop + // the disconnect reset clears the set and forces the inactive state.) + this.setModernStreamState({ + active: this.subscribedResources.size > 0, + status: "ended", + honoredUris: [], + }); + return; + } + + // A drop of an established stream is not itself a failure — schedule a + // re-listen at the current backoff (0 after a healthy stream, so the base + // delay). The counter only advances when a re-listen actually fails. + this.scheduleModernReconnect(); + } + + /** + * Schedule a reconnect re-listen after the current backoff delay (#1630). + * `modernReconnectAttempts` reflects the number of *consecutive failed* + * re-lists (reset to 0 on any successful acknowledgement), so the delay grows + * only while re-listing keeps failing. + */ + private scheduleModernReconnect(): void { + this.setModernStreamState({ + active: true, + status: "reconnecting", + honoredUris: [], + }); + const delay = Math.min( + MODERN_RECONNECT_BASE_MS * 2 ** this.modernReconnectAttempts, + MODERN_RECONNECT_MAX_MS, + ); + this.clearModernReconnectTimer(); + this.modernReconnectTimer = setTimeout(() => { + this.modernReconnectTimer = undefined; + // Disconnect/unsubscribe may have raced the timer — bail if the reconnect + // is no longer wanted. + if (isTerminalStatus(this.status) || this.subscribedResources.size === 0) { + return; + } + this.refreshModernSubscription(true).catch(() => + this.onModernReconnectFailed(), + ); + }, delay); + } + + /** + * A reconnect re-listen failed (#1630). Count it and either retry with a + * longer backoff or, past the consecutive-failure cap, give up and mark the + * stream ended (re-subscribing resets the run and tries again). + */ + private onModernReconnectFailed(): void { + this.modernReconnectAttempts += 1; + if ( + this.modernReconnectAttempts > MODERN_RECONNECT_MAX_ATTEMPTS || + isTerminalStatus(this.status) || + this.subscribedResources.size === 0 + ) { + this.setModernStreamState({ + active: this.subscribedResources.size > 0, + status: "ended", + honoredUris: [], + }); + return; + } + this.scheduleModernReconnect(); + } + + /** + * Subscribe to a resource to receive update notifications. + * + * Legacy era: sends `resources/subscribe`. Modern era (2026-07-28): adds the + * URI to the `subscriptions/listen` filter and re-lists (#1630). In both eras + * `notifications/resources/updated` is delivered through the same handler. + * * @param uri - The URI of the resource to subscribe to * @throws Error if client is not connected or server doesn't support subscriptions */ @@ -3539,12 +3825,38 @@ export class InspectorClient extends InspectorClientEventTarget { throw new Error("Server does not support resource subscriptions"); } try { + if (this.isModernEra()) { + // Already subscribed → the filter is unchanged, so skip the re-listen + // (which would needlessly tear down and reopen the server stream). + if (this.subscribedResources.has(uri)) return; + this.subscribedResources.add(uri); + // Reflect the subscription optimistically so the UI responds to the + // click immediately, and show the stream as "connecting" until the + // `listen()` acknowledgement lands (which can be a visible round-trip on + // the modern era, unlike the single-shot legacy `resources/subscribe`). + this.dispatchSubscriptionsChange(); + this.setModernStreamState({ + active: true, + status: "connecting", + honoredUris: this.modernStreamState.honoredUris, + }); + try { + await this.refreshModernSubscription(); + } catch (error) { + // Roll back the optimistic add + stream state so both stay consistent + // with the (unchanged) server filter. + this.subscribedResources.delete(uri); + this.dispatchSubscriptionsChange(); + if (this.subscribedResources.size === 0) { + this.setModernStreamState(INACTIVE_SUBSCRIPTION_STREAM_STATE); + } + throw error; + } + return; + } await this.client.subscribeResource({ uri }, this.getRequestOptions()); this.subscribedResources.add(uri); - this.dispatchTypedEvent( - "resourceSubscriptionsChange", - Array.from(this.subscribedResources), - ); + this.dispatchSubscriptionsChange(); } catch (error) { throw new Error( `Failed to subscribe to resource: ${error instanceof Error ? error.message : String(error)}`, @@ -3553,7 +3865,12 @@ export class InspectorClient extends InspectorClientEventTarget { } /** - * Unsubscribe from a resource + * Unsubscribe from a resource. + * + * Legacy era: sends `resources/unsubscribe`. Modern era: drops the URI from + * the `subscriptions/listen` filter and re-lists (closing the stream once the + * last URI is removed) (#1630). + * * @param uri - The URI of the resource to unsubscribe from * @throws Error if client is not connected */ @@ -3562,12 +3879,21 @@ export class InspectorClient extends InspectorClientEventTarget { throw new Error("Client is not connected"); } try { - await this.client.unsubscribeResource({ uri }, this.getRequestOptions()); - this.subscribedResources.delete(uri); - this.dispatchTypedEvent( - "resourceSubscriptionsChange", - Array.from(this.subscribedResources), - ); + if (this.isModernEra()) { + // Not subscribed → the filter is unchanged, so skip the re-listen. + if (!this.subscribedResources.delete(uri)) return; + // The removal is the user's intent; keep it even if the re-listen fails + // (the stale URI simply lingers in the server's honored filter). + this.dispatchSubscriptionsChange(); + await this.refreshModernSubscription(); + } else { + await this.client.unsubscribeResource( + { uri }, + this.getRequestOptions(), + ); + this.subscribedResources.delete(uri); + this.dispatchSubscriptionsChange(); + } } catch (error) { throw new Error( `Failed to unsubscribe from resource: ${error instanceof Error ? error.message : String(error)}`, diff --git a/core/mcp/inspectorClientEventTarget.ts b/core/mcp/inspectorClientEventTarget.ts index 23e84558..59d9b96b 100644 --- a/core/mcp/inspectorClientEventTarget.ts +++ b/core/mcp/inspectorClientEventTarget.ts @@ -23,6 +23,7 @@ import type { PromptGetInvocation, ResourceReadInvocation, ResourceTemplateReadInvocation, + ResourceSubscriptionStreamState, } from "./types.js"; import type { Tool, @@ -114,6 +115,13 @@ export interface InspectorClientEventMap { newPendingElicitation: ElicitationCreateMessage; rootsChange: Root[]; resourceSubscriptionsChange: string[]; + /** + * Fired when the modern-era `subscriptions/listen` stream that backs resource + * subscriptions changes lifecycle state (#1630): opened+acknowledged, dropped + * and reconnecting, or ended. Legacy connections never dispatch an `active` + * state (they have no persistent stream). + */ + resourceSubscriptionStreamChange: ResourceSubscriptionStreamState; // Task events /** Fired only from server notification notifications/tasks/status. */ taskStatusChange: { taskId: string; task: Task }; diff --git a/core/mcp/inspectorClientProtocol.ts b/core/mcp/inspectorClientProtocol.ts index 98ea0ba0..cf8d187e 100644 --- a/core/mcp/inspectorClientProtocol.ts +++ b/core/mcp/inspectorClientProtocol.ts @@ -19,6 +19,7 @@ import type { ResourceTemplateReadInvocation, PromptGetInvocation, ToolCallInvocation, + ResourceSubscriptionStreamState, } from "./types.js"; import type { CacheMode, @@ -60,6 +61,7 @@ export interface InspectorClientProtocol extends InspectorClientEventTarget { getInstructions(): string | undefined; getProtocolVersion(): string | undefined; getProtocolEra(): ProtocolEra | undefined; + getResourceSubscriptionStreamState(): ResourceSubscriptionStreamState; getDiscoverResult(): DiscoverResult | undefined; getServerSettings(): InspectorServerSettings | undefined; setServerSettings(settings: InspectorServerSettings): void; diff --git a/core/mcp/remote/node/server.ts b/core/mcp/remote/node/server.ts index fc6600e7..0cec99ca 100644 --- a/core/mcp/remote/node/server.ts +++ b/core/mcp/remote/node/server.ts @@ -335,7 +335,8 @@ function forwardLogEvent( } } -function requestIdForSendWait( +// Exported for unit coverage of the `subscriptions/listen` exemption (#1630). +export function requestIdForSendWait( message: JSONRPCMessage, ): string | number | undefined { if ( @@ -344,6 +345,17 @@ function requestIdForSendWait( message.id !== null && message.id !== undefined ) { + // `subscriptions/listen` (modern era, #1630) is a long-lived stream request: + // it never produces a JSON-RPC response — it's answered by a + // `notifications/subscriptions/acknowledged` and, only on graceful close, an + // empty result. Waiting for a response would block `/api/mcp/send` for the + // full timeout, delaying the client's `listen()` (which awaits `send()`) and + // then tearing the stream down (`closed`) when the wait finally rejects, + // which spuriously drives the reconnect loop. Don't wait: the ack and all + // stream notifications reach the client over the SSE event channel. + if (message.method === "subscriptions/listen") { + return undefined; + } return message.id; } return undefined; diff --git a/core/mcp/remote/remoteClientTransport.ts b/core/mcp/remote/remoteClientTransport.ts index 2a80a3f9..9f3ac419 100644 --- a/core/mcp/remote/remoteClientTransport.ts +++ b/core/mcp/remote/remoteClientTransport.ts @@ -96,6 +96,15 @@ function requestIdForMessage( message.id !== null && message.id !== undefined ) { + // `subscriptions/listen` (modern era, #1630) is a long-lived stream request + // with no JSON-RPC response — it's answered by a + // `notifications/subscriptions/acknowledged` (delivered over the SSE event + // channel) and, only on graceful close, an empty result. Waiting on a + // response here would time out `send()` and, via the SDK's `listen()`, + // spuriously drive the stream's `closed`/reconnect. Don't wait. + if (message.method === "subscriptions/listen") { + return undefined; + } return message.id; } return undefined; diff --git a/core/mcp/state/resourceSubscriptionsState.ts b/core/mcp/state/resourceSubscriptionsState.ts index a9f51b5d..ab57e421 100644 --- a/core/mcp/state/resourceSubscriptionsState.ts +++ b/core/mcp/state/resourceSubscriptionsState.ts @@ -21,8 +21,11 @@ import type { ManagedResourcesState, ManagedResourcesStateEventMap, } from "./managedResourcesState.js"; -import type { InspectorResourceSubscription } from "../types.js"; -import { isTerminalStatus } from "../types.js"; +import type { + InspectorResourceSubscription, + ResourceSubscriptionStreamState, +} from "../types.js"; +import { isTerminalStatus, INACTIVE_SUBSCRIPTION_STREAM_STATE } from "../types.js"; import type { Resource } from "@modelcontextprotocol/client"; import { TypedEventTarget, @@ -31,6 +34,12 @@ import { export interface ResourceSubscriptionsStateEventMap { subscriptionsChange: InspectorResourceSubscription[]; + /** + * Modern-era (2026-07-28) `subscriptions/listen` stream lifecycle (#1630). + * Mirrors the client's `resourceSubscriptionStreamChange`; `active: false` on + * the legacy era. + */ + streamStateChange: ResourceSubscriptionStreamState; } /** @@ -42,6 +51,8 @@ export class ResourceSubscriptionsState extends TypedEventTarget = new Map(); private subscriptions: InspectorResourceSubscription[] = []; + private streamState: ResourceSubscriptionStreamState = + INACTIVE_SUBSCRIPTION_STREAM_STATE; private client: InspectorClientProtocol | null = null; private resourcesState: ManagedResourcesState | null = null; private unsubscribe: (() => void) | null = null; @@ -53,6 +64,17 @@ export class ResourceSubscriptionsState extends TypedEventTarget, + ): void => { + this.streamState = event.detail; + this.dispatchTypedEvent("streamStateChange", this.streamState); + }; const onSubscriptionsChange = ( event: TypedEventGeneric< @@ -87,7 +109,9 @@ export class ResourceSubscriptionsState extends TypedEventTarget [r.uri, r])); @@ -146,5 +186,6 @@ export class ResourceSubscriptionsState extends TypedEventTarget(state?.getSubscriptions() ?? []); + const [streamState, setStreamState] = + useState( + state?.getStreamState() ?? INACTIVE_SUBSCRIPTION_STREAM_STATE, + ); useEffect(() => { if (!state) { setSubscriptions([]); + setStreamState(INACTIVE_SUBSCRIPTION_STREAM_STATE); return; } setSubscriptions(state.getSubscriptions()); + setStreamState(state.getStreamState()); const onSubscriptionsChange = ( event: TypedEventGeneric< ResourceSubscriptionsStateEventMap, @@ -36,11 +53,21 @@ export function useResourceSubscriptions( ) => { setSubscriptions(event.detail); }; + const onStreamStateChange = ( + event: TypedEventGeneric< + ResourceSubscriptionsStateEventMap, + "streamStateChange" + >, + ) => { + setStreamState(event.detail); + }; state.addEventListener("subscriptionsChange", onSubscriptionsChange); + state.addEventListener("streamStateChange", onStreamStateChange); return () => { state.removeEventListener("subscriptionsChange", onSubscriptionsChange); + state.removeEventListener("streamStateChange", onStreamStateChange); }; }, [state]); - return { subscriptions }; + return { subscriptions, streamState }; } diff --git a/pr-screenshots/README.md b/pr-screenshots/README.md new file mode 100644 index 00000000..fcc923e8 --- /dev/null +++ b/pr-screenshots/README.md @@ -0,0 +1,61 @@ +# Resource subscriptions era fork (#1630) — proof screenshots + +End-to-end verification of the era fork against two real test servers +(`test-servers/configs/subscriptions-modern-http.json` on port 3220 and +`subscriptions-legacy-http.json` on 3221), driven in a real browser. + +## Modern era (2026-07-28) + +![Modern header badge](subscriptions-modern-header-badge.png) + +**`subscriptions-modern-header-badge.png`** — on the modern era the Subscriptions +section shows a single **stream-status badge in its accordion header** (next to the +count, so it stays visible while the section is collapsed): `● Listening` when the +`subscriptions/listen` stream is acknowledged, `● Reconnecting…` while it re-lists +after a drop, `● Stream ended` on graceful close — each explained in a tooltip. +Legacy connections show no badge. + +![Modern listen + acknowledged](subscriptions-modern-listen-acknowledged.png) + +**`subscriptions-modern-listen-acknowledged.png`** — subscribing on a +**Modern**-negotiated connection sends **`subscriptions/listen`** (long-lived → +`PENDING`) and the server answers with **`notifications/subscriptions/acknowledged`**. +No `resources/subscribe` is sent — the defining era-fork behavior. Two other +details: the connection era is shown once in the panel header (`Messages · MODERN`), +not per entry; and the `sub ⧉ listen:0` subscription-id tag rides the notification's +top line (beside the direction) so the method badge below gets the full column width +instead of truncating against the pin control. + +## Legacy era (contrast) + +![Legacy resources/subscribe](subscriptions-legacy-resources-subscribe.png) + +**`subscriptions-legacy-resources-subscribe.png`** — the same subscribe on a +**Legacy** connection sends **`resources/subscribe`** (Protocol view, LEGACY) and the +Subscriptions section shows **no stream badge and no header dot** (there is no +persistent stream on the legacy era). Legacy behavior is unchanged. + +![Legacy live update](subscriptions-legacy-live-update.png) + +**`subscriptions-legacy-live-update.png`** — calling the `update_resource` tool emits +**`notifications/resources/updated`** (server → client, Protocol view), and the +subscribed `resource_1` tile stamps its **last-updated time** (`2:53:17 PM`) — the +full subscribe → update → notify round-trip on the legacy era. + +## Notes + +- Modern subscribe in the browser is now prompt (`Connecting…` → `Listening`) and + stable: the web backend's `/api/mcp/send` and the browser remote transport used + to hold the `subscriptions/listen` request waiting for a JSON-RPC response that a + long-lived stream never sends, blocking `listen()` ~60s and then spuriously + driving the reconnect loop. Both sides now exempt `subscriptions/listen` from the + response-wait (its ack + notifications ride the SSE event channel), so the badge + no longer oscillates. (Some of the older screenshots here were captured before + that fix and show the transient `Reconnecting…`/`RECONNECTING…` state.) +- A tool-triggered `resources/updated` does **not** reach the modern + `subscriptions/listen` stream on the SDK's stateless modern leg (a tool call and + the listen stream are separate connections; `server.notification()` rides the + tool call's connection). This is an SDK server-side gap — the same class as the + logging showcase's stateless-notification caveat — independent of this PR's + client-side work. Hence the live-update proof is shown on the legacy era, where + the round-trip completes. diff --git a/pr-screenshots/subscriptions-legacy-live-update.png b/pr-screenshots/subscriptions-legacy-live-update.png new file mode 100644 index 0000000000000000000000000000000000000000..83e31faf1f8153440c7b76a88eb315e9638f8c97 GIT binary patch literal 113750 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�IW;D8*ihk|KB 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≫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

EPZlP6_%nQX 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 literal 0 HcmV?d00001 diff --git a/pr-screenshots/subscriptions-legacy-resources-subscribe.png b/pr-screenshots/subscriptions-legacy-resources-subscribe.png new file mode 100644 index 0000000000000000000000000000000000000000..e687a5cef5a66054926806ec86121e8efc9c4878 GIT binary patch literal 105011 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

?7 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 literal 0 HcmV?d00001 diff --git a/pr-screenshots/subscriptions-modern-header-badge.png b/pr-screenshots/subscriptions-modern-header-badge.png new file mode 100644 index 0000000000000000000000000000000000000000..737a6b5c4d87c5396633bc1b5c53149d45e8a3c3 GIT binary patch literal 50257 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 a$f0wdQ8o5fES>wSh?G;g_3q|<-+uvv5NW*t literal 0 HcmV?d00001 diff --git a/pr-screenshots/subscriptions-modern-listen-acknowledged.png b/pr-screenshots/subscriptions-modern-listen-acknowledged.png new file mode 100644 index 0000000000000000000000000000000000000000..3bffe69d7983c8685cddcb17d83bc7fd6510e845 GIT binary patch literal 103705 zcmcG0Wmr^U*Yzk0ii8p(4bm;$NC?Q#-5^M(bR&p>bPXWgUD72jA=1szCEY{UcjNOu z-~ac!uJ8PsYtEc=?sK2}?7jBdYfX@XoFqCb0V)InL6>^}P6+~eoDP8?eSPu}d^5%J zz#js64v~5%qT-soGl!ysZAyxA;3wQZPo^v!SD`u^>`~TmR;*<@2j|hH6U4ogse%-}okZyH#^%Jl+dN90*#;(j9SG#=hY`hjUS6$VT2q*#hR6F$A9m~vZkT-(&oDoNl*tmxxAj9 zwscAnLPZtkCZK1igo-ZBhT-W5j{dH+>E~x3_P0N2ogQ&;ke=-ahCv%|xDr#}D-yu0 zn9+ojq455JB(4`R#w`mSFBK} zKCuqq`VjGs%ekK3UL|$aCE?)2!eAmAIL`(>2{=USDGCwH@CT0{2~~W~kZ`3*zsoJQnd$qC6H#Orv`%|8ZqcyffOmYw!aD~|Uln$% zl73ui4UJbNOeKW~uSFv*clU;fh=`n=oCdyzHWZ(uCn=$EB=G5;Mw$b0(Tq1tOtL{` z>3M-962~uaurjip5<&9JZAg76BAtY^ucj|)anp2i5%t~0qE}T?l9$p z;7>NzpFaI)ZWc-#j2Flu^HGZCw49Jh=7}nL-W5*V_^}%U4=;XwFb%AMiv4+{!ENrn z$H@Nqg|w57PCFAhDT!K-&5drG3?$9WT)jW8^0}Ce|L`R|dzXYFXVh^X8^ z`A|_=NyusOu4R9Ru5$yS&F*n(Woc?n3{W}kr=k16SJ2nMPH^Gkicp>$y zdT(D}Z%?0$oYWFjQcDZ&hk`jfH)lEayoB;*B8|^!>-=y!y9OY;6pEEXn4u$(8Vlw%qR@o|8xd}>qfb&kjlyxNj)ge&_j zWKBfp_eHMHisdM}6bjJ}Q7~I`0aQ~jkI!;~QC7C!{bY-d&Z~aq>}-Ew^rM1;g1vo3 zVj=-LKMxP1-cO!4Z$6FXE8Y+L?Vx^hdDR<2-k)zhwpJAc83m$?Xld)B&^%^;nwp!> zXXrjF^(5r^wAd3xF@12nKDbG9zTa}E*WgG8qIu4~$xxB5ZCUWca3e*enRlwSa=1z4 zrzMGre0DhVHVR@Xx5Fb2Ot9EW1A>{K=6)4Vb+Sj% zOVI|2=)N^K+sr!+jVYK$WbRUvXfNAp9wLPsW)l{B8*dm?ne->l)L1hZ8cQ9$CT{CX z6-+{c_#Dx{eyydxzMvOpWnDP@7NZwMU0ody508|T6r=)Zn!MGJ{b1IaSQ90ch?F9N zg^_ANLACMM;L3+}vmecbr3;>|H!WpQDcdX^I**&v6w3AwyAEKbUS7H*U-H>zOO%(B zaPP;rNfF`H!DQ={(TpAB!rrm+|6p`(Aors0u66wS0w15(^Zb*ksj05++~vu(?flOK zY?Mb75}{_Zb%*0c>YAKVzhfEHDMw9=j2Ja5vSpLFkdV=Mye_K{R^S0GR2WNRW5*P# z7GdDC{TdvUXA3@!nZhzp+gwlkjPdMQR(qa&T8-Iorh1tk3MPr8gF}&82|SrM6T@U6 z?XCP8yXipolI3J6r!^dg!H~l1kgMO~U7}U3Rrkq2NeN5437_3$NObx&yvBMaLoBd6 zg4EQ+1cR6lHWB%EP@=P|OYZxdwzjqmXe@n`$C=QlMIWQiT)7k|%R$|%e&4?>u7`&1 zVd8Fz^}jkhZw@*zQ}|uHFOJrJ7<6n+lt`CxP*VrgoPKBhNWf+F-tuax14YU!L!r)o z4GO>IC4u{+%H6%#){|K##O3cqAh4p^-Zlmo?SwP2FwJF2tAUeBSq^VF>*edg-)R0pg!rLivZCUz*&u3lTwKNqi0lW>YQd z6x5W|H*D)?=^utUy~xQ8t}s&1t(STqORJ>`IMA`Phm30?uJrMkJ^Hi}>-l!H&{{IL8T_$9y7*1Ib-#QDLJ*l)DSVofoW_ZxxD9%p<0*BVF=828mr0r1W}rJr5b zZ5PCP_w5qS(_Mkq%R{tlO}pYs(M9Zz;l#w|DI^;mlA#0S1&Dcg{ra+E=J06*WE2VuA$vT#vRGGeH-gXFtgK(aikD> zDw==O;&tUr&uhQ>r23fGj=2>Imf*XXAD4~JyU~4t1b520G8e~#Z_U4J{qaLaj}C=5 zdAJA*LmI zdGq{UV`?$)zM`U`xjXD8ji#D!VR2t6Xe%o%9Z;*#YjUr)7(Y5Y%adp}3f%cN)#$Qs zhBV@hwTn5d2P-RM**^E{PcxB=u(!AO|C#@jR-4yp3kO~2rz@ z`{<~$re;D7vbB-Bt`)q<5K$W-8tzoIK5KFGhuLSU z7O4$0G&rmu3-Og4WCp~X1` zUh3KWn$YQPDQ1@+vw>%t+j_*O{aG&=7Iw@`jZI=?q+Y~gR!tjEU33%36z#>L5%cjmP&rgdZF@%f67!@R1@ z=6lAceX(7b>&>@GEYvY~7AQD4uE(bTRBenj?)Ky`aAT12YtIcdn8#dtlRo6Kp5Ygu zh;icA>Y+7<-4Y2o=gJQbXlW%P+y`~*_^dvWmcCPj->&|~4#qX(5fVzpcr`@5z0lGU z5P*D>&TTg2?Q3%jl->>r8Oc?a&t6d_YjJ|(ftkM!_fYV zn+9_Wi;;byo7d8DSU5O{%M;5>PMjx?SoD6TUwd7jAHu%>*sI$3_VDIWV`Jl}mAS1i zvPK%2W9x_YffSB73~!xg&jhUJiEnRaM=`0^t{kU)9^wU`o8K99hZ7S)d>DBymPCBB zu1OfJ-h5+t8hz#Wej!QhQUIg0*k*X^gRS&4_a?Jyqm1YQYBL`-DJ*Wp=5RUM-pA;o z_|ZXsy?x5L^uL9gT`mbPT&OR3BbTB2he#Ng1}1a<71x;?n*pmjn5A`Ql3#NOt4M{J z?m7Z7J>1;JOSI!Ljw(@$?FNG6S$jCiL_D}0-v=V+^U7NP1uw>rN?uypj3#`oN8)IX zkU;FTMppaP_i;96mX@P^*x1-vSy{?TN|cp3DTJsBse&F7{LEFR9cn%V7ox1cMa?IJ zb2H012JKe56#En#ovq{YPurL`|{~r&jVrn(a~{D4qNz1 z(%Igu*Si;8<=E?in7i9%w($uG)eeJE7`s}I`|#B9vEkun*J;0p7^jZHX*Qg?#8k%_ zjEjGFQ3M-ZRvG9=)b~neFt;ZP3NkX}HhqGEhGA)vbhO{x3!UwYn+?aiB8NVG%%Vq( zHA&s*&E3rfX4&^XvuNNMYB{w|ik}zcG+bGhPi~%SFpg<%YN&|zLXqE@|6CQGWT|9t zFOp^7|5fP~lWf>uS;8Y%fm*Ers&TQGyB~h&TexTE3$n4riB8J$%tiT zW6P{oQc>BNt~8w=C3yhpElJPLHw?X`PuqV&h%Y|f_I21VCuyU2`ueh@%yCEoo{g7% zx8T5WR666*CTE@zYgbikY}vC{E=pyL{|VG=Bg=ZE{F1f`(^g@IdYPhcj~V9{f3+;n z-pO~V`LscEZ`O&Sa>)rC$&h3i~9!zjF9vtu$wY6GE%ZF2q<97)qm6Y|P0 zk=u0$Mw+sUiH;T!6x{rdRU|B#U=|oka6F={2o0(g%qofaon(RsWo4DDT_7GO zNeQRZ{*8NtcjP9)c+y}<$S z(02s=vfnU1+&Wep;wrCggRA2*f0XhOc zA7puNZy?BpTH{Yb^^|#hCcwU%o15DcC0RpX<0=4lrO)dSvZ9A8XAon+IWrQi;Z;$o z8II3>l5y}7my8S#)9-I-b{hb#(d1e8uGsxSGaZmo@O%|n&6WlU!!sXuW{nnPmJ1~Xsd z2w%NA|JzR}=NW`9D~&YQ=o0U(82v|{wj>feOHgj_uJ*Z!Sk;33| zJmE($ZY?7lN_&)UMkerDi7h7Lfv=Z`6DM17^u7%8$^PN-lmUHVucUnP6#&u)N{wmK zPz!<^K3eHHG8u7A4x+S3jh=iRcGlv|7RNT3v#yi*3vZ2z>wTm^c{?ftFzLgF#c3?P z2u)t&Wyep;*LS)g6(1codtHs>hY@m*WMEiZ?}C?nWS@uXB)P5wqjxW7T_zB9DrLYt zH9AC<_t5{%;}SIDas_quyif{t-V(Ikg!gKH+x?$~hljV^oD$Lq#kCH+${{@isJHS4 zRI~{PeyYCKlca^Q!j-2dcgkqa*55XwQS53lM&@K-#*Ha2Wet20%5ioIJM9&(e$y7l z?VnIk6&*~Ig{}NvSM6cNI z2?=(~49ZiZo-41MwH~>h?%)%q&t>`eKz>`WM_&y?k*DM|L|809ITkJbk>}9vJvt+w($i&11caoNo$(EIsOvAy!F< z+Z6sfJbFd6CYQkGf66%hBO`-c{LO4U4gw0|RwymCkbACORs(fcT3Lj$0?tip@1Nhw z0wPE!TVvUu#gny@;`Tzk@3v0}ZBf~%Lvd4*!0T67P+(wUA>b-J_ia0cIvw5)7W zi|csGRfNa&kT1jIzpAnuGq>Y}wjg5`uTDQxOtv<$fJH@V4$(TZiOQX}#AlkB<-3?o ze!10c^1d1xW}j=U!FzH(Tbt2=>G;GKdm$iH^f>MFZNh8U%bZWn&bbSXURS4U{Hpw{ zy%Zbof4{xEKEB#-nJiS@UhWJDdC8QS#wF*ON@o0;(=vEo7F8sBki+x(+)jjHWp(vk z0V+U<?AAx9I4}?=$4X4 z5sD@GAaLW?%QBWTdgyrXEn2vcAb)SGu1a=!>zAX)sGI;%X-X9265`0*rzZ?MK-zo{ zul)h}Vu%6vFI3LMKvymmY2?h32#em+S0>o~6pGIt5FYuXgQd!$BZz+`UCJ!)>#5a5 znf{=~h!s^H?htDlz*Odot-dgVAtEIurMfZ^eg?4svkto&u(X2NV3a>v}Y^=R1tF)jXQ#$k|n69sJgppTxWlFCtf}- zf5Tl_UNigCOCJ}>izaZZ_=iKFTJ4^IfWsbCMn(q;rSD%Fi6y*{Bf-V3v_GL{Njs}j zvpak`=B?JVkEq2m&>OFcD_RNH4YZkWzN33{p4gq@g%UBk4Z@yM53R8=RWFN~-y=^f z|2fI5>ac=fqa>hMVpqYq$lj_0T78^i+2hPh5&PQ z&$X1jRZS<&+MX;MbOg>kE@>Pgd zHaVfq4FI84IPpUy zdXA0=YgV=Q-HB679-C8m#KKv+61L?!#{j17&Fif2*<7nlFSmSty8m&bU?4A!A}PtIP0ax<#sLlW@5AAbeg*TIDTkv zK2x~aAj|LJv`=|qV)=KTjDq5LY+9OTP-pp_>Bu2}m35oMFcA*!o%N-Kxp{s;!EL<> zyKGTMIwjsrx zI4qx)g8Hor+SS!{-zFFst-`S$f;7@+JMY3x2UBw{8N0bTIR(8gIf$(mf9cvie*CyU zft`kdp$NRQFv+0^;t=vjhS9hRYHGPFs4LwOc?DAAJ4hB>HMTqxVucg<84(+MNJ$PxF8U0V%J4evv zW*H=d@(7d9!^x{0J}tFBt~sho66I$AyjRZ6Q@L5eSG)2GD+#Br)N;x16GV-SRsoYO zX9pqXdWwdYy+Q+CJ@<T9439Q_>eod&bB8bCIZ#`u=T$# zZ*NOm${ibh+}+vPNPoT?sF)(Er=rJ!+bJlTaWIl24REQHtZWW($@@Seqod%oLSE)^w>VAxAtglyWP%KhoI)z~f4_oGS=yQm<|E?l++ZrnX{7c0E zlny^bupU&M?}dCPCMEzgk|n4}kgg6b7zMmE<+cRM(1w$-k%|=g69iIA^pCK_K zwN$QjBM#oR^r9;7dsbc%gVclN6>Qq!9w*ngbacFY)NyJQ3lOUK^GCxB<72cVYnVYn zQivHCgWr2;Y0QXk97B`JY6EjmSj-uM@& z`aids);5umkw<2}db`sGL}Cz|q4;>agNm}M>elO7W@hGwX}ouo!%4h|^yj-wrnB87cc7^*uZCrDV6< zhR;_=mcRZ_P=nHI1JoiW-f3gwRYHXQoj`xgqCxp8S9&h)i)ESdyr!p~6trvBz3!@nh1Zr6rZL@Twn`syW?CkA$^Don0tBBCF!FsN*aj zn@I*c*O(DgK0smOQ*SXIF;fo>e>RL-c}qt-mp&dhzn`(Dl>QtGOZ3VhT8NS7kV)5k zVB`?BKiIjRa`feGrhSIL(l@e%x1A_e8ITI*OrB)GJk|x#QX$Si;EQ(i5S)XOJ4M}GgV>CDvOvME!wk-eXMq z(qloT2g02u3Vi*G(W)e(=;mt%Szcu_g;ftRCh!BZF-v-j#R4&0_GSz8ni_I*sqgg^ z;u0lih)@oUqxVu$;#FX%k<#Y6nXfl}{O0K5?zIF9pMs!nF)1l2QBhIJ$vWct>bk`7 zAFjLe(%*=Si-Rum0A?o@JvdW#6?5W;v+$e;!Msz`_hJi(I1LR=_sU^DJ}EA7hc9eu ziib~FoDhZPpVWe(L|WzBs$4nGy<(yFZR*dTZ-7GJ=$)Qk>fm}_wh{8`GT>u5lbB4~wd~o`nNZ1%aR?y+JoMN5K_MrWo*Ep!7U>i}w#l;N` zE2O1|Ete-8vG7qdb1~~lNokTje?PGJ`~X)4_81IMI7hwU3=5oy^3g+Ys;4|gPdFFX z*48#lG7O-+*FulX@{2$)qGfnWKi>44jlD8DI_BdF7VY7SJVH-r7Y(jBYf^AILqBBoO5XI=lhwB=!1}e~IclXwuwGS9A9lA2YBa<65@_Uq( z6_>#Uh0z{>$JhEwBI+An8_Qi{OO+wuC^!JTQ>^&8P35nC0JRHq85r{o8s3 z{t0RBKa(9l|F2l+fB9o&*W0dp;m*G;(%7EWPU_!+5gwjxxO=T0qMe2V{9S5aQPpDc)xe=<>g3`MscFHsMMd+lnSVOD{dXqMp$ z)^d!}S4~k2h>>qag|N1Ae~*H^s%8)a!+#`O!d%}HfAjJZji4t`bl(m#OANdqCcInv z_^l?lAuP6_G_E1@HJk-fLC#9Y$;kG%q_!osG}l=5W2wyIvwLY8#7K-hY$cgU6IF0^ zwRy=CSyMH+lIQj7k2gXAWA^2&W0QX&!nyfHbVWr8QyPf^9=q$igbH(A$qZiq89@5a zKQlZgK@#DwXp&Zc)j<j1i4poAR@}q+w6=&KJ;jOPYB0O=&!}{M$2`3pi#>f< z)YLiIIi^M?%Wz)Eb48U^x~Jz`7WBcW0;QCT9>@^-SggC3OtnY3gwxa0M@RO(P|pYY zQQa|3;m7{%R+r_Oq{TZsL~ia>Jv>KGo}fDXV3%xopzuJU%kCl|&$n65{H$Bi`GKU4 zrxMhnp}90SD5Er5I0^}}SXYJU`}zyklh1=|>>HO$aAtiVhy;n1{p}sn8*IgjYusEI z%tlj53(If`yQRv@&doOI39&o)jB`UtnaxqS()vKy|AV;=4#7)fYxCaNTsBl5tY{@S zfmAqZ~`5>rThEIz`B0PG?=}g@EU{rE4WkWLm_o? z1sSmx{U9kij?hpskhC@BYYn|qAJEf?c@f{q8|ct6gzPKu&vT|6);Mls{mU?&9)JAUS>&IRsW(- z8{)&#MU?oG!+b0{`-YYMrc%Z$by6V@#Du3CFKCU5AN=K%=r&|j*$No31KecRu_^I5)%c=c@5wF z{5mk-UVj2*=^lfdn;U38*i)GvE_Z@Pn4+Shc(MLah}Y@$N#?@c(baP@y5GIMTICii zDIO813EC18e^Kt_b)KBjb@pTo(yr4hOMg>nZs+aKH_Rh?@?RTEb$+_-ZR#GJ zw}&W%|3`u8gZi45wr6ydT|hv9f`Wpad}*vexj&J!5eNv?`?IBDs6iF|7b<6Hn5jT3 zBPaK_xxZUpgcRvvt<^$&-06i{2wj1>(EfEcMZ{0q+k4to-nUIB2r4U`mE*A1TCJVB z^n%qoaq=qTqq48?Vf*-%&gOgR!S~XCRw3y`{}YyQdj|nYw$u^W+A567?#PCD zj&SA__*j{C$m+LhMZCMrvVEj22f?0e%)${!S-$R4qh4Nc`kR|1^o2q&}3 zQ83a_BfhON94)wBj5*p7u@3)46WC^qvSrNwm-1 z{M+vp(WSddkNn>W9C#9AC#7eV4A(UmW%y#qN>?`Q9KLzOlNsDB7lX{4NMJz(fzkW} zUJwX9HK3J&ib%akEi52Sz|DTC-5-xd4^RVt{`|?y%j33&JD%;$0cJon<5Ooa?#<;% zmQTmzWW22Og}9NCQS-Q&m4=2!llut<5l?!0x-chb(0Je7-h82tFP<0V!^bDsfqPI2 z35hh!9{&z;N^%Ye@aN~90;JqslXo}Doe!YKxVQjR)?NUr1==Q~P=WB1{wX z0LYtfs~M=6K=+ba@2BhO&NRZYCz2dT28g>>LBEE8fB>D4>nG4niHv)Cdfr~FlLo)7 zv6^PHU+t-@<0;gswVBgxbY9a=U{LfF`n-DZKwAC!W-zs*1LZ6Vme#VGkyF6>c>u>( zI1-l3X18UVDzAUKH>@eu`qmNAx08TfsF|o--C)C9yDyYUwz9Nhis0blnxEXK@TcII ztuvToUoSH;GPz~5P7bR!*3!BJ3Z=BhPbHwAn7KwzKaj?rV8X1KS+*ZYBd>2^X(^W` zpk+V*ZhCZL2f=2aBt?ghhUHykmWVb`n zv20Qfv*#Z0ya-ylI+uODQcYZyT_CIjS_PoW%*_KqP`2xzdH7XGgK>O?;em-(3$5 zp86B3O!tlPyrF$3FCRF9UYM0l`N_Eu$jM*f;!?OnANZ&=h?wCBhLZ~R3F}8(m9DO> z6*I|x-dLQkw0s7*W~%m%*O>*^2L+ZM82ag-O>9D1nWg z^x^i-BAJ%p>bkus(UVza@vw?xJj-yI7eXul2^nQ_D=z%MT)_SGsL+n)%4+}kAhP7t z*Ds#OF5q^QZ82WRaj+4!arqcTPr0$Z*ujAT=AQ(DIedd@Z_Cu>VR(-oJ^CK9rhT!i zJ=`Qtb*VMz`|$9ttu2cd@0FOy$o!0q0cPEd5|NIJQoqDR3w!(C zfd0m=2z=<$ld}{M$llur7g7TT7>0!vv#FR$vry^q49fbBVs-VAr=lq>Kt6U)rJ~JO zIw$j1#kE=V3bmSPMd_!{a3IaZ1B>_f?E?kUMuV z(-fqet@`?rH)&-WwQ{lq<9$uO3bZ;k_BREU@sq_fd&dK1dMSyX-nTc|YPFRlf`(){ z%9N43sSI4(|TTN};V)P=_fw|wd}}My0iA<`#MZ~`?zdo zT@MyTJUl#rz_zqb1r}?j*$Yh*Lx<7^VC+;I{IS8s9ky`UoTaAXJef!dblD3UAYx_X z_+V|Xju!}6ZTYk&0H72m`(vR56E6I2f0ckD+stNQ;MAg!zS@$va+;5S;uTljSsMj- z?oBfC1p}?#bG(OZ^w7H|A#t+jpqQVvXx!McD4RPNoV!Y89yrxWP*zxUvY9zQ3X>ev zzZ&_YsG?%FxtCj%C6(3S{HewDq^&_+l5VqSV89%npR0(gt1g)YgH<`G?15XOOn4e0Db>>w=&hS#H9EpxI_nB71mefVyGptOdZ~p{Ti>9rM~aGe0KvV2mr;!O zaf1BZ_CR<#IwVMX8LBL-@U_T~3I(FTF}QG^ltkb;PI;dC01`>tRl70S;Pm#){K+1A z@PZl3Yd(@xK*q$yQO}u+HfLsKRaaN%5EjXRM!t!ON$HNC$@cnsUVeU0DRb2G1$oNZ zo}O?0dFd9EZ{8@Vs>WtUwy#SukP;9S=H)HZiAWS~HB|-%h~tak5p5Y-oDrES4o=Dw zb~g3`h3JwW_(vC>&MT?}Y6=Rp8}A~PpFTlV$D&oMaq5O~uBp+8%+!w! zb9dyXKL|ZgP8Af=2F1sE0Ol#B!L_XFGs}NhFi}H8!$llJ$Qph2lU6vK&(_$YwDOh* zwM+ugvcYWf!I;^m8Uh^aI-AHeeC*<~mvlL3s{Kcs7=9^h2UKlQRuP*!wt-Da`x1<8l~ZX(WC5YtsXQaM<7 z6gZbA{_{!B7i36!XvV#x2+(Nzlr$7Wht8#6qJLI-$}fP>#PW~%0WJ$)ty?;}g8M=T zeHa@kI#P(TI>?yG$4W~eiiRBvn;gBL8}dV4DQ+IC=7nRT!gF9)n+q@kC*m5 zEi%6(CnLA8FrU`rswyEtQ|kBca=WJ>M?j&yh|EZv_sUoYoE$3GLIE0@uN;8y;u=YG zx46GvNp1c!+6LiWyuSA#0?{`xU_u3K696L-aazEH6}HxE@8`JnjAk#?m-A*?oT!Sl zXXTI$G+jO}Q)C%d_)k}iYa=zibR%iPNzKfBoi=E?Zle;ttsFcsJ9e=7#|5sn^&fVj z!nEuL;mFB3rdkIsiWD9h8HvlFwn{Gm0#_oZ<=$-lMss>MuGJ{!!l(Ug##oE56sz z7Pe!BL^~+w5)_WGw_TnB` zUvB0BjXN;s)|!iMo5Lre6*litI!pZT0^WaBTx1BhTqFq`)S zD<3u?&z=~a=@ByKE(K3)<`!eOcugw_cD)SpZRU~}xm_b{5temgS4Prha?<<>){Z?` zJLn;yhnP>sN5>hH9Q|T4gm@YpH`##ohrsptZ$ALTU>i*4#m2`kC@UKT)A%q>f3=@S zqoLevZ*@7PxsANRf20;cI(VKPiq4*7r@uLJBVWli>rvkFSp;`O_~K|zUc$+tPqo?o zuCf6`m0qdA?nH6%KwRCNjF~)zAr62#NpbNt>pJAek9TM5WBd#a3?T6_$8N&(1d%1* zvno=`$eVxBt^?nTgu1q}q&7PxNADy{4?CUscdAv0@Jm{TXH}fzJ4M=s^bB^!;wBF< zkdXXUKzH#k`m@Bk(qG^}kGnn6GYczhT5=Vqp-72VX-CV;9O z)UDUIHy(n5O{CuEzDih}oQex2q8X8=0^uZrmwR*kiC_PU)j#Fuy#{SW;F=KLpKrRa z65^Uc)Ai=+4454pKzj|~mlQ7R#L`lm2ogcHQXPD3?9rCbcby@4%GIEcXbsFFuU`=p zr+`NIDB6XmkoH6zlXj_o%k5$t64VGdj)1o>y`VtzoZw-rOFZ|=`KhBA0azwfq6S7|IF=kPxv1ir@>f6uX~pSEY}DXJ}cX_Q0!u4)Nh?vzFsI zR_tt1Z2uz0_$d2VhEst~;!uuTggYCT)1%ZTY}((SA20 z-c74hf_>M3&J}QmVCs3RHwO5ICA>^>aF!b&^+*lh-7GF`kJnq?x)~(kAuQkKS&m`T z3KyKOHm_!)(NiA=;=|^onuZT&Zu>FZpykj#S!(ms7$gJ-oue6_jHv?uEMNh9<=-woQ9sO@<{+jFDZ~={5qp9o+U6pQD+U7QybfJkZStVz8rU&bcl?;^KX=h6km}FBmFPXQ9ui0UFSM z{lzcKXncM4fGY#S7X?C}Q#h|3wrGXpCKgv;P~*PM)DQCAEFexY0WU|iV+Q~;nW()A zW()qQBg2GoHg$D%3jAN4E%SE|fp5q{bSVGJ#B)e5=4NQtqtP%OdL_p{Z7yp@C4Z0! zcOJ>{Tc8huN- zv>W)n>Df&4#q*MkUVVqfi-0T^Qw+N-HH{NiF`$3nQvOy^VMpcJ7&4;0yPgG|D>-xi2cJ7(8#_=MDd;3(jcLlSXf+6>VGcJ0|wB%j#v)i@`top+{0A{>hW(>L1Q{u)>&G18O*L_OBW@@e4& zcKj}TJ2SN`gf4$AaR)m&82qFQDssdwa*|>)ej1OH`LE zpFq}nlWO;;S}j=?u+VtuE$$!Scw=nX`pf~y37Q?V8=J>2QMIYa%9i@dvW{^7pk|Bp z0#oijv(&^mDjGgIzoL)&Ii+H_1mZ6`Sj1*ctn1FU6}Y*IuK3*<4ulqJqf?q$OKU3= zgEJA!YP%lrsqyb7uXTBBjhePz!euQJo>V%}E>3af85cE}sLapySHUs)^_wCF8XdKk zP9*jAw8v_knhFtBAs*FyVi-7E*pZdNyN{Q#Ej4JGB*-A~HOzTuf;#hUCqJl|6RI}|;F zPLQvZ15M(xrj0&7Kcv`gthD6GX}r#N27e&%pZ^OejGpaPOavu^(Rt^yVY*_VaNa~l zS1HkoWn!hGTH74W;}E6`2o8q6n2b~l1@wy8$Ubro;o~{=99Qrxo~`v_@4t87VLL(d zNQ_J#?wS7Py`eS1N;p<7k*10FDEMa^anax_9e!I_dOjHozL4`A3m3Wd80Hn zvhSb$fs(ywOHtgMLH<|!NGn*%Y~C~1ABImQlWC!U6cv@KN(ysI+Xt&1(|j~8m#npB zRM=2z2~QH#g7p1sxoY6Kga>C%rh-9Al=1)^rCF)iBH!PQYG1~DzSnjjY+xhh)ZlNEh4_)jF9JM~e--AX`xhD1wEro3yjOXhQv_2StpM^93`O&QvOmq=Mlw*^IB!Brb6hM8c^j_Q{|Lh#3G^!0Ra67?0~B7v zq>CU4tC#8|0Es}Eo*-B7trahrZ(81?@T#DcP9_}GP1@JHRPW`S(*@6g zp7RzlDi277r%#@w3qFOrkOG{&HC|LebpYVO10-YxP6F|WdxfYZ3kwT@2JnFb>*~}1 z9~JdO-*oSr%jEMaYd#J>=N%1tqxfHVUv@`FDRF+uqzcr7CI~Y#vm<4knjaGbaFCG% zqT#bSZYV&-ggnn%zr=b@zFAO1fxw!6p2=kBWXTW8!R(0moWrk75Mkx_`pjiRc}+)Y zq>%)1$YSpdG`wR>|3{%K*s`zow?Z-efc1n{8IHss_nHmv=+5C@_p?6jw%8BFLn ztl*3IL51(_P_R3p@_vVO#rs|W77Lzsi}0pr6|Can$k#*Axr>YoOEb^c=ktP5j}k4e ze{8^L^j@fVZ?@&J*WS1t9WiZvSL0N{3;yix$QiqgHF_h4Rnf`Y4M2dRT|x2&BJ4~> zD6_~9q4cmF3scukl3bkJGP8u)Y_c`EJqlJOqvam==4vae)id74B7I`E-*LwtGtFlz z|GcU`iR6(urITH)W7SAb0^`NHovTc5iD{b$%lT?!x=@J~SBk3_;_~X-cUYy%b)$@6 zQdF#LRDbI6JPvFqlWwl=dJ!Af-Z->=KSJfcu(l@bC~=2`8g3@j0!NIZ4G5~fK_1j9gYbI3@It8+c}900;;?KeC6vKvkx(1iEnfzU7`5 zM*tB6W}+WAMn(y^BlwOqhY0K;2Tiz+k{VKJS>c>k&E;<~Ue4JsA5-VbrwwGzfL4cs zqqIIbVP3eV6Ndf11=SU$MQGW zhDE=*FH;-U0018~*v4s_9|~i`?nDV;_0UFReB66|9V<<6j9Onuho5*YD5|`)ruSOT z2O4HdTXGvPt@OR_GMzuhd04$Yi3p&7tNgvm)zJ_Be^`6#pe)xlZWId?1ea0*0!o8~ zN`rI>NP{#;cQ=wEARs9r-Ca`Bpdj7djdXW&uGh8qeEam|>RZDyDLJN%2And!uEVa#?v>*cui ze0waq`)mG2VdtFcYDD0>2*J>mnk9(FH*8Y3U?A`+KH<~uI zau{AptDx6Z#1)^_kYyh9@MU&9MPdfClz5MIai57w$EU)d%l>bFE*CM1_y=0I0kV!L zAg7y-HYe zqm7-pM(7wx*$-o4P+_UGv9?YTr7B6X^o)?x8*lqwhP^3tdUhsT{n37RjLIK7OCOx; zqjJXb7bgqB;H*eHLcT-JleWZSUz^gdJ+)iY-4Z6A1xsx08qzIsaFZX@Sa7_&%FZ-8pOGFr(`@};2# zCur}kJ$BpYhon?le|{?lN$c|N-arQ}XiSPKSo;0VZ6qpy$vG1abCDDMD07xm>99>i zNNjIqm0T#eDoRy#cyN%XQOn`|@Ze3KS%Fi3%*pwA5A>PpZhI%YI&F3@56}@ys=s;q zy4(+bk>u6q;KNnen ziO{``6l}k&6Q&q{)P+X_3gOt)Uf-&gj@H^F!mkJ{JI5T|EnD!zo{N!@=*Us~wJLlI ziF^1c+EhDn6y@E^245k{bt7syWou&)JS2X+f7X~xE8wgW zLrK@ftE$Wq@ummM?Y?MlpLAHB!h1*AcQ-PvsqQ(JiiKrj#TaJaL)}^~eSyVizdaq_ zvLMr3WY|X{Mmfe6OTH4UUTh)v(SMijtjv6>$Msn47+G(s@*X@d8h^NEXMa1qO^aWp zQMel5`T&f!zd!0G(;G3c_OGmvD6qVInH=xfCi+jQm*k%VLjXbz45Cbyl9Q8dOTS_y ze{U8>7*3g<5pt$~^D>5Ft7J?TjZcDho2;~Ydvh~CJw3v~hshW65&F8(1GOpLaP`n{ z(8TUxT81b16HYCyMchiNNgix2SWckTy1IdqPIr|F6u;+H%%~6*aHpD;)_T*Z2k0;K z+OZ1K5cIrE$F>F?<&G@q&hjKH`z=>}JGOG}h60!NfK`d2MLC6tF|;|It>pAKO2fA?mY z3e~@eKP=b(zo@$YKPi>|?>~&iHWnHZK2Q7)4jy4tTv+oBdGj0^v9l_b$R!_qW17E$ zG0^Z)GTvy(oV}ZP?1`g*z8*aytthvIL{t7dZSZ^RH(#lmFX)F)Hag*iJ=&i!ihuhS z9u}Dp8chw7lcXBi|J4fRwF>{-J*f;%`N+SXQ3gt))NfMiUB8?A7f(%idX~A(3+&-< z@(SVNCWeQ_6cpwfX=mk)S{`jZ;0^A z`uCjkrV$`{C-H=Ye5X3onS(n;lT~p-#vYVwoYHaw$>VKup?O^jiEE%udSMO9ldBtA za1nq5#JY^`B}Rk0EBz24V#uQ+odRX2%)uQ=&4p;?^l1lKr)@9NR~!WiPUsj&sCrq2 z`#agVC{5&$Y?V^afkY+Y@BdowMqbf|tfs_>KD~8!N>De{c z?G%}5a|zT)nu6{W6|UArGF5QL{B3U`iDA38^(vyf&ROmp_V+U~4O*$%A|c@kYc3q< zbw|89-= zSI1U+`$}w@{CrYt=?GQ^QbDhdIHWZc;uzV25{^Jk3PDEG8A7$KS)=E{nl|aA%ye9& zq+f4kRZw*#eepuC$4P7fcvIKce|m`O?}uAUQLT|hT=*Ydt`C)Y`&7|z^5i3jZJsa zF2m&d4J(WqV`yl^n9Sa)H4H>?@9v7?CgX-4>6#>EO8gOR%l4JhV9ZMq9}|=nTZ>0w04XhXtK;nH_`gS081J;@v&uQnREVm^8N90*9tJ{eA2Yd60Z#h%0 zC;e^H?c@CiZD`vE1bCY&EVD>7BnQ?1-u2>?dD~ZFR$gOCG~9JJ7-s5b92RBwo6D${ zc8<`K?xxDc3g<~WJ1=q8OAVQIQCF_?=0I&Muhi9`JCPt423nk=)JOQOZEeZMUHBu` zR;9_A7(==DN%1w3J_#zU!bV$XDc;XPpEN3>`4U~sF*ztsdxXF|5 z7i&vX29ig^T629?yM92}zsC;yI$&Hm+SEjj>OHokfUcYz1N2#>k1hr15m|r&iHjg- zVm((2q-5w>aF=|U6XQmo=Ha#WyNPnu(8Ll6yE|ED+0ySnPw^+j1#ka{5L2^>*O#lT zgr)xa#LgN>I{z>L;j0TiwRUtsDjldFdo5jDit7?^&~*)#$;dJm<1=$As?kvy-~ywm z6vV}4Wd@tt8v1y#3H=ufK*ff%2H&6ru1}CohV+}oTnU$uu*>Z%-TO95;Y>v|0*Kho z|9JaJ;>X4wwTh|YY*lp5j=WCVo@EUzDG*1GPbd>{SPgCKSlSVwIXSWCWaMWT6l7@2 zb#2TaqU6U8$-H|s`Qdz;?ih2bQI z=$d9lIe6R(;iH{;-)MuIFATLJurE97dF-!=7!*%6P2T+lATi`aJW^vSt+-fy*UJ;s zYEMC_BqAq}Z&OVnuhGPtX}4cRR4(+#wpB>Z zVcQ=8K|u@q*mkANO%DFp*;*ztQ_ZirpZSHM`Lm2hr-$3x8qJVFU=U_vc4!27IOfRq zKt4I7vvq#Wu``_dE)n2NO>Gore1=k6mVFnfk_)4cct7ZBS}Ekzz1Y z_5E}BOUq&+Q$z%n&Cu}~g8U2ObY8Tqzq$nl!Z@-f_fV%L&U2vlTd_rb|h>ffQY0xux6A zCb(?!gi}Py2r1J7QWHlx*}y)Ok)F=M&ORU~AVBI2a-!Yq9nZgy5DF{n9S@g9f5s5l z>0SgAao5=GH($Aa$dF7}{B!uuIlR0a7qO_$NO^N0yZ}f^^3aJ{w)W0Jh7PIlRjK)= zCUsj|*%Y?}@7Bgf!;RL@?)1p{oQE%8yb63i(|Hil>`?Z2xH}wZhnukKODA!2aaeu5h{q={V4PbCoRIX2(Kn=7AXq4eBkV+5~xIj~N&}oW&Bls(I zX+!Dw6QrL};m3?@v|Z>tZm0`LNzw-f{O+`{nTF$|p>=etSM~FVh-A7vm(TvVJ!ehB z$oLigHZpP$0js35yrbg@B){1xz~mMZDn zzr4=f+_ue3O)oEb1`9Ti7X1vSst#9PK6{od(xdSt+~WLr8vs!o5PXgefaVmKK2TH3 zu{i7L>J<`hKc%E}UL%ftWjwT=T}wML)OU;~s$9B#`TSbY=2m)QwK9`UpM(Uieau4i zw-|Ei5Qp#5iIa`}-ESi@)@oPAT6VBl1QKc{BikfJ%zZQtu+$sVQ@e?W`tm;LG-lTA zGX8Kbe5_m>8AuTktag}VZkHcQ*a=E%i>J5Zzi^C38|drFU+uZ^2Yc zg_%2Y!DVtZsZo30`R&xC<6Zu0k@7x{TxOTjcgvS3#qT#pi-22a`VKKHkdC*kx(w$B z{!HiytMc>BKr{maKqdCeC14&4`Mi)pQOs;Scyc(R3E3s1RQ{4GKTM6ZwPhic>Y0Gg z$?0YF_S)PWpQsr4EcH9TS%HQLvd|tpe!*+q&4Q)9hXNkl4VC#Z%j^ca^&h#~`( zdb?Lvq4bqZ?Jh~x&=+5gL_yVsr4B>Sl$zK;ipyNH)a>+}oefuh*_@CB{d*-X7l-5f z>Mp#3;~fwDNZ-}^OLeD+5;?c@AKDELg|mCK)BS5T zSjc>#Bfu3ma~n!8tf3r*bBHE0HQfLX1A<+6?AGLI277z|xqCY_^!n(bIA0@B&E!(9 zuC7w?9Cqu&bgZo9eW@Y{rZxf|8qkP-$%yB1znZT7fP#)s7Oe{c*Bdu(u$oUM&B03{ zhtW`Fh(Hh#*iz|Bps&H23>U9JspzAG9avfay3qlP$El<6rrjl=-dS|xnN=*T8t$9W znoi_yVRcVDq3Z0eEUqcYu9FphXMe6q%rJI+b#gJzlq1EMN<0zk-JHf6do~-~NNoSs zCWGIBGM<`??$4ja(jguPB^{lVDy&kT=$yGO&`JKq9nM1 zLdhN6*eN)}^K@fQt`JmR7)jQ03Nj$3&rz&KE_e%75>*PZ`$b=4;{qV6;NndE@|0Z2 z7Ox4gOsdR~+fSJM^-zJ*4);n+PX`v6otfFLJ)An6Hjdjh2GZjOmO*WitPJUK#fl7l zcA|Nc-Q8PYP=|{+Rc3-K(cwpL===iWA|uULR#%0saHAQ z>#H8+1rJi#Q%1NlTfvP@$@qT@^_@eAG^V3~8@}8`7jScgL7@$BrMqyD=zX+RoMus02GXPE1SR;tFm4Xzd49y3b*EV`%8erqYb>}JqbTb_i z28Lxd39pFTLK!kYfB8%d4s%+u#vyaCW<7cs^>R7U!P*+u=kl+f+_2ifA@-@L=%qJ? z>1b!C=|Xd0B@HYmzUUQ|m2G}98N5=Ei7Ffn80nw=Q%Ji-!=*Q!_>o^(c?!Etmdn|} zszQ#usFai@K&JpINJvNkqA&Ufh^VFCAb0K%-PqiOWG-rDoOS6`kdKC&_wr6v*#*>5 z+@UKHRKm}hJg=VXUZoG4)KcOs$vXMM9gw(Ljq}Q=aUvj?)VG{bFLkTV@ACY23%w23 zEmB$cHTei^;pWWxi;$BG*M@}LUwKi1$VcN^A}T*}Q>BXT28Pj^^hv9lU=EeupS**E zB<4XI|8Li~6IkW2U8mjT55OLSN+~#dpN}ZDIsF46fPKTm`i+30V3G9l0t^Q+36)@B zhjV=mK@}t<+K{CMLIenm)X>lXG?2?-E6&#!{74@XcLxJnj*ZF}8 zh8VA%*qzubhjfffV|G`%*B=vLDu_wRM>sNF=gY;7ce=Djq9N_j{cF49{qstlc18vk zGuX>%0XouIYz+nF8wf@q4k8GM7<>C8SRjXnhA1UsO5gwb2*}eGP_j>-dbC5RqYY^E zA>d8o+Y2pVWtpCJ{hFDn2UR*mN@k)0$Gg^_9*~*23;~B^9cz85E%0eWQ=rN~ld`|q z_LZdI9(I9B84Wz)IzO$9wammw$fQnD_qH8aQ}2KDsb*!_7;fE>6U<2t@`y0ZqNR{<72i-ai#A|_`ZM+NsFx7_-A3{)x%5zk5!^#+A@Y- zHb?u%2FaN>qPWJn)KGhBeoVsp_dAP=i+l3g{t^P$|9<{Y>l+|`bza;*b=aQXgzIaI zuWe>FRcT`YaGoC~WwC~ka)vZ)-4Ky#J%3(_|M>Bn_P{S+5YCGHd! zTNM%`Vix$((b4U5nt(<(8ixRJP-y^Yo+}i9BM*^jN+&T`#e!SnF>GsUPLG=YPt~}n zJs(!lkM$4M+}iuL8%S7P`>a<>8OWNSO2Hw^q#SP<2wkS*)&v#_v0O|BI!E-l>)YZ3DO z$KWLShkyVqCU4)qg_RawvH}5mu@T>H1+7E zb4a|+5x*F)=w%Qffd{IjLS9l4bP-@)sYGRFVgfbP{=0WFGJvaUOIIyrHKyBa;}-PPJUT5WI~fZGFi+@L2qH!rW@ z1`_YRx&6}xL}bf}enkK(5^uEg`H@89nH`6n;ktCA{X+AhTG108dnULK&kI^xTXPlZ zaf|lCn$V;YIr^Y0fLN2=)0-F%$aq`+iv|34si}33<@~@~&;1u93x81TfGqM>P1Z$Q zOw8C>Umr(N4Ip=#_L~xR*o66e(+*5X@?_ACdZ8Sto}K$cpeIxStTq<%ErD0L=L(F_ zZR71ONE2(iLlIV>R8w2K)OlK_u+Acs?XtNRK`tJ}Y&!bc>-zk>a41tU;d@aTdhp$4 z#4D5J5|YlyHjgPgU4wRk^#m_5|;K9#MT!jyHr^Jw!G{|*20qW;?A>oP7}j);y4UXM(YdxLisW=%t%Q|vMkR^+nCj# z7$xc1I4BzULXz_Lb~iV-c+MY;tc+`YwI+s!cc16UO?WRY8Cn?V=+)_*v%DKkQT`fA z>T~LT!uxfgo-!dAO=ZFxZAr%4VcSJGm`L*4xPMp#j*NO~F>ZZY~kv-P0V$ZK;bd~c1kA=b`t;#ZiKpM-y(q4>D#6ole-h3Jbj z!qpbj|FwwDo)kvxOW9!@D`u#|Z-z_bh)3rA9X>ArY z)7ja%h3e7$djfMDWF>ah3BA{T6?7oYrydF~vq^w}Ipkt)sYXnC0oes^E^ z!>Ro{OM|OAJ;UGH7}X;z?2)oJyf42${r(vFXJM1essHx)T?Wk$l;q@>McPi!CSGWU z1-*gwt*zhr?_XaYSwv3)mwN6G)#Yw=!;^9+G_$-;2!1sx8ygLbEyu^hvk~g86)AkF zbG0cCWj$A|^Dz*$DRa9E?qExsOKX#3->syJR*rs6WU-jlClSlMESTNZ0+lThkCRW& z^6~0~MN5#GVxijVWV%UTl-*)$GBmp1(K#)y8esjzszXPt!@Lx&5R$NakDAsaNw9HJ zaHf3{r1IWA%J{ayPa3NOjnw!B4n)5t=9i^^{HU#@6xn$&Hbxxa<`$9Z49AdAYp_g=# zOFsg$CXSx6bCq*gfxs(9#<86da{ zoA;MxBqdz{Us2t+yHL|*~}At2m#bDVi=y$fIou+B}61Ox__egD35e0-ggJwHEh z$d5QjI3;w6K+Kllz86imO-8Qtl=Jb?frp37Bf%6B7w7W+y6(s3I5s!2@#6VuZPaVC z{@<6Ym_5D^h&ok(n3qi$kepK zwZwjNVtf4b!TOt_*fSlyyXTrkG0zMdM=xAN-?ZrQS$jB+AzyCbs zaE|6|&6pG%q1#MVg>Y2F9L@pmO|@xNRzSpaST8$(9T@vn!8 zR8^*eo-K^wYfrtxK7U^Mba3#NnVDSO%r4<#`J2z0U=x}CJ#RHDxMXe%qx9-kOvYqY z7W0s64~QP@`Qwn%zxCX1Ycl#d&Ui=E>zf{VAz!~v?DlLuZ1gSAC=2UvHX6_`)}UNs zPxKm|koRN`sv@(_}mr3v4W6(Z`=lbC|NjKTA`g{-D{oPBZ$r`{GK3J_kSex>F{z_cDgS?($ySE?^Vijv@E|&5q#1|z= zHplH8FV_^lQlLY)FnG5Ua|JVh$P^Umu5O#Dl)cE3B`0|eni?LZ2NbI1+fO+42lw>E zsne8d_4AXHA7TeRX3r5{#yDIX?jPzaJG(yQJ~bZCbAqI8eCDiNAm7u|g|_cvyKVmG zG71-bUZ%xTMOd8#c6;_*_vu6C@6$;rpbfYe@;Y6=WP(XFWh*N9IXL>)L1&M#9^z`o z>4berN%`oNKZcu|4vCOiS%`l2&J$h0t$=qwhKVUeUd@e^LB!;8TB%GD8dtE0df#-f>>beRk9=H_A#-l`Yu><~(` zIDuxQK~3ETE+9|`_j~W|?lP$s7#b29DzB}rO^$T5wTVLd<~C-5VBg47vrlTdf*t-r zLBoB0ZDo~vu0=vKHvwshj5sED8DhCjg={9FP{4$}pn703Rh4*7MtzJ-uV!@CyzK<< z`h)ga+?*QCl!gK+ps~owfwv2@_4-XtmYIJ2p|8xgOPgWKr0e}}MMnwUU@ zfxeh9hwTclGO|LF>7UF*H)!L>;6^>OaFU%Psa>XjX zx*R>pb?F-T|B3#x^H4ULg*kx9@IY+eyud}%w67c~xTWKm{OMnIHAJS^Dt7d`)uwyr zn8VL;{oJI zR%Hnnav~;hR86xHmLSDK4H0 zNu)(#>w+$>u7H(XJH^}C?!{|CmpDc~W2;sKZwQFFASa>#L4hp{@(&L|nn^ve5 zO}iNWTKkK^xY6#hv&$V`U*_U{?5oEf`Xqs`8*ve zAmGG5AOL&;n5fru|cF@RgImjgUCi~aDbJTtE2lvLW(3iWSXB_w-APRSo7PS^r z(S6IW-Cu4WCmH~W^L(hHtZcih*c)!-uZe=w2>=^~7X-l4NN;b1d@(!j@G=`Ffla?%_eV9y&6cgsWekeaPw z*)>T>q0xDX89|^>xf}BEKvdHlCIj#%D4hF+G4JeWW;#3bRw{lcg|r@D{gONyy5B@L zTK8Wp;IKYL>k$s#`PwFm8J*p8G#z!i!@??R-O58cg4;Cg(WkePkobi}|G~nMAa*EN z>{ay0PTo?Cua+_W3rfHqV-uWsPDMjiYOWINW&P#jJv(Mh0`afQg_kRIxeLaMzwhat zU8YmqE1O#-PRH)isCCFO*D}u248KQx)A7$`QN~xhI{`@kwR}kJ=MZTubARr=$-5yz zO*w%>f)de~IDP(-6ud}@DnxIAG=oMskvUw5P+7hDI8E!^F@16yE8W`L$vs7c)3A?DvJ_bCkv6l81;0!z~Gt^O=w zGGbmfoG)a(-!2S_tn!LyuT9}#uD3iwMf{e;++P1WJ|woWf9YzZS(8(gPs&NT{9}R^ zPikGgN3tEa3nRR(1Dq(gw=nPe0a?jtyEBB*=UdaS4*L|xX4iSvJc z82R5M4CwYrp+yBzsJDDlk-Tp%Q(Xn0|8f^77vyRGH4g*GV$E*5F^Nz|g?gdhjzXmA z!NE(;U)h|TY9MrLz6HUdOFx^v4=Mu0kwvRiHD_pXe!ALM!WNv`@E?ydQu;jn;tgU- zIrx(R@_?k9Ez5FcpcQhYhMQ9=zZ!iL>m?Rx^7t3R^$-^mv$nEgce|*tor6(Q!a+~k zBK$l&JX|_pQ8hW$1WRw)9w@Bs*M|eomrkQ{Dg)k?xKEu2hB7_nLB72?>iX$9v9^v5 z404*Tu+lLxS%*D&bG$5|KM+V$m`SG7`R%2eP$_VCKywX8%EEFFR!W<6NJrm>+#m=5 zQ)8dy?Gx^iL|c}O4DWr>^aSIYC;65x{@Lu`6P*Pe7NP>M5{5!CFfdR#xxStU+d4fs zW()@hhnU+X>4Ib=3ovq^3}aQ2!yds<6z3-|-t(%dO_ul6AAA>FIPnZTcyq%y?KK(g z{D${BgtE-nv07Mc14!Ll-I*ZEc>yKn!610qFfEu0NX9E|C|$Fxv8QXCN+3p5ZS^se zVK01Xpk3fU*%Ul!omfEb4@AB7Z}QYn1E3>#u1*%9qN*r{L>Y3Y&RjTGm{!rMpac=E z1)r8Q+4T$zj#meK=V5YGAS7o`jE*`wI>Khv0&@Xhz6{N+_{9H=3%-#2-ovn{sLUka z=gdY%MhD+wV%l$nzfwkJEB?fuy~-XP&E8;bWsQmSd1sMbNQhm}Gwx>Lqp2^1u&x=O!fjYSjW)o$3GT8Zm`VU(J!B@M zp!h=F3?sZ|;4Z?2w*5KT-){}uGXQew?I813g=i;fX=#XD2do|!VnTf@vTKw}^nv_F z%sun>Z^u=Ph$Q;wpBe_s@3~q7-(Cd!8}t{HWMsX>H@&$J zUZz^ov9SCAngt@eUokTSu1{}vJ0~$Tl+XPR%wkJh{K#!oO5NGj1f z)ZhDH&K<(~hqgzHNL{a>S;+-jBjVP9=kEw=>|ikL8R4<}wcTYwY9~Z};=Rglw94Kt zW^LTQGK>N$O@gM|5W*n^k0=xdW)MkEotb(m|Coq~+iaZ4xKOr)j)deRzT4nWRTyXG z7QbPS{|6vmbi?fxh4ok3gaf@w&MpTl4_#}F(0Vg-p|}d;HaXgw5>MQLN}C7tFVT;mXX1fTMXp#n z#sD-I?DyE%)S_h{wh8|X4T+0S2nBH_dt^+c0H-^CPAdR_ygxv5VGKk9M9Wlyr8#W} zP8y3uIy?#5Ua79mPJn%&oMJJ~ks%1i|4AtsXE03N2`kH z1Gb)rkGnx;Nk&*_=i6lIR*c}1Qvi_ML5_nJC9O5Bkm6me@r-H~0=BzVJ!1e!rqgMJ zKwM4E>wZ#E)^;uNFqQFxtinP~M`q&`xhlR*cjt3>Oc6j0yjJjL#=Uj|hu~T1+jx$M z`80TCt>-5S|G`g^km$RI9^Ny++KTp45++x;O0VAO7x~P+94 zCnj)zo>jki`Em|PEb#u{XZH;&lJ3pRY>GC6h1amfgxC%C=PKk5gJ9tqb@Hu|xRXZ@ zj>5;A5zE1k^`D-%R!7S`Jw2G&a5edWiQft1TPFqb2bI}(?M>? zZ8wEl7Pf_mZDknD1`g#KSIal4!`ZqOkM|k4Kv@`hzog>^1|g?`J`Jh~)w$#5pV;#1 zmRF4`QwRYFDbrvpLl!sVLruyYGTL>V~5gThrfdkOjuPlRw3!4du&Wu)_t`<{or(@w>QbdD=ZZ8+Gu^H zkN^vdCt{)ku+dmSwi{H=0!HU=G~9r9g-%y=R|JrRsi~>Ty-(bq*!)sIQg3gD&^`lM zM+kYg5&MBb2NXZ8uZ&kW!3PBwBuq8yF+RR*9G^rrf%agP4q+&)?StSv!Z49zEQA(5 z+_pE_ltZ`+-m87IM0alf0&WRm z3tk<9ev#_B`1|*yJw(oXTG|tKS&c1cRa-3MZvmo-jm4I8{B18>uf{~_@53a%blR5W z?9oj}!*xi;)zj1K(@)NX=A_F(85K39aScZ6s5$W`N}c@^IU$~vFsw=1^u+eQ z3&gE${C4x_S$RAO#tks+(!qQFSUPvc8L-q2*JE& z2Yfc-7L^2eXIeW2#qaSp&-UQJ*6=W~Co__WFe@q?7N}gXQ0DcZ+1VXJrif;(GbkM8 z6cx*1KZWH$QO9|KFhI&m`dMq!Z*r@2>ZeobQ58QX$A@_%E~m(5cu zSS{zo27ql(gy>8WA95N!2+VG>!=W9qyr!|;gSDj9Rg!_Iyd zlPjcta2oZ)V#DAdz(TWcW`_SZ)L-7-3i&DuXU^#3dxNu4E@b@t{4iZhP{P693RPg6 z+m(pwNSm;_IQI5Hi_c-1vg!2pt<|EcGUcM@SRaQO0d3_+7rjUR3IOGUHxqn&(XbgM zN2R8uG)Rh|K6sF+OSwI1SR&m8+Ov{%>57j$Me>sF%>C{XLdSH4thn}isGOdkk#V}> z->x>pxNFOf(O1&Q_0q3wVwDhexQA@S^Qos|+Wq9h@V~)}uUiX@+jK9oWhh-qWqs_l zLeMzxJXO@6yIke?!X$2X` z)A_@T+(#f{p*d$qvv?jG7nYHyrX-cl6uD*@(TvM_7wK=3JSX`LNYkdmyje$rq9>`T z_?-5Y&;NFo7P_`I1wVxUx3ffiPkH;Bbsxi!z}G`%cc9>95xd>cKe@ADv!4d(P56PGcz2Ly!y`^ygf#Tu zu_#8<8{F|ICZ){GdfKzF%XUJa+#0DFMK&7mjlT6)){R8+`Xy8fG$a6GwDh=!ShfD+ zT=J@#W()rXryJCmm=+~;2 zI#+c*I9NbZr^`d!a?7hil%s96ik09cx{2?P3d;*|yRZN3rk?I0o*#Mgv+dqea8>(emEJ-m7VhB_kk(ytLw%?x#|l6iW!UK z)&GM;#davplnqL2PJA~qgS=?C(+R%;kh;e{c8q|1D*f>+Umv=VF(jTZhG(_5judKq z^7$nF^Wo#iJ6rLJ07-$q;Uq91)n7cK3RAG5apWalrT|>-O(}FFbrnbQ|!CIhJ zTVzmpmA9B$ui0WRVS9Lx*>e$?U_SFB*(4LkVXJnqZwT{lxbq<%6(s|YUH?iVWmoU; z@Eqc7lJcZW#t^DbZ25Foce-5sejbdZ{@g)V%gzfsH|FP%mul0Jfj7`RQ{|LzRPs)f z@j>^(*`F_84loF-#l!&Bl%#Ik{TkJkqtYvPoIw}MVqa@Hci`dKsC*~qV!vXJN$Z%% z72%6S94GoKUJE7Dt|&z|tQCa^ONZhF6Kgay*Y+O<+<$&IVI_iD_40*tKXLE!fAk{5 z&Uz)mj|sA`zlZdre=J>ulf8hLP*XE4*i&UKwA<<(obImBsit6xbKtiq96?6DW+#5j z$M>sYZw4a{bU87h30sScH0r(-$@kd7cB2{`4fq!khpt%DhL?b(WC7Js5Fr;Y-z{`9O3KX( zgMe(KA^Xj1OaYgj4~YN=7$4jQe&)v}2Otc~@uK`LH3b@1tn|gDrNs`G&KFc|`@3GP zt(LBrG+{E%XUL$`nM0~$9mb~j#)nx)I=AE-Q2#w2-8W75*?_=qXymuS_VM=aO$`bv zNLvj4gO>grj8&06%i>X^6Pz4u91ey96|OA>z*d?M6v$2M=`HK-FFL8YogEOoz2-hU zw=;E2FeXuD>6$_7cvU~3JbXa^mm;2V2nv#?+sn;HeLE?3`hrfUYKi;0| zR^XGGff>xgRl3ckyY2;QBTuf3oC zbyNc6_z88QZKddIlza5<{#HDo4jST8n>iDSwUz<058m-Tm43uULoG^y$7tT(M|$29 z$32{7C3oXtu(f?brT)-%;2Jv(6_ugU`WHOT=;kGrcbCW#S4wp|sr8AA!{0F}uNxM2 zhx1f^ST!0;#wD1JSCxy8B!r1VoG0pi!`|NivMr$h#swWiM21JwT}2e}f(jBH?@3lr zrSBcPYo_~$`uJqnIzh{3X!yOTDBD&`MTO=LLAVbHBS7RNX70R4{ga2B+?yoK#iE

ACeUHSu@OIY3+Ai?S2SuAsv}KKj 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%0D*uy>i2)x6YQQT!pA*~HlR z3qgS+w(vb&>yG8@4WR0P?>;DW2b!|J1JW&z3@Y`xw4+r?w}uLGmFh{);P=ngMpj(Q zt7^NuU%~F)Z3c!D;%cOQzZs8C?K5PbEAHn)1&uw>`m=R+M{dk$yYo|vu`J`$73-U*|dE24^_%4}sgT+;?SIA%VR=qk(ecPfT`4 zIj*n(EuRCsQ9mG-zmcr%9cB@>-9wUGFGJNM`PX!LCd7MGq>f3kh8t7iKYB;%%(IqH zVE;@nW7Y40P<@Tl*|D(WkvduK`JQf@{XA{;EGfgTeSoU(v)t^KHI|VykPB21eZ71- z#q);y<17}UBNYw4810pYO$ldAOxcsJ<8vtMZln!V9r#t$)SN60acz$&R~wcuPc%&x zcUj-ZzJ1d(6s{&B;cTs>qLL;K;KK+m>>C+ZDb}_iIPc$o z2m*~P{ajEV96df-Va}5f-x}Iq87)1*rxFHDQuG2~Ik&_$T>R)V6zghQbP{HHEOb(8O?0BmX2>p$ipIh;Fs=pXQ z9Gi~p6j0(LO$Q;VZ*Bl{`1z1cO z#!aeLfuV+Rjk}`vIXK+5wwo(4b?A;N*A6LK`vT)3&T7{Yz3&|O8>ZA$Tn4!xw^MNk z^mlJMh>cI6HPxUhcu}`$fkJn~)ghmfkR`H;bj}rh!R}CKrm@ay=y5V)yZS_zzv{1PN%c*zpBA} z6dOAV6rdd1{S2QVTRq?sWn@~v=oh_cd>V+7#9c?0tScZmw4j^ApbP5n7K=Fp9A3RMu z;xm!K!3&;#UX4MI3!jC#6UbC8kN`*cVxQUF%{|4zHvQnbF@xA&!81$KO|8%#)t5oO z;j(ES2PN>3tF|i8+KHyoLW6+-N5~~*%?7K;ID||T<&uEiBrd;vnEEp1!5kvFGI=>m zYr`Pgm|Kx5J^ZO>T#)QfAdEdQYqXLy5ZNGVMqM&*XtL^UAAqZ6i<4-IK9@A`>tf2Z z$J*MI&7%SlSvooqKwy@fvkft(gF{$~)B&eH{AFbVF(2`XxoZa~yF*2C3=TtY^CY=z zVfj=REQ71{GwF`EMwg8o9XC)@ioC)ud+FY^2$3l9>MzrijZ>E%8uD<9$!lpTCEq6p z*82%SVC#RX*~-E zhhJw4)A9ofiXq}pd}qyU$kq85-^a$Z?;FhNhumG8hytwejgZ_Abp6(vKo<|B2%gf_{yzpA%N+pQ5Y=YCfaJ1EMDzrT{t*MFv=GIbwMh#^5D4!Wa8pye$gp5MGS)DS z$7153+He>WNOAIkH1Qd*qke8!K>~(1(%O0+H}L=-|0B4WAIt@R{&V;Gl_MvcX(olI zp~VWj?@rf#`Ja3TkuLHa6E}1~u^G6GKO3HXZ?FzrYqKkD;>XU;-u1HQv}OaEgOvik zdlM;C6IpK99rfPO-{TwTft~5uRS#J9> zVSv}7+FZmWsM8sEir7eAaZ_xGnRkz1GN-Ea$Xlsy8p+>D)ePz}bMoWJV10Aw!_?%H zFB+NZ_9xG|d*ArP0L4sObNanfEpc)2{O2f!%J$I-VeZs1dFhZHT=T?!+`Y%Re*KmH z?B)QZleS=gK9J{n0MW|cH>$BeK8c+YjPOHbH1e2Kl*!cT=uoS)7l9;f%4U*&Hj5r* zu6YTkb8a(Qw6RTSp^n`;QWy5E#bcQYrAe}%1C7j-G@QSgBw#MUolzM8s2y{4+l$KM+Y zXZ;%zshkK&Z==ouF{H@+D7ngl5Jzsq1I1>=#-WV{=I}$$g$=K-2t}Bm6exE3G6g@l zwxxMuPYv+6V(-LUJoxPk;$-IrjURw>KhFAGbQYs@4QxQTLbotFL3eW$DGvhoWW)x| zQD59=Uy*G2RJplVOptpiF(rbUTbo?QJOW&GqbdKj;SSy{o9}LPY}dRKP3Y9-#20p{YShT}k&~4$p%0kE7y}9Wz87S+YuQ z}evbCNx4Grn0S{?NrkHd!lwll36foNBctyO#eF*@z4!6@G$ zAUFxyV=fvnqU~HfK500%B}xUj&rlC7c2R+iz*gkyBr>w|pOxjF>nUXfFWz zL3xul`*>Z0iJrBmT`oG6?@Dw}kk%X2LJM^b^-7ANTFq`z#$9QAtTfcj$8{I33nD}K zZr)K6wtf=d88CaZnlj*!O%@HLCbps5nsp65X;9Z*EKg6309`g=XnRD#u*^K=;tW0= zh>vxa4Ww2|eBF)&NETG@fA1!eh`}8{esmdX2F=Mvhl>Z!E!_tIy4H#|;h-Q1NMLCi zgv6V9)JBK4^4D3$p_Iy zu}ut?{seMXzmKCUwtU95K6ehNnS|ED;bP*yR8M<pp{d|G2Rqh?D+tO`w1P-zL7=$yc_@L7=W zR7p+Gy~2`(MrqA4&aLjfub5zbNJ4wyoBGUUK28v4rc3s!hKEvNbaca~AjEo;a>r0@ zfumsF+k^ylRn3%}px8JQZaFyyf7N(eTNY;IY!7+5j#NXBK~RIO9cTo)JKMpLS!&}* zX?VUo{Ge^W`Q&$=xWOyxqNo0%wDayM%2|xzYTIqeS^DnhSn(Db=_lWU&&MtH*0Tv3 z2gs#b{-gXNPTI=x7f=r1>+5qeO7T7PZl$?;hV+?XqC6L^Op3Euln{U7vog6bjo>$} zJirl%x4WR?J~$h|ZC=_Tl#ubqiG}k>2mB708XpnI1`ThqL3r4Zt#2ovowdbh2r2We zFg}ak1D3?8Ln;`z*&rG{JB?5cU!6&&VP&<9q*xG@93u;O4$um+!I7N2@c+gY5hWJS zsCUU)F8qHMRgam;$WBj(pZVzlNA2RDr}aG9(en6P1)7Qo;1x1uc@4QTnHR7A3lv`c AM*si- literal 0 HcmV?d00001 diff --git a/test-servers/configs/subscriptions-legacy-http.json b/test-servers/configs/subscriptions-legacy-http.json new file mode 100644 index 00000000..0aec13d6 --- /dev/null +++ b/test-servers/configs/subscriptions-legacy-http.json @@ -0,0 +1,14 @@ +{ + "serverInfo": { + "name": "subscriptions-legacy", + "version": "1.0.0" + }, + "tools": [{ "preset": "update_resource" }], + "resources": [{ "preset": "numbered_resources", "params": { "count": 3 } }], + "subscriptions": true, + "listChanged": { "resources": true }, + "transport": { + "type": "streamable-http", + "port": 3221 + } +} diff --git a/test-servers/configs/subscriptions-modern-http.json b/test-servers/configs/subscriptions-modern-http.json new file mode 100644 index 00000000..54331e89 --- /dev/null +++ b/test-servers/configs/subscriptions-modern-http.json @@ -0,0 +1,14 @@ +{ + "serverInfo": { + "name": "subscriptions-modern", + "version": "1.0.0" + }, + "resources": [{ "preset": "numbered_resources", "params": { "count": 3 } }], + "subscriptions": true, + "listChanged": { "resources": true }, + "transport": { + "type": "streamable-http", + "port": 3220, + "modern": true + } +}