agentbill-sdk 2.0.1 → 7.17.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/pricing'
+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,23 @@ 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])
+    def estimate_cost(model, input_tokens, output_tokens, provider = 'openai')
+      Pricing.calculate_cost(model, input_tokens, output_tokens, provider)
     end
 
     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,18 +72,42 @@ module AgentBill
       end
     end
 
-    def track_usage(model, provider, input_tokens, output_tokens, latency_ms, cost)
-      uri = URI("#{@config[:base_url] || 'https://bgwyprqxtdreuutzpbgw.supabase.co'}/functions/v1/track-ai-usage")
+    # NOTE: track_usage is deprecated in v7.0.2 - signals now go through OTEL collector
+    def track_usage(model, provider, input_tokens, output_tokens, latency_ms, cost, event_name = 'ai_request', trace_id = nil, span_id = nil)
+      # v7.0.2: Route signals through otel-collector with proper span format
+      uri = URI("#{@config[:base_url] || 'https://api.agentbill.io'}/functions/v1/otel-collector")
+      
+      trace_id ||= SecureRandom.hex(16)
+      span_id ||= SecureRandom.hex(8)
+      now_ns = (Time.now.to_f * 1_000_000_000).to_i.to_s
       
       payload = {
-        api_key: @config[:api_key],
-        customer_id: @config[:customer_id],
-        model: model,
-        provider: provider,
-        prompt_tokens: input_tokens,
-        completion_tokens: output_tokens,
-        latency_ms: latency_ms,
-        cost: cost
+        resourceSpans: [{
+          resource: {
+            attributes: [
+              { key: 'service.name', value: { stringValue: 'agentbill-ruby-sdk' } },
+              { key: 'agentbill.customer_id', value: { stringValue: @config[:customer_id] || '' } }
+            ]
+          },
+          scopeSpans: [{
+            scope: { name: 'agentbill.signals', version: '7.16.1' },
+            spans: [{
+              traceId: trace_id,
+              spanId: span_id,
+              name: 'agentbill.trace.signal',
+              kind: 1,
+              startTimeUnixNano: now_ns,
+              endTimeUnixNano: now_ns,
+              attributes: [
+                { key: 'agentbill.event_name', value: { stringValue: event_name } },
+                { key: 'agentbill.is_business_event', value: { boolValue: true } },
+                { key: 'gen_ai.request.model', value: { stringValue: model } },
+                { key: 'gen_ai.system', value: { stringValue: provider } }
+              ],
+              status: { code: 1 }
+            }]
+          }]
+        }]
       }
       
       begin
@@ -95,12 +117,13 @@ module AgentBill
         
         request = Net::HTTP::Post.new(uri.path)
         request['Content-Type'] = 'application/json'
+        request['x-api-key'] = @config[:api_key]
         request.body = payload.to_json
         
         http.request(request)
-        puts "[AgentBill Cost Guard] Usage tracked: $#{format('%.4f', cost)}" if @config[:debug]
+        puts "[AgentBill] Usage tracked via OTEL: $#{format('%.4f', cost)}" if @config[:debug]
       rescue => e
-        puts "[AgentBill Cost Guard] Tracking failed: #{e.message}" if @config[:debug]
+        puts "[AgentBill] Tracking failed: #{e.message}" if @config[:debug]
       end
     end
 
@@ -116,6 +139,10 @@ module AgentBill
         messages = params[:messages] || []
         max_tokens = params[:max_tokens] || params[:max_completion_tokens] || 1000
         
+        # Extract event_name from agentbill_options if provided (don't pass to OpenAI)
+        agentbill_options = params.delete(:agentbill_options) || {}
+        event_name = agentbill_options[:event_name] || 'ai_request'
+        
         # Phase 1: Validate budget BEFORE API call
         validation = config[:_client].send(:validate_request, model, messages, max_tokens)
         unless validation['allowed']
@@ -126,9 +153,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'
         })
@@ -137,14 +214,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)
-          
           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),
@@ -152,16 +234,24 @@ module AgentBill
           })
           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]
+          
+          # v7.5.0: Cache AI response for semantic caching
+          response_content = response.dig(:choices, 0, :message, :content) || ''
+          prompt_text = messages.map { |m| m[:content] }.join(' ')
+          prompt_hash = Digest::SHA256.hexdigest(prompt_text)[0..15]
+          config[:_client].send(:cache_response, model, prompt_hash, response_content, input_tokens + output_tokens, cost)
+          
           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
@@ -190,6 +280,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'
         })
@@ -198,39 +293,45 @@ 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)
+          cost = config[:_client].send(:estimate_cost, model, input_tokens, output_tokens, 'anthropic')
           
           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
     end
 
-    # Track a comprehensive signal with all 68 parameters
+    # Track a comprehensive signal with all 68 parameters including trace_id and span_id
     #
-    # Supports all parameters:
+    # Supports optional trace_id and span_id for OTEL correlation:
     # - event_name (required)
+    # - trace_id (optional) - For correlating with OTEL spans for cost reconciliation
+    # - span_id (optional) - For correlating with OTEL spans for cost reconciliation
     # - data_source, timestamp
     # - agent_external_id, customer_external_id, account_external_id, user_external_id,
     #   order_external_id, session_id, conversation_id, thread_id
@@ -243,26 +344,46 @@ module AgentBill
     # - feedback_score, user_satisfaction, error_type, error_message, retry_count, success_rate
     # - tags, category, priority, severity, compliance_flag, data_classification
     # - product_id, feature_flag, environment, deployment_version, region, tenant_id
-    # - parent_span_id, trace_id
+    # - parent_span_id
     # - custom_dimensions, metadata, data
     #
     # Example:
+    #   # Basic tracking
     #   agentbill.track_signal(
     #     event_name: "user_conversion",
     #     revenue: 99.99,
-    #     customer_external_id: "cust_123",
-    #     experiment_id: "exp_abc",
-    #     conversion_type: "purchase",
-    #     tags: ["checkout", "success"]
+    #     customer_external_id: "cust_123"
+    #   )
+    #   
+    #   # With OTEL correlation
+    #   span = agentbill.tracer.start_span('ai_completion')
+    #   # ... make AI call ...
+    #   agentbill.track_signal(
+    #     event_name: "ai_request",
+    #     revenue: 5.00,
+    #     trace_id: span.trace_id,  # Optional
+    #     span_id: span.span_id     # Optional
     #   )
     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")
+      uri = URI("#{@config[:base_url] || 'https://api.agentbill.io'}/functions/v1/record-signals")
       
       # Add timestamp if not provided
       params[:timestamp] ||= Time.now.to_f
       
+      # 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
+      
       # Remove nil values
       payload = params.reject { |_, v| v.nil? }
       
@@ -271,14 +392,15 @@ module AgentBill
         http.use_ssl = true
         
         request = Net::HTTP::Post.new(uri.path)
-        request['Authorization'] = "Bearer #{@config[:api_key]}"
+        request['X-API-Key'] = @config[:api_key]
         request['Content-Type'] = 'application/json'
         request.body = payload.to_json
         
         response = http.request(request)
         
         if @config[:debug]
-          puts "[AgentBill] Signal tracked: #{params[:event_name]}"
+          trace_info = params[:trace_id] ? " (trace: #{params[:trace_id]})" : ""
+          puts "[AgentBill] Signal tracked: #{params[:event_name]}#{trace_info}"
         end
         
         response.code == '200'
@@ -290,8 +412,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: 2.0.1
+  version: 7.17.0
 platform: ruby
 authors:
 - AgentBill
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-31 00:00:00.000000000 Z
+date: 2026-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,11 +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/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/pricing.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