salt-agent-sdk 0.20.0 → 0.22.0

package/dist/lattice.d.ts

@@ -0,0 +1,206 @@
+import { type SaltId } from "./ids.js";
+/**
+ * How long request_personal_data waits for a release before reporting
+ * "pending" instead of "released". This bounds how long ONE chat turn keeps
+ * whoever's waiting on the agent hanging -- it is NOT protecting against
+ * Salt's own webhook delivery timeout: webhook.ts acknowledges salt-api's
+ * POST before ever calling dispatch(), so nothing here is on the clock for
+ * that deadline. A "pending" result past this is the normal case, not an
+ * error -- see actions.ts's request_personal_data and onRelease/
+ * onLatticeRelease for what happens when the answer arrives afterward.
+ */
+export declare const LATTICE_REQUEST_TIMEOUT_MS = 15000;
+export declare const REQUEST_MARKER_RE: RegExp;
+export declare const RELEASE_MARKER_RE: RegExp;
+export declare const PROPOSE_MARKER_RE: RegExp;
+export interface LatticeFact {
+    path: string;
+    type: string;
+    field: string;
+    /** A JSON primitive (string/number/boolean/null) -- normalizeFact rejects an object or array here. */
+    value: string | number | boolean | null;
+    /** "you" or "agent" -- WHICH agent wrote it is deliberately never disclosed (PROTOCOL.md). */
+    author: "you" | "agent";
+    updated: number;
+}
+/** The JSON body of a [[SALT-LATTICE-RELEASE]] message, either shape (a
+ *  reply to one request, or a standing push -- see the module comment). */
+export interface ReleaseBody {
+    facts: LatticeFact[];
+    /** Present on an ordinary reply to a request; absent on a standing push. */
+    request_id?: string;
+    /** Present only on a standing push. */
+    grant_id?: string;
+    /** Present only on a standing push: facts changed since this sequence number. */
+    since_seq?: number;
+}
+export interface LatticeRelease {
+    /** The release message's own id (for the disclosure log) -- NOT the request id it answers. */
+    id: string;
+    /** Set to a grant id for a standing push; absent for an ordinary reply. */
+    standing?: string;
+    /** The chat and sender this release actually arrived from (Salt-authenticated, not attacker-controlled). */
+    chatId: SaltId;
+    senderId: SaltId;
+    body: ReleaseBody;
+}
+export interface BuildRequestInput {
+    /** One plain sentence, shown to the person before they decide -- PROTOCOL.md's Request. */
+    purpose: string;
+    /** Selectors, e.g. "preferences.food.cuisine.*" -- only what the agent's grant names is ever released; asking for more is not an error. */
+    asks: string[];
+}
+/**
+ * Mints a fresh request id and its wire text. Send `text` as an ordinary
+ * encrypted chat message into the current chat (or the agent's private
+ * lane); the phone answers it -- in a group, inside a sidechain it opens
+ * with this agent, never in the room (PROTOCOL.md R6).
+ */
+export declare function buildRequest(input: BuildRequestInput): {
+    id: string;
+    text: string;
+};
+export interface LatticeProposalInput {
+    /** A closed-schema type name (PROTOCOL.md) -- an unknown type or field is silently dropped on the phone, never an error here or there. */
+    type: string;
+    parent_name?: string;
+    fields: Record<string, unknown>;
+}
+/**
+ * Builds a [[SALT-LATTICE-PROPOSE]] message suggesting new facts. Always
+ * lands `pending` on the phone unless the agent's grant trusts its writes
+ * to that compartment (PROTOCOL.md R3) -- there is no reply to wait for,
+ * so unlike buildRequest this returns only the wire text.
+ */
+export declare function buildProposal(proposals: LatticeProposalInput[]): string;
+/** A single release's fact count is capped here -- not rejected outright,
+ *  just bounded, since an over-long but otherwise well-formed release isn't
+ *  a protocol violation the way a malformed entry is (see normalizeFact). */
+export declare const MAX_FACTS_PER_RELEASE = 200;
+/** A fact's string value is capped to this many characters, after marker
+ *  stripping (see sanitizeFactValue) -- bounds how much untrusted text from
+ *  the other end of the wire can reach a model in one fact. */
+export declare const MAX_FACT_VALUE_LENGTH = 2000;
+/**
+ * Splits an incoming plaintext into its release marker's id, optional
+ * standing grant id, and parsed JSON body -- or null when `plaintext` isn't
+ * a (well-formed, in-protocol) lattice release at all. Returns null for an
+ * unparseable or malformed body, and also for a body that is neither an
+ * ordinary reply (`request_id`) nor a standing push (`standing=` on the
+ * marker line AND `grant_id` in the body) -- PROTOCOL.md says a release is
+ * "always a reply to a request id" unless it's a standing push, so anything
+ * else is out-of-protocol. Deliberate in all these cases: it's safer to let
+ * a corrupt or nonsensical release fall through as ordinary (harmless)
+ * message text than to silently act on it. A standing push's marker-line
+ * `standing=<grant id>` and its body's `grant_id` must name the SAME grant
+ * -- PROTOCOL.md's own example shows them matching, and disagreeing values
+ * are simply invalid rather than a case to guess between (whoever
+ * eventually checks `grant_id` against this agent's actual grants -- see
+ * webhook.ts's onLatticeRelease verification -- must be checking the one
+ * value the marker itself also claims).
+ */
+export declare function parseRelease(plaintext: string): {
+    id: string;
+    standing?: string;
+    body: ReleaseBody;
+} | null;
+export declare function hasPending(id: string): boolean;
+export interface RegisterBinding {
+    /** The chat the request was actually sent into. */
+    chatId: SaltId;
+    /** The person the request was actually addressed to -- see actions.ts's request_personal_data, which resolves this to one specific chat member even in a group. */
+    senderId: SaltId;
+    timeoutMs: number;
+}
+/**
+ * Registers a wait for the release answering request `id`, bound to the
+ * exact chat and person it was sent to. Only a release arriving from THAT
+ * chat and THAT sender can resolve it (see classifyRelease) -- a request's
+ * plaintext id is visible to every current member of the chat it's sent
+ * into (see actions.ts), so the id alone must never be sufficient to claim
+ * a release.
+ *
+ * Resolves with that release's parsed body, or rejects once `timeoutMs`
+ * elapses -- rejecting is an expected outcome, not a protocol error:
+ * PROTOCOL.md says the phone only answers when the app is next open, which
+ * routinely outlasts one webhook round-trip. Throws synchronously (before
+ * any caller does anything else) if `id` already has a pending wait.
+ */
+export declare function register(id: string, binding: RegisterBinding): Promise<ReleaseBody>;
+/**
+ * Clears a pending wait without settling its promise -- used when sending
+ * the request message itself fails right after register() ran, so the
+ * registry entry doesn't leak (the caller throws its own error instead).
+ */
+export declare function cancel(id: string): void;
+type ReleaseHandler = (release: LatticeRelease) => void | Promise<void>;
+/**
+ * Subscribes to releases that arrive with nothing waiting on them: a late
+ * reply (the request already timed out) or a standing push (there was
+ * never a request to begin with). Returns an unsubscribe function.
+ *
+ * UNVERIFIED: lattice.ts has no REST client and no concept of a grant, so a
+ * handler here fires for ANY sender in ANY chat with no check that they
+ * actually hold a live grant to this agent. webhook.ts's `onLatticeRelease`
+ * option is the verified, recommended path for exactly this case (it
+ * fetches this agent's live grants and checks the sender is human and,
+ * for a standing push, that `grant_id` names one, before ever calling your
+ * handler) -- reach for this lower-level hook only if you're bypassing
+ * webhook.ts entirely, and do your own equivalent check.
+ *
+ * A handler may be async. Either a synchronous throw or a rejected promise
+ * is swallowed -- like every other fire-and-forget hook in this SDK, a bug
+ * in a consumer's handler must not take down webhook processing (an
+ * unhandled rejection crashes the process on modern Node defaults).
+ */
+export declare function onRelease(handler: ReleaseHandler): () => void;
+export type ReleaseOutcome = {
+    kind: "not-a-release";
+} | {
+    kind: "matched";
+} | {
+    kind: "refused";
+} | {
+    kind: "unmatched";
+    release: LatticeRelease;
+};
+/**
+ * Call right after decrypting an inbound message, before deciding whether
+ * to run a fresh reply cycle -- the same spot webhook.ts calls
+ * delegations.resolveIfPending (and what webhook.ts itself calls, to also
+ * learn about an "unmatched" release for its onLatticeRelease option).
+ *
+ * - "not-a-release": `plaintext` isn't lattice wire protocol at all --
+ *   including this identity's own outgoing requests/proposals, which never
+ *   match RELEASE_MARKER_RE, and any genuinely unrelated message.
+ * - "matched": `chatId`/`senderId` agree with a live register() wait for
+ *   this release's `request_id` -- that wait's promise is resolved directly;
+ *   there is nothing further for a caller to do.
+ * - "refused": this release names a request id a wait IS pending for, but
+ *   `chatId`/`senderId` don't match what register() bound it to -- e.g. a
+ *   bystander who merely saw the plaintext request id (see
+ *   RegisterBinding's doc comment) replaying it as a forged release. The
+ *   live wait is untouched (still running, still resolvable by the real
+ *   answer); this message is left for the caller to process as ordinary,
+ *   harmless text -- it must NOT be treated as Lattice traffic.
+ * - "unmatched": a genuine late reply or standing push -- fired to
+ *   onRelease() before this returns.
+ */
+export declare function classifyRelease(chatId: SaltId, senderId: SaltId, plaintext: string): ReleaseOutcome;
+/**
+ * Boolean convenience wrapper over classifyRelease, mirroring
+ * delegations.resolveIfPending(chatId, senderId, plaintext)'s shape for a
+ * simple caller that doesn't need an "unmatched" release's details (e.g. a
+ * custom integration built directly on lattice.ts, without webhook.ts).
+ * True for "matched" and "unmatched" (don't treat `plaintext` as a fresh
+ * prompt); false for "not-a-release" AND "refused" (a forged/misdirected
+ * release is left to fall through exactly like ordinary text, same as
+ * "not-a-release" -- see classifyRelease's doc comment).
+ *
+ * webhook.ts itself calls classifyRelease directly instead of this, since
+ * it also needs an "unmatched" release's details (chat/sender/body) to
+ * offer to its own onLatticeRelease option.
+ */
+export declare function resolveIfPending(chatId: SaltId, senderId: SaltId, plaintext: string): boolean;
+export {};
+//# sourceMappingURL=lattice.d.ts.map

