Merge pull request #1288 from dcSpark/feature/add-previously-used-tools

Add previously used tools to tool selection.

Author: guillevalin

shinkai-bin/shinkai-node/src/llm_provider/execution/chains/generic_chain/generic_inference_chain.rs

@@ -14,6 +14,7 @@ use crate::network::agent_payments_manager::external_agent_offerings_manager::Ex
 use crate::network::agent_payments_manager::my_agent_offerings_manager::MyAgentOfferingsManager;
 use shinkai_fs::shinkai_file_manager::ShinkaiFileManager;
 use shinkai_message_primitives::schemas::tool_router_key::ToolRouterKey;
+use shinkai_message_primitives::shinkai_message::shinkai_message::ShinkaiMessage;
 
 use crate::utils::environment::{fetch_node_environment, NodeEnvironment};
 use async_trait::async_trait;
@@ -770,6 +771,44 @@ impl GenericInferenceChain {
                                 )));
                             }
                         }
+
+                        // Append tools from conversation history to provide contextual continuity
+                        let historical_tool_keys = Self::extract_tools_from_conversation_history(&full_job.step_history, 5);
+                        for tool_key in historical_tool_keys {
+                            // Check if this tool is not already in our tools list to avoid duplicates
+                            let tool_already_exists = tools.iter().any(|existing_tool| {
+                                existing_tool.tool_router_key().to_string_without_version() == tool_key
+                            });
+
+                            if !tool_already_exists {
+                                match tool_router.get_tool_by_name(&tool_key).await {
+                                    Ok(Some(tool)) => {
+                                        tools.push(tool);
+                                        shinkai_log(
+                                            ShinkaiLogOption::JobExecution,
+                                            ShinkaiLogLevel::Debug,
+                                            &format!("Added historical tool from conversation: {}", tool_key),
+                                        );
+                                    }
+                                    Ok(None) => {
+                                        // Tool not found - this is okay, it might have been removed
+                                        shinkai_log(
+                                            ShinkaiLogOption::JobExecution,
+                                            ShinkaiLogLevel::Debug,
+                                            &format!("Historical tool not found (may have been removed): {}", tool_key),
+                                        );
+                                    }
+                                    Err(e) => {
+                                        // Log error but don't fail the whole process
+                                        shinkai_log(
+                                            ShinkaiLogOption::JobExecution,
+                                            ShinkaiLogLevel::Debug,
+                                            &format!("Error retrieving historical tool {}: {:?}", tool_key, e),
+                                        );
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -1407,4 +1446,49 @@ impl GenericInferenceChain {
 
         Ok(additional_files)
     }
+
+    /// Extract tool router keys from conversation history
+    /// Returns a list of unique tool router keys that were used in the last N messages
+    fn extract_tools_from_conversation_history(
+        step_history: &[ShinkaiMessage],
+        max_messages: usize
+    ) -> Vec<String> {
+        let mut tool_keys = Vec::new();
+        let mut seen_keys = std::collections::HashSet::new();
+        let mut message_count = 0;
+        
+        for msg in step_history.iter().rev() {
+            if message_count >= max_messages {
+                break;
+            }
+            
+            if let Ok(content) = msg.get_message_content() {
+                if content.trim().is_empty() {
+                    message_count += 1;
+                    continue;
+                }
+
+                // Parse the JSON content to extract tool calls from metadata
+                if let Ok(job_message) = serde_json::from_str::<serde_json::Value>(&content) {
+                    if let Some(metadata) = job_message.get("metadata") {
+                        if let Some(function_calls) = metadata.get("function_calls").and_then(|fc| fc.as_array()) {
+                            for call in function_calls {
+                                if let Some(tool_router_key) = call.get("tool_router_key").and_then(|k| k.as_str()) {
+                                    // Only add if we haven't seen this key before
+                                    if !seen_keys.contains(tool_router_key) {
+                                        seen_keys.insert(tool_router_key.to_string());
+                                        tool_keys.push(tool_router_key.to_string());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            
+            message_count += 1;
+        }
+        
+        tool_keys
+    }
 }

shinkai-bin/shinkai-node/src/llm_provider/providers/grok.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use super::super::error::LLMProviderError;
 use super::shared::openai_api::openai_prepare_messages;
-use super::shared::openai_api_deprecated::{MessageContent, OpenAIResponse};
+use super::shared::openai_api::{MessageContent, OpenAIResponse};
 use super::shared::shared_model_logic::{send_tool_ws_update, send_ws_update};
 use super::LLMService;
 use crate::llm_provider::execution::chains::inference_chain_trait::{FunctionCall, LLMInferenceResponse};
@@ -228,12 +228,12 @@ async fn handle_streaming_response(
             }
 
             // If we got valid JSON but expected streaming, return the response anyway
-            if let Ok(data) = serde_json::from_value::<super::shared::openai_api_deprecated::OpenAIResponse>(response_json.clone()) {
+            if let Ok(data) = serde_json::from_value::<OpenAIResponse>(response_json.clone()) {
                 let response_string: String = data
                     .choices
                     .iter()
                     .filter_map(|choice| match &choice.message.content {
-                        Some(super::shared::openai_api_deprecated::MessageContent::Text(text)) => Some(text.clone()),
+                        Some(MessageContent::Text(text)) => Some(text.clone()),
                         _ => None,
                     })
                     .collect::<Vec<String>>()

shinkai-bin/shinkai-node/src/llm_provider/providers/groq.rs

@@ -2,7 +2,7 @@ use std::error::Error;
 use std::sync::Arc;
 
 use super::super::error::LLMProviderError;
-use super::shared::openai_api_deprecated::{MessageContent, OpenAIResponse};
+use super::shared::openai_api::{MessageContent, OpenAIResponse};
 use super::shared::shared_model_logic::{send_tool_ws_update, send_ws_update};
 use super::LLMService;
 use crate::llm_provider::execution::chains::inference_chain_trait::{FunctionCall, LLMInferenceResponse};

shinkai-bin/shinkai-node/src/llm_provider/providers/shared/deepseek_api.rs

@@ -3,9 +3,10 @@
 
 use crate::llm_provider::error::LLMProviderError;
 use crate::llm_provider::providers::shared::openai_api;
-use crate::managers::model_capabilities_manager::{PromptResult, PromptResultEnum};
+use crate::managers::model_capabilities_manager::{ModelCapabilitiesManager, PromptResult, PromptResultEnum};
 use shinkai_message_primitives::schemas::llm_providers::serialized_llm_provider::LLMProviderInterface;
 use shinkai_message_primitives::schemas::prompts::Prompt;
+use shinkai_message_primitives::schemas::subprompts::{SubPrompt, SubPromptType};
 
 // DeepSeek is compatible with the OpenAI API, so we reuse its message
 // preparation and response handling logic.
@@ -17,6 +18,17 @@ pub fn deepseek_prepare_messages(
     prompt: Prompt,
     session_id: String,
 ) -> Result<PromptResult, LLMProviderError> {
+    let mut prompt = prompt.clone();
+
+    // If this is a reasoning model, filter out system prompts before any processing
+    if ModelCapabilitiesManager::has_reasoning_capabilities(model) {
+        prompt.sub_prompts.retain(|sp| match sp {
+            SubPrompt::Content(SubPromptType::System, _, _) => false,
+            SubPrompt::Omni(SubPromptType::System, _, _, _) => false,
+            _ => true,
+        });
+    }
+
     let result = openai_api::openai_prepare_messages(model, prompt)?;
     let tools_json = result.functions.unwrap_or_else(Vec::new);
     let messages_json = result.messages.clone();

shinkai-bin/shinkai-node/src/llm_provider/providers/shared/mod.rs

@@ -4,6 +4,5 @@ pub mod gemini_api;
 pub mod groq_api;
 pub mod ollama_api;
 pub mod openai_api;
-pub mod openai_api_deprecated;
 pub mod shared_model_logic;
 pub mod togetherai;

shinkai-bin/shinkai-node/src/llm_provider/providers/shared/openai_api.rs

@@ -110,17 +110,6 @@ pub struct Usage {
 }
 
 pub fn openai_prepare_messages(model: &LLMProviderInterface, prompt: Prompt) -> Result<PromptResult, LLMProviderError> {
-    let mut prompt = prompt.clone();
-
-    // If this is a reasoning model, filter out system prompts before any processing
-    if ModelCapabilitiesManager::has_reasoning_capabilities(model) {
-        prompt.sub_prompts.retain(|sp| match sp {
-            SubPrompt::Content(SubPromptType::System, _, _) => false,
-            SubPrompt::Omni(SubPromptType::System, _, _, _) => false,
-            _ => true,
-        });
-    }
-
     let max_input_tokens = ModelCapabilitiesManager::get_max_input_tokens(model);
 
     // Generate the messages and filter out images
@@ -645,7 +634,8 @@ mod tests {
         let model = SerializedLLMProvider::mock_provider_with_reasoning().model;
 
         // Process the prompt
-        let result = openai_prepare_messages(&model, prompt).expect("Failed to prepare messages");
+        let session_id = uuid::Uuid::new_v4().to_string();
+        let result = crate::llm_provider::providers::shared::deepseek_api::deepseek_prepare_messages(&model, prompt, session_id).expect("Failed to prepare messages");
 
         // Extract the messages from the result
         let messages = match &result.messages {