@ziggs-ai/api-client 0.10.3 → 0.11.0

package/dist/capabilities/links.d.ts

@@ -3,7 +3,7 @@ import { type CapabilityDefinition, type CapabilityEnv } from './types.js';
  * A link is reach-only — the follow-up move differs by surface tool names.
  *
  * Opening a chat is itself the admission: the backend issues a standing from-now
- * chat grant to every agent member as it creates the room, so both delegates can
+ * write grant to each side as it creates the room, so both delegates can
  * read and post immediately. Do NOT tell agents to follow chat_open with an
  * issue_grant on that same new chat — that only mints a duplicate grant carrying
  * the default 30-day expiry. issue_grant / context_delegate are for scopes that

package/dist/capabilities/links.js

@@ -1,4 +1,4 @@
-import { createAgreement, listAgreements } from '../http/AgreementClient.js';
+import { createLink, listAgreements } from '../http/AgreementClient.js';
 import { nextCall, peerAgentId } from './nextCall.js';
 import { fullCreds } from './types.js';
 const DEFAULT_WEB_URL = 'https://ziggsai.com';
@@ -23,7 +23,7 @@ function inviteShareUrl(env, agreementId) {
  * A link is reach-only — the follow-up move differs by surface tool names.
  *
  * Opening a chat is itself the admission: the backend issues a standing from-now
- * chat grant to every agent member as it creates the room, so both delegates can
+ * write grant to each side as it creates the room, so both delegates can
  * read and post immediately. Do NOT tell agents to follow chat_open with an
  * issue_grant on that same new chat — that only mints a duplicate grant carrying
  * the default 30-day expiry. issue_grant / context_delegate are for scopes that
@@ -36,10 +36,9 @@ export function linkIsReachOnly(env) {
 }
 const LINK_STATUSES = ['active', 'open', 'cancelled', 'all'];
 /**
- * Seat ceiling for one invite. ⚠️ SYNC: backend
- * src/agreements/agreements.service.ts MAX_LINK_INVITE_CLAIMS — the backend
- * rejects anything past it; this is only so the tool description says the
- * limit instead of letting an agent discover it by getting a 400.
+ * Seat ceiling for one invite. ⚠️ Mirrors the server's own ceiling, which
+ * rejects anything past it; this copy exists only so the tool description states
+ * the limit instead of letting an agent discover it by getting a 400.
  */
 const MAX_LINK_INVITE_CLAIMS = 25;
 ///1022 — the link rail shrank to two tools. Links are agreements, so
@@ -68,8 +67,7 @@ export const createLinkInviteCapability = {
     needsAgentId: true,
     handler: async (args, env) => {
         const maxClaims = args['maxClaims'];
-        const { agreement } = await createAgreement({
-            engagementKind: 'link',
+        const { agreement } = await createLink({
             description: args['message'],
             ...(maxClaims == null ? {} : { maxClaims }),
         }, fullCreds(env));
@@ -175,9 +173,8 @@ export const proposeLinkCapability = {
     needsAgentId: true,
     handler: async (args, env) => {
         const counterparty = args['counterparty'];
-        const { agreement } = await createAgreement({
-            engagementKind: 'link',
-            providerId: counterparty,
+        const { agreement } = await createLink({
+            targetAgentId: counterparty,
             ...(args['message'] ? { description: args['message'] } : {}),
         }, fullCreds(env));
         // The owner rewrite is surfaced rather than left to be noticed: an agent

package/dist/capabilities/marketplace.js

@@ -1,14 +1,60 @@
-import { pullOffers, pullQuests } from '../http/MarketplaceClient.js';
+import { pullOffers, pullRequests } from '../http/MarketplaceClient.js';
 import { fullCreds } from './types.js';
 import { nextCall } from './nextCall.js';
-const VIEW_KINDS = ['all', 'quests', 'offers'];
+const VIEW_KINDS = ['all', 'requests', 'offers'];
 function publishHint(env) {
-    const propose = env.surface === 'mcp' ? 'ziggs_agreement_quest' : 'agreement_quest';
+    const propose = env.surface === 'mcp' ? 'ziggs_agreement_request' : 'agreement_request';
     const claim = env.surface === 'mcp' ? 'ziggs_agreement_claim' : 'agreement_claim';
     return (`Claim any row with ${claim} (agreementId). Publish your own with ${propose}: ` +
-        `proposedTo "everyone" or "org" with no providerId broadcasts a quest (claimer works, you pay); ` +
+        `proposedTo "everyone" or "org" with no providerId broadcasts a request (claimer works, you pay); ` +
         `the same with providerId = your own id publishes a standing offer (you work, claimer pays).`);
 }
+/** A broadcast sentinel in a party slot means "open", not a counterparty. */
+const BROADCASTS = new Set(['everyone', 'org']);
+const named = (id) => typeof id === 'string' && id && !BROADCASTS.has(id) ? id : undefined;
+/**
+ * One listing, as a browser needs to read it.
+ *
+ * A whole agreement document is around 30 fields and ~2KB per row, so a default
+ * page of 20 is 40KB of context spent mostly on storage bookkeeping — internal
+ * versioning, content hashes, write provenance, approval and lane bookkeeping —
+ * none of which helps anyone decide whether to claim. This projection is what the
+ * decision actually needs: what the work is, who does it, what it costs, on what
+ * terms, and the id to claim it with.
+ *
+ * Deliberately no `raw` escape hatch. The full document is one `agreement_get`
+ * away for the row you chose, and an escape hatch here would just restore the
+ * cost for every row you did not.
+ */
+function toListingRow(a, kind) {
+    const terms = a?.terms ?? {};
+    const parties = a?.parties ?? {};
+    const requiredConnections = terms.requiredConnections ?? [];
+    return {
+        agreementId: a?.agreementId,
+        kind,
+        description: terms.description ?? '',
+        price: a?.money?.price ?? 0,
+        // What that price MEANS: a whole-engagement total, or a rate charged per
+        // completed task. Omitting it left a metered standing hire indistinguishable
+        // from a flat-priced one at the moment a caller decides to claim, and
+        // `per_task` is the default for a hire. Absent on rows written before the
+        // field existed, which read as `total`.
+        ...(terms.billing ? { billing: terms.billing } : {}),
+        engagementKind: a?.engagementKind,
+        lifecycle: terms.lifecycle,
+        ...(terms.expiresAt ? { expiresAt: terms.expiresAt } : {}),
+        ...(terms.maxExecutions != null ? { maxExecutions: terms.maxExecutions } : {}),
+        // Who does the work on an offer, who is paying on a request. The other slot is
+        // the open one you would be filling by claiming, so it carries no name yet.
+        ...(named(parties.providerAgent) ? { providerAgent: parties.providerAgent } : {}),
+        ...(named(parties.provider) ? { provider: parties.provider } : {}),
+        ...(named(parties.payer) ? { payer: parties.payer } : {}),
+        // Access the job cannot be done without — worth knowing before claiming it.
+        ...(requiredConnections.length ? { requiredConnections } : {}),
+        createdAt: a?.createdAt,
+    };
+}
 /**
  * the marketplace read on both surfaces. Publishing and claiming
  * ride the agreement grammar (propose-with-audience / agreement_claim); this
@@ -19,15 +65,15 @@ export const marketplaceViewCapability = {
     names: { sdk: 'marketplace_view', mcp: 'ziggs_marketplace_view' },
     title: 'Browse the marketplace',
     descriptions: {
-        sdk: 'Browse the open marketplace — where every engagement STARTS (posted-first: reuse an active agreement, else claim a listing here, before ever proposing). Quests are work buyers broadcast (you would do the work); standing offers are services sellers broadcast (you would buy). Returns public rows plus org-scoped rows from your org, filtered server-side. Claim a row with agreement_claim — listings are take-it-or-leave-it, never counter one; publish your own via agreement_propose with proposedTo "everyone"/"org" (providerId = your id for an offer, omitted for a quest).',
-        mcp: 'Browse the open marketplace — where every engagement STARTS (posted-first: reuse an active agreement, else claim a listing here, before ever proposing). Quests are work buyers broadcast (you would do the work); standing offers are services sellers broadcast (you would buy). Returns public rows plus org-scoped rows from your org, filtered server-side. Claim a row with ziggs_agreement_claim — listings are take-it-or-leave-it, never counter one; publish your own with ziggs_agreement_offer (you do the work, the claimer pays) or ziggs_agreement_quest (the claimer does the work, you pay).',
+        sdk: 'Browse the open marketplace — where every engagement STARTS (posted-first: reuse an active agreement, else claim a listing here, before ever proposing). Requests are work buyers broadcast (you would do the work); standing offers are services sellers broadcast (you would buy). Returns public rows plus org-scoped rows from your org, filtered server-side. Claim a row with agreement_claim — listings are take-it-or-leave-it, never counter one; publish your own via agreement_propose with proposedTo "everyone"/"org" (providerId = your id for an offer, omitted for a request).',
+        mcp: 'Browse the open marketplace — where every engagement STARTS (posted-first: reuse an active agreement, else claim a listing here, before ever proposing). Requests are work buyers broadcast (you would do the work); standing offers are services sellers broadcast (you would buy). Returns public rows plus org-scoped rows from your org, filtered server-side. Claim a row with ziggs_agreement_claim — listings are take-it-or-leave-it, never counter one; publish your own with ziggs_agreement_offer (you do the work, the claimer pays) or ziggs_agreement_request (the claimer does the work, you pay).',
     },
     annotation: 'read-only',
     params: {
         kind: {
             type: 'string',
             enum: VIEW_KINDS,
-            description: 'all (default) | quests | offers',
+            description: 'all (default) | requests | offers',
         },
         limit: { type: 'number', description: 'Max rows per kind (default 20)' },
         since: { type: 'string', description: 'ISO timestamp — only rows published after this' },
@@ -43,18 +89,22 @@ export const marketplaceViewCapability = {
             limit: typeof args['limit'] === 'number' ? args['limit'] : 20,
             ...(args['since'] ? { since: args['since'] } : {}),
         };
-        const [quests, offers] = await Promise.all([
-            kind === 'offers' ? Promise.resolve([]) : pullQuests(options, creds),
-            kind === 'quests' ? Promise.resolve([]) : pullOffers(options, creds),
+        const [requests, offers] = await Promise.all([
+            kind === 'offers' ? Promise.resolve([]) : pullRequests(options, creds),
+            kind === 'requests' ? Promise.resolve([]) : pullOffers(options, creds),
         ]);
         return {
-            ...(kind !== 'offers' ? { quests, questCount: quests.length } : {}),
-            ...(kind !== 'quests' ? { offers, offerCount: offers.length } : {}),
+            ...(kind !== 'offers'
+                ? { requests: requests.map((q) => toListingRow(q, 'request')), requestCount: requests.length }
+                : {}),
+            ...(kind !== 'requests'
+                ? { offers: offers.map((o) => toListingRow(o, 'offer')), offerCount: offers.length }
+                : {}),
             // Claiming is the move after browsing, and the id is in the row the
             // caller just received. The prose hint stays for the publish side, which
             // is a choice rather than a call.
             readPlan: [
-                ...(quests.length || offers.length
+                ...(requests.length || offers.length
                     ? [
                         nextCall(env, 'agreement_claim', undefined, 'claim a listing from this view by passing its agreementId — listings are take-it-or-leave-it, never countered'),
                     ]

package/dist/capabilities/payments.d.ts

@@ -1,11 +1,27 @@
 import { type CapabilityDefinition } from './types.js';
+/**
+ * Reading the balance is the whole rail on an agent surface.
+ *
+ * What left this surface is every verb that moved value on its own:
+ * `payment_transfer`, `payment_hold`, `payment_release`,
+ * `payment_wait_for_approval` and `payment_resolve_wallet`, plus the three
+ * grant mutations (issue / attenuate / revoke), which are now the wallet
+ * owner's to make in the web app rather than an agent's to make on their
+ * behalf. An agent holding a free-standing "move value from A to B" verb is
+ * what reads as transferring a financial asset between third parties, and it
+ * is the shape assistant-store connector policy rejects.
+ *
+ * What did NOT change: agreements still settle in points. The hold on
+ * activation, the transfer in `settleCompletedTask` and the settle on fulfill
+ * all stay exactly as they were, and priced agreements keep moving points
+ * between org wallets. That double-entry IS the meter — the chain and the
+ * middleman margins are the measurement we want — so removing the verbs costs
+ * no capability: nothing an agent could do through them was load-bearing for
+ * getting paid under an agreement.
+ *
+ * Balance stays readable, because "see your points" is the intended
+ * experience. Note that `ZIGGS_MCP_CORE_ONLY` gates this whole group off
+ * including balance, so it is not the lever for this on its own.
+ */
 export declare const paymentBalanceCapability: CapabilityDefinition;
-export declare const paymentResolveWalletCapability: CapabilityDefinition;
-export declare const paymentTransferCapability: CapabilityDefinition;
-export declare const paymentWaitForApprovalCapability: CapabilityDefinition;
-export declare const paymentHoldCapability: CapabilityDefinition;
-export declare const paymentReleaseCapability: CapabilityDefinition;
-export declare const paymentIssueGrantCapability: CapabilityDefinition;
-export declare const paymentAttenuateGrantCapability: CapabilityDefinition;
-export declare const paymentRevokeGrantCapability: CapabilityDefinition;
 export declare const PAYMENT_CAPABILITIES: CapabilityDefinition[];

package/dist/capabilities/payments.js

@@ -6,36 +6,37 @@ function client(env) {
         throw new Error('operatorKey missing from tool context');
     return new PaymentsClient(operatorKey, agentId, env.baseUrl);
 }
-/** Lower the optional caveat args to the wire's caveat list (was written twice). */
-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;
-}
-const grantCaveatParams = {
-    maxAmount: { type: 'number', description: 'Per-transfer ceiling in cents' },
-    dailyBudget: { type: 'number', description: 'Rolling daily budget in cents' },
-    allowedRecipients: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Wallet ids the holder may pay',
-    },
-    expiresInSeconds: { type: 'number', description: 'Grant lifetime from now' },
-};
+/**
+ * Reading the balance is the whole rail on an agent surface.
+ *
+ * What left this surface is every verb that moved value on its own:
+ * `payment_transfer`, `payment_hold`, `payment_release`,
+ * `payment_wait_for_approval` and `payment_resolve_wallet`, plus the three
+ * grant mutations (issue / attenuate / revoke), which are now the wallet
+ * owner's to make in the web app rather than an agent's to make on their
+ * behalf. An agent holding a free-standing "move value from A to B" verb is
+ * what reads as transferring a financial asset between third parties, and it
+ * is the shape assistant-store connector policy rejects.
+ *
+ * What did NOT change: agreements still settle in points. The hold on
+ * activation, the transfer in `settleCompletedTask` and the settle on fulfill
+ * all stay exactly as they were, and priced agreements keep moving points
+ * between org wallets. That double-entry IS the meter — the chain and the
+ * middleman margins are the measurement we want — so removing the verbs costs
+ * no capability: nothing an agent could do through them was load-bearing for
+ * getting paid under an agreement.
+ *
+ * Balance stays readable, because "see your points" is the intended
+ * experience. Note that `ZIGGS_MCP_CORE_ONLY` gates this whole group off
+ * including balance, so it is not the lever for this on its own.
+ */
 export const paymentBalanceCapability = {
     key: 'payment_balance',
     names: { sdk: 'payment_balance', mcp: 'ziggs_payment_balance' },
-    title: 'Check your balance',
+    title: 'Check your points',
     descriptions: {
-        sdk: "Check the caller's current wallet balance and available balance (total minus active holds). Use before a transfer to confirm sufficient funds.",
-        mcp: "Check the caller's current wallet balance and available balance (total minus active holds). Use before a transfer to confirm sufficient funds.",
+        sdk: "Check the caller's points balance and available balance (total minus points held against active agreements). Points move as a consequence of an agreement settling.",
+        mcp: "Check the caller's points balance and available balance (total minus points held against active agreements). Points move as a consequence of an agreement settling — there is no tool to move them on their own, so earning and spending both happen when an agreement settles.",
     },
     annotation: 'read-only',
     params: {},
@@ -44,375 +45,10 @@ export const paymentBalanceCapability = {
             return await client(env).balance();
         }
         catch (e) {
-            rethrowWithContext(e, 'Failed to get balance');
-        }
-    },
-};
-export const paymentResolveWalletCapability = {
-    key: 'payment_resolve_wallet',
-    names: { sdk: 'payment_resolve_wallet', mcp: 'ziggs_payment_resolve_wallet' },
-    title: 'Look up a wallet',
-    descriptions: {
-        sdk: 'Look up a walletId by userId or agentId. Use before a transfer when you only know the recipient by their platform ID.',
-        mcp: 'Look up a walletId by userId or agentId. Use before a transfer when you only know the recipient by their platform ID.',
-    },
-    annotation: 'read-only',
-    params: {
-        userId: { type: 'string', description: 'User to resolve' },
-        agentId: { type: 'string', description: 'Agent to resolve' },
-    },
-    handler: async (args, env) => {
-        if (!args['userId'] && !args['agentId'])
-            throw new Error('Provide userId or agentId to resolve a wallet');
-        try {
-            const wallet = await client(env).resolve({
-                userId: args['userId'],
-                agentId: args['agentId'],
-            });
-            return {
-                walletId: wallet?.walletId || null,
-                ownerId: wallet?.ownerId || null,
-                currency: wallet?.currency || 'pez',
-                status: wallet?.status || null,
-            };
-        }
-        catch (e) {
-            rethrowWithContext(e, 'Failed to resolve wallet');
-        }
-    },
-};
-export const paymentTransferCapability = {
-    key: 'payment_transfer',
-    names: { sdk: 'payment_transfer', mcp: 'ziggs_payment_transfer' },
-    title: 'Transfer funds',
-    descriptions: {
-        sdk: 'Transfer funds to another wallet. Amounts are integer cents. Transfers above the wallet owner\'s policy pause with status "approval_required" — wait inline with payment_wait_for_approval when you expect a quick decision.',
-        mcp: '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_grant_list 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.',
-    },
-    annotation: 'write',
-    params: {
-        toWalletId: {
-            type: 'string',
-            required: true,
-            description: 'Destination wal_... id — or a userId/agentId to auto-resolve',
-        },
-        amount: { type: 'number', required: true, description: 'Amount in integer cents, > 0' },
-        description: { type: 'string', description: 'Human-readable transfer memo' },
-        idempotencyKey: {
-            type: 'string',
-            description: 'Client-supplied key to make retries safe (auto-generated when omitted)',
-        },
-        paymentGrantId: {
-            type: 'string',
-            description: 'Payment grant to spend under (required for agent-impersonated transfers)',
-        },
-    },
-    handler: async (args, env) => {
-        if (!args['toWalletId'])
-            throw new Error('toWalletId is required');
-        const amount = args['amount'];
-        if (!amount || amount <= 0)
-            throw new Error('amount must be positive');
-        let result;
-        try {
-            result = await client(env).transfer({
-                to: args['toWalletId'],
-                amount: Math.round(amount),
-                description: args['description'] || 'Agent-initiated transfer',
-                idempotencyKey: args['idempotencyKey'],
-                paymentGrantId: args['paymentGrantId'],
-            });
-        }
-        catch (e) {
-            rethrowWithContext(e, 'Transfer failed');
-        }
-        if (result.status === 'approval_required') {
-            const base = {
-                status: 'approval_required',
-                approvalId: result.approvalId,
-                expiresAt: result.expiresAt,
-                reason: result.reason,
-                amount,
-                toWalletId: result.toWalletId,
-            };
-            // Same pause, surface-local guidance: the MCP delegate must surface the
-            // pending approval to the human (pull-only MCP has no push); the SDK
-            // runtime routes via structured next_actions.
-            if (env.surface === 'mcp') {
-                return {
-                    ...base,
-                    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 {
-                ...base,
-                message: 'Transfer paused: the wallet owner must approve this amount.',
-                next_actions: [
-                    {
-                        tool: 'payment_wait_for_approval',
-                        when: 'You expect a quick decision (≤2 min) and can wait inline.',
-                        args: { approvalId: result.approvalId, timeoutMs: 120000 },
-                    },
-                    {
-                        tool: 'task_update_plan_step',
-                        when: 'You want to abandon the transfer and route around it.',
-                    },
-                ],
-            };
-        }
-        return {
-            status: 'transferred',
-            transactionId: result.transactionId,
-            amount,
-            toWalletId: result.toWalletId,
-        };
-    },
-};
-export const paymentWaitForApprovalCapability = {
-    key: 'payment_wait_for_approval',
-    names: { sdk: 'payment_wait_for_approval', mcp: 'ziggs_payment_wait_for_approval' },
-    title: 'Wait on a payment approval',
-    descriptions: {
-        sdk: 'Poll a paused transfer (status "approval_required") until the human decides or the timeout passes. Returns executed | rejected | expired | timeout | gone.',
-        mcp: '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.',
-    },
-    annotation: 'read-only',
-    params: {
-        approvalId: {
-            type: 'string',
-            required: true,
-            description: 'Approval to wait on (from the paused transfer)',
-        },
-        timeoutMs: { type: 'number', description: 'Max wait, default 120000' },
-        pollMs: { type: 'number', description: 'Poll interval, default 3000 (min 500)' },
-    },
-    handler: async (args, env) => {
-        if (!args['approvalId'])
-            throw new Error('approvalId is required');
-        try {
-            const result = await client(env).waitForApproval(args['approvalId'], {
-                timeoutMs: args['timeoutMs'],
-                pollMs: args['pollMs'],
-            });
-            const loose = result;
-            return {
-                status: result.status,
-                approvalId: args['approvalId'],
-                transactionId: loose['transactionId'] || null,
-                approval: loose['approval'] || null,
-            };
-        }
-        catch (e) {
-            rethrowWithContext(e, 'wait_for_approval failed');
-        }
-    },
-};
-export const paymentHoldCapability = {
-    key: 'payment_hold',
-    names: { sdk: 'payment_hold', mcp: 'ziggs_payment_hold' },
-    title: 'Hold funds in escrow',
-    descriptions: {
-        sdk: 'Pre-authorize (escrow) funds without moving them. Use to reserve payment at agreement formation; release with payment_release once work is complete or to refund if work is cancelled.',
-        mcp: "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.",
-    },
-    annotation: 'write',
-    params: {
-        amount: { type: 'number', required: true, description: 'Amount in integer cents, > 0' },
-        description: { type: 'string', description: 'Human-readable hold memo' },
-        idempotencyKey: { type: 'string', description: 'Client-supplied retry-safety key' },
-        paymentGrantId: {
-            type: 'string',
-            description: 'Payment grant authorizing this hold (required for agent actors; auto-picks an active wallet grant when omitted)',
-        },
-    },
-    handler: async (args, env) => {
-        const amount = args['amount'];
-        if (!amount || amount <= 0)
-            throw new Error('amount must be positive');
-        try {
-            const result = await client(env).hold({
-                amount: Math.round(amount),
-                description: args['description'] || 'Agent escrow hold',
-                idempotencyKey: args['idempotencyKey'],
-                paymentGrantId: args['paymentGrantId'],
-            });
-            return {
-                status: 'held',
-                transactionId: result.transaction?.transactionId || null,
-                amount,
-            };
-        }
-        catch (e) {
-            rethrowWithContext(e, 'Hold failed');
-        }
-    },
-};
-export const paymentReleaseCapability = {
-    key: 'payment_release',
-    names: { sdk: 'payment_release', mcp: 'ziggs_payment_release' },
-    title: 'Settle or refund a hold',
-    descriptions: {
-        sdk: "Settle or refund an escrow hold. Use action='complete' to transfer held funds to toWalletId (work done), or action='refund' to return funds to the sender (work cancelled).",
-        mcp: "Settle or refund an escrow hold. action='complete' transfers held funds to toWalletId (work done); action='refund' returns funds to the sender (work cancelled).",
-    },
-    annotation: 'write',
-    params: {
-        holdId: {
-            type: 'string',
-            required: true,
-            description: 'Hold to settle (transactionId from the hold)',
-        },
-        action: {
-            type: 'string',
-            required: true,
-            enum: ['complete', 'refund'],
-            description: 'complete = pay out, refund = return',
-        },
-        toWalletId: { type: 'string', description: 'Destination wallet — required when action=complete' },
-        idempotencyKey: { type: 'string', description: 'Client-supplied retry-safety key' },
-    },
-    handler: async (args, env) => {
-        if (!args['holdId'])
-            throw new Error('holdId is required');
-        const action = args['action'];
-        if (action !== 'complete' && action !== 'refund')
-            throw new Error("action must be 'complete' or 'refund'");
-        if (action === 'complete' && !args['toWalletId'])
-            throw new Error('toWalletId is required when action=complete');
-        try {
-            const result = await client(env).release({
-                holdId: args['holdId'],
-                action,
-                toWalletId: args['toWalletId'],
-                idempotencyKey: args['idempotencyKey'],
-            });
-            return {
-                status: action === 'complete' ? 'settled' : 'refunded',
-                transactionId: result.transaction?.transactionId || null,
-                holdId: args['holdId'],
-                action,
-            };
-        }
-        catch (e) {
-            rethrowWithContext(e, 'Release failed');
-        }
-    },
-};
-export const paymentIssueGrantCapability = {
-    key: 'payment_issue_grant',
-    names: { sdk: 'payment_issue_grant', mcp: 'ziggs_payment_issue_grant' },
-    title: 'Issue a spend grant',
-    descriptions: {
-        sdk: "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.",
-        mcp: "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.",
-    },
-    annotation: 'write',
-    params: {
-        holderId: { type: 'string', required: true, description: 'Agent that will hold the grant' },
-        ...grantCaveatParams,
-    },
-    handler: async (args, env) => {
-        if (!args['holderId'])
-            throw new Error('holderId is required');
-        try {
-            const caveats = buildCaveats(args);
-            const { grant } = await client(env).issueGrant({
-                holderId: args['holderId'],
-                caveats,
-            });
-            return {
-                grantId: grant?.grantId || null,
-                holderId: grant?.holderId || args['holderId'],
-                caveats: grant?.caveats || caveats,
-                expiresAt: grant?.expiresAt || null,
-            };
-        }
-        catch (e) {
-            rethrowWithContext(e, 'Failed to issue payment grant');
-        }
-    },
-};
-export const paymentAttenuateGrantCapability = {
-    key: 'payment_attenuate_grant',
-    names: { sdk: 'payment_attenuate_grant', mcp: 'ziggs_payment_attenuate_grant' },
-    title: 'Pass on a tighter spend grant',
-    descriptions: {
-        sdk: '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.',
-        mcp: '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.',
-    },
-    annotation: 'write',
-    params: {
-        grantId: { type: 'string', required: true, description: 'Parent grant to attenuate' },
-        holderId: {
-            type: 'string',
-            required: true,
-            description: 'Agent that will hold the narrowed grant',
-        },
-        ...grantCaveatParams,
-    },
-    handler: async (args, env) => {
-        const grantId = args['grantId'];
-        if (!grantId)
-            throw new Error('grantId is required');
-        if (!args['holderId'])
-            throw new Error('holderId is required');
-        try {
-            const caveats = buildCaveats(args);
-            const { grant } = await client(env).attenuateGrant({
-                grantId,
-                holderId: args['holderId'],
-                caveats,
-            });
-            return {
-                grantId: grant?.grantId || null,
-                parentGrantId: grant?.parentGrantId || grantId,
-                holderId: grant?.holderId || args['holderId'],
-                caveats: grant?.caveats || caveats,
-                expiresAt: grant?.expiresAt || null,
-            };
-        }
-        catch (e) {
-            rethrowWithContext(e, 'Failed to attenuate payment grant');
-        }
-    },
-};
-export const paymentRevokeGrantCapability = {
-    key: 'payment_revoke_grant',
-    names: { sdk: 'payment_revoke_grant', mcp: 'ziggs_payment_revoke_grant' },
-    title: 'Revoke a spend grant',
-    descriptions: {
-        sdk: 'Revoke a payment grant (and its attenuated children). The holder can no longer spend under it.',
-        mcp: 'Revoke a payment grant (and its attenuated children). The holder can no longer spend under it.',
-    },
-    annotation: 'destructive',
-    params: {
-        grantId: { type: 'string', required: true, description: 'Grant to revoke' },
-    },
-    handler: async (args, env) => {
-        const grantId = args['grantId'];
-        if (!grantId)
-            throw new Error('grantId is required');
-        try {
-            const result = await client(env).revokeGrant(grantId);
-            return { status: 'revoked', grantId, revoked: result?.revoked ?? null };
-        }
-        catch (e) {
-            rethrowWithContext(e, 'Failed to revoke payment grant');
+            rethrowWithContext(e, 'Failed to read points balance');
         }
     },
 };
-// payment_list_grants stays retired; the wallet rail is part of the
-// unified grant_list capability (scopeKind: 'wallet'). Grant *mutations* stay
-// on the payment rail above.
 export const PAYMENT_CAPABILITIES = [
     paymentBalanceCapability,
-    paymentTransferCapability,
-    paymentWaitForApprovalCapability,
-    paymentHoldCapability,
-    paymentReleaseCapability,
-    paymentResolveWalletCapability,
-    paymentIssueGrantCapability,
-    paymentAttenuateGrantCapability,
-    paymentRevokeGrantCapability,
 ];