All Classes and Interfaces
Class
Description
Transport-agnostic control-plane integration tests.
See: https://github.com/swagger-api/swagger-inflector
Shared scaffolding for
LlmClient implementations: URL parsing,
base-request construction (method, path, host, scheme, custom headers) and a
shared ObjectMapper.Focused packaging-smoke base for maven-invoker subprojects.
AbstractSchemaSerializer<T extends io.swagger.v3.oas.models.media.Schema>
Transport-agnostic matching/priority/TTL/verify/retrieve semantic tests.
Explicit per-transport decode-smoke integration tests.
Handles Kubernetes MutatingAdmissionWebhook requests (admission.k8s.io/v1).
A curated catalog of adversarial responses — the kind of hostile or
malformed output an agent might receive from a compromised tool or a
jailbroken upstream model.
A named adversarial payload.
Deterministic, read-only analysis of an agent run reconstructed from recorded
LLM requests.
The correlated call graph of an agent run.
A directed edge in the agent-run call graph.
A node in the agent-run call graph.
Structural summary of an agent run (for
explain_agent_run).A single tool call the assistant made.
Result of a
verify_tool_call-style inspection.Outbound handler that adds an
Alt-Svc header to responses served
over the TCP (HTTP/1.1 and HTTP/2) paths when HTTP/3 is enabled.Codec for Anthropic Messages API (version 2024-10-22).
Runtime client for the Anthropic Messages API (
POST /v1/messages,
x-api-key + anthropic-version).This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
See: https://github.com/swagger-api/swagger-inflector
Represents a single channel from an AsyncAPI specification,
with its name, zero or more message payload examples, and
optional publish-time bindings (MQTT qos/retain, Kafka key).
SPI interface for the AsyncAPI control-plane, defined in mockserver-core so that
HttpState can route PUT/GET /mockserver/asyncapi
without depending on the mockserver-async module.Implementation of
AsyncApiControlPlane that lives in the mockserver-async
module and is registered into the core's AsyncApiControlPlaneRegistry
at server startup.Process-wide holder for the optional
AsyncApiControlPlane implementation.Represents a single message definition within an AsyncAPI channel.
Orchestrates publishing of example messages derived from an AsyncAPI spec
to a message broker via a
MessagePublisher.Parses an AsyncAPI 2.x or 3.x document (JSON or YAML) into an
AsyncApiSpec.Validates JSON payloads against an AsyncAPI channel's JSON Schema definition,
reusing
JsonSchemaValidator from mockserver-core (which uses the
com.networknt:json-schema-validator library under the hood).Result of a schema validation.
A parsed AsyncAPI specification containing the channels and their message definitions.
Stateless, deterministic implementation of AWS Signature Version 4 (header-based
Authorization header signing) using only JDK crypto primitives:
MessageDigest (SHA-256) and Mac / SecretKeySpec
(HmacSHA256).BlobStore implementation backed by Azure Blob Storage.Registers the
AzureBlobStore with the core
StateBackendFactory so that blobStoreType=azure
selects it.Codec for Azure OpenAI Service (API version 2024-10-21).
Runtime client for Azure OpenAI.
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
Codec for AWS Bedrock (Anthropic-on-Bedrock) invokeModel API (version bedrock-2023-05-31).
Encoder and decoder for the AWS event-stream binary message format
(
application/vnd.amazon.eventstream).A decoded event-stream message with parsed headers and raw payload.
Runtime client for Amazon Bedrock's Anthropic models
(
POST /model/{modelId}/invoke).Installed after a WebSocket handshake when the HttpWebSocketResponse has matchers.
Callback interface for sending response frames to the client.
See: https://github.com/swagger-api/swagger-inflector
An opaque binary blob with key and optional metadata, stored in a
BlobStore.Binary large-object store abstraction.
SPI for pluggable
BlobStore implementations.See: https://github.com/swagger-api/swagger-inflector
A thread-safe, bounded FIFO store for
RecordedMessage instances.Process-wide registry of known cassettes — fixture files of MockServer expectations
recorded with
record_llm_fixtures or loaded with load_expectations_from_file.Shared deterministic probability-draw logic for chaos injection, used by both
HttpChaosProfile (HTTP fault injection) and LlmChaosProfile
(LLM fault injection).A bounded
ConcurrentLinkedDeque that evicts the oldest element(s) once it reaches
maxSize, invoking an optional callback on each evicted element.A composite
TransparentProxyHandler.OriginalDestinationResolver that tries
an ordered chain of resolution strategies and returns the first non-null result.Resolves the original destination of a transparently intercepted TCP connection
by reading the Linux conntrack table (
/proc/net/nf_conntrack).Serialisable predicate descriptors for LLM conversation matching.
In-process event bus that bridges protocol events to scenario state
transitions.
Describes a cross-protocol scenario correlation: when a protocol event
matching
CrossProtocolScenario.trigger (and optionally CrossProtocolScenario.matchPattern) is
observed, the named scenario is advanced to CrossProtocolScenario.targetState.Identifies the protocol event that triggers a cross-protocol scenario
state transition.
Loads the
CustomJsonUnitMatcherProvider class named by
mockserver.customJsonUnitMatchersClass and exposes the matchers it produces.Plug-in point for registering custom json-unit
matchers so they can be referenced from JSON body expectations using the
${json-unit.matches:name} placeholder.See: https://github.com/swagger-api/swagger-inflector
Resolves the original destination of a transparently intercepted TCP connection
by consulting the
DnsIntentRegistry — a record of hostname-to-IP answers
that MockServer's DNS server has handed out.Thread-safe bounded registry that records the hostname-to-IP answers MockServer's
DNS server has handed out.
See: https://github.com/swagger-api/swagger-inflector
Compares a real forwarded response against a matching stub expectation's
configured response and emits
DriftRecords for any structural
discrepancies (status code, headers, JSON schema).Replays recorded LLM request/response exchanges against a live provider and
reports structural drift in the responses (new/removed fields, type
changes) — closing the loop on stale VCR cassettes.
A recorded request and the body of its recorded response.
A single drift observation: one field/aspect of a forwarded response that
differs structurally from the matching stub expectation's response.
Result of a drift-detection run: one
DriftReport.ExchangeDrift per recorded
exchange that was replayed against the live provider, plus rollup counts.Per-exchange structural-drift outcome.
Thread-safe LRU-capped store of
DriftRecord entries.Categories of structural drift detected when comparing a forwarded (real)
response against a matching stub expectation's configured response.
Inspects the incoming Netty HttpRequest (headers only) and, when a matching expectation
is configured with
respondBeforeBody=true, dispatches the response and closes the
connection before HttpObjectAggregator buffers the request body.Response writer for the early-dispatch path.
Resolves the original destination of a transparently intercepted TCP connection
by reading a pinned BPF hash map populated by an external eBPF program.
See: https://github.com/swagger-api/swagger-inflector
See: https://github.com/swagger-api/swagger-inflector
Serializable entry stored in the expectation
KeyValueStore.Exports a list of
Expectations into third-party tooling formats —
OpenAPI 3 spec, Postman v2.1 collection, or a Bruno collection ZIP.Deprecated.
instead use org.mockserver.client.initialize.PluginExpectationInitializer or org.mockserver.server.initialize.ExpectationInitializer
Represents a single step in an ordered multi-action expectation pipeline.
Pluggable factory for the expectation store (
RequestMatchers).Creates the
RequestMatchers instance backing an HttpState.Controls what happens to an expectation's primary response when a blocking
before-action fails or times out.Represents a single field-level difference between two
HttpRequest objects.Filesystem-backed
BlobStore implementation.Masks sensitive data in recorded expectations before they are written to fixture files.
See: https://github.com/swagger-api/swagger-inflector
BlobStore implementation backed by Google Cloud Storage.Codec for Google Gemini generateContent API (version v1beta-2025).
Runtime client for the Google Gemini
generateContent API.Optional exporter that publishes explicit OpenTelemetry spans via OTLP.
Static emit point for explicit GenAI semantic-convention spans describing the
LLM completions MockServer serves.
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
AST-aware GraphQL body matcher.
Handles the graphql-transport-ws
protocol over an already-established WebSocket connection.
Callback interface for sending text frames to the client, with optional delay support.
Per-stream handler for serving gRPC Server Reflection interactively over the
bidirectional-streaming multiplex pipeline.
Response action for true bidirectional gRPC streaming.
Per-stream router that inspects the first
Http2HeadersFrame to determine whether
this stream is a true bidirectional-streaming gRPC method.Reactive rule for bidirectional gRPC streaming: each inbound client message is matched
against rules in order; the first rule whose
GrpcBidiRule.matchJson matches the inbound
message JSON emits its GrpcBidiRule.responses as DATA frames.Transport-neutral helper that matches an inbound gRPC bidi message (as JSON)
against a
GrpcBidiRule's matchJson pattern.Per-stream handler for true bidirectional gRPC streaming.
Evaluates a
GrpcChaosProfile against the current request context
(match count, quota state) and decides whether to inject a gRPC fault.The outcome of a gRPC chaos fault decision.
Declarative gRPC fault/chaos injection profile for probabilistically returning
gRPC error statuses (UNAVAILABLE, DEADLINE_EXCEEDED, RESOURCE_EXHAUSTED,
INTERNAL, etc.) on matched gRPC method calls, with latency, quota, and
count-window controls.
Process-wide registry of gRPC chaos profiles, keyed by gRPC service name.
Handles grpc.health.v1.Health/Check requests without a proto descriptor.
Adapter that bridges gRPC request/response framing for the HTTP/3 path.
Holds the parts of a gRPC response for HTTP/3 framing:
the gRPC-framed body bytes, the grpc-status value, and
an optional grpc-message.
Per-stream child initializer used with
Http2MultiplexHandler
when the gRPC bidi-streaming multiplex pipeline is enabled.Handles gRPC Server Reflection requests without a generated proto stub.
Transport-neutral helper that encodes a single gRPC stream message (JSON) into
a gRPC length-prefixed frame, ready to be written as an HTTP/2 DATA frame or an
HTTP/3 DATA frame.
Transport-neutral seam for writing a server-streaming gRPC response
(
GrpcStreamResponse).Translates between gRPC-Web framing and standard gRPC framing.
Imports expectations from HAR (HTTP Archive) format JSON files.
Reads the first
Http2Settings objectHTTP/3 CONNECT-UDP (MASQUE, RFC 9298) relay handler.
Drives true bidirectional gRPC streaming over a single QUIC bidirectional stream
(HTTP/3).
A
ResponseWriter that writes gRPC responses over HTTP/3 with correct
gRPC wire framing: initial HEADERS (:status=200,
content-type=application/grpc), DATA (gRPC length-prefixed message),
and trailing HEADERS (grpc-status, grpc-message).HTTP/3 request stream handler that bridges incoming QUIC requests into
MockServer's standard request-processing pipeline (expectation matching,
actions, recording, proxy forwarding).
Converts between HTTP/3 frames and MockServer's
HttpRequest/HttpResponse model.Parsed HTTP/3 pseudo-headers and regular headers.
A
ResponseWriter that serialises the MockServer HttpResponse
as HTTP/3 frames and writes them to a QUIC stream channel.HTTP/3 (QUIC) server for MockServer, integrated with the full request pipeline.
Declarative HTTP fault/chaos injection for mocked and forwarded responses:
probabilistic connection-drop injection, error status injection (e.g. 500,
503, 429 with an optional
Retry-After header), latency injection, and
response-body corruption (truncateBodyAtFraction keeps only a leading
fraction of the body bytes; malformedBody appends a broken-JSON
fragment) for testing client-side body-parsing resilience, and a slow
("dribbled") response (slowResponseChunkSize + slowResponseChunkDelay
send the body in small chunks with a delay between each) for testing read
timeouts on a trickling response.Forward a request to an upstream host; if upstream returns a configured
status code (default 500-599) or times out, return a fallback mock response.
Handles forward-with-fallback actions: forwards the request to the upstream
host defined by the
HttpForward; if the upstream returns a status code
matching the fallback criteria (default 500-599) or the request times out /
fails to connect, the configured fallback HttpResponse is returned
instead.Process-wide, stateful request quota for HTTP chaos — a fixed-window rate
limiter, the HTTP counterpart of
LlmQuotaRegistry.Matches HTTP request properties against expectation criteria.
Incremental gRPC length-prefixed frame decoder that accumulates across multiple
feed() calls, retaining any trailing partial bytes for the next call.Validates that the destination host of a forward or proxy action is not a
loopback, link-local, RFC 1918 private, or cloud metadata address.
BlobStore backed by an Infinispan LOCAL cache.Infinispan cache listener that bridges Infinispan cache events to the
MockServer
InvalidationListener SPI.KeyValueStore backed by an Infinispan Cache.Infinispan-backed
StateBackend supporting both LOCAL (non-clustered)
and CLUSTERED (JGroups transport, REPL_SYNC) modes.Registers the
InfinispanStateBackend with the core
StateBackendFactory so that stateBackend=infinispan
selects it.In-memory
BlobStore implementation backed by a
ConcurrentHashMap.In-memory
KeyValueStore for expectations, backed by a
CircularPriorityQueue that provides identical ordering and
insertion-order eviction to today's RequestMatchers internals.General-purpose in-memory
KeyValueStore backed by a
ConcurrentHashMap.Default in-memory
StateBackend that wraps today's exact data
structures for zero behaviour change.See: https://github.com/swagger-api/swagger-inflector
Listener for state-change events on a
KeyValueStore.Describes where to extract the isolation key from an inbound HTTP request
for per-session conversation state isolation.
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
String escaping for the small set of code paths that hand-assemble JSON inside
provider codecs (streaming chunks, where building a full Jackson tree per token
is unwarranted overhead).
See: https://github.com/swagger-api/swagger-inflector
See https://github.com/json-path/JsonPath
See http://json-schema.org/
Exposes JVM runtime metrics (heap / non-heap memory, threads, GC) as
Prometheus gauges so the dashboard Metrics view and Grafana can chart
MockServer's process health.
A
MessagePublisher that delegates to a Kafka KafkaProducer.A
MessageSubscriber that uses a Kafka KafkaConsumer to subscribe
to topics and record received messages.Immutable carrier for Kafka security configuration (SASL and/or SSL).
Utility for applying
KafkaSecurity settings to Kafka client
Properties.KeysAndValuesModifier<T extends KeysAndValues<I,T>,K extends KeysAndValuesModifier<T,K,I>,I extends KeyAndValue>
KeysAndValuesModifierDTO<T extends KeysAndValues<I,T>,K extends KeysAndValuesModifier<T,K,I>,I extends KeyAndValue,D extends DTO<K>>
KeysToMultiValuesModifier<T extends KeysToMultiValues<I,T>,K extends KeysToMultiValuesModifier<T,K,I>,I extends KeyToMultiValue>
KeysToMultiValuesModifierDTO<T extends KeysToMultiValues<I,T>,K extends KeysToMultiValuesModifier<T,K,I>,I extends KeyToMultiValue,D extends DTO<K>>
Versioned key-value store abstraction for shared MockServer state.
A key-value entry with version metadata.
Convenience re-exports of LLM model-class static factories so that
users can write a single import:
Declares a real LLM backend that MockServer can call as a client
(the opposite direction to the mock codecs, which build outbound mock
responses).
Resolves which
LlmBackend a runtime-LLM feature should use, across the
three config layers (simplest first):
Provider env conventions — auto-detect from OPENAI_API_KEY
/ ANTHROPIC_API_KEY / GEMINI_API_KEY / OLLAMA_HOST
(the same vars each provider SDK reads).
MockServer properties — a single default backend via
mockserver.llmProvider / llmApiKey / llmModel /
llmBaseUrl.
Named backends JSON — mockserver.llmBackendsConfig points
at a JSON array of backends, selectable by name.
The default backend prefers layer 2 (explicit properties) over layer 1 (env);
named backends come from layer 3.Declarative fault/chaos injection for an
HttpLlmResponse, for testing
agent resilience: probabilistic provider errors (e.g. 429/529 with a
Retry-After header), mid-stream truncation, and malformed SSE chunks.Per-provider knowledge for calling a real LLM as a client.
Orchestrates an outbound completion against a real LLM backend: looks up the
per-provider
LlmClient, builds the request, sends it via the
LlmTransport, and parses the response into a Completion.Builder for multi-turn LLM conversation mocks with optional per-session isolation.
Matches inbound HTTP requests against LLM conversation predicates.
Fluent builder for creating LLM mock expectations.
Estimated cost calculation for LLM API usage.
Input/output list price in USD per million tokens.
Process-wide, stateful request quota for LLM responses — a fixed-window rate
limiter.
Utility for encoding and decoding LLM conversation isolation metadata
in scenario names.
Transport seam for outbound runtime-LLM calls.
See: https://github.com/swagger-api/swagger-inflector
Base interface for all matchers in MockServer.
Shared daemon-thread executor used by request matchers (regex, XPath) to
bound the runtime of pathological user-supplied expressions.
Deterministic conformance / contract tester for a target MCP (Model Context Protocol)
server reachable over Streamable HTTP.
Outcome of a single named conformance check.
Result of a single JSON-RPC exchange.
One JSON-RPC exchange against the target server.
Full conformance report.
Transport-neutral MCP (Model Context Protocol) JSON-RPC request processor.
Result of processing an MCP request.
Netty channel handler that intercepts MCP (Model Context Protocol) requests
on the TCP (HTTP/1.1 and HTTP/2) path.
Generates Model Context Protocol tool definitions
from the current mock expectations, so an AI agent can discover and (via an MCP client) call the
mocked endpoints as tools.
Generates example JSON payloads for each channel in an
AsyncApiSpec.Publishes a message payload to a named channel (topic).
Subscribes to a message broker channel and records received messages for
later retrieval/verification — the consumer counterpart of
MessagePublisher.Produces short, actionable remediation hints from match-difference fields.
High-level operating mode for MockServer, packaging the common
record / replay / pass-through workflows into a single switch (set via
PUT /mockserver/mode).An enriched Testcontainers module for MockServer.
Wires the
IP_TRANSPARENT socket option on the server bootstrap when
TPROXY mode is enabled.Configure MockServer when used in conjunction with
MockServerExtensionA
MessagePublisher that delegates to an MQTT MqttClient.A
MessageSubscriber that uses an MQTT MqttClient to subscribe
to topics and record received messages.Immutable carrier for MQTT security configuration (username/password and/or SSL).
Utility for building
MqttConnectOptions from MqttSecurity
configuration.See: https://github.com/samskivert/jmustache or http://mustache.github.io/mustache.5.html for syntax
LlmTransport backed by the server's NettyHttpClient.Transport-selection utility that picks the highest-performance Netty transport
available on the current platform: Linux epoll when the native library is
present, NIO everywhere else.
Opt-in normalisation applied to LLM prompt text before
ConversationPredicates substring/regex comparisons are evaluated.See: https://github.com/swagger-api/swagger-inflector
Configuration for the OIDC mock identity provider.
Generates MockServer
Expectations that serve a complete set of OIDC/OAuth2
identity provider endpoints: discovery, JWKS, token, userinfo, introspection, and
revocation.Codec for Ollama
/api/chat endpoint (version ollama-2025).Runtime client for a local Ollama server.
Codec for OpenAI Chat Completions API (version 2025-01).
Runtime client for the OpenAI Chat Completions API
(
POST /v1/chat/completions, Authorization: Bearer).Codec for OpenAI Responses API (version 2025-03).
Runtime client for the OpenAI Responses API (
POST /v1/responses,
Authorization: Bearer).Given an OpenAPI spec, builds representative example requests for each operation,
sends them via an injected HTTP-send function, and validates each response against the spec.
Structured result for a single contract test operation.
Given an OpenAPI spec, generates deliberately malformed and boundary-case requests
for each operation, sends them via an injected HTTP-send function, and classifies
each outcome as HANDLED (4xx) or UNEXPECTED (5xx, 2xx, or connection error).
Resolves OpenAPI runtime expressions (RFC 3.4.16) in callback after-action requests
using values from the triggering HTTP request.
Serves the embedded OpenAPI specification at GET /mockserver/openapi.yaml
Pure-function helper for incremental OpenAPI sync: given the set of existing
expectation ids, the set of newly-generated ids, and the namespace prefixes
that the new generation covers, determines which existing ids should be pruned.
Validates a list of request/response pairs against an OpenAPI specification.
Structured result for a single request/response pair validation.
Resolves per-signal OTLP HTTP endpoints from the single configured base URL
(see
mockserver.otelEndpoint).Optional exporter that publishes MockServer's explicitly-defined
metrics (the same
Metrics.Name gauges exposed for Prometheus) via
OpenTelemetry OTLP.Exports MockServer response expectations as a
Pact v3 consumer contract (JSON), so traffic mocked or
recorded in MockServer can be published to a Pact Broker / PactFlow and used for
consumer-driven contract testing.
Verifies that MockServer's currently-active expectations satisfy each interaction
in a Pact v3 consumer contract.
The result of verifying a single Pact interaction.
The overall result of verifying a Pact contract.
Sliding window p50/p95 tracker for response times per expectation ID.
If the MockServer is started using the Maven Plugin a initializationClass property can be specified to initialize expectations, when the MockServer starts.
Imports expectations from Postman Collection v2.x (v2.0 and v2.1) JSON files.
Deterministic normalisation of LLM prompt text prior to conversation-predicate
matching.
Inbound handler that detects and parses PROXY protocol v1 (text format) and v2 (binary
format) headers prepended to TCP connections by upstream load balancers (e.g., AWS GWLB,
HAProxy, nginx with
proxy_protocol on).Immutable carrier for per-message publish-time options extracted from AsyncAPI bindings.
An immutable record of a message received from a broker subscription.
Static emit point for request-level OpenTelemetry spans describing HTTP
request/response handling by MockServer.
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
BlobStore implementation backed by AWS S3 (or any S3-compatible
store such as MinIO).Controls how GraphQL body matching compares the selection set (fields).
Optional LLM-powered extension to
DriftAnalyzer.Process-wide opt-in gate for semantic prompt matching.
Fuzzy, exploratory semantic match of a prompt against an expected
intent, using a runtime LLM as a yes/no judge (via the Phase-2
LlmCompletionService).Severity classification assigned by LLM-powered semantic drift analysis.
Process-wide registry of service-scoped HTTP chaos profiles, keyed by
upstream host.
Configuration for the MockServer sidecar injection.
Builds a RFC 6902 JSON Patch that injects the MockServer sidecar container
and iptables-REDIRECT init container into a Kubernetes Pod spec.
This exception indicates there was an error while trying to communicate over a socket
This exception indicates there was an error while trying to communicate over a socket
This class is expected to be used from within a
ReplayingDecoder, or with enough bytes available.Reads the original destination of an intercepted TCP connection on Linux.
Resolves the original destination of a transparently intercepted TCP connection
by calling
getsockopt(fd, SOL_IP, SO_ORIGINAL_DST, ...) via JNA on Linux.This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
This configuration contains top level beans and any configuration required by filters (as WebMvcConfiguration only loaded within Dispatcher Servlet)
Converts a recorded
Expectation (from a FORWARDED_REQUEST log entry) into an
SSE-aware replay expectation when the forwarded response was a streaming response.Parses raw
text/event-stream bytes into a list of SseEvent objects
suitable for constructing an HttpSseResponse.Pluggable backend for all shared MockServer state.
Pluggable factory for the
StateBackend.Creates a
StateBackend for an HttpState instance.Closes the channel when an
IdleStateEvent fires, which indicates that no
streaming chunk has been received within the configured idle timeout period.An
HttpObjectAggregator that can recognise streaming responses — specifically
Server-Sent Events (Content-Type: text/event-stream) — so that, when
MockServer is acting as a proxy, such responses can be relayed to the client
incrementally instead of being fully buffered in memory before being forwarded.A chunk sink for streaming response bodies.
The wire format used by a provider for streaming responses.
Applies streaming physics (timing delays) to a list of SSE events.
Consumes unaggregated
HttpObjects on the NettyHttpClient channel when
a streaming response is detected.See: https://github.com/swagger-api/swagger-inflector
Compares two JSON documents by shape — the set of field paths and
their value types — ignoring values.
The structural delta between a recorded ("baseline") and a live document.
Builds the prompt sent to a runtime LLM backend to generate a realistic
MockServer expectation from an unmatched request.
Result returned by the AI stub generation endpoint.
Netty
ChannelDuplexHandler that injects raw TCP-layer faults
before HTTP decoding, based on the TcpChaosProfile
registered in TcpChaosRegistry for the connection's remote host.Declarative TCP-layer fault/chaos injection profile, applied at the raw byte
level before HTTP decoding.
Process-wide registry of TCP-layer chaos profiles, keyed by host.
Represents a timed auto-transition for a scenario state machine.
Records the wall-clock time when the first inbound byte (response head) arrives
from the upstream server.
Resolves the original destination of a transparently intercepted TCP connection
using the TPROXY (IP_TRANSPARENT) mechanism.
Shared Netty channel
AttributeKey constants for W3C trace context.Netty handler that extracts W3C
traceparent / tracestate
headers from inbound HttpRequest objects and stores the parsed
W3CTraceContext as a channel attribute.Compares two
HttpRequest objects field-by-field and returns a list of FieldDiff
entries describing the differences.A Netty channel handler that resolves the original destination for transparently
intercepted connections and stores it as the
HttpActionHandler.REMOTE_SOCKET
channel attribute.Strategy interface for resolving the original destination.
Utility for transparent HTTP proxy mode — provides Host-header parsing helpers
and an
TransparentProxyInitializer.isEnabled() configuration check.Sub-builder for configuring a single turn within an LLM conversation mock.
A value paired with an optimistic-concurrency version number.
Wrapper that pairs a value with an explicit version number for storage in
an Infinispan cache.
Parsed W3C traceparent header.
Body matcher that delegates matching to a WASM module stored in the
WasmStore.DTO for serialising/deserialising
WasmBody to/from JSON.Body matcher that delegates matching to a WASM module loaded in the
WasmStore.Thin wrapper around a compiled chicory WASM instance.
Thread-safe in-memory store for WASM modules, keyed by module name.
Kubernetes MutatingAdmissionWebhook HTTPS server.
Generates MockServer
Expectations from a WSDL 1.1 document so SOAP web services
can be mocked without hand-authoring stubs.See: https://github.com/swagger-api/swagger-inflector
See http://xml-schema.org/