All Classes and Interfaces
Class
Description
Base class for admission guardrails.
Shared base for external-service API clients.
Base class for all artifact entities that can be preserved across agent workflows.
Base class for authorization guardrails.
Shared
ClientProvider template: construct the provider-specific client, bind the
spec, return.Base class for content guardrails.
The template every decision client runs: the one wire call inside the rate-limit
feedback, the upstream's verdict classified for the dispatcher the way the embeddings
template classifies it (a 429 and a 5xx as transparent retry signals, an exhausted
account as its own failure, an endpoint DNS never heard of as uncorrectable), and the
call recorded on the response.
What one wire call returned: the decoded answers, the input tokens the endpoint says it
billed (null where it reports none), and the identity it reported, each null when absent.
Base class for coded orchestration logic.
Abstract base class for embeddings client implementations.
What one provider call returned: the vector at the provider's native width and the
input tokens the provider says it billed, null where the provider reports none.
What every EPO OPS tool shares: the one OPS rate limiter, declared against the service the
tool calls; an
EPOClient bound to the job's HTTP client at execution; and the
publication segment of an OPS path, built from a patent number and its input format.Job plumbing shared by all guardrail bases: target and snapshot delivery, resource
capture, observability metadata, the final execute-calls-validate wiring.
A
DBResourceProvider over a Hibernate SessionFactory: each handle owns one
Session holding one connection from admission to completion.Base class for all jobs that can be submitted to the job processing system.
Abstract base class for rich job events.
Base class for LLM client implementations.
A tool whose work is one exchange with a model.
The stateful picker base: holds each spec's availability as observed by the probe and
refuses to serve a spec the observations say is down - the deployment's "turn off
additional models and treat them as deprecated" default.
One spec's accumulated availability state.
Everything about an OpenAI-family conversation that is the dialect's and not the wire's:
the content encoders, the request body as JSON, the response body read back onto the
framework's response, for both of OpenAI's APIs.
Base implementation for resource-free orchestrators that coordinate other jobs.
Base class for API clients with rate limiting support.
Base class for accounts that are their own identity: the wake slot
Admission
installs, the RateLimiter.Replenishment.RELEASE default that fits every capacity gate built
directly on this class, and the nominal (null) status indicator.Base implementation of
Stoppable with common shutdown flag handling.Sealed base class for the four terminal events the dispatcher fires for a job it ran:
completion, failure, timeout and cancellation.
Base class for implementing reasoning agents that coordinate tool execution.
The reply to a call retried after compaction, and the compacted conversation the loop continues on.
One model call of a loop, made on whichever conversation the loop currently holds.
Base implementation for tools that provides input management.
A thinker with no tools is one LLM call wearing a loop's clothes - and the
clothes are what it pays for: tool-use instructions for tools that do not
exist, the ThinkingResponse envelope with its final-answer and artifact
plumbing, and a prompt cache written on every one-shot conversation and never
read back.
Base class for validation guardrails.
Base class for observing events from a specific workflow.
PromptSource dispatching to one of two inner sources by a configurable
probability.The one place a job waits for resources.
The immutable identity payload an
AdmissionGuardrail judges: who is calling
(principal), through which agent (the calling agent's class name, resolved from the
job lineage; null when the gated job sits directly under the workflow root), reaching
which tool.Admission guardrail: decides whether this tool may be reached by this caller at all -
before any call exists, so it has no target.
The agent's capabilities for the page: the tools in its palette and the skills it may draw on.
Reference
AdmissionGuardrail: the declaring tool may only be reached through
the named agent classes.The agent's query and, when the caller names one, the rung it runs at; null runs it at the agent's declared grade.
A static secret minted for an agent, presented to the token endpoint as HTTP Basic
usr:secret.A private key minted for an agent; its public half sits on the agent's credential row and
the authorization server verifies the assertions this key signs.
One agent run, streamed to the browser as it happens: an observer on the runtime's message
bus, scoped to the run's workflow, that writes every event of the run and of every job
under it - the model turns, the tool calls, the sub-agents - as one line of
newline-delimited JSON, so a page draws the run as a timeline while it is on.
Reasoning for information extraction and relevance assessment.
Security monitoring tool that analyzes guardrail violations to determine intent.
What a decision model answered to one
Question: a distribution over the options
the caller declared, in the shape of the question asked.Serves Anthropic models through the AWS Bedrock Mantle endpoint.
Anthropic Claude via the AWS Bedrock Mantle endpoint
(
bedrock-mantle.{region}.api.aws/anthropic/v1/messages).Serves Anthropic models through AWS Bedrock.
Anthropic Claude API client using AWS Bedrock as the backend.
Content formatter for Anthropic Claude API.
Serves Anthropic models through Anthropic's own API.
Anthropic native file: PDFs become a
DocumentBlockParam, image files become an
ImageBlockParam (reusing AnthropicImageBlockEncoder.mediaType(String)); any other type has
no Anthropic representation and produces nothing.Anthropic native image: a base64
ImageBlockParam.Resolves a
ModelSpec to the Anthropic SDK Model.ModelSpec for Anthropic-served models (direct or Bedrock).How Claude models are named in the catalog, from any of the spellings the surfaces use:
the identity is the family and the version with a dot (
opus-4.7, fable-5.1,
haiku-3), read from claude-opus-4-7, anthropic.claude-opus-4-7,
claude-opus-4-5-20251101-v1:0 or the old claude-3-haiku-20240307; the
catalog id is claude- plus the identity with dashes plus the channel the entry is
served on (claude-opus-4-7-bedrock).Anthropic-family provider layer.
Anthropic native redacted-thinking: replays the opaque payload verbatim on later turns.
Anthropic Claude API client using the official Java SDK.
The Anthropic provider's knobs.
The one Anthropic text wrap: a string becomes a
ContentBlockParam.ofText.Anthropic native thinking: replays the assistant's thinking verbatim.
Anthropic
ContentBlocks.ToolDefinitionBlock encoder: nothing inline.Anthropic native tool-result: a
ToolResultBlockParam linked to its tool-use id, so the
model sees a real tool result rather than text.Anthropic native tool-use: a
ToolUseBlockParam carrying the parsed input object, so the
model sees a real assistant tool call rather than text.Marker interface for domain entities that can be preserved as artifacts
across multi-agent workflows.
Custom deserializer for
ListArtifact.getIterands().Custom deserializer for the artifact map in
ConversationPersistenceSnapshot.Reads a field whose declared type is the
Artifact interface, by resolving the
concrete type from the artifact's own ref.Registry for storing and managing artifacts within a conversation context.
Interface for tools that need access to the conversation's artifact registry.
Base class for agent responses that can reference preserved artifacts.
Deterministic text formatter for one artifact type: the same artifact content
always produces the same text.
Thinker output that is itself an
Artifact, so a thinker can serve as a
fan-out worker: its typed answer lands directly in the result list and the
artifact registry.Authorization guardrail: judges whether the principal may perform this invocation.
The part of an RFC 8414 authorization server metadata document a client-credentials
client reads: the issuer identifier (the assertion's audience), the token endpoint, and
whether the server offers the grant and the authentication method the client needs.
The engine's default reader, which pulls no font or graphics toolkit and so compiles to a
native image on any OS: Office documents are read as the zip-of-XML they are
(
DeterministicExtractTool) and PDFs go whole to the model tier
(VisionExtractTool).The OpenAI surface of an Azure AI Foundry resource,
/openai/v1, through the same
OpenAI Java client as OpenAISDKClient, on the Responses API, which Foundry serves for
every model on that surface and which is where the reasoning generation reasons and calls
tools in one turn.Serves the OpenAI surface (
/openai/v1) of an Azure AI Foundry resource, on the
Responses API: the Azure OpenAI models
and the Foundry Models sold by Azure on OpenAI's v1 syntax.Azure OpenAI embeddings client with rate limiting support.
Serves OpenAI embedding models through Azure OpenAI.
Captures Bedrock Converse wire bytes onto the in-flight
LLMRequest, for a
deployment's usage recorder to persist as an audit trail.Builds the framework's configured
BedrockRuntimeClient: credentials per
BedrockClients.credentialsProvider(), the region per BedrockClients.region(), SDK retries disabled
(the framework's dispatcher owns retry/backoff), and the audit interceptor registered
(a no-op on calls without an LLM_REQUEST execution attribute, e.g.Cohere Embed client on AWS Bedrock InvokeModel.
Serves Cohere embedding models on AWS Bedrock.
AWS Bedrock client using the Converse API.
Serves non-Anthropic Bedrock models (Nova, Llama, Mistral, Titan) through the Bedrock
Converse API.
What the AWS account can reach on Bedrock, from the two surfaces that expose it.
Bedrock Converse native file: a document type Converse reads (PDF, Word, Excel, CSV, HTML,
text, Markdown) becomes a
ContentBlock.document carrying the decoded bytes, an image
file becomes a ContentBlock.image (the image encoder's format mapping); any other type
has no Converse representation and produces nothing.Bedrock Converse native image: a
ContentBlock.image carrying the decoded bytes.The stateful picker base for deployments whose overload substitution never leaves
AWS Bedrock:
BedrockOnlyModelPicker.eligibleForFailover(ModelSpec, Situation) admits Bedrock-hosted routes only - mantle,
native anthropic-bedrock, Converse - never a direct endpoint.What every Bedrock-hosted provider says about its credentials, whichever client family it
builds: the AWS key pair under
BedrockClients.SECRET_ID, or the identity the process
runs under when role-based auth is on.The one Bedrock Converse text wrap: a string becomes a
ContentBlock.text.Any model-dependent job, raced across the models of its grade.
What a benchmark produced: the reference run's answer and the report the runtime also logged as a table.
One benchmark's race, streamed to the browser as it runs: an observer on the runtime's
message bus, scoped to the race's workflow, that turns every event of the raced runs
and their judges - and of the calls those runs make, attributed by walking each job's
parent chain up to the run the
Benchmark named - into one line of
newline-delimited JSON on the response, the way the chat endpoints stream a
conversation's progress over a socket.What a benchmark measured: the job class and the grade it raced, the reference row, one
row per model and run, and the means per model.
One run of the job on one model.
One model's means across its runs.
A benchmark request: the query every raced model answers, and how many times each answers it.
Input for fetching full details of specific bioRxiv/medRxiv preprints by DOI.
Output with detailed preprint information from bioRxiv/medRxiv.
Author information.
Detailed preprint record with complete metadata.
Funding information.
Fetches detailed preprint information from bioRxiv/medRxiv by DOI.
Input parameters for searching bioRxiv and medRxiv preprints.
Output from bioRxiv/medRxiv preprint search.
Individual bioRxiv/medRxiv preprint with metadata.
Searches bioRxiv and medRxiv for preprint articles via the official API.
Encodes one
ContentBlocks.ContentBlock into a provider's native content block of type B.A request to remove a pending heartbeat by id.
The judgment tier of the pricing demo: one call, one grade up, that decides which of the
names the documents used mean the same product ("Kestrel 1", "Kestrel 1 gravel", "the
Kestrel") so that the arithmetic over dates runs on products and not on spellings.
An agent working one customer's case.
The case axis: whose customer a piece of work is about.
The case marker: on an orchestrator it binds the flow to one customer, on an input it is
the claim the binding judges.
The demo's write-side catalog logic, shared by every host: connecting a credential for the
session, running the discovery that writes the deployment's catalog, and editing or pinning
one of its entries.
The one development-time action that turns the shipped catalog into this account's: walk
every provider on the classpath, ask each configured one what the account can reach, ping
every entry that is reachable, and write a complete
models.json with the account's
observed limits plus a report of everything that was learned and everything that was not.What happened with one catalog entry.
What happened with one provider.
What happened with one provider.
The whole run: the catalog to write, the report to read, and the facts both were made
from.
What a run decided about one entry.
One catalog entry on the status panel: its id, grade and provider, which client family it
belongs to (an LLM, an embeddings model or a decision model), whether it takes a seat,
whether the compliance envelope permits it, its status, what it accepts beyond text (images,
documents), its output modalities, its per-million prices in the entry's
currency, the bound it declares: a quota window (
tpm) or, for a decision model
served from the deployment's own machine, how many requests its server takes at once
(maxConcurrent), whether its grade and prices are the discovery's inference no
person has confirmed (unverified), and its note, the discovery's own words on where
it came from.One availability observation of one catalog entry, outside the dispatcher: a client built
straight from the entry's provider, one minimal call, and a
ProbeOutcome whatever
happens.The
pins object of a deployment's models.json: which catalog entries serve
each grade, in the deployment's order of preference, which embeddings entry the corpus is
tied to, and which decision entry answers decision seats.A response POJO whose reasoning is a
ChainOfThoughtReasoning: the approach and the
steps, for answers that need a documented path.Multi-step reasoning that captures sequential problem-solving.
The channel axis: which channel's work this is (email, phone).
The channel marker.
Character-count / 4 fallback counter for providers with no known tokenizer.
One stored conversation as the chat picker lists it.
One chat scope as the chat frontend sees it: the entity a conversation is
bound to, projected into a shape that is the same in every application.
Chat interaction thinker.
Pick one of the options the caller names.
The answer to a
Choice: the option that won, the probability of every option in the
order they were asked, and a confidence, which is arithmetic on that distribution (how far
the winner stands above a uniform spread) and not a second estimate of being right.Artifact representing a citation to a scholarly work (paper, preprint, book, etc.).
Counts tokens using OpenAI's cl100k_base encoding (via JTokkit) multiplied by a
per-family adjustment factor.
The classifier's verdict on a file nothing else could place.
The tier for what the code could not place: a small model looks at the file's head and
says whether it is text under a strange extension, a binary with nothing to extract, or
something a person should look at.
ToolProvider that wraps a Class<? extends Tool>.Common root of every API client the framework constructs, so a single
ClientProvider.createClient(ModelSpec) entry point can return either family.The RFC 7523 client assertion an agent signs to authenticate at a token endpoint: a
compact JWS whose claims name the agent as issuer and subject, the authorization
server's issuer identifier as audience (RFC 7523bis; the MCP conformance referee accepts
nothing else), a fresh
jti, and a short life.Constructs the concrete
Client for one provider/endpoint.Registry of
ClientProviders, discovered through the JDK ServiceLoader and
keyed by ClientProvider.key().Artifact representing a code snippet or program.
Defines the aggressiveness of context/message compaction.
POJO for structured compaction results from LLM.
The application's standing answer to "may this model serve my traffic".
A scope value spanning several UNRELATED axes at once - what a carrier returns from
Scoped.scope() when it claims two axes no inheritance chain connects (an
input that is both project- and user-scoped names both here).The CONNECTED frame's payload: a
StatusMessage that also tells the client
which durable conversation the just-started turn belongs to.What connecting did: the provider that verified the credential with its listed count, or its
failure in the provider's own words, or a note when nothing on the credential can list; and
the fresh status the page re-renders from.
The credential records a person provides for the session in one request.
Data classes for storing multimodal content in messages.
Base interface for all content blocks.
Represents a file (like PDF) to be sent to the LLM.
Represents an image to be sent to the LLM.
Raw JSON content that needs provider-specific formatting.
Structured data that needs provider-specific formatting.
Anthropic-redacted thinking block.
Admitted Skill bundle carried in the conversation preamble.
Plain text content.
Anthropic extended / adaptive thinking block.
Tool definition with schema for LLM tool calling.
Represents the result of a tool execution being sent back to the LLM.
Represents a tool invocation from the LLM.
Snapshot of a ContentBlock for persistence.
Interface for provider-specific content formatting.
Content guardrail: a pure function of the payload.
Which side of the gated execution a content guardrail polices.
Processes content blocks with context awareness, particularly for artifact handling.
The site's reading order, parsed from
nucleo-docs/CONTENTS.md: the one place that
says which documents the site carries, what each is called, and in which order a reader
meets them.Event for streaming LLM content chunks to users.
Interface for compacting conversation contexts to reduce token count.
Exception thrown when conversation context exceeds model limits even after compaction.
Base interface for storing and retrieving conversation contexts.
Manages context window limits and triggers compaction when needed.
A tool that acts on the conversation it was called from.
The claim of conversation continuity: an implementor ADOPTS the conversation identity
it is handed - its execution hydrates and continues that conversation.
Represents the conversation context for tool orchestration.
Snapshot of a ConversationContext for persistence.
Manages conversation ownership and access control in a multithreaded environment.
Snapshot of conversation memory stats for diagnostic logging.
Naming a stored conversation.
Base class for exceptions where the LLM's input was wrong and it may fix its
parameters and call the same tool again.
Runtime (unchecked) exception indicating the LLM's input was wrong and it may fix
its parameters and retry.
An amount in a currency: three upper-case letters, the ISO 4217 code, refused at construction
otherwise.
Cost accounting in memory: every call a finished job made, priced from the catalog in
the entry's own currency, kept per workflow, per model and per job, and the spend caps
workflows run under.
One call, as priced.
One model's share of a workflow: how many calls, how many tokens, how long, how much.
A workflow's spend so far: totals per currency, the split per model, every call.
The default database provider: a count and nothing else.
The account shape of every unit-permit gate held for the duration of the work: a fixed
capacity and an in-use count.
One credential as the runtime consumes it.
What a credential is made of, declared once by the code that owns its id: which of the
three parts (
user, secret, host) the credential has, the environment
variable each part is read from, and what each part means to a person.One part of a credential: the environment variable it is read from and what it means to a person.
The credential shapes the runtime knows, by id.
One credential a provider reads, as it declared it: the record id and its parts.
Input for getting the current time.
Output containing current time information in multiple formats, all rendering one
instant in the system timezone, so every field names the same calendar date.
Returns the current date and time in multiple formats, every one of them rendering the
same instant in the system timezone.
The customer-orders tool's input: whose orders to list.
The customer-order tool's input, and a claim: implementing the marker makes the customer
named here the one the flow's binding judges, and the one the tool looks the order up
under.
The customer-orders tool's output: one artifact per order.
Lists one customer's orders as artifacts.
Looks an order up among one customer's orders only, so the customer the input claims is
the customer whose data the tool reads: the field the scope judges is the field the tool
acts on.
What the customer-report doer is handed: whose orders, and the question to answer over
all of them.
What the customer-report doer returns: every order it looked up, exactly as the tool
returned it, and the model's answer to the question over them.
Orchestration written in Java.
The customer axis: a flow bound to one customer admits only inputs that name that
customer.
The customer marker.
The admission account for a single database connection pool.
The default database provider's knobs: whether the host registers a
CountingDBResourceProvider, under what name and with what bound.Input for DateCalculatorTool.
Output from DateCalculatorTool.
Compares two dates and calculates the difference between them.
Opaque handle issued by a
DBResourceProvider.acquire(boolean) call.Generic contract for a database resource provider that Nucleo manages
on behalf of jobs.
The process's database providers, by
DBResourceProvider.name().DB-backed
PromptSource that looks up content by key from a caller-provided
lookup function.What the decision agent is, for a page: its objective in words, the artifact type it starts
from and the one it answers with, and its palette, each tool with what it takes and what it
produces.
One tool of the palette.
The grouping tier of the pricing demo on a decision model: the same names in, the same
groups out as
CanonicalizeProductsTool.One decision, as a job: a
DecisionRequest in, the answers by question id out.A decision model behind one call: a state and typed questions in, a probability over the
options the caller declared per question out, with the call's own accounting (model,
billed input tokens, latency) on the response, which is what the job records and the cost
ledger prices.
One request to a decision model: a state and the questions to answer about it, each under
an id the caller chose.
One decision call, recorded on the job like every other model call: the catalog id it was
issued against, the input tokens the endpoint billed, the latency, the verdict, and the
answers by question id.
An agent whose model is a decision model.
The type of every tool a
DecisionThinker may hold: a tool that takes an artifact
and produces an artifact.One decision agent run, streamed as it happens: an observer on the runtime's message bus,
scoped to the run's workflow, writing every event of the thinker and of every job under it
as one line of newline-delimited JSON.
One turn of a
DecisionThinker, as the run records it: what the model was offered,
what it chose and how surely, and what came of it.A tool declared to a conversation before it has been rendered into a wire definition.
The stock
ComplianceEnvelope: the normal compliance decisions as declared
state, refusing by default.Default
MeterCustomizer that records standard job and LLM metrics.The shipped picker: a deployment that has authored nothing runs on the entries it can
call, and one that has written
pins into its models.json runs on its order,
with no picker class in either case.Default
SpanCustomizer that maps all available event fields to span attributes.Default
TokenizerFactory.Default
ToolWeight instances for unannotated tools.Exception thrown when attempting to access functionality that requires
a ResponseHandler on a dehydrated message (one that has been serialized
and deserialized, losing its transient handler).
A job's whole resource need: the ordered list of accounts it must hold at once, with the
amounts it needs on each.
One account of the demand: the limiter to call, the identity its amounts debit, and the
job's amounts on it.
The demo's one agent: a goal-directed thinker with two tools of its own, a catalog of tools
it may ask for through
request_tools, and a catalog of skills it may admit through
request_skill.What the demo agent returns: the answer, and which skills it admitted on the way, so the
caller can see the skill door being used.
The demo's read-side logic, shared by every host.
The demo's benchmark of
DemoAgent: the reference answers on the strongest model the
deployment serves - resolved through Grade.CEILING, the same way the judge is - while
every raced copy is re-pinned to its candidate, and the judges wait behind the same person
the raced agents do.Which model catalog this process runs on, and what to do when it is not this account's.
What the page and the startup log say about the catalog: the file the demo keeps it in
(
catalogFile, null when the process runs outside its module), where it
was read from (null when nowhere, and the runtime is on the shipped defaults), the file
the page's edits land in (null when the catalog in use is not a file of the deployment's
own: the shipped defaults, or a copy packaged on the classpath), how many entries it has,
each grade's order (its entries in the deployment's order of preference, the first the
grade's default), the single pins (the embeddings and the decision entry), and the steps a
person takes when something is missing.The doors of the demo, which the page at
/ (static/index.html) walks a
person through.Locates the shipped demo corpus, the folder the extract and decide runs read and the page
shows, wherever and on whatever OS the process runs.
Where the demo writes its catalog.
What every job the demo submits has in common: a person is waiting behind it in a
browser, so the runtime's defaults for unattended work are tightened here, in one place
each job's constructor reads.
The engine's plain objects handed to the CDI container: the same
FileIndex,
DemoCorpus and DemoCatalog the Spring host wires as beans, produced here as
application-scoped singletons so the JAX-RS resources inject them.The demo agent's input: the runtime's thinker input (a query and a depth) with nothing
added.
The doors of the demo under Quarkus: the same engine the Spring host serves, behind JAX-RS
instead of Spring MVC.
A refusal body in the shape the page reads: the rule it broke under
message.Once the container is up: the catalog the process runs on, and the steps to fix it when it
is not this account's, logged the same way the Spring host logs it on its ready event.
Exception thrown when a job cannot execute because one of its dependencies
has permanently failed.
Event published when a job fails because a job it depended on failed, before it ran.
Semantic signal for investigation depth, propagated top-down through thinker hierarchies.
The tier that costs nothing: text the code can read without a model or a native toolkit.
What a decision model reads of each artifact of this package, one line each, registered
as the types' text formatters: a decision thinker's state carries one digest line per
artifact and nothing else of it, so these lines are the whole of what the model decides on.
Coerces a provider's native embedding vector to the framework's canonical
dimension and unit length.
One model as a provider's account lists it, with whatever facts the listing carried.
What the discovery did: its report, the file written, the entry count, the providers this run
actually queried with each one's outcome, the entries the discovery's classifier wrote
(
classifiedBy names the model whose judgment they are; each carries a verify note), the
classified entries whose own ping refused them, the new entries left out because the model
refuses the zero-retention mode the account runs at (nonZdr), the listed models no
provider key has a client for (unserved), and the status the page re-renders from.Annotation to provide a human-readable display name and action verb for jobs and tools.
The escalation: work on one disputed order.
A file read as text: its name and the whole text.
What the price extractor sees: one document's path, for the model to reason about the
kind of document it is, and the text the extractor produced for it.
Interface for coded orchestration logic.
Input for DurationCalculatorTool.
Output from DurationCalculatorTool.
Calculates hours and minutes between two date-times with optional minimum threshold.
Declares a registered Prompt source whose content may vary per call.
Sliding-window rate limiter with elastic throttling and a circuit breaker, as an admission
account: it never blocks,
Admission does.Circuit state.
Status snapshot for a sliding-window rate limiter with adaptive throttling.
The shift: one customer's case, worked on the email channel.
A vector and the key it embeds, plus the model that produced it: vectors are comparable
only with vectors from the same model, so the index records which one every vector came from.
What an embedding is for.
An embeddings model behind one call: text in, a vector at the canonical width out, with
the call's own accounting (model, billed input tokens, latency) on the response, which
is what the job records and the cost ledger prices.
One embeddings call, recorded on the job like every other model call: the catalog id it
was issued against, the input tokens the provider billed, the latency, the verdict, and
the vector.
One text into one vector, on the deployment's frozen embeddings model.
An edit to one catalog entry from the page: the entry's id, and any of a new grade, a new
status, a new input or output price per million in the entry's currency, or a confirmation
that the entry's inferred facts were checked; null leaves a field as it is.
Credentials from environment variables, the store a fresh checkout runs against with zero code.
Input for EPO bibliographic data retrieval.
Output from EPO bibliographic data retrieval.
Fetches bibliographic data for a patent from EPO OPS.
Output containing backward citations parsed from EPO bibliographic data.
Input for EPO patent claims retrieval.
Output from EPO patent claims retrieval.
Fetches the claims text of a patent from EPO OPS.
Typed client for the EPO Open Patent Services (OPS) REST API.
Input for EPO patent description/specification retrieval.
Output from EPO patent description/specification retrieval.
Fetches the full description/specification text of a patent from EPO OPS.
Input for EPO INPADOC patent family retrieval.
Output from EPO INPADOC patent family retrieval.
Fetches the INPADOC patent family for a given patent from EPO OPS.
Input for EPOFullTextTool.
Output from EPOFullTextTool.
Fetches full patent content (biblio + claims + description) from EPO OPS in one tool call.
Input for EPO patent images metadata retrieval.
Output from EPO patent images metadata retrieval.
Fetches patent document images metadata from EPO OPS.
Input for EPO patent legal status retrieval.
Output from EPO patent legal status retrieval.
Fetches the legal status and event history of a patent from EPO OPS.
Input for EPO patent number format conversion.
Output from EPO patent number format conversion.
Converts patent numbers between DOCDB and EPODOC formats using EPO OPS number service.
Multi-bucket rate limiter for EPO Open Patent Services.
Input for EPO patent search.
Output from EPO patent search.
Searches EPO Open Patent Services for patents using CQL queries.
EPO OPS service buckets as reported in the
X-Throttling-Control
response header.API Thinker for EPO Open Patent Services queries.
Input for EPOThinker.
Output from EPOThinker.
Console log of every job event but the operational ones, one colored line per event on the
logger of the class the event is about: the workflow as a colored prefix (shortened to its
first ten and last four characters past fifteen), the job id and state in brackets, then
the event's message.
Rejects Prompts whose content contains framework-internal artifact markers of the form
«artifact:...».Exception thrown when an external service or API fails.
The demo's workflow: every file under a directory, read-only, each routed to the cheapest
tier that can read it, all of them in parallel under admission, and a report of what each
one cost.
What came out of one file: its text, or the reason there is none, or both.
How a deployment reads the formats code can open without a model, chosen by which
implementation is on the classpath.
The reading tier of the pricing demo: a small model reads one document's text and lists
every price it states, with what the document says about each (who pays it, whether it
is in force, proposed, former or a cost, and the dates attached).
The second demo, over the first one's result: every document the extractor indexed goes
to a small model that lists the prices it states, all documents in parallel under the
same admission and the same caps; the distinct product names then go once to a model a
grade up, which says which names are one product; and code does the rest, ranking every
price in force by date into current and superseded, and setting proposals, former prices
and costs aside as what they are.
What a run did: one row per file with the tier that handled it, the model that served it
and what that cost, and the run's totals per currency and per model from the ledger.
One file's row.
One model's share of the run.
A run of the extractor: at most how many files, and the spend it may commit.
One cap: an amount in an ISO 4217 currency.
Sealed marker for job failures: exceptions, timeouts, and dependency failures.
Describes a field within a POJO definition for LLM schema generation.
Default
ContentBlocks.FileBlock encoder: a text placeholder naming the file.One file of a folder as the listing saw it: its name, what kind of file its bytes say it
is, its size, and for a text file the first words.
What the classifier sees of a file nothing else could place: its name, its size and
its first bytes decoded as text, with undecodable bytes shown as the replacement
character.
The rudimentary index: every extracted text with its vector, in memory, searched by
cosine.
The note tool's input, claiming two unrelated axes at once: the order (which carries the
case) and the channel.
Files a note on one order of one customer.
The one input every extraction tool takes: which file.
The order agent asked one question: submitted like the tool was, answered as an
OrderAnswer.The customer-report doer run for one customer: every order it looked up, then the model's
answer over them.
The order-status tool submitted by plain Java code, the way any job is: the tool is the
same object whether code or a model calls it, and the next example hands it to a model.
A folder on this machine, the decision agent's input: the one artifact a run starts from.
Human-readable renderings of counts and durations for log lines and LLM-facing summaries.
Generates the HTML documentation site from the markdown files in the reactor's source
trees.
One page of the site: its id (the file name without .html), its title from the
contents, its markdown source, the part it belongs to as the breadcrumb reads it (null
for the front matter) and the package and module the source documents (null for a
document outside every module's source tree).
Generic content formatter for providers without specific requirements.
Generic MCP client implementation backed by the official MCP Java SDK (version managed
by the reactor's BOM,
mcp.sdk.version).Adapts an MCP-served tool to the Nucleo tool framework.
Input for retrieving full content of a specific artifact field.
Output containing full content of an artifact field.
Tool for retrieving full content of a specific artifact field.
Public API for the Nucleo job execution engine.
The capability ladder a seat declares its floor on.
The rule that puts a model on a rung of the
Grade ladder: the vendor's own tier, then
the model's generation, never its price.A job that declares its own guardrails.
A guardrail: a job that validates a single target object at a tool-invocation edge.
Framework-triggered enforcement of the job-based guardrail kinds.
Exception thrown when a guardrail validation fails.
The heartbeat engine: consumes framework-minted
Heartbeats off the bus into
the HeartbeatStore, and fires due entries as ordinary job submissions under
the authority captured at schedule time.A stored heartbeat: the intent of a
ScheduleHeartbeat plus the captured
authority under which it will fire - the publisher's principal and, for
orchestrator-published schedules, the publisher's sealed ScopeGuard, replayed
through the submission door at fire time so a self-scheduling flow cannot strip its
inherited scope.Sealed category for heartbeat control-plane events: schedule requests, cancellations,
and the Heart's lifecycle notifications.
A due heartbeat was dispatched.
Submission threw when the Heart tried to fire a due heartbeat.
A schedule request re-used an existing heartbeatId: the previous spec was replaced
(most-recent-wins).
A framework-minted heartbeat on its way to the store.
Confirmation that a heartbeat landed in the store - the publisher's way to verify its
schedule was accepted (a rebind publishes
HeartbeatRebound instead).Where pending heartbeats live between beats - aliveness as data, not as parked
threads.
The smallest Nucleo program: ask a model one question about a piece of text and print the
answer.
The Hibernate provider a job uses directly: it unwraps the
Session, connected and
held for the job's whole life.HTTP 400 Bad Request from an upstream API.
HTTP 401 Unauthorized from an upstream API.
HTTP 403 Forbidden from an upstream API.
HTTP 404 Not Found from an upstream API.
HTTP 413 Payload Too Large from an upstream API.
HTTP 422 Unprocessable Entity from an upstream API.
HTTP 429 Too Many Requests from an upstream API.
HTTP 500 Internal Server Error from an upstream API.
HTTP 502 Bad Gateway from an upstream API.
HTTP 503 Service Unavailable from an upstream API.
The admission account for the shared HTTP connection pool: one permit per admitted job that
makes HTTP calls, sized to the pool.
Shared HTTP connection pool for all API calls.
The upstream server's actual response to a failed HTTP call: status code,
which service answered, which endpoint was hit, and the raw body it returned.
Implemented by every exception that was raised from an HTTP status code, so
the server's own response can be read without knowing which of the eleven
carriers (the ten
HttpNNNException classes and
HttpUnmappedStatusException) was thrown or which semantic parent it
sits under.Factory for typed HTTP exceptions.
HTTP transport endpoint.
HTTP transport flavor.
A classic HTTP exchange's answer, fully read: status, headers and the body as text.
The HTTP package's knobs: the size of the one shared connection pool.
An error status with no class of its own - a 402, a 408, a 520 from a proxy - carried with
its status, service, endpoint and body like the mapped ones, so a caller judging by
HttpErrorResponse sees every status the service answered and never mistakes an
unmapped status for a failure to reach the service, which has no status at all.Marker interface for any object that contains a message suitable for human consumption.
Interface for workflow lineage tracking.
Default
ContentBlocks.ImageBlock encoder: a text placeholder naming the image, for providers that cannot
carry the image natively.Base class for incoming WebSocket messages with polymorphic deserialization.
The message a model sends back: its text and content blocks, the handler that parses the
typed answer out of it, and the output token count the provider reported.
Chat message request.
Force unlock a conversation that's locked by another job.
List current subscriptions.
Ping request for keepalive.
Subscribe to workflow progress.
Unsubscribe from workflow progress.
The platform-default heartbeat store: process-local, synchronized, gone with the JVM.
What a request sends a model beyond text, and what a catalog entry says the model accepts.
Exception thrown when a tool input parameter fails validation.
A
DBResourceProvider over any DataSource: a job gets a plain
Connection, checked out when the job is admitted and held until it finishes.Interface for all jobs that can be submitted to the job processing system.
Event published when a job is cancelled by explicit request.
Thrown when the dispatcher terminates a job because it was cancelled before
completion.
Event published when a job completes successfully.
Runtime context for an executing job.
The runtime's cancellation signal: thrown by
JobContext.checkCancellation() inside a
running job, raised by the dispatcher for a job cancelled before it started or one
that finished without observing its cancel, and wrapped by
JobCancelledException on the way to the caller.Cancellation token for cooperative cancellation.
Exception thrown when a job attempts to block on another job's completion
while holding resources, which would cause deadlock.
The runtime: one dispatcher per process, the entry point for every job submission and the
one execution path every job takes.
Scheduler configuration.
Base interface for all job-related events: a snapshot of the job at the moment of the
event, the event's instant, and an optional message.
Event published when a job fails with an exception (not timeout, not cancellation).
Handle for a submitted job, providing result retrieval and cancellation.
Observer interface for handling job events;
JobObserver.observe(T) is its one abstract method, so a
lambda is an observer.Job progress event with typed payload.
Specifies the configuration for job execution.
Per-job container for every resource a job holds during execution: the
Grant that
Admission took for the job's whole Demand (model token reservations, the HTTP
connection permit, custom limiters, database gate permits), the database handles
materialized under those permits, and the LLM, embeddings and decision clients.Event published when a job is scheduled or queued for execution.
State of the scheduled job.
Immutable snapshot of a job's identity and state at a specific point in time.
Event published when a job starts executing.
States a job can be in during its lifecycle.
Event published when a job exceeds its maximum execution time.
Thrown when the dispatcher terminates a job because it exceeded its execution
time budget.
Classification of job types for analytics and cost attribution.
Default
ContentBlocks.JsonBlock encoder: the raw JSON, wrapped as a provider text block.Default
ModelsBackend: the catalog discovered on the classpath the way logback finds
its configuration.One catalog source: where it came from (for messages), its text, and whether it is a fragment.
The model's reply was not the JSON object asked for: no JSON in it, JSON that would not parse,
or valid JSON of another shape.
What the judge sees: the task as the job received it, the reference run in full - the
strongest model's transcript, every tool it called and what each returned, and its answer,
the ground truth - the candidate run in full the same way, and any extra criteria the
caller gave.
The benchmark's judge: the strongest model the deployment serves, comparing one
candidate run against the reference run under one fixed rubric, so every model is
measured by the same stick.
What the judge answers, in the rubric's two parts: accuracy out of 7 and shown work out of
3, each in half points, the tool fault it found if any, and the reason.
An artifact whose filterable fields are a dynamic, data-defined name->value set
rather than static Java fields, so a list-processing predicate can address them
by name (e.g.
Sealed marker for events fired exclusively by the platform (job dispatcher).
Per-transition event of one admission account.
The observable identity of one admission account: what the health snapshot, the
LimiterEvent stream and the span and meter customizers
name a row after.Base artifact for any entity that has a title and a URL.
The runtime's message bus: per-subscriber queues on virtual threads, so a slow consumer
never blocks a publisher or another consumer, and three indexes (workflow id, event type,
job type) that narrow the candidates before each subscription's own filter judges the event.
Rewrites links in a page's markdown before conversion.
Connecting to an MCP server the generic way, with no server-specific code: name the
endpoint, attach, and every tool the server grants is ready to hand to an agent
(
thinker.addTool(provider), shown to the model as orders_order_status:
handle, underscore, the tool's own name) or to call from code, as here.Artifact holding an ordered, homogeneous list of artifacts - its iterands.
Deterministic text form of a
ListArtifact: a header with the count and
iterand type, then every iterand numbered in list order, each rendered through
its own formatter via TextFormatterRegistry.Lists a folder: every regular file in it, by name, with what its bytes say it is and, for
a text file, its first words.
Output from literature aggregation analysis.
Autonomous agent that searches biomedical literature, analyzes findings,
and produces a comprehensive synthesis with references to key papers.
Short-lived job that runs a single LLM call against a supplied
ConversationContext.Interface for LLM client implementations across different providers.
Intelligent context compactor using LLMs for semantic-aware conversation summarization.
Marks a field that the LLM may WRITE but must never READ back.
Provides a description of what a field or class should contain.
Provides example values for a field to help guide LLM generation.
Marker interface for any object that contains a message suitable for LLM consumption.
Base class for exceptions that can be communicated to LLMs in an actionable, understandable form.
Sealed interface for exceptions that can be communicated to LLMs in an actionable form.
Base class for unchecked exceptions that can be communicated to LLMs in an actionable form.
Encapsulates an LLM request tied to a
ConversationContext.Marks a field as required in LLM-generated responses:
@required in the notation the
model reads, the required array of the JSON Schema, and what
PojoResponseHandler.validateRequiredFields checks on the instance.Response object from LLM API calls containing token metrics and response data.
Normalized, provider-agnostic reason an LLM stopped generating.
Controls whether a text field should be summarized when serialized for LLM consumption.
Summarizer that spawns
SummarizationTool jobs for high-quality LLM-generated summaries.A decision model served on this machine over the System One wire - a
kev.serve, or
any open replica started locally.Marks a tool as exposable over MCP.
Decides whether a consumer may use an exposable tool.
A bearer token the authorization server minted for an agent, and when it stops being
valid.
Generic artifact wrapping an MCP tool's structured response.
Rebuilds a typed
Artifact from an MCP result served by another redouble process.The URL arithmetic of the MCP authorization specification (2025-11-25), as pure
functions: where a protected resource's metadata lives, where an authorization server's
metadata lives, and what the
WWW-Authenticate challenge says about the former.The JSON reader a host must give its transport, so that bytes from outside are decoded as
strictly as
McpInputGate judges what they decoded into.Client interface for interacting with MCP servers.
What an agent presents to an MCP server's authorization server to prove it is the agent
it claims: a static secret (
AgentSecret) or a private key whose public half the
server holds (AgentSigningKey).Transport-agnostic registry of live
MCPClient instances keyed by
MCPEndpoint.getEndpointId().Single attached MCP server, identified by an
MCPHandle.Process-wide registry of
MCPConnectors, keyed by the composite identity
(handle, endpointId).The principal behind an MCP request as the host resolved it: the name every served tool
runs as (
Job.workflow(name, "mcp")) and the groups the access policy may grant
by.Names the consumer behind an MCP request.
Represents a content item in an MCP tool response.
Describes how to connect to an MCP server.
What a failure is allowed to say to a caller in another process.
Stable identifier for an MCP connector.
The admission gate for arguments arriving from outside the process.
Pure transformation: a
JsonNode (an MCP tool's structured response, however
we obtained it) into an MCPArtifact tree.Conservative JSON-Schema normalization for MCP server schemas before they are placed in
the LLM-facing
ToolDefinitionBlock.The outbound schema boundary: turns a
ToolProvider into the McpSchema.Tool
an external client sees.The MCP endpoint in three beans: the SDK's stateless HTTP servlet mounted at
/mcp
like any servlet, and an McpToolServer over it.Metadata about an MCP server obtained during initialization.
The MCP package's knobs: the STDIO subprocess admission caps, the idle eviction timeout,
and the description ceiling on tools surfaced to the LLM.
Obtains a bearer token for an MCP server the way the MCP authorization specification
(2025-11-25) and its client-credentials extension prescribe, against any conformant
server: discover the protected resource metadata (the well-known forms first, the
server's own bearer challenge when it serves neither), read the authorization server's
metadata, check that it offers the client-credentials grant and this credential's
authentication method, and post the token request carrying the RFC 8707
resource
indicator.Owns "ensure a token" for one transport: attaches the held token to every request, mints
one first when none is held or the held one has expired, and forgets a token the server
rejected so the next request mints again.
Describes an MCP tool's schema and metadata.
Input wrapper for MCP tool calls: the raw
JsonNode arguments, untyped because
the remote server is the schema authority.ToolProvider for an MCP-served tool.Result from an MCP tool call.
Serves exposable tools over MCP through a host-supplied stateless transport.
The fail-closed security decorator around the host's stateless transport.
Transport types supported by MCP endpoints.
Heap-aware back-pressure on new work.
Status snapshot for the memory-pressure gate: heap occupancy, the floor, which is the reading
after the most recent collection the gate saw and the number the growth penalty measures, the
zone the gate is in (
CRITICAL while latched, DRAINING while memory's line is
non-empty, GREEN otherwise), how many jobs admission is holding on it, which is memory's line, how long
until the next release is due if a completion does not come first, and the growth penalty
multiplying that wait.Base interface for all messages in a conversation.
High-performance message bus for job lifecycle events.
Handle for managing subscriptions.
Event signaling that a single message exchange in a chat session has completed.
Snapshot of a Message for persistence.
Callback for recording Micrometer metrics in
MicrometerObserver.Global observer that forwards job lifecycle events to a Micrometer
MeterRegistry.Thrown during
TypeAliasRegistry initialization when concrete
Artifact classes are found without a required @TypeAlias annotation.The deferred binding between a declared model need and the spec that ends up serving
it.
The discovery's own judgment call: an account listed models the catalog has no entry for
and no ancestor to inherit a shape from, and classifying them is exactly what the runtime's
strongest model is for.
A job that holds a model seat: a thinker, the call a thinker spawns per turn, a tool whose
work is one exchange with a model.
A tool that holds a model seat: what a benchmark races, a thinker or a one-call tool
alike.
What a provider knows about its own account that the catalog cannot: which models the
account can reach, and, where the provider publishes them through an API, the account's
limits and each model's retention posture.
The admission account for a model endpoint bounded by how many requests it works on at
once rather than by a quota window: a model served from a machine the deployment owns,
whose catalog entry declares
max_concurrent.The three client families a catalog entry can belong to, and a seat can ask for.
A catalog identity read as a family and a version, so the discovery can tell that
opus-5 is a newer opus than opus-4.8 and that nova-2-lite
succeeds nova-lite: a listed model with an ancestor in the catalog inherits the
ancestor's shape and the ancestor's disposition.Thrown when a model id does not resolve to any catalog spec.
The deployment's model-resolution policy: turns a declared need into a concrete
ModelSpec.The framework-owned gate in front of the configured
ModelPicker.The deployment cannot serve a model seat at all: every rung the seat may legally be
served from was refused - by the compliance envelope, or because nothing is configured
there.
Static facade over the model catalog, mirroring
ai.redouble.nucleo.prompt.Prompts: a
pluggable ModelsBackend (DEFAULTS) under a per-id override layer and a resolution
cache.The model-resolution knobs: which catalog backend serves specs, which picker resolves
seats, and the deployment's Bedrock Mantle projects that model eligibility and request
routing consult.
Capability and account metadata for one concrete (provider, model) deployment.
Whether a catalog entry may be served, and who said so.
Message type for user-facing events.
Generates the sidebar navigation shared by every page of the documentation site, from
the contents: the front matter at the top, then one numbered, collapsible section per
part, its pages in reading order and a nested item under the item it nests under in
CONTENTS.md.Sealed category for discrete notifications surfaced to end users:
warnings, successes, informational messages, and errors that are not
themselves job-lifecycle transitions but warrant user attention.
A planned operation that has not been built yet.
The probability that a statement is true.
The answer to a
Noul: one number, the probability that the statement is true.What the starter puts into a Boot application: the credential store that reads
nucleo.credentials.*, the binder that maps nucleo.* properties onto the
registered Settings classes, the runtime's lifecycle bean, and the registration of
the application's database.The whole configuration surface a deployment author touches: one class per deployment,
one method, assigning the
Settings fields that differ from the shipped defaults.Registers the application's database with the runtime when the container starts: the
CountingDBResourceProvider that DBResourceProviders.registerDefault() builds
from DatabaseSettings, bound from nucleo.database.*.Registers the application's database with the runtime once every bean exists: the
CountingDBResourceProvider that DBResourceProviders.registerDefault() builds
from DatabaseSettings, bound from nucleo.database.*.A Spring Boot process running the runtime in-process, through the starter and nothing
else: credentials are Boot properties under
nucleo.credentials.*, bound in
application.yaml; the dispatcher's lifecycle is the starter's NucleoRuntime
bean; everything else runs on the shipped defaults, AWS through the AWS SDK's own
resolution, and each grade served from the first catalog entry a configured provider can
call.Central JSON serialization for the Nucleo framework.
Pair of (json, prose) returned by
NucleoJsonSerializer.extractJsonWithProse(String).The build-time steps that make the Nucleo runtime work in a GraalVM native image.
The runtime's lifecycle, bound to the CDI container: the
nucleo.* properties bind
onto the registered settings, then the dispatcher starts, before the HTTP router accepts a
request; on shutdown it drains.The runtime's lifecycle, bound to the application context: the dispatcher starts before the
web server accepts requests and drains after it stops accepting them.
The
x-nucleo-* JSON Schema vocabulary: keywords that carry a field's Nucleo
annotations to a consumer that cannot read the annotations themselves.The entry point of a Spring Boot application that runs the runtime: what
SpringApplication.run(String...) is, plus one command.Serves OpenAI chat models through OpenAI's own client on the Chat Completions API: the same
account, key and models as
OpenAIProvider, on the older surface, for an entry that
must be called there.The Chat Completions dialect over the framework's own HTTP transport, for the endpoints that
speak it without being OpenAI: a self-hosted server, an aggregator, a vendor with an
OpenAI-shaped API.
The embeddings half of the OpenAI dialect over the framework's own HTTP client, for
endpoints that speak it without being OpenAI.
Serves embedding models on an endpoint that speaks OpenAI's dialect without being OpenAI,
under the same credential as
OpenAICompatibleProvider: one endpoint, one key, its
chat and embedding models told apart by the provider key of each catalog entry.Serves chat models on an endpoint that speaks OpenAI's Chat Completions API without being
OpenAI, through the framework's own HTTP client;
OpenAICompatibleResponsesProvider is
the same for an endpoint that speaks the Responses API.Serves chat models on an endpoint that speaks OpenAI's Responses API without being OpenAI,
through the framework's own HTTP client:
OpenAICompatibleProvider on the other surface,
same credential, same listing, same rule that its entries are the deployment's to write.Content formatter for OpenAI GPT API.
Serves OpenAI embedding models through OpenAI's own client.
OpenAI native file: image-compatible files become an
image_url element; anything else has
no OpenAI file channel and falls back to a filename text element via the injected wrapper.OpenAI native image: an
image_url content element with a base64 data URL.Serves OpenAI chat models through OpenAI's own client on the Responses API, the surface where
the reasoning generation reasons and calls tools in one turn.
OpenAI itself, through OpenAI's own Java client, on whichever of OpenAI's two APIs the
provider that built it serves.
OpenAI's embedding models through OpenAI's own client.
The one OpenAI text wrap: a string becomes a
{"type":"text","text":...} content element.Chat Completions
ContentBlocks.ToolDefinitionBlock encoder: nothing inline.Chat Completions native tool result: a whole
role:tool message answering one call by
its id.Chat Completions native tool call: one element of an assistant message's
tool_calls
array, carrying the provider's own call id, the function name and the arguments as the
JSON text the model wrote.The completely open picker base: any route of the same identity may substitute for
an overloaded sibling - Bedrock, Mantle, direct, anything the catalog carries.
Global observer that translates job lifecycle events into OpenTelemetry spans.
Sealed category for high-volume operational telemetry: rate limiter
transitions, backpressure signals, and similar framework-internal
observability events that fire at runtime-load frequencies rather than
at job-lifecycle frequencies.
Interface for resource-free orchestrators that coordinate other jobs.
Published when an orchestrator (thinker/doer) finishes its current work and goes idle.
Published when an orchestrator (thinker/doer) resumes work after being idle.
An agent is a model working in a loop with tools: it reads the question, decides which
tool to call, reads what came back, and goes on until it can answer.
What the order agent answers, as the Java object the caller declared.
A grade's order from the page: the grade and its entries in the order of preference, the
first the grade's default; an empty list clears the order.
The order-status tool's input: the one parameter a model fills in when it calls the tool,
and a Java caller sets when it submits it.
What the order agent is asked: a customer's question, in its words, as the query.
When a model passes data along, it retypes it, and now and then a digit changes or a date
is rounded with nothing in the answer showing it.
The examples' stand-in for an application's own data: five orders of two customers, held
in memory.
A narrowing of the case axis: one order of one customer.
The order marker, extending the case marker the way its scope extends the case scope.
A Spring Boot application offering the order-status tool to outside MCP clients, on
http://localhost:8901/mcp.The application's one connection to the orders MCP server: connected at startup, shared
by every tool that wraps one of the server's tools, closed at shutdown.
One order as the order-status tool returns it.
A model on its own can only read and write text; for everything else it needs tools,
pieces of your code it may ask to have run.
Concrete outgoing message class for sending content to LLMs.
What a seat declares about the size of its answer: an
OutputSize rung, or a raw
token count for the seat whose answer fits no rung.The vocabulary form: the entry translates the rung.
The documented exception: a seat that knows its answer size in tokens.
The seat's answer-size vocabulary, the third word next to grade (which model) and depth
(how much effort): "MEDIUM model, STANDARD effort, COMPACT answer".
Event published when an LLM response hit
stop_reason=max_tokens and the
job is being re-run with an enlarged output budget.Signals that the provider returned
stop_reason=max_tokens and the job
should be re-run with a larger output budget.The shift run for C-100: five notes attempted under the overlapping bindings, each
outcome printed.
The provider reported that its fleet is overloaded (Anthropic's 529
overloaded_error): a capacity signal, not a fault and not a budget
violation.Input parameters for the PaperAggregator agent.
Tolerant readings of values a model or a document spells in its own way.
One part of a credential: which part (user, secret, host), the environment variable it reads from, and what it means.
Artifact representing a patent document with bibliographic front-page data.
Extended patent artifact that includes the full claims and description text.
Reference INPUT-direction
ContentGuardrail: refuses any input whose serialized
form exceeds a character cap.The vision reader for the POI/PDFBox host: an image, or a PDF whose pages are pictures.
Exception thrown when a job cannot be executed due to insufficient permissions.
Store for long-term persistence of conversation contexts.
Query object for finding contexts.
Artifact representing a person entity (author, researcher, contributor, etc.).
Reference OUTPUT-direction
ContentGuardrail: detects potential PII in tool
results before they reach the conversation - Social Security numbers, credit card
numbers, email addresses, phone numbers.A single pin from the page: the slot (
embeddings or decision) and the entry id; null clears the slot.Artifact representing a full-text article from PubMed Central.
Input for fetching full-text articles from PubMed Central.
Output from fetching a full-text article from PubMed Central.
Fetches full-text articles from PubMed Central via NCBI E-utilities.
The POI/PDFBox reader: text the code can read with the mature Office and PDF libraries.
The Apache POI / PDFBox reader, chosen over the engine's toolkit-free default whenever this
module is on the classpath (a higher priority).
ContentBlocks.PojoBlock encoder: an invariant guard.Represents a hierarchical definition of a POJO structure.
Generates LLM-friendly schema descriptions from POJOs annotated with
LLM and Jackson annotations.
A conversation flattened for one provider, with the channel distinction preserved:
the system content and the turns are separate, named parts.
The demo's decision agent: a
DecisionThinker over a folder of documents whose
objective is to find the statements that decide a change of a price.The logic of "which price is current", with no model in it.
What the reconciliation produced: the products, and the mentions it could not use.
One mention with where it came from and the date its document carries.
One price a document states, as the model reads it: what it is for, who pays it, what
kind of statement it is, and the dates the document attaches to it.
What the model answers for one document: the date the document carries as a whole, and
every price it states.
One mention placed in a product's history: the amount, the date it ranks by, where it
came from, and the status the reconciliation gave it.
One product's prices for one audience in one currency, ranked by date: the current
price when the documents settle one, and every point that competed for it or was set
aside, newest first.
What the pricing run found: every product with its current price per audience and
currency and the history behind it, the costs the documents state, the mentions the
arithmetic could not use, one row per document read, and what the run spent.
One document's row: what reading it produced and cost.
A run of the pricing demo over the last extraction: the spend the run may commit, one cap
per currency, the same way the extractor is capped, and the day the run answers for.
Reference
AuthGuardrail: only the named principals may invoke the declaring
tool.One availability observation of one catalog spec: what a probe ping saw, in full.
What kind of failure this is; null unless
ProbeOutcome.getStatus() is FAILED.Immutable data structure containing one conversation turn ready for LLM consumption.
What the canonicalizer answers: the names grouped by the product they name, each group
under one canonical name.
One product and every name the documents used for it.
What the canonicalizer sees: every distinct product name the documents used, as they
used it.
Everything the documents say about one product's money: its series per audience and
currency, what it costs the company, and whether it is still sold.
Sealed category for progress-style events emitted during job execution:
intermediate status updates, streaming content chunks, and similar
continuous-or-incremental signals intended for user-visible progress
reporting.
A named, identified, guardrailed unit of instructional content destined for an LLM.
Lineage metadata for a
Prompt: content hash, production timestamp, optional
version and variant tag.Jackson module registering serializer/deserializer for
Prompt.Thrown by
Prompts.produce(String) when the requested key resolves to no source
in the per-key override, global backend, or default layers.Thrown at scan time -
Prompts.scanPackage(String) or the auto-scan the first
produce triggers - for programmer errors in
StaticPrompt / DynamicPrompt declarations: duplicate keys, invalid
placement (non-static fields/methods that the scanner shouldn't touch are skipped, but
a static field/method that violates the contract throws), missing no-arg constructor on
annotated classes, or content type mismatched to the annotation's static/dynamic promise.Governor-style facade for the Prompt registry.
Produces the content for a Prompt given its key.
The part of an RFC 9728 protected resource metadata document a client-credentials client
reads: which resource the document is about, and which authorization servers issue
tokens for it.
The link between a catalog entry and the provider that serves it.
One queried provider's outcome, readable at a glance: LISTED with a count, LISTING_FAILED with
the reason, LISTING_UNSUPPORTED (pinged blind).
The provider declined to answer: the call came back with an empty body and a stop reason
that says so (Anthropic's
refusal, a guardrail, a content filter).One provider on the status panel: its key, whether it is configured, whether a session credential
holds it, the human description of its credential, the credentials it declares, and its connection facts.
Puts the generated site into a checkout of the documentation repository as one version
of the published documentation.
Input for fetching full details of specific PubMed articles by PMID.
Output with detailed article information from PubMed.
Author information with affiliations.
Detailed article record with complete metadata.
Grant/funding information.
Journal information.
MeSH term with major topic indicator.
Fetches detailed article information from PubMed by PMID.
Rate limiter for PubMed/NCBI E-utilities API.
Input parameters for searching PubMed articles.
Output from PubMed article search.
Individual PubMed article with metadata.
Searches PubMed for biomedical literature using NCBI E-utilities API.
The one thing a Quarkus host tells the runtime in code: credentials are MicroProfile Config
properties, read by
QuarkusSecrets.The runtime's credentials, read as MicroProfile Config properties.
One typed question a decision model answers about a state.
The quick question's answer as the page shows it: the answer and the model's reasoning, the
catalog entry that answered and the model that served it, and what the call cost, priced from
the catalog like every other result on the page.
The calls of one job, delivered by its completion event; see
QuickAnswer.capture(JobDispatcher, QuickLLMQuestionTool).Input for quick LLM question.
Output from quick LLM question.
Lightweight tool for asking focused questions about specific text.
The provider account is out of money: no remaining credits, an exhausted
prepaid balance, or a spend budget set to zero.
Is the grade right for this job, and which model at that grade does it best, for what
cost and how fast? The benchmark answers with evidence: it runs the job once the way the
deployment would (the reference), then the same job with the same input on every model of
the grade the deployment can call, and a judge - the strongest model the deployment
serves - compares each run with the reference in full, not told which model ran either
side.
How a permit taken from this limiter comes back, which decides whether
Admission may return it when the job finishes.Lookup facade for per-model accounts: the
TokenBucketRateLimiter of an entry
bounded by a quota window, the ModelGate of an entry bounded by a concurrency.Snapshot of a rate limiter's current state for diagnostics and monitoring.
Captures rate limit information from API responses.
Event published when a job hits a rate limit and will be transparently retried.
The provider rejected this attempt as over the caller's rate budget (429).
Type of rate limit encountered.
Thinker for message-driven interactions, executed as one finite TURN.
Reads a file as text: a text file decoded, an Office document with its tags stripped.
The rules behind
AbstractThinker.isForceReadOnly(): the sweep that removes mutating
tools from a registry, and the admission assertion that backs it.The read-only binding, carried as a
Scope so it travels exactly like every
other binding: composed into the effective guard at an orchestrator's dispatch,
sealed for its lifetime, and inherited by everything that flow submits.Base class for LLM response POJOs that capture reasoning.
Base interface for LLM reasoning capture.
How a heartbeat repeats.
Default
ContentBlocks.RedactedThinkingBlock encoder: nothing on the wire.Construction of configured classes by name or type: the deployment's configurator, the models backend,
the model picker, the secrets store, the discovered client providers.
Field lookup shared by tools that address artifact fields by LLM-supplied
name: accepts snake_case or camelCase and walks the class hierarchy.
One tool of the orders MCP server wrapped as a tool of this application's own, with the
input and output classes fixed here: the same
OrderNumber in and
OrderStatus out as the local tool.Fetches prompt content from a remote URL, passing the key as a query parameter.
Input for the
request_skill meta-tool.Result from requesting skills via
request_skill.Meta-tool that admits skills from the thinker's catalog into the current conversation, the
skill counterpart of
RequestToolsTool.Input for the request_tools meta-tool.
Dynamic
ToolProvider for RequestToolsTool.Result from requesting tools via the catalog.
A tool that was rejected during admission.
Meta-tool that activates tools from the catalog.
Exception thrown when a resource identified by a well-formed identifier does not exist.
The self-correction of one LLM exchange, shared by every job that sends a conversation
and expects a typed answer: a response that fails to parse, or parses but fails the
handler's required-field validation, is fed back to the model.
Event published when an LLM response failed to parse or validate and the job is
being re-run with a correction message appended to its conversation.
Signals that an LLM response failed to parse or validate, a correction message
has already been appended to the conversation, and the job should be re-run so
the model can fix its output.
The typed contract of one outgoing message: how the model is told what shape to answer
in (
ResponseHandler.responseInstructions()), and how its reply parses back into T
(ResponseHandler.parse(String)).Parses a raw HTTP response body into a typed result.
Exception representing an LLM response that parsed but failed required-field
validation (
@LLMRequired fields null or blank).Sealed category for retry / recovery signals.
What a workflow spent, read off the cost ledger once it is done: the caps it ran under,
the totals per currency, the split per model, and the call counts.
The whole status panel in one shape: whether the dispatcher runs, the providers, the catalog
summary, the catalog entries, per grade the entry the runtime serves each kind of request with
now (text, images, documents) and, where it serves none, its refusal in its own words, the
shipped corpus path the page prefills, and the day the corpus's price story is answered for,
which the pricing steps open on.
XML parsing safe against XXE.
Checks that the code a page shows is the code that compiles.
A request to fire a heartbeat: INTENT ONLY.
System-level event for scheduler state changes: started, stopping, stopped, or an error
carrying its cause.
Types of scheduler events.
Validates a
Skill's structural invariants before admission:
name present and non-blank.
body non-null.
suggestedTools entries are known to ToolHub.isKnownTool(String).The spellings in which one tool contract is published over MCP.
Names the
SchemaRefiner that narrows this tool's generated input schema with values
known only at runtime, so a caller is told every accepted name rather than left to guess one.Narrows a tool's generated input schema with what is known only at runtime.
The rewrites the dialects are composed from, and the reference inliner the inbound
normalizer shares with them.
A scope: the value that says what a flow is about - a ticket, a project, a tenant -
carried as a small axis-typed value produced by a
Scoped carrier.The scope-carrying surface of every orchestrator: a
ScopeGuard field that is
the authoring seat before dispatch and a sealed capture afterwards.Something that produces its scope value - the parent of every domain marker
(TicketScoped, ProjectScoped, ClaimScoped, ...).
What the browser sends over a scoped chat socket.
The scope guard of an orchestrator: an immutable bag of bound
Scope values.A position on an ordered scale the caller describes, lowest level first.
The answer to a
Score: a probability per level in the order the levels were asked,
their weighted position on the scale (level index 0 for the lowest, and fractional between
levels), and a confidence, which is arithmetic on the distribution and not a second
estimate of being right.A score in code, for an output that can be compared to the reference without a model:
an extraction against the reference extraction, a classification against the reference
class.
Any thinker goes into a benchmark unchanged: here the selecting agent of the artifacts
example, raced across its grade exactly as written there, with two setters sharpening
what gets measured.
Input for searching across artifact content.
Output containing search results across artifact content.
Tool for searching artifact content by exact case-insensitive string matching.
What the site's search box searches: one entry per place a reader can land on, written
as the page asset
search-index.js.One place a search lands on: the address relative to the site's root, the title of
the page or the name of the class, the part of the contents the page belongs to (null
for the front matter), the heading of the section (null for a page's opening and for a
class) and the text searched.
A single search match result.
Who is asking for a model: the identity of the declaring workload.
Where the runtime gets its credentials.
Lazy holder: the class initializes, and so the store gets built, on the first
Secrets.configured() call.The secrets package's knobs: where the runtime gets its credentials.
A credential the runtime asked for cannot be had: the deployment holds nothing under the id, or
its store cannot answer.
The selecting agent's answer: a summary in the model's words, and - inherited from
ThinkerOutput - the references of the artifacts it selected, which the runtime
resolves to the records the tool produced.An agent that selects data instead of retelling it: it lists a customer's orders with its
one tool and answers with the references of exactly the orders the question asks for.
The selecting agent asked about one customer's orders: the summary is the model's, the
records are the tool's.
Status snapshot for a semaphore-based concurrency limiter.
A MicroProfile config source over the credentials a person pastes into the page, held in memory
for this process only.
The Quarkus host's store of credentials a person pastes into the page.
Credentials a person pastes into the page, held for this process only.
One credential record a person provides for the session: the runtime's record id and its parts.
A host's store of credentials a person pastes into the page, held for the process only.
Store for session-scoped conversation contexts with automatic expiration.
The base of every runtime tunable.
Minimal reasoning implementation for simple justifications.
Goal-driven thinker working toward a single final answer.
Everything the harness knows at the moment it consults the
ModelPicker - an
open bag of ingredients, every field optional.One prior attempt of the current execution: the spec that served and how it failed.
Rejects Prompts whose rendered text exceeds a configurable character limit.
Structured bundle of prompt content admitted into a thinker's conversation as a unit.
Default
ContentBlocks.SkillBlock encoder: the skill's body rendering, wrapped as a provider text block.One skill on the page: its name, description, origin, bundle id and the tools it suggests.
Discovers skill bundles packaged inside classpath JARs ("skilljars") and registers them
in
SkillRegistry.Raised by
SkillJarsLoader when a classpath skill bundle fails to parse or register.Provenance and admission metadata for a
Skill.Name-indexed lookup for
Skill instances.Names the skills a thinker may pull into its conversation at run time.
What a file is by its first bytes, which no extension can lie about.
Callback for customizing OpenTelemetry spans in
OpenTelemetryObserver.A dollar cap on a workflow: this piece of work may spend one cent, and once one cent is
committed, no new model work starts.
A job was refused at admission because the spend its reservation would commit, on top
of what its workflow has already spent, crosses the cap the workflow runs under; or
because the cap is in one currency and the job's model is priced in another, or not
priced at all, so nothing can be said about the spend.
The money wall of admission.
Splits a document into its statements: a paragraph's sentences (consecutive lines make
one paragraph), each bullet or numbered item.
The one thing a Spring Boot host tells the runtime in code: credentials are Boot
properties, read by
SpringSecrets.The runtime's credentials, bound the way every other Boot property is.
A
DBResourceProvider over the application's own Spring
ResourceTransactionManager, so the data access a Spring application already has -
repositories, JdbcTemplate, @Transactional services - runs inside a job on
the connection the job was admitted for.Concrete
ModelSpec for providers that need no fields beyond the common base
(OpenAI chat, OpenAI/Azure embeddings, Bedrock Converse models).One statement of a document: a sentence or a bullet, with the document it came from and
its place in it.
Grants from configuration: a map keyed by a consumer's name or a group name, each naming the
tools that key admits.
Declares a registered Prompt source whose content is promised immutable.
Marker sub-interface for
PromptSource implementations whose produce(key)
always returns identical content for the same key.StaticPromptSource whose content is a fixed String captured at
construction time.Simple status/error message for WebSocket responses.
The case agent bound to one customer and asked about another customer's order.
Global pool for STDIO MCP endpoints.
Admission account for a single STDIO MCP endpoint: the per-endpoint cap on concurrent
subprocess slots.
Background daemon that closes the clients of idle STDIO MCP endpoints.
STDIO transport endpoint - spawns a subprocess and communicates via stdin/stdout.
Convenience base for external observers following the heart's lifecycle - audit
loggers, dashboards, metrics exporters.
Interface for components that need graceful shutdown.
Represents a single chunk of streaming response from an LLM.
Workflow observer that logs streaming events with formatted console output.
A response POJO whose reasoning is a
SimpleReasoning: one thought, for answers that
need a justification and nothing more.The plain-text contract: the model answers in prose and
StringResponseHandler.parse(String) returns it
verbatim.Dynamic sub-agent that any thinker can spawn at runtime.
Input for a dynamically spawned sub-agent.
Output from a dynamically spawned sub-agent.
Sealed marker for successful job completion.
Input for the SummarizationTool.
Output from the SummarizationTool.
Smart summarization tool that handles text of any size.
Holds both summary and full text for a summarized artifact field.
Strategy for summarizing text fields that exceed the
LLMSummarizable threshold.Target size for a summary produced from an
LLMSummarizable field.Sealed category for events that are not tied to any specific job
execution.
Exception thrown when a system-level error or bug occurs during job execution.
Console observer that prints a "state of the system" snapshot on a
sampled cadence.
The decision client over a System One endpoint.
Serves decision models on any endpoint that speaks TypeSafe's System One wire: TypeSafe's
own Jev, and every open replica served from a machine the deployment owns (Kev, Nimble,
OpenJev and the rest publish the same request and response shapes).
The wire shape every decision model of this class speaks: TypeSafe's
/v1/systemone
request and response, which the open replicas (Kev, Nimble, OpenJev and the rest)
reproduce verbatim so a client written for one serves them all.What a decoded body carries besides the answers: the usage and identity the endpoint reported, each null when it sent none.
Lenient date parsing for values that arrive as prose or from a model: a fixed sequence of
formats is tried in order and the first that fits wins.
Reference scope value for the
TenantScoped axis.Reference scope axis, carrier side: anything owning a tenant id.
Sealed interface for events representing a job's final state.
Default
ContentBlocks.TextBlock encoder: the block's text, wrapped into the provider's native text block.Resolves the deterministic text form of any artifact.
Baseline
Prompt implementation.Cutting text that has no natural boundary left to cut at.
Baseline
Skill implementation.A text to turn into a vector, keyed by what it belongs to: a file's path for the index,
or a query for a search.
Wraps a plain string into a provider's native text content block of type
B
(Anthropic ContentBlockParam, OpenAI ObjectNode, Bedrock ContentBlock).Interface for reasoning agents that coordinate tool execution.
What a thinker declares about itself, in one value the base constructors require: the
seat's vocabulary - "MEDIUM model, COMPACT answer" - stated where the compiler can see it.
Base class for all thinker inputs.
Carrier object that binds a registered
Prompt to the per-invocation
ThinkerInput.Base class for thinker outputs that preserves artifacts.
Default
ContentBlocks.ThinkingBlock encoder: nothing on the wire.Capability flag on
ModelSpec describing how a model reasons and what that costs the
caller.Response from a Thinker's LLM indicating next action.
ResponseHandler for ThinkingResponse that converts JSON into properly typed objects.
How a file's text was, or was not, obtained.
Dual-bucket token rate limiter (requests per minute + tokens per minute) with adaptive
throttling, as an admission account: it never blocks,
Admission
does.Configuration for a rate limiter.
Status snapshot for a token-bucket rate limiter with dual request/token buckets.
Counts tokens for text, messages, and multimodal content blocks; conversation-level
totals are the conversation's own (
ConversationContext.getTotalTokens).Thrown when our pre-flight token estimate exceeds the model's context window.
Resolves a
TokenCounter for any ModelSpec.Interface for executable tools that can be invoked by Thinkers.
Represents a single tool invocation request from the LLM.
Default
ContentBlocks.ToolDefinitionBlock encoder: a readable text rendering of the tool's
name, description and parameter schema.Annotation to provide a description of what a tool does.
Central registry of
ToolProvider availability and admission rules.Annotation to specify the name of a tool for LLM invocation.
Single abstraction for "a tool the framework can present to an LLM and invoke."
Registry for
ToolProviders, keyed by ToolProvider.name().Interface for tools that need access to the thinker's tool registry and thinker reference.
Default
ContentBlocks.ToolResultBlock encoder: a readable text rendering of the tool result.Reasoning for tool selection and orchestration decisions.
Accumulates
ToolProviders from packages and individual additions.Classification of tool computational type.
Default
ContentBlocks.ToolUseBlock encoder: a readable text rendering of the tool call.Declares the computational weight of a tool on a normalized 0-100 scale.
A conversation rendered as plain text for a reader other than the model that held it:
every message under its role, the text as said, each tool call with its name and
arguments, each tool result against the call it answers, an admitted skill by name and an
attachment by kind.
What a vision-capable model answers when shown a scan or an image: the text it reads,
and whether the pages carried any.
Event published when a job hits a transient server error and will be retried.
A plain transient provider failure: 5xx errors, connection failures, unparseable
responses.
One decision.
Default summarizer that truncates text to a character budget derived from the
LLMSummarizable.size() annotation, preserving word boundaries.The role of a conversation turn as it goes to the provider.
Declares a hierarchical type alias for an artifact class.
Singleton registry mapping
TypeAlias values to classes and vice versa.Exception thrown when an API or service rejects the request due to authentication
or authorization failure (HTTP 401/403).
Base class for exceptions where the tool itself cannot work right now, regardless of
what the LLM sends.
Runtime (unchecked) exception indicating the tool cannot work right now, regardless
of what the LLM sends.
Input for UnitRateCalculatorTool.
Output from UnitRateCalculatorTool.
Multiplies a unit rate by a quantity with an optional cap on quantity.
What an upstream service actually said when a request failed: the HTTP status and the
response detail, carried together so a
RateLimiter can record them.A provider could not serve this attempt and the framework should retry it
transparently - without charging the job's own retry budget.
Signals that an upstream API is throttling us.
Guardrail that validates URLs against private/reserved IP ranges.
Marker interface for tool inputs that contain a URL to fetch.
An event for important notifications that require user attention.
Severity levels for notifications.
Typed client for the USPTO Open Data Portal (ODP) REST API.
Input for fetching USPTO ODP continuity data.
Output containing USPTO ODP continuity data.
Fetches continuity chain (parent/child applications) for a US patent from USPTO ODP.
Input for fetching a single patent from USPTO Open Data Portal.
Output from fetching a single patent from USPTO Open Data Portal.
Fetches detailed US patent data by patent number from USPTO Open Data Portal.
Input for fetching USPTO ODP foreign priority data.
Output containing USPTO ODP foreign priority data.
Fetches foreign priority claims for a US patent from USPTO ODP.
Input for fetching full patent text from USPTO Open Data Portal.
Output from fetching full patent text from USPTO Open Data Portal.
Fetches full patent text (abstract, claims, description) for a US patent.
Input for fetching USPTO ODP legal events.
Output containing USPTO ODP legal events.
Fetches legal status and event history for a US patent from USPTO ODP.
Rate limiter for the USPTO Open Data Portal API.
Input for USPTO Open Data Portal patent search.
Output from USPTO Open Data Portal patent search.
Searches US patents via the USPTO Open Data Portal (ODP) API.
API Thinker for USPTO Open Data Portal queries.
Input for UsptoOdpThinker.
Output from UsptoOdpThinker.
Validation guardrail: judges a producer's candidate final answer while the producer
is still live and able to act on the verdict.
Input for analyzing guardrail violations to determine intent.
Output from analyzing guardrail violations.
The tier for what the code cannot read: an image, or a PDF.
Empty thinker input for message-driven thinkers like ReactiveThinker.
Empty thinker output for message-driven thinkers like ReactiveThinker.
Input parameters for fetching web page content.
Output from WebFetchTool - fetched web page content.
Fetches web page content from a URL.
Artifact representing a web page from search results.
Generic WebSocket message wrapper for outgoing messages.
Types of outgoing WebSocket messages.
Which of OpenAI's two APIs a client speaks.
Terminal event signaling that an entire workflow has completed (successfully or not).
Sealed category for events signaling that an entire workflow has ended.
The wrapped remote tool called like any local one: a typed input in, a typed
OrderStatus out.The picker base for deployments where zero data retention is non-negotiable: every
answer - pick and failover substitute alike - must be Bedrock-hosted (the account
runs retention mode
none) and must not require the LAX data-share posture
(ModelSpec.requiresLax(): the one path on Bedrock where prompts reach the
model provider).