@stratabook/mcp 0.1.5 → 0.1.7

package/README.md

@@ -1,136 +1,16 @@
-<p align="center">
-  <img src="./assets/readme-hero.svg" alt="Strata — The deepest book in DeFi." width="100%" />
-</p>
+# Strata MCP
 
-<h1 align="center">Strata MCP</h1>
+Official capability-gated MCP access to Strata and Sonar. The server is a thin adapter
+over `@stratabook/sdk`: it follows the live capability catalog and contains no
+private execution logic.
 
-<p align="center">
-  Put live Strata markets and Sonar pricing inside any MCP-compatible agent.
-</p>
-
-<p align="center">
-  <a href="https://stratabook.org/docs/agent-mcp">Documentation</a>
-  ·
-  <a href="https://github.com/alsk1992/strata-sdk-ts">TypeScript</a>
-  ·
-  <a href="https://github.com/alsk1992/strata-agent-skills">Agent Skills</a>
-  ·
-  <a href="https://stratabook.app">Strata</a>
-</p>
-
-One hosted connection gives an agent current market availability and
-decision-ready quotes from Sonar—Strata's unified liquidity and matching
-system. No local daemon is required.
-
-## Connect
-
-Add Strata as a Streamable HTTP server:
-
-```json
-{
-  "mcpServers": {
-    "strata": {
-      "type": "streamable-http",
-      "url": "https://api.stratabook.app/mcp"
-    }
-  }
-}
-```
-
-That is the complete hosted setup. Once connected, the client discovers the
-Strata tools currently available to it.
-
-## See Strata answer from a terminal
-
-Use the official MCP Inspector (Node.js 22.7.5+) to list the hosted tools:
-
-```sh
-npx -y @modelcontextprotocol/inspector --cli \
-  https://api.stratabook.app/mcp \
-  --transport http \
-  --method tools/list
-```
-
-Call Strata directly:
-
-```sh
-npx -y @modelcontextprotocol/inspector --cli \
-  https://api.stratabook.app/mcp \
-  --transport http \
-  --method tools/call \
-  --tool-name strata_markets \
-  --tool-arg includePaused=false
-```
-
-Request a live Sonar quote through the same connection:
+## Local stdio
 
 ```sh
-npx -y @modelcontextprotocol/inspector --cli \
-  https://api.stratabook.app/mcp \
-  --transport http \
-  --method tools/call \
-  --tool-name strata_quote \
-  --tool-arg market=SOL/USDC \
-  --tool-arg side=sell \
-  --tool-arg 'amountInAtoms="10000000"'
+npx -y @stratabook/mcp
 ```
 
-The response is structured data, ready for terminals, scripts, and agents.
-
-## What lands in the agent
-
-| Tool | Result |
-| --- | --- |
-| `strata_capabilities` | The Strata features available in the current session |
-| `strata_markets` | Markets, token decimals, and current Sonar quote readiness |
-| `strata_quote` | Expected output, consumed input, fees, minimum output, price impact, and expiry |
-
-### A Sonar quote call
-
-```json
-{
-  "market": "SOL/USDC",
-  "side": "sell",
-  "amountInAtoms": "10000000"
-}
-```
-
-The result gives an agent the economics it needs to reason clearly:
-
-```json
-{
-  "provider": "Sonar",
-  "amount_in_consumed_atoms": "10000000",
-  "amount_out_atoms": "1990000",
-  "minimum_output_atoms": "1990000",
-  "output_fee_atoms": "995",
-  "reference_price": "199.1",
-  "price_impact_pct": "0.0005"
-}
-```
-
-The values above use the repository's versioned example fixture. Live quotes
-also include a unique quote ID and authoritative expiry.
-
-Sonar handles the market. Your agent works with one economic result.
-
-### Execution tolerance
-
-Quotes default to exact output: `minimum_output_atoms` equals
-`amount_out_atoms`. An agent may explicitly provide `slippageBps` when its task
-accepts a lower minimum output. This is an execution safeguard, not an estimate
-of market depth; `price_impact_pct` reports price impact separately.
-
-## Hosted or local
-
-| | Hosted Streamable HTTP | Local stdio |
-| --- | --- | --- |
-| Start with | `https://api.stratabook.app/mcp` | `npx -y @stratabook/mcp` |
-| Best for | Agents with remote MCP support | Desktop clients and local toolchains |
-| You operate | Nothing | The local Node.js process |
-| Strata market data | Live | Live |
-
-Local stdio configuration:
+Example client configuration:
 
 ```json
 {
@@ -143,36 +23,64 @@ Local stdio configuration:
 }
 ```
 
