@atbash/sdk 0.12.0-dev.0 → 0.13.2-dev.0

package/dist/index.mjs

@@ -3313,11 +3313,34 @@ var ENV_MAP = {
   judgeEndpoint: "ATBASH_ENDPOINT",
   // Same variable name the Hermes plugin already documents.
   judgeVerifyPubKey: "ATBASH_JUDGE_VERIFY_PUBKEY",
-  blockchainRid: "ATBASH_BLOCKCHAIN_RID",
+  defaultChainNetwork: "ATBASH_DEFAULT_CHAIN_NETWORK",
   provider: "ATBASH_PROVIDER",
   providerModel: "ATBASH_PROVIDER_MODEL",
   debug: "ATBASH_DEBUG"
 };
+var DEPRECATED_ENV_VARS = ["ATBASH_BLOCKCHAIN_RID"];
+var DEPRECATED_CONFIG_FIELDS = ["blockchainRid"];
+var deprecatedWarned = false;
+function warnDeprecatedEnvVarsOnce(log = console.warn) {
+  if (deprecatedWarned) return;
+  for (const name2 of DEPRECATED_ENV_VARS) {
+    if (process.env[name2]) {
+      deprecatedWarned = true;
+      log(
+        `[atbash] ${name2} is ignored \u2014 each org's chain is resolved from the dashboard; set ATBASH_DEFAULT_CHAIN_NETWORK=private only to pin everything to private`
+      );
+    }
+  }
+  const fileConfig = loadUserConfig();
+  for (const field of DEPRECATED_CONFIG_FIELDS) {
+    if (fileConfig[field]) {
+      deprecatedWarned = true;
+      log(
+        `[atbash] "${field}" in ${getConfigPath()} is ignored \u2014 pass \`chain\` or \`network\` at construction instead`
+      );
+    }
+  }
+}
 function getConfigDir() {
   const home2 = process.env.HOME || homedir3() || "";
   return join3(home2, ".config", "atbash");
@@ -3359,11 +3382,41 @@ function resolve(key3, flagValue) {
   if (fileVal != null) return String(fileVal);
   return "";
 }
+function forcedChainNetwork(flagValue) {
+  const raw2 = resolve("defaultChainNetwork", flagValue);
+  if (!raw2) return void 0;
+  if (raw2 !== "public" && raw2 !== "private") {
+    throw new Error(
+      `ATBASH_DEFAULT_CHAIN_NETWORK / defaultChainNetwork must be "public" or "private", got ${JSON.stringify(raw2)} \u2014 unset it to let each org's chain decide.`
+    );
+  }
+  return raw2;
+}
 
 // src-ts/client.ts
 function generateToolCallId() {
   return `tc-${Date.now()}-${randomHex(4)}`;
 }
+function resolveConstructorChain(options) {
+  if (options.chain) return options.chain;
+  const hasNodeUrls = options.nodeUrls !== void 0;
+  const hasBrid = options.blockchainRid !== void 0;
+  if (hasNodeUrls !== hasBrid) {
+    throw new Error(
+      'nodeUrls and blockchainRid must be provided together \u2014 passing one without the other 404s every chain request. Prefer `chain: PUBLIC_CHAIN | PRIVATE_CHAIN` or `network: "public" | "private"`.'
+    );
+  }
+  if (hasNodeUrls && hasBrid) {
+    const brid = options.blockchainRid;
+    const derivedNetwork = options.network ?? (brid === PUBLIC_CHAIN.blockchainRid ? "public" : brid === PRIVATE_CHAIN.blockchainRid ? "private" : "private");
+    return {
+      network: derivedNetwork,
+      blockchainRid: brid,
+      nodeUrls: options.nodeUrls
+    };
+  }
+  return chainForNetwork(options.network ?? forcedChainNetwork() ?? "private");
+}
 var Atbash = class _Atbash {
   auth;
   endpoint;
@@ -3387,6 +3440,27 @@ var Atbash = class _Atbash {
    * calls don't re-hit the dashboard. Cleared by `clearChainCache()`.
    */
   _chainCache = /* @__PURE__ */ new Map();
+  /**
+   * The chain the constructor settled on. Used only where a lookup returns no
+   * answer — see {@link resolveChainFromMap}.
+   */
+  _defaultChain;
+  /**
+   * True when the caller named a chain outright — `chain`, `network`, or the
+   * paired `blockchainRid` + `nodeUrls`.
+   *
+   * Such a client is never re-pointed: not by the migration switch, and not by
+   * where an org turns out to live. Naming a chain is the caller saying "talk
+   * to this one", and silently routing elsewhere would make the argument a
+   * suggestion. A client that names nothing is the one that follows the org.
+   */
+  _explicitChain;
+  /**
+   * The fleet-wide chain switch, read once at construction. `resolve()` hits
+   * the config file on disk, so re-reading it per call would put a file read
+   * on every judge.
+   */
+  _forcedNetwork;
   /**
    * Short-TTL cache for `/api/ai/exists`. The `registered` field is
    * monotonic (once true, stays true), so most calls in a burst re-fetch
@@ -3419,8 +3493,13 @@ var Atbash = class _Atbash {
       } : { endpoint: options.endpoint }
     );
     this.endpoint = validated.url;
-    this.nodeUrls = options.nodeUrls ? [...options.nodeUrls] : DEFAULT_CHROMIA_NODE_URLS;
-    this.blockchainRid = options.blockchainRid ?? native.DEFAULT_BLOCKCHAIN_RID;
+    const resolvedChain = resolveConstructorChain(options);
+    this.nodeUrls = [...resolvedChain.nodeUrls];
+    this.blockchainRid = resolvedChain.blockchainRid;
+    this._defaultChain = resolvedChain;
+    this._explicitChain = options.chain !== void 0 || options.network !== void 0 || options.blockchainRid !== void 0 && options.nodeUrls !== void 0;
+    this._forcedNetwork = forcedChainNetwork();
+    warnDeprecatedEnvVarsOnce((msg) => options.logger?.warn?.(msg));
     this.orgName = options.orgName;
     this.verifyPubKey = validated.verifyPubKey ?? void 0;
     this.orgEncryptionPubKey = options.orgEncryptionPubKey;
@@ -3496,10 +3575,11 @@ var Atbash = class _Atbash {
     );
     const agentKey = resolve("agentKey", options.agentKey);
     const auth = agentKey ? native.loadAgent(agentKey) : loadAgentFromFile(options.keyPath);
-    const blockchainRid = resolve("blockchainRid", options.blockchainRid) || void 0;
     return new _Atbash(auth.privkey, {
       endpoint: validated.url,
-      blockchainRid,
+      chain: options.chain,
+      network: options.network,
+      blockchainRid: options.blockchainRid,
       timeoutMs: options.timeoutMs,
       nodeUrls: options.nodeUrls,
       orgName: options.orgName,
@@ -3540,7 +3620,7 @@ var Atbash = class _Atbash {
     return this.track("checkAgentExists", pk, async () => {
       const query = { pubkey: pk };
       if (network) query.network = network;
-      const brid = this.bridFromChainOpts(network ? { network } : void 0);
+      const brid = network ? this.bridFromChainOpts({ network }) : await this.defaultOrgBrid();
       const resp = await this.http.get(
         "/api/ai/exists",
         query,
@@ -3591,7 +3671,7 @@ var Atbash = class _Atbash {
       };
     }
     const toolCallId = generateToolCallId();
-    const brid = this.bridFromChainOpts(options.chainOpts);
+    const brid = options.chainOpts?.blockchainRid || options.chainOpts?.network ? this.bridFromChainOpts(options.chainOpts) : await this.defaultOrgBrid() ?? this.blockchainRid;
     const orgKey = options.orgEncryptionPubKey ?? this.orgEncryptionPubKey ?? this._orgKeyFromChain;
     try {
       const signedHex = orgKey ? signEncryptedToolCall(
@@ -3642,7 +3722,11 @@ var Atbash = class _Atbash {
       throw new Error("action is required and cannot be empty.");
     }
     let chainOpts = options.chainOpts;
-    if (options.orgName) {
+    if (options.orgName && this._explicitChain) {
+      chainOpts = options.chainOpts ?? { network: this._defaultChain.network };
+    } else if (options.orgName && this.forcedNetwork()) {
+      chainOpts = { network: this.forcedNetwork() };
+    } else if (options.orgName) {
       const cached = this._chainCache.get(options.orgName);
       if (cached) {
         chainOpts = { network: cached.network };
@@ -3876,7 +3960,7 @@ var Atbash = class _Atbash {
       const resp = await this.http.get(
         "/api/v1/judge",
         { tool_call_id: judgmentId, agent_pubkey: pk },
-        this.authHeaders()
+        this.authHeaders(await this.defaultOrgBrid())
       );
       await this.raiseIfError(resp);
       const data = await this.json(resp) ?? {};
@@ -3896,7 +3980,11 @@ var Atbash = class _Atbash {
     return this.track(
       "getToolCalls",
       void 0,
-      () => this.riskEngineRecords("tool-calls", { limit: maxCount })
+      async () => this.riskEngineRecords(
+        "tool-calls",
+        { limit: maxCount },
+        await this.defaultOrgBrid()
+      )
     );
   }
   async getOrgToolCalls(orgName, maxCount) {
@@ -3913,24 +4001,31 @@ var Atbash = class _Atbash {
     return this.track(
       "getAgentToolCalls",
       agentPubkey,
-      () => this.riskEngineRecords("agent-tool-calls", {
-        agent: agentPubkey,
-        limit: maxCount
-      })
+      async () => this.riskEngineRecords(
+        "agent-tool-calls",
+        { agent: agentPubkey, limit: maxCount },
+        await this.defaultOrgBrid()
+      )
     );
   }
   async getToolCallCount() {
     return this.track("getToolCallCount", void 0, async () => {
-      const raw2 = await this.riskEngineGet("tool-call-count", {});
+      const raw2 = await this.riskEngineGet(
+        "tool-call-count",
+        {},
+        await this.defaultOrgBrid()
+      );
       const n = Number(raw2);
       return Number.isFinite(n) ? n : 0;
     });
   }
   async getToolCallFull(toolCallId) {
     return this.track("getToolCallFull", void 0, async () => {
-      const raw2 = await this.riskEngineGet("tool-call-full", {
-        tool_call_id: toolCallId
-      });
+      const raw2 = await this.riskEngineGet(
+        "tool-call-full",
+        { tool_call_id: toolCallId },
+        await this.defaultOrgBrid()
+      );
       if (!isRecord(raw2)) return null;
       return toToolCallFull(raw2);
     });
@@ -4016,7 +4111,7 @@ var Atbash = class _Atbash {
       const resp = await this.http.get(
         "/api/insurance",
         { action: "safety-stats" },
-        this.authHeaders()
+        this.authHeaders(await this.defaultOrgBrid())
       );
       await this.raiseIfError(resp);
       const data = await this.json(resp) ?? {};
@@ -4072,10 +4167,15 @@ var Atbash = class _Atbash {
    *   2. Per-chain subscription fallback — public + private records
    *      are fetched in parallel, with `is_private_blockchain` and
    *      `assigned_at` reconciling mixed states.
-   * Defaults to the public chain when nothing else resolves.
+   * A lookup that names exactly one chain wins outright. Where it names
+   * neither (a brand-new org) or cannot choose between them, the client's
+   * configured default decides.
    */
   async resolveChainForOrg(orgName) {
     const name2 = orgName.trim();
+    if (this._explicitChain) return this._defaultChain;
+    const forced = this.forcedNetwork();
+    if (forced) return chainForNetwork(forced);
     const cached = this._chainCache.get(name2);
     if (cached) return cached;
     const mapNetwork = await this.getActiveNetworkForOrg(name2);
@@ -4107,7 +4207,7 @@ var Atbash = class _Atbash {
       return PRIVATE_CHAIN;
     }
     if (pubSub && privSub) {
-      const chain = privSub.assigned_at > pubSub.assigned_at ? PRIVATE_CHAIN : PUBLIC_CHAIN;
+      const chain = privSub.assigned_at === pubSub.assigned_at ? this._defaultChain : privSub.assigned_at > pubSub.assigned_at ? PRIVATE_CHAIN : PUBLIC_CHAIN;
       this._chainCache.set(orgName, chain);
       return chain;
     }
@@ -4128,8 +4228,8 @@ var Atbash = class _Atbash {
         this.endpoint
       );
     }
-    this._chainCache.set(orgName, PUBLIC_CHAIN);
-    return PUBLIC_CHAIN;
+    this._chainCache.set(orgName, this._defaultChain);
+    return this._defaultChain;
   }
   /** Drop any cached chain resolutions. Useful in tests. */
   clearChainCache() {
@@ -4180,6 +4280,7 @@ var Atbash = class _Atbash {
   async resolveAgentLookupNetwork(options) {
     if (options.chainOpts?.network) return options.chainOpts.network;
     if (options.chainOpts?.blockchainRid) return void 0;
+    if (this._explicitChain) return this._defaultChain.network;
     const orgName = options.orgName ?? this.orgName;
     if (!orgName) return void 0;
     return (await this.resolveChainForOrg(orgName)).network;
@@ -4245,15 +4346,40 @@ var Atbash = class _Atbash {
   }
   /**
    * BRID for an org — one round-trip to the map, honoring the client's chain
-   * cache. Returns undefined when the org is unknown, so the caller falls
-   * back to the client default (best-effort discovery).
+   * cache. A "brand-new org" (nothing anywhere names its chain) is not an
+   * error — `resolveChainForOrg` returns the client default for that case and
+   * this helper returns its BRID. A transport failure or non-200 from
+   * `/api/org-network` IS an error and propagates: the caller cannot fall
+   * back to the default chain on outage, because with multi-chain live that
+   * silently reads from the wrong chain. Matches the Python binding's
+   * `_brid_for_org` semantics.
    */
   async bridForOrg(orgName) {
-    try {
-      return (await this.resolveChainForOrg(orgName)).blockchainRid;
-    } catch {
-      return void 0;
-    }
+    return (await this.resolveChainForOrg(orgName)).blockchainRid;
+  }
+  /**
+   * BRID for the client's configured default org, if it has one.
+   *
+   * Calls that carry no `orgName` argument are not chain-less: they still
+   * belong to `this.orgName`, and that org lives on exactly one chain. Routing
+   * them by the constructor's chain instead means a client configured
+   * `network: "private"` reads the private chain for an org that lives on
+   * public, and gets an empty answer rather than an error. So where an org is
+   * known the org decides the chain, and the constructor's chain is what is
+   * left when no org is known at all — the order `resolveAgentLookupNetwork`
+   * already applies to agent metadata reads, and the order the dashboard
+   * applies in `resolveChainForWallet`.
+   *
+   * Undefined when there is no default org, so callers keep falling back to
+   * the client default.
+   */
+  /** The switch's chain, unless this client named one of its own. */
+  forcedNetwork() {
+    return this._explicitChain ? void 0 : this._forcedNetwork;
+  }
+  async defaultOrgBrid() {
+    if (this._explicitChain || !this.orgName) return void 0;
+    return this.bridForOrg(this.orgName);
   }
   async raiseIfError(resp) {
     if (resp.ok) return;
@@ -4523,21 +4649,26 @@ async function scanMemory(entry, auth, opts) {
   }
   const KNOWN_ACTIONS = ["allow", "block", "hold_for_user_confirm"];
   const action = result.actionType.trim().toLowerCase();
-  if (result.verdict !== "No verdict" && !KNOWN_ACTIONS.includes(action)) {
+  if (result.verdict !== "No verdict" && action !== "" && !KNOWN_ACTIONS.includes(action)) {
     throw new Error(
-      `memory scan: unrecognized action_type from judge (${result.actionType || "absent"})`
+      `memory scan: unrecognized action_type from judge (${result.actionType})`
     );
   }
-  const mapped = native.mapVerdict(
-    action,
-    result.confidence,
-    threshold
-  );
-  let verdict = mapped;
-  if (result.verdict === "BLOCK") {
-    verdict = "red";
-  } else if (result.verdict === "HOLD" && mapped === "green") {
-    verdict = "yellow";
+  let verdict;
+  if (action === "") {
+    verdict = result.verdict === "BLOCK" ? "red" : result.verdict === "HOLD" ? "yellow" : "green";
+  } else {
+    const mapped = native.mapVerdict(
+      action,
+      result.confidence,
+      threshold
+    );
+    verdict = mapped;
+    if (result.verdict === "BLOCK") {
+      verdict = "red";
+    } else if (result.verdict === "HOLD" && mapped === "green") {
+      verdict = "yellow";
+    }
   }
   const parsed = native.parseScoreFromReason(result.reason);
   const score = result.score ?? parsed.score ?? native.defaultScoreForVerdict(verdict);
@@ -43504,10 +43635,13 @@ export {
   KEY_FILENAMES,
   MemoryGuardManager,
   MemoryIntegrityError,
+  PRIVATE_CHAIN,
+  PUBLIC_CHAIN,
   PointerStore,
   SignatureVerificationError,
   bootSyncFailureLine,
   buildAllowedJudgeHosts,
+  chainForNetwork,
   chooseKeyPath,
   claimHashHex,
   classifyMemoryRead,