@theokit/sdk 1.5.0

package/dist/internal/agent-loop/loop-types.d.ts

@@ -0,0 +1,29 @@
+import type { ConversationTurn } from "../../types/conversation.js";
+import type { SDKMessage } from "../../types/messages.js";
+import type { RunStatus } from "../../types/run.js";
+export interface AgentLoopOutput {
+    events: SDKMessage[];
+    finalStatus: RunStatus;
+    result: string;
+    conversation: ConversationTurn[];
+    /**
+     * Aggregated token usage across every LLM call in this loop (ADR D376).
+     * Populated whenever ≥1 LLM call completed — including partial-failure
+     * runs (EC-5). Undefined when zero LLM calls fired (e.g., abort before
+     * first send, or fixture-mode path that bypasses this loop).
+     */
+    usage?: import("../../types/usage.js").TokenUsage;
+    /**
+     * Inferred pricing-based cost matching `usage` (ADR D377). Set when the
+     * model has a pricing entry in the registry; `cost.status` is
+     * `"estimated"` / `"unknown"` / `"included"` per D377.
+     */
+    cost?: import("../../types/usage.js").CostBreakdown;
+    /**
+     * Structured error from transport / provider failure (Finding B fix).
+     * When set, `finalStatus === "error"`. Downstream surfaces (runtime,
+     * `RunResult.error`) copy this verbatim. NEVER leaks as an assistant
+     * message (the previous bug — sdk-error-packaging-fix-plan).
+     */
+    error?: AgentLoopErrorDetail;
+}

package/dist/internal/agent-loop/loop.d.ts

@@ -0,0 +1,2 @@
+import type { AgentLoopInputs, AgentLoopOutput } from "./loop-types.js";
+export declare function runAgentLoop(inputs: AgentLoopInputs): Promise<AgentLoopOutput>;

package/dist/internal/agent-loop/message-builders.d.ts

@@ -0,0 +1,6 @@
+import type { SDKAssistantMessage, SDKUserMessageEvent } from "../../types/messages.js";
+import type { LlmMessage, LlmToolCallPart } from "../llm/types.js";
+import type { AgentLoopInputs } from "./loop-types.js";
+export declare function buildUserEvent(inputs: AgentLoopInputs): SDKUserMessageEvent;
+export declare function buildAssistantEvent(inputs: AgentLoopInputs, text: string): SDKAssistantMessage;
+export declare function buildAssistantTurn(text: string, toolCalls: LlmToolCallPart[]): LlmMessage;

package/dist/internal/agent-loop/tool-dispatch.d.ts

@@ -0,0 +1,4 @@
+import type { SDKMessage } from "../../types/messages.js";
+import type { LlmContentPart, LlmToolCallPart } from "../llm/types.js";
+import type { AgentLoopInputs } from "./loop-types.js";
+export declare function dispatchTools(inputs: AgentLoopInputs, tools: ResolvedTool[], toolCalls: LlmToolCallPart[], events: SDKMessage[]): Promise<LlmContentPart[]>;

package/dist/internal/agent-loop/usage-and-cost.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Usage + cost helpers extracted from `loop.ts` (ADRs D376/D377).
+ *
+ * - `accumulateUsage(usage, llmOutput)` — merge a single LLM turn's 5-bucket
+ *   token counts into the per-loop {@link UsageAccumulator}. Early-returns
+ *   when no bucket was populated (avoids spurious zero-step entries on
+ *   pure-error turns).
+ * - `computeUsageCost(inputs, usage)` — resolve provider+model from the
+ *   `model.id` prefix (with LlmClient.name fallback) and run the pricing
+ *   registry lookup to produce the matching `CostBreakdown`. Returns
+ *   `undefined` for the `auto` sentinel model.
+ *
+ * @internal
+ */
+import type { UsageAccumulator } from "../budget/usage-accumulator.js";
+import type { AgentLoopInputs } from "./loop-types.js";
+export interface LlmTurnUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+}
+export declare function accumulateUsage(usage: UsageAccumulator, turn: LlmTurnUsage): void;
+export declare function computeUsageCost(inputs: AgentLoopInputs, usage: TokenUsage): CostBreakdown | undefined;

