@cyanmycelium/mcp-broker 1.3.4 → 1.5.0

package/.mcp-broker.example/CONFIGURATION-EN.md

@@ -333,6 +333,40 @@ What happens when a provider connects to a slot another socket already holds.
 
 Also `MCP_BROKER_PROVIDER_TAKEOVER`.
 
+## Resource subscriptions
+
+```json
+"resourceSubscriptions": {
+    "maxSubscriptionsPerClient": 64,
+    "maxSubscriptionsPerSlot": 1024,
+    "maxResourceUriLength": 2048
+}
+```
+
+When a client sends `resources/subscribe`, the broker answers it itself and
+asks the provider only once per URI, however many clients watch it. It then
+delivers `notifications/resources/updated` to the clients that subscribed to
+that URI, and to nobody else. These three optional keys bound what clients can
+make it hold; the values shown are the defaults.
+
+### `maxSubscriptionsPerClient`
+
+How many URIs one client (a WebSocket, an SSE stream, a Streamable HTTP session)
+may watch at once. Past it, the subscription is refused with `-32000`. Also
+`MCP_BROKER_MAX_SUBSCRIPTIONS_PER_CLIENT`.
+
+### `maxSubscriptionsPerSlot`
+
+How many client subscriptions one slot may hold in total. This is the bound that
+matters for Streamable HTTP clients that close their tab without `DELETE`:
+their sessions never expire, and neither do their subscriptions. Also
+`MCP_BROKER_MAX_SUBSCRIPTIONS_PER_SLOT`.
+
+### `maxResourceUriLength`
+
+The longest URI accepted, in characters. A longer one is refused with `-32602`.
+Also `MCP_BROKER_MAX_RESOURCE_URI_LENGTH`.
+
 ## TLS
 
 ```json

package/.mcp-broker.example/CONFIGURATION-FR.md

@@ -340,6 +340,41 @@ autre socket.
 
 Aussi `MCP_BROKER_PROVIDER_TAKEOVER`.
 
+## Abonnements aux ressources
+
+```json
+"resourceSubscriptions": {
+    "maxSubscriptionsPerClient": 64,
+    "maxSubscriptionsPerSlot": 1024,
+    "maxResourceUriLength": 2048
+}
+```
+
+Quand un client envoie `resources/subscribe`, le broker y répond lui-même et ne
+sollicite le fournisseur qu'une seule fois par URI, quel que soit le nombre de
+clients qui la surveillent. Il remet ensuite `notifications/resources/updated`
+aux seuls clients abonnés à cette URI. Ces trois clés facultatives bornent ce
+que les clients peuvent lui faire conserver ; les valeurs montrées sont celles
+par défaut.
+
+### `maxSubscriptionsPerClient`
+
+Nombre d'URI qu'un même client (un WebSocket, un flux SSE, une session
+Streamable HTTP) peut surveiller à la fois. Au-delà, l'abonnement est refusé
+avec `-32000`. Aussi `MCP_BROKER_MAX_SUBSCRIPTIONS_PER_CLIENT`.
+
+### `maxSubscriptionsPerSlot`
+
+Nombre total d'abonnements clients qu'un slot peut conserver. C'est la borne qui
+compte pour les clients Streamable HTTP qui ferment leur onglet sans `DELETE` :
+leurs sessions n'expirent jamais, leurs abonnements non plus. Aussi
+`MCP_BROKER_MAX_SUBSCRIPTIONS_PER_SLOT`.
+
+### `maxResourceUriLength`
+
+Longueur maximale d'une URI, en caractères. Une URI plus longue est refusée avec
+`-32602`. Aussi `MCP_BROKER_MAX_RESOURCE_URI_LENGTH`.
+
 ## TLS
 
 ```json

package/.mcp-broker.example/README.md

@@ -23,6 +23,14 @@ factory deployment. Two consequences.
    use. A missing directory is skipped with a warning; a missing TLS file stops
    startup, with a message naming the two files and the three ways out.
 
