llm_gateway 0.5.0 → 0.7.0

data/lib/llm_gateway/prompt.rb

@@ -2,94 +2,149 @@
 
 module LlmGateway
   class Prompt
-    attr_reader :model
+    class_attribute :provider, :model, :reasoning
+    class_attribute :before_execute_callbacks, :after_execute_callbacks, instance_accessor: false, default: []
+    attr_accessor :cache_key, :cache_retention
 
     def self.before_execute(*methods, &block)
-      before_execute_callbacks.concat(methods)
-      before_execute_callbacks << block if block_given?
+      self.before_execute_callbacks += methods
+      self.before_execute_callbacks += [ block ] if block_given?
     end
 
     def self.after_execute(*methods, &block)
-      after_execute_callbacks.concat(methods)
-      after_execute_callbacks << block if block_given?
+      self.after_execute_callbacks += methods
+      self.after_execute_callbacks += [ block ] if block_given?
     end
 
-    def self.before_execute_callbacks
-      @before_execute_callbacks ||= []
+    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 self.after_execute_callbacks
-      @after_execute_callbacks ||= []
+    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
+
+      run_callbacks(:before_execute, input)
+
+      response = run_tool_loop(input, provider: resolved_provider(provider), model: model, reasoning: reasoning, **options, &block)
+
+      run_callbacks(:after_execute, response)
+
+      response
     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)
+    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.tools
+      const_defined?(:TOOLS, false) ? self::TOOLS : []
     end
 
-    def initialize(model)
-      @model = model
-      @connection = if model.is_a?(String)
-        LlmGateway.configured_clients.values.find do |client|
-          client.client.model_key == model
+    def self.find_tool(name)
+      tools.find { |tool| tool.tool_name == name }
+    end
+
+    def tools
+      self.class.tools.map(&:definition)
+    end
+
+    def system_prompt
+      nil
+    end
+
+    private
+
+    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)
+
+      result = begin
+        if tool_class
+          execute_tool(tool_class, tool_input)
+        else
+          "Unknown tool: #{tool_name}"
         end
-      else
-        model
+      rescue StandardError => e
+        "Error executing tool: #{e.message}"
       end
+      ToolResult.new(
+        type: "tool_result",
+        tool_use_id: tool_request.id,
+        content: result,
+      )
     end
 
-    def run
-      run_callbacks(:before_execute, prompt)
+    def execute_tool(tool_class, tool_input)
+      tool_class.new.execute(tool_input)
+    end
 
-      response = post
+    def run_tool_loop(input, provider: nil, model: nil, reasoning: nil, **options, &block)
+      response = stream(input, provider: provider, model: model, reasoning: reasoning, **options, &block)
 
-      response_content = if respond_to?(:extract_response)
-        extract_response(response)
-      else
-        response[:choices][0][: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 = if respond_to?(:parse_response)
-        parse_response(response_content)
-      else
-        response_content
-      end
+      response
+    end
 
-      run_callbacks(:after_execute, response, response_content)
+    def tool_requests(response)
+      return [] unless response.respond_to?(:content)
 
-      result
+      response.content.select { |content| content.respond_to?(:type) && content.type == "tool_use" }
     end
 
-    def post
-      if @connection
-        @connection.chat(prompt, tools: tools, system: system_prompt)
-      else
-        LlmGateway::Client.chat(model, prompt, tools: tools, system: system_prompt)
-      end
+    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 tools
-      nil
+    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 self.find_tool(tool_name)
-      tools.find { |tool| tool.tool_name == tool_name }
+    def resolved_provider(provider)
+      provider || self.provider
     end
 
-    def system_prompt
-      nil
+    def resolved_model(model)
+      model || self.model
     end
 
-    private
+    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.5.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"
@@ -100,6 +104,9 @@ module LlmGateway
   def self.build_provider(config)
     config = config.transform_keys(&:to_sym)
     provider_name = config.delete(:provider)
+    if config.key?(:model_key)
+      raise ArgumentError, "model_key is no longer a provider option; pass model: to chat/stream instead"
+    end
     entry = ProviderRegistry.resolve(provider_name)
 
     client = entry[:client].new(**config)
@@ -153,25 +160,4 @@ module LlmGateway
   ProviderRegistry.register("openai_codex",
     client: Clients::OpenAI,
     adapter: Adapters::OpenAICodex::ResponsesAdapter)
-
-  # Backward-compatible aliases (deprecated)
-  ProviderRegistry.register("anthropic_apikey_messages",
-    client: Clients::Anthropic,
-    adapter: Adapters::Anthropic::MessagesAdapter)
-
-  ProviderRegistry.register("openai_apikey_completions",
-    client: Clients::OpenAI,
-    adapter: Adapters::OpenAI::ChatCompletionsAdapter)
-
-  ProviderRegistry.register("openai_apikey_responses",
-    client: Clients::OpenAI,
-    adapter: Adapters::OpenAI::ResponsesAdapter)
-
-  ProviderRegistry.register("groq_apikey_completions",
-    client: Clients::Groq,
-    adapter: Adapters::Groq::ChatCompletionsAdapter)
-
-  ProviderRegistry.register("openai_oauth_codex",
-    client: Clients::OpenAI,
-    adapter: Adapters::OpenAICodex::ResponsesAdapter)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-20 00:00:00.000000000 Z
+date: 2026-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -42,6 +42,8 @@ files:
 - README.md
 - 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
@@ -74,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