Enum RouteAction 

pub enum RouteAction {
    Proxy {
        rewrite: Option<PathRewrite>,
    },
    Redirect {
        scheme: Option<String>,
        host: Option<String>,
        path: Option<String>,
        status: u16,
    },
    Respond {
        status: u16,
        body: Option<String>,
        headers: BTreeMap<String, String>,
    },
    Mock {
        mock: MockAction,
    },
    Ai {
        endpoint: AiEndpoint,
        dialect: AiIngressDialect,
    },
    NanoService {
        nano: NanoServiceAction,
    },
}

What the gateway does when a route matches.

Variants

Proxy

Forward to the route’s service (its upstream).

rewrite (at most ONE per action in v1) is applied to the inbound path before the request is sent upstream; the query string is always preserved verbatim.

Fields

rewrite: Option<PathRewrite>

Redirect

Fields

scheme: Option<String>

host: Option<String>

path: Option<String>

status: u16

Respond

Fields

status: u16

body: Option<String>

headers: BTreeMap<String, String>

Extra response headers (name -> value), emitted verbatim.

Mock

Serve a canned response without contacting any upstream (DW-047 mock mode). The route’s service is still required by the schema (the frozen vocabulary), but a mock route never dials it — the whole point is serving without a backend. Pair with request_validation to mock a write endpoint that still rejects malformed bodies. See MockAction.

Fields

mock: MockAction

Ai

AI provider translation (DW-075): the request body is parsed as an OpenAI chat-completions request, its model resolved through the gateway’s ai: block to a provider, translated to that provider’s wire format (OpenAI/Anthropic/Gemini), sent through the provider’s upstream, and the response translated back to the OpenAI shape. The route’s service is still required by the schema but never dialed. Requires an ai: block (validation rejects the pairing otherwise). stream: true requests are served via zero-buffer SSE pass-through (DW-077).

AI-02: the endpoint field selects which AI endpoint the route serves. The default is chat (the existing behavior). Other endpoints (embeddings, images, audio, moderation) are proxied as a passthrough: the request body is forwarded to the provider’s upstream as-is (no adapter translation), and the response is returned as-is. Model governance (allowlist check) still applies using the model field from the request body.

Fields

endpoint: AiEndpoint

dialect: AiIngressDialect

AI-05 (#195): The client-facing request dialect. Defaults to openai (the historical behavior). When set to anthropic or gemini, the gateway parses the incoming request using that dialect’s native format and translates to the canonical ChatRequest. When set to passthrough, the request body is forwarded to the provider as-is (no translation, still metered/governed).

NanoService

WASM route handler (nano-service, DW-106): instead of proxying to an upstream, the route action runs a WASM module that generates the response directly. The module implements a simple request->response handler ABI over the existing wasmtime runtime (compiled into every build; no cargo feature). The route’s service is still required by the schema (the frozen vocabulary) but never dialed – the whole point is serving without a backend. See NanoServiceAction.

Fields

nano: NanoServiceAction

Trait Implementations

impl Clone for RouteAction

fn clone(&self) -> RouteAction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RouteAction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RouteAction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for RouteAction

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for RouteAction

fn eq(&self, other: &RouteAction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RouteAction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RouteAction