@decidio/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,197 @@
+// @decidio/sdk — the one-line approval gate for AI-agent actions.
+//
+//   import { guard } from "@decidio/sdk";
+//   const createOpportunity = guard.protect(createOpportunityRaw, (a) => ({
+//     action: "createOpportunity", amount: a.amount, scope: "Opportunity",
+//   }));
+//
+// NOTE: `guard` is the preconfigured SINGLETON (a Guard instance, see guard.ts). It is NOT a
+// GuardConfig, so it cannot be passed as withApproval's third argument — this comment used to
+// show exactly that, and the error propagated into the product's own copy-paste snippets.
+// `withApproval(fn, describe, config)` is the lower-level export and takes a config OBJECT.
+//
+// On call, the wrapper asks Decidio's gate to authorize the action. Decidio's
+// policy engine (Cedar / computeChain) returns proceed | route | block:
+//   • proceed → the wrapped fn runs immediately (auto-approved under policy)
+//   • route   → the wrapper WAITS for a human to approve in Decidio's queue, then
+//               runs the fn (or throws if rejected)
+//   • block   → the wrapper throws; the fn never runs
+// The wrapper is a LISTENER: it captures the real source-system response the wrapped
+// fn returns and reports it to Decidio, which seals an `application_confirmed`
+// Authority Receipt (Decidio minimizes + tokenizes before sealing — the immutable
+// seal never stores raw payloads). The agent executes its own action; Decidio
+// authorizes, records, and (optionally) independently verifies it. Decidio holds NO
+// write credentials for your system — only the authority decision and the record.
+//
+// Framework-agnostic by design: it wraps at the tool-call boundary, so it works with
+// any agent runtime (LangGraph, OpenAI Agents SDK, CrewAI, a raw tool loop) and any
+// action (Salesforce, M365, SAP, a DB write) — the wrapper doesn't care what the fn
+// does, only that it returns the source response.
+import { DecidioSuspendedError } from "./resume.js";
+import { signBoundProof, signConfirm } from "./signing.js";
+export { DecidioSuspendedError, FilePendingStore, MemoryPendingStore, createDecidioResume } from "./resume.js";
+export { guard, Guard } from "./guard.js";
+export { generateKeypair, signBoundProof, signConfirm, canonicalize } from "./signing.js";
+export class DecidioBlockedError extends Error {
+    reason;
+    decisionId;
+    constructor(reason, decisionId) {
+        super(`Decidio blocked the action: ${reason}`);
+        this.reason = reason;
+        this.decisionId = decisionId;
+        this.name = "DecidioBlockedError";
+    }
+}
+export class DecidioRejectedError extends Error {
+    reason;
+    decisionId;
+    constructor(reason, decisionId) {
+        super(`A human rejected the action: ${reason}`);
+        this.reason = reason;
+        this.decisionId = decisionId;
+        this.name = "DecidioRejectedError";
+    }
+}
+export class DecidioTimeoutError extends Error {
+    decisionId;
+    constructor(decisionId) {
+        super(`Timed out waiting for human approval (${decisionId})`);
+        this.decisionId = decisionId;
+        this.name = "DecidioTimeoutError";
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function post(cfg, path, body) {
+    const f = cfg.fetchImpl ?? fetch;
+    const res = await f(cfg.apiUrl.replace(/\/$/, "") + path, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...(cfg.apiToken ? { authorization: `Bearer ${cfg.apiToken}` } : {}) },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`decidio ${path} ${res.status}: ${await res.text().catch(() => "")}`);
+    return res.json();
+}
+async function get(cfg, path) {
+    const f = cfg.fetchImpl ?? fetch;
+    const res = await f(cfg.apiUrl.replace(/\/$/, "") + path, {
+        headers: { ...(cfg.apiToken ? { authorization: `Bearer ${cfg.apiToken}` } : {}) },
+    });
+    if (!res.ok)
+        throw new Error(`decidio ${path} ${res.status}`);
+    return res.json();
+}
+/**
+ * Wrap an async action behind the Decidio gate. `describe` extracts the approval
+ * context (action, amount, scope) from the call arguments. Returns a function with
+ * the SAME signature as `fn` — drop-in.
+ */
+/** `<appUrl>/d/<decisionId>` — the deep link that opens this decision directly, on the web app or
+ *  the phone build. Null when DECIDIO_APP_URL is not configured, never a half-built URL. */
+export function decisionUrl(appUrl, decisionId) {
+    if (!appUrl)
+        return null;
+    return `${appUrl.replace(/\/$/, "")}/d/${encodeURIComponent(decisionId)}`;
+}
+export function withApproval(fn, describe, config) {
+    const pollInterval = config.pollIntervalMs ?? 2_000;
+    const pollTimeout = config.pollTimeoutMs ?? 600_000;
+    const resumeUrl = config.resumeUrl ?? config.resume?.resumeUrl;
+    return async (...args) => {
+        const ctx = describe(...args);
+        // 1. ask the gate (carry the resume URL so a routed decision knows where to call back).
+        //    When a signing key is configured, sign a request-bound identity proof so the floor
+        //    can PROVE this agent rather than trust the `requester` label (registered agents must
+        //    sign to auto-approve). Unsigned still works for generic/non-agent callers.
+        const requesterIdentity = (config.agentKey && config.agentDid)
+            ? signBoundProof(config.agentKey, { agentId: config.agentId, did: config.agentDid, action: ctx.action, amount: ctx.amount, scope: ctx.scope, workspaceId: config.workspaceId })
+            : undefined;
+        const auth = await post(config, "/agent/authorize", {
+            requester: config.agentId, action: ctx.action, amount: ctx.amount,
+            scope: ctx.scope, sourceSystem: config.sourceSystem,
+            ...(ctx.context ? { context: ctx.context } : {}),
+            ...(requesterIdentity ? { requesterIdentity } : {}),
+            ...(resumeUrl ? { resumeUrl } : {}),
+        });
+        // Allow-list, not deny-list: an unrecognised verdict means this SDK is older than the
+        // server, and the safe reading of an answer you do not understand is NO. Without this, the
+        // day a fourth verdict ships every deployed SDK falls through and executes it.
+        if (auth.decision !== "proceed" && auth.decision !== "route" && auth.decision !== "block")
+            throw new DecidioBlockedError(`unrecognized gate verdict: ${String(auth.decision)}`, auth.decisionId);
+        if (auth.decision === "block")
+            throw new DecidioBlockedError(auth.reason ?? "blocked by policy", auth.decisionId);
+        // 2. routed → either SUSPEND for async resume (durable) or BLOCK-poll (interactive)
+        if (auth.decision === "route") {
+            // Hand back a link straight to the decision. An agent that suspends and says only "waiting"
+            // leaves the operator to go hunting through a queue; one that prints the URL does not.
+            const approvalUrl = decisionUrl(config.appUrl, auth.decisionId);
+            if (config.onPending)
+                config.onPending({ decisionId: auth.decisionId, receiptId: auth.receiptId, url: approvalUrl });
+            else if (approvalUrl)
+                console.log(`[decidio] ${ctx.action} is awaiting approval — approve it at ${approvalUrl}`);
+            // Durable transport: park the args agent-side, register the raw fn so a (cold)
+            // resume can replay it, and SUSPEND. The process may exit now; the controller's
+            // webhook handler or poll worker re-executes THIS fn when a human approves.
+            // Decidio never executes — it only signals.
+            if (config.resume) {
+                // Propagate the agent's signing identity to the resume controller so the eventual
+                // (possibly cold) confirm on resume is SIGNED too — earning application_confirmed on
+                // the durable path, not just inline. (No-op if the controller already has its own.)
+                config.resume.agentId ??= config.agentId;
+                config.resume.agentKey ??= config.agentKey;
+                config.resume.agentDid ??= config.agentDid;
+                config.resume.register(ctx.action, fn);
+                await config.resume.store.put({
+                    decisionId: auth.decisionId, receiptId: auth.receiptId,
+                    action: ctx.action, amount: ctx.amount, scope: ctx.scope,
+                    args, createdAt: new Date().toISOString(),
+                });
+                throw new DecidioSuspendedError(auth.decisionId, ctx.action);
+            }
+            // Interactive transport (no resume configured): block until decided. Only
+            // appropriate for short, watched approvals (demos, synchronous tools).
+            const deadline = Date.now() + pollTimeout;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const st = await get(config, `/agent/status/${encodeURIComponent(auth.decisionId)}`);
+                if (st.state === "approved" || st.state === "auto_approved")
+                    break;
+                if (st.state === "rejected")
+                    throw new DecidioRejectedError(st.reason ?? "rejected by approver", auth.decisionId);
+                if (st.state === "blocked")
+                    throw new DecidioBlockedError(st.reason ?? "blocked", auth.decisionId);
+                if (Date.now() > deadline) {
+                    // The founder-visible failure of blocking: the wait has a ceiling, and past it the
+                    // work is LOST — the decision stays open in Decidio but nothing is parked to resume.
+                    // Say so, say the limit, and say the durable way out.
+                    console.warn(`[decidio] blocking wait hit its ${Math.round(pollTimeout / 1000)}s limit — decision ${auth.decisionId} is still open in Decidio, but this process stopped waiting and nothing was executed. Re-run to request again, or use durable resume (guard.worker()) so an approval is never lost.`);
+                    throw new DecidioTimeoutError(auth.decisionId);
+                }
+                await sleep(pollInterval);
+            }
+        }
+        // 3. authorized inline (proceed, or interactive route just approved) → run the
+        //    REAL action and capture the source response (listener)
+        const result = await fn(...args);
+        // 4. report the captured outcome → Decidio seals application_confirmed
+        //    (server minimizes + tokenizes the response before sealing). Best-effort:
+        //    a confirmation failure must not undo a successful business action.
+        try {
+            // Sign the confirmation too (bound to {action:"confirm", scope:decisionId}) so the gate
+            // can PROVE this is the receipt's original requester before granting the wrapper tier
+            // (application_confirmed). Without a key the report is capped at agent_asserted server-side.
+            const confirmIdentity = signConfirm(auth.decisionId, config);
+            await post(config, "/agent/confirm", {
+                decisionId: auth.decisionId,
+                capturedResponse: result ?? null,
+                source: "wrapper", // the SDK captured the genuine response, not an agent self-report
+                ...(confirmIdentity ? { requesterIdentity: confirmIdentity } : {}),
+            });
+        }
+        catch (e) {
+            // surface but don't throw — the action already happened
+            console.warn(`[decidio] confirmation post failed (action succeeded): ${e.message}`);
+        }
+        return result;
+    };
+}

