@warlock.js/core 4.8.0 → 4.8.2

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

@@ -1,30 +0,0 @@
-import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/orchestrator-config-error.ts
-/**
-* Authoring-time misconfiguration of `ai.orchestrator(config)`
-* (orchestrator.md §17). Thrown synchronously at construction — never
-* surfaced via `result.error` — so a bad definition fails fast at boot
-* rather than on the first turn.
-*
-* Examples (§17): `iterate: true` with no `snapshotStore` (or
-* `ai.config({ defaultSnapshotStore })`); no resolvable
-* `checkpointStore`; both `route` and `router` configured;
-* `initialAgent` that is not a key in `intents`.
-*
-* Mirrors the `authoring: true` context tag the supervisor factory
-* stamps on its construction-time failures.
-*/
-var OrchestratorConfigError = class extends OrchestratorFailedError {
-	static {
-		this.defaultCategory = "validation";
-	}
-	constructor(message, options) {
-		super(message, options, "ORCHESTRATOR_CONFIG");
-		this.name = "OrchestratorConfigError";
-	}
-};
-
-//#endregion
-export { OrchestratorConfigError };
-//# sourceMappingURL=orchestrator-config-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrator-config-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/orchestrator-config-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { OrchestratorFailedError } from \"./orchestrator-failed-error\";\n\n/**\n * Authoring-time misconfiguration of `ai.orchestrator(config)`\n * (orchestrator.md §17). Thrown synchronously at construction — never\n * surfaced via `result.error` — so a bad definition fails fast at boot\n * rather than on the first turn.\n *\n * Examples (§17): `iterate: true` with no `snapshotStore` (or\n * `ai.config({ defaultSnapshotStore })`); no resolvable\n * `checkpointStore`; both `route` and `router` configured;\n * `initialAgent` that is not a key in `intents`.\n *\n * Mirrors the `authoring: true` context tag the supervisor factory\n * stamps on its construction-time failures.\n */\nexport class OrchestratorConfigError extends OrchestratorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"validation\";\n\n  public constructor(message: string, options?: AIErrorOptions) {\n    super(message, options, \"ORCHESTRATOR_CONFIG\");\n    this.name = \"OrchestratorConfigError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,IAAa,0BAAb,cAA6C,wBAAwB;;yBACX;;CAExD,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MAAM,SAAS,SAAS,qBAAqB;EAC7C,KAAK,OAAO;CACd;AACF"}

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

@@ -1,37 +0,0 @@
-import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/orchestrator-drift-error.ts
-/**
-* Phase 2 drift guard (orchestrator.md §3 / §10). `execute()` or
-* `resume()` loaded a checkpoint whose structural fingerprint does not
-* match the current orchestrator definition (name + intents map +
-* route/router presence + evaluate presence + initialAgent +
-* maxIterations + iterate flag + historyWindow shape — §10.1).
-*
-* The turn is refused synchronously — nothing dispatches — and the dev
-* decides how to recover: discard the session, migrate the persisted
-* state, or pass `{ force: true }` to accept the new signature on the
-* next persisted checkpoint.
-*
-* Mirrors `SupervisorDriftError` / `WorkflowDriftError` — same
-* rationale, orchestrator scope. The orchestrator signature does NOT
-* aggregate the internal supervisor's signature (§10.1); internal-
-* supervisor drift surfaces only on `iterate: true` resume via the
-* supervisor's own drift check.
-*/
-var OrchestratorDriftError = class extends OrchestratorFailedError {
-	static {
-		this.defaultCategory = "drift";
-	}
-	constructor(message, options) {
-		super(message, options, "ORCHESTRATOR_DRIFT");
-		this.name = "OrchestratorDriftError";
-		this.savedSignature = options.savedSignature;
-		this.currentSignature = options.currentSignature;
-		this.sessionId = options.sessionId;
-	}
-};
-
-//#endregion
-export { OrchestratorDriftError };
-//# sourceMappingURL=orchestrator-drift-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrator-drift-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/orchestrator-drift-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 OrchestratorDriftErrorOptions = AIErrorOptions & {\n  /** Signature recorded on the loaded checkpoint. */\n  savedSignature: string;\n  /** Signature computed from the current orchestrator definition. */\n  currentSignature: string;\n  /** The session whose checkpoint drifted. */\n  sessionId: string;\n};\n\n/**\n * Phase 2 drift guard (orchestrator.md §3 / §10). `execute()` or\n * `resume()` loaded a checkpoint whose structural fingerprint does not\n * match the current orchestrator definition (name + intents map +\n * route/router presence + evaluate presence + initialAgent +\n * maxIterations + iterate flag + historyWindow shape — §10.1).\n *\n * The turn is refused synchronously — nothing dispatches — and the dev\n * decides how to recover: discard the session, migrate the persisted\n * state, or pass `{ force: true }` to accept the new signature on the\n * next persisted checkpoint.\n *\n * Mirrors `SupervisorDriftError` / `WorkflowDriftError` — same\n * rationale, orchestrator scope. The orchestrator signature does NOT\n * aggregate the internal supervisor's signature (§10.1); internal-\n * supervisor drift surfaces only on `iterate: true` resume via the\n * supervisor's own drift check.\n */\nexport class OrchestratorDriftError extends OrchestratorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"drift\";\n\n  public readonly savedSignature: string;\n  public readonly currentSignature: string;\n  public readonly sessionId: string;\n\n  public constructor(message: string, options: OrchestratorDriftErrorOptions) {\n    super(message, options, \"ORCHESTRATOR_DRIFT\");\n    this.name = \"OrchestratorDriftError\";\n    this.savedSignature = options.savedSignature;\n    this.currentSignature = options.currentSignature;\n    this.sessionId = options.sessionId;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,yBAAb,cAA4C,wBAAwB;;yBACV;;CAMxD,AAAO,YAAY,SAAiB,SAAwC;EAC1E,MAAM,SAAS,SAAS,oBAAoB;EAC5C,KAAK,OAAO;EACZ,KAAK,iBAAiB,QAAQ;EAC9B,KAAK,mBAAmB,QAAQ;EAChC,KAAK,YAAY,QAAQ;CAC3B;AACF"}

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

