@warlock.js/core 4.4.0 → 4.5.0

package/esm/ai/src/config.mjs

@@ -0,0 +1,59 @@
+//#region ../@warlock.js/ai/src/config.ts
+const aiConfig = {};
+const configListeners = [];
+/**
+* Set or extend process-wide AI configuration. Merges over existing
+* values — fields not present in `partial` keep whatever was set
+* before (or stay unset). Call once at app boot, before constructing
+* any agent / supervisor / middleware that should pick up the
+* defaults.
+*
+* Returns the merged config so callers can verify what landed.
+*
+* @example
+* import { cache } from "@warlock.js/cache";
+* import { ai } from "@warlock.js/ai";
+*
+* ai.config({ defaultStore: cache.driver("redis", { client }) });
+*/
+function setAIConfig(partial) {
+	Object.assign(aiConfig, partial);
+	const snapshot = { ...aiConfig };
+	for (const listener of configListeners) try {
+		listener(snapshot);
+	} catch {}
+	return snapshot;
+}
+/**
+* Resolve the effective `@warlock.js/cache` driver for a cache-backed
+* consumer that didn't receive an explicit one. Returns the global
+* `defaultStore` if set, otherwise `undefined`. The semantic-cache
+* middleware treats `undefined` as fatal and throws. Snapshot
+* persistence no longer consults this — it resolves through
+* {@link resolveDefaultSnapshotStore}.
+*/
+function resolveDefaultStore() {
+	return aiConfig.defaultStore;
+}
+/**
+* Resolve the global default {@link CheckpointStore} for an
+* orchestrator that didn't receive an explicit `checkpointStore`.
+* Returns `undefined` when none is configured — the orchestrator
+* factory decides whether that's fatal.
+*/
+function resolveDefaultCheckpointStore() {
+	return aiConfig.defaultCheckpointStore;
+}
+/**
+* Resolve the global default {@link SnapshotStore} for an orchestrator
+* that didn't receive an explicit `snapshotStore`. Returns `undefined`
+* when none is configured — the orchestrator factory decides whether
+* that's fatal (it is, when `iterate: true`).
+*/
+function resolveDefaultSnapshotStore() {
+	return aiConfig.defaultSnapshotStore;
+}
+
+//#endregion
+export { resolveDefaultCheckpointStore, resolveDefaultSnapshotStore, resolveDefaultStore, setAIConfig };
+//# sourceMappingURL=config.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/config.ts"],"sourcesContent":["import type { CacheDriver } from \"@warlock.js/cache\";\nimport type { CheckpointStore } from \"./contracts/orchestrator/checkpoint-store.contract\";\nimport type { SnapshotStore } from \"./contracts/orchestrator/snapshot-store.contract\";\n\n/**\n * Process-wide `@warlock.js/ai` configuration. **Intentionally tiny.**\n * Lives here only for genuinely cross-cutting defaults that would\n * otherwise force users to wire the same value into every consumer.\n *\n * **What lives here.** A field earns a slot only when it satisfies\n * all three:\n * 1. Multiple unrelated consumers need the same value.\n * 2. The value is infrastructure (drivers, clients, pools), not\n *    behavior (kill-switches, mode flags).\n * 3. Per-call override doesn't make sense for the use case.\n *\n * **What does NOT live here.** Logger config (use\n * `@warlock.js/logger` directly). Per-primitive feature flags\n * (live on the relevant config type). Anything that's really one\n * consumer's concern (lives on that consumer).\n *\n * Phase 3.2 deliberately removed the previous `configureAI()` bag\n * because it was growing unbounded. Treat new fields here with the\n * same suspicion.\n *\n * **Augmentable.** Declared as an `interface` (not a `type` alias) so\n * observability/tooling packages can attach their own opaque config slot\n * via declaration merging WITHOUT core importing them — keeping core\n * dependency-free. For example `@warlock.js/ai-panoptic` adds a\n * `panoptic?` field:\n *\n * ```ts\n * declare module \"@warlock.js/ai\" {\n *   interface AIConfig {\n *     panoptic?: PanopticConfig;\n *   }\n * }\n * ```\n *\n * `setAIConfig` stores the whole object via `Object.assign`, so any\n * augmented field is preserved even though core never reads it.\n */\nexport interface AIConfig {\n  /**\n   * Default `@warlock.js/cache` driver for cache-backed consumers that\n   * didn't supply their own `store` — currently the `semanticCache`\n   * middleware's vector store. Declaring it once here removes the\n   * repetition across middleware declarations.\n   *\n   * NOT the snapshot-persistence fallback anymore. Supervisor /\n   * workflow / orchestrator resume snapshots resolve through\n   * {@link AIConfig.defaultSnapshotStore} (a {@link SnapshotStore}),\n   * never this driver.\n   *\n   * Per-declaration overrides (`semanticCache({ store })`) win when\n   * supplied. Set this once at app boot, *after* you've constructed\n   * your driver.\n   *\n   * @example\n   * import { cache } from \"@warlock.js/cache\";\n   * import { ai } from \"@warlock.js/ai\";\n   *\n   * ai.config({\n   *   defaultStore: cache.driver(\"redis\", { client: redisClient }),\n   * });\n   */\n  defaultStore?: CacheDriver<any, any>;\n\n  /**\n   * Default {@link CheckpointStore} for every orchestrator that didn't\n   * supply its own `checkpointStore` (orchestrator.md §15.2). Holds\n   * durable session state — `state`, `turn_index`, drift `signature`,\n   * compaction locks. Per-orchestrator `checkpointStore` wins when\n   * supplied. Set once at app boot.\n   *\n   * @example\n   * import { ai } from \"@warlock.js/ai\";\n   *\n   * ai.config({ defaultCheckpointStore: ai.checkpoint.memory() });\n   */\n  defaultCheckpointStore?: CheckpointStore;\n\n  /**\n   * Default {@link SnapshotStore} for every orchestrator that didn't\n   * supply its own `snapshotStore` (orchestrator.md §15.2). Holds the\n   * internal supervisor run state used to resume an interrupted\n   * `iterate: true` turn. Per-orchestrator `snapshotStore` wins when\n   * supplied. Set once at app boot.\n   *\n   * @example\n   * import { ai } from \"@warlock.js/ai\";\n   *\n   * ai.config({ defaultSnapshotStore: ai.snapshot.memory() });\n   */\n  defaultSnapshotStore?: SnapshotStore;\n};\n\nconst aiConfig: AIConfig = {};\n\n/** A listener notified after every `setAIConfig` merge. */\ntype ConfigListener = (config: AIConfig) => void;\n\nconst configListeners: ConfigListener[] = [];\n\n/**\n * Subscribe to config changes. The listener fires after every\n * {@link setAIConfig} merge with a fresh snapshot of the full config —\n * the seam observability/tooling packages use to react when their\n * augmented slot (e.g. `panoptic`) is set, WITHOUT core importing them.\n *\n * Mirrors the dependency-inversion of the `Observer` registry: core\n * exposes the structural hook; the tool subscribes on its side-effect\n * import. To also catch config that was applied *before* the subscription,\n * read {@link getAIConfig} once right after subscribing.\n *\n * @example\n * import { onConfigApplied, getAIConfig } from \"@warlock.js/ai\";\n * onConfigApplied((config) => applyPanopticConfig(config.panoptic));\n * applyPanopticConfig(getAIConfig().panoptic); // catch pre-set config\n */\nexport function onConfigApplied(listener: ConfigListener): void {\n  configListeners.push(listener);\n}\n\n/**\n * Set or extend process-wide AI configuration. Merges over existing\n * values — fields not present in `partial` keep whatever was set\n * before (or stay unset). Call once at app boot, before constructing\n * any agent / supervisor / middleware that should pick up the\n * defaults.\n *\n * Returns the merged config so callers can verify what landed.\n *\n * @example\n * import { cache } from \"@warlock.js/cache\";\n * import { ai } from \"@warlock.js/ai\";\n *\n * ai.config({ defaultStore: cache.driver(\"redis\", { client }) });\n */\nexport function setAIConfig(partial: Partial<AIConfig>): AIConfig {\n  Object.assign(aiConfig, partial);\n  const snapshot = { ...aiConfig };\n\n  // Notify subscribers (e.g. panoptic) after the merge. Errors are\n  // swallowed so a misbehaving listener never breaks config application,\n  // mirroring the observer / onUsage swallow-on-throw discipline.\n  for (const listener of configListeners) {\n    try {\n      listener(snapshot);\n    } catch {\n      // intentionally ignored\n    }\n  }\n\n  return snapshot;\n}\n\n/**\n * Read the current AI config snapshot. Returns a shallow copy so\n * callers can't accidentally mutate the source of truth. Used\n * internally by consumers to resolve their `defaultStore` fallback.\n */\nexport function getAIConfig(): AIConfig {\n  return { ...aiConfig };\n}\n\n/**\n * Resolve the effective `@warlock.js/cache` driver for a cache-backed\n * consumer that didn't receive an explicit one. Returns the global\n * `defaultStore` if set, otherwise `undefined`. The semantic-cache\n * middleware treats `undefined` as fatal and throws. Snapshot\n * persistence no longer consults this — it resolves through\n * {@link resolveDefaultSnapshotStore}.\n */\nexport function resolveDefaultStore(): CacheDriver<any, any> | undefined {\n  return aiConfig.defaultStore;\n}\n\n/**\n * Resolve the global default {@link CheckpointStore} for an\n * orchestrator that didn't receive an explicit `checkpointStore`.\n * Returns `undefined` when none is configured — the orchestrator\n * factory decides whether that's fatal.\n */\nexport function resolveDefaultCheckpointStore(): CheckpointStore | undefined {\n  return aiConfig.defaultCheckpointStore;\n}\n\n/**\n * Resolve the global default {@link SnapshotStore} for an orchestrator\n * that didn't receive an explicit `snapshotStore`. Returns `undefined`\n * when none is configured — the orchestrator factory decides whether\n * that's fatal (it is, when `iterate: true`).\n */\nexport function resolveDefaultSnapshotStore(): SnapshotStore | undefined {\n  return aiConfig.defaultSnapshotStore;\n}\n"],"mappings":";AAiGA,MAAM,WAAqB,CAAC;AAK5B,MAAM,kBAAoC,CAAC;;;;;;;;;;;;;;;;AAqC3C,SAAgB,YAAY,SAAsC;CAChE,OAAO,OAAO,UAAU,OAAO;CAC/B,MAAM,WAAW,EAAE,GAAG,SAAS;CAK/B,KAAK,MAAM,YAAY,iBACrB,IAAI;EACF,SAAS,QAAQ;CACnB,QAAQ,CAER;CAGF,OAAO;AACT;;;;;;;;;AAmBA,SAAgB,sBAAyD;CACvE,OAAO,SAAS;AAClB;;;;;;;AAQA,SAAgB,gCAA6D;CAC3E,OAAO,SAAS;AAClB;;;;;;;AAQA,SAAgB,8BAAyD;CACvE,OAAO,SAAS;AAClB"}