+3. **`security.example.json` is the other way to hold `auth`** (broker 1.5.0):
+   a separate security file with one identity and secret per provider and the
+   protected slots, apart from the topology. To use it, rename it
+   `security.json`, add `"securityFile": "security.json"` to `config.json`, and
+   **delete the `auth` block from `config.json`**: the broker refuses to start
+   with `auth` in both files. Each provider's secret comes from the environment
+   variable its entry names, never from the file.
+
 So a straight `cp -r` does not run yet. Do one of these first:
 
 ```sh

package/.mcp-broker.example/config.json

@@ -19,6 +19,12 @@
     "providerRequestTimeoutMs": 60000,
     "providerTakeover": "liveness",
 
+    "resourceSubscriptions": {
+        "maxSubscriptionsPerClient": 64,
+        "maxSubscriptionsPerSlot": 1024,
+        "maxResourceUriLength": 2048
+    },
+
     "tls": {
         "cert": "certs/cert.pem",
         "key":  "certs/key.pem"

package/.mcp-broker.example/security.example.json

@@ -0,0 +1,42 @@
+{
+    "description": "Security settings, kept apart from config.json. Name this file from config.json with \"securityFile\": \"security.json\", or with MCP_BROKER_SECURITY_FILE. No secret is written here: each provider names the environment variable that holds its own.",
+    "auth": {
+        "enabled": true,
+        "publicBaseUrl": "https://broker.example.com",
+        "authorizationServers": ["https://login.example.com"],
+        "jwks": "https://login.example.com/.well-known/jwks.json",
+        "requiredScopes": ["mcp:call"],
+        "subjectMapping": { "userClaim": "sub", "groupClaims": ["groups"], "serviceClaims": ["service"] },
+        "slotResources": {
+            "scada": "/production/site1/scada",
+            "bench-motor01": "/production/site1/bench/motor01"
+        },
+        "roles": {
+            "mcp-caller": { "capabilities": ["mcp.tools.list", "mcp.tools.call"] },
+            "scada-observer": { "inherits": ["mcp-caller"], "capabilities": ["scada.observe"] },
+            "scada-operator": { "inherits": ["scada-observer"], "capabilities": ["scada.acquire", "scada.control"] }
+        },
+        "assignments": [
+            { "id": "line1-operators", "subject": "group:operators-line1", "role": "scada-operator", "resource": "/production/site1/line1/**" },
+            { "id": "scada-service", "subject": "service:mcp-scada", "role": "mcp-caller", "resource": "/production/site1/**" }
+        ]
+    },
+    "providers": [
+        {
+            "id": "mcp-scada",
+            "secretEnv": "SCADA_PROVIDER_SECRET",
+            "subjects": ["service:mcp-scada"],
+            "allowedResources": ["/production/site1/**"]
+        },
+        {
+            "id": "modbus-bench",
+            "secretEnv": "MODBUS_PROVIDER_SECRET",
+            "allowedResources": ["/production/site1/bench/**"]
+        }
+    ],
+    "authorization": {
+        "protectedSlots": {
+            "bench-motor01": { "declaredBy": "mcp-scada", "publishedBy": "modbus-bench" }
+        }
+    }
+}

package/README.md

@@ -79,6 +79,10 @@ the observable signatures are worth knowing:
 
 `broker_diagnose` reports the first as `transport-path-mismatch`.
 
+> **Testing?** `startTestBroker()` from `@cyanmycelium/mcp-broker/testing` runs a
+> real broker in one call, with callers that need no authorization server. See
+> [docs/testing.md](docs/testing.md).
+
 ## Configuration
 
 Two sources, env vars **always win** over the file. The file is the static baseline you ship with the broker; env vars are deploy-specific overrides.
@@ -159,6 +163,8 @@ This table is complete: it lists every `MCP_BROKER_*` variable the CLI reads.
 | `MCP_BROKER_PROVIDER_HEARTBEAT_MS` | `30000` | ws-level ping interval on provider sockets. `0` disables |
 | `MCP_BROKER_PROVIDER_REQUEST_TIMEOUT_MS` | `60000` | How long a provider has to answer one request before it is failed. `0` disables |
 | `MCP_BROKER_PROVIDER_TAKEOVER` | `liveness` | `reject`, `liveness` or `always` when a second provider claims an occupied slot |
+| `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` | (unset) | Standard OpenTelemetry full traces endpoint. Enables provider telemetry export |
+| `OTEL_EXPORTER_OTLP_HEADERS` | (unset) | Standard comma-separated, percent-encoded OTLP headers |
 | `MCP_BROKER_WWW_DIR` | (unset) | If set, serve this directory at `/` |
 | `MCP_BROKER_BUNDLE_DIR` | (unset) | If set, serve this directory at `/bundle` |
 | `MCP_BROKER_OPEN` | (unset) | `1` opens the broker root on startup; a `/path` or a same-origin absolute URL opens that page. Opens only when a static mount actually covers the resolved path |
@@ -225,6 +231,19 @@ Matching resources for clients that prefer `resources/read`: `broker://info`,
 `broker://providers`, the template `broker://providers/{name}`, the six
 `broker://guide/<topic>` pages and the template `broker://guide/{topic}`.
 
