@warlock.js/core 4.7.0 → 4.8.1

package/esm/ai/src/memory/procedural-memory.mjs

@@ -1,103 +0,0 @@
-import { deriveMemoryId } from "./derive-id.mjs";
-
-//#region ../@warlock.js/ai/src/memory/procedural-memory.ts
-/**
-* Extra candidates pulled from `similar()` before re-ranking by the
-* reinforcement-blended score and slicing to `k` — reinforcement can
-* promote a well-worn procedure past a slightly-closer one-off, which the
-* raw top-`k` by similarity would miss.
-*/
-const RECALL_OVERSCAN = 5;
-/**
-* Procedural recall tier (memory core M2).
-*
-* Holds durable *how-to* knowledge — learned procedures, policies, and
-* playbooks — and retrieves the ones relevant to a query, **blended with
-* reinforcement** so procedures that have proven themselves (remembered /
-* re-affirmed more often) outrank one-offs at equal similarity. That
-* reinforcement weighting is the difference from the semantic tier (which
-* treats every fact equally): procedural memory gets *stronger with use*.
-*
-* Reinforcement is explicit and side-effect-free on read: re-remembering
-* a procedure (same id, or same text → same derived id) increments its
-* `uses`, so a caller strengthens a procedure by remembering it again
-* after a successful application. Recall never mutates.
-*
-* Like the other vector tiers it delegates similarity to the
-* `@warlock.js/cache` driver's `similar()`. The blended `score` stays in
-* `[0, 1]` so procedural hits merge and sort alongside the other tiers.
-*
-* Internal to the `memory()` factory — never exported on the package
-* surface.
-*/
-var ProceduralMemory = class {
-	constructor(embedder, store, namespace, reinforcementWeight) {
-		this.embedder = embedder;
-		this.store = store;
-		this.namespace = namespace;
-		this.reinforcementWeight = reinforcementWeight;
-	}
-	/**
-	* Embed the procedure text and index it, incrementing its `uses` when
-	* it already exists (reinforcement) or seeding it at `1` when new.
-	* Metadata on a reinforcing write wins; an omitted metadata keeps the
-	* prior value rather than wiping it.
-	*/
-	async remember(item) {
-		const id = item.id ?? deriveMemoryId(item.text);
-		const { vector } = await this.embedder.embed(item.text);
-		const existing = await this.store.get(this.keyFor(id));
-		const uses = (existing?.uses ?? 0) + 1;
-		const value = {
-			id,
-			text: item.text,
-			uses,
-			metadata: item.metadata ?? existing?.metadata
-		};
-		await this.store.set(this.keyFor(id), value, { vector });
-	}
-	/**
-	* Embed `query`, pull the nearest procedures clearing the similarity
-	* `threshold`, then re-rank each by a reinforcement-blended score and
-	* return the top `k`. The similarity floor still gates relevance;
-	* reinforcement only reorders procedures that already cleared it.
-	*/
-	async recall(query, k, threshold) {
-		const { vector } = await this.embedder.embed(query);
-		const hits = await this.store.similar(vector, {
-			topK: Math.max(k * RECALL_OVERSCAN, k),
-			threshold
-		});
-		const prefix = `${this.namespace}.`;
-		return hits.filter((hit) => hit.key.startsWith(prefix)).map((hit) => ({
-			id: hit.value.id,
-			text: hit.value.text,
-			tier: "procedural",
-			score: this.blend(hit.score, hit.value.uses),
-			metadata: hit.value.metadata
-		})).sort((first, second) => second.score - first.score).slice(0, k);
-	}
-	/** Drop every procedure written under this instance's namespace. */
-	async clear() {
-		await this.store.removeNamespace(this.namespace);
-	}
-	/**
-	* Combine raw similarity with a saturating reinforcement proxy:
-	* `(1 - w)·similarity + w·(uses / (uses + 1))`. A first-time procedure
-	* contributes `0.5`; each reinforcement nudges it toward `1` with
-	* diminishing returns. With `reinforcementWeight` 0 the score is pure
-	* similarity.
-	*/
-	blend(similarity, uses) {
-		const reinforcement = uses / (uses + 1);
-		return (1 - this.reinforcementWeight) * similarity + this.reinforcementWeight * reinforcement;
-	}
-	/** Namespaced key for an entry — dot separator, matching `similar()` keys. */
-	keyFor(id) {
-		return `${this.namespace}.${id}`;
-	}
-};
-
-//#endregion
-export { ProceduralMemory };
-//# sourceMappingURL=procedural-memory.mjs.map

