@stratabook/mcp 0.2.13 → 0.2.15

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 All notable changes to the Strata SDKs (`@stratabook/sdk`, `@stratabook/mcp`,
 and the `strata-sdk` Rust crate) are recorded here. Versions move together.
 
+## 0.2.15
+
+- Add explicit IntentBook prepare/submit tools in advanced mode and a one-call
+  post/permanent-revoke tool for locally configured Vault sessions.
+- Apply the existing ask/limits/instant slider, USD budgets, capability gates,
+  exact retry behavior, and sponsored-fee explanation to intent controls.
+
+## 0.2.14
+
+- Make `strata-mcp connect` the complete client-neutral trading setup flow:
+  choose limits in Strata, sign once, save the secret locally, and return to a
+  confirmed connected Control Center without environment variables or config
+  editing.
+- Re-running `connect` now rotates an existing local session atomically, and
+  saves the new credential only after both activation and old-key revocation
+  are confirmed.
+
 ## 0.2.13
 
 - Add `strata-mcp connect`: generate the session secret locally, open the

package/README.md

@@ -30,6 +30,11 @@ The browser and Strata receive only the public key:
 npx -y @stratabook/mcp connect
 ```
 
+This opens the client-neutral Strata limit picker, registers the locally
+generated key with one wallet signature, saves the credential privately, and
+returns to the live Control Center. Run the same command again to replace the
+old key atomically; the old key is revoked in the same signed transaction.
+
 There is no secret to paste into chat, no environment-variable screen, and no
 client config to edit after the read-only server is installed. Restart or
 refresh the MCP client after the browser confirms connection. Revoke the exact
@@ -99,6 +104,7 @@ Advanced mode additionally exposes the complete protocol surface, including:
 - `strata_market_making_submit_and_wait` — submit the externally signed preparation idempotently and wait for matching chain-derived state
 - `strata_market_making_strand_prepare`, `strata_market_making_strand_submit`
 - `strata_market_making_current_prepare`, `strata_market_making_current_submit`
+- `strata_market_making_intent_prepare`, `strata_market_making_intent_submit` — control an existing curated IntentBook seat with a Vault session; Strata pays the fee
 - `strata_vault_status`
 - `strata_vault_setup`, `strata_vault_deposit`, `strata_vault_withdraw`, `strata_vault_delegate`, `strata_vault_policy`, `strata_vault_pause` — prepare owner actions with Strata as sponsored fee payer
 - `strata_vault_submit` — submit the owner-signed preparation; Strata pays and broadcasts
@@ -152,6 +158,12 @@ restart. Use `action: "stop"` through the same pair. The older product-specific
 tools remain available for strategies that deliberately manage every low-level
 array and safety field.
 
+With a local trading session, `strata_market_making_intent_execute` posts or
+permanently revokes an existing curated IntentBook seat in one call under the
+same ask/limits/instant slider. The session signs only the SDK-verified packet;
+the owner wallet does not sign each update. Exact submit retries return the
+original confirmed signature while the packet remains live.
+
 For maker funding, initialize the market Vault if needed, activate the Strand
 or Current, then deposit with `strata_vault_deposit`. The market keeps that
 available collateral while a control is live and returns it after the final

package/dist/src/autonomy.d.ts

@@ -17,8 +17,9 @@
  *                 caps (the owner's per-asset limits, tolerance, interval,
  *                 expiry). Hyperliquid-style.
  *
- * Withdraw, policy, pause, and revoke are never on this slider — they always
- * require the owner's wallet. The on-chain session caps are the hard ceiling;
+ * Vault withdrawal, policy, session rotation, and pause are never on this
+ * slider — they always require the owner's wallet. An IntentBook seat's own
+ * session-authorized revoke remains available as its permanent risk exit. The on-chain session caps are the hard ceiling;
  * this slider is a softer layer above them. An agent can *read* the level
  * (`strata_autonomy`) and *offer* to change it, but nothing an agent calls can
  * raise its own autonomy: the only knob is the human's (env / Agents page).

package/dist/src/autonomy.js

@@ -17,8 +17,9 @@
  *                 caps (the owner's per-asset limits, tolerance, interval,
  *                 expiry). Hyperliquid-style.
  *
- * Withdraw, policy, pause, and revoke are never on this slider — they always
- * require the owner's wallet. The on-chain session caps are the hard ceiling;
+ * Vault withdrawal, policy, session rotation, and pause are never on this
+ * slider — they always require the owner's wallet. An IntentBook seat's own
+ * session-authorized revoke remains available as its permanent risk exit. The on-chain session caps are the hard ceiling;
  * this slider is a softer layer above them. An agent can *read* the level
  * (`strata_autonomy`) and *offer* to change it, but nothing an agent calls can
  * raise its own autonomy: the only knob is the human's (env / Agents page).

package/dist/src/cli.js

@@ -88,9 +88,10 @@ Options:
   --no-open                Print the wallet pairing URL without opening a browser
 
 Read-only markets, books, and Sonar quotes work immediately. Run strata-mcp
-doctor to check them. Run strata-mcp connect once to register a local session
-with the owner wallet; there are no secrets to copy or environment variables
-to edit. Run strata-mcp disconnect to revoke it. Strata never asks for seed phrases.
+doctor to check them. Run strata-mcp connect to choose limits and register a
+local session with one owner signature; run it again to replace that session
+atomically. There are no secrets to copy or environment variables to edit.
+Run strata-mcp disconnect to revoke it. Strata never asks for seed phrases.
 `);
 }
 async function runDoctor(options, sessionEnv) {

package/dist/src/generated-harness.d.ts

@@ -49,7 +49,7 @@ export declare const STRATA_AGENT_HARNESS: {
         readonly instruction: "When an owner requests a Vault pause or resume and vault.pause is live, prepare the exact transaction with the official SDK, verify that the wallet and requested state are unchanged, then have the owner-configured signer sign and broadcast it externally. Preparation alone does not change state.";
     }, {
         readonly id: "onboard_vault";
-        readonly instruction: "Onboarding is one owner signature, once: register the external session key with vault.setup (only the wallet and the session key are required; one session then trades every market) or simply name the session key on the first vault.deposit, which registers it in the same transaction. Policy fields — expiry, cadence, tolerance, per-asset limits — are optional. Verify every echoed field and the prepared transaction before external owner signing and broadcast; retain the session key only in the owner's signer.";
+        readonly instruction: "Onboarding is one owner signature: register the external session key with vault.setup (only the wallet and the session key are required; one session then trades every market) or simply name the session key on the first vault.deposit, which registers it in the same transaction. Policy fields — expiry, cadence, tolerance, per-asset limits — are optional. Supplying replace_session_public_key atomically revokes the old key while registering the new one. Verify every echoed field and the prepared transaction before external owner signing and broadcast; retain the session key only in the owner's signer.";
     }, {
         readonly id: "fund_vault";
         readonly instruction: "When vault.deposit is live, select an asset from the discovered market and use an exact positive atomic amount. Verify the echoed owner, market, asset, and amount plus the prepared transaction before external owner signing and broadcast.";
@@ -64,7 +64,7 @@ export declare const STRATA_AGENT_HARNESS: {
         readonly instruction: "When vault.policy.manage is live, use blocked mode with no allowed wallets to freeze withdrawals or restricted mode with one to eight exact destination-owner wallets. Verify the echoed mode and complete wallet list before external owner signing and broadcast.";
     }, {
         readonly id: "reconcile_maker_status";
-        readonly instruction: "When mm.status.read is live, read the maker's products by wallet address (public, no signature) before and after any maker action: resting firm orders, the intent budget, live signed quotes, each Strand and Current with its remaining exposure and expiry, oracle health, and armed dead-man guards. Reconcile against what the agent believes it posted; treat missing, expired, or disabled products as not quoting.";
+        readonly instruction: "When mm.status.read is live, read the maker's products by wallet address (public, no signature) before and after any maker action: resting firm orders, live signed quotes, each Strand and Current with its remaining exposure and expiry, oracle health, and armed dead-man guards. Reconcile against what the agent believes it posted; treat missing, expired, or disabled products as not quoting.";
     }, {
         readonly id: "stream_maker_fills";
         readonly instruction: "When mm.fills.stream is live, keep one maker stream open per market through the official SDK by wallet address (public, no signature): start from the maker snapshot, apply only contiguous maker_fill and maker_status events, and recover any gap or reconnect from a fresh snapshot. Reconcile every fill and exposure change against the maker's own state before quoting further.";
@@ -551,4 +551,4 @@ export declare const STRATA_ACTION_GRAPH: {
     }];
 };
 export declare const STRATA_ACTION_GRAPH_URI = "strata://action-graph/v1";
-export declare const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata read-only tools work immediately with no wallet, approval, session key, or environment setup. Call the requested tool directly: use strata_quote for a quote, strata_markets only when the market is unknown, and strata_portfolio for a public account. Do not begin with capability, graph, status, or market discovery unless the requested tool is unavailable, the objective is advanced or ambiguous, or the user asks what Strata supports. Simple MCP tools accept exact human amounts such as 0.1 SOL, 20 USDC, or $20; advanced and SDK interfaces also accept token atoms. Never request or accept a session secret in chat. A session is needed only when the user asks to sign a trading write; if it is missing, strata_trade returns a read-only quote and the single setup link https://stratabook.app/agents. The user can run npx -y @stratabook/mcp connect to generate and store the secret locally while the Agents page receives only its public key. Revoke, withdraw, pause, and policy changes are owner-wallet actions and never use the session signer. Strata Agent Harness 1.0. The action-graph resources are optional references for advanced integrations. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Check quote bindings, labelled fees, minimum output, price impact, tolerance, and expiry. When portfolio.read is live, read the owner's live Vault portfolio before sizing a write and treat null USD totals as an incomplete valuation, never as zero. When mm.status.read is live, reconcile the owner's maker products and exposure before and after maker actions. For normal Strand or Current operation, prefer strata_market_making_prepare, sign only its prepared transaction externally, then pass its unchanged preparationToken with the signed transaction to strata_market_making_submit_and_wait. Advanced order, TWAP, and execution integrations may use explicit challenge, prepare, verify, sign, and submit flows with idempotency. Stop on ambiguity, sequence gaps, unavailable capabilities, paused markets, inconsistent bindings, expiry, or missing signer authority.";
+export declare const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata read-only tools work immediately with no wallet, approval, session key, or environment setup. Call the requested tool directly: use strata_quote for a quote, strata_markets only when the market is unknown, and strata_portfolio for a public account. Do not begin with capability, graph, status, or market discovery unless the requested tool is unavailable, the objective is advanced or ambiguous, or the user asks what Strata supports. Simple MCP tools accept exact human amounts such as 0.1 SOL, 20 USDC, or $20; advanced and SDK interfaces also accept token atoms. Never request or accept a session secret in chat. A session is needed only when the user asks to sign a trading write; if it is missing, strata_trade returns a read-only quote and the single setup link https://stratabook.app/agents. The user can run npx -y @stratabook/mcp connect to generate the secret locally, choose on-chain limits, and register with one owner signature while the Agents page receives only the public key. Rerunning the command atomically replaces the old session. Revoke, withdraw, pause, and policy changes are owner-wallet actions and never use the session signer. Strata Agent Harness 1.0. The action-graph resources are optional references for advanced integrations. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Check quote bindings, labelled fees, minimum output, price impact, tolerance, and expiry. When portfolio.read is live, read the owner's live Vault portfolio before sizing a write and treat null USD totals as an incomplete valuation, never as zero. When mm.status.read is live, reconcile the owner's maker products and exposure before and after maker actions. For normal Strand or Current operation, prefer strata_market_making_prepare, sign only its prepared transaction externally, then pass its unchanged preparationToken with the signed transaction to strata_market_making_submit_and_wait. Advanced order, TWAP, and execution integrations may use explicit challenge, prepare, verify, sign, and submit flows with idempotency. Stop on ambiguity, sequence gaps, unavailable capabilities, paused markets, inconsistent bindings, expiry, or missing signer authority.";

package/dist/src/generated-harness.js

@@ -141,7 +141,7 @@ export const STRATA_AGENT_HARNESS = {
         },
         {
             "id": "onboard_vault",
-            "instruction": "Onboarding is one owner signature, once: register the external session key with vault.setup (only the wallet and the session key are required; one session then trades every market) or simply name the session key on the first vault.deposit, which registers it in the same transaction. Policy fields — expiry, cadence, tolerance, per-asset limits — are optional. Verify every echoed field and the prepared transaction before external owner signing and broadcast; retain the session key only in the owner's signer."
+            "instruction": "Onboarding is one owner signature: register the external session key with vault.setup (only the wallet and the session key are required; one session then trades every market) or simply name the session key on the first vault.deposit, which registers it in the same transaction. Policy fields — expiry, cadence, tolerance, per-asset limits — are optional. Supplying replace_session_public_key atomically revokes the old key while registering the new one. Verify every echoed field and the prepared transaction before external owner signing and broadcast; retain the session key only in the owner's signer."
         },
         {
             "id": "fund_vault",
@@ -161,7 +161,7 @@ export const STRATA_AGENT_HARNESS = {
         },
         {
             "id": "reconcile_maker_status",
-            "instruction": "When mm.status.read is live, read the maker's products by wallet address (public, no signature) before and after any maker action: resting firm orders, the intent budget, live signed quotes, each Strand and Current with its remaining exposure and expiry, oracle health, and armed dead-man guards. Reconcile against what the agent believes it posted; treat missing, expired, or disabled products as not quoting."
+            "instruction": "When mm.status.read is live, read the maker's products by wallet address (public, no signature) before and after any maker action: resting firm orders, live signed quotes, each Strand and Current with its remaining exposure and expiry, oracle health, and armed dead-man guards. Reconcile against what the agent believes it posted; treat missing, expired, or disabled products as not quoting."
         },
         {
             "id": "stream_maker_fills",
@@ -789,4 +789,4 @@ export const STRATA_ACTION_GRAPH = {
     ]
 };
 export const STRATA_ACTION_GRAPH_URI = "strata://action-graph/v1";
-export const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata read-only tools work immediately with no wallet, approval, session key, or environment setup. Call the requested tool directly: use strata_quote for a quote, strata_markets only when the market is unknown, and strata_portfolio for a public account. Do not begin with capability, graph, status, or market discovery unless the requested tool is unavailable, the objective is advanced or ambiguous, or the user asks what Strata supports. Simple MCP tools accept exact human amounts such as 0.1 SOL, 20 USDC, or $20; advanced and SDK interfaces also accept token atoms. Never request or accept a session secret in chat. A session is needed only when the user asks to sign a trading write; if it is missing, strata_trade returns a read-only quote and the single setup link https://stratabook.app/agents. The user can run npx -y @stratabook/mcp connect to generate and store the secret locally while the Agents page receives only its public key. Revoke, withdraw, pause, and policy changes are owner-wallet actions and never use the session signer. Strata Agent Harness 1.0. The action-graph resources are optional references for advanced integrations. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Check quote bindings, labelled fees, minimum output, price impact, tolerance, and expiry. When portfolio.read is live, read the owner's live Vault portfolio before sizing a write and treat null USD totals as an incomplete valuation, never as zero. When mm.status.read is live, reconcile the owner's maker products and exposure before and after maker actions. For normal Strand or Current operation, prefer strata_market_making_prepare, sign only its prepared transaction externally, then pass its unchanged preparationToken with the signed transaction to strata_market_making_submit_and_wait. Advanced order, TWAP, and execution integrations may use explicit challenge, prepare, verify, sign, and submit flows with idempotency. Stop on ambiguity, sequence gaps, unavailable capabilities, paused markets, inconsistent bindings, expiry, or missing signer authority.";
+export const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata read-only tools work immediately with no wallet, approval, session key, or environment setup. Call the requested tool directly: use strata_quote for a quote, strata_markets only when the market is unknown, and strata_portfolio for a public account. Do not begin with capability, graph, status, or market discovery unless the requested tool is unavailable, the objective is advanced or ambiguous, or the user asks what Strata supports. Simple MCP tools accept exact human amounts such as 0.1 SOL, 20 USDC, or $20; advanced and SDK interfaces also accept token atoms. Never request or accept a session secret in chat. A session is needed only when the user asks to sign a trading write; if it is missing, strata_trade returns a read-only quote and the single setup link https://stratabook.app/agents. The user can run npx -y @stratabook/mcp connect to generate the secret locally, choose on-chain limits, and register with one owner signature while the Agents page receives only the public key. Rerunning the command atomically replaces the old session. Revoke, withdraw, pause, and policy changes are owner-wallet actions and never use the session signer. Strata Agent Harness 1.0. The action-graph resources are optional references for advanced integrations. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Check quote bindings, labelled fees, minimum output, price impact, tolerance, and expiry. When portfolio.read is live, read the owner's live Vault portfolio before sizing a write and treat null USD totals as an incomplete valuation, never as zero. When mm.status.read is live, reconcile the owner's maker products and exposure before and after maker actions. For normal Strand or Current operation, prefer strata_market_making_prepare, sign only its prepared transaction externally, then pass its unchanged preparationToken with the signed transaction to strata_market_making_submit_and_wait. Advanced order, TWAP, and execution integrations may use explicit challenge, prepare, verify, sign, and submit flows with idempotency. Stop on ambiguity, sequence gaps, unavailable capabilities, paused markets, inconsistent bindings, expiry, or missing signer authority.";

package/dist/src/pairing.d.ts

@@ -23,4 +23,5 @@ export declare function writeTradingConnection(connection: StoredTradingConnecti
 export declare function removeTradingConnection(path?: string): Promise<void>;
 /** Explicit environment variables win; otherwise load the private local file. */
 export declare function loadTradingEnvironment(env?: Readonly<Record<string, string | undefined>>): Promise<Record<string, string | undefined>>;
+export declare function pairingPageUrl(webBase: string, action: PairingAction, sessionPublicKey: string, callbackUrl: string, existing: Pick<StoredTradingConnection, "owner_wallet" | "session_public_key"> | null): string;
 export declare function runLocalPairing(options: PairingOptions): Promise<void>;

package/dist/src/pairing.js

@@ -114,41 +114,50 @@ function launchBrowser(url) {
     child.on("error", () => undefined);
     child.unref();
 }
-function successHtml(action, wallet) {
-    const connected = action === "connect";
-    return `<!doctype html>
-<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width">
-<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'">
-<title>Strata agent ${connected ? "connected" : "disconnected"}</title>
-<style>html{color-scheme:dark}body{margin:0;min-height:100vh;display:grid;place-items:center;background:#080b11;color:#e2e8f0;font:15px Inter,system-ui,sans-serif}.card{width:min(520px,calc(100% - 48px));padding:28px;border:1px solid transparent;border-radius:16px;background:linear-gradient(#10141c,#090c12) padding-box,linear-gradient(120deg,#22d3ee,#8b5cf6) border-box;box-shadow:0 22px 80px #0008}h1{margin:0 0 10px;color:white;font-size:24px}p{line-height:1.55;color:#94a3b8}.ok{color:#34d399;font-weight:700}.mono{font-family:ui-monospace,monospace;color:#cbd5e1}</style>
-</head><body><main class="card"><div class="ok">${connected ? "CONNECTED" : "REVOKED"}</div>
-<h1>${connected ? "Your agent can trade" : "Agent access removed"}</h1>
-<p>${connected ? "The session secret was saved only on this computer. Restart or refresh your MCP client, then trade normally." : "The local trading credential has been removed. Read-only Strata tools still work."}</p>
-<p class="mono">Wallet ${wallet.slice(0, 6)}…${wallet.slice(-6)}</p></main></body></html>`;
+export function pairingPageUrl(webBase, action, sessionPublicKey, callbackUrl, existing) {
+    const agentUrl = new URL("/agents", pairingWebBase(webBase));
+    agentUrl.searchParams.set("pair", action);
+    agentUrl.searchParams.set("session_public_key", sessionPublicKey);
+    if (existing)
+        agentUrl.searchParams.set("owner_wallet", existing.owner_wallet);
+    if (action === "connect" && existing) {
+        agentUrl.searchParams.set("replace_session_public_key", existing.session_public_key);
+    }
+    agentUrl.searchParams.set("callback", callbackUrl);
+    return agentUrl.toString();
 }
-async function waitForOnChainSession(apiBase, action, ownerWallet, sessionPublicKey) {
+async function waitForOnChainSession(apiBase, action, ownerWallet, sessionPublicKey, replaceSessionPublicKey) {
     const deadline = Date.now() + 60_000;
     let lastState = "unavailable";
+    const stateFor = async (key) => {
+        const query = new URLSearchParams({
+            wallet_address: ownerWallet,
+            session_public_key: key,
+        });
+        const response = await fetch(`${apiBase.replace(/\/$/, "")}/v2/vault/status?${query.toString()}`, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(10_000) });
+        if (!response.ok) {
+            lastState = `http_${response.status}`;
+            return null;
+        }
+        const body = await response.json();
+        if (body.wallet_address !== ownerWallet)
+            return null;
+        if (!body.session)
+            return "absent";
+        if (body.session.session_public_key !== key || typeof body.session.state !== "string")
+            return null;
+        return body.session.state;
+    };
     while (Date.now() < deadline) {
         try {
-            const query = new URLSearchParams({
-                wallet_address: ownerWallet,
-                session_public_key: sessionPublicKey,
-            });
-            const response = await fetch(`${apiBase.replace(/\/$/, "")}/v2/vault/status?${query.toString()}`, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(10_000) });
-            if (response.ok) {
-                const body = await response.json();
-                if (body.wallet_address === ownerWallet) {
-                    lastState = typeof body.session?.state === "string" ? body.session.state : "absent";
-                    const exactSession = body.session?.session_public_key === sessionPublicKey;
-                    if (action === "connect" && exactSession && body.session?.state === "active")
-                        return;
-                    if (action === "disconnect" && (!body.session || (exactSession && body.session.state === "absent")))
-                        return;
-                }
-            }
-            else {
-                lastState = `http_${response.status}`;
+            const state = await stateFor(sessionPublicKey);
+            lastState = state ?? lastState;
+            if (action === "disconnect" && state === "absent")
+                return;
+            if (action === "connect" && state === "active") {
+                if (!replaceSessionPublicKey || await stateFor(replaceSessionPublicKey) === "absent")
+                    return;
+                lastState = "old_session_still_active";
             }
         }
         catch (error) {
@@ -159,7 +168,7 @@ async function waitForOnChainSession(apiBase, action, ownerWallet, sessionPublic
     throw new Error(`Strata could not confirm the ${action === "connect" ? "active" : "revoked"} session on-chain `
         + `(last state: ${lastState}). The local credential was not changed.`);
 }
-async function waitForPairingCallback(action, sessionPublicKey, state, onComplete) {
+async function waitForPairingCallback(sessionPublicKey, state, returnUrl, onComplete) {
     let settle;
     let reject;
     const completion = new Promise((resolvePromise, rejectPromise) => {
@@ -189,13 +198,13 @@ async function waitForPairingCallback(action, sessionPublicKey, state, onComplet
         finished = true;
         try {
             await onComplete(ownerWallet);
-            response.writeHead(200, {
-                "content-type": "text/html; charset=utf-8",
+            response.writeHead(303, {
+                location: returnUrl,
                 "cache-control": "no-store",
                 "x-content-type-options": "nosniff",
                 "x-frame-options": "DENY",
             });
-            response.end(successHtml(action, ownerWallet));
+            response.end();
             settle(ownerWallet);
         }
         catch (error) {
@@ -238,16 +247,12 @@ export async function runLocalPairing(options) {
     const env = options.env ?? process.env;
     const path = options.credentialsFile ?? tradingCredentialsPath(env);
     const existing = await readTradingConnection(path);
-    if (options.action === "connect" && existing) {
-        throw new Error(`Trading is already connected for wallet ${existing.owner_wallet}. `
-            + "Run strata-mcp disconnect before replacing this session.");
-    }
     if (options.action === "disconnect" && !existing) {
         process.stdout.write("Strata trading is not connected. Read-only tools remain ready.\n");
         return;
     }
     let generated;
-    if (existing) {
+    if (options.action === "disconnect" && existing) {
         generated = existing;
     }
     else {
@@ -262,8 +267,14 @@ export async function runLocalPairing(options) {
         };
     }
     const state = randomBytes(24).toString("hex");
-    const callback = await waitForPairingCallback(options.action, generated.session_public_key, state, async (ownerWallet) => {
-        await waitForOnChainSession(options.apiBase ?? DEFAULT_API_BASE, options.action, ownerWallet, generated.session_public_key);
+    const webBase = pairingWebBase(options.webBase ?? DEFAULT_PAIRING_WEB_BASE);
+    const returnUrl = new URL("/agents", webBase);
+    returnUrl.searchParams.set("paired", options.action === "connect" ? "connected" : "revoked");
+    const replaceSessionPublicKey = options.action === "connect"
+        ? existing?.session_public_key ?? null
+        : null;
+    const callback = await waitForPairingCallback(generated.session_public_key, state, returnUrl.toString(), async (ownerWallet) => {
+        await waitForOnChainSession(options.apiBase ?? DEFAULT_API_BASE, options.action, ownerWallet, generated.session_public_key, replaceSessionPublicKey);
         if (options.action === "disconnect") {
             if (existing?.owner_wallet !== ownerWallet) {
                 throw new Error("the revoking wallet does not own this local Strata connection");
@@ -277,14 +288,10 @@ export async function runLocalPairing(options) {
             connected_at_ms: (options.nowMs ?? Date.now)(),
         }, path);
     });
-    const webBase = pairingWebBase(options.webBase ?? DEFAULT_PAIRING_WEB_BASE);
-    const agentUrl = new URL("/agents", webBase);
-    agentUrl.searchParams.set("pair", options.action);
-    agentUrl.searchParams.set("session_public_key", generated.session_public_key);
-    agentUrl.searchParams.set("callback", callback.callbackUrl);
-    process.stdout.write(`${options.action === "connect" ? "Connect" : "Revoke"} Strata agent access in your browser:\n${agentUrl.toString()}\n\n`);
+    const agentUrl = pairingPageUrl(webBase, options.action, generated.session_public_key, callback.callbackUrl, existing);
+    process.stdout.write(`${options.action === "disconnect" ? "Revoke" : replaceSessionPublicKey ? "Replace" : "Connect"} Strata agent access in your browser:\n${agentUrl}\n\n`);
     if (options.openBrowser !== false)
-        launchBrowser(agentUrl.toString());
+        launchBrowser(agentUrl);
     process.stdout.write("Waiting for the owner-wallet signature…\n");
     const ownerWallet = await callback.completion;
     process.stdout.write(options.action === "connect"

package/dist/src/server.js

@@ -173,6 +173,9 @@ const LEGACY_TOOL_CAPABILITIES = {
     strata_market_making_strand_submit: { ids: ["mm.strand.manage"] },
     strata_market_making_current_prepare: { ids: ["mm.current.manage"] },
     strata_market_making_current_submit: { ids: ["mm.current.manage"] },
+    strata_market_making_intent_prepare: { ids: ["mm.intent.manage"] },
+    strata_market_making_intent_submit: { ids: ["mm.intent.manage"] },
+    strata_market_making_intent_execute: { ids: ["mm.intent.manage"] },
     strata_market_making_prepare: { ids: ["mm.strand.manage", "mm.current.manage"], match: "any" },
     strata_market_making_submit_and_wait: { ids: ["mm.strand.manage", "mm.current.manage"], match: "any" },
     strata_execute_quote: { ids: ["trade.submit"] },
@@ -216,6 +219,9 @@ const PLATFORM_TOOL_CAPABILITIES = {
     strata_market_making_strand_submit: { ids: ["mm.strand.manage"] },
     strata_market_making_current_prepare: { ids: ["mm.current.manage"] },
     strata_market_making_current_submit: { ids: ["mm.current.manage"] },
+    strata_market_making_intent_prepare: { ids: ["mm.intent.manage"] },
+    strata_market_making_intent_submit: { ids: ["mm.intent.manage"] },
+    strata_market_making_intent_execute: { ids: ["mm.intent.manage"] },
     strata_market_making_prepare: { ids: ["mm.strand.manage", "mm.current.manage"], match: "any" },
     strata_market_making_submit_and_wait: { ids: ["mm.strand.manage", "mm.current.manage"], match: "any" },
     strata_rewards: { ids: ["rewards.read"] },
@@ -524,7 +530,7 @@ export async function createStrataMcpServer(options = {}) {
         },
     }, async ({ marketId, walletAddress }) => {
         const response = await platformClient.marketMaking.status(marketId, walletAddress);
-        return toolResult(response, `${response.active_products} active maker products; reconcile intent, Strand, Current, signed-quote, and dead-man state before changing exposure.`);
+        return toolResult(response, `${response.active_products} active maker products; reconcile Strand, Current, signed-quote, and dead-man state before changing exposure.`);
     });
     registerTool("strata_market_making_reputation", {
         title: "Read Strata maker reputation",
@@ -2059,6 +2065,76 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, `Submitted ${response.action} as ${response.signature}.`);
     }));
+    const makerIntentPrepare = registerTool("strata_market_making_intent_prepare", {
+        title: "Prepare Strata IntentBook control",
+        description: "Prepare one sponsored Vault-session transaction for an existing curated IntentBook seat. "
+            + "Post updates its side, price band, and maximum fill. Revoke permanently closes the seat; "
+            + "it cannot be posted again. The owner wallet does not sign each update.",
+        inputSchema: {
+            marketId: makerMarketIdSchema,
+            action: z.enum(["post", "revoke"]),
+            ownerWallet: makerPublicKeySchema,
+            sessionPublicKey: makerPublicKeySchema,
+            side: z.enum(["buy", "sell", "both"]).optional(),
+            minPriceAtoms: makerPositiveAtomicSchema.optional(),
+            maxPriceAtoms: makerPositiveAtomicSchema.optional(),
+            maxFillSizeAtoms: makerPositiveAtomicSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (args) => guardedTool(client, "mm.intent.manage", async () => {
+        let request;
+        if (args.action === "revoke") {
+            request = {
+                action: "revoke",
+                ownerWallet: args.ownerWallet,
+                sessionPublicKey: args.sessionPublicKey,
+            };
+        }
+        else {
+            if (args.side === undefined
+                || args.minPriceAtoms === undefined
+                || args.maxPriceAtoms === undefined
+                || args.maxFillSizeAtoms === undefined) {
+                return toolError("invalid_request", "Intent post requires side, minPriceAtoms, maxPriceAtoms, and maxFillSizeAtoms.", false);
+            }
+            request = {
+                action: "post",
+                ownerWallet: args.ownerWallet,
+                sessionPublicKey: args.sessionPublicKey,
+                side: args.side,
+                minPriceAtoms: args.minPriceAtoms,
+                maxPriceAtoms: args.maxPriceAtoms,
+                maxFillSizeAtoms: args.maxFillSizeAtoms,
+            };
+        }
+        const response = await platformClient.marketMaking.intent.prepare(args.marketId, request);
+        return toolResult(response, `Prepared IntentBook ${response.action}; verify and add only the session signature before ${response.expires_at_ms}. Strata pays the network fee.`);
+    }));
+    const makerIntentSubmit = registerTool("strata_market_making_intent_submit", {
+        title: "Submit Strata IntentBook control",
+        description: "Submit the exact session-signed IntentBook packet. Exact retries during the packet's live "
+            + "blockhash window return the original confirmed signature.",
+        inputSchema: {
+            marketId: makerMarketIdSchema,
+            signedTransactionBase64: makerBase64Schema,
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ marketId, signedTransactionBase64 }) => guardedTool(client, "mm.intent.manage", async () => {
+        const response = await platformClient.marketMaking.intent.submit(marketId, {
+            signedTransactionBase64,
+        });
+        return toolResult(response, `Submitted IntentBook control as ${response.signature}.`);
+    }));
     registerAutonomyTools(registerTool, client, platformClient, options.sessionAutonomy, () => typeof Date !== "undefined" ? Date.now() : 0);
     void [
         markets,
@@ -2077,6 +2153,8 @@ export async function createStrataMcpServer(options = {}) {
         makerStrandSubmit,
         makerCurrentPrepare,
         makerCurrentSubmit,
+        makerIntentPrepare,
+        makerIntentSubmit,
     ];
     applyToolAvailability(registeredTools, initialCatalog, initialPlatformCatalog, toolMode);
     let closed = false;
@@ -2175,6 +2253,65 @@ function registerAutonomyTools(registerTool, client, platformClient, autonomy, n
         };
     };
     const refuse = (reason, prepared, summary) => toolResult({ executed: false, reason, prepared }, summary);
+    // ── one-shot existing IntentBook seat control ──────────────────────────────
+    registerTool("strata_market_making_intent_execute", {
+        title: "Execute Strata IntentBook control",
+        description: "Post or permanently revoke an existing curated IntentBook seat in one call. The configured "
+            + "Vault session verifies and signs; Strata pays the network fee. Under ask, or above a limits "
+            + "ceiling, this prepares the exact packet but does not sign it.",
+        inputSchema: {
+            marketId: makerMarketIdSchema,
+            action: z.enum(["post", "revoke"]),
+            side: z.enum(["buy", "sell", "both"]).optional(),
+            minPriceAtoms: makerPositiveAtomicSchema.optional(),
+            maxPriceAtoms: makerPositiveAtomicSchema.optional(),
+            maxFillSizeAtoms: makerPositiveAtomicSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (args) => guardedTool(client, "mm.intent.manage", async () => {
+        let operation;
+        if (args.action === "revoke") {
+            operation = { action: "revoke", ownerWallet: autonomy.ownerWallet };
+        }
+        else {
+            if (args.side === undefined
+                || args.minPriceAtoms === undefined
+                || args.maxPriceAtoms === undefined
+                || args.maxFillSizeAtoms === undefined) {
+                return toolError("invalid_request", "Intent post requires side, minPriceAtoms, maxPriceAtoms, and maxFillSizeAtoms.", false);
+            }
+            operation = {
+                action: "post",
+                ownerWallet: autonomy.ownerWallet,
+                side: args.side,
+                minPriceAtoms: args.minPriceAtoms,
+                maxPriceAtoms: args.maxPriceAtoms,
+                maxFillSizeAtoms: args.maxFillSizeAtoms,
+            };
+        }
+        const baseAtoms = operation.action === "post" ? BigInt(operation.maxFillSizeAtoms) : 0n;
+        const notional = await estimateBaseNotionalUsd(resolver, markFor, args.marketId, baseAtoms);
+        const decision = decideAutonomy(autonomy, args.marketId, notional, nowMs());
+        if (!decision.allow) {
+            const prepared = await platformClient.marketMaking.intent.prepare(args.marketId, {
+                ...operation,
+                sessionPublicKey: autonomy.signer.publicKey,
+            });
+            return refuse(decision.reason, prepared, decision.reason);
+        }
+        const receipt = await platformClient.marketMaking.intent.execute(args.marketId, {
+            operation,
+            signer: autonomy.signer,
+        });
+        if (notional !== null)
+            autonomy.dailyBudget.record(notional, nowMs());
+        return toolResult({ executed: true, receipt, notional_usd: notional }, `Executed IntentBook ${operation.action} as ${receipt.signature}.`);
+    }));
     // ── one-shot immediate execution from a fresh Sonar quote ─────────────────
     registerTool("strata_execute_quote", {
         title: "Execute a Strata quote",

package/dist/src/usability.js

@@ -14,6 +14,7 @@ export const SIMPLE_TOOL_NAMES = new Set([
     "strata_market_making_status",
     "strata_market_making_prepare",
     "strata_market_making_submit_and_wait",
+    "strata_market_making_intent_execute",
     "strata_autonomy",
     "strata_trade",
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stratabook/mcp",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "description": "Connect AI agents to Strata markets and Sonar quotes with MCP.",
   "type": "module",
   "license": "MIT OR Apache-2.0",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
-    "@stratabook/sdk": "0.2.13",
+    "@stratabook/sdk": "0.2.15",
     "zod": "^3.25.76"
   },
   "devDependencies": {