ai-agents 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d4dc10b4aceae77705002488794ecdd15531f604641adaa03445d72374220f0
-  data.tar.gz: b056fcf690121a790808e6aa1229dc1a16b6e19b609fbaa09a5e32613f5bc58f
+  metadata.gz: 7948199bfccd3d11e42735b9ee9f34a2431d00de5876785fa26e369a128a686c
+  data.tar.gz: 7a5a91260825a6c2fc59192dee83e8e050a1260fef3d6a0589a9d1dbd0fbc0fe
 SHA512:
-  metadata.gz: b80b45ccaa92140f6155dceeb2227235150f913c90385197878074af9df0c22b913e611c46424f9efa9b3f8f128b8921795c3136685a889a758c4b8dd81f4dbd
-  data.tar.gz: 63662db9f1dcbed10439dfa64746a868a0ee2cc64266c48e55f613296e90dca0d1661466af01825bbec3015c928209f20f000bc9aeb882f5ff510be7ad7110f7
+  metadata.gz: d314e6d427f6c9ac5d38ea39b77191c8535e5d0e400690afb15cff48588b7e969b7cb30e88d12e78c027175cdc497e92a74feb899b99f50416af006e3edabe79
+  data.tar.gz: 67b9da18847cddfae2b7866f606d335b51690aeb13c9062b8ae2afa8526ed9ae3343fbf86dd435354ee42b6d3145cefcac3e090ee5ca170895cbfc84f3b510b0

