@atrib/agent 0.1.0

package/dist/adapters/cloudflare-agent.js

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Adapter: attribute MCP tool calls flowing through a Cloudflare Agent.
+ *
+ * Cloudflare's `agents` package exposes two MCP integration surfaces:
+ *
+ *   1. **Server-side `McpAgent`**. you build an MCP server inside a Worker
+ *      by extending `McpAgent` and defining tools on `this.server`. Because
+ *      `this.server` is a real `McpServer` from `@modelcontextprotocol/sdk`,
+ *      you wrap it directly with `atrib()` from `@atrib/mcp`. no helper
+ *      needed. See `packages/integration/examples/cloudflare-agents/` for
+ *      the runnable McpAgent example.
+ *
+ *   2. **Client-side `Agent.addMcpServer`**. your `Agent` (or `AIChatAgent`)
+ *      connects to one or more upstream MCP servers via `this.addMcpServer(name, url)`.
+ *      Cloudflare's `MCPClientManager` constructs an `@modelcontextprotocol/sdk`
+ *      Client per upstream and stores it on `agent.mcp.mcpConnections[name].client`.
+ *      Tool invocations flow through `MCPClientManager.callTool()` which
+ *      delegates straight to `mcpConnections[serverId].client.callTool(...)`
+ *      (verified against `agents@0.9.0` `dist/client-BwgM3cRz.js` line 1444).
+ *
+ * This file is the helper for surface (2). It walks `agent.mcp.mcpConnections`
+ * after the agent has finished registering its upstream MCP servers and
+ * replaces each connection's `client` field with one wrapped by `wrapMcpClient`.
+ * Subsequent tool calls go through atrib's interceptor lifecycle.
+ *
+ * Usage:
+ *
+ *   import { Agent } from 'agents'
+ *   import { atrib, attributeCloudflareAgentMcp } from '@atrib/agent'
+ *
+ *   class WeatherAgent extends Agent<Env> {
+ *     interceptor = atrib({
+ *       creatorKey: this.env.ATRIB_PRIVATE_KEY,
+ *       merchantDomain: 'https://merchant.example.com',
+ *       serverUrls: ['https://weather-mcp.example.com'],
+ *     })
+ *
+ *     async onStart() {
+ *       await this.addMcpServer('weather', 'https://weather-mcp.example.com/mcp', {
+ *         transport: { type: 'streamable-http' },
+ *       })
+ *
+ *       // After all addMcpServer() calls complete, attribute the connections.
+ *       attributeCloudflareAgentMcp(this, { interceptor: this.interceptor })
+ *     }
+ *   }
+ *
+ * If you call `addMcpServer` again later (e.g. in a message handler or after
+ * an OAuth flow completes), call `attributeCloudflareAgentMcp` again. The
+ * helper is idempotent. connections that are already wrapped are skipped.
+ *
+ * Per spec §5.8 (degradation contract), if any single connection fails to wrap
+ * (missing `client` field, unexpected shape), the helper logs a warning with
+ * the `atrib:` prefix and skips it without throwing. The agent's tool calls
+ * continue to work. they just won't be attributed for that connection.
+ */
+import { wrapMcpClient } from './mcp-client.js';
+/** Runtime check that an unknown value structurally matches MinimalMcpClient. */
+function isMinimalMcpClient(v) {
+    return (v != null &&
+        typeof v === 'object' &&
+        typeof v.callTool === 'function');
+}
+/**
+ * Marker symbol set on a wrapped client to make repeated calls to
+ * `attributeCloudflareAgentMcp` idempotent. The Proxy returned by
+ * `wrapMcpClient` carries this property; the unwrapped Client does not.
+ */
+const ATRIB_WRAPPED = Symbol.for('atrib.cloudflare.wrapped');
+/**
+ * Wrap every currently-connected MCP client on a Cloudflare Agent with atrib
+ * attribution. Returns the number of connections wrapped (excluding ones that
+ * were already wrapped). Idempotent. safe to call multiple times.
+ *
+ * Call this in `onStart()` after your `addMcpServer()` calls. If you add more
+ * MCP servers later (in a message handler, after OAuth, etc.), call again.
+ */
+export function attributeCloudflareAgentMcp(agent, options) {
+    const connections = agent.mcp?.mcpConnections;
+    if (!connections || typeof connections !== 'object') {
+        console.warn('atrib: attributeCloudflareAgentMcp called on an agent with no mcp.mcpConnections. ' +
+            "the Cloudflare 'agents' package shape may have changed. Skipping.");
+        return 0;
+    }
+    let wrapped = 0;
+    for (const [name, conn] of Object.entries(connections)) {
+        try {
+            if (!conn || !isMinimalMcpClient(conn.client)) {
+                console.warn(`atrib: connection '${name}' has no client field, skipping`);
+                continue;
+            }
+            // Skip already-wrapped clients (idempotency)
+            if (conn.client[ATRIB_WRAPPED] === true) {
+                continue;
+            }
+            // Derive serverUrl: explicit override > connection.url.origin > undefined
+            let serverUrl = options.serverUrls?.[name];
+            if (!serverUrl && conn.url) {
+                try {
+                    const u = conn.url instanceof URL ? conn.url : new URL(conn.url);
+                    serverUrl = u.origin;
+                }
+                catch {
+                    // URL parse failed; let wrapMcpClient fall back to no serverUrl
+                }
+            }
+            const wrappedClient = wrapMcpClient(conn.client, options.interceptor, serverUrl ? { serverUrl } : {});
+            wrappedClient[ATRIB_WRAPPED] = true;
+            // Replace the client field in place. MCPClientManager.callTool reads
+            // mcpConnections[serverId].client at invocation time, so subsequent
+            // tool calls will go through the wrapped client.
+            conn.client = wrappedClient;
+            wrapped++;
+        }
+        catch (err) {
+            // §5.8 degradation contract: never let a single bad connection break
+            // the whole agent. Log and continue.
+            console.warn(`atrib: failed to wrap MCP connection '${name}', skipping:`, err);
+        }
+    }
+    return wrapped;
+}
+//# sourceMappingURL=cloudflare-agent.js.map

