llm_gateway 0.6.0 → 0.7.0

data/lib/llm_gateway/base_client.rb

@@ -41,7 +41,7 @@ module LlmGateway
       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 = build_headers.except("content-type", "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|
@@ -112,7 +112,7 @@ module LlmGateway
           next if data_str == "[DONE]"
 
           data = begin
-            LlmGateway::Utils.deep_symbolize_keys(JSON.parse(data_str))
+            JSON.parse(data_str).deep_symbolize_keys
           rescue JSON::ParserError
             { raw: data_str }
           end
@@ -141,7 +141,7 @@ module LlmGateway
       when 200
         content_type = response["content-type"]
         if content_type&.include?("application/json")
-          LlmGateway::Utils.deep_symbolize_keys(JSON.parse(response.body))
+          JSON.parse(response.body).deep_symbolize_keys
         else
           response.body
         end

data/lib/llm_gateway/clients/anthropic.rb

@@ -54,19 +54,19 @@ module LlmGateway
         }
 
         tools = apply_tools_cache_control(tools, cache_retention)
-        body.merge!(tools: tools) if LlmGateway::Utils.present?(tools)
+        body.merge!(tools: tools) if tools.present?
 
         system = prepend_claude_code_identity(system) if claude_code_oauth_api_key?
         system = apply_system_cache_control(system, cache_retention)
 
-        body.merge!(system: system) if LlmGateway::Utils.present?(system)
+        body.merge!(system: system) if system.present?
         body.merge!(cache_control: cache_control) unless cache_control.nil?
         body.merge!(options)
         body
       end
 
       def apply_system_cache_control(system, cache_retention)
-        return system if system.nil? || system.empty? || !system.is_a?(Array)
+        return system if system.blank? || !system.is_a?(Array)
 
         cache_control = anthropic_cache_control_for(cache_retention)
         return system if cache_control.nil?
@@ -84,7 +84,7 @@ module LlmGateway
       end
 
       def apply_tools_cache_control(tools, cache_retention)
-        return tools if tools.nil? || tools.empty? || !tools.is_a?(Array)
+        return tools if tools.blank? || !tools.is_a?(Array)
 
         cache_control = anthropic_cache_control_for(cache_retention)
         return tools if cache_control.nil?
@@ -149,7 +149,7 @@ module LlmGateway
           text: "You are Claude Code, Anthropic's official CLI for Claude."
         }
 
-        if system.nil? || system.empty?
+        if system.blank?
           [ identity ]
         else
           [ identity ] + system

data/lib/llm_gateway/clients/claude_code/oauth_flow.rb

@@ -105,7 +105,7 @@ module LlmGateway
           code = uri.query && URI.decode_www_form(uri.query).to_h["code"]
           state = uri.query && URI.decode_www_form(uri.query).to_h["state"]
 
-          raise ArgumentError, "Callback URL is missing code parameter" if code.nil? || code.empty?
+          raise ArgumentError, "Callback URL is missing code parameter" if code.blank?
 
           { code: code, state: state }
         rescue URI::InvalidURIError => e
@@ -116,7 +116,7 @@ module LlmGateway
 
         def extract_code_and_state(auth_code_or_callback, state)
           value = auth_code_or_callback.to_s.strip
-          raise ArgumentError, "Authorization code is required" if value.empty?
+          raise ArgumentError, "Authorization code is required" if value.blank?
 
           if looks_like_url?(value)
             callback = parse_callback(value)

data/lib/llm_gateway/clients/openai.rb

@@ -114,7 +114,7 @@ module LlmGateway
 
       def build_codex_body(messages, system, tools, model:, **options)
         instructions = Array(system).filter_map { |s| s.is_a?(Hash) ? s[:content] : s }.join("\n")