package/esm/ai/src/contracts/end.type.mjs

@@ -0,0 +1,47 @@
+//#region ../@warlock.js/ai/src/contracts/end.type.ts
+/**
+* Framework-global termination sentinel. Emitted by any primitive
+* whose control flow is routed through JSON-serializable strings —
+* supervisor (router agent's `next`, deterministic `route` callback),
+* future planner (plan steps), future orchestrator (session
+* directive), any future primitive that needs to say "stop" across a
+* wire that can't carry `null`.
+*
+* **Why one shared literal.** Consumers learn one word. Cross-
+* primitive pipes — a planner feeding a supervisor, a supervisor
+* nested as a tool inside an orchestrator — can pass the sentinel
+* through without translation.
+*
+* **Why this specific string.** Brand-prefixed (`__warlock:`) so it
+* can't collide with a realistic user-chosen intent / step / route
+* key (`"end"`, `"done"`, `"stop"` are all valid user keys).
+* Underscore-surrounded so it stands out in logs and snapshots.
+* JSON-safe so a router agent emits it verbatim.
+*
+* **Not used by every primitive.** Workflow's `nextStep` returns
+* `null` to end — a callback-level mechanism that predates this
+* sentinel. Workflows keep `null`; the sentinel is for primitives
+* whose "end" must survive a JSON boundary.
+*
+* @example
+* import { END } from "@warlock.js/ai";
+*
+* // Supervisor route callback
+* ai.supervisor({
+*   intents: { writer, critic },
+*   route: (ctx) => (ctx.iteration >= 5 ? END : "writer"),
+* });
+*
+* // Router agent output schema
+* const router = ai.agent({
+*   model,
+*   output: z.object({
+*     next: z.union([z.string(), z.array(z.string()), z.literal(END)]),
+*   }),
+* });
+*/
+const END = "__warlock:end__";
+
+//#endregion
+export { END };
+//# sourceMappingURL=end.type.mjs.map