package/dist/inngest.d.ts

@@ -0,0 +1,61 @@
+import type { RequestListener } from "node:http";
+import { verifyResumeSignature } from "./resume.js";
+import type { GuardConfig, ApprovalContext } from "./index.js";
+/** The Inngest event Decidio's verdict is translated into. The waiting function
+ *  correlates on `data.decisionId`. */
+export declare const DECIDIO_RESUME_EVENT = "decidio/decision.resolved";
+/** The minimal slices of the Inngest step + client APIs we use, typed structurally so
+ *  this file doesn't force an `inngest` type dependency on the core build. */
+export interface InngestStepLike {
+    run<T>(id: string, fn: () => Promise<T>): Promise<T>;
+    waitForEvent(id: string, opts: {
+        event: string;
+        timeout: string;
+        match?: string;
+        if?: string;
+    }): Promise<{
+        name: string;
+        data?: Record<string, any>;
+    } | null>;
+}
+export interface InngestClientLike {
+    send(event: {
+        name: string;
+        data: Record<string, any>;
+    }): Promise<unknown>;
+}
+export type GateStepOutcome<R> = {
+    status: "executed" | "rejected" | "blocked";
+    decisionId: string;
+    result?: R;
+};
+/**
+ * Gate an action INSIDE an Inngest function, with durable suspend on routing.
+ *   • proceed → run the action (as a step) + confirm.
+ *   • route   → `step.waitForEvent` durably suspends until Decidio's resume event for
+ *               THIS decision arrives; approved → run + confirm; rejected → status.
+ *   • block   → return blocked (the action never runs).
+ * The action runs in YOUR process with YOUR credentials — Decidio only signals.
+ * `config.resumeUrl` must point at the bridge endpoint (createInngestResumeBridge),
+ * so Decidio's webhook is translated into the event this step waits on.
+ */
+export declare function decidioGateStep<R>(args: {
+    step: InngestStepLike;
+    config: GuardConfig;
+    ctx: ApprovalContext;
+    run: () => Promise<R>;
+    timeout?: string;
+}): Promise<GateStepOutcome<R>>;
+/**
+ * Decidio → Inngest bridge. Mount as an HTTP endpoint and register it as the agent's
+ * `resumeUrl`. It verifies Decidio's signed resume webhook (same HMAC as the core
+ * handler) and emits `DECIDIO_RESUME_EVENT` into Inngest, waking the suspended
+ * `decidioGateStep`. Fails CLOSED without a configured secret (unless allowUnsigned).
+ */
+export declare function createInngestResumeBridge(opts: {
+    inngest: InngestClientLike;
+    webhookSecret?: string;
+    allowUnsigned?: boolean;
+    eventName?: string;
+}): RequestListener;
+export { verifyResumeSignature };

