Struct Manifest 

pub struct Manifest {

    pub package: Option<PackageInfo>,
    pub dependencies: HashMap<String, Dependency>,
    pub mcp: Vec<McpServerConfig>,
    pub check: CheckConfig,
    pub workspace: WorkspaceConfig,
    pub registry: PackageRegistryConfig,
    pub skills: SkillsConfig,
    pub skill: SkillTables,
    pub capabilities: Option<CapabilitiesFile>,
    pub exports: HashMap<String, String>,
    pub llm: ProvidersConfig,
    pub hooks: Vec<HookConfig>,
    pub triggers: Vec<TriggerManifestEntry>,
    pub handoff_routes: Vec<HandoffRouteConfig>,
    pub providers: Vec<ProviderManifestEntry>,
    pub personas: Vec<PersonaManifestEntry>,
    pub connector_contract: ConnectorContractConfig,
    pub orchestrator: OrchestratorConfig,
}

Fields

package: Option<PackageInfo>

dependencies: HashMap<String, Dependency>

mcp: Vec<McpServerConfig>

check: CheckConfig

workspace: WorkspaceConfig

registry: PackageRegistryConfig

[registry] table — lightweight package discovery index configuration. The CLI also honors HARN_PACKAGE_REGISTRY and --registry flags for one-off overrides.

skills: SkillsConfig

[skills] table — per-project skill discovery configuration (paths, lookup_order, disable).

skill: SkillTables

[[skill.source]] array-of-tables — declared skill sources (filesystem, git, reserved registry).

capabilities: Option<CapabilitiesFile>

[capabilities] section — per-provider-per-model override of the shipped capability matrix (defer_loading, tool_search, prompt_caching, etc.). Entries under [[capabilities.provider.<name>]] are prepended to the built-in rules for the same provider so early adopters can flag proxied endpoints as supporting tool search without waiting for a Harn release. See harn_vm::llm::capabilities for the rule schema.

exports: HashMap<String, String>

Stable exported package modules. Keys are the logical import suffixes (e.g. providers/openai) and values are package-root- relative file paths. Consumers import them via <package>/<key>.

llm: ProvidersConfig

[llm] section — packaged provider definitions, aliases, inference rules, tier rules, and model defaults. Uses the same schema as providers.toml, but merges into the current run instead of replacing the global config file.

hooks: Vec<HookConfig>

[[hooks]] array-of-tables — declarative runtime hooks installed once per process/thread before execution starts. Matches the manifest-extension ABI shape added by [exports] / [llm], but the handlers themselves live in Harn modules.

triggers: Vec<TriggerManifestEntry>

[[triggers]] array-of-tables — declarative event-driven trigger registrations that resolve local handlers and predicates from Harn modules at load time and preserve remote URI schemes for later dispatcher work.

handoff_routes: Vec<HandoffRouteConfig>

[[handoff_routes]] array-of-tables — declarative handoff route data. Route selection stays in Harn stdlib/persona code; the Rust manifest loader makes these tenant routes available to that code.

providers: Vec<ProviderManifestEntry>

[[providers]] array-of-tables — provider-specific connector overrides used by the orchestrator to load either builtin Rust connectors or .harn modules as connector implementations.

personas: Vec<PersonaManifestEntry>

[[personas]] array-of-tables — durable, non-executing agent role manifests. Personas bind an entry workflow to tools, capabilities, autonomy, budgets, receipts, handoffs, evals, and rollout metadata.

connector_contract: ConnectorContractConfig

[connector_contract] table — deterministic package-local fixtures consumed by harn connector check for pure-Harn connector packages.

orchestrator: OrchestratorConfig

[orchestrator] table — listener-level controls shared by manifest-driven ingress surfaces.

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.