@warlock.js/core 4.8.0 → 4.8.1

package/esm/ai/src/middleware/builtins/semantic-cache.mjs

@@ -1,149 +0,0 @@
-import { extractUserText } from "../utils/extract-user-text.mjs";
-import { resolveDefaultStore } from "../../config.mjs";
-
-//#region ../@warlock.js/ai/src/middleware/builtins/semantic-cache.ts
-const DEFAULT_NAMESPACE = "ai.cache";
-/**
-* Build a stable fingerprint for a prompt covering the full message
-* list (system + history + user turn). Ensures two prompts sharing
-* the user text but differing in prior context do not collide on
-* the exact-match fast path.
-*
-* FNV-1a variant — cheap, collision-resistant enough for a cache,
-* dependency-free. NOT a cryptographic hash: collisions would
-* surface as wrong cache hits, not a security issue in the current
-* trust model.
-*/
-function hashPrompt(messages) {
-	const serialized = messages.map((message) => {
-		return `${message.role}:${Array.isArray(message.content) ? message.content.filter((part) => part.type === "text").map((part) => part.text).join("|") : message.content}`;
-	}).join("||");
-	let hash = 2166136261;
-	for (let index = 0; index < serialized.length; index++) {
-		hash ^= serialized.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
-	}
-	return (hash >>> 0).toString(16);
-}
-function isFresh(entry, ttlMs) {
-	if (ttlMs === void 0) return true;
-	return Date.now() - entry.storedAt <= ttlMs;
-}
-/**
-* Semantic-similarity response cache for an agent run.
-*
-* **Role.** Skips LLM round-trips when the current prompt is
-* semantically close to one the agent has already answered. For
-* FAQ / support-style traffic this often eliminates 60–80% of
-* model calls — the production win is massive for cost and
-* latency.
-*
-* **Delegation to `@warlock.js/cache`.** This middleware does NOT
-* implement similarity search itself. It delegates to the supplied
-* `CacheDriver`. Production deployments pick a driver with an ANN
-* index (`pg` + pgvector, `redis` + RediSearch). Dev / test
-* environments pass `new MemoryCacheDriver()` — zero config, correct,
-* but O(N) per query. Drivers without similarity support throw
-* `CacheUnsupportedError` from `set({ vector })` / `similar()`.
-*
-* **Two-tier lookup.**
-* 1. *Exact-match key* — a cheap FNV hash over the entire message
-*    list. `store.get(hash)` returns the entry without an embedding
-*    round trip when the prompt hasn't changed at all.
-* 2. *Vector-match* — on exact-match miss, embed the prompt and
-*    call `store.similar(vector, { topK: 1, threshold })`. The
-*    driver uses its native similarity index; anything clearing
-*    `threshold` is returned as a hit.
-*
-* **Write-on-miss.** When both tiers miss, `trip.before` stashes
-* the prompt hash + vector in `ctx.state`; `trip.after` reads back
-* the pending entry and calls
-* `store.set(hash, entry, { vector })`. If an outer middleware
-* (guardrail) throws in `trip.after` before the cache's `trip.after`
-* runs, the pending entry is never written — bad responses stay out
-* of the cache **as long as the canonical install order is followed**
-* (cache outermost).
-*
-* **Synthetic-response on hit.** Returns a `ModelResponse` with
-* `usage: { input: 0, output: 0, total: 0 }` so budget /
-* observability correctly exclude the saved trip.
-*
-* @example
-* import { semanticCache } from "@warlock.js/ai";
-* import { MemoryCacheDriver } from "@warlock.js/cache";
-*
-* const store = new MemoryCacheDriver();
-* store.setOptions({});
-*
-* const cache = semanticCache({
-*   embedder: openai.embedder({ name: "text-embedding-3-small" }),
-*   store,
-*   threshold: 0.95,
-*   ttlMs: 60 * 60 * 1000,
-* });
-*
-* const myAgent = agent({ model, middleware: [cache] });
-*/
-function semanticCache(options) {
-	const name = options.name ?? "semantic-cache";
-	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
-	const pendingKey = `${name}.pending`;
-	const store = options.store ?? resolveDefaultStore();
-	if (!store) throw new Error(`semanticCache: no store supplied — pass \`store\` in options or call \`ai.config({ defaultStore })\` at app boot before constructing the middleware`);
-	const keyFor = (hash) => `${namespace}.${hash}`;
-	return {
-		name,
-		log: true,
-		trip: {
-			async before(context) {
-				if (context.tripIndex !== 0) return;
-				const promptText = extractUserText(context.messages);
-				if (!promptText) return;
-				const promptKey = hashPrompt(context.messages);
-				const scopedKey = keyFor(promptKey);
-				const exact = await store.get(scopedKey);
-				if (exact && isFresh(exact, options.ttlMs)) return toSyntheticResponse(exact.response);
-				const query = await options.embedder.embed(promptText);
-				const [hit] = await store.similar(query.vector, {
-					topK: 1,
-					threshold: options.threshold
-				});
-				if (hit && isFresh(hit.value, options.ttlMs)) {
-					if (hit.key.startsWith(`${namespace}.`)) return toSyntheticResponse(hit.value.response);
-				}
-				const pending = {
-					promptKey,
-					vector: query.vector
-				};
-				context.state.set(pendingKey, pending);
-			},
-			async after(context, response) {
-				const pending = context.state.get(pendingKey);
-				if (!pending) return;
-				if (response.finishReason === "tool_calls") return;
-				context.state.delete(pendingKey);
-				const entry = {
-					response,
-					storedAt: Date.now()
-				};
-				await store.set(keyFor(pending.promptKey), entry, { vector: pending.vector });
-			}
-		}
-	};
-}
-function toSyntheticResponse(response) {
-	return {
-		content: response.content,
-		finishReason: response.finishReason,
-		usage: {
-			input: 0,
-			output: 0,
-			total: 0
-		},
-		toolCalls: response.toolCalls
-	};
-}
-
-//#endregion
-export { semanticCache };
-//# sourceMappingURL=semantic-cache.mjs.map

