agentbill-sdk 5.0.1 → 7.17.0

data/lib/agentbill/perplexity_wrapper.rb

@@ -0,0 +1,101 @@
+# Perplexity AI Wrapper for AgentBill Ruby SDK
+require_relative 'pricing'
+
+module AgentBill
+  class PerplexityWrapper
+    def initialize(client, config, tracer)
+      @client = client
+      @config = config
+      @tracer = tracer
+    end
+
+    def wrap
+      original_chat_create = @client.method(:chat_create)
+      config = @config
+      tracer = @tracer
+
+      @client.define_singleton_method(:chat_create) do |params|
+        model = params[:model] || 'llama-3.1-sonar-small-128k-online'
+        messages = params[:messages] || []
+
+        start_time = Time.now
+        span = tracer.start_span('perplexity.chat.completions.create', {
+          # ✅ OTEL GenAI compliant attributes
+          'gen_ai.system' => 'perplexity',
+          'gen_ai.request.model' => model,
+          'gen_ai.operation.name' => 'chat',
+          # ⚠️ Backward compatibility
+          'model' => model,
+          'provider' => 'perplexity'
+        })
+
+        begin
+          response = original_chat_create.call(params)
+          latency = ((Time.now - start_time) * 1000).round
+
+          input_tokens = response.dig(:usage, :prompt_tokens) || 0
+          output_tokens = response.dig(:usage, :completion_tokens) || 0
+          cost = Pricing.calculate_cost(model, input_tokens, output_tokens, 'perplexity')
+
+          track_usage(model, 'perplexity', input_tokens, output_tokens, latency, cost, config)
+
+          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.prompt_tokens' => input_tokens,
+            'response.completion_tokens' => output_tokens,
+            'latency_ms' => latency,
+            'cost' => cost
+          })
+          span.set_status(0)
+
+          puts "[AgentBill] ✓ Perplexity chat tracked: $#{format('%.6f', cost)}" if config[:debug]
+          response
+        rescue => e
+          span.set_status(1, e.message)
+          raise
+        ensure
+          span.finish
+        end
+      end
+
+      @client
+    end
+
+    private
+
+    def track_usage(model, provider, input_tokens, output_tokens, latency, cost, config)
+      uri = URI("#{config[:base_url] || 'https://api.agentbill.io'}/functions/v1/track-ai-usage")
+
+      payload = {
+        api_key: config[:api_key],
+        customer_id: config[:customer_id],
+        agent_id: config[:agent_id],
+        event_name: 'ai_request',
+        model: model,
+        provider: provider,
+        prompt_tokens: input_tokens,
+        completion_tokens: output_tokens,
+        latency_ms: latency,
+        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)
+      rescue => e
+        puts "[AgentBill] Tracking failed: #{e.message}" if config[:debug]
+      end
+    end
+  end
+end

data/lib/agentbill/pricing.rb

@@ -0,0 +1,52 @@
+# AgentBill SDK Pricing - LOCAL ESTIMATION ONLY
+#
+# IMPORTANT: Cost calculation is now 100% SERVER-SIDE
+# The server uses the model_pricing database table (synced by sync-model-pricing).
+# This module is kept ONLY for local estimation/display purposes.
+# The AUTHORITATIVE cost is always calculated server-side.
+
+module AgentBill
+  module Pricing
+    # Default fallback rates for local estimation only
+    DEFAULT_INPUT_PER_1M = 1.0
+    DEFAULT_OUTPUT_PER_1M = 2.0
+
+    class << self
+      # LOCAL ESTIMATION ONLY - for display purposes.
+      # Actual cost is calculated server-side using model_pricing database.
+      def calculate_cost(model, input_tokens, output_tokens, provider = 'openai')
+        # Ollama is free
+        return 0.0 if provider == 'ollama' || model.to_s.start_with?('ollama/')
+
+        # Simple default estimate - server calculates actual cost
+        input_cost = (input_tokens.to_f / 1_000_000) * DEFAULT_INPUT_PER_1M
+        output_cost = (output_tokens.to_f / 1_000_000) * DEFAULT_OUTPUT_PER_1M
+        input_cost + output_cost
+      end
+
+      # LOCAL ESTIMATION ONLY for image generation
+      def calculate_image_cost(model, size, quality = 'standard')
+        if model.include?('dall-e-3')
+          quality == 'hd' ? 0.08 : 0.04
+        else
+          0.02
+        end
+      end
+
+      # LOCAL ESTIMATION ONLY for audio
+      def calculate_audio_cost(model, duration_seconds: 0, chars: 0)
+        if model == 'whisper-1'
+          (duration_seconds.to_f / 60.0) * 0.006
+        elsif model.start_with?('tts-')
+          (chars.to_f / 1_000_000) * 15.0
+        else
+          0.0
+        end
+      end
+
+      def embedding_model?(model)
+        model.downcase.include?('embedding') || model.downcase.include?('embed')
+      end
+    end
+  end
+end