-Node.js 20+ is required for the local package.
+The tools currently available are:
+
+- `strata_capabilities`
+- `strata_action_graph`
+- `strata_markets`, when `markets.read` is enabled for MCP
+- `strata_quote`, when `quotes.read` is 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_order_challenge`, when `orders.prepare` is enabled for MCP
+- `strata_order_prepare`, when `orders.prepare` is enabled for MCP
+- `strata_order_submit`, when `orders.submit` is enabled for MCP
+- `strata_order_status`, when `orders.submit` is enabled for MCP
+
+Every initialization response carries the compact Strata Agent Harness. The
+server also publishes the complete harness as the
+`strata://agent-harness/v1` resource and provides a `strata_start` prompt for
+applying it to one concrete objective.
+The live executable topology is also available as
+`strata://action-graph/v1`.
+
+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.
+
+## Hosted Streamable HTTP
+
+The managed public endpoint is:
+
+```text
+https://api.stratabook.app/mcp
+```
 
-## Self-host Streamable HTTP
+For a self-hosted or development process:
 
 ```sh
-npx -y @stratabook/mcp \
-  --transport http \
-  --host 127.0.0.1 \
-  --port 8787
+strata-mcp --transport http --port 8787
 ```
 
-The server binds to loopback by default. Add TLS, authentication, and rate
-limiting before making a self-hosted instance remotely accessible.
-
-## Built for exact automation
-
-- Token values stay as atomic-unit decimal strings.
-- Quote expiry and minimum output remain explicit fields.
-- The tool set follows what Strata currently makes available.
-- Errors include stable codes and retryability hints.
+Place TLS and request limiting in front of `/mcp`. Loopback is the default bind;
+the official MCP HTTP helper enforces Host validation for local installations.
 
-`0.1.x` provides market discovery and read-only Sonar quotes. It cannot prepare,
-sign, or submit transactions and never asks for wallet or private-key material.
+`GET /health` is a readiness check, not a shallow process-liveness response. It
+validates the live capability catalog against the bundled public contract and
+agent harness. A stale SDK or incompatible contract therefore returns `503` and
+blocks release activation. The same process serves the reviewed discovery
+manifest at `/.well-known/strata-agent.json` and the graph at
+`/.well-known/strata-action-graph.json`.
 
-## Resources
+## Safety
 