package/esm/ai/src/middleware/builtins/semantic-cache.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"semantic-cache.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/middleware/builtins/semantic-cache.ts"],"sourcesContent":["import type { CacheDriver } from \"@warlock.js/cache\";\nimport { resolveDefaultStore } from \"../../config\";\nimport type { Message } from \"../../contracts/conversation-message.type\";\nimport type { EmbedderContract } from \"../../contracts/embedder.contract\";\nimport type { AgentMiddleware } from \"../../contracts/middleware\";\nimport type { ModelResponse } from \"../../contracts/model.contract\";\nimport { extractUserText } from \"../utils\";\n\n/**\n * Configuration for `semanticCache()`.\n */\nexport type SemanticCacheOptions = {\n  /** Embedder used to produce the query vector from the prompt text. */\n  embedder: EmbedderContract;\n  /**\n   * Vector-capable cache driver from `@warlock.js/cache`. Production\n   * deployments pick a driver with a real ANN index (`pg` with\n   * pgvector, `redis` with RediSearch). Dev / test environments use\n   * `new MemoryCacheDriver()` — zero config, correct, but O(N) per\n   * query. Drivers without similarity support throw\n   * `CacheUnsupportedError` from `set({ vector })` / `similar()`.\n   *\n   * Falls back to `ai.config({ defaultStore })` when omitted. When\n   * neither is set, the factory throws at construction time —\n   * semantic cache cannot operate without a store.\n   */\n  store?: CacheDriver<any, any>;\n  /**\n   * Minimum cosine similarity for a vector hit. Between 0 and 1 —\n   * 0.95 is a solid default for question-answering caches.\n   */\n  threshold: number;\n  /**\n   * Optional TTL in milliseconds. Entries whose `storedAt` is older\n   * than this are treated as misses on read and overwritten on the\n   * next write. Default: no expiry — entries live until the store\n   * evicts them (per its own TTL/eviction policy).\n   */\n  ttlMs?: number;\n  /**\n   * Namespace prefix applied to every key the cache writes. Lets\n   * multiple agents share one driver without collision. Default\n   * `\"ai.cache\"`.\n   */\n  namespace?: string;\n  /**\n   * Middleware name — also the state-bag key prefix inside a single\n   * execution. Default `\"semantic-cache\"`.\n   */\n  name?: string;\n};\n\ntype CachedEntry = {\n  response: ModelResponse;\n  storedAt: number;\n};\n\ntype PendingWrite = {\n  promptKey: string;\n  vector: number[];\n};\n\nconst DEFAULT_NAMESPACE = \"ai.cache\";\n\n/**\n * Build a stable fingerprint for a prompt covering the full message\n * list (system + history + user turn). Ensures two prompts sharing\n * the user text but differing in prior context do not collide on\n * the exact-match fast path.\n *\n * FNV-1a variant — cheap, collision-resistant enough for a cache,\n * dependency-free. NOT a cryptographic hash: collisions would\n * surface as wrong cache hits, not a security issue in the current\n * trust model.\n */\nfunction hashPrompt(messages: ReadonlyArray<Message>): string {\n  const serialized = messages\n    .map((message) => {\n      const role = message.role;\n      const content = Array.isArray(message.content)\n        ? message.content\n            .filter((part) => part.type === \"text\")\n            .map((part) => (part as { text: string }).text)\n            .join(\"|\")\n        : message.content;\n\n      return `${role}:${content}`;\n    })\n    .join(\"||\");\n\n  let hash = 0x811c9dc5;\n\n  for (let index = 0; index < serialized.length; index++) {\n    hash ^= serialized.charCodeAt(index);\n    hash = Math.imul(hash, 0x01000193);\n  }\n\n  return (hash >>> 0).toString(16);\n}\n\nfunction isFresh(entry: CachedEntry, ttlMs: number | undefined): boolean {\n  if (ttlMs === undefined) {\n    return true;\n  }\n\n  return Date.now() - entry.storedAt <= ttlMs;\n}\n\n/**\n * Semantic-similarity response cache for an agent run.\n *\n * **Role.** Skips LLM round-trips when the current prompt is\n * semantically close to one the agent has already answered. For\n * FAQ / support-style traffic this often eliminates 60–80% of\n * model calls — the production win is massive for cost and\n * latency.\n *\n * **Delegation to `@warlock.js/cache`.** This middleware does NOT\n * implement similarity search itself. It delegates to the supplied\n * `CacheDriver`. Production deployments pick a driver with an ANN\n * index (`pg` + pgvector, `redis` + RediSearch). Dev / test\n * environments pass `new MemoryCacheDriver()` — zero config, correct,\n * but O(N) per query. Drivers without similarity support throw\n * `CacheUnsupportedError` from `set({ vector })` / `similar()`.\n *\n * **Two-tier lookup.**\n * 1. *Exact-match key* — a cheap FNV hash over the entire message\n *    list. `store.get(hash)` returns the entry without an embedding\n *    round trip when the prompt hasn't changed at all.\n * 2. *Vector-match* — on exact-match miss, embed the prompt and\n *    call `store.similar(vector, { topK: 1, threshold })`. The\n *    driver uses its native similarity index; anything clearing\n *    `threshold` is returned as a hit.\n *\n * **Write-on-miss.** When both tiers miss, `trip.before` stashes\n * the prompt hash + vector in `ctx.state`; `trip.after` reads back\n * the pending entry and calls\n * `store.set(hash, entry, { vector })`. If an outer middleware\n * (guardrail) throws in `trip.after` before the cache's `trip.after`\n * runs, the pending entry is never written — bad responses stay out\n * of the cache **as long as the canonical install order is followed**\n * (cache outermost).\n *\n * **Synthetic-response on hit.** Returns a `ModelResponse` with\n * `usage: { input: 0, output: 0, total: 0 }` so budget /\n * observability correctly exclude the saved trip.\n *\n * @example\n * import { semanticCache } from \"@warlock.js/ai\";\n * import { MemoryCacheDriver } from \"@warlock.js/cache\";\n *\n * const store = new MemoryCacheDriver();\n * store.setOptions({});\n *\n * const cache = semanticCache({\n *   embedder: openai.embedder({ name: \"text-embedding-3-small\" }),\n *   store,\n *   threshold: 0.95,\n *   ttlMs: 60 * 60 * 1000,\n * });\n *\n * const myAgent = agent({ model, middleware: [cache] });\n */\nexport function semanticCache(options: SemanticCacheOptions): AgentMiddleware {\n  const name = options.name ?? \"semantic-cache\";\n  const namespace = options.namespace ?? DEFAULT_NAMESPACE;\n  const pendingKey = `${name}.pending`;\n\n  // Resolve the effective store at factory time, not per-call. Every\n  // subsequent hook closes over `store` so the resolution happens once.\n  // Throws now (loud, at construction) instead of later during the\n  // first trip (silent until the agent actually runs).\n  const store = options.store ?? resolveDefaultStore();\n\n  if (!store) {\n    throw new Error(\n      `semanticCache: no store supplied — pass \\`store\\` in options or call \\`ai.config({ defaultStore })\\` at app boot before constructing the middleware`,\n    );\n  }\n\n  // Cache's parseKey replaces \":\" with \".\" so the namespace boundary\n  // matches what `similar()` actually returns in `hit.key`. Using a\n  // dot here keeps prefix checks aligned with stored keys.\n  const keyFor = (hash: string): string => `${namespace}.${hash}`;\n\n  return {\n    name,\n    log: true,\n    trip: {\n      async before(context) {\n        // Only cache the first trip's response. Subsequent trips\n        // happen because the previous trip requested tool calls — the\n        // message list now carries tool results the original prompt\n        // never saw, so a semantic match on the unchanged user text\n        // would serve back the prior `tool_calls` response and loop\n        // the agent forever. The first turn is also the only one\n        // where a \"same question → same final answer\" caching story\n        // is sound.\n        if (context.tripIndex !== 0) {\n          return;\n        }\n\n        const promptText = extractUserText(context.messages);\n\n        if (!promptText) {\n          return;\n        }\n\n        const promptKey = hashPrompt(context.messages);\n        const scopedKey = keyFor(promptKey);\n\n        const exact = await store.get<CachedEntry>(scopedKey);\n\n        if (exact && isFresh(exact, options.ttlMs)) {\n          return toSyntheticResponse(exact.response);\n        }\n\n        const query = await options.embedder.embed(promptText);\n\n        const [hit] = await store.similar<CachedEntry>(query.vector, {\n          topK: 1,\n          threshold: options.threshold,\n        });\n\n        if (hit && isFresh(hit.value, options.ttlMs)) {\n          // Only return hits whose stored key is within this cache's\n          // namespace. Drivers shared across namespaces would otherwise\n          // leak foreign entries into queries.\n          if (hit.key.startsWith(`${namespace}.`)) {\n            return toSyntheticResponse(hit.value.response);\n          }\n        }\n\n        const pending: PendingWrite = { promptKey, vector: query.vector };\n        context.state.set(pendingKey, pending);\n\n        return;\n      },\n      async after(context, response) {\n        const pending = context.state.get(pendingKey) as PendingWrite | undefined;\n\n        if (!pending) {\n          return;\n        }\n\n        // Mid-stream tool-call responses must not be cached — the\n        // useful answer comes from the trip *after* the tool returns.\n        // Crucially, leave the pending entry in place so a later trip\n        // (the one that actually finishes with `stop`) can read it\n        // and write the final response under the *original* trip-0\n        // prompt key. Deleting here would orphan the pending and the\n        // post-tool answer would never make it into the store.\n        if (response.finishReason === \"tool_calls\") {\n          return;\n        }\n\n        context.state.delete(pendingKey);\n\n        const entry: CachedEntry = { response, storedAt: Date.now() };\n\n        await store.set(keyFor(pending.promptKey), entry, {\n          vector: pending.vector,\n        });\n\n        return;\n      },\n    },\n  };\n}\n\nfunction toSyntheticResponse(response: ModelResponse): ModelResponse {\n  return {\n    content: response.content,\n    finishReason: response.finishReason,\n    usage: { input: 0, output: 0, total: 0 },\n    toolCalls: response.toolCalls,\n  };\n}\n"],"mappings":";;;;AA8DA,MAAM,oBAAoB;;;;;;;;;;;;AAa1B,SAAS,WAAW,UAA0C;CAC5D,MAAM,aAAa,SAChB,KAAK,YAAY;EAShB,OAAO,GARM,QAAQ,KAQN,GAPC,MAAM,QAAQ,QAAQ,OAAO,IACzC,QAAQ,QACL,QAAQ,SAAS,KAAK,SAAS,MAAM,CAAC,CACtC,KAAK,SAAU,KAA0B,IAAI,CAAC,CAC9C,KAAK,GAAG,IACX,QAAQ;CAGd,CAAC,CAAC,CACD,KAAK,IAAI;CAEZ,IAAI,OAAO;CAEX,KAAK,IAAI,QAAQ,GAAG,QAAQ,WAAW,QAAQ,SAAS;EACtD,QAAQ,WAAW,WAAW,KAAK;EACnC,OAAO,KAAK,KAAK,MAAM,QAAU;CACnC;CAEA,QAAQ,SAAS,EAAC,CAAE,SAAS,EAAE;AACjC;AAEA,SAAS,QAAQ,OAAoB,OAAoC;CACvE,IAAI,UAAU,QACZ,OAAO;CAGT,OAAO,KAAK,IAAI,IAAI,MAAM,YAAY;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,SAAgB,cAAc,SAAgD;CAC5E,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,YAAY,QAAQ,aAAa;CACvC,MAAM,aAAa,GAAG,KAAK;CAM3B,MAAM,QAAQ,QAAQ,SAAS,oBAAoB;CAEnD,IAAI,CAAC,OACH,MAAM,IAAI,MACR,qJACF;CAMF,MAAM,UAAU,SAAyB,GAAG,UAAU,GAAG;CAEzD,OAAO;EACL;EACA,KAAK;EACL,MAAM;GACJ,MAAM,OAAO,SAAS;IASpB,IAAI,QAAQ,cAAc,GACxB;IAGF,MAAM,aAAa,gBAAgB,QAAQ,QAAQ;IAEnD,IAAI,CAAC,YACH;IAGF,MAAM,YAAY,WAAW,QAAQ,QAAQ;IAC7C,MAAM,YAAY,OAAO,SAAS;IAElC,MAAM,QAAQ,MAAM,MAAM,IAAiB,SAAS;IAEpD,IAAI,SAAS,QAAQ,OAAO,QAAQ,KAAK,GACvC,OAAO,oBAAoB,MAAM,QAAQ;IAG3C,MAAM,QAAQ,MAAM,QAAQ,SAAS,MAAM,UAAU;IAErD,MAAM,CAAC,OAAO,MAAM,MAAM,QAAqB,MAAM,QAAQ;KAC3D,MAAM;KACN,WAAW,QAAQ;IACrB,CAAC;IAED,IAAI,OAAO,QAAQ,IAAI,OAAO,QAAQ,KAAK,GAIzC;SAAI,IAAI,IAAI,WAAW,GAAG,UAAU,EAAE,GACpC,OAAO,oBAAoB,IAAI,MAAM,QAAQ;IAC/C;IAGF,MAAM,UAAwB;KAAE;KAAW,QAAQ,MAAM;IAAO;IAChE,QAAQ,MAAM,IAAI,YAAY,OAAO;GAGvC;GACA,MAAM,MAAM,SAAS,UAAU;IAC7B,MAAM,UAAU,QAAQ,MAAM,IAAI,UAAU;IAE5C,IAAI,CAAC,SACH;IAUF,IAAI,SAAS,iBAAiB,cAC5B;IAGF,QAAQ,MAAM,OAAO,UAAU;IAE/B,MAAM,QAAqB;KAAE;KAAU,UAAU,KAAK,IAAI;IAAE;IAE5D,MAAM,MAAM,IAAI,OAAO,QAAQ,SAAS,GAAG,OAAO,EAChD,QAAQ,QAAQ,OAClB,CAAC;GAGH;EACF;CACF;AACF;AAEA,SAAS,oBAAoB,UAAwC;CACnE,OAAO;EACL,SAAS,SAAS;EAClB,cAAc,SAAS;EACvB,OAAO;GAAE,OAAO;GAAG,QAAQ;GAAG,OAAO;EAAE;EACvC,WAAW,SAAS;CACtB;AACF"}

