@cmdoss/suipay-mcp 0.2.2-dev.9 → 0.3.0-dev.0

package/dist/http.d.ts

@@ -1,11 +1,3 @@
-export { r as handleSuipayMcpHttpRequest } from './http-RP-Xlg60.js';
-import '@cmdoss/suipay-core/policy/grant-target';
-import '@cmdoss/suipay-sdk/mcp/access-context';
-import '@cmdoss/suipay-sdk/buyer/settlement-dto';
+export { H as handleSuipayMcpHttpRequest } from './http-BCFfQFIg.js';
 import '@modelcontextprotocol/sdk/server/index.js';
-import '@cmdoss/suipay-sdk/agent-sdk/reads';
-import '@cmdoss/suipay-sdk/delegated-signer/payer';
-import '@cmdoss/suipay-core/trace/types';
-import '@cmdoss/suipay-sdk/protocol/paid-http-request';
-import '@cmdoss/suipay-sdk/protocol/types';
-import '@cmdoss/suipay-sdk/pay-operation';
+import '@mysten/sui/keypairs/ed25519';

package/dist/http.js

@@ -1,6 +1,6 @@
 import {
   handleSuipayMcpHttpRequest
-} from "./chunk-NDJ7BFI4.js";
+} from "./chunk-FKDC22O6.js";
 export {
   handleSuipayMcpHttpRequest
 };

package/dist/index.d.ts

@@ -1,18 +1,15 @@
-import { Wallet } from '@cmdoss/suipay-core/chain/types';
-import { S as SpendAccountSigningRequest, M as McpConfig, a as McpAuthContext, b as McpTraceHooks, c as SpendAccountPayDeps } from './http-RP-Xlg60.js';
-export { A as AgentHeldResolver, d as AgentHeldSettlement, e as MCP_TARGET_PRESETS, f as McpEnvelope, g as McpEnvelopeEntry, h as McpServerOptions, i as McpTarget, j as McpTraceContext, k as McpTraceRuntime, P as PACKAGE_NAME, l as PreparedPayment, m as SpendAccountPrepareResult, n as SpendAccountPrepareSession, T as TOOLS, o as buildSpendAccountPayKind, p as canonicalMcpRequestId, q as createServer, r as handleSuipayMcpHttpRequest, s as inspectMcpEnvelope, t as loadMcpConfig, u as parseMcpTargetFlag, v as prepareSpendAccountPayment, w as resetAgentHeldProcessLedger, x as resolveAgentHeldSettlement, y as resolveMcpTarget, z as sameMcpGateway, B as traceMcpHttpRequest, C as verifySpendAccountPayReconstructs } from './http-RP-Xlg60.js';
-import { GetObjectJson, createReader } from '@cmdoss/suipay-sdk/agent-sdk/reads';
-import { DelegatedKeySigner, DelegatedPayerSession, DelegatedPayerConfig, DelegatedPayerDeps, SpendIntent, DelegatedPayResult } from '@cmdoss/suipay-sdk/delegated-signer/payer';
-import { PaidHttpRequest } from '@cmdoss/suipay-sdk/protocol/paid-http-request';
-import { createPayer } from '@cmdoss/suipay-sdk/agent-sdk/delegate-agent';
+import { S as SpendAccountSigningRequest, P as PaidHttpRequest, D as DelegatedKeySigner, G as GetObjectJson, a as DelegatedPayerSession, b as DelegatedPayerConfig, c as DelegatedPayerDeps, d as SpendIntent, e as DelegatedPayResult, f as DelegationScope, C as CodeFor, N as NextAction, g as GrantPolicyBinding, h as PaymentAttemptLedger, i as DelegatedPayerLog, j as PreparedSettlementTerms, X as X402PayProgress, O as Offer, M as McpConfig, k as McpAuthContext, l as McpTraceHooks, m as SpendAccountPayDeps, n as createReader } from './http-BCFfQFIg.js';
+export { A as AgentHeldResolver, o as AgentHeldSettlement, p as MCP_TARGET_PRESETS, q as McpEnvelope, r as McpEnvelopeEntry, s as McpServerOptions, t as McpTarget, u as McpTraceContext, v as McpTraceRuntime, w as PACKAGE_NAME, x as PreparedPayment, y as SpendAccountPrepareResult, z as SpendAccountPrepareSession, T as TOOLS, B as buildSpendAccountPayKind, E as canonicalMcpRequestId, F as createServer, H as handleSuipayMcpHttpRequest, I as inspectMcpEnvelope, J as loadMcpConfig, K as parseMcpTargetFlag, L as prepareSpendAccountPayment, Q as resetAgentHeldProcessLedger, R as resolveAgentHeldSettlement, U as resolveGrantTarget, V as resolveMcpTarget, W as sameMcpGateway, Y as traceMcpHttpRequest, Z as verifySpendAccountPayReconstructs } from './http-BCFfQFIg.js';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-export { resolveGrantTarget } from '@cmdoss/suipay-core/policy/grant-target';
-import '@cmdoss/suipay-sdk/mcp/access-context';
-import '@cmdoss/suipay-sdk/buyer/settlement-dto';
 import '@modelcontextprotocol/sdk/server/index.js';