package/dist/internal/budget/calendar-window.d.ts

@@ -0,0 +1,19 @@
+/**
+ * UTC-aligned calendar window helpers (ADR D382).
+ *
+ * - `1h` — relative (now - 1 hour).
+ * - `1d` — UTC midnight (current UTC day).
+ * - `1w` — UTC monday 00:00:00 (current UTC week, Monday is week start).
+ * - `30d` — relative 30 days.
+ * - `365d` — relative 365 days.
+ *
+ * `1d` and `1w` are calendar-aligned because users expect "1 USD per day"
+ * = "since midnight UTC", not a rolling 24h.
+ * `30d`/`365d` are relative because nobody expects "since the 1st".
+ *
+ * @internal
+ */
+export declare function startOfDayUtc(now?: Date): Date;
+export declare function startOfWeekUtc(now?: Date): Date;
+/** Returns the inclusive start timestamp (ms) for the given window relative to `now`. */
+export declare function windowStartMs(window: BudgetWindow, now?: Date): number;

package/dist/internal/budget/compute-cost.d.ts

@@ -0,0 +1,28 @@
+/**
+ * computeCost — apply pricing entries to a TokenUsage and produce a
+ * CostBreakdown (ADRs D377, D378).
+ *
+ * Edge cases absorbed:
+ *   - EC-13: negative pricing → status="unknown" + note.
+ *   - EC-14: reasoning tokens fall back to outputCostPerMillion when
+ *     dedicated reasoning rate is undefined.
+ *   - EC-12: money precision via microcent normalization (× 1e6).
+ *   - "subscription_included" routes (Codex CLI, future Claude Pro) →
+ *     return $0 with status="included".
+ *   - Provider unknown / pricing missing → status="unknown" with
+ *     undefined amountUsd (NÃO retorna 0 falso).
+ *
+ * @internal
+ */
+interface ComputeArgs {
+    readonly usage: TokenUsage;
+    readonly provider: string;
+    readonly model: string;
+    readonly baseUrl?: string;
+}
+/**
+ * Returns CostBreakdown with `status="estimated"`, `"unknown"`, or
+ * `"included"`. Never throws; never returns 0 when pricing is missing.
+ */
+export declare function computeCost(args: ComputeArgs): CostBreakdown;
+export {};

package/dist/internal/budget/enforcement.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Budget enforcement (ADRs D383, D386, EC-7/8/9).
+ *
+ * - `preflightCheck(name, estimatedUsd)` — em `block` mode, throw
+ *   `BudgetExceededError` antes da LLM call se qualquer limit seria
+ *   excedido (EC-9 — caller chama dentro do mutex section).
+ * - `chargeAndCheckThresholds(name, actualUsd)` — apply charge ao
+ *   ledger + invoca onThreshold/onExceed callbacks isolated em
+ *   try/catch (EC-8).
+ *
+ * @internal
+ */
+/**
+ * Throws BudgetExceededError if `mode === "block"` and any limit
+ * would be exceeded. No-op for audit/warn modes (post-charge checks
+ * handle those).
+ *
+ * Caller invokes this BEFORE the LLM call.
+ */
+export declare function preflightCheck(name: string, estimatedUsd: number): void;
+/**
+ * Charge the budget + dispatch threshold/exceed callbacks (EC-8 isolated).
+ *
+ * - In `audit` mode: charge only, no callbacks.
+ * - In `warn` mode: charge + onThreshold (80/95) + onExceed (100). No throw.
+ * - In `block` mode: charge + onThreshold + onExceed. No throw post-call
+ *   (preflightCheck already prevented exceed for the upcoming call;
+ *   this protects against simultaneous-call races where multiple sends
+ *   each pass preflight independently — last one to charge may still
+ *   tip a limit. We document the case rather than retroactively throw).
+ */
+export declare function chargeAndCheckThresholds(name: string, actualUsd: number): Promise<void>;

