@warlock.js/core 4.4.0 → 4.6.0

package/esm/ai/src/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/ai/src/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":";;;;;AAwCA,MAAM,iBAAiB;;;;;;AAOvB,MAAM,eAAe;;;;;;;AAQrB,MAAM,eAAe;;;;;;AAOrB,MAAM,6BAA6B;;;;;;;;;;EAUjC,KAAK;;;;;;AAmBP,eAAe,iBAAiB,KAAuC;CACrE,IAAI;CAEJ,IAAI;EACF,MAAO,MAAM,OAAO;CACtB,QAAQ;EACN,MAAM,IAAI,MAAM,0BAA0B;CAC5C;CAEA,MAAM,SAAS,IAAI,aAAa,EAAE,IAAI,CAAC;CACvC,MAAM,OAAO,QAAQ;CAErB,OAAO;AACT;;;;;;;;;;;;;;;;;;AAmBA,IAAM,sBAAN,MAAoD;CAWlD,AAAO,YAAY,SAAgC;EACjD,KAAK,SAAS,QAAQ,UAAU;EAEhC,IAAI,QAAQ,QAAQ;GAClB,IACE,OAAO,QAAQ,OAAO,QAAQ,cAC9B,OAAO,QAAQ,OAAO,QAAQ,cAC9B,OAAO,QAAQ,OAAO,QAAQ,YAE9B,MAAM,IAAI,UACR,qHACF;GAGF,KAAK,gBAAgB,QAAQ,QAAQ,QAAQ,MAAM;GAEnD;EACF;EAEA,IAAI,QAAQ,KAAK;GAGf,KAAK,gBAAgB,iBAAiB,QAAQ,GAAG;GAEjD;EACF;EAEA,MAAM,IAAI,UACR,wEACF;CACF;;;;;CAMA,AAAQ,SAAmC;EACzC,OAAO,KAAK;CACd;;;;;;CAOA,MAAa,KAAK,QAAyC;EAGzD,OAAM,MAFe,KAAK,OAAO,EAErB,CAAC,IAAI,KAAK,UAAU,OAAO,WAAW,GAAG,KAAK,UAAU,MAAM,CAAC;EAC3E,MAAM,KAAK,QAAQ,OAAO,WAAW;CACvC;;;;;;CAOA,MAAa,KACX,aACuC;EAEvC,MAAM,MAAM,OAAM,MADG,KAAK,OAAO,EACT,CAAC,IAAI,KAAK,UAAU,WAAW,CAAC;EAExD,IAAI,QAAQ,MACV;EAGF,OAAO,KAAK,MAAM,GAAG;CACvB;;;;;CAMA,MAAa,OAAO,aAAoC;EAGtD,OAAM,MAFe,KAAK,OAAO,EAErB,CAAC,IAAI,KAAK,UAAU,WAAW,CAAC;EAC5C,MAAM,KAAK,UAAU,WAAW;CAClC;;;;;CAMA,MAAa,KAAK,QAAoC;EACpD,MAAM,MAAM,MAAM,KAAK,UAAU;EAEjC,IAAI,WAAW,QACb,OAAO;EAGT,OAAO,IAAI,QAAQ,OAAO,GAAG,WAAW,MAAM,CAAC;CACjD;;;;;;CAOA,AAAO,SAAiB;EACtB,OAAO;CACT;;;;CAKA,MAAc,YAA+B;EAE3C,MAAM,MAAM,OAAM,MADG,KAAK,OAAO,EACT,CAAC,IAAI,KAAK,SAAS,CAAC;EAE5C,IAAI,QAAQ,MACV,OAAO,CAAC;EAGV,OAAO,KAAK,MAAM,GAAG;CACvB;;;;CAKA,MAAc,QAAQ,aAAoC;EACxD,MAAM,MAAM,MAAM,KAAK,UAAU;EAEjC,IAAI,IAAI,SAAS,WAAW,GAC1B;EAGF,IAAI,KAAK,WAAW;EAGpB,OAAM,MADe,KAAK,OAAO,EACrB,CAAC,IAAI,KAAK,SAAS,GAAG,KAAK,UAAU,GAAG,CAAC;CACvD;;;;CAKA,MAAc,UAAU,aAAoC;EAC1D,MAAM,MAAM,MAAM,KAAK,UAAU;EACjC,MAAM,OAAO,IAAI,QAAQ,OAAO,OAAO,WAAW;EAElD,IAAI,KAAK,WAAW,IAAI,QACtB;EAIF,OAAM,MADe,KAAK,OAAO,EACrB,CAAC,IAAI,KAAK,SAAS,GAAG,KAAK,UAAU,IAAI,CAAC;CACxD;;;;CAKA,AAAQ,UAAU,aAA6B;EAC7C,OAAO,GAAG,KAAK,SAAS;CAC1B;;;;CAKA,AAAQ,WAAmB;EACzB,OAAO,GAAG,KAAK,SAAS;CAC1B;AACF;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,MAAM,SAAgD;CACpE,OAAO,IAAI,oBAAoB,OAAO;AACxC"}

package/esm/ai/src/image/image-cost.mjs