-import '@cmdoss/suipay-core/trace/types';
-import '@cmdoss/suipay-sdk/protocol/types';
-import '@cmdoss/suipay-sdk/pay-operation';
+
+/** Holds a key and signs transaction bytes. Never leaves the payer. */
+interface Wallet {
+    readonly address: string;
+    signTransaction(txBytes: string): Promise<string>;
+}
 
 interface SuiPayCredentials {
     /** 64-hex Ed25519 seed. NEVER logged. */
@@ -113,6 +110,401 @@ declare function settlePreparedMcpPayment(args: {
     intent?: SpendIntent;
 }): Promise<DelegatedPayResult>;
 
+/**
+ * The executable settlement a 402 carries so the agent needs no chain access.
+ *
+ * ADR-0016 §2 says "the server prepares, the agent verifies, the agent signs".
+ * ADR-0015 shipped only the first half: the prepare path emitted a placeholder
+ * `poolInitialSharedVersion: '1'`, so its bytes described a payment instead of
+ * executing one, and an agent still had to make two full-node reads to build
+ * something submittable. These bytes are executable — the gateway resolves the
+ * real shared-object initial versions before it builds them.
+ *
+ * This travels ALONGSIDE the offer on the 402 body, never inside it, exactly as
+ * `requestSchema` does (`src/gateway/app.ts`). The offer digest is a
+ * consensus-relevant wire shape whose fields go on chain via `terms_hash`;
+ * adding to it is a protocol change. A prepared settlement authorizes nothing
+ * on its own — it is unsigned bytes, worthless until the delegate's key signs
+ * them — so it has no business inside a signed digest.
+ *
+ * Every field here exists to let the agent REBUILD the same transaction kind
+ * offline and compare it byte for byte. Nothing here is trusted: see
+ * `verifyPreparedPayment` in `src/agent-sdk/verify-prepared-settlement.ts`
+ * for what an agent must check before it signs, and why what it can check from
+ * the 402 alone is sufficient.
+ */
+
+/** Current prepared-settlement wire version. Bumped on any shape change. */
+declare const PREPARED_SETTLEMENT_VERSION: 1;
+/**
+ * An unsigned, executable settlement transaction plus everything needed to
+ * reconstruct it offline.
+ *
+ * `transactionBytes` is the full sponsored `TransactionData` — gas is already
+ * attached by the gateway's sponsor, so this is the ONE thing the agent signs.
+ * `transactionKindBytes` is the pre-sponsor programmable-transaction kind: the
+ * Move call and nothing else, which is what the agent rebuilds and compares.
+ */
+interface PreparedSettlement {
+    version: typeof PREPARED_SETTLEMENT_VERSION;
+    /** Base64 sponsored `TransactionData`. The agent signs exactly these bytes. */
+    transactionBytes: string;
+    /** Base64 pre-sponsor transaction kind (the Move call baseline). */
+    transactionKindBytes: string;
+    /**
+     * The address that must sign. Move asserts `ctx.sender() == grant.delegate`,
+     * so an agent that checks this equals its own address has the chain enforce
+     * that the named grant is one it may draw on — no `getObject` required.
+     */
+    sender: string;
+    /** Deployed `suipay` package the call targets (normalized). */
+    packageId: string;
+    /** Fully-qualified `package::module::function` the call invokes. */
+    moveTarget: string;
+    /**
+     * Delegation scope: `open` pays an arbitrary recipient, `scoped` an
+     * allowlist. This is the SCOPE discriminator (which pay function) — distinct
+     * from the x402 eligibility (`SpendAccountGrantKind`) and the budget cap. The
+     * `'open'`/`'scoped'` value strings are a frozen wire shape (parsed by
+     * `asPreparedSettlement`); the type only names the concept.
+     */
+    accessMode: DelegationScope;
+    /** Shared `Account` the payment debits. */
+    poolObjectId: string;
+    /** Shared `Grant` naming the delegate. */
+    grantObjectId: string;
+    /** Real initial shared versions — the gap ADR-0015's placeholder `'1'` left. */
+    poolInitialSharedVersion: string;
+    grantInitialSharedVersion: string;
+    clockInitialSharedVersion: string;
+    /** On-chain policy id; `'0'` for an open grant. Decimal string (u64). */
+    policyId: string;
+    /** Coin type the call spends. Must equal the offer's asset. */
+    coinType: string;
+    /** Atomic amount the call moves. Must equal the offer's amount. */
+    amount: string;
+    /** Recipient the call pays. Must equal the offer's payTo. */
+    recipient: string;
+    /**
+     * Fresh lineage (ADR-0043 Option B): settlement is MANDATORY-guarded, so the
+     * prepared call always consumes the offer's single-use exclusion marker before
+     * funds move. These four let the agent rebuild the SAME guarded kind offline
+     * and compare it byte for byte. The `ExclusionDirectory` the offer committed
+     * to (from its `registryIdentity`), read-only.
+     */
+    exclusionDirectoryId: string;
+    /** The per-recipient `RecipientRegistry` the marker is claimed in (mutable). */
+    recipientRegistryId: string;
+    /** Real initial shared version of the exclusion directory. */
+    exclusionDirectoryInitialSharedVersion: string;
+    /** Real initial shared version of the recipient registry. */
+    recipientRegistryInitialSharedVersion: string;
+    /** Signed expiry (epoch-ms, decimal string) bound into the guarded settle. */
+    expiresAtMs: string;
+    /** Absolute URL to POST `{challengeId, signature, body}` to. */
+    payUrl: string;
+}
+
+/**
+ * Connection-manifest → SDK session bridge.
+ *
+ * The dashboard hands an agent a non-secret "Connection manifest" after it
+ * authorizes a delegate key. Historically that manifest could NOT be passed to
+ * the SDK: it named the signer `agentAddress` (not `delegateAddress`), the asset
+ * by symbol (`"USDC"`, not the full `coinType`), and its policies by off-chain
+ * UUID — while the payer needs the full coin type and each policy's NUMERIC
+ * on-chain id + target hashes (`GrantPolicyBinding`). This module closes that
+ * mismatch two ways:
+ *
+ *   1. {@link AgentConnectionManifest} — the SDK-consumable shape a corrected
+ *      console emits directly (delegate address, full coin type, numeric policy
+ *      ids + target hashes). {@link manifestToSession} turns it, plus an agent
+ *      key, into a ready `DelegatedPayerSession` — no protocol reverse-engineering
+ *      and no on-chain lookups.
+ *
+ *   2. {@link dashboardManifestToAgentManifest} — a bridge from the legacy
+ *      console shape, resolving asset→coinType and (for scoped grants) UUID→
+ *      numeric policy binding through injected resolvers.
+ *
+ * Every failure is a typed, caller-safe error (never a thrown internal): a
+ * malformed or legacy manifest that cannot be resolved fails loudly, not
+ * silently.
+ */
+
+/**
+ * A manifest or session that cannot be paid from. Nothing was signed, so the
+ * money state is always `not_charged`. Branch on `code`; `reason` names the
+ * internal check for logs.
+ */
+interface ManifestError {
+    code: CodeFor<'sdk'>;
+    detail: string;
+    paymentState: 'not_charged';
+    retryable: boolean;
+    nextAction: NextAction;
+}
+type ManifestResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: ManifestError;
+};
+/**
+ * A manifest policy binding. `onChainPolicyId` is always a validated u64 DECIMAL
+ * STRING — never a JS number — so `BigInt(onChainPolicyId)` on the money path
+ * (`spend_account::settle_policy`) is exact. A `u64` policy id can exceed `2^53`, past which
+ * a JS number loses precision and would bind the WRONG on-chain policy; carrying
+ * the string preserves every id exactly.
+ */
+type AgentPolicyBinding = Omit<GrantPolicyBinding, 'onChainPolicyId'> & {
+    onChainPolicyId: string;
+};
+/** One grant's SDK-consumable binding: everything the payer needs to settle. */
+interface AgentSessionBinding {
+    /** Display asset symbol (informational; `coinType` is authoritative). */
+    asset: string;
+    /** Full coin struct type, e.g. `0x..::usdc::USDC`. Required for pay. */
+    coinType: string;
+    poolObjectId: string;
+    grantObjectId: string;
+    /** `open` = capped, no allowlist; `scoped` = policy-bound. */
+    accessMode: 'scoped' | 'open';
+    /** Grant-level session cap (atomic); null/undefined = unlimited. */
+    sessionCap?: string | null;
+    /** Grant-level per-payment ceiling (atomic); null/undefined = unlimited. */
+    maxPerPayment?: string | null;
+    /** On-chain policy ids (u64 strings) + target hashes. Empty for open grants. */
+    policies: AgentPolicyBinding[];
+}
+/** Which grant to drive when a manifest carries several. */
+interface SessionSelector {
+    grantObjectId?: string;
+    asset?: string;
+    coinType?: string;
+}
+/** @deprecated Renamed to {@link AgentSessionBinding}. */
+type AgentGrantBinding = AgentSessionBinding;
+/** @deprecated Renamed to {@link SessionSelector}. */
+type GrantSelector = SessionSelector;
+
+/**
+ * Key + gateway URL → a ready delegated-pay session.
+ *
+ * This module is the point of `docs/decisions/ADR-0016-delegate-key-sole-agent-input.md`
+ * §1. Before it, an agent needed a connection manifest — network, package id,
+ * pool id, grant id, caps, expiry — copied out of the console at authorize time
+ * and liable to go stale the moment the owner tightened a cap or the operator
+ * rotated a package. After it, the agent is handed one secret and one URL, and
+ * everything else is resolved from the chain's own projection at startup.
+ *
+ * The order is forced by the protocol. A bootstrap signature binds `network` and
+ * `packageId`, which the gateway reconstructs from its own config, so the agent
+ * must know them before it can sign anything that will verify. It learns them
+ * from the gateway's public deployment constants — the same two values every 402
+ * offer already carries in the clear — and only then signs.
+ *
+ * Nothing here spends. It resolves authority and hands back a session; the
+ * payment is still built and signed later, on this machine, by
+ * `payDelegatedSpendAccount` with a key that never leaves the process.
+ */
+
+/** The gateway's public deployment constants. */
+interface GatewayDeployment {
+    network: string;
+    packageId: string;
+    /**
+     * The canonical `ExclusionDirectory` object id, present only while the gateway
+     * mints guarded offers. Absent means every offer is unguarded and no registry
+     * ever needs resolving.
+     *
+     * It enables the resolver; it is never resolved against. A guarded settle
+     * resolves the directory the OFFER committed to under the HMAC, so a gateway
+     * cannot point a payer at a directory of its choosing by answering here.
+     */
+    exclusionDirectoryObjectId?: string;
+}
+
+/**
+ * A delegate key and a gateway URL, and the agent can pay.
+ *
+ * `resolvePayerSession` already turned a key into a pay *session*
+ * (ADR-0016 §1). What it did not do was assemble the rest of what
+ * `payDelegatedSpendAccount` demands, so a real agent still had to supply four
+ * things its key does not carry: the gateway's own HMAC secret, a fullnode
+ * connection to confirm settlement, a second fullnode read for live
+ * shared-object versions, and a personal-message signer for the sponsor's
+ * personal-message challenge, separate from the transaction signer. This module is
+ * where those four go.
+ *
+ * Where each one went, and why that is safe:
+ *
+ *  - **The gateway's HMAC secret is gone, not relocated.** It authenticated the
+ *    offer's issuer to the agent — but the issuer is the same gateway the agent
+ *    is paying, reached over TLS at an origin the payer pins, so a gateway that
+ *    wanted to overcharge never needed to forge its own offer. What replaces it
+ *    is a bound the gateway cannot see: the agent's own {@link SpendIntent}.
+ *  - **Both fullnode reads stay with the AGENT**, against a public Sui fullnode
+ *    derived from the network the gateway reports. They are not proxied through
+ *    the gateway, because their whole value is that they are independent of it:
+ *    an agent that asked the gateway whether the gateway's transaction settled
+ *    would be verifying nothing. The gateway supplies no input here it could
+ *    not already supply; what it never gains is the ability to answer for the
+ *    chain.
+ *  - **The personal-message challenge signer is the same key**, taken from the one
+ *    keypair the agent already holds. It was never a second credential, only a
+ *    second callback the caller had to wire.
+ *
+ * The key never leaves this process, and the gateway never gains the ability to
+ * spend: every payment is still built here, checked here against the chain's
+ * own view of the grant, and signed here.
+ */
+
+interface PayerOptions {
+    /** Gateway origin, e.g. `https://gateway.suipay.dev`. */
+    gatewayUrl: string;
+    /**
+     * The delegate key. Used for the bootstrap signature, the sponsor
+     * personal-message challenge, and the payment signature — one key, three uses, none
+     * of which leave this process.
+     */
+    keypair: Ed25519Keypair;
+    /** Which grant to drive when the delegate holds several. */
+    select?: GrantSelector;
+    /** Injectable fetch (tests / custom transports). Defaults to global `fetch`. */
+    fetchImpl?: typeof fetch;
+    /**
+     * Sui fullnode for the agent's own on-chain reads. Defaults to the public
+     * fullnode for the network the gateway reports. An operator running a private
+     * network sets it; an agent does not need to.
+     */
+    fullnodeUrl?: string;
+    /**
+     * A chain transport to read through, for a caller that already has one (or a
+     * test). The seam is the CLIENT, not the individual reads: an option to
+     * supply `getSettledTx` directly would let a caller point settlement
+     * confirmation at something that is not the chain.
+     */
+    client?: SuiGrpcClient;
+    /**
+     * Skip deployment discovery by supplying the constants directly. Same escape
+     * hatch `resolvePayerSession` offers.
+     */
+    deployment?: GatewayDeployment;
+    /**
+     * Durable payment-attempt ledger. Defaults to an in-process one, which is
+     * exactly-once for the lifetime of THIS process. An agent that must survive a
+     * restart mid-payment supplies a durable one.
+     */
+    paymentLedger?: PaymentAttemptLedger;
+    /**
+     * The gateway's HMAC secret, when the caller legitimately holds one (an
+     * operator running its own gateway). An external agent leaves it unset and
+     * relies on its spend intent; see {@link SpendIntent}.
+     */
+    offerSecret?: string;
+    /**
+     * The canonical `ExclusionDirectory` object id, so this payer can build a
+     * GUARDED delegate settle for a guarded offer out of the box.
+     *
+     * Optional: `createPayer` otherwise takes it from `GET /v1/delegate/deployment`,
+     * which discovery already calls, so an agent holding only a key and a gateway
+     * URL needs no out-of-band value to pay a guarded offer. Pass it to pin the
+     * behaviour against a gateway that does not publish one.
+     *
+     * When present from either source, `createPayer` constructs the
+     * `resolveExclusionRegistry` dependency bound to this payer's own gRPC reader
+     * (the same client that reads the grant and confirms settlement), which
+     * resolves the per-recipient `RecipientRegistry` from the directory's
+     * dynamic-field binding at settle-build time. When absent from BOTH, a guarded
+     * offer FAILS CLOSED (BUILD_FAILED) — the payer never builds an unguarded
+     * settle, which would reopen the cross-rail double-settle hole and be rejected
+     * by the gateway's self-settled verifier anyway. An unguarded offer never
+     * resolves a registry, so it is unaffected either way.
+     */
+    exclusionDirectoryObjectId?: string;
+    /** Server-side log port for internal failure detail. Never reaches a result. */
+    log?: DelegatedPayerLog;
+}
+/** Result of `payer.pay`. Same shape as the internal settlement result. */
+type PayResult = DelegatedPayResult;
+
+/** One paid request. `intent` is what this agent says it is buying. */
+interface PayInput {
+    method?: string;
+    body?: string | Uint8Array;
+    contentType?: string;
+    /**
+     * Required. Without it nothing bounds what the offer may charge, and the
+     * payer refuses — the whole point of the key-only path is that the ceiling
+     * comes from the agent, not from a secret it should not hold.
+     */
+    intent: SpendIntent;
+    /**
+     * Terms the caller has ALREADY verified, which the offer this payer reads
+     * must price exactly or nothing is signed.
+     *
+     * Distinct from {@link SpendIntent}, and not a replacement for it: `intent`
+     * is a ceiling — it refuses an offer that charges MORE — while this is an
+     * equality. A caller that showed a person a specific price, or checked a
+     * server-prepared kind, is not agreeing to "that or less from anyone in the
+     * catalogue"; it is agreeing to one exact payment. The payer fetches its own
+     * offer immediately before signing, so without this that final offer is only
+     * ceiling-bounded and could legitimately differ from the one the caller
+     * verified.
+     *
+     * Optional, so every existing caller keeps ceiling semantics unchanged.
+     */
+    preparedTerms?: PreparedSettlementTerms;
+    /**
+     * Which dialect to pay in. Default `'mpp'`, unchanged: the sponsor executes
+     * the pay and the payer presents a finalized proof. `'x402'` signs the pay
+     * with the offer's pinned sponsor gas and presents it as `PAYMENT-SIGNATURE`;
+     * the gateway co-signs and submits (ADR-0045). Before reserving anything,
+     * x402 refuses an open-recipient grant and an offer without the pins.
+     */
+    dialect?: 'mpp' | 'x402';
+    /**
+     * x402 only: each step as it happens (built, signed, then presented and
+     * answered per presentation). Called synchronously; a throw is logged and
+     * never affects the payment.
+     */
+    onX402Progress?: (event: X402PayProgress) => void;
+}
+interface Payer {
+    /** The delegate's own address, derived from the key it holds. */
+    address: string;
+    /** Deployment constants the gateway published and the bootstrap bound. */
+    deployment: GatewayDeployment;
+    /** The grant this agent will pay from, as resolved and then verified on chain. */
+    grant: AgentGrantBinding;
+    /** The assembled session; exposed so a caller can inspect what it will sign with. */
+    session: DelegatedPayerSession;
+    /** Pay for one resource and return its response. */
+    pay(url: string, input: PayInput): Promise<PayResult>;
+    /**
+     * Verify a 402 prepared settlement against the grant this agent resolved.
+     * Always pins {@link Payer.grant} — a settlement drawn on another
+     * buyer's grant is refused. Callers with no resolved grant still use
+     * {@link verifyPreparedPayment} unpinned.
+     */
+    verifySettlement(prepared: unknown, offer: Offer): Promise<PreparedSettlement>;
+}
+/**
+ * Create a payer from its key and a gateway URL.
+ *
+ * The call sequence, all of it derivable from those two inputs:
+ *   1. `GET /v1/delegate/deployment` — network, package id, and the exclusion
+ *      directory id when guarded minting is on. All in the clear.
+ *   2. `GET /v1/delegate/grants`, signed by the key — the grants naming it.
+ *   3. an unsigned `getObject` on the resolved grant, against a public
+ *      fullnode — the agent's own check that the grant is its own.
+ *
+ * Typed failure, never a throw: an agent that cannot verify its own authority
+ * must refuse to sign, not proceed on the gateway's word.
+ */
+declare function createPayer(options: PayerOptions): Promise<ManifestResult<Payer>>;
+
 interface StdioLoginOptions {
     consoleUrl: string;
     gatewayUrl: string;

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   loadBootProfile,
   main
-} from "./chunk-LQOZBRH6.js";
+} from "./chunk-W4RIN664.js";
 import {
   MCP_TARGET_PRESETS,
   PACKAGE_NAME,
@@ -26,7 +26,7 @@ import {
   settlePreparedMcpPayment,
   traceMcpHttpRequest,
   verifySpendAccountPayReconstructs
-} from "./chunk-NDJ7BFI4.js";
+} from "./chunk-FKDC22O6.js";
 export {
   MCP_TARGET_PRESETS,
   PACKAGE_NAME,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cmdoss/suipay-mcp",
-  "version": "0.2.2-dev.9",
+  "version": "0.3.0-dev.0",
   "type": "module",
   "description": "SuiPay MCP — pay MPP-gated APIs from a spend-account grant with an agent-held delegate key.",
   "main": "./dist/index.js",
@@ -37,8 +37,8 @@
     "tsup": "^8.0.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
-    "@cmdoss/suipay-core": "0.1.0",
-    "@cmdoss/suipay-sdk": "0.1.0"
+    "@cmdoss/suipay-sdk": "0.1.0",
+    "@cmdoss/suipay-core": "0.1.0"
   },
   "scripts": {
     "build": "tsup",