@warlock.js/ai 4.1.1

package/esm/middleware/helpers/compose.mjs

@@ -0,0 +1,52 @@
+//#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/middleware/helpers/compose.mjs.map

@@ -0,0 +1 @@
+{"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/middleware/helpers/for-tool.d.mts

@@ -0,0 +1,55 @@
+import { AgentMiddleware } from "../../contracts/middleware/middleware.contract.mjs";
+//#region ../../@warlock.js/ai/src/middleware/helpers/for-tool.d.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],
+ * });
+ */
+declare function forTool(toolNames: string | ReadonlyArray<string>, middleware: AgentMiddleware): AgentMiddleware;
+//#endregion
+export { forTool };
+//# sourceMappingURL=for-tool.d.mts.map

package/esm/middleware/helpers/for-tool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"for-tool.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/middleware/helpers/for-tool.ts"],"mappings":";;;;;AAmDA;;;;;;;;;;;;;;AAGkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAHF,OAAA,CACd,SAAA,WAAoB,aAAA,UACpB,UAAA,EAAY,eAAA,GACX,eAAA"}

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

@@ -0,0 +1,80 @@
+//#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/middleware/helpers/for-tool.mjs.map

@@ -0,0 +1 @@
+{"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,EAAE,KAAK,MAAM,KAAK,OAAO,EAAE,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/middleware/helpers/index.d.mts

@@ -0,0 +1,2 @@
+import { composeMiddleware } from "./compose.mjs";
+import { forTool } from "./for-tool.mjs";

package/esm/middleware/index.d.mts

@@ -0,0 +1,8 @@
+import { BudgetOptions, BudgetPricing, budget } from "./builtins/budget.mjs";
+import { GuardrailCheck, GuardrailCheckResult, GuardrailOptions, guardrail } from "./builtins/guardrail.mjs";
+import { SemanticCacheOptions, semanticCache } from "./builtins/semantic-cache.mjs";
+import { composeMiddleware } from "./helpers/compose.mjs";
+import { forTool } from "./helpers/for-tool.mjs";
+import { MiddlewareContextByLevel, MiddlewareLevel, runPipeline } from "./pipeline.mjs";
+import { extractUserText } from "./utils/extract-user-text.mjs";
+import { NamespacedStateAccessor, namespacedState } from "./utils/namespaced-state.mjs";

package/esm/middleware/index.mjs

@@ -0,0 +1,10 @@
+import { extractUserText } from "./utils/extract-user-text.mjs";
+import { namespacedState } from "./utils/namespaced-state.mjs";
+import { budget } 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/middleware/pipeline.d.mts

@@ -0,0 +1,70 @@
+import { MiddlewareExecuteContext, MiddlewareToolContext, MiddlewareTripContext } from "../contracts/middleware/middleware-context.type.mjs";
+import { AgentMiddleware } from "../contracts/middleware/middleware.contract.mjs";
+import { Logger } from "@warlock.js/logger";
+
+//#region ../../@warlock.js/ai/src/middleware/pipeline.d.ts
+/**
+ * The three levels at which agent middleware can hook — mirrors
+ * `AgentMiddleware`'s optional `execute` / `trip` / `tool` keys.
+ * Kept as a single named union so callers can pass it around without
+ * inline-duplicating the literals.
+ */
+type MiddlewareLevel = "execute" | "trip" | "tool";
+/**
+ * Shape of the context object for each level. The pipeline is
+ * level-parameterized on the ctx type via this mapping so callers
+ * get compile-time narrowing when they instantiate `runPipeline`.
+ */
+type MiddlewareContextByLevel = {
+  execute: MiddlewareExecuteContext;
+  trip: MiddlewareTripContext;
+  tool: MiddlewareToolContext;
+};
+/**
+ * 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,
+ * );
+ */
+declare function runPipeline<Level extends MiddlewareLevel, TResult>(middlewares: ReadonlyArray<AgentMiddleware>, level: Level, context: MiddlewareContextByLevel[Level], inner: () => Promise<TResult>, logger?: Logger): Promise<TResult>;
+//#endregion
+export { MiddlewareContextByLevel, MiddlewareLevel, runPipeline };
+//# sourceMappingURL=pipeline.d.mts.map

package/esm/middleware/pipeline.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/middleware/pipeline.ts"],"mappings":";;;;;;;;;AAgBA;;KAAY,eAAA;;AAAe;AAO3B;;;KAAY,wBAAA;EACV,OAAA,EAAS,wBAAA;EACT,IAAA,EAAM,qBAAA;EACN,IAAA,EAAM,qBAAA;AAAA;;;;;;;;AAAqB;AA+C7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMkB;iBANI,WAAA,eAA0B,eAAA,UAAA,CAC9C,WAAA,EAAa,aAAA,CAAc,eAAA,GAC3B,KAAA,EAAO,KAAA,EACP,OAAA,EAAS,wBAAA,CAAyB,KAAA,GAClC,KAAA,QAAa,OAAA,CAAQ,OAAA,GACrB,MAAA,GAAS,MAAA,GACR,OAAA,CAAQ,OAAA"}

package/esm/middleware/pipeline.mjs

@@ -0,0 +1,100 @@
+//#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/middleware/pipeline.mjs.map

@@ -0,0 +1 @@
+{"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  MiddlewareToolContext,\n  MiddlewareTripContext,\n} from \"../contracts/middleware\";\n\nconst LOG_MODULE = \"ai.middleware\";\n\n/**\n * The three levels at which agent middleware can hook — mirrors\n * `AgentMiddleware`'s optional `execute` / `trip` / `tool` keys.\n * Kept as a single named union so callers can pass it around without\n * inline-duplicating the literals.\n */\nexport type MiddlewareLevel = \"execute\" | \"trip\" | \"tool\";\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};\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":";AAQA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiEnB,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/middleware/utils/extract-user-text.d.mts

@@ -0,0 +1,33 @@
+import { Message } from "../../contracts/conversation-message.type.mjs";
+
+//#region ../../@warlock.js/ai/src/middleware/utils/extract-user-text.d.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) 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).
+ *
+ * @example
+ * const prompt = extractUserText(context.messages);
+ * if (!prompt) return;
+ * const verdict = await inputCheck(prompt);
+ */
+declare function extractUserText(messages: ReadonlyArray<Message>): string;
+//#endregion
+export { extractUserText };
+//# sourceMappingURL=extract-user-text.d.mts.map

package/esm/middleware/utils/extract-user-text.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-user-text.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/middleware/utils/extract-user-text.ts"],"mappings":";;;;;AA4BA;;;;;;;;AAAgE;;;;;;;;;;;;;;;;iBAAhD,eAAA,CAAgB,QAAA,EAAU,aAAa,CAAC,OAAA"}

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

@@ -0,0 +1,40 @@
+//#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) 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).
+*
+* @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/middleware/utils/extract-user-text.mjs.map

@@ -0,0 +1 @@
+{"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) 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 * @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":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,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,EACrC,KAAK,SAAU,KAA0B,IAAI,EAC7C,KAAK,IAAI;CAEhB;CAEA,OAAO;AACT"}

package/esm/middleware/utils/index.d.mts

@@ -0,0 +1,2 @@
+import { extractUserText } from "./extract-user-text.mjs";
+import { NamespacedStateAccessor, namespacedState } from "./namespaced-state.mjs";

package/esm/middleware/utils/namespaced-state.d.mts

@@ -0,0 +1,60 @@
+import { MiddlewareState } from "../../contracts/middleware/middleware-state.type.mjs";
+//#region ../../@warlock.js/ai/src/middleware/utils/namespaced-state.d.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;
+ */
+declare function namespacedState<T>(ctx: {
+  readonly state: MiddlewareState;
+}, namespace: string): NamespacedStateAccessor<T>;
+/**
+ * Four-method accessor returned by `namespacedState`. Callers hold
+ * it for the lifetime of a hook body — it is a thin typed view over
+ * `ctx.state`, not a detached snapshot. Reads are live; writes hit
+ * the underlying Map immediately and are visible to every other
+ * hook that uses the same namespace.
+ */
+type NamespacedStateAccessor<T> = {
+  get(): T | undefined;
+  set(value: T): void;
+  delete(): void;
+  has(): boolean;
+};
+//#endregion
+export { NamespacedStateAccessor, namespacedState };
+//# sourceMappingURL=namespaced-state.d.mts.map

package/esm/middleware/utils/namespaced-state.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespaced-state.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/middleware/utils/namespaced-state.ts"],"mappings":";;;;;AAyCA;;;;;;;;;;;;;;;;AAG4B;AAwB5B;;;;;;;;;;;;;AAIK;;;;;;iBA/BW,eAAA,GAAA,CACd,GAAA;EAAA,SAAgB,KAAA,EAAO,eAAA;AAAA,GACvB,SAAA,WACC,uBAAA,CAAwB,CAAA;;;;;;;;KAwBf,uBAAA;EACV,GAAA,IAAO,CAAA;EACP,GAAA,CAAI,KAAA,EAAO,CAAC;EACZ,MAAA;EACA,GAAA;AAAA"}

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

@@ -0,0 +1,60 @@
+//#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/middleware/utils/namespaced-state.mjs.map

@@ -0,0 +1 @@
+{"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"}