llm.rb 11.0.0 → 11.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24c3c2930dd3ab321999075b34ef2e5c6d445fec5c873b00ef071caeef3c1406
-  data.tar.gz: 0d6921f20dc327f7c424f7282ff3c76f5073ad3eec7f21d483ee7623e4c782f7
+  metadata.gz: bb1ffd1e0ecb17422014ec8f75c8b729f74d0a7cef4fd4e12681ef254411b24a
+  data.tar.gz: e5a7815d52c6fa99a38dec111c6d71aef9782272b97bfbad81e8f5bee913f918
 SHA512:
-  metadata.gz: 3b96ea3336114822ccb2defee4da43089df6e004cebdf27987562f7f339bc2a733cc169d64f9752cc51d0346a069ba3921e99db69c2de1f795abfa69f260a730
-  data.tar.gz: b4135fad5bd1c5499b1177c27d6eb9c2da5a84b50a5492e82fe6396821c2b4a5e0891e55cb557d07e5ee4ec912b7ecdd8c7df223ebe76109aa74b7ede5227195
+  metadata.gz: d7c2d1dac8ef97a5be2540896828b523ce1491e43f2fd8c78e53b8fbab34432bf6dedaee066afd43d261fb8f4e2fb9f7c3d8c112de83e60ee809d6ef77f41feb
+  data.tar.gz: d5073e8c5c156739cff4c68c65c4efaf88403229841ada3cdd1adb4920dfb58c00017ae7dbd73d12ef17b6c191b0b71ab4f15fd0c0ae29991dcffb1b840381d0

data/CHANGELOG.md

@@ -2,6 +2,131 @@
 
 ## Unreleased
 
+## v11.2.0
+
+Changes since `v11.1.0`.
+
+This release adds `LLM::Function#skill?` and `LLM::Tool#skill?` so
+callers can inspect whether a function or tool is backed by a skill.
+
+It introduces `LLM::Transport::Request` as a transport-agnostic request
+object so providers no longer depend directly on `Net::HTTP` request
+classes, and adds an optional Curb (libcurl) backend alongside symbolic
+transport shortcuts such as `transport: :curb`.
+
+MCP and A2A clients now accept `persistent: true` matching provider configuration.
+Several fixes land for tool return callback emission, function comparison by
+tool call ID, function array filtering, skill tool inheritance, and JSON generator
+state compatibility on Ruby 4.
+
+### Add
+
+* **Add `LLM::Function#skill?`** <br>
+  Add `skill?` to `LLM::Function` so callers can check whether a
+  function is backed by a skill tool.
+
+* **Add `LLM::Tool.skill?` and `LLM::Tool#skill?`** <br>
+  Add class-level `skill?` and instance-level `skill?` to
+  `LLM::Tool`, matching the existing `mcp?` and `a2a?` pattern.
+
+* **Add `LLM::Transport::Request`** <br>
+  Add `LLM::Transport::Request` as a transport-agnostic request object
+  and update providers to build requests without depending directly on
+  Net::HTTP request classes. The built-in Net::HTTP transports still
+  accept existing Net::HTTP request objects through a compatibility
+  bridge, while alternative transports can handle the generic request
+  shape directly.
+
+* **Add optional Curb transport support** <br>
+  Add `LLM::Transport::Curb`, an optional libcurl-backed transport
+  that can be selected with `transport: :curb`. Providers already
+  emit `LLM::Transport::Request` objects, so the Curb backend can
+  execute requests without routing through Net::HTTP.
+
+* **Add symbolic transport shortcuts** <br>
+  Allow providers, MCP HTTP clients, and A2A HTTP clients to accept
+  transport shortcuts such as `transport: :curb` and
+  `transport: :net_http_persistent`.
+
+* **Add persistent HTTP selection to MCP and A2A clients** <br>
+  Allow MCP and A2A HTTP clients to accept `persistent: true`, matching
+  provider configuration and selecting the persistent Net::HTTP
+  transport by default.
+
+### Fix
+
+* **Support JSON generation state on Ruby 4** <br>
+  Handle JSON generator state objects in the standard JSON adapter so
+  schema objects serialize correctly when Ruby 4 calls custom `to_json`
+  methods during provider request generation.
+
+* **Emit tool return callbacks for direct context waits** <br>
+  Emit `LLM::Stream#on_tool_return` when `LLM::Context#wait` executes
+  pending tool work directly instead of draining `LLM::Stream::Queue`.
+
+* **Emit confirmed tool return callbacks once** <br>
+  Emit `LLM::Stream#on_tool_return` for confirmed and cancelled tool
+  calls, and exclude confirmed functions from later waits so mixed
+  confirmed and unconfirmed tool batches do not execute confirmed tools
+  twice.
+
+* **Compare functions by tool call ID** <br>
+  Add `LLM::Function#==`, `#eql?`, and `#hash` so pending function
+  collections can compare tool calls by provider-assigned ID instead of
+  object identity.
+
+* **Preserve function array behavior after filtering** <br>
+  Preserve `LLM::Function::Array` behavior when subtracting function
+  arrays so filtered tool batches can still spawn through the normal
+  function array API.
+
+* **Prevent skills from inheriting skill-backed tools** <br>
+  Exclude skill-backed tools when a skill sub-agent uses `tools:
+  inherit`, preventing skills loaded through a parent context from
+  being recursively exposed to nested skill agents.
+
+## 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`.
@@ -91,7 +216,7 @@ requests outside `#session`, `LLM::Function#def` as a short alias for
 
 * **Fix context and agent JSON serialization through `LLM.json`** <br>
   Fix `LLM::Context#to_json` and `LLM::Agent#to_json` to serialize
