llm.rb 5.0.0 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 482fe176a5e48457ba806d4ca3ae46c2e39f0e6a8037b8b39f4aaeea399ea33c
-  data.tar.gz: 71088a3ae2878ad20ed021324ab3da60df42c99753d062c3063bf9ba45cfc079
+  metadata.gz: 03ed8d289dc230fb6404f2fb3d1482401354f078b3502cd550949bcff48d97d2
+  data.tar.gz: 8b54acc8723263b5bf8c2d0025452e1448dfc66953a2c0d0c24c13e4d7b3343b
 SHA512:
-  metadata.gz: aef5fa2469606524a5c00cd582c12035b513c284743a2f86650cb8e0b828952be06935c173bf6b20d0230c31c91dbb20475fca5ca1c25b04e08b02069d399a49
-  data.tar.gz: f937bb7f2d381e131f6c4d87b5c095cab5c4a2c3af9a0dc0557b263c26d637fcc463fd876442faa128cb31edb7833a67a34da5bd9e527c86d4030349d388b000
+  metadata.gz: b088838c5b1860e30413ba87e2c66dec393b3bff51e462e38af5bc1f13b746b7bdf5d103b67f949aa31a6bc6da280da3e170f876743f6286f8a5674f6cee42a6
+  data.tar.gz: 769fecd327298f7b17b731f181d3091194cddeb758e1723a20a5c789f4b0298ce9a5f5244aa3d4a807b8d8260d541e1286443ca9d841a11fd666cb354a7f893b

data/CHANGELOG.md

@@ -2,8 +2,72 @@
 
 ## Unreleased
 
+Changes since `v5.2.0`.
+
+## v5.2.0
+
+Changes since `v5.1.0`.
+
+This release adds current DeepSeek V4 support through refreshed provider
+metadata, including `deepseek-v4-flash` and `deepseek-v4-pro`, while fixing
+request-local queue handling for concurrent streamed workloads so `wait` and
+interruption use the active per-call stream correctly.
+
+### Change
+
+* **Add `LLM::MCP#run` for scoped MCP client lifecycle** <br>
+  Add `LLM::MCP#run` so MCP clients can be started for the duration of a
+  block and then stopped automatically, which simplifies the usual
+  `start`/`stop` pattern in examples and application code.
+
+* **Refresh provider model metadata** <br>
+  Add current DeepSeek and OpenAI model metadata to `data/` and update the
+  Google Gemma model entry to match the current provider naming.
+
+### Fix
+
+* **Reject unsupported DeepSeek multimodal prompt objects early** <br>
+  Raise `LLM::PromptError` for `image_url`, `local_file`, and
+  `remote_file` in DeepSeek chat requests instead of sending invalid
+  OpenAI-compatible payloads that the provider rejects at runtime.
+
+* **Preserve DeepSeek reasoning content across tool turns** <br>
+  Replay `reasoning_content` when serializing prior assistant messages for
+  DeepSeek chat completions, so thinking-mode tool calls can continue into
+  follow-up requests without triggering invalid request errors.
+
+* **Default DeepSeek to `deepseek-v4-flash`** <br>
+  Change `LLM::DeepSeek#default_model` to `deepseek-v4-flash` so new
+  contexts and default provider usage align with the current preferred chat
+  model.
+
+* **Use per-call streams when waiting on streamed tool work** <br>
+  Track request-local streams bound through `talk(..., stream:)` and
+  `respond(..., stream:)` so `LLM::Context#wait` and interruption-aware
+  queue handling use the active stream instead of falling back to pending
+  function spawning.
+
+## v5.1.0
+
 Changes since `v5.0.0`.
 
