activeagent 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f352ce28ead5e975e8d64c76c4a263c1ac7cac3b202ea6fef1a137f899e3aea0
-  data.tar.gz: d163e4360d38fdf440465ec0caf76dc9c196cab342de0de4cf67de020b31d0e2
+  metadata.gz: 867cf01603bb86b99c7abdbe6cc9e731264dc60bfdf3e89ca19a4d25fca5ea3d
+  data.tar.gz: c8b86f8988ff27931f4a82f8aa71aa04168bceae00f8f9cab6b98507dd3d2b94
 SHA512:
-  metadata.gz: 8aed9bb0e1d7bec5b5e178940e4e43c8a117c82d36db703d34cbef485b0492d29d628350bb956cf709ee504a81327e152d5510d3c1b81cf43d5ecc70f33ffae8
-  data.tar.gz: 6d8b3c9b6d6f7286985206a42db8949067dbb46bc39db67e4eb507ccc1a9dd405ed46720c06878c4d5ea748f8da184072ce4e9bf9951361d4fe5172ae65770d8
+  metadata.gz: 8c81f0537fddda60bbe3049cdb36b0478130d969ba0d35af408f3a5c527e2448d8e733638cd94b6c72c8f4b8d1ec13da32877baae3101e0373cc7d173253d06c
+  data.tar.gz: 6af0f6a1879a9e291581a51beb5b6b96ac2ec641a9ebc007cb2345c695e1f746741fbb667bd761f889591d15c7ffeb917e7ecb7c5d1151f4d6687af3f87a3930

data/CHANGELOG.md

@@ -5,6 +5,67 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] - Unreleased
+
+### ⚠️ The dashboard has moved to its own gem
+
+The dashboard engine that shipped inside `activeagent` is now a separate
+gem, **`actionagent`**. Nothing is gone — the dashboard is the same
+dashboard, and it gained a great deal in this release — but it comes from a
+different gem now. `activeagent` is the framework alone: it no longer
+defines `ActiveAgent::Dashboard`, and no longer pulls Active Record into
+apps that do not use it.
+
+**If you mount the dashboard, add the new gem in the same change that
+upgrades `activeagent`:**
+
+```ruby
+gem "activeagent", "~> 1.2"
+gem "actionagent", "~> 1.2"   # required if you mount the dashboard
+```
+
+This is a minor version, so a `~> 1.0` or `~> 1.1` constraint **will** pick
+it up on the next `bundle update`. If you mount the dashboard and do not add
+`actionagent` at the same time, the app fails at boot with
+`NameError: uninitialized constant ActiveAgent::Dashboard`, raised by your
+own initializer or by the `mount ActiveAgent::Dashboard::Engine` line in
+`config/routes.rb`. Adding the gem is the whole fix — your existing
+configuration keeps working through the compatibility shims below.
+
+If you do not mount the dashboard, there is nothing to do: the framework API
+is unchanged, and the gem is 95% smaller.
+
+With `actionagent` installed, the old constants keep resolving through
+`ActionAgent::Compatibility` with a deprecation warning:
+
+- `ActiveAgent::Dashboard` → `ActionAgent`
+- `ActiveAgent::TelemetryTrace` → `ActionAgent::TelemetryTrace`
+- `ActiveAgent::ProcessTelemetryTracesJob` → `ActionAgent::ProcessTelemetryTracesJob`
+
+That last one matters beyond tidiness: Active Job serializes the class name
+into the queue payload, so jobs enqueued before the upgrade still resolve
+after it.
+
+Other changes for mounted installs:
+
+- **The server-rendered traces console moves from `/traces` to
+  `/console/traces`.** `/traces` is now the React traces view — the same
+  data, with more of it.
+- **The mount is authenticated everywhere but development and test.** The
+  sandbox API, the session-recording capture endpoints and the template
+  endpoints previously allowed anonymous access; they no longer do. The
+  `GET /api/session_recordings/demo` endpoint is removed.
+- **`current_user_method` / `current_account_method` are superseded by
+  `current_user_resolver` / `current_account_resolver`.** The engine's
+  controllers are their own base class, so a host app's `current_user`
+  helper is not available to them.
+- **An unresolved owner now scopes to nothing rather than to everything.**
+  If you configure `user_class` or `account_class`, make sure the matching
+  resolver actually returns a record, or the dashboard will show no data.
+- Existing installs upgrading from the in-gem dashboard: re-run
+  `rails generate action_agent:install`. It detects the migrations you
+  already have and emits only what is missing.
+
 ## [1.1.0] - 2026-08-12
 
 ### Dashboard — self-hosted (enterprise) mount readiness