package/dist/internal/budget/ledger.d.ts

@@ -0,0 +1,25 @@
+/**
+ * In-process Budget ledger (ADR D385).
+ *
+ * Singleton mutex-protected. Stores per-budget ChargeLog[] arrays;
+ * `spentIn(window)` filters by timestamp.
+ *
+ * EC-6: GC eviction runs DENTRO do mesmo mutex que charge — sem race.
+ * EC-9: charge() é called inside same critical section as preflight
+ * check by Budget enforcement.
+ *
+ * Persistence cross-restart: deferred to v0.2 (JsonFile pattern).
+ *
+ * @internal
+ */
+/** Charge a budget. Idempotent across concurrent calls via withCwdMutex. */
+export declare function charge(name: string, amountUsd: number): Promise<void>;
+/** Return total spend in the given window for `name`. Snapshot read (no mutex needed). */
+export declare function spentIn(name: string, window: BudgetWindow, now?: Date): number;
+/** Diagnostic — total logs across all budgets. */
+export declare function __getLogCountForTests(name?: string): number;
+export declare function __resetLedgerForTests(): void;
+/** Force GC manually (tests only). */
+export declare function __evictNowForTests(): Promise<void>;
+/** Force-insert a log at a specific timestamp (tests only). */
+export declare function __injectLogForTests(name: string, timestamp: number, amountUsd: number): void;

package/dist/internal/budget/normalize-usage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * normalizeUsage — convert provider-shaped raw `usage` object to
+ * canonical `TokenUsage`. Ports Hermes Agent's `normalize_usage`
+ * (referencia/hermes-agent/agent/usage_pricing.py:672-742).
+ *
+ * Handles 3 API shapes:
+ *   - Anthropic Messages: 4 explicit buckets (input/output/cache_read/cache_creation).
+ *   - OpenAI Chat Completions: prompt_tokens INCLUDES cache; subtract cached_tokens.
+ *   - OpenAI Responses (Codex): input_tokens INCLUDES cache; same subtraction.
+ *
+ * Edge cases:
+ *   - cline#10266 — OpenAI-compat proxies (OpenRouter, Vercel AI Gateway,
+ *     Cline) routing Claude expose Anthropic-style top-level fields
+ *     (cache_read_input_tokens / cache_creation_input_tokens). Both
+ *     locations are checked with top-level fallback.
+ *   - Null/undefined fields → 0 via `int()` coerce.
+ *   - String token counts → parsed via int.
+ *   - Negative values → clamped to 0 (defensive against proxy bugs).
+ *
+ * @internal
+ */
+export type ApiMode = "anthropic_messages" | "openai_chat_completions" | "openai_responses";
+export declare function inferApiMode(provider: string): ApiMode;
+export declare function normalizeUsage(rawUsage: unknown, opts: {
+    provider: string;
+    apiMode?: ApiMode;
+}): TokenUsage;

package/dist/internal/budget/pricing-registry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pricing registry — bundled snapshot of LiteLLM JSON (ADR D379) with
+ * lazy load + alias normalization (EC-2).
+ *
+ * Snapshot lives in `pricing-data.json` (hand-curated 2026-05; refresh
+ * via `scripts/refresh-pricing.mjs`). All rates in USD per 1_000_000
+ * tokens (D378).
+ *
+ * Lookup precedence (EC-2):
+ *   1. Direct `provider/model` key
+ *   2. Strip date suffix (-YYYYMMDD or -YYYY-MM-DD)
+ *   3. Anthropic dot-to-dash normalization (claude-opus-4.7 → claude-opus-4-7)
+ *   4. Strip `openrouter/` prefix
+ *
+ * @internal
+ */
+export interface PricingEntry {
+    readonly provider: string;
+    readonly model: string;
+    readonly inputCostPerMillion: number;
+    readonly outputCostPerMillion: number;
+    readonly cacheReadCostPerMillion?: number;
+    readonly cacheWriteCostPerMillion?: number;
+    readonly reasoningCostPerMillion?: number;
+    readonly pricingVersion: string;
+}
+/**
+ * Returns the pricing entry for a given `{provider, model}` route.
+ * Tries direct lookup, then 3 alias normalizations (EC-2).
+ */
+export declare function getPricingEntry(opts: {
+    provider: string;
+    model: string;
+    baseUrl?: string;
+}): PricingEntry | undefined;
+export declare function pricingVersion(): string;

