@openrouter/agent 0.9.0 → 0.10.0

package/esm/mcp/cache/cache-types.d.ts

@@ -0,0 +1,71 @@
+import type { MCPTransportKind } from '../transport-types.js';
+/** A discovered tool definition as stored in a cache snapshot. */
+export interface SerializedMCPToolDef {
+    name: string;
+    description?: string;
+    inputSchema: Readonly<Record<string, unknown>>;
+    outputSchema?: Readonly<Record<string, unknown>>;
+    /** Server-advertised doom-loop identity (field list or `false`), if any. */
+    loopKey?: readonly string[] | false;
+}
+/** OAuth/bearer token material, persisted only when `cacheCredentials` is on. */
+export interface SerializedTokenSet {
+    accessToken: string;
+    tokenType?: string;
+    refreshToken?: string;
+    /** Epoch ms; absence means unknown/no declared expiry. */
+    expiresAt?: number;
+    scope?: string;
+}
+/**
+ * Serializable snapshot of a connected MCP server: enough to rebuild the tool
+ * set (and, opt-in, reconnect with cached credentials) without re-listing or
+ * re-authenticating.
+ */
+export interface SerializedMCPServer {
+    version: 1;
+    url: string;
+    transport: MCPTransportKind;
+    serverInfo?: {
+        name?: string;
+        version?: string;
+    };
+    capabilities?: Readonly<Record<string, unknown>>;
+    /**
+     * Streamable HTTP session id, replayed on reconnect.
+     *
+     * @deprecated No longer written, and never read back. Protocol-level sessions
+     * and the `Mcp-Session-Id` header are removed in revision 2026-07-28
+     * (SEP-2567), where cross-call state moves to server-minted handles passed as
+     * ordinary tool arguments.
+     *
+     * The field remains only so snapshots written by older versions keep
+     * deserializing — a validator that rejected it would turn every existing cache
+     * entry into a hard failure. Nothing populates it now: it is bearer-equivalent
+     * to an authenticated server session, so persisting it to an external store was
+     * attack surface for no functionality once the replay path stopped forwarding
+     * it. Treat any value found here as untrusted legacy data. See the README.
+     */
+    sessionId?: string;
+    tools: SerializedMCPToolDef[];
+    auth?: {
+        headers?: Readonly<Record<string, string>>;
+        tokens?: SerializedTokenSet;
+    };
+    cachedAt: number;
+}
+/**
+ * The shared "valid `cachedAt`" rule: a finite, non-negative epoch (ms).
+ * Consumed by both the read-side snapshot validator and the write-side
+ * serializer so the two can't drift. Rejecting negatives keeps the invariant
+ * honest at the boundary rather than relying on downstream maxAge arithmetic to
+ * fail-safe on a clock-skewed or garbage value.
+ */
+export declare function isFiniteEpoch(value: unknown): value is number;
+/**
+ * Validate an untrusted value as a {@link SerializedMCPServer}. Cache stores may
+ * be backed by a DB or another org member's data, so snapshots are checked
+ * structurally before use — never trusted by shape alone.
+ */
+export declare function isSerializedMCPServer(value: unknown): value is SerializedMCPServer;
+//# sourceMappingURL=cache-types.d.ts.map

package/esm/mcp/cache/cache-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-types.d.ts","sourceRoot":"","sources":["../../../src/mcp/cache/cache-types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,kEAAkE;AAClE,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAC/C,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,4EAA4E;IAC5E,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,CAAC;CACrC;AAED,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,CAAC,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,gBAAgB,CAAC;IAC5B,UAAU,CAAC,EAAE;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;QAC3C,MAAM,CAAC,EAAE,kBAAkB,CAAC;KAC7B,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC;CAClB;AAMD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE7D;AAmBD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,mBAAmB,CAelF"}

package/esm/mcp/cache/cache-types.js

