activeagent 1.1.0 → 1.3.0

data/lib/active_agent/delegation/schema.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Delegation
+    # Declarative JSON Schema for a delegated agent's inputs and outputs.
+    #
+    # A delegation is only as good as its contract: the calling model needs to
+    # know exactly what a sub-agent accepts, and the calling *agent* needs to
+    # know what shape comes back. Schema builds both from a small DSL, from a
+    # plain JSON Schema hash, or from any class that responds to
+    # +to_json_schema+ (see {ActiveAgent::SchemaGenerator}).
+    #
+    # @example DSL
+    #   Schema.build do
+    #     string  :text, required: true, description: "Document to summarize"
+    #     integer :max_points, description: "How many bullets to return"
+    #     array   :tags, of: :string, description: "Topic tags"
+    #   end
+    #
+    # @example Plain JSON Schema
+    #   Schema.build(type: "object", properties: { text: { type: "string" } }, required: [ "text" ])
+    #
+    # @example ActiveModel / ActiveRecord
+    #   Schema.build(ContactForm) # ContactForm includes ActiveAgent::SchemaGenerator
+    class Schema
+      # Scalar types that get a one-line DSL helper.
+      SCALAR_TYPES = %i[string integer number boolean].freeze
+
+      class << self
+        # Coerces any supported schema source into a Schema.
+        #
+        # @param source [Schema, Hash, Class, nil] existing schema, raw JSON Schema,
+        #   or a class responding to +to_json_schema+
+        # @yield DSL block (evaluated against a new Schema, or yielded when arity is 1)
+        # @return [Schema]
+        # @raise [ArgumentError] when the source cannot be interpreted
+        def build(source = nil, &block)
+          schema =
+            case source
+            when Schema then source
+            when Hash   then from_hash(source)
+            when nil    then new
+            else
+              if source.respond_to?(:to_json_schema)
+                from_hash(source.to_json_schema)
+              else
+                raise ArgumentError, "Cannot build a delegation schema from #{source.inspect}. " \
+                  "Pass a Hash, a class responding to #to_json_schema, or use the block DSL."
+              end
+            end
+
+          if block
+            block.arity == 1 ? block.call(schema) : schema.instance_eval(&block)
+          end
+
+          schema
+        end
+
+        # @param hash [Hash] JSON Schema object
+        # @return [Schema]
+        def from_hash(hash)
+          hash = hash.deep_symbolize_keys
+
+          new.tap do |schema|
+            (hash[:properties] || {}).each { |name, definition| schema.property(name, definition) }
+            schema.required(*Array(hash[:required]))
+            schema.additional_properties(hash.fetch(:additionalProperties, hash.fetch(:additional_properties, false)))
+          end
+        end
+      end
+
+      def initialize
+        @properties           = {}
+        @required             = []
+        @additional_properties = false
+      end
+
+      # @return [Boolean] true when nothing has been declared
+      def empty?
+        @properties.empty?
+      end
+
+      # Declares a property from an already-built JSON Schema fragment.
+      #
+      # @param name [Symbol, String]
+      # @param definition [Hash] JSON Schema fragment (e.g. +{ type: "string" }+)
+      # @return [void]
+      def property(name, definition)
+        @properties[name.to_sym] = definition.deep_symbolize_keys
+      end
+
+      # Declares a property.
+      #
+      # @param name [Symbol, String]
+      # @param type [Symbol, String] JSON Schema type
+      # @param required [Boolean] whether the calling model must supply it
+      # @param description [String, nil] shown to the calling model — write it for a reader who
+      #   has never seen your code
+      # @param options [Hash] any other JSON Schema keyword (+enum+, +format+, +minimum+, ...)
+      # @yield nested DSL for object properties
+      # @return [void]
+      def param(name, type = :string, required: false, description: nil, **options, &block)
+        definition = { type: type.to_s, description: description }.compact.merge(options)
+
+        if block
+          nested = self.class.build(&block)
+          definition = definition.merge(nested.to_json_schema.except(:type))
+          definition[:type] = "object"
+        end
+
+        property(name, definition)
+        self.required(name) if required
+      end
+
+      SCALAR_TYPES.each do |type|
+        define_method(type) do |name, **options|
+          param(name, type, **options)
+        end
+      end
+
+      # Declares an object property.
+      #
+      # @param name [Symbol, String]
+      # @yield nested DSL
+      def object(name, **options, &block)
+        param(name, :object, **options, &block)
+      end
+
+      # Declares an array property.
+      #
+      # @param name [Symbol, String]
+      # @param of [Symbol, String, Hash, nil] item type, or a JSON Schema fragment for items
+      # @yield nested DSL describing an object item type
+      def array(name, of: nil, **options, &block)
+        items =
+          if block
+            self.class.build(&block).to_json_schema
+          elsif of.is_a?(Hash)
+            of.deep_symbolize_keys
+          elsif of
+            { type: of.to_s }
+          end
+
+        param(name, :array, **options.merge({ items: items }.compact))
+      end
+
+      # Marks properties as required.
+      #
+      # @param names [Array<Symbol, String>]
+      # @return [Array<Symbol>]
+      def required(*names)
+        names.flatten.each { |name| @required |= [ name.to_sym ] }
+        @required
+      end
+
+      # @param value [Boolean]
+      def additional_properties(value = true)
+        @additional_properties = value
+      end
+
+      # @return [Array<Symbol>] declared property names
+      def keys
+        @properties.keys
+      end
+
+      # @return [Array<Symbol>] required property names
+      def required_keys
+        @required.dup
+      end
+
+      # @return [Hash] JSON Schema object
+      #
+      # @note Deep-duplicated: providers normalize tool definitions in place,
+      #   and a schema is shared by every generation that exposes it.
+      def to_json_schema
+        {
+          type: "object",
+          properties: @properties.deep_dup,
+          required: @required.map(&:to_s),
+          additionalProperties: @additional_properties
+        }
+      end
+      alias_method :to_h, :to_json_schema
+
+      # JSON Schema for a +response_format+ payload.
+      #
+      # ActiveAgent camelizes response-format schema *keys* on the way to the
+      # provider, but the +required+ array holds string *values* — so they are
+      # camelized here to keep the emitted schema internally consistent.
+      # {Assistant#parsed_json} underscores the keys again on the way back, so
+      # agent code only ever sees snake_case.
+      #
+      # @param name [String] schema name reported to the provider
+      # @param strict [Boolean]
+      # @return [Hash]
+      def to_response_format(name:, strict: true)
+        schema = to_json_schema
+        schema[:required] = schema[:required].map { |key| key.camelize(:lower) }
+
+        { name: name, schema: schema, strict: strict }
+      end
+
+      # Validates a parsed payload against the declared required properties.
+      #
+      # This is a deliberately shallow check: it catches the failure that
+      # actually happens in practice (a model omitting a required key) without
+      # pulling a full JSON Schema validator into the gem's dependencies.
+      #
+      # @param payload [Hash, nil]
+      # @return [Array<Symbol>] missing required keys
+      def missing_keys(payload)
+        return required_keys if payload.nil?
+        return [] unless payload.is_a?(Hash)
+
+        keys = payload.keys.map { |key| key.to_s.underscore.to_sym }
+        required_keys.reject { |key| keys.include?(key) }
+      end
+    end
+  end
+end

