llm.rb 11.3.0 → 11.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 314712380b36e57b1492cef3850f5c4c2397522b74d3cc913fc0d09a796d8973
-  data.tar.gz: aefda31d90067a0a49ada778c6658243595b6698cc11ecf342a11e26f69ad93b
+  metadata.gz: e3aad41c57654e1abef4c184da8904ae5840708e8f5ce937e1030279a5e5a240
+  data.tar.gz: 9b03ac6a4f04190a57f2e4698eab923087febbab6a1ff8ad67f391fce4bd5c1e
 SHA512:
-  metadata.gz: 3a998015696027d232e0865c60ff840d11155206b705443035f6af7dcbb18f52d0e82b019cc82379a7ca919b60e3e50bf4156c8c4388beb8ba47a5d57775354a
-  data.tar.gz: 83faf786980a3307a760aec9698e29129dd34f8a838fa8f596caa60498f029bf3b5b4ac9400dd662c70a67a8c1eb748266d89b777773c8185025c8b8c86754bd
+  metadata.gz: f429a75d5b612eb27968b6e6451bd231f2191b5b955262503c68baa7ca27f289c01ad564558e82d7fcc732393f635c32caf883a36815b41d86f6c1289cfffb61
+  data.tar.gz: 90924b997b5d47d74c3df6e303c890fb5d1a771bae10e63c349436bcbd061241604184f62df87cb2dee7d85405fbd53f08d279ef6b4d3a85a12b0d59b7377229

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## Unreleased
 
+## v11.3.1
+
+Changes since `v11.3.0`.
+
+This release rebrands the project under the r.uby.dev umbrella, removes
+the Jekyll-based docs site in favor of a pure-markdown deepdive, and
+cleans up YARD documentation across the codebase.
+
+### Change
+
+* **Rebrand to r.uby.dev** <br>
+  Update README.md with the new logo, streamlined copy, and r.uby.dev
+  URLs. Rewrite `resources/deepdive.md` as a concise walkthrough and
+  bundle it with the gem. Remove the `docs/` directory (Jekyll site).
+  Update all references from `llmrb.github.io` to `r.uby.dev`.
+
+* **Update gemspec** <br>
+  Update homepage, metadata URLs, email, and author list. Switch the
+  YARD markdown processor from kramdown to redcarpet.
+
+### Fix
+
+* **Fix YARD documentation** <br>
+  Fix unnamed, misnamed, and missing `@param` tags across provider
+  adapters, transport classes, stream, tool, schema, registry, agent,
+  and ActiveRecord integration files. Fix backtick-wrapped constant
+  references and other YARD formatting issues.
+
 ## v11.3.0
 
 Changes since `v11.2.0`.

data/README.md

@@ -1,44 +1,33 @@
 <p align="center">
-  <a href="https://github.com/llmrb/llm.rb">
-    <img src="https://github.com/llmrb/llm.rb/raw/main/llm.png" width="200" height="200" border="0" alt="llm.rb">
-  </a>
-</p>
-<p align="center">
-  <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.3.0-green.svg?" alt="Version">
+  <a href="https://r.uby.dev">
+    <img
+      src="https://github.com/r-uby-dev/llm.rb/raw/main/rubydev.svg"
+      width="400"
+      height="200"
+      border="0"
+      alt="a r.uby.dev project"
+     >
   </a>
 </p>
 