package/dist/internal/budget/registry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Internal Budget registry — keeps live `BudgetOptions` per name.
+ * Singleton; no persistence (D385).
+ *
+ * @internal
+ */
+import type { BudgetHandle, BudgetMode, BudgetOptions, BudgetSnapshot } from "../../types/budget.js";
+export declare function __resetRegistryForTests(): void;
+export declare function validateBudgetName(name: string): void;
+export declare function createBudget(opts: BudgetOptions): BudgetHandle;
+export declare function getBudget(name: string): BudgetHandle | undefined;
+export declare function listBudgets(): readonly BudgetHandle[];
+export declare function deleteBudget(name: string): boolean;
+export declare function snapshotAll(): readonly BudgetSnapshot[];
+export declare function getBudgetOptionsRaw(name: string): BudgetOptions | undefined;
+export declare function defaultMode(opts: BudgetOptions): BudgetMode;

package/dist/internal/budget/usage-accumulator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * UsageAccumulator — aggregate multi-step `LlmFinish` token counts
+ * into a canonical `TokenUsage` (ADR D376, mirror openai-agents-python
+ * `Usage.add`).
+ *
+ * Each `add(step)` merges in a per-step finish; `toTokenUsage()`
+ * produces the aggregated public shape with `requests[]` populated
+ * when there were ≥2 steps.
+ *
+ * @internal
+ */
+interface StepUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    reasoningTokens?: number;
+}
+export declare class UsageAccumulator {
+    private input;
+    private output;
+    private cacheRead;
+    private cacheWrite;
+    private reasoning;
+    private readonly requests;
+    add(step: StepUsage): void;
+    /** Did we observe any usage at all? */
+    hasAny(): boolean;
+    toTokenUsage(): TokenUsage;
+}
+export {};

package/dist/internal/cache/cosine.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cosine distance between two equal-length vectors.
+ *
+ * Returns `1 - cos(a, b)`. Range:
+ *   - 0.0 = identical direction
+ *   - 1.0 = orthogonal
+ *   - 2.0 = opposite (rare in normalized embeddings)
+ *
+ * Throws on dim mismatch. (Callers MUST filter by dim before calling
+ * — EC-2 absorbed at the store level.)
+ *
+ * @internal
+ */
+export {};

package/dist/internal/cache/embed-helper.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared embed-with-graceful-degradation helper — used by both `lookup.ts`
+ * and `store-handler.ts`. Extracted to remove the embed-failure boilerplate
+ * clone flagged by jscpd. EC-1 absorbed: embedder failure is silent (caller
+ * decides what to do via the boolean return).
+ *
+ * @internal
+ */
+import type { InMemoryCacheStore } from "./store.js";
+import type { JsonFileCacheStore } from "./store-json.js";
+interface SpanLike {
+    setAttribute(key: string, value: string | number | boolean): SpanLike;
+}
+export declare function embedOrDegrade(embedder: CacheEmbedderRuntime, prompt: string, store: InMemoryCacheStore | JsonFileCacheStore, span: SpanLike, context: "lookup" | "store"): Promise<number[] | undefined>;
+export {};

package/dist/internal/cache/key.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Composite cache key (ADR D253).
+ *
+ * Format: `${namespace}:${embedderId}:${modelId}:${hash(normalizedPrompt)}`.
+ * Normalizes whitespace + lowercases. Hash = first 16 hex chars of SHA-256.
+ *
+ * @internal
+ */
+export interface CacheKeyParams {
+    namespace: string;
+    embedderId: string;
+    modelId: string;
+    prompt: string;
+}
+export declare function computeCacheKey(p: CacheKeyParams): string;