@@ -1,36 +0,0 @@
-import { AIError } from "./ai-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/orchestrator-failed-error.ts
-/**
-* Base class for every orchestrator-specific failure surfaced from
-* `orchestrator.execute()` / `orchestrator.resume()` /
-* `orchestrator.command()` or thrown at authoring-time by
-* `ai.orchestrator()` validation (orchestrator.md §17).
-*
-* **Role.** Anchor for the `ORCHESTRATOR_*` code family. Subclasses
-* carry precise codes (`ORCHESTRATOR_DRIFT`, `ORCHESTRATOR_CONFIG`,
-* `ORCHESTRATOR_CANCELLED`, …); this base catches everything a turn can
-* produce that isn't already an agent / tool / provider / supervisor
-* error bubbling up from the dispatched child.
-*
-* Child-execution errors (agent, tool, provider, supervisor) flow
-* through the orchestrator unchanged — they are captured on the turn's
-* `childReport` and surfaced on `result.error` directly, never
-* re-wrapped.
-*
-* @example
-* const result = await orchestrator.execute(message, { sessionId, history });
-* if (result.error instanceof OrchestratorFailedError) {
-*   console.error(result.error.code, result.error.message);
-* }
-*/
-var OrchestratorFailedError = class extends AIError {
-	constructor(message, options, code = "ORCHESTRATOR_FAILED") {
-		super(code, message, options);
-		this.name = "OrchestratorFailedError";
-	}
-};
-
-//#endregion
-export { OrchestratorFailedError };
-//# sourceMappingURL=orchestrator-failed-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"orchestrator-failed-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/orchestrator-failed-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { AIErrorCode } from \"./error-code.type\";\n\n/**\n * Base class for every orchestrator-specific failure surfaced from\n * `orchestrator.execute()` / `orchestrator.resume()` /\n * `orchestrator.command()` or thrown at authoring-time by\n * `ai.orchestrator()` validation (orchestrator.md §17).\n *\n * **Role.** Anchor for the `ORCHESTRATOR_*` code family. Subclasses\n * carry precise codes (`ORCHESTRATOR_DRIFT`, `ORCHESTRATOR_CONFIG`,\n * `ORCHESTRATOR_CANCELLED`, …); this base catches everything a turn can\n * produce that isn't already an agent / tool / provider / supervisor\n * error bubbling up from the dispatched child.\n *\n * Child-execution errors (agent, tool, provider, supervisor) flow\n * through the orchestrator unchanged — they are captured on the turn's\n * `childReport` and surfaced on `result.error` directly, never\n * re-wrapped.\n *\n * @example\n * const result = await orchestrator.execute(message, { sessionId, history });\n * if (result.error instanceof OrchestratorFailedError) {\n *   console.error(result.error.code, result.error.message);\n * }\n */\nexport class OrchestratorFailedError extends AIError {\n  public constructor(\n    message: string,\n    options?: AIErrorOptions,\n    code: AIErrorCode = \"ORCHESTRATOR_FAILED\",\n  ) {\n    super(code, message, options);\n    this.name = \"OrchestratorFailedError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,0BAAb,cAA6C,QAAQ;CACnD,AAAO,YACL,SACA,SACA,OAAoB,uBACpB;EACA,MAAM,MAAM,SAAS,OAAO;EAC5B,KAAK,OAAO;CACd;AACF"}

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

@@ -1,32 +0,0 @@
-import { AIError } from "./ai-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/outbound-policy-error.ts
-/**
-* A server-side outbound request (attachment fetch, URL skill manifest,
-* RAG loader, …) was blocked by the shared `OutboundPolicy` before it
-* left the process — a disallowed scheme, a host outside the allowlist, a
-* private / loopback / link-local / cloud-metadata address resolved after
-* DNS, an oversized body, or a timeout.
-*
-* This is the framework's SSRF / resource-exhaustion guard surfacing: the
-* request was refused on purpose, not a provider failure. `context`
-* carries the offending `url` / `host` / `reason` for logs.
-*
-* @example
-* if (error instanceof OutboundPolicyError) {
-*   logger.warn("blocked outbound fetch", { context: error.context });
-* }
-*/
-var OutboundPolicyError = class extends AIError {
-	static {
-		this.defaultCategory = "validation";
-	}
-	constructor(message, options) {
-		super("OUTBOUND_POLICY_BLOCKED", message, options);
-		this.name = "OutboundPolicyError";
-	}
-};
-
-//#endregion
-export { OutboundPolicyError };
-//# sourceMappingURL=outbound-policy-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"outbound-policy-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/outbound-policy-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * A server-side outbound request (attachment fetch, URL skill manifest,\n * RAG loader, …) was blocked by the shared `OutboundPolicy` before it\n * left the process — a disallowed scheme, a host outside the allowlist, a\n * private / loopback / link-local / cloud-metadata address resolved after\n * DNS, an oversized body, or a timeout.\n *\n * This is the framework's SSRF / resource-exhaustion guard surfacing: the\n * request was refused on purpose, not a provider failure. `context`\n * carries the offending `url` / `host` / `reason` for logs.\n *\n * @example\n * if (error instanceof OutboundPolicyError) {\n *   logger.warn(\"blocked outbound fetch\", { context: error.context });\n * }\n */\nexport class OutboundPolicyError extends AIError {\n  public static readonly defaultCategory: ErrorCategory = \"validation\";\n\n  public constructor(message: string, options?: AIErrorOptions) {\n    super(\"OUTBOUND_POLICY_BLOCKED\", message, options);\n    this.name = \"OutboundPolicyError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,IAAa,sBAAb,cAAyC,QAAQ;;yBACS;;CAExD,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MAAM,2BAA2B,SAAS,OAAO;EACjD,KAAK,OAAO;CACd;AACF"}

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