package/esm/ai/src/contracts/end.type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"end.type.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/contracts/end.type.ts"],"sourcesContent":["/**\n * Framework-global termination sentinel. Emitted by any primitive\n * whose control flow is routed through JSON-serializable strings —\n * supervisor (router agent's `next`, deterministic `route` callback),\n * future planner (plan steps), future orchestrator (session\n * directive), any future primitive that needs to say \"stop\" across a\n * wire that can't carry `null`.\n *\n * **Why one shared literal.** Consumers learn one word. Cross-\n * primitive pipes — a planner feeding a supervisor, a supervisor\n * nested as a tool inside an orchestrator — can pass the sentinel\n * through without translation.\n *\n * **Why this specific string.** Brand-prefixed (`__warlock:`) so it\n * can't collide with a realistic user-chosen intent / step / route\n * key (`\"end\"`, `\"done\"`, `\"stop\"` are all valid user keys).\n * Underscore-surrounded so it stands out in logs and snapshots.\n * JSON-safe so a router agent emits it verbatim.\n *\n * **Not used by every primitive.** Workflow's `nextStep` returns\n * `null` to end — a callback-level mechanism that predates this\n * sentinel. Workflows keep `null`; the sentinel is for primitives\n * whose \"end\" must survive a JSON boundary.\n *\n * @example\n * import { END } from \"@warlock.js/ai\";\n *\n * // Supervisor route callback\n * ai.supervisor({\n *   intents: { writer, critic },\n *   route: (ctx) => (ctx.iteration >= 5 ? END : \"writer\"),\n * });\n *\n * // Router agent output schema\n * const router = ai.agent({\n *   model,\n *   output: z.object({\n *     next: z.union([z.string(), z.array(z.string()), z.literal(END)]),\n *   }),\n * });\n */\nexport const END = \"__warlock:end__\" as const;\n\n/**\n * Value type of `END`. Exposed so consumers building Zod / Standard\n * Schema output schemas can write `z.literal(END)` without\n * hard-coding the string, and so generic helpers that accept \"the\n * end sentinel\" can type-narrow correctly.\n */\nexport type EndSentinel = typeof END;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,MAAa,MAAM"}

package/esm/ai/src/errors/agent-cancelled-error.mjs

@@ -0,0 +1,43 @@
+import { AgentExecutionError } from "./agent-execution-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/agent-cancelled-error.ts
+/**
+* Agent run was cancelled via `AbortSignal` before it could finish.
+* Between-trip cancellation is guaranteed; mid-trip cancellation is
+* best-effort (the signal is threaded into the provider adapter's
+* HTTP client when supported).
+*
+* Surfaced on `result.error` rather than thrown — `agent.execute()`
+* still returns with `report.status = "cancelled"` and partial trip
+* history intact. Consumers branch on the class (not the message) to
+* distinguish caller-initiated stops from other failures.
+*
+* **Why split from `AgentExecutionError`.** Cancellation is a
+* different operational signal from "the agent crashed" — retry
+* policy and dashboards typically want different behavior for each.
+* Keeping cancellation in its own class lets the category
+* (`"cancelled"`) be set declaratively per type instead of inferred
+* from a `context.cancelled === true` flag.
+*
+* @example
+* const result = await agent.execute(input, { signal });
+* if (result.error instanceof AgentCancelledError) {
+*   // caller pulled the plug — don't retry, surface a "stopped" UI
+*   return { status: "cancelled" };
+* }
+*/
+var AgentCancelledError = class extends AgentExecutionError {
+	static {
+		this.defaultCategory = "cancelled";
+	}
+	constructor(message, options) {
+		super(message, options, "AGENT_CANCELLED");
+		this.name = "AgentCancelledError";
+		this.cancelledAt = options?.cancelledAt;
+		this.reason = options?.reason;
+	}
+};
+
+//#endregion
+export { AgentCancelledError };
+//# sourceMappingURL=agent-cancelled-error.mjs.map

package/esm/ai/src/errors/agent-cancelled-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-cancelled-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/agent-cancelled-error.ts"],"sourcesContent":["import { AgentExecutionError } from \"./agent-execution-error\";\nimport type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * Payload for {@link AgentCancelledError}. `cancelledAt` is the\n * ISO-8601 timestamp at which the abort was observed; `reason`\n * carries the value the caller supplied to `controller.abort(reason)`\n * when present.\n */\nexport type AgentCancelledErrorOptions = AIErrorOptions & {\n  cancelledAt?: string;\n  reason?: string;\n};\n\n/**\n * Agent run was cancelled via `AbortSignal` before it could finish.\n * Between-trip cancellation is guaranteed; mid-trip cancellation is\n * best-effort (the signal is threaded into the provider adapter's\n * HTTP client when supported).\n *\n * Surfaced on `result.error` rather than thrown — `agent.execute()`\n * still returns with `report.status = \"cancelled\"` and partial trip\n * history intact. Consumers branch on the class (not the message) to\n * distinguish caller-initiated stops from other failures.\n *\n * **Why split from `AgentExecutionError`.** Cancellation is a\n * different operational signal from \"the agent crashed\" — retry\n * policy and dashboards typically want different behavior for each.\n * Keeping cancellation in its own class lets the category\n * (`\"cancelled\"`) be set declaratively per type instead of inferred\n * from a `context.cancelled === true` flag.\n *\n * @example\n * const result = await agent.execute(input, { signal });\n * if (result.error instanceof AgentCancelledError) {\n *   // caller pulled the plug — don't retry, surface a \"stopped\" UI\n *   return { status: \"cancelled\" };\n * }\n */\nexport class AgentCancelledError extends AgentExecutionError {\n  public static readonly defaultCategory: ErrorCategory = \"cancelled\";\n\n  public readonly cancelledAt?: string;\n  public readonly reason?: string;\n\n  public constructor(message: string, options?: AgentCancelledErrorOptions) {\n    super(message, options, \"AGENT_CANCELLED\");\n    this.name = \"AgentCancelledError\";\n    this.cancelledAt = options?.cancelledAt;\n    this.reason = options?.reason;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,sBAAb,cAAyC,oBAAoB;;yBACH;;CAKxD,AAAO,YAAY,SAAiB,SAAsC;EACxE,MAAM,SAAS,SAAS,iBAAiB;EACzC,KAAK,OAAO;EACZ,KAAK,cAAc,SAAS;EAC5B,KAAK,SAAS,SAAS;CACzB;AACF"}

package/esm/ai/src/errors/agent-execution-error.mjs