@@ -0,0 +1,55 @@
+import { computeCost } from "../utils/compute-cost.mjs";
+
+//#region ../@warlock.js/ai/src/image/image-cost.ts
+/**
+* Price one image-generation `Usage` against an
+* {@link ImageModelPricing}, returning a `ModelPricing`-shaped USD
+* breakdown so image spend folds into the exact same `Usage.cost`
+* rollup the text path uses (`accumulateCost` / `mergeUsage`). There is
+* no separate image-cost field anywhere downstream — only this one
+* function, which knows the two metering models:
+*
+* - **Per-image** (DALL·E, Imagen): `perImageBySize[size]` (when the
+*   request `size` matches a tier) else flat `perImage`, times the
+*   number of images returned, attributed to `cost.output` (the image
+*   IS the output). Token channels stay 0.
+* - **Token** (gpt-image-1): delegates to the standard
+*   {@link computeCost} against the prompt/image token `Usage`.
+*
+* Per-image wins when both shapes are configured (a provider is one or
+* the other). Returns `undefined` when no usable pricing is present —
+* the framework treats that as "cost unknown", never a false zero.
+*
+* @example
+* computeImageCost({ input: 0, output: 0, total: 0 }, 2, "1024x1024", { perImage: 0.04 });
+* // → { input: 0, output: 0.08 }
+*/
+function computeImageCost(usage, imageCount, size, pricing) {
+	if (!pricing) return;
+	if (pricing.perImage !== void 0 || pricing.perImageBySize !== void 0) {
+		const perImage = resolvePerImageRate(size, pricing);
+		if (perImage === void 0) return;
+		return {
+			input: 0,
+			output: perImage * imageCount
+		};
+	}
+	if (pricing.input !== void 0 && pricing.output !== void 0) return computeCost(usage, {
+		input: pricing.input,
+		output: pricing.output
+	});
+}
+/**
+* Resolve the USD-per-image rate: a `perImageBySize` tier matching the
+* requested `size` wins, otherwise the flat `perImage`. Returns
+* `undefined` only when neither is set (the caller already gated on
+* per-image metering being configured at all).
+*/
+function resolvePerImageRate(size, pricing) {
+	if (size !== void 0 && pricing.perImageBySize?.[size] !== void 0) return pricing.perImageBySize[size];
+	return pricing.perImage;
+}
+
+//#endregion
+export { computeImageCost };
+//# sourceMappingURL=image-cost.mjs.map

package/esm/ai/src/image/image-cost.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-cost.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/image/image-cost.ts"],"sourcesContent":["import type { ImageModelPricing } from \"../contracts/image-model.contract\";\nimport type { ModelPricing } from \"../contracts/result/model-pricing.type\";\nimport type { Usage } from \"../contracts/result/usage.type\";\nimport { computeCost } from \"../utils/compute-cost\";\n\n/**\n * Price one image-generation `Usage` against an\n * {@link ImageModelPricing}, returning a `ModelPricing`-shaped USD\n * breakdown so image spend folds into the exact same `Usage.cost`\n * rollup the text path uses (`accumulateCost` / `mergeUsage`). There is\n * no separate image-cost field anywhere downstream — only this one\n * function, which knows the two metering models:\n *\n * - **Per-image** (DALL·E, Imagen): `perImageBySize[size]` (when the\n *   request `size` matches a tier) else flat `perImage`, times the\n *   number of images returned, attributed to `cost.output` (the image\n *   IS the output). Token channels stay 0.\n * - **Token** (gpt-image-1): delegates to the standard\n *   {@link computeCost} against the prompt/image token `Usage`.\n *\n * Per-image wins when both shapes are configured (a provider is one or\n * the other). Returns `undefined` when no usable pricing is present —\n * the framework treats that as \"cost unknown\", never a false zero.\n *\n * @example\n * computeImageCost({ input: 0, output: 0, total: 0 }, 2, \"1024x1024\", { perImage: 0.04 });\n * // → { input: 0, output: 0.08 }\n */\nexport function computeImageCost(\n  usage: Usage,\n  imageCount: number,\n  size: string | undefined,\n  pricing: ImageModelPricing | undefined,\n): ModelPricing | undefined {\n  if (!pricing) {\n    return undefined;\n  }\n\n  const perImageMetered = pricing.perImage !== undefined || pricing.perImageBySize !== undefined;\n\n  if (perImageMetered) {\n    const perImage = resolvePerImageRate(size, pricing);\n\n    if (perImage === undefined) {\n      return undefined;\n    }\n\n    return { input: 0, output: perImage * imageCount };\n  }\n\n  if (pricing.input !== undefined && pricing.output !== undefined) {\n    return computeCost(usage, { input: pricing.input, output: pricing.output });\n  }\n\n  return undefined;\n}\n\n/**\n * Resolve the USD-per-image rate: a `perImageBySize` tier matching the\n * requested `size` wins, otherwise the flat `perImage`. Returns\n * `undefined` only when neither is set (the caller already gated on\n * per-image metering being configured at all).\n */\nfunction resolvePerImageRate(\n  size: string | undefined,\n  pricing: ImageModelPricing,\n): number | undefined {\n  if (size !== undefined && pricing.perImageBySize?.[size] !== undefined) {\n    return pricing.perImageBySize[size];\n  }\n\n  return pricing.perImage;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,iBACd,OACA,YACA,MACA,SAC0B;CAC1B,IAAI,CAAC,SACH;CAKF,IAFwB,QAAQ,aAAa,UAAa,QAAQ,mBAAmB,QAEhE;EACnB,MAAM,WAAW,oBAAoB,MAAM,OAAO;EAElD,IAAI,aAAa,QACf;EAGF,OAAO;GAAE,OAAO;GAAG,QAAQ,WAAW;EAAW;CACnD;CAEA,IAAI,QAAQ,UAAU,UAAa,QAAQ,WAAW,QACpD,OAAO,YAAY,OAAO;EAAE,OAAO,QAAQ;EAAO,QAAQ,QAAQ;CAAO,CAAC;AAI9E;;;;;;;AAQA,SAAS,oBACP,MACA,SACoB;CACpB,IAAI,SAAS,UAAa,QAAQ,iBAAiB,UAAU,QAC3D,OAAO,QAAQ,eAAe;CAGhC,OAAO,QAAQ;AACjB"}