package/dist/adapters/cloudflare-agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-agent.js","sourceRoot":"","sources":["../../src/adapters/cloudflare-agent.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,OAAO,EAAE,aAAa,EAAyB,MAAM,iBAAiB,CAAA;AAGtE,iFAAiF;AACjF,SAAS,kBAAkB,CAAC,CAAU;IACpC,OAAO,CACL,CAAC,IAAI,IAAI;QACT,OAAO,CAAC,KAAK,QAAQ;QACrB,OAAQ,CAA4B,CAAC,QAAQ,KAAK,UAAU,CAC7D,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAA;AA2C5D;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CACzC,KAA0B,EAC1B,OAA2C;IAE3C,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,EAAE,cAAc,CAAA;IAC7C,IAAI,CAAC,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;QACpD,OAAO,CAAC,IAAI,CACV,oFAAoF;YAClF,mEAAmE,CACtE,CAAA;QACD,OAAO,CAAC,CAAA;IACV,CAAC;IAED,IAAI,OAAO,GAAG,CAAC,CAAA;IAEf,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;QACvD,IAAI,CAAC;YACH,IAAI,CAAC,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC9C,OAAO,CAAC,IAAI,CAAC,sBAAsB,IAAI,iCAAiC,CAAC,CAAA;gBACzE,SAAQ;YACV,CAAC;YAED,6CAA6C;YAC7C,IAAK,IAAI,CAAC,MAA6C,CAAC,aAAa,CAAC,KAAK,IAAI,EAAE,CAAC;gBAChF,SAAQ;YACV,CAAC;YAED,0EAA0E;YAC1E,IAAI,SAAS,GAAuB,OAAO,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,CAAA;YAC9D,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;gBAC3B,IAAI,CAAC;oBACH,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,YAAY,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;oBAChE,SAAS,GAAG,CAAC,CAAC,MAAM,CAAA;gBACtB,CAAC;gBAAC,MAAM,CAAC;oBACP,gEAAgE;gBAClE,CAAC;YACH,CAAC;YAED,MAAM,aAAa,GAAG,aAAa,CACjC,IAAI,CAAC,MAAM,EACX,OAAO,CAAC,WAAW,EACnB,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAC/B,CAMA;YAAC,aAAoD,CAAC,aAAa,CAAC,GAAG,IAAI,CAAA;YAE5E,qEAAqE;YACrE,oEAAoE;YACpE,iDAAiD;YACjD,IAAI,CAAC,MAAM,GAAG,aAAa,CAAA;YAC3B,OAAO,EAAE,CAAA;QACX,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,qEAAqE;YACrE,qCAAqC;YACrC,OAAO,CAAC,IAAI,CAAC,yCAAyC,IAAI,cAAc,EAAE,GAAG,CAAC,CAAA;QAChF,CAAC;IACH,CAAC;IAED,OAAO,OAAO,CAAA;AAChB,CAAC"}

