Struct Command 

pub struct Command {
    pub description: String,
    pub needs_args: bool,
    pub handler: Box<dyn FnMut(&str, &mut Context<'_>) -> Result<(), String>>,
}

A slash command. The handler receives the raw argument string and a Context for host interaction (notify / confirm / submit / …).

Fields

description: String

needs_args: bool

Leave /name in the composer on picker accept / bare submit.

handler: Box<dyn FnMut(&str, &mut Context<'_>) -> Result<(), String>>

Implementations

impl Command

pub fn new( description: impl Into<String>, handler: impl FnMut(&str, &mut Context<'_>) -> Result<(), String> + 'static, ) -> Self

Examples found in repository

examples/full.rs (lines 28-37)

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_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()
}

examples/hello.rs (lines 10-15)

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

    m.register_command(
        "hello",
        phi::Command::new("Say hi", |_args, ctx| {
            ctx.notify("info", "Hello!");
            // ctx.submit("follow-up"); // after /hello returns
            // ctx.send_user_message("…"); // enqueue a turn anytime
            Ok(())
        }),
    );

    m.on_user_input(|_ev| {
        // return Some(phi::UserInputResult { handled: true, ..Default::default() }) to swallow
        // return Some(phi::UserInputResult { text: Some("rewritten".into()), ..Default::default() }) to transform
        None
    });

    m.on_tool_call(|_ev| {
        // return Some(phi::ToolCallResult { block: true, reason: "...".into(), ..Default::default() }) to deny
        None
    });

    m.on_tool_result(|_ev| {
        // return Some(phi::ToolResultResult { stop: true, ..Default::default() }) to end the agent loop
        None
    });

    m.on_turn_stopping(|_ev| {
        // return Some(phi::TurnStoppingResult { continue_: true, message: "check X".into(), ..Default::default() }) to steer
        None
    });

    m.subscribe(pxb::Event::SessionStart, |ev| {
        let _ = ev; // Reason, PreviousSessionID, …
    });

    m.run()
}

pub fn needs_args(self) -> Self

Mark this command as requiring arguments so the host fills the composer instead of auto-submitting an empty invocation.