@niadra/sdk 0.1.0 → 0.7.0

package/dist/langchain.js

@@ -0,0 +1,1068 @@
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
+import { SystemMessage, HumanMessage } from '@langchain/core/messages';
+import { RunnableLambda } from '@langchain/core/runnables';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+
+// src/integrations/langchain.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/errors.ts
+var NiadraError = class extends Error {
+  name = "NiadraError";
+};
+var NiadraReplayRefusedError = class extends NiadraError {
+  constructor(tool2) {
+    super(`the tool ${tool2} would run live in a replay: wrap it with tool(), or pass it through recordTools()`);
+    this.tool = tool2;
+  }
+  tool;
+  name = "NiadraReplayRefusedError";
+};
+
+// src/replay/playback.ts
+function replaying() {
+  return currentTurn()?.playback ?? null;
+}
+
+// src/usage.ts
+function get(value, name) {
+  return (typeof value === "object" || typeof value === "function") && value !== null ? value[name] : void 0;
+}
+function providerOf(model, usage) {
+  const slash = model.indexOf("/");
+  if (slash > 0) return model.slice(0, slash).trim().toLowerCase();
+  const name = model.trim().toLowerCase();
+  if (name.startsWith("claude") || `.${name}`.includes(".anthropic.")) return "anthropic";
+  if (name.startsWith("gemini")) return "google";
+  if (get(usage, "prompt_tokens") === void 0 && get(usage, "cache_read_input_tokens") !== void 0) {
+    return "anthropic";
+  }
+  return "openai";
+}
+
+// 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/langchain.ts
+var states = /* @__PURE__ */ new WeakMap();
+function stateOf(session, options) {
+  let state = states.get(session);
+  if (!state) {
+    state = { bridge: new Bridge(session, options.verify, options.agentMemory), seen: /* @__PURE__ */ new Set() };
+    states.set(session, state);
+  }
+  return state;
+}
+async function withNiadraContext(session, messages, options = {}) {
+  const state = stateOf(session, options);
+  try {
+    const last = lastHumanIndex(messages);
+    const human = messages[last];
+    if ((options.recordCustomer ?? true) && human) {
+      const text = human.text;
+      const key = `${String(last)}:${text}`;
+      if (text && !state.seen.has(key)) {
+        state.seen.add(key);
+        state.bridge.customer(text);
+      }
+    }
+    const read = await state.bridge.read();
+    state.bridge.injected(read.context);
+    const result = [...messages];
+    if (read.suffix && human) result[last] = withSuffix(human, read.suffix);
+    if (read.prefix) {
+      let position = 0;
+      while (position < result.length && result[position]?.type === "system") position++;
+      result.splice(position, 0, new SystemMessage(read.prefix));
+    }
+    return result;
+  } catch (error) {
+    state.bridge.logger.warn(`could not inject context (${errorName(error)})`);
+    return [...messages];
+  }
+}
+function niadraContext(session, options = {}) {
+  return RunnableLambda.from(async (input) => {
+    const messages = Array.isArray(input) ? input : input.messages;
+    const current = resolveSession(session);
+    return current ? withNiadraContext(current, messages, options) : [...messages];
+  }).withConfig({ runName: "niadra_context" });
+}
+var NiadraCallbackHandler = class extends BaseCallbackHandler {
+  constructor(session, options = {}) {
+    super();
+    this.session = session;
+    this.hooks = new TurnHooks("langchain", options.turns ?? false);
+    this.awaitHandlers = true;
+    this.raiseError = true;
+  }
+  session;
+  name = "niadra";
+  hooks;
+  /** Each nested run's top-level run, whose turn it records into. */
+  roots = /* @__PURE__ */ new Map();
+  /** The same handler: the turns it holds open are shared by every run it is passed to. */
+  copy() {
+    return this;
+  }
+  handleChainStart(_chain, _inputs, runId, runType, _tags, _metadata, _runName, parentRunId) {
+    this.started(runId, [runType, parentRunId].find(isRunId));
+  }
+  handleChainEnd(_outputs, runId) {
+    this.ended(runId);
+  }
+  handleChainError(error, runId) {
+    this.ended(runId, error);
+  }
+  handleChatModelStart(_llm, _messages, runId, parentRunId) {
+    this.started(runId, parentRunId);
+  }
+  handleToolStart(tool2, input, runId, parentRunId, _tags, _metadata, runName, toolCallId) {
+    if (replaying() !== null && _metadata?.[RECORDED2] !== true) {
+      throw new NiadraReplayRefusedError(runName ?? (isRecord(tool2) && typeof tool2.name === "string" ? tool2.name : "tool"));
+    }
+    const current = this.hooks.enabled ? resolveSession(this.session) : null;
+    if (!current) return;
+    const root = parentRunId === void 0 ? void 0 : this.rootOf(parentRunId);
+    this.roots.set(runId, root ?? runId);
+    const name = runName ?? (isRecord(tool2) && typeof tool2.name === "string" ? tool2.name : "tool");
+    this.hooks.toolStart(current, runId, name, parsed(input), { ...root ? { frameKey: root } : {}, callId: toolCallId ?? null });
+  }
+  handleToolEnd(output, runId) {
+    this.roots.delete(runId);
+    this.hooks.toolEnd(runId, isRecord(output) && "content" in output ? output.content : output);
+  }
+  handleToolError(error, runId) {
+    this.roots.delete(runId);
+    this.hooks.toolEnd(runId, void 0, error);
+  }
+  handleLLMEnd(output, runId) {
+    const current = resolveSession(this.session);
+    if (!current) return;
+    const bridge = states.get(current)?.bridge ?? new Bridge(current);
+    try {
+      const generation = output.generations[0]?.[0];
+      if (!generation) return;
+      const message = isRecord(generation) && "message" in generation ? generation.message : null;
+      if (message && runId !== void 0) this.model(current, message, runId);
+      const text = message ? message.text : generation.text;
+      const usage = message ? langchainUsage(message) : null;
+      bridge.agent(text, usage ? { usage } : {});
+    } catch (error) {
+      bridge.logger.warn(`could not record the agent's answer (${errorName(error)})`);
+    } finally {
+      if (runId !== void 0) this.ended(runId);
+    }
+  }
+  handleLLMError(error, runId) {
+    this.ended(runId, error);
+  }
+  started(runId, parentRunId) {
+    if (!this.hooks.enabled) return;
+    if (parentRunId !== void 0) {
+      this.roots.set(runId, this.rootOf(parentRunId));
+      return;
+    }
+    const current = resolveSession(this.session);
+    if (current) this.hooks.open(current, runId);
+  }
+  ended(runId, error) {
+    if (!this.hooks.enabled) return;
+    this.roots.delete(runId);
+    if (!this.hooks.has(runId)) return;
+    for (const [run, root] of this.roots) if (root === runId) this.roots.delete(run);
+    this.hooks.close(runId, error);
+  }
+  rootOf(runId) {
+    return this.roots.get(runId) ?? runId;
+  }
+  model(session, message, runId) {
+    if (!this.hooks.enabled) return;
+    const usage = message.usage_metadata;
+    const metadata = message.response_metadata;
+    const name = [metadata?.model_name, metadata?.model].find((value) => typeof value === "string" && value.length > 0);
+    const details = isRecord(usage) && isRecord(usage.input_token_details) ? usage.input_token_details : {};
+    this.hooks.model(
+      session,
+      name,
+      isRecord(usage) ? { in: count(usage.input_tokens), out: count(usage.output_tokens), cached: count(details.cache_read) } : {},
+      this.rootOf(runId)
+    );
+  }
+};
+var RECORDED2 = "niadra_recorded";
+function recordTools(tools, options = {}) {
+  return tools.map((item) => {
+    if (typeof item.func !== "function") throw new TypeError(`${item.name} has no function to wrap: wrap what it calls with tool()`);
+    const func = recordedTool(item.func) ? item.func : tool(item.name, item.func, { args: (input) => input, dryRun: (options.dryRun ?? []).includes(item.name) });
+    return new DynamicStructuredTool({
+      name: item.name,
+      description: item.description,
+      schema: item.schema,
+      func,
+      metadata: { ...item.metadata ?? {}, [RECORDED2]: true }
+    });
+  });
+}
+function niadraTools(session, options = {}) {
+  return new Bridge(session, void 0, options.agentMemory).tools().map(
+    (spec) => new DynamicStructuredTool({
+      name: spec.name,
+      description: spec.description,
+      schema: spec.parameters,
+      func: async (input) => spec.execute(isRecord(input) ? input : {})
+    })
+  );
+}
+function langchainUsage(message) {
+  const usage = message.usage_metadata;
+  const metadata = message.response_metadata;
+  if (!isRecord(usage)) return null;
+  const model = [metadata?.model_name, metadata?.model].find((value) => typeof value === "string" && value.length > 0);
+  const prompt = count(usage.input_tokens);
+  if (!model || prompt === null) return null;
+  const details = isRecord(usage.input_token_details) ? usage.input_token_details : {};
+  const cached = count(details.cache_read) ?? 0;
+  const written = count(details.cache_creation) ?? 0;
+  const declared = typeof metadata?.model_provider === "string" ? metadata.model_provider.toLowerCase() : "";
+  const provider = /^[a-z0-9][a-z0-9_.-]{0,63}$/.test(declared) ? declared : providerOf(model, usage);
+  return { provider, model, prompt_tokens: Math.max(prompt, cached + written), cached_tokens: cached, cache_write_tokens: written };
+}
+var RUN_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isRunId(value) {
+  return typeof value === "string" && RUN_ID.test(value);
+}
+function parsed(input) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return input;
+  }
+}
+function lastHumanIndex(messages) {
+  for (let index = messages.length - 1; index >= 0; index--) if (messages[index]?.type === "human") return index;
+  return -1;
+}
+function withSuffix(message, suffix) {
+  const content = message.content;
+  const next = typeof content === "string" ? `${content}
+
+${suffix}` : [...content, { type: "text", text: suffix }];
+  return new HumanMessage({ ...message.id ? { id: message.id } : {}, content: next });
+}
+
+export { NiadraCallbackHandler, RECORDED2 as RECORDED, attestationProof, langchainUsage, niadraContext, niadraTools, recordTools, withNiadraContext };
+//# sourceMappingURL=langchain.js.map
+//# sourceMappingURL=langchain.js.map