llm.rb 4.16.1 → 4.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6119e0673d055f50139fd33a4523bd99ffabb0fc2688a361f23297ef9ac428fd
-  data.tar.gz: bfa5943241a2e9944245f0976458cfdd4895e7b72dbb83fd186f9d7ad2b987ee
+  metadata.gz: 42357f605b8995c24722c0a2d285d98de0e99fe6f9687e2f4451339dcfbc2e87
+  data.tar.gz: 2953c742deeec6dc7c7acc9ed77f4520846a92299a4df94e415416d5c623033c
 SHA512:
-  metadata.gz: e139622d5cbaa8f42a1a6739b9792119f9086ae0b11ae896794953d9bb0fa9ed46159da7f10f7a8b619ef468404ae425b2158b359c940a11220dd48b0b230e2e
-  data.tar.gz: 563f48928b6836d2bbcbc8d72bd594aa265fa285ad99cb8ff0c9574f9e67b7da60f9d42c2eeb1bddce0ba72e1425dab260bc65670fa7d812f7a77dc8016262d7
+  metadata.gz: 534fad616562768b0a851142f411117634d824a92187577d6baad4427c1e0eddf7a765dbfe3b662f76ba52011d760803793473a1881b4f69b8f4c7f9fc16bdc3
+  data.tar.gz: f1d90ad7f7b71f4817fcfa494f48a4e7f189560674d7b86d618f1f4e217e2a34189e15156e71ecdcfffe81e9588315f4759a82f4ec3eaed3846a29c77a906a66

data/CHANGELOG.md

@@ -2,8 +2,104 @@
 
 ## Unreleased
 
+Changes since `v4.18.0`.
+
+### Change
+
+* **Make provider tracers default to the provider instance** <br>
+  Change `llm.tracer = ...` so it sets a provider default tracer instead of
+  relying on scoped fiber-local state alone. This makes tracer configuration
+  behave more predictably across normal tasks, threads, and fibers that share
+  the same provider instance.
+
+* **Add `LLM::Provider#with_tracer` for scoped overrides** <br>
+  Add `with_tracer` as the opt-in escape hatch for request- or turn-scoped
+  tracer overrides. Use it when you want temporary tracing on the current
+  fiber without replacing the provider's default tracer.
+
+* **Trace concurrent tool calls outside ractors** <br>
+  Make tool tracing fire correctly when functions run through `:thread`,
+  `:task`, or `:fiber` concurrency. Experimental `:ractor` execution still
+  does not emit tool tracer events.
+
+* **Trace streamed tool calls, including MCP tools** <br>
+  Bind stream metadata through `LLM::Stream#extra` so streamed tool calls
+  inherit tracer and model context before they are handed to `on_tool_call`.
+  This restores tool tracing for streamed MCP and local tool execution.
+
+* **Support symbol-based ORM option hooks** <br>
+  Let `provider:`, `context:`, and `tracer:` on the Sequel plugin and
+  the ActiveRecord `acts_as_llm` / `acts_as_agent` wrappers resolve through
+  model method names as well as procs.
+
+* **Add experimental ractor tool concurrency** <br>
+  Add `:ractor` support to `LLM::Function#spawn`, `LLM::Function::Array#wait`,
+  `LLM::Stream#wait`, and `LLM::Agent.concurrency` so class-based tools with
+  ractor-safe arguments and return values can run in Ruby ractors and report
+  their results back into the normal LLM tool-return path. MCP tools are not
+  supported by the current `:ractor` mode, but mixed workloads can still
+  branch on `tool.mcp?` and choose a supported strategy per tool. `:ractor`
+  is especially useful for CPU-bound tools, while `:task`, `:fiber`, or
+  `:thread` may be a better fit for I/O-bound work.
+
+## v4.18.0
+
+Changes since `v4.17.0`.
+
+This release improves tracing and tool execution behavior across llm.rb.
+It makes provider tracers default to the provider instance, adds
+`LLM::Provider#with_tracer` for scoped overrides, restores tool tracing for
+concurrent and streamed tool execution, extends streamed tracing to MCP tools,
+and adds symbol-based ORM option hooks alongside experimental ractor tool
+concurrency.
+
+## v4.17.0
+
 Changes since `v4.16.1`.
 