@@ -0,0 +1,49 @@
+import { isJsonSchemaObject } from '../schema/json-schema-guards.js';
+function isTransportKind(value) {
+    return value === 'streamableHttp' || value === 'sse';
+}
+/**
+ * The shared "valid `cachedAt`" rule: a finite, non-negative epoch (ms).
+ * Consumed by both the read-side snapshot validator and the write-side
+ * serializer so the two can't drift. Rejecting negatives keeps the invariant
+ * honest at the boundary rather than relying on downstream maxAge arithmetic to
+ * fail-safe on a clock-skewed or garbage value.
+ */
+export function isFiniteEpoch(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}
+function isSerializedToolDef(value) {
+    if (!isJsonSchemaObject(value)) {
+        return false;
+    }
+    const loopKey = value['loopKey'];
+    // Absent is valid (the field is optional); present must be `false` or a
+    // string array. Anything else — a truthy scalar, a mixed array, a nested
+    // object — is a poisoned or stale snapshot and rejects the whole entry.
+    const hasValidLoopKey = loopKey === undefined ||
+        loopKey === false ||
+        (Array.isArray(loopKey) && loopKey.every((field) => typeof field === 'string'));
+    return (typeof value['name'] === 'string' && isJsonSchemaObject(value['inputSchema']) && hasValidLoopKey);
+}
+/**
+ * Validate an untrusted value as a {@link SerializedMCPServer}. Cache stores may
+ * be backed by a DB or another org member's data, so snapshots are checked
+ * structurally before use — never trusted by shape alone.
+ */
+export function isSerializedMCPServer(value) {
+    if (!isJsonSchemaObject(value)) {
+        return false;
+    }
+    if (value['version'] !== 1) {
+        return false;
+    }
+    if (typeof value['url'] !== 'string' || !isTransportKind(value['transport'])) {
+        return false;
+    }
+    if (!isFiniteEpoch(value['cachedAt'])) {
+        return false;
+    }
+    const { tools } = value;
+    return Array.isArray(tools) && tools.every(isSerializedToolDef);
+}
+//# sourceMappingURL=cache-types.js.map

package/esm/mcp/cache/cache-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-types.js","sourceRoot":"","sources":["../../../src/mcp/cache/cache-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AA6DrE,SAAS,eAAe,CAAC,KAAc;IACrC,OAAO,KAAK,KAAK,gBAAgB,IAAI,KAAK,KAAK,KAAK,CAAC;AACvD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;AAC3E,CAAC;AAED,SAAS,mBAAmB,CAAC,KAAc;IACzC,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;IACjC,wEAAwE;IACxE,yEAAyE;IACzE,wEAAwE;IACxE,MAAM,eAAe,GACnB,OAAO,KAAK,SAAS;QACrB,OAAO,KAAK,KAAK;QACjB,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC;IAClF,OAAO,CACL,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,QAAQ,IAAI,kBAAkB,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,IAAI,eAAe,CACjG,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAc;IAClD,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC/B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,QAAQ,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC;QAC7E,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC;QACtC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IACxB,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;AAClE,CAAC"}

package/esm/mcp/cache/serialize.d.ts

@@ -0,0 +1,25 @@
+import type { MCPAuth } from '../auth/auth-types.js';
+import type { McpToolDef } from '../tool-wrapper.js';
+import type { MCPTransportKind } from '../types.js';
+import type { SerializedMCPServer } from './cache-types.js';
+export interface SerializeInput {
+    url: string;
+    transport: MCPTransportKind;
+    toolDefs: readonly McpToolDef[];
+    serverInfo?: {
+        name?: string;
+        version?: string;
+    };
+    capabilities?: Readonly<Record<string, unknown>>;
+    auth?: MCPAuth;
+    cacheCredentials: boolean;
+    cachedAt: number;
+}
+/**
+ * Build a serializable snapshot. Credentials (tokens/headers) are included only
+ * when `cacheCredentials` is true; otherwise the snapshot holds just the
+ * structural data needed to rebuild the tool set after a fresh auth. Session ids
+ * are never included — see the note in the `cacheCredentials` branch.
+ */
+export declare function serializeServer(input: SerializeInput): Promise<SerializedMCPServer>;
+//# sourceMappingURL=serialize.d.ts.map

package/esm/mcp/cache/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../../src/mcp/cache/serialize.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAsB,MAAM,kBAAkB,CAAC;AAGhF,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;IAChC,UAAU,CAAC,EAAE;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,gBAAgB,EAAE,OAAO,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAuED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA6CzF"}

package/esm/mcp/cache/serialize.js