@@ -0,0 +1,35 @@
+import { AIError } from "./ai-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/agent-execution-error.ts
+/**
+* Base for agent runtime failures that aren't schema / tool / provider
+* problems — runtime-structural issues inside the trip loop or
+* authoring-time middleware misconfiguration. Two specialized
+* subclasses cover the two non-generic cases:
+*
+* - {@link AgentCancelledError} (`AGENT_CANCELLED`) — caller-driven
+*   abort via `AbortSignal`.
+* - {@link AgentMaxTripsError} (`AGENT_MAX_TRIPS`) — trip loop hit
+*   the `maxTrips` cap without a natural stop.
+*
+* Use the base class directly for anything else (unregistered tool
+* dispatch, authoring-time middleware validation, surprise
+* exceptions). The subclasses exist so consumers can branch on a
+* dedicated `instanceof` / category without inferring from `context`
+* flags or parsing the message.
+*
+* @example
+* if (result.error?.code === "AGENT_EXEC_FAILED") {
+*   logger.warn("unexpected agent failure", result.error.context);
+* }
+*/
+var AgentExecutionError = class extends AIError {
+	constructor(message, options, code = "AGENT_EXEC_FAILED") {
+		super(code, message, options);
+		this.name = "AgentExecutionError";
+	}
+};
+
+//#endregion
+export { AgentExecutionError };
+//# sourceMappingURL=agent-execution-error.mjs.map

package/esm/ai/src/errors/agent-execution-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-execution-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/agent-execution-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { AIErrorCode } from \"./error-code.type\";\n\n/**\n * Base for agent runtime failures that aren't schema / tool / provider\n * problems — runtime-structural issues inside the trip loop or\n * authoring-time middleware misconfiguration. Two specialized\n * subclasses cover the two non-generic cases:\n *\n * - {@link AgentCancelledError} (`AGENT_CANCELLED`) — caller-driven\n *   abort via `AbortSignal`.\n * - {@link AgentMaxTripsError} (`AGENT_MAX_TRIPS`) — trip loop hit\n *   the `maxTrips` cap without a natural stop.\n *\n * Use the base class directly for anything else (unregistered tool\n * dispatch, authoring-time middleware validation, surprise\n * exceptions). The subclasses exist so consumers can branch on a\n * dedicated `instanceof` / category without inferring from `context`\n * flags or parsing the message.\n *\n * @example\n * if (result.error?.code === \"AGENT_EXEC_FAILED\") {\n *   logger.warn(\"unexpected agent failure\", result.error.context);\n * }\n */\nexport class AgentExecutionError extends AIError {\n  public constructor(\n    message: string,\n    options?: AIErrorOptions,\n    code: AIErrorCode = \"AGENT_EXEC_FAILED\",\n  ) {\n    super(code, message, options);\n    this.name = \"AgentExecutionError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAa,sBAAb,cAAyC,QAAQ;CAC/C,AAAO,YACL,SACA,SACA,OAAoB,qBACpB;EACA,MAAM,MAAM,SAAS,OAAO;EAC5B,KAAK,OAAO;CACd;AACF"}

package/esm/ai/src/errors/agent-max-trips-error.mjs

@@ -0,0 +1,41 @@
+import { AgentExecutionError } from "./agent-execution-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/agent-max-trips-error.ts
+/**
+* Runaway-loop hard guard: the agent's trip loop ran `maxTrips` round
+* trips to the model without the model issuing a natural stop. The
+* loop terminates with this typed error on `result.error` and the
+* full trip history preserved in `result.report.trips` so consumers
+* can see where the loop got stuck.
+*
+* **Not retryable by default.** A run that hit the cap usually
+* indicates either a tool the agent can't satisfy (causing infinite
+* re-asks) or a model that won't commit to an answer. Bumping
+* `maxTrips` and retrying without root-causing the underlying issue
+* just burns more tokens.
+*
+* **Why split from `AgentExecutionError`.** The catch-all base wears
+* too many hats — cancellation vs. max-trips vs. generic crashes had
+* to be disambiguated from `context` flags or message regex. Split
+* subclasses let category dispatch (`"max-trips"`) and consumer
+* branching (`instanceof`) work without inference.
+*
+* @example
+* if (result.error instanceof AgentMaxTripsError) {
+*   logger.warn("agent hit trip cap", { max: result.error.maxTrips });
+* }
+*/
+var AgentMaxTripsError = class extends AgentExecutionError {
+	static {
+		this.defaultCategory = "max-trips";
+	}
+	constructor(message, options) {
+		super(message, options, "AGENT_MAX_TRIPS");
+		this.name = "AgentMaxTripsError";
+		this.maxTrips = options.maxTrips;
+	}
+};
+
+//#endregion
+export { AgentMaxTripsError };
+//# sourceMappingURL=agent-max-trips-error.mjs.map

package/esm/ai/src/errors/agent-max-trips-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-max-trips-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/agent-max-trips-error.ts"],"sourcesContent":["import { AgentExecutionError } from \"./agent-execution-error\";\nimport type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * Payload for {@link AgentMaxTripsError}. `maxTrips` is the cap the\n * agent hit — useful for log/metric attribution and for retry-with-\n * higher-cap recovery strategies.\n */\nexport type AgentMaxTripsErrorOptions = AIErrorOptions & {\n  maxTrips: number;\n};\n\n/**\n * Runaway-loop hard guard: the agent's trip loop ran `maxTrips` round\n * trips to the model without the model issuing a natural stop. The\n * loop terminates with this typed error on `result.error` and the\n * full trip history preserved in `result.report.trips` so consumers\n * can see where the loop got stuck.\n *\n * **Not retryable by default.** A run that hit the cap usually\n * indicates either a tool the agent can't satisfy (causing infinite\n * re-asks) or a model that won't commit to an answer. Bumping\n * `maxTrips` and retrying without root-causing the underlying issue\n * just burns more tokens.\n *\n * **Why split from `AgentExecutionError`.** The catch-all base wears\n * too many hats — cancellation vs. max-trips vs. generic crashes had\n * to be disambiguated from `context` flags or message regex. Split\n * subclasses let category dispatch (`\"max-trips\"`) and consumer\n * branching (`instanceof`) work without inference.\n *\n * @example\n * if (result.error instanceof AgentMaxTripsError) {\n *   logger.warn(\"agent hit trip cap\", { max: result.error.maxTrips });\n * }\n */\nexport class AgentMaxTripsError extends AgentExecutionError {\n  public static readonly defaultCategory: ErrorCategory = \"max-trips\";\n\n  public readonly maxTrips: number;\n\n  public constructor(message: string, options: AgentMaxTripsErrorOptions) {\n    super(message, options, \"AGENT_MAX_TRIPS\");\n    this.name = \"AgentMaxTripsError\";\n    this.maxTrips = options.maxTrips;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,qBAAb,cAAwC,oBAAoB;;yBACF;;CAIxD,AAAO,YAAY,SAAiB,SAAoC;EACtE,MAAM,SAAS,SAAS,iBAAiB;EACzC,KAAK,OAAO;EACZ,KAAK,WAAW,QAAQ;CAC1B;AACF"}