package/dist/inngest.js

@@ -0,0 +1,114 @@
+import { verifyResumeSignature } from "./resume.js";
+import { signBoundProof, signConfirm } from "./signing.js";
+/** The Inngest event Decidio's verdict is translated into. The waiting function
+ *  correlates on `data.decisionId`. */
+export const DECIDIO_RESUME_EVENT = "decidio/decision.resolved";
+/**
+ * Gate an action INSIDE an Inngest function, with durable suspend on routing.
+ *   • proceed → run the action (as a step) + confirm.
+ *   • route   → `step.waitForEvent` durably suspends until Decidio's resume event for
+ *               THIS decision arrives; approved → run + confirm; rejected → status.
+ *   • block   → return blocked (the action never runs).
+ * The action runs in YOUR process with YOUR credentials — Decidio only signals.
+ * `config.resumeUrl` must point at the bridge endpoint (createInngestResumeBridge),
+ * so Decidio's webhook is translated into the event this step waits on.
+ */
+export async function decidioGateStep(args) {
+    const { step, config, ctx } = args;
+    const base = config.apiUrl.replace(/\/$/, "");
+    const f = config.fetchImpl ?? fetch;
+    const authHeaders = { "content-type": "application/json", ...(config.apiToken ? { authorization: `Bearer ${config.apiToken}` } : {}) };
+    // 1. authorize (memoized as a step, so a replay doesn't re-ask the gate)
+    const auth = await step.run("decidio-authorize", async () => {
+        // Sign the bound proof so an Inngest-path agent can prove its identity + auto-approve.
+        const requesterIdentity = (config.agentKey && config.agentDid)
+            ? signBoundProof(config.agentKey, { agentId: config.agentId, did: config.agentDid, action: ctx.action, amount: ctx.amount, scope: ctx.scope, workspaceId: config.workspaceId })
+            : undefined;
+        const res = await f(base + "/agent/authorize", {
+            method: "POST", headers: authHeaders,
+            body: JSON.stringify({
+                requester: config.agentId, action: ctx.action, amount: ctx.amount, scope: ctx.scope,
+                sourceSystem: config.sourceSystem,
+                ...(requesterIdentity ? { requesterIdentity } : {}),
+                ...(config.resumeUrl ? { resumeUrl: config.resumeUrl } : {}),
+            }),
+        });
+        if (!res.ok)
+            throw new Error(`decidio authorize ${res.status}`);
+        return res.json();
+    });
+    if (auth.decision === "block")
+        return { status: "blocked", decisionId: auth.decisionId };
+    if (auth.decision === "route") {
+        // 2. durably SUSPEND until the resume event for THIS decision arrives. Zero
+        //    compute while waiting; the worker/process may be recycled — Inngest resumes
+        //    from this checkpoint. `if` correlates the awaited event to this decisionId.
+        const ev = await step.waitForEvent("decidio-await-approval", {
+            event: DECIDIO_RESUME_EVENT,
+            timeout: args.timeout ?? "30d",
+            if: `async.data.decisionId == "${auth.decisionId}"`,
+        });
+        if (!ev)
+            throw new Error(`decidio approval timed out (${auth.decisionId})`);
+        const verdict = ev.data?.verdict;
+        if (verdict === "rejected")
+            return { status: "rejected", decisionId: auth.decisionId };
+        if (verdict !== "approved" && verdict !== "auto_approved")
+            return { status: "blocked", decisionId: auth.decisionId };
+    }
+    // 3. authorized → perform the agent's OWN action (a step), then confirm the captured
+    //    response so Decidio seals application_confirmed (never executes it itself).
+    const result = await step.run("agent-action", args.run);
+    await step.run("decidio-confirm", async () => {
+        const requesterIdentity = signConfirm(auth.decisionId, config);
+        await f(base + "/agent/confirm", {
+            method: "POST", headers: authHeaders,
+            body: JSON.stringify({ decisionId: auth.decisionId, capturedResponse: result ?? null, source: "wrapper", ...(requesterIdentity ? { requesterIdentity } : {}) }),
+        });
+        return true;
+    });
+    return { status: "executed", decisionId: auth.decisionId, result };
+}
+/**
+ * Decidio → Inngest bridge. Mount as an HTTP endpoint and register it as the agent's
+ * `resumeUrl`. It verifies Decidio's signed resume webhook (same HMAC as the core
+ * handler) and emits `DECIDIO_RESUME_EVENT` into Inngest, waking the suspended
+ * `decidioGateStep`. Fails CLOSED without a configured secret (unless allowUnsigned).
+ */
+export function createInngestResumeBridge(opts) {
+    const secret = opts.webhookSecret ?? "";
+    const eventName = opts.eventName ?? DECIDIO_RESUME_EVENT;
+    return (req, res) => {
+        if (req.method !== "POST") {
+            res.statusCode = 405;
+            return res.end("method not allowed");
+        }
+        let raw = "";
+        req.on("data", (c) => (raw += c));
+        req.on("end", async () => {
+            try {
+                if (!secret) {
+                    if (!opts.allowUnsigned) {
+                        res.statusCode = 401;
+                        return res.end(JSON.stringify({ error: "resume webhook unsigned and no secret configured" }));
+                    }
+                }
+                else if (!verifyResumeSignature(secret, raw, req.headers["x-decidio-signature"])) {
+                    res.statusCode = 401;
+                    return res.end(JSON.stringify({ error: "bad signature" }));
+                }
+                const body = JSON.parse(raw || "{}");
+                await opts.inngest.send({ name: eventName, data: { decisionId: String(body.decisionId), verdict: body.verdict, reason: body.reason ?? null } });
+                res.statusCode = 200;
+                res.setHeader("content-type", "application/json");
+                res.end(JSON.stringify({ ok: true, forwarded: eventName, decisionId: body.decisionId }));
+            }
+            catch (e) {
+                res.statusCode = 500;
+                res.end(JSON.stringify({ error: e?.message ?? "bridge failed" }));
+            }
+        });
+    };
+}
+// Re-export the signature check so a host can verify the webhook out-of-band if needed.
+export { verifyResumeSignature };

