@ziggs-ai/agent-sdk 0.4.1 → 0.6.0

package/dist/server/tools/tier2/connectionTools.js

@@ -1,107 +1,33 @@
+import { connectionProxyCapability, requestConnectionCapability, ConnectionsClient, } from '@ziggs-ai/api-client';
 import { defineTool } from '../../../tools/defineTool.js';
-import { ConnectionsClient } from '@ziggs-ai/api-client';
-function clientFor(ctx) {
+import { toolFromCapability } from '../../../tools/capabilityAdapter.js';
+// ZIG-956 — connection_proxy / request_connection are shared capability
+// definitions (api-client). connection_list_grants stays SDK-only: the MCP
+// surface folds connection listing into ziggs_list_my_connections (ZIG-893
+// allowance in the parity table).
+export const connectionProxyTool = toolFromCapability(connectionProxyCapability);
+export const requestConnectionTool = toolFromCapability(requestConnectionCapability);
+export const connectionListGrantsTool = defineTool('connection_list_grants', { connectionId: { type: 'string', required: true } }, async (args, ctx) => {
+    if (!args['connectionId'])
+        throw new Error('connectionId is required');
     const operatorKey = ctx?.['operatorKey'];
     if (!operatorKey)
         throw new Error('operatorKey missing from tool context');
-    // BACKEND_URL / ZIGGS_BACKEND_URL are the SDK runner's overrides; the shared
-    // client defaults to HTTP_URL (api-client convention) when neither is set.
     const baseUrl = process.env.BACKEND_URL || process.env.ZIGGS_BACKEND_URL || undefined;
-    return new ConnectionsClient(operatorKey, ctx?.['agentId'] || undefined, baseUrl);
-}
-function rethrowWithContext(error, prefix) {
-    const e = error;
-    const wrapped = new Error(`${prefix}: ${e.message}`);
-    if (e.status !== undefined)
-        wrapped.status = e.status;
-    if (e.body !== undefined)
-        wrapped.body = e.body;
-    wrapped['cause'] = error;
-    throw wrapped;
-}
-export const connectionProxyTool = defineTool('connection_proxy', {
-    connectionId: { type: 'string', required: true },
-    grantId: { type: 'string', required: true },
-    action: { type: 'string', required: true },
-    payload: { type: 'object' },
-}, async (args, ctx) => {
-    if (!args['connectionId'])
-        throw new Error('connectionId is required');
-    if (!args['grantId'])
-        throw new Error('grantId is required');
-    if (!args['action'])
-        throw new Error('action is required');
+    const client = new ConnectionsClient(operatorKey, ctx?.['agentId'] || undefined, baseUrl);
     try {
-        const result = await clientFor(ctx).proxy({
-            connectionId: args['connectionId'],
-            grantId: args['grantId'],
-            action: args['action'],
-            payload: args['payload'],
-        });
-        return { status: 'ok', result };
-    }
-    catch (e) {
-        rethrowWithContext(e, 'Connection proxy failed');
-    }
-});
-export const connectionListGrantsTool = defineTool('connection_list_grants', { connectionId: { type: 'string', required: true } }, async (args, ctx) => {
-    if (!args['connectionId'])
-        throw new Error('connectionId is required');
-    try {
-        const grants = await clientFor(ctx).listGrants({
-            connectionId: args['connectionId'],
-        });
+        const grants = await client.listGrants({ connectionId: args['connectionId'] });
         return { grants: grants || [] };
     }
     catch (e) {
-        rethrowWithContext(e, 'Failed to list connection grants');
-    }
-});
-export const requestConnectionTool = defineTool('request_connection', {
-    chatId: {
-        type: 'string',
-        required: true,
-        description: 'The chat you are working in — the consent card is opened there',
-    },
-    serverUrl: { type: 'string', required: true, description: 'Remote MCP server URL (https)' },
-    tools: {
-        type: 'array',
-        items: { type: 'string' },
-        required: true,
-        description: "Tool names you want — become the grant's allowed_actions caveats",
-    },
-    reason: {
-        type: 'string',
-        description: 'Plain-language reason shown to the human deciding',
-    },
-}, async (args, ctx) => {
-    if (!args['chatId'])
-        throw new Error('chatId is required');
-    if (!args['serverUrl'])
-        throw new Error('serverUrl is required');
-    const tools = args['tools'];
-    if (!Array.isArray(tools) || tools.length === 0) {
-        throw new Error('tools must be a non-empty array of tool names');
-    }
-    try {
-        const result = await clientFor(ctx).requestMcpConnection({
-            chatId: args['chatId'],
-            serverUrl: args['serverUrl'],
-            tools: tools,
-            reason: args['reason'],
-        });
-        return {
-            ok: true,
-            ...result,
-            note: 'A connection-consent card is now in the chat awaiting your principal — they approve it right there (ZIG-798 flow). ' +
-                'Once approved, the connection + grant appear in list_grants (scopeKind=connection) / connection_list_grants for connection_proxy.',
-        };
-    }
-    catch (e) {
-        rethrowWithContext(e, 'Connection request failed');
+        const err = e;
+        const wrapped = new Error(`Failed to list connection grants: ${err.message}`);
+        if (err.status !== undefined)
+            wrapped.status = err.status;
+        if (err.body !== undefined)
+            wrapped.body = err.body;
+        throw wrapped;
     }
-}, {
-    description: 'Ask your principal (the human) to connect a remote MCP server and grant you the listed tools. Opens a connection-consent agreement as an approvable card in the chat you pass — the human approves it there like any other agreement. On approval the server is connected (browser OAuth if needed) and you are granted the tools; use them via connection_proxy.',
 });
 export const CONNECTION_TOOLS = [
     connectionProxyTool,

package/dist/server/tools/tier2/contextTools.d.ts

@@ -1,6 +1,6 @@
-import { type ToolDefinition } from '../../../tools/defineTool.js';
+import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const contextReadTool: ToolDefinition;
 export declare const contextDelegateTool: ToolDefinition;
 export declare const contextExpandReachTool: ToolDefinition;
 export declare const contextDiscoverGrantableTool: ToolDefinition;
-export declare const CONTEXT_TOOLS: readonly [ToolDefinition, ToolDefinition, ToolDefinition, ToolDefinition];
+export declare const CONTEXT_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/contextTools.js

@@ -1,139 +1,10 @@
-import { defineTool } from '../../../tools/defineTool.js';
-import { ContextDiscoveryClient, ContextGrantsClient, ContextReadClient, } from '@ziggs-ai/api-client';
-/**
- * Context grant calls impersonate the grant holder, so both operatorKey (fleet
- * or agent-scoped key) and agentId (X-Agent-Id) must be on the tool context.
- * The same api-client clients back ziggs-mcp — one wire contract, no fork
- * (ZIG-869 / ZIG-775).
- */
-function creds(ctx) {
-    const operatorKey = ctx?.['operatorKey'];
-    const agentId = ctx?.['agentId'];
-    if (!operatorKey)
-        throw new Error('operatorKey missing from tool context');
-    if (!agentId)
-        throw new Error('agentId missing from tool context');
-    return { operatorKey, agentId };
-}
-const CONTEXT_READ_TYPES = [
-    'messages',
-    'artifacts',
-    'agreements',
-    'tasks',
-];
-export const contextReadTool = defineTool('context_read', {
-    type: {
-        type: 'string',
-        required: true,
-        enum: [...CONTEXT_READ_TYPES],
-        description: 'Resource type to read from the scope',
-    },
-    via: {
-        type: 'string',
-        required: true,
-        description: 'Scope entry you hold, e.g. chat:<id>, agreement:<id>, task:<id>',
-    },
-    cursor: { type: 'string', description: 'Opaque cursor from a prior nextCursor to page' },
-    after: {
-        type: 'string',
-        description: 'ISO timestamp for forward-delta (messages/artifacts)',
-    },
-    direction: {
-        type: 'string',
-        enum: ['forward'],
-        description: 'Use "forward" with after for a message forward-delta',
-    },
-    limit: { type: 'number', description: 'Page size (server default when omitted)' },
-    state: { type: 'string', description: 'Task state filter (tasks only)' },
-    contextGrantId: {
-        type: 'string',
-        description: 'Pin a specific grant when you hold several over the same scope',
-    },
-}, async (args, ctx) => {
-    const { operatorKey, agentId } = creds(ctx);
-    const type = args['type'];
-    if (!CONTEXT_READ_TYPES.includes(type)) {
-        throw new Error(`type must be one of ${CONTEXT_READ_TYPES.join(', ')}`);
-    }
-    const via = args['via'];
-    if (!via)
-        throw new Error('via is required');
-    const direction = args['direction'];
-    if (direction !== undefined && direction !== 'forward') {
-        throw new Error('direction must be "forward"');
-    }
-    return new ContextReadClient(operatorKey, agentId).read(type, {
-        via,
-        cursor: args['cursor'],
-        after: args['after'],
-        direction: direction,
-        limit: typeof args['limit'] === 'number' ? args['limit'] : undefined,
-        state: args['state'],
-        contextGrantId: args['contextGrantId'],
-    });
-}, {
-    description: 'Read the contents of a scope you already hold a grant for: messages | artifacts | agreements | tasks. Use list_grants first to see which scopes your grants cover, then read through any of them. Cursored; all access is grant-fenced server-side.',
-});
-export const contextDelegateTool = defineTool('context_delegate', {
-    parentGrantId: { type: 'string', required: true },
-    holderId: { type: 'string', required: true },
-    scopeKind: { type: 'string', required: true },
-    scopeId: { type: 'string', required: true },
-    temporal: { type: 'string', required: true },
-    expiresAt: 'string',
-    watermarkAt: 'string',
-}, async (args, ctx) => {
-    const temporal = args['temporal'];
-    if (temporal !== 'from-now' && temporal !== 'from-start') {
-        throw new Error('temporal must be from-now or from-start');
-    }
-    const scopeKind = args['scopeKind'];
-    if (scopeKind !== 'chat' && scopeKind !== 'agreement' && scopeKind !== 'org') {
-        throw new Error('scopeKind must be chat, agreement, or org');
-    }
-    const { operatorKey, agentId } = creds(ctx);
-    return new ContextGrantsClient(operatorKey, agentId).delegateGrant(args['parentGrantId'], {
-        holderId: args['holderId'],
-        scope: { kind: scopeKind, id: args['scopeId'] },
-        temporal,
-        expiresAt: args['expiresAt'] ?? undefined,
-        watermarkAt: args['watermarkAt'],
-    });
-}, {
-    description: 'Delegate a narrower child context grant (tighter scope, shorter expiry, or from-now). Holder-only. Delegating a grant whose original owner is another party opens an approval request rather than minting immediately (status: pending_approval).',
-});
-export const contextExpandReachTool = defineTool('context_expand_reach', {
-    grantId: {
-        type: 'string',
-        required: true,
-        description: 'A grant you hold (grantId from list_grants) to expand',
-    },
-}, async (args, ctx) => {
-    const { operatorKey, agentId } = creds(ctx);
-    const grantId = args['grantId'];
-    if (!grantId)
-        throw new Error('grantId is required');
-    return new ContextGrantsClient(operatorKey, agentId).getReach(grantId);
-}, {
-    description: 'Expand a grant you hold into the chat/agreement ids inside its scope, so you can read through it. list_grants tells you that you hold e.g. org:acme or agreement:x; this returns the actual { chats, agreements } (ids + labels only, no content) that scope covers — feed an id to context_read (via=chat:<id> / agreement:<id>). Org scope is capped: truncatedChats/truncatedAgreements say how many were left off. Holder-only, grant-fenced.',
-});
-// ZIG-754 — the negative-space complement to the reach tools. list_grants /
-// context_expand_reach answer "what CAN I read?"; this answers "what exists
-// just outside my fence that I CAN'T read yet?" so the agent can flag missing
-// context and make an informed widen request instead of silently
-// under-delivering on partial context. The MCP surface has had this as
-// ziggs_discover_grantable; this is its SDK/legibility complement, backed by
-// the same ContextDiscoveryClient (one wire contract, no fork).
-export const contextDiscoverGrantableTool = defineTool('context_discover_grantable', {}, async (_args, ctx) => {
-    const { operatorKey, agentId } = creds(ctx);
-    const items = await new ContextDiscoveryClient(operatorKey, agentId).discoverGrantable();
-    return { count: items.length, items };
-}, {
-    description: 'See what context EXISTS in your orgs that you CANNOT read yet — the inverse of list_grants. Covers chats, agreements, and connections (type is one of "chat" | "agreement" | "connection"; connection labels are the provider name only). Returns labels only ({ type, label, scopeRef, orgId } per item), never content, member names, tokens, or money. Bounded to orgs you have an active agreement in, and excludes anything you already hold a grant for. Use it to notice you may be missing context, then either ask your human to grant a scopeRef, or (if you hold a broader grant) context_delegate using that scopeRef. Pair with list_grants (what you hold) and context_expand_reach (what a held grant covers).',
-});
-export const CONTEXT_TOOLS = [
-    contextReadTool,
-    contextDelegateTool,
-    contextExpandReachTool,
-    contextDiscoverGrantableTool,
-];
+import { CONTEXT_CAPABILITIES, contextReadCapability, contextDelegateCapability, contextExpandReachCapability, contextDiscoverGrantableCapability, } from '@ziggs-ai/api-client';
+import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
+// ZIG-869 / ZIG-775 / ZIG-956 — context grant tools ride the same api-client
+// clients as ziggs-mcp; the whole definition (schema + handler) is now shared
+// via the capability layer, so the two surfaces cannot fork.
+export const contextReadTool = toolFromCapability(contextReadCapability);
+export const contextDelegateTool = toolFromCapability(contextDelegateCapability);
+export const contextExpandReachTool = toolFromCapability(contextExpandReachCapability);
+export const contextDiscoverGrantableTool = toolFromCapability(contextDiscoverGrantableCapability);
+export const CONTEXT_TOOLS = toolsFromCapabilities(CONTEXT_CAPABILITIES);

package/dist/server/tools/tier2/discoveryTools.d.ts

@@ -1,4 +1,4 @@
-import { type ToolDefinition } from '../../../tools/defineTool.js';
+import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const agentSearchTool: ToolDefinition;
 export declare const agentGetTool: ToolDefinition;
 export declare const DISCOVERY_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/discoveryTools.js

@@ -1,25 +1,8 @@
-import { defineTool } from '../../../tools/defineTool.js';
-import { AgentSearchClient } from '@ziggs-ai/api-client';
-function clientFor(ctx) {
-    const operatorKey = ctx?.['operatorKey'];
-    const agentId = ctx?.['agentId'];
-    if (!operatorKey)
-        throw new Error('operatorKey missing from tool context');
-    if (!agentId)
-        throw new Error('agentId missing from tool context');
-    return new AgentSearchClient(operatorKey, agentId);
-}
-export const agentSearchTool = defineTool('agent_search', { query: { type: 'string', required: true }, limit: 'number' }, async (args, ctx) => {
-    if (!args['query'])
-        throw new Error('query is required');
-    const options = {};
-    if (typeof args['limit'] === 'number')
-        options.limit = args['limit'];
-    return clientFor(ctx).searchAgents(args['query'], options);
-}, { description: 'Search for agents by capability, name, or description. Returns ranked results with relevance scores. Use before agreement_propose or agreement_subcontract to discover the right agent for a job.', isGenericFallback: true });
-export const agentGetTool = defineTool('agent_get', { agentId: { type: 'string', required: true } }, async (args, ctx) => {
-    if (!args['agentId'])
-        throw new Error('agentId is required');
-    return clientFor(ctx).getAgentById(args['agentId']);
-}, { description: 'Fetch the full profile of a specific agent by ID. Use to confirm capabilities and terms before proposing an agreement.' });
+import { agentSearchCapability, agentGetCapability } from '@ziggs-ai/api-client';
+import { toolFromCapability } from '../../../tools/capabilityAdapter.js';
+// ZIG-956 — agent discovery is a shared capability definition (api-client),
+// so search shaping (ZIG-664 zero-hit hint, reachability rows) is identical
+// on both surfaces.
+export const agentSearchTool = toolFromCapability(agentSearchCapability);
+export const agentGetTool = toolFromCapability(agentGetCapability);
 export const DISCOVERY_TOOLS = [agentSearchTool, agentGetTool];

package/dist/server/tools/tier2/grantsTools.d.ts

@@ -1,3 +1,3 @@
-import { type ToolDefinition } from '../../../tools/defineTool.js';
+import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const listGrantsTool: ToolDefinition;
 export declare const GRANTS_TOOLS: ToolDefinition[];

package/dist/server/tools/tier2/grantsTools.js

@@ -1,81 +1,6 @@
-import { defineTool } from '../../../tools/defineTool.js';
-import { GrantsClient, unreadableGrantRails, } from '@ziggs-ai/api-client';
-/**
- * ZIG-893 — the single "what authority do I hold?" tool. One name, every rail
- * (context chat/agreement/org, connection, wallet), holder-scoped, cross-session.
- * Wraps the unified `GET /grants` (GrantsClient) that already replaced the three
- * per-rail listers server-side; this lifts that unification up to the tool layer
- * so an agent no longer has to know three tool names — or, as in the 2026-07-20
- * incident, tell its principal grant lookup doesn't exist because its config
- * happened to omit the one rail's lister.
- */
-function creds(ctx) {
-    const operatorKey = ctx?.['operatorKey'];
-    const agentId = ctx?.['agentId'];
-    if (!operatorKey)
-        throw new Error('operatorKey missing from tool context');
-    if (!agentId)
-        throw new Error('agentId missing from tool context');
-    return { operatorKey, agentId };
-}
-const SCOPE_KINDS = [
-    'chat',
-    'agreement',
-    'org',
-    'connection',
-    'wallet',
-];
-const HEALTHS = ['active', 'expired', 'revoked'];
-function parseScopeKinds(raw) {
-    if (raw == null)
-        return undefined;
-    const list = Array.isArray(raw) ? raw : [raw];
-    const out = [];
-    for (const r of list) {
-        if (!SCOPE_KINDS.includes(r)) {
-            throw new Error(`scopeKind must be one of ${SCOPE_KINDS.join(', ')}`);
-        }
-        if (!out.includes(r))
-            out.push(r);
-    }
-    return out.length ? out : undefined;
-}
-export const listGrantsTool = defineTool('list_grants', {
-    scopeKind: {
-        type: 'array',
-        items: { type: 'string', enum: [...SCOPE_KINDS] },
-        description: 'Rail filter (repeatable): chat | agreement | org (context) | connection | wallet. Omit for every rail you can read.',
-    },
-    health: {
-        type: 'string',
-        enum: [...HEALTHS],
-        description: 'Grant health filter. Defaults to active (live grants only).',
-    },
-    cursor: { type: 'string', description: 'Opaque cursor from a prior nextCursor to page' },
-    limit: { type: 'number', description: 'Page size (server default when omitted)' },
-}, async (args, ctx) => {
-    const { operatorKey, agentId } = creds(ctx);
-    const scopeKind = parseScopeKinds(args['scopeKind']);
-    const healthArg = args['health'];
-    if (healthArg !== undefined && !HEALTHS.includes(healthArg)) {
-        throw new Error(`health must be one of ${HEALTHS.join(', ')}`);
-    }
-    const { items, nextCursor } = await new GrantsClient(operatorKey, agentId).listGrants({
-        scopeKind,
-        // Reach = live grants only by default; pass health to see expired/revoked.
-        health: healthArg ?? 'active',
-        cursor: args['cursor'],
-        limit: typeof args['limit'] === 'number' ? args['limit'] : undefined,
-    });
-    const unreadable = unreadableGrantRails(operatorKey, scopeKind);
-    return {
-        count: items.length,
-        grants: items,
-        nextCursor,
-        ...(unreadable && unreadable.length ? { unreadableRails: unreadable } : {}),
-    };
-}, {
-    description: 'List every grant this agent holds across all rails in one call — context (chat/agreement/org), connection, and wallet — as canonical grants (grantId, scope, caveats, expiresAt, health; no message/artifact content or credentials). The single answer to "what grants of mine do you hold?", holder-scoped and cross-session. Filter by scopeKind (rail) and health (defaults to active). Rails you lack the operator-key read scope for are named in unreadableRails, not silently dropped. Cursor-paginated: pass cursor from a prior nextCursor. Pair with context_read to read through a context grant, or context_expand_reach to enumerate a scope.',
-    isGenericFallback: true,
-});
-export const GRANTS_TOOLS = [listGrantsTool];
+import { GRANTS_CAPABILITIES, listGrantsCapability } from '@ziggs-ai/api-client';
+import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
+// ZIG-893 / ZIG-956 — the single "what authority do I hold?" tool, defined
+// once in api-client's shared capability layer.
+export const listGrantsTool = toolFromCapability(listGrantsCapability);
+export const GRANTS_TOOLS = toolsFromCapabilities(GRANTS_CAPABILITIES);

package/dist/server/tools/tier2/linkTools.d.ts

@@ -1,4 +1,4 @@
-import { type ToolDefinition } from '../../../tools/defineTool.js';
+import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const requestLinkTool: ToolDefinition;
 export declare const createLinkInviteTool: ToolDefinition;
 export declare const claimLinkInviteTool: ToolDefinition;

package/dist/server/tools/tier2/linkTools.js

@@ -1,156 +1,12 @@
-import { defineTool } from '../../../tools/defineTool.js';
-import { createAgreement, claimAgreement, listAgreements, revokeAgreement, } from '@ziggs-ai/api-client';
-/**
- * ZIG-898 — link tools on the SDK surface, same base names as ziggs-mcp's
- * trustTools (ziggs_request_link → request_link, …). Links are agreements with
- * engagementKind 'link' — bilateral agent-to-agent trust that gives unpublished
- * delegates cross-org reach. No new endpoints: everything rides the agreements
- * rail exactly as the MCP tools do.
- *
- * A link is reach-only: it lets the peers find and message each other, never
- * read context — grants stay separate (context_delegate / the owner's grant
- * tools).
- */
-function creds(ctx) {
-    const operatorKey = ctx?.['operatorKey'];
-    const agentId = ctx?.['agentId'];
-    if (!operatorKey)
-        throw new Error('operatorKey missing from tool context');
-    if (!agentId)
-        throw new Error('agentId missing from tool context');
-    return { operatorKey, agentId };
-}
-function webAppOrigin() {
-    return (process.env.ZIGGS_WEB_URL?.trim() || 'https://ziggsai.com').replace(/\/$/, '');
-}
-/**
- * ZIG-670 rule carried over from the MCP tools: link-shaped summaries, not raw
- * agreement documents — the money block, approvals array, and Mongo internals
- * are noise on a trust relationship.
- */
-function linkSummary(a) {
-    return {
-        agreementId: a.agreementId,
-        status: a.status,
-        proposalStatus: a.proposalStatus,
-        parties: {
-            creatorAgent: a.parties?.creatorAgent ?? null,
-            providerAgent: a.parties?.providerAgent ?? null,
-            creator: a.parties?.creator ?? null,
-            proposedTo: a.parties?.proposedTo ?? null,
-        },
-        ...(a.description ? { description: a.description } : {}),
-        createdAt: a.createdAt,
-    };
-}
-const LINK_IS_REACH_ONLY = 'A link is reach-only: it does not grant context. Share a slice of a grant you hold with context_delegate, or ask the peer owner to issue one, before reading.';
-export const requestLinkTool = defineTool('request_link', {
-    providerId: {
-        type: 'string',
-        required: true,
-        description: 'Bare agent id to link with (the target delegate). Use agent_search or a known delegate id — do not guess.',
-    },
-    message: {
-        type: 'string',
-        description: 'Optional note shown to the counterparty human on approval (agreement description)',
-    },
-}, async (args, ctx) => {
-    const { agreement } = await createAgreement({
-        engagementKind: 'link',
-        providerId: args['providerId'],
-        description: args['message'],
-    }, creds(ctx));
-    return {
-        status: 'pending',
-        message: 'Link agreement created — the counterparty owner must approve (agreement_respond on their side) before cross-org reach. Surface pending state to your principal.',
-        agreement: linkSummary(agreement),
-    };
-}, {
-    description: 'Request a bilateral trust link with another agent before cross-org reach (party-to-party, NOT a third-party service connection — that is the connection rail). A link is just an agreement (engagementKind "link"). The target OWNER must approve it before unpublished delegates can message each other.',
-    isAgreementCreation: true,
-});
-export const createLinkInviteTool = defineTool('create_link_invite', {
-    message: {
-        type: 'string',
-        description: 'Optional note shown to whoever opens the invite (agreement description)',
-    },
-}, async (args, ctx) => {
-    const { agreement } = await createAgreement({ engagementKind: 'link', description: args['message'] }, creds(ctx));
-    return {
-        status: 'open',
-        inviteId: agreement.agreementId,
-        claimUrl: `${webAppOrigin()}/app/link-invites/${agreement.agreementId}`,
-        message: 'Open link invite created. Share claimUrl (or the inviteId) with the counterparty — they claim it in the Ziggs web app or via their claim_link_invite tool. No agent id needed on either side. Revoke with revoke_link to disable.',
-        agreement: linkSummary(agreement),
-    };
-}, {
-    description: "Create a shareable OPEN link invite (bilateral agent-to-agent trust) when you do NOT have the counterparty's agent id (e.g. connecting across orgs). Creates an open link agreement proposed to everyone; the recipient forms the link by claiming the returned inviteId.",
-    isAgreementCreation: true,
-});
-export const claimLinkInviteTool = defineTool('claim_link_invite', {
-    agreementId: {
-        type: 'string',
-        required: true,
-        description: 'The invite id (agreementId) shared by the issuer',
-    },
-}, async (args, ctx) => {
-    const { agreement } = await claimAgreement(args['agreementId'], creds(ctx));
-    return {
-        status: 'linked',
-        message: `Link invite claimed — you are now linked. ${LINK_IS_REACH_ONLY}`,
-        agreement: linkSummary(agreement),
-    };
-}, {
-    description: 'Claim an open link invite by its id to form a bilateral link. You become the counterparty and the link activates immediately (cross-org reach). You cannot claim your own invite.',
-});
-export const listLinksTool = defineTool('list_links', {
-    status: {
-        type: 'string',
-        enum: ['active', 'open', 'cancelled', 'all'],
-        description: 'active (default) = established links; open = pending proposals/invites awaiting approval or claim; cancelled = revoked; all = every link regardless of status',
-    },
-}, async (args, ctx) => {
-    const status = args['status'] ?? 'active';
-    if (!['active', 'open', 'cancelled', 'all'].includes(status)) {
-        throw new Error('status must be one of active, open, cancelled, all');
-    }
-    const links = await listAgreements({
-        engagementKind: 'link',
-        ...(status === 'all' ? {} : { status }),
-    }, creds(ctx));
-    const summaries = links.map(linkSummary);
-    const hasActive = links.some((a) => a.status === 'active');
-    return {
-        count: summaries.length,
-        status,
-        links: summaries,
-        ...(hasActive ? { nextSteps: LINK_IS_REACH_ONLY } : {}),
-    };
-}, {
-    description: 'List link agreements for this agent — bilateral agent-to-agent trust relationships (GET /agreements?engagementKind=link). Defaults to ACTIVE links only; pass status to see pending proposals ("open") or revoked ones ("cancelled"). Each item is a link summary: agreementId, status, proposalStatus, parties.',
-    isGenericFallback: true,
-});
-export const revokeLinkTool = defineTool('revoke_link', {
-    agreementId: {
-        type: 'string',
-        required: true,
-        description: 'agreementId of the link agreement (from list_links)',
-    },
-}, async (args, ctx) => {
-    const result = await revokeAgreement(args['agreementId'], creds(ctx));
-    return {
-        status: 'revoked',
-        message: 'Link revoked — unpublished cross-org reach to this peer is blocked again.',
-        agreementId: args['agreementId'],
-        agreement: result.agreement ? linkSummary(result.agreement) : null,
-    };
-}, {
-    description: 'Revoke a bilateral link agreement (DELETE /agreements/:agreementId). Either party may revoke; cross-org reach ends immediately. For non-link agreements (hire/service/quest), use agreement_revoke — same endpoint, different messaging.',
-});
-export const LINK_TOOLS = [
-    requestLinkTool,
-    createLinkInviteTool,
-    claimLinkInviteTool,
-    listLinksTool,
-    revokeLinkTool,
-];
+import { LINK_CAPABILITIES, requestLinkCapability, createLinkInviteCapability, claimLinkInviteCapability, listLinksCapability, revokeLinkCapability, } from '@ziggs-ai/api-client';
+import { toolFromCapability, toolsFromCapabilities } from '../../../tools/capabilityAdapter.js';
+// ZIG-898 / ZIG-956 — links are agreements with engagementKind 'link':
+// bilateral agent-to-agent trust that gives unpublished delegates cross-org
+// reach. Defined once in api-client's shared capability layer (including the
+// ZIG-670 linkSummary shaping); this file only adapts them onto the SDK.
+export const requestLinkTool = toolFromCapability(requestLinkCapability);
+export const createLinkInviteTool = toolFromCapability(createLinkInviteCapability);
+export const claimLinkInviteTool = toolFromCapability(claimLinkInviteCapability);
+export const listLinksTool = toolFromCapability(listLinksCapability);
+export const revokeLinkTool = toolFromCapability(revokeLinkCapability);
+export const LINK_TOOLS = toolsFromCapabilities(LINK_CAPABILITIES);

package/dist/server/tools/tier2/paymentTools.d.ts

@@ -1,10 +1,10 @@
-import { type ToolDefinition } from '../../../tools/defineTool.js';
+import type { ToolDefinition } from '../../../tools/defineTool.js';
 export declare const paymentBalanceTool: ToolDefinition;
 export declare const paymentTransferTool: ToolDefinition;
 export declare const paymentWaitForApprovalTool: ToolDefinition;
-export declare const paymentResolveWalletTool: ToolDefinition;
 export declare const paymentHoldTool: ToolDefinition;
 export declare const paymentReleaseTool: ToolDefinition;
+export declare const paymentResolveWalletTool: ToolDefinition;
 export declare const paymentIssueGrantTool: ToolDefinition;
 export declare const paymentAttenuateGrantTool: ToolDefinition;
 export declare const paymentRevokeGrantTool: ToolDefinition;