package/esm/ai/src/middleware/helpers/compose.mjs

@@ -1,52 +0,0 @@
-//#region ../@warlock.js/ai/src/middleware/helpers/compose.ts
-/**
-* Flatten one or more middleware sources into a single ordered
-* array suitable for `agent({ middleware: [...] })`.
-*
-* **Role.** As middleware catalogs grow, agent configs accumulate
-* long arrays that mix "always-on" stacks (cache + budget + guardrail)
-* with per-concern extras (per-tool rate-limits, audit hooks). A
-* single `compose` call lets callers keep those sources as named
-* variables and flatten at the registration site.
-*
-* **Semantics.** Registration order is preserved across sources —
-* `compose(a, b, c)` produces `[...a, ...b, ...c]`. Because the
-* pipeline's onion is strictly registration-ordered, the flattened
-* order is the execution order. No de-duplication, no sorting, no
-* priority logic — that would hide bugs, not fix them.
-*
-* **Accepts arrays OR individual middlewares.** Both forms are
-* common in callsite code; the helper flattens either.
-*
-* @example
-* const standardStack = [
-*   ai.middleware.semanticCache({ ... }),
-*   ai.middleware.budget({ maxTokens: 20_000 }),
-*   ai.middleware.guardrail({ ... }),
-* ];
-*
-* const toolRateLimits = [
-*   toolRateLimit({ tool: "search_web", maxCalls: 3 }),
-*   toolRateLimit({ tool: "expensive_api", maxCalls: 1 }),
-* ];
-*
-* const myAgent = ai.agent({
-*   model,
-*   middleware: ai.middleware.compose(standardStack, toolRateLimits, auditMiddleware),
-* });
-*/
-function composeMiddleware(...sources) {
-	const out = [];
-	for (const source of sources) {
-		if (Array.isArray(source)) {
-			out.push(...source);
-			continue;
-		}
-		out.push(source);
-	}
-	return out;
-}
-
-//#endregion
-export { composeMiddleware };
-//# sourceMappingURL=compose.mjs.map

