agentbill-sdk 5.0.1 → 9.4.0

data/lib/agentbill.rb

@@ -1,16 +1,24 @@
 require 'net/http'
 require 'json'
 require 'securerandom'
+require 'digest'
 require_relative 'agentbill/version'
 require_relative 'agentbill/tracer'
 
+require_relative 'agentbill/customers'
+require_relative 'agentbill/agents'
+require_relative 'agentbill/orders'
+
 module AgentBill
   class Client
-    attr_reader :config, :tracer
+    attr_reader :config, :tracer, :customers, :agents, :orders
 
     def initialize(config)
       @config = config
       @tracer = Tracer.new(config)
+      @customers = CustomersResource.new(config)
+      @agents = AgentsResource.new(config)
+      @orders = OrdersResource.new(config)
     end
 
     def self.init(config)
@@ -24,33 +32,21 @@ module AgentBill
       [1, text.to_s.length / 4].max
     end
 
-    def estimate_cost(model, input_tokens, output_tokens)
-      # Model pricing (per 1K tokens)
-      pricing = {
-        'gpt-4' => { input: 0.03, output: 0.06 },
-        'gpt-4o' => { input: 0.005, output: 0.015 },
-        'gpt-4o-mini' => { input: 0.00015, output: 0.0006 },
-        'claude-sonnet-4-5' => { input: 0.003, output: 0.015 },
-        'claude-opus-4-1-20250805' => { input: 0.015, output: 0.075 },
-        'claude-3-5-sonnet-20241022' => { input: 0.003, output: 0.015 },
-        'mistral-large-latest' => { input: 0.004, output: 0.012 },
-        'gemini-pro' => { input: 0.00025, output: 0.0005 }
-      }
-      
-      model_price = pricing[model] || { input: 0.001, output: 0.002 }
-      (input_tokens / 1000.0 * model_price[:input]) + (output_tokens / 1000.0 * model_price[:output])
-    end
+    # v9.1.0: estimate_cost() REMOVED. Cost is 100% server-side via model_pricing table.
 
     def validate_request(model, messages, estimated_output_tokens = 1000)
-      return { 'allowed' => true } unless @config[:daily_budget] || @config[:monthly_budget]
+      # Always validate when customer_id is present - backend will check DB policies
+      return { 'allowed' => true } unless @config[:customer_id]
       
-      uri = URI("#{@config[:base_url] || 'https://bgwyprqxtdreuutzpbgw.supabase.co'}/functions/v1/ai-cost-guard-router")
+      uri = URI("#{@config[:base_url] || 'https://api.agentbill.io'}/functions/v1/ai-cost-guard-router")
       
       payload = {
         api_key: @config[:api_key],
         customer_id: @config[:customer_id],
         model: model,
-        messages: messages
+        messages: messages,
+        daily_budget_override: @config[:daily_budget],
+        monthly_budget_override: @config[:monthly_budget]
       }
       
       begin
@@ -74,37 +70,8 @@ module AgentBill
       end
     end
 
-    def track_usage(model, provider, input_tokens, output_tokens, latency_ms, cost, event_name = 'ai_request')
-      uri = URI("#{@config[:base_url] || 'https://bgwyprqxtdreuutzpbgw.supabase.co'}/functions/v1/track-ai-usage")
-      
-      payload = {
-        api_key: @config[:api_key],
-        customer_id: @config[:customer_id],
-        agent_id: @config[:agent_id],
-        event_name: event_name,
-        model: model,
-        provider: provider,
-        prompt_tokens: input_tokens,
-        completion_tokens: output_tokens,
-        latency_ms: latency_ms,
-        cost: cost
-      }
-      
-      begin
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-        http.read_timeout = 10
-        
-        request = Net::HTTP::Post.new(uri.path)
-        request['Content-Type'] = 'application/json'
-        request.body = payload.to_json
-        
-        http.request(request)
-        puts "[AgentBill Cost Guard] Usage tracked: $#{format('%.4f', cost)}" if @config[:debug]
-      rescue => e
-        puts "[AgentBill Cost Guard] Tracking failed: #{e.message}" if @config[:debug]
-      end
-    end
+    # v7.17.3: track_usage method DELETED - all tracking now goes through OTEL spans
+    # Use self.tracer.start_span() + span.finish() + self.tracer.flush_sync() instead
 
     public
 
