llm.rb 4.20.2 → 4.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a182d595ad65c1cb2f1a796b83e48cba4f1038031ec140709e902734051a8b46
-  data.tar.gz: b8cdb2e051bc620f111a97236bd64fe7940ff9f3d5b44c9f07b115641d74abcd
+  metadata.gz: 96698cb3af793b0bd83cae7635279cefbff24f86b11f59c9209edd76f76b757c
+  data.tar.gz: 389e4372ab3b4a2e90020e6e2e838b5a36516d5a5dd82a71243975dfe6f8f959
 SHA512:
-  metadata.gz: a6fd61aaa9479ec34af93a1e732acf553a055e36a4f5e822a2c643ef2bf537923a7d0a968b40c6a8cfa9a09af8186ba31467fe627462da49389f1c6594d7ee41
-  data.tar.gz: df56a4624eca8f7007ea2054d79812df553df69d867297230c9b38368c87e67c06187dbf03195b5fcaae1b1701b82a79cd7be10ed86364a49802573367910d10
+  metadata.gz: 6bd4fa02802333bbb925db2e513913bd1669e8a4d7c85d8cb76b88399e9b0e84bfd5ddf922c7816a2afd0c0d76d6a9f8c873702c789665dfe3205ada01d34203
+  data.tar.gz: 0d579386ead2158a4e7ad4991ff0c025758ac51624947d07e5d112779d46cb36bcabdd492ac20bbabc981b3e75e25300d04ba8b86808e4825b5c66e2186e52ae

data/CHANGELOG.md

@@ -2,8 +2,78 @@
 
 ## Unreleased
 
+Changes since `v4.22.0`.
+
+## v4.22.0
+
+Changes since `v4.21.0`.
+
+This release deepens the runtime shape of llm.rb. It reduces helper-method
+surface on persisted ORM models, expands real ORM coverage, and makes skills
+behave more like bounded sub-agents with inherited recent context and proper
+instruction injection.
+
+### Change
+
+* **Reduce ActiveRecord wrapper model surface** <br>
+  Move helper methods such as option resolution, column mapping,
+  serialization, and persistence into `Utils` for the ActiveRecord
+  wrappers so wrapped models include fewer internal helper methods.
+
+* **Reduce Sequel wrapper model surface** <br>
+  Move helper methods such as option resolution, column mapping,
+  serialization, and persistence into `Utils` for the Sequel wrappers
+  so wrapped models include fewer internal helper methods.
+
+* **Expand ORM integration coverage** <br>
+  Add broader ActiveRecord and Sequel coverage for persisted context and
+  agent wrappers, including real SQLite-backed records and cassette-backed
+  OpenAI persistence paths.
+
+* **Make skills inherit recent parent context** <br>
+  Run `LLM::Skill` with a curated slice of recent parent user and assistant
+  messages, prefixed with `Recent context:`, so skills behave more like
+  task-scoped sub-agents instead of instruction-only helpers.
+
+### Fix
+
+* **Fix Sequel `plugin :agent` load order** <br>
+  Require the shared Sequel plugin support from `LLM::Sequel::Agent` so
+  `plugin :agent` can load independently without raising
+  `uninitialized constant LLM::Sequel::Plugin`.
+
+* **Make skill execution inherit parent context request settings** <br>
+  Run `LLM::Skill` through a parent `LLM::Context` instead of a bare
+  provider so nested skill agents inherit context-level settings such as
+  `mode: :responses`, `store: false`, streaming, and other request defaults,
+  while still keeping skill-local tools and avoiding parent schemas.
+
+* **Keep agent instructions when history is preseeded** <br>
+  Inject `LLM::Agent` instructions once unless a system message is already
+  present, so agents and nested skills still get their instructions when
+  they start with inherited non-system context.
+
+## v4.21.0
+
 Changes since `v4.20.2`.
 
