@warlock.js/core 4.7.0 → 4.8.1

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

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

@@ -1,43 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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-drift-error.mjs

@@ -1,31 +0,0 @@
-import { AgentExecutionError } from "./agent-execution-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/agent-drift-error.ts
-/**
-* `agent.resume(runId)` loaded a durable snapshot whose structural
-* fingerprint does not match the current agent definition (model +
-* provider + sorted tool names + maxTrips + output presence + version).
-* The resume is refused — no trip runs — and the user decides how to
-* recover: discard the snapshot, migrate manually, or call
-* `resume(runId, { force: true })` to bypass the check.
-*
-* Mirrors `SupervisorDriftError` / `WorkflowDriftError` — same rationale,
-* different primitive. Thrown (not returned on `result.error`) because a
-* drifted resume never produces a valid run.
-*/
-var AgentDriftError = class extends AgentExecutionError {
-	static {
-		this.defaultCategory = "drift";
-	}
-	constructor(message, options) {
-		super(message, options, "AGENT_DRIFT");
-		this.name = "AgentDriftError";
-		this.savedSignature = options.savedSignature;
-		this.currentSignature = options.currentSignature;
-		this.runId = options.runId;
-	}
-};
-
-//#endregion
-export { AgentDriftError };
-//# sourceMappingURL=agent-drift-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"agent-drift-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/agent-drift-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport { AgentExecutionError } from \"./agent-execution-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\nexport type AgentDriftErrorOptions = AIErrorOptions & {\n  /** Signature recorded on the snapshot being resumed. */\n  savedSignature: string;\n  /** Signature computed from the current agent definition. */\n  currentSignature: string;\n  runId: string;\n};\n\n/**\n * `agent.resume(runId)` loaded a durable snapshot whose structural\n * fingerprint does not match the current agent definition (model +\n * provider + sorted tool names + maxTrips + output presence + version).\n * The resume is refused — no trip runs — and the user decides how to\n * recover: discard the snapshot, migrate manually, or call\n * `resume(runId, { force: true })` to bypass the check.\n *\n * Mirrors `SupervisorDriftError` / `WorkflowDriftError` — same rationale,\n * different primitive. Thrown (not returned on `result.error`) because a\n * drifted resume never produces a valid run.\n */\nexport class AgentDriftError extends AgentExecutionError {\n  public static readonly defaultCategory: ErrorCategory = \"drift\";\n\n  public readonly savedSignature: string;\n  public readonly currentSignature: string;\n  public readonly runId: string;\n\n  public constructor(message: string, options: AgentDriftErrorOptions) {\n    super(message, options, \"AGENT_DRIFT\");\n    this.name = \"AgentDriftError\";\n    this.savedSignature = options.savedSignature;\n    this.currentSignature = options.currentSignature;\n    this.runId = options.runId;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAwBA,IAAa,kBAAb,cAAqC,oBAAoB;;yBACC;;CAMxD,AAAO,YAAY,SAAiB,SAAiC;EACnE,MAAM,SAAS,SAAS,aAAa;EACrC,KAAK,OAAO;EACZ,KAAK,iBAAiB,QAAQ;EAC9B,KAAK,mBAAmB,QAAQ;EAChC,KAAK,QAAQ,QAAQ;CACvB;AACF"}

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

@@ -1,35 +0,0 @@
-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

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

@@ -1,41 +0,0 @@
-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

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

@@ -1,68 +0,0 @@
-//#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

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

@@ -1,31 +0,0 @@
-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

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

@@ -1,28 +0,0 @@
-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

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

@@ -1,31 +0,0 @@
-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

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

@@ -1,41 +0,0 @@
-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

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

@@ -1,40 +0,0 @@
-import { AIError } from "./ai-error.mjs";
-import { AgentExecutionError } from "./agent-execution-error.mjs";
-import { AgentCancelledError } from "./agent-cancelled-error.mjs";
-import { AgentDriftError } from "./agent-drift-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 { PlannerDriftError } from "./planner-drift-error.mjs";
-import { PlannerPlanInvalidError } from "./planner-plan-invalid-error.mjs";
-import { PromptRefinementError } from "./prompt-refinement-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

@@ -1,31 +0,0 @@
-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

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

@@ -1,32 +0,0 @@
-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

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

@@ -1 +0,0 @@
-{"version":3,"file":"max-iterations-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/max-iterations-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { SupervisorFailedError } from \"./supervisor-failed-error\";\n\nexport type MaxIterationsErrorOptions = AIErrorOptions & {\n  maxIterations: number;\n};\n\n/**\n * Hard-cap guard: the supervisor ran `maxIterations` loop turns\n * without reaching a terminal decision (`END`, `satisfied: true`, or\n * cancellation). Terminates the run immediately with a typed error on\n * `result.error` — partial per-iteration snapshots are still\n * available on `result.report.snapshots`.\n *\n * @example\n * const { error, report } = await supervisor.execute(input);\n * if (error?.code === \"SUPERVISOR_MAX_ITERATIONS\") {\n *   logger.warn(\"supervisor did not converge\", {\n *     iterations: report.iterations,\n *   });\n * }\n */\nexport class MaxIterationsError extends SupervisorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"max-iterations\";\n\n  public readonly maxIterations: number;\n\n  public constructor(message: string, options: MaxIterationsErrorOptions) {\n    super(message, options, \"SUPERVISOR_MAX_ITERATIONS\");\n    this.name = \"MaxIterationsError\";\n    this.maxIterations = options.maxIterations;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAuBA,IAAa,qBAAb,cAAwC,sBAAsB;;yBACJ;;CAIxD,AAAO,YAAY,SAAiB,SAAoC;EACtE,MAAM,SAAS,SAAS,2BAA2B;EACnD,KAAK,OAAO;EACZ,KAAK,gBAAgB,QAAQ;CAC/B;AACF"}