@@ -1,29 +0,0 @@
-import { PlannerFailedError } from "./planner-failed-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/planner-cancelled-error.ts
-/**
-* Planner run was cancelled via `AbortSignal` before it could finish.
-* Between-step cancellation is guaranteed; mid-step cancellation is
-* best-effort (the signal is threaded into every in-flight capability
-* `execute()` call, but effectiveness depends on the child primitive
-* respecting it).
-*
-* On cancellation the planner returns normally with
-* `report.status === "cancelled"` and the partial step snapshots — the
-* error is placed on `result.error` rather than thrown.
-*/
-var PlannerCancelledError = class extends PlannerFailedError {
-	static {
-		this.defaultCategory = "cancelled";
-	}
-	constructor(message, options) {
-		super(message, options, "PLANNER_CANCELLED");
-		this.name = "PlannerCancelledError";
-		this.cancelledAt = options.cancelledAt;
-		this.reason = options.reason;
-	}
-};
-
-//#endregion
-export { PlannerCancelledError };
-//# sourceMappingURL=planner-cancelled-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"planner-cancelled-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/planner-cancelled-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { PlannerFailedError } from \"./planner-failed-error\";\n\n/**\n * Options for {@link PlannerCancelledError}. Carries the observation\n * timestamp and the optional `controller.abort(reason)` payload.\n */\nexport type PlannerCancelledErrorOptions = AIErrorOptions & {\n  /** ISO-8601 timestamp at which the abort was observed by the planner. */\n  cancelledAt: string;\n  /** `controller.abort(reason)` payload when the caller supplied one. */\n  reason?: string;\n};\n\n/**\n * Planner run was cancelled via `AbortSignal` before it could finish.\n * Between-step cancellation is guaranteed; mid-step cancellation is\n * best-effort (the signal is threaded into every in-flight capability\n * `execute()` call, but effectiveness depends on the child primitive\n * respecting it).\n *\n * On cancellation the planner returns normally with\n * `report.status === \"cancelled\"` and the partial step snapshots — the\n * error is placed on `result.error` rather than thrown.\n */\nexport class PlannerCancelledError extends PlannerFailedError {\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: PlannerCancelledErrorOptions) {\n    super(message, options, \"PLANNER_CANCELLED\");\n    this.name = \"PlannerCancelledError\";\n    this.cancelledAt = options.cancelledAt;\n    this.reason = options.reason;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AA0BA,IAAa,wBAAb,cAA2C,mBAAmB;;yBACJ;;CAKxD,AAAO,YAAY,SAAiB,SAAuC;EACzE,MAAM,SAAS,SAAS,mBAAmB;EAC3C,KAAK,OAAO;EACZ,KAAK,cAAc,QAAQ;EAC3B,KAAK,SAAS,QAAQ;CACxB;AACF"}

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

@@ -1,33 +0,0 @@
-import { PlannerFailedError } from "./planner-failed-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/planner-drift-error.ts
-/**
-* `planner.resume(runId)` loaded a durable snapshot whose structural
-* fingerprint does not match the current planner definition (name +
-* ordered capability names). The resume is refused — no node runs — and
-* the user decides how to recover: discard the snapshot, migrate
-* manually, or call `resume(runId, { force: true })` to bypass the check.
-*
-* A mid-run re-plan is NOT drift — the plan changed, not the definition;
-* the persisted `replanCount` honors the replan budget across a resume.
-*
-* Mirrors `SupervisorDriftError` / `WorkflowDriftError` — same rationale,
-* different primitive. Thrown (not returned on `result.error`) because a
-* drifted resume never produces a valid run.
-*/
-var PlannerDriftError = class extends PlannerFailedError {
-	static {
-		this.defaultCategory = "drift";
-	}
-	constructor(message, options) {
-		super(message, options, "PLANNER_DRIFT");
-		this.name = "PlannerDriftError";
-		this.savedSignature = options.savedSignature;
-		this.currentSignature = options.currentSignature;
-		this.runId = options.runId;
-	}
-};
-
-//#endregion
-export { PlannerDriftError };
-//# sourceMappingURL=planner-drift-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"planner-drift-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/planner-drift-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { PlannerFailedError } from \"./planner-failed-error\";\n\nexport type PlannerDriftErrorOptions = AIErrorOptions & {\n  /** Signature recorded on the snapshot being resumed. */\n  savedSignature: string;\n  /** Signature computed from the current planner definition. */\n  currentSignature: string;\n  runId: string;\n};\n\n/**\n * `planner.resume(runId)` loaded a durable snapshot whose structural\n * fingerprint does not match the current planner definition (name +\n * ordered capability names). The resume is refused — no node runs — and\n * the user decides how to recover: discard the snapshot, migrate\n * manually, or call `resume(runId, { force: true })` to bypass the check.\n *\n * A mid-run re-plan is NOT drift — the plan changed, not the definition;\n * the persisted `replanCount` honors the replan budget across a resume.\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 PlannerDriftError extends PlannerFailedError {\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: PlannerDriftErrorOptions) {\n    super(message, options, \"PLANNER_DRIFT\");\n    this.name = \"PlannerDriftError\";\n    this.savedSignature = options.savedSignature;\n    this.currentSignature = options.currentSignature;\n    this.runId = options.runId;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,IAAa,oBAAb,cAAuC,mBAAmB;;yBACA;;CAMxD,AAAO,YAAY,SAAiB,SAAmC;EACrE,MAAM,SAAS,SAAS,eAAe;EACvC,KAAK,OAAO;EACZ,KAAK,iBAAiB,QAAQ;EAC9B,KAAK,mBAAmB,QAAQ;EAChC,KAAK,QAAQ,QAAQ;CACvB;AACF"}

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

