use std::time::Duration;
use tea_policy::{ActorId, PolicyEnvironment, WorkspaceId};
use tea_protocol::ProtocolMetadata;
use crate::compaction::{CompactionPolicy, CompactionSummarizer, NeverCompactPolicy};
use crate::retry::ModelRetryPolicy;
use crate::{KernelError, KernelErrorCode};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[allow(clippy::struct_field_names)] pub struct RunLimits {
max_tool_iterations: u32,
max_elapsed: Duration,
max_assistant_output_bytes: usize,
max_events: u64,
max_queued_messages: usize,
}
impl RunLimits {
pub fn new(
max_tool_iterations: u32,
max_elapsed: Duration,
max_assistant_output_bytes: usize,
max_events: u64,
max_queued_messages: usize,
) -> Result<Self, KernelError> {
if max_tool_iterations == 0
|| max_elapsed.is_zero()
|| max_elapsed > Duration::from_hours(24)
|| max_assistant_output_bytes == 0
|| max_assistant_output_bytes > 16 * 1024 * 1024
|| max_events == 0
|| max_events > 1_000_000
|| max_queued_messages == 0
|| max_queued_messages > 1024
{
return Err(KernelError::new(
KernelErrorCode::InvalidRequest,
"run limits are invalid",
));
}
Ok(Self {
max_tool_iterations,
max_elapsed,
max_assistant_output_bytes,
max_events,
max_queued_messages,
})
}
#[must_use]
pub const fn max_tool_iterations(self) -> u32 {
self.max_tool_iterations
}
#[must_use]
pub const fn max_elapsed(self) -> Duration {
self.max_elapsed
}
#[must_use]
pub const fn max_assistant_output_bytes(self) -> usize {
self.max_assistant_output_bytes
}
#[must_use]
pub const fn max_events(self) -> u64 {
self.max_events
}
#[must_use]
pub const fn max_queued_messages(self) -> usize {
self.max_queued_messages
}
}
impl Default for RunLimits {
fn default() -> Self {
Self {
max_tool_iterations: 16,
max_elapsed: Duration::from_mins(5),
max_assistant_output_bytes: 4 * 1024 * 1024,
max_events: 100_000,
max_queued_messages: 64,
}
}
}
#[derive(Debug, Clone)]
pub struct KernelRunConfig {
actor_id: ActorId,
workspace_id: Option<WorkspaceId>,
environment: PolicyEnvironment,
system_prompt: Option<String>,
compiled_prompt: Option<tea_context::CompiledPrompt>,
request_metadata: ProtocolMetadata,
approval_ttl: Duration,
retry_policy: ModelRetryPolicy,
compaction_policy: std::sync::Arc<dyn CompactionPolicy>,
compaction_summarizer: Option<std::sync::Arc<dyn CompactionSummarizer>>,
limits: RunLimits,
}
impl KernelRunConfig {
#[must_use]
pub fn new(actor_id: ActorId, environment: PolicyEnvironment) -> Self {
Self {
actor_id,
workspace_id: None,
environment,
system_prompt: None,
compiled_prompt: None,
request_metadata: ProtocolMetadata::default(),
approval_ttl: Duration::from_mins(10),
retry_policy: ModelRetryPolicy::default(),
compaction_policy: std::sync::Arc::new(NeverCompactPolicy),
compaction_summarizer: None,
limits: RunLimits {
max_tool_iterations: 16,
max_elapsed: Duration::from_mins(5),
max_assistant_output_bytes: 4 * 1024 * 1024,
max_events: 100_000,
max_queued_messages: 64,
},
}
}
#[must_use]
pub fn with_workspace(mut self, workspace_id: WorkspaceId) -> Self {
self.workspace_id = Some(workspace_id);
self
}
pub fn with_system_prompt(mut self, prompt: impl Into<String>) -> Result<Self, KernelError> {
let prompt = prompt.into();
if self.compiled_prompt.is_some()
|| prompt.is_empty()
|| prompt.len() > 1024 * 1024
|| prompt.contains('\0')
{
return Err(KernelError::new(
KernelErrorCode::InvalidRequest,
"system prompt is invalid",
));
}
self.system_prompt = Some(prompt);
Ok(self)
}
pub fn with_compiled_prompt(
mut self,
prompt: tea_context::CompiledPrompt,
) -> Result<Self, KernelError> {
if self.system_prompt.is_some() {
return Err(KernelError::new(
KernelErrorCode::InvalidRequest,
"compiled and legacy system prompts are mutually exclusive",
));
}
self.compiled_prompt = Some(prompt);
Ok(self)
}
#[must_use]
pub fn with_request_metadata(mut self, metadata: ProtocolMetadata) -> Self {
self.request_metadata = metadata;
self
}
pub fn with_approval_ttl(mut self, ttl: Duration) -> Result<Self, KernelError> {
if ttl.is_zero() || ttl > Duration::from_hours(24) {
return Err(KernelError::new(
KernelErrorCode::InvalidRequest,
"approval lifetime is invalid",
));
}
self.approval_ttl = ttl;
Ok(self)
}
#[must_use]
pub const fn with_limits(mut self, limits: RunLimits) -> Self {
self.limits = limits;
self
}
#[must_use]
pub const fn with_retry_policy(mut self, policy: ModelRetryPolicy) -> Self {
self.retry_policy = policy;
self
}
#[must_use]
pub fn with_compaction_policy(mut self, policy: std::sync::Arc<dyn CompactionPolicy>) -> Self {
self.compaction_policy = policy;
self
}
#[must_use]
pub fn with_compaction_summarizer(
mut self,
summarizer: std::sync::Arc<dyn CompactionSummarizer>,
) -> Self {
self.compaction_summarizer = Some(summarizer);
self
}
#[must_use]
pub const fn actor_id(&self) -> &ActorId {
&self.actor_id
}
#[must_use]
pub const fn workspace_id(&self) -> Option<&WorkspaceId> {
self.workspace_id.as_ref()
}
#[must_use]
pub const fn environment(&self) -> &PolicyEnvironment {
&self.environment
}
#[must_use]
pub fn system_prompt(&self) -> Option<&str> {
self.compiled_prompt.as_ref().map_or_else(
|| self.system_prompt.as_deref(),
|prompt| (!prompt.text().is_empty()).then_some(prompt.text()),
)
}
#[must_use]
pub const fn compiled_prompt(&self) -> Option<&tea_context::CompiledPrompt> {
self.compiled_prompt.as_ref()
}
#[must_use]
pub const fn request_metadata(&self) -> &ProtocolMetadata {
&self.request_metadata
}
#[must_use]
pub const fn approval_ttl(&self) -> Duration {
self.approval_ttl
}
#[must_use]
pub const fn limits(&self) -> RunLimits {
self.limits
}
#[must_use]
pub const fn retry_policy(&self) -> ModelRetryPolicy {
self.retry_policy
}
#[must_use]
pub fn compaction_policy(&self) -> &std::sync::Arc<dyn CompactionPolicy> {
&self.compaction_policy
}
#[must_use]
pub fn compaction_summarizer(&self) -> Option<&std::sync::Arc<dyn CompactionSummarizer>> {
self.compaction_summarizer.as_ref()
}
}