robot_lab 0.0.1 → 0.0.6

data/examples/prompts/product_support/user.txt.erb

@@ -1,32 +0,0 @@
-Customer <%= customer[:name] %> asks: <%= message %>
-
-## Relevant Products
-<% if products&.any? %>
-<% products.each do |product| %>
-### <%= product[:name] %>
-- SKU: <%= product[:sku] %>
-- Price: $<%= product[:price] %>
-- Category: <%= product[:category] %>
-- In Stock: <%= product[:in_stock] ? "Yes (#{product[:quantity]} available)" : "No" %>
-<% if product[:features]&.any? %>
-- Features:
-<% product[:features].each do |feature| %>
-  - <%= feature %>
-<% end %>
-<% end %>
-<% if product[:compatible_with]&.any? %>
-- Compatible With: <%= product[:compatible_with].join(", ") %>
-<% end %>
-<% end %>
-<% else %>
-No specific products matched the query. Provide general guidance.
-<% end %>
-
-<% if promotions&.any? %>
-## Current Promotions
-<% promotions.each do |promo| %>
-- **<%= promo[:name] %>**: <%= promo[:description] %> (Code: <%= promo[:code] %>)
-<% end %>
-<% end %>
-
-Please help the customer with their product question.

data/examples/prompts/sentiment_analyzer/user.txt.erb

@@ -1,3 +0,0 @@
-Analyze the sentiment of this text:
-
-<%= message %>

data/examples/prompts/synthesizer/user.txt.erb

@@ -1,15 +0,0 @@
-Please synthesize these analysis results into a comprehensive summary:
-
-## Original Text
-<%= message %>
-
-## Sentiment Analysis
-<%= sentiment %>
-
-## Entities Found
-<%= entities %>
-
-## Keywords & Topics
-<%= keywords %>
-
-Provide a unified analysis combining all these perspectives.

data/examples/prompts/technical/user.txt.erb

@@ -1 +0,0 @@
-<%= message %>

data/examples/prompts/triage/user.txt.erb

@@ -1,17 +0,0 @@
-Customer Message: <%= message %>
-
-<% if customer && customer[:recent_orders]&.any? %>
-Recent Order Activity:
-<% customer[:recent_orders].each do |order| %>
-- Order #<%= order[:id] %> (<%= order[:date] %>): <%= order[:status] %> - $<%= order[:total] %>
-<% end %>
-<% end %>
-
-<% if customer && customer[:open_tickets]&.any? %>
-Open Support Tickets:
-<% customer[:open_tickets].each do |ticket| %>
-- Ticket #<%= ticket[:id] %>: <%= ticket[:subject] %> (<%= ticket[:status] %>)
-<% end %>
-<% end %>
-
-Please classify this request.

data/lib/robot_lab/adapters/anthropic.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module Adapters
-    # Adapter for Anthropic Claude models
-    #
-    # Handles Anthropic-specific API conventions:
-    # - System message as top-level parameter (not in messages array)
-    # - Tool use/result format differences
-    # - Content block structure
-    #
-    class Anthropic < Base
-      # Creates a new Anthropic adapter instance.
-      def initialize
-        super(:anthropic)
-      end
-
-      # Format messages for Anthropic API
-      #
-      # Anthropic requires system message at top level, not in messages array.
-      # Also handles tool_use and tool_result message formats.
-      #
-      # @param messages [Array<Message>]
-      # @return [Array<Hash>]
-      #
-      def format_messages(messages)
-        conversation_messages(messages).map do |msg|
-          format_single_message(msg)
-        end
-      end
-
-      # Parse Anthropic response into internal messages
-      #
-      # @param response [RubyLLM::Response] ruby_llm response object
-      # @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 Anthropic
-      #
-      # @param tools [Array<Tool>]
-      # @return [Array<Hash>]
-      #
-      def format_tools(tools)
-        tools.map do |tool|
-          schema = tool.to_json_schema
-          {
-            name: schema[:name],
-            description: schema[:description],
-            input_schema: schema[:parameters] || { type: "object", properties: {} }
-          }
-        end
-      end
-
-      # Anthropic tool choice format
-      #
-      # @param choice [String, Symbol]
-      # @return [Hash]
-      #
-      def format_tool_choice(choice)
-        case choice.to_s
-        when "auto" then { type: "auto" }
-        when "any" then { type: "any" }
-        else { type: "tool", 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: msg.tools.map do |tool|
-              {
-                type: "tool_use",
-                id: tool.id,
-                name: tool.name,
-                input: tool.input
-              }
-            end
-          }
-        when ToolResultMessage
-          {
-            role: "user",
-            content: [
-              {
-                type: "tool_result",
-                tool_use_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
-          if content[:error]
-            JSON.generate(content)
-          elsif content[:data]
-            content[:data].is_a?(String) ? content[:data] : JSON.generate(content[:data])
-          else
-            JSON.generate(content)
-          end
-        else
-          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
-    end
-  end
-end

data/lib/robot_lab/adapters/base.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module RobotLab
-  module Adapters
-    # Base adapter interface for LLM providers
-    #
-    # Adapters handle provider-specific message formatting and response parsing.
-    # Each provider (Anthropic, OpenAI, Gemini) has different API conventions
-    # that the adapter normalizes.
-    #
-    # @abstract Subclass and implement {#format_messages} and {#parse_response}
-    #
-    class Base
-      # @!attribute [r] provider
-      #   @return [Symbol] the provider name
-      attr_reader :provider
-
-      # Creates a new adapter instance.
-      #
-      # @param provider [Symbol] the provider name
-      def initialize(provider)
-        @provider = provider
-      end
-
-      # Format internal messages for the provider's API
-      #
-      # @param messages [Array<Message>] Internal message format
-      # @return [Array<Hash>] Provider-specific message format
-      #
-      def format_messages(messages)
-        raise NotImplementedError, "#{self.class}#format_messages must be implemented"
-      end
-
-      # Parse provider response into internal message format
-      #
-      # @param response [Object] Provider-specific response
-      # @return [Array<Message>] Internal message format
-      #
-      def parse_response(response)
-        raise NotImplementedError, "#{self.class}#parse_response must be implemented"
-      end
-
-      # Format tools for the provider's function calling API
-      #
-      # @param tools [Array<Tool>] Internal tool definitions
-      # @return [Array<Hash>] Provider-specific tool format
-      #
-      def format_tools(tools)
-        tools.map(&:to_json_schema)
-      end
-
-      # Format tool choice for the provider
-      #
-      # @param choice [String, Symbol] "auto", "any", or specific tool name
-      # @return [Object] Provider-specific tool choice
-      #
-      def format_tool_choice(choice)
-        case choice.to_s
-        when "auto" then "auto"
-        when "any" then "required"
-        else { type: "function", function: { name: choice.to_s } }
-        end
-      end
-
-      # Extract system message from messages array
-      #
-      # @param messages [Array<Message>]
-      # @return [String, nil]
-      #
-      def extract_system_message(messages)
-        system_msg = messages.find(&:system?)
-        system_msg&.content
-      end
-
-      # Filter out system messages
-      #
-      # @param messages [Array<Message>]
-      # @return [Array<Message>]
-      #
-      def conversation_messages(messages)
-        messages.reject(&:system?)
-      end
-    end
-  end
-end

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,159 +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
-          {
-            type: "function",
-            function: {
-              name: schema[:name],
-              description: schema[:description],
-              parameters: schema[:parameters] || { type: "object", properties: {} },
-              strict: tool.strict.nil? ? true : tool.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