@warlock.js/core 4.8.0 → 4.8.1

package/esm/ai/src/human/human-approval.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"human-approval.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/human/human-approval.ts"],"sourcesContent":["import type { AgentMiddleware } from \"../contracts/middleware/middleware.contract\";\nimport type { MiddlewareToolContext } from \"../contracts/middleware/middleware-context.type\";\nimport type { BaseReport } from \"../contracts/result/base-report.type\";\nimport type { Usage } from \"../contracts/result/usage.type\";\nimport type { AIError } from \"../errors/ai-error\";\nimport type { ToolInvokeResult } from \"../tool/tool\";\nimport { generateRunId } from \"../utils/generate-run-id\";\nimport type {\n  ApprovalDecision,\n  ApprovalRequest,\n  HumanApprovalOptions,\n  PolicyContext,\n} from \"./contracts\";\nimport { ApprovalRejectedError, InterruptSuspendedError } from \"./errors\";\nimport { evaluatePolicy } from \"./policy\";\nimport { takeSeededDecision } from \"./resume-seed\";\n\n/** Default middleware name when {@link HumanApprovalOptions.name} is omitted. */\nconst DEFAULT_NAME = \"human-approval\";\n\n/** Zero usage for a synthetic, no-LLM-spend short-circuit result. */\nconst ZERO_USAGE: Usage = Object.freeze({ input: 0, output: 0, total: 0 });\n\n/**\n * Mutable view of {@link MiddlewareToolContext.request} used only to\n * apply an `edit` decision. The context types `request.input` as\n * `readonly`, but the agent dispatch reads `request.input` (the SAME\n * object) when it invokes the real tool *after* the `tool.before`\n * pipeline returns — so reassigning it here is how an edited-args\n * decision reaches the tool. This narrow local type makes that one\n * deliberate write explicit instead of casting away the whole context.\n */\ninterface MutableToolRequest {\n  input: unknown;\n}\n\n/**\n * Derive the read-only {@link PolicyContext} the policy + request are\n * built from out of the wrapping {@link MiddlewareToolContext}.\n */\nfunction toPolicyContext(ctx: MiddlewareToolContext): PolicyContext {\n  return {\n    toolName: ctx.tool.name,\n    toolDescription: ctx.tool.description,\n    args: ctx.request.input,\n    agentName: ctx.agent.name,\n    tripIndex: ctx.tripIndex,\n    sessionId: ctx.options?.sessionId,\n  };\n}\n\n/**\n * Generate a stable, unique id for a pending interrupt. Shaped\n * `${agentName}.${sessionId ?? \"nosession\"}.${tripIndex}.${random}` so a\n * reviewer can eyeball the originating run, while the trailing random\n * segment guarantees per-call uniqueness even within one trip.\n */\nfunction makeInterruptId(ctx: MiddlewareToolContext): string {\n  const session = ctx.options?.sessionId ?? \"nosession\";\n  const random = generateRunId(\"interrupt\");\n\n  return `${ctx.agent.name}.${session}.${ctx.tripIndex}.${random}`;\n}\n\n/**\n * Build the {@link ApprovalRequest} a human rules on, from the tool\n * context and the policy-derived tags.\n */\nfunction buildRequest(\n  ctx: MiddlewareToolContext,\n  interruptId: string,\n  tags: string[] | undefined,\n): ApprovalRequest {\n  return {\n    interruptId,\n    toolName: ctx.tool.name,\n    toolDescription: ctx.tool.description,\n    args: ctx.request.input,\n    context: {\n      agentName: ctx.agent.name,\n      tripIndex: ctx.tripIndex,\n      sessionId: ctx.options?.sessionId,\n      originalInput: ctx.input,\n      ...(tags ? { tags } : {}),\n    },\n    requestedAt: new Date().toISOString(),\n  };\n}\n\n/**\n * Synthesize a failed {@link ToolInvokeResult} carrying a typed error.\n *\n * The approval middleware returns this from `tool.before` to\n * **short-circuit** the real tool without throwing: the pipeline treats a\n * defined return as the tool's result, the agent records a failed\n * `ToolCall`, and the model sees `{ error }` on the next trip — exactly\n * the existing tool-error feedback path. Used for both `reject`\n * (`ApprovalRejectedError`) and durable suspend (`InterruptSuspendedError`).\n */\nfunction failedResult(error: AIError, toolName: string): ToolInvokeResult<unknown> {\n  const runId = generateRunId(\"tool\");\n  const nowIso = new Date().toISOString();\n\n  const report: BaseReport = {\n    runId,\n    rootRunId: runId,\n    name: toolName,\n    type: \"tool\",\n    status: \"failed\",\n    startedAt: nowIso,\n    endedAt: nowIso,\n    duration: 0,\n    usage: ZERO_USAGE,\n    children: [],\n  };\n\n  return { error, usage: ZERO_USAGE, report };\n}\n\n/**\n * Human-in-the-loop approval gate for an agent's tool calls — the\n * middleware behind `ai.human.approval(options)`.\n *\n * **Role.** Pauses *before a specific tool call* and routes it to a human\n * who can **approve** (run the real tool unchanged), **reject** (the model\n * sees a typed error and self-corrects), or **edit** (run the tool with\n * reviewer-replaced args). The dangerous subset is chosen by an\n * {@link import(\"./contracts\").InterruptPolicy} (allowlist / denylist /\n * predicate); every other call passes through untouched.\n *\n * **One hook.** Declares only `tool.before`. On each tool dispatch it:\n * 1. evaluates the policy — not gated → returns `void`, the real tool runs;\n * 2. for a gated call, builds an {@link ApprovalRequest} and calls the\n *    {@link import(\"./contracts\").ApprovalHandler};\n * 3. applies the returned {@link ApprovalDecision}:\n *    - `approve` → returns `void`, the real tool runs;\n *    - `reject` → short-circuits a failed `ToolInvokeResult` carrying an\n *      {@link ApprovalRejectedError} (the reviewer's `reason` reaches the\n *      model);\n *    - `edit` → rewrites `ctx.request.input` to the reviewer's args and\n *      returns `void`, so the real tool runs with the edited args (schema\n *      validation still applies — bad edits surface as a tool error).\n *\n * **Durable mode.** When a `store` is configured and the handler throws\n * {@link InterruptSuspendedError} (after persisting the interrupt\n * out-of-band), the middleware catches its **own** sentinel and\n * short-circuits a failed result carrying it — so the caller reads\n * `result.error.interruptId` and later calls\n * `ai.human.resume(interruptId, decision)`. The middleware **never throws\n * out of the pipeline**: every outcome (skip, approve, reject, edit,\n * suspend) returns normally; only a *handler bug* (a non-sentinel throw)\n * propagates, and even then the agent dispatch funnels it onto\n * `result.error` — `execute()` still never throws.\n *\n * @param options - Policy, handler, optional durable store, optional name.\n * @returns An {@link AgentMiddleware} declaring a single `tool.before` hook.\n *\n * @example\n * const support = ai.agent({\n *   model,\n *   tools: [refundCustomer],\n *   middleware: [\n *     humanApproval({\n *       policy: { type: \"allowlist\", tools: [\"refundCustomer\"], tags: () => [\"money\"] },\n *       handler: async (req) => ui.prompt(req), // { type: \"edit\", args: { amount: 5 } }\n *     }),\n *   ],\n * });\n */\nexport function humanApproval(options: HumanApprovalOptions): AgentMiddleware {\n  const name = options.name ?? DEFAULT_NAME;\n  const { policy, handler } = options;\n\n  return {\n    name,\n    tool: {\n      async before(\n        ctx: MiddlewareToolContext,\n      ): Promise<ToolInvokeResult<unknown> | void> {\n        const verdict = evaluatePolicy(policy, toPolicyContext(ctx));\n\n        // Not gated — let the real tool run unchanged.\n        if (!verdict.requiresApproval) {\n          return;\n        }\n\n        const interruptId = makeInterruptId(ctx);\n        const request = buildRequest(ctx, interruptId, verdict.tags);\n\n        // Durable resume: `ai.human.resume(...)` re-runs this same agent\n        // with the human's decision pre-seeded (keyed by agent name). On a\n        // hit we replay the seeded decision exactly once and skip the\n        // author's handler entirely — the gated call resolves to the\n        // ruling instead of pausing again.\n        const seeded = takeSeededDecision(ctx.agent.name);\n\n        let decision: ApprovalDecision;\n\n        if (seeded !== undefined) {\n          decision = seeded;\n        } else {\n          try {\n            decision = await handler(request);\n          } catch (thrown) {\n            // A durable handler signals suspension by throwing our OWN\n            // sentinel after persisting the interrupt. Recognize it and\n            // short-circuit a failed result carrying it — the caller reads\n            // `error.interruptId` and resumes later. Any OTHER throw is a\n            // handler bug; re-throw so the agent dispatch funnels it onto\n            // `result.error` (we never swallow a bug into silent approval).\n            if (thrown instanceof InterruptSuspendedError) {\n              return failedResult(thrown, ctx.tool.name);\n            }\n\n            throw thrown;\n          }\n        }\n\n        if (decision.type === \"approve\") {\n          // Run the real tool with the model's original args.\n          return;\n        }\n\n        if (decision.type === \"reject\") {\n          const error = new ApprovalRejectedError(\n            `Tool call \"${ctx.tool.name}\" rejected by reviewer — ${decision.reason}`,\n            { reason: decision.reason, toolName: ctx.tool.name },\n          );\n\n          return failedResult(error, ctx.tool.name);\n        }\n\n        // `edit` — rewrite the pending args, then let the real tool run.\n        // The agent dispatch reads `request.input` (this same object) when\n        // it invokes the tool after this hook returns, so the reassignment\n        // takes effect. Bad edits still fail the tool's own schema check.\n        (ctx.request as unknown as MutableToolRequest).input = decision.args;\n\n        return;\n      },\n    },\n  };\n}\n"],"mappings":";;;;;;;AAkBA,MAAM,eAAe;;AAGrB,MAAM,aAAoB,OAAO,OAAO;CAAE,OAAO;CAAG,QAAQ;CAAG,OAAO;AAAE,CAAC;;;;;AAmBzE,SAAS,gBAAgB,KAA2C;CAClE,OAAO;EACL,UAAU,IAAI,KAAK;EACnB,iBAAiB,IAAI,KAAK;EAC1B,MAAM,IAAI,QAAQ;EAClB,WAAW,IAAI,MAAM;EACrB,WAAW,IAAI;EACf,WAAW,IAAI,SAAS;CAC1B;AACF;;;;;;;AAQA,SAAS,gBAAgB,KAAoC;CAC3D,MAAM,UAAU,IAAI,SAAS,aAAa;CAC1C,MAAM,SAAS,cAAc,WAAW;CAExC,OAAO,GAAG,IAAI,MAAM,KAAK,GAAG,QAAQ,GAAG,IAAI,UAAU,GAAG;AAC1D;;;;;AAMA,SAAS,aACP,KACA,aACA,MACiB;CACjB,OAAO;EACL;EACA,UAAU,IAAI,KAAK;EACnB,iBAAiB,IAAI,KAAK;EAC1B,MAAM,IAAI,QAAQ;EAClB,SAAS;GACP,WAAW,IAAI,MAAM;GACrB,WAAW,IAAI;GACf,WAAW,IAAI,SAAS;GACxB,eAAe,IAAI;GACnB,GAAI,OAAO,EAAE,KAAK,IAAI,CAAC;EACzB;EACA,8BAAa,IAAI,KAAK,EAAC,CAAC,YAAY;CACtC;AACF;;;;;;;;;;;AAYA,SAAS,aAAa,OAAgB,UAA6C;CACjF,MAAM,QAAQ,cAAc,MAAM;CAClC,MAAM,0BAAS,IAAI,KAAK,EAAC,CAAC,YAAY;CAetC,OAAO;EAAE;EAAO,OAAO;EAAY;GAZjC;GACA,WAAW;GACX,MAAM;GACN,MAAM;GACN,QAAQ;GACR,WAAW;GACX,SAAS;GACT,UAAU;GACV,OAAO;GACP,UAAU,CAAC;EAG2B;CAAE;AAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDA,SAAgB,cAAc,SAAgD;CAC5E,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,EAAE,QAAQ,YAAY;CAE5B,OAAO;EACL;EACA,MAAM,EACJ,MAAM,OACJ,KAC2C;GAC3C,MAAM,UAAU,eAAe,QAAQ,gBAAgB,GAAG,CAAC;GAG3D,IAAI,CAAC,QAAQ,kBACX;GAIF,MAAM,UAAU,aAAa,KADT,gBAAgB,GACQ,GAAG,QAAQ,IAAI;GAO3D,MAAM,SAAS,mBAAmB,IAAI,MAAM,IAAI;GAEhD,IAAI;GAEJ,IAAI,WAAW,QACb,WAAW;QAEX,IAAI;IACF,WAAW,MAAM,QAAQ,OAAO;GAClC,SAAS,QAAQ;IAOf,IAAI,kBAAkB,yBACpB,OAAO,aAAa,QAAQ,IAAI,KAAK,IAAI;IAG3C,MAAM;GACR;GAGF,IAAI,SAAS,SAAS,WAEpB;GAGF,IAAI,SAAS,SAAS,UAMpB,OAAO,aAAa,IALF,sBAChB,cAAc,IAAI,KAAK,KAAK,2BAA2B,SAAS,UAChE;IAAE,QAAQ,SAAS;IAAQ,UAAU,IAAI,KAAK;GAAK,CAG7B,GAAG,IAAI,KAAK,IAAI;GAO1C,AAAC,IAAI,QAA0C,QAAQ,SAAS;EAGlE,EACF;CACF;AACF"}

