@sema-agent/server 7.93.3 → 7.93.5

package/dist/tool-approval.js

@@ -84,6 +84,9 @@ export const PERSIST_RULE_EDITED_FLAG_ERROR = "persistRule.edited must be a bool
 export const PERSIST_RULE_BATCH_INDEX_ERROR = "persistRule.batchOfferIndex must be a non-negative integer when present";
 export const PERSIST_RULE_BATCH_EXCLUSIVE_ERROR = "persistRule.batchOfferIndex is mutually exclusive with persistRule.rule / persistRule.edited — send exactly one arm";
 export const SETTLED_BY_MUST_BE_STRING = "settledBy must be a string — the settlement source is one word from the engine's closed set, and this layer judges only the SHAPE (which word it is, the engine decides)";
+function respondSettledBy(parsed) {
+    return parsed.settledBy;
+}
 export const SETTLED_BY_DENY_ONLY = 'settledBy is only meaningful with decision "deny" — only a person approves an action that EXECUTES, so a self-reported settlement source on an allow is a contradiction the engine refuses; the refusal would arrive too late to undo this door\'s own side effects (a session allow-all grant, a persisted rule, a DECIDED row that replays as a plain approval), so it is refused here, before the decision';
 export const PERSIST_RULE_SCOPE_REFUSED = "this endpoint does not accept a rule scope — the server mints it from where the approval happened (send neither `scope` nor `persistRule.scope`)";
 export function parseToolApprovalResponse(body) {
@@ -222,21 +225,28 @@ function effectiveAskWindowMs(ttlMs, windowMarginMs, legDeadlineMonotonic, nowMo
     return Math.min(ttlMs, Math.max(0, legRemainingMs - windowMarginMs));
 }
 function replayTerminalAskRow(row) {
-    if (row.state === "DECIDED") {
-        if (row.decision !== "approve")
-            return false;
-        return row.updatedInput !== undefined ? { allow: true, updatedInput: row.updatedInput } : true;
-    }
+    if (row.state === "DECIDED")
+        return outcomeOfDecidedRow(row);
     if (row.state === "PARKING" || row.state === "PARKED")
         return "unavailable";
     return false;
 }
-function settleArgsOf(outcome) {
-    if (outcome === "unavailable")
-        return "unavailable";
+export function outcomeOfDecidedRow(row) {
+    if (row.decision !== "approve")
+        return row.settledBy !== null ? { allow: false, settledBy: row.settledBy } : false;
+    return row.updatedInput !== undefined ? { allow: true, updatedInput: row.updatedInput } : true;
+}
+function settleArgsOfDecided(outcome) {
     if (typeof outcome === "boolean")
         return { allowed: outcome };
-    return { allowed: outcome.allow, ...(outcome.updatedInput !== undefined ? { updatedInput: outcome.updatedInput } : {}) };
+    return {
+        allowed: outcome.allow,
+        ...(outcome.updatedInput !== undefined ? { updatedInput: outcome.updatedInput } : {}),
+        ...(outcome.settledBy !== undefined ? { settledBy: outcome.settledBy } : {}),
+    };
+}
+function settleArgsOf(outcome) {
+    return outcome === "unavailable" ? "unavailable" : settleArgsOfDecided(outcome);
 }
 export class ToolApprovalCoordinator {
     als = new AsyncLocalStorage();
@@ -616,16 +626,17 @@ export class ToolApprovalCoordinator {
     classifyClaimLoss(askId, current, _where) {
         if (current.state === "absent")
             return { kind: "absent" };
-        const replayed = settleArgsOf(replayTerminalAskRow(current));
-        if (replayed === "unavailable")
+        const replayedOutcome = replayTerminalAskRow(current);
+        if (replayedOutcome === "unavailable")
             return { kind: "parked" };
+        const replayed = settleArgsOfDecided(replayedOutcome);
         if (!replayed.allowed)
-            return { kind: "denied" };
+            return { kind: "decided", outcome: replayedOutcome };
         if (replayed.updatedInput !== undefined)
-            return { kind: "approved", updatedInput: replayed.updatedInput };
+            return { kind: "decided", outcome: replayedOutcome };
         if (this.editedDecisionInFlight(askId))
             return { kind: "edit-in-flight" };
-        return { kind: "approved" };
+        return { kind: "decided", outcome: replayedOutcome };
     }
     hasOtherSuspendedOwner(askId, self) {
         if (askId === undefined)
@@ -713,13 +724,14 @@ export class ToolApprovalCoordinator {
         }
         return tomb;
     }
-    notifyExternalDecision(askId, allowed, updatedInput) {
+    notifyExternalDecision(askId, outcome) {
         const entries = this.pendingByAskId.get(askId);
         if (!entries)
             return { settled: 0 };
+        const args = settleArgsOfDecided(outcome);
         let settled = 0;
         for (const entry of [...entries]) {
-            entry.settle(allowed, allowed ? "allowed" : "denied", updatedInput);
+            entry.settle(args.allowed, args.allowed ? "allowed" : "denied", args.updatedInput, args.settledBy);
             settled += 1;
         }
         return { settled };
@@ -1091,11 +1103,8 @@ export class ToolApprovalCoordinator {
             if (askId === undefined)
                 return;
             switch (read.kind) {
-                case "approved":
-                    this.notifyExternalDecision(askId, true, read.updatedInput);
-                    return;
-                case "denied":
-                    this.notifyExternalDecision(askId, false);
+                case "decided":
+                    this.notifyExternalDecision(askId, read.outcome);
                     return;
                 case "parked":
                     this.settleSameAskIdParkRoute(askId);
@@ -1111,14 +1120,12 @@ export class ToolApprovalCoordinator {
         };
         const settleFromClaimLoss = (read) => {
             switch (read.kind) {
-                case "approved":
-                    settle(true, "allowed", read.updatedInput);
-                    broadcastClaimTruth(read);
-                    return true;
-                case "denied":
-                    settle(false, "denied");
+                case "decided": {
+                    const args = settleArgsOfDecided(read.outcome);
+                    settle(args.allowed, args.allowed ? "allowed" : "denied", args.updatedInput, args.settledBy);
                     broadcastClaimTruth(read);
                     return true;
+                }
                 case "parked":
                     windowRouteUnavailable = true;
                     settle(false, "expired");
@@ -1622,7 +1629,7 @@ export class ToolApprovalCoordinator {
             });
             return this.notPending();
         }
-        this.notifyExternalDecision(row.askId, row.decision === "approve", row.updatedInput);
+        this.notifyExternalDecision(row.askId, outcomeOfDecidedRow(row));
         return {
             status: 200,
             body: {
@@ -1895,21 +1902,23 @@ export class ToolApprovalCoordinator {
         }
     }
     async respondWithCas(askStore, askId, batchId, id, entry, parsed, ruleEligibility) {
-        let decidedWon = false;
-        let confirmedRowPayload;
+        let winnerRow;
+        let ambiguousConfirmedRow;
         let noteLanded = false;
         try {
             const decided = await this.withStoreDeadline(askStore.decideAsk(askId, batchId, {
                 decision: parsed.value === "deny" ? "deny" : "approve",
                 ...(parsed.note !== undefined ? { decisionNote: parsed.note } : {}),
                 ...(parsed.value !== "deny" && parsed.updatedInput !== undefined ? { updatedInput: parsed.updatedInput } : {}),
+                ...(parsed.settledBy !== undefined ? { settledBy: respondSettledBy(parsed) } : {}),
             }), "decideAsk", DURABLE_CALL_TIMEOUT_MS, (late) => {
                 if (late.ok)
-                    this.notifyExternalDecision(askId, parsed.value !== "deny", parsed.updatedInput);
+                    this.notifyExternalDecision(askId, outcomeOfDecidedRow(late.row));
             });
-            decidedWon = decided.ok;
-            if (decided.ok)
+            if (decided.ok) {
+                winnerRow = decided.row;
                 noteLanded = true;
+            }
             if (!decided.ok) {
                 return this.notPending();
             }
@@ -1920,8 +1929,8 @@ export class ToolApprovalCoordinator {
             try {
                 const row = await this.withStoreDeadline(askStore.getAsk(askId), "getAsk(decideAsk-confirm)", DURABLE_CONVERGE_READ_TIMEOUT_MS);
                 if (row?.state === "DECIDED" && row.decision === (parsed.value === "deny" ? "deny" : "approve")) {
-                    decidedWon = true;
-                    confirmedRowPayload = { updatedInput: row.updatedInput };
+                    winnerRow = row;
+                    ambiguousConfirmedRow = row;
                     noteLanded = parsed.note === undefined || row.decisionNote === parsed.note;
                 }
             }
@@ -1930,22 +1939,25 @@ export class ToolApprovalCoordinator {
             }
         }
         const wantAllowed = parsed.value !== "deny";
+        const decidedWon = winnerRow !== undefined;
         if (this.pending.get(id) !== entry) {
-            if (decidedWon)
-                this.notifyExternalDecision(askId, wantAllowed, confirmedRowPayload !== undefined ? confirmedRowPayload.updatedInput : parsed.updatedInput);
+            if (winnerRow !== undefined)
+                this.notifyExternalDecision(askId, outcomeOfDecidedRow(winnerRow));
             const converged = decidedWon && entry.settledOutcome === (wantAllowed ? "allowed" : "denied");
             if (!converged) {
                 return this.notPending();
             }
             return this.finishRespond(id, entry, parsed, { updatedInputDelivered: false, noteRecorded: noteLanded });
         }
-        const payloadIsMine = confirmedRowPayload === undefined ||
-            approvalPayloadFingerprint({ updatedInput: confirmedRowPayload.updatedInput }) === approvalPayloadFingerprint({ updatedInput: parsed.updatedInput });
+        const payloadIsMine = ambiguousConfirmedRow === undefined ||
+            approvalPayloadFingerprint({ updatedInput: ambiguousConfirmedRow.updatedInput }) === approvalPayloadFingerprint({ updatedInput: parsed.updatedInput });
         const result = this.finishRespond(id, entry, parsed, {
             noteRecorded: noteLanded,
-            ...(confirmedRowPayload !== undefined ? { settlePayload: confirmedRowPayload, updatedInputDelivered: payloadIsMine } : {}),
+            ...(winnerRow !== undefined ? { settleOutcome: outcomeOfDecidedRow(winnerRow) } : {}),
+            ...(ambiguousConfirmedRow !== undefined ? { updatedInputDelivered: payloadIsMine } : {}),
         });
-        this.notifyExternalDecision(askId, wantAllowed, confirmedRowPayload !== undefined ? confirmedRowPayload.updatedInput : parsed.updatedInput);
+        if (winnerRow !== undefined)
+            this.notifyExternalDecision(askId, outcomeOfDecidedRow(winnerRow));
         return result;
     }
     finishRespond(id, entry, parsed, opts) {
@@ -1962,7 +1974,8 @@ export class ToolApprovalCoordinator {
             this.allowAllSessions.add(sessionAllowKey(entry.owner, entry.sessionId, sessionAllowCategory(entry.toolName)));
         }
         const allowed = parsed.value !== "deny";
-        entry.settle(allowed, allowed ? "allowed" : "denied", opts?.settlePayload !== undefined ? opts.settlePayload.updatedInput : parsed.updatedInput, parsed.settledBy, allowed ? undefined : parsed.note);
+        const settleArgs = opts?.settleOutcome !== undefined ? settleArgsOfDecided(opts.settleOutcome) : { allowed, updatedInput: parsed.updatedInput, settledBy: respondSettledBy(parsed) };
+        entry.settle(settleArgs.allowed, settleArgs.allowed ? "allowed" : "denied", settleArgs.updatedInput, settleArgs.settledBy, settleArgs.allowed ? undefined : parsed.note);
         const updatedInputDelivered = opts?.updatedInputDelivered ?? true;
         const noteRecorded = opts?.noteRecorded ?? false;
         return {
@@ -2035,14 +2048,14 @@ export class ToolApprovalCoordinator {
                 continue;
             if (this.editedDecisionInFlight(askId))
                 continue;
-            const outcome = settleArgsOf(replayTerminalAskRow(row));
+            const outcome = replayTerminalAskRow(row);
             if (outcome === "unavailable") {
                 const before = this.pendingByAskId.get(askId)?.size ?? 0;
                 this.settleSameAskIdParkRoute(askId);
                 settled += before;
                 continue;
             }
-            const delivered = this.notifyExternalDecision(askId, outcome.allowed, outcome.updatedInput).settled;
+            const delivered = this.notifyExternalDecision(askId, outcome).settled;
             settled += delivered;
         }
         const backlog = Math.max(0, candidates.length - polled);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.93.3",
+  "version": "7.93.5",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -74,7 +74,7 @@
     "sharp": "^0.35.3"
   },
   "devDependencies": {
-    "@sema-agent/sdk": "11.2.1",
+    "@sema-agent/sdk": "11.3.0",
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "22.10.2",
     "@types/pg": "^8.20.0",