@theokit/sdk 1.5.0

package/dist/errors-CvAeEWgE.d.ts

@@ -0,0 +1,448 @@
+import { an as RunOperation } from './run-DkCD5DeO.js';
+
+/**
+ * Public type contract for the Budget enforcement primitive
+ * (ADRs D375, D382-D387). The runtime facade lives in `budget.ts`.
+ *
+ * @public
+ */
+/**
+ * Scope of a budget — where the charge is attributed. v1 supports
+ * `process` (shared global) only; `agent` and `call` reserved for
+ * v0.2 multi-tenant scenarios.
+ */
+type BudgetScope = "agent" | "call" | "process";
+/**
+ * Time window for a budget limit (D382 — UTC calendar-aligned).
+ * - `1h` is relative (last 60 minutes).
+ * - `1d` / `1w` / `30d` / `365d` are aligned to UTC calendar
+ *   boundaries (UTC midnight / monday 00:00 UTC / 1st 00:00 UTC).
+ */
+type BudgetWindow = "1h" | "1d" | "1w" | "30d" | "365d";
+/**
+ * Enforcement mode (D383).
+ * - `audit`: log only, never throw, never block.
+ * - `warn`: callbacks fire at 80/95/100% thresholds; no throw.
+ * - `block`: preflightCheck throws `BudgetExceededError` BEFORE LLM call
+ *   when would-exceed.
+ */
+type BudgetMode = "audit" | "warn" | "block";
+/** A single limit; stacked in an array (D384, ANY exceeded blocks). */
+interface BudgetLimit {
+    readonly window: BudgetWindow;
+    readonly limitUsd: number;
+}
+/** Threshold event emitted at 80% and 95% in `warn` and `block` modes. */
+interface BudgetThresholdEvent {
+    readonly budgetName: string;
+    readonly window: BudgetWindow;
+    readonly threshold: 0.8 | 0.95;
+    readonly spentUsd: number;
+    readonly limitUsd: number;
+}
+/** Exceed event emitted at 100% across all modes. */
+interface BudgetExceedEvent {
+    readonly budgetName: string;
+    readonly window: BudgetWindow;
+    readonly spentUsd: number;
+    readonly limitUsd: number;
+    readonly mode: BudgetMode;
+}
+/** Options for `Budget.create`. */
+interface BudgetOptions {
+    /**
+     * Identifier. Must match grammar `^[a-z0-9][a-z0-9_-]*$` (EC-7);
+     * empty/invalid → `ConfigurationError({ code: "invalid_budget_name" })`.
+     */
+    readonly name: string;
+    readonly scope: BudgetScope;
+    /**
+     * Stacked limits — at least one is expected for `warn`/`block`. Empty
+     * array (EC-19) is allowed → registry-only tracking, callbacks never
+     * fire.
+     */
+    readonly limits: ReadonlyArray<BudgetLimit>;
+    /** Default `warn` (D383). */
+    readonly mode?: BudgetMode;
+    /** Fires at 80% and 95% of any limit. Caller throws are isolated (EC-8). */
+    readonly onThreshold?: (event: BudgetThresholdEvent) => void | Promise<void>;
+    /** Fires at 100%. Caller throws are isolated (EC-8). */
+    readonly onExceed?: (event: BudgetExceedEvent) => void | Promise<void>;
+}
+/** Returned by `Budget.create` and `Budget.get` — read-only view. */
+interface BudgetHandle {
+    readonly name: string;
+    readonly mode: BudgetMode;
+    readonly scope: BudgetScope;
+    readonly limits: ReadonlyArray<BudgetLimit>;
+    /** Snapshot spend for the given window. */
+    spentIn(window: BudgetWindow): number;
+    /** Remaining USD before the given window's limit is reached. */
+    remainingIn(window: BudgetWindow): number;
+}
+/** Per-window snapshot returned by `Budget.snapshot()`. */
+interface BudgetSnapshot {
+    readonly name: string;
+    readonly window: BudgetWindow;
+    readonly spentUsd: number;
+    readonly limitUsd: number;
+    readonly ratio: number;
+}
+
+/**
+ * Finite, machine-readable error codes for provider-originated errors
+ * (ADR D66). Consumers can `switch (err.metadata?.code)` exhaustively
+ * — adding a new variant is an explicit decision + test coverage.
+ *
+ * @public
+ */
+type ErrorCode = "rate_limit" | "auth_failed" | "invalid_request" | "timeout" | "server_error" | "context_too_long" | "content_filtered" | "model_unavailable" | "network" | "unknown";
+/**
+ * Codes used by {@link AgentRunError} (Production-Readiness #3, ADR D311).
+ *
+ * Superset of {@link ErrorCode} extended with codes that do NOT originate
+ * from a provider HTTP response:
+ *
+ * - `quota_exceeded` — billing limit hit (provider 402 or signalled error)
+ * - `tool_runtime_error` — custom tool handler threw inside dispatch
+ * - `aborted` — caller's `AbortSignal` fired (Phase 4)
+ * - `invalid_model` — model id rejected by provider (400 "model not found")
+ * - `safety_blocked` — provider safety filter blocked req or resp
+ * - `provider_unreachable` — DNS/TCP/timeout/5xx at transport boundary
+ *
+ * The `& {}` tail keeps the literal-union ergonomics (autocomplete) while
+ * accepting any string for forward compatibility with constructor calls
+ * that pass arbitrary code values (legacy callers).
+ *
+ * @public
+ */
+type AgentRunErrorCode = ErrorCode | "quota_exceeded" | "tool_runtime_error" | "aborted" | "invalid_model" | "safety_blocked" | "provider_unreachable" | (string & {});
+/**
+ * Structured context for errors that originated from a provider HTTP
+ * call (ADR D65). Lets callers retry with the right backoff (`retryAfter`),
+ * surface actionable diagnostics (`provider`, `endpoint`), and inspect the
+ * raw response body when needed (`raw`, capped at ~2KB by the mapper).
+ *
+ * @public
+ */
+interface ErrorMetadata {
+    /** Provider canonical name (e.g., `"anthropic"`, `"openai"`, `"openrouter"`, `"gemini"`). */
+    provider: string;
+    /** HTTP endpoint that failed (e.g., `"/v1/messages"`, `"/v1/chat/completions"`). */
+    endpoint: string;
+    /** Machine-readable error code (finite enum). */
+    code: ErrorCode;
+    /** HTTP status code if applicable. */
+    statusCode?: number;
+    /** Seconds to wait before retry, per provider's `retry-after` header (numeric form only). */
+    retryAfter?: number;
+    /** Raw response body for debugging (truncated to ~2KB by the mapper). */
+    raw?: unknown;
+}
+/**
+ * Base class for all errors thrown by `@theokit/sdk`.
+ *
+ * Use `isRetryable` to drive retry/backoff logic. `code` and `protoErrorCode`
+ * are populated for server-originated errors when available. `metadata`
+ * (ADR D65) carries structured `{ provider, endpoint, code, ... }` when
+ * the error originated from a provider HTTP call.
+ *
+ * @public
+ */
+declare class TheokitAgentError extends Error {
+    readonly name: string;
+    readonly isRetryable: boolean;
+    readonly code?: string;
+    readonly protoErrorCode?: string;
+    readonly metadata?: ErrorMetadata;
+    constructor(message: string, options?: {
+        isRetryable?: boolean;
+        code?: string;
+        protoErrorCode?: string;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Invalid API key, not logged in, insufficient permissions.
+ *
+ * @public
+ */
+declare class AuthenticationError extends TheokitAgentError {
+    readonly name: string;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Too many requests or usage limits exceeded.
+ *
+ * @public
+ */
+declare class RateLimitError extends TheokitAgentError {
+    readonly name: string;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Invalid model, bad request parameters, malformed options.
+ *
+ * @public
+ */
+declare class ConfigurationError extends TheokitAgentError {
+    readonly name: string;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Thrown when creating a cloud agent for a repo whose SCM provider is not
+ * connected. Use `helpUrl` to point the user at the right reconnect flow.
+ *
+ * @public
+ */
+declare class IntegrationNotConnectedError extends ConfigurationError {
+    readonly name: string;
+    readonly provider: string;
+    readonly helpUrl: string;
+    constructor(message: string, options: {
+        provider: string;
+        helpUrl: string;
+        code?: string;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Service unavailable, timeout, transport-level failure.
+ *
+ * @public
+ */
+declare class NetworkError extends TheokitAgentError {
+    readonly name: string;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Catch-all for unclassified server or runtime errors.
+ *
+ * @public
+ */
+declare class UnknownAgentError extends TheokitAgentError {
+    readonly name: string;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Thrown by `Agent.prompt` (and helpers that go through `run.wait()`) when
+ * the option `{ throwOnError: true }` is set and the run terminates with
+ * `status: 'error'`. Carries the structured `RunResult.error` fields so
+ * callers can `catch` once and branch on `code` / `provider` instead of
+ * unwrapping the run.
+ *
+ * Extends {@link TheokitAgentError} per ADR D65 — no new hierarchy.
+ *
+ * @example
+ *   try {
+ *     await Agent.prompt(msg, { apiKey, model, throwOnError: true });
+ *   } catch (err) {
+ *     if (err instanceof AgentRunError && err.code === 'auth_failed') {
+ *       // bad key
+ *     }
+ *   }
+ *
+ * @public
+ */
+declare class AgentRunError extends TheokitAgentError {
+    readonly name: string;
+    readonly provider?: string;
+    readonly raw?: string;
+    /** Provider's request id (`x-request-id` / `request-id` header). Useful for support tickets. */
+    readonly requestId?: string;
+    /** SDK conversation id this error was raised inside. */
+    readonly conversationId?: string;
+    constructor(message: string, options: {
+        code: AgentRunErrorCode;
+        provider?: string;
+        raw?: string;
+        requestId?: string;
+        conversationId?: string;
+        retriable?: boolean;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+    /**
+     * Production-Readiness #3 (ADR D311): alias for `isRetryable` exposed as
+     * `retriable` to match the handoff contract. Future v2 will deprecate
+     * `isRetryable` in favor of this.
+     */
+    get retriable(): boolean;
+    /**
+     * D312: provider's `Retry-After` header in **milliseconds**. Mappers store
+     * the header value (seconds) in `metadata.retryAfter`; this getter
+     * multiplies by 1000 so the result composes with `Date.now()`/`setTimeout`.
+     *
+     * Returns `undefined` when no hint was provided. `0` is a legitimate value
+     * — use `=== undefined` check rather than truthy check.
+     */
+    get retryAfterMs(): number | undefined;
+    /**
+     * D313: alias for `metadata.raw`. Provider response body for debugging.
+     * Available but NEVER serialized into `.message` (anti-leak invariant).
+     */
+    get providerError(): unknown;
+}
+/**
+ * Thrown when a {@link Run} or agent operation is not available on the current
+ * runtime. Check first with `run.supports(operation)`.
+ *
+ * Extends {@link TheokitAgentError} (so error-catching code that branches on
+ * `instanceof TheokitAgentError` continues to work) but is never retryable —
+ * an unsupported operation will not become supported on retry.
+ *
+ * @public
+ */
+declare class UnsupportedRunOperationError extends TheokitAgentError {
+    readonly name: string;
+    readonly operation: RunOperation;
+    constructor(message: string, operation: RunOperation, options?: {
+        code?: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when every credential in a per-provider pool is in cooldown
+ * and no healthy key is available (ADR D133). The caller's
+ * {@link import("./internal/llm/fallback-client.js").FallbackLlmClient}
+ * catches this and tries the next provider in the fallback chain.
+ *
+ * `metadata.nextRetryAt` (epoch ms) tells callers when the soonest
+ * pool entry resumes — useful for manual retry scheduling.
+ *
+ * @public
+ */
+declare class CredentialPoolExhaustedError extends TheokitAgentError {
+    readonly name: string;
+    readonly provider: string;
+    readonly nextRetryAt: number | undefined;
+    constructor(message: string, options: {
+        provider: string;
+        nextRetryAt?: number;
+        code?: string;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Finite error codes specific to memory adapter operations (ADR D141).
+ *
+ * @public
+ */
+type MemoryAdapterErrorCode = "auth_failed" | "rate_limited" | "not_found" | "network" | "invalid_input" | "unknown";
+/**
+ * Error raised by `@theokit-memory-*` adapters. Carries `adapterId`
+ * so callers can branch on which provider failed (ADR D141).
+ *
+ * @public
+ */
+declare class MemoryAdapterError extends TheokitAgentError {
+    readonly name: string;
+    readonly adapterId: string;
+    constructor(message: string, options: {
+        adapterId: string;
+        code: MemoryAdapterErrorCode;
+        cause?: unknown;
+        metadata?: ErrorMetadata;
+    });
+}
+/**
+ * Thrown when a user-supplied task ID violates the grammar
+ * `^[a-z0-9][a-z0-9_-]*$` (D368) OR starts with a reserved adapter
+ * prefix (`wf-` / `b-` / `cron-`, EC-5).
+ *
+ * @public
+ */
+declare class InvalidTaskIdError extends TheokitAgentError {
+    readonly name: string;
+    readonly taskId: string;
+    constructor(message: string, taskId: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when `Task.subscribe(id)` is called for a task that has been
+ * evicted, never submitted, or evicted after retention (D373).
+ *
+ * @public
+ */
+declare class TaskNotFoundError extends TheokitAgentError {
+    readonly name: string;
+    readonly taskId: string;
+    constructor(taskId: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when `CloudAgent` is asked to wrap a task (D370). Cloud
+ * task observability is deferred until Theo PaaS GA.
+ *
+ * @public
+ */
+declare class UnsupportedTaskOperationError extends TheokitAgentError {
+    readonly name: string;
+    readonly operation: string;
+    constructor(operation: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown by `Budget` enforcement (ADR D386) when a `mode: "block"`
+ * budget would be exceeded by the upcoming LLM call. Caller pega
+ * tipado para retry-after-window-reset or surface to the user.
+ *
+ * @public
+ */
+declare class BudgetExceededError extends TheokitAgentError {
+    readonly name: string;
+    readonly budgetName: string;
+    readonly window: BudgetWindow;
+    readonly spentUsd: number;
+    readonly limitUsd: number;
+    readonly mode: BudgetMode;
+    constructor(args: {
+        budgetName: string;
+        window: BudgetWindow;
+        spentUsd: number;
+        limitUsd: number;
+        mode: BudgetMode;
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when `CloudAgent.send({ budget })` is invoked (D388). Cloud
+ * budget surface waits for Theo PaaS GA.
+ *
+ * @public
+ */
+declare class UnsupportedBudgetOperationError extends TheokitAgentError {
+    readonly name: string;
+    readonly operation: string;
+    constructor(operation: string, options?: {
+        cause?: unknown;
+    });
+}
+
+export { AgentRunError as A, type BudgetOptions as B, ConfigurationError as C, type ErrorCode as E, IntegrationNotConnectedError as I, MemoryAdapterError as M, NetworkError as N, RateLimitError as R, TheokitAgentError as T, UnknownAgentError as U, type BudgetHandle as a, type BudgetSnapshot as b, type AgentRunErrorCode as c, AuthenticationError as d, type BudgetExceedEvent as e, BudgetExceededError as f, type BudgetLimit as g, type BudgetMode as h, type BudgetScope as i, type BudgetThresholdEvent as j, type BudgetWindow as k, type ErrorMetadata as l, InvalidTaskIdError as m, type MemoryAdapterErrorCode as n, TaskNotFoundError as o, UnsupportedBudgetOperationError as p, UnsupportedRunOperationError as q, UnsupportedTaskOperationError as r, CredentialPoolExhaustedError as s };

package/dist/errors.cjs

@@ -0,0 +1,255 @@
+'use strict';
+
+// src/errors.ts
+var TheokitAgentError = class extends Error {
+  name = "TheokitAgentError";
+  isRetryable;
+  code;
+  protoErrorCode;
+  metadata;
+  constructor(message, options = {}) {
+    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.isRetryable = options.isRetryable ?? false;
+    if (options.code !== void 0) this.code = options.code;
+    if (options.protoErrorCode !== void 0) this.protoErrorCode = options.protoErrorCode;
+    if (options.metadata !== void 0) this.metadata = options.metadata;
+  }
+};
+var AuthenticationError = class extends TheokitAgentError {
+  name = "AuthenticationError";
+  constructor(message, options = {}) {
+    super(message, { ...options, isRetryable: false });
+  }
+};
+var RateLimitError = class extends TheokitAgentError {
+  name = "RateLimitError";
+  constructor(message, options = {}) {
+    super(message, { ...options, isRetryable: true });
+  }
+};
+var ConfigurationError = class extends TheokitAgentError {
+  name = "ConfigurationError";
+  constructor(message, options = {}) {
+    super(message, { ...options, isRetryable: false });
+  }
+};
+var IntegrationNotConnectedError = class extends ConfigurationError {
+  name = "IntegrationNotConnectedError";
+  provider;
+  helpUrl;
+  constructor(message, options) {
+    super(message, options);
+    this.provider = options.provider;
+    this.helpUrl = options.helpUrl;
+  }
+};
+var NetworkError = class extends TheokitAgentError {
+  name = "NetworkError";
+  constructor(message, options = {}) {
+    super(message, { ...options, isRetryable: true });
+  }
+};
+var UnknownAgentError = class extends TheokitAgentError {
+  name = "UnknownAgentError";
+  constructor(message, options = {}) {
+    super(message, { ...options, isRetryable: false });
+  }
+};
+var AgentRunError = class extends TheokitAgentError {
+  name = "AgentRunError";
+  provider;
+  raw;
+  /** Provider's request id (`x-request-id` / `request-id` header). Useful for support tickets. */
+  requestId;
+  /** SDK conversation id this error was raised inside. */
+  conversationId;
+  constructor(message, options) {
+    super(message, {
+      code: options.code,
+      cause: options.cause,
+      metadata: options.metadata,
+      // D311: most AgentRunErrors are not retriable (auth, validation, abort).
+      // Provider mappers (D314) override per-status — explicit `retriable` wins
+      // over the implicit default when supplied.
+      isRetryable: options.retriable ?? defaultRetriableForCode(options.code)
+    });
+    if (options.provider !== void 0) this.provider = options.provider;
+    if (options.raw !== void 0) this.raw = options.raw;
+    if (options.requestId !== void 0) this.requestId = options.requestId;
+    if (options.conversationId !== void 0) this.conversationId = options.conversationId;
+  }
+  /**
+   * Production-Readiness #3 (ADR D311): alias for `isRetryable` exposed as
+   * `retriable` to match the handoff contract. Future v2 will deprecate
+   * `isRetryable` in favor of this.
+   */
+  get retriable() {
+    return this.isRetryable;
+  }
+  /**
+   * D312: provider's `Retry-After` header in **milliseconds**. Mappers store
+   * the header value (seconds) in `metadata.retryAfter`; this getter
+   * multiplies by 1000 so the result composes with `Date.now()`/`setTimeout`.
+   *
+   * Returns `undefined` when no hint was provided. `0` is a legitimate value
+   * — use `=== undefined` check rather than truthy check.
+   */
+  get retryAfterMs() {
+    if (this.metadata?.retryAfter === void 0) return void 0;
+    return this.metadata.retryAfter * 1e3;
+  }
+  /**
+   * D313: alias for `metadata.raw`. Provider response body for debugging.
+   * Available but NEVER serialized into `.message` (anti-leak invariant).
+   */
+  get providerError() {
+    return this.metadata?.raw;
+  }
+};
+function defaultRetriableForCode(code) {
+  switch (code) {
+    case "rate_limit":
+    case "timeout":
+    case "server_error":
+    case "network":
+    case "provider_unreachable":
+      return true;
+    default:
+      return false;
+  }
+}
+var UnsupportedRunOperationError = class extends TheokitAgentError {
+  name = "UnsupportedRunOperationError";
+  operation;
+  constructor(message, operation, options = {}) {
+    super(message, {
+      ...options,
+      isRetryable: false,
+      code: options.code ?? "unsupported_run_operation"
+    });
+    this.operation = operation;
+  }
+};
+var CredentialPoolExhaustedError = class extends TheokitAgentError {
+  name = "CredentialPoolExhaustedError";
+  provider;
+  nextRetryAt;
+  constructor(message, options) {
+    super(message, {
+      ...options,
+      isRetryable: true,
+      code: options.code ?? "credential_pool_exhausted"
+    });
+    this.provider = options.provider;
+    this.nextRetryAt = options.nextRetryAt;
+  }
+};
+var MemoryAdapterError = class extends TheokitAgentError {
+  name = "MemoryAdapterError";
+  adapterId;
+  constructor(message, options) {
+    super(message, {
+      isRetryable: options.code === "rate_limited" || options.code === "network",
+      code: options.code,
+      ...options.cause !== void 0 ? { cause: options.cause } : {},
+      ...options.metadata !== void 0 ? { metadata: options.metadata } : {}
+    });
+    this.adapterId = options.adapterId;
+  }
+};
+var InvalidTaskIdError = class extends TheokitAgentError {
+  name = "InvalidTaskIdError";
+  taskId;
+  constructor(message, taskId, options = {}) {
+    super(message, {
+      ...options,
+      isRetryable: false,
+      code: "invalid_task_id"
+    });
+    this.taskId = taskId;
+  }
+};
+var TaskNotFoundError = class extends TheokitAgentError {
+  name = "TaskNotFoundError";
+  taskId;
+  constructor(taskId, options = {}) {
+    super(`Task not found: ${taskId}`, {
+      ...options,
+      isRetryable: false,
+      code: "task_not_found"
+    });
+    this.taskId = taskId;
+  }
+};
+var UnsupportedTaskOperationError = class extends TheokitAgentError {
+  name = "UnsupportedTaskOperationError";
+  operation;
+  constructor(operation, options = {}) {
+    super(
+      `Task operation "${operation}" is not supported on CloudAgent (pre-release; see ADR D370)`,
+      {
+        ...options,
+        isRetryable: false,
+        code: "task_op_unsupported"
+      }
+    );
+    this.operation = operation;
+  }
+};
+var BudgetExceededError = class extends TheokitAgentError {
+  name = "BudgetExceededError";
+  budgetName;
+  window;
+  spentUsd;
+  limitUsd;
+  mode;
+  constructor(args) {
+    super(
+      `Budget "${args.budgetName}" exceeded for window ${args.window}: spent $${args.spentUsd.toFixed(4)} > limit $${args.limitUsd.toFixed(4)}`,
+      {
+        ...args.cause !== void 0 ? { cause: args.cause } : {},
+        isRetryable: false,
+        code: "budget_exceeded"
+      }
+    );
+    this.budgetName = args.budgetName;
+    this.window = args.window;
+    this.spentUsd = args.spentUsd;
+    this.limitUsd = args.limitUsd;
+    this.mode = args.mode;
+  }
+};
+var UnsupportedBudgetOperationError = class extends TheokitAgentError {
+  name = "UnsupportedBudgetOperationError";
+  operation;
+  constructor(operation, options = {}) {
+    super(
+      `Budget operation "${operation}" is not supported on CloudAgent (pre-release; see ADR D388)`,
+      {
+        ...options,
+        isRetryable: false,
+        code: "budget_op_unsupported"
+      }
+    );
+    this.operation = operation;
+  }
+};
+
+exports.AgentRunError = AgentRunError;
+exports.AuthenticationError = AuthenticationError;
+exports.BudgetExceededError = BudgetExceededError;
+exports.ConfigurationError = ConfigurationError;
+exports.CredentialPoolExhaustedError = CredentialPoolExhaustedError;
+exports.IntegrationNotConnectedError = IntegrationNotConnectedError;
+exports.InvalidTaskIdError = InvalidTaskIdError;
+exports.MemoryAdapterError = MemoryAdapterError;
+exports.NetworkError = NetworkError;
+exports.RateLimitError = RateLimitError;
+exports.TaskNotFoundError = TaskNotFoundError;
+exports.TheokitAgentError = TheokitAgentError;
+exports.UnknownAgentError = UnknownAgentError;
+exports.UnsupportedBudgetOperationError = UnsupportedBudgetOperationError;
+exports.UnsupportedRunOperationError = UnsupportedRunOperationError;
+exports.UnsupportedTaskOperationError = UnsupportedTaskOperationError;
+//# sourceMappingURL=errors.cjs.map
+//# sourceMappingURL=errors.cjs.map