package/esm/ai/src/errors/ai-error.mjs

@@ -0,0 +1,68 @@
+//#region ../@warlock.js/ai/src/errors/ai-error.ts
+/**
+* Base class for every error thrown (or surfaced via `result.error`) by
+* `@warlock.js/ai` and its provider adapter packages.
+*
+* **Role.** The single typed error contract across the AI framework.
+* Every thrown error anywhere in `@warlock.js/ai*` is either an
+* `AIError` itself or one of its subclasses — plain `Error` must never
+* leak out. Consumers branch either on the narrow `error.code` (stable
+* string), on `error.category` (coarse dashboard grouping), or on
+* `instanceof` a specific subclass.
+*
+* **Independence.** Deliberately extends the platform `Error` directly
+* — never `HttpError` from `@warlock.js/core`. The AI framework is a
+* standalone product; coupling its error base to a web framework would
+* force every consumer to pull in the HTTP layer even when they only
+* use AI in a CLI, worker, or test.
+*
+* **Fields.**
+* - `code` — stable machine-readable identifier (see `AIErrorCode`).
+* - `category` — coarse `ErrorCategory` for dashboards / retry policy.
+*   Resolved at construction from the subclass's `static defaultCategory`
+*   (or, for direct `new AIError(...)` calls, from the explicit 4th
+*   constructor argument).
+* - `cause` — optional original thrown value (SDK error, nested error,
+*   raw value). Preserves root cause through re-wrapping.
+* - `context` — optional free-form diagnostic bag (status, requestId,
+*   headers). Consumers treat it as opaque; logs and telemetry read it.
+*
+* **Category override — direct AIError usage only.** Subclasses ARE
+* their category by type; there's no legitimate runtime override at
+* the subclass level. The 4th constructor argument exists ONLY for
+* direct `new AIError(...)` callers, who would otherwise be stuck with
+* the `"unknown"` default. Subclasses construct via `super(code,
+* message, options)` and physically cannot reach the override slot
+* through their own typed signatures.
+*
+* @example
+* try {
+*   await agent.execute("hello");
+* } catch (error) {
+*   if (error instanceof AIError) {
+*     console.error(`[${error.code}] (${error.category}) ${error.message}`);
+*   }
+* }
+*
+* @example
+* // Direct AIError construction with explicit category — escape hatch
+* // for call sites that lack a specific subclass.
+* throw new AIError("UNEXPECTED", "transient glitch", undefined, "provider");
+*/
+var AIError = class extends Error {
+	static {
+		this.defaultCategory = "unknown";
+	}
+	constructor(code, message, options, category) {
+		super(message);
+		this.name = "AIError";
+		this.code = code;
+		this.context = options?.context;
+		this.category = category ?? this.constructor.defaultCategory;
+		if (options?.cause !== void 0) this.cause = options.cause;
+	}
+};
+
+//#endregion
+export { AIError };
+//# sourceMappingURL=ai-error.mjs.map

package/esm/ai/src/errors/ai-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/ai-error.ts"],"sourcesContent":["import type { ErrorCategory } from \"./error-category.type\";\nimport type { AIErrorCode } from \"./error-code.type\";\n\n/**\n * Optional constructor payload shared by every `AIError` subclass.\n *\n * `cause` carries the original thrown value (SDK error, runtime crash,\n * validation failure) so downstream logging and debuggers can still\n * reach it. `context` is a free-form diagnostic bag for provider-raw\n * metadata (status codes, request ids, response headers) that shouldn't\n * be promoted to typed fields but is useful in logs and telemetry.\n *\n * **No `category` here.** Category is fixed per subclass via the\n * class-level `static defaultCategory`. Subclasses ARE their\n * category — `RateLimitError` is always `\"rate-limit\"`, never\n * something else at runtime. Direct `new AIError(...)` callers (the\n * one legitimate override case, since the base catch-all has no\n * specific class) receive a separate 4th constructor argument\n * instead, so the override is structurally unreachable from subclass\n * call sites.\n */\nexport type AIErrorOptions = {\n  cause?: unknown;\n  context?: Record<string, unknown>;\n};\n\n/**\n * Base class for every error thrown (or surfaced via `result.error`) by\n * `@warlock.js/ai` and its provider adapter packages.\n *\n * **Role.** The single typed error contract across the AI framework.\n * Every thrown error anywhere in `@warlock.js/ai*` is either an\n * `AIError` itself or one of its subclasses — plain `Error` must never\n * leak out. Consumers branch either on the narrow `error.code` (stable\n * string), on `error.category` (coarse dashboard grouping), or on\n * `instanceof` a specific subclass.\n *\n * **Independence.** Deliberately extends the platform `Error` directly\n * — never `HttpError` from `@warlock.js/core`. The AI framework is a\n * standalone product; coupling its error base to a web framework would\n * force every consumer to pull in the HTTP layer even when they only\n * use AI in a CLI, worker, or test.\n *\n * **Fields.**\n * - `code` — stable machine-readable identifier (see `AIErrorCode`).\n * - `category` — coarse `ErrorCategory` for dashboards / retry policy.\n *   Resolved at construction from the subclass's `static defaultCategory`\n *   (or, for direct `new AIError(...)` calls, from the explicit 4th\n *   constructor argument).\n * - `cause` — optional original thrown value (SDK error, nested error,\n *   raw value). Preserves root cause through re-wrapping.\n * - `context` — optional free-form diagnostic bag (status, requestId,\n *   headers). Consumers treat it as opaque; logs and telemetry read it.\n *\n * **Category override — direct AIError usage only.** Subclasses ARE\n * their category by type; there's no legitimate runtime override at\n * the subclass level. The 4th constructor argument exists ONLY for\n * direct `new AIError(...)` callers, who would otherwise be stuck with\n * the `\"unknown\"` default. Subclasses construct via `super(code,\n * message, options)` and physically cannot reach the override slot\n * through their own typed signatures.\n *\n * @example\n * try {\n *   await agent.execute(\"hello\");\n * } catch (error) {\n *   if (error instanceof AIError) {\n *     console.error(`[${error.code}] (${error.category}) ${error.message}`);\n *   }\n * }\n *\n * @example\n * // Direct AIError construction with explicit category — escape hatch\n * // for call sites that lack a specific subclass.\n * throw new AIError(\"UNEXPECTED\", \"transient glitch\", undefined, \"provider\");\n */\nexport class AIError extends Error {\n  /**\n   * Class-level category for every instance of this error type.\n   * Subclasses redeclare with their own concrete `ErrorCategory` so\n   * `error.category` is correct without per-call wiring. The base\n   * class keeps `\"unknown\"` so untyped direct throws of `AIError`\n   * itself remain honest about their lack of dispatch information\n   * (and can override via the 4th constructor argument).\n   */\n  public static readonly defaultCategory: ErrorCategory = \"unknown\";\n\n  public readonly code: AIErrorCode;\n  public readonly category: ErrorCategory;\n  public readonly context?: Record<string, unknown>;\n\n  public constructor(\n    code: AIErrorCode,\n    message: string,\n    options?: AIErrorOptions,\n    category?: ErrorCategory,\n  ) {\n    super(message);\n\n    this.name = \"AIError\";\n    this.code = code;\n    this.context = options?.context;\n    this.category = category ?? (this.constructor as typeof AIError).defaultCategory;\n\n    if (options?.cause !== undefined) {\n      (this as { cause?: unknown }).cause = options.cause;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EA,IAAa,UAAb,cAA6B,MAAM;;yBASuB;;CAMxD,AAAO,YACL,MACA,SACA,SACA,UACA;EACA,MAAM,OAAO;EAEb,KAAK,OAAO;EACZ,KAAK,OAAO;EACZ,KAAK,UAAU,SAAS;EACxB,KAAK,WAAW,YAAa,KAAK,YAA+B;EAEjE,IAAI,SAAS,UAAU,QACrB,AAAC,KAA6B,QAAQ,QAAQ;CAElD;AACF"}