@@ -1,37 +0,0 @@
-import { AIError } from "./ai-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/planner-failed-error.ts
-/**
-* Base class for every planner-specific failure surfaced from
-* `planner.execute()` or thrown at authoring-time by `ai.planner()`
-* validation.
-*
-* **Role.** Anchor for the `PLANNER_*` code family. Subclasses carry
-* precise codes (`PLANNER_PLAN_INVALID`, `PLANNER_CANCELLED`); this base
-* catches everything a planning run can produce that isn't already an
-* agent / tool / workflow / supervisor error bubbling up from a
-* dispatched capability.
-*
-* Child-execution errors (agent, tool, provider, workflow) flow through
-* the planner unchanged — they are captured on the relevant step
-* snapshot and surfaced on `result.error` directly, never re-wrapped.
-*
-* @example
-* const result = await planner.execute("Research and summarize X");
-* if (result.error instanceof PlannerFailedError) {
-*   console.error(result.error.code, result.error.message);
-* }
-*/
-var PlannerFailedError = class extends AIError {
-	static {
-		this.defaultCategory = "provider";
-	}
-	constructor(message, options, code = "PLANNER_FAILED") {
-		super(code, message, options);
-		this.name = "PlannerFailedError";
-	}
-};
-
-//#endregion
-export { PlannerFailedError };
-//# sourceMappingURL=planner-failed-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"planner-failed-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/planner-failed-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { AIErrorCode } from \"./error-code.type\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * Base class for every planner-specific failure surfaced from\n * `planner.execute()` or thrown at authoring-time by `ai.planner()`\n * validation.\n *\n * **Role.** Anchor for the `PLANNER_*` code family. Subclasses carry\n * precise codes (`PLANNER_PLAN_INVALID`, `PLANNER_CANCELLED`); this base\n * catches everything a planning run can produce that isn't already an\n * agent / tool / workflow / supervisor error bubbling up from a\n * dispatched capability.\n *\n * Child-execution errors (agent, tool, provider, workflow) flow through\n * the planner unchanged — they are captured on the relevant step\n * snapshot and surfaced on `result.error` directly, never re-wrapped.\n *\n * @example\n * const result = await planner.execute(\"Research and summarize X\");\n * if (result.error instanceof PlannerFailedError) {\n *   console.error(result.error.code, result.error.message);\n * }\n */\nexport class PlannerFailedError extends AIError {\n  /**\n   * Generic planner failures (authoring-time config violations, the\n   * `toAIError` catch-all for unexpected runtime crashes during a run)\n   * are orchestration-level provider failures. Subclasses with a more\n   * precise meaning redeclare their own — `PlannerPlanInvalidError` is\n   * `\"schema\"`, `PlannerCancelledError` is `\"cancelled\"`.\n   */\n  public static readonly defaultCategory: ErrorCategory = \"provider\";\n\n  public constructor(\n    message: string,\n    options?: AIErrorOptions,\n    code: AIErrorCode = \"PLANNER_FAILED\",\n  ) {\n    super(code, message, options);\n    this.name = \"PlannerFailedError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAa,qBAAb,cAAwC,QAAQ;;yBAQU;;CAExD,AAAO,YACL,SACA,SACA,OAAoB,kBACpB;EACA,MAAM,MAAM,SAAS,OAAO;EAC5B,KAAK,OAAO;CACd;AACF"}

package/esm/ai/src/errors/planner-plan-invalid-error.mjs

