llm_gateway 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86c8c0937c6d8d78b1b4b3c2dfa1ed749fbd74eb40e52ccf084dbf0e3cccbb8e
-  data.tar.gz: 682021570b7d903ba44bfc606a9ca9e9fc45ce897bb8637a32d563bfd5497de4
+  metadata.gz: 829e306ff0af794ce1a301b1eac5ab52edfa9a21ce1eec479955de3a328be443
+  data.tar.gz: 6935b650d14237e48a82cdbb0614e5201c6960abf71d6dc23bd51e76d6b37ee3
 SHA512:
-  metadata.gz: b684e11152959b054bb30213982845e0978dfe91a2473de7e2a326ca37d2c9e6ec8411be1b5a729e3d99bfb0654bfc420bacf7b752219286295cf80d2c1245f1
-  data.tar.gz: 3da1cf5fcc649024b9e08859905430e1a89082333ec614c39b6fd22ff360143fe5be5f1efb9d7ddf81e8d9f08e62549c23ae1daadc8ef82e234fb6e433a4b899
+  metadata.gz: 89572a5c0d05806fdc5fa7a06a7336f5b8b738daaff37f834595b96415a601adc50ca13e33c79cfa29abcb82766eeb6ad3cbe14c099b030e340af7d8dd943f2f
+  data.tar.gz: 0001f5413fe4b3c3b17b2bca197a37e00c0503b09da7e79b90b52a45c65a4247dfd8be60fa86cc99505eb408c4c69c3d2cd835eb700c8018faa1f64da6e0f6ab

data/.rubocop.yml

@@ -3,3 +3,32 @@ inherit_gem:
 
 AllCops:
   TargetRubyVersion: 3.1
