Skip to content

A platform for community discussion. Free, open, simple.

6.8 KB
Raw Blame
# frozen_string_literal: true

module DiscourseAi
  module Decisions
    class Client
      # Billing a provider that omits usage must not make its decisions free. Engines
      # answer every question in a single pass over the state, behind a fixed prompt.
      ESTIMATED_PROMPT_TOKENS = 85
      ESTIMATED_TOKENS_PER_IMAGE = 1_000

      def initialize(decision_model, timeout: 30, max_attempts: 3)
        @decision_model = decision_model
        @endpoint = Endpoints::Base.for(decision_model)
        @timeout = timeout
        @max_attempts = max_attempts
      end

      def decide(state, questions:, feature_name:, user: nil, images: [])
        questions = Array.wrap(questions).map { |question| Question.wrap(question) }
        validate!(state, questions, feature_name, images)
        DecisionModelCreditAllocation.check_credits!(@decision_model, feature_name)
        if (canned = CannedAnswers.current)
          return canned.decide(state:, questions:, feature_name:, user:, images:)
        end

        uri = URI(@decision_model.endpoint_url)
        payload = @endpoint.payload(state:, questions:, images:)
        body = payload.to_json
        log =
          AiApiAuditLog.new(
            provider_id: @endpoint.provider_id,
            user_id: user&.id,
            feature_name:,
            language_model: @decision_model.name,
            raw_request_payload: @endpoint.audit_payload(payload).to_json,
          )
        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
        begin
          headers = @endpoint.headers(feature_name:, has_images: images.present?)
          response_body = post(uri, headers, body, log)
          begin
            parsed = JSON.parse(response_body)
            # Cloudflare Workers AI wraps answers in {result, success, errors}.
            parsed = parsed["result"] if parsed.is_a?(Hash) && parsed["success"] == true
          rescue JSON::ParserError
            raise RequestFailed.new(
                    "Request failed: invalid JSON",
                    http_status: log.response_status,
                  )
          end
          answers = @endpoint.parse(parsed, questions)
          input_tokens, output_tokens = @endpoint.usage(parsed)
          log.request_tokens = input_tokens
          log.response_tokens = output_tokens
        ensure
          log.duration_msecs =
            ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round
          log.save!
          AiApiRequestStat.record_from_audit_log(log, llm_model: nil)
        end
        if @decision_model.credit_system_enabled?
          input_tokens_for_credits =
            input_tokens || estimated_input_tokens(state, questions, images)
          DecisionModelCreditAllocation.deduct_credits!(
            @decision_model,
            feature_name,
            input_tokens_for_credits + output_tokens.to_i,
          )
        end
        Result.new(
          answers:,
          provider_model: parsed["model"],
          input_tokens:,
          output_tokens:,
          audit_log_id: log.id,
        )
      end

      private

      def estimated_input_tokens(state, questions, images)
        tokenizer = DiscourseAi::Tokenizer::OpenAiTokenizer
        question_tokens =
          questions.sum do |question|
            criteria = [*question.choices, *question.levels].join(" ")
            tokenizer.size("#{question.instructions} #{criteria}")
          end
        tokenizer.size(state.is_a?(String) ? state : state.to_json) +
          images.size * ESTIMATED_TOKENS_PER_IMAGE + question_tokens + ESTIMATED_PROMPT_TOKENS
      end

      def validate!(state, questions, feature_name, images)
        raise InvalidRequest, "feature_name is required" if feature_name.blank?
        raise InvalidRequest, "At least one question is required" if questions.empty?
        if questions.map(&:name).uniq.size != questions.size
          raise InvalidRequest, "Question names must be unique"
        end
        raise InvalidRequest, "Images must be a list of base64 data URLs" if !images.is_a?(Array)
        if images.any? { |image|
             !image.is_a?(String) || !image.start_with?("data:image/") ||
               !image.include?(";base64,")
           }
          raise InvalidRequest, "Images must be base64 data URLs"
        end
        if images.present? && !@decision_model.vision_enabled
          raise InvalidRequest, "Images require a decision model with image input enabled"
        end
        raise InvalidRequest, "State must be present" if state.blank?
        if !state.is_a?(String) && !state.is_a?(Hash) && !state.is_a?(Array)
          raise InvalidRequest, "State must be a string, hash or array"
        end
      end

      def retryable_network_error?(exception)
        return false if exception.is_a?(FinalDestination::SSRFError)
        # FinalDestination raises a bare Timeout::Error when DNS resolution is slow.
        return true if exception.is_a?(Timeout::Error)

        DiscourseAi::Completions::Endpoints::Base::RETRIABLE_NETWORK_ERRORS.any? do |klass|
          exception.is_a?(klass)
        end
      end

      # @return [String] the body of the successful response; the audit log only keeps a
      #   redacted copy
      def post(uri, headers, body, log)
        api_key = @decision_model.api_key
        header_values = @decision_model.custom_headers_for_request.values
        attempts = []
        loop do
          begin
            request = FinalDestination::HTTP::Post.new(uri.request_uri, headers)
            request.body = body
            response =
              FinalDestination::HTTP.start(
                uri.host,
                uri.port,
                use_ssl: uri.scheme == "https",
                open_timeout: @timeout,
                read_timeout: @timeout,
                write_timeout: @timeout,
              ) { |http| http.request(request) }
            log.response_status = response.code.to_i
            log.raw_response_payload =
              RequestFailed.redact_response(response.body, api_key, header_values:)
            error = RequestFailed.from_response(@decision_model, response) if !response.is_a?(
              Net::HTTPSuccess,
            )
          rescue StandardError => exception
            log.response_status = 0
            message = RequestFailed.sanitize(exception.message, api_key, header_values:)
            error =
              RequestFailed.new(
                "Request failed: #{message}",
                retryable: retryable_network_error?(exception),
              )
          end
          return response.body.to_s if error.nil?
          raise error if !error.retryable? || attempts.size + 1 >= @max_attempts

          delay = (error.retry_after || 2**attempts.size).clamp(0, 5)
          attempts << { "status" => error.http_status || 0, "delay_ms" => (delay * 1000).round }
          log.request_attempts = attempts
          sleep(delay)
        end
      end
    end
  end
end