@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/hitl/hitlBridge.js

@@ -3,10 +3,13 @@ import { eventSeq } from '../adapter/types.js';
 import { hostLog } from '../host.js';
 import { invokeHostCallbackIsolated } from '../hostCallbackGuard.js';
 import { abortableSleep } from '../abortableSleep.js';
-import { ownDataField, readOwnDataValue } from '../ownKey.js';
-import { PROTOCOL_ERROR_NAME, THROWN_SLOT_UNREADABLE, protocolErrorNameReading, readBlockedBy, readThrownSlot, thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { attemptTimeoutOnChain, causeSlotReadOf, transportChainReading } from '../engineWireFor.js';
+import { guardedRead, ownDataField, readOwnDataValue } from '../ownKey.js';
+import { PROTOCOL_ERROR_NAME, isSlotCarrier, protocolErrorNameReading, readBlockedBy, readThrownSlot, thrownIsInstanceOf, wireFailureTextsOf } from '../wireFailureShape.js';
 import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_INVALID_OUTCOME, RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
 import { suspendedReopenOf } from './suspendedReopen.js';
+import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp } from './decisionLedger.js';
+import { askParkBlockGeneration, noteAskParkDecideSettled } from './askParkAutoReopenBlock.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
@@ -52,6 +55,30 @@ export class HitlSafetyError extends Error {
         this.name = 'HitlSafetyError';
     }
 }