package/esm/ai/src/human/policy.mjs

@@ -1,67 +0,0 @@
-//#region ../@warlock.js/ai/src/human/policy.ts
-/**
-* A verdict that lets a call through untouched. Frozen and shared so the
-* (common) skip path allocates nothing.
-*/
-const SKIP = Object.freeze({ requiresApproval: false });
-/**
-* Normalize an author-supplied tags array into the verdict shape — an
-* empty array is treated as "no tags" so callers never have to
-* distinguish `[]` from `undefined`.
-*/
-function withTags(tags) {
-	if (tags === void 0 || tags.length === 0) return { requiresApproval: true };
-	return {
-		requiresApproval: true,
-		tags
-	};
-}
-/**
-* Decide whether a single pending tool call requires human approval —
-* the pure core behind the `ai.human.approval` middleware's gate.
-*
-* **Pure.** No IO, no throwing, no mutation of `policy` or `context`. The
-* middleware calls this once per tool dispatch and routes to a human only
-* when {@link PolicyVerdict.requiresApproval} is `true`.
-*
-* **The three rule types** ({@link InterruptPolicy}):
-* - `allowlist` — gate the call **only** when its tool name is listed; an
-*   optional `tags(toolName)` callback derives the verdict tags.
-* - `denylist` — gate **every** call **except** the listed tool names;
-*   the same optional `tags(toolName)` callback applies to the gated
-*   (non-listed) name.
-* - `predicate` — gate the call when `requiresApproval(context)` returns a
-*   truthy result. A non-empty `string[]` both gates the call **and**
-*   supplies the verdict tags; `true` gates with no tags; `false` (or an
-*   **empty** array — "no rule matched") lets the call through.
-*
-* @param policy - The interrupt policy to evaluate.
-* @param context - The read-only view of the pending tool call.
-* @returns A {@link PolicyVerdict} — gate-or-skip plus any tags.
-*
-* @example
-* const verdict = evaluatePolicy(
-*   { type: "allowlist", tools: ["refundCustomer"], tags: () => ["money"] },
-*   { toolName: "refundCustomer", args: { amount: 50 }, agentName: "support", tripIndex: 0 },
-* );
-* // → { requiresApproval: true, tags: ["money"] }
-*/
-function evaluatePolicy(policy, context) {
-	if (policy.type === "allowlist") {
-		if (!policy.tools.includes(context.toolName)) return SKIP;
-		return withTags(policy.tags?.(context.toolName));
-	}
-	if (policy.type === "denylist") {
-		if (policy.tools.includes(context.toolName)) return SKIP;
-		return withTags(policy.tags?.(context.toolName));
-	}
-	const outcome = policy.requiresApproval(context);
-	if (outcome === false) return SKIP;
-	if (outcome === true) return { requiresApproval: true };
-	if (outcome.length === 0) return SKIP;
-	return withTags(outcome);
-}
-
-//#endregion
-export { evaluatePolicy };
-//# sourceMappingURL=policy.mjs.map

