robot_lab 0.0.1 → 0.0.6

data/lib/robot_lab/adapters/registry.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module Adapters
-    # Registry for looking up provider adapters
-    #
-    # Maps provider symbols to their adapter classes.
-    #
-    # @example
-    #   adapter = Registry.for(:anthropic)
-    #   adapter.format_messages(messages)
-    #
-    module Registry
-      # @return [Hash<Symbol, Class>] mapping of provider symbols to adapter classes
-      ADAPTERS = {
-        anthropic: Anthropic,
-        openai: OpenAI,
-        gemini: Gemini,
-        # Azure uses OpenAI adapter
-        azure_openai: OpenAI,
-        # Grok uses OpenAI adapter
-        grok: OpenAI,
-        # Ollama uses OpenAI adapter
-        ollama: OpenAI,
-        # OpenRouter uses OpenAI adapter
-        openrouter: OpenAI,
-        # Bedrock uses Anthropic adapter
-        bedrock: Anthropic,
-        # VertexAI uses Gemini adapter
-        vertexai: Gemini
-      }.freeze
-
-      class << self
-        # Get adapter for a provider
-        #
-        # @param provider [Symbol, String] Provider name
-        # @return [Base] Adapter instance
-        # @raise [ArgumentError] If provider not found
-        #
-        def for(provider)
-          provider_sym = provider.to_s.downcase.gsub("-", "_").to_sym
-          adapter_class = ADAPTERS[provider_sym]
-
-          unless adapter_class
-            raise ArgumentError, "Unknown provider: #{provider}. " \
-                                 "Available providers: #{available.join(', ')}"
-          end
-
-          adapter_class.new
-        end
-
-        # List available providers
-        #
-        # @return [Array<Symbol>]
-        #
-        def available
-          ADAPTERS.keys
-        end
-
-        # Check if provider is supported
-        #
-        # @param provider [Symbol, String]
-        # @return [Boolean]
-        #
-        def supports?(provider)
-          provider_sym = provider.to_s.downcase.gsub("-", "_").to_sym
-          ADAPTERS.key?(provider_sym)
-        end
-
-        # Register a custom adapter
-        #
-        # @param provider [Symbol] Provider name
-        # @param adapter_class [Class] Adapter class
-        #
-        def register(provider, adapter_class)
-          ADAPTERS[provider.to_sym] = adapter_class
-        end
-      end
-    end
-  end
-end

data/lib/robot_lab/configuration.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  # Global configuration for RobotLab
-  #
-  # @example
-  #   RobotLab.configure do |config|
-  #     config.default_provider = :anthropic
-  #     config.default_model = "claude-sonnet-4"
-  #     config.template_path = "app/prompts"
-  #     config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
-  #
-  #     # Global MCP servers available to all networks and robots
-  #     config.mcp = [
-  #       { name: "github", transport: { type: "stdio", command: "github-mcp" } }
-  #     ]
-  #
-  #     # Global tools whitelist (only these tools are available)
-  #     config.tools = %w[search_code create_issue]
-  #   end
-  #
-  class Configuration
-    # @!attribute [rw] default_provider
-    #   @return [Symbol] the default LLM provider (defaults to :anthropic)
-    # @!attribute [rw] default_model
-    #   @return [String] the default model to use (defaults to "claude-sonnet-4")
-    # @!attribute [rw] max_iterations
-    #   @return [Integer] maximum robot iterations per network run (defaults to 10)
-    # @!attribute [rw] max_tool_iterations
-    #   @return [Integer] maximum tool iterations per robot run (defaults to 10)
-    # @!attribute [rw] streaming_enabled
-    #   @return [Boolean] whether streaming is enabled by default (defaults to true)
-    # @!attribute [rw] logger
-    #   @return [Logger] the logger instance
-    # @!attribute [rw] mcp
-    #   @return [Symbol, Array] global MCP server configuration (:none, :inherit, or array)
-    # @!attribute [rw] tools
-    #   @return [Symbol, Array] global tools whitelist (:none, :inherit, or array)
-    attr_accessor :default_provider,
-                  :default_model,
-                  :max_iterations,
-                  :max_tool_iterations,
-                  :streaming_enabled,
-                  :logger,
-                  :mcp,
-                  :tools
-
-    # Creates a new Configuration with default values.
-    def initialize
-      @default_provider = :anthropic
-      @default_model = "claude-sonnet-4"
-      @max_iterations = 10
-      @max_tool_iterations = 10
-      @streaming_enabled = true
-      @logger = default_logger
-      @template_path = nil
-      @mcp = :none
-      @tools = :none
-    end
-
-    # Sets the Anthropic API key.
-    #
-    # @param key [String] the API key
-    # @return [void]
-    def anthropic_api_key=(key)
-      RubyLLM.configure { |c| c.anthropic_api_key = key }
-    end
-
-    # Sets the OpenAI API key.
-    #
-    # @param key [String] the API key
-    # @return [void]
-    def openai_api_key=(key)
-      RubyLLM.configure { |c| c.openai_api_key = key }
-    end
-
-    # Sets the Google Gemini API key.
-    #
-    # @param key [String] the API key
-    # @return [void]
-    def gemini_api_key=(key)
-      RubyLLM.configure { |c| c.gemini_api_key = key }
-    end
-
-    # Sets the AWS Bedrock API key.
-    #
-    # @param key [String] the API key
-    # @return [void]
-    def bedrock_api_key=(key)
-      RubyLLM.configure { |c| c.bedrock_api_key = key }
-    end
-
-    # Sets the OpenRouter API key.
-    #
-    # @param key [String] the API key
-    # @return [void]
-    def openrouter_api_key=(key)
-      RubyLLM.configure { |c| c.openrouter_api_key = key }
-    end
-
-    # Set the template path and configure ruby_llm-template
-    #
-    # @param path [String] Path to the templates directory
-    #
-    def template_path=(path)
-      @template_path = path
-      configure_template_library if path
-    end
-
-    # Returns the template path.
-    #
-    # @return [String] the configured template path or default
-    def template_path
-      @template_path || default_template_path
-    end
-
-    private
-
-    def configure_template_library
-      require "ruby_llm/template"
-      RubyLLM::Template.configure do |config|
-        config.template_directory = @template_path
-      end
-    end
-
-    def default_template_path
-      if defined?(Rails) && Rails.root
-        Rails.root.join("app", "prompts").to_s
-      else
-        "prompts"
-      end
-    end
-
-    def default_logger
-      if defined?(Rails) && Rails.respond_to?(:logger)
-        Rails.logger
-      else
-        require "logger"
-        Logger.new($stdout, level: Logger::INFO)
-      end
-    end
-  end
-end