data/lib/agentbill/signal_types.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module AgentBill
+  # Signal Types Resource - CRUD operations for signal type management
+  # v7.15.0: New resource for programmatic signal type management
+  #
+  # @example
+  #   client = AgentBill::Client.new(api_key: 'agb_...')
+  #   
+  #   # Create signal type
+  #   st = client.signal_types.create(name: 'ai_completion', category: 'activity')
+  #   
+  #   # List all
+  #   signal_types = client.signal_types.list
+  #   
+  #   # Get by ID
+  #   st = client.signal_types.get(signal_type_id)
+  #   
+  #   # Update
+  #   client.signal_types.update(signal_type_id, description: 'Updated')
+  #   
+  #   # Delete
+  #   client.signal_types.delete(signal_type_id)
+  #
+  class SignalTypesResource
+    def initialize(config)
+      @base_url = config[:base_url] || 'https://api.agentbill.io'
+      @api_key = config[:api_key]
+      @debug = config[:debug] || false
+    end
+
+    # List signal types with optional filters
+    #
+    # @param category [String, nil] Filter by category ('activity' or 'outcome')
+    # @param include_global [Boolean] Include global signal types (default: true)
+    # @return [Hash] Response with :data array and :summary
+    def list(category: nil, include_global: true)
+      uri = URI("#{@base_url}/functions/v1/api-signal-types")
+      params = {}
+      params[:category] = category if category
+      params[:include_global] = 'false' unless include_global
+      uri.query = URI.encode_www_form(params) unless params.empty?
+
+      response = make_request(:get, uri)
+      handle_response(response, 'list signal types')
+    end
+
+    # Create a new signal type
+    #
+    # @param name [String] Signal type name (required)
+    # @param category [String] Category - 'activity' or 'outcome' (default: 'activity')
+    # @param description [String, nil] Description
+    # @param unit [String, nil] Unit of measurement
+    # @param default_value [Float, nil] Default value
+    # @param external_id [String, nil] Your external ID
+    # @param expected_metrics [Hash, nil] Expected metrics configuration
+    # @param revenue_formula [String, nil] Revenue formula
+    # @param validation_rules [Hash, nil] Validation rules
+    # @return [Hash] Created signal type
+    def create(name:, category: 'activity', description: nil, unit: nil, default_value: nil,
+               external_id: nil, expected_metrics: nil, revenue_formula: nil, validation_rules: nil)
+      payload = { name: name, category: category }
+      payload[:description] = description if description
+      payload[:unit] = unit if unit
+      payload[:default_value] = default_value if default_value
+      payload[:external_id] = external_id if external_id
+      payload[:expected_metrics] = expected_metrics if expected_metrics
+      payload[:revenue_formula] = revenue_formula if revenue_formula
+      payload[:validation_rules] = validation_rules if validation_rules
+
+      uri = URI("#{@base_url}/functions/v1/api-signal-types")
+      response = make_request(:post, uri, payload)
+      handle_response(response, 'create signal type')
+    end
+
+    # Get a signal type by ID or external_id
+    #
+    # @param signal_type_id [String] Signal type UUID or external_id
+    # @param by_external_id [Boolean] If true, treat signal_type_id as external_id
+    # @return [Hash] Signal type object
+    def get(signal_type_id, by_external_id: false)
+      uri = URI("#{@base_url}/functions/v1/api-signal-types")
+      param = by_external_id ? :external_id : :id
+      uri.query = URI.encode_www_form({ param => signal_type_id })
+
+      response = make_request(:get, uri)
+      handle_response(response, 'get signal type')
+    end
+
+    # Update a signal type
+    #
+    # @param signal_type_id [String] Signal type UUID
+    # @param name [String, nil] New name
+    # @param description [String, nil] New description
+    # @param category [String, nil] New category
+    # @param unit [String, nil] New unit
+    # @param default_value [Float, nil] New default value
+    # @param external_id [String, nil] New external ID
+    # @param expected_metrics [Hash, nil] New expected metrics
+    # @param revenue_formula [String, nil] New revenue formula
+    # @param validation_rules [Hash, nil] New validation rules
+    # @param is_active [Boolean, nil] Active status
+    # @return [Hash] Updated signal type
+    def update(signal_type_id, name: nil, description: nil, category: nil, unit: nil,
+               default_value: nil, external_id: nil, expected_metrics: nil,
+               revenue_formula: nil, validation_rules: nil, is_active: nil)
+      payload = { id: signal_type_id }
+      payload[:name] = name if name
+      payload[:description] = description if description
+      payload[:category] = category if category
+      payload[:unit] = unit if unit
+      payload[:default_value] = default_value if default_value
+      payload[:external_id] = external_id if external_id
+      payload[:expected_metrics] = expected_metrics if expected_metrics
+      payload[:revenue_formula] = revenue_formula if revenue_formula
+      payload[:validation_rules] = validation_rules if validation_rules
+      payload[:is_active] = is_active unless is_active.nil?
+
+      uri = URI("#{@base_url}/functions/v1/api-signal-types")
+      response = make_request(:patch, uri, payload)
+      handle_response(response, 'update signal type')
+    end
+
+    # Delete a signal type
+    #
+    # @param signal_type_id [String] Signal type UUID to delete
+    # @return [Hash] Deletion result
+    def delete(signal_type_id)
+      uri = URI("#{@base_url}/functions/v1/api-signal-types")
+      response = make_request(:delete, uri, { id: signal_type_id })
+      handle_response(response, 'delete signal type')
+    end
+
+    private
+
+    def make_request(method, uri, payload = nil)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      request = case method
+                when :get
+                  Net::HTTP::Get.new(uri)
+                when :post
+                  Net::HTTP::Post.new(uri)
+                when :patch
+                  Net::HTTP::Patch.new(uri)
+                when :delete
+                  Net::HTTP::Delete.new(uri)
+                end
+
+      request['Content-Type'] = 'application/json'
+      request['X-API-Key'] = @api_key
+      request.body = payload.to_json if payload
+
+      puts "[AgentBill] #{method.upcase} #{uri}" if @debug
+
+      http.request(request)
+    end
+
+    def handle_response(response, operation)
+      body = response.body ? JSON.parse(response.body) : {}
+
+      case response.code.to_i
+      when 200, 201, 204
+        body
+      when 404
+        raise "Signal type not found"
+      when 409
+        raise "Signal type already exists: #{body['error']}"
+      else
+        raise "Failed to #{operation}: #{body['error'] || response.body}"
+      end
+    end
+  end
+end