package/esm/ai/src/memory/procedural-memory.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"procedural-memory.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/memory/procedural-memory.ts"],"sourcesContent":["import type { CacheDriver, CacheSimilarHit } from \"@warlock.js/cache\";\nimport type { EmbedderContract } from \"../contracts/embedder.contract\";\nimport type {\n  MemoryItem,\n  RecalledMemory,\n} from \"../contracts/memory/memory-item.type\";\nimport { deriveMemoryId } from \"./derive-id\";\n\n/**\n * Shape persisted per procedure. `uses` is the reinforcement counter —\n * how many times the procedure has been remembered/re-affirmed — and\n * feeds the reinforcement half of the blended recall score. The vector\n * lives in the driver's index, so it is not duplicated here.\n */\ntype StoredProcedure = {\n  id: string;\n  text: string;\n  uses: number;\n  metadata?: Record<string, unknown>;\n};\n\n/**\n * Extra candidates pulled from `similar()` before re-ranking by the\n * reinforcement-blended score and slicing to `k` — reinforcement can\n * promote a well-worn procedure past a slightly-closer one-off, which the\n * raw top-`k` by similarity would miss.\n */\nconst RECALL_OVERSCAN = 5;\n\n/**\n * Procedural recall tier (memory core M2).\n *\n * Holds durable *how-to* knowledge — learned procedures, policies, and\n * playbooks — and retrieves the ones relevant to a query, **blended with\n * reinforcement** so procedures that have proven themselves (remembered /\n * re-affirmed more often) outrank one-offs at equal similarity. That\n * reinforcement weighting is the difference from the semantic tier (which\n * treats every fact equally): procedural memory gets *stronger with use*.\n *\n * Reinforcement is explicit and side-effect-free on read: re-remembering\n * a procedure (same id, or same text → same derived id) increments its\n * `uses`, so a caller strengthens a procedure by remembering it again\n * after a successful application. Recall never mutates.\n *\n * Like the other vector tiers it delegates similarity to the\n * `@warlock.js/cache` driver's `similar()`. The blended `score` stays in\n * `[0, 1]` so procedural hits merge and sort alongside the other tiers.\n *\n * Internal to the `memory()` factory — never exported on the package\n * surface.\n */\nexport class ProceduralMemory {\n  public constructor(\n    private readonly embedder: EmbedderContract,\n    private readonly store: CacheDriver<any, any>,\n    private readonly namespace: string,\n    private readonly reinforcementWeight: number,\n  ) {}\n\n  /**\n   * Embed the procedure text and index it, incrementing its `uses` when\n   * it already exists (reinforcement) or seeding it at `1` when new.\n   * Metadata on a reinforcing write wins; an omitted metadata keeps the\n   * prior value rather than wiping it.\n   */\n  public async remember(item: MemoryItem): Promise<void> {\n    const id = item.id ?? deriveMemoryId(item.text);\n    const { vector } = await this.embedder.embed(item.text);\n\n    const existing = await this.store.get<StoredProcedure>(this.keyFor(id));\n    const uses = (existing?.uses ?? 0) + 1;\n\n    const value: StoredProcedure = {\n      id,\n      text: item.text,\n      uses,\n      metadata: item.metadata ?? existing?.metadata,\n    };\n\n    await this.store.set(this.keyFor(id), value, { vector });\n  }\n\n  /**\n   * Embed `query`, pull the nearest procedures clearing the similarity\n   * `threshold`, then re-rank each by a reinforcement-blended score and\n   * return the top `k`. The similarity floor still gates relevance;\n   * reinforcement only reorders procedures that already cleared it.\n   */\n  public async recall(\n    query: string,\n    k: number,\n    threshold: number,\n  ): Promise<RecalledMemory[]> {\n    const { vector } = await this.embedder.embed(query);\n\n    const hits = await this.store.similar<StoredProcedure>(vector, {\n      topK: Math.max(k * RECALL_OVERSCAN, k),\n      threshold,\n    });\n\n    const prefix = `${this.namespace}.`;\n\n    return hits\n      .filter((hit: CacheSimilarHit<StoredProcedure>) =>\n        hit.key.startsWith(prefix),\n      )\n      .map((hit: CacheSimilarHit<StoredProcedure>) => ({\n        id: hit.value.id,\n        text: hit.value.text,\n        tier: \"procedural\" as const,\n        score: this.blend(hit.score, hit.value.uses),\n        metadata: hit.value.metadata,\n      }))\n      .sort((first, second) => second.score - first.score)\n      .slice(0, k);\n  }\n\n  /** Drop every procedure written under this instance's namespace. */\n  public async clear(): Promise<void> {\n    await this.store.removeNamespace(this.namespace);\n  }\n\n  /**\n   * Combine raw similarity with a saturating reinforcement proxy:\n   * `(1 - w)·similarity + w·(uses / (uses + 1))`. A first-time procedure\n   * contributes `0.5`; each reinforcement nudges it toward `1` with\n   * diminishing returns. With `reinforcementWeight` 0 the score is pure\n   * similarity.\n   */\n  private blend(similarity: number, uses: number): number {\n    const reinforcement = uses / (uses + 1);\n\n    return (\n      (1 - this.reinforcementWeight) * similarity +\n      this.reinforcementWeight * reinforcement\n    );\n  }\n\n  /** Namespaced key for an entry — dot separator, matching `similar()` keys. */\n  private keyFor(id: string): string {\n    return `${this.namespace}.${id}`;\n  }\n}\n"],"mappings":";;;;;;;;;AA2BA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;AAwBxB,IAAa,mBAAb,MAA8B;CAC5B,AAAO,YACL,AAAiB,UACjB,AAAiB,OACjB,AAAiB,WACjB,AAAiB,qBACjB;EAJiB;EACA;EACA;EACA;CAChB;;;;;;;CAQH,MAAa,SAAS,MAAiC;EACrD,MAAM,KAAK,KAAK,MAAM,eAAe,KAAK,IAAI;EAC9C,MAAM,EAAE,WAAW,MAAM,KAAK,SAAS,MAAM,KAAK,IAAI;EAEtD,MAAM,WAAW,MAAM,KAAK,MAAM,IAAqB,KAAK,OAAO,EAAE,CAAC;EACtE,MAAM,QAAQ,UAAU,QAAQ,KAAK;EAErC,MAAM,QAAyB;GAC7B;GACA,MAAM,KAAK;GACX;GACA,UAAU,KAAK,YAAY,UAAU;EACvC;EAEA,MAAM,KAAK,MAAM,IAAI,KAAK,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,CAAC;CACzD;;;;;;;CAQA,MAAa,OACX,OACA,GACA,WAC2B;EAC3B,MAAM,EAAE,WAAW,MAAM,KAAK,SAAS,MAAM,KAAK;EAElD,MAAM,OAAO,MAAM,KAAK,MAAM,QAAyB,QAAQ;GAC7D,MAAM,KAAK,IAAI,IAAI,iBAAiB,CAAC;GACrC;EACF,CAAC;EAED,MAAM,SAAS,GAAG,KAAK,UAAU;EAEjC,OAAO,KACJ,QAAQ,QACP,IAAI,IAAI,WAAW,MAAM,CAC3B,CAAC,CACA,KAAK,SAA2C;GAC/C,IAAI,IAAI,MAAM;GACd,MAAM,IAAI,MAAM;GAChB,MAAM;GACN,OAAO,KAAK,MAAM,IAAI,OAAO,IAAI,MAAM,IAAI;GAC3C,UAAU,IAAI,MAAM;EACtB,EAAE,CAAC,CACF,MAAM,OAAO,WAAW,OAAO,QAAQ,MAAM,KAAK,CAAC,CACnD,MAAM,GAAG,CAAC;CACf;;CAGA,MAAa,QAAuB;EAClC,MAAM,KAAK,MAAM,gBAAgB,KAAK,SAAS;CACjD;;;;;;;;CASA,AAAQ,MAAM,YAAoB,MAAsB;EACtD,MAAM,gBAAgB,QAAQ,OAAO;EAErC,QACG,IAAI,KAAK,uBAAuB,aACjC,KAAK,sBAAsB;CAE/B;;CAGA,AAAQ,OAAO,IAAoB;EACjC,OAAO,GAAG,KAAK,UAAU,GAAG;CAC9B;AACF"}

package/esm/ai/src/memory/semantic-memory.mjs

@@ -1,80 +0,0 @@
-import { deriveMemoryId } from "./derive-id.mjs";
-
-//#region ../@warlock.js/ai/src/memory/semantic-memory.ts
-/**
-* Semantic recall tier (memory core M1).
-*
-* Owns: embedding remembered text, writing it to a `@warlock.js/cache`
-* driver with `set({ vector })`, and retrieving by cosine similarity via
-* the driver's `similar()`. Does NOT own: the similarity algorithm or
-* the ANN index — those belong to the cache driver. This mirrors the
-* delegation model of `middleware/builtins/semantic-cache.ts`: memory is
-* embedding-agnostic and store-agnostic, gluing an {@link EmbedderContract}
-* to a {@link CacheDriver}.
-*
-* The driver may be shared across memory instances, so every key carries
-* the configured `namespace` and recall filters hits to that prefix —
-* foreign entries indexed by another instance never leak into a query.
-*
-* Internal to the `memory()` factory — never exported on the package
-* surface.
-*/
-var SemanticMemory = class {
-	constructor(embedder, store, namespace) {
-		this.embedder = embedder;
-		this.store = store;
-		this.namespace = namespace;
-	}
-	/**
-	* Embed the item's text and index it under a namespaced, id-derived
-	* key. Re-remembering the same id overwrites the prior vector +
-	* value (the driver upserts by key).
-	*/
-	async remember(item) {
-		const id = item.id ?? deriveMemoryId(item.text);
-		const { vector } = await this.embedder.embed(item.text);
-		const value = {
-			id,
-			text: item.text,
-			metadata: item.metadata
-		};
-		await this.store.set(this.keyFor(id), value, { vector });
-	}
-	/**
-	* Embed `query`, ask the driver for the `k` nearest entries clearing
-	* `threshold`, and return those within this instance's namespace as
-	* scored {@link RecalledMemory}. Hits indexed under a different
-	* namespace (a shared driver) are filtered out.
-	*/
-	async recall(query, k, threshold) {
-		const { vector } = await this.embedder.embed(query);
-		const hits = await this.store.similar(vector, {
-			topK: k,
-			threshold
-		});
-		const prefix = `${this.namespace}.`;
-		return hits.filter((hit) => hit.key.startsWith(prefix)).map((hit) => ({
-			id: hit.value.id,
-			text: hit.value.text,
-			tier: "semantic",
-			score: hit.score,
-			metadata: hit.value.metadata
-		}));
-	}
-	/** Drop every semantic entry written under this instance's namespace. */
-	async clear() {
-		await this.store.removeNamespace(this.namespace);
-	}
-	/**
-	* Namespaced key for an entry. The cache's `parseKey` normalizes `:`
-	* to `.`, so a dot separator keeps the prefix used here aligned with
-	* the `hit.key` the driver returns from `similar()`.
-	*/
-	keyFor(id) {
-		return `${this.namespace}.${id}`;
-	}
-};
-
-//#endregion
-export { SemanticMemory };
-//# sourceMappingURL=semantic-memory.mjs.map

