Struct Schema 

pub struct Schema { /* private fields */ }

JSON Schema body for an LLM tool’s parameters (type / properties / required / …).

Implementations

impl Schema

pub fn object() -> Self

Object schema ({"type":"object",…}). Default for tool parameters.

Examples found in repository

examples/full.rs (line 12)

fn main() -> Result<(), phi::Error> {
    let mut m = phi::Extension::new("full", "0.1.0");

    m.register_tool(
        phi::Tool::new(
            "echo",
            "Echo the input back",
            phi::Schema::object()
                .property("text", phi::Schema::string())
                .required(["text"]),
            |args| {
                let text = String::from_utf8_lossy(args);
                Ok(phi::ToolResult {
                    content: format!("echo: {text}"),
                    ..Default::default()
                })
            },
        )
        .detail_from_args(|args| String::from_utf8_lossy(args).into_owned()),
    );

    m.register_tool(
        phi::Tool::new_async(
            "async-echo",
            "Echo the input back (async handler)",
            phi::Schema::object()
                .property("text", phi::Schema::string())
                .required(["text"]),
            |args| async move {
                // Yield once: proves the SDK's runtime drives the future
                // rather than just polling a ready block.
                tokio::task::yield_now().await;
                let text = String::from_utf8_lossy(&args);
                Ok(phi::ToolResult {
                    content: format!("async echo: {text}"),
                    ..Default::default()
                })
            },
        )
        .timeout_sec(10),
    );

    m.register_command(
        "ask",
        phi::Command::new("Ask a yes/no question", |_args, ctx| {
            let reply = ctx.confirm("Confirm?", "Proceed with /tmp/x?");
            if reply.ok {
                ctx.notify("info", "Confirmed!");
            } else {
                ctx.notify("warning", "Declined.");
            }
            ctx.submit("follow-up from ask");
            Ok(())
        }),
    );

    m.run()
}

pub fn string() -> Self

Examples found in repository

examples/full.rs (line 13)

fn main() -> Result<(), phi::Error> {
    let mut m = phi::Extension::new("full", "0.1.0");

    m.register_tool(
        phi::Tool::new(
            "echo",
            "Echo the input back",
            phi::Schema::object()
                .property("text", phi::Schema::string())
                .required(["text"]),
            |args| {
                let text = String::from_utf8_lossy(args);
                Ok(phi::ToolResult {
                    content: format!("echo: {text}"),
                    ..Default::default()
                })
            },
        )
        .detail_from_args(|args| String::from_utf8_lossy(args).into_owned()),
    );

    m.register_tool(
        phi::Tool::new_async(
            "async-echo",
            "Echo the input back (async handler)",
            phi::Schema::object()
                .property("text", phi::Schema::string())
                .required(["text"]),
            |args| async move {
                // Yield once: proves the SDK's runtime drives the future
                // rather than just polling a ready block.
                tokio::task::yield_now().await;
                let text = String::from_utf8_lossy(&args);
                Ok(phi::ToolResult {
                    content: format!("async echo: {text}"),
                    ..Default::default()
                })
            },
        )
        .timeout_sec(10),
    );

    m.register_command(
        "ask",
        phi::Command::new("Ask a yes/no question", |_args, ctx| {
            let reply = ctx.confirm("Confirm?", "Proceed with /tmp/x?");
            if reply.ok {
                ctx.notify("info", "Confirmed!");
            } else {
                ctx.notify("warning", "Declined.");
            }
            ctx.submit("follow-up from ask");
            Ok(())
        }),
    );

    m.run()
}

pub fn number() -> Self

pub fn integer() -> Self

pub fn boolean() -> Self

pub fn array(items: Schema) -> Self

Array schema. items must be a builder schema (not Schema::raw).

pub fn raw(json: impl Into<Vec<u8>>) -> Self

Opaque JSON Schema bytes (the previous Vec<u8> API).

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