+export function refusalCarrierOf(err, localCodeRead, answeredLayer = false, causeRead, headRead) {
+    if (!isSlotCarrier(err))
+        return { carrier: err };
+    const head = headRead ?? safetyStopHeadOf(err, localCodeRead);
+    if (!head.named)
+        return { carrier: err };
+    const read = answeredLayer ? undefined : (causeRead ?? causeSlotReadOf(err));
+    const cause = read !== undefined && read.presence === 'present' ? read.value : undefined;
+    const carrier = isSlotCarrier(cause) ? cause : err;
+    return head.local !== undefined ? { local: head.local, carrier } : { carrier };
+}
+export function safetyStopNamed(err) {
+    return isSlotCarrier(err) && guardedRead(() => ownDataField(err, 'name')) === 'HitlSafetyError';
+}
+export function safetyStopHeadOf(err, localCodeRead, namedRead) {
+    if (!isSlotCarrier(err))
+        return { named: false };
+    if (!(namedRead ?? safetyStopNamed(err)))
+        return { named: false };
+    const own = (k) => guardedRead(() => ownDataField(err, k));
+    const code = localCodeRead !== undefined ? localCodeRead.value : own('code');
+    const local = typeof code === 'string' && GATE_FAILURE_CODES.includes(code) ? code : undefined;
+    return local !== undefined ? { named: true, local } : { named: true };
+}
 export function hitlSafetyCodeOf(e) {
     if (!thrownIsInstanceOf(e, HitlSafetyError))
         return undefined;
@@ -69,12 +96,12 @@ void _gateCurrentPendingReadonlyPin;
 export function readDecideCurrentPending(e) {
     if (e === null || e === undefined)
         return undefined;
-    const raw = readThrownSlot(e, 'currentPending');
+    const raw = readThrownSlot(e, 'currentPending', 'data');
     if (typeof raw !== 'object' || raw === null)
         return undefined;
-    const toolName = readThrownSlot(raw, 'toolName');
-    const boundCallId = readThrownSlot(raw, 'boundCallId');
-    const boundInputHash = readThrownSlot(raw, 'boundInputHash');
+    const toolName = readThrownSlot(raw, 'toolName', 'data');
+    const boundCallId = readThrownSlot(raw, 'boundCallId', 'data');
+    const boundInputHash = readThrownSlot(raw, 'boundInputHash', 'data');
     if (typeof toolName !== 'string' || toolName.length === 0)
         return undefined;
     if (typeof boundCallId !== 'string' || boundCallId.length === 0)
@@ -129,36 +156,8 @@ export function __setDecideTimeoutRetryBudgetForTests(ms) {
 function decideTimeoutRetryBudgetMs() {
     return decideTimeoutRetryBudgetOverrideMs ?? DECIDE_TIMEOUT_RETRY_TOTAL_BUDGET_MS;
 }
-function isDecideAttemptTimeout(e, depth = 0) {
-    if (depth > 3 || e === null || typeof e !== 'object')
-        return false;
-    if (readThrownSlot(e, 'name') === 'TimeoutError')
-        return true;
-    return isDecideAttemptTimeout(readThrownSlot(e, 'cause'), depth + 1);
-}
-const TRANSIENT_NETWORK_CODES = new Set([
-    'ECONNREFUSED', 'ECONNRESET', 'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN',
-    'ENETUNREACH', 'EHOSTUNREACH', 'ECONNABORTED',
-    'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT', 'UND_ERR_SOCKET',
-]);
-function isTransientDecideTransportFailure(e, depth = 0) {
-    if (depth > 3 || e === null || typeof e !== 'object')
-        return false;
-    if (thrownIsInstanceOf(e, HitlSafetyError))
-        return false;
-    const status = readThrownSlot(e, 'status', 'data');
-    if (status === THROWN_SLOT_UNREADABLE || typeof status === 'number')
-        return false;
-    const name = readThrownSlot(e, 'name');
-    if (name === 'TimeoutError' || name === 'AbortError')
-        return true;
-    const code = readThrownSlot(e, 'code', 'data');
-    if (typeof code === 'string' && TRANSIENT_NETWORK_CODES.has(code))
-        return true;
-    const message = readThrownSlot(e, 'message');
-    if (typeof message === 'string' && message.toLowerCase().includes('fetch failed'))
-        return true;
-    return isTransientDecideTransportFailure(readThrownSlot(e, 'cause'), depth + 1);
+function isTransientDecideTransportFailure(e) {
+    return transportChainReading(e, 'retry', (layer) => thrownIsInstanceOf(layer, HitlSafetyError)) === 'transient';
 }
 export class DecideTransportRetryExhaustedError extends Error {
     attempts;
@@ -172,6 +171,7 @@ class DecideSpan {
     owner;
     observer;
     identity;
+    ledgerOp;
     attempts = 0;
     ok = false;
     retryExhausted = false;
@@ -189,21 +189,26 @@ class DecideSpan {
         return mine === undefined || (mine.sessionId === identity.sessionId && mine.boundCallId === identity.boundCallId);
     }
     async run(identity, send) {
-        if (this.observer !== undefined && this.identity === undefined) {
+        if (this.identity === undefined) {
             this.identity = identity;
-            notifyDecideObserver(this.observer, Object.freeze({ ...this.identity, phase: 'start' }));
+            this.ledgerOp = openDecideLedgerOp(identity);
+            if (this.observer !== undefined)
+                notifyDecideObserver(this.observer, Object.freeze({ ...this.identity, phase: 'start' }));
         }
         this.inFlight++;
         const tally = { attempts: 0 };
+        const blockGen = askParkBlockGeneration(identity.sessionId);
         try {
             const r = await send(tally);
             this.ok = true;
             this.retryExhausted = false;
+            noteAskParkDecideSettled(identity, blockGen, { ok: true });
             return r;
         }
         catch (e) {
             this.ok = false;
             this.retryExhausted = thrownIsInstanceOf(e, DecideTransportRetryExhaustedError);
+            noteAskParkDecideSettled(identity, blockGen, { ok: false, error: e });
             throw e;
         }
         finally {
@@ -224,11 +229,16 @@ class DecideSpan {
         if (this.ended)
             return;
         this.ended = true;
+        if (this.ledgerOp !== undefined)
+            closeDecisionOp(this.ledgerOp, 'package');
         if (this.observer === undefined || this.identity === undefined)
             return;
         notifyDecideObserver(this.observer, Object.freeze({ ...this.identity, phase: 'end', ok: this.ok, attempts: this.attempts, retryExhausted: this.retryExhausted }));
     }
 }
+function openDecideLedgerOp(identity) {
+    return openDecisionOp('tool_approval', decisionLedgerKeysOf({ taskId: identity.taskId, callId: identity.boundCallId }), 'posting', true);
+}
 function wireOptsOf(opts) {
     if (opts === undefined || opts.operation === undefined)
         return opts;
@@ -408,23 +418,29 @@ export class HitlBridge {
         }
         const observer = this.decideObserver;
         const tally = { attempts: 0 };
-        if (observer === undefined)
-            return this.decideRawAttempts(sessionId, decision, opts, tally);
         const identity = this.decideIdentityOf(sessionId, decision);
-        notifyDecideObserver(observer, Object.freeze({ ...identity, phase: 'start' }));
+        const ledgerOp = openDecideLedgerOp(identity);
+        const blockGen = askParkBlockGeneration(identity.sessionId);
+        if (observer !== undefined)
+            notifyDecideObserver(observer, Object.freeze({ ...identity, phase: 'start' }));
         let ok = false;
         let retryExhausted = false;
         try {
             const r = await this.decideRawAttempts(sessionId, decision, opts, tally);
             ok = true;
+            noteAskParkDecideSettled(identity, blockGen, { ok: true });
             return r;
         }
         catch (e) {
             retryExhausted = thrownIsInstanceOf(e, DecideTransportRetryExhaustedError);
+            noteAskParkDecideSettled(identity, blockGen, { ok: false, error: e });
             throw e;
         }
         finally {
-            notifyDecideObserver(observer, Object.freeze({ ...identity, phase: 'end', ok, attempts: tally.attempts, retryExhausted }));
+            closeDecisionOp(ledgerOp, 'package');
+            if (observer !== undefined) {
+                notifyDecideObserver(observer, Object.freeze({ ...identity, phase: 'end', ok, attempts: tally.attempts, retryExhausted }));
+            }
         }
     }
     decideIdentityOf(sessionId, decision) {
@@ -461,7 +477,7 @@ export class HitlBridge {
                     throw e;
                 if (!isTransientDecideTransportFailure(e) || callerAborted())
                     throw e;
-                if (isDecideAttemptTimeout(e)) {
+                if (attemptTimeoutOnChain(e)) {
                     if (attempts >= DECIDE_TIMEOUT_MIN_ATTEMPTS && Date.now() - startedAt >= decideTimeoutRetryBudgetMs()) {
                         throw new DecideTransportRetryExhaustedError(attempts, wireFailureTextsOf(e).reason);
                     }

package/dist/hitl/livePendingAsk.js

@@ -1,3 +1,4 @@
+import { appendOwnElement } from '../ownKey.js';
 import { readRequiresRealApproval } from './approvalCardReading.js';
 import { THROWN_SLOT_UNREADABLE, readThrownSlot } from '../wireFailureShape.js';
 import { isToolApprovalFrame, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
@@ -14,9 +15,9 @@ function snapshotMembers(raw) {
     const out = [];
     for (let i = 0; i < length; i++) {
         const d = Object.getOwnPropertyDescriptor(raw, i);
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !Object.hasOwn(d, 'value'))
             return undefined;
-        out.push(d.value);
+        appendOwnElement(out, d.value);
     }
     return raw.length === length ? out : undefined;
 }
@@ -26,7 +27,7 @@ export function readLivePendingRows(body) {
     const field = Object.getOwnPropertyDescriptor(body, 'livePending');
     if (field === undefined)
         return 'livePending' in body ? { kind: 'malformed' } : { kind: 'not_reported' };
-    if (!('value' in field))
+    if (!Object.hasOwn(field, 'value'))
         return { kind: 'malformed' };
     const raw = field.value;
     if (raw === undefined)

package/dist/hitl/noAllowCause.js

@@ -4,7 +4,7 @@ function ladderSays(ladder, key) {
         return false;
     try {
         const d = Object.getOwnPropertyDescriptor(ladder, key);
-        return d !== undefined && 'value' in d && d.value === true;
+        return d !== undefined && Object.hasOwn(d, 'value') && d.value === true;
     }
     catch {
         return false;

package/dist/hitl/parkResolver.js

@@ -1,6 +1,6 @@
 import { putOwnKey, readOwnDataValue } from '../ownKey.js';
 import { HitlBridge, NO_QUESTION_OVERLAY_REASON, findPendingForTask, isNoDecisionSurfaceReason, } from './hitlBridge.js';
-import { approvalResolutionDetail, resolutionOfDecisionFailure } from './approvalResolution.js';
+import { approvalResolutionDetail, directSafetyStopOf, resolutionOfDecisionFailure } from './approvalResolution.js';
 import { readDecisionRefusalAsk } from './decisionRefusal.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
@@ -136,9 +136,10 @@ async function surfaceGateAndDecide(deps, taskId, askArgsByCall, signal, parkGat
         return { kind: 'decided', ...at, decision: 'deny', ...(declinedReceipt !== undefined ? { receipt: declinedReceipt } : {}) };
     }
     catch (e) {
+        const directStop = directSafetyStopOf(e);
         const failureTexts = wireFailureTextsOf(e);
         hostLog('debug', `liveHitlAskWire: decide failed: ${failureTexts.log}`);
-        return resolutionOfDecisionFailure(e, { lane: 'ask', route: 'ask_decide', gatedCallId, detail: `decide failed: ${failureTexts.reason}${decideFailureNote(e, attemptedDecision)}` });
+        return resolutionOfDecisionFailure(e, { lane: 'ask', route: 'ask_decide', gatedCallId, detail: `decide failed: ${failureTexts.reason}${decideFailureNote(e, attemptedDecision)}`, ...(directStop !== undefined ? { directStop } : {}) });
     }
 }
 function argsByCallOf(led) {

package/dist/hitl/persistedRulesWire.js

@@ -207,6 +207,7 @@ const PERSISTED_RULE_MATCH_KEYS = Object.freeze({
     name_prefix: 'rules.match.namePrefix',
     host: 'rules.match.host',
     subdomain: 'rules.match.subdomain',
+    pattern: 'rules.match.pattern',
 });
 export function persistedRuleMatchLabel(ruleOrMatch, lang) {
     const word = typeof ruleOrMatch === 'string' ? ruleOrMatch : ownSlot(ruleOrMatch, 'match');

package/dist/hitl/planReviewWire.d.ts

@@ -43,6 +43,9 @@ export interface PlanReviewQuestionIdReading {
 }
 export declare function planReviewTaskIdFromQuestionId(questionId: {} | null | undefined): PlanReviewQuestionIdReading | undefined;
 export declare function planReviewOfferedModeOf(card: string | PlanReviewCardLike): PlanReviewOfferedMode;
+export declare function planReviewShownLabelsOf(questionId: {} | null | undefined): readonly string[] | undefined;
+export declare function planReviewAnswerChoiceOf(questionId: {} | null | undefined, answer: QuestionAnswer | null | undefined): PlanReviewChoice | 'dismissed';
+export declare function planReviewAnswerDecisionOf(questionId: {} | null | undefined, answer: QuestionAnswer | null | undefined): 'approve' | 'reject' | 'dismissed';
 export interface ArmPlanReviewOptions {
     submittedInPlanMode?: boolean;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
@@ -56,6 +59,7 @@ export interface PlanReviewOutcomeMeta {
     dispatchNo: number;
     decision: 'approve' | 'reject';
     effect: PlanReviewDecisionEffect;
+    cause?: 'stored_form_unsupported';
 }
 export declare function planReviewOutcomeTail(taskId: string, decision: 'approve' | 'reject', effect: PlanReviewDecisionEffect, cause?: 'stored_form_unsupported'): string;
 export type PlanReviewWireClient = {