package/dist/resume.d.ts

@@ -0,0 +1,152 @@
+import type { RequestListener } from "node:http";
+/** A routed action parked on the agent side, awaiting human approval. The `args`
+ *  are the original call arguments, replayed verbatim when the action resumes. */
+export interface PendingAction {
+    decisionId: string;
+    receiptId?: string;
+    action: string;
+    amount: number;
+    scope?: string;
+    args: unknown[];
+    createdAt: string;
+}
+/** Where suspended actions live between request and approval. The default is a
+ *  file store; swap in Redis/Postgres/your queue for production. AGENT-SIDE only —
+ *  Decidio never sees this. */
+export interface PendingStore {
+    put(p: PendingAction): Promise<void>;
+    get(decisionId: string): Promise<PendingAction | null>;
+    delete(decisionId: string): Promise<void>;
+    list(): Promise<PendingAction[]>;
+    /** Atomically take ownership of a parked action for execution. Returns true if THIS
+     *  caller claimed it, false if it's already claimed/gone — the cross-process single-use
+     *  guarantee (a production store backs this with rename/SETNX/SELECT-FOR-UPDATE). A
+     *  claimed entry is excluded from list(). Optional: if absent, the controller falls
+     *  back to an in-process guard (same-process only). */
+    claim?(decisionId: string): Promise<boolean>;
+    /** Undo a claim so a failed execution is retryable. */
+    release?(decisionId: string): Promise<void>;
+}
+export declare class MemoryPendingStore implements PendingStore {
+    private m;
+    private claimed;
+    put(p: PendingAction): Promise<void>;
+    get(id: string): Promise<PendingAction | null>;
+    delete(id: string): Promise<void>;
+    list(): Promise<PendingAction[]>;
+    claim(id: string): Promise<boolean>;
+    release(id: string): Promise<void>;
+}
+/** File-backed store so a COLD process (the original requester long gone) can still
+ *  resume — the proof that nothing is "kept alive". One JSON file per decision. A claim
+ *  renames `<id>.json` → `<id>.claimed` atomically (same-volume rename), so two processes
+ *  sharing the dir can't both execute. (A stale `.claimed` from a crash mid-execute needs
+ *  TTL recovery — tracked in the backlog.) */
+export declare class FilePendingStore implements PendingStore {
+    private dir;
+    constructor(dir: string);
+    private key;
+    private path;
+    private claimedPath;
+    put(p: PendingAction): Promise<void>;
+    get(id: string): Promise<PendingAction | null>;
+    delete(id: string): Promise<void>;
+    list(): Promise<PendingAction[]>;
+    claim(id: string): Promise<boolean>;
+    release(id: string): Promise<void>;
+}
+/** Thrown by a `withApproval`-wrapped call when the action is routed and configured
+ *  for async resume: the action is now SUSPENDED (parked in the store), not failed.
+ *  The caller can stop here — the process may even exit; the resume transport will
+ *  complete it later. */
+export declare class DecidioSuspendedError extends Error {
+    decisionId: string;
+    action: string;
+    constructor(decisionId: string, action: string);
+}
+export type ResumeStatus = "executed" | "rejected" | "blocked" | "no_handler" | "unknown";
+export interface ResumeOutcome {
+    status: ResumeStatus;
+    decisionId: string;
+    action?: string;
+    result?: unknown;
+    reason?: string;
+}
+/** Minimal config the controller needs to confirm outcomes + poll status. Shared
+ *  with GuardConfig (apiUrl/apiToken). */
+export interface ResumeConfig {
+    apiUrl: string;
+    apiToken?: string;
+    /** Agent identity for SIGNING the confirm call on resume (so the durable path can earn the
+     *  application_confirmed tier, not just the inline path). Default from DECIDIO_AGENT_ID/
+     *  _KEY/_DID env when unset — a cold resume process that has the env signs automatically. */
+    agentId?: string;
+    agentKey?: string;
+    agentDid?: string;
+    /** The workspace the agent acts in (DECIDIO_WORKSPACE_ID) — bound into the cold-resume confirm
+     *  proof (D-B3.6) so it's tenant-scoped too. Default from env when unset. */
+    workspaceId?: string;
+    /** Shared secret Decidio signs the resume webhook with (HMAC-SHA256). Defaults to
+     *  the API token if unset. Verified before any re-execution. */
+    webhookSecret?: string;
+    /** Escape hatch to accept UNSIGNED resume webhooks (no secret). Off by default:
+     *  with no secret and this unset, the webhook handler rejects every call (fail
+     *  closed) so a misconfigured agent can't be driven by forged callbacks. Only set
+     *  true behind a trusted network boundary (e.g. mTLS / private mesh). */
+    allowUnsigned?: boolean;
+    /** The callback URL Decidio should POST the verdict to (webhook transport). Sent
+     *  on /agent/authorize so the decision carries it; omit when using the poll worker. */
+    resumeUrl?: string;
+    /** Fired after every terminal resolution (executed / rejected / blocked / no_handler),
+     *  via either transport. Use it to log, close a listener, or exit a CLI. */
+    onResolved?: (o: ResumeOutcome) => void;
+    fetchImpl?: typeof fetch;
+}
+/** Re-execute the agent's own fn on approval, confirm the captured outcome to
+ *  Decidio, and clear the parked entry. Bound to a store + a registry of raw fns. */
+export interface ResumeController extends ResumeConfig {
+    store: PendingStore;
+    /** Register a RAW fn under its action name so a (possibly cold) resume can replay
+     *  it. `withApproval` auto-registers on the hot path; a cold worker/service should
+     *  register at startup so it can resume actions it never originated. */
+    register(action: string, fn: (...args: any[]) => Promise<any>): void;
+    /** Drive a parked decision to completion once a verdict is known. Idempotent:
+     *  a second call after success finds nothing parked → "unknown" (no double-write). */
+    resolve(input: {
+        decisionId: string;
+        verdict: "approved" | "rejected" | "blocked";
+        reason?: string;
+    }): Promise<ResumeOutcome>;
+    /** node:http listener for Decidio's signed approval webhook (Express/Fastify/node). */
+    webhookHandler(): RequestListener;
+    /** Web-Fetch handler (Request → Response) for Next.js route handlers, Hono,
+     *  Cloudflare Workers, Bun, Deno. Same fail-closed signature check. */
+    fetchHandler(): (req: Request) => Promise<Response>;
+    /** Poll-based resume for hosts with no inbound URL (CLI/laptop). A long-lived
+     *  watcher — this is a durable WORKER, not the request path blocking. */
+    worker(opts?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+        onResolved?: (o: ResumeOutcome) => void;
+    }): {
+        stop: () => void;
+    };
+}
+declare function sign(secret: string, body: string): string;
+/** Verify Decidio's `x-decidio-signature` over the raw webhook body (HMAC-SHA256).
+ *  Exported so engine adapters (e.g. the Inngest bridge) reuse the exact check. */
+export declare function verifyResumeSignature(secret: string, body: string, header: string | undefined): boolean;
+/**
+ * Build the resume controller. Spread it into your GuardConfig as `resume`, then
+ * either mount `webhookHandler()` (production) or run `worker()` (CLI/laptop).
+ *
+ *   const resume = createDecidioResume({ apiUrl, apiToken, store: new FilePendingStore(".decidio-pending"), resumeUrl });
+ *   const guard  = { apiUrl, agentId, apiToken, resume };
+ *   const createOpportunity = withApproval(createOpportunityRaw, describe, guard);
+ *   // production:  http.createServer(resume.webhookHandler()).listen(4100)
+ *   // or CLI:      resume.worker()
+ */
+export declare function createDecidioResume(opts: ResumeConfig & {
+    store: PendingStore;
+}): ResumeController;
+export { sign as _signResumeBody };