@namzu/sdk 40.0.0 → 42.0.0

package/dist/connector/mcp/era.js

@@ -0,0 +1,304 @@
+import { JSON_RPC_METHOD_NOT_FOUND, MCP_LEGACY_VERSIONS, MCP_META_SERVER_INFO, MCP_MODERN_HTTP_FALLBACK_STATUSES, MCP_MODERN_VERSIONS, MCP_SUPPORTED_PROTOCOL_VERSIONS, } from '../../constants/mcp/index.js';
+import { MCPHttpStatusError, MCPProtocolError, isHeaderMismatchError, isMissingRequiredClientCapabilityError, isUnsupportedProtocolVersionError, protocolErrorFromReply, } from './errors.js';
+/**
+ * Is this the answer of a server that speaks the modern protocol?
+ *
+ * The spec is explicit that a fallback MUST NOT be keyed to one specific
+ * error code, because a legacy server refuses an unknown method with
+ * whatever its implementation happens to use — commonly `-32601`, commonly
+ * `-32602`, sometimes something else entirely, sometimes silence. So the
+ * question is never "was this `-32601`?"; it is "did the peer answer in a
+ * vocabulary only a modern server has?" — which is what these three codes
+ * are. Everything else, including a code this client has never seen, means
+ * fall back.
+ */
+export function isRecognizedModernError(error) {
+    return (isUnsupportedProtocolVersionError(error) ||
+        isMissingRequiredClientCapabilityError(error) ||
+        isHeaderMismatchError(error));
+}
+/**
+ * Read a failed HTTP response for evidence of a modern server.
+ *
+ * `400`, `404` and `405` are the statuses a legacy origin answers a modern
+ * request with — and also the statuses a MODERN origin uses for a request
+ * it understands but will not serve. The body decides. A `404` whose body
+ * is a JSON-RPC `-32601` is a modern server saying "no such method", which
+ * the spec calls out precisely so it is not mistaken for the `404` of an
+ * origin that has never heard of the protocol.
+ *
+ * `-32601` counts ONLY on a `404`. On a `400` or `405` it is an ordinary
+ * unimplemented-method answer that any server of any era can send, and
+ * reading it as proof of modernity there would strand this client on a
+ * legacy origin with no way back.
+ */
+export function classifyModernHttpFailure(status, bodyText) {
+    if (!MCP_MODERN_HTTP_FALLBACK_STATUSES.includes(status))
+        return { kind: 'legacy' };
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch {
+        // An HTML error page, an empty body, a proxy's plain-text notice:
+        // none of them are a server answering in JSON-RPC at all.
+        return { kind: 'legacy' };
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return { kind: 'legacy' };
+    const error = parsed.error;
+    if (!error)
+        return { kind: 'legacy' };
+    const reason = protocolErrorFromReply(error);
+    if (isRecognizedModernError(reason))
+        return { kind: 'modern', error: reason };
+    if (status === 404 &&
+        reason instanceof MCPProtocolError &&
+        reason.code === JSON_RPC_METHOD_NOT_FOUND) {
+        return { kind: 'modern', error: reason };
+    }
+    return { kind: 'legacy' };
+}
+/** A cache that remembers nothing outside this object. */
+export function createMcpEraCache() {
+    const entries = new Map();
+    return {
+        get: (key) => entries.get(key),
+        set: (key, era) => {
+            entries.set(key, era);
+        },
+        delete: (key) => {
+            entries.delete(key);
+        },
+    };
+}
+/**
+ * The cache every `MCPClient` shares unless it was given its own.
+ *
+ * Process-wide on purpose: two clients reaching the same origin should not
+ * each pay a probe. Injectable on purpose too — a suite that shared this
+ * one would leak era state between cases and become order-dependent, which
+ * is the failure mode a conformance suite can least afford.
+ */
+export const defaultMcpEraCache = createMcpEraCache();
+/**
+ * What a cached era belongs to: an HTTP origin, or a stdio process
+ * identity.
+ *
+ * Path and query are deliberately dropped from an HTTP URL. Era is a
+ * property of the server behind the origin, not of one endpoint on it, and
+ * keying per URL would re-probe every path of the same deployment.
+ *
+ * Two things the key deliberately does and does not fold together:
+ *
+ * - `streamable_http` and `streamable-http` are two spellings of ONE
+ *   transport, so they key together. An origin probed under one spelling is
+ *   the same origin under the other, and keying them apart would probe it
+ *   twice and let one half of the process believe something the other half
+ *   had already disproved.
+ * - `http-sse` keys APART from those two, on the same origin. It is the
+ *   2024-11-05 transport and is never probed at all, so it records a legacy
+ *   era it never tested; a Streamable HTTP client reading that entry would
+ *   skip its own probe on the strength of an answer nobody asked for.
+ */
+export function mcpEraCacheKey(transport) {
+    if (transport.type === 'stdio') {
+        // JSON rather than a joined string: an argument containing the
+        // separator would otherwise make two different commands share a key.
+        // `cwd` is part of the process identity because a relative command or
+        // script path resolves against it — `node ./dist/server.js` run in two
+        // directories is two servers, and they need not be the same revision.
+        // `env` is not: it is where credentials live, and a key is a string
+        // this process keeps in a Map for its lifetime.
+        return `stdio ${JSON.stringify([transport.cwd ?? '', transport.command, ...(transport.args ?? [])])}`;
+    }
+    const family = transport.type === 'http-sse' ? 'http-sse' : 'streamable-http';
+    try {
+        return `${family} ${new URL(transport.url).origin}`;
+    }
+    catch {
+        // A URL this client cannot parse is one the transport will fail on
+        // anyway; keying by the raw string keeps this function total.
+        return `${family} ${transport.url}`;
+    }
+}
+const NEWEST_LEGACY = MCP_LEGACY_VERSIONS[0];
+const NEWEST_MODERN = MCP_MODERN_VERSIONS[0];
+const LEGACY_ERA = { kind: 'legacy', version: NEWEST_LEGACY };
+function isModernVersion(version) {
+    return MCP_MODERN_VERSIONS.includes(version);
+}
+/**
+ * The newest version both sides can speak, or `undefined` when there is
+ * none.
+ *
+ * Intersection, never "take the server's newest": offering a version this
+ * client has not implemented produces a malformed exchange later instead of
+ * a clean negotiation failure now.
+ */
+function newestMutuallySupported(offered) {
+    const mutual = offered.filter((version) => typeof version === 'string' && MCP_SUPPORTED_PROTOCOL_VERSIONS.includes(version));
+    // Every version is a `YYYY-MM-DD` literal, so lexicographic order is
+    // chronological order.
+    return mutual.sort().at(-1);
+}
+function supportedVersionsFrom(data) {
+    const supported = data?.supported;
+    return Array.isArray(supported) ? supported : [];
+}
+/**
+ * Is this success reply actually a `DiscoverResult`?
+ *
+ * Strict on purpose. The spec says a `2xx` means modern, but a `2xx` whose
+ * body is not a discover result is not evidence of anything — it is a
+ * legacy server that answers unknown methods with `{}` rather than an
+ * error, and treating that as a modern origin would leave the client
+ * sending `_meta` to a peer that has never heard of it. A reply with no
+ * version list is not proof, so it is not taken as proof.
+ */
+function asDiscoverResult(result) {
+    if (typeof result !== 'object' || result === null)
+        return undefined;
+    const candidate = result;
+    if (!Array.isArray(candidate.supportedVersions))
+        return undefined;
+    if (candidate.supportedVersions.length === 0)
+        return undefined;
+    return candidate;
+}
+/** The server info a modern peer carries under the reserved `_meta` key. */
+export function serverInfoFromDiscover(discover) {
+    const info = discover?._meta?.[MCP_META_SERVER_INFO];
+    if (typeof info !== 'object' || info === null)
+        return undefined;
+    const { name, version } = info;
+    if (typeof name !== 'string' || name.length === 0)
+        return undefined;
+    return typeof version === 'string' ? { name, version } : { name };
+}
+function disjointVersionsError(serverName, offered) {
+    const theirs = offered.length > 0 ? offered.map((v) => String(v)).join(', ') : '(none named)';
+    return new Error(`MCP server "${serverName}" supports no protocol version this client speaks ` +
+        `(server: ${theirs}; supported: ${MCP_SUPPORTED_PROTOCOL_VERSIONS.join(', ')}).`);
+}
+function classifyAnswer(answer, attempted, serverName) {
+    if (answer.kind === 'timeout')
+        return { kind: 'legacy' };
+    if (answer.kind === 'result') {
+        const discover = asDiscoverResult(answer.result);
+        if (!discover)
+            return { kind: 'legacy' };
+        const chosen = newestMutuallySupported(discover.supportedVersions ?? []);
+        if (chosen === undefined) {
+            return {
+                kind: 'refuse',
+                error: disjointVersionsError(serverName, discover.supportedVersions ?? []),
+            };
+        }
+        // A discover result that lists only legacy revisions is a server
+        // telling us, in the modern vocabulary, that it wants the legacy
+        // handshake. Believe it rather than insisting on the era its
+        // answering `server/discover` implied.
+        if (!isModernVersion(chosen))
+            return { kind: 'legacy' };
+        if (chosen !== attempted)
+            return { kind: 'retry', version: chosen };
+        return { kind: 'modern', era: { kind: 'modern', version: chosen }, discover };
+    }
+    const { error } = answer;
+    if (isUnsupportedProtocolVersionError(error)) {
+        const offered = supportedVersionsFrom(error.data);
+        const chosen = newestMutuallySupported(offered);
+        if (chosen === undefined) {
+            return { kind: 'refuse', error: disjointVersionsError(serverName, offered) };
+        }
+        // The best both sides can do is a legacy revision, so stop probing and
+        // go and shake hands — the server named the era it wants.
+        if (!isModernVersion(chosen))
+            return { kind: 'legacy' };
+        // A server that refuses the very version it lists as supported is
+        // contradicting itself, and retrying the same version would be a
+        // round trip spent asking a question already answered. It answered in
+        // the modern vocabulary, so the era is settled at that version and
+        // the request that failed is somebody else's problem to retry.
+        if (chosen === attempted) {
+            return { kind: 'modern', era: { kind: 'modern', version: attempted } };
+        }
+        return { kind: 'retry', version: chosen };
+    }
+    // `-32021` and `-32020` are answers only a modern server can give: it
+    // understood the request and objected to its capabilities or its
+    // headers. The era is settled even though this particular probe failed.
+    if (isRecognizedModernError(error)) {
+        return { kind: 'modern', era: { kind: 'modern', version: attempted } };
+    }
+    if (error instanceof MCPHttpStatusError) {
+        const verdict = classifyModernHttpFailure(error.status, error.bodyText);
+        if (verdict.kind === 'legacy')
+            return { kind: 'legacy' };
+        if (isUnsupportedProtocolVersionError(verdict.error)) {
+            return classifyAnswer({ kind: 'error', error: verdict.error }, attempted, serverName);
+        }
+        return { kind: 'modern', era: { kind: 'modern', version: attempted } };
+    }
+    // A refused connection, a DNS failure, a malformed reply: none of these
+    // say anything about the era. Falling back means the legacy handshake
+    // meets the same failure and reports it in its own words, which is a
+    // better error than "the probe could not decide".
+    return { kind: 'legacy' };
+}
+/**
+ * Decide which era a peer speaks, probing at most twice.
+ *
+ * Modern first, per the spec's own guidance and because the alternative is
+ * worse than a wasted round trip: a legacy server handed an era-ambiguous
+ * method processes it under legacy semantics and fails confusingly, where a
+ * probe fails cleanly. The cache makes the cost one round trip per origin
+ * or per command rather than one per connection.
+ *
+ * The two probes are NOT the same algorithm — an HTTP probe reads a status
+ * and a body, a stdio probe reads a reply or a silence — but both reduce to
+ * one {@link McpEraProbe} answer, so this state machine is written once and
+ * neither transport carries a copy of it.
+ */
+export async function resolveMcpEra(input) {
+    const { cache, key, probe, probeSupported, serverName } = input;
+    if (!probeSupported)
+        return { era: LEGACY_ERA, probes: 0, fromCache: false };
+    const cached = cache.get(key);
+    if (cached?.kind === 'legacy')
+        return { era: cached, probes: 0, fromCache: true };
+    const start = cached?.kind === 'modern' ? cached.version : NEWEST_MODERN;
+    let probes = 0;
+    const run = async (version) => {
+        probes++;
+        return classifyAnswer(await probe(version), version, serverName);
+    };
+    let outcome = await run(start);
+    // Exactly one retry, and only ever at a version drawn from BOTH the
+    // server's list and this client's. There is no loop here to run away.
+    if (outcome.kind === 'retry')
+        outcome = await run(outcome.version);
+    if (outcome.kind === 'retry')
+        outcome = { kind: 'legacy' };
+    if (outcome.kind === 'refuse')
+        throw outcome.error;
+    if (outcome.kind === 'modern') {
+        cache.set(key, outcome.era);
+        return {
+            era: outcome.era,
+            ...(outcome.discover ? { discover: outcome.discover } : {}),
+            probes,
+            fromCache: false,
+        };
+    }
+    // A cached modern answer that no longer holds is replaced rather than
+    // left in place to be believed again: a stale assumption costs exactly
+    // one probe, once, and the next connection goes straight to the legacy
+    // handshake. The version recorded on a legacy entry is only the one this
+    // client OFFERS — which revision a legacy connection settles on is
+    // decided by `initialize`, every time, and is never read from here.
+    cache.set(key, LEGACY_ERA);
+    return { era: LEGACY_ERA, probes, fromCache: false };
+}
+//# sourceMappingURL=era.js.map

package/dist/connector/mcp/era.js.map

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

package/dist/connector/mcp/errors.d.ts

@@ -0,0 +1,106 @@
+import type { MCPInputRequest, MCPJsonRpcError } from '../../types/connector/index.js';
+/**
+ * A JSON-RPC error reply from an MCP peer, with its `code` and `data`
+ * preserved.
+ *
+ * `MCPClient.handleMessage` used to flatten every error reply into
+ * `new Error('MCP error {code}: {message}')`, which threw away the one
+ * thing a caller needs to react to it programmatically. Era negotiation
+ * reads `code === -32022` and `data.supported`; header recovery reads
+ * `-32020`; the capability path reads `-32021` and `data.requiredCapabilities`.
+ * None of that is recoverable from a formatted string.
+ *
+ * A subclass of `Error`, never a replacement: every existing catch site that
+ * treats the rejection as a plain `Error` keeps working unchanged, and
+ * `.message` keeps its original `MCP error {code}: {message}` text so no
+ * existing log line or string-matching test is disturbed.
+ */
+export declare class MCPProtocolError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+/**
+ * A JSON-RPC error reply whose `code` was missing or not an integer.
+ *
+ * A well-formed peer never sends this; a malformed one must not be mistaken
+ * for a recognized protocol error, because era negotiation and the recovery
+ * paths key their fallback behaviour on exactly which modern error code (or
+ * none) came back. Named distinctly from `MCPProtocolError` so that no
+ * `is*Error` predicate below can ever match it.
+ */
+export declare class MCPMalformedErrorReplyError extends Error {
+    constructor(receivedCode: unknown, message: unknown);
+}
+/**
+ * An HTTP response that was not a success, with the body it carried.
+ *
+ * The body is the reason this type exists. A status alone cannot tell a
+ * legacy origin apart from a modern one: a modern server answers an unknown
+ * method with `404` and a JSON-RPC `-32601` body specifically so a client
+ * can distinguish it from the `404` of a server that has never heard of the
+ * modern protocol. Discarding the body — which this transport used to do —
+ * makes that distinction unreachable and turns every `404` into a fallback.
+ *
+ * `.message` is unchanged from the plain `Error` this replaces, so existing
+ * logs and assertions that match on the text are undisturbed.
+ */
+export declare class MCPHttpStatusError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly bodyText: string;
+    constructor(where: string, status: number, statusText: string, bodyText: string);
+}
+/**
+ * Build the rejection reason for a JSON-RPC error reply.
+ *
+ * The wire message is cast to `MCPJsonRpcMessage` at the transport boundary
+ * without validation (see `JSON.parse(...) as MCPJsonRpcMessage` in
+ * `stdio.ts`, `http-sse.ts`, `streamable-http.ts`), so `error.code` is only
+ * a `number` by declared type — a misbehaving peer can still send anything.
+ * Guarding here, once, keeps that distrust out of `handleMessage`.
+ */
+export declare function protocolErrorFromReply(error: MCPJsonRpcError): Error;
+/** A modern server answered that it does not speak the requested protocol version. */
+export declare function isUnsupportedProtocolVersionError(error: unknown): error is MCPProtocolError;
+/** A modern server answered that this client lacks a capability the request required. */
+export declare function isMissingRequiredClientCapabilityError(error: unknown): error is MCPProtocolError;
+/** A modern server rejected a request's `Mcp-Param-*` headers as stale against its current schema. */
+export declare function isHeaderMismatchError(error: unknown): error is MCPProtocolError;
+/**
+ * A server answered that the resource, prompt or tool a request named does
+ * not exist — the current spec's `-32002`, or the older `-32602` a
+ * pre-2025-06-18 server may still use for the same condition (see
+ * {@link RESOURCE_NOT_FOUND_CODES}).
+ */
+export declare function isResourceNotFoundError(error: unknown): error is MCPProtocolError;
+/**
+ * A result named a `resultType` this client does not recognize.
+ *
+ * The spec's own words: "A resultType of any value unrecognized by the
+ * client MUST be considered invalid." Accepting it silently would mean
+ * reading fields from a shape a future revision defines as if they meant
+ * what they mean today, or finding none and returning an empty result with
+ * no diagnostic. Refusing it is the only reading that MUST leaves open.
+ */
+export declare class MCPInvalidResultTypeError extends Error {
+    readonly resultType: unknown;
+    constructor(resultType: unknown);
+}
+/**
+ * A tool call asked this client for input it has no way to supply.
+ *
+ * namzu declares `clientCapabilities: {}`, so MRTR rule 7 means a
+ * CONFORMING server never sends an `inputRequests` this client did not
+ * declare support for. This is the defensive path: a non-conforming
+ * server's demand, or a second `input_required` after the one automatic
+ * retry the spec allows for the `requestState`-only case. Carries the raw
+ * `inputRequests` so a caller — `mcpToolToToolDefinition`'s `execute`, or a
+ * host calling `MCPClient.callTool` directly — can name what was asked for
+ * without this class knowing what a `ToolResult` is.
+ */
+export declare class MCPInputRequiredError extends Error {
+    readonly inputRequests: readonly MCPInputRequest[];
+    constructor(inputRequests: readonly MCPInputRequest[]);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/connector/mcp/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/connector/mcp/errors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAA;AAYtF;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;gBAEX,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO;CAMzD;AAED;;;;;;;;GAQG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO;CAInD;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;gBAEb,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAO/E;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,eAAe,GAAG,KAAK,CAMpE;AAED,sFAAsF;AACtF,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAE3F;AAED,yFAAyF;AACzF,wBAAgB,sCAAsC,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAEhG;AAED,sGAAsG;AACtG,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAE/E;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAEjF;AAED;;;;;;;;GAQG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;IACnD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;gBAEhB,UAAU,EAAE,OAAO;CAK/B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,aAAa,EAAE,SAAS,eAAe,EAAE,CAAA;gBAEtC,aAAa,EAAE,SAAS,eAAe,EAAE;CAUrD"}

package/dist/connector/mcp/errors.js

@@ -0,0 +1,154 @@
+import { RESOURCE_NOT_FOUND_CODES } from '../../constants/mcp/index.js';
+/**
+ * The 2026-07-28 error codes a modern MCP server answers with. Kept private
+ * to this module: callers narrow on the predicates below rather than
+ * comparing magic numbers, so era negotiation, header recovery and the
+ * capability path never need to know the numbers themselves.
+ */
+const UNSUPPORTED_PROTOCOL_VERSION_CODE = -32022;
+const MISSING_REQUIRED_CLIENT_CAPABILITY_CODE = -32021;
+const HEADER_MISMATCH_CODE = -32020;
+/**
+ * A JSON-RPC error reply from an MCP peer, with its `code` and `data`
+ * preserved.
+ *
+ * `MCPClient.handleMessage` used to flatten every error reply into
+ * `new Error('MCP error {code}: {message}')`, which threw away the one
+ * thing a caller needs to react to it programmatically. Era negotiation
+ * reads `code === -32022` and `data.supported`; header recovery reads
+ * `-32020`; the capability path reads `-32021` and `data.requiredCapabilities`.
+ * None of that is recoverable from a formatted string.
+ *
+ * A subclass of `Error`, never a replacement: every existing catch site that
+ * treats the rejection as a plain `Error` keeps working unchanged, and
+ * `.message` keeps its original `MCP error {code}: {message}` text so no
+ * existing log line or string-matching test is disturbed.
+ */
+export class MCPProtocolError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(`MCP error ${code}: ${message}`);
+        this.name = 'MCPProtocolError';
+        this.code = code;
+        this.data = data;
+    }
+}
+/**
+ * A JSON-RPC error reply whose `code` was missing or not an integer.
+ *
+ * A well-formed peer never sends this; a malformed one must not be mistaken
+ * for a recognized protocol error, because era negotiation and the recovery
+ * paths key their fallback behaviour on exactly which modern error code (or
+ * none) came back. Named distinctly from `MCPProtocolError` so that no
+ * `is*Error` predicate below can ever match it.
+ */
+export class MCPMalformedErrorReplyError extends Error {
+    constructor(receivedCode, message) {
+        super(`MCP error reply had a malformed code (${JSON.stringify(receivedCode)}): ${message}`);
+        this.name = 'MCPMalformedErrorReplyError';
+    }
+}
+/**
+ * An HTTP response that was not a success, with the body it carried.
+ *
+ * The body is the reason this type exists. A status alone cannot tell a
+ * legacy origin apart from a modern one: a modern server answers an unknown
+ * method with `404` and a JSON-RPC `-32601` body specifically so a client
+ * can distinguish it from the `404` of a server that has never heard of the
+ * modern protocol. Discarding the body — which this transport used to do —
+ * makes that distinction unreachable and turns every `404` into a fallback.
+ *
+ * `.message` is unchanged from the plain `Error` this replaces, so existing
+ * logs and assertions that match on the text are undisturbed.
+ */
+export class MCPHttpStatusError extends Error {
+    status;
+    statusText;
+    bodyText;
+    constructor(where, status, statusText, bodyText) {
+        super(`${where}: HTTP ${status}: ${statusText}`);
+        this.name = 'MCPHttpStatusError';
+        this.status = status;
+        this.statusText = statusText;
+        this.bodyText = bodyText;
+    }
+}
+/**
+ * Build the rejection reason for a JSON-RPC error reply.
+ *
+ * The wire message is cast to `MCPJsonRpcMessage` at the transport boundary
+ * without validation (see `JSON.parse(...) as MCPJsonRpcMessage` in
+ * `stdio.ts`, `http-sse.ts`, `streamable-http.ts`), so `error.code` is only
+ * a `number` by declared type — a misbehaving peer can still send anything.
+ * Guarding here, once, keeps that distrust out of `handleMessage`.
+ */
+export function protocolErrorFromReply(error) {
+    const code = error.code;
+    if (typeof code !== 'number' || !Number.isInteger(code)) {
+        return new MCPMalformedErrorReplyError(code, error.message);
+    }
+    return new MCPProtocolError(code, error.message, error.data);
+}
+/** A modern server answered that it does not speak the requested protocol version. */
+export function isUnsupportedProtocolVersionError(error) {
+    return error instanceof MCPProtocolError && error.code === UNSUPPORTED_PROTOCOL_VERSION_CODE;
+}
+/** A modern server answered that this client lacks a capability the request required. */
+export function isMissingRequiredClientCapabilityError(error) {
+    return error instanceof MCPProtocolError && error.code === MISSING_REQUIRED_CLIENT_CAPABILITY_CODE;
+}
+/** A modern server rejected a request's `Mcp-Param-*` headers as stale against its current schema. */
+export function isHeaderMismatchError(error) {
+    return error instanceof MCPProtocolError && error.code === HEADER_MISMATCH_CODE;
+}
+/**
+ * A server answered that the resource, prompt or tool a request named does
+ * not exist — the current spec's `-32002`, or the older `-32602` a
+ * pre-2025-06-18 server may still use for the same condition (see
+ * {@link RESOURCE_NOT_FOUND_CODES}).
+ */
+export function isResourceNotFoundError(error) {
+    return error instanceof MCPProtocolError && RESOURCE_NOT_FOUND_CODES.includes(error.code);
+}
+/**
+ * A result named a `resultType` this client does not recognize.
+ *
+ * The spec's own words: "A resultType of any value unrecognized by the
+ * client MUST be considered invalid." Accepting it silently would mean
+ * reading fields from a shape a future revision defines as if they meant
+ * what they mean today, or finding none and returning an empty result with
+ * no diagnostic. Refusing it is the only reading that MUST leaves open.
+ */
+export class MCPInvalidResultTypeError extends Error {
+    resultType;
+    constructor(resultType) {
+        super(`MCP result carried an unrecognized resultType: ${JSON.stringify(resultType)}`);
+        this.name = 'MCPInvalidResultTypeError';
+        this.resultType = resultType;
+    }
+}
+/**
+ * A tool call asked this client for input it has no way to supply.
+ *
+ * namzu declares `clientCapabilities: {}`, so MRTR rule 7 means a
+ * CONFORMING server never sends an `inputRequests` this client did not
+ * declare support for. This is the defensive path: a non-conforming
+ * server's demand, or a second `input_required` after the one automatic
+ * retry the spec allows for the `requestState`-only case. Carries the raw
+ * `inputRequests` so a caller — `mcpToolToToolDefinition`'s `execute`, or a
+ * host calling `MCPClient.callTool` directly — can name what was asked for
+ * without this class knowing what a `ToolResult` is.
+ */
+export class MCPInputRequiredError extends Error {
+    inputRequests;
+    constructor(inputRequests) {
+        const methods = inputRequests.map((request) => request.method);
+        super(methods.length > 0
+            ? `MCP tool call requires input this client cannot supply: ${methods.join(', ')}`
+            : 'MCP tool call requires input this client cannot supply');
+        this.name = 'MCPInputRequiredError';
+        this.inputRequests = inputRequests;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/connector/mcp/errors.js.map

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

package/dist/connector/mcp/http-sse.d.ts

@@ -13,6 +13,8 @@ export declare class HttpSseTransport implements MCPTransport {
     private postUrl;
     private log;
     private readonly timeoutMs;
+    /** Defaults to the ambient global `fetch`; never read again once captured. */
+    private readonly fetchImpl;
     constructor(config: MCPHttpSseTransportConfig, log?: Logger);
     connect(): Promise<void>;
     close(): Promise<void>;
@@ -31,6 +33,15 @@ export declare class HttpSseTransport implements MCPTransport {
     onClose(handler: () => void): void;
     onError(handler: (error: Error) => void): void;
     isConnected(): boolean;
+    /**
+     * `extra` comes from `MCPTransportSendOptions.headers` — the client's
+     * per-send authority — and is merged over this transport's own static
+     * config headers so a caller's value wins on a collision. See
+     * {@link StreamableHttpTransport}'s method of the same name, which this
+     * mirrors; the HTTP-SSE POST had no equivalent merge until now, so a
+     * per-request header or bearer token silently never reached the wire.
+     */
+    private buildHeaders;
     private beginSend;
     private assertCurrent;
     private isCurrent;

package/dist/connector/mcp/http-sse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http-sse.d.ts","sourceRoot":"","sources":["../../../src/connector/mcp/http-sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EACvB,MAAM,gCAAgC,CAAA;AAEvC,OAAO,EAAE,KAAK,MAAM,EAAiB,MAAM,uBAAuB,CAAA;AAqBlE,qBAAa,gBAAiB,YAAW,YAAY;IAcnD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAbxB,OAAO,CAAC,eAAe,CAAkD;IACzE,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,aAAa,CAAoC;IACzD,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,eAAe,CAA+B;IACtD,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,GAAG,CAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;gBAGhB,MAAM,EAAE,yBAAyB,EAClD,GAAG,CAAC,EAAE,MAAM;IAYP,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAUxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAMf,IAAI,CAAC,OAAO,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IA8CxF,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,GAAG,IAAI;IAI9D,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI;IAIlC,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAI9C,WAAW,IAAI,OAAO;IAItB,OAAO,CAAC,SAAS;IAyBjB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,SAAS;YAIH,QAAQ;YAUR,SAAS;CA+CvB"}
+{"version":3,"file":"http-sse.d.ts","sourceRoot":"","sources":["../../../src/connector/mcp/http-sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEX,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EACvB,MAAM,gCAAgC,CAAA;AAEvC,OAAO,EAAE,KAAK,MAAM,EAAiB,MAAM,uBAAuB,CAAA;AAqBlE,qBAAa,gBAAiB,YAAW,YAAY;IAgBnD,OAAO,CAAC,QAAQ,CAAC,MAAM;IAfxB,OAAO,CAAC,eAAe,CAAkD;IACzE,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,aAAa,CAAoC;IACzD,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,eAAe,CAA+B;IACtD,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,GAAG,CAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAQ;IAClC,8EAA8E;IAC9E,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;gBAGtB,MAAM,EAAE,yBAAyB,EAClD,GAAG,CAAC,EAAE,MAAM;IAaP,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAUxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAMf,IAAI,CAAC,OAAO,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IA2CxF,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,GAAG,IAAI;IAI9D,OAAO,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,IAAI;IAIlC,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAI9C,WAAW,IAAI,OAAO;IAItB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,SAAS;IAyBjB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,SAAS;YAIH,QAAQ;YAUR,SAAS;CA+CvB"}