@@ -0,0 +1,96 @@
+import { resolveAuth } from '../auth/auth-resolver.js';
+import { isFiniteEpoch } from './cache-types.js';
+const _expiresInStillRelative = true;
+void _expiresInStillRelative;
+/** Pull a serializable token set from an OAuth provider, if it has tokens. */
+async function tokensFromProvider(provider) {
+    const tokens = await provider.tokens();
+    if (tokens === undefined) {
+        return undefined;
+    }
+    const expiresInMs = typeof tokens.expires_in === 'number' ? tokens.expires_in * 1000 : undefined;
+    return {
+        accessToken: tokens.access_token,
+        ...(typeof tokens.token_type === 'string' && {
+            tokenType: tokens.token_type,
+        }),
+        ...(typeof tokens.refresh_token === 'string' && {
+            refreshToken: tokens.refresh_token,
+        }),
+        ...(typeof tokens.scope === 'string' && {
+            scope: tokens.scope,
+        }),
+        ...(expiresInMs !== undefined && {
+            expiresAt: Date.now() + expiresInMs,
+        }),
+    };
+}
+async function buildAuthBlock(auth) {
+    if (auth === undefined) {
+        return undefined;
+    }
+    if (auth.kind === 'oauth') {
+        const tokens = await tokensFromProvider(auth.provider);
+        return tokens !== undefined
+            ? {
+                tokens,
+            }
+            : undefined;
+    }
+    const { headers } = resolveAuth(auth);
+    return Object.keys(headers).length > 0
+        ? {
+            headers,
+        }
+        : undefined;
+}
+/**
+ * Build a serializable snapshot. Credentials (tokens/headers) are included only
+ * when `cacheCredentials` is true; otherwise the snapshot holds just the
+ * structural data needed to rebuild the tool set after a fresh auth. Session ids
+ * are never included — see the note in the `cacheCredentials` branch.
+ */
+export async function serializeServer(input) {
+    const tools = input.toolDefs.map((def) => ({
+        name: def.name,
+        ...(def.description !== undefined && {
+            description: def.description,
+        }),
+        inputSchema: def.inputSchema,
+        ...(def.outputSchema !== undefined && {
+            outputSchema: def.outputSchema,
+        }),
+        ...(def.loopKey !== undefined && {
+            loopKey: def.loopKey,
+        }),
+    }));
+    const snapshot = {
+        version: 1,
+        url: input.url,
+        transport: input.transport,
+        ...(input.serverInfo !== undefined && {
+            serverInfo: input.serverInfo,
+        }),
+        ...(input.capabilities !== undefined && {
+            capabilities: input.capabilities,
+        }),
+        tools,
+        cachedAt: isFiniteEpoch(input.cachedAt) ? input.cachedAt : Date.now(),
+    };
+    if (input.cacheCredentials) {
+        const auth = await buildAuthBlock(input.auth);
+        if (auth !== undefined) {
+            snapshot.auth = auth;
+        }
+        // `sessionId` is deliberately NOT persisted. A Streamable HTTP
+        // `Mcp-Session-Id` is a bearer-equivalent handle to an authenticated server
+        // session, and nothing reads it back: the replay path stopped forwarding it
+        // once we found that a transport reporting a sessionId makes SDK v2 skip
+        // negotiation entirely, silently losing server capabilities. Writing it to an
+        // external store (Redis, a database, a file) would be attack surface for no
+        // functionality. That it was gated behind `cacheCredentials` at all reflects
+        // that it was always credential-grade.
+    }
+    return snapshot;
+}
+//# sourceMappingURL=serialize.js.map

package/esm/mcp/cache/serialize.js.map

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

package/esm/mcp/close-quietly.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Release something closeable on a path that is already failing, swallowing
+ * whatever `close()` does on the way out.
+ *
+ * The `try` matters as much as the `catch`: `close()` is not guaranteed to
+ * return a rejected promise on failure, and a *synchronous* throw never
+ * produces one — so `x.close().catch(() => {})` throws before `.catch()` is
+ * ever attached. On an unwinding path that is actively harmful in two ways: it
+ * replaces the real error (a useful "couldn't reach the server" becomes an
+ * opaque teardown failure), and it skips whatever recovery followed the close —
+ * a fallback that used to self-heal starts rejecting instead.
+ *
+ * Every teardown-on-failure site in this package goes through here, so the
+ * guarantee holds uniformly rather than depending on each caller remembering
+ * the distinction.
+ *
+ * Deliberately not exported from the package entrypoint: callers close through
+ * `MCPToolsHandle.close()` / `MCPConnection.close()`, which report failures
+ * rather than swallowing them. This is only for teardown during error unwinding.
+ */
+export declare function closeQuietly(closeable: {
+    close(): Promise<void>;
+}): Promise<void>;
+//# sourceMappingURL=close-quietly.d.ts.map

