attenu-guard 0.3.1 → 0.5.0

package/dist/cjs/reasons.js

@@ -11,7 +11,7 @@
  * the Python library's `attenu_guard.reasons` value for value.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decision = exports.Reason = exports.DISPOSITIONS = exports.Disposition = exports.ReasonCode = void 0;
+exports.Decision = exports.Reason = exports.CompletionResult = exports.BODY_STATES = exports.BodyState = exports.CAPTURES = exports.Capture = exports.DISPOSITIONS = exports.Disposition = exports.ReasonCode = void 0;
 /**
  * Stable string constants for machine-readable denial reasons. Never rename an
  * existing value; add new ones instead.
@@ -37,6 +37,14 @@ exports.ReasonCode = {
     CHAIN_CEILING: "chain_ceiling",
     /** The principal holds no authority at all in this chain. */
     NO_AUTHORITY: "no_authority",
+    // 0.9.0 execution-binding transition (schema_version=2 chains only — see guard.ts):
+    /** `check` refused: the node already called `complete()`. */
+    NODE_FINALIZED: "node_finalized",
+    /**
+     * The CSPRNG failed while allocating `callId`; fail-closed — the call is denied and
+     * nothing is written.
+     */
+    CALL_ID_UNAVAILABLE: "call_id_unavailable",
 };
 /**
  * WHY a denied scope was not in the node's authority — the ledger's answer to
@@ -54,6 +62,74 @@ exports.Disposition = {
     OUT_OF_AUTHORITY: "out_of_authority",
 };
 exports.DISPOSITIONS = new Set(Object.values(exports.Disposition));
+/**
+ * What the adapter's code path WILL observe for a given `check`ed call (0.9.0 execution binding)
+ * — recorded on the `allow` entry alongside `adapter` (module/version/hookPath). Describes
+ * observation CAPABILITY only, never a claim of quality: a verifier routes a call into
+ * observed/unobserved reporting from this label, never trusts it as evidence on its own.
+ */
+exports.Capture = {
+    /** The adapter's wrapper calls the body itself, synchronously. */
+    WRAPPER_SYNC: "wrapper_sync",
+    /** ... and awaits it. */
+    WRAPPER_ASYNC: "wrapper_async",
+    /** The framework itself calls back after the body runs. */
+    FRAMEWORK_POST_HOOK: "framework_post_hook",
+    /** The adapter sees the call authorized but never observes it finish. */
+    PRE_HOOK_ONLY: "pre_hook_only",
+};
+exports.CAPTURES = new Set(Object.values(exports.Capture));
+/**
+ * The `outcome` record's observation of how a body-owning wrapper's call ended (0.9.0 execution
+ * binding, docs/execution-binding spec section 3) — an OBSERVATION, not a judgment about the
+ * world. There is no `executed`/`blocked`/`timeout`/`cancelled` at this layer; each of those
+ * words claims knowledge a wrapper does not always have. Adapters emitting into a richer outcome
+ * vocabulary own that mapping.
+ */
+exports.BodyState = {
+    /** The body returned to the wrapper. */
+    RETURNED: "returned",
+    /** It raised (`errorCode` required, from the exception's class/constructor name). */
+    RAISED: "raised",
+    /** The wrapper stopped observing while the body may still run. */
+    ABANDONED: "abandoned",
+    /** The wrapper returned a generator/stream/future it does not itself consume. */
+    DEFERRED: "deferred",
+};
+exports.BODY_STATES = new Set(Object.values(exports.BodyState));
+/**
+ * `Guard.complete()`'s return value on a `schemaVersion: 2` chain ONLY (0.9.0, docs/
+ * execution-binding spec section 1): whether the node was actually finalized, and — when it
+ * refused because calls are still pending an outcome — the `callId`s it is waiting on. On a
+ * `schemaVersion: 1` chain (the default), `complete()` returns a plain `boolean`,
+ * byte-and-type IDENTICAL to every release before 0.9.0 — v1 never gained pending-call
+ * awareness, so there is nothing new for it to report and no reason to change its return type
+ * (mirrors attenu-guard Python's merge-gate fix restoring this exact split).
+ *
+ * Python's v2 return value is bool-coercible via `__bool__`, so `if guard.complete():` keeps
+ * reading naturally there. JavaScript has no such hook for `if` — `ToBoolean` on any object is
+ * unconditionally `true`, so on v2 an `if (guard.complete())` check cannot be bridged to `false`
+ * no matter what this class defines, and neither can `assert.equal`/`assert.strictEqual` from
+ * `node:assert/strict` (no coercion at all). What CAN be bridged: `valueOf()` returns
+ * `.completed`, so contexts that genuinely coerce via `==`/`!=` (loose equality), template
+ * literals, and arithmetic still read as a boolean. On v2, read `.completed` explicitly wherever
+ * you would have written `if (guard.complete())`.
+ */
+class CompletionResult {
+    completed;
+    pendingCallIds;
+    constructor(completed, pendingCallIds = []) {
+        this.completed = completed;
+        this.pendingCallIds = pendingCallIds;
+    }
+    valueOf() {
+        return this.completed;
+    }
+    toString() {
+        return String(this.completed);
+    }
+}
+exports.CompletionResult = CompletionResult;
 /** One specific cause of a denial. */
 class Reason {
     code;
@@ -107,10 +183,18 @@ class Decision {
     allowed;
     reasons;
     determiningNode;
-    constructor(allowed, reasons = [], determiningNode = null) {
+    callId;
+    constructor(allowed, reasons = [], determiningNode = null, 
+    /**
+     * 0.9.0 execution binding: set only on a `schemaVersion: 2` chain (`Guard.check` /
+     * `Guard.recordDenial`); `null` on schema-version-1 chains and on any `Decision` built
+     * outside a `Guard` transition (`wouldAllow`, tests).
+     */
+    callId = null) {
         this.allowed = allowed;
         this.reasons = reasons;
         this.determiningNode = determiningNode;
+        this.callId = callId;
     }
     /** A single human-readable line — for logs, CLIs and error messages. */
     explain() {
@@ -120,12 +204,24 @@ class Decision {
             return "denied";
         return "denied: " + this.reasons.map((r) => r.toString()).join("; ");
     }
+    /**
+     * `callId` is included only when set (a `schemaVersion: 2` chain's `check`/`recordDenial`) — a
+     * v1 Decision's serialized shape stays byte-and-key identical to every release before 0.9.0,
+     * never gaining a `call_id: null` key it never had.
+     */
     toDict() {
-        return {
+        const d = {
             allowed: this.allowed,
             reasons: this.reasons.map((r) => r.toDict()),
             determining_node: this.determiningNode,
         };
+        if (this.callId !== null)
+            d["call_id"] = this.callId;
+        return d;
+    }
+    /** A copy of this Decision with `callId` set — mirrors Python's `dataclasses.replace`. */
+    withCallId(callId) {
+        return new Decision(this.allowed, this.reasons, this.determiningNode, callId);
     }
     static allow(node = null) {
         return new Decision(true, [], node);

package/dist/cjs/reasons.js.map

@@ -1 +1 @@
-{"version":3,"file":"reasons.js","sourceRoot":"","sources":["../../src/reasons.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reasons.js","sourceRoot":"","sources":["../../src/reasons.ts"],"names":[],"mappings":"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"}

package/dist/cjs/version.d.ts

@@ -0,0 +1,10 @@
+/**
+ * version.ts — the package version, as its own leaf module.
+ *
+ * guard.ts needs this (to attribute a guard-supplied `adapter.version` on a bare `check()` with
+ * no wrapper — see the "Execution binding" section of guard.ts's module doc comment) and is
+ * itself imported BY index.ts, so index.ts cannot be the source: `guard.ts -> index.ts ->
+ * guard.ts` would be circular. A one-constant leaf module has nothing to be circular with.
+ */
+export declare const VERSION = "0.5.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/cjs/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/dist/cjs/version.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+/**
+ * version.ts — the package version, as its own leaf module.
+ *
+ * guard.ts needs this (to attribute a guard-supplied `adapter.version` on a bare `check()` with
+ * no wrapper — see the "Execution binding" section of guard.ts's module doc comment) and is
+ * itself imported BY index.ts, so index.ts cannot be the source: `guard.ts -> index.ts ->
+ * guard.ts` would be circular. A one-constant leaf module has nothing to be circular with.
+ */
+exports.VERSION = "0.5.0";
+//# sourceMappingURL=version.js.map

package/dist/cjs/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACU,QAAA,OAAO,GAAG,OAAO,CAAC"}

package/dist/esm/adapters/langgraph.d.ts

@@ -35,6 +35,85 @@
  * this adapter does not prescribe which. It guarantees only that the tool body
  * never executes on a denial.
  *
+ * ## Execution binding (0.9.0, reference wiring for this adapter)
+ *
+ * When `guard`'s chain was issued with `schemaVersion: 2` (see `Guard.issue`), `guardNode` also
+ * passes `capture`/`adapter`/`authorizedParams` to `check` and calls `guard.recordOutcome` once
+ * the wrapped callable finishes — `Capture.WRAPPER_ASYNC` when `fn` is a genuine `async function`
+ * (`fn.constructor.name === "AsyncFunction"`, the same test Python's `inspect.iscoroutinefunction`
+ * makes), `Capture.WRAPPER_SYNC` otherwise. `authorizedParams`/`invokedParams` are
+ * `{args: [...]}` built from exactly what the wrapped callable is called with — JavaScript has no
+ * separate `kwargs`, so unlike the Python adapter's `{args, kwargs}` this carries only `args`; a
+ * LangGraph.js node in any case receives one state object, not Python's `(*args, **kwargs)`. They
+ * are unchanged between the two observations here, since this decorator itself never mutates
+ * them; a framework that DOES mutate arguments between authorization and invocation is where a
+ * real substitution would become visible. On a `schemaVersion: 1` chain (the default), this
+ * adapter behaves exactly as it did before 0.9.0: no `capture`/`authorizedParams`, no
+ * `recordOutcome` call. Every other framework adapter is unchanged in this release.
+ *
+ * ## Adversarial review: the Python batch-1/batch-2 defect classes, checked against this
+ * adapter specifically (not assumed absent by analogy)
+ *
+ * The Python `attenu-guard` adapters went through two rounds of adversarial review that found
+ * several defect classes across their (many) framework adapters. This TS package ships exactly
+ * ONE adapter surface (this file — verified against `package.json`'s own `exports` map, which
+ * declares nothing besides `.` and `./adapters/langgraph`), so each class was checked against
+ * THIS adapter specifically, not inherited by assumption:
+ *
+ * - **Composable middleware / sibling short-circuit or retry** (a sibling wrapper positioned
+ *   closer to the tool body than this one, able to fabricate or repeat what it observes) — NOT
+ *   APPLICABLE. Verified directly against pinned `@langchain/core@1.2.9` and
+ *   `@langchain/langgraph@1.4.13` (installed and grepped, not read off documentation): zero
+ *   `"middleware"` hits anywhere near tool invocation in either package, and
+ *   `ToolNode.prototype.runTool` (`dist/prebuilt/tool_node.js`) calls `tool.invoke(toolCall,
+ *   runtime)` directly — `guardTool`'s `Proxy` IS what gets called, nothing sits between it and
+ *   `ToolNode`. Neither framework has a composable per-call hook chain the way LangChain-Python's
+ *   `create_agent(middleware=[...])` or AG2's `FunctionTool.register()` do.
+ * - **Double authorization via a second, independent gate** (e.g. Python's `claude_sdk`
+ *   adapter's `can_use_tool` calling `authorize()` a second time for the same call) — NOT
+ *   APPLICABLE. There is no second entry point here: `guardNode`/`guardTool` are each the ONLY
+ *   caller-facing wrapper for their call, and there is nothing in either framework analogous to
+ *   a second permission callback for a call this adapter already gated.
+ * - **Snapshot double-evaluation / narrow-projection commitment** — NOT APPLICABLE in the
+ *   double-evaluation shape (`snapshotParams`/`snapshotToolParams` already compute ONE snapshot,
+ *   reused unchanged for both `authorizedParams` and `invokedParams`), but a DIFFERENT,
+ *   TS-specific gap in the same family was found and fixed — see `freeze()`'s own doc comment
+ *   above and the CHANGELOG.
+ * - **Correlation-key collision across hooks** (e.g. Python's `claude_sdk` `tool_use_id`
+ *   collision) — NOT APPLICABLE. `guard.recordOutcome` is called synchronously inside the same
+ *   closure that owns the whole call, from `authorize()`'s own returned `Decision.callId` — no
+ *   external pending-map keyed by a framework-supplied correlation id exists to collide on.
+ * - **Lazy-result detection gaps** (e.g. Python's `smolagents` adapter missing a coroutine or a
+ *   `concurrent.futures.Future`) — `isDeferredResult` catches generators (an object with its own
+ *   `.next` AND `[Symbol.iterator]` — "self-iterating", the shape a native generator has, but
+ *   deliberately NOT the shape a plain `Array`/`Set`/`Map` has, since those implement
+ *   `[Symbol.iterator]` too without an own `.next`, and their contents are already fully
+ *   computed), a genuine ASYNC ITERABLE (anything implementing a callable
+ *   `[Symbol.asyncIterator]`, self-iterating async generators included — see the RELEASE-GATE
+ *   CORRECTION on this function's own body for why this does NOT require an own `.next` the way
+ *   the sync branch does), and anything thenable. A plain (non-`async`) function that manually
+ *   returns a bare `Promise` is also caught correctly, via the thenable check, in the sync
+ *   branch of both wrappers. This is NOT a claim of covering "the whole lazy-result landscape" —
+ *   only what this function's own checks actually implement, listed above; a class implementing
+ *   some OTHER deferred-consumption protocol this function does not check for would not be
+ *   caught.
+ * - **Lost-terminal-event / "fires unconditionally" false claims** (e.g. Python's `strands`
+ *   adapter's before-hook interrupt paths) — NOT APPLICABLE. There is no external, multi-phase
+ *   hook-dispatch loop for an event to be lost across; one wrapper function's own `try`/`catch`
+ *   (or `await`ed async path) owns authorize-through-`recordOutcome` for the whole call
+ *   synchronously. Structurally this adapter was already closest to Python's own `langgraph.py`
+ *   reference wiring, not any of the adapters that needed this class of fix.
+ * - **Unbounded correlation cache** (Python's `claude_sdk` `_recentVerdicts`) — NOT APPLICABLE,
+ *   for the same reason as the correlation-collision point above: no cache or pending-map exists
+ *   in this adapter to bound.
+ * - **Wrong dependency declaration** (Python's `semantic-kernel` `protobuf` lesson: check what
+ *   the RESOLVED version actually requires, not what is assumed) — checked: `src/` imports only
+ *   `@langchain/langgraph` (lazily, in `isLangGraphAvailable()`); it never imports
+ *   `@langchain/core` at all (only this file's own tests do, to build fixtures). `package.json`
+ *   declares zero `dependencies` and no `peerDependencies` — matching the README's own "zero
+ *   runtime dependencies" claim — and both `@langchain/core`/`@langchain/langgraph` are correctly
+ *   `devDependencies`-only. Nothing this package's `src/` needs at runtime is undeclared.
+ *
  * ## Delegation
  *
  * Handing work to a sub-agent is the delegation moment. `delegateTo` mints the
@@ -51,8 +130,9 @@
  */
 import { type Guard } from "../guard.js";
 import type { Authority } from "../authority.js";
+import type { Json } from "../canonical.js";
 import type { Context } from "../ceilings.js";
-import type { Decision } from "../reasons.js";
+import { type Decision } from "../reasons.js";
 /** Options shared by every guarded wrapper. */
 export interface GuardOptions {
     /**
@@ -74,6 +154,129 @@ export type GuardedNode<F extends (...args: any[]) => any> = F & {
     readonly toolScope: string;
     readonly unwrapped: F;
 };
+/**
+ * A private, freeze()-only sentinel for "could not be represented as a JSON leaf" — a Proxy, an
+ * accessor property, a genuine cycle, a boxed primitive, a TypedArray, a function, or anything
+ * else this module does not know how to rebuild as plain JSON. NEVER a JSON-representable
+ * value (a string, `null`, …): a second release-gate finding showed a literal string sentinel
+ * (`"<accessor>"`) genuinely COLLIDES — a real getter-bearing object and a plain object holding
+ * the literal string `"<accessor>"` produced the IDENTICAL `authorizedParamsHash`, an
+ * evidence-integrity ambiguity in a supposedly cryptographic commitment (two materially
+ * different inputs, one commitment). A fresh, private `Symbol` cannot equal any real call
+ * argument, so it cannot collide with one — and it makes the SAME degradation apply uniformly
+ * everywhere this function cannot represent something, rather than inventing a new
+ * JSON-shaped sentinel (with its own collision risk) per case.
+ *
+ * Declared as `Json` even though a `Symbol` is not one — a deliberate escape from that type's
+ * nominal domain, not an oversight: `canonical.ts`'s own JCS `serialize()` already runtime-checks
+ * `typeof` for exactly this reason (its switch handles `"undefined"`/`"bigint"`/`"symbol"`/
+ * `"function"` despite `CJson`'s declared type not admitting any of them either), because the
+ * type system cannot fully describe this module's actual runtime domain. Once this sentinel
+ * reaches `params.ts`'s `commit()` — inside a plain object or array, same as any other frozen
+ * leaf — `canonicalBytes` hits that `"symbol"` case, throws `UnsupportedTypeError`, and `commit()`
+ * turns that into `paramsHashReason: "unsupported"` for the WHOLE params value, never a partial
+ * or per-field one: there is no such thing as "this one nested field is unsupported," only
+ * "this whole call's arguments are, or are not, representable."
+ *
+ * Exported for the same reason `freeze` itself is: not part of this adapter's semantic
+ * contract, but its own tests need to assert directly that a given leaf became this exact
+ * sentinel (by identity — nothing else can equal it) rather than inferring it indirectly.
+ */
+export declare const FREEZE_UNSUPPORTED: Json;
+/**
+ * A genuinely immutable, fully decoupled rebuild of `value` — the ONE, UNCONDITIONAL sanitizer
+ * every snapshot in this adapter goes through. Safe JSON-primitive leaves
+ * (`string`/`number`/`boolean`/`null`) pass through verbatim; plain objects and arrays are
+ * rebuilt fresh, recursively, by inspecting their REAL own property descriptors directly
+ * (`Object.getOwnPropertyDescriptor`), never by invoking anything the value itself controls (a
+ * getter, an iterator, a copy protocol, a Proxy trap, a `toString`/`valueOf`/`Symbol.toPrimitive`
+ * override); anything this function cannot represent becomes `UNSUPPORTED` (above) — never a
+ * string, never the live object.
+ *
+ * RELEASE-GATE CORRECTION (CRITICAL): this used to run ONLY as a fallback, after
+ * `structuredClone` had already been tried and had THROWN — the previous revision of this
+ * comment documented that carefully, but never asked whether `structuredClone` SUCCEEDING was
+ * itself a sufficient guarantee. It is not, on three counts, each reproduced directly before
+ * that fix: (1) a circular object clones successfully — `structuredClone` handles cycles
+ * natively — so this function never ran on it at all, and the circularity later reached
+ * `params.ts`'s own cycle-guard-less hash walk and crashed with `RangeError`; (2) a sparse
+ * array clones successfully too, bypassing this function's own densification; (3) a
+ * `SharedArrayBuffer` clones to a DISTINCT wrapper object sharing the SAME underlying memory —
+ * a "successful" clone that is not independent at all. Fixed by making this function the ONLY
+ * snapshot path, unconditionally — `structuredClone` is not called anywhere in this adapter.
+ *
+ * A SECOND release-gate pass then found that "pure introspection" was not fully true either —
+ * three more code-execution paths, all reproduced directly before this fix:
+ *
+ *   1. A `Proxy` is not inert under reflection. `Object.getPrototypeOf`, `Object.keys`
+ *      (`[[OwnPropertyKeys]]` + a `[[GetOwnProperty]]` per key to check enumerability), and
+ *      `Object.getOwnPropertyDescriptor` are each real, user-definable traps — reproduced
+ *      directly: walking an ordinary handler-tracked Proxy through the OLD version of this
+ *      function fired four separate traps before authorization was ever decided. `Array.isArray`
+ *      is worse: called on a REVOKED Proxy, it throws `TypeError` outright (its spec algorithm,
+ *      `IsArray`, unwraps `[[ProxyTarget]]`, which does not exist on a revoked handle) —
+ *      reproduced directly. Fixed: `require("node:util").types.isProxy(value)` recognizes a
+ *      Proxy — live OR revoked — via an internal engine slot, invoking NOTHING (verified
+ *      directly: zero trap calls, no throw on a revoked handle either) — checked FIRST, before
+ *      `Array.isArray` or any other reflection, and routed straight to `UNSUPPORTED`.
+ *   2. The bottom fallback used `String(value)` for anything not a plain object/array — a boxed
+ *      primitive (`new Number(...)`) with a hostile `Symbol.toPrimitive`, or a `TypedArray` with
+ *      a hostile own `toString`, each ran attacker code exactly once per snapshot, reproduced
+ *      directly both ways — BEFORE `Guard.check` had decided allow or deny. The same is true, in
+ *      principle, of ANY object-typed exotic value (a function's own `.toString` is just as
+ *      overridable) — there is no way to distinguish "safe to stringify" from "hostile" by
+ *      inspection alone, so none of them are stringified any more. Fixed: every value that is
+ *      not a safe JSON primitive and not a plain object/array — a Proxy, a boxed primitive, a
+ *      TypedArray/`ArrayBuffer`/`SharedArrayBuffer`/`DataView`, a `Map`/`Set`/`Date`/`RegExp`, a
+ *      function, a `Symbol`, a `BigInt`, anything else — becomes `UNSUPPORTED` (never `String()`,
+ *      never any other protocol) — see the confirmed-good note above: stringification itself
+ *      was never unsafe as a RESULT (a `SharedArrayBuffer` never retained live memory as a
+ *      string), the defect was invoking attacker-controlled code to PRODUCE that string before
+ *      authorization ran, and `UNSUPPORTED` avoids that entirely rather than picking a "safer"
+ *      string.
+ *   3. Any OTHER reflection failure — an exotic value this pass did not specifically anticipate,
+ *      still throwing from `Object.getPrototypeOf`/`Object.keys`/`Object.getOwnPropertyDescriptor`
+ *      despite the Proxy check above — must degrade the same way, not propagate an exception out
+ *      of a snapshot taken before authorization. The whole reflective walk (everything past the
+ *      Proxy/primitive fast paths) runs inside one `try`/`catch`; any throw there becomes
+ *      `UNSUPPORTED` too.
+ *
+ * `active` is the PATH-ACTIVE cycle guard: the set of containers on the CURRENT recursion path,
+ * passed as a NEW `Set` at each recursive call rather than mutated in place and shared across
+ * sibling branches (an earlier revision DID share one mutable `WeakSet` across the whole call,
+ * which meant a DAG's repeated reference — the SAME object appearing twice as sibling values,
+ * never as its own ancestor — was wrongly flagged on its second occurrence; reproduced directly
+ * before that fix too). A genuine cycle's own leaf value is `UNSUPPORTED`, not a literal string
+ * `"<circular>"` — audited for the same collision class as `"<accessor>"` below, and it has the
+ * identical problem: a self-referential object and a plain object holding the literal string
+ * `"<circular>"` would otherwise produce the same commitment. There is no position-based reason
+ * a cycle's collision is any less real than an accessor's, so it gets the same fix.
+ *
+ * The property-descriptor walk ALSO closes a separate, protocol-driven gap: the previous
+ * revision used `Array.from`/`.map()` (which invoke `[Symbol.iterator]()` — a hostile array's
+ * own override can yield ANYTHING regardless of its real indexed properties; reproduced
+ * directly: `[1, , 3]` with a hostile iterator froze as `[999]`) and `Object.entries()` (which
+ * reads each property's VALUE directly, invoking a getter if one is defined there — reproduced
+ * directly: a getter with a side effect was observed three times across the old clone-attempt/
+ * freeze/body sequence, and the committed snapshot was the SECOND of three observations, not the
+ * first). `Object.getOwnPropertyDescriptor` and a `.length`-bounded index loop are pure
+ * introspection — they never invoke user code — and an accessor property (`.get`/`.set` present)
+ * becomes `UNSUPPORTED` rather than read at all: a getter can have arbitrary side effects, throw,
+ * or return something different on every call, so there is no single "correct" observation of it
+ * to commit, and (release-gate correction) the earlier `"<accessor>"` string sentinel this
+ * function used instead genuinely collided — reproduced directly: a real getter-bearing object
+ * and a plain object holding the literal string `"<accessor>"` produced the identical
+ * `authorizedParamsHash`. Both now degrade the same commitment to `unsupported` via `UNSUPPORTED`
+ * (see its own doc comment above), never a JSON-representable stand-in.
+ *
+ * Exported — not part of this adapter's semantic contract (it is an internal sanitizer, not a
+ * feature callers configure), but its own aliasing-safety invariant is worth a direct unit
+ * test in isolation, the same way every Python adapter's `_freeze()` is imported directly by
+ * its own tests: the audit log never exposes the raw snapshot value it produces (only its
+ * hash — see `params.ts`'s own doc comment), so "does this alias a live mutable object" is
+ * not otherwise observable from outside this module.
+ */
+export declare function freeze(value: unknown, active?: ReadonlySet<unknown>): Json;
 /**
  * Wrap a callable so every call is authorized through `guard` first.
  *
@@ -81,7 +284,9 @@ export type GuardedNode<F extends (...args: any[]) => any> = F & {
  * `guard.check(toolScope, {context, tool})`. On a denial this throws
  * `AuthorityDenied` and the wrapped callable is NEVER invoked. Otherwise it
  * calls through with the original arguments and returns the result unchanged —
- * including a promise, which is passed along untouched.
+ * including a promise, which is passed along untouched. On a `schemaVersion: 2`
+ * guard, also binds the call's outcome via `guard.recordOutcome` — see the
+ * module doc comment's "Execution binding" section.
  *
  * Use the Guard for the SPECIFIC agent this callable belongs to, not the
  * orchestrator's broader one, so a denial reflects that node's real, narrowed
@@ -125,7 +330,13 @@ export interface GuardToolOptions extends GuardOptions {
  * The context function receives the raw invoke arguments. `ToolNode` passes a
  * tool call object, so the arguments the model proposed are at `input.args`;
  * a direct `tool.invoke({...})` passes them at the top level. `toolArgs` below
- * reads either shape.
+ * reads either shape — and, on a `schemaVersion: 2` guard, feeds a single
+ * IMMUTABLE snapshot taken BEFORE `tool.invoke` runs, reused for both
+ * `authorizedParams` and `invokedParams`: this adapter's closest analogue of "the
+ * exact tool-call JSON object" the execution-binding spec names (see the module
+ * doc comment's "Execution binding" section; this is the one construct in this
+ * adapter that wraps a tool BODY, so it is the reference wiring for
+ * `recordOutcome`, mirroring `guardNode` above).
  */
 export declare function guardTool<T extends ToolLike>(guard: Guard, tool: T, options?: GuardToolOptions): T;
 /** Marker properties, so a caller can tell a guarded tool from a bare one. */

package/dist/esm/adapters/langgraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"langgraph.d.ts","sourceRoot":"","sources":["../../../src/adapters/langgraph.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"langgraph.d.ts","sourceRoot":"","sources":["../../../src/adapters/langgraph.ts"],"names":[],"mappings":"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"}