@oobe-protocol-labs/sap-mcp-server 0.1.0

package/dist/tools/sap-sdk-tools.js

@@ -0,0 +1,1515 @@
+/**
+ * SAP SDK MCP tools.
+ *
+ * This module intentionally wraps only methods that exist on
+ * `@oobe-protocol-labs/synapse-sap-sdk@0.21.x`. It does not create local
+ * facades for missing SDK namespaces and it does not fabricate network data.
+ */
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+import { TOOL_CATEGORY_VALUES } from '@oobe-protocol-labs/synapse-sap-sdk';
+import { SettlementMode, TokenType, } from '@oobe-protocol-labs/synapse-sap-sdk/types';
+import { createTextResponse } from '../adapters/mcp/tool-response.js';
+import { registerTool } from '../adapters/mcp/sdk-compat.js';
+import { getSapClient, isSapClientInitialized } from '../sap/sap-client-manager.js';
+import { logger } from '../core/logger.js';
+/**
+ * @name jsonReplacer
+ * @description Serializes SDK values such as PublicKey, BN, bigint, Buffer, and Uint8Array into JSON-safe output.
+ */
+function jsonReplacer(_key, value) {
+    if (value instanceof PublicKey) {
+        return value.toBase58();
+    }
+    if (BN.isBN(value)) {
+        return value.toString(10);
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    if (value instanceof Uint8Array) {
+        return Array.from(value);
+    }
+    return value;
+}
+/**
+ * @name ok
+ * @description Wraps a successful tool result in the MCP text response shape.
+ */
+function ok(payload) {
+    return createTextResponse(JSON.stringify({ success: true, ...asObjectPayload(payload) }, jsonReplacer, 2));
+}
+/**
+ * @name asObjectPayload
+ * @description Preserves object payloads and wraps scalar payloads under `result`.
+ */
+function asObjectPayload(payload) {
+    return payload && typeof payload === 'object' && !Array.isArray(payload)
+        ? payload
+        : { result: payload };
+}
+/**
+ * @name getSapAnchorAccounts
+ * @description Narrows the SDK Anchor program account namespace used for global read-only enumeration.
+ */
+function getSapAnchorAccounts(client) {
+    return client.program.account;
+}
+/**
+ * @name bnString
+ * @description Converts BN-like SDK counters into stable decimal strings.
+ */
+function bnString(value) {
+    return BN.isBN(value) ? value.toString(10) : String(value);
+}
+/**
+ * @name buildProtocolMembership
+ * @description Builds an agent PDA to protocol ID lookup from protocol index accounts.
+ */
+function buildProtocolMembership(protocolIndexes) {
+    const membership = new Map();
+    for (const { account } of protocolIndexes) {
+        for (const agent of account.agents) {
+            const agentPda = agent.toBase58();
+            const protocols = membership.get(agentPda) ?? [];
+            protocols.push(account.protocolId);
+            membership.set(agentPda, protocols);
+        }
+    }
+    return membership;
+}
+/**
+ * @name summarizeProtocolIndexes
+ * @description Converts protocol index accounts into compact MCP-safe summaries.
+ */
+function summarizeProtocolIndexes(protocolIndexes) {
+    return protocolIndexes
+        .map(({ publicKey, account }) => ({
+        pda: publicKey.toBase58(),
+        protocolId: account.protocolId,
+        agentCount: account.agents.length,
+        lastUpdated: bnString(account.lastUpdated),
+    }))
+        .sort((left, right) => left.protocolId.localeCompare(right.protocolId));
+}
+/**
+ * @name buildAgentDirectoryEntry
+ * @description Converts an AgentAccount into a compact directory row with optional stats and protocol-index membership.
+ */
+function buildAgentDirectoryEntry(accountResult, statsByAgent, indexedProtocolsByAgent) {
+    const agentPda = accountResult.publicKey.toBase58();
+    const account = accountResult.account;
+    const stats = statsByAgent.get(agentPda);
+    return {
+        agentPda,
+        wallet: account.wallet.toBase58(),
+        name: account.name,
+        description: account.description,
+        agentId: account.agentId,
+        agentUri: account.agentUri,
+        x402Endpoint: account.x402Endpoint,
+        isActive: account.isActive,
+        createdAt: bnString(account.createdAt),
+        updatedAt: bnString(account.updatedAt),
+        reputationScore: account.reputationScore,
+        totalFeedbacks: account.totalFeedbacks,
+        totalCallsServed: stats ? bnString(stats.totalCallsServed) : bnString(account.totalCallsServed),
+        avgLatencyMs: account.avgLatencyMs,
+        uptimePercent: account.uptimePercent,
+        protocols: account.protocols,
+        indexedProtocols: indexedProtocolsByAgent.get(agentPda) ?? [],
+        capabilities: account.capabilities.map((capability) => capability.id),
+        activePlugins: account.activePlugins.map((plugin) => `${plugin.pluginType}:${plugin.pda.toBase58()}`),
+    };
+}
+/**
+ * @name matchesAgentDirectoryFilters
+ * @description Applies optional directory filters to an already hydrated agent row.
+ */
+function matchesAgentDirectoryFilters(entry, filters) {
+    if (!filters.includeInactive && !entry.isActive) {
+        return false;
+    }
+    if (filters.protocol && !entry.protocols.includes(filters.protocol) && !entry.indexedProtocols.includes(filters.protocol)) {
+        return false;
+    }
+    if (filters.capability && !entry.capabilities.includes(filters.capability)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * @name asRecord
+ * @description Normalizes MCP tool input into an object.
+ */
+function asRecord(input) {
+    return input && typeof input === 'object' && !Array.isArray(input) ? input : {};
+}
+/**
+ * @name requiredString
+ * @description Reads a required string field from tool input.
+ */
+function requiredString(input, field) {
+    const value = input[field];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`${field} is required`);
+    }
+    return value;
+}
+/**
+ * @name optionalString
+ * @description Reads an optional string field from tool input.
+ */
+function optionalString(input, field) {
+    const value = input[field];
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/**
+ * @name requiredNumber
+ * @description Reads a required finite number field from tool input.
+ */
+function requiredNumber(input, field) {
+    const value = input[field];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim() !== '' && Number.isFinite(Number(value))) {
+        return Number(value);
+    }
+    throw new Error(`${field} must be a finite number`);
+}
+/**
+ * @name optionalNumber
+ * @description Reads an optional finite number field from tool input.
+ */
+function optionalNumber(input, field) {
+    const value = input[field];
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    return requiredNumber(input, field);
+}
+/**
+ * @name requiredBn
+ * @description Reads a numeric field and converts it to BN for SAP SDK calls.
+ */
+function requiredBn(input, field) {
+    const value = input[field];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return new BN(Math.trunc(value));
+    }
+    if (typeof value === 'string' && /^-?\d+$/.test(value)) {
+        return new BN(value, 10);
+    }
+    throw new Error(`${field} must be an integer number or decimal string`);
+}
+/**
+ * @name optionalBn
+ * @description Reads an optional numeric field and converts it to BN.
+ */
+function optionalBn(input, field, fallback) {
+    const value = input[field];
+    return value === undefined || value === null || value === '' ? fallback : requiredBn(input, field);
+}
+/**
+ * @name optionalBoolean
+ * @description Reads an optional boolean field from tool input.
+ */
+function optionalBoolean(input, field) {
+    const value = input[field];
+    if (value === undefined || value === null || value === '') {
+        return undefined;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string' && (value === 'true' || value === 'false')) {
+        return value === 'true';
+    }
+    throw new Error(`${field} must be a boolean`);
+}
+/**
+ * @name requiredPublicKey
+ * @description Reads a required base58 public key field from tool input.
+ */
+function requiredPublicKey(input, field) {
+    return new PublicKey(requiredString(input, field));
+}
+/**
+ * @name optionalPublicKey
+ * @description Reads an optional base58 public key field from tool input.
+ */
+function optionalPublicKey(input, field) {
+    const value = optionalString(input, field);
+    return value ? new PublicKey(value) : undefined;
+}
+/**
+ * @name parseVolumeCurve
+ * @description Converts MCP JSON input into SDK volume-curve breakpoints.
+ */
+function parseVolumeCurve(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('volumeCurve must be an array');
+    }
+    return value.map((item) => {
+        const record = asRecord(item);
+        return {
+            afterCalls: requiredNumber(record, 'afterCalls'),
+            pricePerCall: requiredBn(record, 'pricePerCall'),
+        };
+    });
+}
+/**
+ * @name requiredBytes
+ * @description Reads byte-array fields used for hashes, nonces, and encrypted payloads.
+ */
+function requiredBytes(input, field, expectedLength) {
+    const value = input[field];
+    let bytes;
+    if (Array.isArray(value)) {
+        bytes = value.map((item) => {
+            if (typeof item !== 'number' || item < 0 || item > 255 || !Number.isInteger(item)) {
+                throw new Error(`${field} must contain byte values between 0 and 255`);
+            }
+            return item;
+        });
+    }
+    else if (typeof value === 'string') {
+        const normalized = value.startsWith('0x') ? value.slice(2) : value;
+        if (/^[0-9a-fA-F]+$/.test(normalized) && normalized.length % 2 === 0) {
+            bytes = Array.from(Buffer.from(normalized, 'hex'));
+        }
+        else {
+            bytes = Array.from(Buffer.from(value, 'base64'));
+        }
+    }
+    else {
+        throw new Error(`${field} must be a byte array, hex string, or base64 string`);
+    }
+    if (expectedLength !== undefined && bytes.length !== expectedLength) {
+        throw new Error(`${field} must be ${expectedLength} bytes`);
+    }
+    return bytes;
+}
+/**
+ * @name optionalBytes
+ * @description Reads an optional byte-array field.
+ */
+function optionalBytes(input, field, fallback = []) {
+    return input[field] === undefined || input[field] === null ? fallback : requiredBytes(input, field);
+}
+/**
+ * @name optionalFairScaleTask
+ * @description Reads an optional FairScale task value supported by the SDK.
+ */
+function optionalFairScaleTask(input, field) {
+    const value = optionalString(input, field);
+    if (!value) {
+        return undefined;
+    }
+    if (value === 'defi_execution' || value === 'trust_focused' || value === 'work_focused' || value === 'hiring') {
+        return value;
+    }
+    throw new Error(`${field} must be one of defi_execution, trust_focused, work_focused, hiring`);
+}
+/**
+ * @name requiredToolCategory
+ * @description Reads a tool category compatible with SDK DiscoveryRegistry.findToolsByCategory.
+ */
+function requiredToolCategory(input) {
+    const rawCategory = input.category;
+    if (typeof rawCategory === 'number') {
+        return rawCategory;
+    }
+    const category = requiredString(input, 'category');
+    if (category in TOOL_CATEGORY_VALUES) {
+        return category;
+    }
+    throw new Error(`category must be a numeric category or one of ${Object.keys(TOOL_CATEGORY_VALUES).join(', ')}`);
+}
+/**
+ * @name parseCapabilities
+ * @description Converts user input into SDK `Capability[]` values.
+ */
+function parseCapabilities(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('capabilities must be an array');
+    }
+    return value.map((item) => {
+        if (typeof item === 'string') {
+            return { id: item, description: null, protocolId: null, version: null };
+        }
+        const record = asRecord(item);
+        return {
+            id: requiredString(record, 'id'),
+            description: optionalString(record, 'description') ?? null,
+            protocolId: optionalString(record, 'protocolId') ?? null,
+            version: optionalString(record, 'version') ?? null,
+        };
+    });
+}
+/**
+ * @name parsePricingTiers
+ * @description Converts user input into SDK `PricingTier[]` values.
+ */
+function parsePricingTiers(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('pricing must be an array');
+    }
+    return value.map((item) => {
+        const record = asRecord(item);
+        const pricePerCall = optionalBn(record, 'pricePerCall', new BN(0));
+        return {
+            tierId: optionalString(record, 'tierId') ?? 'default',
+            pricePerCall,
+            minPricePerCall: record.minPricePerCall === undefined ? null : requiredBn(record, 'minPricePerCall'),
+            maxPricePerCall: record.maxPricePerCall === undefined ? null : requiredBn(record, 'maxPricePerCall'),
+            rateLimit: optionalNumber(record, 'rateLimit') ?? 60,
+            maxCallsPerSession: optionalNumber(record, 'maxCallsPerSession') ?? 1_000,
+            burstLimit: optionalNumber(record, 'burstLimit') ?? null,
+            tokenType: TokenType.Sol,
+            tokenMint: optionalPublicKey(record, 'tokenMint') ?? null,
+            tokenDecimals: optionalNumber(record, 'tokenDecimals') ?? null,
+            settlementMode: SettlementMode.Escrow,
+            minEscrowDeposit: record.minEscrowDeposit === undefined ? null : requiredBn(record, 'minEscrowDeposit'),
+            batchIntervalSec: optionalNumber(record, 'batchIntervalSec') ?? null,
+            volumeCurve: null,
+        };
+    });
+}
+/**
+ * @name parseProtocols
+ * @description Converts user input into SDK protocol identifiers.
+ */
+function parseProtocols(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('protocols must be an array');
+    }
+    return value.map((item) => {
+        if (typeof item !== 'string' || item.length === 0) {
+            throw new Error('protocols must contain non-empty strings');
+        }
+        return item;
+    });
+}
+/**
+ * @name parseRegisterAgentArgs
+ * @description Builds strongly typed `RegisterAgentArgs` from MCP JSON input.
+ */
+function parseRegisterAgentArgs(input) {
+    return {
+        name: requiredString(input, 'name'),
+        description: requiredString(input, 'description'),
+        capabilities: parseCapabilities(input.capabilities),
+        pricing: parsePricingTiers(input.pricing),
+        protocols: parseProtocols(input.protocols),
+        agentId: optionalString(input, 'agentId') ?? null,
+        agentUri: optionalString(input, 'agentUri') ?? optionalString(input, 'metadataUri') ?? null,
+        x402Endpoint: optionalString(input, 'x402Endpoint') ?? null,
+    };
+}
+/**
+ * @name parseUpdateAgentArgs
+ * @description Builds strongly typed `UpdateAgentArgs` from MCP JSON input.
+ */
+function parseUpdateAgentArgs(input) {
+    return {
+        name: optionalString(input, 'name') ?? null,
+        description: optionalString(input, 'description') ?? null,
+        capabilities: input.capabilities === undefined ? null : parseCapabilities(input.capabilities),
+        pricing: input.pricing === undefined ? null : parsePricingTiers(input.pricing),
+        protocols: input.protocols === undefined ? null : parseProtocols(input.protocols),
+        agentId: optionalString(input, 'agentId') ?? null,
+        agentUri: optionalString(input, 'agentUri') ?? optionalString(input, 'metadataUri') ?? null,
+        x402Endpoint: optionalString(input, 'x402Endpoint') ?? null,
+    };
+}
+/**
+ * @name parseEscrowArgs
+ * @description Builds typed V1 escrow creation args from MCP JSON input.
+ */
+function parseEscrowArgs(input) {
+    return {
+        pricePerCall: requiredBn(input, 'pricePerCall'),
+        maxCalls: requiredBn(input, 'maxCalls'),
+        initialDeposit: requiredBn(input, 'initialDeposit'),
+        expiresAt: optionalBn(input, 'expiresAt', new BN(0)),
+        volumeCurve: [],
+        tokenMint: optionalPublicKey(input, 'tokenMint') ?? null,
+        tokenDecimals: optionalNumber(input, 'tokenDecimals') ?? 9,
+    };
+}
+/**
+ * @name parseX402PreparePaymentOptions
+ * @description Builds typed V1 x402 payment preparation options from MCP JSON input.
+ */
+function parseX402PreparePaymentOptions(input) {
+    return {
+        pricePerCall: requiredString(input, 'pricePerCall'),
+        deposit: requiredString(input, 'deposit'),
+        maxCalls: optionalString(input, 'maxCalls'),
+        expiresAt: optionalString(input, 'expiresAt'),
+        volumeCurve: parseVolumeCurve(input.volumeCurve).map(point => ({
+            afterCalls: point.afterCalls,
+            pricePerCall: point.pricePerCall,
+        })),
+        tokenMint: optionalPublicKey(input, 'tokenMint') ?? null,
+        tokenDecimals: optionalNumber(input, 'tokenDecimals'),
+        networkIdentifier: optionalString(input, 'networkIdentifier'),
+    };
+}
+/**
+ * @name parsePaymentContext
+ * @description Reconstructs a safe x402 payment context from public MCP fields.
+ */
+function parsePaymentContext(input) {
+    return {
+        escrowPda: requiredPublicKey(input, 'escrowPda'),
+        agentPda: requiredPublicKey(input, 'agentPda'),
+        agentWallet: requiredPublicKey(input, 'agentWallet'),
+        depositorWallet: requiredPublicKey(input, 'depositorWallet'),
+        pricePerCall: requiredBn(input, 'pricePerCall'),
+        maxCalls: requiredBn(input, 'maxCalls'),
+        txSignature: requiredString(input, 'txSignature'),
+        networkIdentifier: requiredString(input, 'networkIdentifier'),
+    };
+}
+/**
+ * @name parseSettleOptions
+ * @description Builds optional SDK settlement tuning options from MCP JSON input.
+ */
+function parseSettleOptions(input) {
+    const priorityFeeMicroLamports = optionalNumber(input, 'priorityFeeMicroLamports');
+    const computeUnits = optionalNumber(input, 'computeUnits');
+    const skipPreflight = optionalBoolean(input, 'skipPreflight');
+    const commitment = optionalString(input, 'commitment');
+    const maxRetries = optionalNumber(input, 'maxRetries');
+    if (priorityFeeMicroLamports === undefined
+        && computeUnits === undefined
+        && skipPreflight === undefined
+        && commitment === undefined
+        && maxRetries === undefined) {
+        return undefined;
+    }
+    if (commitment !== undefined && commitment !== 'processed' && commitment !== 'confirmed' && commitment !== 'finalized') {
+        throw new Error('commitment must be processed, confirmed, or finalized');
+    }
+    return {
+        ...(priorityFeeMicroLamports !== undefined ? { priorityFeeMicroLamports } : {}),
+        ...(computeUnits !== undefined ? { computeUnits } : {}),
+        ...(skipPreflight !== undefined ? { skipPreflight } : {}),
+        ...(commitment !== undefined ? { commitment } : {}),
+        ...(maxRetries !== undefined ? { maxRetries } : {}),
+    };
+}
+/**
+ * @name parseX402BatchSettlementEntries
+ * @description Converts MCP JSON input into SDK x402 batch-settlement entries.
+ */
+function parseX402BatchSettlementEntries(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('entries must be an array');
+    }
+    return value.map((item) => {
+        const record = asRecord(item);
+        return {
+            calls: requiredNumber(record, 'calls'),
+            serviceData: requiredString(record, 'serviceData'),
+        };
+    });
+}
+/**
+ * @name parseEscrowV2Args
+ * @description Builds typed V2 escrow creation args from MCP JSON input.
+ */
+function parseEscrowV2Args(input) {
+    return {
+        escrowNonce: optionalBn(input, 'nonce', new BN(0)),
+        pricePerCall: requiredBn(input, 'pricePerCall'),
+        maxCalls: requiredBn(input, 'maxCalls'),
+        initialDeposit: requiredBn(input, 'initialDeposit'),
+        expiresAt: optionalBn(input, 'expiresAt', new BN(0)),
+        volumeCurve: [],
+        tokenMint: optionalPublicKey(input, 'tokenMint') ?? null,
+        tokenDecimals: optionalNumber(input, 'tokenDecimals') ?? 9,
+        settlementSecurity: optionalNumber(input, 'settlementSecurity') ?? 0,
+        disputeWindowSlots: optionalBn(input, 'disputeWindowSlots', new BN(0)),
+        coSigner: optionalPublicKey(input, 'coSigner') ?? null,
+        arbiter: optionalPublicKey(input, 'arbiter') ?? null,
+    };
+}
+/**
+ * @name parseSettlement
+ * @description Builds typed V1 batch-settlement entries from MCP JSON input.
+ */
+function parseSettlement(item) {
+    const record = asRecord(item);
+    return {
+        callsToSettle: requiredBn(record, 'callsToSettle'),
+        serviceHash: requiredBytes(record, 'serviceHash', 32),
+    };
+}
+/**
+ * @name parseFeedbackArgs
+ * @description Builds typed feedback args from MCP JSON input.
+ */
+function parseFeedbackArgs(input) {
+    return {
+        score: requiredNumber(input, 'score'),
+        tag: optionalString(input, 'tag') ?? 'general',
+        commentHash: input.commentHash === undefined ? null : requiredBytes(input, 'commentHash', 32),
+    };
+}
+/**
+ * @name parseUpdateFeedbackArgs
+ * @description Builds typed feedback update args from MCP JSON input.
+ */
+function parseUpdateFeedbackArgs(input) {
+    return {
+        newScore: requiredNumber(input, 'score'),
+        newTag: optionalString(input, 'tag') ?? null,
+        commentHash: input.commentHash === undefined ? null : requiredBytes(input, 'commentHash', 32),
+    };
+}
+/**
+ * @name parseAttestationArgs
+ * @description Builds typed attestation creation args from MCP JSON input.
+ */
+function parseAttestationArgs(input) {
+    return {
+        attestationType: optionalString(input, 'attestationType') ?? 'generic',
+        metadataHash: requiredBytes(input, 'metadataHash', 32),
+        expiresAt: optionalBn(input, 'expiresAt', new BN(0)),
+    };
+}
+/**
+ * @name parseSubscriptionArgs
+ * @description Builds typed subscription creation args from MCP JSON input.
+ */
+function parseSubscriptionArgs(input) {
+    return {
+        subId: optionalBn(input, 'subId', new BN(0)),
+        pricePerInterval: requiredBn(input, 'pricePerInterval'),
+        billingInterval: requiredNumber(input, 'billingInterval'),
+        initialFund: requiredBn(input, 'initialFund'),
+    };
+}
+/**
+ * @name parseMemoryArgs
+ * @description Builds typed memory inscription args from MCP JSON input.
+ */
+function parseMemoryArgs(input) {
+    return {
+        sequence: requiredNumber(input, 'sequence'),
+        encryptedData: Buffer.from(requiredBytes(input, 'encryptedData')),
+        nonce: requiredBytes(input, 'nonce'),
+        contentHash: requiredBytes(input, 'contentHash', 32),
+        totalFragments: optionalNumber(input, 'totalFragments') ?? 1,
+        fragmentIndex: optionalNumber(input, 'fragmentIndex') ?? 0,
+        compression: optionalNumber(input, 'compression') ?? 0,
+        epochIndex: optionalNumber(input, 'epochIndex') ?? 0,
+    };
+}
+/**
+ * @name parseCompactMemoryArgs
+ * @description Builds typed compact inscription args from MCP JSON input.
+ */
+function parseCompactMemoryArgs(input) {
+    return {
+        sequence: requiredNumber(input, 'sequence'),
+        encryptedData: Buffer.from(requiredBytes(input, 'encryptedData')),
+        nonce: requiredBytes(input, 'nonce'),
+        contentHash: requiredBytes(input, 'contentHash', 32),
+    };
+}
+/**
+ * @name parseUpdateToolArgs
+ * @description Builds typed tool update args from MCP JSON input.
+ */
+function parseUpdateToolArgs(input) {
+    return {
+        descriptionHash: input.descriptionHash === undefined ? null : requiredBytes(input, 'descriptionHash', 32),
+        inputSchemaHash: input.inputSchemaHash === undefined ? null : requiredBytes(input, 'inputSchemaHash', 32),
+        outputSchemaHash: input.outputSchemaHash === undefined ? null : requiredBytes(input, 'outputSchemaHash', 32),
+        httpMethod: optionalNumber(input, 'httpMethod') ?? null,
+        category: optionalNumber(input, 'category') ?? null,
+        paramsCount: optionalNumber(input, 'paramsCount') ?? null,
+        requiredParams: optionalNumber(input, 'requiredParams') ?? null,
+    };
+}
+/**
+ * @name registerSapTool
+ * @description Registers one SAP SDK-backed MCP tool with common error handling.
+ */
+function registerSapTool(server, client, definition) {
+    registerTool(server, definition.name, {
+        title: definition.title,
+        description: definition.description,
+        inputSchema: definition.inputSchema,
+    }, async (rawInput) => {
+        try {
+            return ok(await definition.handler(asRecord(rawInput), client));
+        }
+        catch (error) {
+            logger.error(`SAP SDK tool failed: ${definition.name}`, { error });
+            return createTextResponse(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`, { isError: true });
+        }
+    });
+}
+const agentTools = [
+    {
+        name: 'sap_register_agent',
+        title: 'Register SAP Agent',
+        description: 'Register the connected wallet as a SAP agent using SDK AgentModule.register.',
+        inputSchema: {
+            name: { type: 'string', description: 'Human-readable name for the SAP agent' },
+            description: { type: 'string', description: 'Detailed description of the agent\'s purpose and capabilities' },
+            capabilities: { type: 'array', description: 'Array of capability objects or strings identifying what the agent can do (e.g. "jupiter:swap")' },
+            pricing: { type: 'array', description: 'Array of pricing tier objects defining per-call costs, rate limits, and settlement terms' },
+            protocols: { type: 'array', items: { type: 'string' }, description: 'Array of protocol identifiers the agent supports (e.g. "jupiter", "drift")' },
+            agentId: { type: 'string', description: 'Optional unique agent identifier string' },
+            agentUri: { type: 'string', description: 'Optional URI to the agent\'s off-chain metadata or service endpoint' },
+            metadataUri: { type: 'string', description: 'Alias for agentUri — URI to off-chain agent metadata JSON' },
+            x402Endpoint: { type: 'string', description: 'Optional x402 payment endpoint URL for HTTP-based agent payments' },
+        },
+        handler: async (input, client) => ({ signature: await client.agent.register(parseRegisterAgentArgs(input)) }),
+    },
+    {
+        name: 'sap_update_agent',
+        title: 'Update SAP Agent',
+        description: 'Update the connected wallet SAP agent using SDK AgentModule.update.',
+        inputSchema: { type: 'object', additionalProperties: true, description: 'Object containing any combination of agent fields to update (name, description, capabilities, pricing, protocols, agentId, agentUri, x402Endpoint)' },
+        handler: async (input, client) => ({ signature: await client.agent.update(parseUpdateAgentArgs(input)) }),
+    },
+    {
+        name: 'sap_deactivate_agent',
+        title: 'Deactivate SAP Agent',
+        description: 'Deactivate the connected wallet SAP agent.',
+        inputSchema: {},
+        handler: async (_input, client) => ({ signature: await client.agent.deactivate() }),
+    },
+    {
+        name: 'sap_reactivate_agent',
+        title: 'Reactivate SAP Agent',
+        description: 'Reactivate the connected wallet SAP agent.',
+        inputSchema: {},
+        handler: async (_input, client) => ({ signature: await client.agent.reactivate() }),
+    },
+    {
+        name: 'sap_close_agent',
+        title: 'Close SAP Agent',
+        description: 'Close the connected wallet SAP agent and reclaim rent.',
+        inputSchema: {},
+        handler: async (_input, client) => ({ signature: await client.agent.close() }),
+    },
+    {
+        name: 'sap_report_calls',
+        title: 'Report Agent Calls',
+        description: 'Report served call count for the connected wallet SAP agent.',
+        inputSchema: { callsServed: { type: 'number', description: 'Number of calls served to report for the agent' } },
+        handler: async (input, client) => ({ signature: await client.agent.reportCalls(requiredNumber(input, 'callsServed')) }),
+    },
+    {
+        name: 'sap_update_reputation_metrics',
+        title: 'Update Reputation Metrics',
+        description: 'Update self-reported latency and uptime metrics for the connected wallet SAP agent.',
+        inputSchema: { avgLatencyMs: { type: 'number', description: 'Average response latency in milliseconds to report' }, uptimePercent: { type: 'number', description: 'Uptime percentage (0–100) to report for the agent' } },
+        handler: async (input, client) => ({
+            signature: await client.agent.updateReputation(requiredNumber(input, 'avgLatencyMs'), requiredNumber(input, 'uptimePercent')),
+        }),
+    },
+    {
+        name: 'sap_get_agent',
+        title: 'Get SAP Agent',
+        description: 'Fetch agent identity by owner wallet. If omitted, fetches the connected wallet agent.',
+        inputSchema: { wallet: { type: 'string', description: 'Solana public key of the agent owner wallet (base58). If omitted, uses the connected wallet.' } },
+        handler: async (input, client) => {
+            const wallet = optionalPublicKey(input, 'wallet');
+            const pda = client.agent.deriveAgent(wallet)[0];
+            const agent = await client.agent.fetchNullable(wallet);
+            return { agentPda: pda, agent };
+        },
+    },
+    {
+        name: 'sap_get_agent_stats',
+        title: 'Get SAP Agent Stats',
+        description: 'Fetch agent stats by agent PDA.',
+        inputSchema: { agentPda: { type: 'string', description: 'Agent PDA (base58) to fetch stats for' } },
+        handler: async (input, client) => ({
+            stats: await client.agent.fetchStatsNullable(requiredPublicKey(input, 'agentPda')),
+        }),
+    },
+    {
+        name: 'sap_get_global_state',
+        title: 'Get SAP Global State',
+        description: 'Fetch the on-chain global registry through SDK AgentModule.fetchGlobalRegistry.',
+        inputSchema: {},
+        handler: async (_input, client) => ({ state: await client.agent.fetchGlobalRegistry() }),
+    },
+];
+const discoveryTools = [
+    {
+        name: 'sap_get_network_overview',
+        title: 'Get SAP Network Overview',
+        description: 'Fetch real network counters from SDK DiscoveryRegistry.getNetworkOverview.',
+        inputSchema: {},
+        handler: async (_input, client) => ({ overview: await client.discovery.getNetworkOverview() }),
+    },
+    {
+        name: 'sap_get_agent_profile',
+        title: 'Get SAP Agent Profile',
+        description: 'Fetch a hydrated SAP agent profile by owner wallet.',
+        inputSchema: { wallet: { type: 'string', description: 'Solana public key of the agent owner wallet (base58)' } },
+        handler: async (input, client) => ({ profile: await client.discovery.getAgentProfile(requiredPublicKey(input, 'wallet')) }),
+    },
+    {
+        name: 'sap_is_agent_active',
+        title: 'Check SAP Agent Active',
+        description: 'Check if a wallet owns an active SAP agent.',
+        inputSchema: { wallet: { type: 'string', description: 'Solana public key of the wallet to check for an active SAP agent (base58)' } },
+        handler: async (input, client) => ({ active: await client.discovery.isAgentActive(requiredPublicKey(input, 'wallet')) }),
+    },
+    {
+        name: 'sap_discover_agents',
+        title: 'Discover SAP Agents',
+        description: 'Discover agents by protocol, capability, or capability list. Unfiltered global listing is not exposed by SDK v0.20.',
+        inputSchema: {
+            protocol: { type: 'string', description: 'Protocol identifier to filter agents by (e.g. "jupiter", "drift")' },
+            capability: { type: 'string', description: 'Single capability ID to filter agents by (e.g. "jupiter:swap")' },
+            capabilities: { type: 'array', items: { type: 'string' }, description: 'Array of capability IDs to filter agents by (requires at least one)' },
+            hydrate: { type: 'boolean', description: 'Whether to include full hydrated agent profiles in results (default: true)' },
+            limit: { type: 'number', description: 'Maximum number of agents to return (default: 50)' },
+        },
+        handler: async (input, client) => {
+            const hydrate = input.hydrate !== false;
+            const limit = optionalNumber(input, 'limit') ?? 50;
+            const capabilities = Array.isArray(input.capabilities)
+                ? input.capabilities.filter((item) => typeof item === 'string' && item.length > 0)
+                : [];
+            const protocol = optionalString(input, 'protocol');
+            const capability = optionalString(input, 'capability');
+            if (protocol) {
+                const agents = await client.discovery.findAgentsByProtocol(protocol, { hydrate });
+                return { count: Math.min(agents.length, limit), agents: agents.slice(0, limit) };
+            }
+            if (capability) {
+                const agents = await client.discovery.findAgentsByCapability(capability, { hydrate });
+                return { count: Math.min(agents.length, limit), agents: agents.slice(0, limit) };
+            }
+            if (capabilities.length > 0) {
+                const agents = await client.discovery.findAgentsByCapabilities(capabilities, { hydrate });
+                return { count: Math.min(agents.length, limit), agents: agents.slice(0, limit) };
+            }
+            return {
+                count: 0,
+                agents: [],
+                overview: await client.discovery.getNetworkOverview(),
+                note: 'SDK v0.20 exposes filtered discovery, not unfiltered global agent enumeration. Provide protocol or capability.',
+            };
+        },
+    },
+    {
+        name: 'sap_list_agents',
+        title: 'List SAP Agents',
+        description: 'Compatibility alias for filtered SAP agent discovery. Requires protocol or capability. Use sap_list_all_agents for a global on-chain directory snapshot.',
+        inputSchema: {
+            protocol: { type: 'string', description: 'Protocol identifier to filter agents by (e.g. "jupiter", "drift")' },
+            capability: { type: 'string', description: 'Single capability ID to filter agents by (e.g. "jupiter:swap")' },
+            capabilities: { type: 'array', items: { type: 'string' }, description: 'Array of capability IDs to filter agents by (requires at least one)' },
+            hydrate: { type: 'boolean', description: 'Whether to include full hydrated agent profiles in results (default: true)' },
+            limit: { type: 'number', description: 'Maximum number of agents to return (default: 50)' },
+        },
+        handler: async (input, client) => discoveryTools[3].handler(input, client),
+    },
+    {
+        name: 'sap_list_all_agents',
+        title: 'List All SAP Agents',
+        description: 'Enumerate SAP AgentAccount PDAs directly from the on-chain program account set. Use this for current global directory requests such as "list all agents in the SAP ecosystem rn".',
+        inputSchema: {
+            limit: { type: 'number', description: 'Maximum rows to return. Defaults to 100; hard-capped at 500.' },
+            offset: { type: 'number', description: 'Zero-based pagination offset. Defaults to 0.' },
+            includeInactive: { type: 'boolean', description: 'Include inactive agents. Defaults to false.' },
+            protocol: { type: 'string', description: 'Optional protocol filter matched against agent profile protocols and protocol-index membership.' },
+            capability: { type: 'string', description: 'Optional capability ID filter such as jupiter:swap.' },
+            includeProtocolIndexes: { type: 'boolean', description: 'Include compact protocol index summaries. Defaults to true.' },
+        },
+        handler: async (input, client) => {
+            const limit = Math.max(1, Math.min(optionalNumber(input, 'limit') ?? 100, 500));
+            const offset = Math.max(0, optionalNumber(input, 'offset') ?? 0);
+            const includeInactive = input.includeInactive === true;
+            const includeProtocolIndexes = input.includeProtocolIndexes !== false;
+            const protocol = optionalString(input, 'protocol');
+            const capability = optionalString(input, 'capability');
+            const accounts = getSapAnchorAccounts(client);
+            const [agentAccounts, statsAccounts, protocolIndexes, overview] = await Promise.all([
+                accounts.agentAccount.all(),
+                accounts.agentStats.all(),
+                accounts.protocolIndex.all(),
+                client.discovery.getNetworkOverview(),
+            ]);
+            const statsByAgent = new Map(statsAccounts.map(({ account }) => [account.agent.toBase58(), account]));
+            const indexedProtocolsByAgent = buildProtocolMembership(protocolIndexes);
+            const filteredAgents = agentAccounts
+                .map((account) => buildAgentDirectoryEntry(account, statsByAgent, indexedProtocolsByAgent))
+                .filter((entry) => matchesAgentDirectoryFilters(entry, { includeInactive, protocol, capability }))
+                .sort((left, right) => Number(right.createdAt) - Number(left.createdAt));
+            const page = filteredAgents.slice(offset, offset + limit);
+            return {
+                source: 'program.account.agentAccount.all + program.account.protocolIndex.all',
+                overview,
+                filters: {
+                    includeInactive,
+                    protocol: protocol ?? null,
+                    capability: capability ?? null,
+                },
+                totalEnumerated: filteredAgents.length,
+                totalAgentAccounts: agentAccounts.length,
+                activeAgentAccounts: agentAccounts.filter(({ account }) => account.isActive).length,
+                returned: page.length,
+                offset,
+                limit,
+                truncated: offset + page.length < filteredAgents.length,
+                protocolIndexes: includeProtocolIndexes ? summarizeProtocolIndexes(protocolIndexes) : undefined,
+                agents: page,
+                note: 'This is global account enumeration, not filtered DiscoveryRegistry lookup. Use sap_discover_agents for protocol/capability search and sap_fetch_protocol_index when you already know a protocol ID.',
+            };
+        },
+    },
+    {
+        name: 'sap_find_tools_by_category',
+        title: 'Find SAP Tools By Category',
+        description: 'Find on-chain tool descriptors by SDK tool category name or numeric category.',
+        inputSchema: { category: { type: ['string', 'number'], description: 'Tool category name (e.g. "defi", "infrastructure") or numeric category ID' }, hydrate: { type: 'boolean', description: 'Whether to include full hydrated tool descriptors in results (default: true)' }, limit: { type: 'number', description: 'Maximum number of tools to return (default: 50)' } },
+        handler: async (input, client) => {
+            const tools = await client.discovery.findToolsByCategory(requiredToolCategory(input), { hydrate: input.hydrate !== false });
+            const limit = optionalNumber(input, 'limit') ?? 50;
+            return { count: Math.min(tools.length, limit), tools: tools.slice(0, limit) };
+        },
+    },
+    {
+        name: 'sap_get_tool_category_summary',
+        title: 'Get SAP Tool Category Summary',
+        description: 'Fetch SDK discovery summary across SAP tool categories.',
+        inputSchema: {},
+        handler: async (_input, client) => ({ categories: await client.discovery.getToolCategorySummary() }),
+    },
+];
+const indexAndFetchTools = [
+    {
+        name: 'sap_fetch_capability_index',
+        title: 'Fetch Capability Index',
+        description: 'Fetch a SAP capability index by capability ID.',
+        inputSchema: { capabilityId: { type: 'string', description: 'Capability ID to fetch the index for (e.g. "jupiter:swap")' } },
+        handler: async (input, client) => ({ index: await client.indexing.fetchCapabilityIndexNullable(requiredString(input, 'capabilityId')) }),
+    },
+    {
+        name: 'sap_fetch_protocol_index',
+        title: 'Fetch Protocol Index',
+        description: 'Fetch a SAP protocol index by protocol ID.',
+        inputSchema: { protocolId: { type: 'string', description: 'Protocol ID to fetch the index for (e.g. "jupiter", "drift")' } },
+        handler: async (input, client) => ({ index: await client.indexing.fetchProtocolIndexNullable(requiredString(input, 'protocolId')) }),
+    },
+    {
+        name: 'sap_fetch_tool_category_index',
+        title: 'Fetch Tool Category Index',
+        description: 'Fetch a SAP tool category index by numeric category.',
+        inputSchema: { category: { type: 'number', description: 'Numeric tool category ID to fetch the index for' } },
+        handler: async (input, client) => ({ index: await client.indexing.fetchToolCategoryIndexNullable(requiredNumber(input, 'category')) }),
+    },
+    {
+        name: 'sap_fetch_tool',
+        title: 'Fetch SAP Tool Descriptor',
+        description: 'Fetch a tool descriptor by agent PDA and tool name.',
+        inputSchema: { agentPda: { type: 'string', description: 'Agent PDA (base58) that owns the tool descriptor' }, toolName: { type: 'string', description: 'Name of the tool descriptor to fetch' } },
+        handler: async (input, client) => ({
+            tool: await client.tools.fetchNullable(requiredPublicKey(input, 'agentPda'), requiredString(input, 'toolName')),
+        }),
+    },
+    {
+        name: 'sap_fetch_feedback',
+        title: 'Fetch SAP Feedback',
+        description: 'Fetch a feedback PDA by agent PDA and optional reviewer wallet.',
+        inputSchema: { agentPda: { type: 'string', description: 'Agent PDA (base58) to fetch feedback for' }, reviewer: { type: 'string', description: 'Optional reviewer wallet (base58) to filter feedback by' } },
+        handler: async (input, client) => ({
+            feedback: await client.feedback.fetchNullable(requiredPublicKey(input, 'agentPda'), optionalPublicKey(input, 'reviewer')),
+        }),
+    },
+    {
+        name: 'sap_fetch_attestation',
+        title: 'Fetch SAP Attestation',
+        description: 'Fetch an attestation PDA by agent PDA and optional attester wallet.',
+        inputSchema: { agentPda: { type: 'string', description: 'Agent PDA (base58) to fetch attestation for' }, attester: { type: 'string', description: 'Optional attester wallet (base58) to filter attestation by' } },
+        handler: async (input, client) => ({
+            attestation: await client.attestation.fetchNullable(requiredPublicKey(input, 'agentPda'), optionalPublicKey(input, 'attester')),
+        }),
+    },
+    {
+        name: 'sap_fetch_escrow',
+        title: 'Fetch SAP Escrow V1',
+        description: 'Fetch a V1 escrow by escrow PDA, or by agent PDA and optional depositor.',
+        inputSchema: { escrowPda: { type: 'string', description: 'Escrow PDA (base58) to fetch directly' }, agentPda: { type: 'string', description: 'Agent PDA (base58) — used when escrowPda is omitted' }, depositor: { type: 'string', description: 'Optional depositor wallet (base58) to filter by' } },
+        handler: async (input, client) => ({
+            escrow: optionalString(input, 'escrowPda')
+                ? await client.escrow.fetchByPda(requiredPublicKey(input, 'escrowPda'))
+                : await client.escrow.fetchNullable(requiredPublicKey(input, 'agentPda'), optionalPublicKey(input, 'depositor')),
+        }),
+    },
+    {
+        name: 'sap_fetch_escrow_v2',
+        title: 'Fetch SAP Escrow V2',
+        description: 'Fetch a V2 escrow by escrow PDA, or by agent PDA, depositor, and nonce.',
+        inputSchema: { escrowPda: { type: 'string', description: 'Escrow V2 PDA (base58) to fetch directly' }, agentPda: { type: 'string', description: 'Agent PDA (base58) — used when escrowPda is omitted' }, depositor: { type: 'string', description: 'Optional depositor wallet (base58) to filter by' }, nonce: { type: 'number', description: 'Escrow nonce (default: 0) — used with agentPda and depositor' } },
+        handler: async (input, client) => ({
+            escrow: optionalString(input, 'escrowPda')
+                ? await client.escrowV2.fetchByPda(requiredPublicKey(input, 'escrowPda'))
+                : await client.escrowV2.fetchNullable(requiredPublicKey(input, 'agentPda'), optionalPublicKey(input, 'depositor'), optionalBn(input, 'nonce', new BN(0))),
+        }),
+    },
+    {
+        name: 'sap_fetch_pending_settlement',
+        title: 'Fetch Pending Settlement',
+        description: 'Fetch a V2 pending settlement PDA.',
+        inputSchema: { pendingPda: { type: 'string', description: 'Pending settlement PDA (base58) to fetch' } },
+        handler: async (input, client) => ({ pendingSettlement: await client.escrowV2.fetchPendingSettlementNullable(requiredPublicKey(input, 'pendingPda')) }),
+    },
+    {
+        name: 'sap_fetch_dispute',
+        title: 'Fetch SAP Dispute',
+        description: 'Fetch a V2 dispute PDA.',
+        inputSchema: { disputePda: { type: 'string', description: 'Dispute PDA (base58) to fetch' } },
+        handler: async (input, client) => ({ dispute: await client.escrowV2.fetchDisputeNullable(requiredPublicKey(input, 'disputePda')) }),
+    },
+    {
+        name: 'sap_fetch_vault',
+        title: 'Fetch SAP Vault',
+        description: 'Fetch a memory vault by agent PDA.',
+        inputSchema: { agentPda: { type: 'string', description: 'Agent PDA (base58) to fetch the memory vault for' } },
+        handler: async (input, client) => ({ vault: await client.vault.fetchVaultNullable(requiredPublicKey(input, 'agentPda')) }),
+    },
+    {
+        name: 'sap_fetch_session',
+        title: 'Fetch SAP Session',
+        description: 'Fetch a session ledger by session PDA.',
+        inputSchema: { sessionPda: { type: 'string', description: 'Session PDA (base58) to fetch the ledger for' } },
+        handler: async (input, client) => ({ session: await client.vault.fetchSessionByPda(requiredPublicKey(input, 'sessionPda')) }),
+    },
+    {
+        name: 'sap_fetch_epoch_page',
+        title: 'Fetch SAP Epoch Page',
+        description: 'Fetch an epoch page by session PDA and epoch index.',
+        inputSchema: { sessionPda: { type: 'string', description: 'Session PDA (base58) to fetch epoch page for' }, epochIndex: { type: 'number', description: 'Zero-based epoch index to fetch' } },
+        handler: async (input, client) => ({
+            epochPage: await client.vault.fetchEpochPage(requiredPublicKey(input, 'sessionPda'), requiredNumber(input, 'epochIndex')),
+        }),
+    },
+    {
+        name: 'sap_fetch_stake',
+        title: 'Fetch SAP Stake',
+        description: 'Fetch agent stake by stake PDA or agent PDA.',
+        inputSchema: { stakePda: { type: 'string', description: 'Stake PDA (base58) to fetch directly' }, agentPda: { type: 'string', description: 'Agent PDA (base58) — used when stakePda is omitted' } },
+        handler: async (input, client) => ({
+            stake: optionalString(input, 'stakePda')
+                ? await client.staking.fetchByPda(requiredPublicKey(input, 'stakePda'))
+                : await client.staking.fetchNullable(requiredPublicKey(input, 'agentPda')),
+        }),
+    },
+    {
+        name: 'sap_fetch_subscription',
+        title: 'Fetch SAP Subscription',
+        description: 'Fetch a subscription by PDA or by agent PDA/subscriber/subId.',
+        inputSchema: { subscriptionPda: { type: 'string', description: 'Subscription PDA (base58) to fetch directly' }, agentPda: { type: 'string', description: 'Agent PDA (base58) — used when subscriptionPda is omitted' }, subscriber: { type: 'string', description: 'Optional subscriber wallet (base58) to filter by' }, subId: { type: 'number', description: 'Subscription ID (default: 0) — used with agentPda and subscriber' } },
+        handler: async (input, client) => ({
+            subscription: optionalString(input, 'subscriptionPda')
+                ? await client.subscription.fetchByPda(requiredPublicKey(input, 'subscriptionPda'))
+                : await client.subscription.fetchNullable(requiredPublicKey(input, 'agentPda'), optionalPublicKey(input, 'subscriber'), optionalBn(input, 'subId', new BN(0))),
+        }),
+    },
+];
+const paymentAndEscrowTools = [
+    {
+        name: 'sap_create_escrow',
+        title: 'Create SAP Escrow V1',
+        description: 'Create a V1 escrow using SDK EscrowModule.create.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, pricePerCall: { type: 'string', description: 'Price per call in lamports (as a decimal string)' }, maxCalls: { type: 'string', description: 'Maximum number of calls the escrow covers (as a decimal string)' }, initialDeposit: { type: 'string', description: 'Initial deposit amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.escrow.create(requiredPublicKey(input, 'agentWallet'), parseEscrowArgs(input)) }),
+    },
+    {
+        name: 'sap_deposit_escrow',
+        title: 'Deposit SAP Escrow V1',
+        description: 'Deposit funds into a V1 escrow.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, amount: { type: 'string', description: 'Deposit amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.escrow.deposit(requiredPublicKey(input, 'agentWallet'), requiredBn(input, 'amount')) }),
+    },
+    {
+        name: 'sap_settle_escrow',
+        title: 'Settle SAP Escrow V1',
+        description: 'Settle calls against a V1 escrow.',
+        inputSchema: { depositorWallet: { type: 'string', description: 'Depositor wallet public key (base58)' }, callsToSettle: { type: 'string', description: 'Number of calls to settle (as a decimal string)' }, serviceHash: { type: 'array', description: '32-byte service hash as a byte array, hex string, or base64 string' } },
+        handler: async (input, client) => ({
+            signature: await client.escrow.settle(requiredPublicKey(input, 'depositorWallet'), requiredBn(input, 'callsToSettle'), requiredBytes(input, 'serviceHash', 32)),
+        }),
+    },
+    {
+        name: 'sap_settle_escrow_batch',
+        title: 'Batch Settle SAP Escrow V1',
+        description: 'Batch settle V1 escrow entries using SDK EscrowModule.settleBatch.',
+        inputSchema: { depositorWallet: { type: 'string', description: 'Depositor wallet public key (base58)' }, settlements: { type: 'array', description: 'Array of settlement objects, each containing callsToSettle (string) and serviceHash (32-byte array)' }, batchRoot: { type: 'array', description: 'Optional 32-byte Merkle root for batch verification' } },
+        handler: async (input, client) => {
+            if (!Array.isArray(input.settlements)) {
+                throw new Error('settlements must be an array');
+            }
+            return {
+                signature: await client.escrow.settleBatch(requiredPublicKey(input, 'depositorWallet'), input.settlements.map(parseSettlement), input.batchRoot === undefined ? null : requiredBytes(input, 'batchRoot', 32)),
+            };
+        },
+    },
+    {
+        name: 'sap_withdraw_escrow',
+        title: 'Withdraw SAP Escrow V1',
+        description: 'Withdraw funds from a V1 escrow.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, amount: { type: 'string', description: 'Withdrawal amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.escrow.withdraw(requiredPublicKey(input, 'agentWallet'), requiredBn(input, 'amount')) }),
+    },
+    {
+        name: 'sap_close_escrow',
+        title: 'Close SAP Escrow V1',
+        description: 'Close an empty V1 escrow.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' } },
+        handler: async (input, client) => ({ signature: await client.escrow.close(requiredPublicKey(input, 'agentWallet')) }),
+    },
+    {
+        name: 'sap_x402_estimate_cost',
+        title: 'Estimate SAP x402 Cost',
+        description: 'Estimate cost for a number of calls using SDK X402Registry.estimateCost. Reads escrow/pricing when available and supports optional volume curve overrides.',
+        inputSchema: {
+            agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' },
+            calls: { type: 'number', description: 'Number of calls to estimate' },
+            pricePerCall: { type: 'string', description: 'Optional base price per call override in token base units' },
+            totalCallsBefore: { type: 'number', description: 'Optional cumulative settled calls before this estimate' },
+            volumeCurve: { type: 'array', description: 'Optional array of { afterCalls, pricePerCall } pricing breakpoints' },
+        },
+        handler: async (input, client) => ({
+            estimate: await client.x402.estimateCost(requiredPublicKey(input, 'agentWallet'), requiredNumber(input, 'calls'), {
+                pricePerCall: input.pricePerCall === undefined ? undefined : requiredBn(input, 'pricePerCall'),
+                volumeCurve: input.volumeCurve === undefined ? undefined : parseVolumeCurve(input.volumeCurve),
+                totalCallsBefore: optionalNumber(input, 'totalCallsBefore'),
+            }),
+        }),
+    },
+    {
+        name: 'sap_x402_calculate_cost',
+        title: 'Calculate SAP x402 Cost',
+        description: 'Pure local cost calculation using SDK X402Registry.calculateCost; does not read chain state.',
+        inputSchema: {
+            basePrice: { type: 'string', description: 'Base price per call in token base units' },
+            calls: { type: 'number', description: 'Number of calls to calculate' },
+            totalCallsBefore: { type: 'number', description: 'Cumulative settled calls before this calculation (default: 0)' },
+            volumeCurve: { type: 'array', description: 'Array of { afterCalls, pricePerCall } pricing breakpoints' },
+        },
+        handler: async (input, client) => ({
+            estimate: client.x402.calculateCost(requiredBn(input, 'basePrice'), parseVolumeCurve(input.volumeCurve), optionalNumber(input, 'totalCallsBefore') ?? 0, requiredNumber(input, 'calls')),
+        }),
+    },
+    {
+        name: 'sap_x402_prepare_payment',
+        title: 'Prepare SAP x402 Payment V1 Deprecated',
+        description: 'Prepare a V1 x402 payment context using SDK X402Registry.preparePayment. Deprecated by the SDK for production escrow creation; prefer Escrow V2 tools for new flows.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, pricePerCall: { type: 'string', description: 'Price per call as a decimal string' }, deposit: { type: 'string', description: 'Initial deposit amount as a decimal string' }, maxCalls: { type: 'string', description: 'Optional maximum number of calls covered' }, expiresAt: { type: 'string', description: 'Optional expiry timestamp in unix seconds' }, volumeCurve: { type: 'array', description: 'Optional array of { afterCalls, pricePerCall } pricing breakpoints' }, tokenMint: { type: 'string', description: 'Optional SPL token mint; omit/null for SOL' }, tokenDecimals: { type: 'number', description: 'Optional token decimals' }, networkIdentifier: { type: 'string', description: 'Optional x402 network identifier written into headers' } },
+        handler: async (input, client) => ({
+            payment: await client.x402.preparePayment(requiredPublicKey(input, 'agentWallet'), parseX402PreparePaymentOptions(input)),
+        }),
+    },
+    {
+        name: 'sap_x402_build_payment_headers',
+        title: 'Build SAP x402 Payment Headers',
+        description: 'Build SAP x402 HTTP headers from a public PaymentContext returned by sap_x402_prepare_payment.',
+        inputSchema: { escrowPda: { type: 'string', description: 'Escrow PDA (base58)' }, agentPda: { type: 'string', description: 'Agent PDA (base58)' }, agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, depositorWallet: { type: 'string', description: 'Depositor wallet public key (base58)' }, pricePerCall: { type: 'string', description: 'Price per call in token base units' }, maxCalls: { type: 'string', description: 'Max calls as a decimal string' }, txSignature: { type: 'string', description: 'Escrow creation transaction signature' }, networkIdentifier: { type: 'string', description: 'x402 network identifier stored in the payment context' }, network: { type: 'string', description: 'Optional override for X-Payment-Network' } },
+        handler: async (input, client) => ({
+            headers: client.x402.buildPaymentHeaders(parsePaymentContext(input), { network: optionalString(input, 'network') }),
+        }),
+    },
+    {
+        name: 'sap_x402_build_headers_from_escrow',
+        title: 'Build SAP x402 Headers From Escrow',
+        description: 'Build SAP x402 HTTP headers by fetching escrow data for an agent wallet with SDK X402Registry.buildPaymentHeadersFromEscrow.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, network: { type: 'string', description: 'Optional network identifier for X-Payment-Network' } },
+        handler: async (input, client) => ({
+            headers: await client.x402.buildPaymentHeadersFromEscrow(requiredPublicKey(input, 'agentWallet'), {
+                network: optionalString(input, 'network'),
+            }),
+        }),
+    },
+    {
+        name: 'sap_x402_has_escrow',
+        title: 'Check SAP x402 Escrow',
+        description: 'Check whether an x402 escrow exists for an agent/depositor pair.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, depositor: { type: 'string', description: 'Optional depositor wallet (base58); defaults to caller in SDK' } },
+        handler: async (input, client) => ({ exists: await client.x402.hasEscrow(requiredPublicKey(input, 'agentWallet'), optionalPublicKey(input, 'depositor')) }),
+    },
+    {
+        name: 'sap_x402_fetch_escrow',
+        title: 'Fetch SAP x402 Escrow',
+        description: 'Fetch raw x402 escrow account data using SDK X402Registry.fetchEscrow. Resolves V2 first, then V1 fallback.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, depositor: { type: 'string', description: 'Optional depositor wallet (base58); defaults to caller in SDK' } },
+        handler: async (input, client) => ({ escrow: await client.x402.fetchEscrow(requiredPublicKey(input, 'agentWallet'), optionalPublicKey(input, 'depositor')) }),
+    },
+    {
+        name: 'sap_x402_get_balance',
+        title: 'Get SAP x402 Balance',
+        description: 'Fetch x402 escrow balance using SDK X402Registry.getBalance.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, depositor: { type: 'string', description: 'Optional depositor wallet (base58) to filter balance by' } },
+        handler: async (input, client) => ({ balance: await client.x402.getBalance(requiredPublicKey(input, 'agentWallet'), optionalPublicKey(input, 'depositor')) }),
+    },
+    {
+        name: 'sap_x402_settle',
+        title: 'Settle SAP x402 Calls',
+        description: 'Settle served x402 calls through SDK X402Registry.settle. Must be called by the agent owner wallet.',
+        inputSchema: { depositorWallet: { type: 'string', description: 'Depositor wallet public key (base58)' }, callsToSettle: { type: 'number', description: 'Number of calls to settle' }, serviceData: { type: 'string', description: 'Service data to hash into the settlement proof' }, priorityFeeMicroLamports: { type: 'number', description: 'Optional priority fee in microlamports per compute unit' }, computeUnits: { type: 'number', description: 'Optional compute-unit limit' }, skipPreflight: { type: 'boolean', description: 'Optional skip preflight flag' }, commitment: { type: 'string', description: 'Optional processed|confirmed|finalized commitment' }, maxRetries: { type: 'number', description: 'Optional RPC retry limit' } },
+        handler: async (input, client) => ({
+            settlement: await client.x402.settle(requiredPublicKey(input, 'depositorWallet'), requiredNumber(input, 'callsToSettle'), requiredString(input, 'serviceData'), parseSettleOptions(input)),
+        }),
+    },
+    {
+        name: 'sap_x402_settle_batch',
+        title: 'Batch Settle SAP x402 Calls',
+        description: 'Batch-settle served x402 calls through SDK X402Registry.settleBatch. Must be called by the agent owner wallet.',
+        inputSchema: { depositorWallet: { type: 'string', description: 'Depositor wallet public key (base58)' }, entries: { type: 'array', description: 'Array of { calls, serviceData } settlement entries' }, priorityFeeMicroLamports: { type: 'number', description: 'Optional priority fee in microlamports per compute unit' }, computeUnits: { type: 'number', description: 'Optional compute-unit limit' }, skipPreflight: { type: 'boolean', description: 'Optional skip preflight flag' }, commitment: { type: 'string', description: 'Optional processed|confirmed|finalized commitment' }, maxRetries: { type: 'number', description: 'Optional RPC retry limit' } },
+        handler: async (input, client) => ({
+            settlement: await client.x402.settleBatch(requiredPublicKey(input, 'depositorWallet'), parseX402BatchSettlementEntries(input.entries), parseSettleOptions(input)),
+        }),
+    },
+];
+const escrowV2Tools = [
+    {
+        name: 'sap_create_escrow_v2',
+        title: 'Create SAP Escrow V2',
+        description: 'Create a V2 escrow using SDK EscrowV2Module.create.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, pricePerCall: { type: 'string', description: 'Price per call in lamports (as a decimal string)' }, maxCalls: { type: 'string', description: 'Maximum number of calls the escrow covers (as a decimal string)' }, initialDeposit: { type: 'string', description: 'Initial deposit amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.escrowV2.create(requiredPublicKey(input, 'agentWallet'), parseEscrowV2Args(input)) }),
+    },
+    {
+        name: 'sap_deposit_escrow_v2',
+        title: 'Deposit SAP Escrow V2',
+        description: 'Deposit funds into a V2 escrow.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, nonce: { type: 'string', description: 'Escrow nonce (as a decimal string, default: 0)' }, amount: { type: 'string', description: 'Deposit amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.escrowV2.deposit(requiredPublicKey(input, 'agentWallet'), optionalBn(input, 'nonce', new BN(0)), requiredBn(input, 'amount')) }),
+    },
+    {
+        name: 'sap_settle_escrow_v2',
+        title: 'Settle SAP Escrow V2',
+        description: 'Settle calls against a V2 escrow.',
+        inputSchema: { depositorWallet: { type: 'string', description: 'Depositor wallet public key (base58)' }, nonce: { type: 'string', description: 'Escrow nonce (as a decimal string, default: 0)' }, callsToSettle: { type: 'string', description: 'Number of calls to settle (as a decimal string)' }, serviceHash: { type: 'array', description: '32-byte service hash as a byte array, hex string, or base64 string' } },
+        handler: async (input, client) => ({
+            signature: await client.escrowV2.settle(requiredPublicKey(input, 'depositorWallet'), optionalBn(input, 'nonce', new BN(0)), requiredBn(input, 'callsToSettle'), requiredBytes(input, 'serviceHash', 32)),
+        }),
+    },
+    {
+        name: 'sap_next_settlement_index',
+        title: 'Get Next Settlement Index',
+        description: 'Read the next V2 settlement index.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, depositorWallet: { type: 'string', description: 'Depositor wallet public key (base58)' }, nonce: { type: 'string', description: 'Escrow nonce (as a decimal string, default: 0)' } },
+        handler: async (input, client) => ({
+            settlementIndex: await client.escrowV2.nextSettlementIndex(requiredPublicKey(input, 'agentWallet'), requiredPublicKey(input, 'depositorWallet'), optionalBn(input, 'nonce', new BN(0))),
+        }),
+    },
+    {
+        name: 'sap_finalize_settlement_v2',
+        title: 'Finalize SAP Escrow V2 Settlement',
+        description: 'Finalize a V2 pending settlement.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, depositorWallet: { type: 'string', description: 'Depositor wallet public key (base58)' }, nonce: { type: 'string', description: 'Escrow nonce (as a decimal string, default: 0)' }, settlementIndex: { type: 'string', description: 'Settlement index to finalize (as a decimal string)' } },
+        handler: async (input, client) => ({
+            signature: await client.escrowV2.finalizeSettlement(requiredPublicKey(input, 'agentWallet'), requiredPublicKey(input, 'depositorWallet'), optionalBn(input, 'nonce', new BN(0)), requiredBn(input, 'settlementIndex')),
+        }),
+    },
+    {
+        name: 'sap_file_dispute_v2',
+        title: 'File SAP Escrow V2 Dispute',
+        description: 'File a dispute for a V2 pending settlement.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, nonce: { type: 'string', description: 'Escrow nonce (as a decimal string, default: 0)' }, settlementIndex: { type: 'string', description: 'Settlement index to dispute (as a decimal string)' }, evidenceHash: { type: 'array', description: '32-byte evidence hash as a byte array, hex string, or base64 string' }, disputeType: { type: 'number', description: 'Optional dispute type identifier (numeric)' } },
+        handler: async (input, client) => ({
+            signature: await client.escrowV2.fileDispute(requiredPublicKey(input, 'agentWallet'), optionalBn(input, 'nonce', new BN(0)), requiredBn(input, 'settlementIndex'), requiredBytes(input, 'evidenceHash', 32), optionalNumber(input, 'disputeType')),
+        }),
+    },
+    {
+        name: 'sap_withdraw_escrow_v2',
+        title: 'Withdraw SAP Escrow V2',
+        description: 'Withdraw funds from a V2 escrow.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, nonce: { type: 'string', description: 'Escrow nonce (as a decimal string, default: 0)' }, amount: { type: 'string', description: 'Withdrawal amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.escrowV2.withdraw(requiredPublicKey(input, 'agentWallet'), optionalBn(input, 'nonce', new BN(0)), requiredBn(input, 'amount')) }),
+    },
+    {
+        name: 'sap_close_escrow_v2',
+        title: 'Close SAP Escrow V2',
+        description: 'Close a V2 escrow.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, nonce: { type: 'string', description: 'Escrow nonce (as a decimal string, default: 0)' } },
+        handler: async (input, client) => ({ signature: await client.escrowV2.close(requiredPublicKey(input, 'agentWallet'), optionalBn(input, 'nonce', new BN(0))) }),
+    },
+];
+const reputationAndTrustTools = [
+    {
+        name: 'sap_give_feedback',
+        title: 'Give SAP Feedback',
+        description: 'Create on-chain feedback for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58) to give feedback for' }, score: { type: 'number', description: 'Feedback score (numeric, e.g. 1–5)' }, tag: { type: 'string', description: 'Optional feedback tag/category (default: "general")' }, commentHash: { type: 'array', description: 'Optional 32-byte comment hash as a byte array, hex string, or base64 string' } },
+        handler: async (input, client) => ({ signature: await client.feedback.give(requiredPublicKey(input, 'agentWallet'), parseFeedbackArgs(input)) }),
+    },
+    {
+        name: 'sap_update_feedback',
+        title: 'Update SAP Feedback',
+        description: 'Update existing on-chain feedback for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58) to update feedback for' }, score: { type: 'number', description: 'New feedback score (numeric, e.g. 1–5)' }, tag: { type: 'string', description: 'Optional new feedback tag/category' }, commentHash: { type: 'array', description: 'Optional 32-byte comment hash as a byte array, hex string, or base64 string' } },
+        handler: async (input, client) => ({ signature: await client.feedback.update(requiredPublicKey(input, 'agentWallet'), parseUpdateFeedbackArgs(input)) }),
+    },
+    {
+        name: 'sap_revoke_feedback',
+        title: 'Revoke SAP Feedback',
+        description: 'Revoke feedback for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58) to revoke feedback for' } },
+        handler: async (input, client) => ({ signature: await client.feedback.revoke(requiredPublicKey(input, 'agentWallet')) }),
+    },
+    {
+        name: 'sap_create_attestation',
+        title: 'Create SAP Attestation',
+        description: 'Create an on-chain attestation for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58) to create attestation for' }, attestationType: { type: 'string', description: 'Optional attestation type string (default: "generic")' }, metadataHash: { type: 'array', description: '32-byte metadata hash as a byte array, hex string, or base64 string' }, expiresAt: { type: 'string', description: 'Optional expiry timestamp (as a decimal string, 0 = no expiry)' } },
+        handler: async (input, client) => ({ signature: await client.attestation.create(requiredPublicKey(input, 'agentWallet'), parseAttestationArgs(input)) }),
+    },
+    {
+        name: 'sap_revoke_attestation',
+        title: 'Revoke SAP Attestation',
+        description: 'Revoke attestation for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58) to revoke attestation for' } },
+        handler: async (input, client) => ({ signature: await client.attestation.revoke(requiredPublicKey(input, 'agentWallet')) }),
+    },
+    {
+        name: 'sap_fairscale_score',
+        title: 'Get FairScale Score',
+        description: 'Score an agent with SDK FairScaleRegistry.score.',
+        inputSchema: { agent: { type: 'string', description: 'Agent PDA or wallet (base58) to score' }, task: { type: 'string', description: 'Optional FairScale task type: one of "defi_execution", "trust_focused", "work_focused", "hiring"' } },
+        handler: async (input, client) => ({ score: await client.fairscale.score(requiredString(input, 'agent'), { task: optionalFairScaleTask(input, 'task') }) }),
+    },
+    {
+        name: 'sap_fairscale_trust_gate',
+        title: 'FairScale Trust Gate',
+        description: 'Evaluate an agent with SDK FairScaleRegistry.trustGate.',
+        inputSchema: { agent: { type: 'string', description: 'Agent PDA or wallet (base58) to evaluate' }, minScore: { type: 'number', description: 'Optional minimum trust score threshold' }, requireVerification: { type: 'boolean', description: 'Whether verified status is required to pass the gate (default: false)' } },
+        handler: async (input, client) => ({
+            result: await client.fairscale.trustGate(requiredString(input, 'agent'), {
+                minScore: optionalNumber(input, 'minScore'),
+                requireVerification: input.requireVerification === true,
+            }),
+        }),
+    },
+];
+const vaultSessionTools = [
+    {
+        name: 'sap_init_vault',
+        title: 'Initialize SAP Vault',
+        description: 'Initialize a memory vault for the connected agent.',
+        inputSchema: { vaultNonce: { type: 'array', description: 'Vault nonce as a byte array, hex string, or base64 string' } },
+        handler: async (input, client) => ({ signature: await client.vault.initVault(requiredBytes(input, 'vaultNonce')) }),
+    },
+    {
+        name: 'sap_open_vault_session',
+        title: 'Open SAP Vault Session',
+        description: 'Open a vault session by 32-byte session hash.',
+        inputSchema: { sessionHash: { type: 'array', description: '32-byte session hash as a byte array, hex string, or base64 string' } },
+        handler: async (input, client) => ({ signature: await client.vault.openSession(requiredBytes(input, 'sessionHash', 32)) }),
+    },
+    {
+        name: 'sap_inscribe_memory',
+        title: 'Inscribe SAP Memory',
+        description: 'Inscribe encrypted memory using SDK VaultModule.inscribe.',
+        inputSchema: { type: 'object', additionalProperties: true, description: 'Object containing memory inscription fields: sequence (number), encryptedData (byte array), nonce (byte array), contentHash (32-byte array), and optional totalFragments, fragmentIndex, compression, epochIndex' },
+        handler: async (input, client) => ({ signature: await client.vault.inscribe(parseMemoryArgs(input)) }),
+    },
+    {
+        name: 'sap_compact_inscribe_memory',
+        title: 'Compact Inscribe SAP Memory',
+        description: 'Compact memory inscription with explicit vault/session PDAs.',
+        inputSchema: { sessionPda: { type: 'string', description: 'Session PDA (base58) for the memory inscription' }, vaultPda: { type: 'string', description: 'Vault PDA (base58) for the memory inscription' }, encryptedData: { type: 'array', description: 'Encrypted memory data as a byte array, hex string, or base64 string' }, nonce: { type: 'array', description: 'Encryption nonce as a byte array, hex string, or base64 string' }, contentHash: { type: 'array', description: '32-byte content hash as a byte array, hex string, or base64 string' } },
+        handler: async (input, client) => ({
+            signature: await client.vault.compactInscribe(requiredPublicKey(input, 'sessionPda'), requiredPublicKey(input, 'vaultPda'), parseCompactMemoryArgs(input)),
+        }),
+    },
+    {
+        name: 'sap_session_start',
+        title: 'Start SAP Memory Session',
+        description: 'Start a high-level SDK session by session ID.',
+        inputSchema: { sessionId: { type: 'string', description: 'High-level session identifier string' }, vaultNonce: { type: 'array', description: 'Optional vault nonce as a byte array, hex string, or base64 string' } },
+        handler: async (input, client) => ({
+            session: await client.session.start(requiredString(input, 'sessionId'), optionalBytes(input, 'vaultNonce', [])),
+        }),
+    },
+    {
+        name: 'sap_session_read_latest',
+        title: 'Read Latest SAP Session Entries',
+        description: 'Read latest entries from a high-level SDK session ID.',
+        inputSchema: { sessionId: { type: 'string', description: 'High-level session identifier string to read latest entries from' } },
+        handler: async (input, client) => {
+            const ctx = client.session.deriveContext(requiredString(input, 'sessionId'));
+            return { entries: await client.session.readLatest(ctx) };
+        },
+    },
+    {
+        name: 'sap_session_status',
+        title: 'Get SAP Session Status',
+        description: 'Fetch high-level SDK session status by session ID.',
+        inputSchema: { sessionId: { type: 'string', description: 'High-level session identifier string to get status for' } },
+        handler: async (input, client) => {
+            const ctx = client.session.deriveContext(requiredString(input, 'sessionId'));
+            return { status: await client.session.getStatus(ctx) };
+        },
+    },
+];
+const toolRegistryTools = [
+    {
+        name: 'sap_publish_tool_by_name',
+        title: 'Publish SAP Tool By Name',
+        description: 'Publish a tool descriptor using SDK ToolsModule.publishByName.',
+        inputSchema: {
+            toolName: { type: 'string', description: 'Name of the tool to publish' },
+            protocolId: { type: 'string', description: 'Protocol ID the tool belongs to (e.g. "jupiter")' },
+            description: { type: 'string', description: 'Human-readable description of the tool' },
+            inputSchemaJson: { type: 'string', description: 'JSON string of the tool input schema' },
+            outputSchemaJson: { type: 'string', description: 'JSON string of the tool output schema' },
+            httpMethod: { type: 'number', description: 'HTTP method code (e.g. 0=GET, 1=POST)' },
+            category: { type: 'number', description: 'Numeric tool category ID' },
+            paramsCount: { type: 'number', description: 'Total number of parameters the tool accepts' },
+            requiredParams: { type: 'number', description: 'Number of required parameters' },
+            isCompound: { type: 'boolean', description: 'Whether the tool is a compound tool (default: false)' },
+        },
+        handler: async (input, client) => ({
+            signature: await client.tools.publishByName(requiredString(input, 'toolName'), requiredString(input, 'protocolId'), requiredString(input, 'description'), requiredString(input, 'inputSchemaJson'), requiredString(input, 'outputSchemaJson'), requiredNumber(input, 'httpMethod'), requiredNumber(input, 'category'), requiredNumber(input, 'paramsCount'), requiredNumber(input, 'requiredParams'), input.isCompound === true),
+        }),
+    },
+    {
+        name: 'sap_update_tool',
+        title: 'Update SAP Tool',
+        description: 'Update tool descriptor hashes using SDK ToolsModule.update.',
+        inputSchema: { toolName: { type: 'string', description: 'Name of the tool to update' }, type: 'object', additionalProperties: true, description: 'Object containing optional update fields: descriptionHash, inputSchemaHash, outputSchemaHash (32-byte arrays), httpMethod, category, paramsCount, requiredParams (numbers)' },
+        handler: async (input, client) => ({ signature: await client.tools.update(requiredString(input, 'toolName'), parseUpdateToolArgs(input)) }),
+    },
+    {
+        name: 'sap_deactivate_tool',
+        title: 'Deactivate SAP Tool',
+        description: 'Deactivate a SAP tool descriptor by name.',
+        inputSchema: { toolName: { type: 'string', description: 'Name of the tool descriptor to deactivate' } },
+        handler: async (input, client) => ({ signature: await client.tools.deactivate(requiredString(input, 'toolName')) }),
+    },
+    {
+        name: 'sap_reactivate_tool',
+        title: 'Reactivate SAP Tool',
+        description: 'Reactivate a SAP tool descriptor by name.',
+        inputSchema: { toolName: { type: 'string', description: 'Name of the tool descriptor to reactivate' } },
+        handler: async (input, client) => ({ signature: await client.tools.reactivate(requiredString(input, 'toolName')) }),
+    },
+    {
+        name: 'sap_report_tool_invocations',
+        title: 'Report SAP Tool Invocations',
+        description: 'Report invocation count for a SAP tool descriptor.',
+        inputSchema: { toolName: { type: 'string', description: 'Name of the tool descriptor to report invocations for' }, invocations: { type: 'number', description: 'Number of invocations to report' } },
+        handler: async (input, client) => ({
+            signature: await client.tools.reportInvocations(requiredString(input, 'toolName'), requiredNumber(input, 'invocations')),
+        }),
+    },
+];
+const stakingAndSubscriptionTools = [
+    {
+        name: 'sap_init_stake',
+        title: 'Initialize SAP Stake',
+        description: 'Initialize stake for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58) to initialize stake for' }, initialDeposit: { type: 'string', description: 'Initial stake deposit amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.staking.initStake(requiredPublicKey(input, 'agentWallet'), requiredBn(input, 'initialDeposit')) }),
+    },
+    {
+        name: 'sap_deposit_stake',
+        title: 'Deposit SAP Stake',
+        description: 'Deposit additional stake for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, amount: { type: 'string', description: 'Additional stake deposit amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.staking.deposit(requiredPublicKey(input, 'agentWallet'), requiredBn(input, 'amount')) }),
+    },
+    {
+        name: 'sap_request_unstake',
+        title: 'Request SAP Unstake',
+        description: 'Request unstake for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, amount: { type: 'string', description: 'Unstake request amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.staking.requestUnstake(requiredPublicKey(input, 'agentWallet'), requiredBn(input, 'amount')) }),
+    },
+    {
+        name: 'sap_complete_unstake',
+        title: 'Complete SAP Unstake',
+        description: 'Complete unstake for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58) to complete unstaking for' } },
+        handler: async (input, client) => ({ signature: await client.staking.completeUnstake(requiredPublicKey(input, 'agentWallet')) }),
+    },
+    {
+        name: 'sap_create_subscription',
+        title: 'Create SAP Subscription',
+        description: 'Create a recurring subscription for an agent wallet.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58) to create subscription for' }, subId: { type: 'string', description: 'Subscription ID (as a decimal string, default: 0)' }, pricePerInterval: { type: 'string', description: 'Price per billing interval in lamports (as a decimal string)' }, billingInterval: { type: 'number', description: 'Billing interval in seconds between charges' }, initialFund: { type: 'string', description: 'Initial fund amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({ signature: await client.subscription.create(requiredPublicKey(input, 'agentWallet'), parseSubscriptionArgs(input)) }),
+    },
+    {
+        name: 'sap_fund_subscription',
+        title: 'Fund SAP Subscription',
+        description: 'Fund a recurring subscription.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, subId: { type: 'string', description: 'Subscription ID (as a decimal string, default: 0)' }, amount: { type: 'string', description: 'Funding amount in lamports (as a decimal string)' } },
+        handler: async (input, client) => ({
+            signature: await client.subscription.fund(requiredPublicKey(input, 'agentWallet'), optionalBn(input, 'subId', new BN(0)), requiredBn(input, 'amount')),
+        }),
+    },
+    {
+        name: 'sap_cancel_subscription',
+        title: 'Cancel SAP Subscription',
+        description: 'Cancel a recurring subscription.',
+        inputSchema: { agentWallet: { type: 'string', description: 'Agent wallet public key (base58)' }, subId: { type: 'string', description: 'Subscription ID (as a decimal string, default: 0)' } },
+        handler: async (input, client) => ({
+            signature: await client.subscription.cancel(requiredPublicKey(input, 'agentWallet'), optionalBn(input, 'subId', new BN(0))),
+        }),
+    },
+];
+const sapToolGroups = [
+    agentTools,
+    discoveryTools,
+    indexAndFetchTools,
+    paymentAndEscrowTools,
+    escrowV2Tools,
+    reputationAndTrustTools,
+    vaultSessionTools,
+    toolRegistryTools,
+    stakingAndSubscriptionTools,
+];
+/**
+ * @name registerSapSdkTools
+ * @description Registers production SAP SDK-backed tools using the public SDK v0.20 client surface.
+ */
+export function registerSapSdkTools(server, _context) {
+    logger.info('Registering SAP SDK tools');
+    if (!isSapClientInitialized()) {
+        logger.warn('SAP client not initialized - skipping SDK tools');
+        return;
+    }
+    const client = getSapClient();
+    let count = 0;
+    for (const group of sapToolGroups) {
+        for (const tool of group) {
+            registerSapTool(server, client, tool);
+            count++;
+        }
+    }
+    logger.info('SAP SDK tools registered', { count });
+}
+//# sourceMappingURL=sap-sdk-tools.js.map