@@ -132,9 +99,59 @@ module AgentBill
           raise error
         end
         
+        # v7.6.10: Check for cached response from semantic cache
+        # CRITICAL FIX: Router sends cost_saved/tokens_saved at top level
+        if validation['cached'] && validation['response_data']
+          puts "[AgentBill] ✓ Cache hit - returning cached response" if config[:debug]
+          
+          # v7.6.10 FIX: Check both nested 'cache'/'cache_info' AND top-level fields
+          cache_info = validation['cache'] || validation['cache_info'] || {}
+          cached_response = validation['response_data']
+          usage = cached_response['usage'] || {}
+          
+          # v7.6.10 FIX: Extract from cache_info OR top-level validation
+          tokens_saved = cache_info['tokens_saved'] || validation['tokens_saved'] || usage['total_tokens'] || 0
+          cost_saved = cache_info['cost_saved'] || validation['cost_saved'] || 0
+          cached_input_tokens = usage['prompt_tokens'] || (tokens_saved * 0.2).to_i
+          cached_output_tokens = usage['completion_tokens'] || (tokens_saved - cached_input_tokens)
+          cached_total_tokens = tokens_saved > 0 ? tokens_saved : (cached_input_tokens + cached_output_tokens)
+          
+          # v7.6.10 CRITICAL FIX: Set gen_ai.usage.* to 0 for cache hits
+          # This prevents OTEL ingestion from calculating cost for cached responses
+          span = tracer.start_span('openai.chat.completion', {
+            'gen_ai.system' => 'openai',
+            'gen_ai.request.model' => model,
+            'gen_ai.operation.name' => 'chat',
+            'model' => model,
+            'provider' => 'openai',
+            'agentbill.from_cache' => true,
+            'agentbill.cache_hit' => true,
+            # OTEL cost calculation attributes - set to 0 for cache hits
+            'gen_ai.usage.input_tokens' => 0,
+            'gen_ai.usage.output_tokens' => 0,
+            'gen_ai.usage.total_tokens' => 0,
+            # Informational attributes - actual cached token counts
+            'agentbill.cached_input_tokens' => cached_input_tokens,
+            'agentbill.cached_output_tokens' => cached_output_tokens,
+            'agentbill.cached_total_tokens' => cached_total_tokens,
+            'agentbill.tokens_saved' => tokens_saved,
+            'agentbill.cost_saved' => cost_saved
+          })
+          span.set_status(0)
+          span.finish
+          tracer.flush
+          
+          return cached_response
+        end
+        
         # Phase 2: Execute AI call
         start_time = Time.now
         span = tracer.start_span('openai.chat.completion', {
+          # ✅ OTEL GenAI compliant attributes
+          'gen_ai.system' => 'openai',
+          'gen_ai.request.model' => model,
+          'gen_ai.operation.name' => 'chat',
+          # ⚠️ Backward compatibility
           'model' => model,
           'provider' => 'openai'
         })
@@ -143,14 +160,19 @@ module AgentBill
           response = original_method.call(params)
           latency = ((Time.now - start_time) * 1000).round
           
-          # Phase 3: Track actual usage
+          # NOTE: wrap() only creates OTEL spans, NOT signals
+          # Signals should be created explicitly via track_signal()
           input_tokens = response.dig(:usage, :prompt_tokens) || 0
           output_tokens = response.dig(:usage, :completion_tokens) || 0
-          cost = config[:_client].send(:estimate_cost, model, input_tokens, output_tokens)
-          
-          config[:_client].send(:track_usage, model, 'openai', input_tokens, output_tokens, latency, cost, event_name)
+          # v9.1.0: Cost calculated server-side from token counts in span
           
           span.set_attributes({
+            # ✅ OTEL GenAI compliant attributes
+            'gen_ai.usage.input_tokens' => input_tokens,
+            'gen_ai.usage.output_tokens' => output_tokens,
+            'gen_ai.usage.total_tokens' => response.dig(:usage, :total_tokens),
+            'gen_ai.response.id' => response.dig(:id),
+            # ⚠️ Backward compatibility
             'response.prompt_tokens' => input_tokens,
             'response.completion_tokens' => output_tokens,
             'response.total_tokens' => response.dig(:usage, :total_tokens),
@@ -158,16 +180,25 @@ module AgentBill
           })
           span.set_status(0)
           
