Enum ResponseFormat 

pub enum ResponseFormat {
    JsonSchema {
        schema: Value,
        strict: bool,
        name: Option<String>,
    },
    JsonObject,
}

Constraint on the model’s response shape. Distinct from tools — tools are a side-channel for action invocation; response_format constrains the primary text output to be parseable JSON, optionally against a caller-supplied schema.

Provider mapping (handled in protocol.rs):

• OpenAI / Azure / OpenAI-compatible: response_format: {type: "json_schema", json_schema: {schema, strict, name}} (or {type: "json_object"} for the looser variant). Strict mode rejects any deviation from the schema.
• Google (Gemini): response_mime_type: "application/json" plus optional response_schema.
• Anthropic: no native field as of early 2026 — the schema is logged at warn level and dropped. Callers needing schema-validated output on Claude should fall back to the tools + tool_choice="required" coercion idiom (which is what worked before this field landed).

JsonObject is the looser variant — tells the provider “emit valid JSON, no schema check required”. Use when the schema is too dynamic to spell out but the parse contract still matters.

Variants

JsonSchema

JSON output validated against the provided schema. strict: true asks the provider to reject any deviation; false makes the schema a best-effort hint. name is OpenAI-specific (the json_schema.name field, max 64 chars, alphanumerics + -_); other providers ignore it.

Fields

schema: Value

strict: bool

name: Option<String>

JsonObject

Plain JSON-mode output — the provider emits valid JSON without schema enforcement.

Trait Implementations

impl Clone for ResponseFormat

fn clone(&self) -> ResponseFormat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ResponseFormat

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ResponseFormat

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ResponseFormat

fn eq(&self, other: &ResponseFormat) -> 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 ResponseFormat

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 ResponseFormat