@warlock.js/ai 4.1.1

package/esm/errors/quota-exceeded-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quota-exceeded-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/quota-exceeded-error.ts"],"mappings":";;;;;;;AA4BA;;;;;;;;;;;;;;;;AAG8D;;;;;;cAHjD,kBAAA,SAA2B,aAAA;EAAA,gBACf,eAAA,EAAiB,aAAA;cAErB,OAAA,UAAiB,OAAA,GAAU,cAAA;AAAA"}

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

@@ -0,0 +1,40 @@
+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 { QuotaExceededError };
+//# sourceMappingURL=quota-exceeded-error.mjs.map

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

@@ -0,0 +1 @@
+{"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/errors/routing-error.d.mts

@@ -0,0 +1,23 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { WorkflowError } from "./workflow-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/routing-error.d.ts
+type RoutingErrorOptions = AIErrorOptions & {
+  stepName: string;
+  targetName?: string;
+};
+/**
+ * `nextStep` returned an invalid `goto`, or the `nextStep` callback
+ * itself threw. Routing is authoritative and has no recovery path —
+ * the workflow terminates immediately.
+ */
+declare class RoutingError extends WorkflowError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly stepName: string;
+  readonly targetName?: string;
+  constructor(message: string, options: RoutingErrorOptions);
+}
+//#endregion
+export { RoutingError, RoutingErrorOptions };
+//# sourceMappingURL=routing-error.d.mts.map

package/esm/errors/routing-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/routing-error.ts"],"mappings":";;;;;KAIY,mBAAA,GAAsB,cAAc;EAC9C,QAAA;EACA,UAAA;AAAA;;;;;;cAQW,YAAA,SAAqB,aAAA;EAAA,gBACT,eAAA,EAAiB,aAAA;EAAA,SAExB,QAAA;EAAA,SACA,UAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,mBAAA;AAAA"}

package/esm/errors/routing-error.mjs

@@ -0,0 +1,23 @@
+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/errors/routing-error.mjs.map

@@ -0,0 +1 @@
+{"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/errors/schema-validation-error.d.mts

@@ -0,0 +1,40 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIError, AIErrorOptions } from "./ai-error.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region ../../@warlock.js/ai/src/errors/schema-validation-error.d.ts
+/**
+ * Payload passed to `SchemaValidationError`. Subset of
+ * `AIErrorOptions` plus the machine-readable validation issues list.
+ */
+type SchemaValidationErrorOptions = AIErrorOptions & {
+  issues?: readonly StandardSchemaV1.Issue[];
+};
+/**
+ * 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);
+ *   }
+ * }
+ */
+declare class SchemaValidationError extends AIError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly issues?: readonly StandardSchemaV1.Issue[];
+  constructor(message: string, options?: SchemaValidationErrorOptions);
+}
+//#endregion
+export { SchemaValidationError, SchemaValidationErrorOptions };
+//# sourceMappingURL=schema-validation-error.d.mts.map

package/esm/errors/schema-validation-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-validation-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/schema-validation-error.ts"],"mappings":";;;;;;;AAQA;;KAAY,4BAAA,GAA+B,cAAA;EACzC,MAAA,YAAkB,gBAAA,CAAiB,KAAK;AAAA;;;;;AAAA;AAuB1C;;;;;;;;;;;;;;;cAAa,qBAAA,SAA8B,OAAA;EAAA,gBAClB,eAAA,EAAiB,aAAA;EAAA,SAExB,MAAA,YAAkB,gBAAA,CAAiB,KAAA;cAEhC,OAAA,UAAiB,OAAA,GAAU,4BAAA;AAAA"}

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

@@ -0,0 +1,37 @@
+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/errors/schema-validation-error.mjs.map

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

package/esm/errors/step-failed-error.d.mts

