enact-core 0.0.2

Core agent runtime for Enact - Graph-Native AI agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Invocation Context - Context for agent/tool invocation
//!
//! Extends RuntimeContext with invocation-specific fields like input
//! and available services.

use super::execution_context::RuntimeContext;
use crate::kernel::{ExecutionId, StepId};
use serde::{Deserialize, Serialize};

/// Services available during invocation
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct InvocationServices {
    /// Memory service available
    pub memory: bool,
    /// Artifact storage available
    pub artifacts: bool,
    /// Tool registry available
    pub tools: bool,
}

impl InvocationServices {
    /// Create with all services enabled
    pub fn all() -> Self {
        Self {
            memory: true,
            artifacts: true,
            tools: true,
        }
    }

    /// Create with no services
    pub fn none() -> Self {
        Self::default()
    }
}

/// InvocationContext - Context for invoking an agent or tool
///
/// Extends RuntimeContext with invocation-specific fields like input
/// and available services.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InvocationContext {
    /// Runtime context
    pub runtime: RuntimeContext,

    /// Invocation input
    pub input: serde_json::Value,

    /// Services available to the invocation
    pub services: InvocationServices,
}

impl InvocationContext {
    /// Create a new InvocationContext
    pub fn new(runtime: RuntimeContext, input: serde_json::Value) -> Self {
        Self {
            runtime,
            input,
            services: InvocationServices::default(),
        }
    }

    /// Enable all services
    pub fn with_all_services(mut self) -> Self {
        self.services = InvocationServices::all();
        self
    }

    /// Enable specific services
    pub fn with_services(mut self, services: InvocationServices) -> Self {
        self.services = services;
        self
    }

    /// Get the execution ID
    pub fn execution_id(&self) -> &ExecutionId {
        &self.runtime.execution_id
    }

    /// Get the step ID
    pub fn step_id(&self) -> Option<&StepId> {
        self.runtime.step_id.as_ref()
    }

    /// Get the runtime context
    pub fn runtime(&self) -> &RuntimeContext {
        &self.runtime
    }

    /// Get the input
    pub fn input(&self) -> &serde_json::Value {
        &self.input
    }

    /// Get input as string (convenience method)
    pub fn input_str(&self) -> Option<&str> {
        self.input.as_str()
    }
}