data/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.12.0] - 2026-06-29
+
+### Added
+- Propagate Langfuse trace metadata and filter attributes from root traces to child agent, tool, and generation spans, while keeping span-specific input/output attributes local to each span.
+- Support optional generation-level attributes via `attribute_provider#generation_attributes(context_wrapper, chat, message)`.
+- Add `gen_ai.request.temperature` to generation spans when an agent temperature is configured.
+
+## [0.11.0] - 2026-05-27
+
+### Added
+- Support RubyLLM provider overrides and custom model/deployment IDs on agents, including Azure configuration passthrough (#66)
+
+### Fixed
+- Preserve per-message assistant agent attribution when restoring and snapshotting multi-agent conversation history, preventing earlier assistant messages from being re-labeled as the final active agent after handoffs (#68)
 
 ## [0.10.0] - 2026-04-20
 

data/README.md

@@ -193,22 +193,40 @@ ruby examples/isp-support/interactive.rb
 Agents.configure do |config|
   # Provider API keys
   config.openai_api_key = ENV['OPENAI_API_KEY']
+  config.azure_api_base = ENV['AZURE_API_BASE']
+  config.azure_api_key = ENV['AZURE_API_KEY']
   config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
   config.gemini_api_key = ENV['GEMINI_API_KEY']
 
   # Defaults
-  config.default_provider = :openai
   config.default_model = 'gpt-4o'
 
   # Performance
   config.request_timeout = 120
-  config.max_turns = 10
 
   # Debugging
   config.debug = true
 end
 ```
 
+### Azure and Custom Deployments
+
+```ruby
+Agents.configure do |config|
+  config.azure_api_base = ENV["AZURE_API_BASE"]
+  config.azure_api_key = ENV["AZURE_API_KEY"]
+end
+
+agent = Agents::Agent.new(
+  name: "Support",
+  model: "my-azure-deployment",
+  provider: :azure,
+  assume_model_exists: true
+)
+```
+
+`provider` is optional for known, unambiguous registry models. Set it for custom deployment names and for model IDs that can exist under multiple providers, such as Azure and OpenAI deployments.
+
 ## 🔍 Observability
 
 Optional OpenTelemetry instrumentation for tracing agent execution, compatible with

data/docs/guides/rails-integration.md

@@ -24,12 +24,25 @@ Configure your LLM providers in an initializer:
 # config/initializers/ai_agents.rb
 Agents.configure do |config|
   config.openai_api_key = Rails.application.credentials.openai_api_key
+  config.azure_api_base = Rails.application.credentials.azure_api_base
+  config.azure_api_key = Rails.application.credentials.azure_api_key
   config.anthropic_api_key = Rails.application.credentials.anthropic_api_key
   config.default_model = 'gpt-4o-mini'
   config.debug = Rails.env.development?
 end
 ```
 
+For Azure custom deployment names, pass the provider at the agent level:
+
+```ruby
+support = Agents::Agent.new(
+  name: "Support",
+  model: "my-azure-deployment",
+  provider: :azure,
+  assume_model_exists: true
+)
+```
+
 ## ActiveRecord Integration
 
 ### Conversation Persistence

data/docs/index.md

@@ -61,6 +61,8 @@ require 'agents'
 # Configure your API keys
 Agents.configure do |config|
   config.openai_api_key = ENV['OPENAI_API_KEY']
+  # config.azure_api_base = ENV['AZURE_API_BASE']
+  # config.azure_api_key = ENV['AZURE_API_KEY']
   # config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
   # config.gemini_api_key = ENV['GEMINI_API_KEY']
   config.default_model = 'gpt-4o-mini'
@@ -87,6 +89,24 @@ result = runner.run("I need help with a technical issue")
 puts result.output
 ```
 
+### Azure and Custom Deployments
+
+```ruby
+Agents.configure do |config|
+  config.azure_api_base = ENV["AZURE_API_BASE"]
+  config.azure_api_key = ENV["AZURE_API_KEY"]
+end
+
+agent = Agents::Agent.new(
+  name: "Support",
+  model: "my-azure-deployment",
+  provider: :azure,
+  assume_model_exists: true
+)
+```
+
+`provider` is optional for known, unambiguous registry models. Set it for custom deployment names and duplicate model IDs, such as Azure and OpenAI deployments.
+
 ## Next Steps
 
 - [Learn about Agents](concepts/agents.html)

data/lib/agents/agent.rb

@@ -50,24 +50,29 @@ require_relative "helpers/hash_normalizer"
 #   )
 module Agents
   class Agent
-    attr_reader :name, :instructions, :model, :tools, :handoff_agents, :temperature, :response_schema, :headers, :params
+    attr_reader :name, :instructions, :model, :provider, :assume_model_exists, :tools, :handoff_agents, :temperature,
+                :response_schema, :headers, :params
 
     # Initialize a new Agent instance
     #
     # @param name [String] The name of the agent
     # @param instructions [String, Proc, nil] Static string or dynamic Proc that returns instructions
     # @param model [String] The LLM model to use (default: "gpt-4.1-mini")
+    # @param provider [Symbol, String, nil] Optional RubyLLM provider override
+    # @param assume_model_exists [Boolean] Whether RubyLLM should skip registry validation for custom model IDs
     # @param tools [Array<Agents::Tool>] Array of tool instances the agent can use
     # @param handoff_agents [Array<Agents::Agent>] Array of agents this agent can hand off to
     # @param temperature [Float] Controls randomness in responses (0.0 = deterministic, 1.0 = very random, default: 0.7)
     # @param response_schema [Hash, nil] JSON schema for structured output responses
     # @param headers [Hash, nil] Default HTTP headers applied to LLM requests
     # @param params [Hash, nil] Default provider-specific parameters applied to LLM requests (e.g., service_tier)
-    def initialize(name:, instructions: nil, model: "gpt-4.1-mini", tools: [], handoff_agents: [], temperature: 0.7,
-                   response_schema: nil, headers: nil, params: nil)
+    def initialize(name:, instructions: nil, model: "gpt-4.1-mini", provider: nil, assume_model_exists: false,
+                   tools: [], handoff_agents: [], temperature: 0.7, response_schema: nil, headers: nil, params: nil)
       @name = name
       @instructions = instructions
       @model = model
+      @provider = provider&.to_sym
+      @assume_model_exists = assume_model_exists
       @tools = tools.dup
       @handoff_agents = []
       @temperature = temperature
@@ -155,6 +160,8 @@ module Agents
     # @option changes [String] :name New agent name
     # @option changes [String, Proc] :instructions New instructions
     # @option changes [String] :model New model identifier
+    # @option changes [Symbol, String, nil] :provider New provider override
+    # @option changes [Boolean] :assume_model_exists Whether to skip model registry validation
     # @option changes [Array<Agents::Tool>] :tools New tools array (replaces all tools)
     # @option changes [Array<Agents::Agent>] :handoff_agents New handoff agents
     # @option changes [Float] :temperature Temperature for LLM responses (0.0-1.0)
@@ -165,6 +172,8 @@ module Agents
         name: changes.fetch(:name, @name),
         instructions: changes.fetch(:instructions, @instructions),
         model: changes.fetch(:model, @model),
+        provider: changes.fetch(:provider, @provider),
+        assume_model_exists: changes.fetch(:assume_model_exists, @assume_model_exists),
         tools: changes.fetch(:tools, @tools.dup),
         handoff_agents: changes.fetch(:handoff_agents, @handoff_agents),
         temperature: changes.fetch(:temperature, @temperature),

data/lib/agents/helpers/message_extractor.rb

@@ -18,8 +18,30 @@
 module Agents
   module Helpers
     module MessageExtractor
+      # RubyLLM::Message has no metadata/extension API, so agent ownership is stored
+      # as an SDK-namespaced ivar on the message object until it is extracted.
+      #
+      # Caveat: RubyLLM::Message#instance_variables is overridden to hide :@raw but does
+      # not hide this ivar, so it will appear in instance_variables listings. This is
+      # harmless for our own code path (we read it via instance_variable_get and
+      # serialize through extract_messages, not Marshal), but external introspection
+      # of a message's ivars will see :@agents_authoring_agent.
+      AUTHORING_AGENT_IVAR = :@agents_authoring_agent
+
       module_function
 
+      def assign_agent_name(message, agent_name)
+        return unless message && agent_name
+
+        message.instance_variable_set(AUTHORING_AGENT_IVAR, agent_name)
+      end
+
+      def attributed_agent_name_for(message)
+        return unless message&.instance_variable_defined?(AUTHORING_AGENT_IVAR)
+
+        message.instance_variable_get(AUTHORING_AGENT_IVAR)
+      end
+
       # Check if content is considered empty (handles both String and Hash content)
       #
       # @param content [String, Hash, nil] The content to check
@@ -65,7 +87,8 @@ module Agents
 
         return message unless msg.role == :assistant
 
-        message[:agent_name] = current_agent.name if current_agent
+        attributed_agent_name = attributed_agent_name_for(msg) || current_agent&.name
+        message[:agent_name] = attributed_agent_name if attributed_agent_name
 
         if tool_calls_present
           # RubyLLM stores tool_calls as Hash with call_id => ToolCall object

data/lib/agents/instrumentation/constants.rb

@@ -15,6 +15,7 @@ module Agents
 
       # GenAI semantic conventions (ONLY on generation spans)
       ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model"
+      ATTR_GEN_AI_REQUEST_TEMPERATURE = "gen_ai.request.temperature"
       ATTR_GEN_AI_PROVIDER      = "gen_ai.provider.name"
       ATTR_GEN_AI_USAGE_INPUT   = "gen_ai.usage.input_tokens"
       ATTR_GEN_AI_USAGE_OUTPUT  = "gen_ai.usage.output_tokens"
@@ -22,14 +23,17 @@ module Agents
       # Langfuse trace-level attributes
       ATTR_LANGFUSE_USER_ID     = "langfuse.user.id"
       ATTR_LANGFUSE_SESSION_ID  = "langfuse.session.id"
+      ATTR_LANGFUSE_PREFIX      = "langfuse."
       ATTR_LANGFUSE_TRACE_TAGS  = "langfuse.trace.tags"
       ATTR_LANGFUSE_TRACE_INPUT = "langfuse.trace.input"
       ATTR_LANGFUSE_TRACE_OUTPUT = "langfuse.trace.output"
+      ATTR_LANGFUSE_TRACE_METADATA_PREFIX = "langfuse.trace.metadata."
 
       # Langfuse observation-level attributes
       ATTR_LANGFUSE_OBS_TYPE   = "langfuse.observation.type"
       ATTR_LANGFUSE_OBS_INPUT  = "langfuse.observation.input"
       ATTR_LANGFUSE_OBS_OUTPUT = "langfuse.observation.output"
+      ATTR_LANGFUSE_OBS_METADATA_PREFIX = "langfuse.observation.metadata."
     end
   end
 end

data/lib/agents/instrumentation/tracing_callbacks.rb

@@ -18,6 +18,15 @@ module Agents
     class TracingCallbacks
       include Constants
 
+      CHILD_LANGFUSE_EXCLUDED_ATTRIBUTES = [
+        ATTR_LANGFUSE_TRACE_INPUT,
+        ATTR_LANGFUSE_TRACE_OUTPUT,
+        ATTR_LANGFUSE_OBS_INPUT,
+        ATTR_LANGFUSE_OBS_OUTPUT,
+        ATTR_LANGFUSE_OBS_TYPE
+      ].freeze
+      private_constant :CHILD_LANGFUSE_EXCLUDED_ATTRIBUTES
+
       def initialize(tracer:, trace_name: SPAN_RUN, span_attributes: {}, attribute_provider: nil)
         @tracer = tracer
         @trace_name = trace_name
@@ -31,6 +40,7 @@ module Agents
 
       def on_run_start(agent_name, input, context_wrapper)
         attributes = build_root_attributes(agent_name, input, context_wrapper)
+        child_attributes = build_child_langfuse_attributes(attributes)
 
         root_span = @tracer.start_span(@trace_name, attributes: attributes)
         root_context = OpenTelemetry::Trace.context_with_span(root_span)
@@ -38,6 +48,7 @@ module Agents
         store_tracing_state(context_wrapper,
                             root_span: root_span,
                             root_context: root_context,
+                            child_langfuse_attributes: child_attributes,
                             current_tool_span: nil,
                             current_agent_name: nil,
                             current_agent_span: nil,
@@ -66,12 +77,14 @@ module Agents
         finish_agent_span(tracing)
       end
 
-      def on_chat_created(chat, agent_name, model, context_wrapper)
+      def on_chat_created(chat, agent_name, model, context_wrapper, temperature = nil)
         tracing = tracing_state(context_wrapper)
         return unless tracing
 
+        request_attributes = { model: model, temperature: temperature }
+
         chat.on_end_message do |message|
-          handle_end_message(chat, agent_name, model, message, context_wrapper)
+          handle_end_message(chat, agent_name, request_attributes, message, context_wrapper)
         end
       end
 
@@ -84,6 +97,7 @@ module Agents
           ATTR_LANGFUSE_OBS_TYPE => "tool",
           ATTR_LANGFUSE_OBS_INPUT => serialize_output(args)
         }
+        attributes.merge!(tracing[:child_langfuse_attributes])
 
         parent = handoff_tool?(tool_name) ? tracing[:root_context] : parent_context(tracing)
         tool_span = @tracer.start_span(
@@ -139,18 +153,19 @@ module Agents
 
       private
 
-      def handle_end_message(chat, _agent_name, model, message, context_wrapper)
+      def handle_end_message(chat, _agent_name, request_attributes, message, context_wrapper)
         return unless message.respond_to?(:role) && message.role == :assistant
 
         tracing = tracing_state(context_wrapper)
         return unless tracing
 
-        input = format_chat_messages(chat)
-        attrs = {}
-        attrs[ATTR_LANGFUSE_OBS_INPUT] = input if input
-        llm_span = @tracer.start_span(@llm_span_name, with_parent: parent_context(tracing), attributes: attrs)
+        llm_span = @tracer.start_span(
+          @llm_span_name,
+          with_parent: parent_context(tracing),
+          attributes: generation_span_attributes(tracing, chat, message, context_wrapper)
+        )
 
-        llm_span.set_attribute(ATTR_GEN_AI_REQUEST_MODEL, model) if model
+        set_llm_request_attributes(llm_span, request_attributes)
 
         output = llm_output_text(message)
         set_llm_response_attributes(llm_span, message, output)
@@ -159,6 +174,22 @@ module Agents
         llm_span.finish
       end
 
+      def generation_span_attributes(tracing, chat, message, context_wrapper)
+        attrs = tracing[:child_langfuse_attributes].dup
+        input = format_chat_messages(chat)
+        attrs[ATTR_LANGFUSE_OBS_INPUT] = input if input
+        apply_generation_dynamic_attributes(attrs, context_wrapper, chat, message)
+        attrs
+      end
+
+      def set_llm_request_attributes(span, request_attributes)
+        model = request_attributes[:model]
+        temperature = request_attributes[:temperature]
+
+        span.set_attribute(ATTR_GEN_AI_REQUEST_MODEL, model) if model
+        span.set_attribute(ATTR_GEN_AI_REQUEST_TEMPERATURE, temperature) unless temperature.nil?
+      end
+
       def finish_dangling_spans(tracing)
         if tracing[:current_tool_span]
           tracing[:current_tool_span].finish
@@ -250,13 +281,9 @@ module Agents
         finish_agent_span(tracing) # close previous agent span if missed
 
         span_name = format(@agent_span_name, agent_name)
-        attrs = { "agent.name" => agent_name }
-        input = tracing[:pending_llm_input]
-        attrs[ATTR_LANGFUSE_OBS_INPUT] = input if input && !input.empty?
-
         agent_span = @tracer.start_span(span_name,
                                         with_parent: tracing[:root_context],
-                                        attributes: attrs)
+                                        attributes: agent_span_attributes(tracing, agent_name))
         agent_context = OpenTelemetry::Trace.context_with_span(agent_span)
 
         tracing[:current_agent_name] = agent_name
@@ -265,6 +292,13 @@ module Agents
         tracing[:last_agent_output] = nil
       end
 
+      def agent_span_attributes(tracing, agent_name)
+        attrs = tracing[:child_langfuse_attributes].merge("agent.name" => agent_name)
+        input = tracing[:pending_llm_input]
+        attrs[ATTR_LANGFUSE_OBS_INPUT] = input if input && !input.empty?
+        attrs
+      end
+
       def finish_agent_span(tracing)
         return unless tracing[:current_agent_span]
 
@@ -297,6 +331,57 @@ module Agents
         attributes
       end
 
+      def build_child_langfuse_attributes(root_attributes)
+        root_attributes.each_with_object({}) do |(key, value), attrs|
+          next if value.nil?
+          next unless child_langfuse_attribute?(key)
+
+          attrs[key] = value
+          add_observation_metadata_mirror(attrs, key, value) if mirrored_observation_metadata_attribute?(key)
+        end
+      end
+
+      def child_langfuse_attribute?(key)
+        key.start_with?(ATTR_LANGFUSE_PREFIX) && !child_langfuse_excluded_attribute?(key)
+      end
+
+      def child_langfuse_excluded_attribute?(key)
+        CHILD_LANGFUSE_EXCLUDED_ATTRIBUTES.include?(key)
+      end
+
+      def mirrored_observation_metadata_attribute?(key)
+        key == ATTR_LANGFUSE_USER_ID ||
+          key == ATTR_LANGFUSE_SESSION_ID ||
+          key == ATTR_LANGFUSE_TRACE_TAGS ||
+          key.start_with?(ATTR_LANGFUSE_TRACE_METADATA_PREFIX)
+      end
+
+      def add_observation_metadata_mirror(attrs, key, value)
+        metadata_key = observation_metadata_mirror_key(key)
+        attrs[observation_metadata_key(metadata_key)] = serialize_metadata_value(value)
+      end
+
+      def observation_metadata_mirror_key(key)
+        case key
+        when ATTR_LANGFUSE_USER_ID
+          "user_id"
+        when ATTR_LANGFUSE_SESSION_ID
+          "session_id"
+        when ATTR_LANGFUSE_TRACE_TAGS
+          "trace_tags"
+        else
+          key.delete_prefix(ATTR_LANGFUSE_TRACE_METADATA_PREFIX)
+        end
+      end
+
+      def observation_metadata_key(key)
+        "#{ATTR_LANGFUSE_OBS_METADATA_PREFIX}#{key}"
+      end
+
+      def serialize_metadata_value(value)
+        value.is_a?(Hash) || value.is_a?(Array) ? value.to_json : value.to_s
+      end
+
       def apply_session_id(attributes, context_wrapper)
         session_id = context_wrapper&.context&.dig(:session_id)&.to_s
         attributes[ATTR_LANGFUSE_SESSION_ID] = session_id if session_id && !session_id.empty?
@@ -317,6 +402,13 @@ module Agents
         attributes.merge!(dynamic_attrs) if dynamic_attrs.is_a?(Hash)
       end
 
+      def apply_generation_dynamic_attributes(attributes, context_wrapper, chat, message)
+        return unless @attribute_provider.respond_to?(:generation_attributes)
+
+        dynamic_attrs = @attribute_provider.generation_attributes(context_wrapper, chat, message)
+        attributes.merge!(dynamic_attrs) if dynamic_attrs.is_a?(Hash)
+      end
+
       def store_tracing_state(context_wrapper, **state)
         context_wrapper.context[:__otel_tracing] = state
       end

data/lib/agents/instrumentation.rb

@@ -34,6 +34,22 @@ module Agents
   #       { 'langfuse.user.id' => ctx.context[:account_id].to_s }
   #     }
   #   )
+  #
+  # @example With custom generation attributes
+  #   class MyAttributeProvider
+  #     def call(ctx)
+  #       { 'langfuse.user.id' => ctx.context[:account_id].to_s }
+  #     end
+  #
+  #     def generation_attributes(_ctx, _chat, message)
+  #       { 'app.generation.has_tool_calls' => message.tool_calls&.any? }
+  #     end
+  #   end
+  #
+  #   Agents::Instrumentation.install(runner,
+  #     tracer: tracer,
+  #     attribute_provider: MyAttributeProvider.new
+  #   )
   module Instrumentation
     INSTALL_MUTEX = Mutex.new
     private_constant :INSTALL_MUTEX
@@ -52,7 +68,9 @@ module Agents
     # @param tracer [OpenTelemetry::Trace::Tracer] OTel tracer instance
     # @param trace_name [String] Name for the root span (default: "agents.run")
     # @param span_attributes [Hash] Static attributes applied to the root span
-    # @param attribute_provider [Proc, nil] Lambda receiving context_wrapper, returning dynamic attributes
+    # @param attribute_provider [#call, nil] Object receiving context_wrapper and returning dynamic root attributes.
+    #   If it also responds to #generation_attributes, that method receives context_wrapper, chat, and message,
+    #   and can return dynamic attributes for generation spans.
     # @return [Agents::AgentRunner, nil] The runner (for chaining), or nil if OTel is unavailable
     def self.install(runner, tracer:, trace_name: Constants::SPAN_RUN, span_attributes: {},
                      attribute_provider: nil)

data/lib/agents/runner.rb

@@ -103,7 +103,11 @@ module Agents
       agent_params = Helpers::HashNormalizer.normalize(current_agent.params, label: "params")
 
       # Create chat and restore conversation history
-      chat = RubyLLM::Chat.new(model: current_agent.model)
+      chat = RubyLLM::Chat.new(
+        model: current_agent.model,
+        provider: current_agent.provider,
+        assume_model_exists: current_agent.assume_model_exists
+      )
       current_headers = Helpers::HashNormalizer.merge(agent_headers, runtime_headers)
       current_params = Helpers::HashNormalizer.merge(agent_params, runtime_params)
       apply_headers(chat, current_headers)
@@ -111,13 +115,16 @@ module Agents
       configure_chat_for_agent(chat, current_agent, context_wrapper, replace: false)
       restore_conversation_history(chat, context_wrapper)
       input_already_in_history = last_message_matches?(chat, input)
-      context_wrapper.callback_manager.emit_chat_created(chat, current_agent.name, current_agent.model, context_wrapper)
+      context_wrapper.callback_manager.emit_chat_created(
+        chat, current_agent.name, current_agent.model, context_wrapper, current_agent.temperature
+      )
 
       loop do
         current_turn += 1
         raise MaxTurnsExceeded, "Exceeded maximum turns: #{max_turns}" if current_turn > max_turns
 
         # Get response from LLM (RubyLLM handles tool execution with halting based handoff detection)
+        message_count_before_response = chat_message_count(chat)
         response = if current_turn == 1
                      # Emit agent thinking event for initial message
                      context_wrapper.callback_manager.emit_agent_thinking(current_agent.name, input, context_wrapper)
@@ -130,6 +137,7 @@ module Agents
                                                                           context_wrapper)
                      chat.complete
                    end
+        assign_agent_name_to_new_assistant_messages(chat, current_agent, message_count_before_response)
         track_usage(response, context_wrapper)
 
         # Emit LLM call complete event with model and response for instrumentation
@@ -172,7 +180,7 @@ module Agents
           current_params = Helpers::HashNormalizer.merge(agent_params, runtime_params)
           apply_params(chat, current_params)
           context_wrapper.callback_manager.emit_chat_created(
-            chat, current_agent.name, current_agent.model, context_wrapper
+            chat, current_agent.name, current_agent.model, context_wrapper, current_agent.temperature
           )
 
           # Force the new agent to respond to the conversation context
@@ -266,6 +274,7 @@ module Agents
         next unless message_params # Skip invalid messages
 
         message = RubyLLM::Message.new(**message_params)
+        assign_restored_agent_name(message, msg)
         chat.add_message(message)
 
         if message.role == :assistant && message_params[:tool_calls]
@@ -377,6 +386,33 @@ module Agents
       context_wrapper.context.delete(:pending_handoff)
     end
 
+    def assign_agent_name_to_new_assistant_messages(chat, current_agent, start_index)
+      # Runtime chats are RubyLLM::Chat instances and expose messages. Keep this
+      # no-op guard for chat-like doubles/adapters that do not expose history.
+      return unless chat.respond_to?(:messages)
+
+      chat.messages[start_index..]&.each do |message|
+        next unless message.role == :assistant
+
+        Helpers::MessageExtractor.assign_agent_name(message, current_agent.name)
+      end
+    end
+
+    def chat_message_count(chat)
+      # Runtime chats are RubyLLM::Chat instances and expose messages. Keep this
+      # fallback for chat-like doubles/adapters where attribution is irrelevant.
+      return 0 unless chat.respond_to?(:messages)
+
+      chat.messages.length
+    end
+
+    def assign_restored_agent_name(message, msg)
+      return unless message.role == :assistant
+
+      restored_agent_name = msg[:agent_name] || msg["agent_name"]
+      Helpers::MessageExtractor.assign_agent_name(message, restored_agent_name)
+    end
+
     # Configures a RubyLLM chat instance with agent-specific settings.
     # Uses RubyLLM's replace option to swap agent context while preserving conversation history during handoffs.
     #
@@ -393,7 +429,13 @@ module Agents
       all_tools = build_agent_tools(agent, context_wrapper)
 
       # Switch model if different (important for handoffs between agents using different models)
-      chat.with_model(agent.model) if replace
+      if replace
+        chat.with_model(
+          agent.model,
+          provider: agent.provider,
+          assume_exists: agent.assume_model_exists
+        )
+      end
 
       # Configure chat with instructions, temperature, tools, and schema
       chat.with_instructions(system_prompt, replace: replace) if system_prompt

data/lib/agents/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Agents
-  VERSION = "0.10.0"
+  VERSION = "0.12.0"
 end

data/lib/agents.rb

@@ -56,6 +56,9 @@ module Agents
 
       # Other providers
       apply_if_present(config, :anthropic_api_key)
+      apply_if_present(config, :azure_api_base)
+      apply_if_present(config, :azure_api_key)
+      apply_if_present(config, :azure_ai_auth_token)
       apply_if_present(config, :gemini_api_key)
       apply_if_present(config, :deepseek_api_key)
       apply_if_present(config, :openrouter_api_key)
@@ -83,8 +86,9 @@ module Agents
   class Configuration
     # Provider API keys and configuration
     attr_accessor :openai_api_key, :openai_api_base, :openai_organization_id, :openai_project_id
-    attr_accessor :anthropic_api_key, :gemini_api_key, :deepseek_api_key, :openrouter_api_key, :ollama_api_base,
-                  :bedrock_api_key, :bedrock_secret_key, :bedrock_region, :bedrock_session_token
+    attr_accessor :anthropic_api_key, :azure_api_base, :azure_api_key, :azure_ai_auth_token, :gemini_api_key,
+                  :deepseek_api_key, :openrouter_api_key, :ollama_api_base, :bedrock_api_key, :bedrock_secret_key,
+                  :bedrock_region, :bedrock_session_token
 
     # General configuration
     attr_accessor :request_timeout, :default_model, :debug
@@ -100,7 +104,7 @@ module Agents
     def configured?
       @openai_api_key || @anthropic_api_key || @gemini_api_key ||
         @deepseek_api_key || @openrouter_api_key || @ollama_api_base ||
-        @bedrock_api_key
+        @bedrock_api_key || (@azure_api_base && (@azure_api_key || @azure_ai_auth_token))
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ai-agents
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Shivam Mishra