llm_gateway 0.3.0 → 0.5.0

data/lib/llm_gateway/adapters/open_ai/chat_completions/bidirectional_message_mapper.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      module ChatCompletions
-        class BidirectionalMessageMapper
-        attr_reader :direction
-
-        def initialize(direction)
-          @direction = direction
-        end
-
-        def map_content(content)
-          # Convert string content to text format
-          content = { type: "text", text: content } unless content.is_a?(Hash)
-          case content[:type]
-          when "text"
-            map_text_content(content)
-          when "file"
-            map_file_content(content)
-          when "image"
-            map_image_content(content)
-          when "tool_use"
-            map_tool_use_content(content)
-          when "function"
-            map_tool_use_content(content)
-          when "tool_result"
-            map_tool_result_content(content)
-          else
-            content
-          end
-        end
-
-        private
-
-        def parse_tool_arguments(arguments)
-          return arguments unless arguments.is_a?(String)
-          JSON.parse(arguments, symbolize_names: true)
-        end
-
-        def map_text_content(content)
-          {
-            type: "text",
-            text: content[:text]
-          }
-        end
-
-        def map_file_content(content)
-          # 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])}"
-            }
-          }
-        end
-
-        def map_image_content(content)
-          {
-            type: "image_url",
-            image_url: {
-              url: "data:#{content[:media_type]};base64,#{content[:data]}"
-            }
-          }
-        end
-
-        def map_tool_use_content(content)
-          if direction == LlmGateway::DIRECTION_IN
-          {
-            id: content[:id],
-            type: "function",
-            function: {
-              name: content[:name],
-              arguments: content[:input].to_json
-            }
-          }
-          else
-          {
-            id: content[:id],
-            type: "tool_use",
-            name: content[:function][:name],
-            input: parse_tool_arguments(content[:function][:arguments])
-          }
-          end
-        end
-
-        def map_tool_result_content(content)
-          {
-            role: "tool",
-            tool_call_id: content[:tool_use_id],
-            content: content[:content]
-          }
-        end
-        end
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require_relative "bidirectional_message_mapper"
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      module ChatCompletions
-        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_response_format(response_format)
-          response_format
-        end
-
-        def self.map_messages(messages)
-          return messages unless messages
-
-          message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_IN)
-
-          # First map messages like Claude
-          mapped_messages = messages.map do |msg|
-            msg = msg.merge(role: "user") if msg[:role] == "developer"
-
-            content = if msg[:content].is_a?(Array)
-                msg[:content].map do |content|
-                  message_mapper.map_content(content)
-                end
-            else
-              [ message_mapper.map_content(msg[:content]) ]
-            end
-
-            {
-              role: msg[:role],
-              content: content
-            }
-          end
-          # Then transform to OpenAI format
-          mapped_messages.flat_map do |msg|
-            # Handle array content with tool calls and tool results
-            tool_calls = []
-            regular_content = []
-            tool_messages = []
-            msg[:content].each do |content|
-              case content[:type] || content[:role]
-              when "tool"
-                tool_messages << content
-              when "function"
-                tool_calls << 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
-          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_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
-end

