llm.rb 11.0.0 → 11.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24c3c2930dd3ab321999075b34ef2e5c6d445fec5c873b00ef071caeef3c1406
-  data.tar.gz: 0d6921f20dc327f7c424f7282ff3c76f5073ad3eec7f21d483ee7623e4c782f7
+  metadata.gz: 5bb91948d8cfa006f7512dd0a4fa62f90b42360e3f11a57074870470fdc70d3f
+  data.tar.gz: 64b49f633318bc0439252cebca4c3886db4c7676f3cb9a78f4945eefe58b4356
 SHA512:
-  metadata.gz: 3b96ea3336114822ccb2defee4da43089df6e004cebdf27987562f7f339bc2a733cc169d64f9752cc51d0346a069ba3921e99db69c2de1f795abfa69f260a730
-  data.tar.gz: b4135fad5bd1c5499b1177c27d6eb9c2da5a84b50a5492e82fe6396821c2b4a5e0891e55cb557d07e5ee4ec912b7ecdd8c7df223ebe76109aa74b7ede5227195
+  metadata.gz: c56b48185604b22c44f7b4697da56a5fda8359a69e110392abf2510b47a4dc9aedbe5c6a9e64e733fafb5672c34d4a0833448fab5ca9de52c453c8a906080174
+  data.tar.gz: a2a9241da0e8749569111573451c99c92ed3569fa7cee0c9178b8aa884a72b27a24f18e19566cef8a16c2e460420a392b83d441708da67a571a9e2648d4d81e2

data/CHANGELOG.md

@@ -2,6 +2,48 @@
 
 ## Unreleased
 
+## v11.1.0
+
+Changes since `v11.0.0`.
+
+This release adds the `inherit` directive for skill sub-agents so they can
+inherit access to the local, MCP, and A2A tools available to their parent
+agent. It introduces class-level `required %i[...]` declarations to
+`LLM::Schema` and wraps `LLM::Function#arguments` in `LLM::Object` for
+method-style argument access. The OpenTelemetry tracer now samples all spans
+regardless of environment, and the tool-call loop repair step prevents stale
+history from being sent on follow-up requests.
+
+### Add
+
+* **Add support for the `inherit` directive in skills** <br>
+  Add support for the `inherit` directive so a skill sub-agent can
+  inherit access to the local, MCP, and A2A tools available to its
+  parent agent.
+
+* **Add class-level `required %i[...]` support to `LLM::Schema`** <br>
+  Add class-level `required %i[...]` declarations to `LLM::Schema`, so
+  schema classes can mark existing properties as required the same way
+  `LLM::Tool` params already can.
+
+* **Wrap function arguments in `LLM::Object`** <br>
+  Wrap `LLM::Function#arguments` in `LLM::Object`, so function
+  implementations can read arguments with method-style access while
+  still invoking runners with keyword arguments.
+
+### Fix
+
+* **Ensure all traces are sampled regardless of environment** <br>
+  Explicitly pass `Samplers::ALWAYS_ON` when creating the OpenTelemetry
+  `TracerProvider` so the in-memory exporter always captures every span,
+  regardless of the `OTEL_TRACES_SAMPLER` environment variable.
+
+* **Always close the tool call loop before sending follow-up requests** <br>
+  Add a repair step in `Context#talk` that closes assistant tool-call
+  messages without matching tool responses before the next provider
+  request is sent. This prevents stale tool-call history from being sent
+  on follow-up requests, which some providers reject as invalid.
+
 ## v11.0.0
 
 Changes since `v10.0.0`.

data/README.md

@@ -4,14 +4,14 @@
   </a>
 </p>
 <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 href="https://llmrb.github.io/llm.rb">
+    <img src="https://img.shields.io/badge/docs-llmrb.github.io-blue.svg" alt="Official llm.rb website">
   </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-11.0.0-green.svg?" alt="Version">
+    <img src="https://img.shields.io/badge/version-11.1.0-green.svg?" alt="Version">
   </a>
 </p>
 
@@ -22,8 +22,7 @@ llm.rb is Ruby's most 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](https://github.com/llmrb/mruby-llm).
+streaming, files, and persisted state.
 
 It supports OpenAI, OpenAI-compatible endpoints, Anthropic, Google
 Gemini, DeepSeek, xAI, Z.ai, AWS Bedrock, Ollama, and llama.cpp. It
@@ -31,6 +30,11 @@ 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).
 