package/esm/ai/src/middleware/helpers/compose.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"compose.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/middleware/helpers/compose.ts"],"sourcesContent":["import type { AgentMiddleware } from \"../../contracts/middleware\";\n\n/**\n * Flatten one or more middleware sources into a single ordered\n * array suitable for `agent({ middleware: [...] })`.\n *\n * **Role.** As middleware catalogs grow, agent configs accumulate\n * long arrays that mix \"always-on\" stacks (cache + budget + guardrail)\n * with per-concern extras (per-tool rate-limits, audit hooks). A\n * single `compose` call lets callers keep those sources as named\n * variables and flatten at the registration site.\n *\n * **Semantics.** Registration order is preserved across sources —\n * `compose(a, b, c)` produces `[...a, ...b, ...c]`. Because the\n * pipeline's onion is strictly registration-ordered, the flattened\n * order is the execution order. No de-duplication, no sorting, no\n * priority logic — that would hide bugs, not fix them.\n *\n * **Accepts arrays OR individual middlewares.** Both forms are\n * common in callsite code; the helper flattens either.\n *\n * @example\n * const standardStack = [\n *   ai.middleware.semanticCache({ ... }),\n *   ai.middleware.budget({ maxTokens: 20_000 }),\n *   ai.middleware.guardrail({ ... }),\n * ];\n *\n * const toolRateLimits = [\n *   toolRateLimit({ tool: \"search_web\", maxCalls: 3 }),\n *   toolRateLimit({ tool: \"expensive_api\", maxCalls: 1 }),\n * ];\n *\n * const myAgent = ai.agent({\n *   model,\n *   middleware: ai.middleware.compose(standardStack, toolRateLimits, auditMiddleware),\n * });\n */\nexport function composeMiddleware(\n  ...sources: ReadonlyArray<AgentMiddleware | ReadonlyArray<AgentMiddleware>>\n): AgentMiddleware[] {\n  const out: AgentMiddleware[] = [];\n\n  for (const source of sources) {\n    if (Array.isArray(source)) {\n      out.push(...source);\n      continue;\n    }\n\n    out.push(source as AgentMiddleware);\n  }\n\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,kBACd,GAAG,SACgB;CACnB,MAAM,MAAyB,CAAC;CAEhC,KAAK,MAAM,UAAU,SAAS;EAC5B,IAAI,MAAM,QAAQ,MAAM,GAAG;GACzB,IAAI,KAAK,GAAG,MAAM;GAClB;EACF;EAEA,IAAI,KAAK,MAAyB;CACpC;CAEA,OAAO;AACT"}

package/esm/ai/src/middleware/helpers/for-tool.mjs

@@ -1,80 +0,0 @@
-//#region ../@warlock.js/ai/src/middleware/helpers/for-tool.ts
-/**
-* Scope a middleware's `tool`-level hooks to only fire for a
-* specific tool name (or a set of names). `execute` and `trip`
-* hooks pass through unchanged.
-*
-* **Role.** Tool-specific concerns — "rate-limit `search_web`",
-* "cache results for `fetch_faq`" — are common. Rather than adding
-* a `middleware` field to `ai.tool()` (see decisions §27), the
-* framework keeps one contract (`AgentMiddleware`) and offers this
-* helper for the locality problem. The middleware body stays agnostic
-* of the tool name; `forTool` handles the filtering.
-*
-* **What gets filtered.** Only `tool.before` / `tool.after` /
-* `tool.onError`. Each hook is wrapped so that `ctx.tool.name`
-* must be in the allowed set or the wrapped hook is a no-op.
-* `execute` and `trip` hooks are NOT touched — they run normally.
-*
-* **Why not filter execute/trip too?** Because a middleware that
-* reaches across levels (a tool-specific budget that initializes a
-* counter in `execute.before` and checks it in `tool.before`) still
-* needs `execute.before` to fire unconditionally. Scoping all hooks
-* would break cross-level middleware; scoping only `tool` hooks
-* matches the mental model of "this middleware cares about these
-* tools."
-*
-* **Single-name vs multi-name.** A string matches one tool; a string
-* array matches any of the listed tools. No wildcards, no regex —
-* keep it boring.
-*
-* @example
-* // Single tool
-* const scoped = ai.middleware.forTool(
-*   "search_web",
-*   toolRateLimit({ maxCalls: 3 }),
-* );
-*
-* @example
-* // Multiple tools sharing a rule
-* const scoped = ai.middleware.forTool(
-*   ["paid_api", "expensive_db"],
-*   toolRateLimit({ maxCalls: 5 }),
-* );
-*
-* ai.agent({
-*   model,
-*   tools: [webTool, paidApiTool, expensiveDbTool],
-*   middleware: [scoped],
-* });
-*/
-function forTool(toolNames, middleware) {
-	const allowed = new Set(typeof toolNames === "string" ? [toolNames] : toolNames);
-	const scope = allowed.size === 1 ? Array.from(allowed)[0] : Array.from(allowed).join("+");
-	if (!middleware.tool) return middleware;
-	const innerBefore = middleware.tool.before;
-	const innerAfter = middleware.tool.after;
-	const innerOnError = middleware.tool.onError;
-	return {
-		...middleware,
-		name: `${middleware.name}[for:${scope}]`,
-		tool: {
-			before: innerBefore ? async (ctx) => {
-				if (!allowed.has(ctx.tool.name)) return;
-				return innerBefore(ctx);
-			} : void 0,
-			after: innerAfter ? async (ctx, result) => {
-				if (!allowed.has(ctx.tool.name)) return;
-				return innerAfter(ctx, result);
-			} : void 0,
-			onError: innerOnError ? async (ctx, error) => {
-				if (!allowed.has(ctx.tool.name)) return;
-				return innerOnError(ctx, error);
-			} : void 0
-		}
-	};
-}
-
-//#endregion
-export { forTool };
-//# sourceMappingURL=for-tool.mjs.map

