llm.rb 0.10.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39e538d8185cf5c8c5a36da0e1bf5b0b9e0055945a02570cd00fefc805b288d0
-  data.tar.gz: 7fc0d3a4422fe10bb3058c7b1b5b9bc80693ccc0dbf6b62bda46d42fb7c2830c
+  metadata.gz: 2cd935a4ccd3b911e92b5ff54335cfc143247cbb5fe55214fd563551f7349da4
+  data.tar.gz: c76b36f2877c0cec7fdde54471a81ae19a4ec044158077742eba9acd26cd1483
 SHA512:
-  metadata.gz: a2b3de69ce317d856ec593074e22883ec2b96ddcdc2637cb2b4c555885c1c771b2ffd447b255cdc16a2c7f1c2b72362ab1b6e29ec0fdf775e977292b03fd3e34
-  data.tar.gz: c2ba0f853b7eaac4ca8fab15f497a3fa375e054b7da928b2f0798e393909baff20d2381afd48e793fd878261a0d838474e4be3be5b5232e480cf162af57dbe2e
+  metadata.gz: f654d042a6f44cba15b2dc0049d3933aa442f631293be446486e524773ff01bfc0f13f89ecbf09659a175c3ff9f7c6512ae8bde5716f6935c8d3d05528d3e4e9
+  data.tar.gz: 73945113e01d89188301a1a7db921c8c07ac19a847fa71528bc2e62eb5162ac656aca02a5f17e02bc4918dc973c298f0021afbb14a4cb38e7f81705950c4ed5b

data/README.md

@@ -1,16 +1,16 @@
 ## About
 
 llm.rb is a zero-dependency Ruby toolkit for Large Language Models that
-includes OpenAI, Gemini, Anthropic, DeepSeek, Ollama, and LlamaCpp. The
-toolkit includes full support for chat, streaming, tool calling, audio,
-images, files, and JSON Schema generation.
+includes OpenAI, Gemini, Anthropic, xAI (grok), DeepSeek, Ollama, and
+LlamaCpp. The toolkit includes full support for chat, streaming, tool calling,
+audio, images, files, and JSON Schema generation.
 
 ## Features
 
 #### General
 - ✅ A single unified interface for multiple providers
 - 📦 Zero dependencies outside Ruby's standard library
-- 🚀 Efficient API design that minimizes the request count
+- 🚀 Efficient API design that minimizes the number of requests made
 
 #### Chat, Agents
 - 🧠 Stateless and stateful chat via completions and responses API
@@ -24,27 +24,39 @@ images, files, and JSON Schema generation.
 - 📎 File uploads and prompt-aware file interaction
 - 💡 Multimodal prompts (text, images, PDFs, URLs, files)
 
-#### Miscellaneous
+#### Embeddings
 - 🧮 Text embeddings and vector support
-- 🔌 Retrieve models dynamically for introspection and selection
+- 🧱 Includes support for OpenAI's vector stores API
+
+#### Miscellaneous
+- 📜 Model management and selection
+- 🔧 Includes support for OpenAI's responses, moderations, and vector stores APIs
+
+## Matrix
+
+While the Features section above gives you the high-level picture, the table below
+breaks things down by provider, so you can see exactly what’s supported where.
 
-## Demos
 