+This release tightens streamed tool execution around the actual request-local
+runtime state. It fixes streamed resolution of per-request tools and makes
+that streamed path work cleanly with `LLM.function(...)`, MCP tools, bound
+tool instances, and normal tool classes.
+
+### Fix
+
+* **Resolve request-local tools during streaming** <br>
+  Resolve streamed tool calls through `LLM::Stream` request-local tools
+  before falling back to the global registry, so per-request tools and bound
+  tool instances work correctly during streaming.
+
+* **Support `LLM.function(...)` and MCP tools in streamed tool resolution** <br>
+  Let streamed tool resolution use the current request tool set, so
+  `LLM.function(...)`, MCP tools, bound tool instances, and normal
+  `LLM::Tool` classes all work through the same streamed tool path.
+
 ## v5.0.0
 
 Changes since `v4.23.0`.

data/README.md

@@ -4,7 +4,7 @@
 <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>
   <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-5.0.0-green.svg?" alt="Version"></a>
+  <a href="https://github.com/llmrb/llm.rb/tags"><img src="https://img.shields.io/badge/version-5.2.0-green.svg?" alt="Version"></a>
 </p>
 
 ## About
@@ -261,13 +261,17 @@ Remote MCP tools and prompts are not bolted on as a separate integration
 stack. They adapt into the same tool and prompt path used by local tools,
 skills, contexts, and agents.
 
+Use `mcp.run do ... end` for scoped work where the client should start and
+stop around one block. Use `mcp.start` and `mcp.stop` directly when you need
+finer sequential control across several steps before shutting the client down.
+
 ```ruby
-begin
-  mcp = LLM::MCP.http(url: "https://api.githubcopilot.com/mcp/").persistent
-  mcp.start
+mcp = LLM::MCP.http(
+  url: "https://api.githubcopilot.com/mcp/",
+  headers: {"Authorization" => "Bearer #{ENV.fetch("GITHUB_PAT")}"}
+).persistent
+mcp.run do
   ctx = LLM::Context.new(llm, tools: mcp.tools)
-ensure
-  mcp.stop
 end
 ```
 
@@ -281,12 +285,17 @@ Go's context package. In fact, llm.rb is heavily inspired by Go but with a Ruby
 twist.
 
 ```ruby
+require "llm"
+require "io/console"
+
+llm = LLM.openai(key: ENV["KEY"])
 ctx = LLM::Context.new(llm, stream: $stdout)
 worker = Thread.new do
   ctx.talk("Write a very long essay about network protocols.")
 rescue LLM::Interrupt
   puts "Request was interrupted!"
 end
+
 STDIN.getch
 ctx.interrupt!
 worker.join
@@ -615,9 +624,10 @@ require "io/console"
 
 llm = LLM.openai(key: ENV["KEY"])
 ctx = LLM::Context.new(llm, stream: $stdout)
-
 worker = Thread.new do
   ctx.talk("Write a very long essay about network protocols.")
+rescue LLM::Interrupt
+  puts "Request was interrupted!"
 end
 
 STDIN.getch
@@ -695,7 +705,7 @@ puts ticket.talk("How do I rotate my API key?").content
 
 #### MCP
 
-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. See the [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or [deepdive (markdown)](resources/deepdive.md) for more examples.
+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 (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
 require "llm"
@@ -707,13 +717,24 @@ mcp = LLM::MCP.http(
   headers: {"Authorization" => "Bearer #{ENV.fetch("GITHUB_PAT")}"}
 ).persistent
 
-begin
-  mcp.start
+mcp.start
+ctx = LLM::Context.new(llm, stream: $stdout, tools: mcp.tools)
+ctx.talk("Pull information about my GitHub account.")
+ctx.talk(ctx.call(:functions)) while ctx.functions.any?
+mcp.stop
+```
+
+For scoped work, `mcp.run do ... end` is shorter and handles cleanup for you:
+
+```ruby
+mcp = LLM::MCP.http(
+  url: "https://api.githubcopilot.com/mcp/",
+  headers: {"Authorization" => "Bearer #{ENV.fetch("GITHUB_PAT")}"}
+).persistent
+mcp.run do
   ctx = LLM::Context.new(llm, stream: $stdout, tools: mcp.tools)
   ctx.talk("Pull information about my GitHub account.")
   ctx.talk(ctx.call(:functions)) while ctx.functions.any?
-ensure
-  mcp.stop
 end
 ```
 

