Struct StarpodAgent 

pub struct StarpodAgent { /* private fields */ }

The Starpod agent orchestrator.

Wires together memory, sessions, vault, skills, cron, and the agent-sdk to provide a high-level chat() interface.

Config is wrapped in RwLock for hot reload support — config files can be updated on disk and the agent will pick up changes on the next request.

Implementations

impl StarpodAgent

pub async fn new(config: StarpodConfig) -> Result<Self>

Create a new StarpodAgent from a StarpodConfig.

Constructs synthetic ResolvedPaths from the config’s db_dir and project_root. Prefer with_paths() for workspace-aware construction.

pub async fn with_paths( agent_config: AgentConfig, paths: ResolvedPaths, ) -> Result<Self>

Create a new StarpodAgent from an AgentConfig and ResolvedPaths.

This is the workspace-aware constructor that uses resolved paths for all file locations instead of deriving them from db_dir.

pub fn paths(&self) -> &ResolvedPaths

Get the resolved paths.

pub fn core_db(&self) -> &Arc<CoreDb>

Get the shared core database.

pub fn reload_config(&self, new_config: StarpodConfig)

Hot-reload the agent config. Updates per-request settings (model, provider, agent_name, etc.) and applies memory tuning parameters immediately.

Settings that require restart: server_addr, TELEGRAM_BOT_TOKEN env var.

impl StarpodAgent

pub async fn invalidate_model_registry(&self)

Invalidate the cached model registry (e.g. after config change).

pub async fn chat(&self, message: ChatMessage) -> Result<ChatResponse>

Process a chat message through the full Starpod pipeline.

pub async fn chat_stream( &self, message: &ChatMessage, ) -> Result<(Query, String, UnboundedSender<String>, Arc<Mutex<Vec<Attachment>>>)>

Start a streaming chat that yields raw agent-sdk messages.

Returns (Query stream, session_id, followup_tx, out_attachments). The caller should consume the stream for real-time display, then call finalize_chat() with the collected results. After the stream ends, drain out_attachments for any files the agent attached via the Attach tool.

The returned followup_tx can be used to inject followup messages into the running agent loop (when followup_mode = "inject"). Messages sent through this channel are drained at each iteration boundary and appended as user messages before the next API call.

pub fn followup_mode(&self) -> FollowupMode

Get the configured followup mode.

pub async fn finalize_chat( &self, session_id: &str, user_text: &str, result_text: &str, result: &ResultMessage, user_id: Option<&str>, )

Finalize a streaming chat — record usage and append daily log.

pub fn memory(&self) -> &Arc<MemoryStore>

Get a reference to the memory store.

pub fn session_mgr(&self) -> &Arc<SessionManager>

Get a reference to the session manager.

pub fn skills(&self) -> &Arc<SkillStore>

Get a reference to the skill store.

pub fn cron(&self) -> &Arc<CronStore>

Get a reference to the cron store.

pub fn vault(&self) -> Option<&Arc<Vault>>

Get a reference to the vault (if available).

pub fn config(&self) -> StarpodConfig

Get a snapshot of the current config.

pub fn run_lifecycle(self: &Arc<Self>) -> JoinHandle<()>

Run startup lifecycle prompts (boot + bootstrap) in the background.

See [run_lifecycle_prompts] for details.

pub fn start_scheduler( self: &Arc<Self>, notifier: Option<NotificationSender>, ) -> JoinHandle<()>

Start the cron scheduler as a background task.

The executor callback sends the job prompt through chat(). Session routing depends on JobContext.session_mode:

• Isolated: channel_id=“scheduler”, no session key (each run is its own session)
• Main: channel_id=“main”, channel_session_key=“main” (shared main session)

An optional notifier is called after each job completes to deliver results to the user (e.g. via Telegram). Returns a JoinHandle for the background task.