data/lib/robot_lab/errors.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  # Error serialization utilities
-  #
-  # Provides methods to serialize Ruby exceptions into a format
-  # suitable for tool results and logging.
-  #
-  module Errors
-    class << self
-      # Serialize an exception to a hash
-      #
-      # @param error [Exception] The error to serialize
-      # @param include_backtrace [Boolean] Whether to include backtrace
-      # @return [Hash] Serialized error
-      #
-      def serialize(error, include_backtrace: false)
-        result = {
-          type: error.class.name,
-          message: error.message
-        }
-
-        if include_backtrace && error.backtrace
-          result[:backtrace] = error.backtrace.first(10)
-        end
-
-        if error.cause
-          result[:cause] = serialize(error.cause, include_backtrace: include_backtrace)
-        end
-
-        result
-      end
-
-      # Deserialize an error hash back to an exception
-      #
-      # @param hash [Hash] Serialized error
-      # @return [StandardError]
-      #
-      def deserialize(hash)
-        hash = hash.transform_keys(&:to_sym)
-        klass = begin
-          Object.const_get(hash[:type])
-        rescue NameError
-          StandardError
-        end
-        klass.new(hash[:message])
-      end
-
-      # Format error for display
-      #
-      # @param error [Exception] The error
-      # @return [String]
-      #
-      def format(error)
-        "[#{error.class.name}] #{error.message}"
-      end
-
-      # Wrap a block and return error hash on failure
-      #
-      # @yield Block to execute
-      # @return [Hash] { data: result } or { error: serialized_error }
-      #
-      def capture
-        { data: yield }
-      rescue StandardError => e
-        { error: serialize(e) }
-      end
-    end
-  end
-end

