@ziggs-ai/ziggs-mcp 0.3.2 → 0.5.0

package/dist/capabilityAdapter.d.ts

@@ -0,0 +1,25 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type ZodRawShape } from 'zod';
+import type { CapabilityDefinition, CapabilityParam, Creds } from '@ziggs-ai/api-client';
+/** One JSON text-content result shape for every MCP tool (was copied 3×). */
+export declare function textResult(data: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export declare function toZodShape(params: Record<string, CapabilityParam>): ZodRawShape;
+export interface RegisterCapabilityOptions {
+    /** Web-app origin for human-facing URLs (claim links etc.). */
+    webUrl?: string;
+    /**
+     * Description override for wording assembled from MCP-local shared consts
+     * (e.g. the delegate-protocol reporting rule, ZIG-557) — schema and handler
+     * still come from the shared definition.
+     */
+    description?: string;
+    /** Surface-local response decoration (e.g. the read-plan on ziggs_read_context). */
+    transformResult?: (result: unknown, args: Record<string, unknown>) => unknown;
+}
+export declare function registerCapability(server: McpServer, cap: CapabilityDefinition, creds: Creds, opts?: RegisterCapabilityOptions): void;
+export declare function registerCapabilities(server: McpServer, caps: CapabilityDefinition[], creds: Creds, opts?: RegisterCapabilityOptions): void;

package/dist/capabilityAdapter.js

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { READ_ONLY, WRITE, DESTRUCTIVE } from './toolAnnotations.js';
+import { toolError } from './toolError.js';
+/** One JSON text-content result shape for every MCP tool (was copied 3×). */
+export function textResult(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    };
+}
+/**
+ * ZIG-956 — the MCP surface adapter for shared capability definitions
+ * (api-client `capabilities/`). Lowers the neutral param DSL to zod v3 (the
+ * MCP SDK's ZodRawShape; api-client itself carries no zod, and agent-sdk is on
+ * zod v4, so the schema is defined once and lowered per surface).
+ */
+function zodParam(param) {
+    let t;
+    switch (param.type) {
+        case 'string':
+            t = param.enum ? z.enum(param.enum) : z.string();
+            break;
+        case 'number':
+            t = z.number();
+            break;
+        case 'boolean':
+            t = z.boolean();
+            break;
+        case 'object':
+            t = z.record(z.unknown());
+            break;
+        case 'array': {
+            const items = param.items;
+            const inner = items?.type === 'string'
+                ? items.enum
+                    ? z.enum(items.enum)
+                    : z.string()
+                : z.record(z.unknown());
+            t = z.array(inner);
+            break;
+        }
+    }
+    if (param.description)
+        t = t.describe(param.description);
+    if (!param.required)
+        t = t.optional();
+    return t;
+}
+export function toZodShape(params) {
+    const shape = {};
+    for (const [name, param] of Object.entries(params)) {
+        shape[name] = zodParam(param);
+    }
+    return shape;
+}
+export function registerCapability(server, cap, creds, opts = {}) {
+    const annotations = cap.annotation === 'read-only'
+        ? READ_ONLY
+        : cap.annotation === 'destructive'
+            ? DESTRUCTIVE
+            : WRITE;
+    server.tool(cap.names.mcp, opts.description ?? cap.descriptions.mcp, toZodShape(cap.params), annotations, async (args) => {
+        try {
+            const env = { creds, webUrl: opts.webUrl, surface: 'mcp' };
+            const result = await cap.handler(args, env);
+            return textResult(opts.transformResult ? opts.transformResult(result, args) : result);
+        }
+        catch (e) {
+            return toolError(e.message);
+        }
+    });
+}
+export function registerCapabilities(server, caps, creds, opts = {}) {
+    for (const cap of caps)
+        registerCapability(server, cap, creds, opts);
+}

package/dist/inboxToolResult.d.ts

