@warlock.js/ai 4.1.1

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

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

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

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

package/esm/errors/index.d.mts

@@ -0,0 +1,29 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorCode } from "./error-code.type.mjs";
+import { AIError, AIErrorOptions } from "./ai-error.mjs";
+import { AgentExecutionError } from "./agent-execution-error.mjs";
+import { AgentCancelledError, AgentCancelledErrorOptions } from "./agent-cancelled-error.mjs";
+import { AgentMaxTripsError, AgentMaxTripsErrorOptions } from "./agent-max-trips-error.mjs";
+import { BudgetExceededError, BudgetExceededErrorOptions, BudgetUnit } from "./budget-exceeded-error.mjs";
+import { ProviderError } from "./provider-error.mjs";
+import { ContentFilterError, ContentFilterErrorOptions } from "./content-filter-error.mjs";
+import { ContextLengthExceededError, ContextLengthExceededErrorOptions } from "./context-length-exceeded-error.mjs";
+import { GuardrailPhase, GuardrailViolationError, GuardrailViolationErrorOptions } from "./guardrail-violation-error.mjs";
+import { InvalidRequestError } from "./invalid-request-error.mjs";
+import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
+import { MaxIterationsError, MaxIterationsErrorOptions } from "./max-iterations-error.mjs";
+import { WorkflowError } from "./workflow-error.mjs";
+import { MaxStepsExceededError, MaxStepsExceededErrorOptions } from "./max-steps-exceeded-error.mjs";
+import { ProviderAuthError } from "./provider-auth-error.mjs";
+import { ProviderRateLimitError, ProviderRateLimitErrorOptions } from "./provider-rate-limit-error.mjs";
+import { ProviderTimeoutError } from "./provider-timeout-error.mjs";
+import { QuotaExceededError } from "./quota-exceeded-error.mjs";
+import { RoutingError, RoutingErrorOptions } from "./routing-error.mjs";
+import { SchemaValidationError, SchemaValidationErrorOptions } from "./schema-validation-error.mjs";
+import { StepFailedError, StepFailedErrorOptions } from "./step-failed-error.mjs";
+import { SupervisorCancelledError, SupervisorCancelledErrorOptions } from "./supervisor-cancelled-error.mjs";
+import { SupervisorDriftError, SupervisorDriftErrorOptions } from "./supervisor-drift-error.mjs";
+import { SupervisorRoutingError, SupervisorRoutingErrorOptions } from "./supervisor-routing-error.mjs";
+import { ToolExecutionError, ToolExecutionErrorOptions } from "./tool-execution-error.mjs";
+import { WorkflowCancelledError, WorkflowCancelledErrorOptions } from "./workflow-cancelled-error.mjs";
+import { WorkflowDriftError, WorkflowDriftErrorOptions } from "./workflow-drift-error.mjs";

package/esm/errors/index.mjs

@@ -0,0 +1,29 @@
+import { AIError } from "./ai-error.mjs";
+import { AgentExecutionError } from "./agent-execution-error.mjs";
+import { AgentCancelledError } from "./agent-cancelled-error.mjs";
+import { AgentMaxTripsError } from "./agent-max-trips-error.mjs";
+import { BudgetExceededError } from "./budget-exceeded-error.mjs";
+import { ProviderError } from "./provider-error.mjs";
+import { ContentFilterError } from "./content-filter-error.mjs";
+import { ContextLengthExceededError } from "./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 { ProviderAuthError } from "./provider-auth-error.mjs";
+import { ProviderRateLimitError } from "./provider-rate-limit-error.mjs";
+import { ProviderTimeoutError } from "./provider-timeout-error.mjs";
+import { QuotaExceededError } from "./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/errors/invalid-request-error.d.mts

