llm.rb 7.0.0 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c923952039095a2234eb1bd5c058a951b0d797d27577cdf7f679df59b49060b
-  data.tar.gz: 3667e0d79e44634f769dfced198dd07c1039f173cb43b72aab7d3204aa3638f8
+  metadata.gz: 8aa3ee461642fb157bece63a4ebe00ceda8ec66ce24df5c842efdcc176861a53
+  data.tar.gz: 2d26e36b812704a80e5c8ba4814cfbec770afd5694be71b69d7937422f9a642c
 SHA512:
-  metadata.gz: 655d450b2ffeb71ed9564b7c5c23a2a86e9e385de9dc1abdac18588e460cffdecd1b2da1d5ef9fc162dc3f3286b7d2c979baec3953cd1ddbdab74d1ef5b87112
-  data.tar.gz: a044fedb675c4d92eff55c210d588b68b80c7e3967188674c2de4d8f6bc69d76e8f15c18f49fb54e09a8c93dff89074304d231609337bfa3bc79c96e1f3f576b
+  metadata.gz: 3a30bf9d5309bf49c660137ed5e81b74f9b028f8846077f3db0b7c92745a5d96b16115db765a4bd1970ba0cbaaa7bd805e0a4a37c04c7e63aacdf3d019d268ec
+  data.tar.gz: 4e297d159dc459ee9ec228862f271b7a21be48ce06f092773c4b56d9cc007252b1cfeb66a119c7e14f3e683213e5923d34b0c256397b92cfa981cd47fe023008

data/CHANGELOG.md

@@ -2,6 +2,150 @@
 
 ## Unreleased
 