@@ -0,0 +1,20 @@
+import { AIErrorOptions } from "./ai-error.mjs";
+import { WorkflowError } from "./workflow-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/step-failed-error.d.ts
+type StepFailedErrorOptions = AIErrorOptions & {
+  stepName: string;
+  attempts: number;
+};
+/**
+ * A workflow step exhausted its retries (or was not retried) and
+ * terminated with an error. `cause` carries the last underlying error.
+ */
+declare class StepFailedError extends WorkflowError {
+  readonly stepName: string;
+  readonly attempts: number;
+  constructor(message: string, options: StepFailedErrorOptions);
+}
+//#endregion
+export { StepFailedError, StepFailedErrorOptions };
+//# sourceMappingURL=step-failed-error.d.mts.map

package/esm/errors/step-failed-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-failed-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/step-failed-error.ts"],"mappings":";;;;KAGY,sBAAA,GAAyB,cAAc;EACjD,QAAA;EACA,QAAA;AAAA;;;;;cAOW,eAAA,SAAwB,aAAa;EAAA,SAChC,QAAA;EAAA,SACA,QAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,sBAAA;AAAA"}

package/esm/errors/step-failed-error.mjs

@@ -0,0 +1,19 @@
+import { WorkflowError } from "./workflow-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/step-failed-error.ts
+/**
+* A workflow step exhausted its retries (or was not retried) and
+* terminated with an error. `cause` carries the last underlying error.
+*/
+var StepFailedError = class extends WorkflowError {
+	constructor(message, options) {
+		super(message, options, "STEP_FAILED");
+		this.name = "StepFailedError";
+		this.stepName = options.stepName;
+		this.attempts = options.attempts;
+	}
+};
+
+//#endregion
+export { StepFailedError };
+//# sourceMappingURL=step-failed-error.mjs.map

package/esm/errors/step-failed-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-failed-error.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/step-failed-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport { WorkflowError } from \"./workflow-error\";\n\nexport type StepFailedErrorOptions = AIErrorOptions & {\n  stepName: string;\n  attempts: number;\n};\n\n/**\n * A workflow step exhausted its retries (or was not retried) and\n * terminated with an error. `cause` carries the last underlying error.\n */\nexport class StepFailedError extends WorkflowError {\n  public readonly stepName: string;\n  public readonly attempts: number;\n\n  public constructor(message: string, options: StepFailedErrorOptions) {\n    super(message, options, \"STEP_FAILED\");\n    this.name = \"StepFailedError\";\n    this.stepName = options.stepName;\n    this.attempts = options.attempts;\n  }\n}\n"],"mappings":";;;;;;;AAYA,IAAa,kBAAb,cAAqC,cAAc;CAIjD,AAAO,YAAY,SAAiB,SAAiC;EACnE,MAAM,SAAS,SAAS,aAAa;EACrC,KAAK,OAAO;EACZ,KAAK,WAAW,QAAQ;EACxB,KAAK,WAAW,QAAQ;CAC1B;AACF"}

package/esm/errors/supervisor-cancelled-error.d.mts

@@ -0,0 +1,29 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/supervisor-cancelled-error.d.ts
+type SupervisorCancelledErrorOptions = AIErrorOptions & {
+  /** ISO-8601 timestamp at which the abort was observed by the supervisor. */cancelledAt: string; /** `controller.abort(reason)` payload when the caller supplied one. */
+  reason?: string;
+};
+/**
+ * Supervisor run was cancelled via `AbortSignal` before it could
+ * finish. Between-iteration cancellation is guaranteed; mid-iteration
+ * cancellation is best-effort (the signal is also threaded into every
+ * in-flight child `execute()` call, but effectiveness depends on the
+ * child primitive respecting it).
+ *
+ * On cancellation the supervisor returns normally with `status:
+ * "cancelled"` and partial `report.snapshots` — the error is placed
+ * on `result.error` rather than thrown.
+ */
+declare class SupervisorCancelledError extends SupervisorFailedError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly cancelledAt: string;
+  readonly reason?: string;
+  constructor(message: string, options: SupervisorCancelledErrorOptions);
+}
+//#endregion
+export { SupervisorCancelledError, SupervisorCancelledErrorOptions };
+//# sourceMappingURL=supervisor-cancelled-error.d.mts.map

