Struct ObjectSchema 

pub struct ObjectSchema {
    pub name: String,
    pub description: Option<String>,
    pub properties: Vec<Schema>,
    pub required: Vec<String>,
    pub allow_additional_properties: bool,
    pub json_schema: Option<Value>,
}

A schema for a JSON object made up of named fields – this is what Tool::parameters returns, and it’s how you describe a whole tool’s argument list.

Each entry in properties carries its own name (every Schema variant has one), so properties is a plain list rather than a name-keyed map – you never have to keep a field’s key and its schema’s name in sync separately.

Example

use llmprism::schema::{NumberSchema, ObjectSchema, Schema, StringSchema};

let parameters = ObjectSchema::new("parameters")
    .with_property(Schema::String(StringSchema::new("city")), true) // required
    .with_property(Schema::Number(NumberSchema::new("days_ahead")), false); // optional

Fields

name: String

The field/parameter name this schema describes (for a tool’s top-level parameter list, this is usually just a placeholder like "parameters", since it isn’t itself nested inside another object).

description: Option<String>

A plain-language explanation of what this object represents, shown to the model so it can fill it in correctly.

properties: Vec<Schema>

The object’s fields. Each entry’s own name() is its key.

required: Vec<String>

The names of fields the model must always provide (as opposed to fields it may omit).

allow_additional_properties: bool

Whether the model is allowed to include fields beyond the ones listed in properties. Defaults to false – most providers expect a closed set of fields.

json_schema: Option<Value>

An already-formed JSON Schema document to send exactly as-is, bypassing properties/required/allow_additional_properties entirely. None (the default) builds the schema from those fields normally, the same way it always has.

This is RawSchema’s escape hatch, made available here too: RawSchema works anywhere a general Schema fits, but Tool::parameters and StructuredRequest::schema are both typed as ObjectSchema specifically, so Schema::Raw can’t be plugged in at either point. Set via from_raw_json_schema instead of directly, for a schema you already have in hand – from an MCP server’s tool listing, or a user-supplied schema file – rather than one you’re building field by field.

Implementations

impl ObjectSchema

pub fn new(name: impl Into<String>) -> Self

Creates an empty object schema named name, with no fields yet. Add fields with with_property.

pub fn from_raw_json_schema(name: impl Into<String>, json_schema: Value) -> Self

Creates an object schema named name that sends json_schema exactly as-is, instead of being built from with_property calls. See json_schema for when this is worth reaching for.

One caveat worth knowing if you’re targeting OpenAI: its structured-output request sets "strict": true, which requires additionalProperties: false and every property listed in required, recursively, throughout the whole schema. A raw schema that doesn’t already satisfy that shape will be rejected by OpenAI at request time – this crate can’t fix that up for you, since it sends json_schema unmodified by design.

pub fn with_description(self, description: impl Into<String>) -> Self

Attaches a plain-language description, shown to the model.

pub fn with_property(self, schema: Schema, required: bool) -> Self

Adds one field to the object. schema’s own name becomes the field’s key. Set required to true if the model must always provide this field.

pub fn with_additional_properties(self, allow: bool) -> Self

Sets whether the model may include fields beyond the ones you’ve listed.

Trait Implementations

impl Clone for ObjectSchema

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ObjectSchema

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ObjectSchema

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ObjectSchema

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

where __S: Serializer,

Serialize this value into the given Serde serializer.