data/lib/active_agent/providers/_base_provider.rb

@@ -54,8 +54,11 @@ module ActiveAgent
       attr_internal :options, :context, :trace_id,   # Setup
                     :request, :message_stack,        # Runtime
                     :stream_broadcaster, :streaming, # Callback (Streams)
+                    :stream_completion_pending,      # Callback (Streams)
+                    :stream_completion_result,       # Callback (Streams)
                     :tools_function,                 # Callback (Tools)
                     :usage_stack,                    # Usage Tracking
+                    :stream_usage_index,             # Usage Tracking (Streams)
                     :max_tool_turns, :tool_turns     # Tool-loop safety
 
       # Upper bound on tool-calling round-trips within one generation. A
@@ -118,6 +121,9 @@ module ActiveAgent
         self.context            = kwargs
         self.message_stack      = []
         self.usage_stack        = []
+        self.stream_completion_pending = false
+        self.stream_completion_result  = nil
+        self.stream_usage_index        = nil
       end
 
       # Generates prompt preview without executing the API call.
@@ -179,6 +185,9 @@ module ActiveAgent
       #
       # @return [ActiveAgent::Providers::Common::PromptResponse]
       def resolve_prompt
+        # Each turn streams its own usage; see record_stream_usage.
+        self.stream_usage_index = nil
+
         api_parameters = api_request_build(prepare_prompt_request, prompt_request_type)
         api_response = instrument("prompt.provider.active_agent") do |payload|
           raw_response = with_exception_handling { api_prompt_execute(api_parameters) }
@@ -193,6 +202,12 @@ module ActiveAgent
           raw_response
         end
 
+        # A stream that deferred its completion has already run
+        # process_prompt_finished (including any tool-call recursion) from
+        # stream_finished!, and holds the response it produced. Calling it a
+        # second time here would re-run that work.
+        return stream_completion_result if stream_completion_result
+
         process_prompt_finished(api_response)
       end
 
@@ -231,7 +246,11 @@ module ActiveAgent
       # @return [Hash] API request parameters
       def api_request_build(request, request_type)
         parameters          = request_type.serialize(request)