data/data/deepseek.json

@@ -70,6 +70,74 @@
         "context": 128000,
         "output": 64000
       }
+    },
+    "deepseek-v4-flash": {
+      "id": "deepseek-v4-flash",
+      "name": "DeepSeek V4 Flash",
+      "family": "deepseek-flash",
+      "attachment": false,
+      "reasoning": true,
+      "tool_call": true,
+      "interleaved": {
+        "field": "reasoning_content"
+      },
+      "structured_output": true,
+      "temperature": true,
+      "knowledge": "2025-05",
+      "release_date": "2026-04-24",
+      "last_updated": "2026-04-24",
+      "modalities": {
+        "input": [
+          "text"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": true,
+      "cost": {
+        "input": 0.14,
+        "output": 0.28,
+        "cache_read": 0.028
+      },
+      "limit": {
+        "context": 1000000,
+        "output": 384000
+      }
+    },
+    "deepseek-v4-pro": {
+      "id": "deepseek-v4-pro",
+      "name": "DeepSeek V4 Pro",
+      "family": "deepseek-thinking",
+      "attachment": false,
+      "reasoning": true,
+      "tool_call": true,
+      "interleaved": {
+        "field": "reasoning_content"
+      },
+      "structured_output": true,
+      "temperature": true,
+      "knowledge": "2025-05",
+      "release_date": "2026-04-24",
+      "last_updated": "2026-04-24",
+      "modalities": {
+        "input": [
+          "text"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": true,
+      "cost": {
+        "input": 1.74,
+        "output": 3.48,
+        "cache_read": 0.145
+      },
+      "limit": {
+        "context": 1000000,
+        "output": 384000
+      }
     }
   }
 }

data/data/google.json

@@ -1058,6 +1058,32 @@
         "output": 8192
       }
     },
+    "gemma-4-26b-a4b-it": {
+      "id": "gemma-4-26b-a4b-it",
+      "name": "Gemma 4 26B",
+      "family": "gemma",
+      "attachment": false,
+      "reasoning": true,
+      "tool_call": true,
+      "structured_output": true,
+      "temperature": true,
+      "release_date": "2026-04-02",
+      "last_updated": "2026-04-02",
+      "modalities": {
+        "input": [
+          "text",
+          "image"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": true,
+      "limit": {
+        "context": 256000,
+        "output": 8192
+      }
+    },
     "gemini-2.5-flash-lite": {
       "id": "gemini-2.5-flash-lite",
       "name": "Gemini 2.5 Flash Lite",
@@ -1093,32 +1119,6 @@
         "output": 65536
       }
     },
-    "gemma-4-26b-it": {
-      "id": "gemma-4-26b-it",
-      "name": "Gemma 4 26B",
-      "family": "gemma",
-      "attachment": false,
-      "reasoning": true,
-      "tool_call": true,
-      "structured_output": true,
-      "temperature": true,
-      "release_date": "2026-04-02",
-      "last_updated": "2026-04-02",
-      "modalities": {
-        "input": [
-          "text",
-          "image"
-        ],
-        "output": [
-          "text"
-        ]
-      },
-      "open_weights": true,
-      "limit": {
-        "context": 256000,
-        "output": 8192
-      }
-    },
     "gemini-2.5-flash-image-preview": {
       "id": "gemini-2.5-flash-image-preview",
       "name": "Gemini 2.5 Flash Image (Preview)",

data/data/openai.json

@@ -195,6 +195,61 @@
         "output": 16384
       }
     },
