@stratabook/mcp 0.2.2 → 0.2.5

package/README.md

@@ -4,6 +4,11 @@ Official capability-gated MCP access to Strata and Sonar. The server delegates
 to `@stratabook/sdk`: it follows the live capability catalog and contains no
 separate quote or execution logic.
 
+The official hosted endpoint currently exposes market, exact-output, and
+asset-to-asset Sonar quotes, together with quote-bound execution tools.
+Capability gating is a runtime safety check so clients stop if policy changes;
+it does **not** mean quotes are inactive.
+
 ## Local stdio
 
 ```sh
@@ -40,6 +45,10 @@ The tools currently available are:
 - `strata_portfolio_history`
 - `strata_market_making_status`
 - `strata_market_making_reputation`
+- `strata_market_making_prepare` — start or stop a Strand/Current from a market label, decimal base size, spread, and duration; no arrays or atom conversion
+- `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_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
@@ -50,12 +59,12 @@ The tools currently available are:
 - `strata_referral_claim` — prepare externally signable consent or submit the signed claim
 - `strata_bugs`
 - `strata_bug_submit` — prepare externally signable bytes or submit the signed report
-- `strata_markets`, when `markets.read` is enabled for MCP
-- `strata_quote` and `strata_exact_output_quote` (spend X / receive at least Y), when market quotes are enabled for MCP
-- `strata_swap_quote`, when catalog-asset swap quotes are enabled for MCP
-- `strata_execution_challenge`, when `trade.prepare` is enabled for MCP
-- `strata_execution_prepare`, when `trade.prepare` is enabled for MCP
-- `strata_execution_submit`, when `trade.submit` is enabled for MCP
+- `strata_markets`
+- `strata_quote` and `strata_exact_output_quote` — live market quotes (spend X / receive at least Y)
+- `strata_swap_quote` — live catalog-asset swap quotes
+- `strata_execution_challenge`
+- `strata_execution_prepare`
+- `strata_execution_submit`
 - `strata_execution_status` — recover a durable immediate-execution receipt
 - `strata_order_challenge`, when `orders.prepare` is enabled for MCP
 - `strata_order_prepare`, when `orders.prepare` is enabled for MCP
@@ -72,7 +81,29 @@ available as `strata://platform-graph/v2`.
 
 The tool list follows the live public policy. Every call rechecks that policy,
 so a disabled capability stops immediately even if a client cached an older
-tool list.
+tool list. Tool discovery from the connected server remains authoritative for
+self-hosted deployments or any future policy change.
+
+For normal maker operation, use two calls:
+
+1. Call `strata_market_making_prepare` with `action: "start"`, a label such as
+   `SOL/USDC`, `product: "current"` or `"strand"`, `spreadBps`, a decimal size
+   such as `0.01 SOL`, and the maker wallet. Duration defaults to ten minutes
+   and levels default to three.
+2. Verify and sign only `prepared.transaction_base64` in the external wallet,
+   then pass it and `prepared.maker_control_id` to
+   `strata_market_making_submit_and_wait`.
+
+The second call returns only after Strata's chain-derived maker status matches
+the exact product settings. 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.
+
+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
+control is disabled, exhausted, expired, or cancelled. Current follows Strata's
+live mark and needs no separate publisher transaction.
 
 ## Hosted Streamable HTTP
 

package/dist/src/server.js