+
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: start_of_line
+
+Layout/FirstHashElementLineBreak:
+  Enabled: true
+
+Layout/FirstHashElementIndentation:
+  Enabled: true
+  EnforcedStyle: consistent
+
+Layout/MultilineHashKeyLineBreaks:
+  Enabled: true
+
+Layout/HashAlignment:
+  Enabled: true
+  EnforcedHashRocketStyle: key
+  EnforcedColonStyle: key
+
+Layout/IndentationConsistency:
+  Enabled: true
+  EnforcedStyle: normal
+
+Layout/IndentationWidth:
+  Width: 2
+
+Layout/MultilineHashBraceLayout:
+  Enabled: true
+  EnforcedStyle: new_line

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [v0.2.0](https://github.com/Hyper-Unearthing/llm_gateway/tree/v0.2.0) (2025-08-08)
+
+[Full Changelog](https://github.com/Hyper-Unearthing/llm_gateway/compare/v0.1.6...v0.2.0)
+
+**Merged pull requests:**
+
+- feat: improve read me  [\#21](https://github.com/Hyper-Unearthing/llm_gateway/pull/21) ([billybonks](https://github.com/billybonks))
+- refactor: remove fluent mapper from the lib [\#20](https://github.com/Hyper-Unearthing/llm_gateway/pull/20) ([billybonks](https://github.com/billybonks))
+- test: dont fail vcr if key order changes [\#19](https://github.com/Hyper-Unearthing/llm_gateway/pull/19) ([billybonks](https://github.com/billybonks))
+- burn: fluent mapper from input mappers [\#18](https://github.com/Hyper-Unearthing/llm_gateway/pull/18) ([billybonks](https://github.com/billybonks))
+- test: open ai mapper [\#17](https://github.com/Hyper-Unearthing/llm_gateway/pull/17) ([billybonks](https://github.com/billybonks))
+- feat: handle basic text document handling [\#16](https://github.com/Hyper-Unearthing/llm_gateway/pull/16) ([billybonks](https://github.com/billybonks))
+- test: improve issues [\#15](https://github.com/Hyper-Unearthing/llm_gateway/pull/15) ([billybonks](https://github.com/billybonks))
+- style: format aligment of content automatically to my preference [\#14](https://github.com/Hyper-Unearthing/llm_gateway/pull/14) ([billybonks](https://github.com/billybonks))
+- fix: tool calling open ai [\#13](https://github.com/Hyper-Unearthing/llm_gateway/pull/13) ([billybonks](https://github.com/billybonks))
+
 ## [v0.1.6](https://github.com/Hyper-Unearthing/llm_gateway/tree/v0.1.6) (2025-08-05)
 
 [Full Changelog](https://github.com/Hyper-Unearthing/llm_gateway/compare/v0.1.5...v0.1.6)

data/README.md

@@ -30,19 +30,94 @@ gem install llm_gateway
 require 'llm_gateway'
 
 # Simple text completion
-result = LlmGateway::Client.chat(
+LlmGateway::Client.chat(
   'claude-sonnet-4-20250514',
   'What is the capital of France?'
 )
 
 # With system message
-result = LlmGateway::Client.chat(
+LlmGateway::Client.chat(
   'gpt-4',
   'What is the capital of France?',
   system: 'You are a helpful geography teacher.'
 )
+
+# With inline file
+LlmGateway::Client.chat(
+  "claude-sonnet-4-20250514",
+  [
+    {
+      role: "user", content: [
+        { type: "text", text: "return the content of the document exactly" },
+        { type: "file", data: "abc\n", media_type: "text/plain", name: "small.txt"  }
+      ]
+    },
+  ]
+)
+
+# Transcript
+LlmGateway::Client.chat('llama-3.3-70b-versatile',[
+    { role: "user", content: "Tell Me a joke" },
+    { role: "assistant", content: "what kind of content"},
+    { role: "user", content: "About Sparkling water" },
+  ]
+)
+
+
+# Tool usage
+LlmGateway::Client.chat('gpt-5',[
+    { role: "user", content: "What's the weather in Singapore? reply in 10 words and no special characters" },
+    { role: "assistant",
+        content: [
+          { id: "call_gpXfy9l9QNmShNEbNI1FyuUZ", type: "tool_use", name: "get_weather", input: { location: "Singapore" } }
+        ]
+    },
+    { role: "developer",
+      content: [
+        { content: "-15 celcius", type: "tool_result", tool_use_id: "call_gpXfy9l9QNmShNEbNI1FyuUZ" }
+      ]
+    }
+  ],
+  tools: [ { name: "get_weather", description: "Get current weather for a location", input_schema: { type: "object", properties: { location: { type: "string", description: "City name" } }, required: [ "location" ] } } ]
+)
 ```
 
+### Supported Roles
+
+- user
+- developer
+- assistant
+
+#### Examples
+```ruby
+# tool call
+{ role: "developer",
+  content: [
+    { content: "-15 celcius", type: "tool_result", tool_use_id: "call_gpXfy9l9QNmShNEbNI1FyuUZ" }
+  ]
+}
+# plain message
+{ role: "user", content: "What's the weather in Singapore? reply in 10 words and no special characters" }
+
+# plain response
+{ role: "assistant", content: "what kind of content"},
+
+# tool call response
+{ role: "assistant",
+    content: [
+      { id: "call_gpXfy9l9QNmShNEbNI1FyuUZ", type: "tool_use", name: "get_weather", input: { location: "Singapore" } }
+    ]
+},
+```
+
+developer is an open ai role, but i thought it was usefull for tracing if message sent from server or user so i added
+it to the list of roles, when it is not supported it will be mapped to user instead.
+
+you can assume developer and user to be interchangeable
+
+
+
+
 ### Sample Application
 
 See the [file search bot example](sample/claude_code_clone/) for a complete working application that demonstrates:

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

@@ -4,30 +4,52 @@ module LlmGateway
   module Adapters
     module Claude
       class InputMapper
-        extend LlmGateway::FluentMapper
+        def self.map(data)
+          {
+            messages: map_messages(data[:messages]),
+            response_format: data[:response_format],
+            tools: data[:tools],
+            system: map_system(data[:system])
+          }
+        end
+
+        private
+
+        def self.map_messages(messages)
+          return messages unless messages
 
-        map :messages do |_, value|
-          value.map do |msg|
+          messages.map do |msg|
             msg = msg.merge(role: "user") if msg[:role] == "developer"
             msg.slice(:role, :content)
+            content = if msg[:content].is_a?(Array)
+                msg[:content].map do |content|
+                  if content[:type] == "file"
+                    { type: "document", source: { data: content[:data], type: "text", media_type: content[:media_type] } }
+                  else
+                    content
+                  end
+                end
+            else
+              msg[:content]
+            end
+            {
+              role: msg[:role],
+              content: content
+            }
           end
         end
 
-        map :system do |_, value|
-          if value.empty?
+        def self.map_system(system)
+          if !system || system.empty?
             nil
-          elsif value.length == 1 && value.first[:role] == "system"
+          elsif system.length == 1 && system.first[:role] == "system"
             # If we have a single system message, convert to Claude format
-            [ { type: "text", text: value.first[:content] } ]
+            [ { type: "text", text: system.first[:content] } ]
           else
             # For multiple messages or non-standard format, pass through
-            value
+            system
           end
         end
-
-        map :tools do |_, value|
-          value
-        end
       end
     end
   end

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

@@ -4,17 +4,23 @@ module LlmGateway
   module Adapters
     module Claude
       class OutputMapper
-        extend LlmGateway::FluentMapper
+        def self.map(data)
+          {
+            id: data[:id],
+            model: data[:model],
+            usage: data[:usage],
+            choices: map_choices(data)
+          }
+        end
+
+        private
 
-        map :id
-        map :model
-        map :usage
-        map :choices do |_, _|
+        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],
+            content: data[:content] || [], # Use content directly from Claude response
+            finish_reason: data[:stop_reason],
             role: "assistant"
           } ]
         end

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

@@ -4,74 +4,101 @@ module LlmGateway
   module Adapters
     module Groq
       class InputMapper
-        extend LlmGateway::FluentMapper
+        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
 
-        map :system
-        map :response_format
+        private
 
-        mapper :tool_usage do
-          map :role, default: "assistant"
-          map :content do
-            nil
-          end
-          map :tool_calls, from: :content do |_, value|
-            value.map do |content|
-              {
-                'id': content[:id],
-                'type': "function",
-                'function': {
-                  'name': content[:name],
-                  'arguments': content[:input].to_json
-                }
-              }
-            end
-          end
+        def self.map_system(system)
+          system
         end
 
-        mapper :tool_result_message do
-          map :role, default: "tool"
-          map :tool_call_id, from: "tool_use_id"
-          map :content
+        def self.map_response_format(response_format)
+          response_format
         end
 
-        map :messages do |_, value|
-          value.map do |msg|
-            if msg[:role] == "user"
-              msg
-            elsif msg[:content].is_a?(Array)
-              results = []
-              # Handle tool_use messages
-              tool_uses = msg[:content].select { |c| c[:type] == "tool_use" }
-              results << map_single(msg, with: :tool_usage) if tool_uses.any?
-              # Handle tool_result messages
-              tool_results = msg[:content].select { |c| c[:type] == "tool_result" }
-              tool_results.each do |content|
-                results << map_single(content, with: :tool_result_message)
+        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
 
-              results
+              # Add separate tool result messages
+              result += tool_messages
+
+              result
             else
-              msg
+              # Regular message, return as-is
+              [ msg ]
             end
-          end.flatten
+          end
         end
 
-        map :tools do |_, value|
-          if value
-            value.map do |tool|
-              {
-                type: "function",
-                function: {
-                  name: tool[:name],
-                  description: tool[:description],
-                  parameters: tool[:input_schema]
-                }
+        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
-          else
-            value
+            }
           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

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

@@ -4,42 +4,58 @@ module LlmGateway
   module Adapters
     module Groq
       class OutputMapper
-        extend LlmGateway::FluentMapper
-
-        mapper :tool_call do
-          map :id
-          map :type do
-            "tool_use" # Always return 'tool_use' regardless of input
-          end
-          map :name, from: "function.name"
-          map :input, from: "function.arguments" do |_, value|
-            parsed = value.is_a?(String) ? JSON.parse(value) : value
-            parsed
-          end
+        def self.map(data)
+          {
+            id: data[:id],
+            model: data[:model],
+            usage: data[:usage],
+            choices: map_choices(data[:choices])
+          }
         end
 
-        mapper :content_item do
-          map :text, from: "content"
-          map :type, default: "text"
-        end
+        private
 
-        map :id
-        map :model
-        map :usage
-        map :choices, from: "choices" do |_, value|
-          value.map do |choice|
+        def self.map_choices(choices)
+          return [] unless choices
+
+          choices.map do |choice|
             message = choice[:message] || {}
-            content_item = map_single(message, with: :content_item, default: {})
-            tool_calls = map_collection(message[:tool_calls], with: :tool_call, default: [])
+            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 << 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

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

@@ -1,14 +1,58 @@
 # frozen_string_literal: true
 
+require "base64"
+
 module LlmGateway
   module Adapters
     module OpenAi
       class InputMapper < LlmGateway::Adapters::Groq::InputMapper
-        map :system do |_, value|
-          if value.empty?
+        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
-            value.map do |msg|
+            system.map do |msg|
               msg[:role] == "system" ? msg.merge(role: "developer") : msg
             end
           end

data/lib/llm_gateway/client.rb

@@ -10,11 +10,11 @@ module LlmGateway
 
       input_mapper = input_mapper_for_client(client)
       normalized_input = input_mapper.map({
-                                            messages: normalize_messages(message),
-                                            response_format: normalize_response_format(response_format),
-                                            tools: tools,
-                                            system: normalize_system(system)
-                                          })
+        messages: normalize_messages(message),
+        response_format: normalize_response_format(response_format),
+        tools: tools,
+        system: normalize_system(system)
+      })
       result = client.chat(
         normalized_input[:messages],
         response_format: normalized_input[:response_format],

data/lib/llm_gateway/version.rb

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

data/lib/llm_gateway.rb

@@ -3,7 +3,6 @@
 require_relative "llm_gateway/utils"
 require_relative "llm_gateway/version"
 require_relative "llm_gateway/errors"
-require_relative "llm_gateway/fluent_mapper"
 require_relative "llm_gateway/base_client"
 require_relative "llm_gateway/client"
 require_relative "llm_gateway/prompt"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-05 00:00:00.000000000 Z
+date: 2025-08-08 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,
@@ -38,7 +38,6 @@ files:
 - lib/llm_gateway/base_client.rb
 - lib/llm_gateway/client.rb
 - lib/llm_gateway/errors.rb
-- lib/llm_gateway/fluent_mapper.rb
 - lib/llm_gateway/prompt.rb
 - lib/llm_gateway/tool.rb
 - lib/llm_gateway/utils.rb

data/lib/llm_gateway/fluent_mapper.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-module LlmGateway
-  module FluentMapper
-    def self.extended(base)
-      base.instance_variable_set(:@mappers, {})
-      base.instance_variable_set(:@mappings, [])
-    end
-
-    def inherited(subclass)
-      super
-      # Copy parent's mappers and mappings to the subclass
-      subclass.instance_variable_set(:@mappers, @mappers.dup)
-      subclass.instance_variable_set(:@mappings, @mappings.dup)
-    end
-
-    def mapper(name, &block)
-      @mappers[name] = block
-    end
-
-    def map(field_or_data, options = {}, &block)
-      # If called with a single argument and no block, it's the class method usage
-      if block.nil? && options.empty? && !field_or_data.is_a?(Symbol) && !field_or_data.is_a?(String)
-        return new(field_or_data).call
-      end
-
-      # Otherwise it's the field mapping usage
-      @mappings << { field: field_or_data, options: options, block: block }
-    end
-
-    def new(data)
-      MapperInstance.new(data, @mappers, @mappings)
-    end
-
-    class MapperInstance
-      def initialize(data, mappers, mappings)
-        @data = data.respond_to?(:with_indifferent_access) ? data.with_indifferent_access : data
-        @mappers = mappers
-        @mappings = mappings
-        @mapper_definitions = {}
-
-        # Execute mapper definitions
-        mappers.each do |name, block|
-          @mapper_definitions[name] = MapperDefinition.new
-          @mapper_definitions[name].instance_eval(&block)
-        end
-      end
-
-      def call
-        result = {}
-
-        @mappings.each do |mapping|
-          field = mapping[:field]
-          options = mapping[:options]
-          block = mapping[:block]
-
-          from_path = options[:from] || field.to_s
-          default_value = options[:default]
-
-          value = get_nested_value(@data, from_path)
-          value = default_value if value.nil? && !default_value.nil?
-
-          value = instance_exec(field, value, &block) if block
-
-          result[field] = value
-        end
-
-        LlmGateway::Utils.deep_symbolize_keys(result)
-      end
-
-      def map_single(data, options = {})
-        mapper_name = options[:with]
-        default_value = options[:default]
-        return default_value if data.nil? && !default_value.nil?
-        return data unless mapper_name && @mapper_definitions[mapper_name]
-
-        # Apply with_indifferent_access to data
-        data = data.respond_to?(:with_indifferent_access) ? data.with_indifferent_access : data
-
-        mapper_def = @mapper_definitions[mapper_name]
-        result = {}
-
-        mapper_def.mappings.each do |mapping|
-          field = mapping[:field]
-          map_options = mapping[:options]
-          block = mapping[:block]
-
-          from_path = map_options[:from] || field.to_s
-          field_default_value = map_options[:default]
-
-          value = get_nested_value(data, from_path)
-          value = field_default_value if value.nil? && !field_default_value.nil?
-
-          value = instance_exec(field, value, &block) if block
-
-          result[field.to_s] = value
-        end
-
-        result
-      end
-
-      def map_collection(collection, options = {})
-        default_value = options[:default]
-        return default_value if collection.nil? && !default_value.nil?
-        return [] if collection.nil?
-
-        collection.map { |item| map_single(item, options) }
-      end
-
-      private
-
-      def get_nested_value(data, path)
-        return data[path] if data.respond_to?(:[]) && data.key?(path)
-        return data[path.to_sym] if data.respond_to?(:[]) && data.key?(path.to_sym)
-        return data[path.to_s] if data.respond_to?(:[]) && data.key?(path.to_s)
-
-        keys = path.split(".")
-        current = data
-
-        keys.each do |key|
-          return nil unless current.respond_to?(:[])
-
-          current = current[key] || current[key.to_sym] || current[key.to_s]
-
-          return nil if current.nil?
-        end
-
-        current
-      end
-    end
-
-    class MapperDefinition
-      attr_reader :mappings
-
-      def initialize
-        @mappings = []
-      end
-
-      def map(field, options = {}, &block)
-        @mappings << { field: field, options: options, block: block }
-      end
-    end
-  end
-end