package/esm/ai/src/errors/max-steps-exceeded-error.mjs

@@ -1,21 +0,0 @@
-import { WorkflowError } from "./workflow-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/max-steps-exceeded-error.ts
-/**
-* Runaway-loop hard guard: workflow executed more step transitions
-* than `maxSteps` allows. Terminates the workflow immediately.
-*/
-var MaxStepsExceededError = class extends WorkflowError {
-	static {
-		this.defaultCategory = "max-steps";
-	}
-	constructor(message, options) {
-		super(message, options, "WORKFLOW_MAX_STEPS");
-		this.name = "MaxStepsExceededError";
-		this.maxSteps = options.maxSteps;
-	}
-};
-
-//#endregion
-export { MaxStepsExceededError };
-//# sourceMappingURL=max-steps-exceeded-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"max-steps-exceeded-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/max-steps-exceeded-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { WorkflowError } from \"./workflow-error\";\n\nexport type MaxStepsExceededErrorOptions = AIErrorOptions & {\n  maxSteps: number;\n};\n\n/**\n * Runaway-loop hard guard: workflow executed more step transitions\n * than `maxSteps` allows. Terminates the workflow immediately.\n */\nexport class MaxStepsExceededError extends WorkflowError {\n  public static readonly defaultCategory: ErrorCategory = \"max-steps\";\n\n  public readonly maxSteps: number;\n\n  public constructor(message: string, options: MaxStepsExceededErrorOptions) {\n    super(message, options, \"WORKFLOW_MAX_STEPS\");\n    this.name = \"MaxStepsExceededError\";\n    this.maxSteps = options.maxSteps;\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,wBAAb,cAA2C,cAAc;;yBACC;;CAIxD,AAAO,YAAY,SAAiB,SAAuC;EACzE,MAAM,SAAS,SAAS,oBAAoB;EAC5C,KAAK,OAAO;EACZ,KAAK,WAAW,QAAQ;CAC1B;AACF"}

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

@@ -1,31 +0,0 @@
-import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/orchestrator-cancelled-error.ts
-/**
-* A turn was cancelled via `AbortSignal` before it could settle
-* (orchestrator.md §17 — "mid-turn cancel"). The orchestrator returns
-* normally with `report.status: "cancelled"` and the error placed on
-* `result.error` rather than thrown; session state reverts to the
-* pre-turn checkpoint (the orchestrator does not persist a fresh row
-* for a cancelled turn — Q10).
-*
-* Mirrors `SupervisorCancelledError`, orchestrator scope. When an
-* `iterate: true` turn is cancelled mid-iteration, the underlying
-* `SupervisorCancelledError` rides on `cause`.
-*/
-var OrchestratorCancelledError = class extends OrchestratorFailedError {
-	static {
-		this.defaultCategory = "cancelled";
-	}
-	constructor(message, options) {
-		super(message, options, "ORCHESTRATOR_CANCELLED");
-		this.name = "OrchestratorCancelledError";
-		this.cancelledAt = options.cancelledAt;
-		this.sessionId = options.sessionId;
-		this.reason = options.reason;
-	}
-};
-
-//#endregion
-export {  };
-//# sourceMappingURL=orchestrator-cancelled-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrator-cancelled-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/orchestrator-cancelled-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { OrchestratorFailedError } from \"./orchestrator-failed-error\";\n\nexport type OrchestratorCancelledErrorOptions = AIErrorOptions & {\n  /** ISO-8601 timestamp at which the abort was observed by the orchestrator. */\n  cancelledAt: string;\n  /** The session whose turn was cancelled. */\n  sessionId: string;\n  /** `controller.abort(reason)` payload when the caller supplied one. */\n  reason?: string;\n};\n\n/**\n * A turn was cancelled via `AbortSignal` before it could settle\n * (orchestrator.md §17 — \"mid-turn cancel\"). The orchestrator returns\n * normally with `report.status: \"cancelled\"` and the error placed on\n * `result.error` rather than thrown; session state reverts to the\n * pre-turn checkpoint (the orchestrator does not persist a fresh row\n * for a cancelled turn — Q10).\n *\n * Mirrors `SupervisorCancelledError`, orchestrator scope. When an\n * `iterate: true` turn is cancelled mid-iteration, the underlying\n * `SupervisorCancelledError` rides on `cause`.\n */\nexport class OrchestratorCancelledError extends OrchestratorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"cancelled\";\n\n  public readonly cancelledAt: string;\n  public readonly sessionId: string;\n  public readonly reason?: string;\n\n  public constructor(\n    message: string,\n    options: OrchestratorCancelledErrorOptions,\n  ) {\n    super(message, options, \"ORCHESTRATOR_CANCELLED\");\n    this.name = \"OrchestratorCancelledError\";\n    this.cancelledAt = options.cancelledAt;\n    this.sessionId = options.sessionId;\n    this.reason = options.reason;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAyBA,IAAa,6BAAb,cAAgD,wBAAwB;;yBACd;;CAMxD,AAAO,YACL,SACA,SACA;EACA,MAAM,SAAS,SAAS,wBAAwB;EAChD,KAAK,OAAO;EACZ,KAAK,cAAc,QAAQ;EAC3B,KAAK,YAAY,QAAQ;EACzB,KAAK,SAAS,QAAQ;CACxB;AACF"}