Struct AgentIdentity 

pub struct AgentIdentity {
    pub name: String,
    pub email: String,
    pub signing_key: Option<String>,
    pub public_key: Option<String>,
    pub github_app: Option<GithubApp>,
    pub tokens: BTreeMap<String, SecretRef>,
}

A newt-based agent’s commit identity.

Resolved with the same precedence as .newt/config.toml. See the module docs for the secrets-by-reference rule: this struct carries no raw key or token material, only the public name/email and paths to / references for secrets.

Fields

name: String

Git author/committer name (public). Default: newt-agent[bot].

email: String

Git author/committer email (public). Default: the [bot] noreply address for newt-agent[bot].

signing_key: Option<String>

Filesystem path to the agent’s signing key PEM (tilde-expanded), the agent_mesh_protocol::UserKey that roots the §6 writer fingerprint and the mesh AgentKey. A path, never inline key material. None → no commit signing / no mesh-rooted identity.

public_key: Option<String>

Filesystem path to the matching public key (tilde-expanded). A path, never inline key material. Optional.

github_app: Option<GithubApp>

GitHub App coordinates for a later autonomous-push path. None by default — newt never mints a token unless this is set (and even then, minting is out of scope for the foundation).

tokens: BTreeMap<String, SecretRef>

Named token references ([agent-identity.tokens]). Each value is a SecretRef ({env|file|cmd}) — the NAME is config, the VALUE is resolved on demand and never stored here. Empty by default.

Implementations

impl AgentIdentity

pub fn load(path: &Path) -> Result<Self>

Load an identity config from an explicit file path.

pub fn from_toml_str(text: &str) -> Result<Self>

Parse an identity config from a TOML string.

The file’s top-level table is [agent-identity], so we read that sub-table and deserialize it over the compiled-in default (any omitted field inherits the newt-agent[bot] base).

pub fn resolve() -> Result<Self>

Resolve the agent identity using the same precedence as .newt/config.toml:

1. workspace .newt/agent-identity.toml (walk-up from cwd, stopping before $HOME),
2. ~/.newt/agent-identity.toml,
3. /etc/newt/agent-identity.toml,
4. the compiled-in AgentIdentity::default (newt-agent[bot]).

First file found wins; no file → the default. This never requires any file to exist.

pub fn resolve_with_source() -> Result<(Self, IdentitySource)>

Like AgentIdentity::resolve but also reports which layer it came from (for newt identity).

pub fn git_author(&self) -> (String, String)

(name, email) for the git author/committer.

pub fn co_author_trailer(&self) -> String

A Co-Authored-By: trailer line for commit messages.

pub fn signing_key_path(&self) -> Option<PathBuf>

The configured signing-key path, tilde-expanded. None when unset (the default identity mints nothing).

pub fn public_key_path(&self) -> Option<PathBuf>

The configured public-key path, tilde-expanded. None when unset.

pub fn token(&self, name: &str) -> Result<Option<Secret>>

Resolve a named token reference to its Secret. Ok(None) when no token of that name is configured (or its source is empty); Err only when a configured cmd token fails. The value is never stored on the struct.

pub fn github_app(&self) -> Option<&GithubApp>

The GitHub App config, if any. Token-minting is deferred; this only surfaces the (public) coordinates + the private-key path.

Trait Implementations

impl Clone for AgentIdentity

fn clone(&self) -> AgentIdentity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AgentIdentity

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

Formats the value using the given formatter.

impl Default for AgentIdentity

fn default() -> Self

The compiled-in newt-agent[bot] base every newt agent inherits. No signing key, no GitHub App, no tokens — a fresh newt with zero config resolves cleanly to this.

impl<'de> Deserialize<'de> for AgentIdentity

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for AgentIdentity

impl PartialEq for AgentIdentity

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

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 AgentIdentity