package/esm/errors/supervisor-cancelled-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-cancelled-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/supervisor-cancelled-error.ts"],"mappings":";;;;;KAIY,+BAAA,GAAkC,cAAc;8EAE1D,WAAA,UAFyC;EAIzC,MAAA;AAAA;;;;;AAAM;AAcR;;;;;;cAAa,wBAAA,SAAiC,qBAAA;EAAA,gBACrB,eAAA,EAAiB,aAAA;EAAA,SAExB,WAAA;EAAA,SACA,MAAA;cAGd,OAAA,UACA,OAAA,EAAS,+BAAA;AAAA"}

package/esm/errors/supervisor-cancelled-error.mjs

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

package/esm/errors/supervisor-cancelled-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-cancelled-error.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/supervisor-cancelled-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 SupervisorCancelledErrorOptions = AIErrorOptions & {\n  /** ISO-8601 timestamp at which the abort was observed by the supervisor. */\n  cancelledAt: string;\n  /** `controller.abort(reason)` payload when the caller supplied one. */\n  reason?: string;\n};\n\n/**\n * Supervisor run was cancelled via `AbortSignal` before it could\n * finish. Between-iteration cancellation is guaranteed; mid-iteration\n * cancellation is best-effort (the signal is also threaded into every\n * in-flight child `execute()` call, but effectiveness depends on the\n * child primitive respecting it).\n *\n * On cancellation the supervisor returns normally with `status:\n * \"cancelled\"` and partial `report.snapshots` — the error is placed\n * on `result.error` rather than thrown.\n */\nexport class SupervisorCancelledError extends SupervisorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"cancelled\";\n\n  public readonly cancelledAt: string;\n  public readonly reason?: string;\n\n  public constructor(\n    message: string,\n    options: SupervisorCancelledErrorOptions,\n  ) {\n    super(message, options, \"SUPERVISOR_CANCELLED\");\n    this.name = \"SupervisorCancelledError\";\n    this.cancelledAt = options.cancelledAt;\n    this.reason = options.reason;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAsBA,IAAa,2BAAb,cAA8C,sBAAsB;;yBACV;;CAKxD,AAAO,YACL,SACA,SACA;EACA,MAAM,SAAS,SAAS,sBAAsB;EAC9C,KAAK,OAAO;EACZ,KAAK,cAAc,QAAQ;EAC3B,KAAK,SAAS,QAAQ;CACxB;AACF"}

package/esm/errors/supervisor-drift-error.d.mts

@@ -0,0 +1,31 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/supervisor-drift-error.d.ts
+type SupervisorDriftErrorOptions = AIErrorOptions & {
+  /** Signature recorded on the snapshot being resumed. */savedSignature: string; /** Signature computed from the current supervisor definition. */
+  currentSignature: string;
+  runId: string;
+};
+/**
+ * `supervisor.resume(runId)` loaded a snapshot whose structural
+ * fingerprint does not match the current supervisor definition
+ * (agent keys + descriptions + router identity + route presence).
+ * The resume is refused — no iteration runs — and the user decides
+ * how to recover: discard the snapshot, migrate manually, or call
+ * `resume(runId, { force: true })` to bypass the check.
+ *
+ * Mirrors `WorkflowDriftError` for workflow resume — same rationale,
+ * different primitive.
+ */
+declare class SupervisorDriftError extends SupervisorFailedError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly savedSignature: string;
+  readonly currentSignature: string;
+  readonly runId: string;
+  constructor(message: string, options: SupervisorDriftErrorOptions);
+}
+//#endregion
+export { SupervisorDriftError, SupervisorDriftErrorOptions };
+//# sourceMappingURL=supervisor-drift-error.d.mts.map

package/esm/errors/supervisor-drift-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-drift-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/supervisor-drift-error.ts"],"mappings":";;;;;KAIY,2BAAA,GAA8B,cAAc;0DAEtD,cAAA,UAFqC;EAIrC,gBAAA;EACA,KAAA;AAAA;;;;;AAAK;AAcP;;;;;;cAAa,oBAAA,SAA6B,qBAAA;EAAA,gBACjB,eAAA,EAAiB,aAAA;EAAA,SAExB,cAAA;EAAA,SACA,gBAAA;EAAA,SACA,KAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,2BAAA;AAAA"}

package/esm/errors/supervisor-drift-error.mjs

