@niadra/sdk 0.1.0 → 0.7.0

package/dist/ai-sdk.js

@@ -0,0 +1,1030 @@
+import { tool as tool$1, jsonSchema } from 'ai';
+
+// src/integrations/ai-sdk.ts
+
+// src/constraints/binding.ts
+function parseBinding(raw, families = {}) {
+  return {
+    tool: raw.tool,
+    args: (raw.args ?? []).map((a) => ({
+      attr: a.attr,
+      param: a.param,
+      transform: a.transform ?? null,
+      negation: a.negation?.param ?? null,
+      ops: [...a.ops ?? []],
+      family: families[a.attr] ?? null
+    })),
+    overfetch: raw.overfetch ?? raw.capabilities?.overfetch ?? false
+  };
+}
+function resultItems(raw, result) {
+  const out = [];
+  for (const spec of raw.results ?? []) {
+    for (const found2 of readPath(result, spec.path ?? "$")) {
+      if (typeof found2 !== "object" || found2 === null || Array.isArray(found2)) continue;
+      const entry = found2;
+      const item = {};
+      for (const [field, key] of Object.entries(spec.fields ?? {})) if (key in entry) item[`${String(spec.type)}.${field}`] = entry[key];
+      const ident = entry[spec.id ?? "id"];
+      if (typeof ident === "string" || typeof ident === "number") item.ref = `${String(spec.type)}:${spec.namespace ?? "default"}:${String(ident)}`;
+      out.push(item);
+    }
+  }
+  return out;
+}
+function relaxed(raw, result) {
+  const path = raw.capabilities?.relax_flag;
+  return typeof path === "string" && readPath(result, path).some((v) => v === true);
+}
+function readPath(value, path) {
+  let found2 = [value];
+  const trimmed = path.replace(/^\$/, "").replace(/^\.+|\.+$/g, "");
+  if (!trimmed) return found2;
+  for (const part of trimmed.split(".")) {
+    const many = part.endsWith("[*]");
+    const key = many ? part.slice(0, -3) : part;
+    const step = [];
+    for (const current of found2) {
+      const got = key ? typeof current === "object" && current !== null ? current[key] : void 0 : current;
+      if (many) {
+        if (Array.isArray(got)) step.push(...got);
+      } else if (got !== void 0 && got !== null) step.push(got);
+    }
+    found2 = step;
+  }
+  return found2;
+}
+
+// src/claims/text.ts
+var WORD_CHARS = String.raw`\p{L}\p{N}_`;
+var SPACE_CHARS = String.raw`\t-\r\x1c-\x20\x85\xa0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000`;
+var CLASSES = { w: WORD_CHARS, d: String.raw`\p{Nd}`, s: SPACE_CHARS };
+var BOUNDARY = `(?:(?<=[${WORD_CHARS}])(?![${WORD_CHARS}])|(?<![${WORD_CHARS}])(?=[${WORD_CHARS}]))`;
+function pattern(source, flags = "") {
+  let out = "";
+  let inClass = false;
+  for (let i = 0; i < source.length; i++) {
+    const ch = source.charAt(i);
+    if (ch === "\\") {
+      const next = source.charAt(++i);
+      const chars = CLASSES[next];
+      if (chars !== void 0) out += inClass ? chars : `[${chars}]`;
+      else if (next === "b" && !inClass) out += BOUNDARY;
+      else out += next === "Z" && !inClass ? "$" : `\\${next}`;
+      continue;
+    }
+    if (ch === "[") inClass = true;
+    else if (ch === "]") inClass = false;
+    out += ch === "$" && !inClass ? String.raw`(?=\n?$)` : ch;
+  }
+  return new RegExp(out, `${flags}u`);
+}
+function memo(compute, size = 256) {
+  const cache = /* @__PURE__ */ new Map();
+  return (text) => {
+    const hit = cache.get(text);
+    if (hit !== void 0) return hit;
+    const value = compute(text);
+    const oldest = cache.keys().next();
+    if (cache.size >= size && !oldest.done) cache.delete(oldest.value);
+    cache.set(text, value);
+    return value;
+  };
+}
+var ASCII = /^\p{ASCII}*$/u;
+var MARK = /^[\p{Mn}\p{Mc}]$/u;
+function combining(c) {
+  if (!MARK.test(c)) return false;
+  const run = `\u0301${c}\u0316`;
+  return run.normalize("NFD") !== run;
+}
+function plain(text) {
+  let out = "";
+  for (const c of text.normalize("NFKD")) if (!combining(c)) out += c;
+  return out;
+}
+var fold = memo((text) => {
+  if (ASCII.test(text)) return text.toLowerCase();
+  let out = "";
+  for (const ch of text) {
+    const folded2 = plain(ch).toLowerCase();
+    out += Array.from(folded2).length === 1 ? folded2 : "?";
+  }
+  return out;
+});
+pattern(String.raw`[!?;](?=\s|$)|\.(?=\s+[A-ZÀ-Ý]|\s*$)|\n`, "g");
+
+// src/constraints/render.ts
+var SAID = /* @__PURE__ */ new Set(["stated", "tool_args", "correction"]);
+var NEGATED = /* @__PURE__ */ new Set(["not_in", "ne"]);
+var POSITIVE = /* @__PURE__ */ new Set(["in", "eq"]);
+function render(block, binding, call, mode = "advisory") {
+  if ((block.subject?.for ?? "self") !== (call.for ?? "self")) {
+    const args2 = { ...call.args };
+    return { applies: false, args: args2, suggested: {}, injected: [], hardSent: [], residual: [], postFilter: [], conflicts: [] };
+  }
+  const hard = block.hard ?? [];
+  const attributes = block.attributes ?? [];
+  const lost = new Set((block.conflicts ?? []).flatMap((c) => c.ids.filter((id) => id !== c.kept)));
+  const category = call.category ?? null;
+  const suggested = /* @__PURE__ */ new Map();
+  const sources = /* @__PURE__ */ new Map();
+  const residual = [];
+  const conflicts = [];
+  const routed = [];
+  for (const h of hard) {
+    if (lost.has(h.id) || h.category != null && h.category !== category) continue;
+    const route = routeOf(h, binding);
+    if (!route) {
+      residual.push(h.id);
+      continue;
+    }
+    const [arg, param] = route;
+    let value = shape(h.values, arg.transform);
+    if (suggested.has(param)) {
+      if (!POSITIVE.has(h.op) && !NEGATED.has(h.op)) {
+        residual.push(h.id);
+        continue;
+      }
+      const before = asList(suggested.get(param));
+      const merged = [...before, ...asList(value).filter((v) => !before.includes(v))];
+      value = merged.length === 1 ? merged[0] : merged;
+    }
+    suggested.set(param, value);
+    sources.set(param, [...sources.get(param) ?? [], h.id]);
+    routed.push([h, param]);
+    if (against(h, arg, call.args)) conflicts.push({ id: h.id, param: arg.param });
+  }
+  const asked = new Set(call.asked ?? []);
+  for (const a of attributes) {
+    const family = a.name.split(".")[0] ?? a.name;
+    if (a.category != null && a.category !== category) continue;
+    if (a.apply !== "always" && !asked.has(family) && !asked.has(a.name)) continue;
+    const carrier = binding.args.find((b) => b.family === family);
+    if (carrier && !suggested.has(carrier.param)) {
+      suggested.set(carrier.param, shape([a.value], carrier.transform));
+      sources.set(carrier.param, [a.id]);
+    }
+  }
+  if ((block.exclude ?? []).length > 0) residual.push("exclude");
+  const args = new Map(Object.entries(call.args));
+  const injected = [];
+  if (mode === "apply") {
+    const disputed = new Set(conflicts.map((c) => c.id));
+    const allowed = /* @__PURE__ */ new Set([
+      ...hard.filter((h) => SAID.has(h.source) && (h.scope === "turn" || h.scope === "session") && !disputed.has(h.id)).map((h) => h.id),
+      ...attributes.filter((a) => a.source === "stated" || a.source === "correction").map((a) => a.id)
+    ]);
+    for (const [param, value] of suggested) {
+      const ids = sources.get(param) ?? [];
+      if (!args.has(param) && ids.every((id) => allowed.has(id))) {
+        args.set(param, value);
+        injected.push(...ids);
+      }
+    }
+  }
+  const hardSent = routed.filter(([h, param]) => sent(h, param, args)).map(([h]) => h.id);
+  return {
+    applies: true,
+    args: Object.fromEntries(args),
+    suggested: Object.fromEntries(suggested),
+    injected,
+    hardSent,
+    residual,
+    postFilter: binding.overfetch ? [...residual] : [],
+    conflicts
+  };
+}
+function honored(block, sentIds, results) {
+  const checks = (block.hard ?? []).filter((h) => sentIds.includes(h.id));
+  let violations = 0;
+  let unverifiable = 0;
+  for (const item of results) {
+    if (checks.some((h) => item[h.attr] != null && !satisfies(h.op, h.values, item[h.attr]))) violations++;
+    else if (checks.some((h) => item[h.attr] == null)) unverifiable++;
+  }
+  return { resultsChecked: results.length, violations, unverifiable };
+}
+function satisfies(op, values, value) {
+  const got = keyOf(value);
+  const want = values.map(keyOf);
+  const first = want[0];
+  switch (op) {
+    case "in":
+    case "eq":
+      return want.some((w) => same(got, w));
+    case "not_in":
+    case "ne":
+      return !want.some((w) => same(got, w));
+    case "lt":
+      return holds(compare(got, first), (c) => c < 0);
+    case "lte":
+      return holds(compare(got, first), (c) => c <= 0);
+    case "gt":
+      return holds(compare(got, first), (c) => c > 0);
+    case "gte":
+      return holds(compare(got, first), (c) => c >= 0);
+    case "between":
+      return holds(compare(first, got), (c) => c <= 0) && holds(compare(got, want[1]), (c) => c <= 0);
+  }
+}
+function shape(values, transform) {
+  const out = values.map((v) => {
+    if (typeof v !== "string") return v;
+    return transform === "lower" ? v.toLowerCase() : transform === "upper" ? v.toUpperCase() : v;
+  });
+  return out.length === 1 ? out[0] : out;
+}
+function asList(value) {
+  return Array.isArray(value) ? [...value] : [value];
+}
+function routeOf(h, binding) {
+  for (const arg of binding.args) {
+    if (arg.attr !== h.attr) continue;
+    const ops = arg.ops ?? [];
+    if (POSITIVE.has(h.op) && (ops.length === 0 || ops.includes(h.op) || ops.includes("in"))) return [arg, arg.param];
+    if (NEGATED.has(h.op) && arg.negation != null) return [arg, arg.negation];
+    if (!POSITIVE.has(h.op) && !NEGATED.has(h.op) && ops.includes(h.op)) return [arg, arg.param];
+  }
+  return null;
+}
+function sent(h, param, args) {
+  if (!args.has(param)) return false;
+  const given = asList(args.get(param));
+  if (NEGATED.has(h.op)) return h.values.every((v) => satisfies("in", given, v));
+  if (POSITIVE.has(h.op)) return given.every((v) => satisfies("in", h.values, v));
+  return given.every((v) => satisfies(h.op, h.values, v));
+}
+function against(h, arg, args) {
+  if (!Object.hasOwn(args, arg.param)) return false;
+  return asList(args[arg.param]).some((v) => !satisfies(h.op, h.values, v));
+}
+var DECIMAL = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:e([+-]?\d+))?$/i;
+var OTHER = { kind: "other" };
+function keyOf(value) {
+  if (typeof value === "string") {
+    return decimal(value.trim().replace(/_/g, "")) ?? { kind: "text", text: fold(value).trim() };
+  }
+  const number = typeof value === "boolean" ? Number(value) : value;
+  return typeof number === "number" && Number.isFinite(number) ? decimal(String(number)) ?? OTHER : OTHER;
+}
+function decimal(text) {
+  const m = DECIMAL.exec(text);
+  if (!m) return null;
+  const fraction = m[3] ?? m[4] ?? "";
+  const all = `${m[2] ?? ""}${fraction}`.replace(/^0+/, "");
+  const digits = all.replace(/0+$/, "");
+  if (!digits) return { kind: "number", sign: 0, digits: "", exponent: 0 };
+  const exponent = Number(m[5] ?? 0) - fraction.length + (all.length - digits.length);
+  return { kind: "number", sign: m[1] === "-" ? -1 : 1, digits, exponent };
+}
+function same(a, b) {
+  if (a.kind === "number" && b?.kind === "number") {
+    return a.sign === b.sign && a.digits === b.digits && a.exponent === b.exponent;
+  }
+  return a.kind === "text" && b?.kind === "text" && a.text === b.text;
+}
+function compare(a, b) {
+  if (a?.kind === "text" && b?.kind === "text") return a.text < b.text ? -1 : a.text > b.text ? 1 : 0;
+  if (a?.kind !== "number" || b?.kind !== "number") return null;
+  if (a.sign !== b.sign) return a.sign < b.sign ? -1 : 1;
+  if (a.sign === 0) return 0;
+  const lead = a.digits.length + a.exponent - (b.digits.length + b.exponent);
+  if (lead !== 0) return lead * a.sign < 0 ? -1 : 1;
+  const width = Math.max(a.digits.length, b.digits.length);
+  const left = a.digits.padEnd(width, "0");
+  const right = b.digits.padEnd(width, "0");
+  return left === right ? 0 : (left < right ? -1 : 1) * a.sign;
+}
+function holds(order, test) {
+  return order !== null && test(order);
+}
+
+// src/capture/context.ts
+var chosen;
+var stores = /* @__PURE__ */ new Map();
+function storeClass() {
+  if (chosen !== void 0) return chosen;
+  try {
+    const proc = globalThis.process;
+    const hooks = proc?.getBuiltinModule?.("node:async_hooks");
+    chosen = hooks?.AsyncLocalStorage ?? null;
+  } catch {
+    chosen = null;
+  }
+  return chosen;
+}
+function store(name) {
+  const existing = stores.get(name);
+  if (existing) return existing;
+  const Class = storeClass();
+  if (!Class) return null;
+  const created = new Class();
+  stores.set(name, created);
+  return created;
+}
+
+// src/capture/frame.ts
+var turns = () => store("niadra_turn");
+function currentTurn() {
+  return turns()?.getStore();
+}
+
+// src/capture/mask.ts
+var MASKED = "[masked]";
+var WITHHELD = "[withheld: the fields this agent may read are not known yet]";
+function protect(result, access, types, onUnknown) {
+  if (access === null) return onUnknown === "block" ? WITHHELD : result;
+  const rules = /* @__PURE__ */ new Map();
+  for (const name of types ?? Object.keys(access)) {
+    for (const [field, effect] of Object.entries(access[name] ?? {})) rules.set(field, effect === "deny" || rules.get(field) === "deny" ? "deny" : effect);
+  }
+  if (rules.size === 0) return result;
+  if (typeof result === "string" && /^\s*[[{]/.test(result)) {
+    try {
+      return JSON.stringify(walk(JSON.parse(result), rules));
+    } catch {
+      return result;
+    }
+  }
+  return walk(result, rules);
+}
+function walk(value, rules) {
+  if (Array.isArray(value)) return value.map((v) => walk(v, rules));
+  if (typeof value !== "object" || value === null) return value;
+  const out = {};
+  for (const [key, v] of Object.entries(value)) {
+    const effect = rules.get(key);
+    if (effect === "deny") continue;
+    out[key] = effect === "mask" ? MASKED : walk(v, rules);
+  }
+  return out;
+}
+
+// src/capture/tool.ts
+var RECORDED = /* @__PURE__ */ Symbol.for("niadra.tool");
+function recordedTool(fn) {
+  return typeof fn === "function" ? fn[RECORDED] ?? null : null;
+}
+var isAsyncFunction = (fn) => Object.prototype.toString.call(fn) === "[object AsyncFunction]";
+function isAsyncIterator(value) {
+  return typeof value === "object" && value !== null && typeof value.next === "function" && Symbol.asyncIterator in value;
+}
+function found(frame) {
+  try {
+    return frame?.() ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function thenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+function tool(name, fn, options = {}) {
+  const isAsync = isAsyncFunction(fn);
+  function bindingOf(frame) {
+    return options.binding ?? (options.served ?? frame?.profile.bindings)?.(name) ?? null;
+  }
+  function masks(frame) {
+    return options.maskOutput ?? bindingOf(frame)?.capabilities?.mask_output ?? false;
+  }
+  function shield(result, frame) {
+    if (!masks(frame)) return result;
+    const access = options.access ?? frame?.profile.fieldAccess ?? (() => null);
+    return protect(result, access(), typesOf(result), options.onUnknown ?? "pass");
+  }
+  function typesOf(result) {
+    if (!options.provenance) return null;
+    try {
+      const found2 = options.provenance(result);
+      const items = found2 == null ? [] : Array.isArray(found2) ? found2 : [found2];
+      return items.map((o) => o.ref.split(":")[0] ?? "");
+    } catch {
+      return null;
+    }
+  }
+  function end(call, result, model = result) {
+    const observations = observed(call, result);
+    let shown;
+    if (options.ui) {
+      try {
+        shown = options.ui(result);
+      } catch {
+        call.frame.incomplete();
+      }
+    }
+    call.result(model, { ui: shown, observations });
+  }
+  function observed(call, result) {
+    if (!options.provenance) return [];
+    try {
+      const found2 = options.provenance(result);
+      if (found2 == null) return [];
+      const items = Array.isArray(found2) ? found2 : [found2];
+      return items.filter((o) => typeof o.ref === "string" && typeof o.fields === "object");
+    } catch {
+      call.frame.incomplete();
+      return [];
+    }
+  }
+  async function* pieces(call, source) {
+    const kept = [];
+    try {
+      for await (const piece of source) {
+        const shown = shield(piece, call.frame);
+        kept.push(shown);
+        yield shown;
+      }
+    } catch (error) {
+      call.failed(error);
+      throw error;
+    }
+    end(call, kept);
+  }
+  const wrapped = function(...args) {
+    const frame = currentTurn() ?? found(options.frame);
+    if (frame === void 0 || frame.closed) {
+      if (!masks(frame)) return fn.apply(this, args);
+      const out = fn.apply(this, args);
+      if (isAsyncIterator(out)) return maskedPieces(out, frame);
+      return thenable(out) ? Promise.resolve(out).then((v) => shield(v, frame)) : shield(out, frame);
+    }
+    let recorded;
+    let callId;
+    try {
+      recorded = options.args ? options.args(...args) : args.length === 1 ? args[0] : args;
+      callId = options.callId?.(...args);
+    } catch {
+      recorded = args;
+    }
+    const call = frame.adopt(name, recorded) ?? frame.toolCall(name, recorded, typeof callId === "string" && callId ? { callId } : {});
+    const binding = bindingOf(frame);
+    if (binding !== null && frame.constraints !== null) call.measure = measure(frame, binding, recorded);
+    if (frame.playback !== null) call.played = frame.playback.answer(name, recorded, options.dryRun ?? false);
+    if (call.played !== null && !call.played.live) {
+      const value = call.played.value;
+      end(call, value);
+      return isAsync ? Promise.resolve(value) : value;
+    }
+    let result;
+    try {
+      result = call.run(() => fn.apply(this, args));
+    } catch (error) {
+      call.failed(error);
+      throw error;
+    }
+    if (isAsyncIterator(result)) return pieces(call, result);
+    if (thenable(result)) {
+      return Promise.resolve(result).then(
+        (value) => {
+          const shown2 = shield(value, frame);
+          end(call, value, shown2);
+          return shown2;
+        },
+        (error) => {
+          call.failed(error);
+          throw error;
+        }
+      );
+    }
+    const shown = shield(result, frame);
+    end(call, result, shown);
+    return shown;
+  };
+  async function* maskedPieces(source, frame) {
+    for await (const piece of source) yield shield(piece, frame);
+  }
+  Object.defineProperty(wrapped, "name", { value: fn.name || name });
+  const marker = {
+    name,
+    dryRun: options.dryRun ?? false,
+    provenance: options.provenance ?? null,
+    binding: options.binding ?? null
+  };
+  Object.defineProperty(wrapped, RECORDED, { value: marker });
+  return wrapped;
+}
+function measure(frame, raw, args) {
+  const block = frame.constraints;
+  if (block === null) return null;
+  const given = typeof args === "object" && args !== null && !Array.isArray(args) ? args : {};
+  const rendering = render(block, parseBinding(raw, frame.profile.families?.() ?? {}), { args: given });
+  if (!rendering.applies) return null;
+  return (result) => {
+    const seen = honored(block, rendering.hardSent, resultItems(raw, result));
+    return {
+      constraints: block.version,
+      hard_sent: [...rendering.hardSent],
+      results_checked: seen.resultsChecked,
+      violations: seen.violations,
+      unverifiable: seen.unverifiable,
+      ...relaxed(raw, result) ? { relaxed: "declared" } : {}
+    };
+  };
+}
+
+// src/context.ts
+function emptyResult(error) {
+  return { text: "", suffix: "", variables: {}, pack: null, source: "none", response: null, error, constraints: null, state: null, coordination: null };
+}
+
+// src/integrations/shared.ts
+var ATTESTED = { A: "V2", B: "V1", C: "V1" };
+function attestationProof(attestation) {
+  if (!attestation) return null;
+  const value = attestation.trim().toUpperCase();
+  if (value.includes("FAILED") || value.startsWith("NO-")) return null;
+  const letter = value.length === 1 ? value : /PASSED-([ABC])$/.exec(value)?.[1];
+  const level = letter ? ATTESTED[letter] : void 0;
+  return level ? { method: "network_attestation", level } : null;
+}
+function resolveSession(source) {
+  if (typeof source !== "function") return source;
+  try {
+    return source() ?? null;
+  } catch {
+    return null;
+  }
+}
+function isConversation(session) {
+  return "customer" in session && typeof session.customer === "function";
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+var Bridge = class {
+  constructor(session, proof, memory = false) {
+    this.session = session;
+    this.proof = proof;
+    this.memory = memory;
+  }
+  session;
+  proof;
+  memory;
+  proving = null;
+  /** `begin()` started the first read of a call: the first `context()` waits for it with `ready()`. */
+  begun = false;
+  opened = false;
+  /**
+   * The context and, when enabled, the agent's notes, read side by side within the same budget.
+   * Never rejects.
+   */
+  async read(options = {}) {
+    const memoryParams = this.memory === false ? null : this.memory === true ? {} : withoutWrite(this.memory);
+    const [context, memory] = await Promise.all([
+      this.context(options),
+      memoryParams ? this.agentMemory(memoryParams, options) : Promise.resolve("")
+    ]);
+    return { context, memory, prefix: [memory, context.text].filter(Boolean).join("\n\n"), suffix: context.suffix };
+  }
+  get logger() {
+    return this.session.logger;
+  }
+  /**
+   * Starts the first read of a call now, in the background, after the proof when one was given (the
+   * pack depends on the level it proves): at call start, so the read runs while the call is set up.
+   * The first `context()` then waits for it within `timeouts.contextVoiceStart`. Never throws.
+   */
+  begin() {
+    const session = this.session;
+    if (!isConversation(session)) return;
+    const start = () => {
+      this.safe("start the first read", () => {
+        this.begun = session.begin();
+      });
+    };
+    if (this.proof === void 0 || this.proof === null) start();
+    else void this.verifyOnce().then(start);
+  }
+  /** Verifies once (when a proof was given), then reads the context. Never rejects. */
+  async context(options = {}) {
+    await this.verifyOnce();
+    try {
+      const session = this.session;
+      if (this.begun && !this.opened && isConversation(session)) {
+        this.opened = true;
+        await session.ready(options.timeout === void 0 ? {} : { timeout: options.timeout });
+      }
+      return await this.session.context(options);
+    } catch (error) {
+      this.logger.warn(`could not read context (${errorName(error)})`);
+      return emptyResult(null);
+    }
+  }
+  /** Records that `context` went into the prompt, unless it was empty for a reason other than the holdout. */
+  injected(context) {
+    if (!context.text && !context.suffix && context.response?.path !== "holdout") return;
+    this.safe("mark the injection", () => {
+      this.session.markInjected(context);
+    });
+  }
+  customer(text, options = {}) {
+    const session = this.session;
+    if (!text.trim() || !isConversation(session)) return;
+    this.safe("record the customer's turn", () => session.customer(text, options));
+  }
+  /** Sends the customer's turn so far, while they speak. In the background; never throws. */
+  prefetch(text) {
+    const session = this.session;
+    if (!text.trim() || !isConversation(session)) return;
+    this.safe("prefetch the turn", () => session.prefetch(text));
+  }
+  agent(text, options = {}) {
+    if (!text.trim()) return;
+    this.safe("record the agent's turn", () => this.session.agent(text, options));
+  }
+  /** Records a transfer. Tasks have no transfer; the call is ignored for them. */
+  async handoff(target, reason) {
+    const session = this.session;
+    if (!isConversation(session)) return;
+    try {
+      await session.handoff(reason ? { target, reason } : { target });
+    } catch (error) {
+      this.logger.warn(`could not record the handoff (${errorName(error)})`);
+    }
+  }
+  async end() {
+    try {
+      await this.session.end();
+    } catch (error) {
+      this.logger.warn(`could not end the session (${errorName(error)})`);
+    }
+  }
+  /** The navigation kit as plain specs (with the agent's memory tools when enabled), or none for a task about an object only. */
+  tools() {
+    let bound;
+    try {
+      const memory = this.memory;
+      bound = this.session.tools(memory === false ? {} : { agentMemory: true, writeAgentMemory: memory !== true && memory.write === true });
+    } catch (error) {
+      this.logger.warn(`could not build the tools (${errorName(error)})`);
+      return [];
+    }
+    return bound ? toolSpecs(bound) : [];
+  }
+  async agentMemory(params, options) {
+    try {
+      const result = await this.session.agentMemory(params, options.timeout === void 0 ? {} : { timeout: options.timeout });
+      return result.text;
+    } catch (error) {
+      this.logger.warn(`could not read the agent's memory (${errorName(error)})`);
+      return "";
+    }
+  }
+  async verifyOnce() {
+    if (this.proof === void 0 || this.proof === null) return;
+    this.proving ??= this.runVerify();
+    await this.proving;
+  }
+  async runVerify() {
+    try {
+      const source = this.proof;
+      const proof = typeof source === "function" ? await source() : source;
+      if (!proof) return;
+      await this.session.verify(proof);
+    } catch (error) {
+      this.logger.warn(`could not record the verification (${errorName(error)})`);
+    }
+  }
+  safe(what, run) {
+    try {
+      run();
+    } catch (error) {
+      this.logger.warn(`could not ${what} (${errorName(error)})`);
+    }
+  }
+};
+function withoutWrite(option) {
+  const { write: _, ...params } = option;
+  return params;
+}
+function toolSpecs(bound) {
+  return bound.definitions.map(({ function: definition }) => ({
+    name: definition.name,
+    description: definition.description,
+    parameters: definition.parameters,
+    execute: (args) => bound.call(definition.name, args)
+  }));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function count(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+var TurnHooks = class _TurnHooks {
+  constructor(adapter, enabled) {
+    this.adapter = adapter;
+    this.enabled = enabled;
+  }
+  adapter;
+  enabled;
+  /** Runs held open at most; past it the oldest run's turn closes, incomplete (a run whose end never came). */
+  static MAX_OPEN = 100;
+  frames = /* @__PURE__ */ new Map();
+  calls = /* @__PURE__ */ new Map();
+  /** The turn of the run `key`: the session's turn in progress, or a new one of its own. */
+  open(session, key, params = {}) {
+    if (!this.enabled) return void 0;
+    const held = this.frames.get(key);
+    if (held !== void 0) return held.frame;
+    try {
+      const active = session.activeTurn();
+      if (active !== void 0 && !this.owns(active)) {
+        this.frames.set(key, { frame: active, own: false });
+        return active;
+      }
+      const frame = session.openTurn({ ...params, adapter: this.adapter });
+      this.frames.set(key, { frame, own: true });
+      if (this.frames.size > _TurnHooks.MAX_OPEN) {
+        const [oldest] = this.frames.keys();
+        if (oldest !== void 0) {
+          this.frames.get(oldest)?.frame.incomplete();
+          this.close(oldest);
+        }
+      }
+      return frame;
+    } catch (error) {
+      session.logger.warn(`could not open the turn (${errorName(error)})`);
+      return void 0;
+    }
+  }
+  /** The turn of `key`, else the session's turn in progress. */
+  frame(session, key) {
+    if (!this.enabled) return void 0;
+    const held = key === void 0 ? void 0 : this.frames.get(key);
+    const frame = held?.frame ?? session.activeTurn();
+    return frame === void 0 || frame.closed ? void 0 : frame;
+  }
+  has(key) {
+    return this.frames.has(key);
+  }
+  owns(frame) {
+    for (const held of this.frames.values()) if (held.own && held.frame === frame) return true;
+    return false;
+  }
+  /** Ends the run `key`: a turn the adapter opened closes; the calls it left open failed. */
+  close(key, error) {
+    const held = this.frames.get(key);
+    if (held === void 0) return;
+    this.frames.delete(key);
+    for (const [callKey, call] of this.calls) {
+      if (call.frame !== held.frame) continue;
+      this.calls.delete(callKey);
+      if (held.own) call.failed(error ?? "error");
+    }
+    if (held.own) held.frame.close(error);
+  }
+  /** A tool call starting, keyed by `callKey`; `callId` is the provider's id of the call, when there is one. */
+  toolStart(session, callKey, name, args, options = {}) {
+    const frame = this.frame(session, options.frameKey);
+    if (frame === void 0) return;
+    try {
+      this.calls.set(callKey, frame.toolCall(name, args, { callId: options.callId ?? null, adoptable: true }));
+    } catch {
+      frame.incomplete();
+    }
+  }
+  /**
+   * In a replay, how a framework tool the adapter stands in for answers: the recorded result of a call with the
+   * same arguments, or empty (a divergence), never the live tool. `null` outside a replay, and for a function
+   * wrapped with `tool()`, which answers itself.
+   */
+  replayed(session, name, args, fn, frameKey) {
+    const frame = this.enabled ? this.frame(session, frameKey) : session.activeTurn();
+    if (frame?.playback == null || fn !== void 0 && recordedTool(fn) !== null) return null;
+    return frame.playback.answer(name, args, false);
+  }
+  toolEnd(callKey, result, error) {
+    const call = this.calls.get(callKey);
+    if (call === void 0) return;
+    this.calls.delete(callKey);
+    try {
+      if (error !== void 0) call.failed(error);
+      else call.result(result);
+    } catch {
+      call.frame.incomplete();
+    }
+  }
+  /** A model call that ended, with its tokens when the framework reported them. */
+  model(session, model, tokens = {}, frameKey) {
+    const frame = this.frame(session, frameKey);
+    if (frame === void 0) return;
+    try {
+      frame.modelCall(model, { tokensIn: tokens.in ?? null, tokensOut: tokens.out ?? null, tokensCached: tokens.cached ?? 0 });
+    } catch {
+      frame.incomplete();
+    }
+  }
+};
+
+// src/integrations/prompt.ts
+function injectPrompt(prompt, read) {
+  const injected = [...prompt];
+  if (read.suffix) {
+    const last = lastUserIndex(injected);
+    const message = injected[last];
+    if (isRecord(message) && Array.isArray(message.content)) {
+      injected[last] = { ...message, content: [...message.content, { type: "text", text: read.suffix }] };
+    }
+  }
+  if (read.prefix) {
+    let position = 0;
+    while (position < injected.length && roleOf(injected[position]) === "system") position++;
+    injected.splice(position, 0, { role: "system", content: read.prefix });
+  }
+  return injected;
+}
+function recordNewest(bridge, seen, prompt) {
+  const index = lastUserIndex(prompt);
+  if (index < 0) return;
+  const message = prompt[index];
+  const text = isRecord(message) ? textParts(message.content) : "";
+  const key = `${String(index)}:${text}`;
+  if (!text || seen.has(key)) return;
+  seen.add(key);
+  bridge.customer(text);
+}
+function textParts(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
+}
+function lastUserIndex(prompt) {
+  for (let index = prompt.length - 1; index >= 0; index--) if (roleOf(prompt[index]) === "user") return index;
+  return -1;
+}
+function roleOf(message) {
+  return isRecord(message) && typeof message.role === "string" ? message.role : "";
+}
+
+// src/integrations/ai-sdk.ts
+function niadraMiddleware(session, options = {}) {
+  const states = /* @__PURE__ */ new WeakMap();
+  const hooks = new TurnHooks("ai-sdk", true);
+  const modelCall = (usage, model, modelId) => {
+    const current = resolveSession(session);
+    if (!current) return;
+    const name = typeof modelId === "string" && modelId ? modelId : model.modelId;
+    const reported = aiSdkUsage(usage, model, modelId);
+    const out = isRecord(usage) ? count(usage.outputTokens) ?? (isRecord(usage.outputTokens) ? count(usage.outputTokens.total) : null) : null;
+    hooks.model(current, name, reported ? { in: reported.prompt_tokens, out, cached: reported.cached_tokens ?? 0 } : {});
+  };
+  const stateOf = () => {
+    const current = resolveSession(session);
+    if (!current) return null;
+    let state = states.get(current);
+    if (!state) {
+      state = { bridge: new Bridge(current, options.verify, options.agentMemory), seen: /* @__PURE__ */ new Set() };
+      states.set(current, state);
+    }
+    return state;
+  };
+  return {
+    specificationVersion: "v3",
+    async transformParams({ params }) {
+      const state = stateOf();
+      if (!state || !Array.isArray(params.prompt)) return params;
+      try {
+        const prompt = params.prompt;
+        if (options.recordCustomer ?? true) recordNewest(state.bridge, state.seen, prompt);
+        const read = await state.bridge.read();
+        state.bridge.injected(read.context);
+        return { ...params, prompt: injectPrompt(prompt, read) };
+      } catch (error) {
+        state.bridge.logger.warn(`could not inject context (${errorName(error)})`);
+        return params;
+      }
+    },
+    async wrapGenerate({ doGenerate, model }) {
+      const result = await doGenerate();
+      if (isRecord(result)) modelCall(result.usage, model, isRecord(result.response) ? result.response.modelId : void 0);
+      if (options.recordAgent ?? true) {
+        const state = stateOf();
+        if (state) {
+          try {
+            const content = isRecord(result) && Array.isArray(result.content) ? result.content : [];
+            const text = content.map((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? part.text : "").join("");
+            const response = isRecord(result) && isRecord(result.response) ? result.response : {};
+            record(state, text, isRecord(result) ? result.usage : void 0, model, response.modelId);
+          } catch (error) {
+            state.bridge.logger.warn(`could not capture the model's answer (${errorName(error)})`);
+          }
+        }
+      }
+      return result;
+    },
+    async wrapStream({ doStream, model }) {
+      const result = await doStream();
+      const state = options.recordAgent ?? true ? stateOf() : null;
+      if (!state || !isRecord(result) || !(result.stream instanceof ReadableStream)) return result;
+      const parts = [];
+      let usage;
+      let modelId;
+      const capture = new TransformStream({
+        transform(chunk, controller) {
+          if (isRecord(chunk)) {
+            if (chunk.type === "text-delta") parts.push(typeof chunk.delta === "string" ? chunk.delta : typeof chunk.textDelta === "string" ? chunk.textDelta : "");
+            else if (chunk.type === "finish") usage = chunk.usage;
+            else if (chunk.type === "response-metadata") modelId = chunk.modelId;
+          }
+          controller.enqueue(chunk);
+        },
+        flush() {
+          try {
+            modelCall(usage, model, modelId);
+            record(state, parts.join(""), usage, model, modelId);
+          } catch (error) {
+            state.bridge.logger.warn(`could not capture the model's answer (${errorName(error)})`);
+          }
+        }
+      });
+      return { ...result, stream: result.stream.pipeThrough(capture) };
+    }
+  };
+}
+function niadraTools(session, options = {}) {
+  const tools = {};
+  for (const spec of new Bridge(session, void 0, options.agentMemory).tools()) {
+    tools[spec.name] = tool$1({
+      description: spec.description,
+      inputSchema: jsonSchema(spec.parameters),
+      execute: async (input) => parsed(await spec.execute(input))
+    });
+  }
+  return tools;
+}
+function niadraTurn(session, params = {}) {
+  const frame = session.openTurn({ ...params, adapter: "ai-sdk" });
+  return {
+    frame,
+    run: (fn) => frame.run(fn),
+    onFinish: () => {
+      frame.close();
+    },
+    onError: (event) => {
+      frame.close(event.error);
+    },
+    onAbort: () => {
+      frame.close();
+    }
+  };
+}
+function recordTools(tools, options = {}) {
+  const out = {};
+  for (const [name, spec] of Object.entries(tools)) {
+    const execute = isRecord(spec) ? spec.execute : void 0;
+    if (typeof execute !== "function") {
+      out[name] = spec;
+      continue;
+    }
+    const dryRun = Array.isArray(options.dryRun) ? options.dryRun.includes(name) : options.dryRun === true;
+    const session = options.session;
+    out[name] = {
+      ...spec,
+      execute: tool(name, execute, {
+        args: (input) => input,
+        callId: (_input, context) => isRecord(context) && typeof context.toolCallId === "string" ? context.toolCallId : null,
+        ...session ? { frame: () => session.activeTurn() } : {},
+        dryRun
+      })
+    };
+  }
+  return out;
+}
+function aiSdkUsage(usage, model, modelId) {
+  if (!isRecord(usage)) return null;
+  const name = typeof modelId === "string" && modelId ? modelId : model.modelId;
+  const provider = model.provider?.split(".")[0]?.toLowerCase();
+  if (!name || !provider) return null;
+  let prompt;
+  let cached;
+  let written;
+  if (isRecord(usage.inputTokens)) {
+    const input = usage.inputTokens;
+    cached = count(input.cacheRead) ?? 0;
+    written = count(input.cacheWrite) ?? 0;
+    prompt = count(input.total) ?? (count(input.noCache) === null ? null : (count(input.noCache) ?? 0) + cached + written);
+  } else {
+    prompt = count(usage.inputTokens);
+    cached = count(usage.cachedInputTokens) ?? 0;
+    written = 0;
+  }
+  if (prompt === null) return null;
+  return { provider, model: name, prompt_tokens: Math.max(prompt, cached + written), cached_tokens: cached, cache_write_tokens: written };
+}
+function record(state, text, usage, model, modelId) {
+  const reported = aiSdkUsage(usage, model, modelId);
+  state.bridge.agent(text, reported ? { usage: reported } : {});
+}
+function parsed(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+export { aiSdkUsage, attestationProof, niadraMiddleware, niadraTools, niadraTurn, recordTools };
+//# sourceMappingURL=ai-sdk.js.map
+//# sourceMappingURL=ai-sdk.js.map