@ziggs-ai/api-client 0.10.4 → 0.12.0

package/dist/capabilities/nextCall.js

@@ -14,19 +14,65 @@ export function nextCall(env, capabilityKey, args, why) {
     };
 }
 /**
- * The other party in a two-party agreement, from the perspective of `selfId`.
+ * The other PRINCIPAL in a two-party agreement, from the perspective of
+ * `selfId`.
+ *
+ * This was `peerAgentId`, and it read the `actor` columns — the agents that
+ * carried the paperwork. Those became courier info when a link was re-keyed to
+ * the two people it belongs to, and on most links they are null, so the hint it
+ * fed either pre-filled a call with an agent that is no longer a door or
+ * silently vanished because the helper returned nothing.
+ *
+ * Named for the SLOT, not for what a link happens to put in it. On a link both
+ * principals are guaranteed to be people, because links are person-only and
+ * both sides are userIds by construction — but the same slots hold an org or an
+ * agent on other engagement kinds, so a caller who read "person" here and
+ * trusted it on a hire would be wrong. The person guarantee is a link-only
+ * property; ask the kind before relying on it.
  *
  * Returns null rather than guessing when the row does not identify one, because
  * a pre-filled call naming the wrong counterparty is worse than no pre-filled
  * call: the caller would run it, and it would do something they did not ask for.
  */
-export function peerAgentId(parties, selfId) {
+export function peerPrincipalId(parties, selfId) {
     if (!parties || !selfId)
         return null;
-    const { creatorAgent, providerAgent } = parties;
-    if (creatorAgent && creatorAgent !== selfId)
-        return creatorAgent;
-    if (providerAgent && providerAgent !== selfId)
-        return providerAgent;
+    const creator = parties.creator?.principal;
+    const provider = parties.provider?.principal;
+    if (creator && creator !== selfId)
+        return creator;
+    if (provider && provider !== selfId)
+        return provider;
     return null;
 }
+/**
+ * The peer's principal, located by finding MY side rather than by knowing my
+ * own principal id.
+ *
+ * An agent knows its own agent id and not the id of the person it answers for,
+ * so it cannot ask {@link peerPrincipalId} which of two people it is. What it
+ * CAN recognise is its own courier stamp: if my agent id is in one side's
+ * `actor`, that side is mine and the other side's principal is the peer.
+ *
+ * Note the difference from the bug this replaced. Reading the peer's `actor` as
+ * the peer's address was wrong — those slots are courier info, null on most
+ * links, and never a door. Reading MY OWN `actor` to work out which side I am on
+ * is sound, because I am comparing against an id I hold.
+ *
+ * Returns null when neither side carries my stamp, which is the common case for
+ * a link two people formed from the web. No pre-filled call is the right answer
+ * there: naming the wrong counterparty would get run.
+ */
+export function peerPrincipalForCourier(parties, myAgentId) {
+    if (!parties || !myAgentId)
+        return null;
+    const mineIsCreator = parties.creator?.actor === myAgentId;
+    const mineIsProvider = parties.provider?.actor === myAgentId;
+    // Both sides stamped with me is one estate on both ends, not a peer.
+    if (mineIsCreator === mineIsProvider)
+        return null;
+    const peer = mineIsCreator
+        ? parties.provider?.principal
+        : parties.creator?.principal;
+    return peer && peer !== myAgentId ? peer : null;
+}

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,
 ];

package/dist/capabilities/proposeProviderId.d.ts

@@ -3,4 +3,4 @@
  * tools. Stated on the schema so a fresh agent does not burn a turn learning
  * the rule from the validation error.
  */
-export declare const AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION = "REQUIRED on a direct proposal: name who does the work \u2014 your own id (you are offering to work) or the proposedTo id (you are commissioning the recipient). Do not omit it when proposedTo is a person/agent id. Broadcast (proposedTo everyone/org): omit for a quest (claimer works), or your own id for a standing offer (you work). A third-party id brokers and needs a matching published offer. Payer is always the non-providing side.";
+export declare const AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION = "REQUIRED on a direct proposal: name who does the work \u2014 your own id (you are offering to work) or the proposedTo id (you are commissioning the recipient). Do not omit it when proposedTo is a person/agent id. Broadcast (proposedTo everyone/org): omit for a request (claimer works), or your own id for a standing offer (you work). A third-party id brokers and needs a matching published offer. Payer is always the non-providing side.";

package/dist/capabilities/proposeProviderId.js

@@ -3,4 +3,4 @@
  * tools. Stated on the schema so a fresh agent does not burn a turn learning
  * the rule from the validation error.
  */
-export const AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION = 'REQUIRED on a direct proposal: name who does the work — your own id (you are offering to work) or the proposedTo id (you are commissioning the recipient). Do not omit it when proposedTo is a person/agent id. Broadcast (proposedTo everyone/org): omit for a quest (claimer works), or your own id for a standing offer (you work). A third-party id brokers and needs a matching published offer. Payer is always the non-providing side.';
+export const AGREEMENT_PROPOSE_PROVIDER_ID_DESCRIPTION = 'REQUIRED on a direct proposal: name who does the work — your own id (you are offering to work) or the proposedTo id (you are commissioning the recipient). Do not omit it when proposedTo is a person/agent id. Broadcast (proposedTo everyone/org): omit for a request (claimer works), or your own id for a standing offer (you work). A third-party id brokers and needs a matching published offer. Payer is always the non-providing side.';