+    "gpt-5.5": {
+      "id": "gpt-5.5",
+      "name": "GPT-5.5",
+      "family": "gpt",
+      "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": 5,
+        "output": 30,
+        "cache_read": 0.5,
+        "context_over_200k": {
+          "input": 10,
+          "output": 45,
+          "cache_read": 1
+        }
+      },
+      "limit": {
+        "context": 1050000,
+        "input": 920000,
+        "output": 130000
+      },
+      "experimental": {
+        "modes": {
+          "fast": {
+            "cost": {
+              "input": 12.5,
+              "output": 75,
+              "cache_read": 1.25
+            },
+            "provider": {
+              "body": {
+                "service_tier": "priority"
+              }
+            }
+          }
+        }
+      }
+    },
     "gpt-5-mini": {
       "id": "gpt-5-mini",
       "name": "GPT-5 Mini",

data/lib/llm/context.rb

@@ -177,7 +177,7 @@ module LLM
       params = params.merge(messages: @messages.to_a)
       params = @params.merge(params)
       prompt, params = transform(prompt, params)
-      bind!(params[:stream], params[:model])
+      bind!(params[:stream], params[:model], params[:tools])
       res = @llm.complete(prompt, params)
       role = params[:role] || @llm.user_role
       role = @llm.tool_role if params[:role].nil? && [*prompt].grep(LLM::Function::Return).any?
@@ -205,7 +205,7 @@ module LLM
       compactor.compact!(prompt) if compactor.compact?(prompt)
       params = @params.merge(params)
       prompt, params = transform(prompt, params)
-      bind!(params[:stream], params[:model])
+      bind!(params[:stream], params[:model], params[:tools])
       res_id = params[:store] == false ? nil : @messages.find(&:assistant?)&.response&.response_id
       params = params.merge(previous_response_id: res_id, input: @messages.to_a).compact
       res = @llm.responses.create(prompt, params)
@@ -295,7 +295,6 @@ module LLM
     #  ractor work, in that order.
     # @return [Array<LLM::Function::Return>]
     def wait(strategy)
-      stream = @params[:stream]
       if LLM::Stream === stream && !stream.queue.empty?
         @queue = stream.queue
         @queue.wait(strategy)
@@ -459,19 +458,24 @@ module LLM
 
     private
 
-    def bind!(stream, model)
+    def bind!(stream, model, tools)
       return unless LLM::Stream === stream
+      @stream = stream
       stream.extra[:ctx] = self
       stream.extra[:tracer] = tracer
       stream.extra[:model] = model
+      stream.extra[:tools] = tools
     end
 
     def queue
       return @queue if @queue
-      stream = @params[:stream]
       stream.queue if LLM::Stream === stream
     end
 
+    def stream
+      @stream || @params[:stream]
+    end
+
     def load_skills(skills)
       [*skills].map { LLM::Skill.load(_1).to_tool(self) }
     end
@@ -494,7 +498,6 @@ module LLM
         message: warning
       })
     end
-
   end
 
   # Backward-compatible alias

data/lib/llm/mcp.rb

@@ -103,6 +103,21 @@ class LLM::MCP
     nil
   end
 
+  ##
+  # Starts the MCP client for the duration of a block and then stops it.
+  # @yield Runs with the MCP client started
+  # @raise [LocalJumpError]
+  #  When called without a block
+  # @raise [StandardError]
+  #  Propagates errors raised by {#start}, the block itself, or {#stop}
+  # @return [void]
+  def run
+    start
+    yield
+  ensure
+    stop
+  end
+
   ##
   # Configures an HTTP MCP transport to use a persistent connection pool
   # via the optional dependency [Net::HTTP::Persistent](https://github.com/drbrain/net-http-persistent)

data/lib/llm/message.rb

@@ -33,11 +33,15 @@ module LLM
     # Returns a Hash representation of the message.
     # @return [Hash]
     def to_h
-      {role:, content:, reasoning_content:,
-       compaction: extra.compaction,
-       tools: extra.tool_calls,
-       usage:,
-       original_tool_calls: extra.original_tool_calls}.compact
+      {
+        role:,
+        content:,
+        reasoning_content:,
+        compaction: extra.compaction,
+        tools: extra.tool_calls&.map { LLM::Object === _1 ? _1.to_h : _1 },
+        usage:,
+        original_tool_calls: extra.original_tool_calls
+      }.compact.then { preserve_nil_content(_1) }
     end
 
     ##