+As a bonus, llm.rb is also available to embedded systems [via mruby](https://github.com/llmrb/mruby-llm#readme),
+to the browser and edge devices [via WebAssembly](https://github.com/llmrb/wasm-llm#readme),
+and has first-class [Rails support](https://github.com/llmrb/rails-llm#readme)
+via a separate gem.
+
 ## Quick start
 
 #### LLM::Context
@@ -90,7 +94,7 @@ class Agent < LLM::Agent
   confirm "delete-file"
 
   def on_tool_confirmation(fn, strategy)
-    path = fn.arguments["path"] || fn.arguments[:path]
+    path = fn.arguments.path
     if path.start_with?("/tmp/")
       fn.spawn(strategy).wait
     else
@@ -260,6 +264,19 @@ llm = LLM.openai(key: ENV["KEY"])
 ReleaseAgent.new(llm, stream: $stdout).talk("Prepare the next release.")
 ```
 
+A skill can also have its sub-agent inherit the parents tools through the
+`inherit` directive. The `inherit` directive has coverage for the "classic"
+tools (a subclass of [LLM::Tool](https://0x1eef.github.io/x/llm.rb/LLM/Tool.html)),
+MCP tools, and A2A tools that a parent context or agent has access to:
+
+```yaml
+---
+  name: release
+  description: Prepare a release
+  tools: inherit
+---
+```
+
 #### LLM::Stream
 
 The
@@ -389,7 +406,7 @@ gem install llm.rb
 
 This example uses [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html)
 directly for an interactive REPL. <br> See the
-[deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or
+[deepdive (web)](https://llmrb.github.io/llm.rb/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -442,7 +459,7 @@ different model from the main context. `token_threshold:` accepts either a
 fixed token count or a percentage string like `"90%"`, which resolves
 against the active model context window and triggers compaction once total
 token usage goes over that percentage. See the
-[deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or
+[deepdive (web)](https://llmrb.github.io/llm.rb/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -475,7 +492,7 @@ ctx = LLM::Context.new(
 This example uses [`LLM::Stream`](https://0x1eef.github.io/x/llm.rb/LLM/Stream.html)
 with the OpenAI Responses API so reasoning output is streamed separately from
 visible assistant output. See the
-[deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or
+[deepdive (web)](https://llmrb.github.io/llm.rb/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 To use the Responses API (OpenAI-specific), initialize a
@@ -510,7 +527,7 @@ ctx.talk("Solve 17 * 19 and show your work.")
 
 Need to cancel a stream? llm.rb has you covered through
 [`LLM::Context#interrupt!`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html#interrupt-21-instance_method).
-<br> See the [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html)
+<br> See the [deepdive (web)](https://llmrb.github.io/llm.rb/)
 or [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -538,7 +555,7 @@ The `plugin :llm` integration wraps
 wrappers, its built-in persistence contract is the serialized `data` column,
 while `provider:` resolves a real `LLM::Provider` instance and `context:`
 injects defaults such as `model:`. <br> See the
-[deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or
+[deepdive (web)](https://llmrb.github.io/llm.rb/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -574,7 +591,7 @@ one serialized `data` column. If your app has provider, model, or usage
 columns, provide them to llm.rb through `provider:` and `context:` instead of
 relying on reserved wrapper columns.
 
-See the [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html)
+See the [deepdive (web)](https://llmrb.github.io/llm.rb/)
 or [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -631,7 +648,7 @@ manages tool execution for you. Like `acts_as_llm`, its built-in persistence
 contract is one serialized `data` column. If your app has provider or model
 columns, provide them to llm.rb through your hooks and agent DSL.
 
-See the [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html)
+See the [deepdive (web)](https://llmrb.github.io/llm.rb/)
 or [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -689,7 +706,7 @@ This example uses [`LLM::MCP`](https://0x1eef.github.io/x/llm.rb/LLM/MCP.html)
 over HTTP so remote GitHub MCP tools run through the same
 `LLM::Context` tool path as local tools. It expects a GitHub token in
 `ENV["GITHUB_PAT"]`. See the
-[deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or
+[deepdive (web)](https://llmrb.github.io/llm.rb/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -710,7 +727,7 @@ ctx.talk(ctx.wait(:call)) while ctx.functions?
 
 ## Resources
 
-- [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) and
+- [deepdive (web)](https://llmrb.github.io/llm.rb/) and
   [deepdive (markdown)](resources/deepdive.md) are the examples guide.
 - [relay](https://github.com/llmrb/relay) shows a real application built on
   top of llm.rb.

data/lib/llm/context.rb

@@ -193,6 +193,7 @@ module LLM
     def talk(prompt, params = {})
       @owner = @llm.request_owner
       compactor.compact!(prompt) if compactor.compact?(prompt)
+      repair!(@messages, prompt)
       prompt, params, res = mode == :responses ? respond(prompt, params) : complete(prompt, params)
       self.compacted = false
       role = params[:role] || @llm.user_role
@@ -566,5 +567,25 @@ module LLM
         message: warning
       })
     end
+
+    ##
+    # Closes assistant tool-call messages that do not have matching tool
+    # responses. This can happen when a turn is interrupted while a tool
+    # call is streaming or waiting for user confirmation.
+    # @param [Array<LLM::Message>] messages
+    # @param [Object] prompt
+    # @return [void]
+    def repair!(messages, prompt)
+      message = messages.last
+      return unless message&.tool_call?
+      returns = self.returns + [*prompt].grep(LLM::Function::Return)
+      cancelled = []
+      [*message.extra.tool_calls].each do |tool|
+        next if returns.any? { _1.id == tool[:id] }
+        attrs = {cancelled: true, reason: "function call cancelled"}
+        cancelled << LLM::Function::Return.new(tool.id, tool.name, attrs)
+      end
+      messages << LLM::Message.new(@llm.tool_role, cancelled) unless cancelled.empty?
+    end
   end
 end

data/lib/llm/function.rb

@@ -109,8 +109,16 @@ class LLM::Function
 
   ##
   # Returns function arguments
-  # @return [Array, nil]
-  attr_accessor :arguments
+  # @return [Hash, Array, LLM::Object, nil]
+  attr_reader :arguments
+
+  ##
+  # Sets function arguments, wrapping them in an LLM::Object
+  # @param [Hash, LLM::Object] other
+  # @return [void]
+  def arguments=(other)
+    @arguments = LLM::Object.from(other)
+  end
 
   ##
   # Returns a tracer, or nil
@@ -373,10 +381,10 @@ class LLM::Function
   #   Returns a Return object with either the function result or error information.
   def call_function
     runner = self.runner
-    kwargs = Hash === arguments ? arguments.transform_keys(&:to_sym) : arguments
+    kwargs = arguments.respond_to?(:to_h) ? arguments.to_h.transform_keys(&:to_sym) : arguments
     Return.new(id, name, runner.call(**kwargs))
   rescue => ex
-    Return.new(id, name,  {error: true, type: ex.class.name, message: ex.message})
+    Return.new(id, name, {error: true, type: ex.class.name, message: ex.message})
   end
 
   def call!

data/lib/llm/object/builder.rb

@@ -17,6 +17,7 @@ class LLM::Object
       case obj
       when self then from(obj.to_h)
       when Array then obj.map { |v| from(v) }
+      when String then obj
       else
         visited = {}
         obj.each { visited[_1] = visit(_2) }

data/lib/llm/object.rb

@@ -184,6 +184,15 @@ class LLM::Object < BasicObject
     @h.slice(*args)
   end
 
+  ##
+  # @param [Hash, #to_h] other
+  # @return [Boolean]
+  def ==(other)
+    return false unless other.respond_to?(:to_h)
+    to_h == other.to_h || to_hash == other.to_h
+  end
+  alias_method :eql?, :==
+
   private
 
   def method_missing(m, *args, &b)

data/lib/llm/schema.rb

@@ -20,14 +20,16 @@
 #
 # @example Ruby-style
 #  class Address < LLM::Schema
-#    property :street, String, "Street address", required: true
+#    property :street, String, "Street address"
+#    required %i[street]
 #  end
 #
 #  class Person < LLM::Schema
-#    property :name, String, "Person's name", required: true
-#    property :age, Integer, "Person's age", required: true
-#    property :hobbies, Array[String], "Person's hobbies", required: true
-#    property :address, Address, "Person's address", required: true
+#    property :name, String, "Person's name"
+#    property :age, Integer, "Person's age"
+#    property :hobbies, Array[String], "Person's hobbies"
+#    property :address, Address, "Person's address"
+#    required %i[name age hobbies address]
 #  end
 class LLM::Schema
   require_relative "schema/version"
@@ -74,6 +76,10 @@ class LLM::Schema
       end
       schema.array(item)
     end
+
+    def fetch(properties, name)
+      properties[name] || properties.fetch(name.to_s)
+    end
   end
 
   ##
@@ -103,6 +109,18 @@ class LLM::Schema
     end
   end
 
+  ##
+  # Mark existing properties as required.
+  # @param names [Array<Symbol,String>]
+  # @return [LLM::Schema::Object]
+  def self.required(names)
+    lock do
+      object.tap do |schema|
+        [*names].each { Utils.fetch(schema.properties, _1).required }
+      end
+    end
+  end
+
   ##
   # @api private
   # @return [LLM::Schema]

data/lib/llm/skill.rb

@@ -56,6 +56,7 @@ module LLM
       @instructions = ""
       @frontmatter = LLM::Object.from({})
       @tools = []
+      @inherit_tools = false
     end
 
     ##
@@ -74,18 +75,8 @@ module LLM
     # @param [LLM::Context] ctx
     # @return [Hash]
     def call(ctx)
-      instructions, tools, tracer = self.instructions, self.tools, ctx.llm.tracer
-      params = ctx.params.merge(mode: ctx.mode).reject { [:tools, :schema].include?(_1) }
-      concurrency = params[:stream].extra[:concurrency] if LLM::Stream === params[:stream]
-      params[:concurrency] = concurrency if concurrency
-      agent = Class.new(LLM::Agent) do
-        instructions(instructions)
-        tools(*tools)
-        tracer(tracer)
-      end.new(ctx.llm, params)
-      agent.messages.concat(messages_for(ctx))
-      res = agent.talk("Solve the user's query.")
-      {content: res.content}
+      content = agent(ctx).talk("Solve the user's query.").content
+      {content:}
     end
 
     ##
@@ -96,9 +87,10 @@ module LLM
     def to_tool(ctx)
       skill = self
       Class.new(LLM::Tool) do
+        attr_accessor :tracer
+
         name skill.name
         description skill.description
-        attr_accessor :tracer
 
         define_singleton_method(:skill?) do
           true
@@ -110,6 +102,13 @@ module LLM
       end
     end
 
+    ##
+    # Returns true when a skill should inherit tools from its parent
+    # @return [Boolean]
+    def inherit_tools?
+      @inherit_tools
+    end
+
     private
 
     def messages_for(ctx)
@@ -132,8 +131,39 @@ module LLM
       @frontmatter = LLM::Object.from(YAML.safe_load(match[1]) || {})
       @name = @frontmatter.name || @name
       @description = @frontmatter.description || @description
-      @tools = [*@frontmatter.tools].map { LLM::Tool.find_by_name!(_1) }
       @instructions = match[2]
+      @inherit_tools, @tools = parse_tools(@frontmatter.tools)
+    end
+
+    def parse_tools(tools)
+      case tools
+      when String
+        tools == "inherit" ? [true, []] : raise_invalid_error!(tools)
+      when Array
+        [false, [*@frontmatter.tools].map { LLM::Tool.find_by_name!(_1) }]
+      when NilClass
+        [false, []]
+      else
+        raise_invalid_error!(tools)
+      end
+    end
+
+    def raise_invalid_error!(tools)
+      raise LLM::Error, "invalid value for tools key: '#{tools}'"
+    end
+
+    def agent(ctx)
+      instructions, tools, tracer, inherit_tools = self.instructions, self.tools, ctx.llm.tracer, inherit_tools?
+      params = ctx.params.merge(mode: ctx.mode).reject { [:tools, :schema].include?(_1) }
+      concurrency = params[:stream].extra[:concurrency] if LLM::Stream === params[:stream]
+      params[:concurrency] = concurrency if concurrency
+      agent = Class.new(LLM::Agent) do
+        instructions(instructions)
+        tools(inherit_tools ? ctx.params[:tools] : tools)
+        tracer(tracer)
+      end.new(ctx.llm, params)
+      agent.messages.concat(messages_for(ctx))
+      agent
     end
   end
 end

data/lib/llm/tracer/telemetry.rb

@@ -223,7 +223,9 @@ module LLM
       require "opentelemetry/sdk" unless defined?(OpenTelemetry)
       @exporter ||= OpenTelemetry::SDK::Trace::Export::InMemorySpanExporter.new
       processor = OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(@exporter)
-      @tracer_provider = OpenTelemetry::SDK::Trace::TracerProvider.new
+      @tracer_provider = OpenTelemetry::SDK::Trace::TracerProvider.new(
+        sampler: OpenTelemetry::SDK::Trace::Samplers::ALWAYS_ON
+      )
       @tracer_provider.add_span_processor(processor)
       @tracer = @tracer_provider.tracer("llm.rb", LLM::VERSION)
     end

data/lib/llm/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm.rb
 version: !ruby/object:Gem::Version
-  version: 11.0.0
+  version: 11.1.0
 platform: ruby
 authors:
 - Antar Azri