package/esm/mcp/close-quietly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-quietly.d.ts","sourceRoot":"","sources":["../../src/mcp/close-quietly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,YAAY,CAAC,SAAS,EAAE;IAAE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAOvF"}

package/esm/mcp/close-quietly.js

@@ -0,0 +1,30 @@
+/**
+ * Release something closeable on a path that is already failing, swallowing
+ * whatever `close()` does on the way out.
+ *
+ * The `try` matters as much as the `catch`: `close()` is not guaranteed to
+ * return a rejected promise on failure, and a *synchronous* throw never
+ * produces one — so `x.close().catch(() => {})` throws before `.catch()` is
+ * ever attached. On an unwinding path that is actively harmful in two ways: it
+ * replaces the real error (a useful "couldn't reach the server" becomes an
+ * opaque teardown failure), and it skips whatever recovery followed the close —
+ * a fallback that used to self-heal starts rejecting instead.
+ *
+ * Every teardown-on-failure site in this package goes through here, so the
+ * guarantee holds uniformly rather than depending on each caller remembering
+ * the distinction.
+ *
+ * Deliberately not exported from the package entrypoint: callers close through
+ * `MCPToolsHandle.close()` / `MCPConnection.close()`, which report failures
+ * rather than swallowing them. This is only for teardown during error unwinding.
+ */
+export async function closeQuietly(closeable) {
+    try {
+        await closeable.close();
+    }
+    catch {
+        // Nothing actionable: we are already unwinding a failure, and the close
+        // outcome is never the error the caller needs to see.
+    }
+}
+//# sourceMappingURL=close-quietly.js.map

package/esm/mcp/close-quietly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"close-quietly.js","sourceRoot":"","sources":["../../src/mcp/close-quietly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,SAAqC;IACtE,IAAI,CAAC;QACH,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACP,wEAAwE;QACxE,sDAAsD;IACxD,CAAC;AACH,CAAC"}

package/esm/mcp/create-mcp-tools.d.ts

@@ -0,0 +1,13 @@
+import type { SerializedMCPServer } from './cache/cache-types.js';
+import type { CreateMCPToolsOptions, MCPToolsHandle } from './types.js';
+/**
+ * Connect to a remote MCP server, discover its tools, and return a handle whose
+ * `.tools` can be passed straight into `callModel({ tools })`. Auth is supplied
+ * once and reused for discovery and every subsequent tool call.
+ *
+ * When `cache` is provided, a valid non-stale snapshot is rehydrated instead of
+ * re-listing; otherwise the fresh result is written back to the cache.
+ */
+export declare function createMCPTools(options: CreateMCPToolsOptions): Promise<MCPToolsHandle>;
+export type { SerializedMCPServer };
+//# sourceMappingURL=create-mcp-tools.d.ts.map

package/esm/mcp/create-mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-mcp-tools.d.ts","sourceRoot":"","sources":["../../src/mcp/create-mcp-tools.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAKlE,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAExE;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,cAAc,CAAC,CAY5F;AAyED,YAAY,EAAE,mBAAmB,EAAE,CAAC"}

package/esm/mcp/create-mcp-tools.js

