robot_lab 0.0.4 → 0.0.6

data/lib/robot_lab/adapters/gemini.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module Adapters
-    # Adapter for Google Gemini models
-    #
-    # Handles Gemini-specific API conventions:
-    # - Role mapping (assistant -> model)
-    # - Contents/parts array structure
-    # - functionCall/functionResponse format
-    #
-    class Gemini < Base
-      # Creates a new Gemini adapter instance.
-      def initialize
-        super(:gemini)
-      end
-
-      # Format messages for Gemini API
-      #
-      # Gemini uses "model" role instead of "assistant" and structures
-      # content as parts arrays.
-      #
-      # @param messages [Array<Message>]
-      # @return [Array<Hash>]
-      #
-      def format_messages(messages)
-        # Gemini handles system messages differently - as system_instruction
-        conversation_messages(messages).map { |msg| format_single_message(msg) }
-      end
-
-      # Parse Gemini response into internal messages
-      #
-      # @param response [RubyLLM::Response]
-      # @return [Array<Message>]
-      #
-      def parse_response(response)
-        messages = []
-
-        # Handle text content
-        if response.content && !response.content.empty?
-          messages << TextMessage.new(
-            role: "assistant",
-            content: response.content,
-            stop_reason: response.tool_calls&.any? ? "tool" : "stop"
-          )
-        end
-
-        # Handle function calls
-        if response.tool_calls&.any?
-          tool_messages = response.tool_calls.map do |id, tool_call|
-            ToolMessage.new(
-              id: id,
-              name: tool_call.name,
-              input: parse_tool_arguments(tool_call.arguments)
-            )
-          end
-
-          messages << ToolCallMessage.new(
-            role: "assistant",
-            tools: tool_messages,
-            stop_reason: "tool"
-          )
-        end
-
-        messages
-      end
-
-      # Format tools for Gemini function declarations
-      #
-      # Gemini doesn't support additionalProperties in schemas
-      #
-      # @param tools [Array<Tool>]
-      # @return [Array<Hash>]
-      #
-      def format_tools(tools)
-        tools.map do |tool|
-          schema = tool.to_json_schema
-          params = clean_schema_for_gemini(schema[:parameters] || { type: "object", properties: {} })
-          {
-            name: schema[:name],
-            description: schema[:description],
-            parameters: params
-          }
-        end
-      end
-
-      # Gemini tool choice format
-      #
-      # @param choice [String, Symbol]
-      # @return [Hash]
-      #
-      def format_tool_choice(choice)
-        case choice.to_s
-        when "auto" then { mode: "AUTO" }
-        when "any" then { mode: "ANY" }
-        when "none" then { mode: "NONE" }
-        else { mode: "ANY", allowed_function_names: [choice.to_s] }
-        end
-      end
-
-      private
-
-      def format_single_message(msg)
-        role = gemini_role(msg.role)
-
-        case msg
-        when TextMessage
-          {
-            role: role,
-            parts: [{ text: msg.content }]
-          }
-        when ToolCallMessage
-          {
-            role: "model",
-            parts: msg.tools.map do |tool|
-              {
-                functionCall: {
-                  name: tool.name,
-                  args: tool.input
-                }
-              }
-            end
-          }
-        when ToolResultMessage
-          {
-            role: "user",
-            parts: [
-              {
-                functionResponse: {
-                  name: msg.tool.name,
-                  response: format_tool_result_content(msg.content)
-                }
-              }
-            ]
-          }
-        else
-          { role: role, parts: [{ text: msg.content.to_s }] }
-        end
-      end
-
-      def gemini_role(role)
-        case role.to_s
-        when "assistant" then "model"
-        when "system" then "user"  # Gemini handles system as system_instruction
-        else role.to_s
-        end
-      end
-
-      def format_tool_result_content(content)
-        case content
-        when Hash
-          content
-        when String
-          { result: content }
-        else
-          { result: content.to_s }
-        end
-      end
-
-      def parse_tool_arguments(arguments)
-        case arguments
-        when String
-          begin
-            JSON.parse(arguments, symbolize_names: true)
-          rescue JSON::ParserError
-            { raw: arguments }
-          end
-        when Hash
-          arguments.transform_keys(&:to_sym)
-        else
-          arguments || {}
-        end
-      end
-
-      # Remove additionalProperties which Gemini doesn't support
-      def clean_schema_for_gemini(schema)
-        return schema unless schema.is_a?(Hash)
-
-        cleaned = schema.dup
-        cleaned.delete(:additionalProperties)
-        cleaned.delete("additionalProperties")
-
-        if cleaned[:properties]
-          cleaned[:properties] = cleaned[:properties].transform_values do |prop|
-            clean_schema_for_gemini(prop)
-          end
-        end
-
-        cleaned
-      end
-    end
-  end
-end