package/esm/ai/src/image/image.mjs

@@ -0,0 +1,112 @@
+import { AIError } from "../errors/ai-error.mjs";
+import { ProviderError } from "../errors/provider-error.mjs";
+import { generateRunId } from "../utils/generate-run-id.mjs";
+import { stampReportLineage } from "../utils/stamp-report-lineage.mjs";
+import { notifyObservers } from "../observe/resolve-observers.mjs";
+import { computeImageCost } from "./image-cost.mjs";
+
+//#region ../@warlock.js/ai/src/image/image.ts
+/**
+* Generate one or more images from a text prompt — the image-output
+* counterpart to `ai.agent`, and the first verb of the output-modality
+* track (Theme I). Wraps an {@link ImageModelContract} (from
+* `openai.image(...)` / `google.image(...)`) in the framework's uniform
+* result contract:
+*
+* - **Never throws.** Provider failures (auth, rate-limit,
+*   content-filter, invalid request) surface as a typed `AIError` on
+*   `result.error`; `result.data` is then `undefined`.
+* - **Cost-truth.** When the model carries pricing, `result.usage.cost`
+*   is filled in — per-token for gpt-image-1, per-image for
+*   DALL·E / Imagen — folding into the same `Usage.cost` rollup as text.
+* - **Observable.** The completed {@link ImageReport} routes to any
+*   registered `Observer` (panoptic, OTel, …) via the shared `observe`
+*   seam, exactly like an agent run.
+*
+* @example
+* const openai = new OpenAISDK({ apiKey });
+* const { data, error, usage } = await ai.image({
+*   model: openai.image({ name: "gpt-image-1" }),
+*   prompt: "an isometric office desk, soft studio lighting",
+*   size: "1024x1024",
+* });
+*
+* if (error) console.warn(error.code);
+* else for (const img of data.images) save(img); // { type: "base64" | "url", ... }
+*/
+async function image(params) {
+	const { model, prompt } = params;
+	const runId = generateRunId("image");
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const startPerf = performance.now();
+	const usage = {
+		input: 0,
+		output: 0,
+		total: 0
+	};
+	let data;
+	let error;
+	let status = "completed";
+	let imageCount = 0;
+	try {
+		const response = await model.generate(prompt, {
+			count: params.count,
+			size: params.size,
+			quality: params.quality,
+			aspectRatio: params.aspectRatio,
+			negativePrompt: params.negativePrompt,
+			format: params.format,
+			signal: params.signal,
+			...params.options
+		});
+		Object.assign(usage, response.usage);
+		if (usage.cost === void 0) {
+			const cost = computeImageCost(usage, response.images.length, params.size, model.pricing);
+			if (cost !== void 0) usage.cost = cost;
+		}
+		data = { images: response.images };
+		imageCount = response.images.length;
+	} catch (thrown) {
+		error = thrown instanceof AIError ? thrown : new ProviderError(toMessage(thrown), { cause: thrown });
+		status = params.signal?.aborted ? "cancelled" : "failed";
+	}
+	const report = {
+		runId,
+		rootRunId: runId,
+		name: params.name ?? "image",
+		type: "image",
+		status,
+		error,
+		startedAt,
+		endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		duration: performance.now() - startPerf,
+		usage,
+		children: [],
+		model: {
+			name: model.name,
+			provider: model.provider
+		},
+		imageCount,
+		reportSchemaVersion: 1
+	};
+	stampReportLineage(report, {
+		rootRunId: runId,
+		sessionId: params.sessionId
+	});
+	await notifyObservers(params.observe, report);
+	return {
+		type: "image",
+		data,
+		error,
+		usage,
+		report
+	};
+}
+/** Best-effort message for a non-`AIError` thrown value. */
+function toMessage(thrown) {
+	return thrown instanceof Error ? thrown.message : String(thrown);
+}
+
+//#endregion
+export { image };
+//# sourceMappingURL=image.mjs.map

