Skip to content

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

9.0 KB
Raw Blame
# frozen_string_literal: true

module DiscourseAi
  module Admin
    class AiToolsController < ::Admin::AdminController
      requires_plugin PLUGIN_NAME

      before_action :find_ai_tool, only: %i[test edit update destroy export]

      def index
        ai_tools = AiTool.includes(:secret_bindings)
        render_serialized({ ai_tools: ai_tools }, AiCustomToolListSerializer, root: false)
      end

      def new
      end

      def edit
        render_serialized(@ai_tool, AiCustomToolSerializer)
      end

      def create
        ai_tool = AiTool.new(ai_tool_params)
        ai_tool.created_by_id = current_user.id

        if save_tool_with_optional_bindings(ai_tool)
          RagDocumentFragment.link_target_and_uploads(ai_tool, attached_upload_ids)
          log_ai_tool_creation(ai_tool)
          render_serialized(ai_tool, AiCustomToolSerializer, status: :created)
        else
          render_json_error ai_tool
        end
      end

      def export
        response.headers[
          "Content-Disposition"
        ] = "attachment; filename=\"#{@ai_tool.tool_name}.json\""
        render_serialized(
          @ai_tool,
          AiCustomToolSerializer,
          scope: {
            include_secret_bindings: false,
          },
        )
      end

      def import
        existing_tool = AiTool.find_by(tool_name: ai_tool_params[:tool_name])
        force_update = params[:force].present? && params[:force].to_s.downcase == "true"

        if existing_tool && !force_update
          return(
            render_json_error "Tool with tool_name '#{ai_tool_params[:tool_name]}' already exists. Use force=true to overwrite.",
                              status: :conflict
          )
        end

        if existing_tool && force_update
          initial_attributes = existing_tool.attributes.dup
          if update_tool_with_optional_bindings(existing_tool)
            log_ai_tool_update(existing_tool, initial_attributes)
            render_serialized(existing_tool, AiCustomToolSerializer)
          else
            render_json_error existing_tool
          end
        else
          ai_tool = AiTool.new(ai_tool_params)
          ai_tool.created_by_id = current_user.id

          if save_tool_with_optional_bindings(ai_tool)
            log_ai_tool_creation(ai_tool)
            render_serialized(ai_tool, AiCustomToolSerializer, status: :created)
          else
            render_json_error ai_tool
          end
        end
      end

      def update
        initial_attributes = @ai_tool.attributes.dup

        if update_tool_with_optional_bindings(@ai_tool)
          RagDocumentFragment.update_target_uploads(@ai_tool, attached_upload_ids)
          log_ai_tool_update(@ai_tool, initial_attributes)
          render_serialized(@ai_tool, AiCustomToolSerializer)
        else
          render_json_error @ai_tool
        end
      end

      def destroy
        tool_logger_details = {
          tool_id: @ai_tool.id,
          name: @ai_tool.name,
          tool_name: @ai_tool.tool_name,
          subject: @ai_tool.name,
        }

        if @ai_tool.destroy
          log_ai_tool_deletion(tool_logger_details)
          head :no_content
        else
          render_json_error @ai_tool
        end
      end

      def test
        # Mutate the in-memory model with unsaved edits (script, parameters, contracts)
        # so the test run reflects the form state without persisting anything.
        @ai_tool.assign_attributes(ai_tool_params) if params[:ai_tool]
        parameters = params[:parameters]&.to_unsafe_h || {}
        test_bindings = secret_bindings_supplied? ? secret_bindings_params : nil

        # we need an llm so we have a tokenizer
        # but will do without if none is available
        llm = LlmModel.first&.to_llm
        context = DiscourseAi::Agents::BotContext.new(guardian: guardian)
        runner =
          @ai_tool.runner(
            parameters,
            llm: llm,
            bot_user: current_user,
            context: context,
            secret_bindings: test_bindings,
          )
        result = runner.invoke

        if result.is_a?(Hash) && result[:error]
          render_json_error result[:error]
        elsif (source_error = ask_ai_source_error(result))
          render_json_error source_error
        else
          response = { output: result }
          response[:custom_raw] = runner.custom_raw if runner.custom_raw.present?
          render json: response
        end
      rescue ActiveRecord::RecordNotFound => e
        render_json_error e.message, status: 400
      rescue => e
        render_json_error "Error executing the tool: #{e.message}", status: 400
      end

      private

      # Ask AI calls its sources without a model to read their output, so a
      # result in the wrong shape would be dropped without a word.
      def ask_ai_source_error(result)
        return if !DiscourseAi::Discoveries::ExternalSource.configured?(@ai_tool)

        DiscourseAi::Discoveries::ExternalSource.normalize(result, strict: true)
        nil
      rescue DiscourseAi::Discoveries::ExternalSource::InvalidResults => error
        error.message
      end

      def attached_upload_ids
        params[:ai_tool][:rag_uploads].to_a.map { |h| h[:id] }
      end

      def find_ai_tool
        @ai_tool = AiTool.includes(:secret_bindings).find(params[:id].to_i)
      end

      def ai_tool_params
        params
          .require(:ai_tool)
          .permit(
            :name,
            :tool_name,
            :description,
            :script,
            :summary,
            :rag_chunk_tokens,
            :rag_chunk_overlap_tokens,
            :rag_llm_model_id,
            rag_uploads: [:id],
            parameters: [:name, :type, :description, :required, enum: []],
            secret_contracts: [:alias],
          )
          .except(:rag_uploads)
      end

      def ai_tool_logger_fields
        {
          name: {
          },
          tool_name: {
          },
          description: {
          },
          summary: {
          },
          enabled: {
          },
          rag_chunk_tokens: {
          },
          rag_chunk_overlap_tokens: {
          },
          rag_llm_model_id: {
          },
          script: {
            type: :large_text,
          },
          parameters: {
            type: :large_text,
          },
          secret_contracts: {
            type: :large_text,
          },
        }
      end

      def save_tool_with_optional_bindings(ai_tool)
        AiTool.transaction do
          ai_tool.save!
          apply_secret_bindings!(ai_tool) if secret_bindings_supplied?
        end
        true
      rescue ActiveRecord::RecordInvalid => e
        collect_tool_errors(ai_tool, e.record)
        false
      rescue ArgumentError => e
        ai_tool.errors.add(:base, e.message)
        false
      end

      def update_tool_with_optional_bindings(ai_tool)
        AiTool.transaction do
          ai_tool.update!(ai_tool_params)
          if secret_bindings_supplied?
            apply_secret_bindings!(ai_tool)
          else
            prune_orphan_bindings!(ai_tool)
          end
        end
        true
      rescue ActiveRecord::RecordInvalid => e
        collect_tool_errors(ai_tool, e.record)
        false
      rescue ArgumentError => e
        ai_tool.errors.add(:base, e.message)
        false
      end

      def collect_tool_errors(ai_tool, record)
        return if record.blank?

        return if record == ai_tool

        record.errors.full_messages.each { |message| ai_tool.errors.add(:base, message) }
      end

      def apply_secret_bindings!(ai_tool)
        ai_tool.replace_secret_bindings!(secret_bindings_params, created_by: current_user)
      end

      def prune_orphan_bindings!(ai_tool)
        ai_tool.prune_orphan_bindings!
      end

      def secret_bindings_supplied?
        return false if params[:ai_tool].blank?

        params[:ai_tool].key?(:secret_bindings) || params[:ai_tool].key?("secret_bindings")
      end

      def secret_bindings_params
        Array(
          params.require(:ai_tool).permit(secret_bindings: %i[alias ai_secret_id])[
            :secret_bindings
          ],
        )
      end

      def log_ai_tool_creation(ai_tool)
        logger = DiscourseAi::Utils::AiStaffActionLogger.new(current_user)

        entity_details = { tool_id: ai_tool.id, subject: ai_tool.name }
        entity_details[:parameter_count] = ai_tool.parameters.size if ai_tool.parameters.present?

        logger.log_creation("tool", ai_tool, ai_tool_logger_fields, entity_details)
      end

      def log_ai_tool_update(ai_tool, initial_attributes)
        logger = DiscourseAi::Utils::AiStaffActionLogger.new(current_user)
        entity_details = { tool_id: ai_tool.id, subject: ai_tool.name }

        logger.log_update(
          "tool",
          ai_tool,
          initial_attributes,
          ai_tool_logger_fields,
          entity_details,
        )
      end

      def log_ai_tool_deletion(tool_details)
        logger = DiscourseAi::Utils::AiStaffActionLogger.new(current_user)
        logger.log_deletion("tool", tool_details)
      end
    end
  end
end