package/esm/ai/src/memory/semantic-memory.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"semantic-memory.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/memory/semantic-memory.ts"],"sourcesContent":["import type { CacheDriver, CacheSimilarHit } from \"@warlock.js/cache\";\nimport type { EmbedderContract } from \"../contracts/embedder.contract\";\nimport type {\n  MemoryItem,\n  RecalledMemory,\n} from \"../contracts/memory/memory-item.type\";\nimport { deriveMemoryId } from \"./derive-id\";\n\n/**\n * Shape persisted per semantic memory in the cache driver. The vector\n * itself is stored by the driver's own index (passed via\n * `set({ vector })`), so it is not duplicated in the value.\n */\ntype StoredMemory = {\n  id: string;\n  text: string;\n  metadata?: Record<string, unknown>;\n};\n\n/**\n * Semantic recall tier (memory core M1).\n *\n * Owns: embedding remembered text, writing it to a `@warlock.js/cache`\n * driver with `set({ vector })`, and retrieving by cosine similarity via\n * the driver's `similar()`. Does NOT own: the similarity algorithm or\n * the ANN index — those belong to the cache driver. This mirrors the\n * delegation model of `middleware/builtins/semantic-cache.ts`: memory is\n * embedding-agnostic and store-agnostic, gluing an {@link EmbedderContract}\n * to a {@link CacheDriver}.\n *\n * The driver may be shared across memory instances, so every key carries\n * the configured `namespace` and recall filters hits to that prefix —\n * foreign entries indexed by another instance never leak into a query.\n *\n * Internal to the `memory()` factory — never exported on the package\n * surface.\n */\nexport class SemanticMemory {\n  public constructor(\n    private readonly embedder: EmbedderContract,\n    private readonly store: CacheDriver<any, any>,\n    private readonly namespace: string,\n  ) {}\n\n  /**\n   * Embed the item's text and index it under a namespaced, id-derived\n   * key. Re-remembering the same id overwrites the prior vector +\n   * value (the driver upserts by key).\n   */\n  public async remember(item: MemoryItem): Promise<void> {\n    const id = item.id ?? deriveMemoryId(item.text);\n    const { vector } = await this.embedder.embed(item.text);\n\n    const value: StoredMemory = {\n      id,\n      text: item.text,\n      metadata: item.metadata,\n    };\n\n    await this.store.set(this.keyFor(id), value, { vector });\n  }\n\n  /**\n   * Embed `query`, ask the driver for the `k` nearest entries clearing\n   * `threshold`, and return those within this instance's namespace as\n   * scored {@link RecalledMemory}. Hits indexed under a different\n   * namespace (a shared driver) are filtered out.\n   */\n  public async recall(\n    query: string,\n    k: number,\n    threshold: number,\n  ): Promise<RecalledMemory[]> {\n    const { vector } = await this.embedder.embed(query);\n\n    const hits = await this.store.similar<StoredMemory>(vector, {\n      topK: k,\n      threshold,\n    });\n\n    const prefix = `${this.namespace}.`;\n\n    return hits\n      .filter((hit: CacheSimilarHit<StoredMemory>) =>\n        hit.key.startsWith(prefix),\n      )\n      .map((hit: CacheSimilarHit<StoredMemory>) => ({\n        id: hit.value.id,\n        text: hit.value.text,\n        tier: \"semantic\" as const,\n        score: hit.score,\n        metadata: hit.value.metadata,\n      }));\n  }\n\n  /** Drop every semantic entry written under this instance's namespace. */\n  public async clear(): Promise<void> {\n    await this.store.removeNamespace(this.namespace);\n  }\n\n  /**\n   * Namespaced key for an entry. The cache's `parseKey` normalizes `:`\n   * to `.`, so a dot separator keeps the prefix used here aligned with\n   * the `hit.key` the driver returns from `similar()`.\n   */\n  private keyFor(id: string): string {\n    return `${this.namespace}.${id}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBAAb,MAA4B;CAC1B,AAAO,YACL,AAAiB,UACjB,AAAiB,OACjB,AAAiB,WACjB;EAHiB;EACA;EACA;CAChB;;;;;;CAOH,MAAa,SAAS,MAAiC;EACrD,MAAM,KAAK,KAAK,MAAM,eAAe,KAAK,IAAI;EAC9C,MAAM,EAAE,WAAW,MAAM,KAAK,SAAS,MAAM,KAAK,IAAI;EAEtD,MAAM,QAAsB;GAC1B;GACA,MAAM,KAAK;GACX,UAAU,KAAK;EACjB;EAEA,MAAM,KAAK,MAAM,IAAI,KAAK,OAAO,EAAE,GAAG,OAAO,EAAE,OAAO,CAAC;CACzD;;;;;;;CAQA,MAAa,OACX,OACA,GACA,WAC2B;EAC3B,MAAM,EAAE,WAAW,MAAM,KAAK,SAAS,MAAM,KAAK;EAElD,MAAM,OAAO,MAAM,KAAK,MAAM,QAAsB,QAAQ;GAC1D,MAAM;GACN;EACF,CAAC;EAED,MAAM,SAAS,GAAG,KAAK,UAAU;EAEjC,OAAO,KACJ,QAAQ,QACP,IAAI,IAAI,WAAW,MAAM,CAC3B,CAAC,CACA,KAAK,SAAwC;GAC5C,IAAI,IAAI,MAAM;GACd,MAAM,IAAI,MAAM;GAChB,MAAM;GACN,OAAO,IAAI;GACX,UAAU,IAAI,MAAM;EACtB,EAAE;CACN;;CAGA,MAAa,QAAuB;EAClC,MAAM,KAAK,MAAM,gBAAgB,KAAK,SAAS;CACjD;;;;;;CAOA,AAAQ,OAAO,IAAoB;EACjC,OAAO,GAAG,KAAK,UAAU,GAAG;CAC9B;AACF"}

package/esm/ai/src/memory/working-memory.mjs

@@ -1,62 +0,0 @@
-import { deriveMemoryId } from "./derive-id.mjs";
-
-//#region ../@warlock.js/ai/src/memory/working-memory.ts
-/**
-* In-run working memory — the volatile scratch tier (memory core M1).
-*
-* Owns: an insertion-ordered buffer of remembered items keyed by id,
-* with overwrite-in-place on a repeated id. Does NOT own: durability,
-* cross-process sharing, embeddings, or similarity — working memory is
-* a plain in-process buffer the orchestrator threads across the turns of
-* a single run.
-*
-* Recall here is not semantic: with no vector index, "relevant" reduces
-* to "recent." `recall()` returns the most-recently-remembered items
-* first, each scored on a `[0, 1]` recency proxy so a caller can merge
-* working hits with semantic hits and sort on one `score` field.
-*
-* Internal to the `memory()` factory — never exported on the package
-* surface.
-*/
-var WorkingMemory = class {
-	constructor() {
-		this.entries = /* @__PURE__ */ new Map();
-	}
-	/**
-	* Append an item to the buffer (or overwrite the entry sharing its
-	* id). Re-inserting an existing id keeps its original position; delete
-	* + set would move it to the end and lie about recency, so the value
-	* is updated in place.
-	*/
-	remember(item) {
-		const id = item.id ?? deriveMemoryId(item.text);
-		this.entries.set(id, {
-			text: item.text,
-			metadata: item.metadata
-		});
-	}
-	/**
-	* Return up to `k` most-recently-remembered items, newest first. The
-	* `score` is a linear recency proxy: the newest item scores `1`, the
-	* oldest of the returned slice trends toward `0`. Working memory
-	* ignores any similarity threshold — it has no vector to compare.
-	*/
-	recall(k) {
-		const slice = [...this.entries.entries()].reverse().slice(0, Math.max(0, k));
-		return slice.map(([id, entry], index) => ({
-			id,
-			text: entry.text,
-			tier: "working",
-			score: slice.length <= 1 ? 1 : 1 - index / slice.length,
-			metadata: entry.metadata
-		}));
-	}
-	/** Drop every working-tier entry. */
-	clear() {
-		this.entries.clear();
-	}
-};
-
-//#endregion
-export { WorkingMemory };
-//# sourceMappingURL=working-memory.mjs.map

