TOOL-519: Implement mock LLM client prototype and conversation state

Author: the-nick-fischer

application/apps/indexer/mcp/src/client/conversation.rs

@@ -0,0 +1,47 @@
+use rmcp::{
+    model::Content,
+    serde_json::{Map, Value},
+};
+
+pub enum ChatMessage {
+    SystemPrompt {
+        content: String,
+    },
+    Prompt {
+        content: String,
+    },
+    ToolResult {
+        content: Vec<Content>,
+    },
+    ToolCall {
+        tool_name: String,
+        arguments: Option<Map<String, Value>>,
+    },
+    FinalResponse {
+        content: String,
+    },
+}
+
+pub struct Conversation {
+    chat_messages: Vec<ChatMessage>,
+    // TODO: keep track of steps?
+    // TODO: conversation ID=?
+}
+
+impl Conversation {
+    pub fn new(system_prompt: String) -> Self {
+        Self {
+            chat_messages: vec![ChatMessage::SystemPrompt {
+                content: system_prompt,
+            }],
+        }
+    }
+
+    pub fn chat_messages(&self) -> &[ChatMessage] {
+        &self.chat_messages
+    }
+
+    pub fn add_chat_message(&mut self, message: ChatMessage) {
+        self.chat_messages.push(message);
+    }
+}

application/apps/indexer/mcp/src/client/llm.rs

@@ -0,0 +1,45 @@
+use std::time::Duration;
+
+use rmcp::serde_json::{self, Map, Value};
+use tokio::time::sleep;
+
+use super::{ClientToLlm, LlmToClient};
+use crate::{
+    client::conversation::{self, ChatMessage, Conversation},
+    types::McpError,
+};
+
+pub struct MockLlmClient;
+
+impl MockLlmClient {
+    pub async fn process(&self, conversation: &Conversation) -> Result<LlmToClient, McpError> {
+        match conversation.chat_messages().last() {
+            Some(ChatMessage::Prompt { content }) => {
+                // Simulate LLM latency
+                sleep(Duration::from_secs(5)).await;
+
+                Ok(LlmToClient::ToolCall {
+                    tool_name: "apply_filter".into(),
+                    arguments: serde_json::json!({
+                        "filter_type": "low_pass",
+                        "cutoff_frequency": 300,
+                    })
+                    .as_object()
+                    .cloned(),
+                })
+            }
+
+            Some(ChatMessage::ToolResult { content }) => {
+                // Simulate follow-up reasoning
+                sleep(Duration::from_secs(3)).await;
+
+                Ok(LlmToClient::FinalResponse {
+                    content: format!("Final LLM Answer: Tool result {:?}", content),
+                })
+            }
+            _ => Err(McpError::Generic {
+                message: "Mock LLM client received unsupported request".into(),
+            }),
+        }
+    }
+}

application/apps/indexer/mcp/src/client/llm/mock.rs

@@ -0,0 +1,52 @@
+use crate::{
+    client::conversation::{self, Conversation},
+    types::McpError,
+};
+use rmcp::serde_json::{Map, Value};
+
+pub mod mock;
+
+// Client messages sent to the LLM
+pub enum ClientToLlm {
+    SystemPrompt { content: String },
+    UserPrompt { content: String },
+    ToolResult { content: String },
+}
+
+// LLM messages sent to the client
+pub enum LlmToClient {
+    FinalResponse {
+        content: String,
+    },
+    ToolCall {
+        tool_name: String,
+        arguments: Option<Map<String, Value>>,
+    },
+}
+
+/// Configuration for creating an LLM client
+#[derive(Debug, Clone)]
+pub enum LlmConfig {
+    Mock,
+    // OpenAi { api_key: String, model: String },
+}
+
+/// The actual LLM client implementation - this is what you use
+pub enum Llm {
+    Mock(mock::MockLlmClient),
+    // OpenAi(openai::OpenAiClient),
+}
+
+impl Llm {
+    pub fn from_config(config: LlmConfig) -> Self {
+        match config {
+            LlmConfig::Mock => Llm::Mock(mock::MockLlmClient),
+        }
+    }
+
+    pub async fn process(&self, conversation: &Conversation) -> Result<LlmToClient, McpError> {
+        match self {
+            Llm::Mock(client) => client.process(conversation).await,
+        }
+    }
+}

application/apps/indexer/mcp/src/client/llm/mod.rs

@@ -4,19 +4,22 @@ use tokio::{select, sync::mpsc};
 
 use rmcp::{
     RoleClient,
-    model::{ClientInfo, Implementation, InitializeRequestParam},
+    model::{CallToolRequestParam, ClientInfo, Implementation, InitializeRequestParam},
+    serde_json::{Map, Value},
     service::{RunningService, ServiceExt},
     transport::StreamableHttpClientTransport,
 };
 
 use crate::{
     client::{
-        llm::LlmConfig,
+        conversation::{ChatMessage, Conversation},
+        llm::{ClientToLlm, Llm, LlmConfig, LlmToClient},
         messages::{McpChipmunkToClient, McpClientToChipmunk},
     },
     types::McpError,
 };
 
