@warlock.js/ai 4.3.0 → 4.5.0

package/esm/human/stores/pg.mjs

@@ -0,0 +1,220 @@
+//#region ../@warlock.js/ai/src/human/stores/pg.ts
+/**
+* Default backing table — provisions the store with no extra config when
+* the dev runs {@link InterruptStore.schema} through their migration tool.
+*/
+const DEFAULT_TABLE = "warlock_ai_human_interrupts";
+/**
+* Allowed characters in a Postgres identifier (table name). The table name
+* is interpolated into DDL/DML, so anything outside this conservative
+* ASCII subset is rejected — interpolating an arbitrary string would be a
+* SQL-injection footgun (mirrors `@warlock.js/ai`'s pg stores).
+*/
+const SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Module specifier for the optional `pg` driver. Held in a `string`
+* variable so the dynamic `import()` is not statically resolved at
+* compile time — `pg` is an optional peer that need not be installed for
+* this package to type-check or for a memory-only consumer to run.
+*/
+const PG_MODULE = "pg";
+/**
+* Curated install string surfaced (at use time) when a `connectionString`
+* is configured but the optional `pg` driver is absent. Never thrown at
+* import — a memory-only consumer must be able to load this module.
+*/
+const PG_INSTALL_INSTRUCTIONS = `
+The @warlock.js/ai Postgres interrupt store requires the pg package.
+Install it with:
+
+  npm install pg
+
+Or with your preferred package manager:
+
+  pnpm add pg
+  yarn add pg
+`.trim();
+/**
+* Lazily import `pg` and return a `Pool` built from `connectionString`. A
+* bare `catch` rethrows the curated install string — a missing optional
+* peer surfaces as actionable guidance, never a raw resolution error.
+*/
+async function buildPgClient(connectionString) {
+	let sdk;
+	try {
+		sdk = await import(PG_MODULE);
+	} catch {
+		throw new Error(PG_INSTALL_INSTRUCTIONS);
+	}
+	return new sdk.Pool({ connectionString });
+}
+/**
+* Coerce a Postgres timestamp/text column to an ISO string. `pg` returns
+* `TIMESTAMPTZ` as a `Date`; normalize to the ISO wire shape the
+* {@link PendingInterrupt} contract declares.
+*/
+function toIso(value) {
+	if (value instanceof Date) return value.toISOString();
+	return value;
+}
+/**
+* Map a raw DB row to a {@link PendingInterrupt}. Column names match the
+* reference DDL 1:1; the `request` JSONB rides one column, so it is parsed
+* defensively (node-postgres parses `JSONB` already, but some pool
+* wrappers hand back the raw string).
+*/
+function rowToRecord(row) {
+	const request = typeof row.request === "string" ? JSON.parse(row.request) : row.request;
+	return {
+		interruptId: row.interrupt_id,
+		request,
+		status: row.status,
+		savedAt: toIso(row.saved_at)
+	};
+}
+/**
+* Postgres-backed {@link InterruptStore} — one durable row per pending
+* interrupt, keyed by `interrupt_id`.
+*
+* Owns: durable round-tripping of the {@link PendingInterrupt} envelope so
+* a reviewer can rule out-of-process (a webhook approves hours later, in a
+* different process), the reference DDL via {@link PgInterruptStore.schema},
+* and prefix-filtered enumeration. Does NOT own: the connection lifecycle
+* (a dev-supplied client is never closed; a store-built `Pool` from a
+* `connectionString` is also left open for the process to reuse) or schema
+* migration (the dev runs `schema()` through their own tool — never
+* auto-migrated).
+*
+* Like the snapshot store, a call has exactly one live interrupt, so
+* `save()` upserts on the `interrupt_id` primary key.
+*
+* Front it with the {@link pg} factory — callers never `new` it.
+*/
+var PgInterruptStore = class {
+	constructor(options) {
+		const table = options.table ?? DEFAULT_TABLE;
+		if (!SAFE_IDENTIFIER.test(table)) throw new TypeError(`ai.human.interrupt.pg: invalid table name '${table}'. Allowed: [A-Za-z_][A-Za-z0-9_]*.`);
+		this.table = table;
+		if (options.client) {
+			if (typeof options.client.query !== "function") throw new TypeError("ai.human.interrupt.pg requires a 'client' option implementing { query(text, params) } — pass a pg.Pool or pg.Client.");
+			this.clientPromise = Promise.resolve(options.client);
+			return;
+		}
+		if (options.connectionString) {
+			this.clientPromise = buildPgClient(options.connectionString);
+			return;
+		}
+		throw new TypeError("ai.human.interrupt.pg requires either a 'client' or a 'connectionString' option.");
+	}
+	/**
+	* Resolve the backing client, surfacing the lazy `pg` import's curated
+	* install string on the first call that needs it.
+	*/
+	client() {
+		return this.clientPromise;
+	}
+	/**
+	* Persist a pending interrupt, keyed by its own `interrupt_id`. Upserts
+	* — a call has exactly one live interrupt, so a second save for the same
+	* id overwrites the payload rather than appending.
+	*/
+	async save(record) {
+		await (await this.client()).query(`INSERT INTO ${this.table} (interrupt_id, request, status, saved_at)
+       VALUES ($1, $2::jsonb, $3, $4)
+       ON CONFLICT (interrupt_id) DO UPDATE
+         SET request = EXCLUDED.request,
+             status = EXCLUDED.status,
+             saved_at = EXCLUDED.saved_at`, [
+			record.interruptId,
+			JSON.stringify(record.request),
+			record.status,
+			record.savedAt
+		]);
+	}
+	/**
+	* Load the interrupt for an `interruptId`, or `undefined` when none is
+	* recorded.
+	*/
+	async load(interruptId) {
+		const { rows } = await (await this.client()).query(`SELECT interrupt_id, request, status, saved_at
+       FROM ${this.table}
+       WHERE interrupt_id = $1`, [interruptId]);
+		if (rows.length === 0) return;
+		return rowToRecord(rows[0]);
+	}
+	/**
+	* Drop the interrupt for an `interruptId`. Idempotent — deleting an
+	* absent id deletes zero rows.
+	*/
+	async delete(interruptId) {
+		await (await this.client()).query(`DELETE FROM ${this.table} WHERE interrupt_id = $1`, [interruptId]);
+	}
+	/**
+	* List the interrupt ids known to the store, optionally filtered by a
+	* prefix. The `_` and `%` LIKE wildcards in the prefix are escaped so an
+	* opaque interruptId that happens to contain them is matched literally.
+	*/
+	async list(prefix) {
+		const client = await this.client();
+		if (prefix === void 0) {
+			const { rows } = await client.query(`SELECT interrupt_id FROM ${this.table}`);
+			return rows.map((row) => row.interrupt_id);
+		}
+		const escaped = prefix.replace(/\\/g, "\\\\").replace(/_/g, "\\_").replace(/%/g, "\\%");
+		const { rows } = await client.query(`SELECT interrupt_id FROM ${this.table}
+       WHERE interrupt_id LIKE $1 ESCAPE '\\'`, [`${escaped}%`]);
+		return rows.map((row) => row.interrupt_id);
+	}
+	/**
+	* Return the reference DDL for this store's backing table, interpolating
+	* the configured table name. The dev runs it through their migration
+	* tool — the framework never auto-migrates.
+	*
+	* @example
+	* await pool.query(store.schema());
+	*/
+	schema() {
+		return [
+			`CREATE TABLE IF NOT EXISTS ${this.table} (`,
+			`  interrupt_id  TEXT PRIMARY KEY,`,
+			`  request       JSONB NOT NULL,`,
+			`  status        TEXT NOT NULL,`,
+			`  saved_at      TIMESTAMPTZ NOT NULL DEFAULT now()`,
+			`);`,
+			`CREATE INDEX IF NOT EXISTS idx_${this.table}_saved_at`,
+			`  ON ${this.table} (saved_at);`
+		].join("\n");
+	}
+};
+/**
+* Create a Postgres-backed {@link InterruptStore}. Either pass a live
+* `pg.Pool` / `pg.Client` (`{ client }`) — `@warlock.js/ai` never
+* imports `pg` in that case — or a `{ connectionString }` and let the
+* store lazily `import("pg")` to build its own pool. When `pg` is not
+* installed, the curated install string surfaces on first use, never at
+* import. Run {@link InterruptStore.schema} through your migration tool
+* once before use; the store never auto-migrates.
+*
+* @example
+* import { Pool } from "pg";
+* import { ai } from "@warlock.js/ai";
+*
+* const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+* const store = ai.human.interrupt.pg({ client: pool });
+*
+* // Once, via your migration tooling:
+* // await pool.query(store.schema());
+*
+* @example
+* // Let the store build its own pool from a connection string:
+* const store = ai.human.interrupt.pg({
+*   connectionString: process.env.DATABASE_URL,
+* });
+*/
+function pg(options) {
+	return new PgInterruptStore(options);
+}
+
+//#endregion
+export { pg };
+//# sourceMappingURL=pg.mjs.map