package/esm/ai/src/memory/working-memory.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"working-memory.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/memory/working-memory.ts"],"sourcesContent":["import type {\n  MemoryItem,\n  RecalledMemory,\n} from \"../contracts/memory/memory-item.type\";\nimport { deriveMemoryId } from \"./derive-id\";\n\n/**\n * In-run working memory — the volatile scratch tier (memory core M1).\n *\n * Owns: an insertion-ordered buffer of remembered items keyed by id,\n * with overwrite-in-place on a repeated id. Does NOT own: durability,\n * cross-process sharing, embeddings, or similarity — working memory is\n * a plain in-process buffer the orchestrator threads across the turns of\n * a single run.\n *\n * Recall here is not semantic: with no vector index, \"relevant\" reduces\n * to \"recent.\" `recall()` returns the most-recently-remembered items\n * first, each scored on a `[0, 1]` recency proxy so a caller can merge\n * working hits with semantic hits and sort on one `score` field.\n *\n * Internal to the `memory()` factory — never exported on the package\n * surface.\n */\nexport class WorkingMemory {\n  /**\n   * Id → text/metadata. A `Map` preserves insertion order, so iteration\n   * yields oldest-first; recall reverses it for most-recent-first.\n   */\n  private readonly entries = new Map<\n    string,\n    { text: string; metadata?: Record<string, unknown> }\n  >();\n\n  /**\n   * Append an item to the buffer (or overwrite the entry sharing its\n   * id). Re-inserting an existing id keeps its original position; delete\n   * + set would move it to the end and lie about recency, so the value\n   * is updated in place.\n   */\n  public remember(item: MemoryItem): void {\n    const id = item.id ?? deriveMemoryId(item.text);\n\n    this.entries.set(id, { text: item.text, metadata: item.metadata });\n  }\n\n  /**\n   * Return up to `k` most-recently-remembered items, newest first. The\n   * `score` is a linear recency proxy: the newest item scores `1`, the\n   * oldest of the returned slice trends toward `0`. Working memory\n   * ignores any similarity threshold — it has no vector to compare.\n   */\n  public recall(k: number): RecalledMemory[] {\n    const ordered = [...this.entries.entries()].reverse();\n    const slice = ordered.slice(0, Math.max(0, k));\n\n    return slice.map(([id, entry], index) => ({\n      id,\n      text: entry.text,\n      tier: \"working\" as const,\n      score: slice.length <= 1 ? 1 : 1 - index / slice.length,\n      metadata: entry.metadata,\n    }));\n  }\n\n  /** Drop every working-tier entry. */\n  public clear(): void {\n    this.entries.clear();\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,gBAAb,MAA2B;;iCAKE,IAAI,IAG7B;;;;;;;;CAQF,AAAO,SAAS,MAAwB;EACtC,MAAM,KAAK,KAAK,MAAM,eAAe,KAAK,IAAI;EAE9C,KAAK,QAAQ,IAAI,IAAI;GAAE,MAAM,KAAK;GAAM,UAAU,KAAK;EAAS,CAAC;CACnE;;;;;;;CAQA,AAAO,OAAO,GAA6B;EAEzC,MAAM,QADU,CAAC,GAAG,KAAK,QAAQ,QAAQ,CAAC,CAAC,CAAC,QACxB,CAAC,CAAC,MAAM,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC;EAE7C,OAAO,MAAM,KAAK,CAAC,IAAI,QAAQ,WAAW;GACxC;GACA,MAAM,MAAM;GACZ,MAAM;GACN,OAAO,MAAM,UAAU,IAAI,IAAI,IAAI,QAAQ,MAAM;GACjD,UAAU,MAAM;EAClB,EAAE;CACJ;;CAGA,AAAO,QAAc;EACnB,KAAK,QAAQ,MAAM;CACrB;AACF"}

package/esm/ai/src/middleware/builtins/budget.mjs