package/dist/internal/cache/lookup.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Cache lookup handler — wired to `pre_user_send` hook (ADRs D259, D260).
+ *
+ * EC-1: embedder failure degrades to miss (cache is transparent).
+ * EC-3: empty / whitespace prompt bypasses cache (avoids hash collision).
+ * EC-5: telemetry span ends in finally even on early-return.
+ *
+ * @internal
+ */
+import type { InMemoryCacheStore } from "./store.js";
+import type { JsonFileCacheStore } from "./store-json.js";
+export type LookupableStore = InMemoryCacheStore | JsonFileCacheStore;
+export interface LookupParams {
+    prompt: string;
+    store: LookupableStore;
+    embedder: CacheEmbedderRuntime;
+    threshold: number;
+    ttl: CacheTTLConfig;
+    namespace: string;
+    modelId: string;
+}
+export interface LookupResult {
+    cached: boolean;
+    response?: string;
+    source?: "kv" | "semantic";
+    distance?: number;
+}
+export declare function performLookup(p: LookupParams): Promise<LookupResult>;

package/dist/internal/cache/store-handler.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Cache store handler — wired to `post_assistant_reply` hook (ADRs D260, D266).
+ *
+ * EC-1: embedder failure during store is silent (LLM call already succeeded;
+ * no cache entry written).
+ * EC-3: empty prompt bypass.
+ * EC-10 / D266: skip storage when the run invoked tools (replay loses
+ * side-effects).
+ *
+ * @internal
+ */
+import type { LookupableStore } from "./lookup.js";
+export interface StoreParams {
+    prompt: string;
+    response: string;
+    /** D266: skip cache when tools were used. */
+    usedTools?: boolean;
+    store: LookupableStore;
+    embedder: CacheEmbedderRuntime;
+    ttl: CacheTTLConfig;
+    namespace: string;
+    modelId: string;
+}
+export declare function performStore(p: StoreParams): Promise<void>;

package/dist/internal/cache/store-json.d.ts

@@ -0,0 +1,48 @@
+/**
+ * JSON disk-backed cache store (ADR D265).
+ *
+ * One file per namespace at `<dir>/<namespace>.json`. Uses
+ * `atomicWriteText` (D60) for crash-safe writes. Debounced flush (200ms)
+ * to coalesce bursts.
+ *
+ * EC-7: corrupt JSON load → log warn + treat as empty cache. Never
+ * propagates parse errors that would block `Agent.create`.
+ *
+ * Layered behind `InMemoryCacheStore` — disk is just persistence; all
+ * lookups still hit the in-memory Map for O(1) KV / O(N) vector scan.
+ *
+ * @internal
+ */
+import type { CacheEntry, CacheStats } from "../../types/cache.js";
+import { type CacheStore } from "./store.js";
+export declare class JsonFileCacheStore implements CacheStore {
+    private readonly dir;
+    private readonly namespace;
+    private readonly inner;
+    private flushTimer;
+    private dirty;
+    constructor(dir: string, namespace: string, maxEntries: number);
+    /** Hydrate from disk. EC-7: corrupt file → empty cache. */
+    hydrate(): Promise<void>;
+    kvGet(key: string, now: number): CacheEntry | undefined;
+    semanticSearch(vector: ReadonlyArray<number>, threshold: number, embedderId: string, namespace: string, now: number): {
+        entry: CacheEntry;
+        distance: number;
+    } | undefined;
+    set(entry: CacheEntry): void;
+    delete(key: string): void;
+    clear(): Promise<void>;
+    stats(): CacheStats;
+    evictExpired(now: number): number;
+    /** Force write the current snapshot. Called on shutdown / clear. */
+    flush(): Promise<void>;
+    /** Counters proxied to inner. */
+    incrementKvHits(): void;
+    incrementSemanticHits(): void;
+    incrementMisses(): void;
+    incrementExcluded(): void;
+    incrementEmbedderFailures(): void;
+    private filePath;
+    private markDirty;
+    private writeSnapshot;
+}