package/esm/ai/src/human/policy.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"policy.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/human/policy.ts"],"sourcesContent":["import type { InterruptPolicy, PolicyContext } from \"./contracts\";\n\n/**\n * Verdict of evaluating an {@link InterruptPolicy} against a single\n * pending tool call.\n *\n * - `requiresApproval` — `true` when the call must be routed to a human\n *   before the real tool runs; `false` when the policy lets it through\n *   untouched.\n * - `tags` — author-supplied labels from the matched rule (e.g.\n *   `\"destructive\"`, `\"money\"`), surfaced verbatim on the resulting\n *   `ApprovalRequest.context.tags`. Only ever present when\n *   `requiresApproval` is `true`; `undefined` when the rule produced no\n *   tags.\n */\nexport interface PolicyVerdict {\n  /** Whether this tool call must be approved by a human. */\n  requiresApproval: boolean;\n\n  /** Author-supplied tags from the matched rule, when any. */\n  tags?: string[];\n}\n\n/**\n * A verdict that lets a call through untouched. Frozen and shared so the\n * (common) skip path allocates nothing.\n */\nconst SKIP: PolicyVerdict = Object.freeze({ requiresApproval: false });\n\n/**\n * Normalize an author-supplied tags array into the verdict shape — an\n * empty array is treated as \"no tags\" so callers never have to\n * distinguish `[]` from `undefined`.\n */\nfunction withTags(tags: string[] | undefined): PolicyVerdict {\n  if (tags === undefined || tags.length === 0) {\n    return { requiresApproval: true };\n  }\n\n  return { requiresApproval: true, tags };\n}\n\n/**\n * Decide whether a single pending tool call requires human approval —\n * the pure core behind the `ai.human.approval` middleware's gate.\n *\n * **Pure.** No IO, no throwing, no mutation of `policy` or `context`. The\n * middleware calls this once per tool dispatch and routes to a human only\n * when {@link PolicyVerdict.requiresApproval} is `true`.\n *\n * **The three rule types** ({@link InterruptPolicy}):\n * - `allowlist` — gate the call **only** when its tool name is listed; an\n *   optional `tags(toolName)` callback derives the verdict tags.\n * - `denylist` — gate **every** call **except** the listed tool names;\n *   the same optional `tags(toolName)` callback applies to the gated\n *   (non-listed) name.\n * - `predicate` — gate the call when `requiresApproval(context)` returns a\n *   truthy result. A non-empty `string[]` both gates the call **and**\n *   supplies the verdict tags; `true` gates with no tags; `false` (or an\n *   **empty** array — \"no rule matched\") lets the call through.\n *\n * @param policy - The interrupt policy to evaluate.\n * @param context - The read-only view of the pending tool call.\n * @returns A {@link PolicyVerdict} — gate-or-skip plus any tags.\n *\n * @example\n * const verdict = evaluatePolicy(\n *   { type: \"allowlist\", tools: [\"refundCustomer\"], tags: () => [\"money\"] },\n *   { toolName: \"refundCustomer\", args: { amount: 50 }, agentName: \"support\", tripIndex: 0 },\n * );\n * // → { requiresApproval: true, tags: [\"money\"] }\n */\nexport function evaluatePolicy(\n  policy: InterruptPolicy,\n  context: PolicyContext,\n): PolicyVerdict {\n  if (policy.type === \"allowlist\") {\n    if (!policy.tools.includes(context.toolName)) {\n      return SKIP;\n    }\n\n    return withTags(policy.tags?.(context.toolName));\n  }\n\n  if (policy.type === \"denylist\") {\n    if (policy.tools.includes(context.toolName)) {\n      return SKIP;\n    }\n\n    return withTags(policy.tags?.(context.toolName));\n  }\n\n  // Predicate: a truthy result gates the call; a `string[]` doubles as the\n  // verdict tags.\n  const outcome = policy.requiresApproval(context);\n\n  if (outcome === false) {\n    return SKIP;\n  }\n\n  if (outcome === true) {\n    return { requiresApproval: true };\n  }\n\n  // `outcome` is a `string[]`. Per the contract, an EMPTY array means \"no\n  // rule matched\" and skips approval; a non-empty array gates the call and\n  // doubles as the verdict tags.\n  if (outcome.length === 0) {\n    return SKIP;\n  }\n\n  return withTags(outcome);\n}\n"],"mappings":";;;;;AA2BA,MAAM,OAAsB,OAAO,OAAO,EAAE,kBAAkB,MAAM,CAAC;;;;;;AAOrE,SAAS,SAAS,MAA2C;CAC3D,IAAI,SAAS,UAAa,KAAK,WAAW,GACxC,OAAO,EAAE,kBAAkB,KAAK;CAGlC,OAAO;EAAE,kBAAkB;EAAM;CAAK;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,eACd,QACA,SACe;CACf,IAAI,OAAO,SAAS,aAAa;EAC/B,IAAI,CAAC,OAAO,MAAM,SAAS,QAAQ,QAAQ,GACzC,OAAO;EAGT,OAAO,SAAS,OAAO,OAAO,QAAQ,QAAQ,CAAC;CACjD;CAEA,IAAI,OAAO,SAAS,YAAY;EAC9B,IAAI,OAAO,MAAM,SAAS,QAAQ,QAAQ,GACxC,OAAO;EAGT,OAAO,SAAS,OAAO,OAAO,QAAQ,QAAQ,CAAC;CACjD;CAIA,MAAM,UAAU,OAAO,iBAAiB,OAAO;CAE/C,IAAI,YAAY,OACd,OAAO;CAGT,IAAI,YAAY,MACd,OAAO,EAAE,kBAAkB,KAAK;CAMlC,IAAI,QAAQ,WAAW,GACrB,OAAO;CAGT,OAAO,SAAS,OAAO;AACzB"}