-          puts "[AgentBill Cost Guard] ✓ Protected call completed: $#{format('%.4f', cost)}" if config[:debug]
+          puts "[AgentBill] ✓ OpenAI call: #{input_tokens}in/#{output_tokens}out tokens (cost calculated server-side)" if config[:debug]
+          
+          # v7.5.0: Cache AI response for semantic caching
+          response_content = response.dig(:choices, 0, :message, :content) || ''
+          # v9.1.0: Fixed prompt_hash to match backend algorithm (SHA-256 of JSON, full hash)
+          prompt_text = JSON.generate(messages)
+          prompt_hash = Digest::SHA256.hexdigest(prompt_text)
+          config[:_client].send(:cache_response, model, prompt_hash, response_content, input_tokens + output_tokens, 0)
+          
           response
         rescue => e
           span.set_status(1, e.message)
           raise
         ensure
           span.finish
+          # Auto-flush spans to prevent data loss
+          tracer.flush
         end
       end
-      
       # Store reference to self for helper methods
       @config[:_client] = self
       client
@@ -196,6 +227,11 @@ module AgentBill
         # Phase 2: Execute AI call
         start_time = Time.now
         span = tracer.start_span('anthropic.message', {
+          # ✅ OTEL GenAI compliant attributes
+          'gen_ai.system' => 'anthropic',
+          'gen_ai.request.model' => model,
+          'gen_ai.operation.name' => 'chat',
+          # ⚠️ Backward compatibility
           'model' => model,
           'provider' => 'anthropic'
         })
@@ -204,30 +240,34 @@ module AgentBill
           response = original_method.call(params)
           latency = ((Time.now - start_time) * 1000).round
           
-          # Phase 3: Track actual usage
+          # NOTE: wrap() only creates OTEL spans, NOT signals
           input_tokens = response.dig(:usage, :input_tokens) || 0
           output_tokens = response.dig(:usage, :output_tokens) || 0
-          cost = config[:_client].send(:estimate_cost, model, input_tokens, output_tokens)
-          
-          config[:_client].send(:track_usage, model, 'anthropic', input_tokens, output_tokens, latency, cost)
+          # v9.1.0: Cost calculated server-side from token counts in span
           
           span.set_attributes({
+            # ✅ OTEL GenAI compliant attributes
+            'gen_ai.usage.input_tokens' => input_tokens,
+            'gen_ai.usage.output_tokens' => output_tokens,
+            'gen_ai.response.id' => response.dig(:id),
+            # ⚠️ Backward compatibility
             'response.input_tokens' => input_tokens,
             'response.output_tokens' => output_tokens,
             'latency_ms' => latency
           })
           span.set_status(0)
           
-          puts "[AgentBill Cost Guard] ✓ Protected call completed: $#{format('%.4f', cost)}" if config[:debug]
+          puts "[AgentBill] ✓ OTEL span created: $#{format('%.4f', cost)} (use track_signal() for signals)" if config[:debug]
           response
         rescue => e
           span.set_status(1, e.message)
           raise
         ensure
           span.finish
+          # Auto-flush spans
+          tracer.flush
         end
       end
-      
       # Store reference to self for helper methods
       @config[:_client] = self
       client
@@ -274,25 +314,59 @@ module AgentBill
     def track_signal(**params)
       raise ArgumentError, "event_name is required" unless params[:event_name]
       
-      uri = URI("#{@config[:base_url] || 'https://bgwyprqxtdreuutzpbgw.supabase.co'}/functions/v1/record-signals")
+      # v7.17.1: Unified OTEL model - route through otel-collector
+      uri = URI("#{@config[:base_url] || 'https://api.agentbill.io'}/functions/v1/otel-collector")
       
-      # Add timestamp if not provided
-      params[:timestamp] ||= Time.now.to_f
+      # Generate trace context
+      trace_id = params[:trace_id] || SecureRandom.hex(16)
+      span_id = params[:span_id] || SecureRandom.hex(8)
+      now_ns = (Time.now.to_f * 1_000_000_000).to_i
       
-      # Auto-fill customer_id or customer_external_id from config if not provided
-      if !params[:customer_id] && !params[:customer_external_id] && @config[:customer_id]
-        # Check if it's a UUID format - send as customer_id, else customer_external_id
-        uuid_regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
-        is_uuid = @config[:customer_id].match?(uuid_regex)
-        if is_uuid
-          params[:customer_id] = @config[:customer_id]
-        else
-          params[:customer_external_id] = @config[:customer_id]
-        end
-      end
+      # Auto-fill customer_id from config if not provided
+      customer_id = params[:customer_id] || params[:customer_external_id] || @config[:customer_id] || ""
+      agent_id = params[:agent_id] || params[:agent_external_id] || @config[:agent_id] || ""
       