package/dist/internal/cache/store.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Cache store interface + in-memory implementation (ADRs D252, D259, D261).
+ *
+ * INVARIANT (EC-9, EC-13): KV map and vector view are the SAME Map.
+ * `semanticSearch` iterates `Map.values()`. No parallel list. `set` replaces
+ * by key (Map semantics) — no duplicate-on-race possible.
+ *
+ * EC-2: `semanticSearch` filters by `embedderId === currentEmbedderId &&
+ * vector.length === currentDim` before cosine compare. Protects against
+ * dim mismatch when disk-loaded entries used a different embedder.
+ *
+ * @internal
+ */
+export interface CacheStore {
+    kvGet(key: string, now: number): CacheEntry | undefined;
+    semanticSearch(vector: ReadonlyArray<number>, threshold: number, embedderId: string, namespace: string, now: number): {
+        entry: CacheEntry;
+        distance: number;
+    } | undefined;
+    set(entry: CacheEntry): void;
+    delete(key: string): void;
+    clear(): Promise<void>;
+    stats(): CacheStats;
+    evictExpired(now: number): number;
+    /** For persistence backends — bulk import. */
+    loadAll?(entries: ReadonlyArray<CacheEntry>): void;
+    /** For persistence backends — snapshot for serialization. */
+    dump?(): ReadonlyArray<CacheEntry>;
+}
+export declare class InMemoryCacheStore implements CacheStore {
+    private readonly maxEntries;
+    private readonly map;
+    private readonly counters;
+    constructor(maxEntries: number);
+    kvGet(key: string, now: number): CacheEntry | undefined;
+    private isEligibleForSearch;
+    semanticSearch(vector: ReadonlyArray<number>, threshold: number, embedderId: string, namespace: string, now: number): {
+        entry: CacheEntry;
+        distance: number;
+    } | undefined;
+    set(entry: CacheEntry): void;
+    delete(key: string): void;
+    clear(): Promise<void>;
+    stats(): CacheStats;
+    evictExpired(now: number): number;
+    loadAll(entries: ReadonlyArray<CacheEntry>): void;
+    dump(): ReadonlyArray<CacheEntry>;
+    /** Internal helpers for counters (used by lookup/store handlers). */
+    incrementKvHits(): void;
+    incrementSemanticHits(): void;
+    incrementMisses(): void;
+    incrementExcluded(): void;
+    incrementEmbedderFailures(): void;
+}

package/dist/internal/cache/telemetry.d.ts

@@ -0,0 +1,20 @@
+/**
+ * OTel telemetry for semantic cache (ADR D262).
+ *
+ * Spans:
+ *   - `cache.lookup` — per `pre_user_send`. Attributes: namespace, embedder.id,
+ *     hit (kv|semantic|miss), distance, ttl_remaining_s, bypass_reason.
+ *   - `cache.store` — per `post_assistant_reply`. Attributes: bypass_reason, stored.
+ *
+ * @internal
+ */
+export declare function startCacheLookupSpan(info: {
+    namespace: string;
+    embedderId: string;
+}): SpanLike;
+export declare function startCacheStoreSpan(info: {
+    namespace: string;
+    embedderId: string;
+}): SpanLike;
+/** Test seam — reset tracer cache so a fresh require attempt happens. */
+export declare function __resetCacheTelemetryForTests(): void;

package/dist/internal/cache/ttl.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TTL string parser. Accepts:
+ *   - number → treated as SECONDS
+ *   - string `"\d+(s|m|h|d|w)"` → seconds/minutes/hours/days/weeks
+ *
+ * EC-8: `"0s"` / `0` returns 0 (effectively disables cache for that entry).
+ *       Negative numbers throw `CacheInvalidTtlError`.
+ *
+ * @internal
+ */
+export declare function parseTtlMs(input: string | number): number;

package/dist/internal/catalog/fixtures.d.ts

