@llm-dev-ops/agentics-cli 1.4.29 → 1.4.32

package/dist/bundled-agents/memory-graph-agents/src/types/nodes.rs

@@ -0,0 +1,1712 @@
+//! Node types for the memory graph
+
+use super::{AgentId, NodeId, SessionId, TemplateId};
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::fmt;
+
+/// Enum representing different node types in the graph
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum NodeType {
+    /// A prompt sent to an LLM
+    Prompt,
+    /// A response received from an LLM
+    Response,
+    /// A conversation session
+    Session,
+    /// A tool invocation by an LLM
+    ToolInvocation,
+    /// An autonomous agent
+    Agent,
+    /// A versioned prompt template
+    Template,
+}
+
+/// Generic node wrapper that contains any node type
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum Node {
+    /// Prompt node
+    Prompt(PromptNode),
+    /// Response node
+    Response(ResponseNode),
+    /// Session node
+    Session(ConversationSession),
+    /// Tool invocation node
+    ToolInvocation(ToolInvocation),
+    /// Agent node
+    Agent(AgentNode),
+    /// Template node
+    Template(PromptTemplate),
+}
+
+impl Node {
+    /// Get the node ID
+    #[must_use]
+    pub fn id(&self) -> NodeId {
+        match self {
+            Node::Prompt(p) => p.id,
+            Node::Response(r) => r.id,
+            Node::Session(s) => s.node_id,
+            Node::ToolInvocation(t) => t.id,
+            Node::Agent(a) => a.node_id,
+            Node::Template(t) => t.node_id,
+        }
+    }
+
+    /// Get the node type
+    #[must_use]
+    pub fn node_type(&self) -> NodeType {
+        match self {
+            Node::Prompt(_) => NodeType::Prompt,
+            Node::Response(_) => NodeType::Response,
+            Node::Session(_) => NodeType::Session,
+            Node::ToolInvocation(_) => NodeType::ToolInvocation,
+            Node::Agent(_) => NodeType::Agent,
+            Node::Template(_) => NodeType::Template,
+        }
+    }
+}
+
+/// A conversation session that groups related prompts and responses
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConversationSession {
+    /// Internal node ID for the session
+    pub node_id: NodeId,
+    /// Unique session identifier
+    pub id: SessionId,
+    /// When the session was created
+    pub created_at: DateTime<Utc>,
+    /// When the session was last updated
+    pub updated_at: DateTime<Utc>,
+    /// Custom metadata for the session
+    pub metadata: HashMap<String, String>,
+    /// Tags for categorization
+    pub tags: Vec<String>,
+}
+
+impl ConversationSession {
+    /// Create a new conversation session
+    #[must_use]
+    pub fn new() -> Self {
+        let now = Utc::now();
+        Self {
+            node_id: NodeId::new(),
+            id: SessionId::new(),
+            created_at: now,
+            updated_at: now,
+            metadata: HashMap::new(),
+            tags: Vec::new(),
+        }
+    }
+
+    /// Create a session with custom metadata
+    #[must_use]
+    pub fn with_metadata(metadata: HashMap<String, String>) -> Self {
+        let mut session = Self::new();
+        session.metadata = metadata;
+        session
+    }
+
+    /// Add a tag to the session
+    pub fn add_tag(&mut self, tag: String) {
+        if !self.tags.contains(&tag) {
+            self.tags.push(tag);
+        }
+    }
+
+    /// Update the last modified timestamp
+    pub fn touch(&mut self) {
+        self.updated_at = Utc::now();
+    }
+}
+
+impl Default for ConversationSession {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Metadata associated with a prompt
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PromptMetadata {
+    /// The LLM model name (e.g., "gpt-4", "claude-3-opus")
+    pub model: String,
+    /// Temperature parameter for generation
+    pub temperature: f32,
+    /// Maximum tokens to generate
+    pub max_tokens: Option<usize>,
+    /// List of tools/functions available to the model
+    pub tools_available: Vec<String>,
+    /// Additional custom metadata
+    pub custom: HashMap<String, String>,
+}
+
+impl Default for PromptMetadata {
+    fn default() -> Self {
+        Self {
+            model: String::from("unknown"),
+            temperature: 0.7,
+            max_tokens: None,
+            tools_available: Vec::new(),
+            custom: HashMap::new(),
+        }
+    }
+}
+
+/// A prompt node representing input to an LLM
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PromptNode {
+    /// Unique node identifier
+    pub id: NodeId,
+    /// Session this prompt belongs to
+    pub session_id: SessionId,
+    /// When the prompt was created
+    pub timestamp: DateTime<Utc>,
+    /// Optional template this prompt was instantiated from
+    pub template_id: Option<TemplateId>,
+    /// The actual prompt content
+    pub content: String,
+    /// Variables used if instantiated from a template
+    pub variables: HashMap<String, String>,
+    /// Metadata about the prompt
+    pub metadata: PromptMetadata,
+}
+
+impl PromptNode {
+    /// Create a new prompt node
+    #[must_use]
+    pub fn new(session_id: SessionId, content: String) -> Self {
+        Self {
+            id: NodeId::new(),
+            session_id,
+            timestamp: Utc::now(),
+            template_id: None,
+            content,
+            variables: HashMap::new(),
+            metadata: PromptMetadata::default(),
+        }
+    }
+
+    /// Create a prompt with custom metadata
+    #[must_use]
+    pub fn with_metadata(session_id: SessionId, content: String, metadata: PromptMetadata) -> Self {
+        Self {
+            id: NodeId::new(),
+            session_id,
+            timestamp: Utc::now(),
+            template_id: None,
+            content,
+            variables: HashMap::new(),
+            metadata,
+        }
+    }
+
+    /// Create a prompt from a template
+    #[must_use]
+    pub fn from_template(
+        session_id: SessionId,
+        template_id: TemplateId,
+        content: String,
+        variables: HashMap<String, String>,
+    ) -> Self {
+        Self {
+            id: NodeId::new(),
+            session_id,
+            timestamp: Utc::now(),
+            template_id: Some(template_id),
+            content,
+            variables,
+            metadata: PromptMetadata::default(),
+        }
+    }
+}
+
+/// Token usage statistics for a response
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+pub struct TokenUsage {
+    /// Number of tokens in the prompt
+    pub prompt_tokens: u32,
+    /// Number of tokens in the completion
+    pub completion_tokens: u32,
+    /// Total tokens used
+    pub total_tokens: u32,
+}
+
+impl TokenUsage {
+    /// Create new token usage stats
+    #[must_use]
+    pub const fn new(prompt_tokens: u32, completion_tokens: u32) -> Self {
+        Self {
+            prompt_tokens,
+            completion_tokens,
+            total_tokens: prompt_tokens + completion_tokens,
+        }
+    }
+}
+
+/// Metadata associated with a response
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ResponseMetadata {
+    /// The model that generated the response
+    pub model: String,
+    /// Reason why generation stopped
+    pub finish_reason: String,
+    /// Latency in milliseconds
+    pub latency_ms: u64,
+    /// Additional custom metadata
+    pub custom: HashMap<String, String>,
+}
+
+impl Default for ResponseMetadata {
+    fn default() -> Self {
+        Self {
+            model: String::from("unknown"),
+            finish_reason: String::from("stop"),
+            latency_ms: 0,
+            custom: HashMap::new(),
+        }
+    }
+}
+
+/// A response node representing output from an LLM
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ResponseNode {
+    /// Unique node identifier
+    pub id: NodeId,
+    /// The prompt this response is replying to
+    pub prompt_id: NodeId,
+    /// When the response was created
+    pub timestamp: DateTime<Utc>,
+    /// The response content
+    pub content: String,
+    /// Token usage statistics
+    pub usage: TokenUsage,
+    /// Metadata about the response
+    pub metadata: ResponseMetadata,
+}
+
+impl ResponseNode {
+    /// Create a new response node
+    #[must_use]
+    pub fn new(prompt_id: NodeId, content: String, usage: TokenUsage) -> Self {
+        Self {
+            id: NodeId::new(),
+            prompt_id,
+            timestamp: Utc::now(),
+            content,
+            usage,
+            metadata: ResponseMetadata::default(),
+        }
+    }
+
+    /// Create a response with custom metadata
+    #[must_use]
+    pub fn with_metadata(
+        prompt_id: NodeId,
+        content: String,
+        usage: TokenUsage,
+        metadata: ResponseMetadata,
+    ) -> Self {
+        Self {
+            id: NodeId::new(),
+            prompt_id,
+            timestamp: Utc::now(),
+            content,
+            usage,
+            metadata,
+        }
+    }
+}
+
+/// A tool invocation node representing a function call by an LLM
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolInvocation {
+    /// Unique node identifier
+    pub id: NodeId,
+    /// Response that triggered this tool call
+    pub response_id: NodeId,
+    /// Name of the tool/function
+    pub tool_name: String,
+    /// JSON parameters passed to the tool
+    pub parameters: serde_json::Value,
+    /// Tool execution result (if completed)
+    pub result: Option<serde_json::Value>,
+    /// Error message (if failed)
+    pub error: Option<String>,
+    /// Execution duration in milliseconds
+    pub duration_ms: u64,
+    /// When the tool was invoked
+    pub timestamp: DateTime<Utc>,
+    /// Success/failure status
+    pub success: bool,
+    /// Retry count (for failed invocations)
+    pub retry_count: u32,
+    /// Additional metadata
+    pub metadata: HashMap<String, String>,
+}
+
+impl ToolInvocation {
+    /// Create a new pending tool invocation
+    #[must_use]
+    pub fn new(response_id: NodeId, tool_name: String, parameters: serde_json::Value) -> Self {
+        Self {
+            id: NodeId::new(),
+            response_id,
+            tool_name,
+            parameters,
+            result: None,
+            error: None,
+            duration_ms: 0,
+            timestamp: Utc::now(),
+            success: false,
+            retry_count: 0,
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Mark tool invocation as successful
+    pub fn mark_success(&mut self, result: serde_json::Value, duration_ms: u64) {
+        self.success = true;
+        self.result = Some(result);
+        self.error = None;
+        self.duration_ms = duration_ms;
+    }
+
+    /// Mark tool invocation as failed
+    pub fn mark_failed(&mut self, error: String, duration_ms: u64) {
+        self.success = false;
+        self.error = Some(error);
+        self.result = None;
+        self.duration_ms = duration_ms;
+    }
+
+    /// Record retry attempt
+    pub fn record_retry(&mut self) {
+        self.retry_count += 1;
+        self.timestamp = Utc::now();
+    }
+
+    /// Check if tool invocation is pending (not completed)
+    #[must_use]
+    pub fn is_pending(&self) -> bool {
+        self.result.is_none() && self.error.is_none()
+    }
+
+    /// Check if tool invocation succeeded
+    #[must_use]
+    pub const fn is_success(&self) -> bool {
+        self.success
+    }
+
+    /// Check if tool invocation failed
+    #[must_use]
+    pub fn is_failed(&self) -> bool {
+        self.error.is_some()
+    }
+
+    /// Get the tool execution status as a string
+    #[must_use]
+    pub fn status(&self) -> &str {
+        if self.is_pending() {
+            "pending"
+        } else if self.success {
+            "success"
+        } else {
+            "failed"
+        }
+    }
+
+    /// Add metadata to the tool invocation
+    pub fn add_metadata(&mut self, key: String, value: String) {
+        self.metadata.insert(key, value);
+    }
+}
+
+/// Agent status enum
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)]
+pub enum AgentStatus {
+    /// Agent is active and ready to process tasks
+    Active,
+    /// Agent is idle, waiting for work
+    #[default]
+    Idle,
+    /// Agent is currently busy processing a task
+    Busy,
+    /// Agent is paused and not accepting new tasks
+    Paused,
+    /// Agent has been terminated
+    Terminated,
+}
+
+impl AgentStatus {
+    /// Check if agent can accept new tasks
+    #[must_use]
+    pub const fn can_accept_tasks(&self) -> bool {
+        matches!(self, Self::Active | Self::Idle)
+    }
+
+    /// Check if agent is processing a task
+    #[must_use]
+    pub const fn is_busy(&self) -> bool {
+        matches!(self, Self::Busy)
+    }
+
+    /// Check if agent is operational
+    #[must_use]
+    pub const fn is_operational(&self) -> bool {
+        !matches!(self, Self::Terminated)
+    }
+}
+
+/// Agent configuration parameters
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentConfig {
+    /// Temperature parameter for generation
+    pub temperature: f32,
+    /// Maximum tokens to generate
+    pub max_tokens: usize,
+    /// Timeout in seconds for agent operations
+    pub timeout_seconds: u64,
+    /// Maximum number of retries for failed operations
+    pub max_retries: u32,
+    /// List of tools/functions available to the agent
+    pub tools_enabled: Vec<String>,
+}
+
+impl Default for AgentConfig {
+    fn default() -> Self {
+        Self {
+            temperature: 0.7,
+            max_tokens: 2000,
+            timeout_seconds: 300,
+            max_retries: 3,
+            tools_enabled: Vec::new(),
+        }
+    }
+}
+
+/// Agent performance metrics
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentMetrics {
+    /// Total number of prompts processed
+    pub total_prompts: u64,
+    /// Number of successfully completed tasks
+    pub successful_tasks: u64,
+    /// Number of failed tasks
+    pub failed_tasks: u64,
+    /// Average latency in milliseconds
+    pub average_latency_ms: f64,
+    /// Total tokens used across all operations
+    pub total_tokens_used: u64,
+}
+
+impl Default for AgentMetrics {
+    fn default() -> Self {
+        Self {
+            total_prompts: 0,
+            successful_tasks: 0,
+            failed_tasks: 0,
+            average_latency_ms: 0.0,
+            total_tokens_used: 0,
+        }
+    }
+}
+
+impl AgentMetrics {
+    /// Calculate success rate as a percentage
+    #[must_use]
+    pub fn success_rate(&self) -> f64 {
+        let total = self.successful_tasks + self.failed_tasks;
+        if total == 0 {
+            0.0
+        } else {
+            (self.successful_tasks as f64 / total as f64) * 100.0
+        }
+    }
+
+    /// Update average latency with new measurement
+    pub fn update_average_latency(&mut self, new_latency_ms: u64, current_count: u64) {
+        if current_count == 0 {
+            self.average_latency_ms = new_latency_ms as f64;
+        } else {
+            self.average_latency_ms = (self.average_latency_ms * current_count as f64
+                + new_latency_ms as f64)
+                / (current_count + 1) as f64;
+        }
+    }
+}
+
+/// An agent node representing an autonomous AI agent
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentNode {
+    /// Unique agent identifier
+    pub id: AgentId,
+    /// Internal node ID for graph storage
+    pub node_id: NodeId,
+    /// Human-readable agent name
+    pub name: String,
+    /// Agent role/specialization (e.g., "researcher", "coder", "reviewer")
+    pub role: String,
+    /// List of agent capabilities
+    pub capabilities: Vec<String>,
+    /// Model used by this agent
+    pub model: String,
+    /// When the agent was created
+    pub created_at: DateTime<Utc>,
+    /// Last activity timestamp
+    pub last_active: DateTime<Utc>,
+    /// Agent status (active, idle, busy, paused, terminated)
+    pub status: AgentStatus,
+    /// Configuration parameters
+    pub config: AgentConfig,
+    /// Performance metrics
+    pub metrics: AgentMetrics,
+    /// Tags for categorization
+    pub tags: Vec<String>,
+}
+
+impl AgentNode {
+    /// Create a new agent
+    #[must_use]
+    pub fn new(name: String, role: String, capabilities: Vec<String>) -> Self {
+        let now = Utc::now();
+        Self {
+            id: AgentId::new(),
+            node_id: NodeId::new(),
+            name,
+            role,
+            capabilities,
+            model: String::from("gpt-4"),
+            created_at: now,
+            last_active: now,
+            status: AgentStatus::Idle,
+            config: AgentConfig::default(),
+            metrics: AgentMetrics::default(),
+            tags: Vec::new(),
+        }
+    }
+
+    /// Create an agent with custom configuration
+    #[must_use]
+    pub fn with_config(
+        name: String,
+        role: String,
+        capabilities: Vec<String>,
+        config: AgentConfig,
+    ) -> Self {
+        let mut agent = Self::new(name, role, capabilities);
+        agent.config = config;
+        agent
+    }
+
+    /// Create an agent with a specific model
+    #[must_use]
+    pub fn with_model(
+        name: String,
+        role: String,
+        capabilities: Vec<String>,
+        model: String,
+    ) -> Self {
+        let mut agent = Self::new(name, role, capabilities);
+        agent.model = model;
+        agent
+    }
+
+    /// Update agent status
+    pub fn set_status(&mut self, status: AgentStatus) {
+        self.status = status;
+        self.last_active = Utc::now();
+    }
+
+    /// Record agent activity
+    pub fn record_activity(&mut self) {
+        self.last_active = Utc::now();
+    }
+
+    /// Update performance metrics
+    pub fn update_metrics(&mut self, success: bool, latency_ms: u64, tokens: u64) {
+        let current_count = self.metrics.total_prompts;
+        self.metrics.total_prompts += 1;
+        if success {
+            self.metrics.successful_tasks += 1;
+        } else {
+            self.metrics.failed_tasks += 1;
+        }
+        self.metrics
+            .update_average_latency(latency_ms, current_count);
+        self.metrics.total_tokens_used += tokens;
+        self.record_activity();
+    }
+
+    /// Add a capability to the agent
+    pub fn add_capability(&mut self, capability: String) {
+        if !self.capabilities.contains(&capability) {
+            self.capabilities.push(capability);
+        }
+    }
+
+    /// Remove a capability from the agent
+    pub fn remove_capability(&mut self, capability: &str) {
+        self.capabilities.retain(|c| c != capability);
+    }
+
+    /// Check if agent has a specific capability
+    #[must_use]
+    pub fn has_capability(&self, capability: &str) -> bool {
+        self.capabilities.contains(&String::from(capability))
+    }
+
+    /// Add a tag to the agent
+    pub fn add_tag(&mut self, tag: String) {
+        if !self.tags.contains(&tag) {
+            self.tags.push(tag);
+        }
+    }
+
+    /// Get agent uptime in seconds
+    #[must_use]
+    pub fn uptime_seconds(&self) -> i64 {
+        (Utc::now() - self.created_at).num_seconds()
+    }
+
+    /// Get time since last activity in seconds
+    #[must_use]
+    pub fn idle_time_seconds(&self) -> i64 {
+        (Utc::now() - self.last_active).num_seconds()
+    }
+
+    /// Check if agent is healthy (active and operational)
+    #[must_use]
+    pub fn is_healthy(&self) -> bool {
+        self.status.is_operational() && self.idle_time_seconds() < 3600 // Not idle for more than 1 hour
+    }
+}
+
+/// Semantic version for template versioning
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct Version {
+    /// Major version (breaking changes)
+    pub major: u16,
+    /// Minor version (new features, backwards compatible)
+    pub minor: u16,
+    /// Patch version (bug fixes)
+    pub patch: u16,
+}
+
+impl Version {
+    /// Create a new version
+    #[must_use]
+    pub const fn new(major: u16, minor: u16, patch: u16) -> Self {
+        Self {
+            major,
+            minor,
+            patch,
+        }
+    }
+
+    /// Bump major version (resets minor and patch to 0)
+    pub fn bump_major(&mut self) {
+        self.major += 1;
+        self.minor = 0;
+        self.patch = 0;
+    }
+
+    /// Bump minor version (resets patch to 0)
+    pub fn bump_minor(&mut self) {
+        self.minor += 1;
+        self.patch = 0;
+    }
+
+    /// Bump patch version
+    pub fn bump_patch(&mut self) {
+        self.patch += 1;
+    }
+}
+
+impl Default for Version {
+    fn default() -> Self {
+        Self::new(1, 0, 0)
+    }
+}
+
+impl fmt::Display for Version {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
+    }
+}
+
+impl std::str::FromStr for Version {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parts: Vec<&str> = s.split('.').collect();
+        if parts.len() != 3 {
+            return Err(format!("Invalid version format: {}", s));
+        }
+
+        let major = parts[0]
+            .parse::<u16>()
+            .map_err(|_| format!("Invalid major version: {}", parts[0]))?;
+        let minor = parts[1]
+            .parse::<u16>()
+            .map_err(|_| format!("Invalid minor version: {}", parts[1]))?;
+        let patch = parts[2]
+            .parse::<u16>()
+            .map_err(|_| format!("Invalid patch version: {}", parts[2]))?;
+
+        Ok(Self::new(major, minor, patch))
+    }
+}
+
+/// Version bump level
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum VersionLevel {
+    /// Major version bump (breaking changes)
+    Major,
+    /// Minor version bump (new features)
+    Minor,
+    /// Patch version bump (bug fixes)
+    Patch,
+}
+
+/// Variable specification for template variables
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct VariableSpec {
+    /// Variable name (e.g., "user_query")
+    pub name: String,
+    /// Type hint (e.g., "string", "number", "array")
+    pub type_hint: String,
+    /// Whether the variable is required
+    pub required: bool,
+    /// Default value if not provided
+    pub default: Option<String>,
+    /// Validation regex pattern
+    pub validation_pattern: Option<String>,
+    /// Human-readable description
+    pub description: String,
+}
+
+impl VariableSpec {
+    /// Create a new variable specification
+    #[must_use]
+    pub fn new(name: String, type_hint: String, required: bool, description: String) -> Self {
+        Self {
+            name,
+            type_hint,
+            required,
+            default: None,
+            validation_pattern: None,
+            description,
+        }
+    }
+
+    /// Create a variable spec with a default value
+    #[must_use]
+    pub fn with_default(mut self, default: String) -> Self {
+        self.default = Some(default);
+        self
+    }
+
+    /// Create a variable spec with validation pattern
+    #[must_use]
+    pub fn with_validation(mut self, pattern: String) -> Self {
+        self.validation_pattern = Some(pattern);
+        self
+    }
+
+    /// Validate a value against this spec
+    pub fn validate(&self, value: &Option<String>) -> Result<(), String> {
+        // Check if required
+        if self.required && value.is_none() {
+            return Err(format!("Required variable '{}' is missing", self.name));
+        }
+
+        // If value is present, validate pattern
+        if let Some(val) = value {
+            if let Some(ref pattern) = self.validation_pattern {
+                let re = regex::Regex::new(pattern)
+                    .map_err(|e| format!("Invalid regex pattern: {}", e))?;
+                if !re.is_match(val) {
+                    return Err(format!(
+                        "Variable '{}' value '{}' does not match pattern '{}'",
+                        self.name, val, pattern
+                    ));
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// A prompt template node for reusable prompts
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PromptTemplate {
+    /// Unique template identifier
+    pub id: TemplateId,
+    /// Internal node ID for graph storage
+    pub node_id: NodeId,
+    /// Semantic version
+    pub version: Version,
+    /// Human-readable template name
+    pub name: String,
+    /// Template description
+    pub description: String,
+    /// Template content with {{variables}}
+    pub template: String,
+    /// Variable specifications
+    pub variables: Vec<VariableSpec>,
+    /// Parent template ID (for inheritance)
+    pub parent_id: Option<TemplateId>,
+    /// When the template was created
+    pub created_at: DateTime<Utc>,
+    /// Last modification timestamp
+    pub updated_at: DateTime<Utc>,
+    /// Template author
+    pub author: String,
+    /// Usage count
+    pub usage_count: u64,
+    /// Tags for categorization
+    pub tags: Vec<String>,
+    /// Additional metadata
+    pub metadata: HashMap<String, String>,
+}
+
+impl PromptTemplate {
+    /// Create a new template
+    #[must_use]
+    pub fn new(name: String, template: String, variables: Vec<VariableSpec>) -> Self {
+        let now = Utc::now();
+        Self {
+            id: TemplateId::new(),
+            node_id: NodeId::new(),
+            version: Version::default(),
+            name,
+            description: String::new(),
+            template,
+            variables,
+            parent_id: None,
+            created_at: now,
+            updated_at: now,
+            author: String::from("unknown"),
+            usage_count: 0,
+            tags: Vec::new(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Create template from parent (inheritance)
+    #[must_use]
+    pub fn from_parent(
+        parent_id: TemplateId,
+        name: String,
+        template: String,
+        variables: Vec<VariableSpec>,
+    ) -> Self {
+        let mut tmpl = Self::new(name, template, variables);
+        tmpl.parent_id = Some(parent_id);
+        tmpl
+    }
+
+    /// Set template description
+    #[must_use]
+    pub fn with_description(mut self, description: String) -> Self {
+        self.description = description;
+        self
+    }
+
+    /// Set template author
+    #[must_use]
+    pub fn with_author(mut self, author: String) -> Self {
+        self.author = author;
+        self
+    }
+
+    /// Instantiate template with variable values
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if:
+    /// - Required variables are missing
+    /// - Variable validation fails
+    pub fn instantiate(&self, values: &HashMap<String, String>) -> Result<String, String> {
+        // Validate all variables
+        self.validate(values)?;
+
+        // Build final variable map with defaults
+        let mut final_values = HashMap::new();
+        for var in &self.variables {
+            if let Some(value) = values.get(&var.name) {
+                final_values.insert(var.name.clone(), value.clone());
+            } else if let Some(ref default) = var.default {
+                final_values.insert(var.name.clone(), default.clone());
+            }
+        }
+
+        // Replace variables in template
+        let mut result = self.template.clone();
+        for (key, value) in final_values {
+            let placeholder = format!("{{{{{}}}}}", key);
+            result = result.replace(&placeholder, &value);
+        }
+
+        Ok(result)
+    }
+
+    /// Validate variable values
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if validation fails
+    pub fn validate(&self, values: &HashMap<String, String>) -> Result<(), String> {
+        for var in &self.variables {
+            let value = values.get(&var.name).cloned();
+            var.validate(&value)?;
+        }
+        Ok(())
+    }
+
+    /// Increment usage counter
+    pub fn record_usage(&mut self) {
+        self.usage_count += 1;
+        self.updated_at = Utc::now();
+    }
+
+    /// Bump version
+    pub fn bump_version(&mut self, level: VersionLevel) {
+        match level {
+            VersionLevel::Major => self.version.bump_major(),
+            VersionLevel::Minor => self.version.bump_minor(),
+            VersionLevel::Patch => self.version.bump_patch(),
+        }
+        self.updated_at = Utc::now();
+    }
+
+    /// Add a tag to the template
+    pub fn add_tag(&mut self, tag: String) {
+        if !self.tags.contains(&tag) {
+            self.tags.push(tag);
+        }
+    }
+
+    /// Add metadata to the template
+    pub fn add_metadata(&mut self, key: String, value: String) {
+        self.metadata.insert(key, value);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_session_creation() {
+        let session = ConversationSession::new();
+        assert!(!session.tags.is_empty() || session.tags.is_empty()); // Always true, just checking API
+        assert!(session.metadata.is_empty());
+    }
+
+    #[test]
+    fn test_session_tags() {
+        let mut session = ConversationSession::new();
+        session.add_tag("test".to_string());
+        session.add_tag("test".to_string()); // Should not duplicate
+        assert_eq!(session.tags.len(), 1);
+    }
+
+    #[test]
+    fn test_prompt_creation() {
+        let session_id = SessionId::new();
+        let prompt = PromptNode::new(session_id, "Test prompt".to_string());
+        assert_eq!(prompt.session_id, session_id);
+        assert_eq!(prompt.content, "Test prompt");
+    }
+
+    #[test]
+    fn test_response_creation() {
+        let prompt_id = NodeId::new();
+        let usage = TokenUsage::new(10, 20);
+        let response = ResponseNode::new(prompt_id, "Test response".to_string(), usage);
+        assert_eq!(response.prompt_id, prompt_id);
+        assert_eq!(response.usage.total_tokens, 30);
+    }
+
+    #[test]
+    fn test_token_usage() {
+        let usage = TokenUsage::new(100, 50);
+        assert_eq!(usage.prompt_tokens, 100);
+        assert_eq!(usage.completion_tokens, 50);
+        assert_eq!(usage.total_tokens, 150);
+    }
+
+    #[test]
+    fn test_node_type() {
+        let session = ConversationSession::new();
+        let node = Node::Session(session);
+        assert_eq!(node.node_type(), NodeType::Session);
+    }
+
+    #[test]
+    fn test_tool_invocation_creation() {
+        let response_id = NodeId::new();
+        let params = serde_json::json!({"operation": "add", "a": 2, "b": 3});
+        let tool = ToolInvocation::new(response_id, "calculator".to_string(), params.clone());
+
+        assert_eq!(tool.response_id, response_id);
+        assert_eq!(tool.tool_name, "calculator");
+        assert_eq!(tool.parameters, params);
+        assert!(tool.is_pending());
+        assert!(!tool.is_success());
+        assert!(!tool.is_failed());
+        assert_eq!(tool.retry_count, 0);
+    }
+
+    #[test]
+    fn test_tool_invocation_mark_success() {
+        let response_id = NodeId::new();
+        let params = serde_json::json!({"operation": "add", "a": 2, "b": 3});
+        let mut tool = ToolInvocation::new(response_id, "calculator".to_string(), params);
+
+        let result = serde_json::json!({"result": 5});
+        tool.mark_success(result.clone(), 150);
+
+        assert!(tool.is_success());
+        assert!(!tool.is_pending());
+        assert!(!tool.is_failed());
+        assert_eq!(tool.result, Some(result));
+        assert_eq!(tool.duration_ms, 150);
+        assert_eq!(tool.error, None);
+        assert_eq!(tool.status(), "success");
+    }
+
+    #[test]
+    fn test_tool_invocation_mark_failed() {
+        let response_id = NodeId::new();
+        let params = serde_json::json!({"operation": "divide", "a": 10, "b": 0});
+        let mut tool = ToolInvocation::new(response_id, "calculator".to_string(), params);
+
+        tool.mark_failed("Division by zero".to_string(), 50);
+
+        assert!(!tool.is_success());
+        assert!(!tool.is_pending());
+        assert!(tool.is_failed());
+        assert_eq!(tool.error, Some("Division by zero".to_string()));
+        assert_eq!(tool.duration_ms, 50);
+        assert_eq!(tool.result, None);
+        assert_eq!(tool.status(), "failed");
+    }
+
+    #[test]
+    fn test_tool_invocation_retry() {
+        let response_id = NodeId::new();
+        let params = serde_json::json!({"url": "https://api.example.com"});
+        let mut tool = ToolInvocation::new(response_id, "http_request".to_string(), params);
+
+        assert_eq!(tool.retry_count, 0);
+
+        tool.record_retry();
+        assert_eq!(tool.retry_count, 1);
+
+        tool.record_retry();
+        assert_eq!(tool.retry_count, 2);
+    }
+
+    #[test]
+    fn test_tool_invocation_metadata() {
+        let response_id = NodeId::new();
+        let params = serde_json::json!({"query": "test"});
+        let mut tool = ToolInvocation::new(response_id, "search".to_string(), params);
+
+        tool.add_metadata("provider".to_string(), "google".to_string());
+        tool.add_metadata("cache_hit".to_string(), "true".to_string());
+
+        assert_eq!(tool.metadata.len(), 2);
+        assert_eq!(tool.metadata.get("provider"), Some(&"google".to_string()));
+        assert_eq!(tool.metadata.get("cache_hit"), Some(&"true".to_string()));
+    }
+
+    #[test]
+    fn test_tool_invocation_node_type() {
+        let response_id = NodeId::new();
+        let params = serde_json::json!({"test": "value"});
+        let tool = ToolInvocation::new(response_id, "test_tool".to_string(), params);
+        let node = Node::ToolInvocation(tool);
+
+        assert_eq!(node.node_type(), NodeType::ToolInvocation);
+    }
+
+    // AgentNode tests
+
+    #[test]
+    fn test_agent_creation() {
+        let agent = AgentNode::new(
+            "Researcher".to_string(),
+            "research".to_string(),
+            vec!["web_search".to_string(), "summarize".to_string()],
+        );
+
+        assert_eq!(agent.name, "Researcher");
+        assert_eq!(agent.role, "research");
+        assert_eq!(agent.capabilities.len(), 2);
+        assert_eq!(agent.status, AgentStatus::Idle);
+        assert_eq!(agent.model, "gpt-4");
+        assert_eq!(agent.metrics.total_prompts, 0);
+    }
+
+    #[test]
+    fn test_agent_with_config() {
+        let config = AgentConfig {
+            temperature: 0.5,
+            max_tokens: 1000,
+            timeout_seconds: 60,
+            max_retries: 5,
+            tools_enabled: vec!["calculator".to_string()],
+        };
+
+        let agent = AgentNode::with_config(
+            "Calculator".to_string(),
+            "math".to_string(),
+            vec!["calculate".to_string()],
+            config.clone(),
+        );
+
+        assert_eq!(agent.config.temperature, 0.5);
+        assert_eq!(agent.config.max_tokens, 1000);
+        assert_eq!(agent.config.timeout_seconds, 60);
+        assert_eq!(agent.config.max_retries, 5);
+        assert_eq!(agent.config.tools_enabled.len(), 1);
+    }
+
+    #[test]
+    fn test_agent_with_model() {
+        let agent = AgentNode::with_model(
+            "Claude Agent".to_string(),
+            "assistant".to_string(),
+            vec![],
+            "claude-3-opus".to_string(),
+        );
+
+        assert_eq!(agent.model, "claude-3-opus");
+    }
+
+    #[test]
+    fn test_agent_status_transitions() {
+        let mut agent = AgentNode::new("Test".to_string(), "test".to_string(), vec![]);
+
+        assert_eq!(agent.status, AgentStatus::Idle);
+        assert!(agent.status.can_accept_tasks());
+
+        agent.set_status(AgentStatus::Busy);
+        assert_eq!(agent.status, AgentStatus::Busy);
+        assert!(agent.status.is_busy());
+        assert!(!agent.status.can_accept_tasks());
+
+        agent.set_status(AgentStatus::Active);
+        assert_eq!(agent.status, AgentStatus::Active);
+        assert!(agent.status.can_accept_tasks());
+
+        agent.set_status(AgentStatus::Paused);
+        assert!(!agent.status.can_accept_tasks());
+
+        agent.set_status(AgentStatus::Terminated);
+        assert!(!agent.status.is_operational());
+    }
+
+    #[test]
+    fn test_agent_metrics_update() {
+        let mut agent = AgentNode::new("Test".to_string(), "test".to_string(), vec![]);
+
+        assert_eq!(agent.metrics.total_prompts, 0);
+        assert_eq!(agent.metrics.success_rate(), 0.0);
+
+        agent.update_metrics(true, 100, 50);
+        assert_eq!(agent.metrics.total_prompts, 1);
+        assert_eq!(agent.metrics.successful_tasks, 1);
+        assert_eq!(agent.metrics.failed_tasks, 0);
+        assert_eq!(agent.metrics.average_latency_ms, 100.0);
+        assert_eq!(agent.metrics.total_tokens_used, 50);
+        assert_eq!(agent.metrics.success_rate(), 100.0);
+
+        agent.update_metrics(false, 200, 30);
+        assert_eq!(agent.metrics.total_prompts, 2);
+        assert_eq!(agent.metrics.successful_tasks, 1);
+        assert_eq!(agent.metrics.failed_tasks, 1);
+        assert_eq!(agent.metrics.total_tokens_used, 80);
+        assert_eq!(agent.metrics.success_rate(), 50.0);
+
+        // Average latency should be (100 + 200) / 2 = 150
+        assert_eq!(agent.metrics.average_latency_ms, 150.0);
+    }
+
+    #[test]
+    fn test_agent_capabilities() {
+        let mut agent = AgentNode::new("Test".to_string(), "test".to_string(), vec![]);
+
+        assert!(!agent.has_capability("web_search"));
+
+        agent.add_capability("web_search".to_string());
+        assert!(agent.has_capability("web_search"));
+        assert_eq!(agent.capabilities.len(), 1);
+
+        agent.add_capability("web_search".to_string()); // Duplicate
+        assert_eq!(agent.capabilities.len(), 1); // Should not add duplicate
+
+        agent.add_capability("summarize".to_string());
+        assert_eq!(agent.capabilities.len(), 2);
+
+        agent.remove_capability("web_search");
+        assert!(!agent.has_capability("web_search"));
+        assert_eq!(agent.capabilities.len(), 1);
+    }
+
+    #[test]
+    fn test_agent_tags() {
+        let mut agent = AgentNode::new("Test".to_string(), "test".to_string(), vec![]);
+
+        assert_eq!(agent.tags.len(), 0);
+
+        agent.add_tag("production".to_string());
+        assert_eq!(agent.tags.len(), 1);
+
+        agent.add_tag("production".to_string()); // Duplicate
+        assert_eq!(agent.tags.len(), 1); // Should not add duplicate
+
+        agent.add_tag("critical".to_string());
+        assert_eq!(agent.tags.len(), 2);
+    }
+
+    #[test]
+    fn test_agent_activity_tracking() {
+        let mut agent = AgentNode::new("Test".to_string(), "test".to_string(), vec![]);
+
+        let initial_active = agent.last_active;
+        std::thread::sleep(std::time::Duration::from_millis(10));
+
+        agent.record_activity();
+        assert!(agent.last_active > initial_active);
+        assert_eq!(agent.idle_time_seconds(), 0);
+    }
+
+    #[test]
+    fn test_agent_uptime() {
+        let agent = AgentNode::new("Test".to_string(), "test".to_string(), vec![]);
+
+        let uptime = agent.uptime_seconds();
+        assert!(uptime >= 0);
+        assert!(uptime < 5); // Should be very small since just created
+    }
+
+    #[test]
+    fn test_agent_health_check() {
+        let mut agent = AgentNode::new("Test".to_string(), "test".to_string(), vec![]);
+
+        agent.set_status(AgentStatus::Active);
+        assert!(agent.is_healthy());
+
+        agent.set_status(AgentStatus::Terminated);
+        assert!(!agent.is_healthy());
+    }
+
+    #[test]
+    fn test_agent_node_type() {
+        let agent = AgentNode::new("Test".to_string(), "test".to_string(), vec![]);
+        let node = Node::Agent(agent);
+
+        assert_eq!(node.node_type(), NodeType::Agent);
+    }
+
+    #[test]
+    fn test_agent_status_helpers() {
+        assert!(AgentStatus::Active.can_accept_tasks());
+        assert!(AgentStatus::Idle.can_accept_tasks());
+        assert!(!AgentStatus::Busy.can_accept_tasks());
+        assert!(!AgentStatus::Paused.can_accept_tasks());
+        assert!(!AgentStatus::Terminated.can_accept_tasks());
+
+        assert!(!AgentStatus::Active.is_busy());
+        assert!(AgentStatus::Busy.is_busy());
+
+        assert!(AgentStatus::Active.is_operational());
+        assert!(AgentStatus::Idle.is_operational());
+        assert!(AgentStatus::Busy.is_operational());
+        assert!(AgentStatus::Paused.is_operational());
+        assert!(!AgentStatus::Terminated.is_operational());
+    }
+
+    #[test]
+    fn test_agent_metrics_success_rate() {
+        let mut metrics = AgentMetrics::default();
+
+        assert_eq!(metrics.success_rate(), 0.0);
+
+        metrics.successful_tasks = 5;
+        metrics.failed_tasks = 5;
+        assert_eq!(metrics.success_rate(), 50.0);
+
+        metrics.successful_tasks = 9;
+        metrics.failed_tasks = 1;
+        assert_eq!(metrics.success_rate(), 90.0);
+
+        metrics.successful_tasks = 0;
+        metrics.failed_tasks = 10;
+        assert_eq!(metrics.success_rate(), 0.0);
+    }
+
+    #[test]
+    fn test_agent_config_defaults() {
+        let config = AgentConfig::default();
+
+        assert_eq!(config.temperature, 0.7);
+        assert_eq!(config.max_tokens, 2000);
+        assert_eq!(config.timeout_seconds, 300);
+        assert_eq!(config.max_retries, 3);
+        assert_eq!(config.tools_enabled.len(), 0);
+    }
+
+    // ===== Template Tests =====
+
+    #[test]
+    fn test_version_creation() {
+        let version = Version::new(1, 2, 3);
+        assert_eq!(version.major, 1);
+        assert_eq!(version.minor, 2);
+        assert_eq!(version.patch, 3);
+    }
+
+    #[test]
+    fn test_version_display() {
+        let version = Version::new(2, 5, 10);
+        assert_eq!(version.to_string(), "2.5.10");
+    }
+
+    #[test]
+    fn test_version_from_str() {
+        let version: Version = "1.2.3".parse().unwrap();
+        assert_eq!(version, Version::new(1, 2, 3));
+
+        let version: Version = "10.0.5".parse().unwrap();
+        assert_eq!(version, Version::new(10, 0, 5));
+
+        assert!("invalid".parse::<Version>().is_err());
+        assert!("1.2".parse::<Version>().is_err());
+        assert!("1.2.3.4".parse::<Version>().is_err());
+    }
+
+    #[test]
+    fn test_version_comparison() {
+        let v1 = Version::new(1, 0, 0);
+        let v2 = Version::new(1, 0, 1);
+        let v3 = Version::new(1, 1, 0);
+        let v4 = Version::new(2, 0, 0);
+
+        assert!(v1 < v2);
+        assert!(v2 < v3);
+        assert!(v3 < v4);
+        assert_eq!(v1, Version::new(1, 0, 0));
+    }
+
+    #[test]
+    fn test_version_bumping() {
+        let mut version = Version::new(1, 2, 3);
+
+        version.bump_patch();
+        assert_eq!(version, Version::new(1, 2, 4));
+
+        version.bump_minor();
+        assert_eq!(version, Version::new(1, 3, 0));
+
+        version.bump_major();
+        assert_eq!(version, Version::new(2, 0, 0));
+    }
+
+    #[test]
+    fn test_variable_spec_creation() {
+        let var = VariableSpec::new(
+            "user_input".to_string(),
+            "String".to_string(),
+            true,
+            "User's input text".to_string(),
+        );
+
+        assert_eq!(var.name, "user_input");
+        assert_eq!(var.type_hint, "String");
+        assert!(var.required);
+        assert_eq!(var.description, "User's input text");
+        assert!(var.default.is_none());
+        assert!(var.validation_pattern.is_none());
+    }
+
+    #[test]
+    fn test_variable_spec_with_default() {
+        let var = VariableSpec::new(
+            "count".to_string(),
+            "Number".to_string(),
+            false,
+            "Item count".to_string(),
+        )
+        .with_default("10".to_string());
+
+        assert_eq!(var.default, Some("10".to_string()));
+    }
+
+    #[test]
+    fn test_variable_spec_validation() {
+        let var = VariableSpec::new(
+            "email".to_string(),
+            "String".to_string(),
+            true,
+            "Email address".to_string(),
+        )
+        .with_validation(r"^[\w\.-]+@[\w\.-]+\.\w+$".to_string());
+
+        // Valid email
+        let result = var.validate(&Some("test@example.com".to_string()));
+        assert!(result.is_ok());
+
+        // Invalid email
+        let result = var.validate(&Some("invalid-email".to_string()));
+        assert!(result.is_err());
+
+        // Missing required value
+        let result = var.validate(&None);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_variable_spec_optional_validation() {
+        let var = VariableSpec::new(
+            "optional".to_string(),
+            "String".to_string(),
+            false,
+            "Optional field".to_string(),
+        );
+
+        // Missing optional value is OK
+        let result = var.validate(&None);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_prompt_template_creation() {
+        let variables = vec![VariableSpec::new(
+            "name".to_string(),
+            "String".to_string(),
+            true,
+            "User's name".to_string(),
+        )];
+
+        let template = PromptTemplate::new(
+            "Greeting Template".to_string(),
+            "Hello, {{name}}!".to_string(),
+            variables,
+        );
+
+        assert_eq!(template.name, "Greeting Template");
+        assert_eq!(template.template, "Hello, {{name}}!");
+        assert_eq!(template.variables.len(), 1);
+        assert_eq!(template.version, Version::new(1, 0, 0));
+        assert_eq!(template.usage_count, 0);
+    }
+
+    #[test]
+    fn test_prompt_template_with_description() {
+        let template = PromptTemplate::new("Test".to_string(), "{{content}}".to_string(), vec![])
+            .with_description("A test template".to_string());
+
+        assert_eq!(template.description, "A test template");
+    }
+
+    #[test]
+    fn test_prompt_template_with_author() {
+        let template = PromptTemplate::new("Test".to_string(), "{{content}}".to_string(), vec![])
+            .with_author("John Doe".to_string());
+
+        assert_eq!(template.author, "John Doe");
+    }
+
+    #[test]
+    fn test_prompt_template_instantiation() {
+        let variables = vec![
+            VariableSpec::new(
+                "name".to_string(),
+                "String".to_string(),
+                true,
+                "Name".to_string(),
+            ),
+            VariableSpec::new(
+                "action".to_string(),
+                "String".to_string(),
+                true,
+                "Action".to_string(),
+            ),
+        ];
+
+        let template = PromptTemplate::new(
+            "Action Template".to_string(),
+            "{{name}} is {{action}}".to_string(),
+            variables,
+        );
+
+        let mut values = HashMap::new();
+        values.insert("name".to_string(), "Alice".to_string());
+        values.insert("action".to_string(), "coding".to_string());
+
+        let result = template.instantiate(&values).unwrap();
+        assert_eq!(result, "Alice is coding");
+    }
+
+    #[test]
+    fn test_prompt_template_instantiation_with_defaults() {
+        let variables = vec![
+            VariableSpec::new(
+                "name".to_string(),
+                "String".to_string(),
+                true,
+                "Name".to_string(),
+            ),
+            VariableSpec::new(
+                "greeting".to_string(),
+                "String".to_string(),
+                false,
+                "Greeting".to_string(),
+            )
+            .with_default("Hello".to_string()),
+        ];
+
+        let template = PromptTemplate::new(
+            "Greeting".to_string(),
+            "{{greeting}}, {{name}}!".to_string(),
+            variables,
+        );
+
+        let mut values = HashMap::new();
+        values.insert("name".to_string(), "Bob".to_string());
+
+        let result = template.instantiate(&values).unwrap();
+        assert_eq!(result, "Hello, Bob!");
+    }
+
+    #[test]
+    fn test_prompt_template_validation_missing_required() {
+        let variables = vec![VariableSpec::new(
+            "required_field".to_string(),
+            "String".to_string(),
+            true,
+            "Required".to_string(),
+        )];
+
+        let template = PromptTemplate::new(
+            "Test".to_string(),
+            "{{required_field}}".to_string(),
+            variables,
+        );
+
+        let values = HashMap::new();
+        let result = template.validate(&values);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_prompt_template_validation_pattern() {
+        let variables = vec![VariableSpec::new(
+            "number".to_string(),
+            "String".to_string(),
+            true,
+            "Number".to_string(),
+        )
+        .with_validation(r"^\d+$".to_string())];
+
+        let template = PromptTemplate::new(
+            "Test".to_string(),
+            "Count: {{number}}".to_string(),
+            variables,
+        );
+
+        let mut values = HashMap::new();
+        values.insert("number".to_string(), "123".to_string());
+        assert!(template.validate(&values).is_ok());
+
+        let mut values = HashMap::new();
+        values.insert("number".to_string(), "abc".to_string());
+        assert!(template.validate(&values).is_err());
+    }
+
+    #[test]
+    fn test_prompt_template_usage_tracking() {
+        let mut template =
+            PromptTemplate::new("Test".to_string(), "{{content}}".to_string(), vec![]);
+
+        assert_eq!(template.usage_count, 0);
+
+        template.record_usage();
+        assert_eq!(template.usage_count, 1);
+
+        template.record_usage();
+        assert_eq!(template.usage_count, 2);
+    }
+
+    #[test]
+    fn test_prompt_template_version_bumping() {
+        let mut template =
+            PromptTemplate::new("Test".to_string(), "{{content}}".to_string(), vec![]);
+
+        assert_eq!(template.version, Version::new(1, 0, 0));
+
+        template.bump_version(VersionLevel::Patch);
+        assert_eq!(template.version, Version::new(1, 0, 1));
+
+        template.bump_version(VersionLevel::Minor);
+        assert_eq!(template.version, Version::new(1, 1, 0));
+
+        template.bump_version(VersionLevel::Major);
+        assert_eq!(template.version, Version::new(2, 0, 0));
+    }
+
+    #[test]
+    fn test_prompt_template_from_parent() {
+        let parent_id = TemplateId::new();
+        let template = PromptTemplate::from_parent(
+            parent_id,
+            "Child Template".to_string(),
+            "Extended: {{content}}".to_string(),
+            vec![],
+        );
+
+        assert_eq!(template.parent_id, Some(parent_id));
+        assert_eq!(template.name, "Child Template");
+    }
+
+    #[test]
+    fn test_prompt_template_tags() {
+        let mut template =
+            PromptTemplate::new("Test".to_string(), "{{content}}".to_string(), vec![]);
+
+        assert_eq!(template.tags.len(), 0);
+
+        template.add_tag("production".to_string());
+        template.add_tag("verified".to_string());
+
+        assert_eq!(template.tags.len(), 2);
+        assert!(template.tags.contains(&"production".to_string()));
+        assert!(template.tags.contains(&"verified".to_string()));
+    }
+
+    #[test]
+    fn test_prompt_template_metadata() {
+        let mut template =
+            PromptTemplate::new("Test".to_string(), "{{content}}".to_string(), vec![]);
+
+        assert_eq!(template.metadata.len(), 0);
+
+        template.add_metadata("category".to_string(), "greeting".to_string());
+        template.add_metadata("priority".to_string(), "high".to_string());
+
+        assert_eq!(template.metadata.len(), 2);
+        assert_eq!(
+            template.metadata.get("category"),
+            Some(&"greeting".to_string())
+        );
+        assert_eq!(template.metadata.get("priority"), Some(&"high".to_string()));
+    }
+}