package/esm/human/stores/pg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pg.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/human/stores/pg.ts"],"sourcesContent":["import type {\n  InterruptStore,\n  PendingInterrupt,\n  PgClientLike,\n} from \"../contracts/interrupt-store.contract\";\n\n/**\n * Options for the Postgres {@link InterruptStore}.\n *\n * Two mutually-supportive ways to supply the connection:\n * - **`client`** — pass an already-built `pg.Pool` / `pg.Client` (anything\n *   satisfying {@link PgClientLike}). The store only ever calls `query`\n *   and never opens or closes it; a single pool can back both an\n *   orchestrator's checkpoint/snapshot stores and this interrupt table.\n * - **`connectionString`** — let the store lazily `import(\"pg\")` and build\n *   its own `Pool`. `@warlock.js/ai` takes **no** hard dependency on\n *   `pg` (it is an optional peer); when it is absent the store throws a\n *   curated install string at first use, never a raw module-resolution\n *   stack trace at import.\n *\n * Exactly one of the two must be present.\n */\nexport interface PgInterruptOptions {\n  /** An already-built `pg.Pool` / `pg.Client` — anything matching {@link PgClientLike}. */\n  client?: PgClientLike;\n\n  /** Connection string the store passes to a lazily-imported `pg.Pool`. */\n  connectionString?: string;\n\n  /**\n   * Backing table name. Defaults to `warlock_ai_human_interrupts`. Must be\n   * a safe SQL identifier — it is interpolated into DDL/DML.\n   */\n  table?: string;\n}\n\n/**\n * Default backing table — provisions the store with no extra config when\n * the dev runs {@link InterruptStore.schema} through their migration tool.\n */\nconst DEFAULT_TABLE = \"warlock_ai_human_interrupts\";\n\n/**\n * Allowed characters in a Postgres identifier (table name). The table name\n * is interpolated into DDL/DML, so anything outside this conservative\n * ASCII subset is rejected — interpolating an arbitrary string would be a\n * SQL-injection footgun (mirrors `@warlock.js/ai`'s pg stores).\n */\nconst SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;\n\n/**\n * Module specifier for the optional `pg` driver. Held in a `string`\n * variable so the dynamic `import()` is not statically resolved at\n * compile time — `pg` is an optional peer that need not be installed for\n * this package to type-check or for a memory-only consumer to run.\n */\nconst PG_MODULE = \"pg\";\n\n/**\n * Curated install string surfaced (at use time) when a `connectionString`\n * is configured but the optional `pg` driver is absent. Never thrown at\n * import — a memory-only consumer must be able to load this module.\n */\nconst PG_INSTALL_INSTRUCTIONS = `\nThe @warlock.js/ai Postgres interrupt store requires the pg package.\nInstall it with:\n\n  npm install pg\n\nOr with your preferred package manager:\n\n  pnpm add pg\n  yarn add pg\n`.trim();\n\n/**\n * Minimal structural view of a `pg.Pool` constructor — just enough of the\n * `pg` module surface for the store to build a client when handed a\n * `connectionString`. Declared locally (rather than `typeof import(\"pg\")`)\n * so this module type-checks even when `pg` is not installed.\n */\ninterface PgModuleLike {\n  Pool: new (config: { connectionString: string }) => PgClientLike;\n}\n\n/**\n * Lazily import `pg` and return a `Pool` built from `connectionString`. A\n * bare `catch` rethrows the curated install string — a missing optional\n * peer surfaces as actionable guidance, never a raw resolution error.\n */\nasync function buildPgClient(connectionString: string): Promise<PgClientLike> {\n  let sdk: PgModuleLike;\n\n  try {\n    sdk = (await import(PG_MODULE)) as unknown as PgModuleLike;\n  } catch {\n    throw new Error(PG_INSTALL_INSTRUCTIONS);\n  }\n\n  return new sdk.Pool({ connectionString });\n}\n\n/**\n * Coerce a Postgres timestamp/text column to an ISO string. `pg` returns\n * `TIMESTAMPTZ` as a `Date`; normalize to the ISO wire shape the\n * {@link PendingInterrupt} contract declares.\n */\nfunction toIso(value: unknown): string {\n  if (value instanceof Date) {\n    return value.toISOString();\n  }\n\n  return value as string;\n}\n\n/**\n * Map a raw DB row to a {@link PendingInterrupt}. Column names match the\n * reference DDL 1:1; the `request` JSONB rides one column, so it is parsed\n * defensively (node-postgres parses `JSONB` already, but some pool\n * wrappers hand back the raw string).\n */\nfunction rowToRecord(row: Record<string, unknown>): PendingInterrupt {\n  const request =\n    typeof row.request === \"string\" ? JSON.parse(row.request) : row.request;\n\n  return {\n    interruptId: row.interrupt_id as string,\n    request: request as PendingInterrupt[\"request\"],\n    status: row.status as PendingInterrupt[\"status\"],\n    savedAt: toIso(row.saved_at),\n  };\n}\n\n/**\n * Postgres-backed {@link InterruptStore} — one durable row per pending\n * interrupt, keyed by `interrupt_id`.\n *\n * Owns: durable round-tripping of the {@link PendingInterrupt} envelope so\n * a reviewer can rule out-of-process (a webhook approves hours later, in a\n * different process), the reference DDL via {@link PgInterruptStore.schema},\n * and prefix-filtered enumeration. Does NOT own: the connection lifecycle\n * (a dev-supplied client is never closed; a store-built `Pool` from a\n * `connectionString` is also left open for the process to reuse) or schema\n * migration (the dev runs `schema()` through their own tool — never\n * auto-migrated).\n *\n * Like the snapshot store, a call has exactly one live interrupt, so\n * `save()` upserts on the `interrupt_id` primary key.\n *\n * Front it with the {@link pg} factory — callers never `new` it.\n */\nclass PgInterruptStore implements InterruptStore {\n  /** Validated backing table name, safe to interpolate into SQL. */\n  private readonly table: string;\n\n  /**\n   * A ready client, or a promise resolving to one the store builds lazily\n   * from a `connectionString`. Resolved once and memoized so the optional\n   * `pg` import happens at most once.\n   */\n  private clientPromise: Promise<PgClientLike>;\n\n  public constructor(options: PgInterruptOptions) {\n    const table = options.table ?? DEFAULT_TABLE;\n\n    if (!SAFE_IDENTIFIER.test(table)) {\n      throw new TypeError(\n        `ai.human.interrupt.pg: invalid table name '${table}'. Allowed: [A-Za-z_][A-Za-z0-9_]*.`,\n      );\n    }\n\n    this.table = table;\n\n    if (options.client) {\n      if (typeof options.client.query !== \"function\") {\n        throw new TypeError(\n          \"ai.human.interrupt.pg requires a 'client' option implementing { query(text, params) } — pass a pg.Pool or pg.Client.\",\n        );\n      }\n\n      this.clientPromise = Promise.resolve(options.client);\n\n      return;\n    }\n\n    if (options.connectionString) {\n      // Defer the optional `pg` import to first use — a curated install\n      // string surfaces from `buildPgClient`, not at construction.\n      this.clientPromise = buildPgClient(options.connectionString);\n\n      return;\n    }\n\n    throw new TypeError(\n      \"ai.human.interrupt.pg requires either a 'client' or a 'connectionString' option.\",\n    );\n  }\n\n  /**\n   * Resolve the backing client, surfacing the lazy `pg` import's curated\n   * install string on the first call that needs it.\n   */\n  private client(): Promise<PgClientLike> {\n    return this.clientPromise;\n  }\n\n  /**\n   * Persist a pending interrupt, keyed by its own `interrupt_id`. Upserts\n   * — a call has exactly one live interrupt, so a second save for the same\n   * id overwrites the payload rather than appending.\n   */\n  public async save(record: PendingInterrupt): Promise<void> {\n    const client = await this.client();\n\n    await client.query(\n      `INSERT INTO ${this.table} (interrupt_id, request, status, saved_at)\n       VALUES ($1, $2::jsonb, $3, $4)\n       ON CONFLICT (interrupt_id) DO UPDATE\n         SET request = EXCLUDED.request,\n             status = EXCLUDED.status,\n             saved_at = EXCLUDED.saved_at`,\n      [\n        record.interruptId,\n        JSON.stringify(record.request),\n        record.status,\n        record.savedAt,\n      ],\n    );\n  }\n\n  /**\n   * Load the interrupt for an `interruptId`, or `undefined` when none is\n   * recorded.\n   */\n  public async load(\n    interruptId: string,\n  ): Promise<PendingInterrupt | undefined> {\n    const client = await this.client();\n\n    const { rows } = await client.query(\n      `SELECT interrupt_id, request, status, saved_at\n       FROM ${this.table}\n       WHERE interrupt_id = $1`,\n      [interruptId],\n    );\n\n    if (rows.length === 0) {\n      return undefined;\n    }\n\n    return rowToRecord(rows[0] as Record<string, unknown>);\n  }\n\n  /**\n   * Drop the interrupt for an `interruptId`. Idempotent — deleting an\n   * absent id deletes zero rows.\n   */\n  public async delete(interruptId: string): Promise<void> {\n    const client = await this.client();\n\n    await client.query(\n      `DELETE FROM ${this.table} WHERE interrupt_id = $1`,\n      [interruptId],\n    );\n  }\n\n  /**\n   * List the interrupt ids known to the store, optionally filtered by a\n   * prefix. The `_` and `%` LIKE wildcards in the prefix are escaped so an\n   * opaque interruptId that happens to contain them is matched literally.\n   */\n  public async list(prefix?: string): Promise<string[]> {\n    const client = await this.client();\n\n    if (prefix === undefined) {\n      const { rows } = await client.query(\n        `SELECT interrupt_id FROM ${this.table}`,\n      );\n\n      return rows.map(\n        (row) => (row as Record<string, unknown>).interrupt_id as string,\n      );\n    }\n\n    const escaped = prefix\n      .replace(/\\\\/g, \"\\\\\\\\\")\n      .replace(/_/g, \"\\\\_\")\n      .replace(/%/g, \"\\\\%\");\n\n    const { rows } = await client.query(\n      `SELECT interrupt_id FROM ${this.table}\n       WHERE interrupt_id LIKE $1 ESCAPE '\\\\'`,\n      [`${escaped}%`],\n    );\n\n    return rows.map(\n      (row) => (row as Record<string, unknown>).interrupt_id as string,\n    );\n  }\n\n  /**\n   * Return the reference DDL for this store's backing table, interpolating\n   * the configured table name. The dev runs it through their migration\n   * tool — the framework never auto-migrates.\n   *\n   * @example\n   * await pool.query(store.schema());\n   */\n  public schema(): string {\n    return [\n      `CREATE TABLE IF NOT EXISTS ${this.table} (`,\n      `  interrupt_id  TEXT PRIMARY KEY,`,\n      `  request       JSONB NOT NULL,`,\n      `  status        TEXT NOT NULL,`,\n      `  saved_at      TIMESTAMPTZ NOT NULL DEFAULT now()`,\n      `);`,\n      `CREATE INDEX IF NOT EXISTS idx_${this.table}_saved_at`,\n      `  ON ${this.table} (saved_at);`,\n    ].join(\"\\n\");\n  }\n}\n\n/**\n * Create a Postgres-backed {@link InterruptStore}. Either pass a live\n * `pg.Pool` / `pg.Client` (`{ client }`) — `@warlock.js/ai` never\n * imports `pg` in that case — or a `{ connectionString }` and let the\n * store lazily `import(\"pg\")` to build its own pool. When `pg` is not\n * installed, the curated install string surfaces on first use, never at\n * import. Run {@link InterruptStore.schema} through your migration tool\n * once before use; the store never auto-migrates.\n *\n * @example\n * import { Pool } from \"pg\";\n * import { ai } from \"@warlock.js/ai\";\n *\n * const pool = new Pool({ connectionString: process.env.DATABASE_URL });\n * const store = ai.human.interrupt.pg({ client: pool });\n *\n * // Once, via your migration tooling:\n * // await pool.query(store.schema());\n *\n * @example\n * // Let the store build its own pool from a connection string:\n * const store = ai.human.interrupt.pg({\n *   connectionString: process.env.DATABASE_URL,\n * });\n */\nexport function pg(options: PgInterruptOptions): InterruptStore {\n  return new PgInterruptStore(options);\n}\n"],"mappings":"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"}

