llm_gateway 0.6.0 → 0.8.0

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/proxy/adapter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module LlmGateway
+  module Proxy
+    class Adapter
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      def stream(message, tools: nil, system: nil, **options, &block)
+        target_adapter = LlmGateway.build_provider(client.target_config.merge(provider: client.target_provider))
+        mapper_class = target_adapter.stream_mapper_class
+        raise LlmGateway::Errors::MissingMapperForProvider, "No stream_mapper configured" unless mapper_class
+
+        mapper = mapper_class.new(
+          provider: LlmGateway::Client.provider_id_from_client(target_adapter.client),
+          api: target_adapter.stream_api_name
+        )
+
+        client.stream(normalize_messages(message), tools: tools, system: normalize_system(system), **options) do |chunk|
+          mapper.map(chunk, &block)
+        end
+
+        mapper.result
+      end
+
+      private
+
+      def normalize_system(system)
+        if system.nil?
+          []
+        elsif system.is_a?(String)
+          [ { role: "system", content: system } ]
+        elsif system.is_a?(Array)
+          system
+        else
+          raise ArgumentError, "System parameter must be a string or array, got #{system.class}"
+        end
+      end
+
+      def normalize_messages(message)
+        message.is_a?(String) ? [ { role: "user", content: message } ] : message
+      end
+    end
+  end
+end

data/lib/llm_gateway/proxy/client.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module LlmGateway
+  module Proxy
+    class Client
+      attr_reader :url, :target_provider, :target_config, :path
+
+      def initialize(url:, target_provider:, target_config: {}, api_key: nil, path: "/agent/llm_proxy", **_options)
+        @url = url.to_s.sub(%r{/+\z}, "")
+        @target_provider = target_provider.to_s
+        @target_config = (target_config || {}).transform_keys(&:to_sym)
+        @api_key = api_key
+        @path = path.to_s.start_with?("/") ? path.to_s : "/#{path}"
+      end
+
+      def stream(messages, tools: nil, system: nil, **options, &block)
+        uri = URI("#{url}#{path}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.read_timeout = 480
+        http.open_timeout = 10
+
+        request = Net::HTTP::Post.new(uri)
+        request["content-type"] = "application/json"
+        request["accept"] = "text/event-stream"
+        request["accept-encoding"] = "identity"
+        request["authorization"] = "Bearer #{@api_key}" if @api_key
+        request.body = {
+          provider: target_provider,
+          config: target_config,
+          messages: messages,
+          system: system,
+          tools: tools,
+          options: options
+        }.to_json
+
+        http.request(request) do |response|
+          unless response.code.to_i == 200
+            body = +""
+            response.read_body { |chunk| body << chunk }
+            raise Errors::APIStatusError.new("Proxy request failed with status #{response.code}: #{body}", nil)
+          end
+
+          parse_sse_stream(response, &block)
+        end
+      end
+
+      private
+
+      def parse_sse_stream(response)
+        buffer = +""
+        response.read_body do |chunk|
+          buffer << chunk
+          while (idx = buffer.index("\n\n"))
+            raw_event = buffer.slice!(0, idx + 2)
+            event_type = nil
+            data_lines = []
+
+            raw_event.each_line do |line|
+              line = line.chomp
+              event_type = line.sub(/^event:\s*/, "") if line.start_with?("event:")
+              data_lines << line.sub(/^data:\s*/, "") if line.start_with?("data:")
+            end
+
+            next if data_lines.empty?
+
+            data_str = data_lines.join("\n")
+            next if data_str == "[DONE]"
+
+            data = begin
+              JSON.parse(data_str).deep_symbolize_keys
+            rescue JSON::ParserError
+              { raw: data_str }
+            end
+            yield({ event: event_type, data: data })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/llm_gateway/proxy/server.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+
+module LlmGateway
+  module Proxy
+    class Server
+      PATH = "/agent/llm_proxy"
+
+      def call(env)
+        return not_found unless env["REQUEST_METHOD"] == "POST" && env["PATH_INFO"] == PATH
+
+        request = JSON.parse(env["rack.input"].read).deep_symbolize_keys
+        options = request[:options] || {}
+        options = options.merge(model: request[:model]) if request.key?(:model)
+        adapter = build_adapter(request)
+
+        body = Enumerator.new do |yielder|
+          adapter.raw_stream(
+            request[:messages],
+            system: request[:system],
+            tools: request[:tools],
+            **options
+          ) do |chunk|
+            yielder << encode_sse(chunk)
+          end
+        end
+
+        [ 200, { "content-type" => "text/event-stream", "cache-control" => "no-cache" }, body ]
+      rescue KeyError, JSON::ParserError, ArgumentError => e
+        json_error(400, e.message)
+      rescue Errors::UnsupportedProvider => e
+        json_error(404, e.message)
+      rescue StandardError => e
+        json_error(500, e.message)
+      end
+
+      private
+
+      def build_adapter(request)
+        provider = request.fetch(:provider)
+        config = (request[:config] || {}).merge(provider: provider)
+
+        LlmGateway.build_provider(config)
+      end
+
+      def encode_sse(chunk)
+        event = chunk[:event]
+        data = chunk[:data]
+        out = +""
+        out << "event: #{event}\n" if event
+        JSON.generate(data).each_line { |line| out << "data: #{line.chomp}\n" }
+        out << "\n"
+      end
+
+      def json_error(status, message)
+        [ status, { "content-type" => "application/json" }, [ { error: message }.to_json ] ]
+      end
+
+      def not_found
+        [ 404, { "content-type" => "application/json" }, [ { error: "Not found" }.to_json ] ]
+      end
+    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.8.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"
@@ -44,6 +48,9 @@ require_relative "llm_gateway/adapters/groq/chat_completions_adapter"
 
 # Load provider registry
 require_relative "llm_gateway/provider_registry"
+require_relative "llm_gateway/proxy/client"
+require_relative "llm_gateway/proxy/adapter"
+require_relative "llm_gateway/proxy/server"
 
 module LlmGateway
   class Error < StandardError; end
@@ -106,7 +113,7 @@ module LlmGateway
     entry = ProviderRegistry.resolve(provider_name)
 
     client = entry[:client].new(**config)
-    entry[:adapter].new(client)
+    entry[:adapter].new(client, provider_key: provider_name)
   end
 
   def self.configure(configs)
@@ -156,4 +163,8 @@ module LlmGateway
   ProviderRegistry.register("openai_codex",
     client: Clients::OpenAI,
     adapter: Adapters::OpenAICodex::ResponsesAdapter)
+
+  ProviderRegistry.register("proxy",
+    client: Proxy::Client,
+    adapter: Proxy::Adapter)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: llm_gateway
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - billybonks
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-27 00:00:00.000000000 Z
+date: 2026-06-06 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
@@ -87,6 +97,9 @@ files:
 - lib/llm_gateway/errors.rb
 - lib/llm_gateway/prompt.rb
 - lib/llm_gateway/provider_registry.rb
+- lib/llm_gateway/proxy/adapter.rb
+- lib/llm_gateway/proxy/client.rb
+- lib/llm_gateway/proxy/server.rb
 - lib/llm_gateway/tool.rb
 - lib/llm_gateway/utils.rb
 - lib/llm_gateway/version.rb