-        instructions = "You are a helpful assistant." if instructions.empty?
+        instructions = instructions.presence || "You are a helpful assistant."
 
         body = {
           model: model,
@@ -196,7 +196,7 @@ module LlmGateway
         end
         # If we get here, we didn't handle it specifically
         fallback_body = response.body.to_s.strip
-        fallback_message = if fallback_body.empty?
+        fallback_message = if fallback_body.blank?
           "OpenAI request failed with status #{response.code}"
         else
           "OpenAI request failed with status #{response.code}: #{fallback_body}"

data/lib/llm_gateway/clients/openai_codex/oauth_flow.rb

@@ -96,7 +96,7 @@ module LlmGateway
           uri    = URI.parse(callback_url)
           params = URI.decode_www_form(uri.query.to_s).to_h
           code   = params["code"]
-          raise ArgumentError, "Callback URL is missing code parameter" if code.nil? || code.empty?
+          raise ArgumentError, "Callback URL is missing code parameter" if code.blank?
 
           { code: code, state: params["state"] }
         rescue URI::InvalidURIError => e
@@ -120,7 +120,7 @@ module LlmGateway
           input = tty.gets&.strip
           tty.close
 
-          raise "No authorization code provided" if input.nil? || input.empty?
+          raise "No authorization code provided" if input.blank?
 
           exchange_code(input, flow[:code_verifier], expected_state: flow[:state])
         end
@@ -183,7 +183,7 @@ module LlmGateway
           auth       = payload[JWT_CLAIM_PATH]
           account_id = auth&.dig("chatgpt_account_id")
 
-          account_id.is_a?(String) && !account_id.empty? ? account_id : nil
+          account_id.is_a?(String) ? account_id.presence : nil
         rescue StandardError
           nil
         end
@@ -214,7 +214,7 @@ module LlmGateway
         end
 
         def parse_authorization_input(input, expected_state = nil)
-          return nil if input.nil? || input.empty?
+          return nil if input.blank?
 
           value = input.to_s.strip
 

data/lib/llm_gateway/prompt.rb

@@ -2,112 +2,149 @@
 
 module LlmGateway
   class Prompt
-    UNSET = Object.new.freeze
+    class_attribute :provider, :model, :reasoning
+    class_attribute :before_execute_callbacks, :after_execute_callbacks, instance_accessor: false, default: []
+    attr_accessor :cache_key, :cache_retention
 
-    attr_reader :provider, :model
+    def self.before_execute(*methods, &block)
+      self.before_execute_callbacks += methods
+      self.before_execute_callbacks += [ block ] if block_given?
+    end
 
-    class << self
-      def provider(value = UNSET)
-        @provider = value unless value.equal?(UNSET)
-        @provider
-      end
+    def self.after_execute(*methods, &block)
+      self.after_execute_callbacks += methods
+      self.after_execute_callbacks += [ block ] if block_given?
+    end
 
-      def provider=(value)
-        @provider = value
-      end
+    def initialize(provider: nil, model: nil, reasoning: nil, cache_key: nil, cache_retention: nil)
+      @provider = provider || self.class.provider
+      @model = model || self.class.model
+      @reasoning = reasoning || self.class.reasoning
+      @cache_key = cache_key
+      @cache_retention = cache_retention
+    end
 
-      def model(value = UNSET)
-        @model = value unless value.equal?(UNSET)
-        @model
-      end
+    def run(provider: nil, model: nil, reasoning: nil, **options, &block)
+      # Resolve the prompt once so dynamic or expensive prompt builders are not
+      # evaluated multiple times during a single run.
+      input = prompt
 
-      def model=(value)
-        @model = value
-      end
-    end
+      run_callbacks(:before_execute, input)
 
-    def self.before_execute(*methods, &block)
-      before_execute_callbacks.concat(methods)
-      before_execute_callbacks << block if block_given?
+      response = run_tool_loop(input, provider: resolved_provider(provider), model: model, reasoning: reasoning, **options, &block)
+
+      run_callbacks(:after_execute, response)
+
+      response
     end
 
-    def self.after_execute(*methods, &block)
-      after_execute_callbacks.concat(methods)
-      after_execute_callbacks << block if block_given?
+    def stream(input = prompt, provider: nil, model: nil, reasoning: nil, **options, &block)
+      stream_provider = resolved_provider(provider)
+      stream_options = default_stream_options(model: model, reasoning: reasoning).merge(options)
+
+      stream_provider.stream(input, **stream_options, &block)
     end
 
-    def self.before_execute_callbacks
-      @before_execute_callbacks ||= []
+    def self.tools
+      const_defined?(:TOOLS, false) ? self::TOOLS : []
     end
 
-    def self.after_execute_callbacks
-      @after_execute_callbacks ||= []
+    def self.find_tool(name)
+      tools.find { |tool| tool.tool_name == name }
     end
 
-    def self.inherited(subclass)
-      super
-      subclass.instance_variable_set(:@before_execute_callbacks, before_execute_callbacks.dup)
-      subclass.instance_variable_set(:@after_execute_callbacks, after_execute_callbacks.dup)
-      subclass.provider = provider
-      subclass.model = model
+    def tools
+      self.class.tools.map(&:definition)
     end
 
-    def initialize(provider = nil, model = nil)
-      @provider = provider || self.class.provider
-      @model = model || self.class.model
+    def system_prompt
+      nil
     end
 
-    def run
-      run_callbacks(:before_execute, prompt)
+    private
 
-      response = stream
+    def find_and_execute_tool(tool_request)
+      tool_name = tool_request.name
+      tool_input = tool_request.input
+      tool_class = self.class.find_tool(tool_name)
 
-      response_content = if respond_to?(:extract_response)
-        extract_response(response)
-      else
-        response[:choices][0][:content]
+      result = begin
+        if tool_class
+          execute_tool(tool_class, tool_input)
+        else
+          "Unknown tool: #{tool_name}"
+        end
+      rescue StandardError => e
+        "Error executing tool: #{e.message}"
       end
+      ToolResult.new(
+        type: "tool_result",
+        tool_use_id: tool_request.id,
+        content: result,
+      )
+    end
 
-      result = if respond_to?(:parse_response)
-        parse_response(response_content)
-      else
-        response_content
-      end
+    def execute_tool(tool_class, tool_input)
+      tool_class.new.execute(tool_input)
+    end
+
+    def run_tool_loop(input, provider: nil, model: nil, reasoning: nil, **options, &block)
+      response = stream(input, provider: provider, model: model, reasoning: reasoning, **options, &block)
 
-      run_callbacks(:after_execute, response, response_content)
+      while tool_requests(response).any?
+        input = prompt_with_tool_results(input, response, tool_requests(response))
+        response = stream(input, provider: provider, model: model, reasoning: reasoning, **options, &block)
+      end
 
-      result
+      response
     end
 
-    def stream(provider: nil, model: nil, **options)
-      stream_provider = provider || self.provider
-      stream_model = model || self.model
-      options[:model] = stream_model if stream_model
+    def tool_requests(response)
+      return [] unless response.respond_to?(:content)
 
-      stream_provider.stream(prompt, tools: tools, system: system_prompt, **options)
+      response.content.select { |content| content.respond_to?(:type) && content.type == "tool_use" }
     end
 
-    def tools
-      nil
+    def prompt_with_tool_results(input, response, requests)
+      messages = input.is_a?(Array) ? input.dup : [ { role: "user", content: input } ]
+      messages << response.to_h
+      messages << {
+        role: "user",
+        content: requests.map { |request| find_and_execute_tool(request).to_h }
+      }
+      messages
     end
 
-    def self.find_tool(tool_name)
-      tools.find { |tool| tool.tool_name == tool_name }
+    def default_stream_options(model: nil, reasoning: nil)
+      {
+        tools: tools,
+        system: system_prompt,
+        model: resolved_model(model),
+        reasoning: resolved_reasoning(reasoning),
+        cache_key: cache_key,
+        cache_retention: cache_retention
+      }.compact
     end
 
-    def system_prompt
-      nil
+    def resolved_provider(provider)
+      provider || self.provider
     end
 
-    private
+    def resolved_model(model)
+      model || self.model
+    end
+
+    def resolved_reasoning(reasoning)
+      reasoning || self.reasoning
+    end
 
     def run_callbacks(callback_type, *args)
-      callbacks = self.class.send("#{callback_type}_callbacks")
-      callbacks.each do |callback|
-        if callback.is_a?(Proc)
+      self.class.public_send("#{callback_type}_callbacks").each do |callback|
+        case callback
+        when Proc
           instance_exec(*args, &callback)
-        elsif callback.is_a?(Symbol) || callback.is_a?(String)
-          send(callback, *args)
+        when Symbol, String
+          public_send(callback, *args)
         end
       end
     end

data/lib/llm_gateway/utils.rb

@@ -4,16 +4,20 @@ module LlmGateway
   module Utils
     module_function
 
-    def deep_symbolize_keys(hash)
-      case hash
+    def symbolize_keys(hash)
+      hash.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+    end
+
+    def deep_symbolize_keys(value)
+      case value
       when Hash
-        hash.each_with_object({}) do |(key, value), result|
-          result[key.to_sym] = deep_symbolize_keys(value)
+        value.each_with_object({}) do |(key, nested_value), result|
+          result[symbolize_key(key)] = deep_symbolize_keys(nested_value)
         end
       when Array
-        hash.map { |item| deep_symbolize_keys(item) }
+        value.map { |item| deep_symbolize_keys(item) }
       else
-        hash
+        value
       end
     end
 
@@ -21,19 +25,118 @@ module LlmGateway
       !blank?(value)
     end
 
+    def presence(value)
+      present?(value) ? value : nil
+    end
+
     def blank?(value)
       case value
-      when nil
+      when nil, false
         true
-      when String
-        value.strip.empty?
-      when Array, Hash
-        value.empty?
-      when Numeric
+      when true, Numeric
         false
+      when String
+        value.match?(/\A[[:space:]]*\z/)
       else
-        value.respond_to?(:empty?) ? value.empty? : false
+        value.respond_to?(:empty?) ? !!value.empty? : false
       end
     end
+
+    def symbolize_key(key)
+      key.respond_to?(:to_sym) ? key.to_sym : key
+    rescue StandardError
+      key
+    end
+  end
+end
+
+unless Class.method_defined?(:class_attribute)
+  class Class
+    def class_attribute(*names, instance_accessor: true, instance_reader: instance_accessor, instance_writer: instance_accessor, instance_predicate: true, default: nil)
+      names.each do |name|
+        ivar = :"@#{name}"
+        instance_variable_set(ivar, default)
+
+        unset = Object.new
+
+        define_singleton_method(name) do |value = unset|
+          unless value.equal?(unset)
+            instance_variable_set(ivar, value)
+            next value
+          end
+
+          if instance_variable_defined?(ivar)
+            instance_variable_get(ivar)
+          elsif superclass.respond_to?(name)
+            superclass.public_send(name)
+          end
+        end
+
+        define_singleton_method("#{name}=") do |value|
+          instance_variable_set(ivar, value)
+        end
+
+        define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+        if instance_reader
+          define_method(name) do
+            if instance_variable_defined?(ivar)
+              instance_variable_get(ivar)
+            else
+              self.class.public_send(name)
+            end
+          end
+        end
+
+        define_method("#{name}=") { |value| instance_variable_set(ivar, value) } if instance_writer
+
+        define_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
+    end
+  end
+end
+
+class Object
+  def blank?
+    LlmGateway::Utils.blank?(self)
+  end
+
+  def present?
+    LlmGateway::Utils.present?(self)
+  end
+
+  def presence
+    LlmGateway::Utils.presence(self)
+  end
+end
+
+class Hash
+  def symbolize_keys
+    transform_keys { |key| LlmGateway::Utils.symbolize_key(key) }
+  end
+
+  def symbolize_keys!
+    replace(symbolize_keys)
+  end
+
+  def deep_symbolize_keys
+    LlmGateway::Utils.deep_symbolize_keys(self)
+  end
+
+  def deep_symbolize_keys!
+    replace(deep_symbolize_keys)
+  end
+
+  unless method_defined?(:except)
+    def except(*keys)
+      reject { |key, _| keys.include?(key) }
+    end
+  end
+
+  unless method_defined?(:except!)
+    def except!(*keys)
+      keys.each { |key| delete(key) }
+      self
+    end
   end
 end

data/lib/llm_gateway/version.rb

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

data/lib/llm_gateway.rb

@@ -7,6 +7,10 @@ require_relative "llm_gateway/base_client"
 require_relative "llm_gateway/client"
 require_relative "llm_gateway/prompt"
 require_relative "llm_gateway/tool"
+require_relative "llm_gateway/agents/event"
+require_relative "llm_gateway/agents/in_memory_session_manager"
+require_relative "llm_gateway/agents/file_session_manager"
+require_relative "llm_gateway/agents/harness"
 
 # Load clients - order matters for inheritance
 require_relative "llm_gateway/clients/anthropic"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-27 00:00:00.000000000 Z
+date: 2026-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -43,6 +43,7 @@ files:
 - Rakefile
 - docs/migration-guide.md
 - docs/migration_guide_0.6.0.md
+- docs/migration_guide_0.7.0.md
 - lib/llm_gateway.rb
 - lib/llm_gateway/adapters/adapter.rb
 - lib/llm_gateway/adapters/anthropic/acts_like_messages.rb
@@ -75,6 +76,15 @@ files:
 - lib/llm_gateway/adapters/option_mapper.rb
 - lib/llm_gateway/adapters/stream_mapper.rb
 - lib/llm_gateway/adapters/structs.rb
+- lib/llm_gateway/agents/event.rb
+- lib/llm_gateway/agents/file_session_manager.rb
+- lib/llm_gateway/agents/harness.rb
+- lib/llm_gateway/agents/in_memory_session_manager.rb
+- lib/llm_gateway/agents/tools/bash_tool.rb
+- lib/llm_gateway/agents/tools/edit_tool.rb
+- lib/llm_gateway/agents/tools/read_tool.rb
+- lib/llm_gateway/agents/tools/tool_utils.rb
+- lib/llm_gateway/agents/tools/write_tool.rb
 - lib/llm_gateway/base_client.rb
 - lib/llm_gateway/client.rb
 - lib/llm_gateway/clients/anthropic.rb