@@ -1,219 +0,0 @@
-import { BudgetExceededError } from "../../errors/budget-exceeded-error.mjs";
-import "../../errors/index.mjs";
-import { namespacedState } from "../utils/namespaced-state.mjs";
-
-//#region ../@warlock.js/ai/src/middleware/builtins/budget.ts
-/**
-* The `BudgetUnit` to stamp on the thrown error per contract dimension.
-* Latency has no native unit — it borrows `"requests"` as the least-wrong
-* operational measure, while the authoritative detail rides on the
-* error's `context.dimension`.
-*/
-const DIMENSION_UNIT = {
-	tokens: "tokens",
-	cost: "usd",
-	latency: "requests"
-};
-function breach(limit, actual, unit, name) {
-	throw new BudgetExceededError(`budget "${name}" exceeded — ${actual} ${unit} (cap: ${limit})`, {
-		limit,
-		actual,
-		unit
-	});
-}
-function breachContract(name, dimension, limit, actual) {
-	throw new BudgetExceededError(`budget "${name}" contract exceeded — ${dimension} ${actual} (cap: ${limit})`, {
-		limit,
-		actual,
-		unit: DIMENSION_UNIT[dimension],
-		context: {
-			dimension,
-			limit,
-			actual,
-			source: "contract"
-		}
-	});
-}
-/**
-* Read the contract fallback signal recorded by a `budget()` middleware
-* running under `contract.onViolation: "fallback"`. Returns `undefined`
-* when no clause was breached.
-*
-* **Role.** The middleware cannot itself switch models on a soft breach,
-* so it records a typed {@link BudgetFallbackSignal} in the shared state
-* bag and lets the run continue. A fallback orchestrator (or the
-* `execute.after` hook of an outer middleware) reads it back here and
-* decides how to degrade the next run — cheaper model, cached answer,
-* truncated context.
-*
-* @param state - The middleware state bag (`ctx.state`).
-* @param name - The budget middleware's name. Default `"budget"`,
-*   matching `BudgetOptions.name`'s default.
-*
-* @example
-* const guard = budget({ contract: { maxCostUSD: 0.05, onViolation: "fallback" } });
-*
-* // In an outer middleware's execute.after, after the run:
-* const signal = readBudgetFallbackSignal(ctx.state);
-* if (signal?.dimension === "cost") {
-*   await rerunOnCheaperModel();
-* }
-*/
-function readBudgetFallbackSignal(state, name = "budget") {
-	return namespacedState({ state }, `${name}.fallback`).get();
-}
-/**
-* Enforced token and / or USD budget for an agent run.
-*
-* **Role.** Guards against runaway tool loops, misconfigured
-* prompts, and unexpected provider price swings by capping
-* cumulative usage across every LLM trip of a single execution.
-* Aborts the run with a typed `BudgetExceededError` the moment a cap
-* is breached, rather than letting the damage grow trip by trip.
-*
-* **Scope.** Per-execution. A fresh counter is created at
-* `execute.before` and lives in the middleware state bag until the
-* run ends. Two concurrent `agent.execute()` calls on the same
-* agent therefore enforce the cap independently.
-*
-* **Token accounting.** After each successful trip, the middleware
-* adds `response.usage.total` to its running total and checks
-* against `maxTokens`. Synthetic trips (cache hits) contribute
-* `usage.total` as returned by the cache — cache middleware is
-* expected to surface zero usage on a hit, which naturally excludes
-* those trips from the budget.
-*
-* **USD accounting.** When `maxCostUSD` + `pricing[modelName]` are
-* both present, the middleware converts per-trip input / output
-* tokens to USD and accumulates. Missing pricing silently degrades
-* to tokens-only — explicit rather than guessing.
-*
-* **Warn mode.** `onExceeded: "warn"` logs a single warning the first
-* time a cap is breached and lets the run continue. Useful for
-* measuring real-world traffic against a proposed cap before flipping
-* to `"abort"` in production.
-*
-* **Contract / SLO mode.** Pass `contract` to enforce a declarative
-* service-level objective — `maxCostUSD`, `maxLatencyMs`, `maxTokens` —
-* on top of the legacy caps, with a single `onViolation` reaction:
-* `"abort"` hard-stops with `BudgetExceededError`; `"fallback"` records
-* a typed signal (read it via {@link readBudgetFallbackSignal}), fires
-* the optional `fallback` callback, and lets the run continue so an
-* outer layer can degrade gracefully. The contract's clauses are
-* evaluated independently of — and after — the top-level caps; the
-* top-level caps stay fully functional with or without a contract.
-*
-* @example
-* const budgetMiddleware = budget({ maxTokens: 50_000 });
-*
-* const myAgent = agent({
-*   model,
-*   middleware: [budgetMiddleware],
-* });
-*
-* @example
-* // With USD cap and custom pricing
-* const guard = budget({
-*   maxCostUSD: 0.5,
-*   pricing: {
-*     "gpt-4o": { inputPer1K: 0.005, outputPer1K: 0.015 },
-*   },
-* });
-*
-* @example
-* // SLO contract — soft-fallback on any breach
-* const sloGuard = budget({
-*   pricing: { "gpt-4o": { inputPer1K: 0.005, outputPer1K: 0.015 } },
-*   contract: {
-*     maxCostUSD: 0.05,
-*     maxLatencyMs: 8_000,
-*     maxTokens: 40_000,
-*     onViolation: "fallback",
-*     fallback: (violation) => routeToCheaperModel(violation.dimension),
-*   },
-* });
-*/
-function budget(options) {
-	const name = options.name ?? "budget";
-	const onExceeded = options.onExceeded ?? "abort";
-	const hasTokenCap = typeof options.maxTokens === "number";
-	const hasCostCap = typeof options.maxCostUSD === "number";
-	const contract = options.contract;
-	const contractMode = contract?.onViolation ?? "abort";
-	const hasContractTokenCap = typeof contract?.maxTokens === "number";
-	const hasContractCostCap = typeof contract?.maxCostUSD === "number";
-	const hasContractLatencyCap = typeof contract?.maxLatencyMs === "number";
-	const contractNeedsCost = hasCostCap || hasContractCostCap;
-	const warnedUnpricedModels = /* @__PURE__ */ new Set();
-	return {
-		name,
-		execute: { before(context) {
-			namespacedState(context, name).set({
-				tokens: 0,
-				costUSD: 0,
-				warned: false,
-				startedAt: Date.now(),
-				fallbackFired: false
-			});
-		} },
-		trip: { async after(context, response) {
-			const counters = namespacedState(context, name).get();
-			if (!counters) return;
-			counters.tokens += response.usage.total;
-			if (contractNeedsCost) {
-				const pricing = options.pricing?.[context.model.name];
-				if (pricing) {
-					const tripCost = response.usage.input / 1e3 * pricing.inputPer1K + response.usage.output / 1e3 * pricing.outputPer1K;
-					counters.costUSD += tripCost;
-				} else if (!warnedUnpricedModels.has(context.model.name)) {
-					warnedUnpricedModels.add(context.model.name);
-					console.warn(`ai.middleware.budget("${name}"): a USD cost cap is set but no pricing entry matches the running model "${context.model.name}" — the cap cannot be enforced for it. Add a pricing entry for "${context.model.name}" to options.pricing.`);
-				}
-			}
-			if (hasTokenCap && counters.tokens > options.maxTokens) {
-				if (onExceeded === "abort") breach(options.maxTokens, counters.tokens, "tokens", name);
-				if (!counters.warned) counters.warned = true;
-			}
-			if (hasCostCap && counters.costUSD > options.maxCostUSD) {
-				if (onExceeded === "abort") breach(options.maxCostUSD, counters.costUSD, "usd", name);
-				if (!counters.warned) counters.warned = true;
-			}
-			if (!contract) return;
-			if (hasContractTokenCap && counters.tokens > contract.maxTokens) await enforceContract(context, counters, name, contractMode, contract, "tokens", contract.maxTokens, counters.tokens);
-			if (hasContractCostCap && counters.costUSD > contract.maxCostUSD) await enforceContract(context, counters, name, contractMode, contract, "cost", contract.maxCostUSD, counters.costUSD);
-			if (hasContractLatencyCap) {
-				const elapsedMs = Date.now() - counters.startedAt;
-				if (elapsedMs > contract.maxLatencyMs) await enforceContract(context, counters, name, contractMode, contract, "latency", contract.maxLatencyMs, elapsedMs);
-			}
-		} }
-	};
-}
-/**
-* Apply the contract's reaction to a single breached clause. `"abort"`
-* throws `BudgetExceededError` (stops the run); `"fallback"` records the
-* signal once, fires the callback, and returns so the run continues.
-*
-* The callback is invoked at most once per run (guarded by
-* `counters.fallbackFired`) and its rejections are swallowed — a buggy
-* fallback hook must never crash the agent.
-*/
-async function enforceContract(context, counters, name, mode, contract, dimension, limit, actual) {
-	if (mode === "abort") breachContract(name, dimension, limit, actual);
-	if (counters.fallbackFired) return;
-	counters.fallbackFired = true;
-	const violation = {
-		dimension,
-		limit,
-		actual,
-		mode
-	};
-	namespacedState(context, `${name}.fallback`).set(violation);
-	if (!contract.fallback) return;
-	try {
-		await contract.fallback(violation, context);
-	} catch {}
-}
-
-//#endregion
-export { budget, readBudgetFallbackSignal };
-//# sourceMappingURL=budget.mjs.map

