Struct Manifest 

pub struct Manifest {
    pub owner: String,
    pub name: String,
    pub version: String,
    pub description: String,
    pub exec: Exec,
    pub cli_zip: CliZip,
    pub viewer_zip: Option<String>,
    pub viewer_url: Option<String>,
    pub viewer_routes: Vec<ViewerRoute>,
    pub mcp_servers: Vec<McpServer>,
}

Declarative metadata a plugin ships with — the on-disk objectiveai.json at <base_dir>/plugins/<owner>/<name>/<version>/objectiveai.json. The CLI reads and writes this shape verbatim (install writes the fetched manifest exactly as authored); the plugins get wire response is a lean projection of it.

Fields

owner: String

GitHub <owner> segment of the source repo, written verbatim from the fetched manifest (forks land on disk with whatever owner they authored, not rewritten to the install coordinate).

name: String

The plugin’s identifier (matches the <name> directory segment).

version: String

Version string. Semver convention is recommended but not enforced — the host just displays whatever’s here.

description: String

One-line description of what the plugin does. Surfaced in listings and the plugin’s --help-equivalent UI.

exec: Exec

Per-OS exec command for the plugin’s cli side — the same shape tools use. The current platform’s vector is the program plus its leading arguments; the run’s args are appended, and the whole thing runs with CWD = <plugin dir>/cli/. Relative program paths resolve against that folder; bare names keep PATH-lookup semantics. An empty per-OS vector means viewer-only for that platform.

cli_zip: CliZip

Per-OS cli bundle zip filenames. At install the current platform’s entry (when present) is downloaded and extracted into <plugin dir>/cli/ (the Self::exec working directory), the same way Self::viewer_zip extracts to viewer/. Required field; each per-OS entry is optional — absent means the exec needs nothing on disk for that platform (e.g. it invokes a PATH-resolved program, or the plugin is viewer-only).

viewer_zip: Option<String>

GitHub-release asset filename for the plugin’s viewer UI bundle (a .zip whose root contains index.html plus assets). When absent, the plugin has no viewer tab from this source. Mutually exclusive with Self::viewer_url — validated by Self::validate.

viewer_url: Option<String>

Remote URL the viewer’s iframe loads directly, instead of an on-disk bundle from Self::viewer_zip. The full URL is used as the iframe src= verbatim — query string, path, port, fragment all pass through. Must use https://, or http:// targeting localhost / 127.0.0.1 (development only).

Mutually exclusive with Self::viewer_zip. Self::viewer_routes apply to remote-URL viewers the same way they apply to zip-bundled viewers — the embedded axum server still hosts the declared routes; the iframe still receives the same postMessage protocol regardless of where its HTML/JS loaded from.

viewer_routes: Vec<ViewerRoute>

HTTP routes the viewer exposes on behalf of this plugin. Each entry registers a handler at /plugin/<repository>/<path> on the viewer’s embedded axum server; a hit emits a PluginRequest { type, value } event to the React frontend, which dispatches to the plugin’s iframe via the postMessage bridge.

mcp_servers: Vec<McpServer>

MCP servers the plugin wants the host to expose. Each entry has a name (the identifier agents reference via objectiveai_sdk::agent::ClientObjectiveaiMcpPluginEntry::mcp_servers) plus an authorization flag. Auth-requiring entries flag authorization = true; credentials are resolved by the host (env vars / config), not the manifest.

Implementations

impl Manifest

pub fn has_viewer(&self) -> bool

Whether this plugin presents a viewer tab in the host. True iff either viewer source field — Self::viewer_zip or Self::viewer_url — is set.

pub fn validate(&self) -> Result<(), &'static str>

Validate fields that can’t be enforced by serde alone: viewer_zip and viewer_url are mutually exclusive, and viewer_url (when present) must be https:// or http:// targeting localhost / 127.0.0.1. Called at every parse boundary (remote-fetched install, on-disk read) so a broken manifest can’t sneak through.

Trait Implementations

impl Clone for Manifest

fn clone(&self) -> Manifest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Manifest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Manifest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Manifest> for ResponseManifest

fn from(m: Manifest) -> Self

Converts to this type from the input type.

impl JsonSchema for Manifest

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Manifest

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

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 Manifest