+This release expands agent support across llm.rb. It brings `LLM::Agent`
+closer to `LLM::Context`, adds configurable automatic tool concurrency
+including experimental ractor support for class-based tools,
+extends persisted ORM wrappers with more of the context runtime surface and
+tracer hooks, and introduces built-in ActiveRecord agent persistence through
+`acts_as_agent`.
+
+### Change
+
+* **Add configurable tool concurrency to `LLM::Agent`** <br>
+  Add the class-level `concurrency` DSL to `LLM::Agent` so automatic
+  tool loops can run with `:call`, `:thread`, `:task`, `:fiber`, or
+  experimental `:ractor` support for class-based tools instead of
+  always executing sequentially.
+
+* **Bring `LLM::Agent` closer to `LLM::Context`** <br>
+  Expand `LLM::Agent` so it exposes more of the same runtime surface as
+  `LLM::Context`, including returns, interruption, mode, cost, context
+  window, structured serialization, and other context-backed helpers,
+  while still auto-managing tool loops.
+
+* **Refresh agent docs and coverage** <br>
+  Update the README and deep dive to explain the current role of
+  `LLM::Agent`, add examples that show automatic tool execution and
+  concurrency, and add focused specs for the expanded agent surface and
+  tool-loop behavior.
+
+* **Add ORM tracer hooks for persisted contexts** <br>
+  Add `tracer:` to both the Sequel plugin and `acts_as_llm` so models
+  can resolve and assign tracers onto the provider used by their persisted
+  `LLM::Context`.
+
+* **Bring persisted ORM wrappers closer to `LLM::Context`** <br>
+  Expand both the Sequel plugin and `acts_as_llm` so record-backed
+  contexts expose more of the same runtime surface as `LLM::Context`,
+  including mode, returns, interruption, prompt helpers, file helpers,
+  and tracer access.
+
+* **Add ActiveRecord agent persistence with `acts_as_agent`** <br>
+  Add `acts_as_agent` for ActiveRecord models that should wrap
+  `LLM::Agent`, reusing the same record-backed runtime shape as
+  `acts_as_llm` while letting tool execution be managed by the agent.
+
 ## v4.16.1
 
 Changes since `v4.16.0`.

data/README.md

@@ -4,27 +4,26 @@
 <p align="center">
   <a href="https://0x1eef.github.io/x/llm.rb?rebuild=1"><img src="https://img.shields.io/badge/docs-0x1eef.github.io-blue.svg" alt="RubyDoc"></a>
   <a href="https://opensource.org/license/0bsd"><img src="https://img.shields.io/badge/License-0BSD-orange.svg?" alt="License"></a>
-  <a href="https://github.com/llmrb/llm.rb/tags"><img src="https://img.shields.io/badge/version-4.16.1-green.svg?" alt="Version"></a>
+  <a href="https://github.com/llmrb/llm.rb/tags"><img src="https://img.shields.io/badge/version-4.18.0-green.svg?" alt="Version"></a>
 </p>
 
 ## About
 
-llm.rb is a runtime for building AI systems that integrate directly with your
-application. It is not just an API wrapper. It provides a unified execution
-model for providers, tools, MCP servers, streaming, schemas, files, and
-state.
+llm.rb is a lightweight runtime for building capable AI systems in Ruby.
 
-It is built for engineers who want control over how these systems run. llm.rb
-stays close to Ruby, runs on the standard library by default, loads optional
-pieces only when needed, and remains easy to extend. It also works well in
-Rails or ActiveRecord applications, with built-in `acts_as_llm`, and includes
-built-in Sequel support through `plugin :llm`, so long-lived context state can
-be saved and restored across requests, jobs, or retries.
+It is not just an API wrapper. llm.rb gives you one runtime for providers,
+contexts, agents, tools, MCP servers, streaming, schemas, files, and persisted
+state, so real systems can be built out of one coherent execution model instead
+of a pile of adapters.
 