@@ -1,25 +0,0 @@
-import { PlannerFailedError } from "./planner-failed-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/planner-plan-invalid-error.ts
-/**
-* The planner asked the LLM for an execution plan but the response
-* could not be parsed / validated into a usable {@link PlannerPlan},
-* or it referenced a capability that was never registered.
-*
-* Surfaced on `result.error` with `report.status === "failed"` — the
-* planner returns normally rather than throwing, so callers branch on
-* the typed envelope like every other primitive.
-*/
-var PlannerPlanInvalidError = class extends PlannerFailedError {
-	static {
-		this.defaultCategory = "schema";
-	}
-	constructor(message, options) {
-		super(message, options, "PLANNER_PLAN_INVALID");
-		this.name = "PlannerPlanInvalidError";
-	}
-};
-
-//#endregion
-export { PlannerPlanInvalidError };
-//# sourceMappingURL=planner-plan-invalid-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"planner-plan-invalid-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/planner-plan-invalid-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { PlannerFailedError } from \"./planner-failed-error\";\n\n/**\n * The planner asked the LLM for an execution plan but the response\n * could not be parsed / validated into a usable {@link PlannerPlan},\n * or it referenced a capability that was never registered.\n *\n * Surfaced on `result.error` with `report.status === \"failed\"` — the\n * planner returns normally rather than throwing, so callers branch on\n * the typed envelope like every other primitive.\n */\nexport class PlannerPlanInvalidError extends PlannerFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"schema\";\n\n  public constructor(message: string, options?: AIErrorOptions) {\n    super(message, options, \"PLANNER_PLAN_INVALID\");\n    this.name = \"PlannerPlanInvalidError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAaA,IAAa,0BAAb,cAA6C,mBAAmB;;yBACN;;CAExD,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MAAM,SAAS,SAAS,sBAAsB;EAC9C,KAAK,OAAO;CACd;AACF"}

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

@@ -1,27 +0,0 @@
-import { AIError } from "./ai-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/prompt-refinement-error.ts
-/**
-* An explicit `refine()` / `refinePrompt()` call could not produce an
-* acceptable compiled prompt. Thrown (not degraded) because the explicit
-* compilation surface is used by routes, warmup, and CI — callers there need
-* the failure, not a silently-served original.
-*
-* The LAZY agent path never sees this error: `materialize()` catches it,
-* warns once, and serves the original prompt text — refinement is advisory
-* there, mirroring the Nova-safe judge policy in `ai.prompts.validate`.
-*/
-var PromptRefinementError = class extends AIError {
-	static {
-		this.defaultCategory = "validation";
-	}
-	constructor(message, options) {
-		super("PROMPT_REFINEMENT_FAILED", message, options);
-		this.name = "PromptRefinementError";
-		this.reason = options.reason;
-	}
-};
-
-//#endregion
-export { PromptRefinementError };
-//# sourceMappingURL=prompt-refinement-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"prompt-refinement-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/prompt-refinement-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport { AIError } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * Why a prompt refinement was rejected:\n *\n * - `\"model\"` — the refiner model call itself failed (provider error, no\n *   key, timeout); the underlying `AIError` rides on `cause`.\n * - `\"parity\"` — the rewrite broke placeholder parity (added, removed, or\n *   renamed a `{{placeholder}}` / changed its `|default`) and one repair\n *   attempt didn't fix it; the offending tokens are listed in `context.issues`.\n * - `\"empty\"` — the refiner returned no usable text.\n */\nexport type PromptRefinementFailureReason = \"model\" | \"parity\" | \"empty\";\n\nexport type PromptRefinementErrorOptions = AIErrorOptions & {\n  reason: PromptRefinementFailureReason;\n};\n\n/**\n * An explicit `refine()` / `refinePrompt()` call could not produce an\n * acceptable compiled prompt. Thrown (not degraded) because the explicit\n * compilation surface is used by routes, warmup, and CI — callers there need\n * the failure, not a silently-served original.\n *\n * The LAZY agent path never sees this error: `materialize()` catches it,\n * warns once, and serves the original prompt text — refinement is advisory\n * there, mirroring the Nova-safe judge policy in `ai.prompts.validate`.\n */\nexport class PromptRefinementError extends AIError {\n  public static readonly defaultCategory: ErrorCategory = \"validation\";\n\n  public readonly reason: PromptRefinementFailureReason;\n\n  public constructor(message: string, options: PromptRefinementErrorOptions) {\n    super(\"PROMPT_REFINEMENT_FAILED\", message, options);\n    this.name = \"PromptRefinementError\";\n    this.reason = options.reason;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AA8BA,IAAa,wBAAb,cAA2C,QAAQ;;yBACO;;CAIxD,AAAO,YAAY,SAAiB,SAAuC;EACzE,MAAM,4BAA4B,SAAS,OAAO;EAClD,KAAK,OAAO;EACZ,KAAK,SAAS,QAAQ;CACxB;AACF"}

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

@@ -1,26 +0,0 @@
-import { ProviderError } from "./provider-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/provider-auth-error.ts
-/**
-* Provider rejected the credential — missing / invalid / expired API
-* key or insufficient permissions on the underlying account. Not
-* retryable; fix the credential and retry.
-*
-* @example
-* if (result.error instanceof ProviderAuthError) {
-*   notifyOps("rotate API key", result.error.context);
-* }
-*/
-var ProviderAuthError = class extends ProviderError {
-	static {
-		this.defaultCategory = "auth";
-	}
-	constructor(message, options) {
-		super(message, options, "PROVIDER_AUTH");
-		this.name = "ProviderAuthError";
-	}
-};
-
-//#endregion
-export {  };
-//# sourceMappingURL=provider-auth-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"provider-auth-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/provider-auth-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 credential — missing / invalid / expired API\n * key or insufficient permissions on the underlying account. Not\n * retryable; fix the credential and retry.\n *\n * @example\n * if (result.error instanceof ProviderAuthError) {\n *   notifyOps(\"rotate API key\", result.error.context);\n * }\n */\nexport class ProviderAuthError extends ProviderError {\n  public static readonly defaultCategory: ErrorCategory = \"auth\";\n\n  public constructor(message: string, options?: AIErrorOptions) {\n    super(message, options, \"PROVIDER_AUTH\");\n    this.name = \"ProviderAuthError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,IAAa,oBAAb,cAAuC,cAAc;;yBACK;;CAExD,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MAAM,SAAS,SAAS,eAAe;EACvC,KAAK,OAAO;CACd;AACF"}

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