@@ -0,0 +1,87 @@
+import { defaultCacheKey } from './cache/cache-store.js';
+import { isSerializedMCPServer } from './cache/cache-types.js';
+import { freshConnect, normalizeUrl } from './handle.js';
+import { rehydrateMCPTools } from './rehydrate.js';
+/**
+ * Connect to a remote MCP server, discover its tools, and return a handle whose
+ * `.tools` can be passed straight into `callModel({ tools })`. Auth is supplied
+ * once and reused for discovery and every subsequent tool call.
+ *
+ * When `cache` is provided, a valid non-stale snapshot is rehydrated instead of
+ * re-listing; otherwise the fresh result is written back to the cache.
+ */
+export async function createMCPTools(options) {
+    const url = normalizeUrl(options.url);
+    const cacheKey = options.cache?.key ?? defaultCacheKey(url.href);
+    if (options.cache !== undefined) {
+        const hit = await tryCacheHit(options, options.cache.store, cacheKey);
+        if (hit !== undefined) {
+            return hit;
+        }
+    }
+    return freshConnect(options, url, cacheKey);
+}
+// Option keys forwarded verbatim from a cache-hit `createMCPTools` call into
+// `rehydrateMCPTools`, so a warm handle applies the same auth, filters, prefix,
+// loop identities, and credential-caching behavior as a cold one. Anything
+// omitted here is SILENTLY DROPPED on a cache hit — when adding an option to
+// `CreateMCPToolsOptions` that rehydrate also honors, add it here too.
+const FORWARDED_REHYDRATE_KEYS = [
+    'auth',
+    'fetch',
+    'clientInfo',
+    'onUnconvertibleSchema',
+    'onElicitation',
+    'signal',
+    'toolNamePrefix',
+    'includeTools',
+    'excludeTools',
+    'resources',
+    'emitProgress',
+    'loopKeys',
+    'autoRefreshOnListChanged',
+    'cacheCredentials',
+    'protocolNegotiation',
+    'probeTimeoutMs',
+    'staleness',
+];
+/** Copy the defined forwarded options from `createMCPTools` into a rehydrate base. */
+function forwardedRehydrateOptions(options) {
+    const out = {};
+    for (const key of FORWARDED_REHYDRATE_KEYS) {
+        const value = options[key];
+        if (value !== undefined) {
+            Object.assign(out, {
+                [key]: value,
+            });
+        }
+    }
+    return out;
+}
+async function tryCacheHit(options, store, cacheKey) {
+    let snapshot;
+    try {
+        snapshot = await store.get(cacheKey);
+    }
+    catch {
+        snapshot = undefined;
+    }
+    if (snapshot === null || snapshot === undefined || !isSerializedMCPServer(snapshot)) {
+        return undefined;
+    }
+    const maxAge = options.staleness?.maxAgeMs;
+    if (maxAge !== undefined && Date.now() - snapshot.cachedAt > maxAge) {
+        return undefined;
+    }
+    // Defer to rehydrate, which reconnects and falls back to a fresh connect on
+    // expiry.
+    return rehydrateMCPTools({
+        snapshot,
+        ...forwardedRehydrateOptions(options),
+        cache: {
+            store,
+            key: cacheKey,
+        },
+    });
+}
+//# sourceMappingURL=create-mcp-tools.js.map

package/esm/mcp/create-mcp-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-mcp-tools.js","sourceRoot":"","sources":["../../src/mcp/create-mcp-tools.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGnD;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,OAA8B;IACjE,MAAM,GAAG,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACtC,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,eAAe,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAEjE,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAChC,MAAM,GAAG,GAAG,MAAM,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACtE,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACtB,OAAO,GAAG,CAAC;QACb,CAAC;IACH,CAAC;IAED,OAAO,YAAY,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;AAC9C,CAAC;AAED,6EAA6E;AAC7E,gFAAgF;AAChF,2EAA2E;AAC3E,6EAA6E;AAC7E,uEAAuE;AACvE,MAAM,wBAAwB,GAAG;IAC/B,MAAM;IACN,OAAO;IACP,YAAY;IACZ,uBAAuB;IACvB,eAAe;IACf,QAAQ;IACR,gBAAgB;IAChB,cAAc;IACd,cAAc;IACd,WAAW;IACX,cAAc;IACd,UAAU;IACV,0BAA0B;IAC1B,kBAAkB;IAClB,qBAAqB;IACrB,gBAAgB;IAChB,WAAW;CACiF,CAAC;AAE/F,sFAAsF;AACtF,SAAS,yBAAyB,CAChC,OAA8B;IAE9B,MAAM,GAAG,GAAsC,EAAE,CAAC;IAClD,KAAK,MAAM,GAAG,IAAI,wBAAwB,EAAE,CAAC;QAC3C,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE;gBACjB,CAAC,GAAG,CAAC,EAAE,KAAK;aACb,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,KAAK,UAAU,WAAW,CACxB,OAA8B,EAC9B,KAAoB,EACpB,QAAgB;IAEhB,IAAI,QAA+D,CAAC;IACpE,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACvC,CAAC;IAAC,MAAM,CAAC;QACP,QAAQ,GAAG,SAAS,CAAC;IACvB,CAAC;IACD,IAAI,QAAQ,KAAK,IAAI,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,EAAE,CAAC;QACpF,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC3C,IAAI,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,QAAQ,GAAG,MAAM,EAAE,CAAC;QACpE,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,4EAA4E;IAC5E,UAAU;IACV,OAAO,iBAAiB,CAAC;QACvB,QAAQ;QACR,GAAG,yBAAyB,CAAC,OAAO,CAAC;QACrC,KAAK,EAAE;YACL,KAAK;YACL,GAAG,EAAE,QAAQ;SACd;KACF,CAAC,CAAC;AACL,CAAC"}

