@ziggs-ai/api-client 0.19.0 → 0.21.0

package/dist/capabilities/agreementVerbs.d.ts

@@ -22,3 +22,10 @@ export declare const agreementRequestCapability: CapabilityDefinition;
 export declare const agreementOfferCapability: CapabilityDefinition;
 export declare const agreementHandoffCapability: CapabilityDefinition;
 export declare const AGREEMENT_VERB_CAPABILITIES: CapabilityDefinition[];
+/**
+ * Subcontract sits next to the propose verbs, not inside them: the parent
+ * already exists, and the conversation is optional. The server uses the
+ * parent's own chat when none is named. That list of required arguments is
+ * this definition — nextCall, MCP, and the SDK tool all read it.
+ */
+export declare const agreementSubcontractCapability: CapabilityDefinition;

package/dist/capabilities/agreementVerbs.js

@@ -1,4 +1,4 @@
-import { getAgreement, proposeBroadcast, proposeDirectTo, } from '../http/AgreementClient.js';
+import { delegateAgreement, getAgreement, proposeBroadcast, proposeDirectTo, } from '../http/AgreementClient.js';
 import { publishOffer } from '../http/MarketplaceClient.js';
 import { fullCreds } from './types.js';
 import { nextCall } from './nextCall.js';
@@ -382,3 +382,86 @@ export const AGREEMENT_VERB_CAPABILITIES = [
     agreementOfferCapability,
     agreementHandoffCapability,
 ];
+/**
+ * Subcontract sits next to the propose verbs, not inside them: the parent
+ * already exists, and the conversation is optional. The server uses the
+ * parent's own chat when none is named. That list of required arguments is
+ * this definition — nextCall, MCP, and the SDK tool all read it.
+ */
+export const agreementSubcontractCapability = {
+    key: 'agreement_subcontract',
+    names: { sdk: 'agreement_subcontract', mcp: 'ziggs_agreement_subcontract' },
+    title: 'Subcontract part of your work',
+    descriptions: {
+        sdk: 'Delegate a slice of an active parent agreement to another agent. Name the parent, the worker, and the slice. The worker must approve — never impersonated. A chat is optional: omit it and the slice lands in the parent agreement\'s own room.',
+        mcp: 'Delegate a slice of an active parent agreement to another agent. Name the parent, the worker, and the slice. The worker must approve — never impersonated. A chat is optional: omit it and the slice lands in the parent agreement\'s own room. Spawn tasks for the worker under the sub-agreement once it is active.',
+    },
+    annotation: 'write',
+    params: {
+        parentAgreementId: {
+            type: 'string',
+            required: true,
+            description: 'The active agreement you are delegating under',
+        },
+        executorId: {
+            type: 'string',
+            required: true,
+            description: 'Agent doing the delegated work',
+        },
+        description: {
+            type: 'string',
+            required: true,
+            description: 'What the sub-agreement covers',
+        },
+        chatId: {
+            type: 'string',
+            description: "Chat the subcontract is coordinated in. Omit it and the server uses the parent agreement's own chat — which is where a slice with no conversation of its own belongs.",
+        },
+        price: {
+            type: 'number',
+            description: 'Price in POINTS, as an integer of hundredths — 500 means ϟ5.00. Recording a price here does not itself move any.',
+        },
+        lifecycle: {
+            type: 'string',
+            enum: ['open', 'time-bound', 'count-bound'],
+            description: "Usually inferred: expiresAt → 'time-bound', maxExecutions → 'count-bound', neither → 'open' (standing).",
+        },
+        expiresAt: { type: 'string' },
+        maxExecutions: { type: 'number' },
+        agreementDescription: { type: 'string' },
+        payerId: {
+            type: 'string',
+            description: 'Who pays for the subcontracted work. Defaults to the delegating side.',
+        },
+    },
+    needsAgentId: true,
+    handler: async (args, env) => {
+        const chatId = args['chatId'];
+        const agreement = await delegateAgreement({
+            parentAgreementId: args['parentAgreementId'],
+            executorId: args['executorId'],
+            description: args['description'],
+            ...(typeof chatId === 'string' && chatId.trim()
+                ? { chatId: chatId.trim() }
+                : {}),
+            ...(args['price'] === undefined ? {} : { price: args['price'] }),
+            ...(args['lifecycle'] === undefined
+                ? {}
+                : { lifecycle: args['lifecycle'] }),
+            ...(args['expiresAt'] === undefined
+                ? {}
+                : { expiresAt: args['expiresAt'] }),
+            ...(args['maxExecutions'] === undefined
+                ? {}
+                : { maxExecutions: args['maxExecutions'] }),
+            ...(args['agreementDescription'] === undefined
+                ? {}
+                : { agreementDescription: args['agreementDescription'] }),
+            ...(args['payerId'] === undefined
+                ? {}
+                : { payerId: args['payerId'] }),
+        }, fullCreds(env));
+        return { agreement };
+    },
+    sdkOptions: { isAgreementCreation: true },
+};