package/esm/ai/src/human/register.mjs

@@ -1,37 +0,0 @@
-import { humanApproval } from "./human-approval.mjs";
-import { resume } from "./resume.mjs";
-import { memory } from "./stores/memory.mjs";
-import { pg } from "./stores/pg.mjs";
-import { redis } from "./stores/redis.mjs";
-import "./stores/index.mjs";
-
-//#region ../@warlock.js/ai/src/human/register.ts
-/**
-* The assembled `ai.human.*` namespace — the human-in-the-loop surface
-* mounted onto the shared `ai` object in `../ai`.
-*
-* - `approval(options)` — the `tool.before` approval-gate middleware.
-* - `resume(id, decision, options)` — out-of-process durable resume.
-* - `interrupt.{memory,pg,redis}()` — the
-*   {@link import("./contracts").InterruptStore} factories (memory ships
-*   real; pg/redis lazily import their optional-peer driver).
-*
-* Declared as a standalone object so `../ai` can spread it onto the `ai`
-* literal and pin the `Ai.human` member to this exact shape with no casts.
-* Lives here (not inlined into `../ai`) to keep the human factories grouped
-* with the rest of the human module and avoid `../ai` reaching into each
-* store/middleware file directly.
-*/
-const human = {
-	approval: humanApproval,
-	resume,
-	interrupt: {
-		memory,
-		pg,
-		redis
-	}
-};
-
-//#endregion
-export { human };
-//# sourceMappingURL=register.mjs.map

package/esm/ai/src/human/register.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"register.mjs","names":["interruptMemory","interruptPg","interruptRedis"],"sources":["../../../../../../../../../@warlock.js/ai/src/human/register.ts"],"sourcesContent":["import { humanApproval } from \"./human-approval\";\nimport { resume } from \"./resume\";\nimport { interruptMemory, interruptPg, interruptRedis } from \"./stores\";\n\n/**\n * The assembled `ai.human.*` namespace — the human-in-the-loop surface\n * mounted onto the shared `ai` object in `../ai`.\n *\n * - `approval(options)` — the `tool.before` approval-gate middleware.\n * - `resume(id, decision, options)` — out-of-process durable resume.\n * - `interrupt.{memory,pg,redis}()` — the\n *   {@link import(\"./contracts\").InterruptStore} factories (memory ships\n *   real; pg/redis lazily import their optional-peer driver).\n *\n * Declared as a standalone object so `../ai` can spread it onto the `ai`\n * literal and pin the `Ai.human` member to this exact shape with no casts.\n * Lives here (not inlined into `../ai`) to keep the human factories grouped\n * with the rest of the human module and avoid `../ai` reaching into each\n * store/middleware file directly.\n */\nexport const human = {\n  approval: humanApproval,\n  resume,\n  interrupt: {\n    memory: interruptMemory,\n    pg: interruptPg,\n    redis: interruptRedis,\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,QAAQ;CACnB,UAAU;CACV;CACA,WAAW;EACDA;EACJC;EACGC;CACT;AACF"}

package/esm/ai/src/human/resume-seed.mjs