+pub mod conversation;
 pub mod llm;
 pub mod messages;
 
@@ -56,6 +59,7 @@ impl MCPClient {
     }
 
     pub async fn start(self) -> Result<(), McpError> {
+        // Setup MCP connection
         let transport =
             StreamableHttpClientTransport::from_uri("http:://localhost:8080/chipmunk_mcp");
 
@@ -71,7 +75,7 @@ impl MCPClient {
             },
         };
 
-        let mcp_service = client_info
+        let mcp_service: RunningService<RoleClient, InitializeRequestParam> = client_info
             .serve(transport)
             .await
             .map_err(|e| McpError::Generic {
@@ -80,15 +84,22 @@ impl MCPClient {
 
         warn!("Connected to MCP server: {:?}", mcp_service.peer_info());
 
-        let chipmunk_to_client_rx = self.chipmunk_to_client_rx;
-
         let tools = mcp_service.list_tools(Default::default()).await?;
+        warn!("Available tools: {:?}", tools);
 
+        let chipmunk_to_client_rx = self.chipmunk_to_client_rx;
         let chipmunk_response_tx = self.client_to_chipmunk_tx.clone();
 
+        let llm = Llm::from_config(self.llm_config);
+
         tokio::spawn(async move {
-            if let Err(e) =
-                MCPClient::run(chipmunk_to_client_rx, chipmunk_response_tx, mcp_service).await
+            if let Err(e) = MCPClient::run(
+                chipmunk_to_client_rx,
+                chipmunk_response_tx,
+                mcp_service,
+                llm,
+            )
+            .await
             {
                 error!("MCP client event loop ended: {:?}", e);
             }
@@ -99,29 +110,60 @@ impl MCPClient {
 
     pub async fn run(
         mut chipmunk_request_rx: mpsc::Receiver<McpChipmunkToClient>,
-        _chipmunk_response_tx: mpsc::Sender<McpClientToChipmunk>,
-        mcp_service: RunningService<RoleClient, InitializeRequestParam>,
+        chipmunk_response_tx: mpsc::Sender<McpClientToChipmunk>,
+        mut mcp_service: RunningService<RoleClient, InitializeRequestParam>,
+        llm: Llm,
     ) -> Result<(), McpError> {
-        let tools_result = mcp_service.list_tools(Default::default()).await;
-
-        loop {
-            select! {
-                Some(chipmunk_request) = chipmunk_request_rx.recv() => {
-                    match chipmunk_request {
-                        McpChipmunkToClient::Prompt { .. } => {
-                            // Send prompt to LLM via HTTP Client
-                            // Wait for response and handle:
-                            // match response {
-                            //  LlmMessage::ToolCall => {
-                            //      mcp_service.tool_call(...)
-                            //      }
-                            // }
+        let mut conversation = Conversation::new("You are a helpful assistant.".into());
+
+        select! {
+            Some(chipmunk_request) = chipmunk_request_rx.recv() => {
+                match chipmunk_request {
+                    McpChipmunkToClient::Prompt { prompt } => {
+                        conversation.add_chat_message(ChatMessage::Prompt { content: prompt.clone() });
+
+                        loop {
+                            let llm_response = llm.process(&conversation).await?;
+
+                            match llm_response {
+                                LlmToClient::ToolCall { tool_name, arguments } => {
+                                    let tool_call_param = CallToolRequestParam {
+                                        name: tool_name.clone().into(),
+                                        arguments: arguments.clone(),
+                                    };
+
+                                    let tool_result = mcp_service
+                                        .call_tool(tool_call_param)
+                                        .await
+                                        .map_err(|e| McpError::Generic {
+                                            message: e.to_string(),
+                                        })?;
+
+                                    conversation.add_chat_message(ChatMessage::ToolResult {
+                                        content: tool_result.content,
+                                    });
+
+                                    let _llm_response = llm.process(&conversation).await?;
+                                }
+
+                                LlmToClient::FinalResponse { content } => {
+                                    warn!("LLM final response: {:?}", content);
+                                    // 5. Send final response back to Chipmunk
+                                    // chipmunk_response_tx
+                                    //     .send(McpClientToChipmunk::FinalAnswer { content })
+                                    //     .await
+                                    //     .map_err(|_| McpError::ChannelClosed)?;
+
+                                    break;
+                                }
+                            }
                         }
                     }
                 }
-                else => break
             }
+            else => {}
         }
+
         Ok(())
     }
 }

application/apps/indexer/mcp/src/client/mod.rs

@@ -20,12 +20,9 @@ pub struct McpChannelEndpoints {
 }
 
 pub fn new() -> (McpServer, MCPClient, McpChannelEndpoints) {
-    let llm_config = LlmConfig::Dummy {
-        api_key: String::default(),
-        model: None,
-    };
+    let llm_config = LlmConfig::Mock {};
     let mcp_config = McpConfig {
-        url: String::from("http//:localhost:8080/chipmunk_mcp"),
+        url: String::from("http//:localhost:8181"),
     };
     let (mcp_client, chipmunk_to_client_tx, client_to_chipmunk_rx) =
         MCPClient::new(mcp_config, llm_config);