feat: update dependencies for bob-adapters, bob-core, bob-runtime, and tokio to version 1.50.0 in Cargo.toml

Author: Akagi201

Cargo.toml

@@ -11,9 +11,10 @@ resolver = "3"
 
 [workspace.dependencies]
 async-trait = "0.1.89"
-bob-adapters = "0.2.0"
-bob-core = "0.2.0"
-bob-runtime = "0.2.0"
+bob-adapters = "0.2.1"
+bob-chat = "0.2.1"
+bob-core = "0.2.1"
+bob-runtime = "0.2.1"
 clap = "4.5.60"
 config = "0.15.19"
 eyre = "0.6.12"
@@ -23,7 +24,7 @@ serde = "1.0.228"
 serde_json = "1.0.149"
 sqlite-vec = "0.1.6"
 thiserror = "2.0.18"
-tokio = "1.49.0"
+tokio = "1.50.0"
 tracing = "0.1.44"
 tracing-subscriber = "0.3.22"
 

bin/alice-cli/Cargo.toml

@@ -19,6 +19,7 @@ alice-adapters = { path = "../../crates/alice-adapters" }
 alice-core = { path = "../../crates/alice-core" }
 async-trait.workspace = true
 bob-adapters.workspace = true
+bob-chat.workspace = true
 bob-core.workspace = true
 bob-runtime.workspace = true
 parking_lot.workspace = true

bin/alice-cli/tests/alice_once_smoke.rs

@@ -5,28 +5,30 @@
 //! 2. The `AgentLoop` correctly routes natural language to the LLM.
 //! 3. Memory recall is injected and persisted across turns.
 //! 4. Skill composer integration works end-to-end.
-//! 5. Channel runner processes mock messages correctly.
+//! 5. ChatBot runner processes mock adapters correctly.
 //! 6. Full context with all components is accessible.
 
 use std::{collections::VecDeque, path::PathBuf, sync::Arc};
 
 use alice_adapters::memory::sqlite_store::SqliteMemoryStore;
 use alice_core::memory::{domain::HybridWeights, service::MemoryService};
 use alice_runtime::{
-    channel_runner::run_channels,
+    chatbot_runner::run_chatbot,
     config::{SkillSourceEntry, SkillsConfig},
     context::AliceRuntimeContext,
     handle_input::handle_input_with_skills,
     skill_wiring::build_skill_composer,
 };
 use async_trait::async_trait;
 use bob_adapters::tape_memory::InMemoryTapeStore;
