actionagent 0.0.0 → 1.2.0

data/app/controllers/action_agent/api/agent_runs_controller.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  module Api
+    class AgentRunsController < BaseController
+      before_action :set_run, only: [ :show, :cancel ]
+
+      # GET /api/runs/:id
+      def show
+        render json: {
+          run: run_json(@run),
+          messages: interaction_messages(@run),
+          agent: {
+            id: @run.agent.id,
+            name: @run.agent.name,
+            slug: @run.agent.slug
+          }
+        }
+      end
+
+      # POST /api/runs/:id/cancel
+      def cancel
+        @run.cancel!
+        render json: { run: @run.summary }
+      end
+
+      # GET /api/runs
+      def index
+        # Scoped to the caller's own agents: this listed (and counted) every
+        # run in the database regardless of who owned it.
+        scope = AgentRun.includes(:agent).where(agent: owner_agents).recent
+
+        scope = scope.where(agent_id: params[:agent_id]) if params[:agent_id].present?
+        scope = scope.where(status: params[:status]) if params[:status].present?
+
+        page = (params[:page] || 1).to_i
+        per_page = (params[:per_page] || 20).to_i
+        total = scope.count
+        runs = scope.offset((page - 1) * per_page).limit(per_page)
+
+        render json: {
+          runs: runs.map { |run| run_json(run, include_agent: true) },
+          meta: {
+            page: page,
+            per_page: per_page,
+            total: total
+          }
+        }
+      end
+
+      private
+
+      def set_run
+        @run = AgentRun.where(agent: owner_agents).find(params[:id])
+      end
+
+      # The run's slice of its agent's conversation stream, for the shared
+      # InteractionStream UI. User messages carry the run's trace_id in
+      # provenance (SolidAgent::HasContext); the slice spans from this run's
+      # user message up to the next user message with a different trace_id.
+      # Prepended with the system instructions the run executed under
+      # (captured in output_metadata; falls back to the agent's current ones).
+      def interaction_messages(run)
+        return [] if run.trace_id.blank?
+
+        context = AgentContext.for_agents(Agent.where(id: run.agent_id)).order(created_at: :desc).first
+        return [] unless context
+
+        messages = context.messages.chronological.to_a
+        start_index = messages.index do |message|
+          message.role == "user" && message.provenance&.dig("trace_id") == run.trace_id
+        end
+        return [] unless start_index
+
+        slice = [ messages[start_index] ]
+        messages[(start_index + 1)..].each do |message|
+          trace = message.provenance&.dig("trace_id")
+          break if message.role == "user" && trace.present? && trace != run.trace_id
+
+          slice << message
+        end
+
+        serialized = slice.map { |message| AgentMessageSerializer.call(message) }
+        instructions = run.output_metadata&.dig("instructions").presence || run.agent.instructions
+        if instructions.present?
+          serialized.unshift(
+            id: "run-#{run.id}-system",
+            role: "system",
+            content: instructions,
+            created_at: (run.started_at || run.created_at).iso8601(3)
+          )
+        end
+        serialized
+      end
+
+      def run_json(run, include_agent: false)
+        json = {
+          id: run.id,
+          status: run.status,
+          input_prompt: run.input_prompt,
+          input_params: run.input_params,
+          output: run.output,
+          output_metadata: run.output_metadata,
+          duration_ms: run.calculated_duration_ms,
+          input_tokens: run.input_tokens,
+          output_tokens: run.output_tokens,
+          total_tokens: run.total_tokens,
+          error_message: run.error_message,
+          trace_id: run.trace_id,
+          logs: run.logs,
+          started_at: run.started_at,
+          completed_at: run.completed_at,
+          created_at: run.created_at
+        }
+
+        if include_agent
+          json[:agent] = {
+            id: run.agent.id,
+            name: run.agent.name,
+            slug: run.agent.slug
+          }
+        end
+
+        json
+      end
+    end
+  end
+end

data/app/controllers/action_agent/api/agents_controller.rb