package/esm/ai/src/image/image.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/image/image.ts"],"sourcesContent":["import type {\n  GeneratedImage,\n  ImageModelContract,\n} from \"../contracts/image-model.contract\";\nimport type { BaseReport } from \"../contracts/result/base-report.type\";\nimport { REPORT_SCHEMA_VERSION } from \"../contracts/result/base-report.type\";\nimport type { ExecuteResult } from \"../contracts/result/execute-result.type\";\nimport type { Usage } from \"../contracts/result/usage.type\";\nimport { AIError } from \"../errors/ai-error\";\nimport { ProviderError } from \"../errors/provider-error\";\nimport type { FlowObserveOption } from \"../observe/resolve-observers\";\nimport { notifyObservers } from \"../observe/resolve-observers\";\nimport { generateRunId } from \"../utils/generate-run-id\";\nimport { stampReportLineage } from \"../utils/stamp-report-lineage\";\nimport { computeImageCost } from \"./image-cost\";\n\n/**\n * Parameters for {@link image}. `model` comes from an adapter's\n * `image()` factory (`openai.image({ name })` / `google.image({ name })`);\n * the rest are provider-neutral generation knobs plus the standard\n * observability seam every verb shares.\n */\nexport type ImageParams = {\n  /** The image model to generate from (`sdk.image({ name })`). */\n  model: ImageModelContract;\n  /** Text description of the image(s) to generate. */\n  prompt: string;\n  /** How many images to generate. Adapters clamp to the provider max. */\n  count?: number;\n  /** Requested pixel size as `\"WxH\"` (e.g. `\"1024x1024\"`). */\n  size?: string;\n  /** Quality tier (e.g. `\"standard\"` / `\"hd\"`). */\n  quality?: string;\n  /** Aspect ratio (e.g. `\"1:1\"`, `\"16:9\"`) — ratio-based providers (Imagen). */\n  aspectRatio?: string;\n  /** Concepts to steer away from (Imagen `negativePrompt`). */\n  negativePrompt?: string;\n  /** Output container hint (`\"png\"` / `\"jpeg\"` / `\"webp\"`). */\n  format?: string;\n  /** Cancellation handle, wired into the provider request where supported. */\n  signal?: AbortSignal;\n  /**\n   * Observability routing for this call — same `observe` seam as\n   * agents / workflows. `true` routes to the globally registered\n   * observers; an `Observer` object routes flow-locally; `false` opts\n   * out; omitted follows the global observe-all flag.\n   */\n  observe?: FlowObserveOption;\n  /** Groups this call into a session for flat cost/trace queries. */\n  sessionId?: string;\n  /** Report node name (defaults to `\"image\"`). */\n  name?: string;\n  /** Provider-specific options forwarded verbatim to the adapter. */\n  options?: Record<string, unknown>;\n};\n\n/** Success payload of an {@link image} run. */\nexport type ImageData = {\n  /** The generated images, normalized to the discriminated shape. */\n  images: GeneratedImage[];\n};\n\n/**\n * The report node an {@link image} run produces — a {@link BaseReport}\n * (`type: \"image\"`) plus which model ran and how many images came back,\n * so panoptic and any flat-row consumer attribute the cost/latency\n * without special-casing.\n */\nexport type ImageReport = BaseReport & {\n  type: \"image\";\n  /** Identity of the image model this run used. */\n  model: { name: string; provider: string };\n  /** Number of images returned (0 on failure). */\n  imageCount: number;\n};\n\n/**\n * Result envelope of {@link image} — the same uniform\n * `{ data, error, usage, report }` every executable returns, narrowed\n * with the `\"image\"` discriminant.\n */\nexport type ImageResult = ExecuteResult<ImageData> & {\n  type: \"image\";\n  report: ImageReport;\n};\n\n/**\n * Generate one or more images from a text prompt — the image-output\n * counterpart to `ai.agent`, and the first verb of the output-modality\n * track (Theme I). Wraps an {@link ImageModelContract} (from\n * `openai.image(...)` / `google.image(...)`) in the framework's uniform\n * result contract:\n *\n * - **Never throws.** Provider failures (auth, rate-limit,\n *   content-filter, invalid request) surface as a typed `AIError` on\n *   `result.error`; `result.data` is then `undefined`.\n * - **Cost-truth.** When the model carries pricing, `result.usage.cost`\n *   is filled in — per-token for gpt-image-1, per-image for\n *   DALL·E / Imagen — folding into the same `Usage.cost` rollup as text.\n * - **Observable.** The completed {@link ImageReport} routes to any\n *   registered `Observer` (panoptic, OTel, …) via the shared `observe`\n *   seam, exactly like an agent run.\n *\n * @example\n * const openai = new OpenAISDK({ apiKey });\n * const { data, error, usage } = await ai.image({\n *   model: openai.image({ name: \"gpt-image-1\" }),\n *   prompt: \"an isometric office desk, soft studio lighting\",\n *   size: \"1024x1024\",\n * });\n *\n * if (error) console.warn(error.code);\n * else for (const img of data.images) save(img); // { type: \"base64\" | \"url\", ... }\n */\nexport async function image(params: ImageParams): Promise<ImageResult> {\n  const { model, prompt } = params;\n\n  const runId = generateRunId(\"image\");\n  const startedAt = new Date().toISOString();\n  const startPerf = performance.now();\n\n  const usage: Usage = { input: 0, output: 0, total: 0 };\n  let data: ImageData | undefined;\n  let error: AIError | undefined;\n  let status: ImageReport[\"status\"] = \"completed\";\n  let imageCount = 0;\n\n  try {\n    const response = await model.generate(prompt, {\n      count: params.count,\n      size: params.size,\n      quality: params.quality,\n      aspectRatio: params.aspectRatio,\n      negativePrompt: params.negativePrompt,\n      format: params.format,\n      signal: params.signal,\n      ...params.options,\n    });\n\n    // Preserve every usage channel the adapter reported (cached /\n    // reasoning / cache-write, and any adapter-supplied `cost`), mirroring\n    // how the agent path routes provider usage. Then honor a pre-priced\n    // response or compute image cost — `usage.cost ??= …` precedence, same\n    // as the agent path.\n    Object.assign(usage, response.usage);\n\n    if (usage.cost === undefined) {\n      const cost = computeImageCost(usage, response.images.length, params.size, model.pricing);\n      if (cost !== undefined) {\n        usage.cost = cost;\n      }\n    }\n\n    data = { images: response.images };\n    imageCount = response.images.length;\n  } catch (thrown) {\n    error = thrown instanceof AIError ? thrown : new ProviderError(toMessage(thrown), { cause: thrown });\n    // A caller-aborted run is \"cancelled\", not \"failed\" — keep the typed\n    // cause but distinguish the terminal status for dashboards/retry policy.\n    status = params.signal?.aborted ? \"cancelled\" : \"failed\";\n  }\n\n  const report: ImageReport = {\n    runId,\n    rootRunId: runId,\n    name: params.name ?? \"image\",\n    type: \"image\",\n    status,\n    error,\n    startedAt,\n    endedAt: new Date().toISOString(),\n    duration: performance.now() - startPerf,\n    usage,\n    children: [],\n    model: { name: model.name, provider: model.provider },\n    imageCount,\n    reportSchemaVersion: REPORT_SCHEMA_VERSION,\n  };\n\n  stampReportLineage(report, { rootRunId: runId, sessionId: params.sessionId });\n\n  await notifyObservers(params.observe, report);\n\n  return { type: \"image\", data, error, usage, report };\n}\n\n/** Best-effort message for a non-`AIError` thrown value. */\nfunction toMessage(thrown: unknown): string {\n  return thrown instanceof Error ? thrown.message : String(thrown);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkHA,eAAsB,MAAM,QAA2C;CACrE,MAAM,EAAE,OAAO,WAAW;CAE1B,MAAM,QAAQ,cAAc,OAAO;CACnC,MAAM,6BAAY,IAAI,KAAK,EAAC,CAAC,YAAY;CACzC,MAAM,YAAY,YAAY,IAAI;CAElC,MAAM,QAAe;EAAE,OAAO;EAAG,QAAQ;EAAG,OAAO;CAAE;CACrD,IAAI;CACJ,IAAI;CACJ,IAAI,SAAgC;CACpC,IAAI,aAAa;CAEjB,IAAI;EACF,MAAM,WAAW,MAAM,MAAM,SAAS,QAAQ;GAC5C,OAAO,OAAO;GACd,MAAM,OAAO;GACb,SAAS,OAAO;GAChB,aAAa,OAAO;GACpB,gBAAgB,OAAO;GACvB,QAAQ,OAAO;GACf,QAAQ,OAAO;GACf,GAAG,OAAO;EACZ,CAAC;EAOD,OAAO,OAAO,OAAO,SAAS,KAAK;EAEnC,IAAI,MAAM,SAAS,QAAW;GAC5B,MAAM,OAAO,iBAAiB,OAAO,SAAS,OAAO,QAAQ,OAAO,MAAM,MAAM,OAAO;GACvF,IAAI,SAAS,QACX,MAAM,OAAO;EAEjB;EAEA,OAAO,EAAE,QAAQ,SAAS,OAAO;EACjC,aAAa,SAAS,OAAO;CAC/B,SAAS,QAAQ;EACf,QAAQ,kBAAkB,UAAU,SAAS,IAAI,cAAc,UAAU,MAAM,GAAG,EAAE,OAAO,OAAO,CAAC;EAGnG,SAAS,OAAO,QAAQ,UAAU,cAAc;CAClD;CAEA,MAAM,SAAsB;EAC1B;EACA,WAAW;EACX,MAAM,OAAO,QAAQ;EACrB,MAAM;EACN;EACA;EACA;EACA,0BAAS,IAAI,KAAK,EAAC,CAAC,YAAY;EAChC,UAAU,YAAY,IAAI,IAAI;EAC9B;EACA,UAAU,CAAC;EACX,OAAO;GAAE,MAAM,MAAM;GAAM,UAAU,MAAM;EAAS;EACpD;EACA;CACF;CAEA,mBAAmB,QAAQ;EAAE,WAAW;EAAO,WAAW,OAAO;CAAU,CAAC;CAE5E,MAAM,gBAAgB,OAAO,SAAS,MAAM;CAE5C,OAAO;EAAE,MAAM;EAAS;EAAM;EAAO;EAAO;CAAO;AACrD;;AAGA,SAAS,UAAU,QAAyB;CAC1C,OAAO,kBAAkB,QAAQ,OAAO,UAAU,OAAO,MAAM;AACjE"}