@@ -0,0 +1,27 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { ProviderError } from "./provider-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/invalid-request-error.d.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 });
+ * }
+ */
+declare class InvalidRequestError extends ProviderError {
+  static readonly defaultCategory: ErrorCategory;
+  constructor(message: string, options?: AIErrorOptions);
+}
+//#endregion
+export { InvalidRequestError };
+//# sourceMappingURL=invalid-request-error.d.mts.map

package/esm/errors/invalid-request-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid-request-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/invalid-request-error.ts"],"mappings":";;;;;;;AAmBA;;;;;;;;;;;;;cAAa,mBAAA,SAA4B,aAAA;EAAA,gBAChB,eAAA,EAAiB,aAAA;cAErB,OAAA,UAAiB,OAAA,GAAU,cAAA;AAAA"}

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

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

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

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

package/esm/errors/max-iterations-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/max-iterations-error.d.ts
+type MaxIterationsErrorOptions = AIErrorOptions & {
+  maxIterations: number;
+};
+/**
+ * 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,
+ *   });
+ * }
+ */
+declare class MaxIterationsError extends SupervisorFailedError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly maxIterations: number;
+  constructor(message: string, options: MaxIterationsErrorOptions);
+}
+//#endregion
+export { MaxIterationsError, MaxIterationsErrorOptions };
+//# sourceMappingURL=max-iterations-error.d.mts.map

package/esm/errors/max-iterations-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-iterations-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/max-iterations-error.ts"],"mappings":";;;;;KAIY,yBAAA,GAA4B,cAAc;EACpD,aAAa;AAAA;;;;AAAA;AAkBf;;;;;;;;;;;cAAa,kBAAA,SAA2B,qBAAA;EAAA,gBACf,eAAA,EAAiB,aAAA;EAAA,SAExB,aAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,yBAAA;AAAA"}

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

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

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

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

@@ -0,0 +1,20 @@
+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/max-steps-exceeded-error.d.ts
+type MaxStepsExceededErrorOptions = AIErrorOptions & {
+  maxSteps: number;
+};
+/**
+ * Runaway-loop hard guard: workflow executed more step transitions
+ * than `maxSteps` allows. Terminates the workflow immediately.
+ */
+declare class MaxStepsExceededError extends WorkflowError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly maxSteps: number;
+  constructor(message: string, options: MaxStepsExceededErrorOptions);
+}
+//#endregion
+export { MaxStepsExceededError, MaxStepsExceededErrorOptions };
+//# sourceMappingURL=max-steps-exceeded-error.d.mts.map

package/esm/errors/max-steps-exceeded-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"max-steps-exceeded-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/max-steps-exceeded-error.ts"],"mappings":";;;;;KAIY,4BAAA,GAA+B,cAAc;EACvD,QAAQ;AAAA;;;;AAAA;cAOG,qBAAA,SAA8B,aAAA;EAAA,gBAClB,eAAA,EAAiB,aAAA;EAAA,SAExB,QAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,4BAAA;AAAA"}

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

@@ -0,0 +1,21 @@
+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/errors/max-steps-exceeded-error.mjs.map

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

@@ -0,0 +1,22 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { ProviderError } from "./provider-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/provider-auth-error.d.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);
+ * }
+ */
+declare class ProviderAuthError extends ProviderError {
+  static readonly defaultCategory: ErrorCategory;
+  constructor(message: string, options?: AIErrorOptions);
+}
+//#endregion
+export { ProviderAuthError };
+//# sourceMappingURL=provider-auth-error.d.mts.map

package/esm/errors/provider-auth-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-auth-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/provider-auth-error.ts"],"mappings":";;;;;;;AAcA;;;;;;;;cAAa,iBAAA,SAA0B,aAAA;EAAA,gBACd,eAAA,EAAiB,aAAA;cAErB,OAAA,UAAiB,OAAA,GAAU,cAAA;AAAA"}

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

@@ -0,0 +1,26 @@
+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 { ProviderAuthError };
+//# sourceMappingURL=provider-auth-error.mjs.map

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

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

