@cat-factory/server 0.296.0 → 0.298.0

package/dist/modules/publicApi/openapiDocument.generated.js.map

@@ -1 +1 @@
-{"version":3,"file":"openapiDocument.generated.js","sourceRoot":"","sources":["../../../src/modules/publicApi/openapiDocument.generated.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,EAAE;AACF,0FAA0F;AAC1F,8FAA8F;AAC9F,8FAA8F;AAC9F,8EAA8E;AAE9E,MAAM,CAAC,MAAM,YAAY,GAAG,ouwrBAAouwrB,CAAA"}
+{"version":3,"file":"openapiDocument.generated.js","sourceRoot":"","sources":["../../../src/modules/publicApi/openapiDocument.generated.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,EAAE;AACF,0FAA0F;AAC1F,8FAA8F;AAC9F,8FAA8F;AAC9F,8EAA8E;AAE9E,MAAM,CAAC,MAAM,YAAY,GAAG,0mvsBAA0mvsB,CAAA"}

package/dist/modules/toolServers/mcpDialect.d.ts

@@ -0,0 +1,130 @@
+/** The modern revision the probe opens with. */
+export declare const MODERN_PROTOCOL_VERSION = "2026-07-28";
+/**
+ * Every modern revision this client can speak, newest first. A server answering
+ * `UnsupportedProtocolVersionError` lists what it supports, and this is what that list is
+ * intersected against: a version outside it is one whose per-request shape we have not implemented,
+ * so agreeing to it would be a handshake we could not follow.
+ */
+export declare const MODERN_PROTOCOL_VERSIONS: readonly string[];
+/** The legacy revision the fallback handshake asks for. Negotiated, so a server may answer older. */
+export declare const LEGACY_PROTOCOL_VERSION = "2025-11-25";
+/** What the probe identifies itself as, on every modern request and in the legacy handshake. */
+export declare const CLIENT_INFO: {
+    readonly name: 'cat-factory-tool-server-probe';
+    readonly version: '1';
+};
+/** Which dialect the exchange is speaking. Decided once per server, then held for every request. */
+export type McpEra = {
+    era: 'modern';
+    version: string;
+} | {
+    era: 'legacy';
+};
+export declare const MODERN_ERA: {
+    readonly era: 'modern';
+    readonly version: "2026-07-28";
+};
+export declare const LEGACY_ERA: {
+    readonly era: 'legacy';
+};
+/**
+ * The params one request carries.
+ *
+ * Modern: the caller's params plus the `_meta` block, on EVERY request rather than once at a
+ * handshake. `clientCapabilities: {}` is honest and load-bearing, exactly as the legacy
+ * `capabilities: {}` was: this client implements no roots, no sampling and no elicitation.
+ */
+export declare function requestParams(era: McpEra, params?: Record<string, unknown>): Record<string, unknown> | undefined;
+/**
+ * The headers the dialect adds to a POST.
+ *
+ * `Mcp-Method` is REQUIRED on every modern request and is validated against the body under penalty
+ * of `-32020 HeaderMismatch`, so it is derived from the method rather than passed beside it.
+ * `Mcp-Name` is required only for `tools/call`, `resources/read` and `prompts/get`: a probe calls
+ * none of them, and sending a name for a method that has none is itself a mismatch.
+ * `MCP-Protocol-Version` must equal the body's `_meta` version, which is why both read the same
+ * `era.version`.
+ */
+export declare function dialectHeaders(era: McpEra, method: string): Record<string, string>;
+/** The `initialize` params of the legacy handshake. */
+export declare function legacyInitializeParams(): Record<string, unknown>;
+export interface ServerIdentity {
+    serverName: string;
+    serverVersion: string;
+}
+/**
+ * The server's self-reported identity out of a modern result's `_meta`, or undefined when it sent
+ * none. Only SHOULD-level in the modern revision, so its absence is not a fault: it is a name the
+ * surface renders, and refusing an otherwise complete probe over a missing display string would
+ * report a working server as broken.
+ */
+export declare function readModernServerInfo(result: Record<string, unknown>): ServerIdentity | undefined;
+/**
+ * A `server/discover` result, or undefined when the answer was not one. `supportedVersions` is the
+ * field that makes the answer PROOF of a modern MCP server: a JSON-RPC endpoint that is something
+ * else entirely answers 200 with a result that has none, and that is the case the caller must not
+ * read as a successful probe.
+ */
+export declare function readDiscoverResult(result: Record<string, unknown>): {
+    supportedVersions: string[];
+    identity?: ServerIdentity;
+} | undefined;
+/** Which revision to speak, given the list a server named. */
+export type VersionChoice = 
+/** Speak this one: either the server left what we asked standing, or it named one we implement. */
+{
+    choice: 'speak';
+    version: string;
+}
+/** Nothing modern is mutual, but the server named a handshake-era revision. Fall back. */
+ | {
+    choice: 'legacy';
+}
+/** The two sides share no revision at all. Say so, naming both lists. */
+ | {
+    choice: 'mismatch';
+    error: string;
+};
+/**
+ * Reconcile the revisions a server named with the ones this client speaks.
+ *
+ * Two callers ask, and the whole point is that they cannot answer differently: a successful
+ * `server/discover`, whose `supportedVersions` is the list the modern revision publishes it FOR,
+ * and an `UnsupportedProtocolVersionError`, which names the same list on the way out. The refusal
+ * passes no `asked`, because the version it would name is the one the server just rejected.
+ *
+ * A named handshake-era revision means fall back rather than report: the legacy `initialize` is a
+ * dialect this client speaks, so refusing a server that just said it speaks `2025-11-25` while
+ * listing `2025-11-25` among our own revisions is a contradiction the operator cannot act on.
+ */
+export declare function chooseProtocolVersion(supported: readonly string[], asked?: string): VersionChoice;
+/** What a refused modern attempt means for which dialect to speak next. */
+export type EraVerdict = 
+/** A modern server refused the VERSION and named what it speaks. Retry with this one. */
+{
+    verdict: 'retry';
+    version: string;
+}
+/** The refusal is a modern server's, and no version we speak is on offer. Report it. */
+ | {
+    verdict: 'report';
+    error: string;
+}
+/** Nothing modern answered. Fall back to the `initialize` handshake. */
+ | {
+    verdict: 'legacy';
+};
+/**
+ * Read a refusal of the modern `server/discover` and decide what it says about the server's ERA.
+ *
+ * The spec's rule for Streamable HTTP is to attempt a modern request and inspect the BODY of a 4xx,
+ * because a modern server also answers 400 for an unsupported version, a missing client capability
+ * and a header mismatch. This widens that in one direction the spec's prose does not spell out but
+ * its own compatibility matrix does: a legacy server may refuse an unknown method at HTTP 200 with
+ * a JSON-RPC `-32601`, or refuse it as "not initialized", and neither is a 4xx. Every refusal that
+ * is not one of the three MCP-reserved codes therefore means "not modern", and the fallback is what
+ * decides whether the server is legacy or not an MCP server at all.
+ */
+export declare function readEraVerdict(frame: Record<string, unknown> | undefined): EraVerdict;
+//# sourceMappingURL=mcpDialect.d.ts.map

package/dist/modules/toolServers/mcpDialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpDialect.d.ts","sourceRoot":"","sources":["../../../src/modules/toolServers/mcpDialect.ts"],"names":[],"mappings":"AAsBA,gDAAgD;AAChD,eAAO,MAAM,uBAAuB,eAAe,CAAA;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,SAAS,MAAM,EAA8B,CAAA;AAEpF,qGAAqG;AACrG,eAAO,MAAM,uBAAuB,eAAe,CAAA;AAkCnD,gGAAgG;AAChG,eAAO,MAAM,WAAW;aAAK,IAAI,EAAE,+BAA+B;aAAE,OAAO,EAAE,GAAG;CAAW,CAAA;AAE3F,oGAAoG;AACpG,MAAM,MAAM,MAAM,GAAG;IAAE,GAAG,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,QAAQ,CAAA;CAAE,CAAA;AAE3E,eAAO,MAAM,UAAU;kBAChB,QAAQ;;CAEY,CAAA;AAC3B,eAAO,MAAM,UAAU;kBAAU,QAAQ;CAA4B,CAAA;AAErE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAUrC;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAGlF;AAED,uDAAuD;AACvD,wBAAgB,sBAAsB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMhE;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,cAAc,GAAG,SAAS,CAQhG;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B;IAAE,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,cAAc,CAAA;CAAE,GAAG,SAAS,CAQxE;AAED,8DAA8D;AAC9D,MAAM,MAAM,aAAa;AACvB,mGAAmG;AACjG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AACtC,0FAA0F;GACxF;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE;AACtB,yEAAyE;GACvE;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzC;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAejG;AAED,2EAA2E;AAC3E,MAAM,MAAM,UAAU;AACpB,yFAAyF;AACvF;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AACvC,wFAAwF;GACtF;IAAE,OAAO,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACtC,wEAAwE;GACtE;IAAE,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAA;AAEzB;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,UAAU,CAuBrF"}

package/dist/modules/toolServers/mcpDialect.js

@@ -0,0 +1,210 @@
+// ---------------------------------------------------------------------------
+// What an MCP request LOOKS like, per protocol era, and how a refusal tells the two eras apart.
+//
+// Revision `2026-07-28` did not extend the protocol the probe was written against, it deleted its
+// spine: there is no `initialize`, no `notifications/initialized` and no `Mcp-Session-Id`. A modern
+// request instead carries its protocol version, client identity and client capabilities in `_meta`
+// on EVERY call, mirrors its method into an `Mcp-Method` header, and asks a dedicated
+// `server/discover` RPC for the identity the handshake used to return. The spec's own compatibility
+// matrix rates a legacy client against a modern server as "Fails", with no fall-forward, which is
+// why speaking only the old dialect is a break rather than drift.
+//
+// Both eras are still live in the wild, so the probe is DUAL-ERA: it opens modern and falls back,
+// which is the direction the spec prescribes for Streamable HTTP (attempt a modern request, inspect
+// the body of a 4xx before falling back). This module owns the two dialects as pure functions, so
+// the transport beside it stays about fetch, redirects and body reading.
+//
+// Read 2026-08-18:
+//   https://modelcontextprotocol.io/specification/2026-07-28/basic/versioning
+//   https://modelcontextprotocol.io/specification/2026-07-28/basic/transports/streamable-http
+//   https://modelcontextprotocol.io/specification/2026-07-28/server/discover
+// ---------------------------------------------------------------------------
+/** The modern revision the probe opens with. */
+export const MODERN_PROTOCOL_VERSION = '2026-07-28';
+/**
+ * Every modern revision this client can speak, newest first. A server answering
+ * `UnsupportedProtocolVersionError` lists what it supports, and this is what that list is
+ * intersected against: a version outside it is one whose per-request shape we have not implemented,
+ * so agreeing to it would be a handshake we could not follow.
+ */
+export const MODERN_PROTOCOL_VERSIONS = [MODERN_PROTOCOL_VERSION];
+/** The legacy revision the fallback handshake asks for. Negotiated, so a server may answer older. */
+export const LEGACY_PROTOCOL_VERSION = '2025-11-25';
+/**
+ * The revision at which the modern dialect BEGINS: `2026-07-28` is the one that deleted the
+ * `initialize` handshake, so every earlier revision is handshake-era by definition.
+ *
+ * A fact about the SPEC, which is why it is not derived from `MODERN_PROTOCOL_VERSIONS`: that list
+ * says only which modern revisions this client has implemented, so a future revision we have not
+ * caught up with yet is still modern and must not be mistaken for one the handshake can reach.
+ * Revisions are `YYYY-MM-DD`, which orders lexicographically.
+ */
+const FIRST_MODERN_REVISION = '2026-07-28';
+/** Whether a revision a server named is one the legacy `initialize` handshake could speak. */
+function isLegacyRevision(version) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(version) && version < FIRST_MODERN_REVISION;
+}
+/** The `_meta` keys the modern revision reserves. Prefixed by the spec, not by us. */
+const META_PROTOCOL_VERSION = 'io.modelcontextprotocol/protocolVersion';
+const META_CLIENT_INFO = 'io.modelcontextprotocol/clientInfo';
+const META_CLIENT_CAPABILITIES = 'io.modelcontextprotocol/clientCapabilities';
+const META_SERVER_INFO = 'io.modelcontextprotocol/serverInfo';
+/**
+ * The MCP error codes the spec reserves for itself, which is what makes a 400 readable as "a modern
+ * server refused this" rather than "an older server did not understand it". `-32601` is deliberately
+ * NOT here: it is JSON-RPC's own "method not found", which a legacy server answers to
+ * `server/discover` precisely because it is not modern.
+ */
+const HEADER_MISMATCH = -32020;
+const MISSING_REQUIRED_CLIENT_CAPABILITY = -32021;
+const UNSUPPORTED_PROTOCOL_VERSION = -32022;
+/** What the probe identifies itself as, on every modern request and in the legacy handshake. */
+export const CLIENT_INFO = { name: 'cat-factory-tool-server-probe', version: '1' };
+export const MODERN_ERA = {
+    era: 'modern',
+    version: MODERN_PROTOCOL_VERSION,
+};
+export const LEGACY_ERA = { era: 'legacy' };
+/**
+ * The params one request carries.
+ *
+ * Modern: the caller's params plus the `_meta` block, on EVERY request rather than once at a
+ * handshake. `clientCapabilities: {}` is honest and load-bearing, exactly as the legacy
+ * `capabilities: {}` was: this client implements no roots, no sampling and no elicitation.
+ */
+export function requestParams(era, params) {
+    if (era.era === 'legacy')
+        return params;
+    return {
+        ...params,
+        _meta: {
+            [META_PROTOCOL_VERSION]: era.version,
+            [META_CLIENT_INFO]: CLIENT_INFO,
+            [META_CLIENT_CAPABILITIES]: {},
+        },
+    };
+}
+/**
+ * The headers the dialect adds to a POST.
+ *
+ * `Mcp-Method` is REQUIRED on every modern request and is validated against the body under penalty
+ * of `-32020 HeaderMismatch`, so it is derived from the method rather than passed beside it.
+ * `Mcp-Name` is required only for `tools/call`, `resources/read` and `prompts/get`: a probe calls
+ * none of them, and sending a name for a method that has none is itself a mismatch.
+ * `MCP-Protocol-Version` must equal the body's `_meta` version, which is why both read the same
+ * `era.version`.
+ */
+export function dialectHeaders(era, method) {
+    if (era.era === 'legacy')
+        return {};
+    return { 'mcp-protocol-version': era.version, 'mcp-method': method };
+}
+/** The `initialize` params of the legacy handshake. */
+export function legacyInitializeParams() {
+    return {
+        protocolVersion: LEGACY_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: CLIENT_INFO,
+    };
+}
+/**
+ * The server's self-reported identity out of a modern result's `_meta`, or undefined when it sent
+ * none. Only SHOULD-level in the modern revision, so its absence is not a fault: it is a name the
+ * surface renders, and refusing an otherwise complete probe over a missing display string would
+ * report a working server as broken.
+ */
+export function readModernServerInfo(result) {
+    const meta = isRecord(result._meta) ? result._meta : undefined;
+    const info = meta && isRecord(meta[META_SERVER_INFO]) ? meta[META_SERVER_INFO] : undefined;
+    if (!info)
+        return undefined;
+    return {
+        serverName: typeof info.name === 'string' ? info.name : '',
+        serverVersion: typeof info.version === 'string' ? info.version : '',
+    };
+}
+/**
+ * A `server/discover` result, or undefined when the answer was not one. `supportedVersions` is the
+ * field that makes the answer PROOF of a modern MCP server: a JSON-RPC endpoint that is something
+ * else entirely answers 200 with a result that has none, and that is the case the caller must not
+ * read as a successful probe.
+ */
+export function readDiscoverResult(result) {
+    const versions = result.supportedVersions;
+    if (!Array.isArray(versions))
+        return undefined;
+    const identity = readModernServerInfo(result);
+    return {
+        supportedVersions: versions.filter((v) => typeof v === 'string'),
+        ...(identity ? { identity } : {}),
+    };
+}
+/**
+ * Reconcile the revisions a server named with the ones this client speaks.
+ *
+ * Two callers ask, and the whole point is that they cannot answer differently: a successful
+ * `server/discover`, whose `supportedVersions` is the list the modern revision publishes it FOR,
+ * and an `UnsupportedProtocolVersionError`, which names the same list on the way out. The refusal
+ * passes no `asked`, because the version it would name is the one the server just rejected.
+ *
+ * A named handshake-era revision means fall back rather than report: the legacy `initialize` is a
+ * dialect this client speaks, so refusing a server that just said it speaks `2025-11-25` while
+ * listing `2025-11-25` among our own revisions is a contradiction the operator cannot act on.
+ */
+export function chooseProtocolVersion(supported, asked) {
+    // The server ANSWERED the request that carried `asked` and named nothing that displaces it, so
+    // that revision is settled: an empty list is a server publishing no opinion, not a refusal.
+    if (asked && (supported.length === 0 || supported.includes(asked))) {
+        return { choice: 'speak', version: asked };
+    }
+    const mutual = MODERN_PROTOCOL_VERSIONS.find((version) => supported.includes(version));
+    if (mutual)
+        return { choice: 'speak', version: mutual };
+    if (supported.some(isLegacyRevision))
+        return { choice: 'legacy' };
+    return {
+        choice: 'mismatch',
+        error: `the server supports MCP ${supported.join(', ') || '(none named)'} and this deployment ` +
+            `speaks ${[...MODERN_PROTOCOL_VERSIONS, LEGACY_PROTOCOL_VERSION].join(', ')}`,
+    };
+}
+/**
+ * Read a refusal of the modern `server/discover` and decide what it says about the server's ERA.
+ *
+ * The spec's rule for Streamable HTTP is to attempt a modern request and inspect the BODY of a 4xx,
+ * because a modern server also answers 400 for an unsupported version, a missing client capability
+ * and a header mismatch. This widens that in one direction the spec's prose does not spell out but
+ * its own compatibility matrix does: a legacy server may refuse an unknown method at HTTP 200 with
+ * a JSON-RPC `-32601`, or refuse it as "not initialized", and neither is a 4xx. Every refusal that
+ * is not one of the three MCP-reserved codes therefore means "not modern", and the fallback is what
+ * decides whether the server is legacy or not an MCP server at all.
+ */
+export function readEraVerdict(frame) {
+    const error = frame && isRecord(frame.error) ? frame.error : undefined;
+    const code = typeof error?.code === 'number' ? error.code : undefined;
+    if (code === UNSUPPORTED_PROTOCOL_VERSION) {
+        const supported = isRecord(error?.data) && Array.isArray(error.data.supported)
+            ? error.data.supported.filter((v) => typeof v === 'string')
+            : [];
+        const choice = chooseProtocolVersion(supported);
+        if (choice.choice === 'speak')
+            return { verdict: 'retry', version: choice.version };
+        // A server that named a handshake-era revision gets the handshake. Only a server naming
+        // nothing either side speaks is reported, and then with both lists, because there is no
+        // second dialect left to ask in.
+        if (choice.choice === 'legacy')
+            return { verdict: 'legacy' };
+        return { verdict: 'report', error: choice.error };
+    }
+    if (code === HEADER_MISMATCH || code === MISSING_REQUIRED_CLIENT_CAPABILITY) {
+        // A modern server refusing a modern request on grounds this client controls. Reported rather
+        // than retried: the fix is here, and falling back would hide it behind a legacy handshake.
+        const message = typeof error?.message === 'string' ? error.message : `JSON-RPC error ${code}`;
+        return { verdict: 'report', error: `the server refused the request: ${message}` };
+    }
+    return { verdict: 'legacy' };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=mcpDialect.js.map

package/dist/modules/toolServers/mcpDialect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpDialect.js","sourceRoot":"","sources":["../../../src/modules/toolServers/mcpDialect.ts"],"names":[],"mappings":"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"}

package/dist/modules/toolServers/mcpProbe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcpProbe.d.ts","sourceRoot":"","sources":["../../../src/modules/toolServers/mcpProbe.ts"],"names":[],"mappings":"AAiEA,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B;;;;;;OAMG;IACH,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1C;AAED,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,IAAI,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;IACrB,yFAAyF;IACzF,eAAe,EAAE,MAAM,CAAA;IACvB,8EAA8E;IAC9E,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,sFAAsF;IACtF,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,MAAM,eAAe,GACvB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,MAAM,EAAE,gBAAgB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/C,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,eAAe,CAAA;AAO/D;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,eAAe,CAAC,CAoB1B"}
+{"version":3,"file":"mcpProbe.d.ts","sourceRoot":"","sources":["../../../src/modules/toolServers/mcpProbe.ts"],"names":[],"mappings":"AA0EA,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B;;;;;;OAMG;IACH,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC1C;AAED,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,KAAK,CAAC,EAAE,OAAO,KAAK,CAAA;IACpB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,IAAI,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;IACrB,yFAAyF;IACzF,eAAe,EAAE,MAAM,CAAA;IACvB,8EAA8E;IAC9E,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,sFAAsF;IACtF,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,MAAM,eAAe,GACvB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,MAAM,EAAE,gBAAgB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/C,MAAM,MAAM,eAAe,GAAG,eAAe,GAAG,eAAe,CAAA;AAa/D;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,cAAc,EACtB,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,eAAe,CAAC,CAwB1B"}