package/dist/lattice.d.ts.map

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

package/dist/lattice.js

@@ -0,0 +1,366 @@
+"use strict";
+// Lets a hosted identity ask the person it's chatting with for personal
+// facts from Lattice -- their private, on-device knowledge graph -- and get
+// an answer back over a real Salt message, the same way delegations.ts gets
+// a reply from another agent. See ../../salt-lattice/docs/PROTOCOL.md for
+// the wire contract this implements; nothing here decides WHETHER a fact is
+// released (that is entirely the phone's own grant evaluation, offline and
+// invisible to the server) -- this module only builds the outgoing
+// markers, parses the incoming one, and matches a release back to the
+// request it answers.
+//
+// Three message shapes ride inside encrypted plaintext, one line then a
+// JSON body, exactly like [[SALT-DELEGATION]]:
+//   [[SALT-LATTICE-REQUEST id=<ulid>]]                        agent -> person, asking
+//   [[SALT-LATTICE-RELEASE id=<ulid> [standing=<grant id>]]]  person's phone -> agent, answering
+//   [[SALT-LATTICE-PROPOSE id=<ulid>]]                        agent -> person's phone, suggesting a fact
+//
+// A release is matched back to its request by `request_id` IN ITS JSON BODY
+// -- never by the release's own `id`, which only identifies that one
+// disclosure for the log -- AND by the chat and sender it was actually
+// registered against (see register()/classifyRelease()). A request's
+// plaintext id is visible to every current member of whatever chat it was
+// sent into (see actions.ts's request_personal_data), so a request id alone
+// is not a secret; the chat+sender binding is what stops a bystander who
+// merely SAW that id from forging a release and having it accepted as the
+// real recipient's answer.
+//
+// Three outcomes a release-shaped message can produce, besides "not a
+// release at all" (see ReleaseOutcome/classifyRelease):
+//   - matched: chat and sender agree with what register() bound to this
+//     request id. Resolves that wait's promise directly; nothing else to do.
+//   - refused: names a request id this process really is waiting on, but
+//     the chat or the sender don't match the binding -- a forged or
+//     misdirected release. The live wait keeps waiting; this message is
+//     left for the caller to fall through as ordinary (harmless) text.
+//   - unmatched (late or standing): a release-shaped message with no live
+//     wait to resolve -- either a genuinely late reply (the request already
+//     timed out; the phone only answers when the app is next open, which
+//     routinely outlasts one webhook round-trip) or an opted-in standing
+//     push, which never had a request to begin with. Unlike "matched",
+//     THIS module never authenticates who sent it -- lattice.ts has no
+//     REST client and no concept of a grant. Reaches onRelease() (raw,
+//     unverified) and, via webhook.ts's onLatticeRelease option, a
+//     consumer's own follow-up logic -- webhook.ts is what verifies the
+//     sender is human and holds a live grant (and, for standing, that it's
+//     the grant named) before that option ever fires, dropping and logging
+//     otherwise. Reaching onRelease/onLatticeRelease at all is not itself a
+//     trust signal.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_FACT_VALUE_LENGTH = exports.MAX_FACTS_PER_RELEASE = exports.PROPOSE_MARKER_RE = exports.RELEASE_MARKER_RE = exports.REQUEST_MARKER_RE = exports.LATTICE_REQUEST_TIMEOUT_MS = void 0;
+exports.buildRequest = buildRequest;
+exports.buildProposal = buildProposal;
+exports.parseRelease = parseRelease;
+exports.hasPending = hasPending;
+exports.register = register;
+exports.cancel = cancel;
+exports.onRelease = onRelease;
+exports.classifyRelease = classifyRelease;
+exports.resolveIfPending = resolveIfPending;
+const ids_js_1 = require("./ids.js");
+/**
+ * How long request_personal_data waits for a release before reporting
+ * "pending" instead of "released". This bounds how long ONE chat turn keeps
+ * whoever's waiting on the agent hanging -- it is NOT protecting against
+ * Salt's own webhook delivery timeout: webhook.ts acknowledges salt-api's
+ * POST before ever calling dispatch(), so nothing here is on the clock for
+ * that deadline. A "pending" result past this is the normal case, not an
+ * error -- see actions.ts's request_personal_data and onRelease/
+ * onLatticeRelease for what happens when the answer arrives afterward.
+ */
+exports.LATTICE_REQUEST_TIMEOUT_MS = 15_000;
+// Embed ULID_RE's character class without its ^...$ anchors, so the id
+// group inside each marker regex stays in lock-step with what newUlid()
+// actually produces.
+const ULID_SRC = ids_js_1.ULID_RE.source.slice(1, -1);
+exports.REQUEST_MARKER_RE = new RegExp(`^\\[\\[SALT-LATTICE-REQUEST id=(${ULID_SRC})\\]\\]\\n`, "i");
+exports.RELEASE_MARKER_RE = new RegExp(`^\\[\\[SALT-LATTICE-RELEASE id=(${ULID_SRC})(?: standing=(\\S+))?\\]\\]\\n`, "i");
+exports.PROPOSE_MARKER_RE = new RegExp(`^\\[\\[SALT-LATTICE-PROPOSE id=(${ULID_SRC})\\]\\]\\n`, "i");
+/**
+ * Mints a fresh request id and its wire text. Send `text` as an ordinary
+ * encrypted chat message into the current chat (or the agent's private
+ * lane); the phone answers it -- in a group, inside a sidechain it opens
+ * with this agent, never in the room (PROTOCOL.md R6).
+ */
+function buildRequest(input) {
+    const id = (0, ids_js_1.newUlid)();
+    const body = JSON.stringify({ purpose: input.purpose, asks: input.asks });
+    return { id, text: `[[SALT-LATTICE-REQUEST id=${id}]]\n${body}` };
+}
+/**
+ * Builds a [[SALT-LATTICE-PROPOSE]] message suggesting new facts. Always
+ * lands `pending` on the phone unless the agent's grant trusts its writes
+ * to that compartment (PROTOCOL.md R3) -- there is no reply to wait for,
+ * so unlike buildRequest this returns only the wire text.
+ */
+function buildProposal(proposals) {
+    const id = (0, ids_js_1.newUlid)();
+    const body = JSON.stringify({ proposals });
+    return `[[SALT-LATTICE-PROPOSE id=${id}]]\n${body}`;
+}
+const FACT_AUTHORS = new Set(["you", "agent"]);
+// PROTOCOL.md's exact fact shape. Validated field-by-field, not just "facts
+// is an array": a forged or buggy release could otherwise hand a model
+// whatever shape it likes under `facts[]`, and (pre-binding-fix) that used
+// to reach a calling tool's "released" result unfiltered. One malformed
+// entry rejects the WHOLE body (returns null), the same fail-closed
+// convention as an unparseable body -- a partially-trusted release is worse
+// than a dropped one.
+function isPrimitive(value) {
+    return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+/** A single release's fact count is capped here -- not rejected outright,
+ *  just bounded, since an over-long but otherwise well-formed release isn't
+ *  a protocol violation the way a malformed entry is (see normalizeFact). */
+exports.MAX_FACTS_PER_RELEASE = 200;
+/** A fact's string value is capped to this many characters, after marker
+ *  stripping (see sanitizeFactValue) -- bounds how much untrusted text from
+ *  the other end of the wire can reach a model in one fact. */
+exports.MAX_FACT_VALUE_LENGTH = 2_000;
+// Every wire marker this SDK recognizes starts with this exact two-bracket
+// prefix, anchored at the very start of a plaintext (see the *_MARKER_RE
+// definitions above -- none of them carry the `m` flag). A fact's value is
+// untrusted content from the other end of the wire; without this, a value
+// containing literal "[[SALT-...]]" text could later start some OTHER
+// outbound message built by echoing the fact back (e.g. "the person's
+// favorite cuisine is <value>") and be mistaken for a genuine protocol
+// marker by whatever receives it. Breaks the bracket pair rather than
+// deleting the text outright, so the value stays legible.
+const MARKER_TEXT_RE = /\[\[SALT-/g;
+function sanitizeFactValue(value) {
+    if (typeof value !== "string")
+        return value;
+    const stripped = value.replace(MARKER_TEXT_RE, "[SALT-");
+    return stripped.length > exports.MAX_FACT_VALUE_LENGTH ? stripped.slice(0, exports.MAX_FACT_VALUE_LENGTH) : stripped;
+}
+function normalizeFact(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const f = raw;
+    if (typeof f.path !== "string" || typeof f.type !== "string" || typeof f.field !== "string")
+        return null;
+    if (typeof f.author !== "string" || !FACT_AUTHORS.has(f.author))
+        return null;
+    if (typeof f.updated !== "number")
+        return null;
+    if (!isPrimitive(f.value))
+        return null;
+    return { path: f.path, type: f.type, field: f.field, value: sanitizeFactValue(f.value), author: f.author, updated: f.updated };
+}
+function normalizeReleaseBody(parsed) {
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const obj = parsed;
+    if (!Array.isArray(obj.facts))
+        return null;
+    const facts = [];
+    for (const raw of obj.facts) {
+        const fact = normalizeFact(raw);
+        if (!fact)
+            return null;
+        facts.push(fact);
+    }
+    const body = { facts: facts.slice(0, exports.MAX_FACTS_PER_RELEASE) };
+    if (typeof obj.request_id === "string")
+        body.request_id = obj.request_id;
+    if (typeof obj.grant_id === "string")
+        body.grant_id = obj.grant_id;
+    if (typeof obj.since_seq === "number")
+        body.since_seq = obj.since_seq;
+    return body;
+}
+/**
+ * Splits an incoming plaintext into its release marker's id, optional
+ * standing grant id, and parsed JSON body -- or null when `plaintext` isn't
+ * a (well-formed, in-protocol) lattice release at all. Returns null for an
+ * unparseable or malformed body, and also for a body that is neither an
+ * ordinary reply (`request_id`) nor a standing push (`standing=` on the
+ * marker line AND `grant_id` in the body) -- PROTOCOL.md says a release is
+ * "always a reply to a request id" unless it's a standing push, so anything
+ * else is out-of-protocol. Deliberate in all these cases: it's safer to let
+ * a corrupt or nonsensical release fall through as ordinary (harmless)
+ * message text than to silently act on it. A standing push's marker-line
+ * `standing=<grant id>` and its body's `grant_id` must name the SAME grant
+ * -- PROTOCOL.md's own example shows them matching, and disagreeing values
+ * are simply invalid rather than a case to guess between (whoever
+ * eventually checks `grant_id` against this agent's actual grants -- see
+ * webhook.ts's onLatticeRelease verification -- must be checking the one
+ * value the marker itself also claims).
+ */
+function parseRelease(plaintext) {
+    const match = exports.RELEASE_MARKER_RE.exec(plaintext);
+    if (!match)
+        return null;
+    const [full, id, standing] = match;
+    let parsed;
+    try {
+        parsed = JSON.parse(plaintext.slice(full.length));
+    }
+    catch {
+        return null;
+    }
+    const body = normalizeReleaseBody(parsed);
+    if (!body)
+        return null;
+    if (standing) {
+        if (!body.grant_id || !(0, ids_js_1.sameId)(body.grant_id, standing))
+            return null;
+        return { id, standing, body };
+    }
+    if (!body.request_id)
+        return null;
+    return { id, body };
+}
+// Keyed by REQUEST id (the id a request_personal_data call minted and put
+// in the marker it sent) -- NOT by chat, unlike delegations.ts's registry,
+// which is chat-scoped because a chat can only be mid-delegation with one
+// target at a time. A person can plausibly be asked several independent
+// things in parallel (different tool calls, possibly from different hosted
+// identities sharing this process), so the request id is what safely tells
+// two pending waits apart.
+//
+// Lowercased on every store/lookup -- like delegations.ts's own `mapKey` and
+// ids.ts's `sameId`, whose comments say why: an id can cross this SDK's
+// boundary (webhook body, REST response, a phone's own JSON) without a
+// casing guarantee, and RELEASE_MARKER_RE already matches either case
+// (ULID_RE's `/i` flag), so the map lookup that follows it must too.
+const pending = new Map();
+const mapKey = (id) => id.toLowerCase();
+function hasPending(id) {
+    return pending.has(mapKey(id));
+}
+/**
+ * Registers a wait for the release answering request `id`, bound to the
+ * exact chat and person it was sent to. Only a release arriving from THAT
+ * chat and THAT sender can resolve it (see classifyRelease) -- a request's
+ * plaintext id is visible to every current member of the chat it's sent
+ * into (see actions.ts), so the id alone must never be sufficient to claim
+ * a release.
+ *
+ * Resolves with that release's parsed body, or rejects once `timeoutMs`
+ * elapses -- rejecting is an expected outcome, not a protocol error:
+ * PROTOCOL.md says the phone only answers when the app is next open, which
+ * routinely outlasts one webhook round-trip. Throws synchronously (before
+ * any caller does anything else) if `id` already has a pending wait.
+ */
+function register(id, binding) {
+    const key = mapKey(id);
+    if (pending.has(key)) {
+        throw new Error("Already waiting on a release for this request.");
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pending.delete(key);
+            reject(new Error(`No release within ${Math.round(binding.timeoutMs / 1000)}s.`));
+        }, binding.timeoutMs);
+        pending.set(key, { chatId: binding.chatId, senderId: binding.senderId, resolve, reject, timer });
+    });
+}
+/**
+ * Clears a pending wait without settling its promise -- used when sending
+ * the request message itself fails right after register() ran, so the
+ * registry entry doesn't leak (the caller throws its own error instead).
+ */
+function cancel(id) {
+    const key = mapKey(id);
+    const entry = pending.get(key);
+    if (!entry)
+        return;
+    clearTimeout(entry.timer);
+    pending.delete(key);
+}
+const releaseHandlers = new Set();
+/**
+ * Subscribes to releases that arrive with nothing waiting on them: a late
+ * reply (the request already timed out) or a standing push (there was
+ * never a request to begin with). Returns an unsubscribe function.
+ *
+ * UNVERIFIED: lattice.ts has no REST client and no concept of a grant, so a
+ * handler here fires for ANY sender in ANY chat with no check that they
+ * actually hold a live grant to this agent. webhook.ts's `onLatticeRelease`
+ * option is the verified, recommended path for exactly this case (it
+ * fetches this agent's live grants and checks the sender is human and,
+ * for a standing push, that `grant_id` names one, before ever calling your
+ * handler) -- reach for this lower-level hook only if you're bypassing
+ * webhook.ts entirely, and do your own equivalent check.
+ *
+ * A handler may be async. Either a synchronous throw or a rejected promise
+ * is swallowed -- like every other fire-and-forget hook in this SDK, a bug
+ * in a consumer's handler must not take down webhook processing (an
+ * unhandled rejection crashes the process on modern Node defaults).
+ */
+function onRelease(handler) {
+    releaseHandlers.add(handler);
+    return () => releaseHandlers.delete(handler);
+}
+function fireOnRelease(release) {
+    for (const handler of releaseHandlers) {
+        Promise.resolve()
+            .then(() => handler(release))
+            .catch(() => {
+            // see onRelease's doc comment
+        });
+    }
+}
+/**
+ * Call right after decrypting an inbound message, before deciding whether
+ * to run a fresh reply cycle -- the same spot webhook.ts calls
+ * delegations.resolveIfPending (and what webhook.ts itself calls, to also
+ * learn about an "unmatched" release for its onLatticeRelease option).
+ *
+ * - "not-a-release": `plaintext` isn't lattice wire protocol at all --
+ *   including this identity's own outgoing requests/proposals, which never
+ *   match RELEASE_MARKER_RE, and any genuinely unrelated message.
+ * - "matched": `chatId`/`senderId` agree with a live register() wait for
+ *   this release's `request_id` -- that wait's promise is resolved directly;
+ *   there is nothing further for a caller to do.
+ * - "refused": this release names a request id a wait IS pending for, but
+ *   `chatId`/`senderId` don't match what register() bound it to -- e.g. a
+ *   bystander who merely saw the plaintext request id (see
+ *   RegisterBinding's doc comment) replaying it as a forged release. The
+ *   live wait is untouched (still running, still resolvable by the real
+ *   answer); this message is left for the caller to process as ordinary,
+ *   harmless text -- it must NOT be treated as Lattice traffic.
+ * - "unmatched": a genuine late reply or standing push -- fired to
+ *   onRelease() before this returns.
+ */
+function classifyRelease(chatId, senderId, plaintext) {
+    const parsed = parseRelease(plaintext);
+    if (!parsed)
+        return { kind: "not-a-release" };
+    if (!parsed.standing) {
+        const key = mapKey(parsed.body.request_id); // parseRelease guarantees request_id is set for a non-standing release
+        const entry = pending.get(key);
+        if (entry) {
+            if ((0, ids_js_1.sameId)(entry.chatId, chatId) && (0, ids_js_1.sameId)(entry.senderId, senderId)) {
+                clearTimeout(entry.timer);
+                pending.delete(key);
+                entry.resolve(parsed.body);
+                return { kind: "matched" };
+            }
+            return { kind: "refused" };
+        }
+    }
+    const release = { id: parsed.id, standing: parsed.standing, chatId, senderId, body: parsed.body };
+    fireOnRelease(release);
+    return { kind: "unmatched", release };
+}
+/**
+ * Boolean convenience wrapper over classifyRelease, mirroring
+ * delegations.resolveIfPending(chatId, senderId, plaintext)'s shape for a
+ * simple caller that doesn't need an "unmatched" release's details (e.g. a
+ * custom integration built directly on lattice.ts, without webhook.ts).
+ * True for "matched" and "unmatched" (don't treat `plaintext` as a fresh
+ * prompt); false for "not-a-release" AND "refused" (a forged/misdirected
+ * release is left to fall through exactly like ordinary text, same as
+ * "not-a-release" -- see classifyRelease's doc comment).
+ *
+ * webhook.ts itself calls classifyRelease directly instead of this, since
+ * it also needs an "unmatched" release's details (chat/sender/body) to
+ * offer to its own onLatticeRelease option.
+ */
+function resolveIfPending(chatId, senderId, plaintext) {
+    const outcome = classifyRelease(chatId, senderId, plaintext);
+    return outcome.kind === "matched" || outcome.kind === "unmatched";
+}
+//# sourceMappingURL=lattice.js.map

package/dist/lattice.js.map

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