@@ -0,0 +1,16 @@
+import type { SDKProvider } from "../../types/providers.js";
+import type { SDKModel, SDKRepository, SDKUser } from "../../types/theokit.js";
+/** Fixture user identity (matches `tests/golden/theokit/me.json`). */
+export declare const FIXTURE_USER: SDKUser;
+/** Fixture model catalog (matches `tests/golden/theokit/models.json`). */
+export declare const FIXTURE_MODELS: SDKModel[];
+/** Fixture connected repos (matches `tests/golden/theokit/repositories.json`). */
+export declare const FIXTURE_REPOSITORIES: SDKRepository[];
+/**
+ * Fixture provider catalog. Covers chat, web_search, image, and embedding
+ * capabilities. The `setupSchema` is intentionally generic JSON Schema —
+ * consumers drive UI from these definitions.
+ *
+ * Public and secret-free by design — no tokens or API key examples.
+ */
+export declare const FIXTURE_PROVIDERS: SDKProvider[];

package/dist/internal/catalog/local-models.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Local model discovery via OpenAI-compatible `/v1/models` endpoint
+ * (T2.1, ADR D184).
+ *
+ * Used by `Theokit.models.list({ provider: "ollama" })` (and any other
+ * future provider with `authType: "none"` exposing the OpenAI-shape
+ * models endpoint — LM Studio, llama.cpp `./server`, vLLM, etc.) to
+ * enumerate locally-installed models without a cloud round-trip.
+ *
+ * Aligned with OpenClaw `extensions/ollama/src/provider-models.ts` which
+ * targets the same endpoint shape. Mirrors the relevant Hermes
+ * `models.dev` catalog behavior for local providers.
+ *
+ * @internal
+ */
+import type { SDKModel } from "../../types/theokit.js";
+/**
+ * Fetch and map `<baseUrl>/v1/models` → `SDKModel[]`. Throws a typed
+ * `ConfigurationError` on connection failures (ECONNREFUSED → "Run
+ * `ollama serve`"). Returns `[]` when the body is unparseable —
+ * defensive choice over crashing on malformed responses from
+ * non-standard local runtimes.
+ */
+export declare function listLocalModelsViaOpenAiCompat(baseUrl: string): Promise<SDKModel[]>;

package/dist/internal/cron/run-job.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/cron/scheduler.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/cron/store.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/cron/validate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/env.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/errors/mappers/anthropic.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Anthropic HTTP error mapper (ADR D67).
+ *
+ * Translates an Anthropic API error response into a typed
+ * `TheokitAgentError` subclass with full `ErrorMetadata`. Mapping rules:
+ *
+ *   401/403 → `AuthenticationError`  (`code: "auth_failed"`)
+ *   429     → `RateLimitError`        (`code: "rate_limit"`)
+ *   400     → `ConfigurationError`    (`code: "context_too_long"` if body
+ *                                       mentions context length, else
+ *                                       `"invalid_request"`; or
+ *                                       `"content_filtered"` for policy.)
+ *   408     → `NetworkError`          (`code: "timeout"`)
+ *   5xx     → `NetworkError`          (`code: "server_error"` — covers 529
+ *                                       overloaded_error common em horário
+ *                                       de pico)
+ *   other   → `UnknownAgentError`     (`code: "unknown"`)
+ *
+ * Never throws — caller is already in an error path.
+ *
+ * @internal
+ */
+interface MapAnthropicErrorArgs {
+    status: number;
+    body: unknown;
+    headers: Headers | undefined;
+    endpoint: string;
+}
+export declare function mapAnthropicError(args: MapAnthropicErrorArgs): TheokitAgentError;
+export {};

package/dist/internal/errors/mappers/bedrock.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AWS Bedrock HTTP error mapper (ADRs D67, D300).
+ *
+ * Bedrock returns either AWS-style `{ message, __type: "ThrottlingException" }`
+ * or sometimes `{ Message }` (capitalized) depending on the model dialect.
+ * We accept both shapes and map to canonical `TheokitAgentError` subclasses.
+ *
+ * @internal
+ */
+export interface MapBedrockErrorArgs {
+    status: number;
+    body: unknown;
+    headers: Headers | undefined;
+    endpoint: string;
+}
+export declare function mapBedrockError(args: MapBedrockErrorArgs): TheokitAgentError;