data/README.md

@@ -25,6 +25,10 @@ Use bundler to add activeagent to your Gemfile and install:
 bundle add activeagent
 ```
 
+That is the framework — agents, providers, generation and telemetry
+reporting. The dashboard is a second gem, `actionagent`, added separately
+when you want it; see [Dashboard & Dev Console](#dashboard--dev-console).
+
 Add the generation provider gem you want to use:
 
 ```bash
@@ -127,14 +131,19 @@ development:
     service: "RubyLLM"
 ```
 
-## Dev Console & Observability
+## Dashboard & Dev Console
 
-Active Agent includes a local dev console — traces with span waterfalls,
-token usage, and per-agent metrics — as a mountable Rails engine, so you
-can watch your agents while you build:
+The dashboard is its own gem, `actionagent`: a mountable Rails engine with
+traces and span waterfalls, token usage and per-agent metrics, plus the agent
+builder, runs, conversations, evaluations, scorecards and cost estimates — so
+you can watch and drive your agents while you build. It ships separately
+because its models are Active Record models and it runs agents through
+[solid_agent](https://github.com/activeagents/solid_agent) — neither of which
+`activeagent` depends on, so an app that only runs agents installs neither.
 
 ```bash
-rails generate active_agent:dashboard:install
+bundle add actionagent
+rails generate action_agent:install
 rails db:migrate
 ```
 
@@ -145,13 +154,14 @@ telemetry:
   local_storage: true
 ```
 
-Open `/activeagents` and every generation appears as a trace. See
+The generator mounts the engine at `/activeagents` — open it and every
+generation appears as a trace. See
 [docs/framework/dashboard.md](docs/framework/dashboard.md) for
