@decidio/sdk 0.1.9 → 0.1.10

package/README.md

@@ -126,11 +126,14 @@ becomes the record's execution evidence.
 
 ```bash
 npx @decidio/sdk receipt <decisionId>
-npx @decidio/sdk verify decidio-receipt-<decisionId>.json
+npx @decidio/sdk verify --issuer <did:key:...> decidio-receipt-<decisionId>.json
 ```
 
-The download is an authenticated fetch from your workspace; the *verification* is fully
-offline — the verifier ships inside this package (no second download, no registry probe, same
+Lead with the pin: `--issuer` binds the check to YOUR workspace's DID (the `receipt` command
+prints it from the authenticated response, so it is already on your screen). An UNPINNED
+`verify` proves internal consistency only — any keyholder could have issued such a file — and
+says so; pinned verification proves *who*. The download is an authenticated fetch from your
+workspace; the *verification* is fully offline — the verifier ships inside this package (no second download, no registry probe, same
 implementation as the standalone `@decidio/verify`). The receipt is a W3C Verifiable
 Credential: signature and content binding verify with no Decidio account and no network — the
 evidence is yours, not ours. To also prove *who* issued it, pin your workspace's issuer:
@@ -278,7 +281,9 @@ If your agent runs on Inngest/Temporal/LangGraph, the engine *is* the durable st
 `@decidio/sdk/inngest` maps the gate onto `step.waitForEvent`; `@decidio/sdk/langgraph` is a
 drop-in via `interrupt()`; `@decidio/sdk/temporal` uses `condition` + signal;
 `@decidio/sdk/openai` gates RunState approvals. All optional peer dependencies — the core SDK
-imports none of them. Each adapter's shipped `.d.ts` header documents its wiring; `npx
+imports none of them — install the engine you use alongside the SDK (`npm i inngest`,
+`@langchain/langgraph`, `@temporalio/workflow`, or `@openai/agents`); nothing is downloaded
+for engines you don't. Each adapter's shipped `.d.ts` header documents its wiring; `npx
 @decidio/sdk quickstart` is the fastest runnable end-to-end.
 
 ## One surface, every runtime — and Python too

package/dist/adapters/_gate.js