-- [Agent quick start](https://stratabook.org/docs/hello-agents)
-- [MCP documentation](https://stratabook.org/docs/agent-mcp)
-- [TypeScript SDK](https://github.com/alsk1992/strata-sdk-ts)
-- [Issues and feature requests](https://github.com/alsk1992/strata-mcp/issues)
-- [Security policy](SECURITY.md)
+The external agent owner decides what its agent may do and configures its
+signer. MCP can request authorization bytes, prepare quote-bound trades or
+resting-order controls, and submit the externally signed result. It accepts
+public keys, detached signatures, and signed transactions, never private keys,
+seed phrases, or wallet secrets. Amounts are token atoms encoded as base-10
+strings.
 
-Licensed under either [Apache-2.0](LICENSE-APACHE) or [MIT](LICENSE-MIT).
+Quotes default to zero execution tolerance. An agent can request a non-zero
+`slippageBps` explicitly when its task accepts a lower minimum output; price
+impact remains a separate measure of current market depth.

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

@@ -15,7 +15,7 @@ export declare const STRATA_AGENT_HARNESS: {
         readonly manifest: "https://api.stratabook.app/.well-known/strata-agent.json";
     };
     readonly interfaces: {
-        readonly mcp_tool_order: readonly ["strata_capabilities", "strata_action_graph", "strata_markets", "strata_quote", "strata_execution_challenge", "strata_execution_prepare", "strata_execution_submit"];
+        readonly mcp_tool_order: readonly ["strata_capabilities", "strata_action_graph", "strata_markets", "strata_quote", "strata_execution_challenge", "strata_execution_prepare", "strata_execution_submit", "strata_order_challenge", "strata_order_prepare", "strata_order_submit", "strata_order_status"];
         readonly terminal: readonly ["npx -y @stratabook/sdk capabilities --json", "npx -y @stratabook/sdk action-graph --json", "npx -y @stratabook/sdk markets --json", "npx -y @stratabook/sdk quote --market SOL/USDC --side sell --amount-atoms 10000000 --json"];
     };
     readonly workflow: readonly [{
@@ -50,10 +50,10 @@ export declare const STRATA_AGENT_HARNESS: {
         readonly instruction: "Report consumed input, expected output, minimum output, fees by asset side, price impact, and remaining validity.";
     }, {
         readonly id: "authorize_writes";
-        readonly instruction: "When prepare and submit are exposed, keep signing external to Strata: request canonical authorization bytes, sign them with the owner-configured signer, verify the prepared transaction preserves the quote, then submit the externally signed transaction with idempotency.";
+        readonly instruction: "When prepare and submit are exposed, keep signing external to Strata: request canonical authorization bytes, sign them with the owner-configured signer, verify the prepared transaction preserves the quote or exact opaque order set, then submit the externally signed transaction with idempotency. Resting-order control uses place, cancel, or cancel-all and cancel-all is atomically bounded to six orders per call.";
     }, {
         readonly id: "monitor_outcome";
-        readonly instruction: "After an authorized submission, report the durable receipt or explicit failure. Never claim completion from preparation, signing, or an unconfirmed request.";
+        readonly instruction: "After an authorized submission, report the durable receipt or explicit failure. If the request times out or either process restarts, recover it with the same control ID and idempotency key. Never claim completion from preparation, signing, or an unconfirmed request.";
     }];
     readonly stop_conditions: readonly ["The required live capability is disabled or absent.", "The market is paused, unavailable, or has no reviewed operation path.", "Market, side, amount, decimals, tolerance, or signer authority is unavailable or ambiguous.", "The contract version is unsupported or a response contains unknown fields.", "A quote is expired or its market, side, amount, fee, minimum-output, or time binding is inconsistent.", "A requested operation exceeds the exposed tool, account, or policy scope.", "A user asks the agent to receive or expose wallet secrets, private keys, seed phrases, session keys, or production credentials."];
     readonly safety_rules: readonly ["Never request or accept wallet secrets, private keys, seed phrases, session keys, or production credentials in a prompt.", "Never call undocumented endpoints or reconstruct private Sonar behavior.", "Never silently widen slippage, refresh changed economics, substitute a market, or retry a non-retryable failure.", "Treat capability removal, revocation, expiry, and emergency disable as immediate stop signals.", "Capability and action-graph availability are authoritative for Strata operations; permission and signer policy remain controlled by the external agent owner."];
@@ -270,6 +270,68 @@ export declare const STRATA_ACTION_GRAPH: {
         readonly summary: "Receive the execution ID, Solana signature, and submitted status.";
         readonly required_capabilities: readonly [];
         readonly available: true;
+    }, {
+        readonly id: "request_order_challenge";
+        readonly kind: "prepare";
+        readonly summary: "Bind a product-level place, cancel, or cancel-all operation to canonical authorization bytes.";
+        readonly required_capabilities: readonly ["orders.prepare"];
+        readonly available: false;
+        readonly operation: {
+            readonly method: "POST";
+            readonly path: "/v2/markets/{market_id}/orders/challenge";
+            readonly mcp_tool: "strata_order_challenge";
+        };
+    }, {
+        readonly id: "sign_order_authorization";
+        readonly kind: "external_signature";
+        readonly summary: "The agent owner's configured session signer verifies the exact order set and signs externally.";
+        readonly required_capabilities: readonly [];
+        readonly available: true;
+    }, {
+        readonly id: "prepare_order_control";
+        readonly kind: "prepare";
+        readonly summary: "Exchange the order authorization signature for a partially signed transaction.";
+        readonly required_capabilities: readonly ["orders.prepare"];
+        readonly available: false;
+        readonly operation: {
+            readonly method: "POST";
+            readonly path: "/v2/markets/{market_id}/orders/prepare";
+            readonly mcp_tool: "strata_order_prepare";
+        };
+    }, {
+        readonly id: "sign_order_transaction";
+        readonly kind: "external_signature";
+        readonly summary: "The external session signer verifies and fills only its transaction signature slot.";
+        readonly required_capabilities: readonly [];
+        readonly available: true;
+    }, {
+        readonly id: "submit_order_control";
+        readonly kind: "submit";
+        readonly summary: "Submit the unchanged signed order transaction with an idempotency key.";
+        readonly required_capabilities: readonly ["orders.submit"];
+        readonly available: false;
+        readonly operation: {
+            readonly method: "POST";
+            readonly path: "/v2/markets/{market_id}/orders/submit";
+            readonly mcp_tool: "strata_order_submit";
+        };
+    }, {
+        readonly id: "receive_order_receipt";
+        readonly kind: "receipt";
+        readonly summary: "Receive the opaque order IDs, transaction signature, and submitted status.";
+        readonly required_capabilities: readonly [];
+        readonly available: true;
+    }, {
+        readonly id: "recover_order_status";
+        readonly kind: "read";
+        readonly summary: "Recover durable submitting, submitted, or failed status after a timeout or restart.";
+        readonly required_capabilities: readonly ["orders.submit"];
+        readonly available: false;
+        readonly operation: {
+            readonly method: "POST";
+            readonly path: "/v2/markets/{market_id}/orders/status";
+            readonly mcp_tool: "strata_order_status";
+        };
     }];
     readonly edges: readonly [{
         readonly from: "discover_capabilities";
@@ -351,7 +413,39 @@ export declare const STRATA_ACTION_GRAPH: {
         readonly from: "submit_execution";
         readonly to: "receive_receipt";
         readonly condition: "the execution ID and idempotency key match";
+    }, {
+        readonly from: "discover_platform_markets";
+        readonly to: "request_order_challenge";
+        readonly condition: "orders.prepare is enabled and the market accepts order control";
+    }, {
+        readonly from: "request_order_challenge";
+        readonly to: "sign_order_authorization";
+        readonly condition: "the action and exact opaque order set match owner intent";
+    }, {
+        readonly from: "sign_order_authorization";
+        readonly to: "prepare_order_control";
+        readonly condition: "a valid external authorization signature is available";
+    }, {
+        readonly from: "prepare_order_control";
+        readonly to: "sign_order_transaction";
+        readonly condition: "the prepared transaction preserves the signed order bindings";
+    }, {
+        readonly from: "sign_order_transaction";
+        readonly to: "submit_order_control";
+        readonly condition: "orders.submit is enabled and the signed transaction is unmodified";
+    }, {
+        readonly from: "submit_order_control";
+        readonly to: "receive_order_receipt";
+        readonly condition: "the control ID and idempotency key match";
+    }, {
+        readonly from: "submit_order_control";
+        readonly to: "recover_order_status";
+        readonly condition: "the submission result is ambiguous or either process restarted";
+    }, {
+        readonly from: "recover_order_status";
+        readonly to: "receive_order_receipt";
+        readonly condition: "durable status is submitted";
     }];
 };
 export declare const STRATA_ACTION_GRAPH_URI = "strata://action-graph/v1";
-export declare const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata Agent Harness 1.0. Start every objective with strata_capabilities, then strata_action_graph, then strata_markets. Read strata://agent-harness/v1 and strata://action-graph/v1. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Resolve the market, side, exact input atoms, and tolerance before strata_quote. Treat amounts as unsigned base-10 token atoms; check quote bindings, labelled fees, minimum output, and expiry. To execute: request a challenge, sign its canonical authorization bytes externally, prepare, verify and sign the returned transaction externally, then submit with idempotency. Stop on ambiguity, unavailable capabilities, paused markets, unsupported contracts, inconsistent bindings, expiry, or missing signer authority.";
+export declare const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata Agent Harness 1.0. Start every objective with strata_capabilities, then strata_action_graph, then strata_markets. Read strata://agent-harness/v1 and strata://action-graph/v1. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Resolve the market, side, exact input atoms, and tolerance before strata_quote. Treat amounts as unsigned base-10 token atoms; check quote bindings, labelled fees, minimum output, and expiry. To execute or control a resting order: request a challenge, verify its quote or exact opaque order bindings, sign canonical authorization bytes externally, prepare, verify and sign the returned transaction externally, then submit with idempotency. If order submission is ambiguous, recover durable status with the same control ID and idempotency key. Cancel-all is atomically bounded to six orders per call. Stop on ambiguity, unavailable capabilities, paused markets, unsupported contracts, inconsistent bindings, expiry, or missing signer authority.";

package/dist/src/generated-harness.js

@@ -23,7 +23,11 @@ export const STRATA_AGENT_HARNESS = {
             "strata_quote",
             "strata_execution_challenge",
             "strata_execution_prepare",
-            "strata_execution_submit"
+            "strata_execution_submit",
+            "strata_order_challenge",
+            "strata_order_prepare",
+            "strata_order_submit",
+            "strata_order_status"
         ],
         "terminal": [
             "npx -y @stratabook/sdk capabilities --json",
@@ -75,11 +79,11 @@ export const STRATA_AGENT_HARNESS = {
         },
         {
             "id": "authorize_writes",
-            "instruction": "When prepare and submit are exposed, keep signing external to Strata: request canonical authorization bytes, sign them with the owner-configured signer, verify the prepared transaction preserves the quote, then submit the externally signed transaction with idempotency."
+            "instruction": "When prepare and submit are exposed, keep signing external to Strata: request canonical authorization bytes, sign them with the owner-configured signer, verify the prepared transaction preserves the quote or exact opaque order set, then submit the externally signed transaction with idempotency. Resting-order control uses place, cancel, or cancel-all and cancel-all is atomically bounded to six orders per call."
         },
         {
             "id": "monitor_outcome",
-            "instruction": "After an authorized submission, report the durable receipt or explicit failure. Never claim completion from preparation, signing, or an unconfirmed request."
+            "instruction": "After an authorized submission, report the durable receipt or explicit failure. If the request times out or either process restarts, recover it with the same control ID and idempotency key. Never claim completion from preparation, signing, or an unconfirmed request."
         }
     ],
     "stop_conditions": [
@@ -360,6 +364,83 @@ export const STRATA_ACTION_GRAPH = {
             "summary": "Receive the execution ID, Solana signature, and submitted status.",
             "required_capabilities": [],
             "available": true
+        },
+        {
+            "id": "request_order_challenge",
+            "kind": "prepare",
+            "summary": "Bind a product-level place, cancel, or cancel-all operation to canonical authorization bytes.",
+            "required_capabilities": [
+                "orders.prepare"
+            ],
+            "available": false,
+            "operation": {
+                "method": "POST",
+                "path": "/v2/markets/{market_id}/orders/challenge",
+                "mcp_tool": "strata_order_challenge"
+            }
+        },
+        {
+            "id": "sign_order_authorization",
+            "kind": "external_signature",
+            "summary": "The agent owner's configured session signer verifies the exact order set and signs externally.",
+            "required_capabilities": [],
+            "available": true
+        },
+        {
+            "id": "prepare_order_control",
+            "kind": "prepare",
+            "summary": "Exchange the order authorization signature for a partially signed transaction.",
+            "required_capabilities": [
+                "orders.prepare"
+            ],
+            "available": false,
+            "operation": {
+                "method": "POST",
+                "path": "/v2/markets/{market_id}/orders/prepare",
+                "mcp_tool": "strata_order_prepare"
+            }
+        },
+        {
+            "id": "sign_order_transaction",
+            "kind": "external_signature",
+            "summary": "The external session signer verifies and fills only its transaction signature slot.",
+            "required_capabilities": [],
+            "available": true
+        },
+        {
+            "id": "submit_order_control",
+            "kind": "submit",
+            "summary": "Submit the unchanged signed order transaction with an idempotency key.",
+            "required_capabilities": [
+                "orders.submit"
+            ],
+            "available": false,
+            "operation": {
+                "method": "POST",
+                "path": "/v2/markets/{market_id}/orders/submit",
+                "mcp_tool": "strata_order_submit"
+            }
+        },
+        {
+            "id": "receive_order_receipt",
+            "kind": "receipt",
+            "summary": "Receive the opaque order IDs, transaction signature, and submitted status.",
+            "required_capabilities": [],
+            "available": true
+        },
+        {
+            "id": "recover_order_status",
+            "kind": "read",
+            "summary": "Recover durable submitting, submitted, or failed status after a timeout or restart.",
+            "required_capabilities": [
+                "orders.submit"
+            ],
+            "available": false,
+            "operation": {
+                "method": "POST",
+                "path": "/v2/markets/{market_id}/orders/status",
+                "mcp_tool": "strata_order_status"
+            }
         }
     ],
     "edges": [
@@ -462,8 +543,48 @@ export const STRATA_ACTION_GRAPH = {
             "from": "submit_execution",
             "to": "receive_receipt",
             "condition": "the execution ID and idempotency key match"
+        },
+        {
+            "from": "discover_platform_markets",
+            "to": "request_order_challenge",
+            "condition": "orders.prepare is enabled and the market accepts order control"
+        },
+        {
+            "from": "request_order_challenge",
+            "to": "sign_order_authorization",
+            "condition": "the action and exact opaque order set match owner intent"
+        },
+        {
+            "from": "sign_order_authorization",
+            "to": "prepare_order_control",
+            "condition": "a valid external authorization signature is available"
+        },
+        {
+            "from": "prepare_order_control",
+            "to": "sign_order_transaction",
+            "condition": "the prepared transaction preserves the signed order bindings"
+        },
+        {
+            "from": "sign_order_transaction",
+            "to": "submit_order_control",
+            "condition": "orders.submit is enabled and the signed transaction is unmodified"
+        },
+        {
+            "from": "submit_order_control",
+            "to": "receive_order_receipt",
+            "condition": "the control ID and idempotency key match"
+        },
+        {
+            "from": "submit_order_control",
+            "to": "recover_order_status",
+            "condition": "the submission result is ambiguous or either process restarted"
+        },
+        {
+            "from": "recover_order_status",
+            "to": "receive_order_receipt",
+            "condition": "durable status is submitted"
         }
     ]
 };
 export const STRATA_ACTION_GRAPH_URI = "strata://action-graph/v1";
-export const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata Agent Harness 1.0. Start every objective with strata_capabilities, then strata_action_graph, then strata_markets. Read strata://agent-harness/v1 and strata://action-graph/v1. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Resolve the market, side, exact input atoms, and tolerance before strata_quote. Treat amounts as unsigned base-10 token atoms; check quote bindings, labelled fees, minimum output, and expiry. To execute: request a challenge, sign its canonical authorization bytes externally, prepare, verify and sign the returned transaction externally, then submit with idempotency. Stop on ambiguity, unavailable capabilities, paused markets, unsupported contracts, inconsistent bindings, expiry, or missing signer authority.";
+export const STRATA_AGENT_HARNESS_INSTRUCTIONS = "Strata Agent Harness 1.0. Start every objective with strata_capabilities, then strata_action_graph, then strata_markets. Read strata://agent-harness/v1 and strata://action-graph/v1. The external agent owner controls permission and signer authority. Strata accepts public keys, detached signatures, and signed transactions, never private keys or seed phrases. Resolve the market, side, exact input atoms, and tolerance before strata_quote. Treat amounts as unsigned base-10 token atoms; check quote bindings, labelled fees, minimum output, and expiry. To execute or control a resting order: request a challenge, verify its quote or exact opaque order bindings, sign canonical authorization bytes externally, prepare, verify and sign the returned transaction externally, then submit with idempotency. If order submission is ambiguous, recover durable status with the same control ID and idempotency key. Cancel-all is atomically bounded to six orders per call. Stop on ambiguity, unavailable capabilities, paused markets, unsupported contracts, inconsistent bindings, expiry, or missing signer authority.";

package/dist/src/server.d.ts

@@ -1,9 +1,10 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StrataClient, type CapabilityCatalog } from "@stratabook/sdk";
+import { StrataClient, StrataPlatformClient, type CapabilityCatalog } from "@stratabook/sdk";
 export interface StrataMcpOptions {
     apiBase?: string;
     timeoutMs?: number;
     client?: StrataClient;
+    platformClient?: StrataPlatformClient;
 }
 export interface StrataMcpRuntime {
     server: McpServer;

package/dist/src/server.js

@@ -1,5 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { DEFAULT_SLIPPAGE_BPS, StrataApiError, StrataClient, } from "@stratabook/sdk";
+import { DEFAULT_SLIPPAGE_BPS, StrataApiError, StrataClient, StrataPlatformClient, } from "@stratabook/sdk";
 import * as z from "zod/v4";
 import { STRATA_AGENT_HARNESS, STRATA_AGENT_HARNESS_INSTRUCTIONS, STRATA_AGENT_HARNESS_URI, STRATA_ACTION_GRAPH_URI, } from "./generated-harness.js";
 import { SERVER_VERSION } from "./version.js";
@@ -33,6 +33,10 @@ export async function probeStrataMcpReadiness(options = {}) {
 }
 export async function createStrataMcpServer(options = {}) {
     const client = strataClient(options);
+    const platformClient = options.platformClient ?? new StrataPlatformClient({
+        apiBase: options.apiBase,
+        timeoutMs: options.timeoutMs,
+    });
     const initialCatalog = await client.capabilities();
     if (initialCatalog.contract_version !== STRATA_AGENT_HARNESS.contract_version) {
         throw new Error("agent harness and live contract versions differ");
@@ -285,12 +289,152 @@ 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", {
+        title: "Strata order challenge",
+        description: "Bind a product-level place, cancel, or cancel-all request to canonical bytes for the agent owner's external signer.",
+        inputSchema: {
+            marketId: z.string().regex(/^market_[0-9a-f]{32}$/),
+            action: z.enum(["place", "cancel", "cancel_all"]),
+            ownerWallet: z.string().min(32).max(44),
+            sessionPublicKey: z.string().min(32).max(44),
+            accountSequence: z.string().regex(/^[0-9]+$/).max(20).optional(),
+            clientOrderId: z.string().min(1).max(64).regex(/^[A-Za-z0-9._-]+$/).optional(),
+            side: z.enum(["buy", "sell"]).optional(),
+            orderType: z.enum(["good_until_cancelled", "post_only"]).optional(),
+            limitPriceAtoms: z.string().regex(/^[1-9][0-9]*$/).max(20).optional(),
+            sizeAtoms: z.string().regex(/^[1-9][0-9]*$/).max(20).optional(),
+            orderId: z.string().regex(/^order_[0-9a-f]{32}$/).optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async (args) => guardedTool(client, "orders.prepare", async () => {
+        let request;
+        if (args.action === "place") {
+            if (args.accountSequence === undefined
+                || args.clientOrderId === undefined
+                || args.side === undefined
+                || args.orderType === undefined
+                || args.limitPriceAtoms === undefined
+                || args.sizeAtoms === undefined) {
+                return toolError("invalid_request", "Place requires accountSequence, clientOrderId, side, orderType, limitPriceAtoms, and sizeAtoms.", false);
+            }
+            request = {
+                action: "place",
+                ownerWallet: args.ownerWallet,
+                sessionPublicKey: args.sessionPublicKey,
+                accountSequence: args.accountSequence,
+                clientOrderId: args.clientOrderId,
+                side: args.side,
+                orderType: args.orderType,
+                limitPriceAtoms: args.limitPriceAtoms,
+                sizeAtoms: args.sizeAtoms,
+            };
+        }
+        else if (args.action === "cancel") {
+            if (args.orderId === undefined) {
+                return toolError("invalid_request", "Cancel requires orderId.", false);
+            }
+            request = {
+                action: "cancel",
+                ownerWallet: args.ownerWallet,
+                sessionPublicKey: args.sessionPublicKey,
+                orderId: args.orderId,
+            };
+        }
+        else {
+            request = {
+                action: "cancel_all",
+                ownerWallet: args.ownerWallet,
+                sessionPublicKey: args.sessionPublicKey,
+            };
+        }
+        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", {
+        title: "Prepare Strata order control",
+        description: "Exchange an externally signed order challenge for an immutable partially signed transaction.",
+        inputSchema: {
+            marketId: z.string().regex(/^market_[0-9a-f]{32}$/),
+            challengeId: z.string().regex(/^oc_[0-9a-f]{32}$/),
+            authorizationSignature: z
+                .string()
+                .min(64)
+                .max(88)
+                .regex(/^[1-9A-HJ-NP-Za-km-z]+$/),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, async ({ marketId, challengeId, authorizationSignature }) => guardedTool(client, "orders.prepare", async () => {
+        const response = await platformClient.orders.prepare(marketId, {
+            challengeId,
+            authorizationSignature,
+        });
+        return toolResult(response, `Prepared ${response.action} control ${response.order_control_id}; externally verify and sign before ${response.expires_at_ms}.`);
+    }));
+    const orderSubmit = server.registerTool("strata_order_submit", {
+        title: "Submit Strata order control",
+        description: "Submit an externally signed order transaction with a stable retry key.",
+        inputSchema: {
+            marketId: z.string().regex(/^market_[0-9a-f]{32}$/),
+            orderControlId: z.string().regex(/^or_[0-9a-f]{32}$/),
+            signedTransactionBase64: z
+                .string()
+                .min(4)
+                .max(8_192)
+                .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._-]+$/),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ marketId, orderControlId, signedTransactionBase64, idempotencyKey }) => guardedTool(client, "orders.submit", async () => {
+        const response = await platformClient.orders.submit(marketId, {
+            orderControlId,
+            signedTransactionBase64,
+            idempotencyKey,
+        });
+        return toolResult(response, `Submitted ${response.action} control ${response.order_control_id} as ${response.signature}.`);
+    }));
+    const orderStatus = server.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: {
+            marketId: z.string().regex(/^market_[0-9a-f]{32}$/),
+            orderControlId: z.string().regex(/^or_[0-9a-f]{32}$/),
+            idempotencyKey: z.string().min(1).max(64).regex(/^[A-Za-z0-9._-]+$/),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ marketId, orderControlId, idempotencyKey }) => guardedTool(client, "orders.submit", async () => {
+        const response = await platformClient.orders.status(marketId, { orderControlId, idempotencyKey });
+        return toolResult(response, `Order control ${response.order_control_id} is ${response.status}.`);
+    }));
     const handles = {
         markets,
         quote,
         executionChallenge,
         executionPrepare,
         executionSubmit,
+        orderChallenge,
+        orderPrepare,
+        orderSubmit,
+        orderStatus,
     };
     applyCapabilityCatalog(handles, initialCatalog);
     let closed = false;
@@ -321,6 +465,10 @@ function applyCapabilityCatalog(handles, catalog) {
     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"));
 }
 function setToolEnabled(tool, enabled) {
     if (enabled)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stratabook/mcp",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "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.1.4",
+    "@stratabook/sdk": "0.1.6",
     "zod": "^3.25.76"
   },
   "devDependencies": {