+## v8.1.0
+
+Changes since `v8.0.0`.
+
+This release adds Amazon Bedrock provider support through the Converse
+API, including AWS SigV4 request signing, event stream decoding,
+structured output through `schema:`, and a models.dev-backed registry.
+It exposes `llm.models.all` for Bedrock via the ListFoundationModels
+API and adds `LLM::Object#transform_values!` for in-place value
+transformation. Several Bedrock-specific fixes land as well, including
+response id exposure, blank text block suppression in tool turns, and
+DSML tool-marker filtering in streamed text.
+
+### Add
+
+* **Add AWS Bedrock provider support** <br>
+  Add `LLM.bedrock(...)` with Bedrock Converse chat support, AWS SigV4
+  request signing, Bedrock event stream decoding, structured output
+  support through `schema:`, and models.dev-backed `bedrock.json`
+  registry generation.
+
+* **Add AWS Bedrock Models endpoint support** <br>
+  Add `llm.models.all` for Bedrock via the ListFoundationModels API,
+  including SigV4 signing for the control-plane endpoint and normalized
+  `LLM::Model` collection responses.
+
+* **Add `LLM::Object#transform_values!`** <br>
+  Let `LLM::Object` transform stored values in place through
+  `#transform_values!`.
+
+### Fix
+
+* **Expose response ids on Bedrock completion responses** <br>
+  Read the Bedrock request id into `LLM::Response#id` for completion
+  responses adapted from the Converse API.
+
+* **Avoid blank assistant text blocks in Bedrock tool turns** <br>
+  Stop replaying assistant tool-call messages with empty text content
+  blocks that Bedrock rejects.
+
+* **Suppress Bedrock DSML tool markers in streamed text** <br>
+  Filter `"<｜DSML｜function_calls"` markers out of streamed Bedrock
+  assistant text so tool-call sentinels do not leak into user-visible
+  output.
+
+## v8.0.0
+
+Changes since `v7.0.0`.
+
+This release adds Unix-fork concurrency for process-isolated tool
+execution, extends `LLM::Object` with `#merge` and `#delete`, and drops
+Ruby 3.2 support due to segfaults observed with the `:fork` path. It
+promotes `LLM::Pipe` to the top-level namespace and adds
+`persistent: true` on `LLM::MCP.http` for direct persistent transport
+configuration. `LLM::Function#runner` is exposed as public API, agent
+tracer overrides are supported, fiber execution now uses `Fiber.schedule`,
+missing optional dependencies raise clearer `LLM::LoadError` guidance,
+and ActiveRecord wrapper plumbing is deduplicated between `acts_as_llm`
+and `acts_as_agent`.
+
+### Breaking
+
+* **Drop Ruby 3.2 support** <br>
+  Stop supporting Ruby 3.2 due to a segfault observed with the `:fork`
+  tool concurrency strategy.
+
+### Add
+
+* **Add `LLM::Object#merge`** <br>
+  Let `LLM::Object` return a new wrapped object when merging hash-like
+  data through `#merge`.
+
+* **Add `LLM::Object#delete`** <br>
+  Let `LLM::Object` delete keys directly through `#delete`.
+
+### Change
+
+* **Add fork-based tool concurrency** <br>
+  Add `:fork` as a new concurrency strategy for `LLM::Function#spawn`,
+  `LLM::Function::Array#wait`, and `LLM::Agent.concurrency` that runs
+  class-based tools in isolated child processes. Fork-backed tools support
+  tracer callbacks, `on_interrupt`/`on_cancel` hooks, and `alive?` checks.
+  Requires the `xchan` gem for inter-process communication with `:fork`.
+  This is especially useful for tools that need process isolation, such as
+  running shell commands or handling unsafe data.
+
+* **Promote `LLM::Pipe` from MCP namespace to top-level** <br>
+  Move `LLM::MCP::Pipe` to `LLM::Pipe` so the pipe abstraction is available
+  outside MCP internals. The new class adds a `binmode:` option for binary
+  pipes. `LLM::MCP::Command` and related MCP transport code have been updated
+  to use `LLM::Pipe`.
+
+* **Allow `persistent: true` on `LLM::MCP.http`** <br>
+  Let `LLM::MCP.http(...)` enable persistent HTTP transport directly
+  through `persistent: true`, instead of requiring a separate
+  `.persistent` call after construction.
+
+* **Expose `LLM::Function#runner` as public API** <br>
+  Promote the internal runner instantiation to a public `runner` method on
+  `LLM::Function`, so callers can inspect or reuse the resolved tool instance
+  that a function wraps.
+
+* **Allow agent instance tracer overrides** <br>
+  Let `LLM::Agent.new(..., tracer: ...)` override the class-level tracer
+  for that agent instance.
+
+* **Make `:fiber` use scheduler-backed fibers** <br>
+  Change `:fiber` tool execution to use `Fiber.schedule` and require
+  `Fiber.scheduler`, instead of wrapping direct calls in raw fibers. This
+  gives `:fiber` a real cooperative concurrency model instead of acting as
+  a thin wrapper around sequential execution.
+
+* **Read stored values from zero-argument `LLM::Object` method calls** <br>
+  Let calls like `obj.delete`, `obj.fetch`, `obj.merge`, `obj.key?`,
+  `obj.dig`, `obj.slice`, or `obj.keys` return a stored value when that
+  method name exists as a key and no arguments are given.
+
+* **Harden `LLM::Object` against arbitrary key names** <br>
+  Move internal lookup logic off `LLM::Object` instances and onto the
+  singleton class instead, making stored keys like `method_missing`
+  more resilient while preserving normal dynamic field access.
+
+* **Deduplicate ActiveRecord wrapper plumbing** <br>
+  Move shared ActiveRecord wrapper defaults and utility methods into
+  `LLM::ActiveRecord`, reducing duplication between `acts_as_llm` and
+  `acts_as_agent`.
+
+* **Raise clearer errors for missing optional runtime dependencies** <br>
+  Route optional `async`, `xchan`, and `net/http/persistent` loads
+  through `LLM.require` so missing runtime gems raise `LLM::LoadError`
+  with installation guidance instead of leaking raw `LoadError`
+  exceptions.
+
+### Fix
+
+* **Avoid `RuntimeError` from `Async::Task.current` lookups** <br>
+  Check `Async::Task.current?` before reading the current Async task so
+  provider transports fall back to `Fiber.current` without raising when
+  no Async task is active.
+
+* **Serialize `LLM::Object` values correctly through `LLM.json`** <br>
+  Make `LLM::Object#to_json` call `LLM.json.dump(to_h, ...)` so
+  `LLM::Object` values serialize through the llm.rb JSON adapter.
+
 ## v7.0.0
 
 Changes since `v6.1.0`.
@@ -121,6 +265,12 @@ and `LLM::RactorError` is raised for unsupported ractor tool work.
   for unsupported tool types such as skill-backed tools, instead of letting
   deeper Ruby isolation errors leak out later in execution.
 