package/dist/capabilities/agreements.d.ts

@@ -1,5 +1,6 @@
 import type { ClaimedKind } from '../http/AgreementClient.js';
 import type { Agreement } from '../types.js';
+import { type NextCallOutcome, type WorkContext } from './nextCall.js';
 import { type CapabilityDefinition, type CapabilityEnv } from './types.js';
 /**
  * One claim result shape for both surfaces. The SDK protocol runner used to
@@ -8,9 +9,11 @@ import { type CapabilityDefinition, type CapabilityEnv } from './types.js';
  */
 export declare function presentClaimResult(agreement: Agreement, kind: ClaimedKind, env: CapabilityEnv): {
     status: string;
+    outcome: NextCallOutcome;
     kind: ClaimedKind;
     message: string;
     agreement: Agreement;
+    workContext?: WorkContext;
 };
 /**
  * the one claim verb. Requests, standing offers, and link invites

package/dist/capabilities/agreements.js

@@ -1,6 +1,7 @@
 import { agreementAppUrl } from '../utils/appUrls.js';
 import { claimOpenAgreement } from '../http/agreementFlows.js';
 import { linkIsReachOnly, webAppOrigin } from './links.js';
+import { workContextFromEnv } from './nextCall.js';
 import { fullCreds } from './types.js';
 /** Which side the claimer just took, for a claim that has not activated yet. */
 function claimedWhat(kind) {
@@ -16,12 +17,15 @@ function claimedWhat(kind) {
  * agreement}` — same HTTP call, two answers.
  */
 export function presentClaimResult(agreement, kind, env) {
+    const workContext = workContextFromEnv(env);
     if (kind === 'link') {
         return {
             status: 'linked',
+            outcome: 'ok',
             kind,
             message: `Link invite claimed — you are now linked. ${linkIsReachOnly(env)}`,
             agreement,
+            ...(workContext ? { workContext } : {}),
         };
     }
     if (agreement?.status !== 'active') {
@@ -31,16 +35,19 @@ export function presentClaimResult(agreement, kind, env) {
             ? 'This is a first engagement with that counterparty — your human approves once; a standing link covers it after that.'
             : 'Claiming for a job your human already approved activates at once — name the job with mandateAgreementId.';
         return {
-            status: 'claimed',
+            status: 'pending_approval',
+            outcome: 'pending',
             kind,
             message: `${claimedWhat(kind)} It is not active yet: the formation is waiting on ` +
                 'human approval, so nothing can be created under it until that lands. ' +
                 `Your human can approve it here: ${approveUrl} — ${remedy}`,
             agreement,
+            ...(workContext ? { workContext } : {}),
         };
     }
     return {
         status: 'claimed',
+        outcome: 'ok',
         kind,
         message: kind === 'offer'
             ? 'Standing offer claimed — the publisher provides, your side pays. Spawn work under it with the task-create tool.'
@@ -48,6 +55,7 @@ export function presentClaimResult(agreement, kind, env) {
                 ? 'Hand-off claimed — the pinned agent works FOR you: you are the customer (and the payer when priced), never the worker. Spawn work under it with the task-create tool.'
                 : 'Request claimed — you provide the work. Read the terms, then post progress and set the task result under this agreement.',
         agreement,
+        ...(workContext ? { workContext } : {}),
     };
 }
 /**

package/dist/capabilities/artifacts.d.ts

@@ -1,4 +1,6 @@
+import { type DiscoverableItem } from '../http/ContextDiscoveryClient.js';
 import { type CapabilityDefinition } from './types.js';
+import { type NextCall } from './nextCall.js';
 export declare const recordArtifactCapability: CapabilityDefinition;
 /**
  * the artifacts you wrote, across every scope and none.
@@ -8,6 +10,42 @@ export declare const recordArtifactCapability: CapabilityDefinition;
  * agent finds what it recorded without naming a container.
  */
 export declare const listArtifactsCapability: CapabilityDefinition;
+/**
+ * What the agent could not read, said as metadata and nothing else.
+ *
+ * The one thing this block must never become is a second results list. A row
+ * here is a LABEL — `context_discover_grantable` re-shapes every row to
+ * type/label/scopeRef/orgId on the way through, so no message, no member name
+ * and no artifact body can travel in it, and none of these scopes were searched
+ * at all. Keeping them in a separate field with its own wording is the whole
+ * point: an agent that cannot tell "no match in what I can read" from "there is
+ * a locked room over there" will confidently report the first while the answer
+ * sits in the second.
+ */
+export interface UnsearchedContext {
+    /** Locked scopes, labels only — never content, never counts of content. */
+    items: (DiscoverableItem & {
+        requestAccess: NextCall;
+    })[];
+    count: number;
+    note: string;
+}
+/**
+ * search the work you hold, and say what you searched.
+ *
+ * `artifact_list` answers "what did I write" and the scope reads answer "what
+ * is in this container". Neither answers "where is the thing about X", which is
+ * the question an agent actually has when it has been handed work that refers
+ * to something it did not produce. The server bounds this by the agent's own
+ * reach — authorship, readable containers, artifact grants it holds — under the
+ * active lane and shared-room containment, so there is no `reach` arm to ask
+ * for and the narrowing filters are refused rather than ignored.
+ *
+ * The response is deliberately two things that never merge: `artifacts`, which
+ * is readable content that matched, and `notSearched`, which is labels of
+ * scopes that were never opened. `coverage` sits between them naming what ran.
+ */
+export declare const findArtifactsCapability: CapabilityDefinition;
 /**
  * hand one artifact you authored to one other agent.
  *

package/dist/capabilities/artifacts.js

@@ -1,7 +1,9 @@
 import { ArtifactsClient } from '../http/ArtifactsClient.js';
 import { ContextGrantsClient } from '../http/ContextGrantsClient.js';
+import { ContextDiscoveryClient, } from '../http/ContextDiscoveryClient.js';
 import { fullCreds } from './types.js';
 import { LIST_FIELDS_PARAM, parseListFields, pickListedRows } from './listedFields.js';
+import { nextCall } from './nextCall.js';
 /**
  * teaching: name the result slot on the success path so an agent finds
  * the right move unaided — worded in each surface's task grammar (SDK
@@ -16,7 +18,10 @@ function reportingHint(env, contentType, taskId) {
             ? `Recorded as a task-bound result artifact. Close the task by setting its terminal result with ${close}.`
             : `Recorded as a result artifact, but not bound to a task — pass taskId to bind it, then close the task with ${close}.`;
     }
-    return `Reporting finished work? Record it with contentType=result bound to the task (taskId), then close the task with ${close} — chat messages are conversation only.`;
+    // The record and the delivery are different acts. A chat message
+    // is not where the next agent collects the work, and saying that as "chat is
+    // conversation only" read as a ban on telling the person who asked.
+    return `Reporting finished work? Record it with contentType=result bound to the task (taskId), then close the task with ${close} — that record is what the next agent reads. Telling the person who asked is a separate chat message, and still worth sending.`;
 }
 /** Inline body cap + escape hatch, shared by SDK/MCP descriptions. */
 const ARTIFACT_RECORD_INLINE_CAP = 'Inline text max 50000 characters. Over that: pass the body as a file ' +
@@ -267,8 +272,8 @@ export const listArtifactsCapability = {
     names: { sdk: 'artifact_list', mcp: 'ziggs_artifact_list' },
     title: 'List artifacts you wrote',
     descriptions: {
-        sdk: 'List artifacts you authored, in any scope or none — including free-standing ones no scope read can reach. Forward-delta with `after`.',
-        mcp: 'List artifacts YOU authored, across every scope and none. Use this to find something you ' +
+        sdk: 'List business artifacts you authored, in any scope or none — including free-standing ones no scope read can reach. Tool-operation and thought traces are excluded. Forward-delta with `after`.',
+        mcp: 'List business artifacts YOU authored, across every scope and none; tool-operation and thought traces are excluded. Use this to find something you ' +
             'recorded free-standing (no chat/agreement/task), which the scope reads cannot return. ' +
             'To read an artifact someone shared WITH you, use ziggs_context_read with via=artifact:<id>; ' +
             'to see what has been shared with you, use ziggs_grant_list with scopeKind=artifact.',
@@ -295,6 +300,133 @@ export const listArtifactsCapability = {
             : listed;
     },
 };
+const UNSEARCHED_NOTE = 'These were NOT searched. You hold no grant on them, so only their label is ' +
+    'visible here — no contents, no message counts, nothing that would leak what ' +
+    'is inside. Each row carries requestAccess: an access explanation, not a ' +
+    'root grant. A human issues the grant; this never widens the scope to the ' +
+    'chat, agreement, or org around one artifact.';
+const OPEN_ID_FIELD = {
+    chat: 'chatId',
+    agreement: 'agreementId',
+    artifact: 'artifactId',
+    task: 'taskId',
+};
+function pendingAccessReceipt(result, extra) {
+    return {
+        ...extra,
+        ok: false,
+        outcome: 'pending',
+        status: 'pending_approval',
+        state: 'requested',
+        recoverable: true,
+        agreementId: result.agreementId,
+        ownerId: result.ownerId,
+    };
+}
+/**
+ * The locked scopes near a search that found nothing.
+ *
+ * Fetched only when it changes what a caller should conclude, which is why it
+ * is not on every response: an agent holding a page of matches does not need
+ * the list of doors it has not opened, and an extra round trip on every find
+ * would buy nothing. A search that came back empty is exactly where the wrong
+ * conclusion gets drawn, so that is where this arrives unasked.
+ *
+ * Discovery failing is not find failing. It is bounded to orgs the agent holds
+ * an active work agreement in and can legitimately return nothing, or refuse;
+ * either way the matches already computed are the answer, and the miss is
+ * reported as a limitation rather than thrown over the top of them.
+ */
+async function unsearchedContext(env) {
+    const creds = fullCreds(env);
+    let items;
+    try {
+        items = await new ContextDiscoveryClient(creds.operatorKey, creds.agentId).discoverGrantable();
+    }
+    catch (err) {
+        return {
+            note: 'Could not check for context you cannot read yet: ' +
+                `${err instanceof Error ? err.message : String(err)}. ` +
+                'Treat this answer as covering only what was searched.',
+        };
+    }
+    return {
+        items: items.map((item) => {
+            const idField = OPEN_ID_FIELD[item.scopeRef.kind];
+            return {
+                ...item,
+                requestAccess: nextCall(env, 'access_explain', idField ? { [idField]: item.scopeRef.id } : undefined, idField
+                    ? `explain access to locked ${item.type} "${item.label}" — a human issues a root grant; this call does not request or widen`
+                    : `locked ${item.type} "${item.label}" cannot be requested from this surface — a human issues a root grant; this never widens the scope`, {
+                    hold: 'human_approval',
+                    ...(idField ? {} : { outcome: 'unavailable' }),
+                }),
+            };
+        }),
+        count: items.length,
+        note: UNSEARCHED_NOTE,
+    };
+}
+/**
+ * search the work you hold, and say what you searched.
+ *
+ * `artifact_list` answers "what did I write" and the scope reads answer "what
+ * is in this container". Neither answers "where is the thing about X", which is
+ * the question an agent actually has when it has been handed work that refers
+ * to something it did not produce. The server bounds this by the agent's own
+ * reach — authorship, readable containers, artifact grants it holds — under the
+ * active lane and shared-room containment, so there is no `reach` arm to ask
+ * for and the narrowing filters are refused rather than ignored.
+ *
+ * The response is deliberately two things that never merge: `artifacts`, which
+ * is readable content that matched, and `notSearched`, which is labels of
+ * scopes that were never opened. `coverage` sits between them naming what ran.
+ */
+export const findArtifactsCapability = {
+    key: 'artifact_find',
+    names: { sdk: 'artifact_find', mcp: 'ziggs_artifact_find' },
+    title: 'Find artifacts you can read',
+    descriptions: {
+        sdk: 'Search business artifacts you can already reach (excluding tool-operation and thought traces) — what you authored, what your readable chats/agreements/tasks hold, and what artifact grants you hold — by words in the name, filename or body. Bounded by your active lane and the rooms this wake is shared into, the same fences a point read obeys; there is no cross-customer arm and narrowing filters are refused, not ignored. Every answer carries coverage (fields searched, reach arms and their sizes, any that hit a cap), so an empty result means no match in what was searched, never that the thing does not exist. When nothing matched you also get notSearched: labels of context you hold no grant on, each with an access explanation — a human issues a root grant; this never widens. Metadata only, never contents.',
+        mcp: 'Search the business artifacts YOU can read for words in their name, filename or body; tool-operation and thought traces are excluded. Covers what you authored, what the chats/agreements/tasks you can read contain, and artifacts shared with you — bounded by your active lane and shared-room containment, exactly like a point read. Open a hit with ziggs_context_read (via=artifact:<id>). ' +
+            'Read the coverage block before concluding anything: it names the fields searched, the arms that produced candidates and any that hit a cap. No match means no match in THOSE sources — it is never a statement that the artifact does not exist. ' +
+            'If nothing matched, notSearched lists context you cannot read yet (same rows as ziggs_context_discover_grantable): labels only, never contents, each with an access explanation. A human issues a root grant; do not treat that as a share or a wider container grant. Do not report "not found" while notSearched is non-empty — say what you searched and what is still locked.',
+    },
+    annotation: 'read-only',
+    params: {
+        q: {
+            type: 'string',
+            required: true,
+            description: 'Words to match; every term must appear. This is a lexical match on name, filename and extracted text — not a semantic search.',
+        },
+        limit: { type: 'number', description: 'Page size (server default when omitted)' },
+        before: {
+            type: 'string',
+            description: 'Older-rows cursor: pass the previous page’s coverage.nextCursor back verbatim (opaque).',
+        },
+        includeUnreadable: {
+            type: 'boolean',
+            description: 'Also list context you hold no grant on (labels only, never contents). Defaults on when nothing matched, since that is when an empty answer is most likely to be misread; pass true to ask for it alongside matches.',
+        },
+        fields: LIST_FIELDS_PARAM,
+    },
+    needsAgentId: true,
+    handler: async (args, env) => {
+        const creds = fullCreds(env);
+        const found = await new ArtifactsClient(creds.operatorKey, creds.agentId, creds.laneId).find(args['q'], {
+            limit: typeof args['limit'] === 'number' ? args['limit'] : undefined,
+            before: args['before'],
+        });
+        const fields = parseListFields(args['fields']);
+        const shaped = fields
+            ? { ...found, artifacts: pickListedRows(found.artifacts, fields) }
+            : found;
+        const asked = args['includeUnreadable'] === true;
+        if (!asked && found.artifacts.length > 0)
+            return shaped;
+        return { ...shaped, notSearched: await unsearchedContext(env) };
+    },
+};
 /**
  * hand one artifact you authored to one other agent.
  *
@@ -335,6 +467,10 @@ export const shareArtifactCapability = {
             type: 'string',
             description: 'Chat to surface the approval request in, when the receiver’s owner has to approve',
         },
+        idempotencyKey: {
+            type: 'string',
+            description: 'Replay the same share. Same key and payload recover the original request; the same key with a different payload is a conflict, not a second share.',
+        },
     },
     needsAgentId: true,
     handler: async (args, env) => {
@@ -349,16 +485,20 @@ export const shareArtifactCapability = {
             holderId,
             expiresAt: args['expiresAt'],
             chatId: args['chatId'],
+        }, {
+            idempotencyKey: typeof args['idempotencyKey'] === 'string'
+                ? args['idempotencyKey']
+                : undefined,
         });
         if (result.status === 'pending_approval') {
-            return {
-                ok: true,
+            return pendingAccessReceipt(result, {
                 ...result,
-                note: `Not shared yet — ${result.ownerId ?? 'the owner'} must approve agreement ${result.agreementId}.`,
-            };
+                note: `Requested, not granted — ${result.ownerId ?? 'the owner'} must approve agreement ${result.agreementId}. Recover that id; do not open a second card.`,
+            });
         }
         return {
             ok: true,
+            outcome: 'ok',
             ...result,
             note: `${holderId} can now read artifact ${artifactId} with via=artifact:${artifactId}.`,
         };
@@ -644,6 +784,7 @@ export const reextractArtifactCapability = {
 export const ARTIFACT_CAPABILITIES = [
     recordArtifactCapability,
     listArtifactsCapability,
+    findArtifactsCapability,
     shareArtifactCapability,
     attachArtifactCapability,
     uploadArtifactUrlCapability,

package/dist/capabilities/chat.d.ts

@@ -1,4 +1,34 @@
-import { type CapabilityDefinition } from './types.js';
+import { type SendChatMessageResult } from '../http/ChatClient.js';
+import { type CapabilityDefinition, type CapabilityEnv } from './types.js';
+import { type WorkContext } from './nextCall.js';
+export interface SendPresentation {
+    ok: true;
+    chatId: string;
+    messageId: string;
+    /** What the server did with this send, stated so it cannot be over-read. */
+    delivered: string;
+    /** Who it was addressed to, exactly as the server resolved it. */
+    to?: {
+        id: string;
+        type: string;
+    };
+    workContext?: WorkContext;
+}
+/**
+ * Present a send as what it is: a message that now exists, addressed to
+ * somebody, which may or may not wake anyone.
+ *
+ * An agent that sent an answer and read `success: true` had every reason to
+ * report the answer delivered. Three different things hide behind that word.
+ * The message exists — that much is certain. Who it reached is the server's
+ * decision, not the caller's, because an omitted recipient may be inferred.
+ * Mailbox routing is a separate asynchronous decision, including coverage by
+ * an assistant when the addressee is a person.
+ *
+ * A server that does not report the destination gets one honest line about the
+ * message existing, and nothing invented about where it went.
+ */
+export declare function presentSendResult(result: SendChatMessageResult, env: CapabilityEnv): SendPresentation;
 /**
  * the decided chat surface for agents: chat_open only.
  * There is deliberately NO chat-listing tool on the SDK: taking part in a room

package/dist/capabilities/chat.js

@@ -1,5 +1,44 @@
 import { openConversation } from '../http/ChatClient.js';
 import { fullCreds } from './types.js';
+import { workContextFromEnv } from './nextCall.js';
+/**
+ * Present a send as what it is: a message that now exists, addressed to
+ * somebody, which may or may not wake anyone.
+ *
+ * An agent that sent an answer and read `success: true` had every reason to
+ * report the answer delivered. Three different things hide behind that word.
+ * The message exists — that much is certain. Who it reached is the server's
+ * decision, not the caller's, because an omitted recipient may be inferred.
+ * Mailbox routing is a separate asynchronous decision, including coverage by
+ * an assistant when the addressee is a person.
+ *
+ * A server that does not report the destination gets one honest line about the
+ * message existing, and nothing invented about where it went.
+ */
+export function presentSendResult(result, env) {
+    const workContext = workContextFromEnv(env);
+    const delivery = result.delivery;
+    const base = {
+        ok: true,
+        chatId: result.chatId,
+        messageId: result.messageId,
+        ...(workContext ? { workContext } : {}),
+    };
+    if (!delivery) {
+        return {
+            ...base,
+            delivered: `Message ${result.messageId} was accepted into chat ${result.chatId}. Accepted is not read: nothing here says anyone has seen it.`,
+        };
+    }
+    const destination = delivery.broadcast
+        ? 'the humans in the room, not one addressee'
+        : `${delivery.to.id} (${delivery.to.type})`;
+    return {
+        ...base,
+        delivered: `Message ${result.messageId} was accepted into chat ${result.chatId}, addressed to ${destination}. Mailbox routing is unconfirmed; a person may be covered by an assistant. Accepted is not read and does not confirm a wake or reply.`,
+        to: delivery.to,
+    };
+}
 /**
  * the decided chat surface for agents: chat_open only.
  * There is deliberately NO chat-listing tool on the SDK: taking part in a room

package/dist/capabilities/context.d.ts

@@ -20,4 +20,7 @@ export declare const contextReadCapability: CapabilityDefinition;
 export declare const contextExpandReachCapability: CapabilityDefinition;
 export declare const contextDiscoverGrantableCapability: CapabilityDefinition;
 export declare const contextDelegateCapability: CapabilityDefinition;
+export declare const openCapability: CapabilityDefinition;
+export declare const accessExplainCapability: CapabilityDefinition;
 export declare const CONTEXT_CAPABILITIES: CapabilityDefinition[];
+export declare const contextRequestCapability: CapabilityDefinition;