@@ -21,16 +21,15 @@ export interface ReadPlanResult {
 /**
  * ZIG-634: replace the free-text `nextActions` hints with typed `readPlan`
  * call objects — tool name + pre-filled args — so the most common loop
- * (inbox → read each chat with news → ack) needs no guesswork.
+ * (inbox → read what was addressed to you → ack) needs no guesswork.
  *
  * Safe by construction: every entry is synthesized purely from fields already
- * on the envelope (scope kinds, ids, per-chat counts, latestAt). No new data
- * is read and no new permission check runs — this is the same information the
- * caller already received, restated as runnable calls.
+ * on the envelope (delivery kinds and ids, the per-chat fold, ackTo). No new
+ * data is read and no new permission check runs — this is the same information
+ * the caller already received, restated as runnable calls.
  *
  * Mapping honours how reads resolve server-side: messages read only via chat,
- * artifacts via chat or agreement. For multi-chat scopes (org / agreement) we
- * use the per-chat breakdown (ZIG-543) to name the chatIds.
+ * artifacts via chat or agreement.
  */
 export declare function buildReadPlan(inbox: InboxEnvelope, grantsByScope?: Map<string, ScopeGrantTag>): ReadPlanResult;
 /**
@@ -70,7 +69,8 @@ export declare function indexReachByScope(reach: GrantView[]): Map<string, Scope
  * and append readPlan last so each inbox call self-narrates the follow-up
  * calls (ZIG-634) without disturbing the leading humanAttention key.
  *
- * When `reach` (the caller's own live grants) is passed, each scope is tagged
- * with its covering grant (ZIG-635) so the agent can pin X-Context-Grant-Id.
+ * When `reach` (the caller's own live grants) is passed, the read plan pins
+ * each read's covering grant (ZIG-635) so the agent can present
+ * X-Context-Grant-Id without a separate discover round-trip.
  */
 export declare function formatInboxToolResult(inbox: InboxEnvelope, ack?: InboxAckResult | null, webOrigin?: string, activeTasks?: Task[], reach?: GrantView[], activeTasksError?: string): Record<string, unknown>;

package/dist/inboxToolResult.js

@@ -1,6 +1,6 @@
 import { grantCaveat } from '@ziggs-ai/api-client';
 import { formatPendingDecisionsPayload, resolveWebAppOrigin, } from './pendingDecisions.js';
-/** Keep the plan bounded; the full scopes array still carries everything. */
+/** Keep the plan bounded; the full deliveries array still carries everything. */
 const MAX_READ_PLAN = 12;
 function readContextCall(type, kind, id, grantId) {
     // ZIG-660: pin the covering grant so the read presents the right
@@ -15,25 +15,24 @@ function readContextCall(type, kind, id, grantId) {
 /**
  * ZIG-634: replace the free-text `nextActions` hints with typed `readPlan`
  * call objects — tool name + pre-filled args — so the most common loop
- * (inbox → read each chat with news → ack) needs no guesswork.
+ * (inbox → read what was addressed to you → ack) needs no guesswork.
  *
  * Safe by construction: every entry is synthesized purely from fields already
- * on the envelope (scope kinds, ids, per-chat counts, latestAt). No new data
- * is read and no new permission check runs — this is the same information the
- * caller already received, restated as runnable calls.
+ * on the envelope (delivery kinds and ids, the per-chat fold, ackTo). No new
+ * data is read and no new permission check runs — this is the same information
+ * the caller already received, restated as runnable calls.
  *
  * Mapping honours how reads resolve server-side: messages read only via chat,
- * artifacts via chat or agreement. For multi-chat scopes (org / agreement) we
- * use the per-chat breakdown (ZIG-543) to name the chatIds.
+ * artifacts via chat or agreement.
  */
 export function buildReadPlan(inbox, grantsByScope) {
     const proposals = inbox.proposalsAwaitingMe ?? [];
     const connectionRequests = inbox.connectionRequestsAwaitingMe ?? [];
-    const scopes = inbox.scopes ?? [];
+    const deliveries = inbox.deliveries ?? [];
     // ZIG-660: dedup by call signature so the same (type, via) can't appear
-    // twice when one chat is covered by both its own grant and an org/agreement
-    // grant. Collect candidates uncapped; the cap is applied once, after the ack
-    // is reserved, so the ack step always survives.
+    // twice when several deliveries land in one chat. Collect candidates
+    // uncapped; the cap is applied once, after the ack is reserved, so the ack
+    // step always survives.
     const candidates = [];
     const seen = new Set();
     const add = (key, call) => {
@@ -58,57 +57,35 @@ export function buildReadPlan(inbox, grantsByScope) {
             why: 'connection request awaiting your response — wait for the human to approve/reject',
         });
     }
-    // The covering grant for reads derived from a scope is that scope's own grant
-    // (ZIG-635) — the same grant tagged onto the scope entry.
-    const grantFor = (s) => grantsByScope?.get(`${s.scope.kind}:${s.scope.id}`)?.grantId;
-    // Reads — point each scope's news at the call that opens it.
-    for (const s of scopes) {
-        const { kind, id } = s.scope;
-        const grantId = grantFor(s);
-        const read = (type, viaKind, viaId) => add(`read:${type}:${viaKind}:${viaId}`, readContextCall(type, viaKind, viaId, grantId));
-        if (kind === 'chat') {
-            if (s.newMessages)
-                read('messages', 'chat', id);
-            if (s.newArtifacts)
-                read('artifacts', 'chat', id);
-        }
-        else if (kind === 'agreement') {
-            // Messages resolve only via chat — name the chats from the breakdown.
-            for (const c of s.chats ?? []) {
-                if (c.newMessages)
-                    read('messages', 'chat', c.chatId);
-            }
-            // Artifacts (incl. task-result artifacts) read directly via the agreement.
-            if (s.newArtifacts)
-                read('artifacts', 'agreement', id);
-        }
-        else {
-            // org: both messages and artifacts resolve per chat only.
-            for (const c of s.chats ?? []) {
-                if (c.newMessages)
-                    read('messages', 'chat', c.chatId);
-                if (c.newArtifacts)
-                    read('artifacts', 'chat', c.chatId);
-            }
+    // ZIG-635: pin the covering grant for a chat/agreement read when the caller
+    // holds one, so the read presents the right X-Context-Grant-Id without a
+    // separate discover round-trip. Untagged reads still work by id.
+    const grantFor = (kind, id) => grantsByScope?.get(`${kind}:${id}`)?.grantId;
+    const read = (type, viaKind, viaId) => add(`read:${type}:${viaKind}:${viaId}`, readContextCall(type, viaKind, viaId, grantFor(viaKind, viaId)));
+    // Reads — one call per place mail actually landed. The delivery names the
+    // chat or agreement directly, so nothing has to be inferred from a scope.
+    for (const d of deliveries) {
+        if (d.kind === 'message' && d.chatId)
+            read('messages', 'chat', d.chatId);
+        else if (d.kind === 'artifact') {
+            if (d.chatId)
+                read('artifacts', 'chat', d.chatId);
+            else if (d.agreementId)
+                read('artifacts', 'agreement', d.agreementId);
         }
     }
-    // Close the loop: reading never clears the inbox — pre-fill the ack call with
-    // each scope's own latestAt (only scopes that actually have a high-water mark).
-    const ackTargets = scopes
-        .filter((s) => s.latestAt)
-        .map((s) => ({ kind: s.scope.kind, id: s.scope.id, upTo: s.latestAt }));
     // ZIG-660: reserve a slot for the ack before capping, so the pre-filled ack
     // never gets squeezed out exactly when there's the most news. Report how many
     // read/decision candidates the cap dropped as an explicit count.
-    const reserve = ackTargets.length ? 1 : 0;
+    const reserve = inbox.ackTo ? 1 : 0;
     const budget = Math.max(0, MAX_READ_PLAN - reserve);
     const truncated = Math.max(0, candidates.length - budget);
     const plan = candidates.slice(0, budget);
-    if (ackTargets.length) {
+    if (inbox.ackTo) {
         plan.push({
             tool: 'ziggs_inbox',
-            args: { ack: ackTargets },
-            why: 'reading does not clear the inbox — ack the scopes you handled (drop any you did not)',
+            args: { ack: inbox.ackTo },
+            why: 'reading does not clear the inbox — ack once you have handled everything above',
         });
     }
     return { plan, truncated };
@@ -186,34 +163,18 @@ export function indexReachByScope(reach) {
     }
     return byScope;
 }
-/**
- * ZIG-635: tag each inbox scope with its covering grant. Scopes with no
- * matching live grant (e.g. reachable via membership, not a grant) are left
- * untagged — the agent keeps navigating by id, never a fabricated grant.
- */
-function tagScopesWithGrants(scopes, byScope) {
-    if (!byScope?.size)
-        return scopes;
-    return scopes.map((s) => {
-        const tag = byScope.get(`${s.scope.kind}:${s.scope.id}`);
-        return tag ? { ...s, grant: tag } : s;
-    });
-}
 /**
  * Put humanAttention first so MCP hosts surface it before counts (ZIG-482),
  * and append readPlan last so each inbox call self-narrates the follow-up
  * calls (ZIG-634) without disturbing the leading humanAttention key.
  *
- * When `reach` (the caller's own live grants) is passed, each scope is tagged
- * with its covering grant (ZIG-635) so the agent can pin X-Context-Grant-Id.
+ * When `reach` (the caller's own live grants) is passed, the read plan pins
+ * each read's covering grant (ZIG-635) so the agent can present
+ * X-Context-Grant-Id without a separate discover round-trip.
  */
 export function formatInboxToolResult(inbox, ack, webOrigin, activeTasks, reach, activeTasksError) {
-    // ZIG-660: build the grant index once and feed both the read plan (grant
-    // pinning) and the scope tags from it — buildReadPlan no longer runs before
-    // the grants are available.
     const byScope = reach?.length ? indexReachByScope(reach) : undefined;
     const { plan: readPlan, truncated: readPlanTruncated } = buildReadPlan(inbox, byScope);
-    const scopes = tagScopesWithGrants(inbox.scopes ?? [], byScope);
     const origin = resolveWebAppOrigin(webOrigin);
     // ZIG-659: the inbox reports session-start counts and points to
     // ziggs_pending_decisions for the sessionChatCard — it no longer re-emits the
@@ -248,11 +209,7 @@ export function formatInboxToolResult(inbox, ack, webOrigin, activeTasks, reach,
     };
     const { humanAttention, ...rest } = inbox;
     const payload = ack
-        ? { acked: ack.acked, ...rest, scopes, ...tail }
-        : { ...rest, scopes, ...tail };
-    return humanAttention
-        ? { humanAttention, ...payload }
-        : ack
-            ? payload
-            : { ...inbox, scopes, ...tail };
+        ? { ackedUpTo: ack.ackedUpTo, ...rest, ...tail }
+        : { ...rest, ...tail };
+    return humanAttention ? { humanAttention, ...payload } : payload;
 }

package/dist/paymentTools.d.ts

@@ -1,13 +1,14 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type Creds } from '@ziggs-ai/api-client';
 /**
- * ZIG-896 — the wallet toolset on the MCP surface, same base names as the SDK's
- * PAYMENT_TOOLS (payment_* → ziggs_payment_*), riding the shared PaymentsClient
- * (ZIG-894). Safety is unchanged: money-moving calls are policy-gated
- * server-side (transfers above threshold return `approval_required`; the human
- * decides on the wallet page — surfaced by ziggs_pending_decisions), and rails
- * stay gated by the operator key's payments scopes. There is deliberately NO
- * approve/decide tool on either agent surface — an agent must not approve its
- * own spend.
+ * ZIG-896 / ZIG-956 — the wallet toolset on the MCP surface, same base names
+ * as the SDK's PAYMENT_TOOLS (payment_* → ziggs_payment_*), now registered
+ * from the shared capability definitions in api-client (one schema + handler,
+ * two thin surface adapters). Safety is unchanged: money-moving calls are
+ * policy-gated server-side (transfers above threshold return
+ * `approval_required`; the human decides on the wallet page — surfaced by
+ * ziggs_pending_decisions), and rails stay gated by the operator key's
+ * payments scopes. There is deliberately NO approve/decide tool on either
+ * agent surface — an agent must not approve its own spend.
  */
 export declare function registerPaymentTools(server: McpServer, creds: Creds): void;

package/dist/paymentTools.js

@@ -1,252 +1,16 @@
-import { z } from 'zod';
-import { PaymentsClient } from '@ziggs-ai/api-client';
-import { READ_ONLY, WRITE, DESTRUCTIVE } from './toolAnnotations.js';
-import { toolError } from './toolError.js';
-function textResult(data) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-    };
-}
-function buildCaveats(args) {
-    const caveats = [];
-    if (args.maxAmount != null)
-        caveats.push({ type: 'max_amount', value: args.maxAmount });
-    if (args.dailyBudget != null)
-        caveats.push({ type: 'daily_budget', value: args.dailyBudget });
-    if (args.allowedRecipients != null)
-        caveats.push({ type: 'allowed_recipients', value: args.allowedRecipients });
-    if (args.expiresInSeconds != null)
-        caveats.push({ type: 'expires_at', value: Date.now() + args.expiresInSeconds * 1000 });
-    return caveats;
-}
+import { PAYMENT_CAPABILITIES } from '@ziggs-ai/api-client';
+import { registerCapabilities } from './capabilityAdapter.js';
 /**
- * ZIG-896 — the wallet toolset on the MCP surface, same base names as the SDK's
- * PAYMENT_TOOLS (payment_* → ziggs_payment_*), riding the shared PaymentsClient
- * (ZIG-894). Safety is unchanged: money-moving calls are policy-gated
- * server-side (transfers above threshold return `approval_required`; the human
- * decides on the wallet page — surfaced by ziggs_pending_decisions), and rails
- * stay gated by the operator key's payments scopes. There is deliberately NO
- * approve/decide tool on either agent surface — an agent must not approve its
- * own spend.
+ * ZIG-896 / ZIG-956 — the wallet toolset on the MCP surface, same base names
+ * as the SDK's PAYMENT_TOOLS (payment_* → ziggs_payment_*), now registered
+ * from the shared capability definitions in api-client (one schema + handler,
+ * two thin surface adapters). Safety is unchanged: money-moving calls are
+ * policy-gated server-side (transfers above threshold return
+ * `approval_required`; the human decides on the wallet page — surfaced by
+ * ziggs_pending_decisions), and rails stay gated by the operator key's
+ * payments scopes. There is deliberately NO approve/decide tool on either
+ * agent surface — an agent must not approve its own spend.
  */
 export function registerPaymentTools(server, creds) {
-    const client = () => new PaymentsClient(creds.operatorKey, creds.agentId);
-    server.tool('ziggs_payment_balance', "Check the caller's current wallet balance and available balance (total minus active holds). Use before a transfer to confirm sufficient funds.", {}, READ_ONLY, async () => {
-        try {
-            return textResult(await client().balance());
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_payment_resolve_wallet', 'Look up a walletId by userId or agentId. Use before a transfer when you only know the recipient by their platform ID.', {
-        userId: z.string().optional().describe('User to resolve'),
-        agentId: z.string().optional().describe('Agent to resolve'),
-    }, READ_ONLY, async ({ userId, agentId }) => {
-        if (!userId && !agentId) {
-            return toolError('Provide userId or agentId to resolve a wallet');
-        }
-        try {
-            const wallet = (await client().resolve({ userId, agentId }));
-            return textResult({
-                walletId: wallet?.['walletId'] || null,
-                ownerId: wallet?.['ownerId'] || null,
-                currency: wallet?.['currency'] || 'pez',
-                status: wallet?.['status'] || null,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_payment_transfer', 'Transfer funds to another wallet. Amounts are integer cents. As a delegate you spend under a payment grant the wallet owner issued (paymentGrantId — find yours via ziggs_list_grants scopeKind=wallet). Transfers above the owner\'s policy pause with status "approval_required": the human approves on the wallet page (it also shows in ziggs_pending_decisions) — you can wait inline with ziggs_payment_wait_for_approval, and you must NEVER approve your own transfer.', {
-        toWalletId: z
-            .string()
-            .describe('Destination wal_... id — or a userId/agentId to auto-resolve'),
-        amount: z.number().describe('Amount in integer cents, > 0'),
-        description: z.string().optional().describe('Human-readable transfer memo'),
-        idempotencyKey: z
-            .string()
-            .optional()
-            .describe('Client-supplied key to make retries safe (auto-generated when omitted)'),
-        paymentGrantId: z
-            .string()
-            .optional()
-            .describe('Payment grant to spend under (required for agent-impersonated transfers)'),
-    }, WRITE, async ({ toWalletId, amount, description, idempotencyKey, paymentGrantId }) => {
-        if (!amount || amount <= 0)
-            return toolError('amount must be positive');
-        try {
-            const result = (await client().transfer({
-                to: toWalletId,
-                amount: Math.round(amount),
-                description: description || 'Agent-initiated transfer',
-                idempotencyKey,
-                paymentGrantId,
-            }));
-            if (result['status'] === 'approval_required') {
-                return textResult({
-                    status: 'approval_required',
-                    approvalId: result['approvalId'] || null,
-                    expiresAt: result['expiresAt'] || null,
-                    reason: result['reason'] || null,
-                    amount,
-                    toWalletId: result['toWalletId'],
-                    note: 'Transfer paused: the wallet owner must approve this amount on the wallet page (also listed by ziggs_pending_decisions). Tell the human now (pull-only MCP has no push). ' +
-                        'Wait inline with ziggs_payment_wait_for_approval when you expect a quick decision (≤2 min).',
-                });
-            }
-            return textResult({
-                status: 'transferred',
-                transactionId: result['transactionId'] || null,
-                amount,
-                toWalletId: result['toWalletId'],
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_payment_wait_for_approval', 'Poll a paused transfer (status "approval_required") until the human decides or the timeout passes. Returns executed | rejected | expired | timeout | gone. Use for quick decisions (≤2 min); for longer waits, stop and check again next session.', {
-        approvalId: z.string().describe('Approval to wait on (from ziggs_payment_transfer)'),
-        timeoutMs: z.number().optional().describe('Max wait, default 120000'),
-        pollMs: z.number().optional().describe('Poll interval, default 3000 (min 500)'),
-    }, READ_ONLY, async ({ approvalId, timeoutMs, pollMs }) => {
-        try {
-            const result = (await client().waitForApproval(approvalId, {
-                timeoutMs,
-                pollMs,
-            }));
-            return textResult({
-                status: result['status'],
-                approvalId,
-                transactionId: result['transactionId'] || null,
-                approval: result['approval'] || null,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_payment_hold', "Pre-authorize (escrow) funds without moving them. Use to reserve payment at agreement formation; release with ziggs_payment_release once work is complete, or refund if it's cancelled.", {
-        amount: z.number().describe('Amount in integer cents, > 0'),
-        description: z.string().optional().describe('Human-readable hold memo'),
-        idempotencyKey: z.string().optional().describe('Client-supplied retry-safety key'),
-    }, WRITE, async ({ amount, description, idempotencyKey }) => {
-        if (!amount || amount <= 0)
-            return toolError('amount must be positive');
-        try {
-            const result = (await client().hold({
-                amount: Math.round(amount),
-                description: description || 'Agent escrow hold',
-                idempotencyKey,
-            }));
-            return textResult({
-                status: 'held',
-                transactionId: result['transaction']?.['transactionId'] || null,
-                amount,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_payment_release', "Settle or refund an escrow hold. action='complete' transfers held funds to toWalletId (work done); action='refund' returns funds to the sender (work cancelled).", {
-        holdId: z.string().describe('Hold to settle (transactionId from ziggs_payment_hold)'),
-        action: z.enum(['complete', 'refund']).describe('complete = pay out, refund = return'),
-        toWalletId: z
-            .string()
-            .optional()
-            .describe('Destination wallet — required when action=complete'),
-        idempotencyKey: z.string().optional().describe('Client-supplied retry-safety key'),
-    }, WRITE, async ({ holdId, action, toWalletId, idempotencyKey }) => {
-        if (action === 'complete' && !toWalletId) {
-            return toolError('toWalletId is required when action=complete');
-        }
-        try {
-            const result = (await client().release({
-                holdId,
-                action,
-                toWalletId,
-                idempotencyKey,
-            }));
-            return textResult({
-                status: action === 'complete' ? 'settled' : 'refunded',
-                transactionId: result['transaction']?.['transactionId'] || null,
-                holdId,
-                action,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    const grantCaveatArgs = {
-        maxAmount: z.number().optional().describe('Per-transfer ceiling in cents'),
-        dailyBudget: z.number().optional().describe('Rolling daily budget in cents'),
-        allowedRecipients: z
-            .array(z.string())
-            .optional()
-            .describe('Wallet ids the holder may pay'),
-        expiresInSeconds: z.number().optional().describe('Grant lifetime from now'),
-    };
-    server.tool('ziggs_payment_issue_grant', "Issue a payment grant delegating bounded spend from the operator's wallet to an agent holder. Caveats bound what the holder can do (max_amount, daily_budget, allowed_recipients, expiry). The holder spends by passing the grantId as paymentGrantId on transfers.", {
-        holderId: z.string().describe('Agent that will hold the grant'),
-        ...grantCaveatArgs,
-    }, WRITE, async ({ holderId, ...caveatArgs }) => {
-        try {
-            const caveats = buildCaveats(caveatArgs);
-            const result = (await client().issueGrant({ holderId, caveats }));
-            const grant = result['grant'];
-            return textResult({
-                grantId: grant?.['grantId'] || null,
-                holderId: grant?.['holderId'] || holderId,
-                caveats: grant?.['caveats'] || caveats,
-                expiresAt: grant?.['expiresAt'] || null,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_payment_attenuate_grant', 'Re-delegate a payment grant you hold to another agent with TIGHTER caveats (narrowing only — the child can never exceed the parent). Use to pass a bounded spend slice to a sub-agent.', {
-        grantId: z.string().describe('Parent grant to attenuate'),
-        holderId: z.string().describe('Agent that will hold the narrowed grant'),
-        ...grantCaveatArgs,
-    }, WRITE, async ({ grantId, holderId, ...caveatArgs }) => {
-        try {
-            const caveats = buildCaveats(caveatArgs);
-            const result = (await client().attenuateGrant({
-                grantId,
-                holderId,
-                caveats,
-            }));
-            const grant = result['grant'];
-            return textResult({
-                grantId: grant?.['grantId'] || null,
-                parentGrantId: grant?.['parentGrantId'] || grantId,
-                holderId: grant?.['holderId'] || holderId,
-                caveats: grant?.['caveats'] || caveats,
-                expiresAt: grant?.['expiresAt'] || null,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
-    server.tool('ziggs_payment_revoke_grant', 'Revoke a payment grant (and its attenuated children). The holder can no longer spend under it.', {
-        grantId: z.string().describe('Grant to revoke'),
-    }, DESTRUCTIVE, async ({ grantId }) => {
-        try {
-            const result = (await client().revokeGrant(grantId));
-            return textResult({
-                status: 'revoked',
-                grantId,
-                revoked: result?.['revoked'] ?? null,
-            });
-        }
-        catch (e) {
-            return toolError(e.message);
-        }
-    });
+    registerCapabilities(server, PAYMENT_CAPABILITIES, creds);
 }