package/esm/ai/src/middleware/helpers/for-tool.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"for-tool.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/middleware/helpers/for-tool.ts"],"sourcesContent":["import type { AgentMiddleware } from \"../../contracts/middleware\";\n\n/**\n * Scope a middleware's `tool`-level hooks to only fire for a\n * specific tool name (or a set of names). `execute` and `trip`\n * hooks pass through unchanged.\n *\n * **Role.** Tool-specific concerns — \"rate-limit `search_web`\",\n * \"cache results for `fetch_faq`\" — are common. Rather than adding\n * a `middleware` field to `ai.tool()` (see decisions §27), the\n * framework keeps one contract (`AgentMiddleware`) and offers this\n * helper for the locality problem. The middleware body stays agnostic\n * of the tool name; `forTool` handles the filtering.\n *\n * **What gets filtered.** Only `tool.before` / `tool.after` /\n * `tool.onError`. Each hook is wrapped so that `ctx.tool.name`\n * must be in the allowed set or the wrapped hook is a no-op.\n * `execute` and `trip` hooks are NOT touched — they run normally.\n *\n * **Why not filter execute/trip too?** Because a middleware that\n * reaches across levels (a tool-specific budget that initializes a\n * counter in `execute.before` and checks it in `tool.before`) still\n * needs `execute.before` to fire unconditionally. Scoping all hooks\n * would break cross-level middleware; scoping only `tool` hooks\n * matches the mental model of \"this middleware cares about these\n * tools.\"\n *\n * **Single-name vs multi-name.** A string matches one tool; a string\n * array matches any of the listed tools. No wildcards, no regex —\n * keep it boring.\n *\n * @example\n * // Single tool\n * const scoped = ai.middleware.forTool(\n *   \"search_web\",\n *   toolRateLimit({ maxCalls: 3 }),\n * );\n *\n * @example\n * // Multiple tools sharing a rule\n * const scoped = ai.middleware.forTool(\n *   [\"paid_api\", \"expensive_db\"],\n *   toolRateLimit({ maxCalls: 5 }),\n * );\n *\n * ai.agent({\n *   model,\n *   tools: [webTool, paidApiTool, expensiveDbTool],\n *   middleware: [scoped],\n * });\n */\nexport function forTool(\n  toolNames: string | ReadonlyArray<string>,\n  middleware: AgentMiddleware,\n): AgentMiddleware {\n  const allowed = new Set(\n    typeof toolNames === \"string\" ? [toolNames] : toolNames,\n  );\n  const scope =\n    allowed.size === 1 ? Array.from(allowed)[0] : Array.from(allowed).join(\"+\");\n\n  if (!middleware.tool) {\n    return middleware;\n  }\n\n  const innerBefore = middleware.tool.before;\n  const innerAfter = middleware.tool.after;\n  const innerOnError = middleware.tool.onError;\n\n  return {\n    ...middleware,\n    name: `${middleware.name}[for:${scope}]`,\n    tool: {\n      before: innerBefore\n        ? async ctx => {\n            if (!allowed.has(ctx.tool.name)) {\n              return;\n            }\n\n            return innerBefore(ctx);\n          }\n        : undefined,\n      after: innerAfter\n        ? async (ctx, result) => {\n            if (!allowed.has(ctx.tool.name)) {\n              return;\n            }\n\n            return innerAfter(ctx, result);\n          }\n        : undefined,\n      onError: innerOnError\n        ? async (ctx, error) => {\n            if (!allowed.has(ctx.tool.name)) {\n              return;\n            }\n\n            return innerOnError(ctx, error);\n          }\n        : undefined,\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAgB,QACd,WACA,YACiB;CACjB,MAAM,UAAU,IAAI,IAClB,OAAO,cAAc,WAAW,CAAC,SAAS,IAAI,SAChD;CACA,MAAM,QACJ,QAAQ,SAAS,IAAI,MAAM,KAAK,OAAO,CAAC,CAAC,KAAK,MAAM,KAAK,OAAO,CAAC,CAAC,KAAK,GAAG;CAE5E,IAAI,CAAC,WAAW,MACd,OAAO;CAGT,MAAM,cAAc,WAAW,KAAK;CACpC,MAAM,aAAa,WAAW,KAAK;CACnC,MAAM,eAAe,WAAW,KAAK;CAErC,OAAO;EACL,GAAG;EACH,MAAM,GAAG,WAAW,KAAK,OAAO,MAAM;EACtC,MAAM;GACJ,QAAQ,cACJ,OAAM,QAAO;IACX,IAAI,CAAC,QAAQ,IAAI,IAAI,KAAK,IAAI,GAC5B;IAGF,OAAO,YAAY,GAAG;GACxB,IACA;GACJ,OAAO,aACH,OAAO,KAAK,WAAW;IACrB,IAAI,CAAC,QAAQ,IAAI,IAAI,KAAK,IAAI,GAC5B;IAGF,OAAO,WAAW,KAAK,MAAM;GAC/B,IACA;GACJ,SAAS,eACL,OAAO,KAAK,UAAU;IACpB,IAAI,CAAC,QAAQ,IAAI,IAAI,KAAK,IAAI,GAC5B;IAGF,OAAO,aAAa,KAAK,KAAK;GAChC,IACA;EACN;CACF;AACF"}

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

@@ -1,10 +0,0 @@
-import { extractUserText } from "./utils/extract-user-text.mjs";
-import { namespacedState } from "./utils/namespaced-state.mjs";
-import { budget, readBudgetFallbackSignal } from "./builtins/budget.mjs";
-import { guardrail } from "./builtins/guardrail.mjs";
-import { semanticCache } from "./builtins/semantic-cache.mjs";
-import { composeMiddleware } from "./helpers/compose.mjs";
-import { forTool } from "./helpers/for-tool.mjs";
-import { runPipeline } from "./pipeline.mjs";
-
-export {  };

package/esm/ai/src/middleware/pipeline.mjs

@@ -1,100 +0,0 @@
-//#region ../@warlock.js/ai/src/middleware/pipeline.ts
-const LOG_MODULE = "ai.middleware";
-/**
-* Run an inner async operation through a stack of agent middlewares
-* at a single level, applying the onion-model before/after/onError
-* semantics documented on `AgentMiddleware`.
-*
-* **Semantics.**
-* - `before` hooks run in registration order (top-down).
-*   Returning a defined value from a `before` hook short-circuits the
-*   pipeline with that value as the result, skipping `inner()` and
-*   all deeper `before` / `after` hooks — but outer middleware
-*   `after` hooks (registered earlier) still run on the synthetic
-*   value.
-* - `after` hooks run in reverse registration order (bottom-up).
-*   Returning a defined value replaces the result before it
-*   propagates further out. Returning `void` / `undefined` keeps the
-*   existing result.
-* - `onError` hooks also run in reverse (bottom-up) — any error
-*   thrown by `inner()`, by a `before` hook, or by an `after` hook
-*   unwinds through each frame's `onError` in turn. Returning a
-*   defined value from `onError` recovers: the error is cleared and
-*   the returned value becomes the new result (which then flows
-*   through outer `after` hooks). Returning `void` propagates the
-*   error to the next outer frame.
-*
-* **Implementation.** Built by folding the middleware array from the
-* end inward: each middleware produces a closure that wraps the
-* previous closure (the deeper pipeline). The outermost wrap is
-* middleware index 0 — so registration order matches onion order
-* without any reverse iteration at call time.
-*
-* **No magic.** The pipeline does not swallow, retry, or translate
-* errors. Hooks that throw propagate unchanged (subject to `onError`
-* recovery). Pipeline-level logging is debug-only and respects each
-* middleware's `log: false` kill-switch.
-*
-* @example
-* const response = await runPipeline(
-*   middlewares,
-*   "trip",
-*   tripContext,
-*   () => model.complete(messages, callOptions),
-*   logger,
-* );
-*/
-async function runPipeline(middlewares, level, context, inner, logger) {
-	if (middlewares.length === 0) return inner();
-	let next = inner;
-	for (let index = middlewares.length - 1; index >= 0; index--) {
-		const middleware = middlewares[index];
-		const hooks = middleware[level];
-		if (!hooks) continue;
-		const previous = next;
-		next = async () => {
-			const logEnabled = middleware.log !== false && logger !== void 0;
-			if (hooks.before) {
-				if (logEnabled) logger.debug(LOG_MODULE, `${level}.before`, middleware.name, {
-					middleware: middleware.name,
-					level
-				});
-				const shortCircuit = await hooks.before(context);
-				if (shortCircuit !== void 0) {
-					if (logEnabled) logger.debug(LOG_MODULE, `${level}.short-circuit`, middleware.name, {
-						middleware: middleware.name,
-						level
-					});
-					return shortCircuit;
-				}
-			}
-			let result;
-			try {
-				result = await previous();
-			} catch (thrown) {
-				if (!hooks.onError) throw thrown;
-				const recovered = await hooks.onError(context, thrown);
-				if (recovered === void 0) throw thrown;
-				if (logEnabled) logger.debug(LOG_MODULE, `${level}.recovered`, middleware.name, {
-					middleware: middleware.name,
-					level
-				});
-				result = recovered;
-			}
-			if (hooks.after) {
-				const replacement = await hooks.after(context, result);
-				if (replacement !== void 0) result = replacement;
-				if (logEnabled) logger.debug(LOG_MODULE, `${level}.after`, middleware.name, {
-					middleware: middleware.name,
-					level
-				});
-			}
-			return result;
-		};
-	}
-	return next();
-}
-
-//#endregion
-export { runPipeline };
-//# sourceMappingURL=pipeline.mjs.map