@@ -0,0 +1,30 @@
+import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/supervisor-drift-error.ts
+/**
+* `supervisor.resume(runId)` loaded a snapshot whose structural
+* fingerprint does not match the current supervisor definition
+* (agent keys + descriptions + router identity + route presence).
+* The resume is refused — no iteration runs — and the user decides
+* how to recover: discard the snapshot, migrate manually, or call
+* `resume(runId, { force: true })` to bypass the check.
+*
+* Mirrors `WorkflowDriftError` for workflow resume — same rationale,
+* different primitive.
+*/
+var SupervisorDriftError = class extends SupervisorFailedError {
+	static {
+		this.defaultCategory = "drift";
+	}
+	constructor(message, options) {
+		super(message, options, "SUPERVISOR_DRIFT");
+		this.name = "SupervisorDriftError";
+		this.savedSignature = options.savedSignature;
+		this.currentSignature = options.currentSignature;
+		this.runId = options.runId;
+	}
+};
+
+//#endregion
+export { SupervisorDriftError };
+//# sourceMappingURL=supervisor-drift-error.mjs.map

package/esm/errors/supervisor-drift-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-drift-error.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/supervisor-drift-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 SupervisorDriftErrorOptions = AIErrorOptions & {\n  /** Signature recorded on the snapshot being resumed. */\n  savedSignature: string;\n  /** Signature computed from the current supervisor definition. */\n  currentSignature: string;\n  runId: string;\n};\n\n/**\n * `supervisor.resume(runId)` loaded a snapshot whose structural\n * fingerprint does not match the current supervisor definition\n * (agent keys + descriptions + router identity + route presence).\n * The resume is refused — no iteration runs — and the user decides\n * how to recover: discard the snapshot, migrate manually, or call\n * `resume(runId, { force: true })` to bypass the check.\n *\n * Mirrors `WorkflowDriftError` for workflow resume — same rationale,\n * different primitive.\n */\nexport class SupervisorDriftError extends SupervisorFailedError {\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: SupervisorDriftErrorOptions) {\n    super(message, options, \"SUPERVISOR_DRIFT\");\n    this.name = \"SupervisorDriftError\";\n    this.savedSignature = options.savedSignature;\n    this.currentSignature = options.currentSignature;\n    this.runId = options.runId;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAuBA,IAAa,uBAAb,cAA0C,sBAAsB;;yBACN;;CAMxD,AAAO,YAAY,SAAiB,SAAsC;EACxE,MAAM,SAAS,SAAS,kBAAkB;EAC1C,KAAK,OAAO;EACZ,KAAK,iBAAiB,QAAQ;EAC9B,KAAK,mBAAmB,QAAQ;EAChC,KAAK,QAAQ,QAAQ;CACvB;AACF"}

package/esm/errors/supervisor-failed-error.d.mts

@@ -0,0 +1,40 @@
+import { AIErrorCode } from "./error-code.type.mjs";
+import { AIError, AIErrorOptions } from "./ai-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/supervisor-failed-error.d.ts
+/**
+ * Base class for every supervisor-specific failure surfaced from
+ * `supervisor.execute()` / `supervisor.resume()` / authoring-time
+ * `ai.supervisor()` validation.
+ *
+ * **Role.** Anchor for the `SUPERVISOR_*` code family. Subclasses
+ * carry precise codes (`SUPERVISOR_MAX_ITERATIONS`,
+ * `SUPERVISOR_INVALID_ROUTE`, …); this base catches everything a
+ * supervisor run can produce that isn't already an agent / tool /
+ * provider / workflow error bubbling up from a child execution.
+ *
+ * Child-execution errors (agent, tool, provider, workflow) flow
+ * through the supervisor unchanged — they are captured on the
+ * relevant branch snapshot and, if fatal, wrapped as the `cause` of a
+ * `SupervisorFailedError` only when the supervisor itself has no
+ * narrower subclass to throw.
+ *
+ * @example
+ * try {
+ *   ai.supervisor({
+ *     route: () => "triage",
+ *     router: routerAgent,
+ *     intents: { triage },
+ *   });
+ * } catch (error) {
+ *   if (error instanceof SupervisorFailedError) {
+ *     console.error(error.code, error.message);
+ *   }
+ * }
+ */
+declare class SupervisorFailedError extends AIError {
+  constructor(message: string, options?: AIErrorOptions, code?: AIErrorCode);
+}
+//#endregion
+export { SupervisorFailedError };
+//# sourceMappingURL=supervisor-failed-error.d.mts.map

package/esm/errors/supervisor-failed-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-failed-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/supervisor-failed-error.ts"],"mappings":";;;;;;AAiCA;;;;;;;;;;;;;;;;AAI2C;;;;;;;;;;;;cAJ9B,qBAAA,SAA8B,OAAA;cAEvC,OAAA,UACA,OAAA,GAAU,cAAA,EACV,IAAA,GAAM,WAAA;AAAA"}

package/esm/errors/supervisor-failed-error.mjs

@@ -0,0 +1,43 @@
+import { AIError } from "./ai-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/supervisor-failed-error.ts
+/**
+* Base class for every supervisor-specific failure surfaced from
+* `supervisor.execute()` / `supervisor.resume()` / authoring-time
+* `ai.supervisor()` validation.
+*
+* **Role.** Anchor for the `SUPERVISOR_*` code family. Subclasses
+* carry precise codes (`SUPERVISOR_MAX_ITERATIONS`,
+* `SUPERVISOR_INVALID_ROUTE`, …); this base catches everything a
+* supervisor run can produce that isn't already an agent / tool /
+* provider / workflow error bubbling up from a child execution.
+*
+* Child-execution errors (agent, tool, provider, workflow) flow
+* through the supervisor unchanged — they are captured on the
+* relevant branch snapshot and, if fatal, wrapped as the `cause` of a
+* `SupervisorFailedError` only when the supervisor itself has no
+* narrower subclass to throw.
+*
+* @example
+* try {
+*   ai.supervisor({
+*     route: () => "triage",
+*     router: routerAgent,
+*     intents: { triage },
+*   });
+* } catch (error) {
+*   if (error instanceof SupervisorFailedError) {
+*     console.error(error.code, error.message);
+*   }
+* }
+*/
+var SupervisorFailedError = class extends AIError {
+	constructor(message, options, code = "SUPERVISOR_FAILED") {
+		super(code, message, options);
+		this.name = "SupervisorFailedError";
+	}
+};
+
+//#endregion
+export { SupervisorFailedError };
+//# sourceMappingURL=supervisor-failed-error.mjs.map

package/esm/errors/supervisor-failed-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-failed-error.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/supervisor-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 supervisor-specific failure surfaced from\n * `supervisor.execute()` / `supervisor.resume()` / authoring-time\n * `ai.supervisor()` validation.\n *\n * **Role.** Anchor for the `SUPERVISOR_*` code family. Subclasses\n * carry precise codes (`SUPERVISOR_MAX_ITERATIONS`,\n * `SUPERVISOR_INVALID_ROUTE`, …); this base catches everything a\n * supervisor run can produce that isn't already an agent / tool /\n * provider / workflow error bubbling up from a child execution.\n *\n * Child-execution errors (agent, tool, provider, workflow) flow\n * through the supervisor unchanged — they are captured on the\n * relevant branch snapshot and, if fatal, wrapped as the `cause` of a\n * `SupervisorFailedError` only when the supervisor itself has no\n * narrower subclass to throw.\n *\n * @example\n * try {\n *   ai.supervisor({\n *     route: () => \"triage\",\n *     router: routerAgent,\n *     intents: { triage },\n *   });\n * } catch (error) {\n *   if (error instanceof SupervisorFailedError) {\n *     console.error(error.code, error.message);\n *   }\n * }\n */\nexport class SupervisorFailedError extends AIError {\n  public constructor(\n    message: string,\n    options?: AIErrorOptions,\n    code: AIErrorCode = \"SUPERVISOR_FAILED\",\n  ) {\n    super(code, message, options);\n    this.name = \"SupervisorFailedError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAa,wBAAb,cAA2C,QAAQ;CACjD,AAAO,YACL,SACA,SACA,OAAoB,qBACpB;EACA,MAAM,MAAM,SAAS,OAAO;EAC5B,KAAK,OAAO;CACd;AACF"}

package/esm/errors/supervisor-routing-error.d.mts

@@ -0,0 +1,44 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/supervisor-routing-error.d.ts
+type SupervisorRoutingErrorOptions = AIErrorOptions & {
+  /**
+   * The raw value the `route` callback or router agent returned. Keyed
+   * `unknown` because a misbehaving router can emit any JSON value —
+   * consumers should format it for display, not trust its shape.
+   */
+  returned: unknown; /** Every legal intent key configured on the supervisor at run time. */
+  availableKeys: string[];
+};
+/**
+ * A `route` callback or router agent returned a value that doesn't
+ * resolve to a configured agent key, a `string[]` of configured keys,
+ * or the `END` sentinel. Routing is authoritative — there is no
+ * recovery path, so the supervisor terminates the run immediately.
+ *
+ * Named `SupervisorRoutingError` (not `RoutingError`) to avoid
+ * colliding with `@warlock.js/ai`'s existing workflow `RoutingError`
+ * (`WORKFLOW_INVALID_GOTO`). Both carry the same semantic weight —
+ * "routing asked for something I can't dispatch" — in their
+ * respective primitives.
+ *
+ * @example
+ * const { error } = await supervisor.execute(input);
+ * if (error?.code === "SUPERVISOR_INVALID_ROUTE") {
+ *   logger.error("bad router decision", {
+ *     returned: (error as SupervisorRoutingError).returned,
+ *     available: (error as SupervisorRoutingError).availableKeys,
+ *   });
+ * }
+ */
+declare class SupervisorRoutingError extends SupervisorFailedError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly returned: unknown;
+  readonly availableKeys: string[];
+  constructor(message: string, options: SupervisorRoutingErrorOptions);
+}
+//#endregion
+export { SupervisorRoutingError, SupervisorRoutingErrorOptions };
+//# sourceMappingURL=supervisor-routing-error.d.mts.map