package/esm/human/stores/redis.d.mts

@@ -0,0 +1,56 @@
+import { InterruptStore, RedisClientLike } from "../contracts/interrupt-store.contract.mjs";
+
+//#region ../@warlock.js/ai/src/human/stores/redis.d.ts
+/**
+ * Options for the Redis {@link InterruptStore}.
+ *
+ * Two mutually-supportive ways to supply the connection:
+ * - **`client`** — pass an already-connected `redis` client (anything
+ *   satisfying {@link RedisClientLike}). The store only calls
+ *   `get` / `set` / `del` and never connects or quits it.
+ * - **`url`** — let the store lazily `import("redis")`, build a client
+ *   from the url, and connect it. `@warlock.js/ai` takes **no** hard
+ *   dependency on `redis` (it is an optional peer); when it is absent the
+ *   store throws a curated install string at first use, never a raw
+ *   module-resolution stack trace at import.
+ *
+ * Exactly one of the two must be present.
+ */
+interface RedisInterruptOptions {
+  /** An already-connected `redis` client — anything matching {@link RedisClientLike}. */
+  client?: RedisClientLike;
+  /** Connection url the store passes to a lazily-imported `createClient`. */
+  url?: string;
+  /**
+   * Key prefix prepended to every key this store writes. Lets one Redis
+   * database back multiple stores without collision. Defaults to
+   * `warlock:ai-human:interrupt:`.
+   */
+  prefix?: string;
+}
+/**
+ * Create a Redis-backed {@link InterruptStore}. Either pass a connected
+ * `redis` client (`{ client }`) — `@warlock.js/ai` never imports
+ * `redis` in that case — or a `{ url }` and let the store lazily
+ * `import("redis")`, build, and connect a client. When `redis` is not
+ * installed, the curated install string surfaces on first use, never at
+ * import. {@link InterruptStore.schema} returns an empty string; Redis
+ * needs no migration.
+ *
+ * @example
+ * import { createClient } from "redis";
+ * import { ai } from "@warlock.js/ai";
+ *
+ * const client = createClient({ url: process.env.REDIS_URL });
+ * await client.connect();
+ *
+ * const store = ai.human.interrupt.redis({ client });
+ *
+ * @example
+ * // Let the store build + connect its own client from a url:
+ * const store = ai.human.interrupt.redis({ url: process.env.REDIS_URL });
+ */
+declare function redis(options: RedisInterruptOptions): InterruptStore;
+//#endregion
+export { RedisInterruptOptions, redis };
+//# sourceMappingURL=redis.d.mts.map