package/esm/ai/src/middleware/pipeline.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"pipeline.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/middleware/pipeline.ts"],"sourcesContent":["import type { Logger } from \"@warlock.js/logger\";\nimport type {\n  AgentMiddleware,\n  MiddlewareExecuteContext,\n  MiddlewareSupervisorContext,\n  MiddlewareToolContext,\n  MiddlewareTripContext,\n} from \"../contracts/middleware\";\n\nconst LOG_MODULE = \"ai.middleware\";\n\n/**\n * The four levels at which middleware can hook — mirrors\n * `AgentMiddleware`'s optional `execute` / `trip` / `tool` /\n * `supervisor` keys. Kept as a single named union so callers can pass\n * it around without inline-duplicating the literals. The first three\n * fire on the agent pipeline; `supervisor` fires once around a whole\n * `supervisor.execute()` run.\n */\nexport type MiddlewareLevel = \"execute\" | \"trip\" | \"tool\" | \"supervisor\";\n\n/**\n * Shape of the context object for each level. The pipeline is\n * level-parameterized on the ctx type via this mapping so callers\n * get compile-time narrowing when they instantiate `runPipeline`.\n */\nexport type MiddlewareContextByLevel = {\n  execute: MiddlewareExecuteContext;\n  trip: MiddlewareTripContext;\n  tool: MiddlewareToolContext;\n  supervisor: MiddlewareSupervisorContext;\n};\n\n/**\n * Run an inner async operation through a stack of agent middlewares\n * at a single level, applying the onion-model before/after/onError\n * semantics documented on `AgentMiddleware`.\n *\n * **Semantics.**\n * - `before` hooks run in registration order (top-down).\n *   Returning a defined value from a `before` hook short-circuits the\n *   pipeline with that value as the result, skipping `inner()` and\n *   all deeper `before` / `after` hooks — but outer middleware\n *   `after` hooks (registered earlier) still run on the synthetic\n *   value.\n * - `after` hooks run in reverse registration order (bottom-up).\n *   Returning a defined value replaces the result before it\n *   propagates further out. Returning `void` / `undefined` keeps the\n *   existing result.\n * - `onError` hooks also run in reverse (bottom-up) — any error\n *   thrown by `inner()`, by a `before` hook, or by an `after` hook\n *   unwinds through each frame's `onError` in turn. Returning a\n *   defined value from `onError` recovers: the error is cleared and\n *   the returned value becomes the new result (which then flows\n *   through outer `after` hooks). Returning `void` propagates the\n *   error to the next outer frame.\n *\n * **Implementation.** Built by folding the middleware array from the\n * end inward: each middleware produces a closure that wraps the\n * previous closure (the deeper pipeline). The outermost wrap is\n * middleware index 0 — so registration order matches onion order\n * without any reverse iteration at call time.\n *\n * **No magic.** The pipeline does not swallow, retry, or translate\n * errors. Hooks that throw propagate unchanged (subject to `onError`\n * recovery). Pipeline-level logging is debug-only and respects each\n * middleware's `log: false` kill-switch.\n *\n * @example\n * const response = await runPipeline(\n *   middlewares,\n *   \"trip\",\n *   tripContext,\n *   () => model.complete(messages, callOptions),\n *   logger,\n * );\n */\nexport async function runPipeline<Level extends MiddlewareLevel, TResult>(\n  middlewares: ReadonlyArray<AgentMiddleware>,\n  level: Level,\n  context: MiddlewareContextByLevel[Level],\n  inner: () => Promise<TResult>,\n  logger?: Logger,\n): Promise<TResult> {\n  if (middlewares.length === 0) {\n    return inner();\n  }\n\n  let next: () => Promise<TResult> = inner;\n\n  for (let index = middlewares.length - 1; index >= 0; index--) {\n    const middleware = middlewares[index];\n    const hooks = middleware[level];\n\n    if (!hooks) {\n      continue;\n    }\n\n    const previous = next;\n\n    next = async () => {\n      const logEnabled = middleware.log !== false && logger !== undefined;\n\n      if (hooks.before) {\n        if (logEnabled) {\n          logger!.debug(LOG_MODULE, `${level}.before`, middleware.name, {\n            middleware: middleware.name,\n            level,\n          });\n        }\n\n        const shortCircuit = await (\n          hooks.before as (ctx: unknown) => Promise<unknown> | unknown\n        )(context);\n\n        if (shortCircuit !== undefined) {\n          if (logEnabled) {\n            logger!.debug(\n              LOG_MODULE,\n              `${level}.short-circuit`,\n              middleware.name,\n              {\n                middleware: middleware.name,\n                level,\n              },\n            );\n          }\n\n          return shortCircuit as TResult;\n        }\n      }\n\n      let result: TResult;\n\n      try {\n        result = await previous();\n      } catch (thrown) {\n        if (!hooks.onError) {\n          throw thrown;\n        }\n\n        const recovered = await (\n          hooks.onError as (\n            ctx: unknown,\n            error: unknown,\n          ) => Promise<unknown> | unknown\n        )(context, thrown);\n\n        if (recovered === undefined) {\n          throw thrown;\n        }\n\n        if (logEnabled) {\n          logger!.debug(LOG_MODULE, `${level}.recovered`, middleware.name, {\n            middleware: middleware.name,\n            level,\n          });\n        }\n\n        result = recovered as TResult;\n      }\n\n      if (hooks.after) {\n        const replacement = await (\n          hooks.after as (\n            ctx: unknown,\n            value: unknown,\n          ) => Promise<unknown> | unknown\n        )(context, result);\n\n        if (replacement !== undefined) {\n          result = replacement as TResult;\n        }\n\n        if (logEnabled) {\n          logger!.debug(LOG_MODULE, `${level}.after`, middleware.name, {\n            middleware: middleware.name,\n            level,\n          });\n        }\n      }\n\n      return result;\n    };\n  }\n\n  return next();\n}\n"],"mappings":";AASA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEnB,eAAsB,YACpB,aACA,OACA,SACA,OACA,QACkB;CAClB,IAAI,YAAY,WAAW,GACzB,OAAO,MAAM;CAGf,IAAI,OAA+B;CAEnC,KAAK,IAAI,QAAQ,YAAY,SAAS,GAAG,SAAS,GAAG,SAAS;EAC5D,MAAM,aAAa,YAAY;EAC/B,MAAM,QAAQ,WAAW;EAEzB,IAAI,CAAC,OACH;EAGF,MAAM,WAAW;EAEjB,OAAO,YAAY;GACjB,MAAM,aAAa,WAAW,QAAQ,SAAS,WAAW;GAE1D,IAAI,MAAM,QAAQ;IAChB,IAAI,YACF,OAAQ,MAAM,YAAY,GAAG,MAAM,UAAU,WAAW,MAAM;KAC5D,YAAY,WAAW;KACvB;IACF,CAAC;IAGH,MAAM,eAAe,MACnB,MAAM,OACN,OAAO;IAET,IAAI,iBAAiB,QAAW;KAC9B,IAAI,YACF,OAAQ,MACN,YACA,GAAG,MAAM,iBACT,WAAW,MACX;MACE,YAAY,WAAW;MACvB;KACF,CACF;KAGF,OAAO;IACT;GACF;GAEA,IAAI;GAEJ,IAAI;IACF,SAAS,MAAM,SAAS;GAC1B,SAAS,QAAQ;IACf,IAAI,CAAC,MAAM,SACT,MAAM;IAGR,MAAM,YAAY,MAChB,MAAM,QAIN,SAAS,MAAM;IAEjB,IAAI,cAAc,QAChB,MAAM;IAGR,IAAI,YACF,OAAQ,MAAM,YAAY,GAAG,MAAM,aAAa,WAAW,MAAM;KAC/D,YAAY,WAAW;KACvB;IACF,CAAC;IAGH,SAAS;GACX;GAEA,IAAI,MAAM,OAAO;IACf,MAAM,cAAc,MAClB,MAAM,MAIN,SAAS,MAAM;IAEjB,IAAI,gBAAgB,QAClB,SAAS;IAGX,IAAI,YACF,OAAQ,MAAM,YAAY,GAAG,MAAM,SAAS,WAAW,MAAM;KAC3D,YAAY,WAAW;KACvB;IACF,CAAC;GAEL;GAEA,OAAO;EACT;CACF;CAEA,OAAO,KAAK;AACd"}