package/esm/errors/supervisor-routing-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-routing-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/supervisor-routing-error.ts"],"mappings":";;;;;KAIY,6BAAA,GAAgC,cAAc;;AAA1D;;;;EAME,QAAA;EAEA,aAAA;AAAA;AAAa;AAwBf;;;;;;;;;;;;;;;;;;AAM4E;;AA9B7D,cAwBF,sBAAA,SAA+B,qBAAA;EAAA,gBACnB,eAAA,EAAiB,aAAA;EAAA,SAExB,QAAA;EAAA,SACA,aAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,6BAAA;AAAA"}

package/esm/errors/supervisor-routing-error.mjs

@@ -0,0 +1,39 @@
+import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/supervisor-routing-error.ts
+/**
+* A `route` callback or router agent returned a value that doesn't
+* resolve to a configured agent key, a `string[]` of configured keys,
+* or the `END` sentinel. Routing is authoritative — there is no
+* recovery path, so the supervisor terminates the run immediately.
+*
+* Named `SupervisorRoutingError` (not `RoutingError`) to avoid
+* colliding with `@warlock.js/ai`'s existing workflow `RoutingError`
+* (`WORKFLOW_INVALID_GOTO`). Both carry the same semantic weight —
+* "routing asked for something I can't dispatch" — in their
+* respective primitives.
+*
+* @example
+* const { error } = await supervisor.execute(input);
+* if (error?.code === "SUPERVISOR_INVALID_ROUTE") {
+*   logger.error("bad router decision", {
+*     returned: (error as SupervisorRoutingError).returned,
+*     available: (error as SupervisorRoutingError).availableKeys,
+*   });
+* }
+*/
+var SupervisorRoutingError = class extends SupervisorFailedError {
+	static {
+		this.defaultCategory = "routing";
+	}
+	constructor(message, options) {
+		super(message, options, "SUPERVISOR_INVALID_ROUTE");
+		this.name = "SupervisorRoutingError";
+		this.returned = options.returned;
+		this.availableKeys = options.availableKeys;
+	}
+};
+
+//#endregion
+export { SupervisorRoutingError };
+//# sourceMappingURL=supervisor-routing-error.mjs.map