@@ -208,6 +212,11 @@ module LLM
 
     private
 
+    def preserve_nil_content(hash)
+      hash[:content] = content if content.nil?
+      hash
+    end
+
     def tool_calls
       @tool_calls ||= LLM::Object.from(extra.tool_calls || [])
     end

data/lib/llm/providers/anthropic/stream_parser.rb

@@ -105,7 +105,7 @@ class LLM::Anthropic
     end
 
     def resolve_tool(tool)
-      registered = LLM::Function.find_by_name(tool["name"])
+      registered = @stream.find_tool(tool["name"])
       fn = (registered || LLM::Function.new(tool["name"])).dup.tap do |fn|
         fn.id = tool["id"]
         fn.arguments = LLM::Anthropic.parse_tool_input(tool["input"])

data/lib/llm/providers/deepseek/request_adapter/completion.rb

@@ -19,7 +19,7 @@ module LLM::DeepSeek::RequestAdapter
         if Hash === message
           {role: message[:role], content: adapt_content(message[:content])}
         elsif message.tool_call?
-          {role: message.role, content: nil, tool_calls: message.extra[:original_tool_calls]}
+          wrap(content: nil, tool_calls: message.extra[:original_tool_calls])
         else
           adapt_message
         end
@@ -30,25 +30,34 @@ module LLM::DeepSeek::RequestAdapter
 
     def adapt_content(content)
       case content
+      when LLM::Object
+        adapt_object(content)
       when String
-        content.to_s
+        [{type: :text, text: content.to_s}]
       when LLM::Message
         adapt_content(content.content)
       when LLM::Function::Return
         throw(:abort, {role: "tool", tool_call_id: content.id, content: LLM.json.dump(content.value)})
-      when LLM::Object
-        prompt_error!(content)
       else
         prompt_error!(content)
       end
     end
 
+    def adapt_object(object)
+      case object.kind
+      when :image_url, :local_file, :remote_file
+        prompt_error!(object)
+      else
+        prompt_error!(object)
+      end
+    end
+
     def adapt_message
       case content
       when Array
         adapt_array
       else
-        {role: message.role, content: adapt_content(content)}
+        wrap(content: adapt_content(content))
       end
     end
 
@@ -58,13 +67,13 @@ module LLM::DeepSeek::RequestAdapter
       elsif returns.any?
         returns.map { {role: "tool", tool_call_id: _1.id, content: LLM.json.dump(_1.value)} }
       else
-        {role: message.role, content: content.flat_map { adapt_content(_1) }}
+        wrap(content: content.flat_map { adapt_content(_1) })
       end
     end
 
     def prompt_error!(object)
       if LLM::Object === object
-        raise LLM::PromptError, "The given LLM::Object with kind '#{content.kind}' is not " \
+        raise LLM::PromptError, "The given LLM::Object with kind '#{object.kind}' is not " \
                                 "supported by the DeepSeek API"
       else
         raise LLM::PromptError, "The given object (an instance of #{object.class}) " \
@@ -72,8 +81,22 @@ module LLM::DeepSeek::RequestAdapter
       end
     end
 
+    def wrap(content:, tool_calls: nil)
+      {
+        role: message.role,
+        content:,
+        tool_calls: tool_calls&.map { LLM::Object === _1 ? _1.to_h : _1 },
+        reasoning_content: message.reasoning_content
+      }.compact.then { preserve_nil_content(_1) }
+    end
+
     def message = @message
     def content = message.content
     def returns = content.grep(LLM::Function::Return)
+
+    def preserve_nil_content(hash)
+      hash[:content] = content if content.nil?
+      hash
+    end
   end
 end

data/lib/llm/providers/deepseek.rb

