Synchronous middleware client. Never raises at construction (spec §8): a refused endpoint or an invalid option value warns once, every call p

Deterministic protocol peer behind the public transport seam; records every request.

Class-invariant elision summaries. keepNonRedundant (redundancy.go) keeps one representative of every resemblance class and lets the rest elide again

ModelRequest is one baseline or compressed prompt sent through a model runner.

ModelResponse is the answer and optional usage returned by a model runner.

Input contract for the client-pure cache-optimal request assembler.

One author-declared request fragment for :meth:`Cave.assemble`.

Place inside authentication and original-content guard middleware. Pure ASGI 3, so any ASGI server or framework works (no version gate). reso

Use as a context manager around a native LiteLLM module or Router. completion/acompletion/responses/aresponses take an explicit ``scope``. Mo

Detects and interrupts a repeated identical tool-call loop. Call :meth:`record` (or :meth:`guard`) before each tool invocation with the tool

Returned by server-side auth, never deserialized from caller input. recovery is a binding registered with the host's actual native tool loop.

A tool descriptor for inclusion in the tool catalog.

Add scoped recovery and wrap each selected native model invocation. Other capabilities and the native Agent own authorization, history, tools,

Provider-body projection shared by the OpenAI, Anthropic, LiteLLM and ASGI adapters. ``runtime`` may be either SDK runtime type; sync and async p

What the agent should run for one task, decided locally. ``decision`` is ``"execute"`` (the policy's execute workflow), ``"fallback"`` (the p

Wrap a native CrewAI LLM; assign a separate trusted Scope per context. Use ``with_caveman_agent`` to register the matching recovery BaseTool.

Delegate to an existing native LLM. Model-only calls are recovery-free. Public provider methods retain native serialization, retries, callbacks,

Either SDK runtime type is accepted; recovery pages are awaited through its async view. An unusable scope never raises here: recovery stays unreg

One caller-owned context fragment considered by ``cave.context.pack``.

Budget and scoring options for connected-only context packing.

Counter estimates the token length of a payload. Implementations must be deterministic: the same bytes always yield the same count.

DensityLevel selects how aggressively the pixel renderer packs text into a page. Unknown/invalid values fail closed to conservative.

Client failure classification input (K4/K8); body is the raw response text.

The native MCP definition and the callable registered in the host loop.

One weak native callback per invocation, with no per-chunk callback list.

Either runtime type works on either path (D5): sync calls use its sync view, async calls its async view.

A classified optimize-path I/O or response failure (§6).

Local bypass: no I/O after it, and it never records into the breaker.

codeCompressor keeps imports, signatures, and type/class declarations and elides function/method bodies using a tree-sitter parse, so the structural o

sessionSource isolates provider transcript formats from learn detectors. Sources stream normalized events; detector logic below stays provider-blind.

K10. key = f"{original_sha256}:{segment_id}"; bytes = wire bytes of the segment plus one.

Append after the application's authorization and original-content guards.

Delegate every native call; model-only use is recovery-free.

Public HTTPX transport; original-content request hooks run before it. ``scope`` is only the default for calls not made through a wrapped client;

Native Agno Model delegate. Model-only use has no recovery executor. Agno's Model.response methods retain orchestration. Only invoke/ainvoke and

Public native model delegate. A model wrapper alone is record-only (``recovery_unbound`` in compress mode); ``with_caveman_agent`` registers recov

Native Model delegate. Direct model-only use has no recovery executor, so compress mode reports ``recovery_unbound``; add ``CavemanCapability`` to

Add scoped recovery to a real workbench without changing its tool results. AutoGen 0.7.5 selects streaming tools by this public base class. Deleg

§10 breaker. Pure state machine: callers serialize allow()/record() themselves.

Result of a :meth:`Cave.compress` call — the Engine's compression report. ``basis`` is always ``"inferred"``: the SDK never emits ``verified`` (t

Selected caller-owned context plus inferred token accounting.

One content-free event per report() (K9); asdict() keys are identical in every SDK.

One-call OTel exporter that ships spans to the gateway OTLP endpoint. Build with :meth:`Cave.exporter`. Record spans with :meth:`record_span`

One prepared native operation and its observed physical HTTP attempts.

The outcome of one :meth:`RuntimePolicyClient.refresh`.

The single human-editable object controlling cave-auto routing for a workflow (spec R14). Field names are the snake_case wire names — identical to

Result from :meth:`Cave.assemble`; every token figure is inferred.

Stable/session content changed inside its declared lifetime.

K10 admission: ids in input order.

Final native-call decision; no source text or provider credentials.

Tolerant parse of a capabilities document (K1/K2).

Native FunctionAgent with stable recovery registration before first call. Pass the existing LLM and tools as usual. The native workflow still own

Native model and tools for an application-owned loop; no scheduler.

Native per-model middleware. Register recovery_tool in the host tool list. with_caveman_agent() performs collision-safe model/tool registration t

Native client and immutable dispatch map for an application-owned loop. Call the selected native Chat Completions or Responses API with ``tools``

Executed by CrewAI's existing native tool scheduler.

Class is a position on the engine's safety ladder.

Decision 11 tier plus the tested ranges ``(distribution, oldest tested, exclusive maximum)``.

Thread-safe keep-alive pool; one per runtime. See the module docstring for the contract.