data/lib/agentbill/signals.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'net/http'
+require 'json'
+require 'uri'
+require 'time'
+
+require_relative 'distributed'
+
+module AgentBill
+  # Signal module for tracking business events and linking revenue to AI traces.
+  module Signals
+    BASE_URL = 'https://api.agentbill.io'
+    VERSION = '7.16.1'
+
+    @config = {}
+
+    class << self
+      attr_accessor :config
+
+      def set_config(options)
+        @config = options
+      end
+
+      def get_config
+        @config
+      end
+    end
+  end
+
+  class << self
+    # Emit a business signal/event and link it to AI traces.
+    #
+    # @param event_name [String] Name of the business event
+    # @param options [Hash] Signal options
+    # @option options [Float] :revenue Revenue amount
+    # @option options [Hash] :metadata Additional metadata
+    # @option options [String] :customer_id Customer ID
+    # @option options [String] :session_id Session ID
+    # @option options [String] :trace_id Trace ID to link to
+    # @option options [String] :span_id Span ID to link to
+    # @option options [String] :parent_span_id Parent span ID
+    # @option options [String] :currency Currency (default: USD)
+    # @option options [String] :event_type Event type
+    # @option options [Float] :event_value Event value
+    # @option options [String] :order_id Order ID to link to (v7.8.0)
+    # @option options [String] :order_external_id External order ID (v7.8.0)
+    #
+    # @return [Hash] Result with success status
+    #
+    # @example
+    #   AgentBill.signal('purchase', revenue: 99.99, metadata: { product_id: 'prod-123' })
+    def signal(event_name, **options)
+      config = Signals.get_config
+
+      api_key = config[:api_key]
+      raise ArgumentError, 'AgentBill not initialized. Call AgentBill.init() first or use AgentBill.tracing context.' unless api_key
+
+      effective_customer_id = options[:customer_id] || config[:customer_id]
+
+      # Auto-detect trace context if not provided
+      ctx = Distributed.get_trace_context
+      trace_id = options[:trace_id]
+      parent_span_id = options[:parent_span_id]
+
+      if ctx
+        trace_id ||= ctx[:trace_id]
+        parent_span_id ||= ctx[:span_id] unless parent_span_id
+      end
+
+      generated_span_id = options[:span_id] || SecureRandom.hex(8)
+      generated_trace_id = trace_id || SecureRandom.hex(16)
+      now_ns = (Time.now.to_f * 1_000_000_000).to_i
+
+      # Build OTEL-compliant span attributes
+      attributes = [
+        { key: 'agentbill.event_name', value: { stringValue: event_name } },
+        { key: 'agentbill.is_business_event', value: { boolValue: true } }
+      ]
+
+      attributes << { key: 'agentbill.customer_id', value: { stringValue: effective_customer_id } } if effective_customer_id
+      attributes << { key: 'agentbill.agent_id', value: { stringValue: config[:agent_id] } } if config[:agent_id]
+
+      if options[:revenue]
+        attributes << { key: 'agentbill.revenue', value: { doubleValue: options[:revenue] } }
+        attributes << { key: 'agentbill.currency', value: { stringValue: options[:currency] || 'USD' } }
+      end
+
+      attributes << { key: 'agentbill.event_value', value: { doubleValue: options[:event_value] } } if options[:event_value]
+      attributes << { key: 'agentbill.event_type', value: { stringValue: options[:event_type] } } if options[:event_type]
+      attributes << { key: 'agentbill.session_id', value: { stringValue: options[:session_id] } } if options[:session_id]
+      attributes << { key: 'agentbill.parent_span_id', value: { stringValue: parent_span_id } } if parent_span_id
+      # v7.8.0: Order linking
+      attributes << { key: 'agentbill.order_id', value: { stringValue: options[:order_id] } } if options[:order_id]
+      attributes << { key: 'agentbill.order_external_id', value: { stringValue: options[:order_external_id] } } if options[:order_external_id]
+      attributes << { key: 'agentbill.metadata', value: { stringValue: JSON.generate(options[:metadata]) } } if options[:metadata]
+
+      # Build OTEL payload
+      payload = {
+        resourceSpans: [{
+          resource: {
+            attributes: [
+              { key: 'service.name', value: { stringValue: 'agentbill-ruby-sdk' } },
+              { key: 'agentbill.customer_id', value: { stringValue: effective_customer_id || '' } },
+              { key: 'agentbill.agent_id', value: { stringValue: config[:agent_id] || '' } }
+            ]
+          },
+          scopeSpans: [{
+            scope: { name: 'agentbill.signals', version: Signals::VERSION },
+            spans: [{
+              traceId: generated_trace_id,
+              spanId: generated_span_id,
+              parentSpanId: parent_span_id || '',
+              name: 'agentbill.trace.signal',
+              kind: 1,
+              startTimeUnixNano: now_ns.to_s,
+              endTimeUnixNano: now_ns.to_s,
+              attributes: attributes,
+              status: { code: 1 }
+            }]
+          }]
+        }]
+      }
+
+      base_url = config[:base_url] || Signals::BASE_URL
+      debug = config[:debug] || false
+
+      begin
+        url = URI("#{base_url}/functions/v1/otel-collector")
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true
+        http.read_timeout = 10
+
+        request = Net::HTTP::Post.new(url)
+        request['x-api-key'] = api_key
+        request['Content-Type'] = 'application/json'
+        request.body = JSON.generate(payload)
+
+        response = http.request(request)
+
+        response_data = {}
+        body_success = true
+        begin
+          response_data = JSON.parse(response.body)
+          body_success = response_data['success'] != false
+        rescue StandardError
+          # If can't parse JSON, fall back to HTTP status check
+        end
+
+        is_success = response.code.to_i == 200 && body_success
+
+        if debug
+          if is_success
+            puts "[AgentBill] ✓ Signal '#{event_name}' tracked via OTEL"
+            puts "[AgentBill]   Revenue: $#{'%.2f' % options[:revenue]} #{options[:currency] || 'USD'}" if options[:revenue]
+            puts "[AgentBill]   Trace ID: #{generated_trace_id}"
+          else
+            puts "[AgentBill] ⚠️ Signal tracking failed: #{response_data['error'] || response.message}"
+            response_data['errors']&.each { |err| puts "[AgentBill]   - #{err}" }
+          end
+        end
+
+        {
+          success: is_success,
+          status_code: response.code.to_i,
+          trace_id: generated_trace_id,
+          span_id: generated_span_id,
+          error: is_success ? nil : response_data['error'],
+          errors: is_success ? nil : response_data['errors']
+        }
+      rescue StandardError => e
+        puts "[AgentBill] ⚠️ Signal tracking error: #{e.message}" if debug
+        {
+          success: false,
+          error: e.message,
+          trace_id: generated_trace_id
+        }
+      end
+    end
+
+    # Track a conversion event for revenue attribution.
+    #
+    # @param event_type [String] Type of conversion
+    # @param event_value [Float] Value of the conversion
+    # @param options [Hash] Additional options
+    #
+    # @return [Hash] Result with status
+    def track_conversion(event_type, event_value, **options)
+      signal(
+        "conversion_#{event_type}",
+        revenue: event_value,
+        event_type: event_type,
+        event_value: event_value,
+        **options
+      )
+    end
+  end
+end