@@ -1,42 +0,0 @@
-import { AIError } from "./ai-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/provider-error.ts
-/**
-* Any failure that originated from the model provider (OpenAI, Azure,
-* OpenRouter, local gateway). Base class for the provider subclasses
-* below — raw provider errors caught in an adapter are always wrapped
-* into *some* `ProviderError` so downstream code can branch on
-* `instanceof ProviderError` when any provider-side failure will do.
-*
-* **Subclasses (more specific first).**
-* - `ProviderRateLimitError` — 429 / rate-limit / quota exhaustion.
-* - `ProviderTimeoutError` — connection or request timeout.
-* - `ContextLengthExceededError` — prompt exceeded the model window.
-* - `ContentFilterError` — response blocked by provider safety policy.
-* - `ProviderAuthError` — bad / expired API key.
-* - `InvalidRequestError` — catch-all 4xx not covered above.
-*
-* When no subclass fits (e.g. 5xx server error, unknown network
-* failure), adapters throw plain `ProviderError` with the raw payload
-* captured in `context`.
-*
-* @example
-* if (result.error instanceof ProviderError) {
-*   if (result.error instanceof ProviderRateLimitError) {
-*     return retryAfter(result.error.retryAfter ?? 1000);
-*   }
-* }
-*/
-var ProviderError = class extends AIError {
-	static {
-		this.defaultCategory = "provider";
-	}
-	constructor(message, options, code = "PROVIDER_ERROR") {
-		super(code, message, options);
-		this.name = "ProviderError";
-	}
-};
-
-//#endregion
-export { ProviderError };
-//# sourceMappingURL=provider-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"provider-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/provider-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport type { AIErrorCode } from \"./error-code.type\";\n\n/**\n * Any failure that originated from the model provider (OpenAI, Azure,\n * OpenRouter, local gateway). Base class for the provider subclasses\n * below — raw provider errors caught in an adapter are always wrapped\n * into *some* `ProviderError` so downstream code can branch on\n * `instanceof ProviderError` when any provider-side failure will do.\n *\n * **Subclasses (more specific first).**\n * - `ProviderRateLimitError` — 429 / rate-limit / quota exhaustion.\n * - `ProviderTimeoutError` — connection or request timeout.\n * - `ContextLengthExceededError` — prompt exceeded the model window.\n * - `ContentFilterError` — response blocked by provider safety policy.\n * - `ProviderAuthError` — bad / expired API key.\n * - `InvalidRequestError` — catch-all 4xx not covered above.\n *\n * When no subclass fits (e.g. 5xx server error, unknown network\n * failure), adapters throw plain `ProviderError` with the raw payload\n * captured in `context`.\n *\n * @example\n * if (result.error instanceof ProviderError) {\n *   if (result.error instanceof ProviderRateLimitError) {\n *     return retryAfter(result.error.retryAfter ?? 1000);\n *   }\n * }\n */\nexport class ProviderError extends AIError {\n  public static readonly defaultCategory: ErrorCategory = \"provider\";\n\n  public constructor(\n    message: string,\n    options?: AIErrorOptions,\n    code: AIErrorCode = \"PROVIDER_ERROR\",\n  ) {\n    super(code, message, options);\n    this.name = \"ProviderError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,gBAAb,cAAmC,QAAQ;;yBACe;;CAExD,AAAO,YACL,SACA,SACA,OAAoB,kBACpB;EACA,MAAM,MAAM,SAAS,OAAO;EAC5B,KAAK,OAAO;CACd;AACF"}

package/esm/ai/src/errors/provider-rate-limit-error.mjs

@@ -1,31 +0,0 @@
-import { ProviderError } from "./provider-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/provider-rate-limit-error.ts
-/**
-* Provider refused the call because the account (or key, or window)
-* is over its rate-limit or quota. Retryable after `retryAfter`
-* milliseconds — consumers are expected to back off before retrying.
-*
-* Covers both transient `429 Too Many Requests` and the billing-level
-* `insufficient_quota` case; the adapter decides which provider
-* signals map here.
-*
-* @example
-* if (result.error instanceof ProviderRateLimitError) {
-*   await sleep(result.error.retryAfter ?? 1000);
-* }
-*/
-var ProviderRateLimitError = class extends ProviderError {
-	static {
-		this.defaultCategory = "rate-limit";
-	}
-	constructor(message, options) {
-		super(message, options, "PROVIDER_RATE_LIMIT");
-		this.name = "ProviderRateLimitError";
-		this.retryAfter = options?.retryAfter;
-	}
-};
-
-//#endregion
-export {  };
-//# sourceMappingURL=provider-rate-limit-error.mjs.map