-Most LLM libraries stop at request/response APIs. Building real systems means
-stitching together streaming, tools, state, persistence, and external
-services by hand. llm.rb provides a single execution model for all of these,
-so they compose naturally instead of becoming separate subsystems.
+It stays close to Ruby, runs on the standard library by default, loads optional
+pieces only when needed, includes built-in ActiveRecord support through
+`acts_as_llm` and `acts_as_agent`, includes built-in Sequel support through
+`plugin :llm`, and is designed for engineers who want control over
+long-lived, tool-capable, stateful AI workflows instead of just
+request/response helpers.
+
+Want to see some code? Jump to [the examples](#examples) section.
 
 ## Architecture
 
@@ -66,6 +65,13 @@ same context object.
 - **Streaming and tool execution work together** <br>
   Start tool work while output is still streaming so you can hide latency
   instead of waiting for turns to finish.
+- **Agents auto-manage tool execution** <br>
+  Use `LLM::Agent` when you want the same stateful runtime surface as
+  `LLM::Context`, but with tool loops executed automatically according to a
+  configured concurrency mode such as `:call`, `:thread`, `:task`, `:fiber`,
+  or experimental `:ractor` support for class-based tools. MCP tools are not
+  supported by the current `:ractor` mode, but mixed tool sets can still
+  route MCP tools and local tools through different strategies at runtime.
 - **Tool calls have an explicit lifecycle** <br>
   A tool call can be executed, cancelled through
   [`LLM::Function#cancel`](https://0x1eef.github.io/x/llm.rb/LLM/Function.html#cancel-instance_method),
@@ -77,7 +83,12 @@ same context object.
   [`LLM::Context#cancel!`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html#cancel-21-instance_method)
   is inspired by Go's context cancellation model.
 - **Concurrency is a first-class feature** <br>
-  Use threads, fibers, or async tasks without rewriting your tool layer.
+  Use threads, fibers, async tasks, or experimental ractors without
+  rewriting your tool layer. The current `:ractor` mode is for class-based
+  tools and does not support MCP tools, but mixed workloads can branch on
+  `tool.mcp?` and choose a supported strategy per tool. `:ractor` is
+  especially useful for CPU-bound tools, while `:task`, `:fiber`, or
+  `:thread` may be a better fit for I/O-bound work.
 - **Advanced workloads are built in, not bolted on** <br>
   Streaming, concurrent tool execution, persistence, tracing, and MCP support
   all fit the same runtime model.
@@ -88,11 +99,14 @@ same context object.
   Connect to MCP servers over stdio or HTTP without bolting on a separate
   integration stack.
 - **ActiveRecord and Sequel persistence are built in** <br>
-  Use `acts_as_llm` on ActiveRecord models or `plugin :llm` on Sequel models
-  to persist `LLM::Context` state with sensible default columns. Both support
-  `provider:` and `context:` hooks, plus `format: :string` for text columns
-  or `format: :jsonb` for native PostgreSQL JSON storage when ORM JSON
-  typecasting support is enabled.
+  llm.rb includes built-in ActiveRecord support through `acts_as_llm` and
+  `acts_as_agent`, plus built-in Sequel support through `plugin :llm`.
+  Use `acts_as_llm` when you want to wrap `LLM::Context`, `acts_as_agent`
+  when you want to wrap `LLM::Agent`, or `plugin :llm` on Sequel models to
+  persist `LLM::Context` state with sensible default columns. These
+  integrations support `provider:` and `context:` hooks, plus `format:
+  :string` for text columns or `format: :jsonb` for native PostgreSQL JSON
+  storage when ORM JSON typecasting support is enabled.
 - **Persistent HTTP pooling is shared process-wide** <br>
   When enabled, separate
   [`LLM::Provider`](https://0x1eef.github.io/x/llm.rb/LLM/Provider.html)
@@ -174,7 +188,7 @@ gem install llm.rb
 
 **REPL**
 
-See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+This example uses [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html) directly for an interactive REPL. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
 
 ```ruby
 require "llm"
@@ -191,10 +205,11 @@ end
 
 **Sequel (ORM)**
 
-See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+The `plugin :llm` integration wraps [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html) on a `Sequel::Model` and keeps tool execution explicit. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
 
 ```ruby
 require "llm"
+require "net/http/persistent"
 require "sequel"
 require "sequel/plugins/llm"
 
@@ -207,12 +222,14 @@ ctx.talk("Remember that my favorite language is Ruby")
 puts ctx.talk("What is my favorite language?").content
 ```
 
-**ActiveRecord (ORM)**
+**ActiveRecord (ORM): acts_as_llm**
 
-See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+The `acts_as_llm` method wraps [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html) and
+provides full control over tool execution. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
 
 ```ruby
 require "llm"
+require "net/http/persistent"
 require "active_record"
 require "llm/active_record"
 
@@ -225,6 +242,48 @@ ctx.talk("Remember that my favorite language is Ruby")
 puts ctx.talk("What is my favorite language?").content
 ```
 
+**ActiveRecord (ORM): acts_as_agent**
+
+The `acts_as_agent` method wraps [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html) and
+manages tool execution for you. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+
+```ruby
+require "llm"
+require "net/http/persistent"
+require "active_record"
+require "llm/active_record"
+
+class Ticket < ApplicationRecord
+  acts_as_agent provider: -> { { key: ENV["#{provider.upcase}_SECRET"], persistent: true } }
+  model "gpt-5.4-mini"
+  instructions "You are a concise support assistant."
+  tools SearchDocs, Escalate
+  concurrency :thread
+end
+
+ticket = Ticket.create!(provider: "openai", model: "gpt-5.4-mini")
+puts ticket.talk("How do I rotate my API key?").content
+```
+
+**Agent**
+
+This example uses [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html) directly and lets the agent manage tool execution. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+
+```ruby
+require "llm"
+
+class ShellAgent < LLM::Agent
+  model "gpt-5.4-mini"
+  instructions "You are a Linux system assistant."
+  tools Shell
+  concurrency :thread
+end
+
+llm = LLM.openai(key: ENV["KEY"])
+agent = ShellAgent.new(llm)
+puts agent.talk("What time is it on this system?").content
+```
+
 ## Resources
 
 - [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) is the

data/lib/llm/active_record/acts_as_agent.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module LLM::ActiveRecord
+  ##
+  # ActiveRecord integration for persisting {LLM::Agent LLM::Agent} state.
+  #
+  # This wrapper reuses the same record-backed runtime surface as
+  # {LLM::ActiveRecord::ActsAsLLM}, but builds an {LLM::Agent LLM::Agent}
+  # instead of an {LLM::Context LLM::Context}. Agent defaults such as model,
+  # tools, schema, instructions, and concurrency are configured on the model
+  # class and forwarded to an internal agent subclass.
+  module ActsAsAgent
+    EMPTY_HASH = LLM::ActiveRecord::ActsAsLLM::EMPTY_HASH
+    DEFAULT_USAGE_COLUMNS = LLM::ActiveRecord::ActsAsLLM::DEFAULT_USAGE_COLUMNS
+    DEFAULTS = LLM::ActiveRecord::ActsAsLLM::DEFAULTS
+
+    module ClassMethods
+      def model(model = nil)
+        return agent.model if model.nil?
+        agent.model(model)
+      end
+
+      def tools(*tools)
+        return agent.tools if tools.empty?
+        agent.tools(*tools)
+      end
+
+      def schema(schema = nil)
+        return agent.schema if schema.nil?
+        agent.schema(schema)
+      end
+
+      def instructions(instructions = nil)
+        return agent.instructions if instructions.nil?
+        agent.instructions(instructions)
+      end
+
+      def concurrency(concurrency = nil)
+        return agent.concurrency if concurrency.nil?
+        agent.concurrency(concurrency)
+      end
+
+      def agent
+        @agent ||= Class.new(LLM::Agent)
+      end
+    end
+
+    module Hooks
+      ##
+      # Called when hooks are extended onto an ActiveRecord model.
+      #
+      # @param [Class] model
+      # @return [void]
+      def self.extended(model)
+        options = model.llm_agent_options
+        model.validates options[:provider_column], options[:model_column], presence: true
+        model.include LLM::ActiveRecord::ActsAsLLM::InstanceMethods unless model.ancestors.include?(LLM::ActiveRecord::ActsAsLLM::InstanceMethods)
+        model.include InstanceMethods unless model.ancestors.include?(InstanceMethods)
+        model.extend ClassMethods unless model.singleton_class.ancestors.include?(ClassMethods)
+      end
+    end
+
+    ##
+    # Installs the `acts_as_agent` wrapper on an ActiveRecord model.
+    #
+    # @param [Hash] options
+    # @option options [Symbol] :format
+    #   Storage format for the serialized agent state. Use `:string` for text
+    #   columns, or `:json` / `:jsonb` for structured JSON columns with
+    #   ActiveRecord JSON typecasting enabled.
+    # @option options [Proc, Symbol, LLM::Tracer, nil] :tracer
+    #   Optional tracer, method name, or proc that resolves to one and is
+    #   assigned through `llm.tracer = ...` on the resolved provider.
+    # @return [void]
+    def acts_as_agent(options = EMPTY_HASH)
+      options = DEFAULTS.merge(options)
+      usage_columns = DEFAULT_USAGE_COLUMNS.merge(options[:usage_columns] || EMPTY_HASH)
+      class_attribute :llm_agent_options, instance_accessor: false, default: DEFAULTS unless respond_to?(:llm_agent_options)
+      self.llm_agent_options = options.merge(usage_columns: usage_columns.freeze).freeze
+      extend Hooks
+    end
+
+    module InstanceMethods
+      private
+
+      ##
+      # Returns the resolved provider instance for this record.
+      # @return [LLM::Provider]
+      def llm
+        options = self.class.llm_agent_options
+        provider = self[columns[:provider_column]]
+        kwargs = resolve_options(options[:provider])
+        return @llm if @llm
+        @llm = LLM.method(provider).call(**kwargs)
+        @llm.tracer = resolve_option(options[:tracer]) if options[:tracer]
+        @llm
+      end
+
+      ##
+      # @return [LLM::Agent]
+      def ctx
+        @ctx ||= begin
+          options = self.class.llm_agent_options
+          params = resolve_options(options[:context]).dup
+          params[:model] ||= self[columns[:model_column]]
+          ctx = self.class.agent.new(llm, params.compact)
+          data = self[columns[:data_column]]
+          if data.nil? || data == ""
+            ctx
+          else
+            case options[:format]
+            when :string then ctx.restore(string: data)
+            when :json, :jsonb then ctx.restore(data:)
+            else raise ArgumentError, "Unknown format: #{options[:format].inspect}"
+            end
+          end
+        end
+      end
+
+      ##
+      # @return [void]
+      def flush
+        attrs = {
+          columns[:data_column] => serialize_context(self.class.llm_agent_options[:format]),
+          columns[:input_tokens] => ctx.usage.input_tokens,
+          columns[:output_tokens] => ctx.usage.output_tokens,
+          columns[:total_tokens] => ctx.usage.total_tokens
+        }
+        assign_attributes(attrs)
+        save!
+      end
+
+      ##
+      # @return [Hash]
+      def resolve_option(option)
+        case option
+        when Proc then instance_exec(&option)
+        when Symbol then send(option)
+        when Hash then option.dup
+        else option
+        end
+      end
+
+      ##
+      # @return [Hash]
+      def resolve_options(option)
+        case option
+        when Proc, Hash then resolve_option(option)
+        else EMPTY_HASH.dup
+        end
+      end
+
+      def serialize_context(format)
+        case format
+        when :string then ctx.to_json
+        when :json, :jsonb then ctx.to_h
+        else raise ArgumentError, "Unknown format: #{format.inspect}"
+        end
+      end
+
+      def columns
+        @columns ||= begin
+          options = self.class.llm_agent_options
+          usage_columns = options[:usage_columns]
+          {
+            provider_column: options[:provider_column],
+            model_column: options[:model_column],
+            data_column: options[:data_column],
+            input_tokens: usage_columns[:input_tokens],
+            output_tokens: usage_columns[:output_tokens],
+            total_tokens: usage_columns[:total_tokens]
+          }.freeze
+        end
+      end
+    end
+  end
+end
+
+::ActiveRecord::Base.extend(LLM::ActiveRecord::ActsAsAgent)

data/lib/llm/active_record/acts_as_llm.rb

@@ -13,7 +13,8 @@ module LLM::ActiveRecord
   # default) or as a structured object (`format: :json` / `:jsonb`) for
   # databases such as PostgreSQL that can persist JSON natively.
   # `:json` and `:jsonb` expect a real JSON column type with ActiveRecord
-  # handling JSON typecasting for the model.
+  # handling JSON typecasting for the model. `provider:`, `context:`, and
+  # `tracer:` can also be configured as symbols that are called on the model.
   module ActsAsLLM
     EMPTY_HASH = {}.freeze
     DEFAULT_USAGE_COLUMNS = {
@@ -27,6 +28,7 @@ module LLM::ActiveRecord
       data_column: :data,
       format: :string,
       usage_columns: DEFAULT_USAGE_COLUMNS,
+      tracer: nil,
       provider: EMPTY_HASH,
       context: EMPTY_HASH
     }.freeze
@@ -52,6 +54,9 @@ module LLM::ActiveRecord
     #   Storage format for the serialized context. Use `:string` for text
     #   columns, or `:json` / `:jsonb` for structured JSON columns with
     #   ActiveRecord JSON typecasting enabled.
+    # @option options [Proc, Symbol, LLM::Tracer, nil] :tracer
+    #   Optional tracer, method name, or proc that resolves to one and is
+    #   assigned through `llm.tracer = ...` on the resolved provider.
     # @return [void]
     def acts_as_llm(options = EMPTY_HASH)
       options = DEFAULTS.merge(options)
@@ -94,6 +99,13 @@ module LLM::ActiveRecord
         ctx.call(...)
       end
 
+      ##
+      # @see LLM::Context#mode
+      # @return [Symbol]
+      def mode
+        ctx.mode
+      end
+
       ##
       # @see LLM::Context#messages
       # @return [Array<LLM::Message>]
@@ -116,6 +128,13 @@ module LLM::ActiveRecord
         ctx.functions
       end
 
+      ##
+      # @see LLM::Context#returns
+      # @return [Array<LLM::Function::Return>]
+      def returns
+        ctx.returns
+      end
+
       ##
       # @see LLM::Context#cost
       # @return [LLM::Cost]
@@ -143,6 +162,50 @@ module LLM::ActiveRecord
         )
       end
 
+      ##
+      # @see LLM::Context#interrupt!
+      # @return [nil]
+      def interrupt!
+        ctx.interrupt!
+      end
+      alias_method :cancel!, :interrupt!
+
+      ##
+      # @see LLM::Context#prompt
+      # @return [LLM::Prompt]
+      def prompt(&)
+        ctx.prompt(&)
+      end
+      alias_method :build_prompt, :prompt
+
+      ##
+      # @see LLM::Context#image_url
+      # @return [LLM::Object]
+      def image_url(...)
+        ctx.image_url(...)
+      end
+
+      ##
+      # @see LLM::Context#local_file
+      # @return [LLM::Object]
+      def local_file(...)
+        ctx.local_file(...)
+      end
+
+      ##
+      # @see LLM::Context#remote_file
+      # @return [LLM::Object]
+      def remote_file(...)
+        ctx.remote_file(...)
+      end
+
+      ##
+      # @see LLM::Context#tracer
+      # @return [LLM::Tracer]
+      def tracer
+        ctx.tracer
+      end
+
       private
 
       ##
@@ -152,7 +215,10 @@ module LLM::ActiveRecord
         options = self.class.llm_plugin_options
         provider = self[columns[:provider_column]]
         kwargs = resolve_options(options[:provider])
-        @llm ||= LLM.method(provider).call(**kwargs)
+        return @llm if @llm
+        @llm = LLM.method(provider).call(**kwargs)
+        @llm.tracer = resolve_option(options[:tracer]) if options[:tracer]
+        @llm
       end
 
       ##
@@ -194,6 +260,7 @@ module LLM::ActiveRecord
       def resolve_option(option)
         case option
         when Proc then instance_exec(&option)
+        when Symbol then send(option)
         when Hash then option.dup
         else option
         end

data/lib/llm/active_record.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
 require "llm/active_record/acts_as_llm"
+require "llm/active_record/acts_as_agent"