package/esm/human/stores/redis.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/human/stores/redis.ts"],"mappings":";;;;;AAqBA;;;;;;;;;AAYQ;AA+RR;;;UA3SiB,qBAAA;EA2Sc;EAzS7B,MAAA,GAAS,eAAe;EAyS6B;EAtSrD,GAAA;EAsSmE;;;;;EA/RnE,MAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;iBA+Rc,KAAA,CAAM,OAAA,EAAS,qBAAA,GAAwB,cAAc"}

package/esm/human/stores/redis.mjs

@@ -0,0 +1,201 @@
+//#region ../@warlock.js/ai/src/human/stores/redis.ts
+/**
+* Default key prefix — namespaces the store's keys inside a shared Redis
+* database so interrupt records coexist with other data without collision.
+*/
+const DEFAULT_PREFIX = "warlock:ai-human:interrupt:";
+/**
+* Index key (under the configured prefix) holding the JSON array of live
+* interrupt ids. The structural {@link RedisClientLike} surface exposes no
+* `SCAN` / `KEYS`, so enumeration for `list()` is self-maintained.
+*/
+const INDEX_SUFFIX = "index";
+/**
+* Module specifier for the optional `redis` driver. Held in a `string`
+* variable so the dynamic `import()` is not statically resolved at compile
+* time — `redis` is an optional peer that need not be installed for this
+* package to type-check or for a memory-only consumer to run.
+*/
+const REDIS_MODULE = "redis";
+/**
+* Curated install string surfaced (at use time) when a `url` is configured
+* but the optional `redis` driver is absent. Never thrown at import — a
+* memory-only consumer must be able to load this module.
+*/
+const REDIS_INSTALL_INSTRUCTIONS = `
+The @warlock.js/ai Redis interrupt store requires the redis package.
+Install it with:
+
+  npm install redis
+
+Or with your preferred package manager:
+
+  pnpm add redis
+  yarn add redis
+`.trim();
+/**
+* Lazily import `redis`, build a client from `url`, and connect it. A bare
+* `catch` rethrows the curated install string — a missing optional peer
+* surfaces as actionable guidance, never a raw resolution error.
+*/
+async function buildRedisClient(url) {
+	let sdk;
+	try {
+		sdk = await import(REDIS_MODULE);
+	} catch {
+		throw new Error(REDIS_INSTALL_INSTRUCTIONS);
+	}
+	const client = sdk.createClient({ url });
+	await client.connect();
+	return client;
+}
+/**
+* Redis-backed {@link InterruptStore} — one JSON string value per pending
+* interrupt, under a namespaced key, plus a self-maintained id index so
+* `list()` works without `SCAN`/`KEYS`.
+*
+* Owns: durable round-tripping of the {@link PendingInterrupt} envelope so
+* a reviewer can rule out-of-process, the namespaced key layout, and the
+* per-store id index that backs enumeration. Does NOT own: durability
+* guarantees beyond Redis's own, the connection lifecycle (a dev-supplied
+* client is never disconnected; a store-built client from a `url` is left
+* connected for the process to reuse), or migration —
+* {@link RedisInterruptStore.schema} returns an empty string.
+*
+* A call has exactly one live interrupt, so `save()` overwrites the key.
+*
+* Front it with the {@link redis} factory — callers never `new` it.
+*/
+var RedisInterruptStore = class {
+	constructor(options) {
+		this.prefix = options.prefix ?? DEFAULT_PREFIX;
+		if (options.client) {
+			if (typeof options.client.get !== "function" || typeof options.client.set !== "function" || typeof options.client.del !== "function") throw new TypeError("ai.human.interrupt.redis requires a 'client' option implementing { get, set, del } — pass a connected redis client.");
+			this.clientPromise = Promise.resolve(options.client);
+			return;
+		}
+		if (options.url) {
+			this.clientPromise = buildRedisClient(options.url);
+			return;
+		}
+		throw new TypeError("ai.human.interrupt.redis requires either a 'client' or a 'url' option.");
+	}
+	/**
+	* Resolve the backing client, surfacing the lazy `redis` import's
+	* curated install string on the first call that needs it.
+	*/
+	client() {
+		return this.clientPromise;
+	}
+	/**
+	* Persist a pending interrupt, keyed by its own `interruptId`, and index
+	* the id for enumeration. Overwrites any prior record for the same id —
+	* a call has exactly one live interrupt.
+	*/
+	async save(record) {
+		await (await this.client()).set(this.recordKey(record.interruptId), JSON.stringify(record));
+		await this.indexId(record.interruptId);
+	}
+	/**
+	* Load the interrupt for an `interruptId`, or `undefined` when the key is
+	* missing. Redis returns `null` for an absent key — converted to
+	* `undefined` at the boundary.
+	*/
+	async load(interruptId) {
+		const raw = await (await this.client()).get(this.recordKey(interruptId));
+		if (raw === null) return;
+		return JSON.parse(raw);
+	}
+	/**
+	* Drop the interrupt for an `interruptId` and de-index its id. Idempotent
+	* — deleting an absent id is a no-op.
+	*/
+	async delete(interruptId) {
+		await (await this.client()).del(this.recordKey(interruptId));
+		await this.deindexId(interruptId);
+	}
+	/**
+	* List the interrupt ids known to the store, optionally filtered by a
+	* prefix. Reads the self-maintained index document.
+	*/
+	async list(prefix) {
+		const ids = await this.readIndex();
+		if (prefix === void 0) return ids;
+		return ids.filter((id) => id.startsWith(prefix));
+	}
+	/**
+	* Redis needs no relational table — there is nothing to migrate. Returns
+	* an empty string so callers can treat `schema()` uniformly across
+	* drivers.
+	*/
+	schema() {
+		return "";
+	}
+	/**
+	* Read and parse the id index, defaulting to an empty list when absent.
+	*/
+	async readIndex() {
+		const raw = await (await this.client()).get(this.indexKey());
+		if (raw === null) return [];
+		return JSON.parse(raw);
+	}
+	/**
+	* Add an interrupt id to the index, no-op when already present.
+	*/
+	async indexId(interruptId) {
+		const ids = await this.readIndex();
+		if (ids.includes(interruptId)) return;
+		ids.push(interruptId);
+		await (await this.client()).set(this.indexKey(), JSON.stringify(ids));
+	}
+	/**
+	* Remove an interrupt id from the index, no-op when absent.
+	*/
+	async deindexId(interruptId) {
+		const ids = await this.readIndex();
+		const next = ids.filter((id) => id !== interruptId);
+		if (next.length === ids.length) return;
+		await (await this.client()).set(this.indexKey(), JSON.stringify(next));
+	}
+	/**
+	* Key for a single interrupt record — `<prefix><interruptId>`.
+	*/
+	recordKey(interruptId) {
+		return `${this.prefix}${interruptId}`;
+	}
+	/**
+	* Key for the self-maintained id index — `<prefix>index`.
+	*/
+	indexKey() {
+		return `${this.prefix}${INDEX_SUFFIX}`;
+	}
+};
+/**
+* Create a Redis-backed {@link InterruptStore}. Either pass a connected
+* `redis` client (`{ client }`) — `@warlock.js/ai` never imports
+* `redis` in that case — or a `{ url }` and let the store lazily
+* `import("redis")`, build, and connect a client. When `redis` is not
+* installed, the curated install string surfaces on first use, never at
+* import. {@link InterruptStore.schema} returns an empty string; Redis
+* needs no migration.
+*
+* @example
+* import { createClient } from "redis";
+* import { ai } from "@warlock.js/ai";
+*
+* const client = createClient({ url: process.env.REDIS_URL });
+* await client.connect();
+*
+* const store = ai.human.interrupt.redis({ client });
+*
+* @example
+* // Let the store build + connect its own client from a url:
+* const store = ai.human.interrupt.redis({ url: process.env.REDIS_URL });
+*/
+function redis(options) {
+	return new RedisInterruptStore(options);
+}
+
+//#endregion
+export { redis };
+//# sourceMappingURL=redis.mjs.map