@@ -1,53 +0,0 @@
-//#region ../@warlock.js/ai/src/human/resume-seed.ts
-/**
-* Process-local registry of decisions pre-seeded for a durable re-run.
-*
-* **Why it exists.** v1 durable resume re-runs the *same* agent turn with
-* the human's decision already in hand (it does **not** rehydrate an
-* in-flight supervisor — that is the deferred v2 lift). The agent's
-* `ai.human.approval(...)` middleware is baked in at construction, so the
-* re-run cannot be handed a different handler. Instead, `ai.human.resume(...)`
-* stashes the decision here keyed by the agent name; the approval
-* middleware's handler consults the registry **before** calling the
-* author's handler and, on a hit, replays the seeded decision exactly once
-* — so the gated tool call this time resolves to the human's ruling instead
-* of pausing again.
-*
-* Keyed by agent name (not interrupt id): the re-run produces a *fresh*
-* interrupt id (the id embeds a random segment), so the seed must be
-* matched to the run, not the prior id. The registry holds at most one
-* seeded decision per agent and consumes it on first read, so a second
-* gated call in the same re-run falls through to the author's handler.
-*/
-const seededDecisions = /* @__PURE__ */ new Map();
-/**
-* Stash a decision to be replayed on the next gated tool call of `agentName`.
-* Overwrites any prior seed for the same agent (a re-run carries exactly one
-* pre-seeded decision).
-*/
-function seedDecision(agentName, decision) {
-	seededDecisions.set(agentName, decision);
-}
-/**
-* Take (read **and** remove) the seeded decision for `agentName`, or
-* `undefined` when none is staged. Consuming on read makes the seed
-* one-shot: only the first gated call of a re-run replays it.
-*/
-function takeSeededDecision(agentName) {
-	const decision = seededDecisions.get(agentName);
-	if (decision === void 0) return;
-	seededDecisions.delete(agentName);
-	return decision;
-}
-/**
-* Drop any staged seed for `agentName` without consuming it as a decision.
-* Used to clean up after a re-run that errored before the seeded call fired,
-* so a stale seed never leaks into an unrelated later run of the same agent.
-*/
-function clearSeededDecision(agentName) {
-	seededDecisions.delete(agentName);
-}
-
-//#endregion
-export { clearSeededDecision, seedDecision, takeSeededDecision };
-//# sourceMappingURL=resume-seed.mjs.map

package/esm/ai/src/human/resume-seed.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"resume-seed.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/human/resume-seed.ts"],"sourcesContent":["import type { ApprovalDecision } from \"./contracts\";\n\n/**\n * Process-local registry of decisions pre-seeded for a durable re-run.\n *\n * **Why it exists.** v1 durable resume re-runs the *same* agent turn with\n * the human's decision already in hand (it does **not** rehydrate an\n * in-flight supervisor — that is the deferred v2 lift). The agent's\n * `ai.human.approval(...)` middleware is baked in at construction, so the\n * re-run cannot be handed a different handler. Instead, `ai.human.resume(...)`\n * stashes the decision here keyed by the agent name; the approval\n * middleware's handler consults the registry **before** calling the\n * author's handler and, on a hit, replays the seeded decision exactly once\n * — so the gated tool call this time resolves to the human's ruling instead\n * of pausing again.\n *\n * Keyed by agent name (not interrupt id): the re-run produces a *fresh*\n * interrupt id (the id embeds a random segment), so the seed must be\n * matched to the run, not the prior id. The registry holds at most one\n * seeded decision per agent and consumes it on first read, so a second\n * gated call in the same re-run falls through to the author's handler.\n */\nconst seededDecisions = new Map<string, ApprovalDecision>();\n\n/**\n * Stash a decision to be replayed on the next gated tool call of `agentName`.\n * Overwrites any prior seed for the same agent (a re-run carries exactly one\n * pre-seeded decision).\n */\nexport function seedDecision(agentName: string, decision: ApprovalDecision): void {\n  seededDecisions.set(agentName, decision);\n}\n\n/**\n * Take (read **and** remove) the seeded decision for `agentName`, or\n * `undefined` when none is staged. Consuming on read makes the seed\n * one-shot: only the first gated call of a re-run replays it.\n */\nexport function takeSeededDecision(agentName: string): ApprovalDecision | undefined {\n  const decision = seededDecisions.get(agentName);\n\n  if (decision === undefined) {\n    return undefined;\n  }\n\n  seededDecisions.delete(agentName);\n\n  return decision;\n}\n\n/**\n * Drop any staged seed for `agentName` without consuming it as a decision.\n * Used to clean up after a re-run that errored before the seeded call fired,\n * so a stale seed never leaks into an unrelated later run of the same agent.\n */\nexport function clearSeededDecision(agentName: string): void {\n  seededDecisions.delete(agentName);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,MAAM,kCAAkB,IAAI,IAA8B;;;;;;AAO1D,SAAgB,aAAa,WAAmB,UAAkC;CAChF,gBAAgB,IAAI,WAAW,QAAQ;AACzC;;;;;;AAOA,SAAgB,mBAAmB,WAAiD;CAClF,MAAM,WAAW,gBAAgB,IAAI,SAAS;CAE9C,IAAI,aAAa,QACf;CAGF,gBAAgB,OAAO,SAAS;CAEhC,OAAO;AACT;;;;;;AAOA,SAAgB,oBAAoB,WAAyB;CAC3D,gBAAgB,OAAO,SAAS;AAClC"}

package/esm/ai/src/human/resume.mjs