+* **Delegate interrupt to concurrent task implementations** <br>
+  Make `LLM::Function::Task#interrupt!` delegate to the underlying fork or
+  ractor task when it supports interruption, so `ctx.interrupt!` and
+  `task.interrupt!` work correctly for fork- and ractor-backed tool
+  execution.
+
 ## v5.4.0
 
 Changes since `v5.3.0`.
@@ -828,7 +978,7 @@ Changes since `v4.9.0`.
 
 - Add HTTP transport for MCP with `LLM::MCP::Transport::HTTP` for remote servers
 - Add JSON Schema union types (`any_of`, `all_of`, `one_of`) with parser integration
-- Add JSON Schema type array union support (e.g., `"type": ["object", "null"]`)
+- Add JSON Schema type array union support (e.g., `"type\": [\"object\", \"null\"]`)
 - Add JSON Schema type inference from `const`, `enum`, or `default` fields
 
 ### Change

data/README.md

@@ -4,7 +4,7 @@
 <p align="center">
   <a href="https://0x1eef.github.io/x/llm.rb?rebuild=1"><img src="https://img.shields.io/badge/docs-0x1eef.github.io-blue.svg" alt="RubyDoc"></a>
   <a href="https://opensource.org/license/0bsd"><img src="https://img.shields.io/badge/License-0BSD-orange.svg?" alt="License"></a>
-  <a href="https://github.com/llmrb/llm.rb/tags"><img src="https://img.shields.io/badge/version-7.0.0-green.svg?" alt="Version"></a>
+  <a href="https://github.com/llmrb/llm.rb/tags"><img src="https://img.shields.io/badge/version-8.1.0-green.svg?" alt="Version"></a>
 </p>
 
 ## About
@@ -24,8 +24,18 @@ It provides one runtime for providers, agents, tools, skills, MCP servers, strea
 schemas, files, and persisted state, so real systems can be built out of one coherent
 execution model instead of a pile of adapters.
 