package/esm/ai/src/middleware/builtins/budget.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"budget.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/middleware/builtins/budget.ts"],"sourcesContent":["import type {\n  AgentMiddleware,\n  MiddlewareExecuteContext,\n} from \"../../contracts/middleware\";\nimport { BudgetExceededError, type BudgetUnit } from \"../../errors\";\nimport { namespacedState } from \"../utils\";\nimport type {\n  BudgetContract,\n  BudgetContractDimension,\n  BudgetContractViolation,\n} from \"./budget-contract.type\";\n\nexport type {\n  BudgetContract,\n  BudgetContractDimension,\n  BudgetContractFallback,\n  BudgetContractViolation,\n  BudgetContractViolationMode,\n} from \"./budget-contract.type\";\n\n/**\n * Per-model pricing used to compute USD cost from token counts.\n * Caller-supplied — no bundled table. Keys are model names (the\n * `ModelContract.name` value); values are input / output token\n * prices expressed as **USD per 1K tokens** to match every major\n * provider's published pricing sheet.\n */\nexport type BudgetPricing = Record<\n  string,\n  {\n    /** USD per 1,000 input tokens. */\n    inputPer1K: number;\n    /** USD per 1,000 output tokens. */\n    outputPer1K: number;\n  }\n>;\n\n/**\n * Configuration for `budget()`. At least one of `maxTokens` or\n * `maxCostUSD` must be supplied — a budget with no cap is a no-op.\n */\nexport type BudgetOptions = {\n  /**\n   * Hard cap on cumulative total tokens (input + output, summed\n   * across every trip of the run). Inclusive — exceeding triggers\n   * the configured `onExceeded`.\n   */\n  maxTokens?: number;\n  /**\n   * Hard cap on cumulative USD cost. Requires `pricing` for the\n   * agent's configured model — without a pricing entry the USD check\n   * silently skips (tokens-only enforcement still applies).\n   */\n  maxCostUSD?: number;\n  /**\n   * Per-model pricing table used to compute USD cost. Only consulted\n   * when `maxCostUSD` is set. Model names must match the running\n   * agent's `ModelContract.name` exactly.\n   */\n  pricing?: BudgetPricing;\n  /**\n   * Behavior when a cap is breached. `\"abort\"` throws\n   * `BudgetExceededError` — surfaces on `result.error`, stops the\n   * run at the next trip boundary. `\"warn\"` logs a warning and\n   * lets the run continue (useful for observability-first rollouts\n   * before flipping the switch to abort). Default `\"abort\"`.\n   */\n  onExceeded?: \"abort\" | \"warn\";\n  /**\n   * Override the middleware name. Useful when two budgets coexist\n   * (e.g. a per-request cap plus a session-wide cap via different\n   * instances). Default `\"budget\"`.\n   */\n  name?: string;\n  /**\n   * Declarative SLO / cost contract enforced on top of (and\n   * independently of) the legacy `maxTokens` / `maxCostUSD` caps.\n   * Adds a wall-clock `maxLatencyMs` dimension and a per-contract\n   * `onViolation` reaction (`\"abort\"` hard-stops, `\"fallback\"` records\n   * a signal + fires `fallback` and lets the run continue). Omit to\n   * keep the classic budget behavior unchanged.\n   *\n   * Read a recorded fallback signal back with\n   * {@link readBudgetFallbackSignal}.\n   */\n  contract?: BudgetContract;\n};\n\ntype BudgetCounters = {\n  tokens: number;\n  costUSD: number;\n  warned: boolean;\n  /**\n   * Wall-clock epoch ms captured at `execute.before`. Used to derive\n   * cumulative run latency for the contract's `maxLatencyMs` clause.\n   */\n  startedAt: number;\n  /**\n   * Set once a `\"fallback\"` contract clause has fired, so the signal +\n   * callback are emitted at most once per run even if later trips keep\n   * breaching.\n   */\n  fallbackFired: boolean;\n};\n\n/**\n * Recorded contract fallback signal, stashed under the `<name>.fallback`\n * state key when a `\"fallback\"` clause trips. A fallback orchestrator\n * reads it via {@link readBudgetFallbackSignal} to decide how to degrade.\n */\nexport type BudgetFallbackSignal = BudgetContractViolation;\n\n/**\n * The `BudgetUnit` to stamp on the thrown error per contract dimension.\n * Latency has no native unit — it borrows `\"requests\"` as the least-wrong\n * operational measure, while the authoritative detail rides on the\n * error's `context.dimension`.\n */\nconst DIMENSION_UNIT: Record<BudgetContractDimension, BudgetUnit> = {\n  tokens: \"tokens\",\n  cost: \"usd\",\n  latency: \"requests\",\n};\n\nfunction breach(\n  limit: number,\n  actual: number,\n  unit: BudgetUnit,\n  name: string,\n): never {\n  throw new BudgetExceededError(\n    `budget \"${name}\" exceeded — ${actual} ${unit} (cap: ${limit})`,\n    { limit, actual, unit },\n  );\n}\n\nfunction breachContract(\n  name: string,\n  dimension: BudgetContractDimension,\n  limit: number,\n  actual: number,\n): never {\n  throw new BudgetExceededError(\n    `budget \"${name}\" contract exceeded — ${dimension} ${actual} (cap: ${limit})`,\n    {\n      limit,\n      actual,\n      unit: DIMENSION_UNIT[dimension],\n      context: { dimension, limit, actual, source: \"contract\" },\n    },\n  );\n}\n\n/**\n * Read the contract fallback signal recorded by a `budget()` middleware\n * running under `contract.onViolation: \"fallback\"`. Returns `undefined`\n * when no clause was breached.\n *\n * **Role.** The middleware cannot itself switch models on a soft breach,\n * so it records a typed {@link BudgetFallbackSignal} in the shared state\n * bag and lets the run continue. A fallback orchestrator (or the\n * `execute.after` hook of an outer middleware) reads it back here and\n * decides how to degrade the next run — cheaper model, cached answer,\n * truncated context.\n *\n * @param state - The middleware state bag (`ctx.state`).\n * @param name - The budget middleware's name. Default `\"budget\"`,\n *   matching `BudgetOptions.name`'s default.\n *\n * @example\n * const guard = budget({ contract: { maxCostUSD: 0.05, onViolation: \"fallback\" } });\n *\n * // In an outer middleware's execute.after, after the run:\n * const signal = readBudgetFallbackSignal(ctx.state);\n * if (signal?.dimension === \"cost\") {\n *   await rerunOnCheaperModel();\n * }\n */\nexport function readBudgetFallbackSignal(\n  state: MiddlewareExecuteContext[\"state\"],\n  name = \"budget\",\n): BudgetFallbackSignal | undefined {\n  return namespacedState<BudgetFallbackSignal>(\n    { state },\n    `${name}.fallback`,\n  ).get();\n}\n\n/**\n * Enforced token and / or USD budget for an agent run.\n *\n * **Role.** Guards against runaway tool loops, misconfigured\n * prompts, and unexpected provider price swings by capping\n * cumulative usage across every LLM trip of a single execution.\n * Aborts the run with a typed `BudgetExceededError` the moment a cap\n * is breached, rather than letting the damage grow trip by trip.\n *\n * **Scope.** Per-execution. A fresh counter is created at\n * `execute.before` and lives in the middleware state bag until the\n * run ends. Two concurrent `agent.execute()` calls on the same\n * agent therefore enforce the cap independently.\n *\n * **Token accounting.** After each successful trip, the middleware\n * adds `response.usage.total` to its running total and checks\n * against `maxTokens`. Synthetic trips (cache hits) contribute\n * `usage.total` as returned by the cache — cache middleware is\n * expected to surface zero usage on a hit, which naturally excludes\n * those trips from the budget.\n *\n * **USD accounting.** When `maxCostUSD` + `pricing[modelName]` are\n * both present, the middleware converts per-trip input / output\n * tokens to USD and accumulates. Missing pricing silently degrades\n * to tokens-only — explicit rather than guessing.\n *\n * **Warn mode.** `onExceeded: \"warn\"` logs a single warning the first\n * time a cap is breached and lets the run continue. Useful for\n * measuring real-world traffic against a proposed cap before flipping\n * to `\"abort\"` in production.\n *\n * **Contract / SLO mode.** Pass `contract` to enforce a declarative\n * service-level objective — `maxCostUSD`, `maxLatencyMs`, `maxTokens` —\n * on top of the legacy caps, with a single `onViolation` reaction:\n * `\"abort\"` hard-stops with `BudgetExceededError`; `\"fallback\"` records\n * a typed signal (read it via {@link readBudgetFallbackSignal}), fires\n * the optional `fallback` callback, and lets the run continue so an\n * outer layer can degrade gracefully. The contract's clauses are\n * evaluated independently of — and after — the top-level caps; the\n * top-level caps stay fully functional with or without a contract.\n *\n * @example\n * const budgetMiddleware = budget({ maxTokens: 50_000 });\n *\n * const myAgent = agent({\n *   model,\n *   middleware: [budgetMiddleware],\n * });\n *\n * @example\n * // With USD cap and custom pricing\n * const guard = budget({\n *   maxCostUSD: 0.5,\n *   pricing: {\n *     \"gpt-4o\": { inputPer1K: 0.005, outputPer1K: 0.015 },\n *   },\n * });\n *\n * @example\n * // SLO contract — soft-fallback on any breach\n * const sloGuard = budget({\n *   pricing: { \"gpt-4o\": { inputPer1K: 0.005, outputPer1K: 0.015 } },\n *   contract: {\n *     maxCostUSD: 0.05,\n *     maxLatencyMs: 8_000,\n *     maxTokens: 40_000,\n *     onViolation: \"fallback\",\n *     fallback: (violation) => routeToCheaperModel(violation.dimension),\n *   },\n * });\n */\nexport function budget(options: BudgetOptions): AgentMiddleware {\n  const name = options.name ?? \"budget\";\n  const onExceeded = options.onExceeded ?? \"abort\";\n  const hasTokenCap = typeof options.maxTokens === \"number\";\n  const hasCostCap = typeof options.maxCostUSD === \"number\";\n\n  const contract = options.contract;\n  const contractMode = contract?.onViolation ?? \"abort\";\n  const hasContractTokenCap = typeof contract?.maxTokens === \"number\";\n  const hasContractCostCap = typeof contract?.maxCostUSD === \"number\";\n  const hasContractLatencyCap = typeof contract?.maxLatencyMs === \"number\";\n  const contractNeedsCost = hasCostCap || hasContractCostCap;\n  // Warn once per model when a cost cap is configured but the running model\n  // has no pricing entry — without this the USD cap silently never enforces\n  // (costUSD stays 0), a fail-open the JSDoc on `maxCostUSD` documents.\n  const warnedUnpricedModels = new Set<string>();\n\n  return {\n    name,\n    execute: {\n      before(context) {\n        const counters = namespacedState<BudgetCounters>(context, name);\n        counters.set({\n          tokens: 0,\n          costUSD: 0,\n          warned: false,\n          startedAt: Date.now(),\n          fallbackFired: false,\n        });\n      },\n    },\n    trip: {\n      async after(context, response) {\n        const counters = namespacedState<BudgetCounters>(context, name).get();\n\n        if (!counters) {\n          return;\n        }\n\n        counters.tokens += response.usage.total;\n\n        if (contractNeedsCost) {\n          const pricing = options.pricing?.[context.model.name];\n\n          if (pricing) {\n            const tripCost =\n              (response.usage.input / 1000) * pricing.inputPer1K +\n              (response.usage.output / 1000) * pricing.outputPer1K;\n            counters.costUSD += tripCost;\n          } else if (!warnedUnpricedModels.has(context.model.name)) {\n            // A cost cap is set but no pricing matched the running model, so\n            // costUSD can never grow and the USD cap silently never fires.\n            // Surface the fail-open once per model instead of swallowing it.\n            warnedUnpricedModels.add(context.model.name);\n            console.warn(\n              `ai.middleware.budget(\"${name}\"): a USD cost cap is set but no pricing entry ` +\n                `matches the running model \"${context.model.name}\" — the cap cannot be enforced ` +\n                `for it. Add a pricing entry for \"${context.model.name}\" to options.pricing.`,\n            );\n          }\n        }\n\n        if (hasTokenCap && counters.tokens > options.maxTokens!) {\n          if (onExceeded === \"abort\") {\n            breach(options.maxTokens!, counters.tokens, \"tokens\", name);\n          }\n\n          if (!counters.warned) {\n            counters.warned = true;\n          }\n        }\n\n        if (hasCostCap && counters.costUSD > options.maxCostUSD!) {\n          if (onExceeded === \"abort\") {\n            breach(options.maxCostUSD!, counters.costUSD, \"usd\", name);\n          }\n\n          if (!counters.warned) {\n            counters.warned = true;\n          }\n        }\n\n        if (!contract) {\n          return;\n        }\n\n        if (hasContractTokenCap && counters.tokens > contract.maxTokens!) {\n          await enforceContract(\n            context,\n            counters,\n            name,\n            contractMode,\n            contract,\n            \"tokens\",\n            contract.maxTokens!,\n            counters.tokens,\n          );\n        }\n\n        if (hasContractCostCap && counters.costUSD > contract.maxCostUSD!) {\n          await enforceContract(\n            context,\n            counters,\n            name,\n            contractMode,\n            contract,\n            \"cost\",\n            contract.maxCostUSD!,\n            counters.costUSD,\n          );\n        }\n\n        if (hasContractLatencyCap) {\n          const elapsedMs = Date.now() - counters.startedAt;\n\n          if (elapsedMs > contract.maxLatencyMs!) {\n            await enforceContract(\n              context,\n              counters,\n              name,\n              contractMode,\n              contract,\n              \"latency\",\n              contract.maxLatencyMs!,\n              elapsedMs,\n            );\n          }\n        }\n      },\n    },\n  };\n}\n\n/**\n * Apply the contract's reaction to a single breached clause. `\"abort\"`\n * throws `BudgetExceededError` (stops the run); `\"fallback\"` records the\n * signal once, fires the callback, and returns so the run continues.\n *\n * The callback is invoked at most once per run (guarded by\n * `counters.fallbackFired`) and its rejections are swallowed — a buggy\n * fallback hook must never crash the agent.\n */\nasync function enforceContract(\n  context: MiddlewareExecuteContext,\n  counters: BudgetCounters,\n  name: string,\n  mode: NonNullable<BudgetContract[\"onViolation\"]>,\n  contract: BudgetContract,\n  dimension: BudgetContractDimension,\n  limit: number,\n  actual: number,\n): Promise<void> {\n  if (mode === \"abort\") {\n    breachContract(name, dimension, limit, actual);\n  }\n\n  if (counters.fallbackFired) {\n    return;\n  }\n\n  counters.fallbackFired = true;\n\n  const violation: BudgetContractViolation = {\n    dimension,\n    limit,\n    actual,\n    mode,\n  };\n\n  namespacedState<BudgetContractViolation>(context, `${name}.fallback`).set(\n    violation,\n  );\n\n  if (!contract.fallback) {\n    return;\n  }\n\n  try {\n    await contract.fallback(violation, context);\n  } catch {\n    // A fallback callback is a notification hook — its failure must\n    // never crash the run. Swallow deliberately.\n  }\n}\n"],"mappings":"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"}