package/esm/ai/src/middleware/utils/extract-user-text.mjs

@@ -1,47 +0,0 @@
-//#region ../@warlock.js/ai/src/middleware/utils/extract-user-text.ts
-/**
-* Pull the text a content-inspection middleware should care about
-* from the outbound message list.
-*
-* **Role.** Built-ins that inspect "what the user just said" — the
-* guardrail on `trip.before`, the semantic cache on `trip.before`,
-* future consumers like PII redactors — all need the same string:
-* the most recent `user`-role message's text content. This helper
-* is the single authority on how that string is resolved.
-*
-* **Behavior.**
-* - Walks `messages` from the end backwards so the LAST user turn
-*   wins (correct when the agent has history + a fresh prompt).
-* - Returns a plain string directly when `content` is a string.
-* - Joins `text` parts with `"\n"` when `content` is a multipart
-*   `ContentPart[]`. Non-text parts (images, audio, pdf) are skipped —
-*   callers concerned with multimodal content inspect `request`
-*   / attachments separately.
-* - Returns `""` when there is no user message at all (e.g. a trip
-*   composed entirely of tool results).
-*
-* **Coverage limit (D3).** Because only `text` parts are extracted, any
-* guardrail / PII detector built on this helper inspects **text only** —
-* image / PDF / audio attachment content is NOT scanned. A guardrail is
-* therefore not a multimodal safety control: for non-text inputs add an
-* attachment-level policy (e.g. an OCR / moderation pass before the call)
-* rather than relying on input detectors.
-*
-* @example
-* const prompt = extractUserText(context.messages);
-* if (!prompt) return;
-* const verdict = await inputCheck(prompt);
-*/
-function extractUserText(messages) {
-	for (let index = messages.length - 1; index >= 0; index--) {
-		const message = messages[index];
-		if (message.role !== "user") continue;
-		if (typeof message.content === "string") return message.content;
-		if (Array.isArray(message.content)) return message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-	}
-	return "";
-}
-
-//#endregion
-export { extractUserText };
-//# sourceMappingURL=extract-user-text.mjs.map

package/esm/ai/src/middleware/utils/extract-user-text.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-user-text.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/middleware/utils/extract-user-text.ts"],"sourcesContent":["import type { Message } from \"../../contracts/conversation-message.type\";\n\n/**\n * Pull the text a content-inspection middleware should care about\n * from the outbound message list.\n *\n * **Role.** Built-ins that inspect \"what the user just said\" — the\n * guardrail on `trip.before`, the semantic cache on `trip.before`,\n * future consumers like PII redactors — all need the same string:\n * the most recent `user`-role message's text content. This helper\n * is the single authority on how that string is resolved.\n *\n * **Behavior.**\n * - Walks `messages` from the end backwards so the LAST user turn\n *   wins (correct when the agent has history + a fresh prompt).\n * - Returns a plain string directly when `content` is a string.\n * - Joins `text` parts with `\"\\n\"` when `content` is a multipart\n *   `ContentPart[]`. Non-text parts (images, audio, pdf) are skipped —\n *   callers concerned with multimodal content inspect `request`\n *   / attachments separately.\n * - Returns `\"\"` when there is no user message at all (e.g. a trip\n *   composed entirely of tool results).\n *\n * **Coverage limit (D3).** Because only `text` parts are extracted, any\n * guardrail / PII detector built on this helper inspects **text only** —\n * image / PDF / audio attachment content is NOT scanned. A guardrail is\n * therefore not a multimodal safety control: for non-text inputs add an\n * attachment-level policy (e.g. an OCR / moderation pass before the call)\n * rather than relying on input detectors.\n *\n * @example\n * const prompt = extractUserText(context.messages);\n * if (!prompt) return;\n * const verdict = await inputCheck(prompt);\n */\nexport function extractUserText(messages: ReadonlyArray<Message>): string {\n  for (let index = messages.length - 1; index >= 0; index--) {\n    const message = messages[index];\n\n    if (message.role !== \"user\") {\n      continue;\n    }\n\n    if (typeof message.content === \"string\") {\n      return message.content;\n    }\n\n    if (Array.isArray(message.content)) {\n      return message.content\n        .filter((part) => part.type === \"text\")\n        .map((part) => (part as { text: string }).text)\n        .join(\"\\n\");\n    }\n  }\n\n  return \"\";\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,gBAAgB,UAA0C;CACxE,KAAK,IAAI,QAAQ,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS;EACzD,MAAM,UAAU,SAAS;EAEzB,IAAI,QAAQ,SAAS,QACnB;EAGF,IAAI,OAAO,QAAQ,YAAY,UAC7B,OAAO,QAAQ;EAGjB,IAAI,MAAM,QAAQ,QAAQ,OAAO,GAC/B,OAAO,QAAQ,QACZ,QAAQ,SAAS,KAAK,SAAS,MAAM,CAAC,CACtC,KAAK,SAAU,KAA0B,IAAI,CAAC,CAC9C,KAAK,IAAI;CAEhB;CAEA,OAAO;AACT"}

package/esm/ai/src/middleware/utils/namespaced-state.mjs