@@ -1,19 +1,9 @@
-// Shared adapter gate logic (TS) — the thin-adapter rule in code. Every engine adapter
-// reuses these gate calls + verdict handling; only the suspend/resume translation
-// differs. Pure/testable so the offline smoke covers our logic; the engine-primitive
-// call in each adapter is a thin one-liner verified by typecheck against real types.
-import { DecidioBlockedError, DecidioRejectedError, signBoundProof, signConfirm, assertJsonSafe, assertConfirmRecorded } from "../index.js";
+import { DecidioBlockedError, DecidioRejectedError, signBoundProof, signConfirm, assertJsonSafe, assertConfirmRecorded, assertSafeTransport } from "../index.js";
 export async function gateAuthorize(config, ctx) {
-    // SAME JSON-safety gate as the core wrapper (guard equivalent-path catch: the adapter door
-    // skipped it, and the server's amount coercion turns a drifted NaN→null into a $0 request —
-    // a human would approve an amount that meant something else entirely).
     assertJsonSafe(ctx, "describe(...)");
+    assertSafeTransport(config.apiUrl, !!config.apiToken);
     const f = config.fetchImpl ?? fetch;
-    // Fall back to the resume controller's URL (matches the core wrapper) so an adapter
-    // decision carries a callback URL even when only resume.resumeUrl was set.
     const resumeUrl = config.resumeUrl ?? config.resume?.resumeUrl;
-    // Sign the bound identity proof like the core wrapper, so an adapter-path agent can PROVE
-    // its identity and auto-approve (not just route). No key → unsigned → server routes.
     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;
@@ -33,10 +23,14 @@ export async function gateAuthorize(config, ctx) {
 export async function gateConfirm(config, decisionId, result) {
     const f = config.fetchImpl ?? fetch;
     try {
-        // Sign the confirm too (bound to {action:"confirm", scope:decisionId}) so the adapter path
-        // earns application_confirmed; without a key the server caps it at agent_asserted.
+        assertSafeTransport(config.apiUrl, !!config.apiToken);
+    }
+    catch (e) {
+        console.warn(`[decidio] confirm failed (action succeeded): ${e.message}`);
+        return;
+    }
+    try {
         const requesterIdentity = signConfirm(decisionId, config);
-        // Same no-silent-downgrade rule as the inline wrap (guard equivalent-path catch).
         if (!requesterIdentity)
             console.warn(`[decidio] execution evidence for ${decisionId} recorded as agent_asserted — no signing key configured, so the report can't be proven to come from this agent. Set DECIDIO_AGENT_KEY/DID to earn application_confirmed.`);
         const res = await f(config.apiUrl.replace(/\/$/, "") + "/agent/confirm", {
@@ -44,24 +38,19 @@ export async function gateConfirm(config, decisionId, result) {
             headers: { "content-type": "application/json", ...(config.apiToken ? { authorization: `Bearer ${config.apiToken}` } : {}) },
             body: JSON.stringify({ decisionId, capturedResponse: result ?? null, source: "wrapper", ...(requesterIdentity ? { requesterIdentity } : {}) }),
         });
-        // fetch only rejects on network error — surface a non-2xx (auth/500) too. Best-effort:
-        // log, don't throw (the action already happened).
         if (!res.ok) {
             console.warn(`[decidio] confirm returned ${res.status} (action succeeded)`);
             return;
         }
-        // The ONE confirm-body rule, on this door too (guard equivalent-path catch).
         assertConfirmRecorded(await res.json().catch(() => null), decisionId, !!requesterIdentity);
     }
     catch (e) {
         console.warn(`[decidio] confirm failed (action succeeded): ${e.message}`);
     }
 }
-/** Normalize a resume payload ({verdict} | "approved" | ...) to a verdict string. */
 export function verdictFrom(payload) {
     return (payload && typeof payload === "object" ? payload.verdict : payload) ?? "";
 }
-/** Throw the right error for a non-approving verdict; return for approved/auto_approved. */
 export function assertVerdict(verdict, decisionId, reason) {
     if (verdict === "approved" || verdict === "auto_approved")
         return;

package/dist/adapters/langgraph.js

@@ -1,23 +1,11 @@
 import { interrupt, Command } from "@langchain/langgraph";
 import { DecidioBlockedError } from "../index.js";
 import { gateAuthorize, gateConfirm, verdictFrom, assertVerdict } from "./_gate.js";
-/**
- * @decidio/sdk/langgraph — durable suspend via LangGraph's native `interrupt()`.
- * `interrupt` finds the running graph itself (no handle needed), so the gate drops into
- * a node: authorize → on route, interrupt() durably pauses (the checkpointer persists;
- * the process can die) → on resume (Command(resume={verdict})) run the agent's own
- * action + confirm. Decidio is the approval system; the host bridges its webhook to the
- * graph resume (decidioResumeCommand). Requires @langchain/langgraph (optional peer dep).
- *
- * (This wiring doc ships in the .d.ts — the README points here.)
- */
-/** Gate `run()` behind Decidio inside a LangGraph node. */
 export async function decidioGate(config, ctx, run) {
     const auth = await gateAuthorize(config, ctx);
     if (auth.decision === "block")
         throw new DecidioBlockedError(auth.reason ?? "blocked by policy", auth.decisionId);
     if (auth.decision === "route") {
-        // Durable pause. On resume, interrupt() returns the Command(resume=...) payload.
         const resumed = interrupt({ decidio: { decisionId: auth.decisionId, action: ctx.action, amount: ctx.amount, scope: ctx.scope } });
         assertVerdict(verdictFrom(resumed), auth.decisionId, resumed?.reason);
     }
@@ -25,8 +13,6 @@ export async function decidioGate(config, ctx, run) {
     await gateConfirm(config, auth.decisionId, result);
     return result;
 }
-/** Translate Decidio's signed resume webhook into the LangGraph resume Command. The host
- *  maps decisionId → thread_id and passes this to graph.invoke/stream. */
 export function decidioResumeCommand(body) {
     return new Command({ resume: { verdict: body.verdict, reason: body.reason } });
 }

package/dist/adapters/openai.js

@@ -1,7 +1,4 @@
 import { gateAuthorize } from "./_gate.js";
-/** Ask Decidio for each pending tool-approval on a RunState.
- *  proceed → state.approve(item); block → state.reject(item); route → pending (a human
- *  decides via Decidio; the host parks state.toString() + resumes via applyResume). */
 export async function gateInterruptions(config, state, describe) {
     const resolved = [];
     const pending = [];
@@ -20,7 +17,6 @@ export async function gateInterruptions(config, state, describe) {
     }
     return { resolved, pending };
 }
-/** Apply a Decidio verdict to a resumed RunState (after RunState.fromString). */
 export function applyResume(state, item, verdict) {
     if (verdict === "approved" || verdict === "auto_approved")
         state.approve(item);

package/dist/adapters/temporal.js

@@ -1,23 +1,7 @@
 import { condition, defineSignal, setHandler } from "@temporalio/workflow";
 import { DecidioBlockedError } from "../index.js";
 import { gateAuthorize, gateConfirm, verdictFrom, assertVerdict } from "./_gate.js";
-/**
- * @decidio/sdk/temporal — durable suspend via Temporal's native `condition()` + a
- * Decidio resume signal. Strongest durability (the workflow survives worker restarts for
- * days); the agent's action runs on resume. Requires @temporalio/workflow (optional peer).
- *
- * Inside your workflow:
- * const verdicts = installDecidioSignal();                 // wires the resume signal
- * const out = await decidioGate(config, ctx, () => createOpp(o), verdicts, {
- * authorize: () => executeActivity(authorizeActivity, ...),   // HTTP belongs in activities
- * confirm:   (id, r) => executeActivity(confirmActivity, ...),
- * });
- * Decidio's webhook bridges to: handle.signal(decidioResumeSignal, decisionId, verdict, reason)
- *
- * (This wiring doc ships in the .d.ts — the README points here.)
- */
 export const decidioResumeSignal = defineSignal("decidioResume");
-/** Call inside the workflow to wire the resume signal; returns the verdict store. */
 export function installDecidioSignal() {
     const verdicts = new Map();
     setHandler(decidioResumeSignal, (decisionId, verdict, reason) => { verdicts.set(decisionId, { verdict, reason }); });
@@ -28,7 +12,7 @@ export async function decidioGate(config, ctx, run, verdicts, opts = {}) {
     if (auth.decision === "block")
         throw new DecidioBlockedError(auth.reason ?? "blocked by policy", auth.decisionId);
     if (auth.decision === "route") {
-        await condition(() => verdicts.has(auth.decisionId)); // durable wait on the signal
+        await condition(() => verdicts.has(auth.decisionId));
         const v = verdicts.get(auth.decisionId);
         assertVerdict(verdictFrom(v), auth.decisionId, v.reason);
     }