llm.rb 11.3.1 → 12.0.0

data/lib/llm/sequel/agent.rb

@@ -7,8 +7,7 @@ module LLM::Sequel
   # This wrapper reuses the same record-backed runtime surface as
   # {LLM::Sequel::Plugin}, 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.
+  # instructions, and concurrency are configured on an internal agent subclass.
   module Agent
     require_relative "plugin"
     EMPTY_HASH = LLM::Sequel::Plugin::EMPTY_HASH
@@ -25,7 +24,7 @@ module LLM::Sequel
       options = DEFAULTS.merge(options)
       model.db.extension :pg_json if %i[json jsonb].include?(options[:format])
       model.instance_variable_set(:@llm_agent_options, options.freeze)
-      model.instance_exec(&block) if block
+      block_given? ? model.instance_exec(model.agent, &block) : nil
     end
 
     module ClassMethods
@@ -33,46 +32,6 @@ module LLM::Sequel
         @llm_agent_options || Agent::DEFAULTS
       end
 
-      def model(model = nil, &block)
-        return agent.model if model.nil? && !block
-        agent.model(model, &block)
-      end
-
-      def tools(*tools, &block)
-        return agent.tools if tools.empty? && !block
-        agent.tools(*tools, &block)
-      end
-
-      def skills(*skills, &block)
-        return agent.skills if skills.empty? && !block
-        agent.skills(*skills, &block)
-      end
-
-      def schema(schema = nil, &block)
-        return agent.schema if schema.nil? && !block
-        agent.schema(schema, &block)
-      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 confirm(*tool_names, &block)
-        return agent.confirm if tool_names.empty? && !block
-        agent.confirm(*tool_names, &block)
-      end
-
-      def tracer(tracer = nil, &block)
-        return agent.tracer if tracer.nil? && !block
-        agent.tracer(tracer, &block)
-      end
-
       def agent
         @agent ||= Class.new(LLM::Agent)
       end

data/lib/llm/sequel/plugin.rb

@@ -16,6 +16,13 @@ module LLM::Sequel
   # JSON typecasting for the model. `provider:`, `context:`, and `tracer:`
   # can also be configured as symbols that are called on the model.
   module Plugin
+    DEFAULTS = {
+      data_column: :data,
+      format: :string,
+      provider: :set_provider,
+      context: :set_context,
+      tracer: :set_tracer
+    }.freeze
     EMPTY_HASH = {}.freeze
 
     ##
@@ -94,13 +101,6 @@ module LLM::Sequel
         end
       end
     end
-    DEFAULTS = {
-      data_column: :data,
-      format: :string,
-      tracer: nil,
-      provider: nil,
-      context: EMPTY_HASH
-    }.freeze
 
     ##
     # Called by Sequel when the plugin is first applied to a model class.
@@ -304,6 +304,24 @@ module LLM::Sequel
 
     private
 
+    ##
+    # @return [LLM::Provider]
+    def set_provider
+      raise NotImplementedError, "implement the set_provider callback"
+    end
+
+    ##
+    # @return [Hash]
+    def set_context
+      Plugin::EMPTY_HASH.dup
+    end
+
+    ##
+    # @return [LLM::Tracer]
+    def set_tracer
+      nil
+    end
+
     ##
     # @return [LLM::Context]
     def ctx

data/lib/llm/tracer/telemetry.rb

@@ -30,8 +30,7 @@ module LLM
   #   require "llm"
   #   require "opentelemetry-exporter-otlp"
   #
-  #   endpoint = "https://api.smith.langchain.com/otel/v1/traces"
-  #   exporter = OpenTelemetry::Exporter::OTLP::Exporter.new(endpoint:)
+  #   exporter = OpenTelemetry::Exporter::OTLP::Exporter.new
   #
   #   llm = LLM.openai(key: ENV["KEY"])
   #   llm.tracer = LLM::Tracer::Telemetry.new(llm, exporter:)
@@ -59,7 +58,6 @@ module LLM
     # @return [self]
     def start_trace(trace_group_id: nil, name: "llm", attributes: {}, metadata: nil)
       return self if trace_group_id.to_s.empty?
-
       span_context = span_context_from_trace_group_id(trace_group_id.to_s)
       parent_ctx = ::OpenTelemetry::Trace.context_with_span(
         ::OpenTelemetry::Trace.non_recording_span(span_context)
@@ -316,7 +314,7 @@ module LLM
       set_span_attributes(span, consume_extra_outputs.merge(outputs || {}))
       finish_metadata = consume_finish_metadata_proc(res)
       metadata = (metadata || {}).merge(finish_metadata || {})
-      set_span_attributes(span, metadata.transform_keys { "langsmith.metadata.#{_1}" })
+      set_span_attributes(span, metadata.transform_keys { "llm.metadata.#{_1}" })
       span.add_event("gen_ai.request.finish")
       span.tap(&:finish)
     end
@@ -326,7 +324,7 @@ module LLM
         "gen_ai.operation.name" => operation
       }.merge!(finish_attributes(operation, res)).compact
       chunks_json = retrieval_chunks_json(res)