pub fn property(self, name: impl Into<String>, schema: Schema) -> Self

Add an object property. No-op on non-object / raw schemas.

Examples found in repository

examples/full.rs (line 13)

fn main() -> Result<(), phi::Error> {
    let mut m = phi::Extension::new("full", "0.1.0");

    m.register_tool(
        phi::Tool::new(
            "echo",
            "Echo the input back",
            phi::Schema::object()
                .property("text", phi::Schema::string())
                .required(["text"]),
            |args| {
                let text = String::from_utf8_lossy(args);
                Ok(phi::ToolResult {
                    content: format!("echo: {text}"),
                    ..Default::default()
                })
            },
        )
        .detail_from_args(|args| String::from_utf8_lossy(args).into_owned()),
    );

    m.register_tool(
        phi::Tool::new_async(
            "async-echo",
            "Echo the input back (async handler)",
            phi::Schema::object()
                .property("text", phi::Schema::string())
                .required(["text"]),
            |args| async move {
                // Yield once: proves the SDK's runtime drives the future
                // rather than just polling a ready block.
                tokio::task::yield_now().await;
                let text = String::from_utf8_lossy(&args);
                Ok(phi::ToolResult {
                    content: format!("async echo: {text}"),
                    ..Default::default()
                })
            },
        )
        .timeout_sec(10),
    );

    m.register_command(
        "ask",
        phi::Command::new("Ask a yes/no question", |_args, ctx| {
            let reply = ctx.confirm("Confirm?", "Proceed with /tmp/x?");
            if reply.ok {
                ctx.notify("info", "Confirmed!");
            } else {
                ctx.notify("warning", "Declined.");
            }
            ctx.submit("follow-up from ask");
            Ok(())
        }),
    );

    m.run()
}

pub fn required<I, S>(self, names: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Mark object property names as required.

Examples found in repository

examples/full.rs (line 14)

fn main() -> Result<(), phi::Error> {
    let mut m = phi::Extension::new("full", "0.1.0");

    m.register_tool(
        phi::Tool::new(
            "echo",
            "Echo the input back",
            phi::Schema::object()
                .property("text", phi::Schema::string())
                .required(["text"]),
            |args| {
                let text = String::from_utf8_lossy(args);
                Ok(phi::ToolResult {
                    content: format!("echo: {text}"),
                    ..Default::default()
                })
            },
        )
        .detail_from_args(|args| String::from_utf8_lossy(args).into_owned()),
    );

    m.register_tool(
        phi::Tool::new_async(
            "async-echo",
            "Echo the input back (async handler)",
            phi::Schema::object()
                .property("text", phi::Schema::string())
                .required(["text"]),
            |args| async move {
                // Yield once: proves the SDK's runtime drives the future
                // rather than just polling a ready block.
                tokio::task::yield_now().await;
                let text = String::from_utf8_lossy(&args);
                Ok(phi::ToolResult {
                    content: format!("async echo: {text}"),
                    ..Default::default()
                })
            },
        )
        .timeout_sec(10),
    );

    m.register_command(
        "ask",
        phi::Command::new("Ask a yes/no question", |_args, ctx| {
            let reply = ctx.confirm("Confirm?", "Proceed with /tmp/x?");
            if reply.ok {
                ctx.notify("info", "Confirmed!");
            } else {
                ctx.notify("warning", "Declined.");
            }
            ctx.submit("follow-up from ask");
            Ok(())
        }),
    );

    m.run()
}

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

pub fn enum_values<I, S>(self, values: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Restrict a string schema to an enum (Codex-style compact enums).

pub fn to_json_bytes(&self) -> Vec<u8>

Serialize to JSON Schema bytes for RegisterTool.

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Schema

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

Formats the value using the given formatter.

impl From<&[u8]> for Schema

fn from(json: &[u8]) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for Schema

fn from(json: Vec<u8>) -> Self

Converts to this type from the input type.