package/esm/human/stores/redis.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/human/stores/redis.ts"],"sourcesContent":["import type {\n  InterruptStore,\n  PendingInterrupt,\n  RedisClientLike,\n} from \"../contracts/interrupt-store.contract\";\n\n/**\n * Options for the Redis {@link InterruptStore}.\n *\n * Two mutually-supportive ways to supply the connection:\n * - **`client`** — pass an already-connected `redis` client (anything\n *   satisfying {@link RedisClientLike}). The store only calls\n *   `get` / `set` / `del` and never connects or quits it.\n * - **`url`** — let the store lazily `import(\"redis\")`, build a client\n *   from the url, and connect it. `@warlock.js/ai` takes **no** hard\n *   dependency on `redis` (it is an optional peer); when it is absent the\n *   store throws a curated install string at first use, never a raw\n *   module-resolution stack trace at import.\n *\n * Exactly one of the two must be present.\n */\nexport interface RedisInterruptOptions {\n  /** An already-connected `redis` client — anything matching {@link RedisClientLike}. */\n  client?: RedisClientLike;\n\n  /** Connection url the store passes to a lazily-imported `createClient`. */\n  url?: string;\n\n  /**\n   * Key prefix prepended to every key this store writes. Lets one Redis\n   * database back multiple stores without collision. Defaults to\n   * `warlock:ai-human:interrupt:`.\n   */\n  prefix?: string;\n}\n\n/**\n * Default key prefix — namespaces the store's keys inside a shared Redis\n * database so interrupt records coexist with other data without collision.\n */\nconst DEFAULT_PREFIX = \"warlock:ai-human:interrupt:\";\n\n/**\n * Index key (under the configured prefix) holding the JSON array of live\n * interrupt ids. The structural {@link RedisClientLike} surface exposes no\n * `SCAN` / `KEYS`, so enumeration for `list()` is self-maintained.\n */\nconst INDEX_SUFFIX = \"index\";\n\n/**\n * Module specifier for the optional `redis` driver. Held in a `string`\n * variable so the dynamic `import()` is not statically resolved at compile\n * time — `redis` is an optional peer that need not be installed for this\n * package to type-check or for a memory-only consumer to run.\n */\nconst REDIS_MODULE = \"redis\";\n\n/**\n * Curated install string surfaced (at use time) when a `url` is configured\n * but the optional `redis` driver is absent. Never thrown at import — a\n * memory-only consumer must be able to load this module.\n */\nconst REDIS_INSTALL_INSTRUCTIONS = `\nThe @warlock.js/ai Redis interrupt store requires the redis package.\nInstall it with:\n\n  npm install redis\n\nOr with your preferred package manager:\n\n  pnpm add redis\n  yarn add redis\n`.trim();\n\n/**\n * Minimal structural view of the `redis` module surface — just enough to\n * build and connect a client from a url. Declared locally (rather than\n * `typeof import(\"redis\")`) so this module type-checks even when `redis`\n * is not installed.\n */\ninterface RedisModuleLike {\n  createClient(config: {\n    url: string;\n  }): RedisClientLike & { connect(): Promise<unknown> };\n}\n\n/**\n * Lazily import `redis`, build a client from `url`, and connect it. A bare\n * `catch` rethrows the curated install string — a missing optional peer\n * surfaces as actionable guidance, never a raw resolution error.\n */\nasync function buildRedisClient(url: string): Promise<RedisClientLike> {\n  let sdk: RedisModuleLike;\n\n  try {\n    sdk = (await import(REDIS_MODULE)) as unknown as RedisModuleLike;\n  } catch {\n    throw new Error(REDIS_INSTALL_INSTRUCTIONS);\n  }\n\n  const client = sdk.createClient({ url });\n  await client.connect();\n\n  return client;\n}\n\n/**\n * Redis-backed {@link InterruptStore} — one JSON string value per pending\n * interrupt, under a namespaced key, plus a self-maintained id index so\n * `list()` works without `SCAN`/`KEYS`.\n *\n * Owns: durable round-tripping of the {@link PendingInterrupt} envelope so\n * a reviewer can rule out-of-process, the namespaced key layout, and the\n * per-store id index that backs enumeration. Does NOT own: durability\n * guarantees beyond Redis's own, the connection lifecycle (a dev-supplied\n * client is never disconnected; a store-built client from a `url` is left\n * connected for the process to reuse), or migration —\n * {@link RedisInterruptStore.schema} returns an empty string.\n *\n * A call has exactly one live interrupt, so `save()` overwrites the key.\n *\n * Front it with the {@link redis} factory — callers never `new` it.\n */\nclass RedisInterruptStore implements InterruptStore {\n  /** Key prefix namespacing every key this store writes. */\n  private readonly prefix: string;\n\n  /**\n   * A ready client, or a promise resolving to one the store builds lazily\n   * from a `url`. Resolved once and memoized so the optional `redis`\n   * import + connect happens at most once.\n   */\n  private clientPromise: Promise<RedisClientLike>;\n\n  public constructor(options: RedisInterruptOptions) {\n    this.prefix = options.prefix ?? DEFAULT_PREFIX;\n\n    if (options.client) {\n      if (\n        typeof options.client.get !== \"function\" ||\n        typeof options.client.set !== \"function\" ||\n        typeof options.client.del !== \"function\"\n      ) {\n        throw new TypeError(\n          \"ai.human.interrupt.redis requires a 'client' option implementing { get, set, del } — pass a connected redis client.\",\n        );\n      }\n\n      this.clientPromise = Promise.resolve(options.client);\n\n      return;\n    }\n\n    if (options.url) {\n      // Defer the optional `redis` import to first use — a curated install\n      // string surfaces from `buildRedisClient`, not at construction.\n      this.clientPromise = buildRedisClient(options.url);\n\n      return;\n    }\n\n    throw new TypeError(\n      \"ai.human.interrupt.redis requires either a 'client' or a 'url' option.\",\n    );\n  }\n\n  /**\n   * Resolve the backing client, surfacing the lazy `redis` import's\n   * curated install string on the first call that needs it.\n   */\n  private client(): Promise<RedisClientLike> {\n    return this.clientPromise;\n  }\n\n  /**\n   * Persist a pending interrupt, keyed by its own `interruptId`, and index\n   * the id for enumeration. Overwrites any prior record for the same id —\n   * a call has exactly one live interrupt.\n   */\n  public async save(record: PendingInterrupt): Promise<void> {\n    const client = await this.client();\n\n    await client.set(this.recordKey(record.interruptId), JSON.stringify(record));\n    await this.indexId(record.interruptId);\n  }\n\n  /**\n   * Load the interrupt for an `interruptId`, or `undefined` when the key is\n   * missing. Redis returns `null` for an absent key — converted to\n   * `undefined` at the boundary.\n   */\n  public async load(\n    interruptId: string,\n  ): Promise<PendingInterrupt | undefined> {\n    const client = await this.client();\n    const raw = await client.get(this.recordKey(interruptId));\n\n    if (raw === null) {\n      return undefined;\n    }\n\n    return JSON.parse(raw) as PendingInterrupt;\n  }\n\n  /**\n   * Drop the interrupt for an `interruptId` and de-index its id. Idempotent\n   * — deleting an absent id is a no-op.\n   */\n  public async delete(interruptId: string): Promise<void> {\n    const client = await this.client();\n\n    await client.del(this.recordKey(interruptId));\n    await this.deindexId(interruptId);\n  }\n\n  /**\n   * List the interrupt ids known to the store, optionally filtered by a\n   * prefix. Reads the self-maintained index document.\n   */\n  public async list(prefix?: string): Promise<string[]> {\n    const ids = await this.readIndex();\n\n    if (prefix === undefined) {\n      return ids;\n    }\n\n    return ids.filter((id) => id.startsWith(prefix));\n  }\n\n  /**\n   * Redis needs no relational table — there is nothing to migrate. Returns\n   * an empty string so callers can treat `schema()` uniformly across\n   * drivers.\n   */\n  public schema(): string {\n    return \"\";\n  }\n\n  /**\n   * Read and parse the id index, defaulting to an empty list when absent.\n   */\n  private async readIndex(): Promise<string[]> {\n    const client = await this.client();\n    const raw = await client.get(this.indexKey());\n\n    if (raw === null) {\n      return [];\n    }\n\n    return JSON.parse(raw) as string[];\n  }\n\n  /**\n   * Add an interrupt id to the index, no-op when already present.\n   */\n  private async indexId(interruptId: string): Promise<void> {\n    const ids = await this.readIndex();\n\n    if (ids.includes(interruptId)) {\n      return;\n    }\n\n    ids.push(interruptId);\n\n    const client = await this.client();\n    await client.set(this.indexKey(), JSON.stringify(ids));\n  }\n\n  /**\n   * Remove an interrupt id from the index, no-op when absent.\n   */\n  private async deindexId(interruptId: string): Promise<void> {\n    const ids = await this.readIndex();\n    const next = ids.filter((id) => id !== interruptId);\n\n    if (next.length === ids.length) {\n      return;\n    }\n\n    const client = await this.client();\n    await client.set(this.indexKey(), JSON.stringify(next));\n  }\n\n  /**\n   * Key for a single interrupt record — `<prefix><interruptId>`.\n   */\n  private recordKey(interruptId: string): string {\n    return `${this.prefix}${interruptId}`;\n  }\n\n  /**\n   * Key for the self-maintained id index — `<prefix>index`.\n   */\n  private indexKey(): string {\n    return `${this.prefix}${INDEX_SUFFIX}`;\n  }\n}\n\n/**\n * Create a Redis-backed {@link InterruptStore}. Either pass a connected\n * `redis` client (`{ client }`) — `@warlock.js/ai` never imports\n * `redis` in that case — or a `{ url }` and let the store lazily\n * `import(\"redis\")`, build, and connect a client. When `redis` is not\n * installed, the curated install string surfaces on first use, never at\n * import. {@link InterruptStore.schema} returns an empty string; Redis\n * needs no migration.\n *\n * @example\n * import { createClient } from \"redis\";\n * import { ai } from \"@warlock.js/ai\";\n *\n * const client = createClient({ url: process.env.REDIS_URL });\n * await client.connect();\n *\n * const store = ai.human.interrupt.redis({ client });\n *\n * @example\n * // Let the store build + connect its own client from a url:\n * const store = ai.human.interrupt.redis({ url: process.env.REDIS_URL });\n */\nexport function redis(options: RedisInterruptOptions): InterruptStore {\n  return new RedisInterruptStore(options);\n}\n"],"mappings":"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"}