package/esm/ai/src/errors/budget-exceeded-error.mjs

@@ -0,0 +1,31 @@
+import { AIError } from "./ai-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/budget-exceeded-error.ts
+/**
+* A user- or framework-configured budget was exceeded mid-execution.
+*
+* **Not thrown yet.** The class is defined here so v2's budget
+* middleware can throw it without a breaking release of the error
+* hierarchy. Shape is locked: `{ limit, actual, unit }`.
+*
+* @example
+* if (error instanceof BudgetExceededError && error.unit === "usd") {
+*   alertFinance(error.actual, error.limit);
+* }
+*/
+var BudgetExceededError = class extends AIError {
+	static {
+		this.defaultCategory = "budget";
+	}
+	constructor(message, options) {
+		super("BUDGET_EXCEEDED", message, options);
+		this.name = "BudgetExceededError";
+		this.limit = options.limit;
+		this.actual = options.actual;
+		this.unit = options.unit;
+	}
+};
+
+//#endregion
+export { BudgetExceededError };
+//# sourceMappingURL=budget-exceeded-error.mjs.map

package/esm/ai/src/errors/budget-exceeded-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget-exceeded-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/budget-exceeded-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * Unit of the budget being enforced. `tokens` for context/output\n * caps, `usd` for monetary caps, `requests` for call-count caps.\n */\nexport type BudgetUnit = \"tokens\" | \"usd\" | \"requests\";\n\n/**\n * Payload for `BudgetExceededError`. All three fields are required so\n * consumers can present the breach numerically without having to\n * reparse the message.\n */\nexport type BudgetExceededErrorOptions = AIErrorOptions & {\n  limit: number;\n  actual: number;\n  unit: BudgetUnit;\n};\n\n/**\n * A user- or framework-configured budget was exceeded mid-execution.\n *\n * **Not thrown yet.** The class is defined here so v2's budget\n * middleware can throw it without a breaking release of the error\n * hierarchy. Shape is locked: `{ limit, actual, unit }`.\n *\n * @example\n * if (error instanceof BudgetExceededError && error.unit === \"usd\") {\n *   alertFinance(error.actual, error.limit);\n * }\n */\nexport class BudgetExceededError extends AIError {\n  public static readonly defaultCategory: ErrorCategory = \"budget\";\n\n  public readonly limit: number;\n  public readonly actual: number;\n  public readonly unit: BudgetUnit;\n\n  public constructor(message: string, options: BudgetExceededErrorOptions) {\n    super(\"BUDGET_EXCEEDED\", message, options);\n    this.name = \"BudgetExceededError\";\n    this.limit = options.limit;\n    this.actual = options.actual;\n    this.unit = options.unit;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgCA,IAAa,sBAAb,cAAyC,QAAQ;;yBACS;;CAMxD,AAAO,YAAY,SAAiB,SAAqC;EACvE,MAAM,mBAAmB,SAAS,OAAO;EACzC,KAAK,OAAO;EACZ,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,OAAO,QAAQ;CACtB;AACF"}

package/esm/ai/src/errors/content-filter-error.mjs

@@ -0,0 +1,28 @@
+import { ProviderError } from "./provider-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/content-filter-error.ts
+/**
+* Response (or request) was blocked by the provider's safety filter.
+* Not retryable with the same input — reshape the prompt or lean on
+* a less-restrictive model.
+*
+* @example
+* if (result.error instanceof ContentFilterError) {
+*   return respondWithPolicyMessage(result.error.reason);
+* }
+*/
+var ContentFilterError = class extends ProviderError {
+	static {
+		this.defaultCategory = "content-filter";
+	}
+	constructor(message, options) {
+		super(message, options, "CONTENT_FILTER");
+		this.name = "ContentFilterError";
+		this.reason = options?.reason;
+		this.categories = options?.categories;
+	}
+};
+
+//#endregion
+export {  };
+//# sourceMappingURL=content-filter-error.mjs.map

package/esm/ai/src/errors/content-filter-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-filter-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/content-filter-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { ProviderError } from \"./provider-error\";\n\n/**\n * Payload for `ContentFilterError`. Both fields optional — providers\n * don't consistently disclose the specific filter reason or\n * categories, especially when the block is pre-generation.\n */\nexport type ContentFilterErrorOptions = AIErrorOptions & {\n  reason?: string;\n  categories?: string[];\n};\n\n/**\n * Response (or request) was blocked by the provider's safety filter.\n * Not retryable with the same input — reshape the prompt or lean on\n * a less-restrictive model.\n *\n * @example\n * if (result.error instanceof ContentFilterError) {\n *   return respondWithPolicyMessage(result.error.reason);\n * }\n */\nexport class ContentFilterError extends ProviderError {\n  public static readonly defaultCategory: ErrorCategory = \"content-filter\";\n\n  public readonly reason?: string;\n  public readonly categories?: string[];\n\n  public constructor(message: string, options?: ContentFilterErrorOptions) {\n    super(message, options, \"CONTENT_FILTER\");\n    this.name = \"ContentFilterError\";\n    this.reason = options?.reason;\n    this.categories = options?.categories;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAwBA,IAAa,qBAAb,cAAwC,cAAc;;yBACI;;CAKxD,AAAO,YAAY,SAAiB,SAAqC;EACvE,MAAM,SAAS,SAAS,gBAAgB;EACxC,KAAK,OAAO;EACZ,KAAK,SAAS,SAAS;EACvB,KAAK,aAAa,SAAS;CAC7B;AACF"}