package/esm/errors/supervisor-routing-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor-routing-error.mjs","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/supervisor-routing-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 SupervisorRoutingErrorOptions = AIErrorOptions & {\n  /**\n   * The raw value the `route` callback or router agent returned. Keyed\n   * `unknown` because a misbehaving router can emit any JSON value —\n   * consumers should format it for display, not trust its shape.\n   */\n  returned: unknown;\n  /** Every legal intent key configured on the supervisor at run time. */\n  availableKeys: string[];\n};\n\n/**\n * A `route` callback or router agent returned a value that doesn't\n * resolve to a configured agent key, a `string[]` of configured keys,\n * or the `END` sentinel. Routing is authoritative — there is no\n * recovery path, so the supervisor terminates the run immediately.\n *\n * Named `SupervisorRoutingError` (not `RoutingError`) to avoid\n * colliding with `@warlock.js/ai`'s existing workflow `RoutingError`\n * (`WORKFLOW_INVALID_GOTO`). Both carry the same semantic weight —\n * \"routing asked for something I can't dispatch\" — in their\n * respective primitives.\n *\n * @example\n * const { error } = await supervisor.execute(input);\n * if (error?.code === \"SUPERVISOR_INVALID_ROUTE\") {\n *   logger.error(\"bad router decision\", {\n *     returned: (error as SupervisorRoutingError).returned,\n *     available: (error as SupervisorRoutingError).availableKeys,\n *   });\n * }\n */\nexport class SupervisorRoutingError extends SupervisorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"routing\";\n\n  public readonly returned: unknown;\n  public readonly availableKeys: string[];\n\n  public constructor(message: string, options: SupervisorRoutingErrorOptions) {\n    super(message, options, \"SUPERVISOR_INVALID_ROUTE\");\n    this.name = \"SupervisorRoutingError\";\n    this.returned = options.returned;\n    this.availableKeys = options.availableKeys;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoCA,IAAa,yBAAb,cAA4C,sBAAsB;;yBACR;;CAKxD,AAAO,YAAY,SAAiB,SAAwC;EAC1E,MAAM,SAAS,SAAS,0BAA0B;EAClD,KAAK,OAAO;EACZ,KAAK,WAAW,QAAQ;EACxB,KAAK,gBAAgB,QAAQ;CAC/B;AACF"}