+This release expands higher-level composition in llm.rb. It adds Sequel agent
+persistence through `plugin :agent` and introduces directory-backed skills
+that load from `SKILL.md`, resolve named tools, and plug directly into
+`LLM::Context` and `LLM::Agent`.
+
+### Change
+
+* **Add `plugin :agent` for Sequel models** <br>
+  Add Sequel support for `plugin :agent`, similar to ActiveRecord's
+  `acts_as_agent`, so models can wrap `LLM::Agent` with built-in
+  persistence.
+
+* **Load directory-backed skills through `LLM::Context` and `LLM::Agent`** <br>
+  Add `skills:` to `LLM::Context` and `skills ...` to `LLM::Agent` so
+  directories with `SKILL.md` can be loaded, resolved into tools, and run
+  through the normal llm.rb tool path.
+
 ## v4.20.2
 
 Changes since `v4.20.1`.

data/README.md

@@ -4,25 +4,26 @@
 <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-4.20.2-green.svg?" alt="Version"></a>
+  <a href="https://github.com/llmrb/llm.rb/tags"><img src="https://img.shields.io/badge/version-4.21.0-green.svg?" alt="Version"></a>
 </p>
 
 ## About
 
-llm.rb is a lightweight runtime for building capable AI systems in Ruby.
-
-It is not just an API wrapper. llm.rb gives you one runtime for providers,
-contexts, agents, tools, MCP servers, streaming, schemas, files, and persisted
-state, so real systems can be built out of one coherent execution model instead
-of a pile of adapters.
+llm.rb is the most capable runtime for building AI systems in Ruby.
+<br>
 
-It stays close to Ruby, runs on the standard library by default, loads optional
-pieces only when needed, includes built-in ActiveRecord support through
+llm.rb is designed for Ruby, and although it works great in Rails, it is not tightly
+coupled to it. It runs on the standard library by default (zero dependencies),
+loads optional pieces only when needed, includes built-in ActiveRecord support through
 `acts_as_llm` and `acts_as_agent`, includes built-in Sequel support through
-`plugin :llm`, and is designed for engineers who want control over
+`plugin :llm` and `plugin :agent`, and is designed for engineers who want control over
 long-lived, tool-capable, stateful AI workflows instead of just
 request/response helpers.
 