package/dist/adapters/langchain-mcp.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Adapter: attribute MCP tool calls flowing through a LangChain JS MCP client.
+ *
+ * LangChain exposes MCP integration via the `@langchain/mcp-adapters` package
+ * (verified against `@langchain/mcp-adapters@1.1.3`). Two APIs are supported:
+ *
+ *   1. **High-level: `new MultiServerMCPClient({ mcpServers: {...} }).getTools()`**
+ *     . config-driven, the client owns its internal
+ *      `@modelcontextprotocol/sdk` Client instances behind `#private` fields.
+ *      Users never see the Client reference directly; there is no public
+ *      setter to inject a `wrapMcpClient`-style Proxy replacement. The
+ *      `getClient(serverName)` getter returns the internal Client, so we
+ *      can reach it. but we cannot substitute it.
+ *
+ *   2. **Low-level: `loadMcpTools(serverName, rawClient)`**. accepts a raw
+ *      `@modelcontextprotocol/sdk` Client directly (verified at
+ *      `dist/tools.d.ts:28`). For this path, users can construct their own
+ *      Client, wrap with the existing `wrapMcpClient` helper, and pass it
+ *      in. No new code required. see the example in
+ *      `packages/integration/examples/langchain-js/` for the pattern.
+ *
+ * This adapter handles the high-level `MultiServerMCPClient` path. It walks
+ * the multi-client's configured servers, calls `getClient()` on each to reach
+ * the internal Client, and monkey-patches `callTool` in place. Structurally
+ * the same pattern as `attributeVercelAiSdkMcp` (see D023), with one
+ * additional concern documented below.
+ *
+ * ## Per-call fork propagation
+ *
+ * LangChain's internal `_callTool` function (verified at `dist/tools.js:384`)
+ * supports per-call header changes via `client.fork(headers)`. this creates
+ * a new Client instance with different HTTP headers and calls `callTool` on
+ * the forked instance, not the original. A naive monkey-patch on the original
+ * Client would silently lose attribution for any LangChain user whose tools
+ * set per-call headers (the dominant pattern for per-user authentication).
+ *
+ * The patch therefore ALSO wraps `fork()` when present, so the forked Client
+ * is recursively patched before being returned to `_callTool`. This means
+ * every forked instance also flows through the atrib interceptor. no silent
+ * attribution drop for header-changing tools.
+ *
+ * ## Idempotency
+ *
+ * Each patched Client is marked with `Symbol.for('atrib.langchain-mcp.patched')`.
+ * Repeat calls to the helper on the same multi-client, and repeat `fork()`
+ * calls on already-patched Clients, are no-ops.
+ *
+ * ## Order sensitivity
+ *
+ * The helper is SAFE to call AFTER `multiClient.getTools()` because LangChain's
+ * tool `func` captures `client` by closure but dereferences `client.callTool`
+ * at invocation time (not at tool construction time. see `dist/tools.js:391`).
+ * Patching the client after tools are built still takes effect on the next
+ * tool invocation.
+ *
+ * The helper is also safe to call BEFORE `getTools()`, but in that case
+ * `multiClient.getClient(serverName)` will lazily initialize the connection
+ * if it hasn't happened yet. For predictable startup, most users will call
+ * `await multiClient.initializeConnections()` first, then
+ * `await attributeLangchainMcp(multiClient, { interceptor })`.
+ */
+import type { ToolCallInterceptor } from '../middleware.js';
+/**
+ * Minimal structural type for a LangChain-extended MCP Client (from
+ * `@langchain/mcp-adapters`'s `connection.ts`). This is the MCP SDK Client
+ * with an added `fork()` method for per-call header changes. We don't import
+ * from `@langchain/mcp-adapters` to avoid a hard dependency on the LangChain
+ * ecosystem from `@atrib/agent`.
+ *
+ * The `callTool` signature mirrors `@modelcontextprotocol/sdk`'s
+ * `Client.callTool(params, resultSchema?, options?)`.
+ */
+export interface LangchainMcpClientLike {
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown> | undefined;
+        _meta?: Record<string, unknown> | undefined;
+    }, resultSchema?: unknown, options?: {
+        signal?: AbortSignal | undefined;
+        timeout?: number | undefined;
+        onprogress?: ((progress: unknown) => void) | undefined;
+    }): Promise<unknown>;
+    fork?(headers: Record<string, string>): Promise<LangchainMcpClientLike>;
+}
+/**
+ * Minimal structural type for a LangChain `MultiServerMCPClient`. Mirrors the
+ * subset of the public surface we depend on (verified against
+ * `@langchain/mcp-adapters@1.1.3` `dist/client.d.ts`).
+ *
+ * The `config` getter returns a cloned `ClientConfig` whose `mcpServers`
+ * field enumerates every configured server by name. this is how we
+ * discover which servers to patch without requiring the caller to list
+ * them explicitly.
+ */
+export interface LangchainMultiServerMcpClientLike {
+    readonly config: {
+        mcpServers?: Record<string, unknown> | undefined;
+    };
+    getClient(serverName: string, options?: unknown): Promise<LangchainMcpClientLike | undefined>;
+}
+/** Options for `attributeLangchainMcp`. */
+export interface AttributeLangchainMcpOptions {
+    /** The atrib interceptor that observes tool calls on this client. */
+    interceptor: ToolCallInterceptor;
+    /**
+     * Optional per-server canonical URL map. Used by the interceptor for
+     * content_id derivation when emitting Path 2 transaction records (§5.4.5).
+     * Keys are the server names as they appear in the multi-client's
+     * `mcpServers` config; values are canonical URLs (e.g.
+     * `'https://search.example.com'`).
+     */
+    serverUrls?: Record<string, string>;
+    /**
+     * Optional list of server names to patch. If omitted, the helper patches
+     * every server in the multi-client's `config.mcpServers`. Provide this
+     * when you want to selectively attribute only a subset of configured
+     * servers (rare. usually you want all of them).
+     */
+    servers?: string[];
+}
+/**
+ * Patch a LangChain `MultiServerMCPClient` so every outbound `tools/call`
+ * flows through atrib's interceptor lifecycle.
+ *
+ * Walks the multi-client's configured servers, calls `getClient(serverName)`
+ * on each to reach the internal `@modelcontextprotocol/sdk` Client, and
+ * monkey-patches `callTool` (and `fork` when present) in place.
+ *
+ * Idempotent: calling the helper twice on the same multi-client, or calling
+ * it on a multi-client with some already-patched servers, is safe. Repeat
+ * invocations on already-patched clients are no-ops.
+ *
+ * Order independent: this helper can be called BEFORE or AFTER
+ * `multiClient.getTools()` because LangChain's tool `func` dereferences
+ * `client.callTool` at invocation time, not at build time.
+ *
+ * Returns the number of clients that were newly patched on this call
+ * (excludes clients that were already patched from a previous call).
+ *
+ * Usage:
+ *
+ *   import { MultiServerMCPClient } from '@langchain/mcp-adapters'
+ *   import { ChatAnthropic } from '@langchain/anthropic'
+ *   import { createReactAgent } from '@langchain/langgraph/prebuilt'
+ *   import { atrib, attributeLangchainMcp } from '@atrib/agent'
+ *
+ *   const interceptor = atrib({
+ *     creatorKey: process.env.ATRIB_PRIVATE_KEY!,
+ *     merchantDomain: 'https://merchant.example.com',
+ *     serverUrls: ['https://search.example.com'],
+ *   })
+ *
+ *   const multi = new MultiServerMCPClient({
+ *     mcpServers: {
+ *       search: { transport: 'http', url: 'https://search.example.com/mcp' },
+ *     },
+ *   })
+ *
+ *   await multi.initializeConnections()
+ *   await attributeLangchainMcp(multi, {
+ *     interceptor,
+ *     serverUrls: { search: 'https://search.example.com' },
+ *   })
+ *
+ *   const tools = await multi.getTools()
+ *   const agent = createReactAgent({
+ *     llm: new ChatAnthropic({ model: 'claude-sonnet-4-6' }),
+ *     tools,
+ *   })
+ */
+export declare function attributeLangchainMcp(multiClient: LangchainMultiServerMcpClientLike, options: AttributeLangchainMcpOptions): Promise<number>;
+//# sourceMappingURL=langchain-mcp.d.ts.map