package/esm/ai/src/middleware/builtins/guardrail.mjs

@@ -1,76 +0,0 @@
-import { GuardrailViolationError } from "../../errors/guardrail-violation-error.mjs";
-import "../../errors/index.mjs";
-import { extractUserText } from "../utils/extract-user-text.mjs";
-
-//#region ../@warlock.js/ai/src/middleware/builtins/guardrail.ts
-/**
-* Pre/post content guardrail for an agent run.
-*
-* **Role.** Inspects outbound prompts and inbound responses against
-* caller-supplied policies, aborting the trip with a typed
-* `GuardrailViolationError` when either trips a check. Consumers
-* distinguish `"input"` vs `"output"` violations off `error.phase`
-* — the two failure modes have very different product responses
-* (block the user vs re-prompt the model).
-*
-* **Scope.** Per-trip. Fires on every round-trip the agent makes,
-* including repair attempts and tool-follow-up trips. Input checks
-* evaluate the last user-role message; output checks evaluate the
-* raw model response text before any tool call is dispatched.
-*
-* **Composition.** A single middleware instance can carry both
-* `inputCheck` and `outputCheck`, or two separate instances can be
-* registered (useful when input and output policies come from
-* different teams / services). Registration order determines which
-* guardrail's violation surfaces first — the short-circuit throws
-* from the innermost offending hook, and outer guardrails never run
-* after an abort.
-*
-* **Not a sanitizer.** The guardrail either passes a trip unchanged
-* or aborts it. Mutating the prompt / response in-place is out of
-* scope — use a bespoke middleware for content rewriting.
-*
-* @example
-* const policy = guardrail({
-*   inputCheck: async (text) =>
-*     text.includes("SSN") ? { ok: false, reason: "pii" } : { ok: true },
-*   outputCheck: async (text) =>
-*     text.length > 10_000 ? { ok: false, reason: "too-long" } : { ok: true },
-* });
-*
-* const myAgent = agent({ model, middleware: [policy] });
-*/
-function guardrail(options) {
-	const name = options.name ?? "guardrail";
-	const { inputCheck, outputCheck } = options;
-	return {
-		name,
-		trip: {
-			async before(context) {
-				if (!inputCheck) return;
-				const prompt = extractUserText(context.messages);
-				if (!prompt) return;
-				const verdict = await inputCheck(prompt, context);
-				if (!verdict.ok) throw new GuardrailViolationError(`guardrail "${name}" rejected input — ${verdict.reason}`, {
-					phase: "input",
-					reason: verdict.reason,
-					guardrail: name
-				});
-			},
-			async after(context, response) {
-				if (!outputCheck) return;
-				if (!response.content) return;
-				const verdict = await outputCheck(response.content, context);
-				if (!verdict.ok) throw new GuardrailViolationError(`guardrail "${name}" rejected output — ${verdict.reason}`, {
-					phase: "output",
-					reason: verdict.reason,
-					guardrail: name
-				});
-			}
-		}
-	};
-}
-
-//#endregion
-export { guardrail };
-//# sourceMappingURL=guardrail.mjs.map