+It provides one runtime for providers, agents, tools, skills, MCP servers, streaming,
+schemas, files, and persisted state, so real systems can be built out of one coherent
+execution model instead of a pile of adapters.
+
 Want to see some code? Jump to [the examples](#examples) section. <br>
 Want a taste of what llm.rb can build? See [the screencast](#screencast).
 
@@ -47,6 +48,175 @@ It holds:
 Instead of switching abstractions for each feature, everything builds on the
 same context object.
 
+## Standout features
+
+The following list is **not exhaustive**, but it covers a lot of ground.
+
+#### Skills
+
+Skills are reusable, directory-backed capabilities loaded from `SKILL.md`.
+They run through the same runtime as tools, agents, and MCP. They do not
+require a second orchestration layer or a parallel abstraction. If you've
+used Claude or Codex, you know the general idea of skills, and llm.rb
+supports that same concept with the same execution model as the rest of the
+system.
+
+In llm.rb, a skill has frontmatter and instructions. The frontmatter can
+define `name`, `description`, and `tools`. The `tools` entries are tool names,
+and each name must resolve to a subclass of
+[`LLM::Tool`](https://0x1eef.github.io/x/llm.rb/LLM/Tool.html) that is already
+loaded in the runtime.
+
+If you want Claude/Codex-like skills that can drive scripts or shell
+commands, you would typically pair the skill with a tool that can execute
+system commands.
+
+```yaml
+---
+name: release
+description: Prepare a release
+tools:
+  - search_docs
+  - git
+---
+Review the release state, summarize what changed, and prepare the release.
+```
+
+```ruby
+class Agent < LLM::Agent
+  model "gpt-5.4-mini"
+  skills "./skills/release"
+end
+
+llm = LLM.openai(key: ENV["KEY"])
+Agent.new(llm, stream: $stdout).talk("Let's prepare the release!")
+```
+
+#### ORM
+
+Any ActiveRecord model or Sequel model can become an agent-capable model,
+including existing business and domain models, without forcing you into a
+separate agent table or a second persistence layer.
+
+`acts_as_agent` extends a model with agent capabilities: the same runtime
+surface as [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html),
+because it actually wraps an `LLM::Agent`, plus persistence through a text,
+JSON, or JSONB-backed column on the same table.
+
+
+```ruby
+class Ticket < ApplicationRecord
+  acts_as_agent provider: :set_provider
+  model "gpt-5.4-mini"
+  instructions "You are a support assistant."
+
+  private
+
+  def set_provider
+    { key: ENV["#{provider.upcase}_SECRET"], persistent: true }
+  end
+end
+```
+
+#### Agentic Patterns
+
+llm.rb is especially strong when you want to build agentic systems in a Ruby
+way. Agents can be ordinary application models with state, associations,
+tools, skills, and persistence, which makes it much easier to build systems
+where users have their own specialized agents instead of treating agents as
+something outside the app.
+
+That pattern works so well in llm.rb because
+[`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html),
+`acts_as_agent`, `plugin :agent`, skills, tools, and persisted runtime state
+all fit the same execution model. The runtime stays small enough that the
+main design work becomes application design, not orchestration glue.
+
+For a concrete example, see
+[How to build a platform of agents](https://0x1eef.github.io/posts/how-to-build-a-platform-of-agents).
+
+#### Persistence
+
+The same runtime can be serialized to disk, restored later, persisted in JSON
+or JSONB-backed ORM columns, resumed across process boundaries, or shared
+across long-lived workflows.
+
+```ruby
+ctx = LLM::Context.new(llm)
+ctx.talk("Remember that my favorite language is Ruby.")
+ctx.save(path: "context.json")
+```
+
+#### LLM::Stream
+
+`LLM::Stream` is not just for printing tokens. It supports `on_content`,
+`on_reasoning_content`, `on_tool_call`, and `on_tool_return`, which means
+visible output, reasoning output, and tool execution can all be driven through
+the same execution path.
+
+```ruby
+class Stream < LLM::Stream
+  def on_tool_call(tool, error)
+    queue << tool.spawn(:thread)
+  end
+
+  def on_tool_return(tool, result)
+    puts(result.value)
+  end
+end
+```
+
+#### Concurrency
+
+Tool execution can run sequentially with `:call` or concurrently through
+`:thread`, `:task`, `:fiber`, and experimental `:ractor`, without rewriting
+your tool layer.
+
+```ruby
+class Agent < LLM::Agent
+  model "gpt-5.4-mini"
+  tools FetchWeather, FetchNews, FetchStock
+  concurrency :thread
+end
+```
+
+#### MCP
+
+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.
+
+```ruby
+begin
+  mcp = LLM::MCP.http(url: "https://api.githubcopilot.com/mcp/").persistent
+  mcp.start
+  ctx = LLM::Context.new(llm, tools: mcp.tools)
+ensure
+  mcp.stop
+end
+```
+
+#### Cancellation
+
+Cancellation is one of the harder problems to get right, and while llm.rb
+makes it possible, it still requires careful engineering to use effectively.
+The point though is that it is possible to stop in-flight provider work cleanly
+through the same runtime, and the model used by llm.rb is directly inspired by
+Go's context package. In fact, llm.rb is heavily inspired by Go but with a Ruby
+twist.
+
+```ruby
+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
+```
+
 ## Differentiators
 
 ### Execution Model
@@ -101,13 +271,18 @@ same context object.
   integration stack.
 - **ActiveRecord and Sequel persistence are built in** <br>
   llm.rb includes built-in ActiveRecord support through `acts_as_llm` and
-  `acts_as_agent`, plus built-in Sequel support through `plugin :llm`.
+  `acts_as_agent`, plus built-in Sequel support through `plugin :llm` and
+  `plugin :agent`.
   Use `acts_as_llm` when you want to wrap `LLM::Context`, `acts_as_agent`
-  when you want to wrap `LLM::Agent`, or `plugin :llm` on Sequel models to
-  persist `LLM::Context` state with sensible default columns. These
-  integrations support `provider:` and `context:` hooks, plus `format:
-  :string` for text columns or `format: :jsonb` for native PostgreSQL JSON
-  storage when ORM JSON typecasting support is enabled.
+  when you want to wrap `LLM::Agent`, `plugin :llm` when you want a
+  `LLM::Context` on a Sequel model, or `plugin :agent` when you want an
+  `LLM::Agent`. These integrations support `provider:` and `context:` hooks,
+  plus `format: :string` for text columns or `format: :jsonb` for native
+  PostgreSQL JSON storage when ORM JSON typecasting support is enabled.
+- **ORM models can become persistent agents** <br>
+  Turn an ActiveRecord or Sequel model into an agent-capable model with
+  built-in persistence, stored on the same table, with `jsonb` support when
+  your ORM and database support native JSON columns.
 - **Persistent HTTP pooling is shared process-wide** <br>
   When enabled, separate
   [`LLM::Provider`](https://0x1eef.github.io/x/llm.rb/LLM/Provider.html)
@@ -126,6 +301,11 @@ same context object.
 - **Tools are explicit** <br>
   Run local tools, provider-native tools, and MCP tools through the same path
   with fewer special cases.
+- **Skills become bounded runtime capabilities** <br>
+  Point llm.rb at directories with a `SKILL.md`, resolve named tools through
+  the registry, and adapt each skill into its own callable capability through
+  the normal runtime. Unlike a generic skill-discovery tool, each skill runs
+  with its own bounded tool subset and behaves like a task-scoped sub-agent.
 - **Providers are normalized, not flattened** <br>
   Share one API surface across providers without losing access to provider-
   specific capabilities where they matter.
@@ -157,23 +337,31 @@ same context object.
 
 ## Capabilities
 
+Execution:
 - **Chat & Contexts** — stateless and stateful interactions with persistence
 - **Context Serialization** — save and restore state across processes or time
 - **Streaming** — visible output, reasoning output, tool-call events
 - **Request Interruption** — stop in-flight provider work cleanly
+- **Concurrent Execution** — threads, async tasks, and fibers
+
+Runtime Building Blocks:
 - **Tool Calling** — class-based tools and closure-based functions
 - **Run Tools While Streaming** — overlap model output with tool latency
-- **Concurrent Execution** — threads, async tasks, and fibers
 - **Agents** — reusable assistants with tool auto-execution
+- **Skills** — directory-backed capabilities loaded from `SKILL.md`
+- **MCP Support** — stdio and HTTP MCP clients with prompt and tool support
+
+Data and Structure:
 - **Structured Outputs** — JSON Schema-based responses
 - **Responses API** — stateful response workflows where providers support them
-- **MCP Support** — stdio and HTTP MCP clients with prompt and tool support
 - **Multimodal Inputs** — text, images, audio, documents, URLs
 - **Audio** — speech generation, transcription, translation
 - **Images** — generation and editing
 - **Files API** — upload and reference files in prompts
 - **Embeddings** — vector generation for search and RAG
 - **Vector Stores** — retrieval workflows
+
+Operations:
 - **Cost Tracking** — local cost estimation without extra API calls
 - **Observability** — tracing, logging, telemetry
 - **Model Registry** — local metadata for capabilities, limits, pricing
@@ -189,7 +377,7 @@ 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](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+This example uses [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html) directly for an interactive REPL. <br> See the [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
 require "llm"
@@ -204,9 +392,47 @@ loop do
 end
 ```
 
+#### Agent
+
+This example uses [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html) directly and lets the agent manage tool execution. <br> 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"
+
+class ShellAgent < LLM::Agent
+  model "gpt-5.4-mini"
+  instructions "You are a Linux system assistant."
+  tools Shell
+  concurrency :thread
+end
+
+llm = LLM.openai(key: ENV["KEY"])
+agent = ShellAgent.new(llm)
+puts agent.talk("What time is it on this system?").content
+```
+
+#### Skills
+
+This example uses [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html) with directory-backed skills so `SKILL.md` capabilities run through the normal tool path. In llm.rb, a skill is exposed as a tool in the runtime. When that tool is called, it spawns a sub-agent with relevant context plus the instructions and tool subset declared in its own `SKILL.md`. <br> See the [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or [deepdive (markdown)](resources/deepdive.md) for more examples.
+
+Each skill runs only with the tools declared in its own frontmatter.
+
+```ruby
+require "llm"
+
+class Agent < LLM::Agent
+  model "gpt-5.4-mini"
+  instructions "You are a concise release assistant."
+  skills "./skills/release", "./skills/review"
+end
+
+llm = LLM.openai(key: ENV["KEY"])
+puts Agent.new(llm).talk("Use the review skill.").content
+```
+
 #### Streaming
 
-This example uses [`LLM::Stream`](https://0x1eef.github.io/x/llm.rb/LLM/Stream.html) directly so visible output and tool execution can happen together. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+This example uses [`LLM::Stream`](https://0x1eef.github.io/x/llm.rb/LLM/Stream.html) directly so visible output and tool execution can happen together. <br> 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"
@@ -238,9 +464,37 @@ ctx.talk("Run `date` and `uname -a`.")
 ctx.talk(ctx.wait(:thread)) while ctx.functions.any?
 ```
 
+#### Reasoning
+
+This example uses [`LLM::Stream`](https://0x1eef.github.io/x/llm.rb/LLM/Stream.html) with the OpenAI Responses API so reasoning output is streamed separately from visible assistant output. See the [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or [deepdive (markdown)](resources/deepdive.md) for more examples.
+
+```ruby
+require "llm"
+
+class Stream < LLM::Stream
+  def on_content(content)
+    $stdout << content
+  end
+
+  def on_reasoning_content(content)
+    $stderr << content
+  end
+end
+
+llm = LLM.openai(key: ENV["KEY"])
+ctx = LLM::Context.new(
+  llm,
+  model: "gpt-5.4-mini",
+  mode: :responses,
+  reasoning: {effort: "medium"},
+  stream: Stream.new
+)
+ctx.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](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+Need to cancel a stream? llm.rb has you covered through [`LLM::Context#interrupt!`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html#interrupt-21-instance_method). <br> See the [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) or [deepdive (markdown)](resources/deepdive.md) for more examples.
 
 ```ruby
 require "llm"
@@ -260,7 +514,7 @@ worker.join
 
 #### Sequel (ORM)
 
-The `plugin :llm` integration wraps [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html) on a `Sequel::Model` and keeps tool execution explicit. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+The `plugin :llm` integration wraps [`LLM::Context`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html) on a `Sequel::Model` and keeps tool execution explicit. <br> 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"
@@ -280,7 +534,7 @@ 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
-provides full control over tool execution. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+provides full control over tool execution. <br> 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"
@@ -300,7 +554,7 @@ puts ctx.talk("What is my favorite language?").content
 #### ActiveRecord (ORM): acts_as_agent
 
 The `acts_as_agent` method wraps [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html) and
-manages tool execution for you. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
+manages tool execution for you. <br> 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"
@@ -309,12 +563,11 @@ require "active_record"
 require "llm/active_record"
 
 class Ticket < ApplicationRecord
-  acts_as_agent provider: :set_provider do
-    model "gpt-5.4-mini"
-    instructions "You are a concise support assistant."
-    tools SearchDocs, Escalate
-    concurrency :thread
-  end
+  acts_as_agent provider: :set_provider
+  model "gpt-5.4-mini"
+  instructions "You are a concise support assistant."
+  tools SearchDocs, Escalate
+  concurrency :thread
 
   private
 
@@ -327,28 +580,9 @@ ticket = Ticket.create!(provider: "openai", model: "gpt-5.4-mini")
 puts ticket.talk("How do I rotate my API key?").content
 ```
 
-#### Agent
-
-This example uses [`LLM::Agent`](https://0x1eef.github.io/x/llm.rb/LLM/Agent.html) directly and lets the agent manage tool execution. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) for more examples.
-
-```ruby
-require "llm"
-
-class ShellAgent < LLM::Agent
-  model "gpt-5.4-mini"
-  instructions "You are a Linux system assistant."
-  tools Shell
-  concurrency :thread
-end
-
-llm = LLM.openai(key: ENV["KEY"])
-agent = ShellAgent.new(llm)
-puts agent.talk("What time is it on this system?").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. <br> See the [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) 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. 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"
@@ -379,8 +613,8 @@ how capable the runtime can be in a real application:
 
 ## Resources
 
-- [deepdive](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) is the
-  examples guide.
+- [deepdive (web)](https://0x1eef.github.io/x/llm.rb/file.deepdive.html) 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.

data/data/anthropic.json

@@ -213,7 +213,7 @@
       "reasoning": true,
       "tool_call": true,
       "temperature": true,
-      "knowledge": "2025-08",
+      "knowledge": "2025-08-31",
       "release_date": "2026-02-17",
       "last_updated": "2026-03-13",
       "modalities": {
@@ -271,6 +271,39 @@
         "output": 32000
       }
     },
+    "claude-opus-4-7": {
+      "id": "claude-opus-4-7",
+      "name": "Claude Opus 4.7",
+      "family": "claude-opus",
+      "attachment": true,
+      "reasoning": true,
+      "tool_call": true,
+      "temperature": false,
+      "knowledge": "2026-01-31",
+      "release_date": "2026-04-16",
+      "last_updated": "2026-04-16",
+      "modalities": {
+        "input": [
+          "text",
+          "image",
+          "pdf"
+        ],
+        "output": [
+          "text"
+        ]
+      },
+      "open_weights": false,
+      "cost": {
+        "input": 5,
+        "output": 25,
+        "cache_read": 0.5,
+        "cache_write": 6.25
+      },
+      "limit": {
+        "context": 1000000,
+        "output": 128000
+      }
+    },
     "claude-3-haiku-20240307": {
       "id": "claude-3-haiku-20240307",
       "name": "Claude Haiku 3",
@@ -609,7 +642,7 @@
       "reasoning": true,
       "tool_call": true,
       "temperature": true,
-      "knowledge": "2025-05",
+      "knowledge": "2025-05-31",
       "release_date": "2026-02-05",
       "last_updated": "2026-03-13",
       "modalities": {

data/data/google.json

@@ -594,7 +594,12 @@
       "cost": {
         "input": 1.25,
         "output": 10,
-        "cache_read": 0.31
+        "cache_read": 0.125,
+        "context_over_200k": {
+          "input": 2.5,
+          "output": 15,
+          "cache_read": 0.25
+        }
       },
       "limit": {
         "context": 1048576,
@@ -824,7 +829,7 @@
       "cost": {
         "input": 0.3,
         "output": 2.5,
-        "cache_read": 0.075,
+        "cache_read": 0.03,
         "input_audio": 1
       },
       "limit": {

data/data/openai.json

@@ -1066,36 +1066,6 @@
         "output": 100000
       }
     },
-    "codex-mini-latest": {
-      "id": "codex-mini-latest",
-      "name": "Codex Mini",
-      "family": "gpt-codex-mini",
-      "attachment": true,
-      "reasoning": true,
-      "tool_call": true,
-      "temperature": false,
-      "knowledge": "2024-04",
-      "release_date": "2025-05-16",
-      "last_updated": "2025-05-16",
-      "modalities": {
-        "input": [
-          "text"
-        ],
-        "output": [
-          "text"
-        ]
-      },
-      "open_weights": false,
-      "cost": {
-        "input": 1.5,
-        "output": 6,
-        "cache_read": 0.375
-      },
-      "limit": {
-        "context": 200000,
-        "output": 100000
-      }
-    },
     "gpt-4": {
       "id": "gpt-4",
       "name": "GPT-4",