@atbash/sdk 0.16.5-dev.0 → 0.17.0-dev.0

package/dist/browser.mjs

@@ -44360,6 +44360,13 @@ function buildAllowedJudgeHosts() {
   ]);
 }
 var ALLOWED_JUDGE_HOSTS = buildAllowedJudgeHosts();
+function isAllowlistedJudgeHost(endpoint) {
+  try {
+    return ALLOWED_JUDGE_HOSTS.has(new URL(endpoint).hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
 function validateJudgeEndpoint(judge) {
   const policy = judge?.policy === "self-hosted" ? "self-hosted" : "default";
   const candidate = judge?.endpoint?.trim() || DEFAULT_ENDPOINT;
@@ -44583,7 +44590,7 @@ init_define_ATBASH_CHROMIA_NODE_URLS();
 init_define_ATBASH_PRIVATE_NODE_URLS();
 function normalizeVerdict(raw2) {
   if (raw2 === null || raw2 === void 0) return "No verdict";
-  const v = String(raw2).toUpperCase();
+  const v = String(raw2).trim().toUpperCase();
   if (v === "ALLOW" || v === "GREEN") return "ALLOW";
   if (v === "HOLD" || v === "YELLOW") return "HOLD";
   if (v === "BLOCK" || v === "RED") return "BLOCK";
@@ -44620,17 +44627,58 @@ function allowSignalsPermit(data) {
   }
   return signals.length === 0 || signals.every((value) => value === true);
 }
+function explicitRefusal(data) {
+  let hold = false;
+  for (const source of decisionSources(data)) {
+    const verdict = verdictOf(source);
+    if (verdict === "BLOCK" || verdict === "RED") return "BLOCK";
+    if (verdict === "HOLD" || verdict === "YELLOW") hold = true;
+    const actionType = actionTypeOf(source);
+    if (actionType === "block") return "BLOCK";
+    if (actionType === "hold_for_user_confirm") hold = true;
+  }
+  if (!allowSignalsPermit(data)) return "BLOCK";
+  return hold ? "HOLD" : "";
+}
+function decisionSources(data) {
+  return [data, isRecord(data.decision) ? data.decision : {}];
+}
+function verdictOf(source) {
+  return typeof source.verdict === "string" ? source.verdict.trim().toUpperCase() : "";
+}
+function actionTypeRank(actionType) {
+  if (actionType === "block") return 4;
+  if (actionType === "hold_for_user_confirm") return 3;
+  if (actionType === "") return 1;
+  if (actionType === "allow") return 0;
+  return 2;
+}
+function actionTypeOf(source) {
+  let winner = "";
+  for (const key3 of ["action_type", "actionType"]) {
+    const raw2 = source[key3];
+    if (raw2 === void 0 || raw2 === null) continue;
+    const actionType = normalizeActionType(raw2);
+    if (actionTypeRank(actionType) > actionTypeRank(winner)) winner = actionType;
+  }
+  return winner;
+}
 function wireActionType(data) {
-  if (data.action_type !== void 0)
-    return normalizeActionType(data.action_type);
-  return normalizeActionType(data.actionType);
+  for (const source of decisionSources(data)) {
+    const actionType = actionTypeOf(source);
+    if (actionType !== "") return actionType;
+  }
+  return "";
 }
 function isAuditTier(data) {
   const absentVerdict = data.verdict === null || data.verdict === void 0;
   return absentVerdict && data.status === "logged";
 }
+function isAuditTierBody(data) {
+  return isAuditTier(data);
+}
 function canonicalAllow(data) {
-  if (!allowSignalsPermit(data)) return false;
+  if (explicitRefusal(data) !== "") return false;
   const actionType = wireActionType(data);
   if (actionType && actionType !== "allow") return false;
   if (isAuditTier(data)) return true;
@@ -44713,6 +44761,10 @@ var Atbash = class _Atbash {
   orgEncryptionPubKey;
   /** When true (default), `auditToolCall` denies on any error. */
   failClosed;
+  /** When true (default), an unenforced (audit-tier) answer is refused. */
+  requireEnforcement;
+  /** Overall deadline for one auditToolCall decision, in ms. */
+  decisionTimeoutMs;
   /** Org key learned from the last agent-exists check, for this agent only. */
   _orgKeyFromChain = null;
   debug;
@@ -44786,6 +44838,8 @@ var Atbash = class _Atbash {
     this.verifyPubKey = validated.verifyPubKey ?? void 0;
     this.orgEncryptionPubKey = options.orgEncryptionPubKey;
     this.failClosed = options.failClosed !== false;
+    this.requireEnforcement = options.requireEnforcement !== false;
+    this.decisionTimeoutMs = options.decisionTimeoutMs ?? DEFAULT_DECISION_TIMEOUT_MS;
     this.debug = options.debug === true;
     this.logger = options.logger ?? {};
     this.http = new HttpClient(this.endpoint, options.timeoutMs ?? 12e4);
@@ -44796,16 +44850,23 @@ var Atbash = class _Atbash {
         verifying: this.verifyPubKey ? "with response-signature pubkey configured" : "without signature verification"
       });
     }
-    try {
-      setupTelemetry({
-        enabled: true,
-        endpoint: this.endpoint,
-        getAuthHeaders: () => this.authHeaders()
-      });
-    } catch (err) {
-      this.logger.warn?.(
-        "[atbash] telemetry setup failed \u2014 continuing without metrics",
-        { error: String(err) }
+    if (isAllowlistedJudgeHost(this.endpoint)) {
+      try {
+        setupTelemetry({
+          enabled: true,
+          endpoint: this.endpoint,
+          getAuthHeaders: () => this.authHeaders()
+        });
+      } catch (err) {
+        this.logger.warn?.(
+          "[atbash] telemetry setup failed \u2014 continuing without metrics",
+          { error: String(err) }
+        );
+      }
+    } else {
+      this.logger.info?.(
+        "[atbash] telemetry disabled \u2014 the agent bearer is only sent to hosts that already receive it, and this judge endpoint is not one",
+        { endpoint: this.endpoint }
       );
     }
   }
@@ -44869,6 +44930,8 @@ var Atbash = class _Atbash {
       orgName: options.orgName,
       verifyPubKey: validated.verifyPubKey ?? void 0,
       failClosed: options.failClosed,
+      requireEnforcement: options.requireEnforcement,
+      decisionTimeoutMs: options.decisionTimeoutMs,
       // ATBASH_DEBUG lets an operator turn diagnostics on without editing a
       // host's plugin config, which is usually the harder half.
       debug: options.debug ?? /^(1|true|yes)$/i.test(resolve("debug")),
@@ -45067,34 +45130,16 @@ var Atbash = class _Atbash {
     }
     if (!resp.ok) throw await this.httpError(resp);
     const bodyBytes = Buffer.from(await resp.arrayBuffer());
-    const verifyPubKey = options.verifyPubKey ?? this.verifyPubKey;
+    const verifyPubKey = this.effectiveVerifyKey(options.verifyPubKey);
     if (verifyPubKey !== void 0) {
-      const sig = resp.headers.get("X-Atbash-Signature");
-      if (!sig) {
-        throw new SignatureVerificationError(
-          "missing X-Atbash-Signature header"
-        );
-      }
-      let ok;
-      try {
-        ok = native.verifySignature(bodyBytes, sig, verifyPubKey);
-      } catch (err) {
-        throw new SignatureVerificationError(
-          `signature verification threw: ${errorMessage(err)}`
-        );
-      }
-      if (!ok) {
-        throw new SignatureVerificationError(
-          "signature does not verify against configured verifyPubKey"
-        );
-      }
+      verifyResponseSignature(bodyBytes, resp, verifyPubKey);
     }
     const data = parseJson(bodyBytes);
     const rawScore = data.score;
     const score = typeof rawScore === "number" && Number.isInteger(rawScore) && rawScore >= 1 && rawScore <= 10 ? rawScore : void 0;
     return {
       verdict: normalizeVerdict(data.verdict),
-      allow: canonicalAllow(data),
+      allow: this.executable(data),
       actionType: normalizeActionType(data.action_type),
       reason: String(data.reason ?? ""),
       confidence: Number(data.confidence ?? 0),
@@ -45105,7 +45150,8 @@ var Atbash = class _Atbash {
       enforced: Boolean(data.enforced),
       enforcementMode: String(data.enforcement_mode ?? ""),
       status: String(data.status ?? ""),
-      score
+      score,
+      refusal: explicitRefusal(data)
     };
   }
   /* ── audit_tool_call (redact → judge → decision) ───────────────────────── */
@@ -45138,77 +45184,125 @@ var Atbash = class _Atbash {
     }
     try {
       this.logger.info?.("[atbash] judge API called", { tool: toolName });
-      const result = await this.judgeAction(actionText, contextText, {
-        toolName,
-        toolArgsJson: argsJson,
-        orgName: this.orgName,
-        // Passed through unredacted — caller vouches for the contents.
-        resolved: input.resolved
-      });
-      if (result.verdict === "No verdict") {
-        if (result.status !== "logged") {
-          return this.failJudge(
-            `judge returned no verdict without an audit-tier marker (status: ${result.status || "absent"})`,
-            void 0,
-            result.toolCallId
-          );
-        }
-        return {
-          allow: true,
-          verdict: "ALLOW",
-          reason: result.reason || "audit tier \u2014 request logged on-chain, no AI enforcement",
-          toolCallId: result.toolCallId
-        };
-      }
-      const action = result.actionType;
-      if (action === "block") {
+      const result = await withDeadline(
+        this.judgeAction(actionText, contextText, {
+          toolName,
+          toolArgsJson: argsJson,
+          orgName: this.orgName,
+          // Passed through unredacted — caller vouches for the contents.
+          resolved: input.resolved
+        }),
+        this.decisionTimeoutMs
+      );
+      return this.decide(result);
+    } catch (err) {
+      if (err instanceof SignatureVerificationError) {
+        this.failJudge(errorMessage(err), err);
         return {
           allow: false,
-          verdict: "BLOCK",
-          reason: result.reason,
-          toolCallId: result.toolCallId
+          verdict: "ERROR",
+          reason: `The judge's reply failed its signature check (${errorMessage(err)}), so it was not trusted.`
         };
       }
-      if (action === "hold_for_user_confirm") {
-        return {
-          allow: false,
-          verdict: "HOLD",
-          reason: result.reason || "held for human confirmation",
-          toolCallId: result.toolCallId
-        };
+      return this.failJudge(errorMessage(err), err);
+    }
+  }
+  /**
+   * The verify key for one call (R4, governor tier-2 review). A per-call key
+   * may only narrow what the client accepts: on a client pinned to a judge
+   * key it must be that same key, never a replacement; on an unpinned client
+   * it adds the check.
+   */
+  effectiveVerifyKey(perCall) {
+    if (perCall === void 0) return this.verifyPubKey;
+    const key3 = perCall.trim().toLowerCase();
+    if (this.verifyPubKey !== void 0 && key3 !== this.verifyPubKey) {
+      throw new SignatureVerificationError(
+        "a per-call verifyPubKey cannot replace the judge key this client is pinned to"
+      );
+    }
+    return key3;
+  }
+  /**
+   * Collapse a judge result into a {@link Decision}. The most restrictive
+   * signal wins (security review 2026-09-30, H1): `action_type`, `verdict`
+   * and the canonical `allow` are each able to deny, and only a result where
+   * all three agree may execute. A present `allow` / `decision.allow` that is
+   * not exactly `true` is the judge declining to grant permission, so it
+   * denies even under `failClosed: false` — that option relaxes *errors*, it
+   * never overrides a refusal.
+   */
+  decide(result) {
+    const toolCallId = result.toolCallId;
+    const deny = (verdict, reason) => ({
+      allow: false,
+      verdict,
+      reason,
+      toolCallId
+    });
+    const notGranted = "the judge response did not grant permission";
+    const held = deny("HOLD", result.reason || "held for human confirmation");
+    const blocked = deny("BLOCK", result.reason || notGranted);
+    if (result.refusal === "BLOCK") return blocked;
+    if (result.verdict === "No verdict") {
+      if (result.actionType === "block") {
+        return blocked;
+      }
+      if (result.actionType === "hold_for_user_confirm") {
+        return held;
+      }
+      if (result.refusal === "HOLD") return held;
+      if (result.status !== "logged") {
+        return this.failJudge(
+          `judge returned no verdict without an audit-tier marker (status: ${result.status || "absent"})`,
+          void 0,
+          toolCallId
+        );
       }
-      if (action === "allow") {
-        if (result.verdict === "HOLD") {
-          return {
-            allow: false,
-            verdict: "HOLD",
-            reason: result.reason,
-            toolCallId: result.toolCallId
-          };
-        }
-        if (result.verdict === "BLOCK") {
-          return {
-            allow: false,
-            verdict: "BLOCK",
-            reason: result.reason,
-            toolCallId: result.toolCallId
-          };
-        }
+      if (this.requireEnforcement) {
+        this.logger.warn?.(
+          "[atbash] judge did not enforce this action (audit tier) and requireEnforcement is on: denied",
+          { toolCallId }
+        );
         return {
-          allow: true,
-          verdict: "ALLOW",
-          reason: result.reason,
-          toolCallId: result.toolCallId
+          allow: false,
+          verdict: "ERROR",
+          reason: "Atbash logged this action but did not check it (audit-tier plan), and this client requires a checked decision. Upgrade the plan, or set requireEnforcement: false for log-only mode.",
+          toolCallId
         };
       }
-      return this.failJudge(
-        "unrecognized action_type from judge",
-        void 0,
-        result.toolCallId
-      );
-    } catch (err) {
-      return this.failJudge(errorMessage(err), err);
+      if (result.allow !== true) return deny("BLOCK", notGranted);
+      return {
+        allow: true,
+        verdict: "ALLOW",
+        reason: result.reason || "audit tier \u2014 request logged on-chain, no AI enforcement",
+        toolCallId
+      };
+    }
+    const action = result.actionType;
+    if (action === "block") {
+      return deny("BLOCK", result.reason || "Blocked by your organisation's Atbash policy.");
+    }
+    if (action === "hold_for_user_confirm") {
+      return held;
+    }
+    if (result.refusal === "HOLD") return held;
+    if (action === "allow") {
+      if (result.verdict === "HOLD") return held;
+      if (result.verdict === "BLOCK") return blocked;
+      if (result.allow !== true) return deny("BLOCK", notGranted);
+      return {
+        allow: true,
+        verdict: "ALLOW",
+        reason: result.reason,
+        toolCallId
+      };
     }
+    return this.failJudge(
+      "unrecognized action_type from judge",
+      void 0,
+      toolCallId
+    );
   }
   /**
    * One exit for every judge failure.
@@ -45220,18 +45314,30 @@ var Atbash = class _Atbash {
    */
   failJudge(reason, cause, toolCallId) {
     const api2 = cause instanceof AtbashAPIError ? cause : null;
+    const userReason = userFacingReason(reason, api2);
     const status = api2 ? ` status=${api2.status || "no-response"}` : "";
+    const detail = this.debug ? ` detail=${truncate(reason, 500)}` : "";
     const body = this.debug && api2?.body ? ` body=${truncate(api2.body, 500)}` : "";
     this.logger.warn?.(
-      `[atbash] judge API failed \u2014${status} reason=${truncate(reason, 300)}${body}`,
+      `[atbash] judge API failed \u2014${status} reason=${truncate(userReason, 300)}${detail}${body}`,
       {
-        reason,
-        ...api2 ? { status: api2.status, body: api2.body } : {},
+        reason: userReason,
+        ...api2 ? { status: api2.status } : {},
+        ...this.debug && api2 ? { body: api2.body, detail: reason } : {},
         endpoint: this.endpoint,
         ...toolCallId ? { toolCallId } : {}
       }
     );
-    return this.fail(reason, toolCallId);
+    return this.fail(userReason, toolCallId);
+  }
+  /**
+   * The canonical permission for a response body under this client's
+   * settings: {@link canonicalAllow}, minus the audit tier when
+   * `requireEnforcement` is on. Never more permissive than `auditToolCall`.
+   */
+  executable(data) {
+    if (!canonicalAllow(data)) return false;
+    return !(this.requireEnforcement && isAuditTierBody(data));
   }
   fail(reason, toolCallId) {
     return { allow: !this.failClosed, verdict: "ERROR", reason, toolCallId };
@@ -45257,11 +45363,16 @@ var Atbash = class _Atbash {
         this.authHeaders(brid)
       );
       await this.raiseIfError(resp);
-      const data = await this.json(resp) ?? {};
+      const bytes = Buffer.from(await resp.arrayBuffer());
+      if (this.verifyPubKey !== void 0) {
+        verifyResponseSignature(bytes, resp, this.verifyPubKey);
+      }
+      const parsed = tryParseJson(bytes.toString("utf-8"));
+      const data = isRecord2(parsed) ? parsed : {};
       return {
         status: normalizeStatus(data.status),
         verdict: normalizeVerdict(data.verdict),
-        allow: canonicalAllow(data),
+        allow: this.executable(data),
         reason: String(data.reason ?? ""),
         judgmentId: String(data.judgmentId ?? judgmentId),
         onChain: optBool(data.onChain),
@@ -45736,6 +45847,66 @@ var Atbash = class _Atbash {
     return native.containsEvasionCharacters(text);
   }
 };
+function userFacingReason(reason, api2) {
+  if (api2 && api2.status > 0) {
+    const where = ` (HTTP ${api2.status}${api2.path ? ` from ${api2.path}` : ""})`;
+    const b = api2.body.toLowerCase();
+    if (b.includes("agent not registered")) {
+      return `Agent not registered with Atbash: onboard it in the Atbash dashboard${where}.`;
+    }
+    if (b.includes("jailed")) {
+      return `This agent is jailed; unjail it in the Atbash dashboard${where}.`;
+    }
+    if (b.includes("agent has no policy") || b.includes("no policy configured")) {
+      return `This agent has no policy; attach one in the Atbash dashboard${where}.`;
+    }
+    if (b.includes("audit tier") || b.includes("verdict disabled") || b.includes("verdict not supported")) {
+      return `The organisation's plan does not include checked decisions${where}.`;
+    }
+    return `The Atbash judge answered with an error${where}, so the action was not approved.`;
+  }
+  const text = api2 ? api2.body || reason : reason;
+  return truncate(text.replace(/https?:\/\/[^\s)]+/g, "the judge"), 300);
+}
+var DEFAULT_DECISION_TIMEOUT_MS = 6e4;
+async function withDeadline(p, ms) {
+  let timer;
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(
+        new Error(
+          `The judge did not give a decision within ${Math.round(ms / 1e3)} s, so the action was not approved. Check the network, or raise decisionTimeoutMs.`
+        )
+      ),
+      ms
+    );
+  });
+  p.catch(() => void 0);
+  try {
+    return await Promise.race([p, deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function verifyResponseSignature(bodyBytes, resp, verifyPubKey) {
+  const sig = resp.headers.get("X-Atbash-Signature");
+  if (!sig) {
+    throw new SignatureVerificationError("missing X-Atbash-Signature header");
+  }
+  let ok;
+  try {
+    ok = native.verifySignature(bodyBytes, sig, verifyPubKey);
+  } catch (err) {
+    throw new SignatureVerificationError(
+      `signature verification threw: ${errorMessage(err)}`
+    );
+  }
+  if (!ok) {
+    throw new SignatureVerificationError(
+      "signature does not verify against configured verifyPubKey"
+    );
+  }
+}
 function baseToolCall(raw2) {
   return {
     toolCallId: String(raw2.tool_call_id ?? ""),
@@ -46124,7 +46295,7 @@ async function syncLocalMemory(auth, pointer, opts = {}) {
   if (withinTtl) {
     return { drifted: false, checked: false, pointer };
   }
-  const currentId = await getActiveMemoryId(auth, opts.chainOpts);
+  const currentId = await getActiveMemoryId(auth, opts.chainOpts, opts.filePath);
   const nextPointer = { activeId: currentId, checkedAt: now };
   if (currentId === pointer.activeId) {
     return { drifted: false, checked: true, pointer: nextPointer };