feat(bob-runtime): enhance session management and tower service functionality

Author: Akagi201

AGENTS.md

@@ -54,7 +54,7 @@ utoipa = "5.4.0"
 utoipa-swagger-ui = "9.0.2"
 arc-swap = "1.9.0"
 hpx = "2.4.3"
-scc = "3.6.11"
+scc = "3.6.12"
 winnow = "1.0.0"
 shadow-rs = "1.7.1"
 ecdysis = "1.0.1"

Cargo.toml

@@ -34,21 +34,26 @@ flume = "0.12.0"
 futures-core = "0.3.32"
 futures-util = "0.3.32"
 genai = "=0.6.0-beta.10"
+jsonschema = "0.45.0"
 opentelemetry = "0.31.0"
-opentelemetry-otlp = "0.31.0"
+opentelemetry-otlp = { version = "0.31.1", features = ["grpc-tonic"] }
 opentelemetry_sdk = "0.31.0"
 rmcp = { version = "1.2.0" }
 scc = "3.6.12"
 serde = "1.0.228"
 serde_json = "1.0.149"
+serde_yml = "0.0.12"
 tempfile = "3.27.0"
 thiserror = "2.0.18"
 tokio = "1.50.0"
 tokio-stream = "0.1.18"
 tokio-util = "0.7.18"
+toml = "1.1.0"
+tower = "0.5"
 tracing = "0.1.44"
-tracing-opentelemetry = "0.32.0"
+tracing-opentelemetry = "0.32.1"
 tracing-subscriber = "0.3.23"
+uuid = { version = "1.22.0", features = ["v4"] }
 
 # Enable pedantic lints for stricter code quality
 # Priority -1 so individual lint settings override

bin/bob-cli/Cargo.toml

@@ -26,9 +26,9 @@ eyre = { workspace = true }
 genai = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
-serde_yml = "0.0.12"
+serde_yml = { workspace = true }
 tokio = { workspace = true, features = ["io-std", "io-util"] }
-toml = "0.9.11"
+toml = { workspace = true }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
 
 [lints]

bin/bob-cli/src/bootstrap.rs

@@ -40,6 +40,7 @@ pub(crate) struct CliRuntimeHandles {
     pub tools: Arc<dyn bob_adapters::core::ports::ToolPort>,
     pub store: Arc<dyn bob_adapters::core::ports::SessionStore>,
     pub tape: Arc<dyn bob_adapters::core::ports::TapeStorePort>,
+    #[expect(dead_code)]
     pub skills_context: Option<SkillsRuntimeContext>,
 }
 

bin/bob-cli/src/main.rs

@@ -16,13 +16,13 @@ mod request_context;
 
 use std::path::{Path, PathBuf};
 
-use bob_runtime::agent_loop::{AgentLoop, AgentLoopOutput, help_text};
+use bob_runtime::{Agent, Session};
 use clap::{Parser, Subcommand};
 use eyre::WrapErr;
 
 use crate::{
-    bootstrap::{CliRuntimeHandles, SkillsRuntimeContext, build_runtime},
-    request_context::build_request_context,
+    bootstrap::{CliRuntimeHandles, build_runtime},
+    config::AgentConfig,
 };
 
 /// Bob CLI — a general-purpose AI agent framework CLI.
@@ -140,34 +140,51 @@ fn print_help() {
 CLI session commands:
   /help, /h             Show this help message
   /new, /reset          Start a new session context
-
-{}
-",
-        help_text()
+  /quit, /q             Exit the REPL
+
+Available slash commands:
+  /tools                List available tools
+  /tool <name>          Describe a specific tool
+  /tape search <query>  Search tape history
+  /tape info            Show tape statistics
+  /anchors              List tape anchors
+  /handoff [name]       Create handoff checkpoint
+  /usage                Show session token usage
+"
     );
 }
 
+/// Build an Agent from configuration.
+async fn build_agent(cfg: &AgentConfig) -> eyre::Result<Agent> {
+    let CliRuntimeHandles { runtime, tools, store, tape, skills_context: _ } =
+        build_runtime(cfg).await?;
+
+    let mut builder = Agent::from_runtime(runtime, tools).with_store(store).with_tape(tape);
+
+    // Load system prompt from workspace file if it exists
+    if let Ok(prompt) = std::fs::read_to_string(".agent/system-prompt.md") {
+        builder = builder.with_system_prompt(prompt);
+    }
+
+    Ok(builder.build())
+}
+
 /// Run the interactive REPL loop.
 #[expect(
     clippy::print_stdout,
     clippy::print_stderr,
     reason = "CLI REPL must use stdout/stderr for user interaction"
 )]