data/lib/robot_lab/adapters/openai.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module Adapters
-    # Adapter for OpenAI GPT models
-    #
-    # Handles OpenAI-specific API conventions:
-    # - Function calling format
-    # - Strict mode for structured outputs
-    # - finish_reason to stop_reason mapping
-    #
-    class OpenAI < Base
-      # Creates a new OpenAI adapter instance.
-      def initialize
-        super(:openai)
-      end
-
-      # Format messages for OpenAI API
-      #
-      # @param messages [Array<Message>]
-      # @return [Array<Hash>]
-      #
-      def format_messages(messages)
-        messages.map { |msg| format_single_message(msg) }
-      end
-
-      # Parse OpenAI response into internal messages
-      #
-      # @param response [RubyLLM::Response]
-      # @return [Array<Message>]
-      #
-      def parse_response(response)
-        messages = []
-
-        # Handle text content
-        if response.content && !response.content.empty?
-          messages << TextMessage.new(
-            role: "assistant",
-            content: response.content,
-            stop_reason: response.tool_calls&.any? ? "tool" : "stop"
-          )
-        end
-
-        # Handle tool calls
-        if response.tool_calls&.any?
-          tool_messages = response.tool_calls.map do |id, tool_call|
-            ToolMessage.new(
-              id: id,
-              name: tool_call.name,
-              input: parse_tool_arguments(tool_call.arguments)
-            )
-          end
-
-          messages << ToolCallMessage.new(
-            role: "assistant",
-            tools: tool_messages,
-            stop_reason: "tool"
-          )
-        end
-
-        messages
-      end
-
-      # Format tools for OpenAI function calling
-      #
-      # @param tools [Array<Tool>]
-      # @return [Array<Hash>]
-      #
-      def format_tools(tools)
-        tools.map do |tool|
-          schema = tool.to_json_schema
-          strict = tool.provider_params[:strict]
-          {
-            type: "function",
-            function: {
-              name: schema[:name],
-              description: schema[:description],
-              parameters: schema[:parameters] || { type: "object", properties: {} },
-              strict: strict.nil? ? true : strict
-            }.compact
-          }
-        end
-      end
-
-      # OpenAI tool choice format
-      #
-      # @param choice [String, Symbol]
-      # @return [String, Hash]
-      #
-      def format_tool_choice(choice)
-        case choice.to_s
-        when "auto" then "auto"
-        when "any" then "required"
-        when "none" then "none"
-        else { type: "function", function: { name: choice.to_s } }
-        end
-      end
-
-      private
-
-      def format_single_message(msg)
-        case msg
-        when TextMessage
-          { role: msg.role, content: msg.content }
-        when ToolCallMessage
-          {
-            role: "assistant",
-            content: nil,
-            tool_calls: msg.tools.map do |tool|
-              {
-                id: tool.id,
-                type: "function",
-                function: {
-                  name: tool.name,
-                  arguments: JSON.generate(tool.input)
-                }
-              }
-            end
-          }
-        when ToolResultMessage
-          {
-            role: "tool",
-            tool_call_id: msg.tool.id,
-            content: format_tool_result_content(msg.content)
-          }
-        else
-          { role: msg.role, content: msg.content.to_s }
-        end
-      end
-
-      def format_tool_result_content(content)
-        case content
-        when Hash
-          JSON.generate(content)
-        when String
-          content
-        else
-          content.to_s
-        end
-      end
-
-      def parse_tool_arguments(arguments)
-        case arguments
-        when String
-          # Handle OpenAI's backtick wrapping quirk
-          cleaned = arguments.gsub(/\A```(?:json)?\n?/, "").gsub(/\n?```\z/, "")
-          begin
-            JSON.parse(cleaned, symbolize_names: true)
-          rescue JSON::ParserError
-            { raw: arguments }
-          end
-        when Hash
-          arguments.transform_keys(&:to_sym)
-        else
-          arguments || {}
-        end
-      end
-    end
-  end
-end

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/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