package/esm/mcp/elicitation.d.ts

@@ -0,0 +1,11 @@
+import type { ElicitRequest, ElicitResult } from '@modelcontextprotocol/client';
+import type { ElicitationHandler } from './types.js';
+/**
+ * Build the `elicitation/create` request handler registered on the MCP client.
+ * Delegates to the caller's {@link ElicitationHandler}; when none is supplied,
+ * auto-declines so a tool call awaiting input fails gracefully instead of
+ * hanging. The MCP spec forbids eliciting sensitive/PII data — that contract is
+ * the server's responsibility; callers should treat requested fields as such.
+ */
+export declare function makeElicitationRequestHandler(handler: ElicitationHandler | undefined): (request: ElicitRequest) => Promise<ElicitResult>;
+//# sourceMappingURL=elicitation.d.ts.map

package/esm/mcp/elicitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitation.d.ts","sourceRoot":"","sources":["../../src/mcp/elicitation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEhF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AA4BrD;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,kBAAkB,GAAG,SAAS,GACtC,CAAC,OAAO,EAAE,aAAa,KAAK,OAAO,CAAC,YAAY,CAAC,CA2BnD"}

package/esm/mcp/elicitation.js

@@ -0,0 +1,51 @@
+import { isJsonSchemaObject } from './schema/json-schema-guards.js';
+/** A form-mode elicitation request carries a `requestedSchema`. */
+function hasRequestedSchema(params) {
+    return 'requestedSchema' in params;
+}
+/** Narrow handler-returned content to the primitive record the spec allows. */
+function toElicitContent(content) {
+    const out = {};
+    for (const [key, value] of Object.entries(content)) {
+        if (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean' ||
+            (Array.isArray(value) && value.every((v) => typeof v === 'string'))) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/**
+ * Build the `elicitation/create` request handler registered on the MCP client.
+ * Delegates to the caller's {@link ElicitationHandler}; when none is supplied,
+ * auto-declines so a tool call awaiting input fails gracefully instead of
+ * hanging. The MCP spec forbids eliciting sensitive/PII data — that contract is
+ * the server's responsibility; callers should treat requested fields as such.
+ */
+export function makeElicitationRequestHandler(handler) {
+    return async (request) => {
+        if (handler === undefined) {
+            return {
+                action: 'decline',
+            };
+        }
+        const { params } = request;
+        const requestedSchema = hasRequestedSchema(params) ? params.requestedSchema : undefined;
+        const schema = isJsonSchemaObject(requestedSchema) ? requestedSchema : {};
+        const response = await handler({
+            message: params.message,
+            requestedSchema: schema,
+        });
+        if (response.action === 'accept') {
+            return {
+                action: 'accept',
+                content: toElicitContent(response.content),
+            };
+        }
+        return {
+            action: response.action,
+        };
+    };
+}
+//# sourceMappingURL=elicitation.js.map

package/esm/mcp/elicitation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitation.js","sourceRoot":"","sources":["../../src/mcp/elicitation.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAMpE,mEAAmE;AACnE,SAAS,kBAAkB,CAAC,MAA+B;IAGzD,OAAO,iBAAiB,IAAI,MAAM,CAAC;AACrC,CAAC;AAED,+EAA+E;AAC/E,SAAS,eAAe,CAAC,OAAgC;IACvD,MAAM,GAAG,GAAuC,EAAE,CAAC;IACnD,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACnD,IACE,OAAO,KAAK,KAAK,QAAQ;YACzB,OAAO,KAAK,KAAK,QAAQ;YACzB,OAAO,KAAK,KAAK,SAAS;YAC1B,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,EAChF,CAAC;YACD,GAAG,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACnB,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,6BAA6B,CAC3C,OAAuC;IAEvC,OAAO,KAAK,EAAE,OAAsB,EAAyB,EAAE;QAC7D,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,OAAO;gBACL,MAAM,EAAE,SAAS;aAClB,CAAC;QACJ,CAAC;QAED,MAAM,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QAC3B,MAAM,eAAe,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC;QACxF,MAAM,MAAM,GAAG,kBAAkB,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;QAE1E,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC;YAC7B,OAAO,EAAE,MAAM,CAAC,OAAO;YACvB,eAAe,EAAE,MAAM;SACxB,CAAC,CAAC;QAEH,IAAI,QAAQ,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YACjC,OAAO;gBACL,MAAM,EAAE,QAAQ;gBAChB,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC;aAC3C,CAAC;QACJ,CAAC;QACD,OAAO;YACL,MAAM,EAAE,QAAQ,CAAC,MAAM;SACxB,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/esm/mcp/errors.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Base error for all @openrouter/agent/mcp failures.
+ */
+export declare class MCPError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Raised when an MCP tool call returns `isError: true` or when the result
+ * cannot be mapped to a usable model output.
+ */
+export declare class MCPToolCallError extends MCPError {
+    readonly toolName: string;
+    constructor(toolName: string, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Raised when a cached snapshot cannot be validated or rehydrated.
+ */
+export declare class MCPCacheError extends MCPError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Raised when the tool list was read successfully but writing the snapshot back
+ * to the caller's `MCPCacheStore` failed.
+ *
+ * Distinct from the read failing, because the consequences differ completely: the
+ * connection is live and its tools are current, so the only thing lost is a cache
+ * entry. Callers who treat a store outage as fatal can catch this; callers who
+ * would rather keep working with a warm handle can ignore it.
+ *
+ * Subclasses {@link MCPCacheError}, so existing catch sites keep working.
+ */
+export declare class MCPCacheWriteError extends MCPCacheError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Raised when a snapshot is older than `staleness.maxAgeMs` and the re-list that
+ * would have refreshed it failed — so the only tools available are ones the
+ * caller declared too old to use.
+ *
+ * Subclasses {@link MCPCacheError}, so existing `catch (e instanceof
+ * MCPCacheError)` sites keep working. Catch this specifically to fall back to
+ * stale-but-usable tools instead of failing.
+ */
+export declare class MCPStaleSnapshotError extends MCPCacheError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Raised when connecting to the MCP server fails across all attempted transports.
+ */
+export declare class MCPConnectionError extends MCPError {
+    /**
+     * Every failure behind this one, in attempt order.
+     *
+     * `cause` holds only the last attempt, which loses information: an
+     * `UnauthorizedError` from the Streamable HTTP attempt matters even when the
+     * SSE fallback then failed for an unrelated reason (a URL that simply isn't an
+     * SSE endpoint answering 404). Named `errors` to match `AggregateError`, so it
+     * reads the way callers expect rather than as a bespoke field.
+     *
+     * Always populated: a single-attempt failure contributes its one underlying
+     * error, so `errors[errors.length - 1]` and `cause` agree and a caller can
+     * iterate `errors` alone without special-casing the single-attempt shape —
+     * which matters most on the auth short-circuit, where exactly one attempt was
+     * made and its rejection is the thing worth finding.
+     */
+    readonly errors: readonly unknown[];
+    constructor(message: string, options?: {
+        cause?: unknown;
+        errors?: readonly unknown[];
+    });
+}
+/**
+ * Raised when MCP support is used without its optional SDK peer installed.
+ */
+export declare class MCPMissingPeerDependencyError extends MCPConnectionError {
+    readonly packageName = "@modelcontextprotocol/client";
+    constructor(options?: {
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/esm/mcp/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/mcp/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,QAAS,SAAQ,KAAK;gBAE/B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CAKJ;AAED;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAGxB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CAMJ;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,QAAQ;gBAEvC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CAKJ;AAED;;;;;;;;;;GAUG;AACH,qBAAa,kBAAmB,SAAQ,aAAa;gBAEjD,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CAKJ;AAED;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,SAAQ,aAAa;gBAEpD,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CAKJ;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,QAAQ;IAC9C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;gBAGlC,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;KAC7B;CAcJ;AAED;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,kBAAkB;IACnE,QAAQ,CAAC,WAAW,kCAAkC;gBAE1C,OAAO,CAAC,EAAE;QACpB,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CAQF"}