activeagent 1.0.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90c3dbcc6a09014256fc36ac0bf88de83aa6a85d95c688be1eb289dde397c633
-  data.tar.gz: 6bdf588db4ab2809efaddde5ee7b06fd58ad59e1b5b3479e6c653828d90a4ad9
+  metadata.gz: 867cf01603bb86b99c7abdbe6cc9e731264dc60bfdf3e89ca19a4d25fca5ea3d
+  data.tar.gz: c8b86f8988ff27931f4a82f8aa71aa04168bceae00f8f9cab6b98507dd3d2b94
 SHA512:
-  metadata.gz: a70e79c1a1b0f683ac3322476b9f2cdaa70deaf3f8e035d2d5307e8fb6561ea5cc5b2589edfa1b2e3a68e28a2db0806d591d1f6726cbd6ab39ed512a072388db
-  data.tar.gz: a94dd4a891041044b02117ddc2bcf448cbf1c31c764fbaf8e3cd88b0b81cddf636bb90cac2ddfcb4706ec91b46da2490fdb24fd1e967d9aa200e95ca655a8caf
+  metadata.gz: 8c81f0537fddda60bbe3049cdb36b0478130d969ba0d35af408f3a5c527e2448d8e733638cd94b6c72c8f4b8d1ec13da32877baae3101e0373cc7d173253d06c
+  data.tar.gz: 6af0f6a1879a9e291581a51beb5b6b96ac2ec641a9ebc007cb2345c695e1f746741fbb667bd761f889591d15c7ffeb917e7ecb7c5d1151f4d6687af3f87a3930

data/CHANGELOG.md

@@ -5,6 +5,138 @@ 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
+
+The engine can now be mounted in any Rails app as the self-hosted
+observability surface (see `docs/framework/self-hosted-observability.md`):
+
+- **One install generator**: the duplicate `active_agent:dashboard:install`
+  variant that copied eight migrations (agents, sandboxes, recordings —
+  tables for models with no shipped controllers or routes) is removed.
+  The surviving generator installs the telemetry traces table only and
+  gains `--skip_migrations` / `--skip_routes`; its initializer template now
+  covers authentication, `ingest_api_key`, and multi-tenant options.
+- **Canonical mount path is `/activeagents`** (generator, dummy app and
+  docs updated). `Telemetry::Configuration#resolved_endpoint` now reports
+  the ingest path for wherever the engine is actually mounted — any mount
+  path, including `/` on a dedicated subdomain — instead of a hardcoded
+  constant, falling back to `LOCAL_ENDPOINT_PATH` when it isn't mounted.
+  Note this is informational: `local_storage` capture writes through the
+  trace model without HTTP, and remote apps set `endpoint:` explicitly.
+- **`TracesController` honors configuration**: index/metrics/time-series
+  queries now go through `ActiveAgent::Dashboard.trace_model` (previously
+  only `show` did) and are scoped with `for_account(current_owner)`, so a
+  `trace_model_class` override and multi-tenant scoping apply everywhere.
+- **Single-tenant ingest auth**: new `config.ingest_api_key` requires a
+  matching Bearer token on `POST <mount>/api/traces` when set. The
+  telemetry reporter and ruby_llm_telemetry already send their `api_key`
+  as a Bearer header, so remote apps need no changes.
+- **Metrics page no longer 500s with data**: the per-agent stats table
+  read a grouped SQL alias through a model method that expected per-trace
+  token columns.
+- **Mount detection is route-set based**: the ingest path is resolved by
+  locating the mounted engine in the host's routes rather than assuming
+  the default `active_agent_path` helper, so `mount ... => "/", as:
+  :something_else` and constraint-wrapped (subdomain) mounts resolve
+  correctly instead of silently falling back.
+- Deprecated the never-consumed `base_controller_class` config attribute:
+  it remains a no-op accessor with its historical default so existing
+  initializers keep booting, and will be removed in the next major.
+
+### Dashboard & Telemetry — dev console readiness
+
+The dashboard engine — Active Agent's local dev console — now works out of
+the box (production observability is the hosted platform product):
+
+- **Engine load paths fixed**: `Engine.find_root` now points at the
+  dashboard directory, so `ActiveAgent::TelemetryTrace`,
+  `ProcessTelemetryTracesJob`, the API controller, views and engine routes
+  are auto-discovered in host apps (previously they required manual
+  `require`s). The engine is also required eagerly with Rails, since
+  engines defined lazily miss initializer collection.
+- **Routes now match shipped controllers**: the engine exposes traces,
+  metrics and the ingest API (`<mount>/api/traces`); routes to
+  never-shipped controllers (agents, sandboxes, templates, recordings,
+  api/v1) were removed. Engine root renders the traces index.
+- **`local_storage` telemetry mode fixed**: tracer payloads are
+  symbol-keyed and were silently dropped by the string-keyed ingestion
+  normalizer; the reporter now stringifies and honors
+  `ActiveAgent::Dashboard.trace_model` overrides.
+- **Token totals no longer double-count**: instrumentation mirrors LLM
+  token usage onto the root span; `TelemetryTrace.create_from_payload`
+  now counts child spans as the source of truth.
+- **Span waterfall renders real offsets** (was pinned to 0ms), turbo-rails
+  is now optional (previously 500s without it), layout route helpers fixed,
+  `Agent.for_owner` scope added, synchronous ingest capped at 100
+  traces/request.
+- **New docs** (`docs/framework/dashboard.md`, README section) covering
+  install, authentication (none by default — see docs), remote ingestion
+  and multi-tenant mode; dashboard engine test suite added
+  (`test/dashboard/`).
+
 ## [1.0.0] - 2025-11-21
 
 Major refactor with breaking changes. Complete provider rewrite. New modular architecture.

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,6 +131,38 @@ development:
     service: "RubyLLM"
 ```
 
+## Dashboard & Dev Console
+
+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
+bundle add actionagent
+rails generate action_agent:install
+rails db:migrate
+```
+
+```yaml
+# config/active_agent.yml
+telemetry:
+  enabled: true
+  local_storage: true
+```
+
+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. 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
 
 - **Agent-Oriented Programming**: Build AI applications using familiar Rails patterns
