@sema-agent/client-core 0.109.0 → 0.110.0

package/dist/hitl/parkResolver.js

@@ -86,11 +86,17 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         };
     }
     const questionId = askGateQuestionId(approvalCallKey(gatedCallId, taskId));
+    let withdrawn;
     const answer = await new Promise(resolve => {
         const unregister = registerLocalQuestionResponder(questionId, async (_id, a) => {
             cleanup();
             resolve(a);
             return { ok: true };
+        }, (w) => {
+            withdrawn = w;
+            cleanup();
+            publishQuestionFrame({ type: 'question_complete', questionId });
+            resolve(null);
         });
         const onAbort = () => {
             cleanup();
@@ -109,6 +115,10 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         onPresented?.();
         publishQuestionFrame({ type: 'question', questionId, questions, ...(questionsFromModelCall ? { _sema_questionsFromModelCall: true } : {}) });
     });
+    if (withdrawn !== undefined) {
+        hostLog('debug', `liveHitlAskWire: question-withdrawn-by-host card=${questionId} verdict=${withdrawn.rowVerdict.kind}`);
+        return { kind: 'not_sent', ...at, cause: 'withdrawn', toldBy: withdrawn.toldBy, rowVerdict: withdrawn.rowVerdict };
+    }
     const bridge = new HitlBridge(deps.client, taskId, deps.onDecideOperation ? { onDecideOperation: deps.onDecideOperation } : undefined);
     if (answer === null) {
         observeCancelByDeny(bridge.decideTool({ decision: 'deny', reason: INTERRUPT_DENY_REASON }, gatedCallId, undefined, pending), taskId);
@@ -155,7 +165,7 @@ function isFetchStepNoPending(outcome) {
     return outcome.kind === 'not_sent' && outcome.cause === 'no_pending' && outcome.gatedCallId === undefined;
 }
 function isHumanDisposition(r) {
-    return r.kind === 'decided' || (r.kind === 'unsettled' && r.cause === 'interrupted') || (r.kind === 'not_sent' && r.cause === 'retracted');
+    return r.kind === 'decided' || (r.kind === 'unsettled' && r.cause === 'interrupted') || (r.kind === 'not_sent' && (r.cause === 'retracted' || r.cause === 'withdrawn'));
 }
 function failureReasonOf(r) {
     if (r.kind === 'decided')
@@ -282,7 +292,8 @@ export async function resolvePark(park, ctx) {
     if (outcome.kind !== 'decided') {
         hostLog('debug', `liveHitlAskWire: gate not decided (${outcome.kind}/${outcome.cause}: ${failureReasonOf(outcome)}) — fail-soft to suspended terminal`);
         const interrupted = outcome.kind === 'unsettled' && outcome.cause === 'interrupted';
-        const failedReason = interrupted
+        const toldByHost = outcome.kind === 'not_sent' && outcome.cause === 'withdrawn';
+        const failedReason = interrupted || toldByHost
             ? undefined
             : outcome.kind === 'not_sent' && outcome.cause === 'retracted'
                 ? 'the approval card was retracted by the host without a decision (nothing was sent; the run stays parked and remains decidable elsewhere)'
@@ -312,13 +323,19 @@ export async function resolvePark(park, ctx) {
     };
 }
 function failsoftWayOutOf(outcome) {
+    if (outcome === undefined)
+        return 'card';
+    if (typeof outcome !== 'object' || outcome === null)
+        return 'speak';
     if (outcome.kind === 'not_sent' && (outcome.cause === 'row_unresumable' || (outcome.cause === 'safety_stop' && outcome.safetyCode === 'binding_missing')))
         return 'reason';
-    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && refusedParkFromError(outcome.refusal) !== null)
+    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused' && (refusedParkFromError(outcome.refusal) !== null || outcome.refusal?.conflict === 'row_integrity'))
         return 'cancel';
+    if (outcome.kind === 'unsettled' && outcome.cause === 'engine_refused')
+        return 'speak';
     return 'card';
 }
-function failsoftReasonSentence(park, failedReason, terminal, wayOut = 'card') {
+function failsoftReasonSentence(park, failedReason, terminal, wayOut) {
     if (terminal !== undefined)
         return terminal.errorMessage;
     if (failedReason === undefined)
@@ -328,10 +345,9 @@ function failsoftReasonSentence(park, failedReason, terminal, wayOut = 'card') {
         return renderMessage(msg('approval.park.stillParked', { gate, reason: failedReason }));
     if (wayOut === 'cancel')
         return renderMessage(msg('approval.park.refusedNotResumable', { gate, reason: failedReason }));
-    return (`${park.gate === 'fs' ? 'Tool approval' : 'AskUserQuestion'} gate could not be answered: ${failedReason}` +
-        ' — the run is still parked on this approval: decide it on the card when it is shown again, or cancel the run.');
+    return renderMessage(msg(wayOut === 'speak' ? 'approval.park.resume.speak' : 'approval.park.resume.card', { gate, reason: failedReason }));
 }
-function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface = false, wayOut = 'card') {
+function failsoftEvents(park, ctx, gateAbortedByUser, failedReason, terminal, noDecisionSurface, wayOut) {
     const events = [
         ...flushHeldWithInterruptRewrite(ctx.led, {
             terminal: park.pendingDone,
@@ -360,12 +376,12 @@ export function stalledTerminal(park, ctx, stalledRounds, lastStallReason, decid
             `stopped re-attaching. Your last decision was accepted; sema did not observe the run move on after it — check the ` +
             `transcript, decide the call again if the card comes back, or cancel the run.`;
         hostLog('debug', `liveHitlAskWire: ${errorMessage}`);
-        return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, undefined, { errorCode: 'hitl_stalled', errorMessage }) };
+        return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, undefined, { errorCode: 'hitl_stalled', errorMessage }, false, failsoftWayOutOf(undefined)) };
     }
     const reason = `the run stayed parked across ${stalledRounds} consecutive re-attach rounds without any host progress ` +
         `(last: ${lastStallReason ?? 'the engine kept parking'})`;
     hostLog('debug', `liveHitlAskWire: ${reason} — fail-soft after the round committed`);
-    return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, reason) };
+    return { kind: 'failsoft', events: failsoftEvents(park, ctx, false, reason, undefined, false, failsoftWayOutOf(undefined)) };
 }
 function notifyParkReattach(ctx, attempt, max, reason) {
     invokeHostCallbackIsolated('liveHitlAskWire: onParkReattach', () => {

package/dist/hitl/persistedRulesWire.js

@@ -7,7 +7,7 @@ import { hostLog } from '../host.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 import { appendOwnElement, guardedRead, readOwnDataValue } from '../ownKey.js';
 import { observedPermissionRulesWrite, permissionRulesWriteAvailable } from '../permissionRulesWriteCapability.js';
-import { isToolApprovalRespondReplayed, readToolApprovalRespondAck } from './toolApprovalWire.js';
+import { isToolApprovalRespondParkedRedeemed, isToolApprovalRespondReplayed, readToolApprovalRespondAck } from './toolApprovalWire.js';
 export function persistedRulesLaneAvailable(baseUrl) {
     return engineCapTrue(baseUrl, 'permissionRules');
 }
@@ -637,7 +637,7 @@ export function classifySkippedReason(reason) {
 }
 export function readRulePersistOutcome(ack) {
     const parsed = readToolApprovalRespondAck(ack);
-    if (parsed === undefined || isToolApprovalRespondReplayed(parsed))
+    if (parsed === undefined || isToolApprovalRespondReplayed(parsed) || isToolApprovalRespondParkedRedeemed(parsed))
         return { state: 'unknown' };
     if (parsed.rulePersisted === true)
         return { state: 'persisted' };

package/dist/hitl/planReviewWire.js

@@ -498,11 +498,15 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
         armedPlanReviews.set(taskId, instance);
         armedTaskId = taskId;
         let unregister = () => { };
+        const onWithdraw = () => {
+            hostLog('debug', `planReviewWire: card-withdrawn-by-host task=${taskId} card=${questionId}`);
+            retireArmedPlanReview(taskId, instance);
+        };
         const responder = async (_id, answer) => {
             const choice = planReviewAnswerChoiceOf(questionId, answer);
             if (choice === 'inadmissible') {
                 if (armedPlanReviews.get(taskId) === instance && !hasLocalQuestionResponder(questionId))
-                    unregister = registerLocalQuestionResponder(questionId, responder);
+                    unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
                 hostLog('debug', `planReviewWire: answer-inadmissible card=${questionId}`);
                 return { ok: false, inadmissible: true };
             }
@@ -523,7 +527,7 @@ export function armPlanReviewApproval(result, sessionKey, opts) {
             void decidePlanReviewFor(taskId, decided, modeAfter, cardDelivery, facts);
             return { ok: true };
         };
-        unregister = registerLocalQuestionResponder(questionId, responder);
+        unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
         publishArmedPlanReviewCard(instance);
         hostLog('debug', `planReviewWire: approval card armed for parked plan (task ${taskId})`);
     }
@@ -1160,11 +1164,17 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         });
     const activeKey = `${sessionKey}\u0000${canonicalId}`;
     let unregister = () => { };
+    const onWithdraw = () => {
+        hostLog('debug', `planReviewWire: card-withdrawn-by-host task=${taskId} card=${questionId}`);
+        if (activeReopenResponders.get(activeKey)?.questionId === questionId)
+            activeReopenResponders.delete(activeKey);
+        publishQuestionFrameFor(sessionKey, { type: 'question_complete', questionId });
+    };
     const responder = async (_id, answer) => {
         const choice = planReviewAnswerChoiceOf(questionId, answer);
         if (choice === 'inadmissible') {
             if (activeReopenResponders.get(activeKey)?.questionId === questionId && !hasLocalQuestionResponder(questionId)) {
-                unregister = registerLocalQuestionResponder(questionId, responder);
+                unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
             }
             hostLog('debug', `planReviewWire: answer-inadmissible card=${questionId}`);
             return { ok: false, inadmissible: true };
@@ -1190,7 +1200,7 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs, taken) {
         return { ok: true };
     };
     const shape = cardShapeOf(facts, false);
-    unregister = registerLocalQuestionResponder(questionId, responder);
+    unregister = registerLocalQuestionResponder(questionId, responder, onWithdraw);
     activeReopenResponders.set(activeKey, { questionId, unregister: () => unregister(), shape });
     const receipt = waitForGateArmedFor(sessionKey, [questionId], receiptMs);
     publishQuestionFrameFor(sessionKey, planReviewQuestionFrame(questionId, REOPEN_QUESTION, shape, facts));

package/dist/hitl/sessionPolicyWire.js

@@ -701,10 +701,12 @@ export function sessionPolicyRemovalNotice(outcome, deployment) {
             return 'This session’s rule record holds no entry naming a tool the engine refuses that the supplied roster does not mount, so nothing was changed. If runs still fail at startup over a refused tool name, that entry is set somewhere this record does not cover — the settings sent with the run, a parent session’s rule record, or the deployment’s own tool rules — or it is a name the engine refuses that this version does not yet recognise, or the failing run does not mount a tool the supplied roster has under that name.';
         case 'judge_failed':
             return 'Nothing was changed: this client could not check which entries in this session’s rule record name a tool the engine refuses (its copy of the engine’s tool-name check is unavailable or gave no clear answer), so it removed none rather than guess. Removing them needs that check available in this client.';
-        case 'loosen_forbidden':
-            if (deploymentHasNoOperator(deployment))
-                return renderMessage(msg('rules.sessionPolicy.deployment.noOperator.removeLoosenForbidden'));
-            return 'The engine refused to take these entries out of this session’s rule record: on this engine only an operator can remove entries from it, so the record is unchanged. Ask an operator to remove them, or continue in a new session.';
+        case 'loosen_forbidden': {
+            const stem = msg('rules.sessionPolicy.remove.loosenForbiddenStem');
+            return deploymentHasNoOperator(deployment)
+                ? renderMessage(msg('rules.sessionPolicy.deployment.noOperator.removeLoosenForbidden', { stem }))
+                : renderMessage(msg('rules.sessionPolicy.remove.loosenForbidden', { stem }));
+        }
         case 'conflict':
             return 'This session’s rule record was changed by someone else while the refused entries were being removed, twice in a row — nothing was changed. Try again once the other change has finished.';
         case 'read_failed':

package/dist/hitl/standingRows.d.ts

@@ -18,6 +18,7 @@ export interface StandingRowsHostFacts {
 }
 export declare function standingRowsOf(card: object | null | undefined, host?: StandingRowsHostFacts | null): StandingRows;
 export declare function seatSessionRowOf(card: object | null | undefined, requestId: string | undefined): boolean;
+export declare function seatAllowNoteCarriedOf(card: object | null | undefined, requestId: string | undefined): boolean;
 export type RememberOffer = 'offerable' | 'refused' | 'unknown';
 export interface RememberOfferable {
     readonly session: RememberOffer;

package/dist/hitl/standingRows.js

@@ -1,6 +1,6 @@
 import { DEPLOYMENT_LIST_ASK_CLASSES, readAskClassPairState } from './askClassPair.js';
 import { askLevelVerdict } from './automaticAnswerVerdict.js';
-import { readApprovalCardWord, readRuleOffers } from './toolApprovalWire.js';
+import { answerCarriage, readApprovalCardWord, readRuleOffers } from './toolApprovalWire.js';
 import { CORE_SKILL_TOOL_NAME } from '../generated/toolNameTables.js';
 import { inSlotReadOf, inValueOf } from '../wireFailureShape.js';
 import { toolPermissionRequestIdDomain } from '../seatContract.js';
@@ -153,6 +153,20 @@ export function seatSessionRowOf(card, requestId) {
         return false;
     }
 }
+export function seatAllowNoteCarriedOf(card, requestId) {
+    if (typeof card !== 'object' || card === null)
+        return false;
+    try {
+        if (Object.hasOwn(card, 'requestId'))
+            return false;
+        if (toolPermissionRequestIdDomain(requestId) !== 'durable:')
+            return false;
+        return answerCarriage(card).allowNote === 'model';
+    }
+    catch {
+        return false;
+    }
+}
 const SESSION_OFFER = Object.freeze({
     given: 'offerable',
     card_unreadable: 'unknown',

package/dist/hitl/toolApprovalWire.d.ts

@@ -1,6 +1,6 @@
 import { type HitlClientLike, type DecideOperationObserver } from './hitlBridge.js';
-import { type ApprovalAskReason } from './approvalAskers.js';
-export type { ApprovalAskReason, ApprovalAskReasonByHook, ApprovalAskReasonByPolicy } from './approvalAskers.js';
+import { type ApprovalAskReason, type ApprovalRequestedBy } from './approvalAskers.js';
+export type { ApprovalAskReason, ApprovalAskReasonByHook, ApprovalAskReasonByPolicy, ApprovalRequestedBy } from './approvalAskers.js';
 import { readApprovalCardWord, type ApprovalCardWord } from './approvalCardReading.js';
 import { type ApprovalAllowRuleShadow } from './allowRuleShadow.js';
 import { CORE_PERSISTED_RULE_MATCHES } from '../generated/engineFactTables.js';
@@ -8,6 +8,7 @@ import type { UiLanguage } from '../env/uiLanguage.js';
 import type { SessionRuleInertReason } from './sessionPolicyWire.js';
 import { type ApprovalCardClaim } from './approvalHolds.js';
 import { type ApprovalResolution } from './approvalResolution.js';
+import { type HostWithdrawal } from './hostWithdrawal.js';
 import { type ApprovalMandateWord } from '../gateVocabulary.js';
 import type { ToolPermissionRequest } from '../seatContract.js';
 import { type ApprovalDecidedByReading } from '../approvalDecidedByCapability.js';
@@ -88,13 +89,18 @@ export type ApprovalCardDecision = ApprovalCardAllowDecision | ApprovalCardDenyD
 } | {
     kind: typeof RETRACTED_CARD_DECISION_KIND;
     reason?: string;
-};
+} | ({
+    kind: typeof WITHDRAWN_CARD_DECISION_KIND;
+} & HostWithdrawal);
 export declare const RETRACTED_CARD_DECISION_KIND: "retracted";
+export declare const WITHDRAWN_CARD_DECISION_KIND: "withdrawn";
+export type ApprovalInputSource = 'record' | 'stream';
 export interface ApprovalCardRequest {
     toolName: string;
     args: object;
     callKey: string;
     toolCallId?: string;
+    taskId?: string;
     signal?: AbortSignal;
     workerBadge?: {
         name: string;
@@ -103,6 +109,7 @@ export interface ApprovalCardRequest {
     wireNote?: string;
     argsUnavailable?: true;
     argsRewritten?: true;
+    inputSource?: ApprovalInputSource;
     governanceForced?: true;
     delegation?: ToolApprovalDelegation;
     ruleOffers?: RuleOfferReading[];
@@ -132,6 +139,7 @@ export interface ApprovalCardRequest {
     classes?: readonly string[];
     agentId?: string;
     askReasons?: readonly ApprovalAskReason[];
+    requestedBy?: ApprovalRequestedBy;
     boundGrants?: BoundSkillGrantsWire;
     grantBinding?: ApprovalGrantBinding;
     unreadableEvidence?: readonly string[];
@@ -198,7 +206,7 @@ export declare function readApprovalMandate(v: {
     readonly mandate?: string;
 } | undefined | null): ApprovalMandateWord | undefined;
 export { readApprovalCardWord };
-export declare function toolPermissionRequestAskBits(card: object | null | undefined, requestId?: string): Pick<ToolPermissionRequest, 'mandated' | 'mandate' | 'origin' | 'ruleOffersAbsence' | 'askClass' | 'classes' | 'sessionRow'>;
+export declare function toolPermissionRequestAskBits(card: object | null | undefined, requestId?: string): Pick<ToolPermissionRequest, 'mandated' | 'mandate' | 'origin' | 'ruleOffersAbsence' | 'askClass' | 'classes' | 'sessionRow' | 'probeReason' | 'probeCause' | 'feedbackCapable' | 'requestedBy' | 'frameReading' | 'inputSource'>;
 export declare function isFromSubagent(frame: ToolApprovalFrame): boolean;
 export type ToolApprovalRespondDecision = SdkToolApprovalDecision;
 export declare const RESPOND_DECISIONS: readonly ["allow", "allow_session", "deny"];
@@ -212,18 +220,26 @@ export interface RespondAnswerPayload extends Pick<RespondToolApprovalOpts, 'upd
 export interface DecideApprovePayload extends Pick<ApprovalCardAllowDecision, 'updatedInput'> {
     readonly decision: 'approve';
     readonly remember?: 'session';
+    readonly feedback?: string;
 }
 export interface DecideDenyPayload {
     readonly decision: 'deny';
     readonly reason: string;
 }
 export type DecideAnswerPayload = DecideApprovePayload | DecideDenyPayload;
+export declare function allowNoteReadingOf(answer: object): {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'absent' | 'blank' | 'invalid';
+};
 export declare function answerPayloadFor(answer: ApprovalCardDecision, lane: 'respond', caps?: AnswerPayloadCaps | null): RespondAnswerPayload | undefined;
 export declare function answerPayloadFor(answer: ApprovalCardDecision, lane: 'decide', caps?: AnswerPayloadCaps | null): DecideAnswerPayload | undefined;
 export interface AnswerCarriage {
     readonly allowNote: 'model' | 'none';
 }
-export declare function answerCarriage(card: Pick<ApprovalCardRequest, 'callKey'> | null | undefined): AnswerCarriage;
+export declare function answerCarriage(card: Pick<ApprovalCardRequest, 'callKey' | 'parkRow'> | null | undefined): AnswerCarriage;
+export declare function allowNoteNotCarriedSentence(lang?: UiLanguage): string;
 export interface ApprovalAnswerCommitted {
     readonly callKey: string;
     readonly lane: AnswerPayloadLane;
@@ -242,8 +258,19 @@ export interface RespondToolApprovalOpts {
     decidedBy?: Extract<ApprovalDecidedBy, 'policy'>;
 }
 export type RespondToolApprovalFn = (approvalId: string, decision: ToolApprovalRespondDecision, opts?: RespondToolApprovalOpts) => Promise<ToolApprovalRespondAck | void>;
-export type ToolApprovalRespondAckView = ToolApprovalRespondAck;
+export type ToolApprovalRespondAckView = ToolApprovalRespondAck | ToolApprovalRespondRedeemedView;
+export interface ToolApprovalRespondRedeemedView {
+    readonly approvalId: string;
+    readonly askId: string;
+    readonly accepted: 'parked_redeemed';
+    readonly idempotent?: true;
+    readonly decision?: string;
+    readonly rememberApplied?: boolean;
+}
 export declare function isToolApprovalRespondReplayed(ack: ToolApprovalRespondAckView): ack is ToolApprovalRespondReplayed;
+export declare function isToolApprovalRespondParkedRedeemed(ack: object): ack is ToolApprovalRespondRedeemedView;
+export declare function replayedFirstDecisionOf(ack: ToolApprovalRespondAckView | undefined): 'allow' | 'deny' | undefined;
+export declare function settlementAckOf(read: ToolApprovalRespondAckView | undefined): ToolApprovalRespondAckView | undefined;
 export type { PersistedRuleAnchor };
 export declare function readToolApprovalRespondAck(v: unknown): ToolApprovalRespondAckView | undefined;
 export interface ToolApprovalRespondParkingView {
@@ -284,8 +311,8 @@ export declare function approvalSupersedesDetail(card: Pick<ApprovalCardRequest,
 export declare function readDenialLimitFallback(v: unknown): DenialLimitFallback | undefined;
 export declare function readRuleOffers(v: unknown): RuleOfferReading[] | undefined;
 export declare function readRuleOfferSupply(offers: unknown): RuleOfferReading[] | undefined;
-export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'agentId' | 'askReasons' | 'grantBinding' | 'unreadableEvidence' | 'message' | 'approvalCard'>;
-export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'argsRewritten' | 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable' | 'cardPayloadUnreadableWhy'>;
+export type ApprovalCardV1Facts = Pick<ApprovalCardRequest, 'toolName' | 'args'> & Pick<ApprovalCardRequest, 'toolCallId' | 'workerBadge' | 'wireNote' | 'argsUnavailable' | 'inputSource' | 'governanceForced' | 'delegation' | 'ruleOffersReadOnly' | 'inputHasBidi' | 'allowRuleShadow' | 'probeCause' | 'rememberRefused' | 'ruleEvidence' | 'requiresRealApproval' | 'ruleOffersAbsence' | 'denialLimitFallback' | 'askClass' | 'classes' | 'agentId' | 'askReasons' | 'grantBinding' | 'unreadableEvidence' | 'message' | 'approvalCard'>;
+export type ApprovalCardFacts = ApprovalCardV1Facts & Pick<ApprovalCardRequest, 'argsRewritten' | 'ruleOffers' | 'probeReason' | 'mandated' | 'mandate' | 'readRootCandidate' | 'origin' | 'boundGrants' | 'classifierNoRuling' | 'allowSessionCarried' | 'cardPayloadUnreadable' | 'cardPayloadUnreadableWhy' | 'requestedBy'>;
 export interface ApprovalCardFrameFactsOptions {
     readonly streamArgs?: object;
     readonly argsUnavailable?: true;