-authentication, remote ingestion, and multi-tenant mode. For production
-monitoring — evaluations, cost estimates, retention, team workspaces —
-point telemetry at the hosted platform at
-[activeagents.ai](https://activeagents.ai); every workspace starts with a
-free low-volume trial.
+authentication, remote ingestion, and multi-tenant mode. The hosted
+platform at [activeagents.ai](https://activeagents.ai) runs this same
+engine multi-tenant, adding what a hosted product has to have — accounts,
+plans, billing, quotas and managed sandboxes; every workspace starts with
+a free low-volume trial.
 
 ## Features
 
@@ -199,12 +209,12 @@ response = prompt.generate_now
 
 - [Documentation](https://docs.activeagents.ai)
 - [Getting Started Guide](https://docs.activeagents.ai/getting_started)
-- [API Reference](https://docs.activeagents.ai/docs/framework)
-- [Examples](https://docs.activeagents.ai/docs/agents)
+- [API Reference](https://docs.activeagents.ai/framework)
+- [Examples](https://docs.activeagents.ai/agents)
 
 ## Contributing
 
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.MD) for details.
 
 ## License
 

data/lib/active_agent/telemetry/configuration.rb

@@ -78,15 +78,19 @@ module ActiveAgent
       private
 
       # Persists a trace through the dashboard's trace model, honoring
-      # ActiveAgent::Dashboard.trace_model_class overrides. Idempotent on
-      # trace_id, as HTTP ingest is.
+      # ActionAgent.trace_model_class overrides. Idempotent on trace_id, as
+      # HTTP ingest is.
+      #
+      # The dashboard is the `actionagent` gem, which the framework does not
+      # depend on — every reference to it here is guarded, so local_storage
+      # simply reports that it has nowhere to write when it isn't installed.
       def dashboard_store
         @dashboard_store ||= lambda do |trace, sdk|
           model = local_trace_model
           unless model
             resolved_logger.error(
               "[ActiveAgent::Telemetry] local_storage is enabled but no trace model is available — " \
-              "run `rails generate active_agent:dashboard:install` first"
+              "add the actionagent gem and run `rails generate action_agent:install` first"
             )
             next
           end
@@ -98,10 +102,10 @@ module ActiveAgent
       end
 
       def local_trace_model
-        if defined?(ActiveAgent::Dashboard) && ActiveAgent::Dashboard.respond_to?(:trace_model)
-          ActiveAgent::Dashboard.trace_model
-        elsif defined?(ActiveAgent::TelemetryTrace)
-          ActiveAgent::TelemetryTrace
+        if defined?(::ActionAgent) && ::ActionAgent.respond_to?(:trace_model)
+          ::ActionAgent.trace_model
+        elsif defined?(::ActionAgent::TelemetryTrace)
+          ::ActionAgent::TelemetryTrace
         end
       rescue NameError
         nil
@@ -124,10 +128,10 @@ module ActiveAgent
       # isn't mounted there. Separate from #dashboard_mount_path so it can be
       # exercised against a route set directly.
       public def mount_path_in(route_set)
-        return nil unless defined?(::ActiveAgent::Dashboard::Engine)
+        return nil unless defined?(::ActionAgent::Engine)
 
         route = route_set.routes.find do |candidate|
-          mounted_engine(candidate.app) == ::ActiveAgent::Dashboard::Engine
+          mounted_engine(candidate.app) == ::ActionAgent::Engine
         end
         return nil unless route
 

data/lib/active_agent/telemetry/instrumentation.rb

@@ -147,6 +147,7 @@ module ActiveAgent
                   tool_span = span.add_span("tool.#{tool_call[:name]}", span_type: :tool)
                   tool_span.set_attribute("tool.name", tool_call[:name])
                   tool_span.set_attribute("tool.id", tool_call[:id]) if tool_call[:id]
+                  ToolOrigin.annotate(tool_span, tool_call[:name])
                   tool_span.finish
                 end
               end
@@ -202,6 +203,9 @@ module ActiveAgent
 
             tool_span = parent.add_span("tool.#{tool_name}", span_type: :tool)
             tool_span.set_attribute("tool.name", tool_name.to_s)
+            # Records which MCP server (if any) serves this tool, so tool
+            # traffic can be grouped by service downstream.
+            ToolOrigin.annotate(tool_span, tool_name)
             arguments = kwargs.presence || (args.length == 1 ? args.first : args.presence)
             if arguments.present?
               tool_span.set_attribute("tool.input.args", agent.send(:telemetry_truncate, JSON.generate(arguments)))

data/lib/active_agent/telemetry/tool_origin.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Telemetry
+    # Classifies where a tool call came from, so dashboards can group tool
+    # traffic by the service that serves it instead of showing a flat list
+    # of names.
+    #
+    # Telemetry only ever sees the name a provider used to invoke the tool,
+    # so the origin has to be recovered from naming conventions. The MCP
+    # ecosystem settled on a namespaced form — +mcp__<server>__<tool>+ —
+    # which most clients (Claude Code, Cursor, the Ruby MCP clients) emit
+    # verbatim, and that is the strongest signal available. Everything else
+    # falls back to "the agent class defines this method".
+    #
+    # Classification happens at instrumentation time rather than at read
+    # time so the attribution is recorded in the span itself: a trace stays
+    # self-describing, and consumers (the gem dashboard, activeagents.ai,
+    # any OTLP exporter) all read the same fields instead of each
+    # re-implementing the guess.
+    #
+    # @example Namespaced MCP tool
+    #   ToolOrigin.classify("mcp__playwright__browser_navigate")
+    #   # => { origin: "mcp", server: "playwright", tool: "browser_navigate" }
+    #
+    # @example Agent-defined method
+    #   ToolOrigin.classify("lookup_order")
+    #   # => { origin: "agent", server: nil, tool: "lookup_order" }
+    module ToolOrigin
+      # +mcp__<server>__<tool>+. The tool half may itself contain "__", so
+      # only the first two segments are structural.
+      MCP_PATTERN = /\Amcp__([^_]+(?:_[^_]+)*?)__(.+)\z/
+
+      # Origin values written to +tool.origin+.
+      MCP = "mcp"
+      AGENT = "agent"
+
+      module_function
+
+      # Classifies a tool name.
+      #
+      # @param name [String, Symbol] the tool name as the provider invoked it
+      # @return [Hash] +:origin+ ("mcp" or "agent"), +:server+ (MCP server
+      #   name or nil), and +:tool+ (the bare tool name with any namespace
+      #   stripped)
+      def classify(name)
+        name = name.to_s
+
+        if (match = MCP_PATTERN.match(name))
+          { origin: MCP, server: match[1], tool: match[2] }
+        else
+          { origin: AGENT, server: nil, tool: name }
+        end
+      end
+
+      # Whether a tool name is namespaced to an MCP server.
+      #
+      # @param name [String, Symbol]
+      # @return [Boolean]
+      def mcp?(name)
+        MCP_PATTERN.match?(name.to_s)
+      end
+
+      # The MCP server a tool belongs to, if any.
+      #
+      # @param name [String, Symbol]
+      # @return [String, nil]
+      def server_for(name)
+        classify(name)[:server]
+      end
+
+      # Writes the classification onto a span. Only sets +tool.mcp_server+
+      # when there is a server to name, so agent-defined tools don't carry
+      # an empty attribute.
+      #
+      # @param span [ActiveAgent::Telemetry::Span]
+      # @param name [String, Symbol] the tool name
+      # @return [Hash] the classification, for callers that also want it
+      def annotate(span, name)
+        classification = classify(name)
+        span.set_attribute("tool.origin", classification[:origin])
+        if classification[:server]
+          span.set_attribute("tool.mcp_server", classification[:server])
+          span.set_attribute("tool.base_name", classification[:tool])
+        end
+        classification
+      end
+    end
+  end
+end

data/lib/active_agent/telemetry.rb

@@ -54,6 +54,7 @@ module ActiveAgent
     autoload :Span
     autoload :Reporter
     autoload :Instrumentation
+    autoload :ToolOrigin
 
     class << self
       # Returns the telemetry configuration instance.

data/lib/active_agent/version.rb

@@ -1,3 +1,3 @@
 module ActiveAgent
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/active_agent.rb

@@ -16,10 +16,6 @@ require "active_support/lazy_load_hooks"
 # Module Level Extensions
 require "active_agent/configuration"
 require "active_agent/railtie" if defined?(Rails)
-# The dashboard is a Rails engine; engines must be defined when the gem is
-# required (before the host app collects railtie initializers), so it
-# cannot be left to the Dashboard autoload above.
-require "active_agent/dashboard" if defined?(Rails)
 
 # ActiveAgent is a framework for building AI agents with Rails-like conventions.
 #
@@ -112,7 +108,6 @@ module ActiveAgent
   autoload :Tooling, "active_agent/concerns/tooling"
   autoload :View, "active_agent/concerns/view"
   autoload :Telemetry
-  autoload :Dashboard
 
   class << self
     # Eagerly loads all ActiveAgent components and descendant agent classes.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeagent
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Justin Bowen
@@ -109,6 +109,26 @@ dependencies:
     - - "<="
       - !ruby/object:Gem::Version
         version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: activeagents-telemetry
   requirement: !ruby/object:Gem::Requirement
@@ -400,34 +420,6 @@ files:
 - lib/active_agent/concerns/tooling.rb
 - lib/active_agent/concerns/view.rb
 - lib/active_agent/configuration.rb
-- lib/active_agent/dashboard.rb
-- lib/active_agent/dashboard/app/controllers/active_agent/dashboard/api/traces_controller.rb
-- lib/active_agent/dashboard/app/controllers/active_agent/dashboard/application_controller.rb
-- lib/active_agent/dashboard/app/controllers/active_agent/dashboard/dashboard_controller.rb
-- lib/active_agent/dashboard/app/controllers/active_agent/dashboard/traces_controller.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/dashboard/agent_execution_job.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/dashboard/application_job.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/dashboard/sandbox_cleanup_job.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/dashboard/sandbox_provision_job.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/process_telemetry_traces_job.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/agent.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/agent_run.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/agent_template.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/agent_version.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/application_record.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/recording_action.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/recording_snapshot.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/sandbox_run.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/sandbox_session.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/session_recording.rb
-- lib/active_agent/dashboard/app/models/active_agent/telemetry_trace.rb
-- lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/_trace_detail.html.erb
-- lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/index.html.erb
-- lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/metrics.html.erb
-- lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/show.html.erb
-- lib/active_agent/dashboard/app/views/layouts/active_agent/dashboard/application.html.erb
-- lib/active_agent/dashboard/config/routes.rb
-- lib/active_agent/dashboard/engine.rb
 - lib/active_agent/deprecator.rb
 - lib/active_agent/generation.rb
 - lib/active_agent/generation_job.rb
@@ -551,14 +543,12 @@ files:
 - lib/active_agent/telemetry/instrumentation.rb
 - lib/active_agent/telemetry/reporter.rb
 - lib/active_agent/telemetry/span.rb
+- lib/active_agent/telemetry/tool_origin.rb
 - lib/active_agent/telemetry/tracer.rb
 - lib/active_agent/version.rb
 - lib/activeagent.rb
 - lib/generators/active_agent/agent/USAGE
 - lib/generators/active_agent/agent/agent_generator.rb
-- lib/generators/active_agent/dashboard/install_generator.rb
-- lib/generators/active_agent/dashboard/templates/active_agent_dashboard.rb.erb
-- lib/generators/active_agent/dashboard/templates/create_active_agent_telemetry_traces.rb.erb
 - lib/generators/active_agent/install/USAGE
 - lib/generators/active_agent/install/install_generator.rb
 - lib/generators/active_agent/templates/active_agent.yml

data/lib/active_agent/dashboard/app/controllers/active_agent/dashboard/api/traces_controller.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    module Api
-      # Telemetry ingestion endpoint.
-      #
-      # Receives traces from ActiveAgent::Telemetry::Reporter and stores them
-      # for analysis and visualization in the dashboard.
-      #
-      # Supports two modes:
-      # - Local mode: synchronous processing; unauthenticated unless
-      #   ActiveAgent::Dashboard.ingest_api_key is set (set it whenever the
-      #   mount is reachable beyond your own machine)
-      # - Multi-tenant mode: per-account Bearer token auth, async processing
-      #   via job
-      #
-      # @example Local mode request
-      #   POST <mount>/api/traces  (e.g. /activeagents/api/traces)
-      #   Content-Type: application/json
-      #
-      #   {
-      #     "traces": [...],
-      #     "sdk": { "name": "activeagent", "version": "0.5.0" }
-      #   }
-      #
-      # @example Multi-tenant mode request
-      #   POST <mount>/api/traces  (e.g. /activeagents/api/traces)
-      #   Authorization: Bearer <api_key>
-      #   Content-Type: application/json
-      #
-      #   {
-      #     "traces": [...],
-      #     "sdk": { "name": "activeagent", "version": "0.5.0" }
-      #   }
-      #
-      class TracesController < ActionController::API
-        before_action :authenticate_api_key!, if: -> { ActiveAgent::Dashboard.multi_tenant? }
-        before_action :authenticate_ingest_key!, unless: -> { ActiveAgent::Dashboard.multi_tenant? }
-
-        # Maximum traces accepted per request (mirrors
-        # ProcessTelemetryTracesJob::MAX_TRACES_PER_JOB).
-        MAX_TRACES_PER_REQUEST = 100
-
-        # POST <mount>/api/traces  (e.g. /activeagents/api/traces)
-        def create
-          traces = Array(params[:traces]).take(MAX_TRACES_PER_REQUEST)
-          sdk_info = params[:sdk] || {}
-
-          return head :accepted if traces.empty?
-
-          if ActiveAgent::Dashboard.multi_tenant?
-            # Multi-tenant mode: process in background
-            ActiveAgent::ProcessTelemetryTracesJob.perform_later(
-              account_id: @account&.id,
-              traces: traces.as_json,
-              sdk_info: sdk_info.as_json,
-              received_at: Time.current.iso8601(6)
-            )
-          else
-            # Local mode: process synchronously
-            process_traces_synchronously(traces, sdk_info)
-          end
-
-          head :accepted
-        rescue ActionController::ParameterMissing => e
-          render json: { error: e.message }, status: :bad_request
-        rescue StandardError => e
-          Rails.logger.error("[ActiveAgent::Dashboard] Trace ingestion error: #{e.message}")
-          render json: { error: "Internal server error" }, status: :internal_server_error
-        end
-
-        private
-
-        # Authenticates the request using Bearer token from Authorization header.
-        # Only used in multi-tenant mode.
-        def authenticate_api_key!
-          token = extract_bearer_token
-
-          if token.blank?
-            render json: { error: "Missing Authorization header" }, status: :unauthorized
-            return
-          end
-
-          account_class = ActiveAgent::Dashboard.account_class.constantize
-          @account = account_class.find_by(telemetry_api_key: token)
-
-          if @account.nil?
-            render json: { error: "Invalid API key" }, status: :unauthorized
-            return
-          end
-
-          # Track usage for rate limiting (if the account responds to it)
-          @account.increment_telemetry_usage! if @account.respond_to?(:increment_telemetry_usage!)
-        end
-
-        # Requires the configured single-tenant ingest key when one is set.
-        # The telemetry reporter and ruby_llm_telemetry both send their
-        # api_key as a Bearer header, so remote apps work unchanged.
-        def authenticate_ingest_key!
-          expected = ActiveAgent::Dashboard.ingest_api_key
-          return if expected.blank?
-
-          token = extract_bearer_token
-          return if token.present? && ActiveSupport::SecurityUtils.secure_compare(token, expected)
-
-          render json: { error: "Invalid API key" }, status: :unauthorized
-        end
-
-        # Extracts Bearer token from Authorization header.
-        def extract_bearer_token
-          auth_header = request.headers["Authorization"]
-          return nil if auth_header.blank?
-
-          match = auth_header.match(/^Bearer\s+(.+)$/i)
-          match[1] if match
-        end
-
-        # Process traces synchronously for local development.
-        def process_traces_synchronously(traces, sdk_info)
-          model = ActiveAgent::Dashboard.trace_model
-
-          traces.each do |trace|
-            # Skip if trace already exists (idempotency)
-            next if model.exists?(trace_id: trace["trace_id"])
-
-            model.create_from_payload(trace, sdk_info)
-          rescue StandardError => e
-            Rails.logger.error(
-              "[ActiveAgent::Dashboard] Failed to process trace #{trace['trace_id']}: " \
-              "#{e.class} - #{e.message}"
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/dashboard/app/controllers/active_agent/dashboard/application_controller.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Base controller for the ActiveAgent Dashboard.
-    #
-    # Handles authentication and provides helper methods for multi-tenant mode.
-    class ApplicationController < ActionController::Base
-      protect_from_forgery with: :exception
-
-      before_action :authenticate_dashboard!
-
-      # Add the engine's view path
-      prepend_view_path ActiveAgent::Dashboard::Engine.dashboard_root.join("app", "views").to_s
-
-      # Use custom layout if configured, otherwise use engine layout
-      layout -> { ActiveAgent::Dashboard.layout || "active_agent/dashboard/application" }
-
-      helper_method :current_user, :current_owner
-
-      private
-
-      def authenticate_dashboard!
-        if ActiveAgent::Dashboard.authentication_method.nil?
-          # Traces contain prompts, outputs, and error backtraces. Refuse to
-          # serve them unauthenticated in production rather than exposing
-          # them to the internet by default.
-          if Rails.env.production?
-            render plain: "ActiveAgent Dashboard: set ActiveAgent::Dashboard.authentication_method " \
-              "(see docs/framework/dashboard.md) to enable access in production.",
-              status: :forbidden
-          end
-          return
-        end
-
-        result = ActiveAgent::Dashboard.authentication_method.call(self)
-        head :unauthorized unless result
-      rescue StandardError => e
-        Rails.logger.error("[ActiveAgent::Dashboard] Authentication error: #{e.message}")
-        head :unauthorized
-      end
-
-      # Returns the current user from the host application.
-      def current_user
-        return nil unless ActiveAgent::Dashboard.current_user_method
-
-        send(ActiveAgent::Dashboard.current_user_method)
-      rescue NoMethodError
-        nil
-      end
-
-      # Returns the current owner (account in multi-tenant, user otherwise).
-      def current_owner
-        if ActiveAgent::Dashboard.multi_tenant? && ActiveAgent::Dashboard.current_account_method
-          send(ActiveAgent::Dashboard.current_account_method)
-        else
-          current_user
-        end
-      rescue NoMethodError
-        nil
-      end
-    end
-  end
-end