+**Watch slots instead of polling.** `broker://providers` and
+`broker://providers/<name>` accept `resources/subscribe`. A slot appearing, a
+provider attaching or detaching, a slot joining or leaving `_all` each send
+`notifications/resources/updated`; the counters never do, since reading moves
+them. Reads are always live.
+
+```jsonc
+// -> {"jsonrpc":"2.0","id":2,"method":"resources/subscribe","params":{"uri":"broker://providers"}}
+// <- {"jsonrpc":"2.0","id":2,"result":{}}
+// ...a provider connects:
+// <- {"jsonrpc":"2.0","method":"notifications/resources/updated","params":{"uri":"broker://providers"}}
+```
+
 Each provider entry from `providers_list` / `provider_status`:
 
 ```json
@@ -237,7 +256,8 @@ Each provider entry from `providers_list` / `provider_status`:
     "connectedForMs": 184211,
     "clientCount": 0,
     "sessionCount": 1,
-    "pendingCount": 0
+    "pendingCount": 0,
+    "resourceSubscriptionCount": 0
 }
 ```
 
@@ -256,6 +276,9 @@ Each provider entry from `providers_list` / `provider_status`:
   Streamable HTTP client reads as `clientCount: 0, sessionCount: 1`.
 - `pendingCount` is the number of in-flight requests. One that only grows is the
   signature of a provider that is connected and not answering.
+- `resourceSubscriptionCount` is the client/URI pairs held by
+  `resources/subscribe`. One that only grows is HTTP clients leaving without
+  `DELETE`.
 
 ### `_all`, the aggregate
 
@@ -306,6 +329,148 @@ rejecting the call: a caller sees only the providers it is scoped for, and a
 tool it may not see answers `-32602 Unknown aggregated tool`, deliberately
 indistinguishable from a name that does not exist.
 