@@ -15,7 +15,7 @@ module LLM
   #
   #   llm = LLM.deepseek(key: ENV["KEY"])
   #   ctx = LLM::Context.new(llm)
-  #   ctx.talk ["Tell me about this photo", ctx.local_file("/images/photo.png")]
+  #   ctx.talk "Hello"
   #   ctx.messages.select(&:assistant?).each { print "[#{_1.role}]", _1.content, "\n" }
   class DeepSeek < OpenAI
     require_relative "deepseek/request_adapter"
@@ -73,10 +73,10 @@ module LLM
 
     ##
     # Returns the default model for chat completions
-    # @see https://api-docs.deepseek.com/quick_start/pricing deepseek-chat
+    # @see https://api-docs.deepseek.com/quick_start/pricing deepseek-v4-flash
     # @return [String]
     def default_model
-      "deepseek-chat"
+      "deepseek-v4-flash"
     end
   end
 end

data/lib/llm/providers/google/stream_parser.rb

@@ -153,7 +153,7 @@ class LLM::Google
 
     def resolve_tool(part, cindex, pindex)
       call = part["functionCall"]
-      registered = LLM::Function.find_by_name(call["name"])
+      registered = @stream.find_tool(call["name"])
       fn = (registered || LLM::Function.new(call["name"])).dup.tap do |fn|
         fn.id = LLM::Google.tool_id(part:, cindex:, pindex:)
         fn.arguments = call["args"]

data/lib/llm/providers/openai/responses/stream_parser.rb

@@ -269,7 +269,7 @@ class LLM::OpenAI
     # @group Resolvers
 
     def resolve_tool(tool, arguments)
-      registered = LLM::Function.find_by_name(tool["name"])
+      registered = @stream.find_tool(tool["name"])
       fn = (registered || LLM::Function.new(tool["name"])).dup.tap do |fn|
         fn.id = tool["call_id"]
         fn.arguments = arguments

data/lib/llm/providers/openai/stream_parser.rb

@@ -185,7 +185,7 @@ class LLM::OpenAI
     end
 
     def resolve_tool(tool, function, arguments)
-      registered = LLM::Function.find_by_name(function["name"])
+      registered = @stream.find_tool(function["name"])
       fn = (registered || LLM::Function.new(function["name"])).dup.tap do |fn|
         fn.id = tool["id"]
         fn.arguments = arguments

data/lib/llm/stream.rb

@@ -83,12 +83,12 @@ module LLM
     #   `tool.mcp? ? ctx.spawn(tool, :task) : ctx.spawn(tool, :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}. The current `:ractor` mode is for class-based tools
-    #   and does not support MCP tools.
+    #   the tool-call path to recover and the session to continue. Streamed
+    #   tool resolution now prefers the current request tools, so
+    #   {LLM.function}, MCP tools, bound tool instances, and normal
+    #   {LLM::Tool LLM::Tool} classes can all resolve through the same
+    #   request-local path. 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
@@ -148,6 +148,34 @@ module LLM
       })
     end
 
+    ##
+    # Returns the tool definitions available for the current streamed request.
+    # This prefers request-local tools attached to the stream and falls back
+    # to the current context defaults when present.
+    # @return [Array<LLM::Function, LLM::Tool>]
+    def tools
+      extra[:tools] || ctx&.params&.dig(:tools) || []
+    end
+
+    ##
+    # Resolves a streamed tool call against the current request tools first,
+    # then falls back to the global function registry.
+    # @param [String] name
+    # @return [LLM::Function, nil]
+    def find_tool(name)
+      tool = tools.find do |candidate|
+        candidate_name =
+          if candidate.respond_to?(:function)
+            candidate.function.name
+          else
+            candidate.name
+          end
+        candidate_name.to_s == name.to_s
+      end
+      tool&.then { _1.respond_to?(:function) ? _1.function : _1 } ||
+        LLM::Function.find_by_name(name)
+    end
+
     # @endgroup
   end
 end

data/lib/llm/version.rb

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

metadata

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