activeagent 1.0.0.rc1 → 1.0.0

data/lib/active_agent/providers/common/usage.rb

@@ -0,0 +1,385 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Common
+      # Normalizes token usage statistics across AI providers.
+      #
+      # Providers return usage data in different formats with different field names.
+      # This model normalizes them into a consistent structure, automatically calculating
+      # +total_tokens+ if not provided.
+      #
+      # @example Accessing normalized usage data
+      #   usage = response.normalized_usage
+      #   usage.input_tokens      #=> 100
+      #   usage.output_tokens     #=> 25
+      #   usage.total_tokens      #=> 125
+      #   usage.cached_tokens     #=> 20 (if available)
+      #
+      # @example Provider-specific details
+      #   usage.provider_details  #=> { "completion_tokens_details" => {...}, ... }
+      #   usage.duration_ms       #=> 5000 (for Ollama)
+      #   usage.service_tier      #=> "standard" (for Anthropic)
+      #
+      # @see https://platform.openai.com/docs/api-reference/chat/object OpenAI Chat Completion
+      # @see https://docs.anthropic.com/en/api/messages Anthropic Messages API
+      # @see https://github.com/ollama/ollama/blob/main/docs/api.md Ollama API
+      class Usage < BaseModel
+        # @!attribute [rw] input_tokens
+        #   Normalized from:
+        #   - OpenAI Chat/Embeddings: prompt_tokens
+        #   - OpenAI Responses API: input_tokens
+        #   - Anthropic: input_tokens
+        #   - Ollama: prompt_eval_count
+        #   - OpenRouter: prompt_tokens
+        #
+        #   @return [Integer]
+        attribute :input_tokens, :integer, default: 0
+
+        # @!attribute [rw] output_tokens
+        #   Normalized from:
+        #   - OpenAI Chat: completion_tokens
+        #   - OpenAI Responses API: output_tokens
+        #   - Anthropic: output_tokens
+        #   - Ollama: eval_count
+        #   - OpenRouter: completion_tokens
+        #   - OpenAI Embeddings: 0 (no output tokens)
+        #
+        #   @return [Integer]
+        attribute :output_tokens, :integer, default: 0
+
+        # @!attribute [rw] total_tokens
+        #   Automatically calculated as input_tokens + output_tokens if not provided by provider.
+        #
+        #   @return [Integer]
+        attribute :total_tokens, :integer
+
+        # @!attribute [rw] cached_tokens
+        #   Available from:
+        #   - OpenAI: prompt_tokens_details.cached_tokens or input_tokens_details.cached_tokens
+        #   - Anthropic: cache_read_input_tokens
+        #
+        #   @return [Integer, nil]
+        attribute :cached_tokens, :integer
+
+        # @!attribute [rw] reasoning_tokens
+        #   Available from:
+        #   - OpenAI Chat: completion_tokens_details.reasoning_tokens
+        #   - OpenAI Responses: output_tokens_details.reasoning_tokens
+        #
+        #   @return [Integer, nil]
+        attribute :reasoning_tokens, :integer
+
+        # @!attribute [rw] audio_tokens
+        #   Available from:
+        #   - OpenAI: sum of prompt_tokens_details.audio_tokens and completion_tokens_details.audio_tokens
+        #
+        #   @return [Integer, nil]
+        attribute :audio_tokens, :integer
+
+        # @!attribute [rw] cache_creation_tokens
+        #   Available from:
+        #   - Anthropic: cache_creation_input_tokens
+        #
+        #   @return [Integer, nil]
+        attribute :cache_creation_tokens, :integer
+
+        # @!attribute [rw] service_tier
+        #   Available from:
+        #   - Anthropic: service_tier ("standard", "priority", "batch")
+        #
+        #   @return [String, nil]
+        attribute :service_tier, :string
+
+        # @!attribute [rw] duration_ms
+        #   Available from:
+        #   - Ollama: total_duration (converted from nanoseconds)
+        #
+        #   @return [Integer, nil]
+        attribute :duration_ms, :integer
+
+        # @!attribute [rw] provider_details
+        #   Preserves provider-specific information that doesn't fit the normalized structure.
+        #   Useful for debugging or provider-specific features.
+        #
+        #   @return [Hash]
+        attribute :provider_details, default: -> { {} }
+
+        # Automatically calculates total_tokens if not provided.
+        #
+        # @param attributes [Hash]
+        # @option attributes [Integer] :input_tokens
+        # @option attributes [Integer] :output_tokens
+        # @option attributes [Integer] :total_tokens (calculated if not provided)
+        # @option attributes [Integer] :cached_tokens
+        # @option attributes [Integer] :reasoning_tokens
+        # @option attributes [Integer] :audio_tokens
+        # @option attributes [Integer] :cache_creation_tokens
+        # @option attributes [String] :service_tier
+        # @option attributes [Integer] :duration_ms
+        # @option attributes [Hash] :provider_details
+        def initialize(attributes = {})
+          super
+          # Calculate total_tokens if not provided
+          self.total_tokens ||= (input_tokens || 0) + (output_tokens || 0)
+        end
+
+        # Sums all token counts from two Usage objects.
+        #
+        # @param other [Usage]
+        # @return [Usage]
+        #
+        # @example
+        #   usage1 = Usage.new(input_tokens: 100, output_tokens: 50)
+        #   usage2 = Usage.new(input_tokens: 75, output_tokens: 25)
+        #   combined = usage1 + usage2
+        #   combined.input_tokens  #=> 175
+        #   combined.output_tokens #=> 75
+        #   combined.total_tokens  #=> 250
+        def +(other)
+          return self unless other
+
+          self.class.new(
+            input_tokens:          self.input_tokens  + other.input_tokens,
+            output_tokens:         self.output_tokens + other.output_tokens,
+            total_tokens:          self.total_tokens  + other.total_tokens,
+            cached_tokens:         sum_optional(self.cached_tokens,         other.cached_tokens),
+            cache_creation_tokens: sum_optional(self.cache_creation_tokens, other.cache_creation_tokens),
+            reasoning_tokens:      sum_optional(self.reasoning_tokens,      other.reasoning_tokens),
+            audio_tokens:          sum_optional(self.audio_tokens,          other.audio_tokens)
+          )
+        end
+
+        # Creates a Usage object from OpenAI Chat Completion usage data.
+        #
+        # @param usage_hash [Hash]
+        # @return [Usage]
+        #
+        # @example
+        #   Usage.from_openai_chat({
+        #     "prompt_tokens" => 100,
+        #     "completion_tokens" => 25,
+        #     "total_tokens" => 125,
+        #     "prompt_tokens_details" => { "cached_tokens" => 20 },
+        #     "completion_tokens_details" => { "reasoning_tokens" => 3 }
+        #   })
+        def self.from_openai_chat(usage_hash)
+          return nil unless usage_hash
+
+          usage = usage_hash.deep_symbolize_keys
+          prompt_details = usage[:prompt_tokens_details] || {}
+          completion_details = usage[:completion_tokens_details] || {}
+
+          audio_sum = [
+            prompt_details[:audio_tokens],
+            completion_details[:audio_tokens]
+          ].compact.sum
+
+          new(
+            **usage.slice(:total_tokens),
+            input_tokens: usage[:prompt_tokens] || 0,
+            output_tokens: usage[:completion_tokens] || 0,
+            cached_tokens: prompt_details[:cached_tokens],
+            reasoning_tokens: completion_details[:reasoning_tokens],
+            audio_tokens: audio_sum > 0 ? audio_sum : nil,
+            provider_details: usage.slice(:prompt_tokens_details, :completion_tokens_details).compact
+          )
+        end
+
+        # Creates a Usage object from OpenAI Embedding API usage data.
+        #
+        # @param usage_hash [Hash]
+        # @return [Usage]
+        #
+        # @example
+        #   Usage.from_openai_embedding({
+        #     "prompt_tokens" => 8,
+        #     "total_tokens" => 8
+        #   })
+        def self.from_openai_embedding(usage_hash)
+          return nil unless usage_hash
+
+          usage = usage_hash.deep_symbolize_keys
+
+          new(
+            **usage.slice(:total_tokens),
+            input_tokens: usage[:prompt_tokens] || 0,
+            output_tokens: 0, # Embeddings don't generate output tokens
+            provider_details: usage.except(:prompt_tokens, :total_tokens)
+          )
+        end
+
+        # Creates a Usage object from OpenAI Responses API usage data.
+        #
+        # @param usage_hash [Hash]
+        # @return [Usage]
+        #
+        # @example
+        #   Usage.from_openai_responses({
+        #     "input_tokens" => 150,
+        #     "output_tokens" => 75,
+        #     "total_tokens" => 225,
+        #     "input_tokens_details" => { "cached_tokens" => 50 },
+        #     "output_tokens_details" => { "reasoning_tokens" => 10 }
+        #   })
+        def self.from_openai_responses(usage_hash)
+          return nil unless usage_hash
+
+          usage = usage_hash.deep_symbolize_keys
+          input_details = usage[:input_tokens_details] || {}
+          output_details = usage[:output_tokens_details] || {}
+
+          new(
+            **usage.slice(:input_tokens, :output_tokens, :total_tokens),
+            input_tokens: usage[:input_tokens] || 0,
+            output_tokens: usage[:output_tokens] || 0,
+            cached_tokens: input_details[:cached_tokens],
+            reasoning_tokens: output_details[:reasoning_tokens],
+            provider_details: usage.slice(:input_tokens_details, :output_tokens_details).compact
+          )
+        end
+
+        # Creates a Usage object from Anthropic usage data.
+        #
+        # @param usage_hash [Hash]
+        # @return [Usage]
+        #
+        # @example
+        #   Usage.from_anthropic({
+        #     "input_tokens" => 2095,
+        #     "output_tokens" => 503,
+        #     "cache_read_input_tokens" => 1500,
+        #     "cache_creation_input_tokens" => 2051,
+        #     "service_tier" => "standard"
+        #   })
+        def self.from_anthropic(usage_hash)
+          return nil unless usage_hash
+
+          usage = usage_hash.deep_symbolize_keys
+
+          new(
+            **usage.slice(:input_tokens, :output_tokens, :service_tier),
+            input_tokens: usage[:input_tokens] || 0,
+            output_tokens: usage[:output_tokens] || 0,
+            cached_tokens: usage[:cache_read_input_tokens],
+            cache_creation_tokens: usage[:cache_creation_input_tokens],
+            provider_details: usage.slice(:cache_creation, :server_tool_use).compact
+          )
+        end
+
+        # Creates a Usage object from Ollama usage data.
+        #
+        # @param usage_hash [Hash]
+        # @return [Usage]
+        #
+        # @example
+        #   Usage.from_ollama({
+        #     "prompt_eval_count" => 50,
+        #     "eval_count" => 25,
+        #     "total_duration" => 5000000000,
+        #     "load_duration" => 1000000000
+        #   })
+        def self.from_ollama(usage_hash)
+          return nil unless usage_hash
+
+          usage = usage_hash.deep_symbolize_keys
+
+          new(
+            input_tokens: usage[:prompt_eval_count] || 0,
+            output_tokens: usage[:eval_count] || 0,
+            duration_ms: convert_nanoseconds_to_ms(usage[:total_duration]),
+            provider_details: {
+              load_duration_ms: convert_nanoseconds_to_ms(usage[:load_duration]),
+              prompt_eval_duration_ms: convert_nanoseconds_to_ms(usage[:prompt_eval_duration]),
+              eval_duration_ms: convert_nanoseconds_to_ms(usage[:eval_duration]),
+              tokens_per_second: calculate_tokens_per_second(usage[:eval_count], usage[:eval_duration])
+            }.compact
+          )
+        end
+
+        # Creates a Usage object from OpenRouter usage data.
+        #
+        # OpenRouter uses the same format as OpenAI Chat Completion.
+        #
+        # @param usage_hash [Hash]
+        # @return [Usage]
+        #
+        # @example
+        #   Usage.from_openrouter({
+        #     "prompt_tokens" => 14,
+        #     "completion_tokens" => 4,
+        #     "total_tokens" => 18
+        #   })
+        def self.from_openrouter(usage_hash)
+          from_openai_chat(usage_hash)
+        end
+
+        # Auto-detects the provider format and creates a normalized Usage object.
+        #
+        # @note Detection is based on hash structure rather than native gem types
+        #   because we cannot force-load all provider gems. This allows the framework
+        #   to work with only the gems the user has installed.
+        #
+        # @param usage_hash [Hash]
+        # @return [Usage, nil]
+        #
+        # @example
+        #   Usage.from_provider_usage(some_usage_hash)
+        def self.from_provider_usage(usage_hash)
+          return nil unless usage_hash.is_a?(Hash)
+
+          usage = usage_hash.deep_symbolize_keys
+
+          # Detect Ollama by presence of nanosecond duration fields
+          if usage.key?(:total_duration)
+            from_ollama(usage_hash)
+          # Detect Anthropic by presence of cache_creation or service_tier
+          elsif usage.key?(:cache_creation) || usage.key?(:service_tier)
+            from_anthropic(usage_hash)
+          # Detect OpenAI Responses API by input_tokens/output_tokens with details
+          elsif usage.key?(:input_tokens) && usage.key?(:input_tokens_details)
+            from_openai_responses(usage_hash)
+          # Detect OpenAI Chat/OpenRouter by prompt_tokens/completion_tokens
+          elsif usage.key?(:completion_tokens)
+            from_openai_chat(usage_hash)
+          # Detect OpenAI Embedding by prompt_tokens without completion_tokens
+          elsif usage.key?(:prompt_tokens)
+            from_openai_embedding(usage_hash)
+          # Default to raw initialization
+          else
+            new(usage_hash)
+          end
+        end
+
+        private
+
+        # @param a [Integer, nil]
+        # @param b [Integer, nil]
+        # @return [Integer, nil] nil if both inputs are nil
+        def sum_optional(a, b)
+          return nil if a.nil? && b.nil?
+          (a || 0) + (b || 0)
+        end
+
+        # @param nanoseconds [Integer, nil]
+        # @return [Integer, nil]
+        def self.convert_nanoseconds_to_ms(nanoseconds)
+          return nil unless nanoseconds
+
+          (nanoseconds / 1_000_000.0).round
+        end
+
+        # @param tokens [Integer, nil]
+        # @param duration_ns [Integer, nil]
+        # @return [Float, nil]
+        def self.calculate_tokens_per_second(tokens, duration_ns)
+          return nil unless tokens && duration_ns && duration_ns > 0
+
+          (tokens.to_f / (duration_ns / 1_000_000_000.0)).round(2)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    # Builds instrumentation event payloads for ActiveSupport::Notifications.
+    #
+    # Extracts request parameters and response metadata for monitoring, debugging,
+    # and APM integration (New Relic, DataDog, etc.).
+    #
+    # == Event Payloads
+    #
+    # Top-Level Events (overall request lifecycle):
+    #
+    # prompt.active_agent::
+    #   Initial: `{ model:, temperature:, max_tokens:, message_count:, has_tools:, stream: }`
+    #   Final: `{ usage: { input_tokens:, output_tokens:, total_tokens: }, finish_reason:, response_model:, response_id: }`
+    #   Note: Usage is cumulative across all API calls in multi-turn conversations
+    #
+    # embed.active_agent::
+    #   Initial: `{ model:, input_size:, encoding_format:, dimensions: }`
+    #   Final: `{ usage: { input_tokens:, total_tokens: }, embedding_count:, response_model:, response_id: }`
+    #
+    # Provider-Level Events (per API call):
+    #
+    # prompt.provider.active_agent::
+    #   Initial: `{ model:, temperature:, max_tokens:, message_count:, has_tools:, stream: }`
+    #   Final: `{ usage: { input_tokens:, output_tokens:, total_tokens: }, finish_reason:, response_model:, response_id: }`
+    #   Note: Usage is per individual API call
+    #
+    # embed.provider.active_agent::
+    #   Initial: `{ model:, input_size:, encoding_format:, dimensions: }`
+    #   Final: `{ usage: { input_tokens:, total_tokens: }, embedding_count:, response_model:, response_id: }`
+    module Instrumentation
+      extend ActiveSupport::Concern
+
+      # Builds and merges payload data for prompt instrumentation events.
+      #
+      # Populates both request parameters and response metadata for top-level and
+      # provider-level events. Usage data (tokens) is CRITICAL for APM cost tracking
+      # and performance monitoring.
+      #
+      # @param payload [Hash] instrumentation payload to merge into
+      # @param request [Request] request object with parameters
+      # @param response [Common::PromptResponse] completed response with normalized data
+      # @return [void]
+      def instrumentation_prompt_payload(payload, request, response)
+        # message_count: prefer the request/input messages (pre-call), fall back to
+        # response messages only if the request doesn't expose messages. New Relic
+        # expects parameters[:messages] to be the request messages and computes
+        # total message counts by adding response choices to that count.
+        message_count = safe_access(request, :messages)&.size
+        message_count = safe_access(response, :messages)&.size if message_count.nil?
+
+        payload.merge!(trace_id: trace_id, message_count: message_count || 0, stream: !!safe_access(request, :stream))
+
+        # Common parameters: prefer response-normalized values, then request
+        payload[:model]       = safe_access(response, :model) || safe_access(request, :model)
+        payload[:temperature] = safe_access(request, :temperature)
+        payload[:max_tokens]  = safe_access(request, :max_tokens)
+        payload[:top_p]       = safe_access(request, :top_p)
+
+        # Tools / instructions
+        if (tools_val = safe_access(request, :tools))
+          payload[:has_tools]  = tools_val.respond_to?(:present?) ? tools_val.present? : !!tools_val
+          payload[:tool_count] = tools_val&.size || 0
+        end
+
+        if (instr_val = safe_access(request, :instructions))
+          payload[:has_instructions] = instr_val.respond_to?(:present?) ? instr_val.present? : !!instr_val
+        end
+
+        # Usage (normalized)
+        if response.usage
+          usage = response.usage
+          payload[:usage] = {
+            input_tokens:  usage.input_tokens,
+            output_tokens: usage.output_tokens,
+            total_tokens:  usage.total_tokens
+          }
+
+          payload[:usage][:cached_tokens]         = usage.cached_tokens         if usage.cached_tokens
+          payload[:usage][:cache_creation_tokens] = usage.cache_creation_tokens if usage.cache_creation_tokens
+          payload[:usage][:reasoning_tokens]      = usage.reasoning_tokens      if usage.reasoning_tokens
+          payload[:usage][:audio_tokens]          = usage.audio_tokens          if usage.audio_tokens
+        end
+
+        # Response metadata
+        payload[:finish_reason]  = safe_access(response, :finish_reason) || response.finish_reason
+        payload[:response_model] = safe_access(response, :model)         || response.model
+        payload[:response_id]    = safe_access(response, :id)            || response.id
+
+        # Build messages list: prefer request messages; if unavailable use prior
+        # response messages (all but the final generated message).
+        if (req_msgs = safe_access(request, :messages)).is_a?(Array)
+          payload[:messages] = req_msgs.map { |m| extract_message_hash(m, false) }
+        else
+          prior = safe_access(response, :messages)
+          prior = prior[0...-1] if prior.is_a?(Array) && prior.size > 1
+          if prior.is_a?(Array) && prior.any?
+            payload[:messages] = prior.map { |m| extract_message_hash(m, false) }
+          end
+        end
+
+        # Build a parameters hash that mirrors what New Relic's OpenAI
+        # instrumentation expects. This makes it easy for APM adapters to
+        # map our provider payload to their LLM event constructors.
+        parameters = {}
+        parameters[:model]       = payload[:model]       if payload[:model]
+        parameters[:max_tokens]  = payload[:max_tokens]  if payload[:max_tokens]
+        parameters[:temperature] = payload[:temperature] if payload[:temperature]
+        parameters[:top_p]       = payload[:top_p]       if payload[:top_p]
+        parameters[:stream]      = payload[:stream]
+        parameters[:messages]    = payload[:messages]    if payload[:messages]
+
+        # Include tools/instructions where available — New Relic ignores unknown keys,
+        # but having them here makes the parameter shape closer to OpenAI's.
+        parameters[:tools]        = begin request.tools        rescue nil end if begin request.tools        rescue nil end
+        parameters[:instructions] = begin request.instructions rescue nil end if begin request.instructions rescue nil end
+
+        payload[:parameters] = parameters
+
+        # Attach raw response (provider-specific) so downstream APM integrations
+        # can inspect the provider response if needed. Use the normalized raw_response
+        # available on the Common::Response when possible.
+        begin
+          payload[:response_raw] = response.raw_response if response.respond_to?(:raw_response) && response.raw_response
+        rescue StandardError
+          # ignore
+        end
+      end
+
+      private
+
+      # Safely attempt to call a method or lookup a key on an object. We avoid
+      # probing with `respond_to?` to prevent ActiveModel attribute casting side
+      # effects; instead we attempt the call and rescue failures.
+      def safe_access(obj, name)
+        return nil if obj.nil?
+
+        begin
+          return obj.public_send(name)
+        rescue StandardError
+        end
+
+        begin
+          return obj[name]
+        rescue StandardError
+        end
+
+        begin
+          return obj[name.to_s]
+        rescue StandardError
+        end
+
+        nil
+      end
+
+      # NOTE: message access is handled via `safe_access(obj, :messages)` to
+      # avoid duplicating guarded lookup logic.
+
+      # Extract a simple hash from a provider message object or hash-like value.
+      def extract_message_hash(msg, is_response = false)
+        role = begin
+          if msg.respond_to?(:[])
+            begin msg[:role] rescue (begin msg["role"] rescue nil end) end
+          elsif msg.respond_to?(:role)
+            msg.role
+          elsif msg.respond_to?(:type)
+            msg.type
+          end
+        rescue StandardError
+          begin msg.role rescue msg.type rescue nil end
+        end
+
+        content = begin
+          if msg.respond_to?(:[])
+            begin msg[:content] rescue (begin msg["content"] rescue nil end) end
+          elsif msg.respond_to?(:content)
+            msg.content
+          elsif msg.respond_to?(:text)
+            msg.text
+          elsif msg.respond_to?(:to_h)
+            begin msg.to_h[:content] rescue (begin msg.to_h["content"] rescue nil end) end
+          elsif msg.respond_to?(:to_s)
+            msg.to_s
+          end
+        rescue StandardError
+          begin msg.to_s rescue nil end
+        end
+
+        { role: role, content: content, is_response: is_response }
+      end
+
+      # Builds and merges payload data for embed instrumentation events.
+      #
+      # Embeddings typically only report input tokens (no output tokens).
+      #
+      # @param payload [Hash] instrumentation payload to merge into
+      # @param request [Request] request object with parameters
+      # @param response [Common::EmbedResponse] completed response with normalized data
+      # @return [void]
+      def instrumentation_embed_payload(payload, request, response)
+        # Add request parameters
+        payload[:trace_id] = trace_id
+        payload[:model] = request.model if request.respond_to?(:model)
+
+        # Add input size if available
+        if request.respond_to?(:input)
+          begin
+            input = request.input
+            if input.is_a?(String)
+              payload[:input_size] = 1
+            elsif input.is_a?(Array)
+              payload[:input_size] = input.size
+            end
+          rescue # OpenAI throws errors this for some reason when you try to look at the input.
+            payload[:input_size] = request[:input].size
+          end
+        end
+
+        # Expose embedding input content similarly to message content.
+        # Use guarded access to avoid provider-specific errors.
+        begin
+          if (emb_input = safe_access(request, :input))
+            # Keep the raw input (string or array) in the payload so APM adapters
+            # can inspect it. This matches how we include message content.
+            payload[:input] = emb_input
+          end
+        rescue StandardError
+          # ignore
+        end
+
+        # Add encoding format if available (OpenAI)
+        payload[:encoding_format] = request.encoding_format if request.respond_to?(:encoding_format)
+
+        # Add dimensions if available (OpenAI)
+        payload[:dimensions] = request.dimensions if request.respond_to?(:dimensions)
+
+        # Add response data
+        payload[:embedding_count] = response.data&.size || 0
+
+        # Add usage data if available (CRITICAL for APM integration)
+        # Embeddings typically only have input tokens
+        if response.usage
+          payload[:usage] = {
+            input_tokens: response.usage.input_tokens,
+            total_tokens: response.usage.total_tokens
+          }
+        end
+
+        # Add response metadata directly from response object
+        payload[:response_model] = response.model
+        payload[:response_id]    = response.id
+
+        # Build a parameters hash for embeddings to match New Relic's shape.
+        emb_params = {}
+        emb_params[:model] = payload[:model] if payload[:model]
+        emb_params[:input] = payload[:input] if payload.key?(:input)
+        payload[:parameters] = emb_params unless emb_params.empty?
+      end
+    end
+  end
+end