@niadra/sdk 0.7.0 → 0.9.1

package/dist/cli.js

@@ -503,7 +503,7 @@ function internalRecord(span, ref, act) {
 }
 
 // src/version.ts
-var VERSION = "0.7.0";
+var VERSION = "0.9.1";
 
 // src/transport.ts
 var RETRYABLE_WRITE_STATUS = /* @__PURE__ */ new Set([408, 421, 429, 500, 502, 503, 504]);
@@ -597,6 +597,7 @@ var Transport = class {
     } catch (error) {
       throw deadline.explain(error);
     }
+    warnIfDeprecated(this.config.logger, init.method ?? "GET", url, response.headers);
     const requestId = response.headers.get("x-request-id");
     let payload;
     try {
@@ -666,6 +667,29 @@ var Deadline = class {
     return new NiadraConnectionError(`connection failed: ${message}`, { cause: error });
   }
 };
+var VERSIONING_DOCS = "https://docs.niadra.com/en/security/api-versioning";
+var DEPRECATION_LINK = /<([^>]*)>[^,]*;\s*rel="?deprecation"?/gi;
+var deprecationsSeen = /* @__PURE__ */ new Set();
+function warnIfDeprecated(logger, method, url, headers) {
+  const since = headers.get("deprecation");
+  if (since === null) return;
+  const links = [...(headers.get("link") ?? "").matchAll(DEPRECATION_LINK)].map((match) => match[1] ?? "");
+  const key2 = `${method} ${links.join(" ") || (url.split("?")[0] ?? url)}`;
+  if (deprecationsSeen.has(key2)) return;
+  deprecationsSeen.add(key2);
+  const sunset = headers.get("sunset");
+  logger.warn(
+    `the API deprecated a ${method} route this client calls, since ${deprecatedSince(since)}; it stops answering on ${sunset === null ? "a date not announced yet" : sunsetDay(sunset)}. See ${links.join(", ") || VERSIONING_DOCS}`
+  );
+}
+function deprecatedSince(value) {
+  const seconds = Number(value.trim().replace(/^@/, ""));
+  return Number.isInteger(seconds) ? new Date(seconds * 1e3).toISOString().slice(0, 10) : value;
+}
+function sunsetDay(value) {
+  const time = Date.parse(value);
+  return Number.isNaN(time) ? value : new Date(time).toISOString().slice(0, 10);
+}
 async function readBody(response) {
   const text2 = await response.text();
   if (text2.length === 0) return null;
@@ -2885,6 +2909,11 @@ ${change.field}`)) out.push({ ref, field: change.field, value: change.now, claim
     for (const s of constraints.soft ?? []) said.push([s.attr, s.value]);
     for (const a of constraints.attributes ?? []) said.push([a.name, a.value]);
     for (const [attr, value] of said) out.push({ ref: null, field: attr.split(".").pop() ?? attr, value, claimSafe: true });
+    for (const shown of constraints.already_presented ?? []) {
+      for (const [field, n] of Object.entries(shown.values ?? {})) {
+        out.push({ ref: shown.ref, field, value: n.v, claimSafe: n.claim_safe, role: n.role ?? null });
+      }
+    }
   }
   return out;
 }
@@ -3251,7 +3280,7 @@ function thenable(value) {
 function tool(name, fn, options = {}) {
   const isAsync = isAsyncFunction(fn);
   function bindingOf(frame) {
-    return options.binding ?? (options.served ?? frame?.profile.bindings)?.(name) ?? null;
+    return (options.served ?? frame?.profile.bindings)?.(name) ?? null;
   }
   function masks(frame) {
     return options.maskOutput ?? bindingOf(frame)?.capabilities?.mask_output ?? false;
@@ -3366,8 +3395,7 @@ function tool(name, fn, options = {}) {
   const marker = {
     name,
     dryRun: options.dryRun ?? false,
-    provenance: options.provenance ?? null,
-    binding: options.binding ?? null
+    provenance: options.provenance ?? null
   };
   Object.defineProperty(wrapped, RECORDED, { value: marker });
   return wrapped;
@@ -3629,6 +3657,7 @@ function claimsOf(frame, claims, logger) {
 
 // src/queue.ts
 var HEARTBEAT_WINDOW_MS = 6e4;
+var MAX_PAUSE_MS = 6e4;
 var EventQueue = class {
   constructor(send, options, logger, now = Date.now) {
     this.send = send;
@@ -3649,6 +3678,8 @@ var EventQueue = class {
   droppedSinceWarning = 0;
   windowStart;
   sentInWindow = 0;
+  pauseMs = 0;
+  resumeAt = 0;
   /** Items waiting to be sent, not counting a batch already in flight. */
   get size() {
     return this.items.length;
@@ -3684,10 +3715,16 @@ var EventQueue = class {
     return run;
   }
   /**
-   * Starts a flush without waiting for it. Item failures are logged and settled inside the
-   * drain, so only an unexpected error reaches this catch.
+   * Starts a flush without waiting for it: once the pause after a failed batch ends, or at once with
+   * `now` (a caller waits for an item). Item failures are logged and settled inside the drain, so only
+   * an unexpected error reaches this catch.
    */
-  flushInBackground() {
+  flushInBackground(now = false) {
+    const paused = this.resumeAt - this.now();
+    if (!now && paused > 0) {
+      this.schedule(paused);
+      return;
+    }
     this.flush().catch((error) => {
       this.logger.error(`event flush failed: ${toNiadraError(error).message}`);
     });
@@ -3704,24 +3741,36 @@ var EventQueue = class {
     while (this.items.length > 0) {
       const batch = this.items.splice(0, this.options.maxBatchSize);
       const heartbeat = this.heartbeat();
-      const wire = batch.map((pending) => pending.item);
-      if (heartbeat) wire.push(heartbeat);
-      await this.sendBatch(batch, wire, report);
+      if (heartbeat) batch.push({ item: heartbeat });
+      if (!await this.sendBatch(batch, report)) break;
     }
     return report;
   }
-  async sendBatch(batch, wire, report) {
+  /** Sends one batch; `false` when it went back to the queue and the queue pauses. */
+  async sendBatch(batch, report) {
+    const wire = batch.map((pending) => pending.item);
     let response;
     try {
       response = await this.send(wire);
     } catch (error) {
       const failure = toNiadraError(error);
-      report.failed += batch.length;
       report.errors.push(failure);
-      this.logger.warn(`dropped ${batch.length} events after retries: ${failure.message}`);
+      if (isTransient(failure)) {
+        for (const pending of batch) pending.settle?.(failure);
+        this.requeue(batch);
+        this.pauseMs = Math.min(MAX_PAUSE_MS, Math.max(this.options.flushIntervalMs, this.pauseMs * 2));
+        this.resumeAt = this.now() + this.pauseMs;
+        this.logger.warn(`could not deliver ${batch.length} events, will retry: ${failure.message}`);
+        this.schedule(this.pauseMs);
+        return false;
+      }
+      report.failed += batch.length;
+      this.logger.warn(`dropped ${batch.length} events refused by the API: ${failure.message}`);
       for (const pending of batch) pending.settle?.(failure);
-      return;
+      return true;
     }
+    this.pauseMs = 0;
+    this.resumeAt = 0;
     const rejected = /* @__PURE__ */ new Map();
     for (const itemError of response.errors) {
       const detail = itemError.detail ? `: ${itemError.detail}` : "";
@@ -3732,6 +3781,7 @@ var EventQueue = class {
       this.logger.warn(`server rejected ${rejected.size} of ${wire.length} items (${codes2})`);
     }
     batch.forEach((pending, index) => {
+      if (pending.item.type === "heartbeat") return;
       const error = rejected.get(index) ?? null;
       if (error) {
         report.failed++;
@@ -3742,6 +3792,17 @@ var EventQueue = class {
       }
       pending.settle?.(error);
     });
+    return true;
+  }
+  /** Puts a batch back at the front, keeping only what still fits; what does not is dropped. */
+  requeue(batch) {
+    const room = Math.max(0, this.options.maxQueueSize - this.items.length);
+    const lost = batch.slice(room);
+    this.items.unshift(...batch.slice(0, room));
+    if (lost.length > 0) {
+      this.logger.warn(`event queue is full; dropped ${lost.length} events`);
+      for (const pending of lost) pending.settle?.(new NiadraError("event queue is full"));
+    }
   }
   /**
    * Once a minute, the next batch carries the number of items sent in the previous window.
@@ -3792,7 +3853,7 @@ function unref(timer) {
 var MAX_TURNS = 50;
 var COMPRESSED_ROOM = 4 * 1024 * 1024 - 64 * 1024;
 var DECODED_ROOM = 16 * 1024 * 1024 - 256 * 1024;
-var MAX_PAUSE_MS = 6e4;
+var MAX_PAUSE_MS2 = 6e4;
 var encoder2 = new TextEncoder();
 async function encode(records) {
   const raw = encoder2.encode(JSON.stringify({ turns: records }));
@@ -3951,7 +4012,7 @@ var TurnSender = class {
     }
     if (isTransient(error)) {
       this.queue.requeue(batch.frames);
-      this.pause = Math.min(MAX_PAUSE_MS, Math.max(this.intervalMs, this.pause * 2));
+      this.pause = Math.min(MAX_PAUSE_MS2, Math.max(this.intervalMs, this.pause * 2));
       this.resumeAt = this.now() + this.pause;
       this.logger.warn(`could not deliver ${batch.frames.length} turns, will retry (${toNiadraError(error).name})`);
       return false;
@@ -4339,26 +4400,42 @@ async function suppressionKey(salt, canonical) {
   const key2 = await subtle.importKey("raw", saltBytes(salt), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
   return toBase64url(new Uint8Array(await subtle.sign("HMAC", key2, new TextEncoder().encode(canonical))));
 }
+var AREA_CODES = new Set(
+  "11 12 13 14 15 16 17 18 19 21 22 24 27 28 31 32 33 34 35 37 38 41 42 43 44 45 46 47 48 49 51 53 54 55 61 62 63 64 65 66 67 68 69 71 73 74 75 77 79 81 82 83 84 85 86 87 88 89 91 92 93 94 95 96 97 98 99".split(" ")
+);
+var FORMAT_CHARACTERS = new RegExp("\\p{Cf}", "gu");
 function phone(value) {
-  const raw = value.trim().replace(SEPARATORS2, "");
-  const international = raw.startsWith("+") || raw.startsWith("00");
+  let text2 = value.normalize("NFKC").replace(FORMAT_CHARACTERS, "").trim();
+  if (text2.slice(0, 4).toLowerCase() === "tel:") text2 = text2.slice(4);
+  const international = text2.startsWith("+") || text2.startsWith("00");
+  if (international) text2 = text2.replaceAll("(0)", "");
+  const raw = text2.replace(SEPARATORS2, "");
   let digits = raw.startsWith("+") ? raw.slice(1) : international ? raw.slice(2) : raw;
   if (!DIGITS2.test(digits)) throw new NiadraDestinationError("invalid_handle");
-  const national = digits.replace(/^0+/, "");
-  if (!international && (national.length === 10 || national.length === 11) && isArea(national.slice(0, 2))) {
-    digits = `55${national}`;
+  if (!international) {
+    const national = digits.replace(/^0+/, "");
+    if (isBrazilianNational(national)) {
+      digits = `55${national}`;
+    } else if (digits.startsWith("0") && (national.length === 12 || national.length === 13)) {
+      if (isBrazilianNational(national.slice(2))) digits = `55${national.slice(2)}`;
+    }
   }
   if (digits.length < 8 || digits.length > 15 || digits.startsWith("0")) {
     throw new NiadraDestinationError("invalid_handle");
   }
   const rest = digits.slice(2);
-  if (digits.startsWith("55") && rest.length === 10 && isArea(rest.slice(0, 2)) && "6789".includes(rest.charAt(2))) {
+  if (digits.startsWith("55") && rest.length === 10 && AREA_CODES.has(rest.slice(0, 2)) && "6789".includes(rest.charAt(2))) {
     digits = `55${rest.slice(0, 2)}9${rest.slice(2)}`;
   }
+  if (digits.length === 13 && (digits.startsWith("521") || digits.startsWith("549"))) {
+    digits = digits.slice(0, 2) + digits.slice(3);
+  }
   return `phone:+${digits}`;
 }
-function isArea(code) {
-  return /^[1-9]{2}$/.test(code);
+function isBrazilianNational(national) {
+  if (!AREA_CODES.has(national.slice(0, 2))) return false;
+  if (national.length === 10) return "23456789".includes(national.charAt(2));
+  return national.length === 11 && national.charAt(2) === "9";
 }
 function saltBytes(salt) {
   const bytes = fromBase64url(salt);
@@ -4417,7 +4494,10 @@ var SuppressionCopy = class {
     }
     this.saltValue = salt;
   }
-  /** Applies one page, in order. `true` when more pages follow. */
+  /**
+   * Applies one page, in order. `true` when more pages follow: a full page. Every page carries the cursor to
+   * read from next, the last one too, which the next read starts from.
+   */
   apply(page) {
     if (page.salt_id !== this.saltValue?.salt_id) {
       this.saltValue = null;
@@ -4432,8 +4512,9 @@ var SuppressionCopy = class {
     }
     this.cursor = page.next_cursor ?? this.cursor;
     this.absent = false;
-    if (!page.next_cursor) this.readAt = this.now();
-    return Boolean(page.next_cursor);
+    const more = Boolean(page.next_cursor) && page.items.length >= PAGE;
+    if (!more) this.readAt = this.now();
+    return more;
   }
   /** A 404: the space keeps no list. Anything else: the copy stays as it is. */
   failed(error) {
@@ -4658,7 +4739,7 @@ var ContactGateway = class {
 
 // src/outbox.ts
 var CAPACITY = 1e3;
-var MAX_PAUSE_MS2 = 6e4;
+var MAX_PAUSE_MS3 = 6e4;
 var Outbox = class {
   constructor(logger, intervalMs = 1e3, now = Date.now) {
     this.logger = logger;
@@ -4726,7 +4807,7 @@ var Outbox = class {
       answer = await write.send();
     } catch (error) {
       if (isTransient(error)) {
-        this.pause = Math.min(MAX_PAUSE_MS2, Math.max(this.intervalMs, this.pause * 2));
+        this.pause = Math.min(MAX_PAUSE_MS3, Math.max(this.intervalMs, this.pause * 2));
         this.resumeAt = this.now() + this.pause;
         return false;
       }
@@ -5509,6 +5590,11 @@ var ContextCache = class {
     }
     return true;
   }
+  /** Milliseconds since the server last sent or confirmed the pack held for `key`; `null` when none is held. */
+  age(key2) {
+    const entry = this.entries.get(key2);
+    return entry ? this.now() - entry.confirmedAt : null;
+  }
   /** The cached pack's ETag, without touching the order of eviction. */
   etag(key2) {
     return this.entries.get(key2)?.response.etag ?? null;
@@ -5702,7 +5788,7 @@ function mergeNotModified(cached, fresh) {
     coordination: fresh.coordination ?? cached.coordination ?? null
   };
 }
-function resultFrom(response, source, error = null) {
+function resultFrom(response, source, error = null, ageMs = 0) {
   const holdout = response.path === "holdout";
   const text2 = holdout ? "" : response.text ?? "";
   const pack = holdout ? null : response.pack ?? null;
@@ -5711,10 +5797,10 @@ function resultFrom(response, source, error = null) {
     state: response.state ?? null,
     coordination: response.coordination ?? null
   };
-  return { text: text2, suffix: renderSuffix(response), variables: response.variables, pack, source, response, error, ...blocks2 };
+  return { text: text2, suffix: renderSuffix(response), variables: response.variables, pack, source, ageMs, response, error, ...blocks2 };
 }
 function emptyResult(error) {
-  return { text: "", suffix: "", variables: {}, pack: null, source: "none", response: null, error, constraints: null, state: null, coordination: null };
+  return { text: "", suffix: "", variables: {}, pack: null, source: "none", ageMs: null, response: null, error, constraints: null, state: null, coordination: null };
 }
 function renderSuffix(response) {
   if (response.path === "holdout") return "";
@@ -8410,7 +8496,8 @@ var Niadra = class _Niadra {
       baseURL,
       apiKey,
       fetch: fetchImpl,
-      defaultHeaders: options.defaultHeaders ?? {}
+      defaultHeaders: options.defaultHeaders ?? {},
+      logger: this.logger
     });
     const queueOptions = { ...DEFAULT_QUEUE, ...options.queue };
     queueOptions.maxBatchSize = Math.min(queueOptions.maxBatchSize, 499);
@@ -8507,19 +8594,29 @@ var Niadra = class _Niadra {
    */
   async mayContact(handle, purpose, options = {}) {
     if (this.core && this.suppressions.due()) {
-      const read2 = this.suppressions.read(
-        {
-          salt: () => this.api.suppressionSalt({ timeout: this.timeouts.navigation }),
-          page: (cursor, limit2) => this.api.suppressions({ cursor, limit: limit2 }, { timeout: this.timeouts.navigation })
-        },
-        this.suppressions.held ? this.timeouts.write : this.timeouts.navigation
-      );
+      const read2 = this.readSuppressions(this.suppressions.held ? this.timeouts.write : this.timeouts.navigation);
       if (!this.suppressions.held) await read2;
     }
     const checkOptions = { channel: options.channel ?? null };
     if (options.failOpen !== void 0) checkOptions.failOpen = options.failOpen;
     return this.suppressions.mayContact(handle, purpose, checkOptions);
   }
+  readSuppressions(budgetMs) {
+    return this.suppressions.read(
+      {
+        salt: () => this.api.suppressionSalt({ timeout: this.timeouts.navigation }),
+        page: (cursor, limit2) => this.api.suppressions({ cursor, limit: limit2 }, { timeout: this.timeouts.navigation })
+      },
+      budgetMs
+    );
+  }
+  /**
+   * Reads the local copy of the suppression list in the background when it is due: a check that Niadra does not
+   * answer falls back on it, so an opt-out holds through an outage.
+   */
+  keepSuppressions() {
+    if (this.core && this.suppressions.due()) void this.readSuppressions(this.timeouts.write);
+  }
   /**
    * The build a turn runs on, for `conversation.turn({ build })`: each prompt's version, the digest of the
    * corpus the agent consults (computed by you, never the files), the model, your context assembler's version
@@ -8593,7 +8690,10 @@ var Niadra = class _Niadra {
       states: this.states,
       contract: () => this.currentContract(),
       internalText: this.internalText,
-      check: (request, timeoutMs) => this.api.check(request, { timeout: timeoutMs }),
+      check: (request, timeoutMs) => {
+        if (request.direction === "outbound") this.keepSuppressions();
+        return this.api.check(request, { timeout: timeoutMs });
+      },
       claim: (request, timeoutMs) => this.api.claim(request, {}, { timeout: timeoutMs }),
       verifyClaim: (ref, field, value, options) => this.verifyClaim(ref, field, value, options),
       enabled: this.enabled,
@@ -8707,21 +8807,21 @@ var Niadra = class _Niadra {
     }
     const key2 = cacheKey(request);
     const hit = cache.lookup(key2);
-    if (hit?.freshness === "fresh") return resultFrom(delivered(hit.response, cache.take(key2)), "cache");
+    if (hit?.freshness === "fresh") return resultFrom(delivered(hit.response, cache.take(key2)), "cache", null, cache.age(key2));
     if (hit?.freshness === "stale") {
       this.revalidate(core, cache, key2, scope, request, timeout, options.headers).catch((error) => {
         this.logger.debug(`background context refresh failed: ${describe(toNiadraError(error))}`);
       });
-      return resultFrom(delivered(hit.response, cache.take(key2)), "stale");
+      return resultFrom(delivered(hit.response, cache.take(key2)), "stale", null, cache.age(key2));
     }
     try {
       const pending = this.revalidate(core, cache, key2, scope, request, timeout, options.headers);
       const { response, source } = await abortable(pending, options.signal);
-      return resultFrom(delivered(response, cache.take(key2)), source);
+      return resultFrom(delivered(response, cache.take(key2)), source, null, source === "network" ? 0 : cache.age(key2));
     } catch (error) {
       const failure = toNiadraError(error);
       const fallback2 = cache.lookup(key2);
-      return this.contextFailure(failure, fallback2 ? delivered(fallback2.response, cache.take(key2)) : null);
+      return this.contextFailure(failure, fallback2 ? delivered(fallback2.response, cache.take(key2)) : null, cache.age(key2));
     }
   }
   /**
@@ -8743,11 +8843,11 @@ var Niadra = class _Niadra {
       const failure = toNiadraError(error);
       this.observeAuth(failure, key2);
       const fallback2 = cache && key2 ? cache.lookup(key2) : null;
-      return this.contextFailure(failure, cache && key2 && fallback2 ? delivered(fallback2.response, cache.take(key2)) : null);
+      return this.contextFailure(failure, cache && key2 && fallback2 ? delivered(fallback2.response, cache.take(key2)) : null, key2 ? cache?.age(key2) ?? null : null);
     }
     if (!cache || !key2 || !scope) return resultFrom(response, "network");
     if (response.degraded && !response.not_modified && cached) {
-      return resultFrom(delivered({ ...cached.response, slots: response.slots ?? null }, cache.take(key2)), "fallback");
+      return resultFrom(delivered({ ...cached.response, slots: response.slots ?? null }, cache.take(key2)), "fallback", null, cache.age(key2));
     }
     const merged = response.not_modified && cached ? mergeNotModified(cached.response, response) : response;
     cache.store(key2, scope, withoutSlots(merged), generation);
@@ -9249,11 +9349,11 @@ var Niadra = class _Niadra {
       }
     });
   }
-  contextFailure(error, fallback2) {
+  contextFailure(error, fallback2, ageMs = null) {
     if (this.strict) throw error;
     if (fallback2) {
       this.logger.warn(`context request failed, serving the last good pack: ${describe(error)}`);
-      return resultFrom(fallback2, "fallback", error);
+      return resultFrom(fallback2, "fallback", error, ageMs);
     }
     this.logger.warn(`context unavailable: ${describe(error)}`);
     return emptyResult(error);
@@ -9354,11 +9454,11 @@ var Niadra = class _Niadra {
         });
       }
       const response = compose(delivered(hit.response, cache.take(key2)), chosen2);
-      return resultFrom(response, opening.length > 0 ? "network" : hit.freshness === "fresh" ? "cache" : "stale");
+      return resultFrom(response, opening.length > 0 ? "network" : hit.freshness === "fresh" ? "cache" : "stale", null, cache.age(key2));
     } catch (error) {
       const failure = toNiadraError(error);
       const fallback2 = cache.lookup(key2);
-      return this.contextFailure(failure, fallback2 ? delivered(fallback2.response, cache.take(key2)) : null);
+      return this.contextFailure(failure, fallback2 ? delivered(fallback2.response, cache.take(key2)) : null, cache.age(key2));
     }
   }
   /** Starts one read of a line in the background. */
@@ -9501,7 +9601,7 @@ var Niadra = class _Niadra {
         else resolve({ ok: false, idempotency_key: key2, error });
       };
       core.queue.push(item, settle2);
-      core.queue.flushInBackground();
+      core.queue.flushInBackground(true);
     });
   }
   async endScope(item, scope) {
@@ -9971,7 +10071,8 @@ var Counterfactual = class {
     const fn = this.tools[tool2];
     if (fn === void 0) throw new NiadraError(`no function for the tool ${tool2}: pass it in tools`);
     if (!Number.isInteger(k) || k < 1 || k > MAX_K) throw new RangeError(`k must be 1 to ${String(MAX_K)}`);
-    await this.niadra.profile();
+    const raw = await this.served(tool2);
+    if (raw === null) throw new NiadraError(`the space binds no tool ${tool2} for this key's source: see its tool-bindings`);
     const ids = [...turnIds];
     if ((options.scenarioIds ?? []).length > 0) {
       const found2 = await this.niadra.callRoute({ method: "GET", path: "/v1/scenarios", query: { ids: (options.scenarioIds ?? []).join(","), limit: 50 } });
@@ -9989,7 +10090,7 @@ var Counterfactual = class {
         continue;
       }
       for (const call of calls(record, tool2)) {
-        const found2 = await this.case(record, call, fn, element, k);
+        const found2 = await this.case(record, call, fn, raw, element, k);
         if (found2 === null) run.untouched++;
         else run.cases.push(found2);
       }
@@ -9999,17 +10100,15 @@ var Counterfactual = class {
     run.report = await this.niadra.callRoute({ method: "POST", path: "/v1/measure/counterfactual-runs", body: report });
     return run;
   }
-  async case(record, call, fn, element, k) {
+  async case(record, call, fn, raw, element, k) {
     const base = { turn_id: record.turn_id, call_id: call.call_id };
     const tool2 = String(call.name);
     const wrapped = recordedTool(fn);
-    const raw = this.options.bindings?.[tool2] ?? wrapped?.binding ?? await this.served(tool2);
     let block;
     let args;
     try {
       block = await this.value(record, blockBlob(record, call));
       args = { ...await this.value(record, call.args) };
-      if (raw === null) throw new BlobError("the tool has no binding");
     } catch {
       return { ...base, status: "infrastructure_error", dry_run: false };
     }
@@ -11008,7 +11107,6 @@ async function counterfactual(argv, io) {
       element: { type: "string" },
       turn: { type: "string", multiple: true, default: [] },
       scenario: { type: "string", multiple: true, default: [] },
-      bindings: { type: "string" },
       safe: { type: "string", multiple: true, default: [] },
       k: { type: "string", default: "10" },
       label: { type: "string" }
@@ -11018,8 +11116,7 @@ async function counterfactual(argv, io) {
   if (!["constraints", "hard", "size", "exclude"].includes(values.element)) throw new Error(`--element ${values.element}: constraints, hard, size or exclude`);
   if (values.turn.length === 0 && values.scenario.length === 0) throw new Error("--turn or --scenario is needed");
   const tools = await load(values.tools);
-  const bindings = values.bindings === void 0 ? void 0 : await load(values.bindings);
-  const run = await new Counterfactual(io.client(), tools, { ...bindings ? { bindings } : {}, safe: values.safe }).run(values.turn, {
+  const run = await new Counterfactual(io.client(), tools, { safe: values.safe }).run(values.turn, {
     tool: values.tool,
     element: values.element,
     scenarioIds: values.scenario,