Struct Tool 

pub struct Tool {
    pub name: String,
    pub title: String,
    pub description: String,
    pub id: String,
    pub input_schema: Value,
    pub output_schema: Value,
    pub effect: Effect,
    pub hints: Hints,
}

One tool as a client lists it.

Fields

name: String

The tool name a client calls.

title: String

The title.

description: String

The description.

id: String

The canonical id the tool projects.

input_schema: Value

The canonical input schema.

output_schema: Value

The canonical output schema.

effect: Effect

What the call changes: nothing, this process’s memory, or the repository.

hints: Hints

What a caller may assume before calling, classified from the effect. The tool’s annotations are this value and nothing else.

Implementations

impl Tool

pub fn of(c: &Capability) -> Option<Tool>

The tool a capability projects, when it projects one.

The one place a capability becomes a tool: its name is the declared exposure, and everything else — the schemas, the effect, what a caller may assume — is read from the capability, so a tool cannot say anything its capability does not.

use majordomus_cli::capability::{builtin, CapabilityRegistry, Effect};
use majordomus_cli::mcp::surface::Tool;
let registry = CapabilityRegistry::builder().with_builtin(builtin::all()).build().unwrap();
let c = registry.by_mcp_tool("majordomus_plan_transition").unwrap();
let tool = Tool::of(c).unwrap();
assert_eq!(tool.id, "plan.transition");
assert_eq!(tool.effect, Effect::RepositoryMutation);
assert!(tool.hints.destructive, "a tool that writes the repository is announced as one");

Trait Implementations

impl Clone for Tool

fn clone(&self) -> Tool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tool

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

Formats the value using the given formatter.

impl Eq for Tool

impl PartialEq for Tool

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

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 Tool