+It supports providers including OpenAI, Anthropic, Google Gemini, DeepSeek, xAI,
+Z.ai, and AWS Bedrock.
+
+It provides concurrent tool execution with multiple strategies exposed through a single
+runtime: async-task, threads, fibers, ractors and processes (fork). The first three are
+good for IO-bound work and the last two are good for CPU-bound work. Ractor support is
+experimental and comes with limitations.
+
 Want to see some code? Jump to [the examples](#examples) section. <br>
-Want to see a self-hosted LLM environment built on llm.rb? Check out [Relay](https://github.com/llmrb/relay).
+Want to see a self-hosted LLM environment built on llm.rb? Check out [relay.app](https://github.com/llmrb/relay.app). <br>
+Want to use llm.rb with mruby ? Check out [mruby-llm](https://github.com/llmrb/mruby-llm)
+
 
 ## Architecture
 
@@ -287,8 +297,13 @@ end
 #### Concurrency
 
 Tool execution can run sequentially with `:call` or concurrently through
-`:thread`, `:task`, `:fiber`, and experimental `:ractor`, without rewriting
-your tool layer.
+`:thread`, `:task`, `:fiber`, `:fork`, and experimental `:ractor`, without
+rewriting your tool layer. Async tasks, threads, and fibers are the
+I/O-bound options. Fork and ractor are the CPU-bound options. `:fork`
+requires [`xchan.rb`](https://github.com/0x1eef/xchan.rb#readme) support,
+and `:ractor` is still experimental.
+
+`:fiber` uses `Fiber.schedule`, so it requires `Fiber.scheduler`.
 
 ```ruby
 class Agent < LLM::Agent
@@ -311,8 +326,9 @@ finer sequential control across several steps before shutting the client down.
 ```ruby
 mcp = LLM::MCP.http(
   url: "https://api.githubcopilot.com/mcp/",
-  headers: {"Authorization" => "Bearer #{ENV["GITHUB_PAT"]}"}
-).persistent
+  headers: {"Authorization" => "Bearer #{ENV["GITHUB_PAT"]}"},
+  persistent: true
+)
 mcp.run do
   ctx = LLM::Context.new(llm, tools: mcp.tools)
 end
@@ -367,13 +383,13 @@ worker.join
   Use `LLM::Agent` when you want the same stateful runtime surface as
   `LLM::Context`, but with tool loops executed automatically according to a
   configured concurrency mode such as `:call`, `:thread`, `:task`, `:fiber`,
-  or experimental `:ractor` support for class-based tools. MCP tools are not
-  supported by the current `:ractor` mode, but mixed tool sets can still
-  route MCP tools and local tools through different strategies at runtime.
-  By default, the tool attempt budget is `25`. When an agent exhausts that
-  budget, it sends advisory tool errors back through the model instead of
-  raising out of the runtime. Set `tool_attempts: nil` to disable that
-  advisory behavior.
+  `:fork`, or experimental `:ractor` support for class-based tools. MCP tools
+  are not supported by the current `:ractor` mode, but mixed tool sets can
+  still route MCP tools and local tools through different strategies at
+  runtime. By default, the tool attempt budget is `25`. When an agent
+  exhausts that budget, it sends advisory tool errors back through the model
+  instead of raising out of the runtime. Set `tool_attempts: nil` to disable
+  that advisory behavior.
 - **Tool calls have an explicit lifecycle** <br>
   A tool call can be executed, cancelled through
   [`LLM::Function#cancel`](https://0x1eef.github.io/x/llm.rb/LLM/Function.html#cancel-instance_method),
@@ -385,13 +401,15 @@ worker.join
   [`LLM::Context#cancel!`](https://0x1eef.github.io/x/llm.rb/LLM/Context.html#cancel-21-instance_method)
   is inspired by Go's context cancellation model.
 - **Concurrency is a first-class feature** <br>
-  Use threads, fibers, async tasks, or experimental ractors without
-  rewriting your tool layer. The current `:ractor` mode is for class-based
-  tools and does not support MCP tools, but mixed workloads can branch on
-  `tool.mcp?` and choose a supported strategy per tool. Class-based
-  `:ractor` tools still emit normal tool tracer callbacks. `:ractor` is
-  especially useful for CPU-bound tools, while `:task`, `:fiber`, or
-  `:thread` may be a better fit for I/O-bound work.
+  Use async tasks, threads, fibers, forks, or experimental ractors without
+  rewriting your tool layer. Async tasks, threads, and fibers are the
+  I/O-bound options. Fork and ractor are the CPU-bound options. `:fork`
+  requires [`xchan.rb`](https://github.com/0x1eef/xchan.rb#readme) support.
+  The current `:ractor` mode is for class-based tools, and MCP tools are
+  not supported by ractor, but mixed workloads can branch on `tool.mcp?`
+  and choose a supported strategy per tool. Class-based `:ractor` tools
+  still emit normal tool tracer callbacks. `:fiber` uses `Fiber.schedule`,
+  so it requires `Fiber.scheduler`.
 - **Advanced workloads are built in, not bolted on** <br>
   Streaming, concurrent tool execution, persistence, tracing, and MCP support
   all fit the same runtime model.
@@ -429,7 +447,7 @@ worker.join
   preserve OpenAI request shapes but change the API root path.
 - **Provider support is broad** <br>
   Work with OpenAI, OpenAI-compatible endpoints, Anthropic, Google, DeepSeek,
-  Z.ai, xAI, llama.cpp, and Ollama through the same runtime.
+  Z.ai, xAI, AWS Bedrock, llama.cpp, and Ollama through the same runtime.
 - **Tools are explicit** <br>
   Run local tools, provider-native tools, and MCP tools through the same path
   with fewer special cases.
@@ -865,8 +883,9 @@ require "net/http/persistent"
 llm = LLM.openai(key: ENV["KEY"])
 mcp = LLM::MCP.http(
   url: "https://api.githubcopilot.com/mcp/",
-  headers: {"Authorization" => "Bearer #{ENV["GITHUB_PAT"]}"}
-).persistent
+  headers: {"Authorization" => "Bearer #{ENV["GITHUB_PAT"]}"},
+  persistent: true
+)
 
 mcp.start
 ctx = LLM::Context.new(llm, stream: $stdout, tools: mcp.tools)
@@ -880,8 +899,9 @@ For scoped work, `mcp.run do ... end` is shorter and handles cleanup for you:
 ```ruby
 mcp = LLM::MCP.http(
   url: "https://api.githubcopilot.com/mcp/",
-  headers: {"Authorization" => "Bearer #{ENV["GITHUB_PAT"]}"}
-).persistent
+  headers: {"Authorization" => "Bearer #{ENV["GITHUB_PAT"]}"},
+  persistent: true
+)
 mcp.run do
   ctx = LLM::Context.new(llm, stream: $stdout, tools: mcp.tools)
   ctx.talk("Pull information about my GitHub account.")