package/esm/ai/src/errors/provider-rate-limit-error.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider-rate-limit-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/provider-rate-limit-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 `ProviderRateLimitError`. `retryAfter` is the server's\n * hint (typically parsed from the `Retry-After` header) in milliseconds.\n */\nexport type ProviderRateLimitErrorOptions = AIErrorOptions & {\n  retryAfter?: number;\n};\n\n/**\n * Provider refused the call because the account (or key, or window)\n * is over its rate-limit or quota. Retryable after `retryAfter`\n * milliseconds — consumers are expected to back off before retrying.\n *\n * Covers both transient `429 Too Many Requests` and the billing-level\n * `insufficient_quota` case; the adapter decides which provider\n * signals map here.\n *\n * @example\n * if (result.error instanceof ProviderRateLimitError) {\n *   await sleep(result.error.retryAfter ?? 1000);\n * }\n */\nexport class ProviderRateLimitError extends ProviderError {\n  public static readonly defaultCategory: ErrorCategory = \"rate-limit\";\n\n  public readonly retryAfter?: number;\n\n  public constructor(message: string, options?: ProviderRateLimitErrorOptions) {\n    super(message, options, \"PROVIDER_RATE_LIMIT\");\n    this.name = \"ProviderRateLimitError\";\n    this.retryAfter = options?.retryAfter;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,IAAa,yBAAb,cAA4C,cAAc;;yBACA;;CAIxD,AAAO,YAAY,SAAiB,SAAyC;EAC3E,MAAM,SAAS,SAAS,qBAAqB;EAC7C,KAAK,OAAO;EACZ,KAAK,aAAa,SAAS;CAC7B;AACF"}

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

@@ -1,26 +0,0 @@
-import { ProviderError } from "./provider-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/provider-timeout-error.ts
-/**
-* Provider call timed out — either at the transport layer (socket
-* connection) or on the server side (request exceeded the provider's
-* processing deadline). Idempotent retries are usually safe.
-*
-* @example
-* if (result.error instanceof ProviderTimeoutError) {
-*   return retry();
-* }
-*/
-var ProviderTimeoutError = class extends ProviderError {
-	static {
-		this.defaultCategory = "timeout";
-	}
-	constructor(message, options) {
-		super(message, options, "PROVIDER_TIMEOUT");
-		this.name = "ProviderTimeoutError";
-	}
-};
-
-//#endregion
-export {  };
-//# sourceMappingURL=provider-timeout-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"provider-timeout-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/provider-timeout-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 call timed out — either at the transport layer (socket\n * connection) or on the server side (request exceeded the provider's\n * processing deadline). Idempotent retries are usually safe.\n *\n * @example\n * if (result.error instanceof ProviderTimeoutError) {\n *   return retry();\n * }\n */\nexport class ProviderTimeoutError extends ProviderError {\n  public static readonly defaultCategory: ErrorCategory = \"timeout\";\n\n  public constructor(message: string, options?: AIErrorOptions) {\n    super(message, options, \"PROVIDER_TIMEOUT\");\n    this.name = \"ProviderTimeoutError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,IAAa,uBAAb,cAA0C,cAAc;;yBACE;;CAExD,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MAAM,SAAS,SAAS,kBAAkB;EAC1C,KAAK,OAAO;CACd;AACF"}

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

@@ -1,40 +0,0 @@
-import { ProviderError } from "./provider-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/quota-exceeded-error.ts
-/**
-* Provider refused the call because the account has exhausted its
-* paid quota (monthly credit, billing cap, subscription tier limit).
-*
-* **Not retryable.** Unlike `ProviderRateLimitError` — where the
-* bucket refills after `retryAfter` milliseconds — this one needs
-* human intervention: top up the account, upgrade the plan, or
-* switch to a different key. Consumers who blindly back-off-and-retry
-* on rate-limit errors would loop forever here, which is why the two
-* are split.
-*
-* Typically surfaced as OpenAI `code: "insufficient_quota"`.
-*
-* **Distinct from `BudgetExceededError`.** `QuotaExceededError` is
-* the *provider* telling us their billing cap is hit.
-* `BudgetExceededError` is our *own* middleware enforcing a
-* user-configured ceiling client-side.
-*
-* @example
-* if (result.error instanceof QuotaExceededError) {
-*   await pagerDuty.trigger("openai quota exhausted");
-*   return fallbackResponse();
-* }
-*/
-var QuotaExceededError = class extends ProviderError {
-	static {
-		this.defaultCategory = "quota";
-	}
-	constructor(message, options) {
-		super(message, options, "PROVIDER_QUOTA_EXCEEDED");
-		this.name = "QuotaExceededError";
-	}
-};
-
-//#endregion
-export {  };
-//# sourceMappingURL=quota-exceeded-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"quota-exceeded-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/quota-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 * Provider refused the call because the account has exhausted its\n * paid quota (monthly credit, billing cap, subscription tier limit).\n *\n * **Not retryable.** Unlike `ProviderRateLimitError` — where the\n * bucket refills after `retryAfter` milliseconds — this one needs\n * human intervention: top up the account, upgrade the plan, or\n * switch to a different key. Consumers who blindly back-off-and-retry\n * on rate-limit errors would loop forever here, which is why the two\n * are split.\n *\n * Typically surfaced as OpenAI `code: \"insufficient_quota\"`.\n *\n * **Distinct from `BudgetExceededError`.** `QuotaExceededError` is\n * the *provider* telling us their billing cap is hit.\n * `BudgetExceededError` is our *own* middleware enforcing a\n * user-configured ceiling client-side.\n *\n * @example\n * if (result.error instanceof QuotaExceededError) {\n *   await pagerDuty.trigger(\"openai quota exhausted\");\n *   return fallbackResponse();\n * }\n */\nexport class QuotaExceededError extends ProviderError {\n  public static readonly defaultCategory: ErrorCategory = \"quota\";\n\n  public constructor(message: string, options?: AIErrorOptions) {\n    super(message, options, \"PROVIDER_QUOTA_EXCEEDED\");\n    this.name = \"QuotaExceededError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,qBAAb,cAAwC,cAAc;;yBACI;;CAExD,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MAAM,SAAS,SAAS,yBAAyB;EACjD,KAAK,OAAO;CACd;AACF"}

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

