llm_gateway 0.2.0 → 0.4.0

data/lib/llm_gateway/adapters/claude/client.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../base_client"
-
-module LlmGateway
-  module Adapters
-    module Claude
-      class Client < BaseClient
-        def initialize(model_key: "claude-3-7-sonnet-20250219", api_key: ENV["ANTHROPIC_API_KEY"])
-          @base_endpoint = "https://api.anthropic.com/v1"
-          super(model_key: model_key, api_key: api_key)
-        end
-
-        def chat(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-          body = {
-            model: model_key,
-            max_tokens: max_completion_tokens,
-            messages: messages
-          }
-
-          body.merge!(tools: tools) if LlmGateway::Utils.present?(tools)
-          body.merge!(system: system) if LlmGateway::Utils.present?(system)
-
-          post("messages", body)
-        end
-
-        def download_file(file_id)
-          get("files/#{file_id}/content")
-        end
-
-        private
-
-        def build_headers
-          {
-            "anthropic-version" => "2023-06-01",
-            "content-type" => "application/json",
-            "x-api-key" => api_key,
-            "anthropic-beta" => "code-execution-2025-05-22,files-api-2025-04-14"
-          }
-        end
-
-        def handle_client_specific_errors(response, error)
-          case response.code.to_i
-          when 400
-            if error["message"]&.start_with?("prompt is too long")
-              raise Errors::PromptTooLong.new(error["message"], error["type"])
-            end
-          end
-
-          # If we get here, we didn't handle it specifically
-          raise Errors::APIStatusError.new(error["message"], error["type"])
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/claude/output_mapper.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module Claude
-      class OutputMapper
-        def self.map(data)
-          {
-            id: data[:id],
-            model: data[:model],
-            usage: data[:usage],
-            choices: map_choices(data)
-          }
-        end
-
-        private
-
-        def self.map_choices(data)
-          # Claude returns content directly at root level, not in a choices array
-          # We need to construct the choices array from the full response data
-          [ {
-            content: data[:content] || [], # Use content directly from Claude response
-            finish_reason: data[:stop_reason],
-            role: "assistant"
-          } ]
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/groq/client.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../base_client"
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class Client < BaseClient
-        def initialize(model_key: "gemma2-9b-it", api_key: ENV["GROQ_API_KEY"])
-          @base_endpoint = "https://api.groq.com/openai/v1"
-          super(model_key: model_key, api_key: api_key)
-        end
-
-        def chat(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-          body = {
-            model: model_key,
-            messages: system + messages,
-            temperature: 0,
-            max_completion_tokens: max_completion_tokens,
-            response_format: response_format,
-            tools: tools
-          }
-
-          post("chat/completions", body)
-        end
-
-        private
-
-        def build_headers
-          {
-            "content-type" => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          }
-        end
-
-        def handle_client_specific_errors(response, error)
-          # Groq likely uses 'code' like OpenAI since it's OpenAI-compatible
-          error_code = error["code"]
-
-          case response.code.to_i
-
-          when 413
-            if error["message"]&.start_with?("Request too large")
-              raise Errors::PromptTooLong.new(error["message"], error["type"])
-            end
-          when 429
-            raise Errors::RateLimitError.new(error["type"], error_code) if error_code == "rate_limit_exceeded"
-
-            raise Errors::OverloadError.new(error["message"], error_code)
-          end
-
-          # If we get here, we didn't handle it specifically
-          raise Errors::APIStatusError.new(error["message"], error_code)
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/groq/input_mapper.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class InputMapper
-        def self.map(data)
-          {
-            messages: map_messages(data[:messages]),
-            response_format: map_response_format(data[:response_format]),
-            tools: map_tools(data[:tools]),
-            system: map_system(data[:system])
-          }
-        end
-
-        private
-
-        def self.map_system(system)
-          system
-        end
-
-        def self.map_response_format(response_format)
-          response_format
-        end
-
-        def self.map_messages(messages)
-          return messages unless messages
-
-          messages.flat_map do |msg|
-            if msg[:content].is_a?(Array)
-              # Handle array content with tool calls and tool results
-              tool_calls = []
-              regular_content = []
-              tool_messages = []
-
-              msg[:content].each do |content|
-                case content[:type]
-                when "tool_result"
-                  tool_messages << map_tool_result_message(content)
-                when "tool_use"
-                  tool_calls << map_tool_usage(content)
-                else
-                  regular_content << content
-                end
-              end
-
-              result = []
-
-              # Add the main message with tool calls if any
-              if tool_calls.any? || regular_content.any?
-                main_msg = msg.dup
-                main_msg[:role] = "assistant" if !main_msg[:role]
-                main_msg[:tool_calls] = tool_calls if tool_calls.any?
-                main_msg[:content] = regular_content.any? ? regular_content : nil
-                result << main_msg
-              end
-
-              # Add separate tool result messages
-              result += tool_messages
-
-              result
-            else
-              # Regular message, return as-is
-              [ msg ]
-            end
-          end
-        end
-
-        def self.map_tools(tools)
-          return tools unless tools
-
-          tools.map do |tool|
-            {
-              type: "function",
-              function: {
-                name: tool[:name],
-                description: tool[:description],
-                parameters: tool[:input_schema]
-              }
-            }
-          end
-        end
-
-        def self.map_tool_usage(content)
-            {
-              'id': content[:id],
-              'type': "function",
-              'function': {
-                'name': content[:name],
-                'arguments': content[:input].to_json
-              }
-            }
-        end
-
-        def self.map_tool_result_message(content)
-          {
-            role: "tool",
-            tool_call_id: content[:tool_use_id],
-            content: content[:content]
-          }
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/groq/output_mapper.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module Groq
-      class OutputMapper
-        def self.map(data)
-          {
-            id: data[:id],
-            model: data[:model],
-            usage: data[:usage],
-            choices: map_choices(data[:choices])
-          }
-        end
-
-        private
-
-        def self.map_choices(choices)
-          return [] unless choices
-
-          choices.map do |choice|
-            message = choice[:message] || {}
-            content_item = map_content_item(message)
-            tool_calls = map_tool_calls(message[:tool_calls])
-
-            # Only include content_item if it has actual text content
-            content_array = []
-            content_array << content_item if LlmGateway::Utils.present?(content_item[:text])
-            content_array += tool_calls
-
-            { content: content_array }
-          end
-        end
-
-        def self.map_content_item(message)
-          {
-            text: message[:content],
-            type: "text"
-          }
-        end
-
-        def self.map_tool_calls(tool_calls)
-          return [] unless tool_calls
-
-          tool_calls.map do |tool_call|
-            {
-              id: tool_call[:id],
-              type: "tool_use",
-              name: tool_call.dig(:function, :name),
-              input: parse_tool_arguments(tool_call.dig(:function, :arguments))
-            }
-          end
-        end
-
-        def self.parse_tool_arguments(arguments)
-          return arguments unless arguments.is_a?(String)
-          JSON.parse(arguments, symbolize_names: true)
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/open_ai/client.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../base_client"
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      class Client < BaseClient
-        def initialize(model_key: "gpt-4o", api_key: ENV["OPENAI_API_KEY"])
-          @base_endpoint = "https://api.openai.com/v1"
-          super(model_key: model_key, api_key: api_key)
-        end
-
-        def chat(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-          body = {
-            model: model_key,
-            messages: system + messages,
-            max_completion_tokens: max_completion_tokens
-          }
-          body[:tools] = tools if tools
-
-          post("chat/completions", body)
-        end
-
-        def generate_embeddings(input)
-          body = {
-            input:,
-            model: model_key
-          }
-          post("embeddings", body)
-        end
-
-        private
-
-        def build_headers
-          {
-            "content-type" => "application/json",
-            "Authorization" => "Bearer #{api_key}"
-          }
-        end
-
-        def handle_client_specific_errors(response, error)
-          # OpenAI uses 'code' instead of 'type' for error codes
-          error_code = error["code"]
-
-          case response.code.to_i
-          when 429
-            raise Errors::RateLimitError.new(error["message"], error_code)
-          when 503
-            raise Errors::OverloadError.new(error["message"], error_code)
-          end
-
-          # If we get here, we didn't handle it specifically
-          raise Errors::APIStatusError.new(error["message"], error_code)
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/open_ai/input_mapper.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      class InputMapper < LlmGateway::Adapters::Groq::InputMapper
-        def self.map(data)
-          {
-            messages: map_messages(data[:messages]),
-            response_format: map_response_format(data[:response_format]),
-            tools: map_tools(data[:tools]),
-            system: map_system(data[:system])
-          }
-        end
-
-        private
-
-        def self.map_messages(messages)
-          return messages unless messages
-
-          # First, handle file transformations
-          messages_with_files = messages.map do |msg|
-            if msg[:content].is_a?(Array)
-              content = msg[:content].map do |content|
-                if content[:type] == "file"
-                  # Map text/plain to application/pdf for OpenAI
-                  media_type = content[:media_type] == "text/plain" ? "application/pdf" : content[:media_type]
-                  {
-                    type: "file",
-                    file: {
-                      filename: content[:name],
-                      file_data: "data:#{media_type};base64,#{Base64.encode64(content[:data])}"
-                    }
-                  }
-                else
-                  content
-                end
-              end
-              msg.merge(content: content)
-            else
-              msg
-            end
-          end
-
-          # Then apply parent's tool transformation logic
-          super(messages_with_files)
-        end
-
-        def self.map_system(system)
-          if !system || system.empty?
-            []
-          else
-            system.map do |msg|
-              msg[:role] == "system" ? msg.merge(role: "developer") : msg
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/sample/claude_code_clone/agent.rb

@@ -1,65 +0,0 @@
-class Agent
-  def initialize(prompt_class, model, api_key)
-    @prompt_class = prompt_class
-    @model = model
-    @api_key = api_key
-    @transcript = []
-  end
-
-  def run(user_input, &block)
-    @transcript << { role: 'user', content: [ { type: 'text', text: user_input } ] }
-
-    begin
-      prompt = @prompt_class.new(@model, @transcript, @api_key)
-      result = prompt.post
-      process_response(result[:choices][0][:content], &block)
-    rescue => e
-      yield({ type: 'error', message: e.message }) if block_given?
-      raise e
-    end
-  end
-
-  private
-
-  def process_response(response, &block)
-    @transcript << { role: 'assistant', content: response }
-
-    response.each do |message|
-      yield(message) if block_given?
-
-      if message[:type] == 'text'
-        # Text response processed
-      elsif message[:type] == 'tool_use'
-        result = handle_tool_use(message)
-
-        tool_result = {
-          type: 'tool_result',
-          tool_use_id: message[:id],
-          content: result
-        }
-        @transcript << { role: 'user', content: [ tool_result ] }
-
-        yield(tool_result) if block_given?
-
-        follow_up_prompt = @prompt_class.new(@model, @transcript, @api_key)
-        follow_up = follow_up_prompt.post
-
-        process_response(follow_up[:choices][0][:content], &block) if follow_up[:choices][0][:content]
-      end
-    end
-
-    response
-  end
-
-  def handle_tool_use(message)
-    tool_class = @prompt_class.find_tool(message[:name])
-    if tool_class
-      tool = tool_class.new
-      tool.execute(message[:input])
-    else
-      "Unknown tool: #{message[:name]}"
-    end
-  rescue StandardError => e
-    "Error executing tool: #{e.message}"
-  end
-end

data/sample/claude_code_clone/claude_code_clone.rb

@@ -1,40 +0,0 @@
-require_relative 'prompt'
-require_relative 'agent'
-require 'debug'
-
-# Bash File Search Assistant using LlmGateway architecture
-
-class ClaudeCloneClone
-  def initialize(model, api_key)
-    @agent = Agent.new(Prompt, model, api_key)
-  end
-
-  def query(input)
-    begin
-      @agent.run(input) do |message|
-        case message[:type]
-        when 'text'
-          puts "\n\e[32m•\e[0m #{message[:text]}"
-        when 'tool_use'
-          puts "\n\e[33m•\e[0m \e[36m#{message[:name]}\e[0m"
-          if message[:input] && !message[:input].empty?
-            puts "  \e[90m#{message[:input]}\e[0m"
-          end
-        when 'tool_result'
-          if message[:content] && !message[:content].empty?
-            content_preview = message[:content].to_s.split("\n").first(3).join("\n")
-            if content_preview.length > 100
-              content_preview = content_preview[0..97] + "..."
-            end
-            puts "  \e[90m#{content_preview}\e[0m"
-          end
-        when 'error'
-          puts "\n\e[31m•\e[0m \e[91mError: #{message[:message]}\e[0m"
-        end
-      end
-    rescue => e
-      puts "\n\e[31m•\e[0m \e[91mError: #{e.message}\e[0m"
-      puts "\e[90m  #{e.backtrace.first}\e[0m" if e.backtrace&.first
-    end
-  end
-end

data/sample/claude_code_clone/prompt.rb

@@ -1,79 +0,0 @@
-require_relative 'tools/edit_tool'
-require_relative 'tools/read_tool'
-require_relative 'tools/todowrite_tool'
-require_relative 'tools/bash_tool'
-require_relative 'tools/grep_tool'
-
-class Prompt < LlmGateway::Prompt
-  def initialize(model, transcript, api_key)
-    super(model)
-    @transcript = transcript
-    @api_key = api_key
-  end
-
-  def prompt
-    @transcript
-  end
-
-  def system_prompt
-    <<~SYSTEM
-      You are Claude Code Clone, an interactive CLI tool that assists with software engineering tasks.
-
-      # Core Capabilities
-
-      I provide assistance with:
-      - Code analysis and debugging
-      - Feature implementation
-      - File editing and creation
-      - Running tests and builds
-      - Git operations
-      - Web browsing and research
-      - Task planning and management
-
-      ## Available Tools
-
-      You have access to these specialized tools:
-      - `Edit` - Modify existing files by replacing specific text strings
-      - `Read` - Read file contents with optional pagination
-      - `TodoWrite` - Create and manage structured task lists
-      - `Bash` - Execute shell commands with timeout support
-      - `Grep` - Search for patterns in files using regex
-
-      ## Core Instructions
-
-      I am designed to:
-      - Be concise and direct (minimize output tokens)
-      - Follow existing code conventions and patterns
-      - Use defensive security practices only
-      - Plan tasks with the TodoWrite tool for complex work
-      - Run linting/typechecking after making changes
-      - Never commit unless explicitly asked
-
-      ## Process
-
-      1. **Understand the Request**: Parse what the user needs accomplished
-      2. **Plan if Complex**: Use TodoWrite for multi-step tasks
-      3. **Execute Tools**: Use appropriate tools to complete the work
-      4. **Validate**: Run tests/linting when applicable
-      5. **Report**: Provide concise status updates
-
-      Always use the available tools to perform actions rather than just suggesting commands.
-
-      Before starting any task, build a todo list of what you need to do, ensuring each item is actionable and prioritized. Then, execute the tasks one by one, using the TodoWrite tool to track progress and completion.
-
-      After completing each task, update the TodoWrite list to reflect the status and any necessary follow-up actions.
-    SYSTEM
-  end
-
-  def self.tools
-    [ EditTool, ReadTool, TodoWriteTool, BashTool, GrepTool ]
-  end
-
-  def tools
-    self.class.tools.map(&:definition)
-  end
-
-  def post
-    LlmGateway::Client.chat(model, prompt, tools: tools, system: system_prompt, api_key: @api_key)
-  end
-end

data/sample/claude_code_clone/run.rb

@@ -1,47 +0,0 @@
-require 'tty-prompt'
-require_relative '../../lib/llm_gateway'
-require_relative 'claude_code_clone.rb'
-
-# Terminal Runner for FileSearchBot
-class FileSearchTerminalRunner
-  def initialize
-    @prompt = TTY::Prompt.new
-  end
-
-  def start
-    puts "First, let's configure your LLM settings:\n\n"
-
-    model, api_key = setup_configuration
-    bot = ClaudeCloneClone.new(model, api_key)
-
-    puts "Type 'quit' or 'exit' to stop.\n\n"
-
-    loop do
-      user_input = @prompt.ask("What can i do for you?")
-
-      break if [ 'quit', 'exit' ].include?(user_input.downcase)
-
-      bot.query(user_input)
-    end
-  end
-
-  private
-
-  def setup_configuration
-    model = @prompt.ask("Enter model (default: claude-3-7-sonnet-20250219):") do |q|
-      q.default 'claude-3-7-sonnet-20250219'
-    end
-
-    api_key = @prompt.mask("Enter your API key:") do |q|
-      q.required true
-    end
-
-    [ model, api_key ]
-  end
-end
-
-# Start the bot
-if __FILE__ == $0
-  runner = FileSearchTerminalRunner.new
-  runner.start
-end