-      attributes["langsmith.metadata.chunks"] = chunks_json if chunks_json
+      attributes["llm.metadata.chunks"] = chunks_json if chunks_json
       attributes.each { span.set_attribute(_1, _2) }
       span.add_event("gen_ai.request.finish")
       span.tap(&:finish)
@@ -334,7 +332,7 @@ module LLM
 
     ##
     # @api private
-    # Serialize retrieval response chunks for span attributes (e.g. langsmith.metadata.chunks).
+    # Serialize retrieval response chunks for span attributes.
     # Returns a JSON string or nil when res has no data.
     def consume_finish_metadata_proc(res)
       key = LLM::Tracer::FINISH_METADATA_PROC_KEY

data/lib/llm/tracer.rb

@@ -11,7 +11,6 @@ module LLM
   class Tracer
     require_relative "tracer/logger"
     require_relative "tracer/telemetry"
-    require_relative "tracer/langsmith"
     require_relative "tracer/null"
 
     ##
@@ -45,7 +44,7 @@ module LLM
     # @param [Object, nil] span
     # @param [String] model
     # @param [Hash, nil] outputs Optional span attributes (e.g. gen_ai.output.messages) from llm.rb or caller.
-    # @param [Hash, nil] metadata Optional metadata (emitted as langsmith.metadata.*) from llm.rb or caller.
+    # @param [Hash, nil] metadata Optional metadata from llm.rb or caller.
     # @return [void]
     def on_request_finish(operation:, res:, model: nil, span: nil, outputs: nil, metadata: nil)
       raise NotImplementedError, "#{self.class} does not implement '#{__method__}'"
@@ -110,8 +109,7 @@ module LLM
     # @param [Hash] attributes
     #  OpenTelemetry attributes to set on the root span.
     # @param [Hash, nil] metadata
-    #  Optional. Trace-level metadata merged into the trace (e.g. langsmith.metadata.*).
-    #  Only used by tracers that support it (e.g. {LLM::Tracer::Langsmith}).
+    #  Optional. Trace-level metadata merged into the trace by tracers that support it.
     # @return [self]
     def start_trace(trace_group_id: nil, name: "llm", attributes: {}, metadata: nil)
       self
@@ -150,11 +148,10 @@ module LLM
     ##
     # Merges extra attributes for the current trace/span. Used by applications
     # (e.g. chatbot) to add metadata, span inputs, or span outputs to the next
-    # span or to the trace. No-op by default; {LLM::Tracer::Langsmith} merges
-    # into fiber-local storage and emits them as langsmith/GenAI attributes.
+    # span or to the trace. No-op by default.
     #
     # @param [Hash, nil] metadata
-    #  Key-value pairs merged into trace/span metadata (e.g. langsmith.metadata.*).
+    #  Key-value pairs merged into trace/span metadata.
     # @param [Hash, nil] inputs
     #  Key-value pairs set on the next span at start (e.g. gen_ai.input.messages).
     #  Consumed when the span is created.
@@ -169,9 +166,9 @@ module LLM
     ##
     # Optional: set a proc to supply metadata when the next chat span finishes.
     # The proc is called with the response (res) and should return a Hash of
-    # metadata (e.g. { intent: "...", confidence: 1.0 }) to merge onto the span
-    # as langsmith.metadata.*. Cleared after use. Used by apps to attach
-    # routing/intent that is only known after the response.
+    # metadata (e.g. { intent: "...", confidence: 1.0 }) to merge onto the span.
+    # Cleared after use. Used by apps to attach routing/intent that is only
+    # known after the response.
     #
     # @param [Proc, nil] proc (res) -> Hash or nil
     # @return [self]
@@ -182,19 +179,10 @@ module LLM
 
     FINISH_METADATA_PROC_KEY = :"llm.tracer.finish_metadata_proc"
 
-    ##
-    # Returns the current extra bag (metadata, inputs, outputs) for the current
-    # thread/trace. Used by subclasses; default returns empty hashes.
-    #
-    # @return [Hash] { metadata: {}, inputs: {}, outputs: {} }
-    def current_extra
-      {}
-    end
-
     ##
     # Returns and clears extra inputs for the next span. Called by the telemetry