@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  module Api
+    class AgentsController < BaseController
+      # Ranking for the agent cards. Every dimension except "recent" reads the
+      # scorecard, which is computed in Ruby over both execution sources, so
+      # the ordering is applied there rather than in the SQL scope.
+      LIST_SORTS = {
+        "recent" => "Recently updated",
+        "popular" => "Most runs",
+        "longest" => "Longest average",
+        "cost" => "Highest cost",
+        "tokens" => "Most tokens"
+      }.freeze
+      DEFAULT_LIST_SORT = "recent"
+
+      before_action :set_agent, only: [ :show, :update, :destroy, :versions, :runs, :execute, :test, :restore, :duplicate, :export, :analytics ]
+      before_action :require_execution_enabled!, only: [ :execute, :test ]
+      before_action :require_owner!, only: [ :execute, :test ]
+      before_action :enforce_execution_quota!, only: [ :execute, :test ]
+
+      # GET /api/agents
+      def index
+        @agents = owner_agents.order(updated_at: :desc)
+
+        # Filter by status
+        @agents = @agents.where(status: params[:status]) if params[:status].present?
+
+        # Filter by provider
+        @agents = @agents.where(provider: params[:provider]) if params[:provider].present?
+
+        # Search by name
+        # LOWER(...) LIKE rather than ILIKE: the dashboard is not
+        # PostgreSQL-only.
+        if params[:q].present?
+          @agents = @agents.where("LOWER(name) LIKE ?", "%#{params[:q].to_s.downcase}%")
+        end
+
+        scorecards = AgentScorecard.for_agents(@agents)
+        cards = sort_cards(
+          @agents.map { |agent| agent_json(agent).merge(stats: scorecards[agent.id]) },
+          params[:sort]
+        )
+
+        render json: {
+          agents: cards,
+          meta: {
+            total: cards.size,
+            sorts: LIST_SORTS,
+            sort: list_sort(params[:sort]),
+            providers: Agent::PROVIDERS,
+            preset_types: Agent::PRESET_TYPES,
+            instruction_sets: Agent::INSTRUCTION_SETS,
+            available_tools: Agent::AVAILABLE_TOOLS
+          }
+        }
+      end
+
+      # GET /api/agents/:id
+      def show
+        render json: {
+          agent: agent_json(@agent, include_details: true),
+          versions: @agent.agent_versions.recent.limit(10).map { |v| version_json(v) },
+          recent_runs: @agent.agent_runs.recent.limit(5).map(&:summary)
+        }
+      end
+
+      # POST /api/agents
+      def create
+        @agent = owner_agents.build(agent_params)
+
+        if @agent.save
+          render json: { agent: agent_json(@agent, include_details: true) }, status: :created
+        else
+          render json: { errors: @agent.errors.full_messages }, status: :unprocessable_entity
+        end
+      end
+
+      # PATCH /api/agents/:id
+      def update
+        if @agent.update(agent_params)
+          render json: { agent: agent_json(@agent, include_details: true) }
+        else
+          render json: { errors: @agent.errors.full_messages }, status: :unprocessable_entity
+        end
+      end
+
+      # DELETE /api/agents/:id
+      def destroy
+        @agent.destroy
+        render json: { success: true }
+      end
+
+      # GET /api/agents/:id/versions
+      def versions
+        @versions = @agent.agent_versions.recent
+
+        render json: {
+          versions: @versions.map { |v| version_json(v, include_diff: true) }
+        }
+      end
+
+      # POST /api/agents/:id/restore
+      def restore
+        version = @agent.agent_versions.find(params[:version_id])
+        @agent.restore_from_version!(version)
+
+        render json: { agent: agent_json(@agent, include_details: true) }
+      end
+
+      # GET /api/agents/:id/runs
+      # Every execution of this agent, whoever ran it: dashboard runs and
+      # SDK-reported traces in one list, discriminated by `source`. Agents
+      # observed from telemetry have no AgentRun rows at all, so a runs-only
+      # list showed them as empty while their scorecard reported real traffic.
+      def runs
+        minutes = params[:minutes].presence&.then { |m| m.to_i.clamp(1, 60 * 24 * 90) }
+        page = (params[:page] || 1).to_i
+        per_page = (params[:per_page] || 20).to_i
+
+        executions = AgentExecutions.new(
+          agents: [ @agent ],
+          owner: current_owner,
+          window_minutes: minutes,
+          source: params[:source],
+          status: params[:status],
+          sort: params[:sort]
+        ).page(page: page, per_page: per_page)
+
+        # One digest->version map for the page; labels each run's instructions
+        # with the agent version that introduced them where one matches.
+        digest_versions = @agent.instructions_digest_versions
+        runs_by_id = AgentRun.where(id: executions[:rows].select { |r| r.source == "dashboard" }.map(&:id))
+          .index_by(&:id)
+
+        render json: {
+          runs: executions[:rows].map { |row| serialize_execution(row, runs_by_id, digest_versions) },
+          meta: {
+            page: page,
+            per_page: per_page,
+            total: executions[:total],
+            sources: AgentExecutions::SOURCES,
+            sorts: AgentExecutions::SORTS
+          }
+        }
+      end
+
+      # POST /api/agents/:id/execute
+      def execute
+        run = @agent.execute(
+          params[:prompt],
+          action: params[:action_name],
+          **params.fetch(:params, {}).to_unsafe_h.symbolize_keys
+        )
+        record_execution_usage
+
+        render json: { run: run.summary }, status: :accepted
+      end
+
+      # POST /api/agents/:id/test
+      def test
+        run = @agent.test_execute(
+          params[:prompt],
+          action: params[:action_name],
+          **params.fetch(:params, {}).to_unsafe_h.symbolize_keys
+        )
+        record_execution_usage
+
+        render json: { run: run.summary, output: run.output }
+      end
+
+      # POST /api/agents/:id/duplicate
+      def duplicate
+        new_agent = @agent.dup
+        new_agent.name = "#{@agent.name} (Copy)"
+        new_agent.slug = nil # Will be auto-generated
+        new_agent.status = :draft
+        new_agent.save!
+
+        render json: { agent: agent_json(new_agent, include_details: true) }, status: :created
+      end
+
+      # GET /api/agents/:id/export
+      def export
+        render json: {
+          agent: agent_json(@agent, include_details: true),
+          code: @agent.to_agent_class_code,
+          manifest: {
+            name: @agent.slug,
+            version: "1.0.0",
+            model: "#{@agent.provider}/#{@agent.model}",
+            description: @agent.description,
+            instructions: @agent.instructions,
+            tools: @agent.tools,
+            config: @agent.model_config
+          }
+        }
+      end
+
+      # GET /api/agents/:id/analytics
+      def analytics
+        days = (params[:days] || 30).to_i
+        start_date = days.days.ago.beginning_of_day
+
+        runs = @agent.agent_runs.where("created_at >= ?", start_date)
+
+        # Calculate stats
+        total_runs = runs.count
+        completed_runs = runs.where(status: :complete).count
+        failed_runs = runs.where(status: :failed).count
+        avg_duration = runs.where.not(duration_ms: nil).average(:duration_ms)&.round || 0
+        total_tokens = runs.sum(:total_tokens)
+        avg_tokens = total_runs > 0 ? (total_tokens.to_f / total_runs).round : 0
+
+        # Runs by day
+        runs_by_day = runs.group("DATE(created_at)")
+          .select("DATE(created_at) as date, COUNT(*) as count, SUM(total_tokens) as tokens")
+          .order("date")
+          .map { |r| { date: r.date.to_s, count: r.count, tokens: r.tokens || 0 } }
+
+        # Status breakdown
+        status_breakdown = runs.group(:status).count.transform_keys(&:to_s)
+
+        # Recent errors
+        recent_errors = runs.failed_runs.recent.limit(5).map do |run|
+          {
+            id: run.id,
+            error: run.error_message&.truncate(200),
+            created_at: run.created_at
+          }
+        end
+
+        render json: {
+          period_days: days,
+          summary: {
+            total_runs: total_runs,
+            completed_runs: completed_runs,
+            failed_runs: failed_runs,
+            success_rate: total_runs > 0 ? ((completed_runs.to_f / total_runs) * 100).round(1) : 0,
+            avg_duration_ms: avg_duration,
+            total_tokens: total_tokens,
+            avg_tokens_per_run: avg_tokens
+          },
+          runs_by_day: runs_by_day,
+          status_breakdown: status_breakdown,
+          recent_errors: recent_errors
+        }
+      end
+
+      # GET /api/agents/presets
+      def presets
+        presets = Agent::PRESET_TYPES.map do |preset|
+          {
+            id: preset,
+            name: preset.titleize,
+            appearance: default_appearance_for(preset),
+            suggested_tools: suggested_tools_for(preset),
+            suggested_instructions: suggested_instructions_for(preset)
+          }
+        end
+
+        render json: { presets: presets }
+      end
+
+      private
+
+      def list_sort(requested)
+        LIST_SORTS.key?(requested.to_s) ? requested.to_s : DEFAULT_LIST_SORT
+      end
+
+      # Descending on the chosen dimension. Agents with nothing to rank (no
+      # runs, no priced spend) sort last instead of interleaving as zeroes,
+      # and run count breaks ties.
+      def sort_cards(cards, requested)
+        sort = list_sort(requested)
+        return cards if sort == "recent"
+
+        key = { "popular" => :runs, "longest" => :avg_duration_ms, "cost" => :cost, "tokens" => :tokens }[sort]
+
+        cards.sort_by do |card|
+          value = card[:stats]&.dig(key)
+          [ value.nil? ? 1 : 0, -value.to_f, -card[:stats].to_h[:runs].to_i ]
+        end
+      end
+
+      # Dashboard runs keep their full summary (logs, previews, instructions
+      # version); reported executions carry only what a trace knows. `source`
+      # tells the UI which it is holding.
+      def serialize_execution(row, runs_by_id, digest_versions)
+        run = runs_by_id[row.id] if row.source == "dashboard"
+
+        if run
+          run.summary.merge(
+            source: "dashboard",
+            # Priced here rather than on AgentRun so both sources use one
+            # estimator, and so a run and its trace never quote different costs.
+            cost: row.cost,
+            instructions_version: digest_versions[run.instructions_digest]
+          )
+        else
+          row.as_json.merge(id: row.to_param, record_id: row.id)
+        end
+      end
+
+      # Same contract as Api::SandboxesController#run: 402 + usage stats so the
+      # frontend can show the upgrade prompt.
+      def set_agent
+        @agent = owner_agents.find(params[:id])
+      end
+
+      def agent_params
+        params.require(:agent).permit(
+          :name, :description, :provider, :model, :instructions,
+          :preset_type, :agent_class_name, :status,
+          appearance: {},
+          action_prompts: [ :name, :prompt, :expose_as_tool ],
+          instruction_sets: [],
+          tools: [],
+          mcp_servers: [],
+          model_config: {},
+          response_format: {}
+        )
+      end
+
+      def agent_json(agent, include_details: false)
+        json = {
+          id: agent.id,
+          name: agent.name,
+          slug: agent.slug,
+          description: agent.description,
+          provider: agent.provider,
+          model: agent.model,
+          status: agent.status,
+          preset_type: agent.preset_type,
+          appearance: agent.appearance,
+          version_count: agent.version_count,
+          created_at: agent.created_at,
+          updated_at: agent.updated_at
+        }
+
+        if include_details
+          json.merge!(
+            instructions: agent.instructions,
+            action_prompts: agent.action_prompts,
+            instruction_sets: agent.instruction_sets,
+            tools: agent.tools,
+            mcp_servers: agent.mcp_servers,
+            model_config: agent.model_config,
+            response_format: agent.response_format,
+            agent_class_name: agent.agent_class_name,
+            telemetry_agent_class: agent.telemetry_agent_class
+          )
+        end
+
+        json
+      end
+
+      def version_json(version, include_diff: false)
+        json = {
+          id: version.id,
+          version_number: version.version_number,
+          change_summary: version.change_summary,
+          created_by: version.created_by,
+          created_at: version.created_at,
+          is_latest: version.latest?
+        }
+
+        if include_diff && version.previous
+          json[:diff] = version.diff(version.previous)
+        end
+
+        json
+      end
+
+      def default_appearance_for(preset)
+        appearances = {
+          "terminal" => { hat: "fedora", heldItem: "terminal", theme: "emerald" },
+          "webDeveloper" => { hat: "safari", heldItem: "browser", theme: "blue" },
+          "documentAnalysis" => { hat: "fedora", heldItem: "document", theme: "amber" },
+          "writing" => { hat: "fedora", hatAccessory: "feather", heldItem: "scroll", theme: "purple" },
+          "research" => { hat: "safari", heldItem: "magnifyingGlass", theme: "teal" },
+          "playwright" => { hat: "fedora", hatAccessory: "theaterMasks", heldItem: "browser", theme: "rose" }
+        }
+        appearances[preset] || { theme: "default" }
+      end
+
+      def suggested_tools_for(preset)
+        tools = {
+          "terminal" => %w[terminal filesystem code],
+          "webDeveloper" => %w[terminal filesystem code playwright],
+          "documentAnalysis" => %w[filesystem search],
+          "writing" => %w[edit translate],
+          "research" => %w[fetch search memory],
+          "playwright" => %w[playwright filesystem]
+        }
+        tools[preset] || []
+      end
+
+      def suggested_instructions_for(preset)
+        instructions = {
+          "terminal" => %w[github docker kubernetes],
+          "webDeveloper" => %w[github ruby rails typescript],
+          "research" => %w[github python],
+          "playwright" => %w[github typescript]
+        }
+        instructions[preset] || []
+      end
+    end
+  end
+end

