All Classes and Interfaces
Class
Description
Why a
ResumableRun stopped before reaching its terminal step
(TNS-299).Abstract base class for memory stores.
Abstract base class for output serializers.
Collects restrictions from the actual target hierarchy; no method-first security replacement.
Shared dispatch entry to SecurityEnforcer.
Immutable checked execution binding supplied to the existing security evaluator.
Host-verified subject.
Thrown when an
ActionExecutor dispatches a role action without its accountability wiring:
a principal and a default AuthorityScope.Message types for acknowledgment protocol.
A message that requires acknowledgment from the receiver.
Builder for AcknowledgedMessage.
Result of an acknowledgment operation.
Acknowledgment status.
Audit-grade descriptor of a single agent action (TNS-298).
Programmatic counterpart of
@ActionSpec (TNS-551) — declares a role
action via a builder instead of an annotated method, so
RoleBuilder.addAction(ActionConfig) can register
actions that an agent dispatches identically to annotation-derived ones.Optional contract interface for roles that want to enforce pre/post conditions.
Discovers actions from Role classes using reflection.
Exception thrown when action execution fails.
Error categories for action execution failures.
Main router for action execution in the TnsAI framework.
Dispatch callback for a programmatically-defined action (TNS-551) — the
lambda body of an
ActionConfig / RoleBuilder.addAction(...)
action, the programmatic counterpart of an @ActionSpec-annotated
method body.Generic action-dispatch hook events (issue #59).
Immutable metadata about a Role method that becomes an Action.
AGENT-V008 —
@ActionSpec method names must be unique across
every role attached to an agent.Result of an agent acting on the environment.
Holds parameters for action execution, supporting transformation between
LLM-provided parameters and actual action parameters.
Static helpers for safely picking values out of an action's
Map<String, Object> parameters bag.Typed request for action execution.
Typed response from action execution.
Wrapper for action execution results.
Framework-owned helpers for action-body wiring.
Dedicated exception type so tests can assert the cause without string-matching
and operators can wire dedicated alerts on this failure mode.
Marks a method as an executable action that can be discovered and invoked by agents.
Represents the type of action execution method.
Runtime snapshot of a skill that has been activated for an agent
session (TNS-289).
Marks a method as a post-action handler that runs after the action completes.
Abstract base class for autonomous agents in the TnsAI framework.
Fluent builder for creating Agent instances without subclassing.
Manages agent capabilities: planning, reasoning, evaluation, feedback,
environment perception, variant selection, context graphs, and resilience.
Provides agent context needed by capability methods.
Handles chat orchestration for an Agent.
Context interface for Agent - provides access to agent internals needed for chat.
Represents a checkpoint of agent state for interrupt/resume functionality.
Builder for AgentCheckpoint.
Manages planning, reasoning, evaluation, environment perception,
and feedback collection for an Agent.
Central hub for routing messages between agents.
Thread-local container for the current
EventContext.AutoCloseable returned by
AgentContext.enter(EventContext) — restores the
previous context (or clears entirely if none was active) on close.Declarative description of an agent that an
AgentPrincipalProvider uses to mint an AgentPrincipal
(TNS-298).Represents an agent endpoint in communication.
Handles multi-LLM ensemble operations for an Agent.
Service-side fan-out point for observability events.
Static facade for publishing observability events from anywhere in the
framework or consumer code.
AgentGroup - Core abstraction for collections of cooperating agents.
Builder for creating AgentGroup instances.
SPI for creating AgentGroup instances.
Manages group membership for an agent.
Context interface for accessing agent state needed for group operations.
Represents the health of an agent from the resilience subsystem perspective.
Event representing a snapshot of the agent's hierarchy and state,
intended for multi-agent visualization in the frontend.
Manages hierarchical relationships between agents.
Interface for accessing Agent internals needed for hierarchy management.
Maps an Agent hierarchy tree to a flat list of node maps
suitable for
AgentHierarchyEvent.Agent lifecycle hook events (issue #60).
Defines the identity metadata for an Agent class.
Represents a single identity trait or personality characteristic of an agent.
Fires once when
AgentBuilder.build() completes, before the
first chat() call (issue #60).Handles the initialization of Agent components.
Result of agent initialization containing all initialized components.
Context interface for accessing Agent internals needed for initialization.
Append-only audit record produced for every agent action (TNS-298).
Resolves memory configuration from
@Memory and @VectorMemory annotations.Result of memory resolution containing the configured store and optional consolidation pipeline.
Represents a message between agents.
Handles inter-agent messaging for an Agent.
Context interface for accessing Agent internals needed for messaging.
Orchestrates chat, streaming, tool execution, and knowledge base operations.
Bridge interface implemented by
Agent to provide core
data and callbacks to the orchestrator.Handles output formatting and serialization for an Agent.
Verifiable identity for an agent participating in the framework
(TNS-298).
SPI for issuing and verifying
AgentPrincipal instances
(TNS-298).Thrown by
AgentPrincipalProvider.issue(com.tnsai.identity.AgentDescriptor) when the trust root refuses to mint an
identity (revoked spec, blocked tenant, …).Builds system prompts for agents.
Tracks agent failures and produces recovery decisions (degrade, restart, fallback).
Facade for agent resilience operations.
Builder for AgentResilienceManager.
Configuration for agent restart/degrade decisions driven by repeated failures.
Defines agent specification including identity and default configuration.
Extracts agent configuration from
AgentSpec annotation.Fires once when an agent is about to handle its first chat (issue #60).
Lifecycle state of an
Agent.Captures and restores lightweight memory snapshots for agents.
Immutable snapshot of the agent's conversation state for fast restore.
Fires when an agent is shutting down (issue #60).
Handles streaming and event-based chat operations for an Agent.
Context interface for accessing Agent internals needed for streaming.
Handles tool/action execution for an Agent.
Context interface for Agent - provides access to agent internals.
Represents the result of a tool call execution.
Thrown by
AgentBuilder.build() when one or more
Severity.ERROR issues are detected during pre-flight validation
(issue #85).Defines quality/speed/cost tiers for agent execution.
Token cost level.
Quality level.
Execution speed.
Pass-through
ToolCallFilter that allows every tool call.Event requesting human approval for an action.
Marks an action as requiring human approval before execution.
Exception thrown when an action requires human approval before execution.
Token for human-in-the-loop approval of sensitive actions.
Builder for ApprovalToken.
Token status.
Store for managing approval tokens.
Event representing the creation of an artifact by the agent.
Artifact types.
Interface for asynchronous agent execution.
Async message hub for multi-agent coordination.
Cryptographic / external-system proof that an
AgentPrincipal was issued by a trusted third party (TNS-298).Represents an audio part of a message.
Audio source type.
Immutable audit event recording a security-relevant decision.
Builder for
AuditEvent.Records method invocations to an audit trail.
Selection criteria for
LiabilitySink.query(com.tnsai.accountability.AuditQuery) (TNS-298).Query criteria for filtering audit events.
Builder for
AuditQuery.Persistent storage for audit events.
Pre-declared bounds on what an agent is allowed to do (TNS-298).
HTTP authentication types for WEB_SERVICE actions.
Event representing a change in the agent's BDI (Belief-Desire-Intention) state.
The BDI component types.
The operation types for BDI updates.
Marks a method as a pre-processor for an action.
Represents a single belief that an agent holds about the world.
Strategy interface for handling conflicting beliefs.
BM25 (Okapi BM25) index for text-based memory retrieval.
Per-thread ring buffer of recent operations leading up to a point in
time — typically an exception throw.
Single recorded operation with timestamp and attributes.
Enables broadcast messaging for an Agent or Role.
Catalog of the function-shape POJO toolkits shipped in
tnsai-tools.Thrown by
BuiltInTool.instantiate() when the backing POJO cannot be
resolved or constructed reflectively.Thrown when code observing a
CancellationToken aborts because
the token was cancelled (issue #22).Cooperative cancellation primitive for long-running agent operations
(issue #22).
Marks an interface as a reusable capability contract whose methods are
dispatched by the framework (LLM / MCP / WEB_SERVICE) rather than implemented
by the developer.
Represents a capability or skill that an agent possesses within the BDI architecture.
AGENT-V007 — Verify every
@Capability-annotated
interface implemented by an attached role can be fully reflected
upon at build time.@Capability-dispatch hook events (issue #60).In-memory
AgentEventPublisher for unit tests — records every
published event so the test can assert on them.In-memory
ErrorReportPublisher for tests.Compact summary of a single throwable in a flattened cause chain.
Represents a single chunk in a streaming LLM response.
The type of streaming chunk.
The reason why generation stopped.
Typed events for async chat streaming.
Chat completed event.
Error event.
Chat started event.
Token streamed event.
Tool call initiated event.
Tool execution result event.
Conversation-boundary hook events (issue #60).
Owner-scoped binding between chat grounding and one canonical retrieval
engine source.
The one rule a chat knowledge binding must meet before it grounds a
conversation, whoever installs it: an agent, its builder or an integration.
The DIRECT part of an agent's chat knowledge, given fresh on every chat
turn.
One turn's blocks, split at the first SEARCH entry.
Optional bridge from a canonical source configuration to the chat-level
KnowledgeBase contract.Options for asynchronous chat operations.
Builder for ChatOptions.
Unified request model for LLM chat operations.
Fluent builder for ChatRequest.
Represents a chat response from an LLM, potentially including tool calls.
Represents a tool/function call from the LLM.
Typed, request-local identity and lifecycle context for chat retrieval.
Builder for optional, request-local chat context.
Durable snapshot of a
ResumableRun at a step boundary
(issue #82 closeout / TNS-299).Checkpointer interface - LangGraph-style state checkpointing.
Checkpoint tuple container.
Write operation.
Factory for creating Checkpointer instances using SPI discovery.
Information about a provider.
Service Provider Interface for Checkpointer implementations.
SPI for persisting
Checkpoints across the lifetime of a
long-running run (TNS-299).Opt-in ingest-time transform that prepends chunk context before
embedding and BM25 indexing.
SPI for LLM-written chunk context used by
ChunkContext.LLM.The class configuration file an
AgentSpec.config() or a
RoleSpec.config() points at, read once per class and run; a host
starts a run with ClassConfig.useBaseDirectory(java.nio.file.Path).One level of a file: an agent, a role in an agent's file, or a role's
own file.
A run file as a host passes it to
ClassConfig.useBaseDirectory(RunFile) and
ClassConfig.checkAgents(RunFile): its base directory, its name for
messages, its Agents section and, optionally, the agent types
of the run.Contract Net Protocol (CNP) message types.
Manages the BDI (Belief-Desire-Intention) cognitive state of an agent.
Snapshot of BDI state for serialization.
Builder for CognitiveEngine.
Abstraction for agent cognitive architectures.
Represents an action to be executed.
Builder for BDI cognitive model.
Represents a belief in the cognitive model.
Snapshot of cognitive state for persistence.
Represents a goal/desire in the cognitive model.
Represents an intention/plan in the cognitive model.
Configures communication style and messaging for agents and roles.
Represents the communication style and persona of an agent.
Messaging channel configuration.
Communication style settings.
Enforces communication policies defined via @Communication annotation.
Annotation to define agent's communication style.
Abstraction for the underlying message transport mechanism.
Exception thrown when a communication policy is violated.
Types of communication violations.
Marks an action as a completion signal that terminates the agent loop.
Fan-out
AgentEventPublisher — broadcasts each event to every
delegate.Combines multiple environments into a single view.
Fan-out
ErrorReportPublisher — invokes every wrapped
publisher for each CompositeErrorReportPublisher.publish(ErrorReport) call.Points an agent or role class at its configuration file.
Drops what a module derived from class configuration files when
ClassConfig.useBaseDirectory(java.nio.file.Path) starts a new run.A fully configurable Agent implementation created via AgentBuilder.
A fully configurable Role implementation created via
RoleBuilder.Strategies for resolving conflicting attribute values from different sources.
Extracts one detected document into TnsAI's normalized ingestion model.
Deterministic registry of installed
ContentExtractor providers.Represents a part of a message content (Text or Media).
SPI handle for context graph management.
Factory for creating ContextManagerHandle instances.
Captures the complete state of an agent's context at a specific moment.
Builder for ContextSnapshot.
Thin
RuntimeException that wraps a non-TnsAIException
throwable so its EventContext is preserved at the catch site.Defines behavioral contracts for actions using Design by Contract principles.
Defines how contracts are inherited.
Grouped configuration for action contracts and planning effects.
Evaluates
@Contract expressions with Apache Commons JEXL (TNS-552).Build-time syntax check for declarative
@Contract expressions
(AGENT-V013).Programmatic form of the
@Contract Design-by-Contract
annotation (TNS-552) — the JEXL precondition / postcondition / invariant
gates enforced around an action by ContractValidator.Fluent builder for the programmatic path.
Enforces
@Contract clauses at action-dispatch time (TNS-552) — the
declarative, JEXL-backed counterpart to the imperative ActionContract
interface.Thrown when a
@Contract precondition, postcondition, or invariant is
violated at runtime (TNS-552).Human-readable conversation tracer for agent communication.
Configures coordination behavior for multi-agent systems.
Consensus mechanism configuration.
Negotiation protocol configuration.
Negotiation protocol types.
Represents an operation failure that exhausted retries and fallbacks.
Contract for storing failed operations that exceeded resilience policies.
Enables multi-agent debate and consensus building for an Agent.
Consensus strategy options.
Represents what information was considered when making a decision.
Builder for DecisionInput.
Represents the outcome of a decision and its effects.
Builder for DecisionOutcome.
Represents an error in the outcome.
Status of the decision outcome.
Represents the rules and policies that guided a decision.
Builder for DecisionPolicy.
Represents a policy rule.
Represents the reasoning process behind a decision.
Represents an alternative that was considered.
Builder for DecisionReasoning.
Represents a step in the reasoning process.
Complete record of a decision for auditing and explanation.
Builder for DecisionTrace.
Interface for storing and retrieving decision traces.
Statistics about the decision trace store.
Represents what initiated a decision.
Type of trigger that initiated the decision.
Decorator that suppresses repeat
ErrorReports of the same
ErrorReport.fingerprint() within a configurable time
window.Default implementation of
MessageAcknowledger.Default
ResumableRun implementation (TNS-299).Optional cost-governance hook.
Encodes / decodes the run's state to bytes for checkpoint
persistence.
One unit of work in the run.
Represents a desire or goal that an agent wants to achieve.
Strategy interface for resolving conflicts between desires with the same priority.
Decentralized Identifier (DID) according to W3C DID Core specification.
Programmatic counterpart of
DIDSpec — the configuration an agent
declares to derive its DID (and, where supported, a
DIDDocument).DID Document according to W3C DID Core specification.
Service Endpoint.
Verification Method.
DID Resolver - Resolves DIDs to DID Documents.
Configures W3C Decentralized Identifier (DID) for agent identity.
Supported key types for DID cryptography.
Enables direct point-to-point messaging for an Agent or Role.
Immutable container for actions discovered from a Role class via reflection.
Represents a document or document chunk in a knowledge base.
Builder for creating Document instances.
One structurally addressable block within an extracted document.
Canonical content format for a file-backed knowledge source.
Immutable byte input passed to a
ContentExtractor after detection.Typed failure for document detection, extraction, and chunking.
Stable stages across the document-ingestion pipeline.
A
ToolMethod whose name, description, JSON-Schema, and dispatch handler are
all supplied at construction time — no @Tool annotation,
no reflected Method.Fluent builder — the ergonomic way to set the safety/discovery fields (TNS-556).
Dispatch callback for a
DynamicToolMethod.Defines a structured effect (state modification) for planning.
Effect operations for state modification.
Raised when an embedding vector does not match the dimension of its target.
Functional interface for computing text embeddings.
Decorators for composing
EmbeddingFunction instances.Result of enhancing a prompt with strategies.
Parsed response from an enhanced prompt.
Record for thinking phases (UNDERSTAND, ANALYZE, STRATEGIZE, EXECUTE).
Represents a unified entity resolved from multiple sources.
Builder for Entity.
An entity attribute with provenance tracking.
Historical record of attribute changes.
Result of entity resolution, including confidence and alternatives.
Resolution status enumeration.
Interface for resolving entities across multiple sources.
Statistics about the entity resolver.
Represents a source system that provides entity data.
Builder for EntitySource.
Source type enumeration.
Entity type enumeration for categorizing resolved entities.
Env-backed
FeatureFlag (TAN-3392).Abstraction for the agent's external environment.
Utility class for loading environment variables from .env file.
Marks an action as producing ephemeral outputs that should not accumulate in context.
Coarse classification of errors for routing, alerting, and budget tracking.
Single emission point for
ErrorReport construction.Event representing an error during agent execution.
Deterministic fingerprint for an error instance class.
Represents an error recovery scenario with strategy.
Structured observability record for an error event.
Service-side fan-out point for
ErrorReport emissions.Static facade for publishing
ErrorReports.Context for collecting and managing evaluation metrics during agent execution.
Represents a single metric event.
Statistics for a metric.
SPI handle for evaluation hook management.
Factory for creating EvalHandle instances.
Hook interface for integrating evaluation metrics into agent lifecycle.
Marks a method or class for evaluation metric collection.
Categories for evaluation metrics.
Correlation context attached to every observability event.
Marks a method to automatically emit an event after execution.
Event scope definitions.
Marks a method as an event handler for agent events.
Metadata extracted from an
EventHandler annotation.Extracts
EventHandler metadata from annotated classes.Runtime registry for
EventHandler annotated methods.Severity level for an
TnsAIEvent when published as
an observability log record.Trusted origin of an execution request, never selected from model arguments.
Optional action execution restriction.
Immutable execution restriction for reflected and dynamically registered tools.
Immutable data class representing exported role metadata.
Invokes an external process as a hook (issue #64).
Normalized, provenance-preserving output of a
ContentExtractor.Immutable declaration context supplied to document extractors.
Fallback handler invoked when the primary agent or tool fails.
LLM client with automatic fallback support.
Builder for FallbackLLMClient.
Resolves the
@Fallback annotation on a Role's methods and
invokes the matching handler when an action's primary execution
fails.Callback for re-invoking the primary action during retry.
Functional contract for providing fallback values when an operation ultimately fails.
SPI for gradual feature rollout (TAN-3392).
Locator for the process-wide
FeatureFlag (TAN-3392).SPI for collecting and learning from tool execution feedback.
Factory for creating FeedbackCollector instances.
Immutable record of a tool execution outcome.
File-based Checkpointer with JSON serialization.
Builder for FileCheckpointer.
File-based persistent memory store.
Filesystem-backed
CheckpointStore (TNS-299).Disk-backed
SkillStore reading the Claude Code-compatible
<root>/<skill-name>/SKILL.md layout (TNS-289).Evaluation context for
FeatureFlag.isEnabled(String, FlagContext).Represents the formality level of agent communication.
Output parser that supports multiple formats (JSON, YAML, TOON, TONL).
Builder for FormatAwareOutputParser with fluent API.
Annotation to specify the output format for a class.
Defines a goal for planning.
Event occurring within an AgentGroup.
Builder for GroupEvent.
Event types for group events.
Event bus for intra-group communication.
Lifecycle states for an AgentGroup.
Listener for group lifecycle events.
Declares agent group memberships.
Configuration record for group membership extracted from
GroupMember annotation.Metrics snapshot for an AgentGroup.
Configuration policy for an AgentGroup.
Builder for GroupPolicy.
Policy for handling member failures.
Strategy for selecting members for task assignment.
Exception thrown when a group policy is violated.
Central registry for managing AgentGroups.
A task to be executed by group members.
Builder for GroupTask.
Task priority levels.
Task execution status.
Thrown by
InputGuardrailEnforcer or
OutputGuardrailEnforcer when an action's declared guardrail
is breached and the onFailure policy requires aborting the
action.Why the value was rejected.
Whether the violation occurred before or after action execution.
Defines a custom HTTP header for WEB_SERVICE actions.
Opt-in marker for components whose backing service can be reached over
the network or another out-of-process boundary, and that can answer a
lightweight reachability probe in bounded time.
Outcome of a reachability probe.
Utility class for building agent hierarchies with a fluent API.
Pluggable intercept point in the framework's event chain (issue #58).
Per-event context attached to every
HookEvent
so a hook implementation has the full surrounding scope without having to
fish it out of thread-local state (issue #58).Root of the hook event hierarchy (issue #58).
How the
HookDispatcher handles a hook that throws or times
out during apply (issue #58).Filters whether a
Hook fires for a given
event (issue #58).Unconditional match.
Arbitrary typed predicate — use when regex-on-eventType isn't
enough (payload field inspection, cross-field rules).
Pattern applied to
HookEvent.eventType().Decision returned by a
Hook after observing
an event (issue #58).Pass-through.
Refuse the operation.
Replace the event for the rest of the chain.
Centralized factory for OkHttpClient instances.
HTTP method types for WebService actions.
Combines BM25 text search and vector semantic search via Reciprocal Rank Fusion.
Hybrid memory strategy combining sliding window and summarization.
Builder for HybridStrategy.
Stored record of a previous tool / action call's outcome, keyed by
its idempotency key in an
IdempotencyStore (issue #91).Lightweight snapshot of a stored failure.
Thrown when an idempotency-protected call produces an outcome the
framework cannot resolve safely (issue #91): a hard cache hit under
RetryBehavior.FAIL_FAST, a hash collision against a different
input, or the configured IdempotencyStore being unreachable
mid-call.Why the idempotency-protected call could not be resolved.
Declares the runtime dispatcher's expectation about idempotency-key
tracking for a
Tool method (TNS-299).Derives stable idempotency keys from tool / action input maps per
KeyStrategy (issue #91).Opt-in interface a tool POJO implements to supply its own idempotency key
under
KeyStrategy.EXPLICIT (issue #91).Orchestrates a single tool / action call under
Idempotent
protection (issue #91): derives the key, consults the
IdempotencyStore, decides between
returning the cached outcome and re-running the
call body, then writes the new outcome back to the store on a
cache miss.SPI for persisting
IdempotencyEntrys keyed by their
idempotency key (issue #91).Marks an action as idempotent, meaning it can be safely retried
without causing duplicate side effects.
Marks a
Tool (or action method) as side-effecting and therefore
requiring idempotency protection on retry (issue #91).Suggested action carried by
OnSessionIdle (issue #63).Monitors agent idle time and triggers callbacks when timeout is reached.
Represents an image part of a message.
Stable SHA-256 of the ingestion pipeline that produced one indexed file.
Portable include/exclude globs for FILE knowledge-source candidates.
In-memory implementation of ApprovalTokenStore.
In-Memory Checkpointer - For development/testing.
Process-local
CheckpointStore (TNS-299).Thread-safe in-memory implementation of
DeadLetterQueue.Simple in-memory environment for testing and basic scenarios.
In-memory implementation of TnsAIEventPublisher.
Default
IdempotencyStore — process-local, ephemeral, no
external dependencies (issue #91).In-memory implementation of KnowledgeBase for testing and small datasets.
Process-local
ProgressSink (TNS-299).Default
ReputationLedger (TNS-298) — derives scores directly
from a backing LiabilitySink on every query.In-memory
SkillStore backed by a thread-safe map.In-memory implementation of MemoryStore.
Built-in
inmemory VectorStoreProvider.Configures input validation and sanitization for actions.
Content categories for moderation.
Actions on guardrail failure.
Programmatic counterpart of
@InputGuardrail (TNS-561) — lets a
builder-built Role (which has no annotation to read)
opt into input guardrails via RoleBuilder.inputGuardrail(...).Fluent builder; unset fields take the
@InputGuardrail defaults.Resolves the active input guardrail for an action and enforces it against the
working-parameter map immediately before the action body runs.
Rewrites one string-valued action parameter before dispatch.
Validates one string-valued action parameter before dispatch.
Represents an intention - a committed task that the agent is actively working on.
Sealed hierarchy of interrupt events for agent execution control.
Budget interrupt when token/cost limits are hit.
Error interrupt for recoverable errors.
External system interrupt (e.g., shutdown signal, orchestrator command).
Timeout interrupt when execution exceeds time limit.
User-initiated interrupt (e.g., cancel button, Ctrl+C).
Interface for agents that support graceful interruption and state preservation.
Reasons for requesting an interrupt in AG-UI protocol.
Result of an interrupt request.
Possible outcomes of an interrupt.
Service for AG-UI interrupt pattern - blocking agent execution for human approval.
Interrupt request details for listeners.
Enables automatic invariant checking on a class or method.
SPI handle for invariant checking.
Factory for creating InvariantCheckerHandle instances.
Exception thrown when an invariant condition is violated.
Trusted interaction provenance, separate from executing agent and executor principal.
Stub exporter for JADE (Java Agent DEvelopment Framework) format.
Exports Role definitions to Jason/AgentSpeak format.
JSON-based output parser that converts LLM JSON output into Java objects.
Builder for JsonOutputParser.
JSON output serializer using Jackson.
Exports Role definitions to JSON format.
Builds JSON Schema fragments for
ToolMethod parameters from their
static Java Types.Strategy for deriving the idempotency key of a tool / action call
(issue #91).
Cheap word-overlap
SkillResolver — scores each candidate by
how many of the user-message tokens occur in its
name, description,
and whenToUse text (TNS-289).Declares a body of knowledge and how it reaches the model.
Kinds of corpus a loader can ingest.
How a source's content reaches the model.
Interface for knowledge bases supporting RAG (Retrieval-Augmented Generation).
Exception thrown by knowledge base operations.
The one reader of
Knowledge declarations.One declared knowledge source together with how a scope uses it.
Thrown when a configured
WHEN_CONFIGURED source is not ready before a run: its file is missing, it
holds no unit, or it cannot be read.Why a source is not ready.
How a source the same spec declares must be present.
Whether a source must load when nothing configures it.
Explicit lifetime for source snapshots shared by retrieval and ordered
knowledge consumption.
One thread-bound hold on the scope's resources.
The knowledge one scope sees: an action's named sources, or a chat turn's
whole agent knowledge.
Immutable runtime configuration for one RAG knowledge source.
Builder retaining the annotation defaults.
How one ingested file becomes retrieval documents.
Signals that a knowledge-unit policy has no semantics for a document format.
What one knowledge source gave a chat turn or an action call.
Strategy for electing a leader among group members.
Severity tier the agent's authority scope (
AuthorityScope) classifies an action with (TNS-298).Optional sink for
AgentLiabilityRecords (TNS-298).Marks a method as a lifecycle callback for agent initialization and cleanup.
Agent lifecycle phases.
Manages agent lifecycle method execution based on
Lifecycle annotations.Exception thrown when a lifecycle method fails.
Exception thrown when a lifecycle method times out.
Describes the capabilities of an LLM provider/model.
Input modalities the model can process.
Declarative LLM capability flag for use on
@RoleSpec(requires = {...}).Exception thrown when an LLM model lacks a required capability.
Two-headed LLM capability validator.
Base interface for LLM (Large Language Model) client implementations.
SPI for creating LLM clients from provider configuration.
Exception for LLM-related errors (model errors, invalid responses, etc.).
AGENT-V005 — opt-in reachability probe for the configured
LLMClient.Orchestrates LLM communication for agents.
Functional interface for handling tool calls.
Defines a parameter that is exposed to the LLM for tool calling.
Container annotation for multiple
LLMParam annotations.Spec for parameters exposed to LLM.
AGENT-V002 — LLM should normally be present.
Resolves the appropriate LLM client using a fallback chain.
Builder for LLM resolution with full fallback chain support.
LLM configuration record for passing model settings.
Result of LLM resolution with source tracking.
Source of the resolved LLM in the fallback chain.
Executor for
LLM-typed actions.LLM-driven
SkillResolver — asks the configured
LLMClient to pick the most relevant skill names from a
compact catalog (TNS-289).LLM configuration for Agents and Roles.
Supported LLM providers.
Common interface for LLM configuration sources.
Process-local
AgentPrincipalProvider (TNS-298).Default in-memory transport implementation.
Where in the agent configuration a
ValidationIssue originates.Conversation memory with automatic strategy-based management.
Builder for ManagedConversationMemory.
Memory statistics.
SPI for adapting an MCP server URL into a
Healthcheckable
probe.AGENT-V011 — opt-in reachability probe for every MCP server URL
referenced by an
@MCPTool action across the agent's roles.Configures MCP (Model Context Protocol) tool action execution.
Grouped configuration for MCP_TOOL actions.
Executor for MCP_TOOL actions.
Listener for membership events.
Manages membership lifecycle for an AgentGroup.
Member health status.
Information about a group member.
Membership action types.
Historical membership event.
Membership statistics.
Result of membership validation.
Configures memory and state management for agents.
Conversation memory configuration.
State persistence configuration.
Vector memory configuration.
Programmatic form of the
@MemorySpec annotation — the
builder-path counterpart that closes the @MemorySpec parity gap
(TNS-546).Fluent builder for the programmatic path.
Consolidates conversation memory by summarizing older messages.
A single memory entry with tier, strength, provenance, and versioning.
Computes importance scores for memory entries based on a weighted
combination of recency, frequency, and relevance.
Manages agent memory and state checkpointing.
Represents a captured checkpoint of agent state.
Defines a hierarchical memory namespace as workspace:session.
Memory configuration annotation for Agents.
Memory types.
Persistence backends.
Pruning strategies.
Abstraction for agent memory (conversation history).
Factory for creating MemoryStore instances based on
MemorySpec annotation.AGENT-V010 — opt-in reachability probe for the configured
MemoryStore.Strategy for managing conversation memory within token limits.
Tiers in the memory consolidation pipeline.
TnsAI Native Message - The fundamental unit of inter-agent communication.
Message type defines the communication paradigm.
Interface for acknowledging messages.
Statistics about acknowledgment operations.
Abstraction for agent-to-agent message passing.
Message container for inter-agent communication.
Dispatches incoming messages to annotated callback methods in Roles.
Exception thrown when a callback invocation fails in FAIL_FAST mode.
Strategy for handling callback failures.
Marks a method as a message handler for agent communication.
Error handling strategies.
Message parameters container extending HashMap for cleaner API.
Message type filter for @OnMessageReceived annotation.
Marker interface for all message type enums.
Collects latency, call count, and error rate metrics for a method.
Per-invocation handle for a
@Metered action — opened by
MeteredResolver.start(com.tnsai.metadata.ActionMetadata, com.tnsai.roles.Role) immediately before action dispatch
and closed in a finally block.Resolves the
@Metered annotation on an action method or
its declaring Role class and produces a MeteredHandle to
wrap the dispatch.Default implementation of LLMCapabilities with builder pattern.
Coarse-grained classification of LLM model families for prompt
shading (issue #13).
Represents information about an LLM model from a provider's API.
Memory store with hierarchical namespace support.
Exception for network-related errors (connection failures, DNS issues, etc.).
PaymentBroker that prices everything at 0.00 USD and
settles instantly (TNS-298).Defines a social norm (obligation, prohibition, or permission) for a role.
Splits normalized documents and source files into stable retrieval units.
One stable retrieval unit.
Container for repeatable
Norm annotations.Types of social norms based on deontic logic.
Type of user-attention event carried by
OnNotification
(issue #60).Fires when an action throws during execution (issue #59).
Fires when
ActionExecutor dispatches a method that
originated from a @Capability interface (issue #60).Fires for each
ChatChunk during streaming (issue #60).Marks a method as a callback for receiving messages.
Fires when an agent needs user attention (issue #60): a confirmation
prompt, a long-running status update, an error the user should see
asynchronously, or an idle re-engagement signal.
Fires when a session has been idle past the configured threshold
(issue #63).
Fires when a
ServiceLoader-discovered provider is loaded
(issue #63).Fires on an agent FSM state change (issue #60).
Terminal result of a
ResumableRun.execute(I, com.tnsai.reliability.RunConfig) or
ResumableRun.resume(java.lang.String) call (TNS-299).Orchestrator policy stopped the run; cause is the
AbortReason.Run finished its step list.
A step threw and the orchestrator exhausted retries.
Run yielded cleanly at a step boundary.
Supported output formats for structured agent responses.
Specifies the output format for structured responses from agents or actions.
Configures output validation and formatting for actions.
Actions on guardrail failure.
Output format types.
PII (Personally Identifiable Information) types.
Programmatic counterpart of
@OutputGuardrail (TNS-561) — lets a
builder-built Role (which has no annotation to read)
opt into output guardrails via RoleBuilder.outputGuardrail(...).Fluent builder; unset fields take the
@OutputGuardrail defaults.Resolves the active output guardrail for an action and enforces it against the
executor's return value immediately after the action body completes.
Type-safe output parser interface for parsing LLM responses into structured Java objects.
Exception thrown when output serialization or deserialization fails.
Interface for serializing structured data to various output formats.
Registry and factory for output serializers.
Validates parsed output objects against field constraints.
Specifies maximum numeric value.
Specifies maximum string length.
Specifies minimum numeric value.
Specifies minimum string length.
Marks a field as must not be empty.
Specifies a regex pattern for string validation.
Marks a field as required (must not be null).
Specifies size constraints for collections, arrays, or strings.
Parallel LLM execution utilities.
Result of a parallel LLM call.
Aggregated results from multiple LLMs.
Reflectively maps a typed input bean (Java
record or POJO with
accessors / public fields) to a Map<String, Object> suitable for
the framework's existing executeAction(String, Map) dispatch path.Immutable metadata about a method parameter.
Represents how parameters are sent in web service calls.
Exception thrown when LLM output cannot be parsed into the expected type.
Result of a parsing operation, containing either a successfully parsed value or error details.
Settlement bus for agent-to-agent payments (TNS-298).
Thrown by
PaymentBroker.quote(com.tnsai.identity.AgentPrincipal, com.tnsai.identity.AgentPrincipal, com.tnsai.payment.Service) when broker policy refuses to price.Represents a perception from the environment.
SPI for resolving agent permissions at runtime.
Replaces common PII with stable type-specific tokens.
Heuristic detector for common PII carried in action parameters.
Represents a strategic plan or approach within the BDI architecture.
SPI handle for planning system integration.
Factory for creating PlannerHandle instances.
Result of executing a plan.
A single step in an executable plan.
Result of executing a single plan step.
Plugin / SPI discovery hook events (issue #63).
Fires after an action returns successfully (issue #59).
Fires after the final assistant response for a user turn is ready
(issue #60).
Durable
IdempotencyStore backed by a JDBC database
(issue #91).Fires before
ActionExecutor routes any action (issue #59).Fires when a user message is submitted, before prompt assembly
(issue #60).
Represents the priority level of a desire/objective or responsibility.
Observable mid-run state event (TNS-299).
A
Checkpoint has been persisted.Spend tick — the orchestrator emits this when a cost-tracking
integration reports new spend, so dashboards can plot against
the run's
RunConfig.costCeilingUSD.Idle "I'm still alive" pulse for runs that perform a long-running
step without intermediate checkpoints.
Run aborted by policy (
AbortReason).Run reached the end of its step list.
Run aborted by uncaught exception or retry exhaustion.
A step finished successfully; carries timing for diagnostics.
A step has begun executing.
Pub/sub surface for
Progress events emitted during a
ResumableRun (TNS-299).Walks up from a starting directory looking for a project context file
(
.tnsai.md, TNSAI.md, or CLAUDE.md) and returns its
contents for system-prompt injection.Result of a successful load.
Fluent builder for combining prompt enhancement strategies.
Builder for PromptEnhancer.
Example record for few-shot learning.
Output format options.
Exception thrown when prompt operations fail.
Shared formatting helpers for prompt-building call sites.
Spec for prompt templates.
Builder for PromptSpec.
Predefined prompting strategies for enhanced LLM responses.
Interface for prompt templates with variable substitution.
Loads and caches prompt template files referenced by
PromptTemplates.Specifies a prompt template file for custom state rendering.
SPI handle for protocol management.
Factory for creating ProtocolManagerHandle instances.
Native error details surfaced from an upstream LLM (or external) provider.
Enables publish-subscribe messaging for an Agent or Role.
Defines an evaluation quality threshold for a method's output.
Actions when quality gate fails.
Query/Information exchange message types.
Priced commitment for a
Service between two
AgentPrincipal agents (TNS-298).Exception for rate limit errors (HTTP 429, quota exceeded).
Marker for
Validators that perform out-of-process I/O
(network call, disk write probe, MCP handshake, etc.) and therefore
should run only when the user has explicitly opted into
AgentBuilder.withReachabilityChecks(true) (issue #85 phase 2a).SPI handle for reasoning strategy integration.
Factory for creating ReasoningStrategyHandle instances by name.
Context provided to the reasoning strategy by the Agent.
Result of a reasoning operation.
Reciprocal Rank Fusion (RRF) for combining multiple ranked result lists.
In-memory
LiabilitySink for tests and assertions (TNS-298).Describes the action the agent should take after a failure.
Distributed
CheckpointStore backed by Redis (TNS-312).Distributed
IdempotencyStore backed by Redis (issue #91).Reputation oracle derived from
AgentLiabilityRecord history
(TNS-298).Aggregate reputation derived from an agent's
AgentLiabilityRecord history (TNS-298).Enables synchronous request-reply messaging pattern.
Configures resilience policies for actions and roles.
Circuit breaker configuration.
Rate limiting configuration.
Retry policy configuration.
Programmatic resilience policy for a builder-built
Role
— the builder-path counterpart of the @Resilience annotation
(TNS-567).Fluent builder.
AGENT-V009 — Catches malformed
Resilience configurations
at build time.Central executor that combines retry policies, circuit breaker, bulkhead,
rate limiting and dead-letter queue tracking.
In-memory metrics registry for
@Metered actions
(issue #173, Phase 1).Immutable snapshot of one metric's state at the moment
ResilienceMetrics.snapshot(java.lang.String) was called.Immutable descriptor for executing an operation through the resilience pipeline.
Strategy interface for resilience patterns.
Builder for creating composite resilience strategies.
Driver for a long-running, checkpoint-backed agent execution
(TNS-299).
Immutable runtime configuration for action-level retrieval.
Builder starting from the framework defaults.
Entry-point-neutral diagnostics emitted by a retrieval engine.
Cache behavior visible to callers and observability integrations.
Agent-scoped retrieval engine shared by chat and action entry points.
Backend operation implemented by the intelligence runtime.
SPI for creating agent-scoped
RetrievalEngine instances.Immutable evidence returned by a
RetrievalEngine.Stable provenance required for audit, citation, and diagnostics.
Typed failure raised by the common retrieval runtime.
Stable failure categories shared by chat and action entry points.
Entry-point-neutral request passed to a
RetrievalEngine.Builder with safe defaults for unscoped, non-cancellable retrieval.
Immutable outcome returned by a
RetrievalEngine.Tenant and session identity carried by a retrieval request.
Service Provider Interface for knowledge-context injection at action-dispatch time.
Renders retrieved documents behind a single, explicit untrusted-context boundary.
One chat owner's knowledge for a turn: its DIRECT blocks and its
SEARCH evidence, fitted to its own context window.
Wrapper that adds retry-with-error-correction capability to any OutputParser.
Builder for RetryableParser.
Record of a single parse attempt.
What the framework does when a retry hits a previously-stored
idempotency entry (issue #91).
Immutable retry policy definition used by the resilience layer.
Utility for retrying operations with exponential backoff.
Abstract base class for organizational roles in the Gaia methodology.
Exception thrown when a role assignment fails due to exclusivity constraints.
Fluent builder for creating Role instances without subclassing.
Defines the identity metadata for a Role class.
Interface for exporting Role definitions to various formats.
Represents the identity of a role in the Gaia methodology.
Exception thrown when role initialization fails.
Builds system prompts for roles from Gaia components.
Central registry for managing exclusive Role assignments.
Defines role specification for agents.
Extracts role metadata from annotations.
Cached bundle of all extracted metadata for a role class.
Immutable LLM configuration extracted from a role's
@RoleSpec.llm()
(@LLMSpec) for the role-export subsystem.Immutable responsibility information extracted from
@ActionSpec.Immutable state information extracted from
@State annotation.State with runtime value.
Reads role metadata from TnsAI annotations.
Role metadata container.
AGENT-V001 — at least one
Role is required.Execution-time policy bundle for one run of a
ResumableRun
(TNS-299).Event indicating that an agent run has completed.
Run completion status.
Event indicating that an agent run has started.
S3-backed
CheckpointStore (TNS-312).Stub exporter for SCOP (Spatial Computing and Optimization Platform) format.
A memory entry paired with a retrieval score.
What an
ExternalScriptHook does when the subprocess fails
(timeout, non-zero exit, unparseable response) (issue #64).How a
Knowledge.Use.SEARCH source is ranked and rendered.Fallback actions on retrieval failure.
Query expansion methods.
Retrieval strategies.
Represents a search result from a knowledge base query.
The search settings one knowledge entry contributes to its scope: a partial,
immutable value holding only the
Search members that were given.Builds
SearchSettings; a member not set is not given.Configures security policies for actions and roles.
Audit logging levels.
SPI handle for security enforcement.
Factory for creating SecurityEnforcerHandle instances.
Base exception for security-related violations.
Types of security violations.
The
@Security encryption, timeout and audit features an action's dispatch applies.Immutable runtime configuration for ordered knowledge-unit consumption.
Builder twin for programmatic declarations.
Description of a unit-of-work an agent offers (TNS-298).
Why a session is closing, carried by
SessionEnd (issue #63).Fires when a client session closes for any reason (issue #63).
Server session lifecycle hook events (issue #63).
Manages agent sessions with automatic persistence.
Session information container.
Session state enum.
Transport protocol used by a client session, carried by
SessionStart (issue #63).Restores
TieredMemoryStore state from a JSON session file.Serializes
TieredMemoryStore state to JSON for session persistence.Fires when a new client session opens on the server (issue #63).
Outcome of
PaymentBroker.settle(com.tnsai.payment.Quote) (TNS-298).Idempotency replay — a prior settlement with the same
Quote.idempotencyKey already succeeded; broker returns
the original transactionId so callers can reconcile.Quote was past
Quote.expiresAt when settlement was attempted.Broker refused — insufficient funds, payer KYC failure, broker
policy block.
Funds moved successfully.
Severity of a
ValidationIssue.Severity of a
HookResult.Block decision (issue #58).Shared blackboard for multi-agent collaboration and coordination.
Entry on the blackboard.
Types of blackboard entries.
Vote result record.
Vote types.
Registry for shared memory stores across agents.
A memory store wrapper that enables memory sharing between agents.
Classifies the observable effect a
Tool method has on the
world (TNS-299).What part of the world a
can change.
invalid reference
ToolA structured skill extracted from agent experience.
On-demand modular knowledge layer between role and tools (TNS-289).
Emitted whenever a
com.tnsai.skills.Skill is activated for
an agent (TNS-289).Why a skill was activated.
Result of parsing a
/skill-name [args] user message.Parses a Claude Code-compatible
SKILL.md document into a
Skill (TNS-289).File-based store for structured Markdown skill files.
Ranks
Skills by their relevance to a user message (TNS-289).How an agent surfaces and activates skills (TNS-289).
ToolCallFilter that enforces the
allowed-tools field of each active skill (TNS-289).Per-agent runtime state for the skill layer (TNS-289).
Marks a class as a skill with metadata for routing and discovery.
SPI for skill discovery and lookup (TNS-289).
Placeholder substitution for skill bodies and frontmatter strings
(TNS-289).
Default
AgentEventPublisher — JSON-serializes the event and
writes it via SLF4J at the level corresponding to EventLevel.Default
ErrorReportPublisher — JSON-serialises the report
and writes it via SLF4J at the level matching the report's
ErrorCategory.Sliding window memory strategy that keeps the most recent messages.
Builder for SlidingWindowStrategy.
Represents the difference between two context snapshots.
Type of change.
Summary of changes between snapshots.
Represents a change to a variable.
Interface for storing and retrieving context snapshots.
Statistics about the snapshot store.
Defines when context snapshots are captured.
Classloader-scoped cache for Java SPI providers.
Terminal spinner for showing loading state.
Single-file SQLite-backed
CheckpointStore (TNS-299).Stack-trace normalization for stable error fingerprinting.
Detects contradictions between memory entries via Jaccard similarity
on token sets.
Marks a field as agent state for planning.
Exception thrown when state operations fail.
A
ToolMethod backed by a discovered Tool-annotated
method on a POJO instance.Event representing a status update during agent execution.
Types of status updates.
Why an agent is shutting down, carried by
AgentStop
(issue #60).Builds and selects
structural paths.Memory strategy that summarizes old messages to save tokens.
Builder for SummaryStrategy.
Signals that a task has been completed and the agent loop should terminate.
Analyzes task complexity to determine the appropriate agent variant.
Complexity levels.
Complexity analysis result.
Task-related message types for direct task delegation.
Interface for template rendering engines.
Opt-in marker SPI for components that honour
AgentBuilder.tenantId(...) — i.e. they keep one tenant's
data observably separate from another's.Thread-local tenant scope for tenant-aware runtime components.
Restores the tenant that was active before
TenantContext.enter(String).AGENT-V012 — when an agent is configured with
AgentBuilder.tenantId(...), every wired component that
holds tenant-scoped state must opt into the
TenantAware marker SPI.Event representing a streaming text chunk from the LLM.
Plain Text serializer.
Represents a text part of a message.
Cleans text payloads before they leave the process toward an external API.
Event representing an agent's internal reasoning or thinking process.
Helper for the catch-side of framework boundaries.
Loads conversation context in tiers with token budgets.
Builder for TieredContextLoader.
Functional interface for summarizing a list of messages.
Result of tiered context loading.
Configuration for tier token budgets.
4-tier memory store with Ebbinghaus-inspired decay and promotion.
Result of a consolidation cycle.
Exception for operation timeout errors.
Framework-level timeout configuration for the four call categories
the framework can issue (issue #16).
The four call categories the framework times.
Sealed interface representing internal TnsAI events.
Interface for publishing and subscribing to TnsAI events.
A subscription handle for cancelling event subscriptions.
Base exception for all TnsAI framework exceptions.
Configuration for token budget management.
Builder for TokenBudget.
Content-aware token estimator that improves on simple length/4 heuristics.
Content type classification.
Utility for estimating token counts.
Represents the communication tone of an agent.
TONL (Token-Optimized Notation Language) serializer.
Marks a method as a tool that an LLM agent can call.
AGENT-V006 — at least one registered tool declares
@Tool(requiresConfirmation = true) but the agent has no
ToolCallFilter configured to gate
the call.Tool authentication failed — typically HTTP 401 from upstream, missing
or invalid API key, expired bearer token.
Tool credential is valid but lacks permission for the requested
operation — typically HTTP 403 from upstream, RBAC denial, scope
mismatch on an OAuth token.
Represents the outcome of a
ToolCallFilter evaluation.Allow the tool call to proceed as-is.
Block the tool call entirely.
Don't execute; suggest an alternative tool or approach.
Don't execute; provide feedback for the agent to self-correct.
Splits a batch of
ChatResponse.ToolCalls into ordered execution groups.Strategy interface: callers implement to connect their Tool/ActionMetadata
lookup with the partitioner.
Event indicating that a tool call has completed.
Filter for controlling tool call execution.
Listener for tool call lifecycle events.
Exception thrown when tools are sent to an LLM model that does not support function/tool calling.
Event indicating that a tool call has started.
Tool itself is misconfigured — missing required environment variable,
invalid endpoint URL, malformed credential file.
Tool failed due to a conflict against current upstream state — typically
HTTP 409, optimistic-concurrency version mismatch, stale-resource update,
unique-constraint violation.
Defines an example for a tool/action to help LLMs understand usage patterns.
Represents a usage example for a tool.
Builder for ToolExample.
Immutable metadata about a tool usage example.
Exception thrown when a tool execution fails.
Builder for ToolException.
Error type classification.
Tool failed because the upstream external service returned a server-side
error — typically HTTP 5xx, a connection reset, or any provider-side
malfunction the tool itself did not cause.
Tool input was invalid — required field missing, type mismatch, value
outside allowed range, schema violation.
A tool method addressable by the LLM.
Dispatches an LLM tool call to a discovered
ToolMethod.Discovers and indexes
Tool-annotated methods across a list of POJO
tool-bearing instances.Remote resource the tool was asked to operate on does not exist —
typically HTTP 404 from upstream, file-not-found, missing record.
Per-parameter metadata for a
Tool-annotated method.Metadata for a single parameter of a
ToolMethod.Tool was rate-limited by upstream — typically HTTP 429.
Registry for managing agent tools.
Parameter definition for a tool.
Definition of a tool available to agents.
Builder for ToolRegistryEntry.
Type of tool.
Tool produced a result that the framework could not marshal back to the
caller — JSON encoding failed, return-type adapter missing, recursive
object graph.
Risk classification for a
's execution.
invalid reference
ToolRepresents the JSON schema for a tool's parameters.
Represents a property in the JSON schema.
Builder helper to easily add properties.
Generates tool/function schemas for LLM function calling.
Tool exceeded its execution deadline.
Catchall for tool failures that don't fit any other typed subclass —
a pure
RuntimeException thrown from inside the tool, an
AssertionError, or anything else escaping the well-defined
failure taxonomy.Tool execution was canceled by the user — confirmation prompt declined,
deadline elapsed before the user responded, or an explicit abort signal.
Why the user-facing cancellation happened.
TOON (Token-Optimized Object Notation) serializer.
Adds trace ID propagation and structured logging to a method.
Resolves the
@Traced annotation on an action method or its
declaring Role class and produces a TracedSpan that wraps
the dispatch with structured trace logs.Per-invocation handle for a
@Traced action — opened by
TracedResolver.open(com.tnsai.metadata.ActionMetadata, com.tnsai.roles.Role, java.util.Map<java.lang.String, java.lang.Object>) immediately before dispatch and closed
in a finally block.Defines how agents communicate with each other.
Utility class for converting values between types in action parameter handling.
Interface for type-specific action executors.
Event representing a request to render a specific UI component in the frontend.
Assembles LLM context from multiple sources in priority order with token budget enforcement.
Result of context assembly.
Builder for UnifiedContextAssembler.
Utility-based planning configuration for actions.
Read-only snapshot of an
AgentBuilder state passed to each
Validator.Thrown when an action violates pre/post conditions or parameter contracts.
One detected configuration problem from
Validator run during
AgentBuilder.build() (issue #85).Aggregate output of
AgentBuilder.build() pre-flight validation
(issue #85).Pluggable pre-flight check run during
AgentBuilder.build()
(issue #85).Validation utility methods for null and empty checks.
Overrides the agent's default variant for a specific action.
Manages agent variants and handles runtime switching.
Handle returned by listener registration that allows unregistration.
Event fired when variant changes.
Statistics for a variant.
Intelligent variant selector for automatic quality tier selection.
Builder for VariantSelector.
Reasons for variant selection.
Selection result with reasoning.
Token budget for cost control.
User preference for quality/speed/cost trade-offs.
Statistics for a variant.
Configuration for an agent variant.
Tool set levels.
Storage backend for
VectorMemoryStore.Configures vector memory for an Agent class.
In-memory vector store for semantic search over memory entries.
Conversation
MemoryStore whose VectorSearchMemoryStore.search(java.lang.String, int) is backed by a
VectorMemoryStore instead of TF-IDF.SPI matched against
@VectorMemory(provider = "...").ServiceLoader lookup for
VectorStoreProvider.Represents the verbosity level of agent communication.
Represents a video part of a message.
Video source type.
Configures web service action execution.
Grouped configuration for WEB_SERVICE actions.
Executor for WEB_SERVICE actions.
YAML output serializer.
Exports Role definitions to YAML format.