package/dist/adapters/langchain-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langchain-mcp.d.ts","sourceRoot":"","sources":["../../src/adapters/langchain-mcp.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAO3D;;;;;;;;;GASG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CACN,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAA;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;QAC/C,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;KAC5C,EACD,YAAY,CAAC,EAAE,OAAO,EACtB,OAAO,CAAC,EAAE;QACR,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAA;QAChC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC5B,UAAU,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC,GAAG,SAAS,CAAA;KACvD,GACA,OAAO,CAAC,OAAO,CAAC,CAAA;IACnB,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAA;CACxE;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,MAAM,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;KAAE,CAAA;IACrE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,GAAG,SAAS,CAAC,CAAA;CAC9F;AAED,2CAA2C;AAC3C,MAAM,WAAW,4BAA4B;IAC3C,qEAAqE;IACrE,WAAW,EAAE,mBAAmB,CAAA;IAEhC;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAEnC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,iCAAiC,EAC9C,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,MAAM,CAAC,CA2BjB"}

package/dist/adapters/langchain-mcp.js

@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Marker symbol set on a patched client to make repeated patches idempotent.
+ */
+const ATRIB_PATCHED = Symbol.for('atrib.langchain-mcp.patched');
+/**
+ * Patch a LangChain `MultiServerMCPClient` so every outbound `tools/call`
+ * flows through atrib's interceptor lifecycle.
+ *
+ * Walks the multi-client's configured servers, calls `getClient(serverName)`
+ * on each to reach the internal `@modelcontextprotocol/sdk` Client, and
+ * monkey-patches `callTool` (and `fork` when present) in place.
+ *
+ * Idempotent: calling the helper twice on the same multi-client, or calling
+ * it on a multi-client with some already-patched servers, is safe. Repeat
+ * invocations on already-patched clients are no-ops.
+ *
+ * Order independent: this helper can be called BEFORE or AFTER
+ * `multiClient.getTools()` because LangChain's tool `func` dereferences
+ * `client.callTool` at invocation time, not at build time.
+ *
+ * Returns the number of clients that were newly patched on this call
+ * (excludes clients that were already patched from a previous call).
+ *
+ * Usage:
+ *
+ *   import { MultiServerMCPClient } from '@langchain/mcp-adapters'
+ *   import { ChatAnthropic } from '@langchain/anthropic'
+ *   import { createReactAgent } from '@langchain/langgraph/prebuilt'
+ *   import { atrib, attributeLangchainMcp } from '@atrib/agent'
+ *
+ *   const interceptor = atrib({
+ *     creatorKey: process.env.ATRIB_PRIVATE_KEY!,
+ *     merchantDomain: 'https://merchant.example.com',
+ *     serverUrls: ['https://search.example.com'],
+ *   })
+ *
+ *   const multi = new MultiServerMCPClient({
+ *     mcpServers: {
+ *       search: { transport: 'http', url: 'https://search.example.com/mcp' },
+ *     },
+ *   })
+ *
+ *   await multi.initializeConnections()
+ *   await attributeLangchainMcp(multi, {
+ *     interceptor,
+ *     serverUrls: { search: 'https://search.example.com' },
+ *   })
+ *
+ *   const tools = await multi.getTools()
+ *   const agent = createReactAgent({
+ *     llm: new ChatAnthropic({ model: 'claude-sonnet-4-6' }),
+ *     tools,
+ *   })
+ */
+export async function attributeLangchainMcp(multiClient, options) {
+    const { interceptor, serverUrls = {}, servers } = options;
+    const configuredServers = servers ?? Object.keys(multiClient.config.mcpServers ?? {});
+    let newlyPatched = 0;
+    for (const serverName of configuredServers) {
+        let client;
+        try {
+            client = await multiClient.getClient(serverName);
+        }
+        catch (err) {
+            console.warn(`atrib: langchain-mcp could not resolve client for server '${serverName}', skipping`, err);
+            continue;
+        }
+        if (!client) {
+            console.warn(`atrib: langchain-mcp server '${serverName}' has no client (not initialized?), skipping`);
+            continue;
+        }
+        if (patchClient(client, interceptor, serverUrls[serverName])) {
+            newlyPatched++;
+        }
+    }
+    return newlyPatched;
+}
+/**
+ * Patch a single LangChain MCP Client in place. Returns true if the client
+ * was newly patched, false if it was already patched from a previous call.
+ *
+ * Recursive on `fork()`: when the patched `fork` is invoked, the returned
+ * forked client is itself passed through `patchClient` before being handed
+ * back to LangChain's `_callTool`. This ensures that per-call-header
+ * workflows (common for per-user authentication) don't silently lose
+ * attribution.
+ */
+function patchClient(client, interceptor, serverUrl) {
+    if (client[ATRIB_PATCHED] === true) {
+        return false;
+    }
+    const originalCallTool = client.callTool.bind(client);
+    const patchedCallTool = async (params, resultSchema, opts) => {
+        const toolName = params.name;
+        const existingMeta = (params._meta ?? {});
+        // §5.4.3: Build outbound _meta via the interceptor. The interceptor
+        // returns a record that includes any existing _meta keys plus atrib's
+        // own (atrib token, traceparent, tracestate, baggage, X-Atrib-Chain).
+        let outboundMeta;
+        try {
+            outboundMeta = await interceptor.onBeforeToolCall(toolName, existingMeta);
+        }
+        catch (err) {
+            // §5.8 degradation: pass through with the original params on failure
+            console.warn('atrib: langchain-mcp onBeforeToolCall failed, passing through', err);
+            outboundMeta = undefined;
+        }
+        // Construct new params rather than mutating. caller's reference is preserved.
+        const forwardedParams = outboundMeta !== undefined ? { ...params, _meta: outboundMeta } : params;
+        const result = await originalCallTool(forwardedParams, resultSchema, opts);
+        // §5.4.4: Update session state from the response _meta.
+        try {
+            const responseMeta = (result?._meta ?? {});
+            const responseOptions = {
+                ...(serverUrl !== undefined ? { serverUrl } : {}),
+                isError: result?.isError === true,
+            };
+            interceptor.onAfterToolResponse(toolName, result, responseMeta, responseOptions);
+        }
+        catch (err) {
+            console.warn('atrib: langchain-mcp onAfterToolResponse failed, passing through', err);
+        }
+        return result;
+    };
+    client.callTool = patchedCallTool;
+    // Fork propagation: LangChain's _callTool creates a new Client via fork()
+    // when per-call header changes are requested (dist/tools.js:384). The
+    // forked client needs its own callTool patch, or it silently bypasses
+    // atrib. We wrap fork so the returned forked client is patched recursively
+    // before being handed back to the caller.
+    if (typeof client.fork === 'function') {
+        const originalFork = client.fork.bind(client);
+        const patchedFork = async (headers) => {
+            const forkedClient = await originalFork(headers);
+            patchClient(forkedClient, interceptor, serverUrl);
+            return forkedClient;
+        };
+        client.fork = patchedFork;
+    }
+    ;
+    client[ATRIB_PATCHED] = true;
+    return true;
+}
+//# sourceMappingURL=langchain-mcp.js.map