@@ -1,121 +0,0 @@
-import { clearSeededDecision, seedDecision } from "./resume-seed.mjs";
-
-//#region ../@warlock.js/ai/src/human/resume.ts
-/**
-* Validate that a decision is a well-formed {@link ApprovalDecision}.
-*
-* `ai.human.resume(...)` is a public, out-of-process entry point — a
-* webhook can hand it anything. Guard the closed `type` union (and the
-* per-variant required fields) before applying it, so a malformed payload
-* fails loudly here rather than silently mis-driving the re-run.
-*/
-function assertDecision(decision) {
-	if (decision.type === "approve") return;
-	if (decision.type === "reject") {
-		if (typeof decision.reason !== "string") throw new TypeError("ai.human.resume: a 'reject' decision requires a string 'reason'.");
-		return;
-	}
-	if (decision.type === "edit") {
-		if (!("args" in decision)) throw new TypeError("ai.human.resume: an 'edit' decision requires replacement 'args'.");
-		return;
-	}
-	throw new TypeError(`ai.human.resume: unknown decision type '${decision.type}'. Expected one of: approve, reject, edit.`);
-}
-/**
-* Re-run the agent for a resumed interrupt with the decision pre-seeded.
-*
-* Stages the decision in the process-local seed registry (keyed by agent
-* name), then re-executes the original prompt. The agent's
-* `ai.human.approval(...)` middleware consumes the seed on the gated tool
-* call — so this time it resolves to the human's ruling instead of pausing
-* again. The seed is cleared in a `finally` so a re-run that errors before
-* the gated call never leaks a stale seed into a later run.
-*/
-async function rerun(pending, decision, options) {
-	const { agent } = options;
-	if (!agent) return {
-		type: "applied",
-		interruptId: pending.interruptId,
-		decision
-	};
-	const input = options.input ?? pending.request.context.originalInput ?? "";
-	seedDecision(agent.name, decision);
-	try {
-		const result = await agent.execute(input, options.executeOptions);
-		return {
-			type: "applied",
-			interruptId: pending.interruptId,
-			decision,
-			result
-		};
-	} finally {
-		clearSeededDecision(agent.name);
-	}
-}
-/**
-* Apply a human's decision to a persisted interrupt — the out-of-process
-* resume entry point behind `ai.human.resume(interruptId, decision, options)`.
-*
-* **Durable v1 model — re-run, not mid-supervisor suspend.** This loads the
-* {@link PendingInterrupt} from `options.store`, validates the decision,
-* deletes the pending record, and (when an `agent` is supplied) re-executes
-* the original turn with the decision **pre-seeded**, so the gated tool call
-* resolves to the ruling instead of pausing again. It does **not** rehydrate
-* an in-flight supervisor — that is the deferred v2 lift.
-*
-* **Idempotent.** A second resume of an already-resolved (deleted) or
-* never-raised interrupt is a no-op: it returns `{ type: "already-resolved" }`
-* without re-applying the decision or re-running the turn — mirroring the
-* orchestrator resume's drain idempotency. The record is deleted **before**
-* the re-run, so even a re-run that itself raises a fresh interrupt cannot
-* collide with the one being resolved.
-*
-* **Two shapes** (see {@link ResumeOptions}):
-* - **apply-only** — omit `agent`: load, validate, delete, return
-*   `{ type: "applied", decision }` for a caller-owned re-drive.
-* - **re-run** — pass `agent`: additionally re-execute the turn; the
-*   {@link import("@warlock.js/ai").AgentResult} rides `result.result`.
-*
-* @param interruptId - Id of the persisted interrupt to resolve.
-* @param decision - The human's ruling (approve / reject / edit).
-* @param options - The durable `store` (required) plus optional re-run
-*   `agent` / `input` / `executeOptions`.
-* @returns A {@link ResumeResult} — `"applied"` or idempotent
-*   `"already-resolved"`.
-*
-* @example
-* // Process B (webhook, hours later) — apply-only:
-* const outcome = await ai.human.resume(interruptId, { type: "reject", reason: "Out of policy" }, {
-*   store,
-* });
-*
-* @example
-* // Re-run the turn with the decision pre-seeded:
-* const outcome = await ai.human.resume(interruptId, { type: "edit", args: { amount: 5 } }, {
-*   store,
-*   agent: support,
-* });
-* if (outcome.type === "applied" && outcome.result) {
-*   console.log(outcome.result.text);
-* }
-*/
-async function resume(interruptId, decision, options) {
-	assertDecision(decision);
-	const { store } = options;
-	const pending = await store.load(interruptId);
-	if (pending === void 0 || pending.status !== "pending") return {
-		type: "already-resolved",
-		interruptId
-	};
-	await store.delete(interruptId);
-	if (!options.agent) return {
-		type: "applied",
-		interruptId,
-		decision
-	};
-	return rerun(pending, decision, options);
-}
-
-//#endregion
-export { resume };
-//# sourceMappingURL=resume.mjs.map