data/lib/agentbill/tracer.rb

@@ -1,15 +1,17 @@
 require 'net/http'
 require 'json'
 require 'securerandom'
+require_relative 'distributed'
 
 module AgentBill
   class Span
-    attr_accessor :name, :trace_id, :span_id, :attributes, :start_time, :end_time, :status
+    attr_accessor :name, :trace_id, :span_id, :parent_span_id, :attributes, :start_time, :end_time, :status
 
-    def initialize(name, trace_id, span_id, attributes)
+    def initialize(name, trace_id, span_id, parent_span_id, attributes)
       @name = name
       @trace_id = trace_id
       @span_id = span_id
+      @parent_span_id = parent_span_id
       @attributes = attributes
       @start_time = (Time.now.to_f * 1_000_000_000).to_i
       @end_time = nil
@@ -30,9 +32,21 @@ module AgentBill
   end
 
   class Tracer
+    # OpenTelemetry tracer for AgentBill
+    #
+    # IMPORTANT: This tracer integrates with Distributed module for trace context.
+    # - If a trace context exists (via Distributed.get_trace_context), it reuses the trace_id
+    # - Always generates a new span_id for each span
+    # - Updates the global trace context so get_trace_context returns correct values
+    #
+    # This ensures that:
+    # 1. get_trace_context always returns the trace_id that matches what's sent to the portal
+    # 2. Distributed tracing works correctly across services
+    # 3. Parent-child span relationships are properly maintained
+
     def initialize(config)
       @config = config