-    # tracer when starting a span. Subclasses (e.g. Langsmith) override to
-    # return fiber-local inputs; default returns {}.
+    # tracer when starting a span. Subclasses can override to return stored
+    # inputs; default returns {}.
     #
     # @return [Hash] Attribute key => value to set on the span at start
     def consume_extra_inputs

data/lib/llm/transport/execution.rb

@@ -59,9 +59,24 @@ class LLM::Transport
     # @return [LLM::Object, String]
     def parse_response(res)
       case res["content-type"]
-      when %r{\Aapplication/json\s*} then LLM::Object.from(LLM.json.load(res.body))
+      when %r{\Aapplication/json\s*}
+        body = read_body(res.body)
+        LLM::Object.from(LLM.json.load(body))
       else res.body
       end
     end
+
+    ##
+    # @param [#class] body
+    # @return [String]
+    def read_body(body)
+      case body.class.to_s
+      when "Net::ReadAdapter"
+        str = +""
+        body.read_body { str << _1 }
+        str
+      else body
+      end
+    end
   end
 end

data/lib/llm/transport/net_http_adapter.rb

@@ -21,7 +21,7 @@ class LLM::Transport
       when :put then ::Net::HTTP::Put.new(path, headers)
       when :patch then ::Net::HTTP::Patch.new(path, headers)
       when :delete then ::Net::HTTP::Delete.new(path, headers)
-      else ::Net::HTTP::GenericRequest.new(method, path, nil, headers)
+      else ::Net::HTTPGenericRequest.new(method, path, nil, headers)
       end
       if req.body
         http_req.body = req.body

data/lib/llm/uridata.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LLM
+  class URIData < Struct.new(:content_type, :encoding_type, :encoded, :decoded)
+    ##
+    # @param [String] str
+    #  A string
+    # @return [URIData]
+    def self.parse(str)
+      _, data = str.split(":")
+      content_type, data = data.split(";")
+      encoding_type, data = data.split(",")
+      URIData.new(content_type, encoding_type, data, StringIO.new(data.unpack1("m0")))
+    end
+  end
+end

data/lib/llm/version.rb

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

data/lib/llm.rb

@@ -37,6 +37,7 @@ module LLM
   require_relative "llm/server_tool"
   require_relative "llm/mcp"
   require_relative "llm/a2a"
+  require_relative "llm/uridata"
 
   ##
   # Thread-safe monitors for different contexts
@@ -154,6 +155,14 @@ module LLM
     LLM::OpenAI.new(**)
   end
 
+  ##
+  # @param key (see LLM::Provider#initialize)
+  # @return (see LLM::DeepInfra#initialize)
+  def deepinfra(**)
+    lock(:require) { require_relative "llm/providers/deepinfra" unless defined?(LLM::DeepInfra) }
+    LLM::DeepInfra.new(**)
+  end
+
   ##
   # @param (see LLM::Bedrock#initialize)
   # @return (see LLM::Bedrock#initialize)

data/llm.gemspec

@@ -5,27 +5,14 @@ require_relative "lib/llm/version"
 Gem::Specification.new do |spec|
   spec.name = "llm.rb"
   spec.version = LLM::VERSION
-  spec.authors = ["Robert (0x1eef)", "Antar Azri", "Rodrigo Serrano"]
+  spec.authors = ["bsdrobert", "Antar Azri", "Rodrigo Serrano"]
   spec.email = ["robert@r.uby.dev"]
 
   spec.summary = "Ruby's capable AI runtime"
-  spec.description = <<~DESC
-  llm.rb is Ruby's capable AI runtime.
-
-  It runs on Ruby's standard library by default. loads optional pieces
-  only when needed, and offers a single runtime for providers, agents,
-  tools, skills, MCP, A2A (Agent2Agent), RAG (vector stores & embeddings),
-  streaming, files, and persisted state. As a bonus, llm.rb is also available
-  for mruby.
-
-  It supports OpenAI, OpenAI-compatible endpoints, Anthropic, Google
-  Gemini, DeepSeek, xAI, Z.ai, AWS Bedrock, Ollama, and llama.cpp. It
-  also includes built-in ActiveRecord and Sequel support, plus concurrent
-  tool execution through threads, tasks (via async gem), fibers, ractors,
-  and fork (via xchan.rb gem).
-  DESC
-
-  spec.license = "0BSD"
+  spec.description = "llm.rb is not a library, framework or toolkit but " \
+                     "an advanced runtime for building highly capable AI " \
+                     "applications on CRuby."
+  spec.license = "BUSL-1.1"
   spec.required_ruby_version = ">= 3.3.0"
 
   spec.homepage = "https://r.uby.dev/llm/"