data/lib/robot_lab/history/active_record_adapter.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module History
-    # ActiveRecord-based history persistence adapter
-    #
-    # Provides thread and result storage using ActiveRecord models.
-    # Requires Rails or standalone ActiveRecord setup.
-    #
-    # @example
-    #   adapter = ActiveRecordAdapter.new(
-    #     thread_model: RobotLabThread,
-    #     result_model: RobotLabResult
-    #   )
-    #
-    #   config = adapter.to_config
-    #   network = RobotLab.create_network(history: config)
-    #
-    class ActiveRecordAdapter
-      # @!attribute [r] thread_model
-      #   @return [Class] ActiveRecord model class for threads
-      # @!attribute [r] result_model
-      #   @return [Class] ActiveRecord model class for results
-      attr_reader :thread_model, :result_model
-
-      # Initialize adapter with ActiveRecord models
-      #
-      # @param thread_model [Class] ActiveRecord model for threads
-      # @param result_model [Class] ActiveRecord model for results
-      #
-      def initialize(thread_model:, result_model:)
-        @thread_model = thread_model
-        @result_model = result_model
-      end
-
-      # Create a new thread
-      #
-      # @param state [State] Current state
-      # @param input [String, UserMessage] Initial input
-      # @return [Hash] Thread ID and metadata
-      #
-      def create_thread(state:, input:, **)
-        input_content = input.is_a?(UserMessage) ? input.content : input.to_s
-        input_metadata = input.is_a?(UserMessage) ? input.metadata : {}
-
-        thread = @thread_model.create!(
-          session_id: SecureRandom.uuid,
-          initial_input: input_content,
-          input_metadata: input_metadata,
-          state_data: state.data.to_h
-        )
-
-        { session_id: thread.session_id, created_at: thread.created_at }
-      end
-
-      # Retrieve results for a thread
-      #
-      # @param session_id [String] Thread identifier
-      # @return [Array<RobotResult>] History of results
-      #
-      def get(session_id:, **)
-        @result_model
-          .where(session_id: session_id)
-          .order(:sequence_number, :created_at)
-          .map { |record| deserialize_result(record) }
-      end
-
-      # Append user message to thread
-      #
-      # @param session_id [String] Thread identifier
-      # @param message [UserMessage] Message to append
-      #
-      def append_user_message(session_id:, message:, **)
-        @thread_model.where(session_id: session_id).update_all(
-          last_user_message: message.content,
-          last_user_message_at: Time.current
-        )
-      end
-
-      # Append results to thread
-      #
-      # @param session_id [String] Thread identifier
-      # @param new_results [Array<RobotResult>] Results to append
-      #
-      def append_results(session_id:, new_results:, **)
-        base_sequence = @result_model.where(session_id: session_id).maximum(:sequence_number) || 0
-
-        new_results.each_with_index do |result, index|
-          @result_model.create!(
-            session_id: session_id,
-            robot_name: result.robot_name,
-            sequence_number: base_sequence + index + 1,
-            output_data: serialize_messages(result.output),
-            tool_calls_data: serialize_messages(result.tool_calls),
-            stop_reason: result.stop_reason,
-            checksum: result.checksum
-          )
-        end
-
-        # Update thread timestamp
-        @thread_model.where(session_id: session_id).update_all(
-          updated_at: Time.current
-        )
-      end
-
-      # Convert adapter to Config object
-      #
-      # @return [Config] History configuration
-      #
-      def to_config
-        Config.new(
-          create_thread: method(:create_thread),
-          get: method(:get),
-          append_user_message: method(:append_user_message),
-          append_results: method(:append_results)
-        )
-      end
-
-      private
-
-      def serialize_messages(messages)
-        messages.map(&:to_h)
-      end
-
-      def deserialize_result(record)
-        output = deserialize_messages(record.output_data)
-        tool_calls = deserialize_messages(record.tool_calls_data)
-
-        RobotResult.new(
-          robot_name: record.robot_name,
-          output: output,
-          tool_calls: tool_calls,
-          stop_reason: record.stop_reason
-        )
-      end
-
-      def deserialize_messages(data)
-        return [] unless data
-
-        data.map do |msg_hash|
-          Message.from_hash(msg_hash.symbolize_keys)
-        end
-      end
-    end
-  end
-end