-> The
-> [llmrb/llm-shell](https://github.com/llmrb/llm-shell)
-> project is built with llm.rb and its demos have been
-> included to provide a better idea of what llm.rb
-> is capable of.
+| Feature / Provider                  | OpenAI | Anthropic | Gemini | DeepSeek | xAI (Grok) | Ollama | LlamaCpp |
+|--------------------------------------|:------:|:---------:|:------:|:--------:|:----------:|:------:|:--------:|
+| **Chat Completions**                 | ✅     | ✅        | ✅     | ✅       | ✅         | ✅     | ✅       |
+| **Streaming**                        | ✅     | ✅        | ✅     | ✅       | ✅         | ✅     | ✅       |
+| **Tool Calling**                     | ✅     | ✅        | ✅     | ✅       | ✅         | ✅     | ✅       |
+| **JSON Schema / Structured Output**  | ✅     | ❌        | ✅     | ❌       | ✅         | ✅*    | ✅*      |
+| **Audio (TTS / Transcribe / Translate)** | ✅  | ❌        | ✅     | ❌       | ❌         | ❌     | ❌       |
+| **Image Generation & Editing**       | ✅     | ❌        | ✅     | ❌       | ✅         | ❌     | ❌       |
+| **File Uploads**                     | ✅     | ❌        | ✅     | ❌       | ❌         | ❌     | ❌       |
+| **Multimodal Prompts** *(text+image)* | ✅     | ✅        | ✅     | ✅       | ✅         | ✅     | ✅       |
+| **Embeddings**                       | ✅     | ✅        | ✅     | ✅       | ❌         | ✅     | ✅       |
+| **Models API**                       g| ✅     | ✅        | ✅     | ✅       | ✅         | ✅     | ✅       |
+| **Local Model Support**              | ❌     | ❌        | ❌     | ❌       | ❌         | ✅     | ✅       |
+| **Vector Stores (RAG)**               | ✅     | ❌        | ❌     | ❌       | ❌         | ❌     | ❌       |
+| **Responses**                        | ✅     | ❌        | ❌     | ❌       | ❌         | ❌     | ❌       |
+| **Moderations**                      | ✅     | ❌        | ❌     | ❌       | ❌         | ❌     | ❌       |
 
-<details>
-  <summary><b>1. An introduction to tool calls</b></summary>
-  <img src="https://github.com/llmrb/llm/raw/main/share/llm-shell/examples/toolcalls_v2.gif">
-</details>
+\* JSON Schema support in Ollama/LlamaCpp depends on the model, not the API.
 
-<details>
-  <summary><b>2. Add files as conversation context</b></summary>
-  <img src="https://github.com/llmrb/llm/raw/main/share/llm-shell/examples/files-runtime_v2.gif">
-</details>
 
 ## Examples
 
@@ -66,8 +78,8 @@ require "llm"
 llm = LLM.openai(key: "yourapikey")
 llm = LLM.gemini(key: "yourapikey")
 llm = LLM.anthropic(key: "yourapikey")
+llm = LLM.xai(key: "yourapikey")
 llm = LLM.deepseek(key: "yourapikey")
-llm = LLM.voyageai(key: "yourapikey")
 
 ##
 # local providers
@@ -86,12 +98,11 @@ llm = LLM.llamacpp(key: nil)
 
 The following example creates an instance of
 [LLM::Bot](https://0x1eef.github.io/x/llm.rb/LLM/Bot.html)
-by entering into a conversation where messages are buffered and
-sent to the provider on-demand. This is the default behavior
-because it can reduce the number of requests sent to a provider,
-and avoids unneccessary requests until an attempt to iterate over
+and enters into a conversation where messages are buffered and
+sent to the provider on-demand. The implementation is designed to
+buffer messages by waiting until an attempt to iterate over
 [LLM::Bot#messages](https://0x1eef.github.io/x/llm.rb/LLM/Bot.html#messages-instance_method)
-is made:
+is made before sending a request to the LLM:
 
 ```ruby
 #!/usr/bin/env ruby
@@ -99,11 +110,12 @@ require "llm"
 
 llm  = LLM.openai(key: ENV["KEY"])
 bot  = LLM::Bot.new(llm)
+url  = "https://upload.wikimedia.org/wikipedia/commons/thumb/9/9a/Cognac_glass.jpg/500px-Cognac_glass.jpg"
 msgs = bot.chat do |prompt|
-  prompt.system File.read("./share/llm/prompts/system.txt")
-  prompt.user "Tell me the answer to 5 + 15"
-  prompt.user "Tell me the answer to (5 + 15) * 2"
-  prompt.user "Tell me the answer to ((5 + 15) * 2) / 10"
+  prompt.system "Your task is to answer all user queries"
+  prompt.user ["Tell me about this URL", URI(url)]
+  prompt.user ["Tell me about this pdf", File.open("spec/fixtures/documents/freebsd.sysctl.pdf", "rb")]
+  prompt.user "Is the URL and PDF similar to each other?"
 end
 
 # At this point, we execute a single request
@@ -118,15 +130,11 @@ msgs.each { print "[#{_1.role}] ", _1.content, "\n" }
 > [docs/](docs/STREAMING.md#scopes) for more details.
 
 The following example streams the messages in a conversation
-as they are generated in real-time. This feature can be useful
-when you want to stream a conversation in real time, or when you
-want to avoid potential read timeouts during the generation of a
-response.
-
-The `stream` option can be set to an IO object, or the value `true`
-to enable streaming &ndash; and at the end of the request, `bot.chat`
-returns the same response as the non-streaming version which allows
-you to process a response in the same way:
+as they are generated in real-time. The `stream` option can
+be set to an IO object, or the value `true` to enable streaming
+&ndash; and at the end of the request, `bot.chat` returns the
+same response as the non-streaming version which allows you
+to process a response in the same way:
 
 ```ruby
 #!/usr/bin/env ruby
@@ -134,11 +142,12 @@ require "llm"
 
 llm = LLM.openai(key: ENV["KEY"])
 bot = LLM::Bot.new(llm)
+url = "https://upload.wikimedia.org/wikipedia/commons/thumb/9/9a/Cognac_glass.jpg/500px-Cognac_glass.jpg"
 bot.chat(stream: $stdout) do |prompt|
-  prompt.system "You are my math assistant."
-  prompt.user "Tell me the answer to 5 + 15"
-  prompt.user "Tell me the answer to (5 + 15) * 2"
-  prompt.user "Tell me the answer to ((5 + 15) * 2) / 10"
+  prompt.system "Your task is to answer all user queries"
+  prompt.user ["Tell me about this URL", URI(url)]
+  prompt.user ["Tell me about this pdf", File.open("spec/fixtures/documents/freebsd.sysctl.pdf", "rb")]
+  prompt.user "Is the URL and PDF similar to each other?"
 end.to_a
 ```
 
@@ -158,7 +167,7 @@ require "llm"
 ##
 # Objects
 llm = LLM.openai(key: ENV["KEY"])
-schema = llm.schema.object(answer: llm.schema.integer.required)
+schema = llm.schema.object(probability: llm.schema.integer.required)
 bot = LLM::Bot.new(llm, schema:)
 bot.chat "Does the earth orbit the sun?", role: :user
 bot.messages.find(&:assistant?).content! # => {probability: 1}
@@ -197,11 +206,7 @@ The
 method returns an array of functions that can be called after sending a message and
 it will only be populated if the LLM detects a function should be called. Each function
 corresponds to an element in the "tools" array. The array is emptied after a function call,
-and potentially repopulated on the next message.
-
-The following example defines an agent that can run system commands based on natural language,
-and it is only intended to be a fun demo of tool calling - it is not recommended to run
-arbitrary commands from a LLM without sanitizing the input first :) Without further ado:
+and potentially repopulated on the next message:
 
 ```ruby
 #!/usr/bin/env ruby
@@ -213,10 +218,10 @@ tool = LLM.function(:system) do |fn|
   fn.params do |schema|
     schema.object(command: schema.string.required)
   end
-  fn.define do |params|
+  fn.define do |command:|
     ro, wo = IO.pipe
     re, we = IO.pipe
-    Process.wait Process.spawn(params.command, out: wo, err: we)
+    Process.wait Process.spawn(command, out: wo, err: we)
     [wo,we].each(&:close)
     {stderr: re.read, stdout: ro.read}
   end
@@ -236,6 +241,60 @@ bot.chat bot.functions.map(&:call) # report return value to the LLM
 # {stderr: "", stdout: "FreeBSD"}
 ```
 
+### Files
+
+#### Create
+
+The OpenAI and Gemini providers provide a Files API where a client can upload files
+that can be referenced from a prompt, and with other APIs as well. The following
+example uses the OpenAI provider to describe the contents of a PDF file after
+it has been uploaded. The file (a specialized instance of
+[LLM::Response](https://0x1eef.github.io/x/llm.rb/LLM/Response.html)
+) is given as part of a prompt that is understood by llm.rb:
+
+```ruby
+#!/usr/bin/env ruby
+require "llm"
+
+llm = LLM.openai(key: ENV["KEY"])
+bot = LLM::Bot.new(llm)
+file = llm.files.create(file: "/books/goodread.pdf")
+bot.chat(["Tell me about this file", file])
+bot.messages.select(&:assistant?).each { print "[#{_1.role}] ", _1.content, "\n" }
+```
+
+### Prompts
+
+#### Multimodal
+
+It is generally a given that an LLM will understand text but they can also
+understand and generate other types of media as well: audio, images, video,
+and even URLs. The object given as a prompt in llm.rb can be a string to
+represent text, a URI object to represent a URL, an LLM::Response object
+to represent a file stored with the LLM, and so on. These are objects you
+can throw at the prompt and have them be understood automatically.
+
+A prompt can also have multiple parts, and in that case, an array is given
+as a prompt. Each element is considered to be part of the prompt:
+
+```ruby
+#!/usr/bin/env ruby
+require "llm"
+
+llm = LLM.openai(key: ENV["KEY"])
+bot = LLM::Bot.new(llm)
+
+bot.chat ["Tell me about this URL", URI("https://example.com/path/to/image.png")]
+[bot.messages.find(&:assistant?)].each { print "[#{_1.role}] ", _1.content, "\n" }
+
+file = llm.files.create(file: "/books/goodread.pdf")
+bot.chat ["Tell me about this PDF", file]
+[bot.messages.find(&:assistant?)].each { print "[#{_1.role}] ", _1.content, "\n" }
+
+bot.chat ["Tell me about this image", File.open("/images/nemothefish.png", "r")]
+[bot.messages.find(&:assistant?)].each { print "[#{_1.role}] ", _1.content, "\n" }
+```
+
 ### Audio
 
 #### Speech
@@ -363,71 +422,6 @@ res.urls.each.with_index do |url, index|
 end
 ```
 
-### Files
-
-#### Create
-
-Most LLM providers provide a Files API where you can upload files
-that can be referenced from a prompt and llm.rb has first-class support
-for this feature. The following example uses the OpenAI provider to describe
-the contents of a PDF file after it has been uploaded. The file (an instance
-of [LLM::Response::File](https://0x1eef.github.io/x/llm.rb/LLM/Response/File.html))
-is passed directly to the chat method, and generally any object a prompt supports
-can be given to the chat method:
-
-
-```ruby
-#!/usr/bin/env ruby
-require "llm"
-
-llm = LLM.openai(key: ENV["KEY"])
-bot = LLM::Bot.new(llm)
-file = llm.files.create(file: "/documents/openbsd_is_awesome.pdf")
-bot.chat(file)
-bot.chat("What is this file about?")
-bot.messages.select(&:assistant?).each { print "[#{_1.role}] ", _1.content, "\n" }
-
-##
-# [assistant] This file is about OpenBSD, a free and open-source Unix-like operating system
-#             based on the Berkeley Software Distribution (BSD). It is known for its
-#             emphasis on security, code correctness, and code simplicity. The file
-#             contains information about the features, installation, and usage of OpenBSD.
-```
-
-### Prompts
-
-#### Multimodal
-
-Generally all providers accept text prompts but some providers can
-also understand URLs, and various file types (eg images, audio, video,
-etc). The llm.rb approach to multimodal prompts is to let you pass `URI`
-objects to describe links, `LLM::File` | `LLM::Response::File` objects
-to describe files, `String` objects to describe text blobs, or an array
-of the aforementioned objects to describe multiple objects in a single
-prompt. Each object is a first class citizen that can be passed directly
-to a prompt:
-
-```ruby
-#!/usr/bin/env ruby
-require "llm"
-
-llm = LLM.openai(key: ENV["KEY"])
-bot = LLM::Bot.new(llm)
-
-bot.chat [URI("https://example.com/path/to/image.png"), "Describe the image in the link"]
-bot.messages.select(&:assistant?).each { print "[#{_1.role}] ", _1.content, "\n" }
-
-file = llm.files.create(file: "/documents/openbsd_is_awesome.pdf")
-bot.chat [file, "What is this file about?"]
-bot.messages.select(&:assistant?).each { print "[#{_1.role}] ", _1.content, "\n" }
-
-bot.chat [LLM.File("/images/puffy.png"), "What is this image about?"]
-bot.messages.select(&:assistant?).each { print "[#{_1.role}] ", _1.content, "\n" }
-
-bot.chat [LLM.File("/images/beastie.png"), "What is this image about?"]
-bot.messages.select(&:assistant?).each { print "[#{_1.role}] ", _1.content, "\n" }
-```
-
 ### Embeddings
 
 #### Text
@@ -453,7 +447,7 @@ print res.embeddings.size, "\n"
 print res.embeddings[0].size, "\n"
 
 ##
-# LLM::Response::Embedding
+# LLM::Response
 # 3
 # 1536
 ```
@@ -499,8 +493,15 @@ over or doesn't cover at all. The API reference is available at
 
 ### Guides
 
-The [docs/](docs/) directory contains some additional documentation that
-didn't quite make it into the README.
+* [An introduction to RAG with llm.rb](https://0x1eef.github.io/posts/an-introduction-to-rag-with-llm.rb/) &ndash;
+  a blog post that implements the RAG pattern in 32 lines of Ruby code
+* [docs/](docs/) &ndash; the docs directory contains additional guides
+
+
+## See also
+
+* [llm-shell](https://github.com/llmrb/llm-shell) &ndash; a shell that uses llm.rb to
+  provide a command-line interface to LLMs.
 
 ## Install
 

data/lib/llm/bot/builder.rb

@@ -9,7 +9,7 @@ class LLM::Bot
     ##
     # @param [String] prompt The prompt
     # @param [Hash] params
-    # @return [LLM::Response::Respond]
+    # @return [LLM::Response]
     def create_response!(prompt, params)
       @provider.responses.create(
         prompt,
@@ -20,7 +20,7 @@ class LLM::Bot
     ##
     # @param [String] prompt The prompt
     # @param [Hash] params
-    # @return [LLM::Response::Completion]
+    # @return [LLM::Response]
     def create_completion!(prompt, params)
       @provider.complete(
         prompt,

data/lib/llm/bot.rb

@@ -2,36 +2,27 @@
 
 module LLM
   ##
-  # {LLM::Bot LLM::Bot} provides a bot object that can maintain a
-  # a conversation. A conversation can use the chat completions API
-  # that all LLM providers support or the responses API that a select
-  # few LLM providers support.
+  # {LLM::Bot LLM::Bot} provides an object that can maintain a
+  # conversation. A conversation can use the chat completions API
+  # that all LLM providers support or the responses API that currently
+  # only OpenAI supports.
   #
-  # @example example #1
+  # @example
   #   #!/usr/bin/env ruby
   #   require "llm"
   #
-  #   llm  = LLM.openai(ENV["KEY"])
+  #   llm  = LLM.openai(key: ENV["KEY"])
   #   bot  = LLM::Bot.new(llm)
+  #   url  = "https://upload.wikimedia.org/wikipedia/commons/thumb/9/9a/Cognac_glass.jpg/500px-Cognac_glass.jpg"
   #   msgs = bot.chat do |prompt|
-  #     prompt.system "Answer the following questions."
-  #     prompt.user "What is 5 + 7 ?"
-  #     prompt.user "Why is the sky blue ?"
-  #     prompt.user "Why did the chicken cross the road ?"
+  #     prompt.system "Your task is to answer all user queries"
+  #     prompt.user ["Tell me about this URL", URI(url)]
+  #     prompt.user ["Tell me about this pdf", File.open("freebsd_book.pdf", "rb")]
+  #     prompt.user "Is the URL and PDF similar to each other?"
   #   end
-  #   msgs.each { print "[#{_1.role}]", _1.content, "\n" }
   #
-  # @example example #2
-  #   #!/usr/bin/env ruby
-  #   require "llm"
-  #
-  #   llm = LLM.openai(ENV["KEY"])
-  #   bot = LLM::Bot.new(llm)
-  #   bot.chat "Answer the following questions.", role: :system
-  #   bot.chat "What is 5 + 7 ?", role: :user
-  #   bot.chat "Why is the sky blue ?", role: :user
-  #   bot.chat "Why did the chicken cross the road ?", role: :user
-  #   bot.messages.each { print "[#{_1.role}]", _1.content, "\n" }
+  #   # At this point, we execute a single request
+  #   msgs.each { print "[#{_1.role}] ", _1.content, "\n" }
   class Bot
     require_relative "bot/prompt/completion"
     require_relative "bot/prompt/respond"

data/lib/llm/buffer.rb

@@ -47,6 +47,13 @@ module LLM
       reverse_each.find(...)
     end
 
+    ##
+    # Returns the last message in the buffer
+    # @return [LLM::Message, nil]
+    def last
+      to_a[-1]
+    end
+
     ##
     # @param [[LLM::Message, Hash]] item
     #  A message and its parameters

data/lib/llm/file.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
 ##
-# The {LLM::File LLM::File} class represents a local file. It can
-# be used as a prompt with certain providers (eg: Ollama, Gemini),
-# and as an input with certain methods
+# {LLM::File LLM::File} represents a local file. It can be used
+# as a prompt with certain providers (eg: Ollama, Gemini),
+# and as an input with certain methods. It is usually not necessary
+# to create an instance of LLM::File directly.
 class LLM::File
   ##
   # @return [String]
@@ -29,12 +30,19 @@ class LLM::File
   end
 
   ##
-  # @return [String]
+  # @return [Boolean]
   #  Returns true if the file is an image
   def image?
     mime_type.start_with?("image/")
   end
 
+  ##
+  # @return [Boolean]
+  #  Returns true if the file is a PDF document
+  def pdf?
+    mime_type == "application/pdf"
+  end
+
   ##
   # @return [Integer]
   #  Returns the size of the file in bytes
@@ -68,14 +76,16 @@ class LLM::File
 end
 
 ##
-# @param [String] path
-#  The path to a file
+# @param [String, File, LLM::Response] obj
+#  The path to the file, or an existing file reference
 # @return [LLM::File]
-def LLM.File(path)
-  case path
-  when LLM::File, LLM::Response::File
-    path
-  else
-    LLM::File.new(path)
+def LLM.File(obj)
+  case obj
+  when File
+    obj.close unless obj.closed?
+    LLM.File(obj.path)
+  when LLM::File, LLM::Response then obj
+  when String then LLM::File.new(obj)
+  else raise TypeError, "don't know how to handle #{obj.class} objects"
   end
 end

data/lib/llm/function.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 ##
-# The {LLM::Function LLM::Function} class represents a
-# local function that can be called by an LLM.
+# The {LLM::Function LLM::Function} class represents a local
+# function that can be called by an LLM.
 #
 # @example example #1
 #   LLM.function(:system) do |fn|
@@ -10,15 +10,15 @@
 #     fn.params do |schema|
 #       schema.object(command: schema.string.required)
 #     end
-#     fn.define do |params|
-#       {success: Kernel.system(params.command)}
+#     fn.define do |command:|
+#       {success: Kernel.system(command)}
 #     end
 #   end
 #
 # @example example #2
 #   class System
-#     def call(params)
-#       {success: Kernel.system(params.command)}
+#     def call(command:)
+#       {success: Kernel.system(command)}
 #     end
 #   end
 #
@@ -91,7 +91,8 @@ class LLM::Function
   # Call the function
   # @return [LLM::Function::Return] The result of the function call
   def call
-    Return.new id, (Class === @runner) ? @runner.new.call(arguments) : @runner.call(arguments)
+    runner = ((Class === @runner) ? @runner.new : @runner)
+    Return.new(id, runner.call(**arguments))
   ensure
     @called = true
   end

data/lib/llm/message.rb

@@ -109,6 +109,14 @@ module LLM
       tool_calls.any?
     end
 
+    ##
+    # @return [Boolean]
+    #  Returns true when the message represents a function return
+    def tool_return?
+      LLM::Function::Return === content ||
+        [*content].grep(LLM::Function::Return).any?
+    end
+
     ##
     # Returns a string representation of the message
     # @return [String]

data/lib/llm/multipart.rb

@@ -4,7 +4,6 @@
 ##
 # @private
 class LLM::Multipart
-  require "llm"
   require "securerandom"
 
   ##

data/lib/llm/object/kernel.rb

@@ -12,6 +12,10 @@ class LLM::Object
       ::Kernel.instance_method(:instance_of?).bind(self).call(...)
     end
 
+    def extend(...)
+      ::Kernel.instance_method(:extend).bind(self).call(...)
+    end
+
     def method(...)
       ::Kernel.instance_method(:method).bind(self).call(...)
     end
@@ -41,5 +45,9 @@ class LLM::Object
       "#<#{self.class}:0x#{object_id.to_s(16)} properties=#{to_h.inspect}>"
     end
     alias_method :to_s, :inspect
+
+    def pretty_print(q)
+      q.text(inspect)
+    end
   end
 end

data/lib/llm/object.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 ##
-# The {LLM::Object LLM::Object} class encapsulates a Hash object, and it
-# allows a consumer to get and set Hash keys via regular methods. It is
+# The {LLM::Object LLM::Object} class encapsulates a Hash object. It is
 # similar in spirit to OpenStruct, and it was introduced after OpenStruct
-# became a bundled gem (and not a default gem) in Ruby 3.5.
+# became a bundled gem rather than a default gem in Ruby 3.5.
 class LLM::Object < BasicObject
   require_relative "object/builder"
   require_relative "object/kernel"
@@ -62,6 +61,13 @@ class LLM::Object < BasicObject
   def to_h
     @h
   end
+  alias_method :to_hash, :to_h
+
+  ##
+  # @return [Object, nil]
+  def dig(...)
+    to_h.dig(...)
+  end
 
   private