@openrouter/agent 0.8.0 → 0.10.0

package/esm/mcp/errors.js

@@ -0,0 +1,91 @@
+/**
+ * Base error for all @openrouter/agent/mcp failures.
+ */
+export class MCPError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'MCPError';
+    }
+}
+/**
+ * Raised when an MCP tool call returns `isError: true` or when the result
+ * cannot be mapped to a usable model output.
+ */
+export class MCPToolCallError extends MCPError {
+    constructor(toolName, message, options) {
+        super(message, options);
+        this.name = 'MCPToolCallError';
+        this.toolName = toolName;
+    }
+}
+/**
+ * Raised when a cached snapshot cannot be validated or rehydrated.
+ */
+export class MCPCacheError extends MCPError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'MCPCacheError';
+    }
+}
+/**
+ * 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 class MCPCacheWriteError extends MCPCacheError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'MCPCacheWriteError';
+    }
+}
+/**
+ * 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 class MCPStaleSnapshotError extends MCPCacheError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'MCPStaleSnapshotError';
+    }
+}
+/**
+ * Raised when connecting to the MCP server fails across all attempted transports.
+ */
+export class MCPConnectionError extends MCPError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'MCPConnectionError';
+        // Default a single-attempt failure to its own cause, so `errors` is a
+        // uniform "every attempt" list rather than empty-unless-multi.
+        this.errors =
+            options?.errors ??
+                (options?.cause !== undefined
+                    ? [
+                        options.cause,
+                    ]
+                    : []);
+    }
+}
+/**
+ * Raised when MCP support is used without its optional SDK peer installed.
+ */
+export class MCPMissingPeerDependencyError extends MCPConnectionError {
+    constructor(options) {
+        super('MCP support requires the optional peer "@modelcontextprotocol/client". ' +
+            'Install it alongside @openrouter/agent (for example: pnpm add @modelcontextprotocol/client).', options);
+        this.packageName = '@modelcontextprotocol/client';
+        this.name = 'MCPMissingPeerDependencyError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/esm/mcp/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/mcp/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,QAAS,SAAQ,KAAK;IACjC,YACE,OAAe,EACf,OAEC;QAED,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;IACzB,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,OAAO,gBAAiB,SAAQ,QAAQ;IAG5C,YACE,QAAgB,EAChB,OAAe,EACf,OAEC;QAED,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;QAC/B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,aAAc,SAAQ,QAAQ;IACzC,YACE,OAAe,EACf,OAEC;QAED,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;CACF;AAED;;;;;;;;;;GAUG;AACH,MAAM,OAAO,kBAAmB,SAAQ,aAAa;IACnD,YACE,OAAe,EACf,OAEC;QAED,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AAED;;;;;;;;GAQG;AACH,MAAM,OAAO,qBAAsB,SAAQ,aAAa;IACtD,YACE,OAAe,EACf,OAEC;QAED,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,kBAAmB,SAAQ,QAAQ;IAkB9C,YACE,OAAe,EACf,OAGC;QAED,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,sEAAsE;QACtE,+DAA+D;QAC/D,IAAI,CAAC,MAAM;YACT,OAAO,EAAE,MAAM;gBACf,CAAC,OAAO,EAAE,KAAK,KAAK,SAAS;oBAC3B,CAAC,CAAC;wBACE,OAAO,CAAC,KAAK;qBACd;oBACH,CAAC,CAAC,EAAE,CAAC,CAAC;IACZ,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,6BAA8B,SAAQ,kBAAkB;IAGnE,YAAY,OAEX;QACC,KAAK,CACH,yEAAyE;YACvE,8FAA8F,EAChG,OAAO,CACR,CAAC;QATK,gBAAW,GAAG,8BAA8B,CAAC;QAUpD,IAAI,CAAC,IAAI,GAAG,+BAA+B,CAAC;IAC9C,CAAC;CACF"}

package/esm/mcp/handle.d.ts

@@ -0,0 +1,66 @@
+import type { MCPConnection } from './mcp-connection.js';
+import type { McpToolDef } from './tool-wrapper.js';
+import type { MCPTransportKind } from './transport-types.js';
+import type { CreateMCPToolsOptions, MCPToolsHandle } from './types.js';
+export declare function normalizeUrl(url: string | URL): URL;
+/**
+ * Read the discovered tools off the live connection into our internal shape.
+ *
+ * `tools/list` is paginated: each response may carry a `nextCursor` that must be
+ * passed back as `{ cursor }` to fetch the next page. We accumulate every page so
+ * servers that paginate their tool list aren't silently truncated.
+ *
+ * Always `cacheMode: 'refresh'`. SDK v2 keeps a per-client response cache
+ * honouring the server's `ttlMs` on `tools/list` (up to 24h), so the default
+ * `'use'` would serve a still-fresh cached list without a round trip. That is
+ * fine for an opportunistic read but wrong for every caller here: `refresh()`
+ * documents a forced re-read, `freshConnect` is establishing the tool set for the
+ * first time, and the stale-replay path exists precisely because the age of the
+ * cached list is no longer acceptable. `'refresh'` fetches and re-stores, so the
+ * cache stays warm for the SDK's own readers.
+ *
+ * `'refresh'` rather than `'bypass'` deliberately — bypass would skip the write
+ * too, leaving a stale entry behind for anything that later reads with `'use'`.
+ */
+export declare function listToolDefs(connection: MCPConnection, signal: AbortSignal | undefined): Promise<McpToolDef[]>;
+interface HandleContext {
+    url: URL;
+    transport: MCPTransportKind;
+    cacheKey: string;
+}
+export interface MakeHandleArgs {
+    connection: MCPConnection;
+    options: CreateMCPToolsOptions;
+    context: HandleContext;
+    initialToolDefs: McpToolDef[];
+    /**
+     * `cachedAt` to carry forward when `initialToolDefs` came from a snapshot
+     * rather than a live `listTools()`. Omit on a cold connect so the write
+     * stamps now.
+     *
+     * Without this a replay would restamp `cachedAt` on the write-back below,
+     * resetting the staleness clock on a tool set that was never re-listed —
+     * so `staleness.maxAgeMs` could never fire on a repeatedly-rehydrated
+     * snapshot. Age tracks when the tools were last actually discovered, not
+     * when they were last replayed. `refresh()` clears it, because that path
+     * does re-list.
+     */
+    replayedCachedAt?: number;
+}
+/**
+ * Connect, discover tools via `listTools()`, and build a handle WITHOUT
+ * consulting the cache for a hit. The cache (when present on `options`) is still
+ * written through `makeHandle`, so refreshes persist. This is the cold cache-miss
+ * path, and is also called directly by `rehydrateMCPTools`'s fallback: routing
+ * the fallback here instead of back through `createMCPTools` is what prevents the
+ * cache-fallback loop — re-reading the same snapshot would re-enter rehydrate and
+ * recurse without bound.
+ */
+export declare function freshConnect(options: CreateMCPToolsOptions, url: URL, cacheKey: string): Promise<MCPToolsHandle>;
+/**
+ * Construct an {@link MCPToolsHandle} around a live connection, wiring refresh,
+ * serialize, list_changed listeners, and cache writes.
+ */
+export declare function makeHandle(args: MakeHandleArgs): Promise<MCPToolsHandle>;
+export {};
+//# sourceMappingURL=handle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handle.d.ts","sourceRoot":"","sources":["../../src/mcp/handle.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAExE,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,CAEnD;AAiCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,YAAY,CAChC,UAAU,EAAE,aAAa,EACzB,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,UAAU,EAAE,CAAC,CA0CvB;AAOD,UAAU,aAAa;IACrB,GAAG,EAAE,GAAG,CAAC;IACT,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,aAAa,CAAC;IAC1B,OAAO,EAAE,qBAAqB,CAAC;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,eAAe,EAAE,UAAU,EAAE,CAAC;IAC9B;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,qBAAqB,EAC9B,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,cAAc,CAAC,CA+CzB;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CA4H9E"}

package/esm/mcp/handle.js

@@ -0,0 +1,323 @@
+import { buildTools } from './build-tools.js';
+import { serializeServer } from './cache/serialize.js';
+import { closeQuietly } from './close-quietly.js';
+import { MCPCacheWriteError } from './errors.js';
+import { connect } from './mcp-connection.js';
+export function normalizeUrl(url) {
+    return url instanceof URL ? url : new URL(url);
+}
+// Hard cap on pagination pages. A well-behaved server terminates the cursor
+// chain by omitting `nextCursor`; this bounds a misbehaving one that never does.
+const MAX_LIST_PAGES = 1000;
+/**
+ * Normalize a paginated `nextCursor` field: treat anything that is not a
+ * non-empty string as "no more pages" so a malformed cursor terminates the loop.
+ */
+function nextCursorOrUndefined(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/**
+ * Parse a server-advertised doom-loop identity from a tool definition's
+ * `_meta['openrouter/loopKey']`: a field-name array (the declarative subset
+ * of arguments identifying a call) or `false` (tool exempt). Data-only by
+ * design — functions can't cross the wire; any other shape is ignored.
+ */
+function advertisedLoopKey(meta) {
+    const advertised = meta?.['openrouter/loopKey'];
+    if (advertised === false) {
+        return false;
+    }
+    if (Array.isArray(advertised) && advertised.every((f) => typeof f === 'string')) {
+        return advertised;
+    }
+    return undefined;
+}
+/**
+ * Read the discovered tools off the live connection into our internal shape.
+ *
+ * `tools/list` is paginated: each response may carry a `nextCursor` that must be
+ * passed back as `{ cursor }` to fetch the next page. We accumulate every page so
+ * servers that paginate their tool list aren't silently truncated.
+ *
+ * Always `cacheMode: 'refresh'`. SDK v2 keeps a per-client response cache
+ * honouring the server's `ttlMs` on `tools/list` (up to 24h), so the default
+ * `'use'` would serve a still-fresh cached list without a round trip. That is
+ * fine for an opportunistic read but wrong for every caller here: `refresh()`
+ * documents a forced re-read, `freshConnect` is establishing the tool set for the
+ * first time, and the stale-replay path exists precisely because the age of the
+ * cached list is no longer acceptable. `'refresh'` fetches and re-stores, so the
+ * cache stays warm for the SDK's own readers.
+ *
+ * `'refresh'` rather than `'bypass'` deliberately — bypass would skip the write
+ * too, leaving a stale entry behind for anything that later reads with `'use'`.
+ */
+export async function listToolDefs(connection, signal) {
+    const requestOptions = {
+        cacheMode: 'refresh',
+        ...(signal !== undefined && {
+            signal,
+        }),
+    };
+    const collected = [];
+    let cursor;
+    for (let page = 0; page < MAX_LIST_PAGES; page += 1) {
+        const params = cursor !== undefined
+            ? {
+                cursor,
+            }
+            : undefined;
+        const { tools, nextCursor } = await connection.client.listTools(params, requestOptions);
+        for (const t of tools) {
+            const loopKey = advertisedLoopKey(t._meta);
+            collected.push({
+                name: t.name,
+                ...(t.description !== undefined && {
+                    description: t.description,
+                }),
+                inputSchema: t.inputSchema,
+                ...(t.outputSchema !== undefined && {
+                    outputSchema: t.outputSchema,
+                }),
+                ...(loopKey !== undefined && {
+                    loopKey,
+                }),
+            });
+        }
+        const next = nextCursorOrUndefined(nextCursor);
+        // Stop at the end of the chain, or if the server echoes the same cursor
+        // (which would otherwise spin forever).
+        if (next === undefined || next === cursor) {
+            break;
+        }
+        cursor = next;
+    }
+    return collected;
+}
+function serverHasResources(connection) {
+    const caps = connection.client.getServerCapabilities();
+    return caps?.resources !== undefined;
+}
+/**
+ * Connect, discover tools via `listTools()`, and build a handle WITHOUT
+ * consulting the cache for a hit. The cache (when present on `options`) is still
+ * written through `makeHandle`, so refreshes persist. This is the cold cache-miss
+ * path, and is also called directly by `rehydrateMCPTools`'s fallback: routing
+ * the fallback here instead of back through `createMCPTools` is what prevents the
+ * cache-fallback loop — re-reading the same snapshot would re-enter rehydrate and
+ * recurse without bound.
+ */
+export async function freshConnect(options, url, cacheKey) {
+    const connection = await connect({
+        url,
+        ...(options.transport !== undefined && {
+            transport: options.transport,
+        }),
+        ...(options.auth !== undefined && {
+            auth: options.auth,
+        }),
+        ...(options.fetch !== undefined && {
+            fetch: options.fetch,
+        }),
+        ...(options.clientInfo !== undefined && {
+            clientInfo: options.clientInfo,
+        }),
+        ...(options.onElicitation !== undefined && {
+            onElicitation: options.onElicitation,
+        }),
+        ...(options.protocolNegotiation !== undefined && {
+            protocolNegotiation: options.protocolNegotiation,
+        }),
+        ...(options.probeTimeoutMs !== undefined && {
+            probeTimeoutMs: options.probeTimeoutMs,
+        }),
+        ...(options.signal !== undefined && {
+            signal: options.signal,
+        }),
+    });
+    // Tear the connection down if discovery or the initial cache write throws —
+    // otherwise the open transport (HTTP keep-alive / SSE stream) leaks.
+    try {
+        const initialToolDefs = await listToolDefs(connection, options.signal);
+        return await makeHandle({
+            connection,
+            options,
+            context: {
+                url,
+                transport: connection.transport,
+                cacheKey,
+            },
+            initialToolDefs,
+        });
+    }
+    catch (err) {
+        await closeQuietly(connection);
+        throw err;
+    }
+}
+/**
+ * Construct an {@link MCPToolsHandle} around a live connection, wiring refresh,
+ * serialize, list_changed listeners, and cache writes.
+ */
+export async function makeHandle(args) {
+    const { connection, options, context, initialToolDefs } = args;
+    const listeners = new Set();
+    let toolDefs = initialToolDefs;
+    // Cleared by refresh(): once we have re-listed, age is measured from now.
+    let replayedCachedAt = args.replayedCachedAt;
+    const serverInfo = connection.client.getServerVersion();
+    const rebuild = () => buildTools(buildToolsArgs(connection, toolDefs, options));
+    let tools = rebuild();
+    const snapshot = () => serializeServer(serializeArgs({
+        connection,
+        context,
+        toolDefs,
+        serverInfo,
+        options,
+        ...(replayedCachedAt !== undefined && {
+            cachedAt: replayedCachedAt,
+        }),
+    }));
+    const writeCache = async () => {
+        const store = options.cache?.store;
+        if (store === undefined) {
+            return;
+        }
+        // Built OUTSIDE the try: `snapshot()` can reject from the caller's own
+        // OAuth provider (`provider.tokens()`), and relabelling that as a cache
+        // write failure would send it down every "store outages are harmless"
+        // path — swallowed by the list_changed handler, ignored by
+        // `refreshStaleReplay`, and dismissed by callers following the documented
+        // `MCPCacheWriteError` pattern. Only the store op earns the tag.
+        const payload = await snapshot();
+        try {
+            await store.set(context.cacheKey, payload);
+        }
+        catch (writeErr) {
+            // Tagged so callers can tell a store outage from a failed read. The two
+            // look identical coming out of `refresh()` but mean opposite things: a
+            // failed read leaves the tool set unknown, while a failed write leaves a
+            // live connection with current tools and only a stale cache entry.
+            throw new MCPCacheWriteError('Failed to write the MCP snapshot to the cache store', {
+                cause: writeErr,
+            });
+        }
+    };
+    // INVARIANT internal callers rely on: `refresh()` swaps `tools` to a fresh
+    // array (rebuild() always allocates) exactly when the re-list succeeded, and
+    // it does so BEFORE attempting to persist. A caller that captured the old
+    // reference can therefore tell "the re-list failed" (reference unchanged)
+    // from "only something after the re-list failed" (reference changed) without
+    // inspecting the error — which no error-class check can do reliably, since
+    // persistence can fail outside the store op too (the caller's own OAuth
+    // provider rejecting inside `snapshot()`).
+    const refresh = async () => {
+        toolDefs = await listToolDefs(connection, options.signal);
+        // Re-listed, so the snapshot is genuinely current from here on.
+        replayedCachedAt = undefined;
+        tools = rebuild();
+        await writeCache();
+        return tools;
+    };
+    if (options.autoRefreshOnListChanged ?? true) {
+        connection.setToolListChangedHandler(() => {
+            // Fire-and-forget, but never let a failed refresh escape as an unhandled
+            // rejection. Whether to announce is keyed on ADOPTION (the reference
+            // swap above), not on error class: once `refresh()` has swapped `tools`,
+            // skipping the announcement would leave subscribers permanently out of
+            // sync with `handle.tools`, no matter what broke afterwards — a store
+            // outage and an OAuth provider failing during serialize gate it equally
+            // little. On a failed re-list the reference is untouched and subscribers
+            // correctly keep the last good set.
+            const before = tools;
+            void refresh()
+                .catch(() => undefined)
+                .then(() => {
+                if (tools === before) {
+                    return;
+                }
+                for (const listener of listeners) {
+                    listener(tools);
+                }
+            })
+                .catch(() => { });
+        });
+    }
+    // Skipped entirely on a replay: with `replayedCachedAt` carried forward the
+    // snapshot we would write is the one just read — same tool defs, same
+    // `cachedAt` — so the write is an external store round-trip per rehydrate
+    // buying nothing. (It also cannot *refresh* anything: preserving the age is
+    // the point.) A cold connect writes; `refresh()` clears `replayedCachedAt`
+    // and writes. Skipping here additionally narrows DEV-766's surface — one
+    // fewer path that can rewrite a credentialed entry under different options.
+    //
+    // Best-effort when it does run: the handle is fully usable without its cache
+    // entry, so a store outage should not stop a connection that already
+    // succeeded. `refresh()` reports write failures as `MCPCacheWriteError` for
+    // callers that do care.
+    if (args.replayedCachedAt === undefined) {
+        await writeCache().catch(() => { });
+    }
+    return {
+        get tools() {
+            return tools;
+        },
+        ...(serverInfo !== undefined && {
+            serverInfo,
+        }),
+        serialize: snapshot,
+        refresh,
+        onToolsChanged: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        close: () => connection.close(),
+    };
+}
+/** Assemble the {@link buildTools} arguments, threading only the defined options. */
+function buildToolsArgs(connection, toolDefs, options) {
+    return {
+        client: connection.client,
+        toolDefs,
+        emitProgress: options.emitProgress ?? true,
+        serverHasResources: serverHasResources(connection),
+        ...(options.toolNamePrefix !== undefined && {
+            namePrefix: options.toolNamePrefix,
+        }),
+        ...(options.includeTools !== undefined && {
+            includeTools: options.includeTools,
+        }),
+        ...(options.excludeTools !== undefined && {
+            excludeTools: options.excludeTools,
+        }),
+        ...(options.onUnconvertibleSchema !== undefined && {
+            schemaMode: options.onUnconvertibleSchema,
+        }),
+        ...(options.signal !== undefined && {
+            signal: options.signal,
+        }),
+        ...(options.loopKeys !== undefined && {
+            loopKeys: options.loopKeys,
+        }),
+        ...(options.resources !== undefined && {
+            resources: options.resources,
+        }),
+    };
+}
+/** Assemble the {@link serializeServer} input, threading only the defined fields. */
+function serializeArgs(args) {
+    const { connection, context, toolDefs, serverInfo, options } = args;
+    return {
+        url: context.url.href,
+        transport: connection.transport,
+        toolDefs,
+        cacheCredentials: options.cacheCredentials ?? false,
+        cachedAt: args.cachedAt ?? Date.now(),
+        ...(serverInfo !== undefined && {
+            serverInfo,
+        }),
+        ...(options.auth !== undefined && {
+            auth: options.auth,
+        }),
+    };
+}
+//# sourceMappingURL=handle.js.map

package/esm/mcp/handle.js.map

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

package/esm/mcp/index.d.ts

@@ -0,0 +1,13 @@
+export type { MCPAuth, MCPOAuthClientProvider } from './auth/auth-types.js';
+export type { MCPCacheStore } from './cache/cache-store.js';
+export { defaultCacheKey, InMemoryMCPCacheStore } from './cache/cache-store.js';
+export type { SerializedMCPServer, SerializedMCPToolDef, SerializedTokenSet, } from './cache/cache-types.js';
+export { isSerializedMCPServer } from './cache/cache-types.js';
+export { createMCPTools } from './create-mcp-tools.js';
+export { MCPCacheError, MCPCacheWriteError, MCPConnectionError, MCPError, MCPMissingPeerDependencyError, MCPStaleSnapshotError, MCPToolCallError, } from './errors.js';
+export type { RehydrateMCPToolsOptions } from './rehydrate.js';
+export { rehydrateMCPTools } from './rehydrate.js';
+export type { UnconvertibleSchemaMode } from './schema/json-schema-to-zod.js';
+export { convertMcpInputSchema } from './schema/json-schema-to-zod.js';
+export type { CreateMCPToolsOptions, ElicitationHandler, ElicitationResponse, MCPProtocolNegotiation, MCPProtocolRevision, MCPToolsHandle, MCPTransportKind, ResourcesOption, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAGA,YAAY,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC5E,YAAY,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE5D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAChF,YAAY,EACV,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,6BAA6B,EAC7B,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACnD,YAAY,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAE9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,YAAY,EACV,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,eAAe,GAChB,MAAM,YAAY,CAAC"}

package/esm/mcp/index.js

@@ -0,0 +1,11 @@
+// Main factory + rehydration
+// Cache
+export { defaultCacheKey, InMemoryMCPCacheStore } from './cache/cache-store.js';
+export { isSerializedMCPServer } from './cache/cache-types.js';
+export { createMCPTools } from './create-mcp-tools.js';
+// Errors
+export { MCPCacheError, MCPCacheWriteError, MCPConnectionError, MCPError, MCPMissingPeerDependencyError, MCPStaleSnapshotError, MCPToolCallError, } from './errors.js';
+export { rehydrateMCPTools } from './rehydrate.js';
+// Schema conversion (exported for testing/reuse)
+export { convertMcpInputSchema } from './schema/json-schema-to-zod.js';
+//# sourceMappingURL=index.js.map

package/esm/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAAA,6BAA6B;AAK7B,QAAQ;AACR,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAMhF,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,SAAS;AACT,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,6BAA6B,EAC7B,qBAAqB,EACrB,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,iDAAiD;AACjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC"}