data/lib/robot_lab/history/config.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module History
-    # Configuration for conversation history persistence
-    #
-    # Defines callbacks for creating threads, retrieving history,
-    # and appending messages/results.
-    #
-    # @example
-    #   config = History::Config.new(
-    #     create_thread: ->(state:, input:, **) {
-    #       { session_id: SecureRandom.uuid }
-    #     },
-    #     get: ->(session_id:, **) {
-    #       database.find_results(session_id)
-    #     },
-    #     append_results: ->(session_id:, new_results:, **) {
-    #       database.insert_results(session_id, new_results)
-    #     }
-    #   )
-    #
-    class Config
-      # @!attribute [rw] create_thread
-      #   @return [Proc, nil] callback to create a new conversation thread
-      # @!attribute [rw] get
-      #   @return [Proc, nil] callback to retrieve history for a thread
-      # @!attribute [rw] append_user_message
-      #   @return [Proc, nil] callback to append user messages
-      # @!attribute [rw] append_results
-      #   @return [Proc, nil] callback to append robot results
-      attr_accessor :create_thread, :get, :append_user_message, :append_results
-
-      # Initialize history configuration
-      #
-      # @param create_thread [Proc] Callback to create a new thread
-      # @param get [Proc] Callback to retrieve history for a thread
-      # @param append_user_message [Proc] Callback to append user messages
-      # @param append_results [Proc] Callback to append robot results
-      #
-      def initialize(create_thread: nil, get: nil, append_user_message: nil, append_results: nil)
-        @create_thread = create_thread
-        @get = get
-        @append_user_message = append_user_message
-        @append_results = append_results
-      end
-
-      # Check if history persistence is configured
-      #
-      # @return [Boolean]
-      #
-      def configured?
-        @create_thread && @get
-      end
-
-      # Create a new conversation thread
-      #
-      # @param state [State] Current state
-      # @param input [String, UserMessage] Initial input
-      # @param kwargs [Hash] Additional arguments
-      # @return [Hash] Must include :session_id
-      #
-      def create_thread!(state:, input:, **kwargs)
-        raise HistoryError, "create_thread callback not configured" unless @create_thread
-
-        result = @create_thread.call(state: state, input: input, **kwargs)
-
-        unless result.is_a?(Hash) && result[:session_id]
-          raise HistoryError, "create_thread must return a hash with :session_id"
-        end
-
-        result
-      end
-
-      # Retrieve history for a thread
-      #
-      # @param session_id [String] Thread identifier
-      # @param kwargs [Hash] Additional arguments
-      # @return [Array<RobotResult>] History of results
-      #
-      def get!(session_id:, **kwargs)
-        raise HistoryError, "get callback not configured" unless @get
-
-        @get.call(session_id: session_id, **kwargs)
-      end
-
-      # Append a user message to the thread
-      #
-      # @param session_id [String] Thread identifier
-      # @param message [UserMessage] Message to append
-      # @param kwargs [Hash] Additional arguments
-      #
-      def append_user_message!(session_id:, message:, **kwargs)
-        return unless @append_user_message
-
-        @append_user_message.call(session_id: session_id, message: message, **kwargs)
-      end
-
-      # Append robot results to the thread
-      #
-      # @param session_id [String] Thread identifier
-      # @param new_results [Array<RobotResult>] Results to append
-      # @param kwargs [Hash] Additional arguments
-      #
-      def append_results!(session_id:, new_results:, **kwargs)
-        return unless @append_results
-
-        @append_results.call(session_id: session_id, new_results: new_results, **kwargs)
-      end
-    end
-
-    # Error raised when history operations fail
-    class HistoryError < RobotLab::Error; end
-  end
-end

data/lib/robot_lab/history/thread_manager.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module History
-    # Manages conversation thread lifecycle
-    #
-    # Handles thread creation, history retrieval, and result persistence
-    # using the configured history adapter.
-    #
-    # @example
-    #   manager = ThreadManager.new(config)
-    #   session_id = manager.create_thread(state: state, input: "Hello")
-    #   history = manager.get_history(session_id)
-    #
-    class ThreadManager
-      # @!attribute [r] config
-      #   @return [Config] the history configuration
-      attr_reader :config
-
-      # Initialize thread manager
-      #
-      # @param config [Config] History configuration
-      #
-      def initialize(config)
-        @config = config
-      end
-
-      # Create a new conversation thread
-      #
-      # @param state [State] Current state
-      # @param input [String, UserMessage] Initial input
-      # @return [String] Thread ID
-      #
-      def create_thread(state:, input:)
-        result = @config.create_thread!(state: state, input: input)
-        result[:session_id]
-      end
-
-      # Get history for a thread
-      #
-      # @param session_id [String] Thread identifier
-      # @return [Array<RobotResult>] History of results
-      #
-      def get_history(session_id)
-        @config.get!(session_id: session_id)
-      end
-
-      # Append user message to thread
-      #
-      # @param session_id [String] Thread identifier
-      # @param message [UserMessage] Message to append
-      #
-      def append_user_message(session_id:, message:)
-        @config.append_user_message!(session_id: session_id, message: message)
-      end
-
-      # Append results to thread
-      #
-      # @param session_id [String] Thread identifier
-      # @param results [Array<RobotResult>] Results to append
-      #
-      def append_results(session_id:, results:)
-        @config.append_results!(session_id: session_id, new_results: results)
-      end
-
-      # Load state from thread history
-      #
-      # @param session_id [String] Thread identifier
-      # @param state [State, Memory] State/Memory to populate
-      # @return [State, Memory] State/Memory with loaded history
-      #
-      def load_state(session_id:, state:)
-        results = get_history(session_id)
-
-        state.session_id = session_id
-        results.each { |r| state.append_result(r) }
-
-        state
-      end
-
-      # Save state results to thread
-      #
-      # @param session_id [String] Thread identifier
-      # @param state [State] State with results to save
-      # @param since_index [Integer] Save results from this index
-      #
-      def save_state(session_id:, state:, since_index: 0)
-        new_results = state.results[since_index..]
-        append_results(session_id: session_id, results: new_results) if new_results.any?
-      end
-    end
-  end
-end