llm_chain 0.5.4 → 0.5.5

data/lib/llm_chain/tools/tool_manager.rb

@@ -1,6 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/tool_manager'
+
 module LLMChain
   module Tools
-    class ToolManager
+    # ToolManager manages registration, selection, and execution of tools in LLMChain.
+    # Implements the LLMChain::Interfaces::ToolManager interface.
+    class ToolManager < Interfaces::ToolManager
       attr_reader :tools
 
       def initialize(tools: [])
@@ -9,9 +15,8 @@ module LLMChain
       end
 
       # Register a new tool instance.
-      #
       # @param tool [LLMChain::Tools::Base]
-      # @raise [ArgumentError] if object does not inherit from Tools::Base
+      # @return [void]
       def register_tool(tool)
         unless tool.is_a?(Base)
           raise ArgumentError, "Tool must inherit from LLMChain::Tools::Base"
@@ -20,38 +25,38 @@ module LLMChain
       end
 
       # Unregister a tool by name.
+      # @param name [String]
+      # @return [void]
       def unregister_tool(name)
         @tools.delete(name.to_s)
       end
 
       # Fetch a tool by its name.
+      # @param name [String]
+      # @return [LLMChain::Tools::Base, nil]
       def get_tool(name)
         @tools[name.to_s]
       end
 
-      # @return [Array<LLMChain::Tools::Base>] list of registered tools
+      # List all registered tools.
+      # @return [Array<LLMChain::Tools::Base>]
       def list_tools
         @tools.values
       end
 
-      # Build JSON schemas for all registered tools.
-      def get_tools_schema
-        @tools.values.map(&:to_schema)
-      end
-
-      # Find tools whose {Tools::Base#match?} returns `true` for the prompt.
+      # Find tools whose #match? returns true for the prompt.
+      # @param prompt [String]
+      # @return [Array<LLMChain::Tools::Base>]
       def find_matching_tools(prompt)
         @tools.values.select { |tool| tool.match?(prompt) }
       end
 
       # Execute every matching tool and collect results.
-      #
       # @param prompt [String]
       # @param context [Hash]
       # @return [Hash] mapping tool name → result hash
       def execute_tools(prompt, context: {})
         matching_tools = find_matching_tools(prompt)
-        
         results = {}
         matching_tools.each do |tool|
           begin
@@ -69,108 +74,45 @@ module LLMChain
             }
           end
         end
-
         results
       end
 
-      # Execute a single tool by name.
-      #
-      # @param name [String]
-      # @param prompt [String]
-      # @param context [Hash]
-      # @return [Hash] result wrapper
-      def execute_tool(name, prompt, context: {})
-        tool = get_tool(name)
-        raise ArgumentError, "Tool '#{name}' not found" unless tool
-
-        begin
-          result = tool.call(prompt, context: context)
-          {
-            success: true,
-            result: result,
-            formatted: tool.format_result(result)
-          }
-        rescue => e
-          {
-            success: false,
-            error: e.message,
-            formatted: "Error in #{name}: #{e.message}"
-          }
-        end
-      end
-
-      # Create default toolset (Calculator, WebSearch, CodeInterpreter, DateTime).
-      def self.create_default_toolset
-        tools = [
-          Calculator.new,
-          WebSearch.new,
-          CodeInterpreter.new,
-          DateTime.new
-        ]
-        
-        new(tools: tools)
-      end
-
-      # Build toolset from a config array.
-      def self.from_config(config)
-        tools = []
-        
-        config.each do |tool_config|
-          tool_class = tool_config[:class] || tool_config['class']
-          tool_options = tool_config[:options] || tool_config['options'] || {}
-          
-          case tool_class.to_s.downcase
-          when 'calculator'
-            tools << Calculator.new
-          when 'web_search', 'websearch'
-            tools << WebSearch.new(**tool_options)
-          when 'code_interpreter', 'codeinterpreter'
-            tools << CodeInterpreter.new(**tool_options)
-          else
-            raise ArgumentError, "Unknown tool class: #{tool_class}"
-          end
-        end
-        
-        new(tools: tools)
-      end
-
       # Format tool execution results for inclusion into an LLM prompt.
+      # @param results [Hash]
+      # @return [String]
       def format_tool_results(results)
         return "" if results.empty?
-
         formatted_results = results.map do |tool_name, result|
           "#{tool_name}: #{result[:formatted]}"
         end
-
         "Tool Results:\n#{formatted_results.join("\n\n")}"
       end
 
       # Human-readable list of available tools.
+      # @return [String]
       def tools_description
         descriptions = @tools.values.map do |tool|
           "- #{tool.name}: #{tool.description}"
         end
-
         "Available tools:\n#{descriptions.join("\n")}"
       end
 
       # Determine if prompt likely needs tool usage.
+      # @param prompt [String]
+      # @return [Boolean]
       def needs_tools?(prompt)
-        # Check for explicit tool usage requests
         return true if prompt.match?(/\b(use tool|call tool|execute|calculate|search|run code)\b/i)
-        
-        # Check if there are any matching tools
         find_matching_tools(prompt).any?
       end
 
       # Auto-select and execute best tools for prompt.
+      # @param prompt [String]
+      # @param context [Hash]
+      # @return [Hash]
       def auto_execute(prompt, context: {})
         return {} unless needs_tools?(prompt)
-        
-        # Limit the number of tools executed at once
         matching_tools = find_matching_tools(prompt)
         selected_tools = select_best_tools(matching_tools, prompt)
-        
         results = {}
         selected_tools.each do |tool|
           begin
@@ -188,15 +130,19 @@ module LLMChain
             }
           end
         end
-
         results
       end
 
+      # Build JSON schemas for all registered tools.
+      # @return [Array<Hash>]
+      def get_tools_schema
+        @tools.values.map(&:to_schema)
+      end
+
       private
 
       # Simple heuristic to rank matching tools.
-        def select_best_tools(tools, prompt, limit: 3)
-          # Simple prioritization logic
+      def select_best_tools(tools, prompt, limit: 3)
         prioritized = tools.sort_by do |tool|
           case tool.name
           when 'calculator'
@@ -209,7 +155,6 @@ module LLMChain
             1
           end
         end
-
         prioritized.first(limit)
       end
     end

data/lib/llm_chain/tools/tool_manager_factory.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module LLMChain
+  module Tools
+    # Factory for creating ToolManager instances with default or custom toolsets.
+    module ToolManagerFactory
+      # Create a ToolManager with the default set of tools.
+      # @return [ToolManager]
+      def self.create_default_toolset
+        tools = [
+          Calculator.new,
+          WebSearch.new,
+          CodeInterpreter.new,
+          DateTime.new
+        ]
+        ToolManager.new(tools: tools)
+      end
+
+      # Create a ToolManager from a config array.
+      # @param config [Array<Hash>] tool config hashes
+      # @return [ToolManager]
+      def self.from_config(config)
+        tools = []
+        config.each do |tool_config|
+          tool_class = tool_config[:class] || tool_config['class']
+          tool_options = tool_config[:options] || tool_config['options'] || {}
+          case tool_class.to_s.downcase
+          when 'calculator'
+            tools << Calculator.new
+          when 'web_search', 'websearch'
+            tools << WebSearch.new(**tool_options)
+          when 'code_interpreter', 'codeinterpreter'
+            tools << CodeInterpreter.new(**tool_options)
+          when 'date_time', 'datetime'
+            tools << DateTime.new
+          else
+            raise ArgumentError, "Unknown tool class: #{tool_class}"
+          end
+        end
+        ToolManager.new(tools: tools)
+      end
+    end
+  end
+end