-        parameters[:stream] = process_stream if request.try(:stream)
+
+        if request.try(:stream)
+          parameters[:stream] = process_stream
+          parameters.deep_merge!(api_stream_usage_parameters)
+        end
 
         if options.extra_headers.present?
           parameters[:request_options] = { extra_headers: options.extra_headers }.deep_merge(parameters[:request_options] || {})
@@ -240,6 +259,20 @@ module ActiveAgent
         parameters
       end
 
+      # Extra request parameters needed to make the provider report token usage
+      # while streaming.
+      #
+      # A streaming request returns its usage on a final chunk rather than in a
+      # response body, and several providers only send that chunk when the
+      # request asks for it. Providers that need such a flag override this;
+      # the default asks for nothing, so a provider that reports usage
+      # unconditionally — or not at all — is unaffected.
+      #
+      # @return [Hash]
+      def api_stream_usage_parameters
+        {}
+      end
+
       # @return [Proc] for each response chunk
       def process_stream
         proc do |api_response_chunk|
@@ -258,10 +291,27 @@ module ActiveAgent
           api_prompt_executer.create(**parameters)
         else
           api_prompt_executer.stream(**parameters.except(:stream)).each(&parameters[:stream])
+          stream_finished!
           nil
         end
       end
 
+      # Runs the deferred end-of-generation work once a stream has drained.
+      #
+      # A chunk handler that completed the message marks the generation
+      # pending rather than finishing inline, because providers emit their
+      # usage chunk after the content is done — finishing inline would build
+      # the response before usage is recorded. Handlers that finish inline
+      # leave the flag unset and this is a no-op.
+      #
+      # @return [Object, nil] result of process_prompt_finished, if deferred
+      def stream_finished!
+        return unless stream_completion_pending
+
+        self.stream_completion_pending = false
+        self.stream_completion_result  = process_prompt_finished
+      end
+
       # Returns provider-specific API executer for prompt requests.
       #
       # Since all currently implemented providers use stainless gems, subclasses
@@ -305,6 +355,52 @@ module ActiveAgent
         fail NotImplementedError, "Subclass expected to implement"
       end
 
+      # Records token usage carried on a streaming chunk.
+      #
+      # The non-streaming path pushes onto usage_stack in resolve_prompt, from
+      # the response body. A streaming request has no response body — the
+      # provider streams chunks and api_prompt_execute returns nil — so usage
+      # would otherwise be lost, and every streamed generation reports zero
+      # tokens and zero cost. Chunk handlers call this when they see usage so
+      # the two paths converge on the same usage_stack.
+      #
+      # Ignores blank and all-zero payloads: providers send `usage: null` on
+      # ordinary content chunks, and pushing those would add empty entries to
+      # a stack that is summed with reduce(:+).
+      #
+      # A streamed usage payload is a running total for the turn, not a delta,
+      # so the turn keeps a single entry that later payloads replace. Chat
+      # Completions sends exactly one, on a final chunk, but Gemini's
+      # OpenAI-compatible endpoint repeats a cumulative usage on every chunk —
+      # summing those would report a turn's tokens many times over. Tool
+      # calling still accumulates across turns: each turn enters resolve_prompt
+      # and starts a fresh entry.
+      #
+      # @param raw_usage [Hash, Object, nil] provider-shaped usage payload
+      # @return [void]
+      def record_stream_usage(raw_usage)
+        return if raw_usage.blank?
+
+        # from_provider_usage only reads hashes, and the stainless gems hand
+        # back model objects (e.g. OpenAI::Models::CompletionUsage), so an
+        # unconverted object is silently dropped.
+        raw_usage = raw_usage.deep_to_h if raw_usage.respond_to?(:deep_to_h)
+        raw_usage = raw_usage.to_h if !raw_usage.is_a?(Hash) && raw_usage.respond_to?(:to_h)
+
+        usage = Common::Usage.from_provider_usage(raw_usage)
+        return if usage.blank?
+        return if usage.total_tokens.to_i.zero? &&
+                  usage.input_tokens.to_i.zero? &&
+                  usage.output_tokens.to_i.zero?
+
+        if stream_usage_index
+          usage_stack[stream_usage_index] = usage
+        else
+          self.stream_usage_index = usage_stack.length
+          usage_stack.push(usage)
+        end
+      end
+
       # Broadcasts stream open event.
       #
       # Fires once per request cycle, even during multi-turn tool calling.

data/lib/active_agent/providers/open_ai/chat_provider.rb

@@ -26,6 +26,15 @@ module ActiveAgent
 
         protected
 
