llm.rb 7.0.0 → 8.1.0

data/data/deepseek.json

@@ -29,13 +29,13 @@
       },
       "open_weights": true,
       "cost": {
-        "input": 0.28,
-        "output": 0.42,
+        "input": 0.14,
+        "output": 0.28,
         "cache_read": 0.028
       },
       "limit": {
-        "context": 131072,
-        "output": 8192
+        "context": 1000000,
+        "output": 384000
       }
     },
     "deepseek-reasoner": {
@@ -62,13 +62,13 @@
       },
       "open_weights": true,
       "cost": {
-        "input": 0.28,
-        "output": 0.42,
+        "input": 0.14,
+        "output": 0.28,
         "cache_read": 0.028
       },
       "limit": {
-        "context": 128000,
-        "output": 64000
+        "context": 1000000,
+        "output": 384000
       }
     },
     "deepseek-v4-flash": {

data/data/openai.json

@@ -230,8 +230,8 @@
       },
       "limit": {
         "context": 1050000,
-        "input": 920000,
-        "output": 130000
+        "input": 922000,
+        "output": 128000
       },
       "experimental": {
         "modes": {
@@ -1554,6 +1554,43 @@
         "output": 0
       }
     },
+    "gpt-5.5-pro": {
+      "id": "gpt-5.5-pro",
+      "name": "GPT-5.5 Pro",
+      "family": "gpt-pro",
+      "attachment": true,
+      "reasoning": true,
+      "tool_call": true,
+      "structured_output": true,
+      "temperature": false,
+      "knowledge": "2025-12-01",
+      "release_date": "2026-04-23",
+      "last_updated": "2026-04-23",
+      "modalities": {
+        "input": [
+          "text",
+          "image",
+          "pdf"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "cost": {
+        "input": 30,
+        "output": 180,
+        "context_over_200k": {
+          "input": 60,
+          "output": 270
+        }
+      },
+      "limit": {
+        "context": 1050000,
+        "input": 922000,
+        "output": 128000
+      }
+    },
     "gpt-4.1": {
       "id": "gpt-4.1",
       "name": "GPT-4.1",

data/data/xai.json

@@ -68,6 +68,41 @@
         "output": 4096
       }
     },
+    "grok-4.3": {
+      "id": "grok-4.3",
+      "name": "Grok 4.3",
+      "family": "grok",
+      "attachment": true,
+      "reasoning": true,
+      "tool_call": true,
+      "temperature": true,
+      "release_date": "2026-05-01",
+      "last_updated": "2026-05-01",
+      "modalities": {
+        "input": [
+          "text",
+          "image"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "cost": {
+        "input": 1.25,
+        "output": 2.5,
+        "cache_read": 0.2,
+        "context_over_200k": {
+          "input": 2.5,
+          "output": 5,
+          "cache_read": 0.4
+        }
+      },
+      "limit": {
+        "context": 1000000,
+        "output": 30000
+      }
+    },
     "grok-3-mini-fast": {
       "id": "grok-3-mini-fast",
       "name": "Grok 3 Mini Fast",

data/data/zai.json

@@ -10,7 +10,7 @@
   "models": {
     "glm-5v-turbo": {
       "id": "glm-5v-turbo",
-      "name": "glm-5v-turbo",
+      "name": "GLM-5V-Turbo",
       "family": "glm",
       "attachment": true,
       "reasoning": true,

data/lib/llm/active_record/acts_as_agent.rb

@@ -10,10 +10,6 @@ module LLM::ActiveRecord
   # 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
-    DEFAULTS = LLM::ActiveRecord::ActsAsLLM::DEFAULTS
-    Utils = LLM::ActiveRecord::ActsAsLLM::Utils
-
     module ClassMethods
       def model(model = nil)
         return agent.model if model.nil?
@@ -96,7 +92,7 @@ module LLM::ActiveRecord
       def llm
         options = self.class.llm_plugin_options
         return @llm if @llm
-        @llm = Utils.resolve_provider(self, options, ActsAsAgent::EMPTY_HASH)
+        @llm = Utils.resolve_provider(self, options, EMPTY_HASH)
         @llm.tracer = Utils.resolve_option(self, options[:tracer]) if options[:tracer]
         @llm
       end
@@ -108,7 +104,7 @@ module LLM::ActiveRecord
       def ctx
         @ctx ||= begin
           options = self.class.llm_plugin_options
-          params = Utils.resolve_options(self, options[:context], ActsAsAgent::EMPTY_HASH).dup
+          params = Utils.resolve_options(self, options[:context], EMPTY_HASH).dup
           ctx = self.class.agent.new(llm, params.compact)
           columns = Utils.columns(options)
           data = self[columns[:data_column]]

data/lib/llm/active_record/acts_as_llm.rb

@@ -16,84 +16,6 @@ module LLM::ActiveRecord
   # 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
-    DEFAULTS = {
-      data_column: :data,
-      format: :string,
-      tracer: nil,
-      provider: nil,
-      context: EMPTY_HASH
-    }.freeze
-
-    ##
-    # Shared helper methods for the ORM wrapper.
-    #
-    # These utilities keep persistence plumbing out of the wrapped model's
-    # method namespace so the injected surface stays focused on the runtime
-    # API itself.
-    # @api private
-    module Utils
-      ##
-      # Resolves a single configured option against a model instance.
-      # @return [Object]
-      def self.resolve_option(obj, option)
-        case option
-        when Proc then obj.instance_exec(&option)
-        when Symbol then obj.send(option)
-        when Hash then option.dup
-        else option
-        end
-      end
-
-      ##
-      # Resolves hash-like wrapper options against a model instance.
-      # @return [Hash]
-      def self.resolve_options(obj, option, empty_hash)
-        case option
-        when Proc, Symbol, Hash then resolve_option(obj, option)
-        else empty_hash.dup
-        end
-      end
-
-      ##
-      # Serializes the runtime into the configured storage format.
-      # @return [String, Hash]
-      def self.serialize_context(ctx, 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
-
-      ##
-      # Maps wrapper options onto the record's storage columns.
-      # @return [Hash]
-      def self.columns(options)
-        {
-          data_column: options[:data_column]
-        }.freeze
-      end
-
-      ##
-      # Resolves the provider runtime for a record.
-      # @return [LLM::Provider]
-      def self.resolve_provider(obj, options, empty_hash)
-        provider = resolve_option(obj, options[:provider])
-        return provider if LLM::Provider === provider
-        raise ArgumentError, "provider: must resolve to an LLM::Provider instance"
-      end
-
-      ##
-      # Persists the runtime state and usage columns back onto the record.
-      # @return [void]
-      def self.save(obj, ctx, options)
-        columns = self.columns(options)
-        obj.assign_attributes(columns[:data_column] => serialize_context(ctx, options[:format]))
-        obj.save!
-      end
-    end
-
     module Hooks
       ##
       # Called when hooks are extended onto an ActiveRecord model.
@@ -133,7 +55,7 @@ module LLM::ActiveRecord
       # @return [LLM::Response]
       def talk(...)
         options = self.class.llm_plugin_options
-        ctx.talk(...).tap { Utils.save(self, ctx, options) }
+        ctx.talk(...).tap { Utils.save!(self, ctx, options) }
       end
 
       ##
@@ -142,7 +64,7 @@ module LLM::ActiveRecord
       # @return [LLM::Response]
       def respond(...)
         options = self.class.llm_plugin_options
-        ctx.respond(...).tap { Utils.save(self, ctx, options) }
+        ctx.respond(...).tap { Utils.save!(self, ctx, options) }
       end
 
       ##
@@ -270,7 +192,7 @@ module LLM::ActiveRecord
       def llm
         options = self.class.llm_plugin_options
         return @llm if @llm
-        @llm = Utils.resolve_provider(self, options, ActsAsLLM::EMPTY_HASH)
+        @llm = Utils.resolve_provider(self, options, EMPTY_HASH)
         @llm.tracer = Utils.resolve_option(self, options[:tracer]) if options[:tracer]
         @llm
       end
@@ -283,7 +205,7 @@ module LLM::ActiveRecord
         @ctx ||= begin
           options = self.class.llm_plugin_options
           columns = Utils.columns(options)
-          params = Utils.resolve_options(self, options[:context], ActsAsLLM::EMPTY_HASH).dup
+          params = Utils.resolve_options(self, options[:context], EMPTY_HASH).dup
           ctx = LLM::Context.new(llm, params.compact)
           data = self[columns[:data_column]]
           if data.nil? || data == ""

data/lib/llm/active_record.rb

@@ -1,4 +1,82 @@
 # frozen_string_literal: true
 
-require "llm/active_record/acts_as_llm"
-require "llm/active_record/acts_as_agent"
+module LLM::ActiveRecord
+  EMPTY_HASH = {}.freeze
+  DEFAULTS = {
+    data_column: :data,
+    format: :string,
+    tracer: nil,
+    provider: nil,
+    context: EMPTY_HASH
+  }.freeze
+
+  ##
+  # These utilities keep persistence plumbing out of the wrapped model's
+  # method namespace so the injected surface stays focused on the runtime
+  # API itself.
+  # @api private
+  module Utils
+    ##
+    # Resolves a single configured option against a model instance.
+    # @return [Object]
+    def self.resolve_option(obj, option)
+      case option
+      when Proc then obj.instance_exec(&option)
+      when Symbol then obj.send(option)
+      when Hash then option.dup
+      else option
+      end
+    end
+
+    ##
+    # Resolves hash-like wrapper options against a model instance.
+    # @return [Hash]
+    def self.resolve_options(obj, option, empty_hash)
+      case option
+      when Proc, Symbol, Hash then resolve_option(obj, option)
+      else empty_hash.dup
+      end
+    end
+
+    ##
+    # Serializes the runtime into the configured storage format.
+    # @return [String, Hash]
+    def self.serialize_context(ctx, 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
+
+    ##
+    # Maps wrapper options onto the record's storage columns.
+    # @return [Hash]
+    def self.columns(options)
+      {
+        data_column: options[:data_column]
+      }.freeze
+    end
+
+    ##
+    # Resolves the provider runtime for a record.
+    # @return [LLM::Provider]
+    def self.resolve_provider(obj, options, empty_hash)
+      provider = resolve_option(obj, options[:provider])
+      return provider if LLM::Provider === provider
+      raise ArgumentError, "provider: must resolve to an LLM::Provider instance"
+    end
+
+    ##
+    # Persists the runtime state and usage columns back onto the record.
+    # @return [void]
+    def self.save!(obj, ctx, options)
+      columns = self.columns(options)
+      obj.assign_attributes(columns[:data_column] => serialize_context(ctx, options[:format]))
+      obj.save!
+    end
+  end
+
+  require "llm/active_record/acts_as_llm"
+  require "llm/active_record/acts_as_agent"
+end

data/lib/llm/agent.rb

@@ -106,7 +106,8 @@ module LLM
     #  - `:call`: sequential calls
     #  - `:thread`: concurrent threads
     #  - `:task`: concurrent async tasks
-    #  - `:fiber`: concurrent raw fibers
+    #  - `:fiber`: concurrent scheduler-backed fibers
+    #  - `:fork`: forked child processes
     #  - `:ractor`: concurrent Ruby ractors for class-based tools; MCP tools are not supported,
     #    and this mode is especially useful for CPU-bound tool work
     #  - `[:thread, :ractor]`: the possible concurrency strategies to wait on, in the
@@ -149,12 +150,14 @@ module LLM
     # @option params [Array<LLM::Function>, nil] :tools Defaults to nil
     # @option params [Array<String>, nil] :skills Defaults to nil
     # @option params [#to_json, nil] :schema Defaults to nil
+    # @option params [LLM::Tracer, Proc, nil] :tracer Optional tracer override for this agent instance
     # @option params [Symbol, Array<Symbol>, nil] :concurrency Defaults to the agent class concurrency
     def initialize(llm, params = {})
       defaults = {model: self.class.model, tools: self.class.tools, skills: self.class.skills, schema: self.class.schema}.compact
       @concurrency = params.delete(:concurrency) || self.class.concurrency
       @llm = llm
-      @tracer = resolve_option(self.class.tracer) unless self.class.tracer.nil?
+      tracer = params.key?(:tracer) ? params.delete(:tracer) : self.class.tracer
+      @tracer = resolve_option(tracer) unless tracer.nil?
       @ctx = LLM::Context.new(llm, defaults.merge({guard: true}).merge(params))
     end
 
@@ -395,8 +398,10 @@ module LLM
     def call_functions
       case concurrency || :call
       when :call then call(:functions)
-      when :thread, :task, :fiber, :ractor, Array then wait(concurrency)
-      else raise ArgumentError, "Unknown concurrency: #{concurrency.inspect}. Expected :call, :thread, :task, :fiber, :ractor, or an array of queued task types"
+      when :thread, :task, :fiber, :fork, :ractor, Array then wait(concurrency)
+      else raise ArgumentError, "Unknown concurrency: #{concurrency.inspect}. " \
+                                "Expected :call, :thread, :task, :fiber, :fork, :ractor, " \
+                                "or an array of the mentioned options"
       end
     end
 

data/lib/llm/error.rb

@@ -78,4 +78,8 @@ module LLM
   ##
   # When {LLM::Registry} can't map a registry
   NoSuchRegistryError = Class.new(Error)
+
+  ##
+  # When an optional runtime dependency cannot be required
+  LoadError = Class.new(Error)
 end

data/lib/llm/function/array.rb

@@ -26,7 +26,8 @@ class LLM::Function
     #   Controls concurrency strategy:
     #   - `:thread`: Use threads
     #   - `:task`: Use async tasks (requires async gem)
-    #   - `:fiber`: Use raw fibers
+    #   - `:fiber`: Use scheduler-backed fibers (requires Fiber.scheduler)
+    #   - `:fork`: Use forked child processes
     #   - `:ractor`: Use Ruby ractors (class-based tools only; MCP tools are not supported)
     #
     # @return [LLM::Function::ThreadGroup, LLM::Function::TaskGroup, LLM::Function::FiberGroup, LLM::Function::Ractor::Group]
@@ -38,10 +39,12 @@ class LLM::Function
         ThreadGroup.new(map { |fn| fn.spawn(:thread) })
       when :fiber
         FiberGroup.new(map { |fn| fn.spawn(:fiber) })
+      when :fork
+        Fork::Group.new(map { |fn| fn.spawn(:fork) })
       when :ractor
         Ractor::Group.new(map { |fn| fn.spawn(:ractor) })
       else
-        raise ArgumentError, "Unknown strategy: #{strategy.inspect}. Expected :thread, :task, :fiber, or :ractor"
+        raise ArgumentError, "Unknown strategy: #{strategy.inspect}. Expected :thread, :task, :fiber, :fork, or :ractor"
       end
     end
 
@@ -53,7 +56,8 @@ class LLM::Function
     #   Controls concurrency strategy:
     #   - `:thread`: Use threads
     #   - `:task`: Use async tasks (requires async gem)
-    #   - `:fiber`: Use raw fibers
+    #   - `:fiber`: Use scheduler-backed fibers (requires Fiber.scheduler)
+    #   - `:fork`: Use forked child processes
     #   - `:ractor`: Use Ruby ractors (class-based tools only; MCP tools are not supported)
     #
     # @return [Array<LLM::Function::Return>]

data/lib/llm/function/fiber_group.rb

@@ -4,10 +4,10 @@ class LLM::Function
   ##
   # The {LLM::Function::FiberGroup} class wraps an array of
   # {Fiber} objects that are running {LLM::Function} calls
-  # concurrently using raw fibers.
+  # concurrently using scheduler-backed fibers.
   #
   # This class provides the same interface as {LLM::Function::ThreadGroup}
-  # but uses raw fibers for lightweight concurrency without the async gem.
+  # but uses scheduler-backed fibers for cooperative concurrency.
   #
   # @example
   #   llm = LLM.openai(key: ENV["KEY"])
@@ -90,10 +90,16 @@ class LLM::Function
     #   order as the original fibers.
     def wait
       @fibers.map do |fiber|
-        fiber.resume if fiber.alive?
+        fiber.alive? ? scheduler.run : nil
         fiber.value
       end
     end
     alias_method :value, :wait
+
+    private
+
+    def scheduler
+      Fiber.scheduler
+    end
   end
 end

data/lib/llm/function/fork/job.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class LLM::Function
+  ##
+  # The {LLM::Function::Fork::Job} class represents a single fork-backed
+  # function call inside the child process.
+  #
+  # It is executed in the forked process and is responsible for running the
+  # resolved tool instance, handling control messages such as interrupts, and
+  # writing the final result back to the parent process.
+  class Fork::Job
+    ##
+    # @param [LLM::Function] function
+    # @param [LLM::Object] ch
+    # @return [LLM::Function::Fork::Job]
+    def initialize(function, ch)
+      @function = function
+      @ch = ch
+    end
+
+    ##
+    # @return [void]
+    def call
+      runner = @function.runner
+      controller = setup(runner)
+      @ch.result.write([:result, call!(runner)])
+    rescue => ex
+      @ch.result.write([:result, error(ex)])
+    ensure
+      controller&.kill
+      [@ch.control, @ch.result].each { _1.close unless _1.closed? }
+    end
+
+    private
+
+    def call!(runner)
+      kwargs = if Hash === @function.arguments
+        @function.arguments.transform_keys(&:to_sym)
+      else
+        @function.arguments
+      end
+      {id: @function.id, name: @function.name, value: runner.call(**kwargs)}
+    end
+
+    def error(ex)
+      {
+        id: @function.id,
+        name: @function.name,
+        value: {error: true, type: ex.class.name, message: ex.message}
+      }
+    end
+
+    def setup(runner)
+      ready = Queue.new
+      thread = Thread.new do
+        ready << true
+        kind = @ch.control.recv
+        next unless kind == :interrupt
+        hook = %i[on_cancel on_interrupt].find { runner.respond_to?(_1) }
+        runner.public_send(hook) if hook
+      rescue IOError, ArgumentError
+      end
+      ready.pop
+      thread
+    end
+  end
+end

data/lib/llm/function/fork/task.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class LLM::Function
+  ##
+  # The {LLM::Function::Fork::Task} class wraps a fork-backed function call
+  # and exchanges control and result messages with the child process.
+  class Fork::Task
+    ##
+    # @param [LLM::Function] function
+    # @param [LLM::Tracer, nil] tracer
+    # @param [Object, nil] span
+    # @return [LLM::Function::Fork::Task]
+    def initialize(function, tracer: nil, span: nil)
+      @function = function
+      @tracer = tracer
+      @span = span
+      @waited = false
+    end
+
+    ##
+    # @return [LLM::Function::Fork::Task]
+    def spawn
+      @ch = LLM::Object.from(control: xchan(:marshal), result: xchan(:marshal))
+      @pid = Kernel.fork { Fork::Job.new(@function, @ch).call }
+      self
+    end
+
+    ##
+    # @return [Boolean]
+    def alive?
+      return false if @waited
+      result = ::Process.waitpid(@pid, ::Process::WNOHANG)
+      @waited = !result.nil?
+      !@waited
+    rescue Errno::ECHILD
+      @waited = true
+      false
+    end
+
+    ##
+    # @return [nil]
+    def interrupt!
+      return nil if @waited
+      @ch.control.write(:interrupt)
+      nil
+    rescue Errno::ESRCH, IOError
+      nil
+    end
+    alias_method :cancel!, :interrupt!
+
+    ##
+    # @return [LLM::Function::Return]
+    def wait
+      kind, data = @ch.result.recv
+      raise ArgumentError, "Unknown fork message: #{kind.inspect}" unless kind == :result
+      result = Return.new(data[:id], data[:name], data[:value])
+      reap
+      @tracer&.on_tool_finish(result:, span: @span)
+      result
+    ensure
+      reap
+      [@ch.control, @ch.result].each { _1.close unless _1.closed? }
+    end
+    alias_method :value, :wait
+
+    private
+
+    def reap
+      return if @waited
+      ::Process.waitpid(@pid)
+      @waited = true
+    rescue Errno::ECHILD
+      @waited = true
+    end
+  end
+end

data/lib/llm/function/fork.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class LLM::Function
+  module Fork
+    require_relative "fork/job"
+    require_relative "fork/task"
+  end
+end

data/lib/llm/function/fork_group.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class LLM::Function
+  ##
+  # The {LLM::Function::Fork::Group} class wraps an array of
+  # {LLM::Function::Task} objects that are running in forked child processes.
+  class Fork::Group
+    ##
+    # @param [Array<LLM::Function::Task>] tasks
+    # @return [LLM::Function::Fork::Group]
+    def initialize(tasks)
+      @tasks = tasks
+    end
+
+    ##
+    # @return [Boolean]
+    def alive?
+      @tasks.any?(&:alive?)
+    end
+
+    ##
+    # @return [nil]
+    def interrupt!
+      @tasks.each(&:interrupt!)
+      nil
+    end
+    alias_method :cancel!, :interrupt!
+
+    ##
+    # @return [Array<LLM::Function::Return>]
+    def wait
+      @tasks.map(&:wait)
+    end
+    alias_method :value, :wait
+  end
+end