package/esm/ai/src/middleware/builtins/guardrail.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"guardrail.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/middleware/builtins/guardrail.ts"],"sourcesContent":["import type {\n  AgentMiddleware,\n  MiddlewareTripContext,\n} from \"../../contracts/middleware\";\nimport type { ModelResponse } from \"../../contracts/model.contract\";\nimport { GuardrailViolationError } from \"../../errors\";\nimport { extractUserText } from \"../utils\";\n\n/**\n * Decision returned by a guardrail check function. `ok: true`\n * permits the call; `ok: false` rejects with a human-readable\n * `reason` surfaced on `GuardrailViolationError`.\n */\nexport type GuardrailCheckResult = { ok: true } | { ok: false; reason: string };\n\n/**\n * Synchronous or asynchronous check invoked against the outbound\n * prompt (`inputCheck`) or the inbound response (`outputCheck`).\n * Receives the raw text and the surrounding trip context so\n * consumers can classify, route to an external moderation API, or\n * branch on tripIndex / messages history.\n */\nexport type GuardrailCheck = (\n  text: string,\n  context: MiddlewareTripContext,\n) => GuardrailCheckResult | Promise<GuardrailCheckResult>;\n\n/**\n * Configuration for `guardrail()`.  At least one of `inputCheck` or\n * `outputCheck` must be supplied — a guardrail with no checks is a\n * no-op.\n */\nexport type GuardrailOptions = {\n  /**\n   * Run against the outbound prompt just before the model sees it.\n   * Fires every trip with the concatenated last user-message text.\n   * Rejection aborts the trip with a `GuardrailViolationError` whose\n   * `phase === \"input\"`.\n   */\n  inputCheck?: GuardrailCheck;\n  /**\n   * Run against the model's response text after the trip completes.\n   * Fires every trip with `response.content`. Rejection aborts with\n   * a `GuardrailViolationError` whose `phase === \"output\"`.\n   *\n   * Output checks run BEFORE any tool dispatch — a rejected response\n   * means the tool calls it requested are never invoked.\n   */\n  outputCheck?: GuardrailCheck;\n  /**\n   * Override the middleware name — surfaces on\n   * `GuardrailViolationError.guardrail` so operators can tell two\n   * guardrails apart in logs. Default `\"guardrail\"`.\n   */\n  name?: string;\n};\n\n/**\n * Pre/post content guardrail for an agent run.\n *\n * **Role.** Inspects outbound prompts and inbound responses against\n * caller-supplied policies, aborting the trip with a typed\n * `GuardrailViolationError` when either trips a check. Consumers\n * distinguish `\"input\"` vs `\"output\"` violations off `error.phase`\n * — the two failure modes have very different product responses\n * (block the user vs re-prompt the model).\n *\n * **Scope.** Per-trip. Fires on every round-trip the agent makes,\n * including repair attempts and tool-follow-up trips. Input checks\n * evaluate the last user-role message; output checks evaluate the\n * raw model response text before any tool call is dispatched.\n *\n * **Composition.** A single middleware instance can carry both\n * `inputCheck` and `outputCheck`, or two separate instances can be\n * registered (useful when input and output policies come from\n * different teams / services). Registration order determines which\n * guardrail's violation surfaces first — the short-circuit throws\n * from the innermost offending hook, and outer guardrails never run\n * after an abort.\n *\n * **Not a sanitizer.** The guardrail either passes a trip unchanged\n * or aborts it. Mutating the prompt / response in-place is out of\n * scope — use a bespoke middleware for content rewriting.\n *\n * @example\n * const policy = guardrail({\n *   inputCheck: async (text) =>\n *     text.includes(\"SSN\") ? { ok: false, reason: \"pii\" } : { ok: true },\n *   outputCheck: async (text) =>\n *     text.length > 10_000 ? { ok: false, reason: \"too-long\" } : { ok: true },\n * });\n *\n * const myAgent = agent({ model, middleware: [policy] });\n */\nexport function guardrail(options: GuardrailOptions): AgentMiddleware {\n  const name = options.name ?? \"guardrail\";\n  const { inputCheck, outputCheck } = options;\n\n  return {\n    name,\n    trip: {\n      async before(context) {\n        if (!inputCheck) {\n          return;\n        }\n\n        const prompt = extractUserText(context.messages);\n\n        if (!prompt) {\n          return;\n        }\n\n        const verdict = await inputCheck(prompt, context);\n\n        if (!verdict.ok) {\n          throw new GuardrailViolationError(\n            `guardrail \"${name}\" rejected input — ${verdict.reason}`,\n            { phase: \"input\", reason: verdict.reason, guardrail: name },\n          );\n        }\n      },\n      async after(context, response: ModelResponse) {\n        if (!outputCheck) {\n          return;\n        }\n\n        if (!response.content) {\n          return;\n        }\n\n        const verdict = await outputCheck(response.content, context);\n\n        if (!verdict.ok) {\n          throw new GuardrailViolationError(\n            `guardrail \"${name}\" rejected output — ${verdict.reason}`,\n            { phase: \"output\", reason: verdict.reason, guardrail: name },\n          );\n        }\n      },\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8FA,SAAgB,UAAU,SAA4C;CACpE,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,EAAE,YAAY,gBAAgB;CAEpC,OAAO;EACL;EACA,MAAM;GACJ,MAAM,OAAO,SAAS;IACpB,IAAI,CAAC,YACH;IAGF,MAAM,SAAS,gBAAgB,QAAQ,QAAQ;IAE/C,IAAI,CAAC,QACH;IAGF,MAAM,UAAU,MAAM,WAAW,QAAQ,OAAO;IAEhD,IAAI,CAAC,QAAQ,IACX,MAAM,IAAI,wBACR,cAAc,KAAK,qBAAqB,QAAQ,UAChD;KAAE,OAAO;KAAS,QAAQ,QAAQ;KAAQ,WAAW;IAAK,CAC5D;GAEJ;GACA,MAAM,MAAM,SAAS,UAAyB;IAC5C,IAAI,CAAC,aACH;IAGF,IAAI,CAAC,SAAS,SACZ;IAGF,MAAM,UAAU,MAAM,YAAY,SAAS,SAAS,OAAO;IAE3D,IAAI,CAAC,QAAQ,IACX,MAAM,IAAI,wBACR,cAAc,KAAK,sBAAsB,QAAQ,UACjD;KAAE,OAAO;KAAU,QAAQ,QAAQ;KAAQ,WAAW;IAAK,CAC7D;GAEJ;EACF;CACF;AACF"}