+        # Chat Completions reports a streamed request's token usage on a final
+        # chunk, and only when the request opts in.
+        #
+        # @return [Hash]
+        # @see Base#api_stream_usage_parameters
+        def api_stream_usage_parameters
+          { stream_options: { include_usage: true } }
+        end
+
         # @return [OpenAI::Client::Completions] the API client for chat completions
         # @see Base#api_prompt_executer
         def api_prompt_executer
@@ -100,7 +109,12 @@ module ActiveAgent
           # Called Multiple Times: [Chunk<T>, T]<Content, ToolsCall>
           case api_response_event.type
           when :chunk
+            # The usage chunk carries usage and an empty choices array, so it
+            # must be read before choices.first is dereferenced below.
+            record_stream_usage(api_response_event.chunk.try(:usage))
+
             api_message = api_response_event.chunk.choices.first
+            return if api_message.nil?
 
             # If we have a delta, we need to update a message in the stack
             message = find_or_create_message(api_message.index)
@@ -118,8 +132,13 @@ module ActiveAgent
             # Returns the full content when complete
             # => {type: :"content.done", content: "Hi there! How can I help you today?", parsed: nil}
 
-            # Once we are finished, close out and run tooling callbacks (Recursive)
-            process_prompt_finished
+            # Close out and run tooling callbacks (Recursive) — but not here.
+            # The usage chunk is emitted *after* content.done, and finishing
+            # at this point builds the response from a usage_stack that has
+            # not received it yet, so a streamed generation reports zero
+            # tokens. Deferred to stream_finished!, which the base provider
+            # calls once the stream has drained.
+            self.stream_completion_pending = true
           when :"tool_calls.function.arguments.delta"
             # => {type: :"tool_calls.function.arguments.delta", name: "get_current_weather", index: 0, arguments: "", parsed: nil, arguments_delta: ""}
           when :"tool_calls.function.arguments.done"

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

@@ -94,12 +94,24 @@ module ActiveAgent
                 prompt_span.set_attribute("prompt.input.tools", JSON.generate(roster)) if roster.any?
               end
 
-              if (outbound = prompt_options[:messages]).present?
+              # prompt_options[:messages] holds the turns a caller passed
+              # explicitly. An agent that renders its user turn from the
+              # action's template — the idiomatic form, `instructions:` plus
+              # `locals:` — has none at this point: the rendering happens
+              # later, in prepare_prompt_parameters. Falling back to it means
+              # the message the model actually received is on the trace either
+              # way, which is what an evaluation scores.
+              outbound = prompt_options[:messages]
+              outbound = rendered_prompt_messages if outbound.blank?
+
+              if outbound.present?
                 serialized = Array(outbound).map { |message|
                   if message.is_a?(Hash)
                     role = message[:role] || message["role"] || "user"
                     content = message[:content] || message["content"]
                     { role: role.to_s, content: telemetry_truncate(content) }
+                  elsif message.respond_to?(:content)
+                    { role: (message.try(:role) || "user").to_s, content: telemetry_truncate(message.content) }
                   else
                     { role: "user", content: telemetry_truncate(message) }
                   end
@@ -147,6 +159,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 +215,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)))
@@ -253,6 +269,27 @@ module ActiveAgent
         # tool loop) can't bloat the trace payload.
         TELEMETRY_ATTRIBUTE_MAX_CHARS = 4_000
 
+        # The turns this generation will actually send, for an agent that
+        # renders its user message from the action's template rather than
+        # passing `messages:`. prepare_prompt_parameters is a pure function of
+        # prompt_options — it deep_dups its input and mutates no instance
+        # state — so calling it here is a read, not a side effect. It does
+        # re-render the templates, which is why it is only reached when there
+        # are no explicit messages to record.
+        #
+        # Never raises: a provider that builds parameters differently, or an
+        # agent whose templates need context this call does not have, must
+        # cost the generation nothing more than an absent attribute.
+        def rendered_prompt_messages
+          return unless respond_to?(:prepare_prompt_parameters, true)
+
+          parameters = prepare_prompt_parameters
+          parameters[:messages] || parameters["messages"]
+        rescue StandardError => e
+          logger&.debug { "[ActiveAgent::Telemetry] could not read rendered messages: #{e.class}: #{e.message}" }
+          nil
+        end
+
         def telemetry_truncate(value)
           text = value.to_s
           return text if text.length <= TELEMETRY_ATTRIBUTE_MAX_CHARS

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.3.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.
 #
@@ -97,6 +93,7 @@ module ActiveAgent
   # These components are loaded on-demand when first referenced.
   autoload :Base
   autoload :Callbacks, "active_agent/concerns/callbacks"
+  autoload :Delegation, "active_agent/concerns/delegation"
   autoload :Streaming, "active_agent/concerns/streaming"
   autoload :InlinePreviewInterceptor
   autoload :Generation
@@ -112,7 +109,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.