-## About
+> A [r.uby.dev](https://r.uby.dev) project.
 
-llm.rb is Ruby's most capable AI runtime.
+Ruby's capable AI runtime.
 
-It runs on Ruby's standard library by default. loads optional pieces
-only when needed, and offers a single runtime for providers, agents,
-tools, skills, MCP, A2A (Agent2Agent), RAG (vector stores & embeddings),
-streaming, files, and persisted state.
+It provides one Ruby interface for building with large language models:
+providers, agents, tools, skills, MCP, A2A, RAG, streaming, files, and                 persisted conversation state all share the same runtime.
 
-It supports OpenAI, OpenAI-compatible endpoints, Anthropic, Google
-Gemini, DeepSeek, xAI, Z.ai, AWS Bedrock, Ollama, and llama.cpp. It
-also includes built-in ActiveRecord and Sequel support, plus concurrent
-tool execution through threads, tasks (via async gem), fibers, ractors,
-and fork (via xchan.rb gem).
+The gem runs on Ruby's standard library by default and loads optional
+integrations only when needed. It supports OpenAI, OpenAI-compatible
+endpoints, Anthropic, Google Gemini, DeepSeek, xAI, Z.ai, AWS Bedrock,
+Ollama, and llama.cpp, with built-in ActiveRecord and Sequel support.
 
 ## Services
 
-The llm.rb runtime and its forks
-([mruby-llm](https://github.com/llmrb/mruby-llm),
-[wasm-llm](https://github.com/llmrb/wasm-llm))
-power a growing family of AI applications, and
-services. The following applications are publicly
-accessible over SSH and are free to try. No account
-required. Nothing to install.
+llm.rb is a [r.uby.dev](https://r.uby.dev) project
+that is part of a growing family of AI-related
+projects that also includes publically accessible
+SSH services.
 
 #### matz - the mruby expert
 
@@ -57,13 +46,13 @@ See [https://4.4bsd.dev/robert](https://4.4bsd.dev/robert) for more information.
 #### LLM::Context
 
 The
-[LLM::Context](https://0x1eef.github.io/x/llm.rb/LLM/Context.html)
+[LLM::Context](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html)
 object is at the heart of the runtime. Almost all other features build
 on top of it. It is a low-level interface to a model, and requires tool
 execution to be managed manually. The
-[LLM::Agent](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html)
+[LLM::Agent](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html)
 class is almost the same as
-[LLM::Context](https://0x1eef.github.io/x/llm.rb/LLM/Context.html)
+[LLM::Context](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html)
 but it manages tool execution for you - we'll cover agents next:
 
 ```ruby
@@ -77,9 +66,9 @@ ctx.talk "Hello world"
 #### LLM::Agent
 
 The
-[LLM::Agent](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html)
+[LLM::Agent](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html)
 object is implemented on top of
-[LLM::Context](https://0x1eef.github.io/x/llm.rb/LLM/Context.html).
+[LLM::Context](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html).
 It provides the same interface, but manages tool execution for you. It
 also has builtin features such as a loop guard that detects repeated
 tool call patterns, and another guard that detects infinite tool call
@@ -101,7 +90,7 @@ executed. When a matching tool is called, llm.rb runs
 `on_tool_confirmation`. That callback must decide whether to cancel the
 tool call or approve it and execute it by calling
 `fn.spawn(strategy).wait`, and it must always return an instance of
-[`LLM::Function::Return`](https://0x1eef.github.io/x/llm.rb/LLM/Function/Return.html):
+[`LLM::Function::Return`](https://r.uby.dev/api-docs/llm.rb/LLM/Function/Return.html):
 
 ```ruby
 require "llm"
@@ -127,7 +116,7 @@ Agent.new(llm, stream: $stdout).talk("Delete /tmp/example.txt.")
 #### Tools
 
 The
-[LLM::Tool](https://0x1eef.github.io/x/llm.rb/LLM/Tool.html)
+[LLM::Tool](https://r.uby.dev/api-docs/llm.rb/LLM/Tool.html)
 class can be subclassed to implement your own tools that can extend the
 abilities of a model:
 
@@ -139,7 +128,7 @@ class ReadFile < LLM::Tool
   required %i[path]
 
   def call(path:)
-    {contents: File.read(path)}
+    { contents: File.read(path) }
   end
 end
 ```
@@ -147,15 +136,15 @@ end
 #### MCP
 
 The
-[LLM::MCP](https://0x1eef.github.io/x/llm.rb/LLM/MCP.html)
+[LLM::MCP](https://r.uby.dev/api-docs/llm.rb/LLM/MCP.html)
 object lets llm.rb use tools provided by an MCP server. Those tools are
 exposed through the same runtime as local tools, so you can pass them
 to either
-[LLM::Context](https://0x1eef.github.io/x/llm.rb/LLM/Context.html)
+[LLM::Context](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html)
 or
-[LLM::Agent](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html).
+[LLM::Agent](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html).
 In this example, the MCP server runs over stdio and
-[LLM::Agent](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html)
+[LLM::Agent](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html)
 manages the tool loop. For **stdio**, `mcp.session` is the preferred
 pattern because it keeps one MCP session alive across discovery and
 tool calls:
@@ -191,7 +180,7 @@ 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)
+[LLM::Transport.net_http_persistent](https://r.uby.dev/api-docs/llm.rb/LLM/Transport.html#method-c-net_http_persistent)
 transport:
 
 ```ruby
@@ -210,13 +199,13 @@ agent.talk("Use the available tools to inspect the environment.")
 #### A2A (Agent 2 Agent)
 
 The
-[LLM::A2A](https://0x1eef.github.io/x/llm.rb/LLM/A2A.html)
+[LLM::A2A](https://r.uby.dev/api-docs/llm.rb/LLM/A2A.html)
 object lets llm.rb use skills provided by a remote A2A agent. Those
 skills are exposed through the same runtime as local tools, so you can
 pass them to either
-[LLM::Context](https://0x1eef.github.io/x/llm.rb/LLM/Context.html)
+[LLM::Context](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html)
 or
-[LLM::Agent](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html).
+[LLM::Agent](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html).
 
 Use remote skills as local tools:
 
@@ -225,7 +214,7 @@ require "llm"
 
 a2a = LLM::A2A.rest(
   url: "https://remote-agent.example.com",
-  headers: {"Authorization" => "Bearer token"}
+  headers: { "Authorization" => "Bearer token" }
 )
 llm = LLM.openai(key: ENV["KEY"])
 agent = LLM::Agent.new(llm, tools: a2a.skills)
@@ -245,7 +234,7 @@ a2a = LLM::A2A.rest(
 
 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).
+[LLM::A2A API docs](https://r.uby.dev/api-docs/llm.rb/LLM/A2A.html).
 
 #### Transports
 
@@ -255,9 +244,9 @@ 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)
+[LLM::Transport](https://r.uby.dev/api-docs/llm.rb/LLM/Transport.html)
 interface and receive transport-agnostic
-[LLM::Transport::Request](https://0x1eef.github.io/x/llm.rb/LLM/Transport/Request.html)
+[LLM::Transport::Request](https://r.uby.dev/api-docs/llm.rb/LLM/Transport/Request.html)
 objects from providers.
 
 ```ruby
@@ -302,7 +291,7 @@ 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)),
+tools (a subclass of [LLM::Tool](https://r.uby.dev/api-docs/llm.rb/LLM/Tool.html)),
 MCP tools, and A2A tools that a parent context or agent has access to:
 
 ```yaml
@@ -316,7 +305,7 @@ MCP tools, and A2A tools that a parent context or agent has access to:
 #### LLM::Stream
 
 The
-[LLM::Stream](https://0x1eef.github.io/x/llm.rb/LLM/Stream.html)
+[LLM::Stream](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html)
 object lets you observe output and runtime events as they happen. You
 can subclass it to handle streamed content in your own application:
 
@@ -337,7 +326,7 @@ agent.talk "Write a haiku about Ruby."
 #### LLM::Stream (advanced)
 
 The
-[LLM::Stream](https://0x1eef.github.io/x/llm.rb/LLM/Stream.html)
+[LLM::Stream](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html)
 object can also resolve tool calls while output is still streaming. In
 `on_tool_call`, you can spawn the tool, push the work onto the stream
 queue, and later drain it with `wait`:
@@ -367,7 +356,7 @@ ctx.talk(ctx.wait) while ctx.functions?
 llm.rb can run tool work concurrently. This is useful when a model calls
 multiple tools and you want to resolve them in parallel instead of one
 at a time. On
-[LLM::Agent](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html),
+[LLM::Agent](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html),
 you can enable this with `concurrency`. Common options are `:call` for
 sequential execution, `:thread`, or `:task` for concurrent IO-bound work, and
 `:ractor` or `:fork` for more isolated CPU-bound work:
@@ -388,7 +377,7 @@ agent.talk "Read README.md and CHANGELOG.md and compare them."
 
 #### Serialization
 
-The [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html)
+The [`LLM::Agent`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html)
 object can be serialized to JSON, which makes it suitable for storing
 in a file, a database column, or a Redis queue. The built-in
 ActiveRecord and Sequel plugins are built on top of the same underlying
@@ -412,12 +401,12 @@ agent2.talk "What is my favorite language?"
 
 #### ask
 
-[`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html)
+[`LLM::Agent`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html)
 also provides `ask`, a convenience interface that is compatible with
 RubyLLM's `ask` method. It accepts a prompt, an optional `with:`
 attachment path or paths, an optional `stream:` target, and an optional
 block that chunks are yielded to. It returns an
-[`LLM::Response`](https://0x1eef.github.io/x/llm.rb/LLM/Response.html),
+[`LLM::Response`](https://r.uby.dev/api-docs/llm.rb/LLM/Response.html),
 so use `.content` when you want the text directly:
 
 ```ruby
@@ -441,9 +430,9 @@ gem install llm.rb
 
 #### REPL
 
-This example uses [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html)
+This example uses [`LLM::Agent`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html)
 for an interactive REPL. <br> See the
-[deepdive (web)](https://llmrb.github.io/llm.rb/) or
+[deepdive (web)](https://r.uby.dev/llm/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -461,18 +450,18 @@ end
 
 #### Multimodal: Local Files
 
-In llm.rb, a prompt can be a string, an [`LLM::Prompt`](https://0x1eef.github.io/x/llm.rb/LLM/Prompt.html), or an array.
+In llm.rb, a prompt can be a string, an [`LLM::Prompt`](https://r.uby.dev/api-docs/llm.rb/LLM/Prompt.html), or an array.
 When you use an array, each element can be plain text or a tagged object such as
-[`agent.image_url(...)`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html#image_url-instance_method),
-[`agent.local_file(...)`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html#local_file-instance_method),
-or [`agent.remote_file(...)`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html#remote_file-instance_method).
+[`agent.image_url(...)`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#image_url-instance_method),
+[`agent.local_file(...)`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#local_file-instance_method),
+or [`agent.remote_file(...)`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#remote_file-instance_method).
 Those tagged objects carry the metadata the provider adapter needs to turn one
 Ruby prompt into the provider-specific multimodal request schema.
 
 If the model understands that file type, you can attach a local file directly
 with `agent.ask(..., with: path)` instead of uploading it first through a
 provider Files API. Under the hood, llm.rb tags the path as a
-[`agent.local_file(...)`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html#local_file-instance_method)
+[`agent.local_file(...)`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#local_file-instance_method)
 object:
 
 ```ruby
@@ -485,9 +474,9 @@ puts agent.ask("Summarize this document.", with: "README.md").content
 
 #### Context Compaction
 
-This example uses [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html),
-[`LLM::Compactor`](https://0x1eef.github.io/x/llm.rb/LLM/Compactor.html), and
-[`LLM::Stream`](https://0x1eef.github.io/x/llm.rb/LLM/Stream.html) together so
+This example uses [`LLM::Agent`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html),
+[`LLM::Compactor`](https://r.uby.dev/api-docs/llm.rb/LLM/Compactor.html), and
+[`LLM::Stream`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html) together so
 long-lived conversations can summarize older history and expose the lifecycle
 through stream hooks. This approach is inspired by General Intelligence
 Systems. The
@@ -496,7 +485,7 @@ different model from the main conversation. `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://llmrb.github.io/llm.rb/) or
+[deepdive (web)](https://r.uby.dev/llm/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -526,10 +515,10 @@ agent = LLM::Agent.new(
 
 #### Reasoning
 
-This example uses [`LLM::Stream`](https://0x1eef.github.io/x/llm.rb/LLM/Stream.html)
+This example uses [`LLM::Stream`](https://r.uby.dev/api-docs/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://llmrb.github.io/llm.rb/) or
+[deepdive (web)](https://r.uby.dev/llm/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 To use the Responses API (OpenAI-specific), initialize an agent with
@@ -553,7 +542,7 @@ agent = LLM::Agent.new(
   llm,
   model: "gpt-5.4-mini",
   mode: :responses,
-  reasoning: {effort: "medium"},
+  reasoning: { effort: "medium" },
   stream: Stream.new
 )
 agent.talk("Solve 17 * 19 and show your work.")
@@ -562,8 +551,8 @@ agent.talk("Solve 17 * 19 and show your work.")
 #### Request Cancellation
 
 Need to cancel a stream? llm.rb has you covered through
-[`LLM::Agent#interrupt!`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html#interrupt-21-instance_method).
-<br> See the [deepdive (web)](https://llmrb.github.io/llm.rb/)
+[`LLM::Agent#interrupt!`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#interrupt-21-instance_method).
+<br> See the [deepdive (web)](https://r.uby.dev/llm/)
 or [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -586,12 +575,12 @@ worker.join
 #### Sequel (ORM)
 
 The `plugin :llm` integration wraps
-[`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html) on a
+[`LLM::Context`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html) on a
 `Sequel::Model` and keeps tool execution explicit. Like the ActiveRecord
 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://llmrb.github.io/llm.rb/) or
+[deepdive (web)](https://r.uby.dev/llm/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -610,7 +599,7 @@ class Context < Sequel::Model
   end
 
   def set_context
-    {model: "gpt-5.4-mini", mode: :responses, store: false}
+    { model: "gpt-5.4-mini", mode: :responses, store: false }
   end
 end
 
@@ -621,13 +610,13 @@ puts ctx.talk("What is my favorite language?").content
 
 #### ActiveRecord (ORM): acts_as_llm
 
-The `acts_as_llm` method wraps [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html) and
+The `acts_as_llm` method wraps [`LLM::Context`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html) and
 provides full control over tool execution. Its built-in persistence contract is
 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://llmrb.github.io/llm.rb/)
+See the [deepdive (web)](https://r.uby.dev/llm/)
 or [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -645,7 +634,7 @@ class Context < ApplicationRecord
   end
 
   def set_context
-    {model: "gpt-5.4-mini", mode: :responses, store: false}
+    { model: "gpt-5.4-mini", mode: :responses, store: false }
   end
 end
 
@@ -672,19 +661,19 @@ class Context < ApplicationRecord
   end
 
   def set_context
-    {model: model_name, mode: :responses, store: false}
+    { model: model_name, mode: :responses, store: false }
   end
 end
 ```
 
 #### ActiveRecord (ORM): acts_as_agent
 
-The `acts_as_agent` method wraps [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html) and
+The `acts_as_agent` method wraps [`LLM::Agent`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html) and
 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://llmrb.github.io/llm.rb/)
+See the [deepdive (web)](https://r.uby.dev/llm/)
 or [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -706,7 +695,7 @@ class Ticket < ApplicationRecord
   end
 
   def set_context
-    {mode: :responses, store: false}
+    { mode: :responses, store: false }
   end
 end
 
@@ -731,18 +720,18 @@ class Ticket < ApplicationRecord
   end
 
   def set_context
-    {mode: :responses, store: false}
+    { mode: :responses, store: false }
   end
 end
 ```
 
 #### MCP
 
-This example uses [`LLM::MCP`](https://0x1eef.github.io/x/llm.rb/LLM/MCP.html)
+This example uses [`LLM::MCP`](https://r.uby.dev/api-docs/llm.rb/LLM/MCP.html)
 over HTTP so remote GitHub MCP tools run through the same
 `LLM::Agent` tool path as local tools. It expects a GitHub token in
 `ENV["GITHUB_PAT"]`. See the
-[deepdive (web)](https://llmrb.github.io/llm.rb/) or
+[deepdive (web)](https://r.uby.dev/llm/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
@@ -752,7 +741,7 @@ require "net/http/persistent"
 llm = LLM.openai(key: ENV["KEY"], persistent: true)
 mcp = LLM::MCP.http(
   url: "https://api.githubcopilot.com/mcp/",
-  headers: {"Authorization" => "Bearer #{ENV["GITHUB_PAT"]}"},
+  headers: { "Authorization" => "Bearer " + ENV["GITHUB_PAT"].to_s },
   persistent: true
 )
 
@@ -760,14 +749,6 @@ agent = LLM::Agent.new(llm, stream: $stdout, tools: mcp.tools)
 agent.talk("Pull information about my GitHub account.")
 ```
 
-## Resources
-
-- [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.
-- [doc site](https://0x1eef.github.io/x/llm.rb?rebuild=1) has the API docs.
-
 ## License
 
 [BSD Zero Clause](https://choosealicense.com/licenses/0bsd/)

data/lib/llm/a2a.rb

@@ -177,7 +177,7 @@ class LLM::A2A
   ##
   # Sends a message to the agent and returns the response.
   # @param [String] text The message text to send
-  # @param [Hash] config
+  # @param [Hash] configuration
   #  Optional configuration (accepted_output_modes, return_immediately)
   # @param [Hash, nil] metadata
   #  Optional metadata to attach to the request
@@ -198,7 +198,7 @@ class LLM::A2A
   # The block is called for each {LLM::Object} event in the stream
   # (Task, Message, TaskStatusUpdateEvent, TaskArtifactUpdateEvent).
   # @param [String] text The message text to send
-  # @param [Hash] config Optional configuration
+  # @param [Hash] configuration Optional configuration
   # @yieldparam [LLM::Object] event A stream event
   # @return [void]
   def send_streaming_message(text, configuration = {}, &on_event)

data/lib/llm/active_record/acts_as_agent.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+# @!parse
+#   module ::ActiveRecord
+#     class Base
+#     end
+#   end
+
 module LLM::ActiveRecord
   ##
   # ActiveRecord integration for persisting {LLM::Agent LLM::Agent} state.
@@ -134,4 +140,5 @@ module LLM::ActiveRecord
   end
 end
 
+# @!parse ::ActiveRecord::Base.extend(LLM::ActiveRecord::ActsAsAgent)
 ::ActiveRecord::Base.extend(LLM::ActiveRecord::ActsAsAgent)

data/lib/llm/active_record/acts_as_llm.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+# @!parse
+#   module ::ActiveRecord
+#     class Base
+#     end
+#   end
+
 module LLM::ActiveRecord
   ##
   # ActiveRecord integration for persisting {LLM::Context LLM::Context} state.
@@ -222,4 +228,5 @@ module LLM::ActiveRecord
   end
 end
 
+# @!parse ::ActiveRecord::Base.extend(LLM::ActiveRecord::ActsAsLLM)
 ::ActiveRecord::Base.extend(LLM::ActiveRecord::ActsAsLLM)

data/lib/llm/agent.rb

@@ -192,7 +192,7 @@ module LLM
     end
 
     ##
-    # @param [LLM::Provider] provider
+    # @param [LLM::Provider] llm
     #  A provider
     # @param [Hash] params
     #  The parameters to maintain throughout the conversation.

data/lib/llm/cost.rb

@@ -37,7 +37,7 @@ class LLM::Cost < Struct.new(
 )
   ##
   # Build a cost breakdown from token usage and model pricing.
-  # @param [LLM::Context]
+  # @param [LLM::Context] ctx
   #  Context used to resolve provider, model, and token usage
   # @return [LLM::Cost]
   def self.from(ctx)

data/lib/llm/function/fiber_group.rb

@@ -3,7 +3,7 @@
 class LLM::Function
   ##
   # The {LLM::Function::FiberGroup} class wraps an array of
-  # {Fiber} objects that are running {LLM::Function} calls
+  # `Fiber` objects that are running {LLM::Function} calls
   # concurrently using scheduler-backed fibers.
   #
   # This class provides the same interface as {LLM::Function::ThreadGroup}
@@ -26,7 +26,7 @@ class LLM::Function
     # of fiber objects.
     #
     # @param [Array<Fiber>] fibers
-    #   An array of fibers, each running an {LLM::Function#spawn_fiber} call.
+    #   An array of fibers, each running an `LLM::Function#spawn_fiber` call.
     #
     # @return [LLM::Function::FiberGroup]
     #   Returns a new fiber group.

data/lib/llm/function/task_group.rb

@@ -3,7 +3,7 @@
 class LLM::Function
   ##
   # The {LLM::Function::TaskGroup} class wraps an array of
-  # {Async::Task} objects that are running {LLM::Function} calls
+  # `Async::Task` objects that are running {LLM::Function} calls
   # concurrently using the async gem.
   #
   # This class provides the same interface as {LLM::Function::ThreadGroup}
@@ -27,7 +27,7 @@ class LLM::Function
     # of async task objects.
     #
     # @param [Array<Async::Task>] tasks
-    #   An array of async tasks, each running an {LLM::Function#spawn_async} call.
+    #   An array of async tasks, each running an `LLM::Function#spawn_async` call.
     #
     # @return [LLM::Function::TaskGroup]
     #   Returns a new task group.

data/lib/llm/function/thread_group.rb

@@ -3,7 +3,7 @@
 class LLM::Function
   ##
   # The {LLM::Function::ThreadGroup} class wraps an array of
-  # {Thread} objects that are running {LLM::Function} calls
+  # `Thread` objects that are running {LLM::Function} calls
   # concurrently. It provides a single {#wait} method that
   # collects the {LLM::Function::Return} values from those
   # threads.
@@ -27,11 +27,11 @@ class LLM::Function
   class ThreadGroup
     ##
     # Creates a new {LLM::Function::ThreadGroup} from an array
-    # of {Thread} objects.
+    # of `Thread` objects.
     #
     # @param [Array<Thread>] threads
     #   An array of threads, each running an {LLM::Function#spawn}
-    #   call. The thread's {Thread#value} will be an
+    #   call. The thread's `Thread#value` will be an
     #   {LLM::Function::Return}.
     #
     # @return [LLM::Function::ThreadGroup]