-      @base_url = config[:base_url] || 'https://uenhjwdtnxtchlmqarjo.supabase.co'
+      @base_url = config[:base_url] || 'https://api.agentbill.io'
       @api_key = config[:api_key]
       @customer_id = config[:customer_id]
       @debug = config[:debug] || false
@@ -40,14 +54,37 @@ module AgentBill
     end
 
     def start_span(name, attributes)
-      trace_id = SecureRandom.hex(16)
+      # Check for existing trace context from Distributed module
+      ctx = Distributed.get_trace_context
+      parent_span_id = nil
+
+      if ctx
+        # Reuse existing trace_id for correlation
+        trace_id = ctx[:trace_id]
+        parent_span_id = ctx[:span_id]
+        puts "[AgentBill Tracer] Using existing trace context: trace_id=#{trace_id[0..7]}..." if @debug
+      else
+        # Generate new trace_id for new trace
+        trace_id = SecureRandom.hex(16)
+        puts "[AgentBill Tracer] Creating new trace: trace_id=#{trace_id[0..7]}..." if @debug
+      end
+
+      # Always generate new span_id for this span
       span_id = SecureRandom.hex(8)
 
+      # Update global trace context so get_trace_context returns correct values
+      Distributed.set_trace_context(trace_id, span_id)
+
       attributes['service.name'] = 'agentbill-ruby-sdk'
       attributes['customer.id'] = @customer_id if @customer_id
 
