@openrouter/mcp 1.0.0 → 1.1.1

package/README.md

@@ -1,5 +1,11 @@
 # @openrouter/mcp
 
+> [!NOTE]
+> This package is a migration-only compatibility facade. New code should import
+> the canonical `@openrouter/agent/mcp` subpath. Existing `@openrouter/mcp` root
+> and subpath imports remain functional and would only be removed in a future
+> breaking release after migration notice.
+
 Expose the tools of a remote [Model Context Protocol](https://modelcontextprotocol.io) server
 (Streamable HTTP or SSE) as tools you can pass straight into
 [`@openrouter/agent`](https://www.npmjs.com/package/@openrouter/agent)'s `callModel`.
@@ -9,25 +15,46 @@ Expose the tools of a remote [Model Context Protocol](https://modelcontextprotoc
 - Faithful JSON Schema → Zod conversion so the model sees real parameters.
 - Serializable, rehydratable cache so you can skip re-listing (and, opt-in, re-authenticating).
 - Progress streaming, `tools/list_changed` auto-refresh, cancellation, resources, and elicitation.
-- Speaks both MCP protocol revisions (`2025-11-25` and `2026-07-28`), negotiated per server.
 
 > stdio servers are intentionally out of scope.
 
 ## Install
 
-Requires **Node 20+** (inherited from `@modelcontextprotocol/client@2`, which declares
-`engines.node: >=20`; this package declares the same).
+For new code, install the agent plus the optional MCP peer:
 
 ```bash
-pnpm add @openrouter/mcp @openrouter/agent
+pnpm add @openrouter/agent @modelcontextprotocol/client
 ```
 
+Existing applications can keep installing only the compatibility package; it retains `@modelcontextprotocol/client` as a dependency, so the prior transitive-install behavior is unchanged:
+
+```bash
+pnpm add @openrouter/mcp
+```
+
+The agent package is marked `sideEffects: false`, and MCP code is exposed only
+through explicit `/mcp` exports. Root and `/tool-set` imports do not statically
+load MCP modules; the MCP SDK is not installed transitively for base agent users.
+The `/mcp` entry point also loads the optional SDK lazily: importing it is safe
+without the peer, while the first connection attempt throws an actionable
+`MCPMissingPeerDependencyError` when the SDK has not been installed.
+
+## Compatibility subpaths
+
+| Existing facade | Canonical replacement |
+| --- | --- |
+| `@openrouter/mcp` | `@openrouter/agent/mcp` |
+| `@openrouter/mcp/create-mcp-tools` | `@openrouter/agent/mcp/create-mcp-tools` |
+| `@openrouter/mcp/types` | `@openrouter/agent/mcp/types` |
+| `@openrouter/mcp/schema` | `@openrouter/agent/mcp/schema` |
+| `@openrouter/mcp/cache` | `@openrouter/agent/mcp/cache` |
+
 ## Quick start
 
 ```ts
 import { OpenRouter } from '@openrouter/agent';
 import { callModel } from '@openrouter/agent/call-model';
-import { createMCPTools } from '@openrouter/mcp';
+import { createMCPTools } from '@openrouter/agent/mcp';
 
 const client = new OpenRouter({ apiKey: process.env.OPENROUTER_API_KEY });
 
@@ -59,15 +86,15 @@ auth: { kind: 'headers', headers: { 'X-API-Key': key } }
 auth: { kind: 'oauth', provider }
 ```
 
-Prefer an OAuth provider over caching static tokens — the transport refreshes through it
-automatically. Type yours with `MCPOAuthClientProvider`, re-exported from this package.
+Prefer an `OAuthClientProvider` over caching static tokens — the transport refreshes through it
+automatically.
 
 ## Caching & rehydration
 
 Persist a snapshot and rebuild later without a `listTools()` round-trip:
 
 ```ts
-import { createMCPTools, rehydrateMCPTools } from '@openrouter/mcp';
+import { createMCPTools, rehydrateMCPTools } from '@openrouter/agent/mcp';
 
 const mcp = await createMCPTools({ url, auth, cacheCredentials: true });
 const snapshot = await mcp.serialize();   // plain JSON — store anywhere
@@ -79,7 +106,7 @@ const mcp2 = await rehydrateMCPTools({ snapshot, auth });
 Or let a store manage it (rehydrate on hit, connect + write on miss):
 
 ```ts
-import { InMemoryMCPCacheStore } from '@openrouter/mcp';
+import { InMemoryMCPCacheStore } from '@openrouter/agent/mcp';
 
 const store = new InMemoryMCPCacheStore(); // or your own Redis/DB-backed MCPCacheStore
 const mcp = await createMCPTools({
@@ -90,44 +117,9 @@ const mcp = await createMCPTools({
 });
 ```
 
-`staleness.maxAgeMs` is honoured by `rehydrateMCPTools()` as well as by `createMCPTools()`'s
-cache-hit path, and on every path — including `reconnectOnExpiry: false`, which opts out of
-rebuilding the transport, not out of bounded-age tools. An over-age snapshot re-lists over
-the replayed connection. If that re-list fails, the call rejects with `MCPStaleSnapshotError`
-rather than quietly serving tools you declared too old; catch it to opt back in:
-
-```ts
-import { rehydrateMCPTools, MCPStaleSnapshotError } from '@openrouter/mcp';
-
-try {
-  return await rehydrateMCPTools({
-    snapshot,
-    staleness: { maxAgeMs: 60_000 },
-    reconnectOnExpiry: false,
-  });
-} catch (err) {
-  if (err instanceof MCPStaleSnapshotError) {
-    // Connection was fine, only the re-list failed — take the cached tool set.
-    return await rehydrateMCPTools({ snapshot, reconnectOnExpiry: false });
-  }
-  throw err;
-}
-```
-
-It subclasses `MCPCacheError`, so existing `catch (e instanceof MCPCacheError)` sites keep
-working. Note that a successful replay does not write to the store — the snapshot it would
-write is the one just read. Seeding a store from a snapshot obtained elsewhere means writing
-it yourself or calling `handle.refresh()` after rehydrating. Writing a snapshot back to your store is best-effort: a store outage leaves you with a
-working handle and a stale cache entry rather than a failed call. Catch `MCPCacheWriteError`
-from `handle.refresh()` if you would rather treat that as fatal. `handle.refresh()` also always reaches the server: SDK v2 caches `tools/list` per
-client up to the server's `ttlMs`, and every internal list read bypasses that so a refresh
-cannot hand back the previous tool set.
-
 > **Security:** `cacheCredentials` is `false` by default. When enabled, snapshots contain bearer
 > tokens/headers — treat the store as a secret store and namespace cache keys by principal in
-> multi-tenant setups. Session ids are never persisted: an `Mcp-Session-Id` is
-> bearer-equivalent to an authenticated server session, and nothing reads it back, so it would
-> be attack surface for no functionality. A `sessionId` found in an old snapshot is ignored.
+> multi-tenant setups.
 
 ## Multiple servers
 
@@ -149,9 +141,7 @@ const result = callModel(client, {
 | Option | Description |
 | --- | --- |
 | `url` | Remote MCP server endpoint. |
-| `transport` | `'streamableHttp'` (default, falls back to SSE) or `'sse'` (deprecated upstream). |
-| `protocolNegotiation` | `'auto'` (default), `'legacy'`, or `{ pin }`. See Protocol revisions. |
-| `probeTimeoutMs` | Ceiling on the `server/discover` probe (default 30000). |
+| `transport` | `'streamableHttp'` (default, falls back to SSE) or `'sse'`. |
 | `auth` | Bearer token, headers, or an `OAuthClientProvider`. |
 | `toolNamePrefix` | Prefix every wrapped tool name. |
 | `includeTools` / `excludeTools` | Allow/deny lists by MCP tool name. |
@@ -160,117 +150,8 @@ const result = callModel(client, {
 | `resources` | Expose synthetic `list_resources` / `read_resource` tools (default on). |
 | `emitProgress` | Stream MCP progress as generator-tool events (default on). |
 | `autoRefreshOnListChanged` | Re-list on `tools/list_changed` (default on). |
-| `onElicitation` | Handle elicitation requests (both revisions); auto-declines when omitted. |
-| `signal` | Aborts every tool call and the connection itself (connect, probe, legacy retry, reconnects). |
-
-## Client identity
-
-The client identifies itself to every server it connects to via MCP `clientInfo`
-(`{ name, version }`). Pass `clientInfo` in options to override it; otherwise the default
-is `@openrouter/mcp` at this package's version.
-
-That version is **generated** into `src/version.ts` from `package.json`, which is the
-single source of truth. `build` regenerates it, so a changesets version bump is picked up
-automatically before publish. To regenerate by hand:
-
-```bash
-pnpm --filter @openrouter/mcp gen:version
-```
-
-The generated file is committed rather than gitignored, because CI's lint, typecheck, and
-unit-test jobs compile `src` without running a build. `tests/unit/version.test.ts` fails
-if the committed constant drifts from `package.json`, so a stale value cannot merge.
-
-## Protocol revisions
-
-Both current MCP revisions are supported, and the right one is chosen for you. Point this
-at any server and it works:
-
-```ts
-const mcp = await createMCPTools({ url: 'https://mcp.example.com/mcp' });
-```
-
-By default (`protocolNegotiation: 'auto'`) the client probes with `server/discover` and
-then speaks whichever revision the server offers:
-
-| Server | What goes on the wire |
-| --- | --- |
-| **`2026-07-28`** | `server/discover`, then requests carrying the per-request `_meta` envelope and `Mcp-Method` / `Mcp-Name` headers. No `initialize` — the handshake is removed in this revision (SEP-2575). |
-| **`2025-11-25`** and earlier | `server/discover`, then a fallback to the classic `initialize` + `notifications/initialized` handshake, byte-equivalent to a 2025-only client. |
-
-A probe is a new request, and some infrastructure dislikes new requests — a proxy, WAF, or
-strict gateway may hang or 5xx on an unknown method. **You don't need to configure anything
-for that case.** When you have not set `protocolNegotiation`, a failed connect is retried
-once with `'legacy'`, so such a server connects exactly as it did before this package
-probed at all. That covers the pinned `transport: 'sse'` path and the Streamable HTTP → SSE
-fallback too, since all three share one client factory.
-
-Override when you need to:
-
-```ts
-// Skip the probe. A performance choice, not a compatibility one: saves the extra
-// round trip when you already know the server is 2025-era.
-await createMCPTools({ url, protocolNegotiation: 'legacy' });
-
-// Require a specific revision; fail loudly rather than falling back.
-await createMCPTools({ url, protocolNegotiation: { pin: '2026-07-28' } });
-```
-
-> Setting `protocolNegotiation` at all — **including to `'auto'`** — opts out of the
-> automatic legacy retry. Naming a mode means you want that mode's failures too, and
-> silently overriding a `{ pin }` would defeat the point of pinning.
-
-The probe is bounded at 30s; pass `probeTimeoutMs` to change it. Without a bound the SDK gives
-the probe the full 60s request timeout, so a black-holing gateway takes minutes to fail. The
-ceiling is not tighter because a probe timeout is *not* recoverable — on HTTP it counts as an
-outage, and the legacy retry speaks a handshake that `2026-07-28` removed — so a modern-only
-server slower than the ceiling would fail outright rather than just take longer. Lower it when
-you control the server and want to fail fast; raise it for known-slow cold starts.
-
-`'auto'` costs one extra round trip against legacy servers. When a connect fails, the retry
-re-walks the same transport ladder under `'legacy'`, so an unreachable server is dialled up to
-four times before erroring — the price of guaranteeing that a legacy server reachable only
-over SSE still connects when its probe is refused.
-
-An auth failure skips the retry: the SDK's `UnauthorizedError`, or — when an OAuth provider is
-configured — a **401** status from the probe (which the SDK reports as an `SdkHttpError`
-rather than routing through the OAuth flow), from any attempt, not only the last. A **403**
-never skips it, even under OAuth: the SDK's PKCE side effects occur only on 401, so a 403
-retry re-drives nothing, while gateways commonly answer unknown methods with 403 — the exact
-case the retry exists to rescue. Rejected credentials are not something a different protocol
-revision fixes, and retrying a 401 would drive an OAuth authorization flow twice and overwrite
-the saved PKCE verifier.
-
-`MCPConnectionError` exposes every underlying failure on `errors` (like `AggregateError`), flat
-and in attempt order across both negotiation passes, so nothing is hidden behind `cause` —
-which holds only the last attempt.
-
-There are no hardcoded protocol version strings in this package — negotiation is delegated to
-`@modelcontextprotocol/client`.
-
-### What differs between the revisions
-
-Mostly nothing you need to care about, with three exceptions:
-
-| Surface | Behavior |
-| --- | --- |
-| `onElicitation` | **Works on both.** On 2025-era servers it handles `elicitation/create`; on 2026-07-28 that request is gone, but the SDK's multi-round-trip driver (SEP-2322) routes `input_required` results through the same handler and retries the call. |
-| `sessionId` | 2025-era only. Protocol sessions and `Mcp-Session-Id` are removed in 2026-07-28 (SEP-2567), so it is `undefined` there. Snapshots keep the field so older ones still deserialize. |
-| `transport: 'sse'` | Still supported for legacy servers, but HTTP+SSE is reclassified Deprecated (SEP-2596). Prefer `streamableHttp`. |
-
-Sampling and Roots are deprecated in the new revision and were never implemented here, so
-there is nothing to migrate.
-
-The SDK also keeps its own per-client response cache (24h ceiling), independent of the
-`MCPCacheStore` described above. The two are unrelated: `MCPCacheStore` persists a tool
-snapshot across processes and, opt-in, credentials.
-
-### OAuth provider types
-
-If you pass `{ kind: 'oauth', provider }`, type your provider with
-`MCPOAuthClientProvider` from this package rather than importing from
-`@modelcontextprotocol/client` — that import path is an implementation detail and has
-changed once already.
+| `onElicitation` | Handle server elicitation requests; auto-declines when omitted. |
+| `signal` | Abort signal threaded into every tool call. |
 
 ## License
 

package/esm/cache.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @deprecated Import from `@openrouter/agent/mcp/cache` instead.
+ * This compatibility subpath remains available for migration.
+ */
+export type { MCPCacheStore } from '@openrouter/agent/mcp/cache';
+export { defaultCacheKey, InMemoryMCPCacheStore } from '@openrouter/agent/mcp/cache';
+//# sourceMappingURL=cache.d.ts.map

package/esm/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC"}

package/esm/cache.js

@@ -0,0 +1,2 @@
+export { defaultCacheKey, InMemoryMCPCacheStore } from '@openrouter/agent/mcp/cache';
+//# sourceMappingURL=cache.js.map

package/esm/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC"}

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

@@ -1,13 +1,7 @@
-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.
+ * @deprecated Import from `@openrouter/agent/mcp/create-mcp-tools` instead.
+ * This compatibility subpath remains available for migration.
  */
-export declare function createMCPTools(options: CreateMCPToolsOptions): Promise<MCPToolsHandle>;
-export type { SerializedMCPServer };
+export type { SerializedMCPServer } from '@openrouter/agent/mcp/create-mcp-tools';
+export { createMCPTools } from '@openrouter/agent/mcp/create-mcp-tools';
 //# sourceMappingURL=create-mcp-tools.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"create-mcp-tools.d.ts","sourceRoot":"","sources":["../src/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;AAkFD,YAAY,EAAE,mBAAmB,EAAE,CAAC"}
+{"version":3,"file":"create-mcp-tools.d.ts","sourceRoot":"","sources":["../src/create-mcp-tools.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC"}

package/esm/create-mcp-tools.js

@@ -1,96 +1,6 @@
-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.
+ * @deprecated Import from `@openrouter/agent/mcp/create-mcp-tools` instead.
+ * This compatibility subpath remains available for migration.
  */
-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) {
-    // A failed read is a miss, not a failure. The cache exists to skip a
-    // listTools() round trip; a store blip on the lookup must not reject a call
-    // that a plain miss would have served via a fresh connect. This mirrors the
-    // write side, which is best-effort everywhere — without it, "a store outage
-    // leaves you with a working handle" only held if the outage arrived after
-    // the read. Wrapped in try/catch rather than `.catch()`: `MCPCacheStore.get`
-    // may return synchronously, and a synchronous throw would bypass a
-    // promise-level handler — the exact hole `closeQuietly` exists to plug on
-    // the teardown side.
-    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,
-        },
-    });
-}
+export { createMCPTools } from '@openrouter/agent/mcp/create-mcp-tools';
 //# sourceMappingURL=create-mcp-tools.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"create-mcp-tools.js","sourceRoot":"","sources":["../src/create-mcp-tools.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"create-mcp-tools.js","sourceRoot":"","sources":["../src/create-mcp-tools.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC"}

package/esm/index.d.ts

@@ -1,13 +1,9 @@
-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, 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';
+/**
+ * Compatibility facade for the canonical `@openrouter/agent/mcp` integration.
+ *
+ * @deprecated Import from `@openrouter/agent/mcp` instead. This facade remains
+ * available for migration and may be removed only in a future breaking release.
+ */
+export type { CreateMCPToolsOptions, ElicitationHandler, ElicitationResponse, MCPAuth, MCPCacheStore, MCPOAuthClientProvider, MCPProtocolNegotiation, MCPProtocolRevision, MCPToolsHandle, MCPTransportKind, RehydrateMCPToolsOptions, ResourcesOption, SerializedMCPServer, SerializedMCPToolDef, SerializedTokenSet, UnconvertibleSchemaMode, } from '@openrouter/agent/mcp';
+export { convertMcpInputSchema, createMCPTools, defaultCacheKey, InMemoryMCPCacheStore, isSerializedMCPServer, MCPCacheError, MCPCacheWriteError, MCPConnectionError, MCPError, MCPMissingPeerDependencyError, MCPStaleSnapshotError, MCPToolCallError, rehydrateMCPTools, } from '@openrouter/agent/mcp';
 //# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/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,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,YAAY,EACV,qBAAqB,EACrB,kBAAkB,EAClB,mBAAmB,EACnB,OAAO,EACP,aAAa,EACb,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,6BAA6B,EAC7B,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,uBAAuB,CAAC"}

package/esm/index.js

@@ -1,11 +1,2 @@
-// 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, 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';
+export { convertMcpInputSchema, createMCPTools, defaultCacheKey, InMemoryMCPCacheStore, isSerializedMCPServer, MCPCacheError, MCPCacheWriteError, MCPConnectionError, MCPError, MCPMissingPeerDependencyError, MCPStaleSnapshotError, MCPToolCallError, rehydrateMCPTools, } from '@openrouter/agent/mcp';
 //# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/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,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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAwBA,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACrB,aAAa,EACb,kBAAkB,EAClB,kBAAkB,EAClB,QAAQ,EACR,6BAA6B,EAC7B,qBAAqB,EACrB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,uBAAuB,CAAC"}

package/esm/schema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @deprecated Import from `@openrouter/agent/mcp/schema` instead.
+ * This compatibility subpath remains available for migration.
+ */
+export type { UnconvertibleSchemaMode } from '@openrouter/agent/mcp/schema';
+export { convertMcpInputSchema } from '@openrouter/agent/mcp/schema';
+//# sourceMappingURL=schema.d.ts.map

package/esm/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,YAAY,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}

package/esm/schema.js

@@ -0,0 +1,2 @@
+export { convertMcpInputSchema } from '@openrouter/agent/mcp/schema';
+//# sourceMappingURL=schema.js.map

package/esm/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}