package/esm/errors/tool-execution-error.d.mts

@@ -0,0 +1,35 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIError, AIErrorOptions } from "./ai-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/tool-execution-error.d.ts
+/**
+ * Payload passed to `ToolExecutionError` — identifies which tool
+ * failed and, when applicable, which trip it was dispatched from.
+ */
+type ToolExecutionErrorOptions = AIErrorOptions & {
+  toolName: string;
+  tripIndex?: number;
+};
+/**
+ * A registered tool's `execute()` threw during dispatch — the tool
+ * code itself failed (not its input schema). The model's request was
+ * valid; the implementation crashed.
+ *
+ * Carries `toolName` so consumers can branch on which tool failed
+ * without regex-parsing the message, and `tripIndex` to correlate
+ * with the `LLMTrip` entry in `result.report.trips`.
+ *
+ * @example
+ * if (result.error instanceof ToolExecutionError) {
+ *   metrics.increment("tool.failure", { tool: result.error.toolName });
+ * }
+ */
+declare class ToolExecutionError extends AIError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly toolName: string;
+  readonly tripIndex?: number;
+  constructor(message: string, options: ToolExecutionErrorOptions);
+}
+//#endregion
+export { ToolExecutionError, ToolExecutionErrorOptions };
+//# sourceMappingURL=tool-execution-error.d.mts.map

package/esm/errors/tool-execution-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-execution-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/tool-execution-error.ts"],"mappings":";;;;;;AAOA;;KAAY,yBAAA,GAA4B,cAAc;EACpD,QAAA;EACA,SAAA;AAAA;;;AAAS;AAiBX;;;;;;;;;;;cAAa,kBAAA,SAA2B,OAAA;EAAA,gBACf,eAAA,EAAiB,aAAA;EAAA,SAExB,QAAA;EAAA,SACA,SAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,yBAAA;AAAA"}