@@ -1,23 +0,0 @@
-import { WorkflowError } from "./workflow-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/routing-error.ts
-/**
-* `nextStep` returned an invalid `goto`, or the `nextStep` callback
-* itself threw. Routing is authoritative and has no recovery path —
-* the workflow terminates immediately.
-*/
-var RoutingError = class extends WorkflowError {
-	static {
-		this.defaultCategory = "routing";
-	}
-	constructor(message, options) {
-		super(message, options, "WORKFLOW_INVALID_GOTO");
-		this.name = "RoutingError";
-		this.stepName = options.stepName;
-		this.targetName = options.targetName;
-	}
-};
-
-//#endregion
-export { RoutingError };
-//# sourceMappingURL=routing-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"routing-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/routing-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { WorkflowError } from \"./workflow-error\";\n\nexport type RoutingErrorOptions = AIErrorOptions & {\n  stepName: string;\n  targetName?: string;\n};\n\n/**\n * `nextStep` returned an invalid `goto`, or the `nextStep` callback\n * itself threw. Routing is authoritative and has no recovery path —\n * the workflow terminates immediately.\n */\nexport class RoutingError extends WorkflowError {\n  public static readonly defaultCategory: ErrorCategory = \"routing\";\n\n  public readonly stepName: string;\n  public readonly targetName?: string;\n\n  public constructor(message: string, options: RoutingErrorOptions) {\n    super(message, options, \"WORKFLOW_INVALID_GOTO\");\n    this.name = \"RoutingError\";\n    this.stepName = options.stepName;\n    this.targetName = options.targetName;\n  }\n}\n"],"mappings":";;;;;;;;AAcA,IAAa,eAAb,cAAkC,cAAc;;yBACU;;CAKxD,AAAO,YAAY,SAAiB,SAA8B;EAChE,MAAM,SAAS,SAAS,uBAAuB;EAC/C,KAAK,OAAO;EACZ,KAAK,WAAW,QAAQ;EACxB,KAAK,aAAa,QAAQ;CAC5B;AACF"}

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

@@ -1,37 +0,0 @@
-import { AIError } from "./ai-error.mjs";
-
-//#region ../@warlock.js/ai/src/errors/schema-validation-error.ts
-/**
-* A `StandardSchemaV1` validation call returned issues, or the input
-* was not valid JSON before validation could even run.
-*
-* Produced in two places today:
-* - Agent output parsing — the final trip text failed `JSON.parse` or
-*   the parsed value failed `~standard.validate`.
-* - Tool input validation — the model's raw arguments for a tool call
-*   didn't match the tool's `input` schema.
-*
-* `issues` carries the structured validation result when available so
-* consumers can present per-field feedback.
-*
-* @example
-* if (result.error instanceof SchemaValidationError) {
-*   for (const issue of result.error.issues ?? []) {
-*     console.warn(issue.path, issue.message);
-*   }
-* }
-*/
-var SchemaValidationError = class extends AIError {
-	static {
-		this.defaultCategory = "schema";
-	}
-	constructor(message, options) {
-		super("SCHEMA_VALIDATION_FAILED", message, options);
-		this.name = "SchemaValidationError";
-		this.issues = options?.issues;
-	}
-};
-
-//#endregion
-export { SchemaValidationError };
-//# sourceMappingURL=schema-validation-error.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schema-validation-error.mjs","names":[],"sources":["../../../../../../../../../@warlock.js/ai/src/errors/schema-validation-error.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * Payload passed to `SchemaValidationError`. Subset of\n * `AIErrorOptions` plus the machine-readable validation issues list.\n */\nexport type SchemaValidationErrorOptions = AIErrorOptions & {\n  issues?: readonly StandardSchemaV1.Issue[];\n};\n\n/**\n * A `StandardSchemaV1` validation call returned issues, or the input\n * was not valid JSON before validation could even run.\n *\n * Produced in two places today:\n * - Agent output parsing — the final trip text failed `JSON.parse` or\n *   the parsed value failed `~standard.validate`.\n * - Tool input validation — the model's raw arguments for a tool call\n *   didn't match the tool's `input` schema.\n *\n * `issues` carries the structured validation result when available so\n * consumers can present per-field feedback.\n *\n * @example\n * if (result.error instanceof SchemaValidationError) {\n *   for (const issue of result.error.issues ?? []) {\n *     console.warn(issue.path, issue.message);\n *   }\n * }\n */\nexport class SchemaValidationError extends AIError {\n  public static readonly defaultCategory: ErrorCategory = \"schema\";\n\n  public readonly issues?: readonly StandardSchemaV1.Issue[];\n\n  public constructor(message: string, options?: SchemaValidationErrorOptions) {\n    super(\"SCHEMA_VALIDATION_FAILED\", message, options);\n    this.name = \"SchemaValidationError\";\n    this.issues = options?.issues;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAa,wBAAb,cAA2C,QAAQ;;yBACO;;CAIxD,AAAO,YAAY,SAAiB,SAAwC;EAC1E,MAAM,4BAA4B,SAAS,OAAO;EAClD,KAAK,OAAO;EACZ,KAAK,SAAS,SAAS;CACzB;AACF"}