package/esm/ai/src/human/resume.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"resume.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/human/resume.ts"],"sourcesContent":["import type {\n  ApprovalDecision,\n  PendingInterrupt,\n  ResumeOptions,\n  ResumeResult,\n} from \"./contracts\";\nimport { clearSeededDecision, seedDecision } from \"./resume-seed\";\n\n/**\n * Validate that a decision is a well-formed {@link ApprovalDecision}.\n *\n * `ai.human.resume(...)` is a public, out-of-process entry point — a\n * webhook can hand it anything. Guard the closed `type` union (and the\n * per-variant required fields) before applying it, so a malformed payload\n * fails loudly here rather than silently mis-driving the re-run.\n */\nfunction assertDecision(decision: ApprovalDecision): void {\n  if (decision.type === \"approve\") {\n    return;\n  }\n\n  if (decision.type === \"reject\") {\n    if (typeof decision.reason !== \"string\") {\n      throw new TypeError(\n        \"ai.human.resume: a 'reject' decision requires a string 'reason'.\",\n      );\n    }\n\n    return;\n  }\n\n  if (decision.type === \"edit\") {\n    if (!(\"args\" in decision)) {\n      throw new TypeError(\n        \"ai.human.resume: an 'edit' decision requires replacement 'args'.\",\n      );\n    }\n\n    return;\n  }\n\n  throw new TypeError(\n    `ai.human.resume: unknown decision type '${(decision as { type: string }).type}'. Expected one of: approve, reject, edit.`,\n  );\n}\n\n/**\n * Re-run the agent for a resumed interrupt with the decision pre-seeded.\n *\n * Stages the decision in the process-local seed registry (keyed by agent\n * name), then re-executes the original prompt. The agent's\n * `ai.human.approval(...)` middleware consumes the seed on the gated tool\n * call — so this time it resolves to the human's ruling instead of pausing\n * again. The seed is cleared in a `finally` so a re-run that errors before\n * the gated call never leaks a stale seed into a later run.\n */\nasync function rerun<TOutput>(\n  pending: PendingInterrupt,\n  decision: ApprovalDecision,\n  options: ResumeOptions<TOutput>,\n): Promise<ResumeResult<TOutput>> {\n  const { agent } = options;\n\n  // `agent` is guaranteed by the caller (this is only reached on the\n  // re-run path), but narrow for the type system.\n  if (!agent) {\n    return { type: \"applied\", interruptId: pending.interruptId, decision };\n  }\n\n  const input = options.input ?? pending.request.context.originalInput ?? \"\";\n\n  seedDecision(agent.name, decision);\n\n  try {\n    const result = await agent.execute(input, options.executeOptions);\n\n    return {\n      type: \"applied\",\n      interruptId: pending.interruptId,\n      decision,\n      result,\n    };\n  } finally {\n    // If the seeded call never fired (the re-run errored early, or the\n    // policy no longer gates the tool), drop the stale seed so it cannot\n    // leak into an unrelated later run of the same agent.\n    clearSeededDecision(agent.name);\n  }\n}\n\n/**\n * Apply a human's decision to a persisted interrupt — the out-of-process\n * resume entry point behind `ai.human.resume(interruptId, decision, options)`.\n *\n * **Durable v1 model — re-run, not mid-supervisor suspend.** This loads the\n * {@link PendingInterrupt} from `options.store`, validates the decision,\n * deletes the pending record, and (when an `agent` is supplied) re-executes\n * the original turn with the decision **pre-seeded**, so the gated tool call\n * resolves to the ruling instead of pausing again. It does **not** rehydrate\n * an in-flight supervisor — that is the deferred v2 lift.\n *\n * **Idempotent.** A second resume of an already-resolved (deleted) or\n * never-raised interrupt is a no-op: it returns `{ type: \"already-resolved\" }`\n * without re-applying the decision or re-running the turn — mirroring the\n * orchestrator resume's drain idempotency. The record is deleted **before**\n * the re-run, so even a re-run that itself raises a fresh interrupt cannot\n * collide with the one being resolved.\n *\n * **Two shapes** (see {@link ResumeOptions}):\n * - **apply-only** — omit `agent`: load, validate, delete, return\n *   `{ type: \"applied\", decision }` for a caller-owned re-drive.\n * - **re-run** — pass `agent`: additionally re-execute the turn; the\n *   {@link import(\"@warlock.js/ai\").AgentResult} rides `result.result`.\n *\n * @param interruptId - Id of the persisted interrupt to resolve.\n * @param decision - The human's ruling (approve / reject / edit).\n * @param options - The durable `store` (required) plus optional re-run\n *   `agent` / `input` / `executeOptions`.\n * @returns A {@link ResumeResult} — `\"applied\"` or idempotent\n *   `\"already-resolved\"`.\n *\n * @example\n * // Process B (webhook, hours later) — apply-only:\n * const outcome = await ai.human.resume(interruptId, { type: \"reject\", reason: \"Out of policy\" }, {\n *   store,\n * });\n *\n * @example\n * // Re-run the turn with the decision pre-seeded:\n * const outcome = await ai.human.resume(interruptId, { type: \"edit\", args: { amount: 5 } }, {\n *   store,\n *   agent: support,\n * });\n * if (outcome.type === \"applied\" && outcome.result) {\n *   console.log(outcome.result.text);\n * }\n */\nexport async function resume<TOutput = unknown>(\n  interruptId: string,\n  decision: ApprovalDecision,\n  options: ResumeOptions<TOutput>,\n): Promise<ResumeResult<TOutput>> {\n  assertDecision(decision);\n\n  const { store } = options;\n  const pending = await store.load(interruptId);\n\n  // No live interrupt — already resolved + deleted, or never raised. Never\n  // double-apply; never re-run. Idempotent no-op.\n  if (pending === undefined || pending.status !== \"pending\") {\n    return { type: \"already-resolved\", interruptId };\n  }\n\n  // Resolve + delete BEFORE the re-run so a re-run that itself raises a new\n  // interrupt cannot collide with the one being resolved, and a concurrent\n  // resume of the same id sees it gone.\n  await store.delete(interruptId);\n\n  if (!options.agent) {\n    return { type: \"applied\", interruptId, decision };\n  }\n\n  return rerun(pending, decision, options);\n}\n"],"mappings":";;;;;;;;;;;AAgBA,SAAS,eAAe,UAAkC;CACxD,IAAI,SAAS,SAAS,WACpB;CAGF,IAAI,SAAS,SAAS,UAAU;EAC9B,IAAI,OAAO,SAAS,WAAW,UAC7B,MAAM,IAAI,UACR,kEACF;EAGF;CACF;CAEA,IAAI,SAAS,SAAS,QAAQ;EAC5B,IAAI,EAAE,UAAU,WACd,MAAM,IAAI,UACR,kEACF;EAGF;CACF;CAEA,MAAM,IAAI,UACR,2CAA4C,SAA8B,KAAK,2CACjF;AACF;;;;;;;;;;;AAYA,eAAe,MACb,SACA,UACA,SACgC;CAChC,MAAM,EAAE,UAAU;CAIlB,IAAI,CAAC,OACH,OAAO;EAAE,MAAM;EAAW,aAAa,QAAQ;EAAa;CAAS;CAGvE,MAAM,QAAQ,QAAQ,SAAS,QAAQ,QAAQ,QAAQ,iBAAiB;CAExE,aAAa,MAAM,MAAM,QAAQ;CAEjC,IAAI;EACF,MAAM,SAAS,MAAM,MAAM,QAAQ,OAAO,QAAQ,cAAc;EAEhE,OAAO;GACL,MAAM;GACN,aAAa,QAAQ;GACrB;GACA;EACF;CACF,UAAU;EAIR,oBAAoB,MAAM,IAAI;CAChC;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,eAAsB,OACpB,aACA,UACA,SACgC;CAChC,eAAe,QAAQ;CAEvB,MAAM,EAAE,UAAU;CAClB,MAAM,UAAU,MAAM,MAAM,KAAK,WAAW;CAI5C,IAAI,YAAY,UAAa,QAAQ,WAAW,WAC9C,OAAO;EAAE,MAAM;EAAoB;CAAY;CAMjD,MAAM,MAAM,OAAO,WAAW;CAE9B,IAAI,CAAC,QAAQ,OACX,OAAO;EAAE,MAAM;EAAW;EAAa;CAAS;CAGlD,OAAO,MAAM,SAAS,UAAU,OAAO;AACzC"}

package/esm/ai/src/human/stores/index.mjs

@@ -1,5 +0,0 @@
-import { memory } from "./memory.mjs";
-import { pg } from "./pg.mjs";
-import { redis } from "./redis.mjs";
-
-export {  };

package/esm/ai/src/human/stores/memory.mjs

