Struct Parameters 

pub struct Parameters(/* private fields */);

JSON schema parameters with metadata stripped

Implementations

impl Parameters

pub fn from_object(obj: Map<String, Value>) -> Self

Create Parameters from a Json object (map)

Examples found in repository

examples/mcp.rs (line 39)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to a server running as a child process
    let service = ()
        .serve(TokioChildProcess::new(Command::new("npx").configure(
            |cmd| {
                cmd.args(&["-y", "@modelcontextprotocol/server-filesystem", "."]);
            },
        ))?)
        .await?;
    println!("Connected to MCP server");

    // List available tools and convert to tool definitions
    let tools = service.list_tools(Default::default()).await?.tools;
    let names = tools.iter().map(|t| t.name.to_string()).collect::<Vec<_>>();
    println!("Available tools: {names:#?}");
    let mcp_tool_defs = tools
        .iter()
        .map(|t| ToolDefinition {
            tool_type: "function".into(),
            function: ToolFunction {
                name: t.name.to_string(),
                description: t.description.as_deref().unwrap_or_default().to_string(),
                parameters: Parameters::from_object(t.input_schema.as_ref().clone()),
            },
        })
        .collect();

    let mcp_tool_executor = {
        let peer = service.clone();
        move |name: String, args: String| {
            let peer = peer.clone();
            async move {
                peer.call_tool(CallToolRequestParams {
                    meta: None,
                    name: name.into(),
                    arguments: serde_json::from_str(&args).unwrap(),
                    task: None,
                })
                .await
                .unwrap()
                .content[0]
                    .as_text()
                    .unwrap()
                    .text
                    .clone()
            }
        }
    };

    let api_key = std::env::var("LLM_API_KEY").expect("LLM_API_KEY not set");

    let llm = OpenAIProvider::new()
        .api_key(api_key)
        .base_url("https://openrouter.ai/api/v1")
        .model("google/gemini-3-flash-preview");

    let agent = Agent::new(llm)
        .system("You are a helpful assistant")
        .external(mcp_tool_defs, mcp_tool_executor);

    run_cli_loop(agent).await;

    // Gracefully close the connection
    service.cancel().await?;
    Ok(())
}

pub fn from_schema(schema: Schema) -> Self

Create Parameters from a JsonSchema

pub fn from_type<T: JsonSchema>() -> Self

Create Parameters from a type implementing JsonSchema

Trait Implementations

impl Clone for Parameters

fn clone(&self) -> Parameters

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Parameters

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

Formats the value using the given formatter.

impl Serialize for Parameters

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

where __S: Serializer,

Serialize this value into the given Serde serializer.