llm.rb 11.2.0 → 11.3.1

data/README.md

@@ -1,52 +1,58 @@
 <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.2.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.
+
+Ruby's capable AI runtime.
+
+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.
+
+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
 
-llm.rb is Ruby's most capable AI runtime.
+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.
 
-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.
+#### matz - the mruby expert
 
-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).
+> ssh matz@r.uby.dev
 
-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.
+See [https://r.uby.dev/matz](https://r.uby.dev/matz) for more information.
+
+#### robert - the freebsd expert
+
+> ssh robert@4.4bsd.dev
+
+See [https://4.4bsd.dev/robert](https://4.4bsd.dev/robert) for more information.
 
 ## Quick start
 
 #### 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
@@ -60,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
@@ -84,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"
@@ -110,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:
 
@@ -122,7 +128,7 @@ class ReadFile < LLM::Tool
   required %i[path]
 
   def call(path:)
-    {contents: File.read(path)}
+    { contents: File.read(path) }
   end
 end
 ```
@@ -130,18 +136,18 @@ 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::Context](https://0x1eef.github.io/x/llm.rb/LLM/Context.html)
-uses the same tool loop as local tools. For **stdio**, `mcp.session`
-is the preferred pattern because it keeps one MCP session alive across
-discovery and tool calls:
+[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:
 
 ```ruby
 require "llm"
@@ -150,9 +156,8 @@ llm = LLM.openai(key: ENV["KEY"])
 mcp = LLM::MCP.stdio(argv: ["ruby", "server.rb"])
 
 mcp.session do
-  ctx = LLM::Context.new(llm, stream: $stdout, tools: mcp.tools)
-  ctx.talk "Use the available tools to inspect the environment."
-  ctx.talk(ctx.wait(:call)) while ctx.functions?
+  agent = LLM::Agent.new(llm, stream: $stdout, tools: mcp.tools)
+  agent.talk "Use the available tools to inspect the environment."
 end
 ```
 
@@ -167,16 +172,15 @@ require "llm"
 llm = LLM.openai(key: ENV["KEY"])
 mcp = LLM::MCP.stdio(argv: ["ruby", "server.rb"])
 
-ctx = LLM::Context.new(llm, tools: mcp.tools)
-ctx.talk("Use the available tools to inspect the environment.")
-ctx.talk(ctx.wait(:call)) while ctx.functions?
+agent = LLM::Agent.new(llm, tools: mcp.tools)
+agent.talk("Use the available tools to inspect the environment.")
 ```
 
 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
@@ -188,21 +192,20 @@ mcp = LLM::MCP.http(
   transport: :net_http_persistent
 )
 
-ctx = LLM::Context.new(llm, tools: mcp.tools)
-ctx.talk("Use the available tools to inspect the environment.")
-ctx.talk(ctx.wait(:call)) while ctx.functions?
+agent = LLM::Agent.new(llm, tools: mcp.tools)
+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:
 
@@ -211,12 +214,11 @@ 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"])
-ctx = LLM::Context.new(llm, tools: a2a.skills)
-ctx.talk "Analyze this CSV and summarize the trends."
-ctx.talk(ctx.wait(:call)) while ctx.functions?
+agent = LLM::Agent.new(llm, tools: a2a.skills)
+agent.talk "Analyze this CSV and summarize the trends."
 ```
 
 Use persistent HTTP connections:
@@ -232,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
 
@@ -242,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
@@ -289,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
@@ -303,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:
 
@@ -317,14 +319,14 @@ class Stream < LLM::Stream
 end
 
 llm = LLM.openai(key: ENV["KEY"])
-ctx = LLM::Context.new(llm, stream: Stream.new)
-ctx.talk "Write a haiku about Ruby."
+agent = LLM::Agent.new(llm, stream: Stream.new)
+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`:
@@ -354,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:
@@ -375,46 +377,47 @@ agent.talk "Read README.md and CHANGELOG.md and compare them."
 
 #### Serialization
 
-The [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.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 this feature:
+ActiveRecord and Sequel plugins are built on top of the same underlying
+serialization feature:
 
 ```ruby
 require "llm"
 
 llm = LLM.openai(key: ENV["KEY"])
 
-# Serialize a context
-ctx1 = LLM::Context.new(llm)
-ctx1.talk "Remember that my favorite language is Ruby"
-string = ctx1.to_json
+# Serialize an agent
+agent1 = LLM::Agent.new(llm)
+agent1.talk "Remember that my favorite language is Ruby"
+string = agent1.to_json
 
-# Restore a context (from JSON)
-ctx2 = LLM::Context.new(llm, stream: $stdout)
-ctx2.restore(string:)
-ctx2.talk "What is my favorite language?"
+# Restore an agent (from JSON)
+agent2 = LLM::Agent.new(llm, stream: $stdout)
+agent2.restore(string:)
+agent2.talk "What is my favorite language?"
 ```
 
 #### ask
 
-[`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.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
 require "llm"
 
 llm = LLM.openai(key: ENV["KEY"])
-ctx = LLM::Context.new(llm)
+agent = LLM::Agent.new(llm)
 
-puts ctx.ask("Hello world").content
-puts ctx.ask("Summarize this document.", with: "README.md").content
-ctx.ask("Stream this reply.") { $stdout << _1 }
+puts agent.ask("Hello world").content
+puts agent.ask("Summarize this document.", with: "README.md").content
+agent.ask("Stream this reply.") { $stdout << _1 }
 ```
 
 ## Installation
@@ -427,62 +430,62 @@ gem install llm.rb
 
 #### REPL
 
-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://llmrb.github.io/llm.rb/) or
+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://r.uby.dev/llm/) or
 [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
 require "llm"
 
 llm = LLM.openai(key: ENV["KEY"])
-ctx = LLM::Context.new(llm, stream: $stdout)
+agent = LLM::Agent.new(llm, stream: $stdout)
 
 loop do
   print "> "
-  ctx.talk(STDIN.gets || break)
+  agent.talk(STDIN.gets || break)
   puts
 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
-[`ctx.image_url(...)`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html#image_url-instance_method),
-[`ctx.local_file(...)`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html#local_file-instance_method),
-or [`ctx.remote_file(...)`](https://0x1eef.github.io/x/llm.rb/LLM/Context.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 `ctx.ask(..., with: path)` instead of uploading it first through a
+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
-[`ctx.local_file(...)`](https://0x1eef.github.io/x/llm.rb/LLM/Context.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
 require "llm"
 
 llm = LLM.openai(key: ENV["KEY"])
-ctx = LLM::Context.new(llm)
-puts ctx.ask("Summarize this document.", with: "README.md").content
+agent = LLM::Agent.new(llm)
+puts agent.ask("Summarize this document.", with: "README.md").content
 ```
 
 #### Context Compaction
 
-This example uses [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.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
-long-lived contexts can summarize older history and expose the lifecycle
+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
 compactor can also use its own `model:` if you want summarization to run on a
-different model from the main context. `token_threshold:` accepts either a
+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
@@ -499,7 +502,7 @@ class Stream < LLM::Stream
 end
 
 llm = LLM.openai(key: ENV["KEY"])
-ctx = LLM::Context.new(
+agent = LLM::Agent.new(
   llm,
   stream: Stream.new,
   compactor: {
@@ -512,15 +515,14 @@ ctx = LLM::Context.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 a
-context or agent with `mode: :responses` and keep using
-`talk` for turns.
+To use the Responses API (OpenAI-specific), initialize an agent with
+`mode: :responses` and keep using `talk` for turns.
 
 ```ruby
 require "llm"
@@ -536,21 +538,21 @@ class Stream < LLM::Stream
 end
 
 llm = LLM.openai(key: ENV["KEY"])
-ctx = LLM::Context.new(
+agent = LLM::Agent.new(
   llm,
   model: "gpt-5.4-mini",
   mode: :responses,
-  reasoning: {effort: "medium"},
+  reasoning: { effort: "medium" },
   stream: Stream.new
 )
-ctx.talk("Solve 17 * 19 and show your work.")
+agent.talk("Solve 17 * 19 and show your work.")
 ```
 
 #### Request Cancellation
 
 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://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
@@ -558,27 +560,27 @@ require "llm"
 require "io/console"
 
 llm = LLM.openai(key: ENV["KEY"])
-ctx = LLM::Context.new(llm, stream: $stdout)
+agent = LLM::Agent.new(llm, stream: $stdout)
 worker = Thread.new do
-  ctx.talk("Write a very long essay about network protocols.")
+  agent.talk("Write a very long essay about network protocols.")
 rescue LLM::Interrupt
   puts "Request was interrupted!"
 end
 
 STDIN.getch
-ctx.interrupt!
+agent.interrupt!
 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
@@ -597,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
 
@@ -608,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
@@ -632,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
 
@@ -659,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
@@ -693,7 +695,7 @@ class Ticket < ApplicationRecord
   end
 
   def set_context
-    {mode: :responses, store: false}
+    { mode: :responses, store: false }
   end
 end
 
@@ -718,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::Context` tool path as local tools. It expects a GitHub token in
+`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
@@ -739,23 +741,14 @@ 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
 )
 
-ctx = LLM::Context.new(llm, stream: $stdout, tools: mcp.tools)
-ctx.talk("Pull information about my GitHub account.")
-ctx.talk(ctx.wait(:call)) while ctx.functions?
+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)