package/dist/adapters/langchain-mcp.js.map

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

package/dist/adapters/mcp-client.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Adapter: wrap a raw `@modelcontextprotocol/sdk` Client with atrib attribution.
+ *
+ * The MCP TypeScript SDK exposes a `Client` class with a `callTool(params, ...)`
+ * method. This adapter returns a thin proxy around such a client whose
+ * `callTool` is wrapped to:
+ *
+ *   1. Call `interceptor.onBeforeToolCall(toolName, existingMeta)` to get the
+ *      attribution `_meta` block (traceparent, atrib token, baggage, etc.)
+ *   2. Forward the request through the underlying client with the new
+ *      `_meta` merged into `params._meta`
+ *   3. Call `interceptor.onAfterToolResponse(toolName, result, result._meta, ...)`
+ *      so the interceptor can update its session state, detect transactions,
+ *      and emit Path 2 records when the tool server has no @atrib/mcp
+ *
+ * The adapter is intentionally narrow. it only proxies `callTool`. All other
+ * client methods (`listTools`, `close`, `connect`, `request`, etc.) are
+ * forwarded unchanged. This means a developer can drop the adapter into any
+ * existing code that uses the MCP SDK Client directly without changing
+ * anything else.
+ *
+ * If the MCP SDK ever changes the `callTool` signature, the adapter will
+ * fail loudly because TypeScript will complain about the proxied parameters
+ * shape. see the `MinimalMcpClient` interface below.
+ */
+import type { ToolCallInterceptor } from '../middleware.js';
+/**
+ * The minimal subset of `@modelcontextprotocol/sdk/client/index.js` Client
+ * that this adapter depends on. We do not import the SDK type directly to
+ * avoid making `@modelcontextprotocol/sdk` a hard dependency of `@atrib/agent`
+ *. the SDK is only needed if you actually use this adapter, not for the
+ * core interceptor API.
+ */
+export interface MinimalMcpClient {
+    callTool(params: {
+        name: string;
+        arguments?: Record<string, unknown>;
+        _meta?: Record<string, unknown>;
+        [key: string]: unknown;
+    }, resultSchema?: unknown, options?: unknown): Promise<{
+        content?: unknown;
+        _meta?: Record<string, unknown>;
+        isError?: boolean;
+        [key: string]: unknown;
+    }>;
+}
+/** Options for `wrapMcpClient`. */
+export interface WrapMcpClientOptions {
+    /**
+     * The canonical URL of the MCP server this client connects to. Used by
+     * the interceptor for content_id derivation when emitting Path 2
+     * transaction records (the agent fallback path described in spec §5.4.5).
+     * If omitted, the interceptor will fall back to the tool's MCP server
+     * URL only when it can be derived elsewhere. for many transports
+     * (especially stdio) it cannot, and content_id values for transactions
+     * will be less specific.
+     */
+    serverUrl?: string;
+}
+/**
+ * Wrap a raw MCP Client so every `callTool` invocation participates in
+ * atrib attribution.
+ *
+ * Returns a Proxy over the client. All non-`callTool` methods are forwarded
+ * unchanged via the prototype, so the wrapped client is API-compatible with
+ * the original.
+ *
+ * Usage:
+ *
+ *   import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+ *   import { atrib, wrapMcpClient } from '@atrib/agent'
+ *
+ *   const interceptor = atrib({
+ *     creatorKey: process.env.ATRIB_PRIVATE_KEY,
+ *     merchantDomain: 'https://merchant.example.com',
+ *     serverUrls: ['https://my-tool.example'],
+ *   })
+ *
+ *   const rawClient = new Client({ name: 'my-agent', version: '1.0.0' })
+ *   await rawClient.connect(transport)
+ *
+ *   const client = wrapMcpClient(rawClient, interceptor, {
+ *     serverUrl: 'https://my-tool.example',
+ *   })
+ *
+ *   // Use `client` exactly like the raw MCP Client.
+ *   const result = await client.callTool({ name: 'search', arguments: { q: 'foo' } })
+ *
+ *   // On shutdown:
+ *   await interceptor.flush()
+ *   await rawClient.close()
+ */
+export declare function wrapMcpClient<C extends MinimalMcpClient>(client: C, interceptor: ToolCallInterceptor, options?: WrapMcpClientOptions): C;
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/adapters/mcp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.d.ts","sourceRoot":"","sources":["../../src/adapters/mcp-client.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAE3D;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CACN,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAA;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACnC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KACvB,EACD,YAAY,CAAC,EAAE,OAAO,EACtB,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC;QACT,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QAC/B,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KACvB,CAAC,CAAA;CACH;AAED,mCAAmC;AACnC,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,gBAAgB,EACtD,MAAM,EAAE,CAAC,EACT,WAAW,EAAE,mBAAmB,EAChC,OAAO,GAAE,oBAAyB,GACjC,CAAC,CAiEH"}

