@theokit/sdk 0.0.0-compat-580-20260905204608

package/dist/errors-DrDEgyz1.d.cts

@@ -0,0 +1,569 @@
+import { T as TheokitAgentError, a as ErrorCode, E as ErrorMetadata } from './errors-base-B5g01neU.cjs';
+import { K as RunOperation } from './run-CTAdRU3U.cjs';
+
+/**
+ * Owner: `internal/budget/` (4 of 6 importers). Derived from the import graph, not declared —
+ * `tests/lint/types-name-their-owner.test.ts` re-derives it.
+ *
+ * Public type contract for the Budget enforcement primitive
+ * (ADRs D375, D382-D387). The runtime facade lives in `budget.ts`.
+ *
+ * @public
+ */
+/**
+ * Accounting scope for a budget.
+ *
+ * ONLY `"process"` is implemented, and `Budget.create` now REFUSES the other two with
+ * `unimplemented_budget_scope`. It used to accept them: nothing outside the registry read `scope`, so
+ * a caller asking for per-agent accounting silently got process-wide accounting — a cost control
+ * reporting the wrong number, which is worse than the missing feature.
+ *
+ * The union is not narrowed to `"process"` here because that is a breaking change to a published
+ * type and belongs to a major. Widening it back when the scopes are built is non-breaking.
+ */
+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;
+}
+
+/**
+ * Errors raised by the Task API (`src/task.ts`).
+ *
+ * One actor, one module: these three are about task identity and task lifecycle, and they change
+ * when the Task surface changes rather than when the agent-run surface does. They extend
+ * `TheokitAgentError` like every other error in this package — the hierarchy is the contract, and
+ * `tests/lint/every-error-is-in-the-hierarchy.test.ts` enforces it wherever the class lives.
+ *
+ * Re-exported from `errors.ts`, so `@theokit/sdk/errors` still names every error in one place.
+ *
+ * NOTE ON THE MODULE TAG: this header deliberately carries no internal-visibility tag, and does not
+ * even name one — TypeScript attaches a file-leading docblock to the FIRST declaration below it, and
+ * `stripInternal: true` (tsconfig.base) then deletes that declaration from the emitted `.d.ts`.
+ * `tsc --noEmit` stays clean and the declaration rollup fails with `"X" is not exported by "..."`.
+ * Measured twice on this file on 2026-09-01: once with the tag, and again when the comment
+ * EXPLAINING the trap quoted the tag verbatim and re-armed it.
+ */
+
+/**
+ * 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;
+    });
+}
+
+/**
+ * T1.1 — closed literal union for `AgentRunError.code`. The previous
+ * `(string & {})` escape hatch let arbitrary strings slip into the type
+ * surface and defeated exhaustive `switch (code)` discrimination. This is
+ * the canonical closed form. `AgentRunErrorCode` is re-aliased below for
+ * source-level back-compat.
+ *
+ * Superset of {@link ErrorCode}, extended with codes that do NOT originate from a
+ * provider HTTP response (Production-Readiness #3, ADR D311):
+ *
+ * - `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
+ *
+ * Adding a new code: append the literal here AND audit every `switch (err.code)`
+ * in callers. Type-checker enforces the audit via the `default: assertNever(code)`
+ * convention.
+ *
+ * @public
+ */
+type KnownAgentRunErrorCode = ErrorCode | "quota_exceeded" | "tool_runtime_error" | "aborted" | "invalid_model" | "safety_blocked" | "provider_unreachable";
+/**
+ * Back-compat alias of {@link KnownAgentRunErrorCode}. Pre-T1.1 callers that
+ * imported `AgentRunErrorCode` keep working; new code SHOULD prefer
+ * `KnownAgentRunErrorCode` to make the closed-union intent explicit.
+ *
+ * @public
+ */
+type AgentRunErrorCode = KnownAgentRunErrorCode;
+/**
+ * T1.1 boundary helper — coerce an arbitrary string (typically arriving from
+ * a downstream `RunErrorDetail.code` or a deserialized cloud response) into a
+ * `KnownAgentRunErrorCode`.
+ *
+ * A string that is not one of the known codes collapses to `"unknown"`, and so
+ * does `undefined` — the parameter is optional precisely so a caller can forward
+ * an absent `code` without a guard. The closed type contract therefore holds at
+ * the boundary without forcing every caller to switch.
+ *
+ * This is the migration path the 4.x release notes point at for code that used
+ * to rely on `AgentRunErrorCode` being an open string union.
+ *
+ * @public
+ */
+declare function coerceToKnownAgentRunErrorCode(code: string | undefined): KnownAgentRunErrorCode;
+/**
+ * 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 + T1.5: alias for `metadata.raw`. Provider response body for
+     * debugging. T1.5 wraps the value in `redactSecrets` at the getter
+     * boundary so secret-shaped substrings (`sk-...`, Bearer JWTs, etc.) are
+     * stripped before reaching the caller. Available but NEVER serialized
+     * into `.message` (anti-leak invariant).
+     */
+    get providerError(): unknown;
+    /**
+     * T1.5 — sanitized JSON form. `metadata.raw` is OMITTED by default; opt
+     * in via `THEOKIT_DEBUG_RAW_ERRORS=1` to surface the (redacted) raw
+     * payload for diagnostics. Every other field stays accessible.
+     *
+     * The single env-var gate is read each call so operators can toggle at
+     * runtime without restarting the process.
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Is this error transient (worth retrying)?
+ *
+ * Returns the SDK's own retryability verdict: every {@link TheokitAgentError}
+ * subclass computes `isRetryable` at construction (rate-limit / network /
+ * credential-pool-exhausted are retryable; auth / configuration / unsupported
+ * are not), so this predicate is a single source of truth rather than a
+ * re-derivation. Non-SDK errors return `false` conservatively — wrap a foreign
+ * error in the appropriate SDK error first if you want it considered transient.
+ * It never inspects `err.message`.
+ *
+ * @example
+ *   try {
+ *     await agent.send(message, { throwOnError: true });
+ *   } catch (err) {
+ *     if (isTransientError(err)) return retryWithBackoff();
+ *     throw err;
+ *   }
+ *
+ * @public
+ */
+declare function isTransientError(err: unknown): boolean;
+/**
+ * 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 by `Budget` enforcement (ADR D386) when a `mode: "block"`
+ * budget would be exceeded by the upcoming LLM call. The caller catches a
+ * typed error to retry after the window resets, or surfaces it 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;
+    });
+}
+/**
+ * T1.6 — Thrown when a consumer calls `agent.send()` or any method
+ * on an agent that has already been `dispose()`d. Pre-T1.6 this was
+ * a generic `new Error("Agent has been disposed")` — consumers
+ * couldn't catch it without string-matching the message.
+ *
+ * @public
+ */
+declare class AgentDisposedError extends TheokitAgentError {
+    readonly name: string;
+    readonly agentId: string;
+    constructor(agentId: string);
+}
+/**
+ * Thrown when a budget operation is requested on a `CloudAgent` (D388). The cloud budget surface
+ * waits for Theo PaaS GA, so the operation is not merely failing — it does not exist yet.
+ *
+ * Not retryable: `isRetryable` is `false`, and retrying cannot change the outcome until the
+ * feature ships. Catch it by `instanceof`, or by `code === "budget_op_unsupported"` when the
+ * error has crossed a serialization boundary that dropped the prototype. `operation` carries the
+ * name that was refused and is interpolated into the message.
+ *
+ * The local agent does not raise this — the same call against a local agent runs the budget path
+ * normally.
+ *
+ * @public
+ */
+declare class UnsupportedBudgetOperationError extends TheokitAgentError {
+    readonly name: string;
+    readonly operation: string;
+    constructor(operation: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Why a structured-output call failed.
+ *
+ * A named union rather than a repeated inline one: the narrow form was written out at the class AND
+ * in `agent-generate.ts`'s local type, so widening it meant finding both. One name, one edit.
+ *
+ * @public
+ */
+type StructuredOutputErrorCode = 
+/** The model did not call the forced output tool. The original meaning, unchanged. */
+"no_tool_call"
+/** The tool was called and its arguments did not parse against the schema. */
+ | "parse_failed"
+/** The agent run errored before there was an answer to structure. */
+ | "upstream_run_failed"
+/** The agent run was cancelled before there was an answer to structure. */
+ | "run_cancelled"
+/** The loop finished with tools only and produced no text to structure. */
+ | "no_text_answer";
+/**
+ * The failure contract shared by `generateObject` and `streamObject`.
+ *
+ * Both entry points run the same rule — up to `maxRetries` attempts; if the model never called the
+ * output tool, fail as `no_tool_call`, naming the underlying run error when there was one; if the
+ * schema never parsed, fail as `parse_failed` — and both declared their own error class for it, with
+ * byte-identical user-facing strings. A change to the taxonomy or the wording had to be made twice,
+ * or the two APIs would start describing the same failure differently.
+ *
+ * It extends `TheokitAgentError` because every typed error the SDK publishes does, and these two did
+ * not: a consumer catching `TheokitAgentError` — the documented way to catch anything this SDK throws
+ * — silently missed both, and neither carried `isRetryable`.
+ *
+ * It lives HERE rather than beside the two entry points because it is an error class and this is the
+ * error module. The first home was `internal/structured-output-helpers.ts`, and rollup-plugin-dts
+ * could not resolve it from there when bundling the root declaration — a failure `tsc --noEmit`
+ * does not see, because it never runs the declaration rollup.
+ *
+ * `isRetryable` is false. Both codes mean the model did not produce the requested shape; the caller's
+ * own `maxRetries` has already been spent by the time either is thrown, so an outer retry loop would
+ * re-run a sequence that already gave up.
+ *
+ * The two public names stay DISTINCT subclasses rather than aliases of this one. Collapsing them
+ * would make `streamObjectError instanceof GenerateObjectError` true, which is a semantic widening
+ * nobody asked for; the duplication being removed is the contract, not the identity.
+ *
+ * @public
+ */
+declare class StructuredOutputError extends TheokitAgentError {
+    readonly name: string;
+    /**
+     * Why the structuring failed.
+     *
+     * Three of these are new, and they name causes the SDK ALREADY distinguished in prose while
+     * reporting all three as `no_tool_call`: an upstream run that errored, a run that was cancelled,
+     * and a tool-only completion with no text to structure. Three tests asserted the byte-identical
+     * oracle for three genuinely different setups — swap any two and all three still passed — because
+     * the only thing that differed was the free-text message.
+     *
+     * `no_tool_call` keeps its original meaning: the model did not call the forced output tool.
+     */
+    readonly code: "no_tool_call" | "parse_failed" | "upstream_run_failed" | "run_cancelled" | "no_text_answer";
+    constructor(code: "no_tool_call" | "parse_failed" | "upstream_run_failed" | "run_cancelled" | "no_text_answer", message: string, cause?: unknown);
+}
+
+export { AgentDisposedError as A, type BudgetOptions as B, ConfigurationError as C, IntegrationNotConnectedError as I, type KnownAgentRunErrorCode as K, MemoryAdapterError as M, NetworkError as N, RateLimitError as R, StructuredOutputError as S, TaskNotFoundError as T, UnknownAgentError as U, type BudgetHandle as a, type BudgetSnapshot as b, AgentRunError as c, type AgentRunErrorCode as d, AuthenticationError as e, type BudgetExceedEvent as f, BudgetExceededError as g, type BudgetLimit as h, type BudgetMode as i, type BudgetScope as j, type BudgetThresholdEvent as k, type BudgetWindow as l, InvalidTaskIdError as m, type MemoryAdapterErrorCode as n, UnsupportedBudgetOperationError as o, UnsupportedRunOperationError as p, UnsupportedTaskOperationError as q, isTransientError as r, CredentialPoolExhaustedError as s, type StructuredOutputErrorCode as t, coerceToKnownAgentRunErrorCode as u };

package/dist/errors-base-B5g01neU.d.cts

@@ -0,0 +1,75 @@
+/**
+ * The root of the SDK error hierarchy, and the two types it is built from.
+ *
+ * A LEAF module on purpose: every other error in this package extends `TheokitAgentError`, and
+ * `errors.ts` re-exports the ones that live in their own files. If the root lived in that catalogue,
+ * each sibling would import it from a file that imports the sibling — a cycle madge reports and
+ * `tests/architecture/no-cycles-at-all.test.ts` fails on. `types/messages-base.ts` exists for the
+ * same reason, one layer over.
+ *
+ * Re-exported from `errors.ts`, so `@theokit/sdk/errors` is unchanged and consumers keep catching
+ * `TheokitAgentError` from where the README tells them to.
+ *
+ * NOTE ON THE MODULE TAG: this header deliberately carries no internal-visibility tag, and does not
+ * even name one — TypeScript attaches a file-leading docblock to the FIRST declaration below it, and
+ * `stripInternal: true` (tsconfig.base) then deletes that declaration from the emitted `.d.ts`.
+ * `tsc --noEmit` stays clean and the declaration rollup fails with `"X" is not exported by "..."`.
+ * Measured twice on this file on 2026-09-01: once with the tag, and again when the comment
+ * EXPLAINING the trap quoted the tag verbatim and re-armed it.
+ */
+/**
+ * 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" | "quota_exceeded" | "unknown";
+/**
+ * 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;
+    });
+}
+
+export { type ErrorMetadata as E, TheokitAgentError as T, type ErrorCode as a };