package/esm/ai/src/errors/context-length-exceeded-error.mjs

@@ -0,0 +1,31 @@
+import { ProviderError } from "./provider-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/context-length-exceeded-error.ts
+/**
+* The request's prompt (messages + tools + schema) exceeded the
+* model's context window. Not retryable without shortening the input.
+*
+* Typically surfaced as OpenAI 400 with `code: "context_length_exceeded"`.
+*
+* @example
+* if (result.error instanceof ContextLengthExceededError) {
+*   messages = truncateOldestTurns(messages);
+*   return agent.execute(input, { history: messages });
+* }
+*/
+var ContextLengthExceededError = class extends ProviderError {
+	static {
+		this.defaultCategory = "context-length";
+	}
+	constructor(message, options) {
+		super(message, options, "CONTEXT_LENGTH_EXCEEDED");
+		this.name = "ContextLengthExceededError";
+		this.limit = options?.limit;
+		this.actual = options?.actual;
+		this.modelName = options?.modelName;
+	}
+};
+
+//#endregion
+export {  };
+//# sourceMappingURL=context-length-exceeded-error.mjs.map

package/esm/ai/src/errors/context-length-exceeded-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-length-exceeded-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/context-length-exceeded-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { ProviderError } from \"./provider-error\";\n\n/**\n * Payload for `ContextLengthExceededError`. All fields are optional —\n * providers inconsistently surface exact token counts and the\n * model's limit. When present, they let callers compute a trim\n * target; when absent, the error still categorizes the failure.\n */\nexport type ContextLengthExceededErrorOptions = AIErrorOptions & {\n  limit?: number;\n  actual?: number;\n  modelName?: string;\n};\n\n/**\n * The request's prompt (messages + tools + schema) exceeded the\n * model's context window. Not retryable without shortening the input.\n *\n * Typically surfaced as OpenAI 400 with `code: \"context_length_exceeded\"`.\n *\n * @example\n * if (result.error instanceof ContextLengthExceededError) {\n *   messages = truncateOldestTurns(messages);\n *   return agent.execute(input, { history: messages });\n * }\n */\nexport class ContextLengthExceededError extends ProviderError {\n  public static readonly defaultCategory: ErrorCategory = \"context-length\";\n\n  public readonly limit?: number;\n  public readonly actual?: number;\n  public readonly modelName?: string;\n\n  public constructor(\n    message: string,\n    options?: ContextLengthExceededErrorOptions,\n  ) {\n    super(message, options, \"CONTEXT_LENGTH_EXCEEDED\");\n    this.name = \"ContextLengthExceededError\";\n    this.limit = options?.limit;\n    this.actual = options?.actual;\n    this.modelName = options?.modelName;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AA4BA,IAAa,6BAAb,cAAgD,cAAc;;yBACJ;;CAMxD,AAAO,YACL,SACA,SACA;EACA,MAAM,SAAS,SAAS,yBAAyB;EACjD,KAAK,OAAO;EACZ,KAAK,QAAQ,SAAS;EACtB,KAAK,SAAS,SAAS;EACvB,KAAK,YAAY,SAAS;CAC5B;AACF"}

package/esm/ai/src/errors/guardrail-violation-error.mjs

@@ -0,0 +1,41 @@
+import { AIError } from "./ai-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/guardrail-violation-error.ts
+/**
+* A guardrail middleware rejected the prompt or response mid-execution.
+*
+* **Role.** The typed abort surface for `ai.middleware.guardrail`.
+* Consumers branch on `error.phase` to distinguish "the user asked
+* something disallowed" (`"input"`) from "the model produced something
+* disallowed" (`"output"`) — the two failure modes have very different
+* product responses (block vs. retry, or surface a policy message vs.
+* re-prompt the model).
+*
+* Thrown from inside the middleware pipeline's `trip.before` / `trip.after`
+* hooks; surfaced to the caller via `result.error` like every other
+* `AIError`.
+*
+* @example
+* if (result.error instanceof GuardrailViolationError) {
+*   if (result.error.phase === "input") {
+*     return respondWithPolicyMessage(result.error.reason);
+*   }
+*   return retryWithSanitizedPrompt();
+* }
+*/
+var GuardrailViolationError = class extends AIError {
+	static {
+		this.defaultCategory = "guardrail";
+	}
+	constructor(message, options) {
+		super("GUARDRAIL_VIOLATION", message, options);
+		this.name = "GuardrailViolationError";
+		this.phase = options.phase;
+		this.reason = options.reason;
+		this.guardrail = options.guardrail;
+	}
+};
+
+//#endregion
+export { GuardrailViolationError };
+//# sourceMappingURL=guardrail-violation-error.mjs.map

package/esm/ai/src/errors/guardrail-violation-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"guardrail-violation-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/guardrail-violation-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * Phase at which a guardrail rejected the content — `\"input\"` when the\n * violation was detected on the outbound prompt (before the model saw\n * it), `\"output\"` when it was detected on the model's response (before\n * the caller saw it).\n */\nexport type GuardrailPhase = \"input\" | \"output\";\n\n/**\n * Payload for `GuardrailViolationError`. `phase` tells the caller\n * whether the prompt or the response tripped the check; `reason` is\n * the free-form explanation the guardrail middleware produced;\n * `guardrail` names the offending middleware so operators can tune a\n * specific rule without hunting through logs.\n */\nexport type GuardrailViolationErrorOptions = AIErrorOptions & {\n  phase: GuardrailPhase;\n  reason: string;\n  guardrail?: string;\n};\n\n/**\n * A guardrail middleware rejected the prompt or response mid-execution.\n *\n * **Role.** The typed abort surface for `ai.middleware.guardrail`.\n * Consumers branch on `error.phase` to distinguish \"the user asked\n * something disallowed\" (`\"input\"`) from \"the model produced something\n * disallowed\" (`\"output\"`) — the two failure modes have very different\n * product responses (block vs. retry, or surface a policy message vs.\n * re-prompt the model).\n *\n * Thrown from inside the middleware pipeline's `trip.before` / `trip.after`\n * hooks; surfaced to the caller via `result.error` like every other\n * `AIError`.\n *\n * @example\n * if (result.error instanceof GuardrailViolationError) {\n *   if (result.error.phase === \"input\") {\n *     return respondWithPolicyMessage(result.error.reason);\n *   }\n *   return retryWithSanitizedPrompt();\n * }\n */\nexport class GuardrailViolationError extends AIError {\n  public static readonly defaultCategory: ErrorCategory = \"guardrail\";\n\n  public readonly phase: GuardrailPhase;\n  public readonly reason: string;\n  public readonly guardrail?: string;\n\n  public constructor(message: string, options: GuardrailViolationErrorOptions) {\n    super(\"GUARDRAIL_VIOLATION\", message, options);\n\n    this.name = \"GuardrailViolationError\";\n    this.phase = options.phase;\n    this.reason = options.reason;\n    this.guardrail = options.guardrail;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,IAAa,0BAAb,cAA6C,QAAQ;;yBACK;;CAMxD,AAAO,YAAY,SAAiB,SAAyC;EAC3E,MAAM,uBAAuB,SAAS,OAAO;EAE7C,KAAK,OAAO;EACZ,KAAK,QAAQ,QAAQ;EACrB,KAAK,SAAS,QAAQ;EACtB,KAAK,YAAY,QAAQ;CAC3B;AACF"}

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