@@ -1,60 +0,0 @@
-//#region ../@warlock.js/ai/src/middleware/utils/namespaced-state.ts
-/**
-* Typed accessor over `ctx.state` for a single namespace key. Wraps
-* the raw `Map<string, unknown>` so middleware authors stop typing
-* `as Counters | undefined` on every read.
-*
-* **Role.** Every built-in middleware reads and writes one or two
-* entries in `ctx.state` under its own name. Without a helper,
-* every call-site looks like:
-*
-* ```ts
-* const counters = context.state.get("budget.counters") as Counters | undefined;
-* if (!counters) { ... }
-* counters.tokens += n;
-* ```
-*
-* — cast noise, no type narrowing on `set`, no protection against
-* key typos. `namespacedState<T>` eliminates all three.
-*
-* **Scope.** Deliberately narrow: one key, typed value, four methods
-* (`get` / `set` / `delete` / `has`). Does NOT try to model compound
-* or nested keys — if you need those, use the raw `ctx.state` Map
-* directly, or create a second namespaced accessor for the second key.
-*
-* **Namespace convention.** Use the middleware's `name` as the key
-* (or a `name.<field>` prefix when a middleware needs multiple
-* entries). The pipeline does not enforce this — it is a convention
-* the built-ins follow to avoid collisions between middlewares.
-*
-* @example
-* // Inside a budget middleware:
-* const counters = namespacedState<Counters>(ctx, "budget");
-*
-* if (!counters.has()) {
-*   counters.set({ tokens: 0, costUSD: 0 });
-* }
-*
-* const current = counters.get()!;
-* current.tokens += response.usage.total;
-*/
-function namespacedState(ctx, namespace) {
-	return {
-		get() {
-			return ctx.state.get(namespace);
-		},
-		set(value) {
-			ctx.state.set(namespace, value);
-		},
-		delete() {
-			ctx.state.delete(namespace);
-		},
-		has() {
-			return ctx.state.has(namespace);
-		}
-	};
-}
-
-//#endregion
-export { namespacedState };
-//# sourceMappingURL=namespaced-state.mjs.map

package/esm/ai/src/middleware/utils/namespaced-state.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"namespaced-state.mjs","names":[],"sources":["../../../../../../../../../../@warlock.js/ai/src/middleware/utils/namespaced-state.ts"],"sourcesContent":["import type { MiddlewareState } from \"../../contracts/middleware\";\n\n/**\n * Typed accessor over `ctx.state` for a single namespace key. Wraps\n * the raw `Map<string, unknown>` so middleware authors stop typing\n * `as Counters | undefined` on every read.\n *\n * **Role.** Every built-in middleware reads and writes one or two\n * entries in `ctx.state` under its own name. Without a helper,\n * every call-site looks like:\n *\n * ```ts\n * const counters = context.state.get(\"budget.counters\") as Counters | undefined;\n * if (!counters) { ... }\n * counters.tokens += n;\n * ```\n *\n * — cast noise, no type narrowing on `set`, no protection against\n * key typos. `namespacedState<T>` eliminates all three.\n *\n * **Scope.** Deliberately narrow: one key, typed value, four methods\n * (`get` / `set` / `delete` / `has`). Does NOT try to model compound\n * or nested keys — if you need those, use the raw `ctx.state` Map\n * directly, or create a second namespaced accessor for the second key.\n *\n * **Namespace convention.** Use the middleware's `name` as the key\n * (or a `name.<field>` prefix when a middleware needs multiple\n * entries). The pipeline does not enforce this — it is a convention\n * the built-ins follow to avoid collisions between middlewares.\n *\n * @example\n * // Inside a budget middleware:\n * const counters = namespacedState<Counters>(ctx, \"budget\");\n *\n * if (!counters.has()) {\n *   counters.set({ tokens: 0, costUSD: 0 });\n * }\n *\n * const current = counters.get()!;\n * current.tokens += response.usage.total;\n */\nexport function namespacedState<T>(\n  ctx: { readonly state: MiddlewareState },\n  namespace: string,\n): NamespacedStateAccessor<T> {\n  return {\n    get(): T | undefined {\n      return ctx.state.get(namespace) as T | undefined;\n    },\n    set(value: T): void {\n      ctx.state.set(namespace, value);\n    },\n    delete(): void {\n      ctx.state.delete(namespace);\n    },\n    has(): boolean {\n      return ctx.state.has(namespace);\n    },\n  };\n}\n\n/**\n * Four-method accessor returned by `namespacedState`. Callers hold\n * it for the lifetime of a hook body — it is a thin typed view over\n * `ctx.state`, not a detached snapshot. Reads are live; writes hit\n * the underlying Map immediately and are visible to every other\n * hook that uses the same namespace.\n */\nexport type NamespacedStateAccessor<T> = {\n  get(): T | undefined;\n  set(value: T): void;\n  delete(): void;\n  has(): boolean;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,gBACd,KACA,WAC4B;CAC5B,OAAO;EACL,MAAqB;GACnB,OAAO,IAAI,MAAM,IAAI,SAAS;EAChC;EACA,IAAI,OAAgB;GAClB,IAAI,MAAM,IAAI,WAAW,KAAK;EAChC;EACA,SAAe;GACb,IAAI,MAAM,OAAO,SAAS;EAC5B;EACA,MAAe;GACb,OAAO,IAAI,MAAM,IAAI,SAAS;EAChC;CACF;AACF"}

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

@@ -1,4 +0,0 @@
-import "./mock-agent.mjs";
-import { mockRouter } from "./mock-router.mjs";
-
-export {  };

package/esm/ai/src/mock/mock-agent.mjs

@@ -1,3 +0,0 @@
-import "../agent/agent.mjs";
-
-export {  };

package/esm/ai/src/mock/mock-router.mjs

@@ -1,58 +0,0 @@
-import { END } from "../contracts/end.type.mjs";
-
-//#region ../@warlock.js/ai/src/mock/mock-router.ts
-/**
-* Build a deterministic `route` callback that replays a canned
-* sequence of routing decisions — one per supervisor iteration — for
-* testing supervisors without an LLM router.
-*
-* Drop the returned callback into `ai.supervisor({ route: mockRouter([...]) })`
-* in place of an LLM `router`. The Nth iteration consumes the Nth
-* decision; a function decision is evaluated against the live
-* `RouteContext`. When the queue runs out, behavior follows
-* `options.onExhausted` (default: terminate with `END`).
-*
-* Pairs with the `toRouteTo` / `toConverge` matchers to assert the
-* resulting report tree.
-*
-* @example
-* const supervisor = ai.supervisor({
-*   name: "draft-then-review",
-*   intents: { writer, critic },
-*   route: mockRouter(["writer", "critic", END]),
-* });
-*
-* @example
-* // Branch on accumulated state, repeat the last decision until done.
-* route: mockRouter(
-*   ["research", (ctx) => (ctx.state.summary ? END : "research")],
-*   { onExhausted: "repeat" },
-* );
-*/
-function mockRouter(decisions, options = {}) {
-	const onExhausted = options.onExhausted ?? "end";
-	let cursor = 0;
-	return (context) => {
-		if (cursor < decisions.length) {
-			const decision = decisions[cursor];
-			cursor++;
-			return resolveDecision(decision, context);
-		}
-		if (onExhausted === "throw") throw new Error(`mockRouter exhausted after ${decisions.length} decision(s) at iteration ${context.iteration}`);
-		if (onExhausted === "repeat" && decisions.length > 0) return resolveDecision(decisions[decisions.length - 1], context);
-		return END;
-	};
-}
-/**
-* Resolve a single decision entry into a concrete {@link Next} —
-* invoking the predicate form against the live context, or returning
-* the literal form verbatim.
-*/
-function resolveDecision(decision, context) {
-	if (typeof decision === "function") return decision(context);
-	return decision;
-}
-
-//#endregion
-export { mockRouter };
-//# sourceMappingURL=mock-router.mjs.map