data/app/controllers/action_agent/api/analytics_controller.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  module Api
+    class AnalyticsController < BaseController
+      # GET /api/analytics
+      def index
+        days = (params[:days] || 30).to_i
+        start_date = days.days.ago.beginning_of_day
+
+        # Table names are interpolated rather than written literally: the
+        # engine's tables carry a configurable prefix.
+        runs_table = AgentRun.table_name
+        agents_table = ActionAgent::Agent.table_name
+
+        agents = owner_agents
+        runs = AgentRun.joins(:agent).where(agent: agents).where("#{runs_table}.created_at >= ?", start_date)
+
+        # Overall stats
+        total_agents = agents.count
+        active_agents = agents.where(status: :active).count
+        total_runs = runs.count
+        completed_runs = runs.where(status: :complete).count
+        failed_runs = runs.where(status: :failed).count
+
+        # Token usage
+        total_tokens = runs.sum(:total_tokens)
+        total_input_tokens = runs.sum(:input_tokens)
+        total_output_tokens = runs.sum(:output_tokens)
+
+        # Average metrics
+        avg_duration = runs.where.not(duration_ms: nil).average(:duration_ms)&.round || 0
+        avg_tokens_per_run = total_runs > 0 ? (total_tokens.to_f / total_runs).round : 0
+
+        # Runs over time
+        runs_by_day = runs.group("DATE(#{runs_table}.created_at)")
+          .select("DATE(#{runs_table}.created_at) as date, COUNT(*) as count")
+          .order("date")
+          .map { |r| { date: r.date.to_s, count: r.count } }
+
+        # Token usage over time
+        tokens_by_day = runs.group("DATE(#{runs_table}.created_at)")
+          .select("DATE(#{runs_table}.created_at) as date, SUM(total_tokens) as tokens")
+          .order("date")
+          .map { |r| { date: r.date.to_s, tokens: r.tokens || 0 } }
+
+        # Top agents by usage
+        top_agents = agents.joins(:agent_runs)
+          .where("#{runs_table}.created_at >= ?", start_date)
+          .group("#{agents_table}.id", "#{agents_table}.name", "#{agents_table}.slug")
+          .select(
+            "#{agents_table}.id, #{agents_table}.name, #{agents_table}.slug, " \
+            "COUNT(#{runs_table}.id) as run_count, SUM(#{runs_table}.total_tokens) as total_tokens"
+          )
+          .order("run_count DESC")
+          .limit(5)
+          .map { |a| { id: a.id, name: a.name, slug: a.slug, run_count: a.run_count, total_tokens: a.total_tokens || 0 } }
+
+        # Status distribution
+        status_breakdown = runs.group(:status).count.transform_keys(&:to_s)
+
+        # Provider distribution
+        provider_breakdown = runs.joins(:agent)
+          .group("#{agents_table}.provider")
+          .count
+          .transform_keys(&:to_s)
+
+        render json: {
+          period_days: days,
+          summary: {
+            total_agents: total_agents,
+            active_agents: active_agents,
+            total_runs: total_runs,
+            completed_runs: completed_runs,
+            failed_runs: failed_runs,
+            success_rate: total_runs > 0 ? ((completed_runs.to_f / total_runs) * 100).round(1) : 0,
+            avg_duration_ms: avg_duration,
+            total_tokens: total_tokens,
+            total_input_tokens: total_input_tokens,
+            total_output_tokens: total_output_tokens,
+            avg_tokens_per_run: avg_tokens_per_run
+          },
+          charts: {
+            runs_by_day: runs_by_day,
+            tokens_by_day: tokens_by_day
+          },
+          top_agents: top_agents,
+          status_breakdown: status_breakdown,
+          provider_breakdown: provider_breakdown
+        }
+      end
+    end
+  end
+end

data/app/controllers/action_agent/api/api_keys_controller.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  module Api
+    # Platform API keys (Settings -> API Keys). The full token is returned
+    # exactly once — in the create response — and masked everywhere else.
+    class ApiKeysController < BaseController
+      before_action :require_owner!
+
+      # GET /api/api_keys
+      def index
+        render json: {
+          api_keys: owned(ApiKey).order(created_at: :desc).map { |key| serialize(key) }
+        }
+      end
+
+      # POST /api/api_keys
+      def create
+        api_key = owned(ApiKey).create!(name: params.require(:name))
+
+        render json: {
+          api_key: serialize(api_key).merge(token: api_key.token)
+        }, status: :created
+      end
+
+      # DELETE /api/api_keys/:id
+      def destroy
+        owned(ApiKey).find(params[:id]).destroy!
+        head :no_content
+      end
+
+      private
+
+      def serialize(api_key)
+        {
+          id: api_key.id,
+          name: api_key.name,
+          masked_token: api_key.masked_token,
+          created_at: api_key.created_at.iso8601,
+          last_used_at: api_key.last_used_at&.iso8601
+        }
+      end
+    end
+  end
+end