@@ -173,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/base.rb

@@ -304,6 +304,10 @@ module ActiveAgent
       # Render out proc/lamda attributes before rendering templates
       parameters.deep_transform_values! { _1.respond_to?(:call) ? _1.call : _1 }
 
+      # Strip parameters the target model rejects (e.g. temperature/top_p
+      # on thinking-first models) before they reach the provider.
+      ModelCapabilities.sanitize!(parameters)
+
       # Apply Callbacks
       parameters.merge!(
         trace_id: prompt_options[:trace_id] || SecureRandom.uuid,

data/lib/active_agent/model_capabilities.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  # Per-model capability quirks, applied before a request reaches the
+  # provider. Vendors ship models that reject otherwise-standard sampling
+  # parameters (thinking-first models steered by prompting/effort instead)
+  # with an API 400 — this registry strips those parameters up front so an
+  # agent configured with a shared temperature keeps working across model
+  # switches.
+  #
+  # The built-in rules cover the known families; apps can extend the
+  # registry for new or self-hosted models:
+  #
+  # @example Register a custom rule
+  #   ActiveAgent::ModelCapabilities.register(/\Amy-reasoning-model/, unsupported: [:temperature, :top_p])
+  #
+  # @example Disable sanitization entirely
+  #   ActiveAgent::ModelCapabilities.enabled = false
+  module ModelCapabilities
+    SAMPLING_PARAMS = [ :temperature, :top_p ].freeze
+
+    # Model families that reject sampling parameters with a 400:
+    # - Anthropic thinking-first models (Opus 4.7+, Opus 5, Sonnet 5,
+    #   Fable 5 / Mythos 5)
+    # - OpenAI reasoning models (o-series, GPT-5 family)
+    BUILTIN_RULES = [
+      { pattern: /\Aclaude-(opus-5|opus-4-[78]|sonnet-5|fable-5|mythos-5)/, unsupported: SAMPLING_PARAMS },
+      { pattern: /\A(o1|o3|o4)(-|$)/, unsupported: SAMPLING_PARAMS },
+      { pattern: /\Agpt-5/, unsupported: SAMPLING_PARAMS }
+    ].freeze
+
+    class << self
+      # Master switch; on by default. Set false to send parameters through
+      # untouched (the vendor then enforces its own rules).
+      attr_writer :enabled
+
+      def enabled
+        return @enabled unless @enabled.nil?
+
+        true
+      end
+
+      # Registers an app-defined capability rule ahead of the built-ins.
+      #
+      # @param pattern [Regexp] matched against the model name
+      # @param unsupported [Array<Symbol>] parameter keys the model rejects
+      def register(pattern, unsupported:)
+        custom_rules << { pattern: pattern, unsupported: unsupported.map(&:to_sym) }
+      end
+
+      def custom_rules
+        @custom_rules ||= []
+      end
+
+      def reset!
+        @custom_rules = []
+        @enabled = nil
+      end
+
+      # @return [Array<Symbol>] parameter keys the model rejects
+      def unsupported_params(model)
+        return [] if model.nil?
+
+        (custom_rules + BUILTIN_RULES).each do |rule|
+          return rule[:unsupported] if model.to_s.match?(rule[:pattern])
+        end
+        []
+      end
+
+      def sampling_supported?(model)
+        (unsupported_params(model) & SAMPLING_PARAMS).empty?
+      end
+
+      # Strips parameters the model rejects, in place. Returns the removed
+      # keys (empty when nothing applied).
+      #
+      # @param parameters [Hash] prepared prompt parameters (must carry :model)
+      # @return [Array<Symbol>] removed parameter keys
+      def sanitize!(parameters)
+        return [] unless enabled
+        return [] unless parameters.is_a?(Hash)
+
+        removed = unsupported_params(parameters[:model]).select { |key| parameters.key?(key) }
+        removed.each { |key| parameters.delete(key) }
+        removed
+      end
+    end
+  end
+end

data/lib/active_agent/providers/_base_provider.rb

@@ -55,7 +55,13 @@ module ActiveAgent
                     :request, :message_stack,        # Runtime
                     :stream_broadcaster, :streaming, # Callback (Streams)
                     :tools_function,                 # Callback (Tools)
-                    :usage_stack                     # Usage Tracking
+                    :usage_stack,                    # Usage Tracking
+                    :max_tool_turns, :tool_turns     # Tool-loop safety
+
+      # Upper bound on tool-calling round-trips within one generation. A
+      # model that keeps emitting tool calls otherwise recurses until the
+      # provider stops it — override per agent/prompt with max_tool_turns:.
+      DEFAULT_MAX_TOOL_TURNS = 25
 
       # @return [String] e.g., "Anthropic", "OpenAI"
       def self.service_name
@@ -106,6 +112,8 @@ module ActiveAgent
         self.stream_broadcaster = kwargs.delete(:stream_broadcaster)
         self.streaming          = false
         self.tools_function     = kwargs.delete(:tools_function)
+        self.max_tool_turns     = kwargs.delete(:max_tool_turns) || DEFAULT_MAX_TOOL_TURNS
+        self.tool_turns         = 0
         self.options            = options_klass.new(kwargs.extract!(*options_klass.keys))
         self.context            = kwargs
         self.message_stack      = []
@@ -344,7 +352,7 @@ module ActiveAgent
           message_stack.push(*api_messages)
         end
 
-        if (tool_calls = process_prompt_finished_extract_function_calls)&.any?
+        if (tool_calls = process_prompt_finished_extract_function_calls)&.any? && tool_turn_allowed?
           process_function_calls(tool_calls)
           resolve_prompt
         else
@@ -373,6 +381,19 @@ module ActiveAgent
         end
       end
 
+      # Counts a tool round-trip against the per-generation cap. When the
+      # cap is hit the loop finishes cleanly with the messages gathered so
+      # far (a partial result) instead of recursing indefinitely.
+      #
+      # @return [Boolean] whether another tool round-trip may run
+      def tool_turn_allowed?
+        self.tool_turns += 1
+        return true if max_tool_turns.nil? || tool_turns <= max_tool_turns
+
+        instrument("tool_turns_exceeded.active_agent", limit: max_tool_turns)
+        false
+      end
+
       # @abstract
       # @param api_response [Object]
       # @return [Array<Message>, nil]

data/lib/active_agent/providers/concerns/exception_handler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../errors"
+
 module ActiveAgent
   module Providers
     # Provides exception handling for provider operations.
@@ -54,7 +56,16 @@ module ActiveAgent
       def with_exception_handling(&block)
         yield
       rescue => exception
-        rescue_with_handler(exception) || raise
+        # Vendor API failures are normalized into the framework taxonomy
+        # (Errors::RateLimited, Errors::ContextLengthExceeded, ...) so
+        # rescue_from policy is portable across providers; the original
+        # exception is preserved as #cause. Anything unrecognizable —
+        # including ordinary Ruby errors — passes through untouched.
+        exception = Errors::Taxonomy.normalize(
+          exception,
+          provider_tag: (tag_name if respond_to?(:tag_name))
+        )
+        rescue_with_handler(exception) || raise(exception)
         nil # Discard handler return value to prevent polluting raw_response
       end
 

data/lib/active_agent/providers/errors.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    # Typed provider failures, normalized across vendor SDKs.
+    #
+    # Every vendor raises its own exception classes for the same underlying
+    # conditions (rate limits, context overflows, content filters, outages),
+    # which makes retry/backoff/fallback policy impossible to express
+    # portably. The taxonomy classifies vendor errors into a small set of
+    # framework types — the original exception is preserved as +#cause+, so
+    # nothing is lost.
+    #
+    # @example Portable retry policy
+    #   rescue_from ActiveAgent::Providers::Errors::RateLimited do |error|
+    #     retry_job wait: 30.seconds
+    #   end
+    #
+    # @example Fallback on outage
+    #   rescue_from ActiveAgent::Providers::Errors::ServiceUnavailable do |error|
+    #     FallbackAgent.with(params).ask.generate_later
+    #   end
+    module Errors
+      # Base class for normalized provider failures.
+      class ProviderError < StandardError
+        # @return [Integer, nil] HTTP status from the vendor error, when known
+        attr_reader :status
+
+        # @return [String, nil] provider tag (e.g. "Anthropic", "OpenAI::Chat")
+        attr_reader :provider_tag
+
+        def initialize(message = nil, status: nil, provider_tag: nil)
+          super(message)
+          @status = status
+          @provider_tag = provider_tag
+        end
+      end
+
+      # 429s / vendor rate & quota limits. Retryable with backoff.
+      class RateLimited < ProviderError; end
+
+      # The prompt exceeded the model's context window. Not retryable
+      # without shrinking the input.
+      class ContextLengthExceeded < ProviderError; end
+
+      # Invalid, expired, or unauthorized credentials (401/403).
+      class AuthenticationFailed < ProviderError; end
+
+      # The vendor's safety layer refused the request or response.
+      class ContentFiltered < ProviderError; end
+
+      # Vendor-side failure or overload (5xx, timeouts, connection drops).
+      # Retryable; a natural trigger for provider fallback.
+      class ServiceUnavailable < ProviderError; end
+
+      # Malformed or unsupported request the vendor rejected (400/422)
+      # that doesn't classify more specifically.
+      class InvalidRequest < ProviderError; end
+
+      # Classifies vendor SDK exceptions into the taxonomy. Unrecognizable
+      # exceptions (including ordinary Ruby errors) pass through untouched —
+      # only errors that look like vendor API failures are normalized.
+      module Taxonomy
+        # Vendor SDK class names (demodulized) → taxonomy class. Covers the
+        # official anthropic/openai gems and SDKs following their naming.
+        NAME_MAP = {
+          "RateLimitError" => RateLimited,
+          "AuthenticationError" => AuthenticationFailed,
+          "PermissionDeniedError" => AuthenticationFailed,
+          "ContentFilterError" => ContentFiltered,
+          "InternalServerError" => ServiceUnavailable,
+          "APIConnectionError" => ServiceUnavailable,
+          "APIConnectionTimeoutError" => ServiceUnavailable,
+          "APITimeoutError" => ServiceUnavailable,
+          "OverloadedError" => ServiceUnavailable,
+          "ServiceUnavailableError" => ServiceUnavailable,
+          "BadRequestError" => InvalidRequest,
+          "UnprocessableEntityError" => InvalidRequest
+        }.freeze
+
+        STATUS_MAP = {
+          400 => InvalidRequest,
+          401 => AuthenticationFailed,
+          403 => AuthenticationFailed,
+          408 => ServiceUnavailable,
+          422 => InvalidRequest,
+          429 => RateLimited,
+          529 => ServiceUnavailable # Anthropic "overloaded"
+        }.freeze
+
+        CONTEXT_LENGTH_PATTERN = /context length|context_length|maximum context|context window|too many tokens|prompt is too long|input (?:is )?too long/i
+        CONTENT_FILTER_PATTERN = /content (?:filter|policy|management)|filtered due to|blocked by|safety (?:system|filter)/i
+
+        class << self
+          # @param exception [Exception]
+          # @param provider_tag [String, nil]
+          # @return [Exception] a taxonomy error, or the original exception
+          #   when it doesn't classify
+          def normalize(exception, provider_tag: nil)
+            return exception if exception.is_a?(ProviderError)
+
+            klass = classify(exception)
+            return exception unless klass
+
+            klass.new(exception.message, status: status_of(exception), provider_tag: provider_tag)
+          end
+
+          # @return [Class, nil]
+          def classify(exception)
+            name = exception.class.name.to_s.demodulize
+            status = status_of(exception)
+            api_error = NAME_MAP.key?(name) || !status.nil?
+            return nil unless api_error
+
+            message = exception.message.to_s
+            return ContextLengthExceeded if CONTEXT_LENGTH_PATTERN.match?(message)
+            return ContentFiltered if CONTENT_FILTER_PATTERN.match?(message)
+
+            NAME_MAP[name] || STATUS_MAP[status] || (status && status >= 500 ? ServiceUnavailable : nil)
+          end
+
+          # @return [Integer, nil]
+          def status_of(exception)
+            [ :status, :status_code, :http_status, :code ].each do |reader|
+              next unless exception.respond_to?(reader)
+
+              value = begin
+                exception.public_send(reader)
+              rescue StandardError
+                nil
+              end
+              return value if value.is_a?(Integer)
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ollama/chat/transforms.rb

@@ -55,12 +55,18 @@ module ActiveAgent
               OpenAI::Chat::Transforms.normalize_messages(messages)
             end
 
-            # Normalizes instructions using OpenAI transforms
+            # Normalizes instructions using OpenAI transforms, then remaps the
+            # role: OpenAI's transforms emit the "developer" role, but the chat
+            # templates of Ollama-served models (qwen, llama, gemma, …) only
+            # know "system" — a "developer" message is silently dropped, so the
+            # model never sees its instructions.
             #
             # @param instructions [Array<String>, String]
-            # @return [Array<OpenAI::Models::Chat::ChatCompletionMessageParam>]
+            # @return [Array<Hash>] system messages
             def normalize_instructions(instructions)
-              OpenAI::Chat::Transforms.normalize_instructions(instructions)
+              OpenAI::Chat::Transforms.normalize_instructions(instructions).map do |message|
+                message.is_a?(Hash) ? message.merge(role: "system") : message
+              end
             end
 
             # Cleans up serialized request for API submission

data/lib/active_agent/railtie.rb

@@ -67,6 +67,11 @@ module ActiveAgent
           include ActiveAgent::Telemetry::Instrumentation
           instrument_telemetry!
         end
+
+        # Flush remaining traces when the process exits — without this,
+        # short-lived processes (rails runner, jobs, deploys rolling a
+        # server) drop whatever was buffered since the last interval flush.
+        at_exit { ActiveAgent::Telemetry.shutdown }
       end
       # endregion telemetry_configuration