package/dist/adapters/mcp-client.js

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Wrap a raw MCP Client so every `callTool` invocation participates in
+ * atrib attribution.
+ *
+ * Returns a Proxy over the client. All non-`callTool` methods are forwarded
+ * unchanged via the prototype, so the wrapped client is API-compatible with
+ * the original.
+ *
+ * Usage:
+ *
+ *   import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+ *   import { atrib, wrapMcpClient } from '@atrib/agent'
+ *
+ *   const interceptor = atrib({
+ *     creatorKey: process.env.ATRIB_PRIVATE_KEY,
+ *     merchantDomain: 'https://merchant.example.com',
+ *     serverUrls: ['https://my-tool.example'],
+ *   })
+ *
+ *   const rawClient = new Client({ name: 'my-agent', version: '1.0.0' })
+ *   await rawClient.connect(transport)
+ *
+ *   const client = wrapMcpClient(rawClient, interceptor, {
+ *     serverUrl: 'https://my-tool.example',
+ *   })
+ *
+ *   // Use `client` exactly like the raw MCP Client.
+ *   const result = await client.callTool({ name: 'search', arguments: { q: 'foo' } })
+ *
+ *   // On shutdown:
+ *   await interceptor.flush()
+ *   await rawClient.close()
+ */
+export function wrapMcpClient(client, interceptor, options = {}) {
+    const { serverUrl } = options;
+    const wrappedCallTool = async (params, resultSchema, requestOptions) => {
+        const toolName = params.name;
+        // §5.4.3: Build outbound _meta. The interceptor returns a record that
+        // includes any existing _meta keys from the caller plus atrib's own
+        // (atrib token, traceparent, tracestate, baggage, X-Atrib-Chain).
+        let outboundMeta;
+        try {
+            const existingMeta = (params._meta ?? {});
+            outboundMeta = await interceptor.onBeforeToolCall(toolName, existingMeta);
+        }
+        catch (err) {
+            // §5.8 degradation contract: never let attribution failures break the
+            // primary tool call. Fall through to the original params unchanged.
+            console.warn('atrib: wrapMcpClient onBeforeToolCall failed, passing through', err);
+            outboundMeta = undefined;
+        }
+        const forwardedParams = outboundMeta !== undefined ? { ...params, _meta: outboundMeta } : params;
+        // Forward to the underlying client with the merged _meta.
+        const result = await client.callTool(forwardedParams, resultSchema, requestOptions);
+        // §5.4.4: Update session state from the response _meta. Also runs Path 1/2
+        // transaction detection if the response shape matches a known protocol.
+        try {
+            const responseMeta = (result?._meta ?? {});
+            // exactOptionalPropertyTypes: only include serverUrl when it's set,
+            // because the interceptor's option type doesn't accept undefined.
+            const responseOptions = {
+                ...(serverUrl !== undefined ? { serverUrl } : {}),
+                isError: result?.isError === true,
+            };
+            interceptor.onAfterToolResponse(toolName, result, responseMeta, responseOptions);
+        }
+        catch (err) {
+            console.warn('atrib: wrapMcpClient onAfterToolResponse failed, passing through', err);
+        }
+        return result;
+    };
+    // Proxy the client so all other methods (listTools, close, connect, etc.)
+    // pass through unchanged. We can't simply spread the client because the
+    // SDK's Client class methods rely on `this` being the original instance.
+    return new Proxy(client, {
+        get(target, prop, receiver) {
+            if (prop === 'callTool') {
+                return wrappedCallTool;
+            }
+            const value = Reflect.get(target, prop, receiver);
+            // If the property is a function, bind it to the original target so
+            // method calls like `client.listTools()` still work correctly.
+            if (typeof value === 'function') {
+                return value.bind(target);
+            }
+            return value;
+        },
+    });
+}
+//# sourceMappingURL=mcp-client.js.map

