export declare const redeemContinuation: import("convex/server").RegisteredMutation<"public", { responsesDigest?: string | undefined; expiresAt: number; jti: string; }, Promise<"fresh" | "replay" | "conflict">>; export declare const pruneMrtrRedemptions: import("convex/server").RegisteredMutation<"public", {}, Promise>; /** * The chain's resolution, or `null` while it is still open. Read-only * pre-check: the host uses it to refuse a continuation that could only * fork or re-dispatch an already-resolved chain, while still allowing * an idempotent re-send of a completed call to reproduce its result. * The binding decision is `claimChain` below, not this. */ export declare const getChainResolution: import("convex/server").RegisteredQuery<"public", { chainKey: string; }, Promise<{ resolvedByDigest?: string | undefined; resolution: "dispatched" | "completed"; resolvedByJti: string; } | null>>; /** * Claim a chain's single resolution. Called by the host immediately * before it dispatches the tool or finishes the call via * `completeCall()`, so the insert IS the decision rather than a record * of one: a later claim for the same chain, from any continuation of * it, loses and reports who won. * * This is what makes a resolved decision final. Per-continuation * redemption cannot, because `jti` is fresh per round and a replay that * re-runs the hook mints a new, unpinned sibling. * * Note what this does NOT do: the resolving continuation may dispatch * again when re-sent with the same answer, which is how a lost response * retries. Keeping the side effect single is the tool's job, via the * injected idempotency key. */ export declare const claimChain: import("convex/server").RegisteredMutation<"public", { responsesDigest?: string | undefined; chainKey: string; expiresAt: number; jti: string; resolution: "dispatched" | "completed"; }, Promise<"claimed" | { resolvedByDigest?: string | undefined; resolution: "dispatched" | "completed"; resolvedByJti: string; }>>; //# sourceMappingURL=mrtr.d.ts.map