llm_gateway 0.2.0 → 0.3.0

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

@@ -0,0 +1,110 @@
+# 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

@@ -0,0 +1,40 @@
+# 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

@@ -22,6 +22,23 @@ module LlmGateway
           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:,
@@ -30,6 +47,10 @@ module LlmGateway
           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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Adapters
+    module OpenAi
+      class FileOutputMapper
+        def self.map(data)
+          bytes = data.delete(:bytes)
+          data.delete(:object) # Didnt see much value in this only option is "file"
+          data.delete(:status) # Deprecated so no need to pull through
+          data.delete(:status_details)  # Deprecated so no need to pull through
+          created_at = data.delete(:created_at)
+          time = Time.at(created_at, in: "UTC")
+          iso_format = time.iso8601(6)
+          data.merge(
+            size_bytes: bytes,
+            downloadable: data[:purpose] != "user_data",
+            mime_type: nil,
+            created_at: iso_format # Claude api format, easier for human reading so kept it this way
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# 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

@@ -0,0 +1,62 @@
+# 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

@@ -0,0 +1,47 @@
+# 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/lib/llm_gateway/base_client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "net/http"
+require "stringio"
 require "json"
 
 module LlmGateway
@@ -19,6 +20,40 @@ module LlmGateway
       process_response(response)
     end
 
+    def post_file(url_part, file_contents, filename, purpose: nil, mime_type: "application/octet-stream")
+      endpoint = "#{base_endpoint}/#{url_part.sub(%r{^/}, "")}"
+      uri = URI.parse(endpoint)
+
+      file_io = StringIO.new(file_contents)
+
+      # Create request with full URI (important!)
+      request = Net::HTTP::Post.new(uri)
+
+      form_data = [
+        [
+          "file",
+          file_io,
+          { filename: filename, "Content-Type" => mime_type }
+        ]
+      ]
+
+      # Add purpose parameter if provided
+      form_data << [ "purpose", purpose ] if purpose
+
+      request.set_form(form_data, "multipart/form-data")
+
+      # Headers (excluding Content-Type because set_form already sets it)
+      multipart_headers = build_headers.reject { |k, _| k.downcase == "content-type" }
+      multipart_headers.each { |key, value| request[key] = value }
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
+      end
+
+
+      process_response(response)
+    end
+
     def post(url_part, body = nil, extra_headers = {})
       endpoint = "#{base_endpoint}/#{url_part.sub(%r{^/}, "")}"
       response = make_request(endpoint, Net::HTTP::Post, body, extra_headers)

data/lib/llm_gateway/client.rb

@@ -2,11 +2,45 @@
 
 module LlmGateway
   class Client
+    def self.provider_configs
+      @provider_configs ||= {
+        anthropic: {
+          input_mapper: LlmGateway::Adapters::Claude::InputMapper,
+          output_mapper: LlmGateway::Adapters::Claude::OutputMapper,
+          client: LlmGateway::Adapters::Claude::Client,
+          file_output_mapper: LlmGateway::Adapters::Claude::FileOutputMapper
+        },
+        openai: {
+          input_mapper: LlmGateway::Adapters::OpenAi::ChatCompletions::InputMapper,
+          output_mapper: LlmGateway::Adapters::OpenAi::ChatCompletions::OutputMapper,
+          client: LlmGateway::Adapters::OpenAi::Client,
+          file_output_mapper: LlmGateway::Adapters::OpenAi::FileOutputMapper
+        },
+        openai_responses: {
+          input_mapper: LlmGateway::Adapters::OpenAi::Responses::InputMapper,
+          output_mapper: LlmGateway::Adapters::OpenAi::Responses::OutputMapper,
+          client: LlmGateway::Adapters::OpenAi::Client,
+          file_output_mapper: LlmGateway::Adapters::OpenAi::FileOutputMapper
+        },
+        groq: {
+          input_mapper: LlmGateway::Adapters::Groq::InputMapper,
+          output_mapper: LlmGateway::Adapters::Groq::OutputMapper,
+          client: LlmGateway::Adapters::Groq::Client,
+          file_output_mapper: nil
+        }
+      }.freeze
+    end
+
+    def self.get_provider_config(provider_id)
+      provider_configs[provider_id.to_sym] || raise(LlmGateway::Errors::UnsupportedProvider, provider_id)
+    end
+
     def self.chat(model, message, response_format: "text", tools: nil, system: nil, api_key: nil)
-      client_klass = client_class(model)
+      provider = provider_from_model(model)
+      config = get_provider_config(provider)
       client_options = { model_key: model }
       client_options[:api_key] = api_key if api_key
-      client = client_klass.new(**client_options)
+      client = config[:client].new(**client_options)
 
       input_mapper = input_mapper_for_client(client)
       normalized_input = input_mapper.map({
@@ -24,28 +58,90 @@ module LlmGateway
       result_mapper(client).map(result)
     end
 
-    def self.client_class(model)
-      return LlmGateway::Adapters::Claude::Client if model.start_with?("claude")
-      return LlmGateway::Adapters::Groq::Client if model.start_with?("llama")
-      return LlmGateway::Adapters::OpenAi::Client if model.start_with?("gpt") ||
-                                                     model.start_with?("o4-") ||
-                                                     model.start_with?("openai")
+
+    def self.responses(model, message, response_format: "text", tools: nil, system: nil, api_key: nil)
+      provider = provider_from_model(model)
+      config = provider == "openai" ? get_provider_config("openai_responses") : get_provider_config(provider)
+      client_options = { model_key: model }
+      client_options[:api_key] = api_key if api_key
+      client = config[:client].new(**client_options)
+      input_mapper = config[:input_mapper]
+      normalized_input = input_mapper.map({
+        messages: normalize_messages(message),
+        response_format: normalize_response_format(response_format),
+        tools: tools,
+        system: normalize_system(system)
+      })
+      method = provider == "openai" ? "responses" : "chat"
+      result = client.send(method,
+        normalized_input[:messages],
+        response_format: normalized_input[:response_format],
+        tools: normalized_input[:tools],
+        system: normalized_input[:system]
+      )
+      config[:output_mapper].map(result)
+    end
+
+    def self.build_client(provider, api_key:, model: "none")
+      config = get_provider_config(provider)
+      client_options = { model_key: model }
+      client_options[:api_key] = api_key if api_key
+      config[:client].new(**client_options)
+    end
+
+    def self.upload_file(provider, **kwargs)
+      api_key = kwargs.delete(:api_key)
+      client = build_client(provider, api_key: api_key)
+      result = client.upload_file(*kwargs.values)
+      config = get_provider_config(provider)
+      config[:file_output_mapper].map(result)
+    end
+
+    def self.download_file(provider, **kwargs)
+      api_key = kwargs.delete(:api_key)
+      client = build_client(provider, api_key: api_key)
+      result = client.download_file(*kwargs.values)
+      config = get_provider_config(provider)
+      config[:file_output_mapper].map(result)
+    end
+
+    def self.provider_from_model(model)
+      return "anthropic" if model.start_with?("claude")
+      return "groq" if model.start_with?("llama")
+      return "openai" if model.start_with?("gpt") ||
+                         model.start_with?("o4-") ||
+                         model.start_with?("openai")
 
       raise LlmGateway::Errors::UnsupportedModel, model
     end
 
-    def self.input_mapper_for_client(client)
-      return LlmGateway::Adapters::Claude::InputMapper if client.is_a?(LlmGateway::Adapters::Claude::Client)
-      return LlmGateway::Adapters::OpenAi::InputMapper if client.is_a?(LlmGateway::Adapters::OpenAi::Client)
 
-      LlmGateway::Adapters::Groq::InputMapper if client.is_a?(LlmGateway::Adapters::Groq::Client)
+    def self.input_mapper_for_client(client)
+      config = get_provider_config_by_client(client)
+      config[:input_mapper]
     end
 
     def self.result_mapper(client)
-      return LlmGateway::Adapters::Claude::OutputMapper if client.is_a?(LlmGateway::Adapters::Claude::Client)
-      return LlmGateway::Adapters::OpenAi::OutputMapper if client.is_a?(LlmGateway::Adapters::OpenAi::Client)
+      config = get_provider_config_by_client(client)
+      config[:output_mapper]
+    end
+
+    def self.provider_id_from_client(client)
+      case client
+      when LlmGateway::Adapters::Claude::Client
+        "anthropic"
+      when LlmGateway::Adapters::OpenAi::Client
+        "openai"
+      when LlmGateway::Adapters::Groq::Client
+        "groq"
+      else
+        raise LlmGateway::Errors::UnsupportedProvider, client.class.name
+      end
+    end
 
-      LlmGateway::Adapters::Groq::OutputMapper if client.is_a?(LlmGateway::Adapters::Groq::Client)
+    def self.get_provider_config_by_client(client)
+      provider_id = provider_id_from_client(client)
+      get_provider_config(provider_id)
     end
 
     def self.normalize_system(system)

data/lib/llm_gateway/errors.rb

@@ -28,6 +28,8 @@ module LlmGateway
     class UnknownError < ClientError; end
     class PromptTooLong < BadRequestError; end
     class UnsupportedModel < ClientError; end
+    class UnsupportedProvider < ClientError; end
+    class MissingMapperForProvider < ClientError; end
 
     class PromptError < BaseError; end
 

data/lib/llm_gateway/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmGateway
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/llm_gateway.rb

@@ -12,13 +12,21 @@ require_relative "llm_gateway/tool"
 require_relative "llm_gateway/adapters/claude/client"
 require_relative "llm_gateway/adapters/claude/input_mapper"
 require_relative "llm_gateway/adapters/claude/output_mapper"
+require_relative "llm_gateway/adapters/open_ai/client"
+require_relative "llm_gateway/adapters/open_ai/file_output_mapper"
+require_relative "llm_gateway/adapters/open_ai/chat_completions/input_mapper"
+require_relative "llm_gateway/adapters/open_ai/chat_completions/output_mapper"
 require_relative "llm_gateway/adapters/groq/client"
 require_relative "llm_gateway/adapters/groq/input_mapper"
 require_relative "llm_gateway/adapters/groq/output_mapper"
-require_relative "llm_gateway/adapters/open_ai/client"
-require_relative "llm_gateway/adapters/open_ai/input_mapper"
-require_relative "llm_gateway/adapters/open_ai/output_mapper"
+require_relative "llm_gateway/adapters/open_ai/file_output_mapper"
+require_relative "llm_gateway/adapters/open_ai/responses/input_mapper"
+require_relative "llm_gateway/adapters/open_ai/responses/output_mapper"
 
 module LlmGateway
   class Error < StandardError; end
+
+  # Direction constants for message mappers
+  DIRECTION_IN = :in
+  DIRECTION_OUT = :out
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-08 00:00:00.000000000 Z
+date: 2025-08-19 00:00:00.000000000 Z
 dependencies: []
 description: LlmGateway provides a consistent Ruby interface for multiple LLM providers
   including Claude, OpenAI, and Groq. Features include unified response formatting,
@@ -26,15 +26,22 @@ files:
 - README.md
 - Rakefile
 - lib/llm_gateway.rb
+- lib/llm_gateway/adapters/claude/bidirectional_message_mapper.rb
 - lib/llm_gateway/adapters/claude/client.rb
 - lib/llm_gateway/adapters/claude/input_mapper.rb
 - lib/llm_gateway/adapters/claude/output_mapper.rb
+- lib/llm_gateway/adapters/groq/bidirectional_message_mapper.rb
 - lib/llm_gateway/adapters/groq/client.rb
 - lib/llm_gateway/adapters/groq/input_mapper.rb
 - lib/llm_gateway/adapters/groq/output_mapper.rb
+- lib/llm_gateway/adapters/open_ai/chat_completions/bidirectional_message_mapper.rb
+- lib/llm_gateway/adapters/open_ai/chat_completions/input_mapper.rb
+- lib/llm_gateway/adapters/open_ai/chat_completions/output_mapper.rb
 - lib/llm_gateway/adapters/open_ai/client.rb
-- lib/llm_gateway/adapters/open_ai/input_mapper.rb
-- lib/llm_gateway/adapters/open_ai/output_mapper.rb
+- lib/llm_gateway/adapters/open_ai/file_output_mapper.rb
+- lib/llm_gateway/adapters/open_ai/responses/bidirectional_message_mapper.rb
+- lib/llm_gateway/adapters/open_ai/responses/input_mapper.rb
+- lib/llm_gateway/adapters/open_ai/responses/output_mapper.rb
 - lib/llm_gateway/base_client.rb
 - lib/llm_gateway/client.rb
 - lib/llm_gateway/errors.rb