llm.rb 4.16.1 → 4.18.0

data/lib/llm/sequel/plugin.rb

@@ -13,7 +13,8 @@ module LLM::Sequel
   # 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 Sequel handling
-  # JSON typecasting for the model.
+  # JSON typecasting for the model. `provider:`, `context:`, and `tracer:`
+  # can also be configured as symbols that are called on the model.
   module Plugin
     EMPTY_HASH = {}.freeze
     DEFAULT_USAGE_COLUMNS = {
@@ -27,6 +28,7 @@ module LLM::Sequel
       data_column: :data,
       format: :string,
       usage_columns: DEFAULT_USAGE_COLUMNS,
+      tracer: nil,
       provider: EMPTY_HASH,
       context: EMPTY_HASH
     }.freeze
@@ -59,6 +61,9 @@ module LLM::Sequel
     #   Storage format for the serialized context. Use `:string` for text
     #   columns, or `:json` / `:jsonb` for structured JSON columns with Sequel
     #   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 self.configure(model, options = EMPTY_HASH)
       options = DEFAULTS.merge(options)
@@ -111,6 +116,13 @@ module LLM::Sequel
       ctx.call(...)
     end
 
+    ##
+    # @see LLM::Context#mode
+    # @return [Symbol]
+    def mode
+      ctx.mode
+    end
+
     ##
     # @see LLM::Context#messages
     # @return [Array<LLM::Message>]
@@ -134,6 +146,13 @@ module LLM::Sequel
       ctx.functions
     end
 
+    ##
+    # @see LLM::Context#returns
+    # @return [Array<LLM::Function::Return>]
+    def returns
+      ctx.returns
+    end
+
     ##
     # @see LLM::Context#cost
     # @return [LLM::Cost]
@@ -161,6 +180,50 @@ module LLM::Sequel
       )
     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
 
     ##
@@ -170,7 +233,10 @@ module LLM::Sequel
       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
 
     ##
@@ -211,6 +277,7 @@ module LLM::Sequel
     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/stream/queue.rb

@@ -38,6 +38,7 @@ class LLM::Stream
     #   - `:thread`: Use threads
     #   - `:task`: Use async tasks (requires async gem)
     #   - `:fiber`: Use raw fibers
+    #   - `:ractor`: Use Ruby ractors (class-based tools only; MCP tools are not supported)
     # @return [Array<LLM::Function::Return>]
     def wait(strategy)
       returns, tasks = @items.shift(@items.length).partition { LLM::Function::Return === _1 }
@@ -45,7 +46,8 @@ class LLM::Stream
       when :thread then LLM::Function::ThreadGroup.new(tasks).wait
       when :task then LLM::Function::TaskGroup.new(tasks).wait
       when :fiber then LLM::Function::FiberGroup.new(tasks).wait
-      else raise ArgumentError, "Unknown strategy: #{strategy.inspect}. Expected :thread, :task, or :fiber"
+      when :ractor then LLM::Function::Ractor::Group.new(tasks).wait
+      else raise ArgumentError, "Unknown strategy: #{strategy.inspect}. Expected :thread, :task, :fiber, or :ractor"
       end
       returns.concat fire_hooks(tasks, results)
     end

data/lib/llm/stream.rb

@@ -22,6 +22,13 @@ module LLM
   class Stream
     require_relative "stream/queue"
 
+    ##
+    # Returns extra context associated with the current streamed request.
+    # @return [Hash]
+    def extra
+      @extra ||= LLM::Object.from({})
+    end
+
     ##
     # Returns a lazily-initialized queue for tool results or spawned work.
     # @return [LLM::Stream::Queue]
@@ -63,13 +70,16 @@ module LLM
     # Called when a streamed tool call has been fully constructed.
     # @note A stream implementation may start tool execution here, for
     #   example by pushing `tool.spawn(:thread)`, `tool.spawn(:fiber)`, or
-    #   `tool.spawn(:task)` onto {#queue}. When a streamed tool cannot be
-    #   resolved, `error` is passed as an {LLM::Function::Return}. It can be
-    #   sent back to the model, allowing the tool-call path to recover and the
-    #   session to continue. Tool resolution depends on
+    #   `tool.spawn(:task)` onto {#queue}. Mixed strategies can also be
+    #   selected per tool, such as `tool.mcp? ? tool.spawn(:task) :
+    #   tool.spawn(:ractor)`. When a streamed tool cannot be resolved, `error`
+    #   is passed as an {LLM::Function::Return}. It can be sent back to the
+    #   model, allowing the tool-call path to recover and the session to
+    #   continue. Tool resolution depends on
     #   {LLM::Function.registry}, which includes {LLM::Tool LLM::Tool}
     #   subclasses, including MCP tools, but not functions defined with
-    #   {LLM.function}.
+    #   {LLM.function}. The current `:ractor` mode is for class-based tools
+    #   and does not support MCP tools.
     # @param [LLM::Function] tool
     #  The parsed tool call.
     # @param [LLM::Function::Return, nil] error

data/lib/llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LLM
-  VERSION = "4.16.1"
+  VERSION = "4.18.0"
 end

data/llm.gemspec

@@ -8,25 +8,20 @@ Gem::Specification.new do |spec|
   spec.authors = ["Antar Azri", "0x1eef", "Christos Maris", "Rodrigo Serrano"]
   spec.email = ["azantar@proton.me", "0x1eef@hardenedbsd.org"]
 
-  spec.summary = "System integration layer for LLMs, tools, MCP, and APIs in Ruby."
+  spec.summary = "Lightweight runtime for building capable AI systems in Ruby."
 
   spec.description = <<~DESCRIPTION
-  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.
-
-  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, where a small wrapper around
-  context persistence is enough to save and restore long-lived conversation
-  state across requests, jobs, or retries.
-
-  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.
+  llm.rb is a lightweight runtime for building capable AI systems in Ruby.
+  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. 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.
   DESCRIPTION
 
   spec.license = "0BSD"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm.rb
 version: !ruby/object:Gem::Version
-  version: 4.16.1
+  version: 4.18.0
 platform: ruby
 authors:
 - Antar Azri
@@ -195,22 +195,17 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.7'
 description: |
-  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.
-
-  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, where a small wrapper around
-  context persistence is enough to save and restore long-lived conversation
-  state across requests, jobs, or retries.
-
-  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.
+  llm.rb is a lightweight runtime for building capable AI systems in Ruby.
+  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. 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.
 email:
 - azantar@proton.me
 - 0x1eef@hardenedbsd.org
@@ -229,6 +224,7 @@ files:
 - data/zai.json
 - lib/llm.rb
 - lib/llm/active_record.rb
+- lib/llm/active_record/acts_as_agent.rb
 - lib/llm/active_record/acts_as_llm.rb
 - lib/llm/agent.rb
 - lib/llm/bot.rb
@@ -247,6 +243,11 @@ files:
 - lib/llm/function.rb
 - lib/llm/function/array.rb
 - lib/llm/function/fiber_group.rb
+- lib/llm/function/ractor.rb
+- lib/llm/function/ractor/job.rb
+- lib/llm/function/ractor/mailbox.rb
+- lib/llm/function/ractor/task.rb
+- lib/llm/function/ractor_group.rb
 - lib/llm/function/registry.rb
 - lib/llm/function/task.rb
 - lib/llm/function/task_group.rb
@@ -408,7 +409,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
-summary: System integration layer for LLMs, tools, MCP, and APIs in Ruby.
+summary: Lightweight runtime for building capable AI systems in Ruby.
 test_files: []