+## Resource subscriptions
+
+`resources/subscribe` works on every slot except `_all`, over every client
+transport. The broker owns the reference count between clients and provider:
+
+- N clients on one URI cost the provider **one** `resources/subscribe`; the last
+  one leaving sends **one** `resources/unsubscribe`. Concurrent requests are
+  serialized per URI.
+- `notifications/resources/updated` reaches only the sessions subscribed to that
+  exact `params.uri`. One without a usable `uri` is dropped and logged, never
+  broadcast. Every other notification is still broadcast to the slot.
+- Closing a WebSocket or an SSE stream, `DELETE /<slot>/mcp`, closing stdio,
+  closing an in-process client from `openInternalClient()`, and stopping the
+  broker all release what the client held.
+- When a provider reconnects, the broker replays the last client `initialize`,
+  then one subscribe per URI still held, then sends each subscriber one
+  `updated` so it re-reads. Install the provider's message handler before its
+  socket opens.
+- `resources/subscribe` needs `mcp.resources.read` on the slot
+  (`broker.providers.read` on `_broker`); each update is re-checked per
+  recipient, and one that lost the grant is unsubscribed. `resources/unsubscribe`
+  is never refused.
+- Limits: `resourceSubscriptions` in `config.json` (see
+  [config.md](docs/config.md#resourcesubscriptions)), or
+  `withResourceSubscriptionLimits()` on the builder.
+
+A provider built on `@cyanmycelium/mcp-core` 1.3.0 or later answers
+`resources/subscribe` itself; its behaviors only report changes:
+
+```ts
+class GaugeAdapter extends McpAdapterBase {
+    set(value: number): void {
+        this._value = value;
+        this._forwardResourceContentChanged("plant://gauge"); // -> notifications/resources/updated, subscribers only
+    }
+}
+```
+
+## Provider telemetry and OTLP
+
+The complete protocol and deployment contract is in
+[docs/telemetry.md](https://github.com/pandaGaume/mcp-broker/blob/main/docs/telemetry.md).
+
+The optional telemetry extension accepts `broker/telemetry` from any
+provider slot. The broker consumes these notifications itself. It never sends
+them to MCP clients, and it never waits for the exporter while routing requests
+or responses.
+
+The pipeline has explicit bounds. By default it accepts frames up to 64 KiB,
+queues at most 256 spans, exports batches of up to 32, and drops new telemetry
+when the queue is full. `getTelemetryStats()` reports every accepted, exported,
+and dropped span. A trace failure therefore cannot block MCP control traffic.
+
+For the CLI, set the standard OpenTelemetry environment variable:
+
+```sh
+OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://otel-collector:4318/v1/traces mcp-broker
+```
+
+`OTEL_EXPORTER_OTLP_HEADERS` carries optional comma-separated, percent-encoded
+headers. The same settings can be kept in `config.json` under `telemetry`:
+
+```json
+{
+    "telemetry": {
+        "otlpHttpEndpoint": "http://otel-collector:4318/v1/traces",
+        "timeoutMs": 5000,
+        "queueCapacity": 256,
+        "batchSize": 32
+    }
+}
+```
+
+Configure the built-in dependency-free OTLP/HTTP JSON exporter:
+
+```ts
+import { WsTunnelBuilder } from "@cyanmycelium/mcp-broker";
+
+const broker = new WsTunnelBuilder()
+    .withPort(3000)
+    .withOtlpHttpTelemetry(
+        {
+            endpoint: "http://otel-collector:4318/v1/traces",
+            headers: { Authorization: `Bearer ${process.env.OTLP_TOKEN}` },
+        },
+        {
+            queueCapacity: 512,
+            batchSize: 32,
+            onExportError: (error) => console.error("telemetry export failed", error),
+        }
+    )
+    .build();
+```
+
+Or pass any sink with `withTelemetry({ exporter })`. This is useful for a file,
+Kafka, an existing OpenTelemetry SDK, or a deterministic test collector.
+
+Provider wire format:
+
+```json
+{
+    "jsonrpc": "2.0",
+    "method": "broker/telemetry",
+    "params": {
+        "version": 1,
+        "signal": "traces",
+        "span": {
+            "traceId": "0123456789abcdef0123456789abcdef",
+            "spanId": "0123456789abcdef",
+            "parentSpanId": "fedcba9876543210",
+            "name": "modbus.read",
+            "kind": 3,
+            "startTimeUnixNano": "1720000000000000000",
+            "endTimeUnixNano": "1720000000001000000",
+            "attributes": {
+                "modbus.function_code": 3,
+                "network.transport": "tcp"
+            },
+            "events": [
+                {
+                    "name": "pdu.rx",
+                    "timeUnixNano": "1720000000000900000",
+                    "attributes": { "bytes": 9 }
+                }
+            ],
+            "status": { "code": 1 }
+        }
+    }
+}
+```
+
+Trace IDs and parent relationships follow W3C Trace Context representation.
+Every routed request carries the context in `params._meta.traceparent`.
+TypeScript providers can continue it with `traceparentOf()`,
+`childTraceparent()` and `withTraceparent()`, then emit with
+`transport.broker.span(span)`. The exporter produces an OTLP
+`ExportTraceServiceRequest`. `service.name` is the authenticated provider
+principal when available, otherwise the slot. `mcp.provider.slot` always keeps
+the slot, and `mcp.provider.principal` records the authenticated identity. Raw
+protocol payloads are not required by the schema. A provider should emit them
+only when its own runtime trace policy explicitly enables that level of detail.
+
 ## Authorization (OAuth 2.1)
 
 By default the broker performs **no** authentication. That is fine behind a
@@ -709,6 +874,9 @@ covers the failures the broker cannot see from the inside.
 | `-32602 Unknown aggregated tool` | the prefixed name was reconstructed rather than echoed | re-run `tools/list`, pass the name back verbatim |
 | `did not respond within 60000ms` | the provider stayed connected and never answered | raise `providerRequestTimeoutMs`, or fix the provider |
 | `sessionCount` grows and never falls | Streamable HTTP and SSE sessions do not expire | send `DELETE /<slot>/mcp` when a client is done; restart if it is already large |
+| Subscribed, `notifications/resources/updated` never arrives | the update names another URI (exact match), carries no `params.uri` (dropped, logged once), or the read grant was revoked | compare URIs byte for byte; read the broker log |
+| `resources/subscribe` answers `-32601` on a provider slot | the provider does not implement it (mcp-core before 1.3.0 did not) | upgrade the provider |
+| `-32000 Subscription limit reached` | `maxSubscriptionsPerClient` or `maxSubscriptionsPerSlot` | unsubscribe what you no longer watch, or raise `resourceSubscriptions` |
 
 Reading the console: the broker prints one line per accepted WebSocket upgrade
 naming the path, the role the router assigned (`dedicated-provider`,

package/dist/bin.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { PACKAGE_NAME, VERSION, loadBrokerConfig, WsTunnelBuilder, loadMcpbBundle, BROKER_AGGREGATE_NAME, BROKER_PROVIDER_NAME, resolveOpenTarget } from './chunk-J5TN5RYU.js';
+import { loadBrokerConfig, loadSecurityConfig, BrokerConfigError, loadMcpbBundle, resolveOpenTarget } from './chunk-BTWLF6KI.js';
+import { PACKAGE_NAME, VERSION, WsTunnelBuilder, BROKER_AGGREGATE_NAME, BROKER_PROVIDER_NAME } from './chunk-K2EQP4RQ.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import open from 'open';
@@ -59,6 +60,10 @@ PROVIDER LIVENESS
   MCP_BROKER_PROVIDER_REQUEST_TIMEOUT_MS Deadline for one provider answer (default 60000, 0 off)
   MCP_BROKER_PROVIDER_TAKEOVER           reject | liveness | always (default liveness)
 
+PROVIDER TELEMETRY (OpenTelemetry, opt-in)
+  OTEL_EXPORTER_OTLP_TRACES_ENDPOINT     Full OTLP/HTTP endpoint, enables trace export
+  OTEL_EXPORTER_OTLP_HEADERS             Comma-separated percent-encoded key=value headers
+
 AUTHORIZATION (OAuth 2.1, opt-in)
   MCP_BROKER_AUTH_ENABLED     "1" to require bearer tokens on client endpoints
   MCP_BROKER_PUBLIC_BASE_URL  Public origin, e.g. https://mcp.example.com
@@ -87,8 +92,20 @@ Full reference: https://github.com/pandaGaume/mcp-broker/tree/main/node
 `
   );
 }
-var { config, baseDir } = loadBrokerConfig();
+function loadConfigOrExit() {
+  try {
+    const loaded = loadBrokerConfig();
+    return { ...loaded, security: loadSecurityConfig(loaded) };
+  } catch (error) {
+    if (!(error instanceof BrokerConfigError)) throw error;
+    process.stderr.write(`${error.message}
+`);
+    process.exit(1);
+  }
+}
+var { config, baseDir, security } = loadConfigOrExit();
 var cwd = process.cwd();
+var authConfig = security?.security.auth ?? config.auth;
 function envFromConfig(envName, configValue) {
   if (configValue === void 0 || configValue === null) return;
   if (process.env[envName] !== void 0 && process.env[envName] !== "") return;
@@ -107,13 +124,16 @@ envFromConfig("MCP_BROKER_SSE_PATH", config.paths?.sse);
 envFromConfig("MCP_BROKER_MESSAGES_PATH", config.paths?.messages);
 envFromConfig("MCP_BROKER_PROVIDER_HEARTBEAT_MS", config.providerHeartbeatIntervalMs);
 envFromConfig("MCP_BROKER_PROVIDER_REQUEST_TIMEOUT_MS", config.providerRequestTimeoutMs);
+envFromConfig("MCP_BROKER_MAX_SUBSCRIPTIONS_PER_CLIENT", config.resourceSubscriptions?.maxSubscriptionsPerClient);
+envFromConfig("MCP_BROKER_MAX_SUBSCRIPTIONS_PER_SLOT", config.resourceSubscriptions?.maxSubscriptionsPerSlot);
+envFromConfig("MCP_BROKER_MAX_RESOURCE_URI_LENGTH", config.resourceSubscriptions?.maxResourceUriLength);
 envFromConfig("MCP_BROKER_PROVIDER_TAKEOVER", config.providerTakeover);
 envFromConfig("MCP_BROKER_OPEN", config.www?.open === true ? "1" : typeof config.www?.open === "string" ? config.www.open : void 0);
-envFromConfig("MCP_BROKER_AUTH_ENABLED", config.auth?.enabled === true ? "1" : void 0);
-envFromConfig("MCP_BROKER_PUBLIC_BASE_URL", config.auth?.publicBaseUrl);
-envFromConfig("MCP_BROKER_JWKS", config.auth?.jwks);
-envFromConfig("MCP_BROKER_ISSUER", config.auth?.issuer);
-envFromConfig("MCP_BROKER_PROVIDER_SECRET", config.auth?.providerSecret);
+envFromConfig("MCP_BROKER_AUTH_ENABLED", authConfig?.enabled === true ? "1" : void 0);
+envFromConfig("MCP_BROKER_PUBLIC_BASE_URL", authConfig?.publicBaseUrl);
+envFromConfig("MCP_BROKER_JWKS", authConfig?.jwks);
+envFromConfig("MCP_BROKER_ISSUER", authConfig?.issuer);
+envFromConfig("MCP_BROKER_PROVIDER_SECRET", authConfig?.providerSecret);
 var stdioProvider = process.env["MCP_BROKER_STDIO_PROVIDER"];
 if (stdioProvider) {
   const toStderr = (...args) => process.stderr.write(args.join(" ") + "\n");
@@ -130,6 +150,27 @@ var clientPath = process.env["MCP_BROKER_CLIENT_PATH"] ?? "/";
 var mcpPath = process.env["MCP_BROKER_MCP_PATH"] ?? "/mcp";
 var ssePath = process.env["MCP_BROKER_SSE_PATH"] ?? "/sse";
 var messagesPath = process.env["MCP_BROKER_MESSAGES_PATH"] ?? "/messages";
+var otlpTracesEndpoint = process.env["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"] ?? config.telemetry?.otlpHttpEndpoint;
+function otlpHeadersFromEnv(raw) {
+  const headers = {};
+  if (!raw) return headers;
+  for (const field of raw.split(",")) {
+    const separator = field.indexOf("=");
+    if (separator <= 0) {
+      console.warn(`[mcp-broker] Ignoring malformed OTEL_EXPORTER_OTLP_HEADERS field: ${JSON.stringify(field)}.`);
+      continue;
+    }
+    try {
+      const key = decodeURIComponent(field.slice(0, separator).trim());
+      const value = decodeURIComponent(field.slice(separator + 1).trim());
+      if (key) headers[key] = value;
+    } catch {
+      console.warn(`[mcp-broker] Ignoring malformed percent encoding in OTEL_EXPORTER_OTLP_HEADERS field: ${JSON.stringify(field)}.`);
+    }
+  }
+  return headers;
+}
+var otlpHeaders = { ...config.telemetry?.headers ?? {}, ...otlpHeadersFromEnv(process.env["OTEL_EXPORTER_OTLP_HEADERS"]) };
 var tlsCertPath = process.env["MCP_BROKER_TLS_CERT"] ? path.resolve(cwd, process.env["MCP_BROKER_TLS_CERT"]) : config.tls?.cert ? path.resolve(baseDir, config.tls.cert) : null;
 var tlsKeyPath = process.env["MCP_BROKER_TLS_KEY"] ? path.resolve(cwd, process.env["MCP_BROKER_TLS_KEY"]) : config.tls?.key ? path.resolve(baseDir, config.tls.key) : null;
 var protocolOverride = process.env["MCP_BROKER_PROTOCOL"]?.toLowerCase();
@@ -154,6 +195,21 @@ function millisFromEnv(envName) {
 }
 var providerHeartbeatIntervalMs = millisFromEnv("MCP_BROKER_PROVIDER_HEARTBEAT_MS");
 var providerRequestTimeoutMs = millisFromEnv("MCP_BROKER_PROVIDER_REQUEST_TIMEOUT_MS");
+function countFromEnv(envName) {
+  const raw = process.env[envName];
+  if (raw === void 0 || raw.trim() === "") return void 0;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 1) {
+    console.warn(`[mcp-broker] Ignoring ${envName}="${raw}": expected a whole number of at least 1. Using the default.`);
+    return void 0;
+  }
+  return value;
+}
+var resourceSubscriptionLimits = {
+  maxSubscriptionsPerClient: countFromEnv("MCP_BROKER_MAX_SUBSCRIPTIONS_PER_CLIENT"),
+  maxSubscriptionsPerSlot: countFromEnv("MCP_BROKER_MAX_SUBSCRIPTIONS_PER_SLOT"),
+  maxResourceUriLength: countFromEnv("MCP_BROKER_MAX_RESOURCE_URI_LENGTH")
+};
 var takeoverRaw = process.env["MCP_BROKER_PROVIDER_TAKEOVER"]?.trim().toLowerCase();
 var providerTakeover;
 if (takeoverRaw) {
@@ -197,6 +253,34 @@ function warnIfStdioTargetUnknown(target) {
     `[mcp-broker] MCP_BROKER_STDIO_PROVIDER="${target}" names a slot this broker does not host. Nothing answers on it until a WebSocket provider connects to ${providerPath}/${target} (or announces "${target}" on ${providersPath}), and until then every request from the MCP host, including the initial handshake, fails with 'Provider "${target}" not connected'. An MCP host that starts before that provider is up, which is always the case for a provider hosted in a browser page, will therefore never connect. Prefer MCP_BROKER_STDIO_PROVIDER="${BROKER_AGGREGATE_NAME}": it exists from startup, answers the handshake itself, unions every opted-in provider, and pushes notifications/tools/list_changed as providers join, so a page opened later appears live. Slots this broker hosts right now: ${hosted.length > 0 ? hosted.map((n) => `"${n}"`).join(", ") + `, plus the reserved "${BROKER_AGGREGATE_NAME}" and "${BROKER_PROVIDER_NAME}"` : `the reserved "${BROKER_AGGREGATE_NAME}" and "${BROKER_PROVIDER_NAME}" only`}.`
   );
 }
+function telemetryExportLogger(intervalMs = 6e4) {
+  let failures = 0;
+  let suppressed = 0;
+  let lastReport = 0;
+  return {
+    error(error) {
+      failures++;
+      const now = Date.now();
+      if (lastReport === 0 || now - lastReport >= intervalMs) {
+        const suffix = suppressed > 0 ? ` (${suppressed} repeated failure(s) suppressed)` : "";
+        console.error(`[mcp-broker] telemetry export failed: ${error.message}${suffix}`);
+        lastReport = now;
+        suppressed = 0;
+      } else {
+        suppressed++;
+      }
+    },
+    success(recordCount) {
+      if (failures === 0) return;
+      console.info(
+        `[mcp-broker] telemetry export recovered after ${failures} failed batch(es)${suppressed > 0 ? `, ${suppressed} repeated log line(s) suppressed` : ""}; exported ${recordCount} span(s).`
+      );
+      failures = 0;
+      suppressed = 0;
+      lastReport = 0;
+    }
+  };
+}
 async function main() {
   const localGrammarsDir = path.join(baseDir, "grammars");
   const hasLocalGrammars = fs.existsSync(localGrammarsDir);
@@ -210,9 +294,33 @@ async function main() {
   if (providerRequestTimeoutMs !== void 0) {
     builder.withProviderRequestTimeout(providerRequestTimeoutMs);
   }
+  const limits = Object.fromEntries(Object.entries(resourceSubscriptionLimits).filter(([, v]) => v !== void 0));
+  if (Object.keys(limits).length > 0) {
+    builder.withResourceSubscriptionLimits(limits);
+  }
   if (providerTakeover) {
     builder.withProviderTakeover(providerTakeover);
   }
+  if (otlpTracesEndpoint) {
+    const exportLog = telemetryExportLogger();
+    builder.withOtlpHttpTelemetry(
+      {
+        endpoint: otlpTracesEndpoint,
+        headers: otlpHeaders,
+        timeoutMs: config.telemetry?.timeoutMs,
+        serviceNamespace: config.telemetry?.serviceNamespace
+      },
+      {
+        maxFrameBytes: config.telemetry?.maxFrameBytes,
+        queueCapacity: config.telemetry?.queueCapacity,
+        batchSize: config.telemetry?.batchSize,
+        maxAttributes: config.telemetry?.maxAttributes,
+        maxEvents: config.telemetry?.maxEvents,
+        onExportError: exportLog.error,
+        onExportSuccess: exportLog.success
+      }
+    );
+  }
   if (useTls) {
     try {
       builder.withTlsFiles(tlsCertPath, tlsKeyPath);
@@ -284,7 +392,7 @@ async function main() {
     const publicBaseUrl = process.env["MCP_BROKER_PUBLIC_BASE_URL"];
     const jwks = process.env["MCP_BROKER_JWKS"];
     const issuer = process.env["MCP_BROKER_ISSUER"];
-    const authorizationServers = config.auth?.authorizationServers ?? (issuer ? [issuer] : []);
+    const authorizationServers = authConfig?.authorizationServers ?? (issuer ? [issuer] : []);
     if (!publicBaseUrl || !jwks || authorizationServers.length === 0) {
       console.error(
         "[mcp-broker] auth.enabled requires publicBaseUrl, jwks, and at least one authorizationServers entry (or issuer). Set them via config.auth or MCP_BROKER_PUBLIC_BASE_URL / MCP_BROKER_JWKS / MCP_BROKER_ISSUER."
@@ -296,25 +404,37 @@ async function main() {
       authorizationServers,
       jwksUri: jwks,
       issuer,
-      scopesSupported: config.auth?.scopesSupported,
-      requiredScopes: config.auth?.requiredScopes,
-      perSlotScopes: config.auth?.perSlotScopes,
-      providerScopes: config.auth?.providerScopes,
-      subjectMapping: config.auth?.subjectMapping,
-      roles: config.auth?.roles,
-      assignments: config.auth?.assignments,
-      denies: config.auth?.denies,
-      slotResources: config.auth?.slotResources,
-      toolCapabilities: config.auth?.toolCapabilities,
-      providerToolCapabilities: config.auth?.providerToolCapabilities,
-      audit: config.auth?.audit
+      scopesSupported: authConfig?.scopesSupported,
+      requiredScopes: authConfig?.requiredScopes,
+      perSlotScopes: authConfig?.perSlotScopes,
+      providerScopes: authConfig?.providerScopes,
+      subjectMapping: authConfig?.subjectMapping,
+      roles: authConfig?.roles,
+      assignments: authConfig?.assignments,
+      denies: authConfig?.denies,
+      slotResources: authConfig?.slotResources,
+      toolCapabilities: authConfig?.toolCapabilities,
+      providerToolCapabilities: authConfig?.providerToolCapabilities,
+      audit: authConfig?.audit
     });
   }
   const providerSecret = process.env["MCP_BROKER_PROVIDER_SECRET"];
   if (providerSecret) {
     builder.withProviderSecret(providerSecret);
   }
-  const tunnel = builder.build();
+  let tunnel;
+  try {
+    if (security) {
+      if (security.credentials.length > 0) builder.withProviderPrincipals(security.credentials);
+      const protectedSlots = security.security.authorization?.protectedSlots;
+      if (protectedSlots && Object.keys(protectedSlots).length > 0) builder.withProtectedSlots(protectedSlots);
+      builder.withSecurityVersion(security.version);
+    }
+    tunnel = builder.build();
+  } catch (error) {
+    console.error(`[mcp-broker] ${error.message}`);
+    process.exit(1);
+  }
   await tunnel.start();
   const httpScheme = useTls ? "https" : "http";
   const wsScheme = useTls ? "wss" : "ws";
@@ -343,12 +463,20 @@ async function main() {
     console.log(`\u{1F310}  Local grammars        ${localGrammarsDir}`);
   }
   console.log(`\u{1F510}  Authorization         ${authEnabled ? "OAuth 2.1 (Bearer required)" : "disabled (trusted network only)"}`);
-  console.log(`\u{1F6E1}\uFE0F   Provider auth         ${providerSecret ? "shared secret required" : "disabled"}`);
+  const providerIdentities = security?.credentials.length ?? 0;
+  console.log(
+    `\u{1F6E1}\uFE0F   Provider auth         ${providerIdentities > 0 ? `${providerIdentities} provider identit${providerIdentities === 1 ? "y" : "ies"}${providerSecret ? " + shared secret" : ""}` : providerSecret ? "shared secret required" : "disabled"}`
+  );
+  if (security) {
+    const protectedCount = Object.keys(security.security.authorization?.protectedSlots ?? {}).length;
+    console.log(`\u{1F50F}  Security file         ${security.sourcePath} (version ${security.version}${protectedCount > 0 ? `, ${protectedCount} protected slot(s)` : ""})`);
+  }
   console.log(`\u{1F30D}  Browser origins       ${describeAllowedOrigins()}`);
   console.log(`                          enforced on /<name>/${mcpSuffix}, /<name>/${sseSuffix} and /<name>/${messagesSuffix}`);
   if (!allowedOrigins) {
     console.log(`                          a page this broker serves is refused too, list its origin to admit it`);
   }
+  console.log(`\u{1F4C8}  Provider telemetry    ${otlpTracesEndpoint ? `OTLP/HTTP to ${otlpTracesEndpoint}` : "disabled"}`);
   console.log(hr);
   console.log(`   New here? Call broker_guide on the ${BROKER_PROVIDER_NAME} slot: ${localhost}/${BROKER_PROVIDER_NAME}/${mcpSuffix}`);
   console.log(`   Press Ctrl+C to stop.`);