data/lib/llm_gateway/adapters/open_ai/chat_completions/output_mapper.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      module ChatCompletions
-        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
-          message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_OUT)
-
-          choices.map do |choice|
-            message = choice[:message] || {}
-            content_item = message_mapper.map_content(message[:content])
-            tool_calls = message[:tool_calls] ? message[:tool_calls].map { |tool_call| message_mapper.map_content(tool_call) } : []
-
-            # 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
-
-            { role: message[:role], content: content_array }
-          end
-        end
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +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 responses(messages, response_format: { type: "text" }, tools: nil, system: [], max_completion_tokens: 4096)
-            body = {
-              model: model_key,
-              max_output_tokens: max_completion_tokens,
-              input: messages.flatten
-            }
-            body[:instructions] = system[0][:content] if system.any?
-            body[:tools] = tools if tools
-            result = post("responses", body)
-            result
-        end
-
-
-        def download_file(file_id)
-          get("files/#{file_id}/content")
-        end
-
-        def generate_embeddings(input)
-          body = {
-            input:,
-            model: model_key
-          }
-          post("embeddings", body)
-        end
-
-        def upload_file(filename, content, mime_type = "application/octet-stream", purpose: "user_data")
-          post_file("files", content, filename, purpose: purpose, mime_type: mime_type)
-        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/responses/bidirectional_message_mapper.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      module Responses
-        class BidirectionalMessageMapper < OpenAi::ChatCompletions::BidirectionalMessageMapper
-          def map_content(content)
-            # Convert string content to text format
-            #
-
-            content = { type: "text", text: content } unless content.is_a?(Hash)
-            case content[:type]
-            when "text"
-              map_text_content(content)
-            when "message"
-              map_messages(content)
-            when "output_text"
-              map_output_text_content(content)
-            when "tool_use"
-              map_tool_use_content(content)
-            when "function_call"
-              map_tool_use_content(content)
-            when "tool_result"
-              map_tool_result_content(content)
-            else
-              content
-            end
-          end
-
-        private
-
-          def map_messages(message)
-            message[:content].map { |content| map_content(content) }
-          end
-
-          def map_tool_result_content(content)
-            {
-              "type": "function_call_output",
-              "call_id": content[:tool_use_id],
-              "output": content[:content]
-            }
-          end
-
-          def map_tool_use_content(content)
-            if direction == LlmGateway::DIRECTION_OUT
-              { id: content[:call_id], type: "tool_use", name: content[:name], input: parse_tool_arguments(content[:arguments]) }
-            else
-              { id: content[:id] }
-            end
-          end
-
-          def map_output_text_content(content)
-            {
-              type: "text",
-              text: content[:text]
-            }
-          end
-
-          def map_text_content(content)
-            {
-              type: "input_text",
-              text: content[:text]
-            }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require_relative "bidirectional_message_mapper"
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      module Responses
-        class InputMapper < OpenAi::ChatCompletions::InputMapper
-          def self.message_mapper
-            BidirectionalMessageMapper.new(LlmGateway::DIRECTION_IN)
-          end
-
-          def self.map_tools(tools)
-            return tools unless tools
-
-            tools.map do |tool|
-              {
-                type: "function",
-                name: tool[:name],
-                description: tool[:description],
-                parameters: tool[:input_schema]
-              }
-            end
-          end
-
-          def self.map_messages(messages)
-            return messages unless messages
-            mapper = message_mapper
-
-            # First map messages like Claude
-            messages.map do |msg|
-              if msg[:id]
-                msg = msg.merge(role: "assistant")
-                msg.slice(:id)
-              else
-                content = if msg[:content].is_a?(Array)
-                    msg[:content].map do |content|
-                      mapper.map_content(content)
-                    end
-                elsif msg[:id]
-                  mapper.map_content(msg)
-                else
-                  [ mapper.map_content(msg[:content]) ]
-                end
-                if msg.dig(:content).is_a?(Array) && msg.dig(:content, 0, :type) == "tool_result"
-                  content
-                else
-                  {
-                    role: msg[:role],
-                    content: content
-                  }
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/llm_gateway/adapters/open_ai/responses/output_mapper.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "base64"
-require_relative "bidirectional_message_mapper"
-
-module LlmGateway
-  module Adapters
-    module OpenAi
-      module Responses
-        class OutputMapper
-          def self.map(data)
-            {
-              id: data[:id],
-              model: data[:model],
-              usage: data[:usage],
-              choices: map_choices(data[:output])
-            }
-          end
-
-          private
-
-          def self.map_choices(choices)
-            return [] unless choices
-            message_mapper = BidirectionalMessageMapper.new(LlmGateway::DIRECTION_OUT)
-            choices.map do |choice|
-              content = if choice[:id].start_with?("fc_")
-                {
-                  id: choice[:id],
-                  role: choice[:role] || "assistant", # tool call doesnt have a role apparently
-                  content: [ message_mapper.map_content(choice) ].flatten
-                }
-              else
-               content = message_mapper.map_content(choice)
-               id = content.delete(:id)
-               {
-                 id: choice[:id] || id,
-                 role: choice[:role],
-                 content: [ content ].flatten
-               }
-              end
-            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