@@ -0,0 +1,37 @@
+import { AIError } from "./ai-error.mjs";
+import { AgentExecutionError } from "./agent-execution-error.mjs";
+import { AgentCancelledError } from "./agent-cancelled-error.mjs";
+import { AgentMaxTripsError } from "./agent-max-trips-error.mjs";
+import { BudgetExceededError } from "./budget-exceeded-error.mjs";
+import { ProviderError } from "./provider-error.mjs";
+import "./content-filter-error.mjs";
+import "./context-length-exceeded-error.mjs";
+import { GuardrailViolationError } from "./guardrail-violation-error.mjs";
+import { InvalidRequestError } from "./invalid-request-error.mjs";
+import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
+import { MaxIterationsError } from "./max-iterations-error.mjs";
+import { WorkflowError } from "./workflow-error.mjs";
+import { MaxStepsExceededError } from "./max-steps-exceeded-error.mjs";
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+import "./orchestrator-cancelled-error.mjs";
+import { OrchestratorConfigError } from "./orchestrator-config-error.mjs";
+import { OrchestratorDriftError } from "./orchestrator-drift-error.mjs";
+import { OutboundPolicyError } from "./outbound-policy-error.mjs";
+import { PlannerFailedError } from "./planner-failed-error.mjs";
+import { PlannerCancelledError } from "./planner-cancelled-error.mjs";
+import { PlannerPlanInvalidError } from "./planner-plan-invalid-error.mjs";
+import "./provider-auth-error.mjs";
+import "./provider-rate-limit-error.mjs";
+import "./provider-timeout-error.mjs";
+import "./quota-exceeded-error.mjs";
+import { RoutingError } from "./routing-error.mjs";
+import { SchemaValidationError } from "./schema-validation-error.mjs";
+import { StepFailedError } from "./step-failed-error.mjs";
+import { SupervisorCancelledError } from "./supervisor-cancelled-error.mjs";
+import { SupervisorDriftError } from "./supervisor-drift-error.mjs";
+import { SupervisorRoutingError } from "./supervisor-routing-error.mjs";
+import { ToolExecutionError } from "./tool-execution-error.mjs";
+import { WorkflowCancelledError } from "./workflow-cancelled-error.mjs";
+import { WorkflowDriftError } from "./workflow-drift-error.mjs";
+
+export {  };

package/esm/ai/src/errors/invalid-request-error.mjs

@@ -0,0 +1,31 @@
+import { ProviderError } from "./provider-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/invalid-request-error.ts
+/**
+* Provider rejected the request as malformed — bad model name,
+* unsupported feature, missing required field, image attached to a
+* non-vision model, etc. The catch-all for 4xx responses that aren't
+* auth, rate-limit, context-length, or content-filter.
+*
+* Also thrown from the agent when user-side validation fails at the
+* boundary (e.g. vision gate, malformed attachment shape) — the
+* category is "you sent something the provider / agent cannot use".
+*
+* @example
+* if (result.error instanceof InvalidRequestError) {
+*   logger.error("bad agent input", { context: result.error.context });
+* }
+*/
+var InvalidRequestError = class extends ProviderError {
+	static {
+		this.defaultCategory = "validation";
+	}
+	constructor(message, options) {
+		super(message, options, "PROVIDER_INVALID_REQUEST");
+		this.name = "InvalidRequestError";
+	}
+};
+
+//#endregion
+export { InvalidRequestError };
+//# sourceMappingURL=invalid-request-error.mjs.map

package/esm/ai/src/errors/invalid-request-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-request-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/invalid-request-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { ProviderError } from \"./provider-error\";\n\n/**\n * Provider rejected the request as malformed — bad model name,\n * unsupported feature, missing required field, image attached to a\n * non-vision model, etc. The catch-all for 4xx responses that aren't\n * auth, rate-limit, context-length, or content-filter.\n *\n * Also thrown from the agent when user-side validation fails at the\n * boundary (e.g. vision gate, malformed attachment shape) — the\n * category is \"you sent something the provider / agent cannot use\".\n *\n * @example\n * if (result.error instanceof InvalidRequestError) {\n *   logger.error(\"bad agent input\", { context: result.error.context });\n * }\n */\nexport class InvalidRequestError extends ProviderError {\n  public static readonly defaultCategory: ErrorCategory = \"validation\";\n\n  public constructor(message: string, options?: AIErrorOptions) {\n    super(message, options, \"PROVIDER_INVALID_REQUEST\");\n    this.name = \"InvalidRequestError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAa,sBAAb,cAAyC,cAAc;;yBACG;;CAExD,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MAAM,SAAS,SAAS,0BAA0B;EAClD,KAAK,OAAO;CACd;AACF"}

package/esm/ai/src/errors/max-iterations-error.mjs

@@ -0,0 +1,32 @@
+import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/max-iterations-error.ts
+/**
+* Hard-cap guard: the supervisor ran `maxIterations` loop turns
+* without reaching a terminal decision (`END`, `satisfied: true`, or
+* cancellation). Terminates the run immediately with a typed error on
+* `result.error` — partial per-iteration snapshots are still
+* available on `result.report.snapshots`.
+*
+* @example
+* const { error, report } = await supervisor.execute(input);
+* if (error?.code === "SUPERVISOR_MAX_ITERATIONS") {
+*   logger.warn("supervisor did not converge", {
+*     iterations: report.iterations,
+*   });
+* }
+*/
+var MaxIterationsError = class extends SupervisorFailedError {
+	static {
+		this.defaultCategory = "max-iterations";
+	}
+	constructor(message, options) {
+		super(message, options, "SUPERVISOR_MAX_ITERATIONS");
+		this.name = "MaxIterationsError";
+		this.maxIterations = options.maxIterations;
+	}
+};
+
+//#endregion
+export { MaxIterationsError };
+//# sourceMappingURL=max-iterations-error.mjs.map