@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/hitl/replayedApproval.js

@@ -1,29 +1,64 @@
-import { hasLedgerPositionKey } from './gateLedger.js';
+import { APPROVAL_SETTLED_HOWS, hasLedgerPositionKey } from './gateLedger.js';
 import { readLivePendingRows } from './livePendingAsk.js';
 import { projectCrashConverged } from './crashConverged.js';
+import { quoteUntrustedForSentence } from '../displayUntrusted.js';
 const live = (basis) => Object.freeze({ kind: 'live', basis });
 const unknown = (why) => Object.freeze({ kind: 'unknown', why });
-const decided = (cause) => Object.freeze(cause !== undefined ? { kind: 'decided', cause } : { kind: 'decided' });
+const decided = (row) => Object.freeze(row === undefined
+    ? { kind: 'decided' }
+    : { kind: 'decided', cause: row.cause, ...(row.needsHumanReason !== undefined ? { needsHumanReason: row.needsHumanReason } : {}) });
+const decidedSettled = (how) => Object.freeze({ kind: 'decided', settled: how });
 function approvalIdOf(frame) {
     const v = frame.approvalId;
     return typeof v === 'string' && v !== '' ? v : undefined;
 }
-function crashConvergedCauseOf(body, approvalId) {
+function crashConvergedFactsOf(body, approvalId) {
     const projection = projectCrashConverged(body);
     if (projection === undefined)
         return undefined;
     for (const row of [...projection.resumeSafe, ...projection.needsHuman]) {
         if (row.approvalId === approvalId)
-            return row.cause;
+            return { cause: row.cause, ...(row.needsHumanReason !== undefined ? { needsHumanReason: row.needsHumanReason } : {}) };
     }
     return undefined;
 }
+export function settledApprovalDisposition(frame, settled) {
+    try {
+        if (typeof settled !== 'object' || settled === null || typeof settled.get !== 'function')
+            return undefined;
+        const id = approvalIdOf(frame);
+        if (id === undefined)
+            return undefined;
+        const how = settled.get(id);
+        return typeof how === 'string' && APPROVAL_SETTLED_HOWS.includes(how) ? decidedSettled(how) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function replayedApprovalDisposition(frame, basis) {
     let approvalId;
+    let positioned;
     try {
         if (typeof frame !== 'object' || frame === null)
             return unknown('unreadable_frame');
-        if (!hasLedgerPositionKey(frame))
+        positioned = hasLedgerPositionKey(frame);
+    }
+    catch {
+        return unknown('unreadable_frame');
+    }
+    let settledBasis;
+    try {
+        settledBasis = typeof basis === 'object' && basis !== null ? basis.settled : undefined;
+    }
+    catch {
+        settledBasis = undefined;
+    }
+    const early = settledApprovalDisposition(frame, settledBasis);
+    if (early !== undefined)
+        return early;
+    try {
+        if (!positioned)
             return live('live_leg');
         approvalId = approvalIdOf(frame);
     }
@@ -70,15 +105,15 @@ export function replayedApprovalDisposition(frame, basis) {
     }
     if (reading.kind === 'present' && reading.rows.some((r) => r.approvalId === approvalId))
         return live('pending_list');
-    let cause;
+    let facts;
     try {
-        cause = crashConvergedCauseOf(body, approvalId);
+        facts = crashConvergedFactsOf(body, approvalId);
     }
     catch {
-        cause = undefined;
+        facts = undefined;
     }
-    if (cause !== undefined)
-        return decided(cause);
+    if (facts !== undefined)
+        return decided(facts);
     if (reading.kind === 'not_reported')
         return unknown('list_not_reported');
     if (reading.kind === 'malformed')
@@ -87,3 +122,83 @@ export function replayedApprovalDisposition(frame, basis) {
         return unknown('list_incomplete');
     return decided();
 }
+const TOOL_NAME_MAX = 80;
+const THIS_REQUEST = 'this approval request';
+const sentenceInitial = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+const TOOL_STATE_NOT_SHOWN = 'Whether the tool had started is not shown here.';
+const STOPPED_BY_CAUSE = Object.freeze({
+    crashed_before_park: 'the engine stopped unexpectedly',
+    shutdown_before_park: 'the engine was shut down in an orderly way',
+});
+const STATE_BY_REASON = Object.freeze({
+    pending_unsafe: 'waiting',
+    approved_then_interrupted: 'approved',
+    contradictory: 'unclear',
+    unstable_row: 'unclear',
+});
+const CRASH_CONVERGED_SENTENCE = Object.freeze({
+    waiting: (what, stopped) => `${sentenceInitial(what)} was still waiting when ${stopped}, so the engine denied it automatically; no decision was sent for it from here. ${TOOL_STATE_NOT_SHOWN}`,
+    approved: (what, stopped) => `${sentenceInitial(what)} had already been approved and may have been running when ${stopped}, so a side effect may have partly landed; the engine then marked it denied, and no decision was sent for it from here.`,
+    unclear: (what, stopped) => `${sentenceInitial(what)} was denied automatically when ${stopped}, but its record does not show reliably whether it had been approved or whether the tool had started; no decision was sent for it from here.`,
+});
+function crashConvergedStateOf(disposition) {
+    let reason;
+    try {
+        if (typeof disposition !== 'object' || disposition === null || !('needsHumanReason' in disposition))
+            return 'waiting';
+        reason = disposition.needsHumanReason;
+    }
+    catch {
+        return 'unclear';
+    }
+    if (reason === undefined)
+        return 'waiting';
+    return typeof reason === 'string' && Object.hasOwn(STATE_BY_REASON, reason) ? STATE_BY_REASON[reason] : 'unclear';
+}
+const SETTLED_PHRASE = Object.freeze({
+    answered: 'answered',
+    interrupted: 'dismissed',
+    closed_by_engine: 'closed by the engine',
+});
+const settledRepeat = (what, how) => `${sentenceInitial(what)} was ${SETTLED_PHRASE[how]} earlier, so this repeated copy of it was not raised as a new question and no decision was sent for it.`;
+const decidedPlain = (what) => `${sentenceInitial(what)} is no longer listed by the engine as waiting for a decision, so no decision was sent for it.`;
+const unconfirmed = (what) => `Whether ${what} is still waiting for a decision could not be confirmed, so no decision was sent for it.`;
+function guardedGet(o, key) {
+    try {
+        if (typeof o !== 'object' || o === null)
+            return undefined;
+        return o[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+function subjectOf(opts) {
+    const raw = guardedGet(opts, 'toolName');
+    if (typeof raw !== 'string')
+        return THIS_REQUEST;
+    let quoted;
+    try {
+        quoted = quoteUntrustedForSentence(raw, TOOL_NAME_MAX);
+    }
+    catch {
+        return THIS_REQUEST;
+    }
+    return quoted === undefined ? THIS_REQUEST : `the approval request for ${quoted}`;
+}
+export function replayedApprovalSentence(disposition, opts) {
+    const kind = guardedGet(disposition, 'kind');
+    if (kind === 'unknown')
+        return unconfirmed(subjectOf(opts));
+    if (kind !== 'decided')
+        return undefined;
+    const what = subjectOf(opts);
+    const cause = guardedGet(disposition, 'cause');
+    if (typeof cause === 'string' && Object.hasOwn(STOPPED_BY_CAUSE, cause)) {
+        return CRASH_CONVERGED_SENTENCE[crashConvergedStateOf(disposition)](what, STOPPED_BY_CAUSE[cause]);
+    }
+    const settled = guardedGet(disposition, 'settled');
+    if (typeof settled === 'string' && Object.hasOwn(SETTLED_PHRASE, settled))
+        return settledRepeat(what, settled);
+    return decidedPlain(what);
+}

package/dist/hitl/resumeRunningCard.d.ts

@@ -17,6 +17,7 @@ export interface ResumeRunningCardOption {
 }
 export declare function resumeRunningLivenessRow(msSinceLastActivity: number | null | undefined): string | null;
 export declare function resumeRunningQuestionText(i: ResumeRunningCardInput): string;
+export declare function runningAttachOffered(canAttach: boolean | undefined): boolean;
 export declare function resumeRunningOptions(i: ResumeRunningCardInput): ResumeRunningCardOption[];
 export declare function resumeChoiceFromLabels(selected: readonly string[] | null | undefined): ResumeRunningChoice;
 export declare const RESUME_RUNNING_NO_UI_EXIT_CODE = 75;
@@ -26,4 +27,5 @@ export declare function resumeRunningNoUiGuidance(i: {
     sessionId?: string | null;
 }): string;
 export declare function resumeAttachReplayDisclosure(taskId: string): string;
+export declare function resumeRunningCancelConfirmedRow(taskId: string): string;
 export declare function resumeRunningCancelUnconfirmedRow(taskId: string): string;

package/dist/hitl/resumeRunningCard.js

@@ -14,6 +14,9 @@ export function resumeRunningQuestionText(i) {
     const liveness = resumeRunningLivenessRow(i.msSinceLastActivity);
     return liveness === null ? head : `${head}\n${liveness}`;
 }
+export function runningAttachOffered(canAttach) {
+    return canAttach === true;
+}
 export function resumeRunningOptions(i) {
     const options = [
         {
@@ -21,7 +24,7 @@ export function resumeRunningOptions(i) {
             description: 'Leaves the run alone. It keeps executing on the engine, but this screen will not show it and it will not be listed here — your next message runs into it again, and sema asks you then.',
         },
     ];
-    if (i.canAttach) {
+    if (runningAttachOffered(i.canAttach)) {
         options.push({
             label: RESUME_CHOICE_ATTACH_LABEL,
             description: 'Follows that run from here: sema replays it from the engine ledger and keeps streaming it into this conversation. ' +
@@ -65,8 +68,16 @@ export function resumeAttachReplayDisclosure(taskId) {
         `The replayed turns are not billed into this session's cost again either — the engine's own record ` +
         `(GET /v1/runs/${taskId}) is the authority on what that run really spent.`);
 }
+function cancelRow(taskId, confirmed) {
+    return confirmed
+        ? `The engine accepted the cancel for run ${taskId} on your request. A cancel finishes on the engine's side, so that run may need a moment to stop.`
+        : `sema: the cancel for run ${taskId} did not come back confirmed, so that run may still be executing. ` +
+            `This screen does not list it — read its real state on the engine (GET /v1/runs/${taskId}) before ` +
+            `assuming this session is free.`;
+}
+export function resumeRunningCancelConfirmedRow(taskId) {
+    return cancelRow(taskId, true);
+}
 export function resumeRunningCancelUnconfirmedRow(taskId) {
-    return (`sema: the cancel for run ${taskId} did not come back confirmed, so that run may still be executing. ` +
-        `This screen does not list it — read its real state on the engine (GET /v1/runs/${taskId}) before ` +
-        `assuming this session is free.`);
+    return cancelRow(taskId, false);
 }

package/dist/hitl/sessionPolicyDeliverable.d.ts

@@ -15,7 +15,7 @@ export interface SessionPolicyDeliverability {
 export interface SessionPolicyDeliverableOptions {
     readonly roster?: ToolRosterView;
 }
-export declare function isEngineRefusedToolName(name: string): boolean;
+export { isEngineRefusedToolName } from '../engineRefusedToolName.js';
 export declare function sessionPolicyDeliverable(behavior: 'deny' | 'ask', rules: readonly string[], opts?: SessionPolicyDeliverableOptions): SessionPolicyDeliverability;
 export declare function sessionPolicyWithheldNotice(why: SessionPolicyWithheldWhy): string;
 export declare function legacyToolNameFailureNoteOf(code: string | undefined): string | undefined;

package/dist/hitl/sessionPolicyDeliverable.js

@@ -1,9 +1,10 @@
 import { CONFIG_LEGACY_TOOL_NAME, RULES_LEGACY_TOOL_NAME } from '../engineErrorCodes.js';
-import { rosterMountedNames } from './rosterMountedNames.js';
+import { rosterMountedNames } from '../rosterMountedNames.js';
 import { ruleCompileVerdict } from '../ruleCompileVerdict.js';
 import { protocolSegmentOf } from '../protocolSegment.js';
 import { PREFIXES_IN_PROSE, REFUSED_NAME_CLASSES, REFUSED_NAME_FIX, RULES_LEGACY_TOOL_NAME_WRITE_NOTE } from './refusedToolNameProse.js';
 import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from '../generated/toolNameTables.js';
+import { isEngineRefusedToolName } from '../engineRefusedToolName.js';
 const COVERING_NAMESPACE_PREFIXES = CORE_PROTOCOL_PREFIXES;
 const ENGINE_RETIRED_TOOL_NAMES = CORE_RETIRED_TOOL_CURRENT_NAMES;
 const WITHHELD_NOTICE = {
@@ -40,13 +41,7 @@ function withheldWhyOf(rule) {
         return 'legacy_tool_name';
     return undefined;
 }
-export function isEngineRefusedToolName(name) {
-    if (typeof name !== 'string')
-        return false;
-    if (ENGINE_RETIRED_TOOL_NAMES.has(name))
-        return true;
-    return name.includes('__') && !COVERING_NAMESPACE_PREFIXES.some((prefix) => name.startsWith(prefix));
-}
+export { isEngineRefusedToolName } from '../engineRefusedToolName.js';
 function suppliedRosterNames(opts) {
     if (opts === undefined || opts === null)
         return 'absent';

package/dist/hitl/sessionPolicyWire.js

@@ -3,7 +3,7 @@ import { hostLog } from '../host.js';
 import { isEngineRefusedToolName } from './sessionPolicyDeliverable.js';
 import { RULES_LEGACY_TOOL_NAME_WRITE_NOTE } from './refusedToolNameProse.js';
 import { RULES_LEGACY_TOOL_NAME, isRulesRefusalCode } from '../engineErrorCodes.js';
-import { rosterMountedNames } from './rosterMountedNames.js';
+import { rosterMountedNames } from '../rosterMountedNames.js';
 import { CORE_RULE_TOOL_NAME_VERDICTS } from '../generated/engineFactTables.js';
 function isLegacyToolNameVerdict(v) {
     return typeof v === 'string' && v !== 'current' && CORE_RULE_TOOL_NAME_VERDICTS.includes(v);

package/dist/hitl/toolApprovalWire.d.ts

@@ -6,7 +6,7 @@ import { type DenyAttributionRefusalDetail } from '../wireRefusalCopy.js';
 import { type ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
 import { type DecideReceiptView } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS } from '@sema-agent/sdk';
-import type { ToolApprovalRespondAck, PersistedRuleAnchor as SdkPersistedRuleAnchor, RuleOfferMatch as SdkRuleOfferMatch, RuleOfferBatchMember as SdkRuleOfferBatchMember, RuleOfferUncoveredDetail as SdkRuleOfferUncoveredDetail, RuleOfferUncoveredReason as SdkRuleOfferUncoveredReason, AskOrigin as SdkAskOrigin, RuleOffersAbsence as SdkRuleOffersAbsence, DenialLimitKind as SdkDenialLimitKind, DenialLimitFallback as SdkDenialLimitFallback } from '@sema-agent/sdk';
+import type { ApprovalDecidedBy, ApprovalSettleCause, ToolApprovalRespondAck, PersistedRuleAnchor as SdkPersistedRuleAnchor, RuleOfferMatch as SdkRuleOfferMatch, RuleOfferBatchMember as SdkRuleOfferBatchMember, RuleOfferUncoveredDetail as SdkRuleOfferUncoveredDetail, RuleOfferUncoveredReason as SdkRuleOfferUncoveredReason, AskOrigin as SdkAskOrigin, RuleOffersAbsence as SdkRuleOffersAbsence, DenialLimitKind as SdkDenialLimitKind, DenialLimitFallback as SdkDenialLimitFallback } from '@sema-agent/sdk';
 export declare function isFsApprovalGate(gate: {
     kind?: unknown;
     toolName?: unknown;
@@ -137,7 +137,6 @@ export interface ApprovalCardRequest {
     ruleOffersReadOnly?: RuleOffer[];
     inputHasBidi?: true;
     hasBidiControls?: true;
-    persistedRuleShadowed?: string;
     allowRuleShadow?: ApprovalAllowRuleShadow;
     probeCause?: unknown;
     probeReason?: string;
@@ -157,6 +156,15 @@ export interface ApprovalCardRequest {
     origin?: string;
     askClass?: string;
     classes?: readonly string[];
+    boundGrants?: BoundSkillGrantsWire;
+    classifierNoRuling?: string;
+    priorCardsForCall?: readonly ApprovalPriorCard[];
+}
+export interface ApprovalPriorCard {
+    readonly approvalId?: string;
+    readonly origin?: string;
+    readonly mandate?: ApprovalMandateWord;
+    readonly outcome?: 'allowed' | 'denied';
 }
 export type ApprovalCardPort = (req: ApprovalCardRequest) => Promise<ApprovalCardDecision>;
 export declare function installApprovalCardPort(port: ApprovalCardPort | null): () => void;
@@ -168,6 +176,9 @@ export declare function hasApprovalCardPortFor(sessionKey: string): boolean;
 export declare function approvalCardPortFor(sessionKey: string): ApprovalCardPort | null;
 export declare function _resetApprovalCardPortForTest(): void;
 export declare function surfaceApprovalCard(req: ApprovalCardRequest): Promise<ApprovalCardDecision>;
+declare const REMEMBER_REFUSAL_CODES: readonly ["remember_not_in_proof", "remember_requires_binding", "capability.store_required", "decide.workflow_remember_unsupported", "decide.parked_remember_unsupported"];
+export type RememberRefusalCode = (typeof REMEMBER_REFUSAL_CODES)[number];
+export declare function rememberRefusalOf(error: unknown): RememberRefusalCode | undefined;
 export declare function surfaceFsApprovalAndDecide(deps: FsApprovalWireDeps, taskId: string, argsByCall: Map<string, unknown>, signal?: AbortSignal, parkGatedCallId?: string): Promise<FsApprovalOutcome>;
 export interface BoundSkillGrantsWire {
     readonly skill: string | null;
@@ -183,6 +194,7 @@ export interface ToolApprovalFrame {
     args?: unknown;
     argsOmitted?: boolean;
     outcome?: 'allowed' | 'denied' | 'expired';
+    cause?: ApprovalSettleCause;
     sourceTaskId?: string;
     fromSubagent?: true;
     sourceAgentName?: string;
@@ -223,7 +235,7 @@ export interface ToolApprovalDelegation {
     depth: number;
     agentName?: string;
 }
-export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome"];
+export declare const TOOL_APPROVAL_FRAME_KEYS_MIRROR: readonly ["type", "approvalId", "toolCallId", "toolName", "sourceTaskId", "fromSubagent", "sourceAgentName", "message", "args", "argsOmitted", "governanceForced", "ruleOffers", "ruleOffersAbsence", "denialLimitFallback", "readRootCandidate", "mandated", "mandate", "origin", "askClass", "classes", "inputHasBidi", "parked", "persistedRuleShadowed", "allowRuleShadowed", "probeCause", "probeReason", "rememberRefused", "boundGrantDigest", "boundGrants", "classifierNoRuling", "ruleEvidence", "requiresRealApproval", "expiresInMs", "expiresAtMs", "serverNowMs", "delegation", "outcome", "cause"];
 export interface ApprovalMandatedFacts {
     readonly mandated?: true;
     readonly ruleOffersAbsence?: string;
@@ -244,7 +256,7 @@ export interface RespondToolApprovalOpts {
     persistRuleBatchOfferIndex?: number;
     note?: string;
     settledBy?: 'policy';
-    decidedBy?: 'policy';
+    decidedBy?: Extract<ApprovalDecidedBy, 'policy'>;
 }
 export type RespondToolApprovalFn = (approvalId: string, decision: ToolApprovalRespondDecision, opts?: RespondToolApprovalOpts) => Promise<ToolApprovalRespondAck | void>;
 export type ToolApprovalRespondAckView = ToolApprovalRespondAck;
@@ -254,7 +266,15 @@ export interface ToolApprovalRespondParkingView {
     readonly approvalId: string;
     readonly retryAfterMs?: number;
     readonly decidePath?: string;
+    readonly message?: string;
 }
+export type ToolApprovalParkingBodyReading = {
+    readonly kind: 'parking';
+    readonly view: ToolApprovalRespondParkingView;
+} | {
+    readonly kind: 'claimed_unreadable';
+};
+export declare function readToolApprovalRespondParking(v: unknown): ToolApprovalParkingBodyReading | undefined;
 export declare function decisionAttributionKeyOf(reading: ApprovalDecidedByReading | undefined, denySettledBy: ApprovalDenySettledBy | undefined): {
     decidedBy: 'policy';
 } | {
@@ -266,6 +286,8 @@ export interface ToolApprovalFrameOutcome {
     respondRefusal?: ToolApprovalRespondRefusal;
     editRefused?: true;
     retracted?: true;
+    aborted?: true;
+    joinedInFlight?: true;
     denySettledBy?: ApprovalDenySettledBy;
     denyReason?: string;
     denyAttributionRefusal?: DenyAttributionRefusalDetail;
@@ -287,6 +309,13 @@ export type ToolApprovalRespondRefusal = (ToolApprovalRespondRefusalFields & {
 });
 export declare function readToolApprovalRespondRefusal(err: unknown): ToolApprovalRespondRefusal | undefined;
 export declare function isToolApprovalFrame(ev: unknown): ev is ToolApprovalFrame;
+export declare function askProbeReasonDetail(card: Pick<ApprovalCardRequest, 'probeReason' | 'probeCause'> | null | undefined): string | undefined;
+export declare function readApprovalRememberRefused(v: unknown): boolean;
+export declare function readApprovalBoundGrants(v: unknown): BoundSkillGrantsWire | undefined;
+export declare function readApprovalClassifierNoRuling(v: unknown): string | undefined;
+export declare function classifierNoRulingDetail(word: string | undefined): string;
+export declare function approvalBoundGrantsDetail(grants: BoundSkillGrantsWire | null | undefined): string | undefined;
+export declare function approvalPriorCardsDetail(card: Pick<ApprovalCardRequest, 'priorCardsForCall' | 'origin'> | null | undefined): string | undefined;
 export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback | undefined;
 export declare function readRuleOffers(v: unknown): RuleOffer[] | undefined;
 export declare function readRuleOfferSupply(offers: unknown): RuleOffer[] | undefined;
@@ -298,4 +327,20 @@ export interface ToolApprovalFrameLaneOpts {
     windowIsCurrent?: boolean;
     argsUnavailable?: true;
 }
-export declare function surfaceToolApprovalFrameAndRespond(frame: ToolApprovalFrame, respond: RespondToolApprovalFn, streamArgs: unknown | undefined, signal?: AbortSignal, lane?: ToolApprovalFrameLaneOpts): Promise<ToolApprovalFrameOutcome>;
+export declare function surfaceToolApprovalFrameAndRespond(frame: ToolApprovalFrame, respond: RespondToolApprovalFn, streamArgs: unknown | undefined, signal?: AbortSignal, lane?: ToolApprovalFrameLaneOpts, run?: {
+    readonly taskId?: string;
+    readonly sessionId?: string;
+}): Promise<ToolApprovalFrameOutcome>;
+export interface ApprovalHolderIdentity {
+    readonly approvalId?: string;
+    readonly taskId?: string;
+    readonly toolCallId?: string;
+    readonly sessionId?: string;
+}
+export type ApprovalHolderJoin = {
+    readonly kind: 'joined';
+    readonly outcome: ToolApprovalFrameOutcome;
+} | {
+    readonly kind: 'free';
+};
+export declare function joinApprovalHolder(identity: ApprovalHolderIdentity, signal?: AbortSignal): Promise<ApprovalHolderJoin>;