package/esm/ai/src/image/index.mjs

@@ -0,0 +1,4 @@
+import { computeImageCost } from "./image-cost.mjs";
+import { image } from "./image.mjs";
+
+export {  };

package/esm/ai/src/index.mjs

@@ -0,0 +1,194 @@
+import { AIError } from "./errors/ai-error.mjs";
+import { AgentExecutionError } from "./errors/agent-execution-error.mjs";
+import { AgentCancelledError } from "./errors/agent-cancelled-error.mjs";
+import { AgentDriftError } from "./errors/agent-drift-error.mjs";
+import { AgentMaxTripsError } from "./errors/agent-max-trips-error.mjs";
+import { BudgetExceededError } from "./errors/budget-exceeded-error.mjs";
+import { ProviderError } from "./errors/provider-error.mjs";
+import { GuardrailViolationError } from "./errors/guardrail-violation-error.mjs";
+import { InvalidRequestError } from "./errors/invalid-request-error.mjs";
+import { SupervisorFailedError } from "./errors/supervisor-failed-error.mjs";
+import { MaxIterationsError } from "./errors/max-iterations-error.mjs";
+import { WorkflowError } from "./errors/workflow-error.mjs";
+import { MaxStepsExceededError } from "./errors/max-steps-exceeded-error.mjs";
+import { OrchestratorFailedError } from "./errors/orchestrator-failed-error.mjs";
+import { OrchestratorConfigError } from "./errors/orchestrator-config-error.mjs";
+import { OrchestratorDriftError } from "./errors/orchestrator-drift-error.mjs";
+import { OutboundPolicyError } from "./errors/outbound-policy-error.mjs";
+import { PlannerFailedError } from "./errors/planner-failed-error.mjs";
+import { PlannerCancelledError } from "./errors/planner-cancelled-error.mjs";
+import { PlannerDriftError } from "./errors/planner-drift-error.mjs";
+import { PlannerPlanInvalidError } from "./errors/planner-plan-invalid-error.mjs";
+import { RoutingError } from "./errors/routing-error.mjs";
+import { SchemaValidationError } from "./errors/schema-validation-error.mjs";
+import { StepFailedError } from "./errors/step-failed-error.mjs";
+import { SupervisorCancelledError } from "./errors/supervisor-cancelled-error.mjs";
+import { SupervisorDriftError } from "./errors/supervisor-drift-error.mjs";
+import { SupervisorRoutingError } from "./errors/supervisor-routing-error.mjs";
+import { ToolExecutionError } from "./errors/tool-execution-error.mjs";
+import { WorkflowCancelledError } from "./errors/workflow-cancelled-error.mjs";
+import { WorkflowDriftError } from "./errors/workflow-drift-error.mjs";
+import "./errors/index.mjs";
+import { accumulateCost, computeCost, mergeUsage } from "./utils/compute-cost.mjs";
+import { extractJsonPayload } from "./utils/extract-json-payload.mjs";
+import { extractJsonLenient } from "./utils/extract-json-lenient.mjs";
+import { generateRunId } from "./utils/generate-run-id.mjs";
+import { extractJsonSchema } from "./utils/json-schema.mjs";
+import { isPrivateOrReservedIp } from "./security/private-ip.mjs";
+import { assertUrlAllowed, fetchTextWithPolicy, guardedFetch, readTextCapped, resolveOutboundPolicy } from "./security/outbound-policy.mjs";
+import { resolveAttachment } from "./utils/resolve-attachment.mjs";
+import { prepareAttachmentPart } from "./utils/prepare-attachment-part.mjs";
+import { captureChildReport, withRunFrame, withoutRunFrame } from "./utils/run-context.mjs";
+import { safeJsonParse } from "./utils/safe-json-parse.mjs";
+import { stampReportLineage } from "./utils/stamp-report-lineage.mjs";
+import "./utils/index.mjs";
+import { judge } from "./eval/judge-scorer.mjs";
+import { diff } from "./eval/regression.mjs";
+import { runEval } from "./eval/eval-runner.mjs";
+import { extractUserText } from "./middleware/utils/extract-user-text.mjs";
+import { namespacedState } from "./middleware/utils/namespaced-state.mjs";
+import { budget, readBudgetFallbackSignal } from "./middleware/builtins/budget.mjs";
+import { resolveDefaultCheckpointStore, resolveDefaultSnapshotStore, resolveDefaultStore, setAIConfig } from "./config.mjs";
+import { semanticCache } from "./middleware/builtins/semantic-cache.mjs";
+import { composeMiddleware } from "./middleware/helpers/compose.mjs";
+import { forTool } from "./middleware/helpers/for-tool.mjs";
+import { runPipeline } from "./middleware/pipeline.mjs";
+import "./middleware/index.mjs";
+import { getObservers, isObserveAll } from "./observe/observer-registry.mjs";
+import { resolveObservers } from "./observe/resolve-observers.mjs";
+import { buildCatalog, loadRecord, renderCatalogPrompt, semanticPreselect } from "./skills/catalog.mjs";
+import { tool } from "./tool/tool.mjs";
+import { loadSkillTool } from "./skills/load-skill-tool.mjs";
+import { saveSkillTool } from "./skills/save-skill-tool.mjs";
+import { parseFrontmatter, parseTags } from "./skills/sources/parse-frontmatter.mjs";
+import { directorySource } from "./skills/sources/directory-source.mjs";
+import { storeSource } from "./skills/sources/store-source.mjs";
+import { urlSource } from "./skills/sources/url-source.mjs";
+import { resolveSource } from "./skills/sources/index.mjs";
+import { skills } from "./skills/skills.mjs";
+import { memory } from "./memory/memory.mjs";
+import "./skills/index.mjs";
+import { executableToTool, isExecutableTool, normalizeAgentTools } from "./tool/executable-as-tool.mjs";
+import { createAgentStream } from "./agent/agent-stream.mjs";
+import { agent } from "./agent/agent.mjs";
+import { spawnSubAgent } from "./agent/spawn-sub-agent.mjs";
+import "./agent/index.mjs";
+import { batch } from "./batch/batch.mjs";
+import "./batch/index.mjs";
+import { parsePartialJson } from "./object-stream/parse-partial-json.mjs";
+import { streamObject } from "./object-stream/stream-object.mjs";
+import "./object-stream/index.mjs";
+import { SSE_DONE, encodeSSE } from "./serve/sse.mjs";
+import { streamToSSE } from "./serve/stream-to-sse.mjs";
+import { serve } from "./serve/serve.mjs";
+import { memory as memory$1 } from "./checkpoint/memory.mjs";
+import { pg } from "./checkpoint/pg.mjs";
+import { redis } from "./checkpoint/redis.mjs";
+import { fromJSON, toJSON } from "./eval/report-json.mjs";
+import { toJUnit } from "./eval/report-junit.mjs";
+import { contains, exact, predicate } from "./eval/scorers.mjs";
+import { dataset } from "./eval/dataset.mjs";
+import { evalScorers } from "./eval/index.mjs";
+import { ApprovalRejectedError, InterruptSuspendedError } from "./human/errors.mjs";
+import { evaluatePolicy } from "./human/policy.mjs";
+import { humanApproval } from "./human/human-approval.mjs";
+import { resume } from "./human/resume.mjs";
+import { memory as memory$2 } from "./human/stores/memory.mjs";
+import { pg as pg$1 } from "./human/stores/pg.mjs";
+import { redis as redis$1 } from "./human/stores/redis.mjs";
+import "./human/stores/index.mjs";
+import { computeImageCost } from "./image/image-cost.mjs";
+import { image } from "./image/image.mjs";
+import "./image/index.mjs";
+import { speech } from "./speech/speech.mjs";
+import "./speech/index.mjs";
+import { audioFromBuffer, audioFromFile, audioMediaTypeForFilename } from "./transcribe/audio-input.mjs";
+import { transcribe } from "./transcribe/transcribe.mjs";
+import "./transcribe/index.mjs";
+import { injection } from "./guard/detectors/injection.mjs";
+import { pii } from "./guard/detectors/pii.mjs";
+import { topic } from "./guard/detectors/topic.mjs";
+import { OPENAI_INSTALL_INSTRUCTIONS } from "./guard/errors.mjs";
+import { moderation } from "./guard/detectors/moderation.mjs";
+import "./guard/detectors/index.mjs";
+import { guard } from "./guard/guard.mjs";
+import { guardrail } from "./guard/guardrail.mjs";
+import { END } from "./contracts/end.type.mjs";
+import { mockRouter } from "./mock/mock-router.mjs";
+import "./mock/index.mjs";
+import { fallbackModel } from "./model/fallback-model.mjs";
+import "./model/index.mjs";
+import { asTool } from "./orchestrator/as-tool.mjs";
+import { createCommandDispatcher } from "./orchestrator/commands.mjs";
+import { OrchestratorEmitter } from "./orchestrator/emitter.mjs";
+import { injectMemories, memoryQueryFromInput, outcomeTextFromTurn, recallForTurn, rememberTurnOutcome, resolveOrchestratorMemory } from "./orchestrator/memory.mjs";
+import { asTool as asTool$1 } from "./supervisor/as-tool.mjs";
+import { SupervisorEmitter } from "./supervisor/emitter.mjs";
+import { resolveIntentEntries } from "./supervisor/entries.mjs";
+import { createCancelledError } from "./supervisor/cancellation.mjs";
+import { buildRouterContextMessage } from "./supervisor/router-prompt.mjs";
+import { loadSnapshotForResume, persistSupervisorSnapshot } from "./supervisor/snapshot.mjs";
+import { SupervisorExecution } from "./supervisor/execution.mjs";
+import { computeSignature } from "./supervisor/signature.mjs";
+import { createSupervisorStream } from "./supervisor/supervisor-stream.mjs";
+import { supervisor } from "./supervisor/supervisor.mjs";
+import { OrchestratorExecution, runResume, runTurn } from "./orchestrator/execution.mjs";
+import { createOrchestratorStream } from "./orchestrator/orchestrator-stream.mjs";
+import { inProcessSessionLock, noopSessionLock } from "./orchestrator/session-lock.mjs";
+import { computeOrchestratorSignature } from "./orchestrator/signature.mjs";
+import { orchestrator } from "./orchestrator/orchestrator.mjs";
+import "./orchestrator/index.mjs";
+import { buildPlanSystemPrompt } from "./planner/plan-prompt.mjs";
+import { planSchema } from "./planner/plan-schema.mjs";
+import { computeSignature as computeSignature$1 } from "./planner/signature.mjs";
+import { planner } from "./planner/planner.mjs";
+import "./planner/index.mjs";
+import { renderPlaceholders } from "./system-prompt/render-placeholders.mjs";
+import { Instruction, instruction } from "./system-prompt/instruction.mjs";
+import { Persona, persona } from "./system-prompt/persona.mjs";
+import { SystemPrompt, systemPrompt } from "./system-prompt/system-prompt.mjs";
+import { defaultPromptsManager, promptKey, prompts } from "./prompts/prompts-manager.mjs";
+import { chunk } from "./rag/chunk/chunk.mjs";
+import { cacheVectorStore } from "./rag/store/cache-vector-store.mjs";
+import { rag } from "./rag/rag.mjs";
+import { pgVectorStore, vectorLiteral } from "./rag/store/pg-vector-store.mjs";
+import { loadText } from "./rag/loaders/load-text.mjs";
+import { loadHtml } from "./rag/loaders/load-html.mjs";
+import { loadWeb } from "./rag/loaders/load-web.mjs";
+import { PDF_PARSE_INSTALL_INSTRUCTIONS } from "./rag/loaders/errors.mjs";
+import { loadPdf } from "./rag/loaders/load-pdf.mjs";
+import { keywordReranker } from "./rag/rerank/keyword-reranker.mjs";
+import { llmReranker } from "./rag/rerank/llm-reranker.mjs";
+import { reciprocalRankFusion } from "./rag/hybrid/rrf.mjs";
+import { bm25Rank } from "./rag/hybrid/bm25.mjs";
+import { hybridRank } from "./rag/hybrid/hybrid-rank.mjs";
+import { multiQuery } from "./rag/transforms/multi-query.mjs";
+import "./rag/index.mjs";
+import { PromptNotFoundError, PromptValidationError } from "./prompt/errors.mjs";
+import { prompt } from "./prompt/prompt.mjs";
+import "./prompt/index.mjs";
+import { DEFAULT_SENSITIVE_KEYS, redact } from "./security/redact.mjs";
+import { VcrCassetteMissError } from "./vcr/errors.mjs";
+import { DEFAULT_HASH_OPTIONS, hashRequest } from "./vcr/hash-request.mjs";
+import { vcr } from "./vcr/vcr.mjs";
+import "./vcr/index.mjs";
+import { memory as memory$3 } from "./snapshot/memory.mjs";
+import { pg as pg$2 } from "./snapshot/pg.mjs";
+import { redis as redis$2 } from "./snapshot/redis.mjs";
+import { fanOut } from "./supervisor/fan-out.mjs";
+import { router } from "./supervisor/router-factory.mjs";
+import "./supervisor/index.mjs";
+import { team } from "./team/team.mjs";
+import { step } from "./workflow/step.mjs";
+import { computeSignature as computeSignature$2 } from "./workflow/signature.mjs";
+import { workflow } from "./workflow/workflow.mjs";
+import { ai } from "./ai.mjs";
+import "./observe/index.mjs";
+import "./prompts/index.mjs";
+import "./security/index.mjs";
+import "./team/index.mjs";
+import "./system-prompt/index.mjs";
+import "./tool/index.mjs";
+import "./workflow/index.mjs";
+
+export { ai };

package/esm/ai/src/memory/derive-id.mjs

@@ -0,0 +1,24 @@
+//#region ../@warlock.js/ai/src/memory/derive-id.ts
+/**
+* Derive a stable memory id from its text when the caller didn't supply
+* one. Re-remembering identical text therefore lands on the same id and
+* overwrites in place rather than duplicating.
+*
+* FNV-1a variant — cheap, dependency-free, collision-resistant enough
+* for de-duplicating memory entries. NOT cryptographic: a collision
+* would merge two distinct memories, not breach security in the current
+* trust model. Mirrors the prompt hash in
+* `middleware/builtins/semantic-cache.ts`.
+*/
+function deriveMemoryId(text) {
+	let hash = 2166136261;
+	for (let index = 0; index < text.length; index++) {
+		hash ^= text.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16);
+}
+
+//#endregion
+export { deriveMemoryId };
+//# sourceMappingURL=derive-id.mjs.map