-      # Remove nil values
-      payload = params.reject { |_, v| v.nil? }
+      # Build OTEL-compliant span attributes
+      attributes = [
+        { "key" => "agentbill.event_name", "value" => { "stringValue" => params[:event_name] } },
+        { "key" => "agentbill.is_business_event", "value" => { "boolValue" => true } },
+        { "key" => "agentbill.data_source", "value" => { "stringValue" => "ruby-sdk" } },
+      ]
+      
+      attributes << { "key" => "agentbill.customer_id", "value" => { "stringValue" => customer_id.to_s } } if customer_id && customer_id != ""
+      attributes << { "key" => "agentbill.agent_id", "value" => { "stringValue" => agent_id.to_s } } if agent_id && agent_id != ""
+      attributes << { "key" => "agentbill.revenue", "value" => { "doubleValue" => params[:revenue] } } if params[:revenue]
+      attributes << { "key" => "agentbill.currency", "value" => { "stringValue" => params[:currency] || "USD" } } if params[:revenue]
+      attributes << { "key" => "agentbill.model", "value" => { "stringValue" => params[:model] } } if params[:model]
+      attributes << { "key" => "agentbill.session_id", "value" => { "stringValue" => params[:session_id] } } if params[:session_id]
+      attributes << { "key" => "agentbill.metadata", "value" => { "stringValue" => params[:metadata].to_json } } if params[:metadata]
+      
+      # Build OTEL payload
+      otel_payload = {
+        "resourceSpans" => [{
+          "resource" => {
+            "attributes" => [
+              { "key" => "service.name", "value" => { "stringValue" => "agentbill-ruby-sdk" } },
+              { "key" => "agentbill.customer_id", "value" => { "stringValue" => customer_id.to_s } },
+              { "key" => "agentbill.agent_id", "value" => { "stringValue" => agent_id.to_s } },
+            ]
+          },
+          "scopeSpans" => [{
+            "scope" => { "name" => "agentbill.signals", "version" => "7.17.3" },
+            "spans" => [{
+              "traceId" => trace_id,
+              "spanId" => span_id,
+              "parentSpanId" => params[:parent_span_id] || "",
+              "name" => "agentbill.trace.signal",
+              "kind" => 1,
+              "startTimeUnixNano" => now_ns.to_s,
+              "endTimeUnixNano" => now_ns.to_s,
+              "attributes" => attributes,
+              "status" => { "code" => 1 }
+            }]
+          }]
+        }]
+      }
       
       begin
         http = Net::HTTP.new(uri.host, uri.port)
@@ -301,13 +375,12 @@ module AgentBill
         request = Net::HTTP::Post.new(uri.path)
         request['X-API-Key'] = @config[:api_key]
         request['Content-Type'] = 'application/json'
-        request.body = payload.to_json
+        request.body = otel_payload.to_json
         
         response = http.request(request)
         
         if @config[:debug]
-          trace_info = params[:trace_id] ? " (trace: #{params[:trace_id]})" : ""
-          puts "[AgentBill] Signal tracked: #{params[:event_name]}#{trace_info}"
+          puts "[AgentBill] Signal tracked via OTEL: #{params[:event_name]} (trace: #{trace_id})"
         end
         
         response.code == '200'
@@ -319,8 +392,122 @@ module AgentBill
       end
     end
 