-use bob_core::{
-    channel::{Channel, ChannelError, ChannelMessage, ChannelOutput},
-    error::AgentError,
-    ports::TapeStorePort,
-    types::*,
+use bob_chat::{
+    adapter::ChatAdapter,
+    card::CardElement,
+    error::ChatError,
+    event::ChatEvent,
+    message::{AdapterPostableMessage, Author, IncomingMessage, SentMessage},
 };
+use bob_core::{error::AgentError, ports::TapeStorePort, types::*};
 use bob_runtime::{
     AgentRuntime, NoOpToolPort,
     agent_loop::{AgentLoop, AgentLoopOutput},
@@ -64,31 +66,90 @@ impl AgentRuntime for StubRuntime {
 }
 
 // ---------------------------------------------------------------------------
-// Mock channel
+// Mock chat adapter
 // ---------------------------------------------------------------------------
 
-/// In-memory channel that feeds predetermined messages and collects responses.
-#[derive(Debug)]
-struct MockChannel {
-    messages: VecDeque<ChannelMessage>,
-    outputs: Arc<Mutex<Vec<ChannelOutput>>>,
+/// In-memory chat adapter that feeds predetermined events and collects posted messages.
+struct MockChatAdapter {
+    events: Mutex<VecDeque<ChatEvent>>,
+    posted: Arc<Mutex<Vec<String>>>,
+}
+
+impl std::fmt::Debug for MockChatAdapter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MockChatAdapter").finish_non_exhaustive()
+    }
 }
 
 #[async_trait]
-impl Channel for MockChannel {
-    async fn recv(&mut self) -> Option<ChannelMessage> {
-        self.messages.pop_front()
+impl ChatAdapter for MockChatAdapter {
+    #[expect(clippy::unnecessary_literal_bound)]
+    fn name(&self) -> &str {
+        "mock"
+    }
+
+    async fn recv_event(&mut self) -> Option<ChatEvent> {
+        self.events.lock().pop_front()
+    }
+
+    async fn post_message(
+        &self,
+        _thread_id: &str,
+        message: &AdapterPostableMessage,
+    ) -> Result<SentMessage, ChatError> {
+        let text = self.render_message(message);
+        self.posted.lock().push(text);
+        Ok(SentMessage {
+            id: "mock-sent".into(),
+            thread_id: "mock-thread".into(),
+            adapter_name: "mock".into(),
+            raw: None,
+        })
     }
 
-    async fn send(&self, output: ChannelOutput) -> Result<(), ChannelError> {
-        self.outputs.lock().push(output);
-        Ok(())
+    async fn edit_message(
+        &self,
+        _thread_id: &str,
+        _message_id: &str,
+        _message: &AdapterPostableMessage,
+    ) -> Result<SentMessage, ChatError> {
+        Err(ChatError::NotSupported("edit".into()))
+    }
+
+    async fn delete_message(&self, _thread_id: &str, _message_id: &str) -> Result<(), ChatError> {
+        Err(ChatError::NotSupported("delete".into()))
+    }
+
+    fn render_card(&self, _card: &CardElement) -> String {
+        String::new()
+    }
+
+    fn render_message(&self, message: &AdapterPostableMessage) -> String {
+        match message {
+            AdapterPostableMessage::Text(t) | AdapterPostableMessage::Markdown(t) => t.clone(),
+        }
     }
 }
 
-/// Create a `ChannelMessage` with default session and no sender.
-fn make_message(text: &str) -> ChannelMessage {
-    ChannelMessage { text: text.to_string(), session_id: "test-session".to_string(), sender: None }
+/// Create a `ChatEvent::Message` with default session and no sender.
+fn make_event(text: &str) -> ChatEvent {
+    ChatEvent::Message {
+        thread_id: "test-session".into(),
+        message: IncomingMessage {
+            id: "m1".into(),
+            text: text.to_string(),
+            author: Author {
+                user_id: "test-user".into(),
+                user_name: "tester".into(),
+                full_name: "Test User".into(),
+                is_bot: false,
+            },
+            attachments: vec![],
+            is_mention: false,
+            thread_id: "test-session".into(),
+            timestamp: None,
+        },
+    }
 }
 
 // ---------------------------------------------------------------------------
@@ -226,27 +287,30 @@ async fn cmd_run_with_skill_composer() {
     assert!(result.is_ok(), "cmd_run with skill composer should succeed");
 }
 
-/// Exercise `run_channels` with a `MockChannel` that provides two messages
+/// Exercise `run_chatbot` with a `MockChatAdapter` that provides two messages
 /// then returns `None` (EOF). Both messages should be processed and
 /// responses collected.
 #[tokio::test]
-async fn channel_runner_with_mock_channel() {
+async fn chatbot_runner_with_mock_adapter() {
     let Some(memory_service) = make_memory_service() else { return };
     let context = Arc::new(build_test_context(memory_service));
 
-    let outputs: Arc<Mutex<Vec<ChannelOutput>>> = Arc::new(Mutex::new(Vec::new()));
-    let channel = MockChannel {
-        messages: VecDeque::from(vec![make_message("hello agent"), make_message("second message")]),
-        outputs: Arc::clone(&outputs),
+    let posted: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
+    let adapter = MockChatAdapter {
+        events: Mutex::new(VecDeque::from(vec![
+            make_event("hello agent"),
+            make_event("second message"),
+        ])),
+        posted: Arc::clone(&posted),
     };
 
-    let channels: Vec<Box<dyn Channel>> = vec![Box::new(channel)];
-    let result = run_channels(context, channels).await;
-    assert!(result.is_ok(), "channel runner should complete without error");
+    let adapters: Vec<Box<dyn ChatAdapter>> = vec![Box::new(adapter)];
+    let result = run_chatbot(context, adapters).await;
+    assert!(result.is_ok(), "chatbot runner should complete without error");
 
-    let collected = outputs.lock();
+    let collected = posted.lock();
     assert_eq!(collected.len(), 2, "both messages should produce a response");
-    assert!(collected.iter().all(|o| !o.is_error), "no response should be an error");
+    assert!(collected.iter().all(|o| !o.is_empty()), "no response should be empty");
 }
 
 /// Build a context with all optional components populated and verify every

crates/alice-adapters/Cargo.toml

@@ -9,7 +9,7 @@ workspace = true
 [dependencies]
 alice-core = { path = "../alice-core" }
 async-trait.workspace = true
-bob-core.workspace = true
+bob-chat.workspace = true
 eyre = { workspace = true, optional = true }
 parking_lot.workspace = true
 rusqlite = { workspace = true, features = ["bundled"] }