@@ -1,91 +0,0 @@
-//#region ../@warlock.js/ai/src/human/stores/memory.ts
-/**
-* In-memory {@link InterruptStore} — pending interrupts held in a
-* process-local `Map`, never persisted to disk.
-*
-* Owns: the `interruptId → {@link PendingInterrupt}` index and the
-* last-writer-wins `save` / `load` / `delete` / `list` semantics the
-* contract declares. Does NOT own: durability, cross-process sharing, or
-* TTL eviction — it is the zero-config default for dev, tests, and
-* single-process apps whose approval flow stays interactive (the run
-* `await`s the decision in-process and never needs to survive a restart).
-* Reach for `ai.human.interrupt.pg()` / `ai.human.interrupt.redis()` when
-* a reviewer rules out-of-process, hours later.
-*
-* Front it with the {@link memory} factory — callers never `new` it.
-*/
-var MemoryInterruptStore = class {
-	constructor() {
-		this.interrupts = /* @__PURE__ */ new Map();
-	}
-	/**
-	* Persist a pending interrupt, keyed by its own `interruptId`.
-	* Overwrites any prior record for the same id — a call has exactly one
-	* live interrupt, so a re-save replaces rather than appends.
-	*/
-	async save(record) {
-		this.interrupts.set(record.interruptId, record);
-	}
-	/**
-	* Return the interrupt for an `interruptId`, or `undefined` when none is
-	* recorded (never raised, or already resolved + deleted).
-	*/
-	async load(interruptId) {
-		return this.interrupts.get(interruptId);
-	}
-	/**
-	* Drop the interrupt for an `interruptId`. Idempotent — deleting an
-	* absent id is a no-op.
-	*/
-	async delete(interruptId) {
-		this.interrupts.delete(interruptId);
-	}
-	/**
-	* List the interrupt ids the store knows, optionally filtered by a
-	* prefix. Returns a fresh array each call so a caller can mutate it
-	* freely without touching the backing index.
-	*/
-	async list(prefix) {
-		const ids = [...this.interrupts.keys()];
-		if (prefix === void 0) return ids;
-		return ids.filter((id) => id.startsWith(prefix));
-	}
-	/**
-	* The memory store has no backing table — there is nothing to migrate.
-	* Returns an empty string so callers can treat `schema()` uniformly
-	* across drivers.
-	*/
-	schema() {
-		return "";
-	}
-};
-/**
-* Create an in-memory {@link InterruptStore}. Zero-config — no client, no
-* connection. Suitable for dev, tests, and single-process apps whose
-* approval flow stays interactive and doesn't need resume across
-* restarts.
-*
-* @example
-* import { ai } from "@warlock.js/ai";
-*
-* const store = ai.human.interrupt.memory();
-*
-* const agent = ai.agent({
-*   model,
-*   tools: [deleteAccount],
-*   middleware: [
-*     ai.human.approval({
-*       policy: { type: "allowlist", tools: ["deleteAccount"] },
-*       store,
-*       handler,
-*     }),
-*   ],
-* });
-*/
-function memory() {
-	return new MemoryInterruptStore();
-}
-
-//#endregion
-export { memory };
-//# sourceMappingURL=memory.mjs.map

package/esm/ai/src/human/stores/memory.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/human/stores/memory.ts"],"sourcesContent":["import type {\n  InterruptStore,\n  PendingInterrupt,\n} from \"../contracts/interrupt-store.contract\";\n\n/**\n * In-memory {@link InterruptStore} — pending interrupts held in a\n * process-local `Map`, never persisted to disk.\n *\n * Owns: the `interruptId → {@link PendingInterrupt}` index and the\n * last-writer-wins `save` / `load` / `delete` / `list` semantics the\n * contract declares. Does NOT own: durability, cross-process sharing, or\n * TTL eviction — it is the zero-config default for dev, tests, and\n * single-process apps whose approval flow stays interactive (the run\n * `await`s the decision in-process and never needs to survive a restart).\n * Reach for `ai.human.interrupt.pg()` / `ai.human.interrupt.redis()` when\n * a reviewer rules out-of-process, hours later.\n *\n * Front it with the {@link memory} factory — callers never `new` it.\n */\nclass MemoryInterruptStore implements InterruptStore {\n  /** Pending interrupts keyed by their own `interruptId`. */\n  private readonly interrupts = new Map<string, PendingInterrupt>();\n\n  /**\n   * Persist a pending interrupt, keyed by its own `interruptId`.\n   * Overwrites any prior record for the same id — a call has exactly one\n   * live interrupt, so a re-save replaces rather than appends.\n   */\n  public async save(record: PendingInterrupt): Promise<void> {\n    this.interrupts.set(record.interruptId, record);\n  }\n\n  /**\n   * Return the interrupt for an `interruptId`, or `undefined` when none is\n   * recorded (never raised, or already resolved + deleted).\n   */\n  public async load(\n    interruptId: string,\n  ): Promise<PendingInterrupt | undefined> {\n    return this.interrupts.get(interruptId);\n  }\n\n  /**\n   * Drop the interrupt for an `interruptId`. Idempotent — deleting an\n   * absent id is a no-op.\n   */\n  public async delete(interruptId: string): Promise<void> {\n    this.interrupts.delete(interruptId);\n  }\n\n  /**\n   * List the interrupt ids the store knows, optionally filtered by a\n   * prefix. Returns a fresh array each call so a caller can mutate it\n   * freely without touching the backing index.\n   */\n  public async list(prefix?: string): Promise<string[]> {\n    const ids = [...this.interrupts.keys()];\n\n    if (prefix === undefined) {\n      return ids;\n    }\n\n    return ids.filter((id) => id.startsWith(prefix));\n  }\n\n  /**\n   * The memory store has no backing table — there is nothing to migrate.\n   * Returns an empty string so callers can treat `schema()` uniformly\n   * across drivers.\n   */\n  public schema(): string {\n    return \"\";\n  }\n}\n\n/**\n * Create an in-memory {@link InterruptStore}. Zero-config — no client, no\n * connection. Suitable for dev, tests, and single-process apps whose\n * approval flow stays interactive and doesn't need resume across\n * restarts.\n *\n * @example\n * import { ai } from \"@warlock.js/ai\";\n *\n * const store = ai.human.interrupt.memory();\n *\n * const agent = ai.agent({\n *   model,\n *   tools: [deleteAccount],\n *   middleware: [\n *     ai.human.approval({\n *       policy: { type: \"allowlist\", tools: [\"deleteAccount\"] },\n *       store,\n *       handler,\n *     }),\n *   ],\n * });\n */\nexport function memory(): InterruptStore {\n  return new MemoryInterruptStore();\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,IAAM,uBAAN,MAAqD;;oCAErB,IAAI,IAA8B;;;;;;;CAOhE,MAAa,KAAK,QAAyC;EACzD,KAAK,WAAW,IAAI,OAAO,aAAa,MAAM;CAChD;;;;;CAMA,MAAa,KACX,aACuC;EACvC,OAAO,KAAK,WAAW,IAAI,WAAW;CACxC;;;;;CAMA,MAAa,OAAO,aAAoC;EACtD,KAAK,WAAW,OAAO,WAAW;CACpC;;;;;;CAOA,MAAa,KAAK,QAAoC;EACpD,MAAM,MAAM,CAAC,GAAG,KAAK,WAAW,KAAK,CAAC;EAEtC,IAAI,WAAW,QACb,OAAO;EAGT,OAAO,IAAI,QAAQ,OAAO,GAAG,WAAW,MAAM,CAAC;CACjD;;;;;;CAOA,AAAO,SAAiB;EACtB,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAgB,SAAyB;CACvC,OAAO,IAAI,qBAAqB;AAClC"}