+    # Track a conversion event for prompt profitability analysis
+    # Links conversions to AI prompts to calculate ROI per prompt
+    #
+    # @param event_type [String] Type of conversion (e.g., 'purchase', 'signup', 'trial_start')
+    # @param event_value [Float] Revenue amount from the conversion
+    # @param signal_id [String, nil] Optional UUID linking to specific AI signal/prompt
+    # @param session_id [String, nil] Optional session identifier
+    # @param attribution_window_hours [Integer] Time window for attribution (default: 24 hours)
+    # @param currency [String] Currency code (default: 'USD')
+    # @param metadata [Hash, nil] Optional additional data
+    # @return [Hash] Response with success status and conversion_id
+    #
+    # Example:
+    #   # Track a purchase conversion
+    #   result = agentbill.track_conversion(
+    #     event_type: 'purchase',
+    #     event_value: 99.99,
+    #     currency: 'USD'
+    #   )
+    #
+    #   # Link conversion to specific AI prompt
+    #   result = agentbill.track_conversion(
+    #     event_type: 'trial_signup',
+    #     event_value: 29.99,
+    #     signal_id: 'signal-uuid-from-prompt',
+    #     session_id: 'session-123'
+    #   )
+    def track_conversion(event_type:, event_value:, signal_id: nil, session_id: nil, attribution_window_hours: 24, currency: 'USD', metadata: nil)
+      uri = URI("#{@config[:base_url] || 'https://api.agentbill.io'}/functions/v1/track-conversion")
+      
+      payload = {
+        api_key: @config[:api_key],
+        customer_id: @config[:customer_id],
+        event_type: event_type,
+        event_value: event_value,
+        signal_id: signal_id,
+        session_id: session_id,
+        attribution_window_hours: attribution_window_hours,
+        currency: currency,
+        metadata: metadata
+      }
+      
+      begin
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        
+        request = Net::HTTP::Post.new(uri.path)
+        request['Content-Type'] = 'application/json'
+        request.body = payload.to_json
+        
+        response = http.request(request)
+        data = JSON.parse(response.body)
+        
+        if response.code != '200'
+          return {
+            success: false,
+            error: data['error'] || "HTTP #{response.code}"
+          }
+        end
+        
+        if @config[:debug]
+          puts "[AgentBill] Conversion tracked: #{event_type} = $#{event_value} (ID: #{data['conversion_id']})"
+        end
+        
+        {
+          success: true,
+          conversion_id: data['conversion_id']
+        }
+      rescue => e
+        if @config[:debug]
+          puts "[AgentBill] Failed to track conversion: #{e.message}"
+        end
+        {
+          success: false,
+          error: e.message
+        }
+      end
+    end
+
     def flush
       @tracer.flush
     end
+    
+    private
+    
+    # Cache AI response for semantic caching (v7.5.0)
+    def cache_response(model, prompt_hash, response_content, tokens_used = 0, cost = 0.0)
+      return if response_content.nil? || response_content.empty?
+      
+      uri = URI("#{@config[:base_url] || 'https://api.agentbill.io'}/functions/v1/cache-ai-response")
+      
+      payload = {
+        api_key: @config[:api_key],
+        prompt_hash: prompt_hash,
+        response_content: response_content,
+        model: model,
+        tokens_used: tokens_used,
+        cost: cost,
+        customer_id: @config[:customer_id],
+        agent_id: @config[:agent_id]
+      }
+      
+      begin
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.read_timeout = 5
+        
+        request = Net::HTTP::Post.new(uri.path)
+        request['Content-Type'] = 'application/json'
+        request.body = payload.to_json
+        
+        http.request(request)
+        puts "[AgentBill] Response cached for semantic caching" if @config[:debug]
+      rescue => e
+        puts "[AgentBill] Cache response failed: #{e.message}" if @config[:debug]
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: agentbill-sdk
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 9.4.0
 platform: ruby
 authors:
 - AgentBill
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-06 00:00:00.000000000 Z
+date: 2026-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,12 +65,26 @@ files:
 - agentbill.gemspec
 - examples/anthropic_basic.rb
 - examples/manual_otel_tracking.rb
+- examples/ollama_basic.rb
 - examples/openai_basic.rb
 - examples/openai_custom_event.rb
+- examples/perplexity_basic.rb
 - examples/zero_config.rb
 - lib/agentbill.rb
+- lib/agentbill/agents.rb
+- lib/agentbill/attributes.rb
+- lib/agentbill/customers.rb
+- lib/agentbill/distributed.rb
+- lib/agentbill/exceptions.rb
+- lib/agentbill/ollama_wrapper.rb
+- lib/agentbill/orders.rb
+- lib/agentbill/perplexity_wrapper.rb
+- lib/agentbill/signal_types.rb
+- lib/agentbill/signals.rb
 - lib/agentbill/tracer.rb
+- lib/agentbill/tracing.rb
 - lib/agentbill/version.rb
+- lib/agentbill/wrappers.rb
 homepage: https://github.com/Agent-Bill/Ruby
 licenses:
 - MIT