-async fn repl(
-    agent_loop: AgentLoop,
-    model: &str,
-    skills_context: Option<&SkillsRuntimeContext>,
-    policy: Option<&config::PolicyConfig>,
-) {
+async fn repl(mut session: Session, model: &str, cfg: &AgentConfig) {
     use tokio::io::{AsyncBufReadExt, BufReader};
 
     let stdin = BufReader::new(tokio::io::stdin());
     let mut lines = stdin.lines();
 
-    let mut session_seq: u64 = 1;
-    let mut session_id = format!("cli-session-{session_seq}");
+    let skills_context = bootstrap::build_skills_composer(cfg).ok().flatten();
 
     eprintln!("Bob agent ready  (model: {model})");
+    eprintln!("Session: {}", session.session_id());
     eprintln!("Type a message and press Enter. /help for commands.\n");
 
     loop {
@@ -195,31 +212,37 @@ async fn repl(
                     continue;
                 }
                 ReplCommand::NewSession => {
-                    session_seq = session_seq.saturating_add(1);
-                    session_id = format!("cli-session-{session_seq}");
-                    eprintln!("Started new session: {session_id}");
+                    session = session.new_session();
+                    eprintln!("Started new session: {}", session.session_id());
                     continue;
                 }
             }
         }
 
-        let context = build_request_context(&input, skills_context, policy);
-        match agent_loop.handle_input_with_context(&input, &session_id, context).await {
-            Ok(AgentLoopOutput::Response(bob_runtime::core::types::AgentRunResult::Finished(
-                resp,
-            ))) => {
-                println!("{}", resp.content);
-                println!(
-                    "\n[usage] prompt={} completion={} total={}",
-                    resp.usage.prompt_tokens,
-                    resp.usage.completion_tokens,
-                    resp.usage.total()
-                );
-            }
-            Ok(AgentLoopOutput::CommandOutput(output)) => {
-                println!("{output}");
+        // Build request context with skills if available
+        let context = request_context::build_request_context(
+            &input,
+            skills_context.as_ref(),
+            cfg.policy.as_ref(),
+        );
+
+        match session.chat_with_context(&input, context).await {
+            Ok(response) => {
+                if response.is_quit {
+                    break;
+                }
+                if !response.content.is_empty() {
+                    println!("{}", response.content);
+                }
+                if response.usage.total() > 0 {
+                    println!(
+                        "\n[usage] prompt={} completion={} total={}",
+                        response.usage.prompt_tokens,
+                        response.usage.completion_tokens,
+                        response.usage.total()
+                    );
+                }
             }
-            Ok(AgentLoopOutput::Quit) => break,
             Err(err) => {
                 eprintln!("Error: {err}");
             }
@@ -584,17 +607,11 @@ async fn main() -> eyre::Result<()> {
             let cfg = config::load_config(&cli.config)
                 .wrap_err_with(|| format!("failed to load config from '{}'", cli.config))?;
 
-            let CliRuntimeHandles { runtime, tools, store, tape, skills_context } =
-                build_runtime(&cfg).await?;
-            let agent_loop =
-                AgentLoop::new(runtime.clone(), tools.clone()).with_store(store).with_tape(tape);
-            repl(
-                agent_loop,
-                &cfg.runtime.default_model,
-                skills_context.as_ref(),
-                cfg.policy.as_ref(),
-            )
-            .await;
+            // Build agent using the new simplified API
+            let agent = build_agent(&cfg).await?;
+            let session = agent.start_session();
+
+            repl(session, &cfg.runtime.default_model, &cfg).await;
         }
         Commands::Skills(skills_cmd) => match skills_cmd {
             SkillsCommands::List {

crates/bob-adapters/Cargo.toml

@@ -24,13 +24,15 @@ mcp-rmcp = [
 observe-otel = [
     "dep:tracing",
     "dep:tracing-opentelemetry",
+    "dep:tracing-subscriber",
     "dep:opentelemetry",
     "dep:opentelemetry-otlp",
     "dep:opentelemetry_sdk",
 ]
 observe-tracing = ["dep:tracing"]
 skills-agent = ["dep:bob-skills"]
 store-memory = []
+tracing-subscriber = ["dep:tracing-subscriber"]
 
 [dependencies]
 async-trait = { workspace = true }
@@ -50,6 +52,7 @@ opentelemetry_sdk = { workspace = true, optional = true }
 rmcp = { workspace = true, optional = true }
 tracing = { workspace = true, optional = true }
 tracing-opentelemetry = { workspace = true, optional = true }
+tracing-subscriber = { workspace = true, optional = true }
 
 [dev-dependencies]
 tempfile = { workspace = true }

crates/bob-adapters/src/observe_otel.rs

@@ -27,12 +27,12 @@
 use std::sync::OnceLock;
 
 use bob_core::{ports::EventSink, types::AgentEvent};
-use opentelemetry::trace::SpanKind;
-use opentelemetry_otlp::SpanExporter;
+use opentelemetry::trace::{SpanKind, TracerProvider as _};
+use opentelemetry_otlp::{SpanExporter, WithExportConfig};
 use opentelemetry_sdk::{Resource, trace as sdktrace};
-use tracing_opentelemetry::OpenTelemetrySpanExt;
 
 /// Keeps the OTel pipeline alive. Drop this to shut down export.
+#[derive(Debug)]
 pub struct OtlpGuard {
     _tracer_provider: sdktrace::SdkTracerProvider,
 }
@@ -70,7 +70,8 @@ pub async fn init_otel(
     INSTALL.get_or_init(|| {
         // The subscriber must already be initialised; we just add the OTel layer.
         // If no subscriber is installed, this is a no-op.
-        let _otel_layer = tracing_opentelemetry::layer().with_tracer(tracer);
+        let _otel_layer =
+            tracing_opentelemetry::layer::<tracing_subscriber::Registry>().with_tracer(tracer);
         // NOTE: The caller is responsible for installing the tracing subscriber
         // and adding this layer. We expose the tracer provider so advanced
         // users can add the layer themselves.
@@ -197,6 +198,30 @@ impl EventSink for OtlpEventSink {
                     "agent error",
                 );
             }
+            AgentEvent::SubagentSpawned { parent_session_id, subagent_id, task } => {
+                tracing::info!(
+                    parent: &tracing::Span::current(),
+                    parent_session_id = %parent_session_id,
+                    subagent_id = %subagent_id,
+                    task = %task,
+                    "subagent spawned",
+                );
+            }
+            AgentEvent::SubagentCompleted { subagent_id, is_error } => {
+                if is_error {
+                    tracing::warn!(
+                        parent: &tracing::Span::current(),
+                        subagent_id = %subagent_id,
+                        "subagent completed with error",
+                    );
+                } else {
+                    tracing::info!(
+                        parent: &tracing::Span::current(),
+                        subagent_id = %subagent_id,
+                        "subagent completed",
+                    );
+                }
+            }
         }
     }
 }

crates/bob-adapters/src/provider_router.rs

@@ -269,14 +269,14 @@ mod tests {
     use super::*;
 
     struct MockLlm {
-        name: &'static str,
+        _name: &'static str,
         responses: Mutex<Vec<Result<LlmResponse, LlmError>>>,
     }
 
     impl MockLlm {
         fn succeeds(name: &'static str, content: &'static str) -> Self {
             Self {
-                name,
+                _name: name,
                 responses: Mutex::new(vec![Ok(LlmResponse {
                     content: content.into(),
                     usage: bob_core::types::TokenUsage::default(),
@@ -288,7 +288,7 @@ mod tests {
 
         fn always_fails(name: &'static str) -> Self {
             Self {
-                name,
+                _name: name,
                 responses: Mutex::new(vec![Err(LlmError::Provider(format!(
                     "{name}: simulated failure"
                 )))]),

crates/bob-chat/src/lib.rs

@@ -76,6 +76,7 @@ pub mod event;
 pub mod file;
 pub mod message;
 pub mod modal;
+pub mod state;
 pub mod stream;
 pub mod thread;
 
@@ -103,5 +104,6 @@ pub use message::{
 pub use modal::{
     ModalChild, ModalElement, RadioSelectElement, SelectElement, SelectOption, TextInputElement,
 };
+pub use state::AppState;
 pub use stream::{StreamOptions, TextStream, fallback_stream};
 pub use thread::ThreadHandle;