-  through `LLM.json.dump(...)` instead of plain `to_json`. 
+  through `LLM.json.dump(...)` instead of plain `to_json`.
 
 * **Fix block-form ORM agent DSL forwarding** <br>
   Fix block-form `model { ... }`, `tools { ... }`, and

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.2.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
@@ -171,7 +175,9 @@ ctx.talk(ctx.wait(:call)) while ctx.functions?
 The HTTP transport can be used with or without the `session` method,
 and unlike the stdio transport it can remain efficient without the
 `session` method through a persistent connection pool that is available
-through the [LLM::Transport.net_http_persistent](https://0x1eef.github.io/x/llm.rb/LLM/Transport.html#method-c-net_http_persistent) transport:
+through the
+[LLM::Transport.net_http_persistent](https://0x1eef.github.io/x/llm.rb/LLM/Transport.html#method-c-net_http_persistent)
+transport:
 
 ```ruby
 require "llm"
@@ -179,7 +185,7 @@ require "llm"
 llm = LLM.openai(key: ENV["KEY"])
 mcp = LLM::MCP.http(
   url: "https://remote-mcp.example.com",
-  transport: LLM::Transport.net_http_persistent
+  transport: :net_http_persistent
 )
 
 ctx = LLM::Context.new(llm, tools: mcp.tools)
@@ -220,7 +226,7 @@ require "llm"
 
 a2a = LLM::A2A.rest(
   url: "https://remote-agent.example.com",
-  transport: LLM::Transport.net_http_persistent
+  transport: :net_http_persistent
 )
 ```
 
@@ -228,6 +234,27 @@ For more on direct messaging, task operations, push notification
 configs, and JSON-RPC, see the
 [LLM::A2A API docs](https://0x1eef.github.io/x/llm.rb/LLM/A2A.html).
 
+#### Transports
+
+Providers use Ruby's standard library Net::HTTP transport by default.
+You can opt into persistent Net::HTTP connections with `persistent: true`,
+or provide a transport shortcut when you want a different backend.
+`transport: :curb` uses libcurl through the optional `curb` gem.
+
+Custom transports can implement the
+[LLM::Transport](https://0x1eef.github.io/x/llm.rb/LLM/Transport.html)
+interface and receive transport-agnostic
+[LLM::Transport::Request](https://0x1eef.github.io/x/llm.rb/LLM/Transport/Request.html)
+objects from providers.
+
+```ruby
+require "llm"
+
+llm = LLM.openai(key: ENV["KEY"], persistent: true)
+llm = LLM.openai(key: ENV["KEY"], transport: :net_http_persistent)
+llm = LLM.openai(key: ENV["KEY"], transport: :curb)
+```
+
 #### Skills
 
 Skills are reusable instructions loaded from a `SKILL.md` directory. They let
@@ -260,6 +287,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 +429,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 +482,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 +515,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 +550,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 +578,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 +614,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 +671,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 +729,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 +750,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/a2a/transport/http.rb

@@ -17,13 +17,14 @@ class LLM::A2A
       # @param [String] url The base URL of the A2A agent
       # @param [Hash<String, String>] headers Extra HTTP headers
       # @param [Integer, nil] timeout The timeout in seconds
-      # @param [LLM::Transport, Class, nil] transport Override transport
+      # @param [Boolean] persistent Whether to use persistent HTTP connections
+      # @param [LLM::Transport, Class, Symbol, nil] transport Override transport
       # @param [String] protocol_version The A2A protocol version header
-      def initialize(url:, headers: {}, timeout: nil, transport: nil, protocol_version: "1.0")
+      def initialize(url:, headers: {}, timeout: nil, persistent: false, transport: nil, protocol_version: "1.0")
         @uri = URI.parse(url)
         @headers = headers
         @protocol_version = protocol_version
-        @transport = resolve_transport(@uri, transport, timeout)
+        @transport = resolve_transport(host: @uri.host, port: uri.port, ssl: @uri.scheme == "https", timeout:, persistent:, transport:)
       end
 
       ##
@@ -31,7 +32,7 @@ class LLM::A2A
       # @param [String] path The URL path
       # @return [Hash]
       def get(path, accept: "application/json")
-        req = Net::HTTP::Get.new(request_path(path), headers(accept:))
+        req = LLM::Transport::Request.get(request_path(path), headers(accept:))
         res = transport.request(req, owner: self)
         parse_response(res)
       end
@@ -42,7 +43,7 @@ class LLM::A2A
       # @param [Hash] body The JSON body
       # @return [Hash]
       def post(path, body, content_type: "application/json", accept: "application/json")
-        req = Net::HTTP::Post.new(request_path(path), headers(content_type:, accept:))
+        req = LLM::Transport::Request.post(request_path(path), headers(content_type:, accept:))
         req.body = LLM.json.dump(body)
         res = transport.request(req, owner: self)
         parse_response(res)
@@ -53,7 +54,7 @@ class LLM::A2A
       # @param [String] path The URL path
       # @return [Hash]
       def delete(path, accept: "application/json")
-        req = Net::HTTP::Delete.new(request_path(path), headers(accept:))
+        req = LLM::Transport::Request.delete(request_path(path), headers(accept:))
         res = transport.request(req, owner: self)
         parse_response(res)
       end
@@ -66,7 +67,7 @@ class LLM::A2A
       # @yieldparam [LLM::Object] event A stream event
       # @return [void]
       def get_stream(path, &on_event)
-        req = Net::HTTP::Get.new(request_path(path), headers(accept: "text/event-stream"))
+        req = LLM::Transport::Request.get(request_path(path), headers(accept: "text/event-stream"))
         stream(req, &on_event)
       end
 
@@ -79,7 +80,7 @@ class LLM::A2A
       # @yieldparam [LLM::Object] event A stream event
       # @return [void]
       def post_stream(path, body, content_type: "application/json", &on_event)
-        req = Net::HTTP::Post.new(request_path(path), headers(content_type:, accept: "text/event-stream"))
+        req = LLM::Transport::Request.post(request_path(path), headers(content_type:, accept: "text/event-stream"))
         req.body = LLM.json.dump(body)
         stream(req, &on_event)
       end

data/lib/llm/a2a.rb

@@ -61,8 +61,10 @@ class LLM::A2A
   #  Extra HTTP headers to include in requests (e.g., Authorization)
   # @param [Integer, nil] timeout
   #  The timeout in seconds for HTTP requests
-  # @param [LLM::Transport, Class, nil] transport
-  #  Optional override with any {LLM::Transport} instance or subclass
+  # @param [Boolean] persistent
+  #  Whether to use persistent HTTP connections
+  # @param [LLM::Transport, Class, Symbol, nil] transport
+  #  Optional override with any {LLM::Transport} instance, subclass, or shortcut
   # @param [Symbol] binding
   #  The protocol binding to use. One of `:rest` or `:jsonrpc`
   # @param [String] base_path
@@ -70,7 +72,7 @@ class LLM::A2A
   # @param [String] protocol_version
   #  The expected A2A protocol version. Defaults to `"1.0"`.
   # @return [LLM::A2A]
-  def self.http(url:, headers: {}, timeout: 30, transport: nil, binding: :rest, base_path: "", protocol_version: "1.0")
+  def self.http(url:, headers: {}, timeout: 30, persistent: false, transport: nil, binding: :rest, base_path: "", protocol_version: "1.0")
     new(
       binding:,
       base_path:,
@@ -79,6 +81,7 @@ class LLM::A2A
         url:,
         headers:,
         timeout:,
+        persistent:,
         transport:,
         protocol_version:
       )
@@ -90,13 +93,15 @@ class LLM::A2A
   # @param [String] url
   # @param [Hash<String, String>] headers
   # @param [Integer, nil] timeout
-  # @param [LLM::Transport, Class, nil] transport
+  # @param [Boolean] persistent
+  # @param [LLM::Transport, Class, Symbol, nil] transport
   # @return [LLM::A2A]
-  def self.rest(url:, headers: {}, timeout: 30, transport: nil, base_path: "", protocol_version: "1.0")
+  def self.rest(url:, headers: {}, timeout: 30, persistent: false, transport: nil, base_path: "", protocol_version: "1.0")
     http(
       url:,
       headers:,
       timeout:,
+      persistent:,
       transport:,
       binding: :rest,
       base_path:,
@@ -109,13 +114,15 @@ class LLM::A2A
   # @param [String] url
   # @param [Hash<String, String>] headers
   # @param [Integer, nil] timeout
-  # @param [LLM::Transport, Class, nil] transport
+  # @param [Boolean] persistent
+  # @param [LLM::Transport, Class, Symbol, nil] transport
   # @return [LLM::A2A]
-  def self.jsonrpc(url:, headers: {}, timeout: 30, transport: nil, base_path: "", protocol_version: "1.0")
+  def self.jsonrpc(url:, headers: {}, timeout: 30, persistent: false, transport: nil, base_path: "", protocol_version: "1.0")
     http(
       url:,
       headers:,
       timeout:,
+      persistent:,
       transport:,
       binding: :jsonrpc,
       base_path:,

data/lib/llm/agent.rb

@@ -447,10 +447,13 @@ module LLM
       strategy = concurrency || :call
       return wait(strategy) unless @confirm&.any?
       confirmables = @ctx.functions.select { @confirm.include?(_1.name.to_s) }
-      results = confirmables.map do |tool|
-        send(:on_tool_confirmation, tool, strategy)
+      results = confirmables.map { method(:on_tool_confirmation).call(_1, strategy) }
+      @ctx.method(:emit_tool_returns).call(confirmables, results)
+      if (@ctx.functions - confirmables).any?
+        [*results, *wait(strategy, except: confirmables)]
+      else
+        results
       end
-      @ctx.functions? ? [*results, *wait(strategy)] : results
     end
 
     ##

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
@@ -302,15 +303,21 @@ module LLM
     #  without using this argument.
     #  Otherwise, this controls how pending functions are resolved directly.
     #  Use `:call` for sequential execution without spawning.
+    # @param [Array<LLM::Function>] except
+    #  A list of functions to exclude from the wait
     # @return [Array<LLM::Function::Return>]
-    def wait(strategy)
+    def wait(strategy, except: [])
       if LLM::Stream === stream && !stream.queue.empty?
         @queue = stream.queue
         @queue.wait
       else
-        return guarded_returns if guarded_returns
-        @queue = functions.spawn(strategy)
-        @queue.wait
+        tools  = except.empty? ? functions : functions - except
+        guards = guarded_returns(tools:)
+        return guards if guards
+        @queue = tools.spawn(strategy)
+        returns = @queue.wait
+        emit_tool_returns(tools, returns)
+        returns
       end
     ensure
       @queue = nil
@@ -515,10 +522,10 @@ module LLM
     ##
     # Builds in-band guarded returns when the guard blocks tool work.
     # @api private
-    def guarded_returns
+    def guarded_returns(tools:)
       warning = guard&.call(self)
       return unless warning
-      functions.map { guarded_return_for(_1, warning) }
+      tools.map { guarded_return_for(_1, warning) }
     end
 
     ##
@@ -566,5 +573,33 @@ module LLM
         message: warning
       })
     end
+
+    ##
+    # Emits tool return callbacks for directly waited function work.
+    # @api private
+    def emit_tool_returns(tools, returns)
+      return unless LLM::Stream === stream
+      returns.each_with_index { |result, index| stream.on_tool_return(tools[index], result) }
+    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/array.rb

@@ -68,5 +68,11 @@ class LLM::Function
     def wait(strategy)
       spawn(strategy).wait
     end
+
+    ##
+    # @return [LLM::Function::Array]
+    def -(other)
+      super.extend(Array)
+    end
   end
 end

data/lib/llm/function.rb

@@ -109,8 +109,35 @@ 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
+
+  ##
+  # Compares functions by tool call ID when both sides have one.
+  # @param [LLM::Function] other
+  # @return [Boolean]
+  def ==(other)
+    return true if equal?(other)
+    return false unless self.class === other
+    return false unless id && other.id
+    id == other.id
+  end
+  alias_method :eql?, :==
+
+  ##
+  # Returns a hash value compatible with {#==}.
+  # @return [Integer]
+  def hash
+    id ? id.hash : object_id.hash
+  end
 
   ##
   # Returns a tracer, or nil
@@ -292,6 +319,13 @@ class LLM::Function
     @cancelled
   end
 
+  ##
+  # Returns true when this function is backed by a skill tool.
+  # @return [Boolean]
+  def skill?
+    @runner.respond_to?(:skill?) and @runner.skill?
+  end
+
   ##
   # Returns true when a function has neither been called nor cancelled
   # @return [Boolean]
@@ -373,10 +407,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/json_adapter.rb

@@ -35,9 +35,15 @@ module LLM
   class JSONAdapter::JSON < JSONAdapter
     ##
     # @return (see JSONAdapter#dump)
-    def self.dump(obj, ...)
+    def self.dump(obj, state = nil, **options)
       require "json" unless defined?(::JSON)
-      ::JSON.dump(obj, ...)
+      if ::JSON::State === state
+        ::JSON.generate(obj, state)
+      elsif state
+        ::JSON.dump(obj, state, **options)
+      else
+        ::JSON.dump(obj, **options)
+      end
     end
 
     ##