package/dist/adapters/mcp-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.js","sourceRoot":"","sources":["../../src/adapters/mcp-client.ts"],"names":[],"mappings":"AAAA,sCAAsC;AAqEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,UAAU,aAAa,CAC3B,MAAS,EACT,WAAgC,EAChC,UAAgC,EAAE;IAElC,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;IAE7B,MAAM,eAAe,GAAiC,KAAK,EACzD,MAAM,EACN,YAAY,EACZ,cAAc,EACd,EAAE;QACF,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAA;QAE5B,sEAAsE;QACtE,oEAAoE;QACpE,kEAAkE;QAClE,IAAI,YAAiD,CAAA;QACrD,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAA4B,CAAA;YACpE,YAAY,GAAG,MAAM,WAAW,CAAC,gBAAgB,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAA;QAC3E,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,sEAAsE;YACtE,oEAAoE;YACpE,OAAO,CAAC,IAAI,CAAC,+DAA+D,EAAE,GAAG,CAAC,CAAA;YAClF,YAAY,GAAG,SAAS,CAAA;QAC1B,CAAC;QAED,MAAM,eAAe,GACnB,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,MAAM,CAAA;QAE1E,0DAA0D;QAC1D,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,YAAY,EAAE,cAAc,CAAC,CAAA;QAEnF,2EAA2E;QAC3E,wEAAwE;QACxE,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE,CAA4B,CAAA;YACrE,oEAAoE;YACpE,kEAAkE;YAClE,MAAM,eAAe,GAAG;gBACtB,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACjD,OAAO,EAAG,MAAkC,EAAE,OAAO,KAAK,IAAI;aAC/D,CAAA;YACD,WAAW,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,CAAC,CAAA;QAClF,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,kEAAkE,EAAE,GAAG,CAAC,CAAA;QACvF,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC,CAAA;IAED,0EAA0E;IAC1E,wEAAwE;IACxE,yEAAyE;IACzE,OAAO,IAAI,KAAK,CAAC,MAAM,EAAE;QACvB,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ;YACxB,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;gBACxB,OAAO,eAAe,CAAA;YACxB,CAAC;YACD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAA;YACjD,mEAAmE;YACnE,+DAA+D;YAC/D,IAAI,OAAO,KAAK,KAAK,UAAU,EAAE,CAAC;gBAChC,OAAQ,KAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YACzC,CAAC;YACD,OAAO,KAAK,CAAA;QACd,CAAC;KACF,CAAC,CAAA;AACJ,CAAC"}