@@ -0,0 +1,38 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorCode } from "./error-code.type.mjs";
+import { AIError, AIErrorOptions } from "./ai-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/provider-error.d.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);
+ *   }
+ * }
+ */
+declare class ProviderError extends AIError {
+  static readonly defaultCategory: ErrorCategory;
+  constructor(message: string, options?: AIErrorOptions, code?: AIErrorCode);
+}
+//#endregion
+export { ProviderError };
+//# sourceMappingURL=provider-error.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/provider-error.ts"],"mappings":";;;;;;;AA8BA;;;;;;;;;;;;;;;;;;;AAMwC;;;;;cAN3B,aAAA,SAAsB,OAAA;EAAA,gBACV,eAAA,EAAiB,aAAA;cAGtC,OAAA,UACA,OAAA,GAAU,cAAA,EACV,IAAA,GAAM,WAAA;AAAA"}

package/esm/errors/provider-error.mjs

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

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

@@ -0,0 +1,34 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { ProviderError } from "./provider-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/provider-rate-limit-error.d.ts
+/**
+ * Payload for `ProviderRateLimitError`. `retryAfter` is the server's
+ * hint (typically parsed from the `Retry-After` header) in milliseconds.
+ */
+type ProviderRateLimitErrorOptions = AIErrorOptions & {
+  retryAfter?: number;
+};
+/**
+ * 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);
+ * }
+ */
+declare class ProviderRateLimitError extends ProviderError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly retryAfter?: number;
+  constructor(message: string, options?: ProviderRateLimitErrorOptions);
+}
+//#endregion
+export { ProviderRateLimitError, ProviderRateLimitErrorOptions };
+//# sourceMappingURL=provider-rate-limit-error.d.mts.map

package/esm/errors/provider-rate-limit-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-rate-limit-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/provider-rate-limit-error.ts"],"mappings":";;;;;;;AAQA;;KAAY,6BAAA,GAAgC,cAAc;EACxD,UAAU;AAAA;AAiBZ;;;;;;;;;;;;;;AAAA,cAAa,sBAAA,SAA+B,aAAA;EAAA,gBACnB,eAAA,EAAiB,aAAA;EAAA,SAExB,UAAA;cAEG,OAAA,UAAiB,OAAA,GAAU,6BAAA;AAAA"}

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

@@ -0,0 +1,31 @@
+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 { ProviderRateLimitError };
+//# sourceMappingURL=provider-rate-limit-error.mjs.map

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

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

@@ -0,0 +1,22 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { ProviderError } from "./provider-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/provider-timeout-error.d.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();
+ * }
+ */
+declare class ProviderTimeoutError extends ProviderError {
+  static readonly defaultCategory: ErrorCategory;
+  constructor(message: string, options?: AIErrorOptions);
+}
+//#endregion
+export { ProviderTimeoutError };
+//# sourceMappingURL=provider-timeout-error.d.mts.map

package/esm/errors/provider-timeout-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-timeout-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/ai/src/errors/provider-timeout-error.ts"],"mappings":";;;;;;;AAcA;;;;;;;;cAAa,oBAAA,SAA6B,aAAA;EAAA,gBACjB,eAAA,EAAiB,aAAA;cAErB,OAAA,UAAiB,OAAA,GAAU,cAAA;AAAA"}

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

@@ -0,0 +1,26 @@
+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 { ProviderTimeoutError };
+//# sourceMappingURL=provider-timeout-error.mjs.map

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

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

@@ -0,0 +1,36 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { ProviderError } from "./provider-error.mjs";
+
+//#region ../../@warlock.js/ai/src/errors/quota-exceeded-error.d.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();
+ * }
+ */
+declare class QuotaExceededError extends ProviderError {
+  static readonly defaultCategory: ErrorCategory;
+  constructor(message: string, options?: AIErrorOptions);
+}
+//#endregion
+export { QuotaExceededError };
+//# sourceMappingURL=quota-exceeded-error.d.mts.map