-      span = Span.new(name, trace_id, span_id, attributes)
+      span = Span.new(name, trace_id, span_id, parent_span_id, attributes)
       @spans << span
+
+      if @debug
+        puts "[AgentBill Tracer] Started span: #{name}, trace_id=#{trace_id[0..7]}..., span_id=#{span_id[0..7]}..."
+      end
+
       span
     end
 
@@ -77,16 +114,31 @@ module AgentBill
     private
 
     def build_otlp_payload
+      # Build resource attributes - agent_id and customer_id must be sent here
+      # for the otel-collector to extract them correctly
+      resource_attrs = [
+        { key: 'service.name', value: { stringValue: 'agentbill-ruby-sdk' } },
+        { key: 'service.version', value: { stringValue: '6.8.8' } }
+      ]
+      
+      # Add customer_id as resource attribute if configured
+      if @customer_id
+        resource_attrs << { key: 'customer.id', value: { stringValue: @customer_id } }
+      end
+      
+      # Add agent_id as resource attribute if configured
+      agent_id = @config[:agent_id]
+      if agent_id
+        resource_attrs << { key: 'agent.id', value: { stringValue: agent_id } }
+      end
+      
       {
         resourceSpans: [{
           resource: {
-            attributes: [
-              { key: 'service.name', value: { stringValue: 'agentbill-ruby-sdk' } },
-              { key: 'service.version', value: { stringValue: '1.0.0' } }
-            ]
+            attributes: resource_attrs
           },
           scopeSpans: [{
-            scope: { name: 'agentbill', version: '1.0.0' },
+            scope: { name: 'agentbill', version: '6.8.8' },
             spans: @spans.map { |span| span_to_otlp(span) }
           }]
         }]
@@ -94,7 +146,7 @@ module AgentBill
     end
 
     def span_to_otlp(span)
-      {
+      otlp_span = {
         traceId: span.trace_id,
         spanId: span.span_id,
         name: span.name,
@@ -104,6 +156,11 @@ module AgentBill
         attributes: span.attributes.map { |k, v| { key: k, value: value_to_otlp(v) } },
         status: span.status
       }
+
+      # Add parent span ID if this is a child span
+      otlp_span[:parentSpanId] = span.parent_span_id if span.parent_span_id
+
+      otlp_span
     end
 
     def value_to_otlp(value)