@@ -6,6 +6,74 @@ import { STRATA_AGENT_HARNESS, STRATA_AGENT_HARNESS_INSTRUCTIONS, STRATA_AGENT_H
 import { SERVER_VERSION } from "./version.js";
 const REFRESH_INTERVAL_MS = 5_000;
 export const STRATA_PLATFORM_GRAPH_URI = "strata://platform-graph/v2";
+const LEGACY_TOOL_CAPABILITIES = {
+    strata_markets: { ids: ["markets.read"] },
+    strata_quote: { ids: ["quotes.read"] },
+    strata_exact_output_quote: { ids: ["quotes.read"] },
+    strata_execution_challenge: { ids: ["trade.prepare"] },
+    strata_execution_prepare: { ids: ["trade.prepare"] },
+    strata_execution_submit: { ids: ["trade.submit"] },
+    strata_order_challenge: { ids: ["orders.prepare"] },
+    strata_order_prepare: { ids: ["orders.prepare"] },
+    strata_order_submit: { ids: ["orders.submit"] },
+    strata_order_status: { ids: ["orders.submit"] },
+    strata_market_making_strand_prepare: { ids: ["mm.strand.manage"] },
+    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_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"] },
+    strata_order_execute: { ids: ["orders.prepare", "orders.submit"] },
+};
+const PLATFORM_TOOL_CAPABILITIES = {
+    strata_status: { ids: ["platform.status.read"] },
+    strata_platform_graph: { ids: ["graphs.read"] },
+    strata_candles: { ids: ["market_data.candles.read"] },
+    strata_marks: { ids: ["market_data.marks.read"] },
+    strata_quote: { ids: ["quotes.market.read"] },
+    strata_swap_quote: { ids: ["quotes.swap.read"] },
+    strata_exact_output_quote: { ids: ["quotes.exact_output.read"] },
+    strata_execution_challenge: { ids: ["execution.prepare"] },
+    strata_execution_prepare: { ids: ["execution.prepare"] },
+    strata_execution_submit: { ids: ["execution.submit"] },
+    strata_execution_status: { ids: ["execution.status.read"] },
+    strata_order_challenge: { ids: ["orders.prepare"] },
+    strata_order_prepare: { ids: ["orders.prepare"] },
+    strata_order_submit: { ids: ["orders.submit"] },
+    strata_twap_challenge: { ids: ["algos.twap.place"] },
+    strata_twap_cancel: { ids: ["algos.twap.cancel"] },
+    strata_twap_prepare: { ids: ["algos.twap.place", "algos.twap.cancel"], match: "any" },
+    strata_twap_submit: { ids: ["algos.twap.place", "algos.twap.cancel"], match: "any" },
+    strata_twaps: { ids: ["algos.twap.read"] },
+    strata_portfolio: { ids: ["portfolio.read"] },
+    strata_portfolio_history: { ids: ["portfolio.history.read"] },
+    strata_vault_status: { ids: ["vault.status.read"] },
+    strata_vault_setup: { ids: ["vault.setup"] },
+    strata_vault_deposit: { ids: ["vault.deposit"] },
+    strata_vault_withdraw: { ids: ["vault.withdraw"] },
+    strata_vault_delegate: { ids: ["vault.delegate.manage"] },
+    strata_vault_policy: { ids: ["vault.policy.manage"] },
+    strata_vault_pause: { ids: ["vault.pause"] },
+    strata_vault_submit: { ids: ["vault.relay"] },
+    strata_vault_submission: { ids: ["vault.relay"] },
+    strata_market_making_status: { ids: ["mm.status.read"] },
+    strata_market_making_reputation: { ids: ["mm.reputation.read"] },
+    strata_market_making_strand_prepare: { ids: ["mm.strand.manage"] },
+    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_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"] },
+    strata_referrals: { ids: ["referrals.read"] },
+    strata_referral_link: { ids: ["referrals.link"] },
+    strata_referral_claim: { ids: ["referrals.claim"] },
+    strata_bug_submit: { ids: ["bugs.submit"] },
+    strata_bugs: { ids: ["bugs.read"] },
+    strata_order_execute: { ids: ["orders.prepare", "orders.submit"] },
+    strata_twap_execute: { ids: ["algos.twap.place", "algos.twap.cancel"], match: "any" },
+};
 export function capabilityAvailable(catalog, id) {
     return catalog.capabilities.some((capability) => capability.id === id
         && capability.default_enabled
@@ -184,12 +252,15 @@ export async function createStrataMcpServer(options = {}) {
     if (initialCatalog.contract_version !== STRATA_AGENT_HARNESS.contract_version) {
         throw new Error("agent harness and live contract versions differ");
     }
+    const initialPlatformCatalog = await platformClient.discovery.read();
     const server = new McpServer({
         name: "strata",
         version: SERVER_VERSION,
     }, {
         instructions: STRATA_AGENT_HARNESS_INSTRUCTIONS,
     });
+    const { registerTool, handles: registeredTools } = trackedToolRegistrar(server);
+    const makerQuickstartPreparations = new Map();
     server.registerResource("strata_agent_harness", STRATA_AGENT_HARNESS_URI, {
         title: "Strata Agent Harness",
         description: "Canonical capability-gated first-run workflow for Strata agents.",
@@ -251,7 +322,7 @@ export async function createStrataMcpServer(options = {}) {
             },
         ],
     }));
-    server.registerTool("strata_capabilities", {
+    registerTool("strata_capabilities", {
         title: "Strata capabilities",
         description: "See which Strata features are currently available to MCP clients.",
         annotations: {
@@ -261,7 +332,7 @@ export async function createStrataMcpServer(options = {}) {
             openWorldHint: true,
         },
     }, async () => toolResult(await client.capabilities(), "Current Strata capabilities."));
-    server.registerTool("strata_action_graph", {
+    registerTool("strata_action_graph", {
         title: "Strata action graph",
         description: "Discover live operations, required capabilities, transition conditions, and external signing boundaries.",
         annotations: {
@@ -271,7 +342,7 @@ export async function createStrataMcpServer(options = {}) {
             openWorldHint: true,
         },
     }, async () => toolResult(await client.actionGraph(), "Current Strata action graph."));
-    server.registerTool("strata_platform_graph", {
+    registerTool("strata_platform_graph", {
         title: "Strata platform graph",
         description: "Discover every public module, entity relationship, operation binding, workflow, and live availability gate.",
         annotations: {
@@ -285,7 +356,7 @@ export async function createStrataMcpServer(options = {}) {
         const liveOperations = graph.operations.filter((operation) => operation.available).length;
         return toolResult(graph, `${liveOperations} of ${graph.operations.length} mapped Strata operations are currently live.`);
     });
-    server.registerTool("strata_market_making_status", {
+    registerTool("strata_market_making_status", {
         title: "Read Strata maker status",
         description: "A maker's products, live exposure, health, and kill state in one market — public by wallet address, no signature.",
         inputSchema: {
@@ -302,7 +373,7 @@ export async function createStrataMcpServer(options = {}) {
         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.`);
     });
-    server.registerTool("strata_market_making_reputation", {
+    registerTool("strata_market_making_reputation", {
         title: "Read Strata maker reputation",
         description: "A maker's reliability, participation, tier, and signed-quote eligibility in one market — public by wallet address, no signature.",
         inputSchema: {
@@ -316,7 +387,7 @@ export async function createStrataMcpServer(options = {}) {
             openWorldHint: true,
         },
     }, async ({ marketId, walletAddress }) => toolResult(await platformClient.marketMaking.reputation(marketId, walletAddress), "Maker reputation record. Use tier_progress and signed_quote_stream_eligible before choosing a maker transport."));
-    server.registerTool("strata_status", {
+    registerTool("strata_status", {
         title: "Strata status",
         description: "Read product-level readiness and the number of currently live mapped operations.",
         annotations: {
@@ -329,7 +400,7 @@ export async function createStrataMcpServer(options = {}) {
         const status = await platformClient.discovery.status();
         return toolResult(status, `Strata is ${status.status}; ${status.available_operations} mapped operations are live.`);
     });
-    server.registerTool("strata_candles", {
+    registerTool("strata_candles", {
         title: "Strata candles",
         description: "Read bounded time-bucketed candles for one opaque Strata market ID.",
         inputSchema: {
@@ -352,7 +423,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(candles, `${candles.candles.length} Strata candles returned.`);
     });
-    server.registerTool("strata_marks", {
+    registerTool("strata_marks", {
         title: "Strata mark",
         description: "Read the current customer-facing reference price for one opaque market ID.",
         inputSchema: {
@@ -368,7 +439,7 @@ export async function createStrataMcpServer(options = {}) {
         const mark = await platformClient.marketData.mark(marketId);
         return toolResult(mark, mark.stale ? "Strata mark is stale." : "Current Strata mark.");
     });
-    server.registerTool("strata_book", {
+    registerTool("strata_book", {
         title: "Strata order book",
         description: "Read the executable order book for one opaque market ID: bids and asks, one size per price "
             + "level. Top of book is the best bid and ask.",
@@ -392,7 +463,7 @@ export async function createStrataMcpServer(options = {}) {
         const book = await platformClient.books.snapshot(marketId, depth === undefined ? {} : { depth });
         return toolResult(book, `Book for ${marketId}: ${book.bids.length} bid / ${book.asks.length} ask levels at sequence ${book.sequence}.`);
     });
-    server.registerTool("strata_bbo", {
+    registerTool("strata_bbo", {
         title: "Strata best bid/ask",
         description: "Read the current best bid and best ask (top of book) for one opaque market ID.",
         inputSchema: {
@@ -408,7 +479,7 @@ export async function createStrataMcpServer(options = {}) {
         const bbo = await platformClient.books.bestBidAsk(marketId);
         return toolResult(bbo, `BBO for ${marketId}: bid ${bbo.best_bid?.price_atoms ?? "—"} / ask ${bbo.best_ask?.price_atoms ?? "—"}.`);
     });
-    server.registerTool("strata_trades", {
+    registerTool("strata_trades", {
         title: "Strata recent trades",
         description: "Read recent anonymized prints for one opaque market ID: price, size, side, and time.",
         inputSchema: {
@@ -431,7 +502,7 @@ export async function createStrataMcpServer(options = {}) {
         const trades = await platformClient.books.trades(marketId, limit === undefined ? {} : { limit });
         return toolResult(trades, `${trades.trades.length} recent prints for ${marketId}.`);
     });
-    server.registerTool("strata_execution_status", {
+    registerTool("strata_execution_status", {
         title: "Strata execution status",
         description: "Recover prepared state or a restart-durable confirmed execution receipt.",
         inputSchema: {
@@ -448,7 +519,7 @@ export async function createStrataMcpServer(options = {}) {
         const receipt = await platformClient.executions.status(marketId, executionId);
         return toolResult(receipt, `Execution is ${receipt.status}.`);
     });
-    server.registerTool("strata_twaps", {
+    registerTool("strata_twaps", {
         title: "Strata TWAPs",
         description: "Read sanitized progress and terminal receipts for wallet-owned TWAP schedules.",
         inputSchema: {
@@ -465,7 +536,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.algos.twaps(marketId, walletAddress);
         return toolResult(response, `${response.twaps.length} TWAP schedules returned.`);
     });
-    server.registerTool("strata_twap_challenge", {
+    registerTool("strata_twap_challenge", {
         title: "Prepare a Strata TWAP authorization",
         description: "Request exact external-signing bytes for a bounded TWAP schedule.",
         inputSchema: {
@@ -499,7 +570,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, "Sign the returned authorization payload externally.");
     });
-    server.registerTool("strata_twap_cancel", {
+    registerTool("strata_twap_cancel", {
         title: "Prepare Strata TWAP cancellation",
         description: "Request exact external-signing bytes to cancel one active owned TWAP.",
         inputSchema: {
@@ -523,7 +594,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, "Sign the returned cancellation payload externally.");
     });
-    server.registerTool("strata_twap_prepare", {
+    registerTool("strata_twap_prepare", {
         title: "Prepare Strata TWAP transaction",
         description: "Prepare a canonical TWAP transaction. One signature: pass the action itself (place fields or twapId to cancel) and sign only the returned transaction. (A challengeId + authorizationSignature is still accepted.)",
         inputSchema: {
@@ -596,7 +667,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.algos.prepare(input.marketId, { operation });
         return toolResult(response, "One signature: verify this canonical transaction, then sign it externally with the session key and submit.");
     });
-    server.registerTool("strata_twap_submit", {
+    registerTool("strata_twap_submit", {
         title: "Submit Strata TWAP transaction",
         description: "Submit the exact externally signed TWAP transaction idempotently.",
         inputSchema: {
@@ -619,7 +690,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, `TWAP action submitted as ${response.signature}.`);
     });
-    server.registerTool("strata_portfolio", {
+    registerTool("strata_portfolio", {
         title: "Strata account",
         description: "The whole account in one public read, by wallet address: balances (total / available / locked, exact USD), positions, open orders, and recent fills across every live market. No signature, no session key, no market selection.",
         inputSchema: {
@@ -641,7 +712,7 @@ export async function createStrataMcpServer(options = {}) {
             ? `${response.balances.length} held assets; ${activity}; equity ${response.equity_usd_micros} USD micros at slot ${response.observed_slot}.`
             : `${response.balances.length} held assets; ${activity}; ${response.unpriced_asset_ids.length} unpriced, USD totals unavailable.`);
     });
-    server.registerTool("strata_portfolio_history", {
+    registerTool("strata_portfolio_history", {
         title: "Strata portfolio history",
         description: "Read genuine stored account-equity history in exact USD micros.",
         inputSchema: {
@@ -658,7 +729,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.account.portfolioHistory(walletAddress, range);
         return toolResult(response, `${response.points.length} stored equity samples returned.`);
     });
-    server.registerTool("strata_vault_status", {
+    registerTool("strata_vault_status", {
         title: "Strata Vault status",
         description: "Read sealed owner state and optional external-session readiness without construction identifiers.",
         inputSchema: {
@@ -677,7 +748,7 @@ export async function createStrataMcpServer(options = {}) {
             ? `Vault is ${response.state}; no session was requested.`
             : `Vault is ${response.state}; requested session is ${response.session.state}.`);
     });
-    server.registerTool("strata_vault_pause", {
+    registerTool("strata_vault_pause", {
         title: "Prepare Strata Vault pause",
         description: "Prepare an owner-authorized pause or resume transaction for external verification, signing, and broadcast.",
         inputSchema: {
@@ -694,7 +765,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.vault.preparePause({ walletAddress, paused });
         return toolResult(response, `Verify this ${paused ? "pause" : "resume"} transaction, then owner-sign it and pass preparation_id + the signed transaction to strata_vault_submit (Strata pays the fee when sponsored is true).`);
     });
-    server.registerTool("strata_vault_setup", {
+    registerTool("strata_vault_setup", {
         title: "Prepare Strata Vault onboarding",
         description: "One-signature onboarding: register an external session key for a wallet. Only the wallet and the session key are needed; one session then trades every market. Policy fields are optional. A first strata_vault_deposit that names the session key does this in the same transaction.",
         inputSchema: {
@@ -733,7 +804,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, "Verify every echoed session policy field, then owner-sign it and pass preparation_id + the signed transaction to strata_vault_submit (Strata pays the fee when sponsored is true).");
     });
-    server.registerTool("strata_vault_deposit", {
+    registerTool("strata_vault_deposit", {
         title: "Prepare Strata Vault deposit",
         description: "Prepare an exact owner-funded Vault deposit using opaque market and asset IDs. Name sessionPublicKey and a first deposit also registers that session in the same transaction (one owner signature onboards and funds the wallet).",
         inputSchema: {
@@ -761,7 +832,7 @@ export async function createStrataMcpServer(options = {}) {
             ? "This deposit also registers the session key. Verify the exact market, asset, amount, and session, then owner-sign it and pass preparation_id + the signed transaction to strata_vault_submit (Strata pays the fee when sponsored is true)."
             : "Verify the exact market, asset, and amount, then owner-sign it and pass preparation_id + the signed transaction to strata_vault_submit (Strata pays the fee when sponsored is true).");
     });
-    server.registerTool("strata_vault_withdraw", {
+    registerTool("strata_vault_withdraw", {
         title: "Prepare Strata Vault withdrawal",
         description: "Prepare an exact owner-authorized withdrawal to a destination wallet.",
         inputSchema: {
@@ -787,7 +858,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, "Verify the exact destination and amount, then owner-sign it and pass preparation_id + the signed transaction to strata_vault_submit (Strata pays the fee when sponsored is true).");
     });
-    server.registerTool("strata_vault_delegate", {
+    registerTool("strata_vault_delegate", {
         title: "Prepare Strata Vault session control",
         description: "Prepare owner-authorized revocation of one externally held Vault session key.",
         inputSchema: {
@@ -809,7 +880,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, "Verify both identities and the destructive action, then owner-sign it and pass preparation_id + the signed transaction to strata_vault_submit (Strata pays the fee when sponsored is true).");
     });
-    server.registerTool("strata_vault_policy", {
+    registerTool("strata_vault_policy", {
         title: "Prepare Strata Vault withdrawal policy",
         description: "Prepare an owner-authorized blocked or restricted withdrawal access policy.",
         inputSchema: {
@@ -830,7 +901,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, "Verify the exact withdrawal access policy, then owner-sign it and pass preparation_id + the signed transaction to strata_vault_submit (Strata pays the fee when sponsored is true).");
     });
-    server.registerTool("strata_vault_submit", {
+    registerTool("strata_vault_submit", {
         title: "Submit a prepared Strata Vault transaction",
         description: "Submit an owner-signed prepared Vault transaction (setup, deposit, withdrawal, session, "
             + "policy, pause). Strata verifies it is exactly the prepared transaction, pays the network "
@@ -857,7 +928,7 @@ export async function createStrataMcpServer(options = {}) {
         return toolResult(response, `Vault ${response.action} ${response.status}${response.sponsored ? " (Strata paid the fee)" : ""}: `
             + `signature ${response.signature}. Poll strata_vault_submission until confirmed.`);
     });
-    server.registerTool("strata_vault_submission", {
+    registerTool("strata_vault_submission", {
         title: "Strata Vault submission status",
         description: "Read the durable outcome of a submitted Vault transaction: submitted, confirmed, or failed.",
         inputSchema: {
@@ -874,7 +945,7 @@ export async function createStrataMcpServer(options = {}) {
         return toolResult(response, `Vault ${response.action} is ${response.status}`
             + `${response.failure_code ? ` (${response.failure_code})` : ""}.`);
     });
-    server.registerTool("strata_rewards", {
+    registerTool("strata_rewards", {
         title: "Strata rewards",
         description: "Read the current rewards season, standings, and optional owner score.",
         inputSchema: {
@@ -891,7 +962,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.rewards.read({ walletAddress, limit });
         return toolResult(response, `${response.standings.length} reward standings returned.`);
     });
-    server.registerTool("strata_referrals", {
+    registerTool("strata_referrals", {
         title: "Strata referrals",
         description: "Read an owner's referral state and exact claimable reward atoms.",
         inputSchema: {
@@ -907,7 +978,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.referrals.read(walletAddress);
         return toolResult(response, response.enabled ? "Referral state returned." : "Referrals are disabled.");
     });
-    server.registerTool("strata_referral_link", {
+    registerTool("strata_referral_link", {
         title: "Link a Strata referral",
         description: "Prepare or submit an externally authorized referral link for a new wallet.",
         inputSchema: {
@@ -936,7 +1007,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, "Referral link is pending the wallet's first fill.");
     });
-    server.registerTool("strata_referral_claim", {
+    registerTool("strata_referral_claim", {
         title: "Claim Strata referral rewards",
         description: "Prepare or submit an externally authorized request for currently claimable referral rewards.",
         inputSchema: {
@@ -967,7 +1038,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, `${response.claimable_atoms} referral reward atoms requested.`);
     });
-    server.registerTool("strata_bugs", {
+    registerTool("strata_bugs", {
         title: "Strata bug reports",
         description: "Read an owner's redacted bug reports and confirmed points.",
         inputSchema: {
@@ -983,7 +1054,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.bugs.read(walletAddress);
         return toolResult(response, `${response.reports.length} redacted bug reports returned.`);
     });
-    server.registerTool("strata_bug_submit", {
+    registerTool("strata_bug_submit", {
         title: "Submit Strata bug report",
         description: "Prepare or submit a bug report. Omit authorizationSignature to receive the exact "
             + "payload for the owner wallet to sign externally; provide that hex signature to submit.",
@@ -1013,7 +1084,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, `Bug report ${response.bug_id} is pending review.`);
     });
-    const markets = server.registerTool("strata_markets", {
+    const markets = registerTool("strata_markets", {
         title: "Strata markets",
         description: "List Strata markets and their current Sonar quote availability.",
         inputSchema: {
@@ -1048,7 +1119,7 @@ export async function createStrataMcpServer(options = {}) {
                 ? `; ${identified} carry a market_id — pass it as marketId to every by-market tool.`
                 : "."));
     }));
-    const quote = server.registerTool("strata_quote", {
+    const quote = registerTool("strata_quote", {
         title: "Sonar quote",
         description: "Request a short-lived Sonar quote for a Strata market. Returns expected "
             + "output, minimum output, fees, price impact, and expiry.",
@@ -1091,7 +1162,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await client.quote(request);
         return toolResult(response, quoteSummary(response));
     }));
-    const exactOutputQuote = server.registerTool("strata_exact_output_quote", {
+    const exactOutputQuote = registerTool("strata_exact_output_quote", {
         title: "Sonar exact-output quote",
         description: "Request a short-lived Sonar quote for an exact output amount (for example: buy "
             + "1 SOL). Strata inverts its best route and returns the input that delivers it as "
@@ -1138,7 +1209,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await client.quote(request);
         return toolResult(response, quoteSummary(response));
     }));
-    server.registerTool("strata_swap_quote", {
+    registerTool("strata_swap_quote", {
         title: "Sonar asset swap quote",
         description: "Request short-lived exact-input customer economics between two opaque Strata asset IDs.",
         inputSchema: {
@@ -1164,7 +1235,7 @@ export async function createStrataMcpServer(options = {}) {
             + `${response.amount_out_atoms} user-net output atoms; minimum `
             + `${response.minimum_output_atoms}; expires at ${response.expires_at_ms}.`);
     });
-    const executionChallenge = server.registerTool("strata_execution_challenge", {
+    const executionChallenge = registerTool("strata_execution_challenge", {
         title: "Strata execution challenge",
         description: "Request canonical quote-bound authorization bytes for the external signer configured by the agent owner.",
         inputSchema: {
@@ -1200,7 +1271,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await client.executionChallenge(request);
         return toolResult(response, `Authorization challenge ${response.challenge_id}; expires at ${response.expires_at_ms}.`);
     }));
-    const executionPrepare = server.registerTool("strata_execution_prepare", {
+    const executionPrepare = registerTool("strata_execution_prepare", {
         title: "Prepare Strata execution",
         description: "Prepare a quote-bound partially signed transaction. One signature: pass quoteId + ownerWallet + sessionPublicKey and sign only the returned transaction. (A challengeId + authorizationSignature from strata_execution_challenge is still accepted.)",
         inputSchema: {
@@ -1251,7 +1322,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await client.executionPrepare(request);
         return toolResult(response, `Prepared execution ${response.execution_id}; verify it, then sign the transaction externally with the session key before ${response.expires_at_ms} and submit.`);
     }));
-    const executionSubmit = server.registerTool("strata_execution_submit", {
+    const executionSubmit = registerTool("strata_execution_submit", {
         title: "Submit Strata execution",
         description: "Submit an externally signed prepared transaction with an idempotency key.",
         inputSchema: {
@@ -1289,7 +1360,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await client.executionSubmit(request);
         return toolResult(response, `Submitted execution ${response.execution_id} as ${response.signature}.`);
     }));
-    const orderChallenge = server.registerTool("strata_order_challenge", {
+    const orderChallenge = registerTool("strata_order_challenge", {
         title: "Strata order challenge",
         description: "Bind an atomic place, cancel, cancel-all, replace, or bounded batch request to canonical bytes for the agent owner's external signer.",
         inputSchema: {
@@ -1334,7 +1405,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.orders.challenge(args.marketId, request);
         return toolResult(response, `Order challenge ${response.challenge_id} binds ${response.order_ids.length} opaque order ID(s); expires at ${response.expires_at_ms}.`);
     }));
-    const orderPrepare = server.registerTool("strata_order_prepare", {
+    const orderPrepare = registerTool("strata_order_prepare", {
         title: "Prepare Strata order control",
         description: "Prepare an immutable partially signed order-control transaction. One signature: pass the operation itself (same fields as strata_order_challenge) and sign only the returned transaction with the session key. (A challengeId + authorizationSignature from strata_order_challenge is still accepted.)",
         inputSchema: {
@@ -1398,7 +1469,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.orders.prepare(args.marketId, { operation: mapped });
         return toolResult(response, `Prepared ${response.action} control ${response.order_control_id} — one signature: verify it, sign the transaction externally with the session key before ${response.expires_at_ms}, then submit.`);
     }));
-    const orderSubmit = server.registerTool("strata_order_submit", {
+    const orderSubmit = registerTool("strata_order_submit", {
         title: "Submit Strata order control",
         description: "Submit an externally signed order transaction with a stable retry key.",
         inputSchema: {
@@ -1425,7 +1496,7 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, `Submitted ${response.action} control ${response.order_control_id} as ${response.signature}.`);
     }));
-    const orderStatus = server.registerTool("strata_order_status", {
+    const orderStatus = registerTool("strata_order_status", {
         title: "Read Strata order-control status",
         description: "Recover the durable result for an externally signed order submission after a timeout or restart.",
         inputSchema: {
@@ -1443,7 +1514,110 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.orders.status(marketId, { orderControlId, idempotencyKey });
         return toolResult(response, `Order control ${response.order_control_id} is ${response.status}.`);
     }));
-    const makerStrandPrepare = server.registerTool("strata_market_making_strand_prepare", {
+    const makerPrepare = registerTool("strata_market_making_prepare", {
+        title: "Prepare simple Strata market making",
+        description: "Prepare a pro-level Strand or Current from a market label, decimal base size, spread, and duration. Strata resolves IDs, decimals, live mark, tick grid, expiry, safety bounds, and fixed on-chain arrays. Sign only the returned transaction externally, then call submit_and_wait.",
+        inputSchema: {
+            action: z.enum(["start", "stop"]),
+            market: z.string().min(1).max(128),
+            product: z.enum(["strand", "current"]),
+            makerWallet: z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/),
+            spreadBps: z.number().int().min(1).max(5_000).optional(),
+            size: z.string().min(1).max(64).optional(),
+            duration: z.union([
+                z.number().int().min(1).max(604_800),
+                z.string().regex(/^[1-9][0-9]*(?:s|m|h|d)$/i),
+            ]).optional(),
+            levels: z.number().int().min(1).max(16).optional(),
+            levelStepBps: z.number().int().min(1).max(5_000).optional(),
+            side: z.enum(["both", "buy", "sell"]).optional(),
+            asyncOnly: z.boolean().optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (args) => guardedTool(client, `mm.${args.product}.manage`, async () => {
+        const prepared = args.action === "stop"
+            ? await platformClient.marketMaking.prepareStop({
+                market: args.market,
+                product: args.product,
+                makerWallet: args.makerWallet,
+            })
+            : (() => {
+                if (args.spreadBps === undefined || args.size === undefined) {
+                    return undefined;
+                }
+                return platformClient.marketMaking.prepareStart({
+                    market: args.market,
+                    product: args.product,
+                    makerWallet: args.makerWallet,
+                    spreadBps: args.spreadBps,
+                    size: args.size,
+                    ...(args.duration === undefined ? {} : { duration: args.duration }),
+                    ...(args.levels === undefined ? {} : { levels: args.levels }),
+                    ...(args.levelStepBps === undefined ? {} : { levelStepBps: args.levelStepBps }),
+                    ...(args.side === undefined ? {} : { side: args.side }),
+                    ...(args.asyncOnly === undefined ? {} : { asyncOnly: args.asyncOnly }),
+                });
+            })();
+        if (prepared === undefined) {
+            return toolError("invalid_request", "Starting market making requires spreadBps and size.", false);
+        }
+        const resolved = await prepared;
+        makerQuickstartPreparations.set(resolved.prepared.maker_control_id, resolved);
+        while (makerQuickstartPreparations.size > 128) {
+            const oldest = makerQuickstartPreparations.keys().next().value;
+            if (oldest === undefined)
+                break;
+            makerQuickstartPreparations.delete(oldest);
+        }
+        const response = {
+            action: args.action,
+            market: resolved.market,
+            product: resolved.product,
+            ...("base_asset" in resolved ? { base_asset: resolved.base_asset } : {}),
+            operation: resolved.operation,
+            prepared: resolved.prepared,
+        };
+        return toolResult(response, `Prepared ${args.action} for ${resolved.market.label} as ${resolved.prepared.maker_control_id}. Verify and sign only prepared.transaction_base64, then submit it within 30 seconds.`);
+    }));
+    const makerSubmitAndWait = registerTool("strata_market_making_submit_and_wait", {
+        title: "Submit and confirm Strata market making",
+        description: "Submit the exact externally signed quickstart transaction and wait until Strata's chain-derived maker state confirms the product started or stopped. The control ID is its default idempotency key.",
+        inputSchema: {
+            makerControlId: z.string().regex(/^mc_[0-9a-f]{32}$/),
+            signedTransactionBase64: z.string().min(4).max(4_096).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/),
+            idempotencyKey: z.string().min(1).max(64).regex(/^[A-Za-z0-9._-]+$/).optional(),
+            confirmationTimeoutMs: z.number().int().min(1_000).max(120_000).optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (args) => {
+        const prepared = makerQuickstartPreparations.get(args.makerControlId);
+        if (!prepared) {
+            return toolError("session_expired", "This quickstart preparation is not in the current MCP session. Prepare it again; maker transactions expire after 30 seconds.", false);
+        }
+        return guardedTool(client, `mm.${prepared.product}.manage`, async () => {
+            const response = await platformClient.marketMaking.submitPrepared({
+                prepared,
+                signedTransactionBase64: args.signedTransactionBase64,
+                ...(args.idempotencyKey === undefined ? {} : { idempotencyKey: args.idempotencyKey }),
+                ...(args.confirmationTimeoutMs === undefined
+                    ? {}
+                    : { confirmationTimeoutMs: args.confirmationTimeoutMs }),
+            });
+            makerQuickstartPreparations.delete(args.makerControlId);
+            return toolResult(response, `${response.product} is confirmed ${response.operation.action === "cancel" ? "stopped" : "live"} on ${response.market.label}.`);
+        });
+    });
+    const makerStrandPrepare = registerTool("strata_market_making_strand_prepare", {
         title: "Prepare Strata Strand control",
         description: "Build one exact unsigned maker-owned Strand transaction. Every exposure and level size is expressed in base-asset atoms, never lots or whole tokens. Verify and sign it externally with the maker wallet, then submit it with the Strand submit tool.",
         inputSchema: {
@@ -1516,7 +1690,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.marketMaking.strand.prepare(args.marketId, request);
         return toolResult(response, `Prepared ${response.action} control ${response.maker_control_id}; verify and sign only this transaction with ${response.maker_wallet} before ${response.expires_at_ms}.`);
     }));
-    const makerStrandSubmit = server.registerTool("strata_market_making_strand_submit", {
+    const makerStrandSubmit = registerTool("strata_market_making_strand_submit", {
         title: "Submit Strata Strand control",
         description: "Submit the exact externally maker-signed Strand transaction with a stable retry key.",
         inputSchema: {
@@ -1539,9 +1713,9 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, `Submitted ${response.action} as ${response.signature}.`);
     }));
-    const makerCurrentPrepare = server.registerTool("strata_market_making_current_prepare", {
+    const makerCurrentPrepare = registerTool("strata_market_making_current_prepare", {
         title: "Prepare Strata Current control",
-        description: "Build one exact unsigned maker-owned Current transaction. Upsert fails closed until the market has a verified on-chain reference; cancel does not need that reference.",
+        description: "Build one exact unsigned maker-owned Current transaction. Upsert prices its bands from the market's live Strata mark; cancel remains available independently.",
         inputSchema: {
             marketId: z.string().regex(/^market_[0-9a-f]{32}$/),
             action: z.enum(["upsert", "cancel"]),
@@ -1599,7 +1773,7 @@ export async function createStrataMcpServer(options = {}) {
         const response = await platformClient.marketMaking.current.prepare(args.marketId, request);
         return toolResult(response, `Prepared ${response.action} control ${response.maker_control_id}; verify and sign only this transaction with ${response.maker_wallet} before ${response.expires_at_ms}.`);
     }));
-    const makerCurrentSubmit = server.registerTool("strata_market_making_current_submit", {
+    const makerCurrentSubmit = registerTool("strata_market_making_current_submit", {
         title: "Submit Strata Current control",
         description: "Submit the exact externally maker-signed Current transaction with a stable retry key.",
         inputSchema: {
@@ -1622,8 +1796,8 @@ export async function createStrataMcpServer(options = {}) {
         });
         return toolResult(response, `Submitted ${response.action} as ${response.signature}.`);
     }));
-    registerAutonomyTools(server, client, platformClient, options.sessionAutonomy, () => typeof Date !== "undefined" ? Date.now() : 0);
-    const handles = {
+    registerAutonomyTools(registerTool, client, platformClient, options.sessionAutonomy, () => typeof Date !== "undefined" ? Date.now() : 0);
+    void [
         markets,
         quote,
         exactOutputQuote,
@@ -1634,17 +1808,23 @@ export async function createStrataMcpServer(options = {}) {
         orderPrepare,
         orderSubmit,
         orderStatus,
+        makerPrepare,
+        makerSubmitAndWait,
         makerStrandPrepare,
         makerStrandSubmit,
         makerCurrentPrepare,
         makerCurrentSubmit,
-    };
-    applyCapabilityCatalog(handles, initialCatalog);
+    ];
+    applyToolAvailability(registeredTools, initialCatalog, initialPlatformCatalog);
     let closed = false;
     const refresh = async () => {
         if (closed)
             return;
-        applyCapabilityCatalog(handles, await client.capabilities());
+        const [catalog, platformCatalog] = await Promise.all([
+            client.capabilities(),
+            platformClient.discovery.read(),
+        ]);
+        applyToolAvailability(registeredTools, catalog, platformCatalog);
     };
     const timer = setInterval(() => {
         refresh().catch((error) => {
@@ -1662,10 +1842,10 @@ export async function createStrataMcpServer(options = {}) {
         },
     };
 }
-function registerAutonomyTools(server, client, platformClient, autonomy, nowMs) {
+function registerAutonomyTools(registerTool, client, platformClient, autonomy, nowMs) {
     // Always present, always read-only: the agent may show the slider and offer
     // to change it, but nothing it calls can raise its own autonomy.
-    server.registerTool("strata_autonomy", {
+    registerTool("strata_autonomy", {
         title: "Strata session autonomy",
         description: "Read how much this MCP may finish by itself: the autonomy level (ask / limits / instant), "
             + "any USD ceilings, and how to change it. Read-only — the level is the user's, set out-of-band "
@@ -1730,7 +1910,7 @@ function registerAutonomyTools(server, client, platformClient, autonomy, nowMs)
     };
     const refuse = (reason, prepared, summary) => toolResult({ executed: false, reason, prepared }, summary);
     // ── one-shot immediate execution from a fresh Sonar quote ─────────────────
-    server.registerTool("strata_execute_quote", {
+    registerTool("strata_execute_quote", {
         title: "Execute a Strata quote",
         description: "Take a fresh Sonar quote and, within the autonomy slider, sign it with the session key and "
             + "submit it in one call. Under \"ask\" (or over a \"limits\" ceiling) it does not sign — it returns "
@@ -1775,7 +1955,7 @@ function registerAutonomyTools(server, client, platformClient, autonomy, nowMs)
         return toolResult({ executed: true, receipt, notional_usd: notional }, `Executed ${quote.side} on ${quote.market_id} as ${receipt.signature}.`);
     }));
     // ── one-shot order control (place / cancel / replace / batch) ─────────────
-    server.registerTool("strata_order_execute", {
+    registerTool("strata_order_execute", {
         title: "Execute a Strata order control",
         description: "Place, cancel, replace, or batch orders and, within the autonomy slider, sign with the session "
             + "key and submit in one call. Owner wallet and session key come from the configured session. "
@@ -1837,7 +2017,7 @@ function registerAutonomyTools(server, client, platformClient, autonomy, nowMs)
         return toolResult({ executed: true, receipt, notional_usd: notional }, `Executed ${receipt.action} control ${receipt.order_control_id} as ${receipt.signature}.`);
     }));
     // ── one-shot TWAP (schedule / cancel) ─────────────────────────────────────
-    server.registerTool("strata_twap_execute", {
+    registerTool("strata_twap_execute", {
         title: "Execute a Strata TWAP",
         description: "Schedule or cancel a TWAP and, within the autonomy slider, sign with the session key and submit "
             + "in one call. Owner wallet and session key come from the configured session. Under \"ask\" (or over "
@@ -1860,7 +2040,7 @@ function registerAutonomyTools(server, client, platformClient, autonomy, nowMs)
             idempotentHint: false,
             openWorldHint: true,
         },
-    }, async (args) => guardedTool(client, "algos.submit", async () => {
+    }, async (args) => safeTool(async () => {
         let operation;
         if (args.action === "cancel") {
             if (args.twapId === undefined)
@@ -1909,23 +2089,36 @@ function registerAutonomyTools(server, client, platformClient, autonomy, nowMs)
         return toolResult({ executed: true, receipt, notional_usd: notional }, `Executed TWAP ${receipt.twap_control_id} as ${receipt.signature}.`);
     }));
 }
-function applyCapabilityCatalog(handles, catalog) {
-    setToolEnabled(handles.markets, capabilityAvailable(catalog, "markets.read"));
-    setToolEnabled(handles.quote, capabilityAvailable(catalog, "quotes.read"));
-    setToolEnabled(handles.exactOutputQuote, capabilityAvailable(catalog, "quotes.read"));
-    setToolEnabled(handles.executionChallenge, capabilityAvailable(catalog, "trade.prepare"));
-    setToolEnabled(handles.executionPrepare, capabilityAvailable(catalog, "trade.prepare"));
-    setToolEnabled(handles.executionSubmit, capabilityAvailable(catalog, "trade.submit"));
-    setToolEnabled(handles.orderChallenge, capabilityAvailable(catalog, "orders.prepare"));
-    setToolEnabled(handles.orderPrepare, capabilityAvailable(catalog, "orders.prepare"));
-    setToolEnabled(handles.orderSubmit, capabilityAvailable(catalog, "orders.submit"));
-    setToolEnabled(handles.orderStatus, capabilityAvailable(catalog, "orders.submit"));
-    const strandEnabled = capabilityAvailable(catalog, "mm.strand.manage");
-    setToolEnabled(handles.makerStrandPrepare, strandEnabled);
-    setToolEnabled(handles.makerStrandSubmit, strandEnabled);
-    const currentEnabled = capabilityAvailable(catalog, "mm.current.manage");
-    setToolEnabled(handles.makerCurrentPrepare, currentEnabled);
-    setToolEnabled(handles.makerCurrentSubmit, currentEnabled);
+function trackedToolRegistrar(server) {
+    const handles = new Map();
+    const register = server.registerTool.bind(server);
+    const registerTool = ((...args) => {
+        const tool = register(...args);
+        const name = args[0];
+        if (typeof name === "string")
+            handles.set(name, tool);
+        return tool;
+    });
+    return { registerTool, handles };
+}
+function platformCapabilityAvailable(catalog, id) {
+    return catalog.capabilities.some((capability) => capability.id === id
+        && capability.transports.includes("mcp")
+        && capability.mcp_exposure !== "none");
+}
+function requirementAvailable(requirement, available) {
+    if (requirement === undefined)
+        return true;
+    return requirement.match === "any"
+        ? requirement.ids.some(available)
+        : requirement.ids.every(available);
+}
+function applyToolAvailability(handles, catalog, platformCatalog) {
+    for (const [name, tool] of handles) {
+        const legacyAvailable = requirementAvailable(LEGACY_TOOL_CAPABILITIES[name], (id) => capabilityAvailable(catalog, id));
+        const platformAvailable = requirementAvailable(PLATFORM_TOOL_CAPABILITIES[name], (id) => platformCapabilityAvailable(platformCatalog, id));
+        setToolEnabled(tool, legacyAvailable && platformAvailable);
+    }
 }
 function setToolEnabled(tool, enabled) {
     if (enabled)
@@ -1948,6 +2141,17 @@ async function guardedTool(client, capabilityId, operation) {
         return toolError("request_failed", safeMessage(error), true);
     }
 }
+async function safeTool(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof StrataApiError) {
+            return toolError(error.code, error.message, error.retryable);
+        }
+        return toolError("request_failed", safeMessage(error), true);
+    }
+}
 /**
  * One line that keeps the two numbers apart: price impact is measured from the
  * book; the tolerance is the caller's own floor.

package/package.json

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