ruby_llm-ag_ui 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e2fef2885431f82e496f0e1682bbd6d11ed036a6dcda941353e5f70d22e9589
-  data.tar.gz: 06d1631a5e98ecfea25a53dd9ea9f40c235f2fea871fcc7d4fb9e2b707596439
+  metadata.gz: faaf47d4aefadd16b5b9f9ee3a069efca39ada7c5e6935306879d82fcbe6094f
+  data.tar.gz: 2d81db9c7f7429a33391eb485d791160b5cf363b3313a0c3e65807a72b85fb16
 SHA512:
-  metadata.gz: bc183b5b76a8f3f92a27feb731a879780b454425a95c024bfc5ebba2c23f006ec2da5c2682c1c2074dcb4a946650d3941aa0482915c3987873c5bcc420613f3e
-  data.tar.gz: 19da3e02abe3806802bbe4efee68138a3a8b7e31477ae43a7085511f748dd88df59c71ba12398bf84310a74c7e57fca8ee25581e26d9ce797816ca95f5b5f3db
+  metadata.gz: 4ae655ed6335e4ca391c2caf310567d0ca471d4d2cc7594cae3c0d631456d28627bf3ac2828f895f59e742bc9ea2e9cd94c7e8ea6549fb4db724cadb1506e05f
+  data.tar.gz: 15b3541966a7a4fc2baa342525da774e1adff49929c4d5e334ea8c420ae14a75a5c62bcb574f28a0b69b282865e355c5395391d3cd193ca160dc4a93fe095d26

data/CHANGELOG.md

@@ -6,6 +6,49 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [1.0.0] - 2026-11-02
+
+The stable integration contract. The public API, configuration, and store
+contract proposed in 0.4 are now covered by Semantic Versioning.
+
+### Removed
+
+- Support for Ruby 3.2, which reached end of life in March 2026. The gem now
+  requires Ruby 3.3 or newer, and CI tests Ruby 3.3, 3.4, and 4.0.
+
+### Changed
+
+- The durable store finds interrupted runs through the shipped status index,
+  instead of loading and parsing every run on the thread for each resume.
+
+### Fixed
+
+- Open a new tool call when a streamed fragment carries a new id under a stream
+  index already in use, as RubyLLM does. An OpenAI-compatible server that sends
+  each parallel call whole at index 0 no longer has a second call's arguments
+  appended to the first call.
+- Handle stream refusals in Rails hosts without Active Record, preserving
+  unrelated host errors instead of replacing them with a missing constant.
+- Honor zero quality and media-range precedence in `SSEWriter.accepts?`.
+  Rails refuses an unacceptable stream with 406 before resolving a chat or
+  reserving a run, even when a wildcard would otherwise allow streaming.
+- Open each streamed tool call of a later tool round in the same turn. Providers
+  restart stream indexes in every response, so a second round's arguments were
+  sent to the first round's ended call before the new call opened.
+- Send streamed tool arguments that concatenate to valid JSON for Anthropic,
+  Bedrock, and Gemini. The empty input object that opens an Anthropic or
+  Bedrock call is no longer sent before its partial JSON, and a whole Gemini
+  call is serialized as JSON instead of Ruby `Hash#to_s` output.
+- Defer loading `ActiveRecord::Base` until the host uses the durable store.
+  Requiring the gem during a Rails boot no longer loads Active Record before
+  the application's configuration.
+- Accept a redaction policy object that defines only `#call`, instead of
+  failing the run when a tool result or progress update is redacted.
+- Refuse input with text that is not UTF-8, or a number JSON cannot represent,
+  as `MalformedInputError` (400) instead of raising `JSON::GeneratorError`.
+- Release a finished run's response stream. RubyLLM cannot remove callbacks,
+  so a chat reused across turns kept every earlier run's stream reachable.
+
 ## [0.4.0] - 2026-10-21
 
 ### Added

data/CONTRIBUTING.md

@@ -41,6 +41,10 @@ The package probe installs the artifact outside the checkout using available
 development dependencies; `bin/verify-package` separately tests clean dependency
 resolution. Shut down all task-owned processes when the check finishes.
 
+Before a release, build the gem and run `bundle exec ruby bin/verify-upgrade`
+with the downloaded previous release's gem path. It checks installed artifacts in
+separate processes against one temporary SQLite database, without a provider.
+
 Every behavior change needs a test, and lifecycle, identity and security changes
 need their negative case too. The acceptance IDs (FR-01..FR-08) are referenced
 in spec descriptions. Offline CI uses fakes; live provider tests are opt-in and

data/README.md

@@ -19,10 +19,10 @@ RubyLLM and AG-UI maintainers.
 ## Install
 
 ```ruby
-gem 'ruby_llm-ag_ui', '~> 0.4.0'
+gem 'ruby_llm-ag_ui', '~> 1.0'
 ```
 
-Requires Ruby >= 3.2, RubyLLM >= 2.1 and < 3.0, and `ag-ui-protocol` 0.2.x.
+Requires Ruby >= 3.3, RubyLLM >= 2.1 and < 3.0, and `ag-ui-protocol` 0.2.x.
 Run `bundle install` after adding the gem.
 
 ## Stream a run

data/docs/_advanced/client-example.md

@@ -37,6 +37,13 @@ Choose **Plain Ruby** or **Rails + SQLite**, then run a turn. The official
 chat per fixture actor and thread, so approval resumes the original tool call
 and later turns use the same conversation.
 
+The development bundle pins `@ag-ui/client` 1.0.3 and overrides Zod to 4.6.6
+for [GHSA-mrhx-c7xc-m3w5](https://github.com/advisories/GHSA-mrhx-c7xc-m3w5).
+The client and core schema code import `zod/v4`; browser workflows verify the
+override with the pinned client. Run `npm audit` alongside the browser checks.
+These JavaScript packages are development dependencies and are not shipped in
+the Ruby gem.
+
 ## Try the Interactions
 
 The tool scenario pauses for approval. Approve it to run a synthetic order

data/docs/_advanced/rails-integration.md

@@ -85,7 +85,7 @@ app knows what the client is looking at.
 | Request | Response |
 |---|---|
 | Valid input, `Accept: text/event-stream` | `200`, SSE, one `data:` line per AG-UI event |
-| `Accept` that cannot read SSE | `406` before any event |
+| `Accept` that cannot read SSE, including an effective `q=0` | `406` before resolving the chat or reserving a run |
 | Empty, non-JSON, or schema-invalid body | `400` |
 | Body past `config.max_input_bytes` | `413` |
 | `threadId` the actor does not own, when the block raises `ActiveRecord::RecordNotFound` | `404` |
@@ -195,6 +195,14 @@ what `spec/support/fake_chat.rb` in this repository does.
 | Tool results are `[redacted]` | Redaction is the default; configure `config.redact` |
 | A run succeeds but the client shows nothing | The client was not sent the interrupt/resume flow it expected, or it re-sent a `runId` whose run had already ended |
 
+## Use Rails Without Active Record
+
+You can use the streaming concern without Active Record. In that setup,
+configure a host-supplied store and resolve the chat from your own persistence.
+Stream conflicts still return 409. When Active Record is loaded, a missing
+record returns 404. Other errors raised while resolving a chat remain host
+errors and propagate to your application's error handling.
+
 ## Next Steps
 
 * [Approval and Resume]({% link _core_features/approval-and-resume.md %}) - answer a tool approval pause.

data/docs/_core_features/streaming-runs.md

@@ -30,7 +30,7 @@ In an application, parse the request first, then pass the host-selected chat, pa
 
 The mapper turns RubyLLM callbacks into AG-UI events. The emitter assigns each event a sequence, persists run state, closes open text or tool events, and writes one JSON event per `data:` line through the SSE writer.
 
-An assistant message opens on its first non-empty chunk and closes before a tool call, phase change, or terminal event. A tool call starts when its id and name are known, emits the arguments as received, and ends before the call runs. One run ends with one terminal result.
+An assistant message opens on its first non-empty chunk and closes before a tool call, phase change, or terminal event. A tool call starts when its id and name are known and ends before the call runs. Its argument deltas concatenate to the JSON arguments the tool receives: streamed fragments go out unchanged, a call a provider sends whole is serialized once, and the empty object some providers open a call with is not sent. Calls from one response can be open at the same time, so assemble arguments by `toolCallId`. One run ends with one terminal result.
 
 ## Outcomes
 
@@ -55,6 +55,14 @@ failure cannot replace an outcome that is already persisted. `SSEWriter` used
 directly raises `TransportError`, a subclass of `StreamError`; `Run` handles
 that transport error. Mapping and persistence errors are separate failures.
 
+## Check the Client's Accept Header
+
+`SSEWriter.accepts?` checks whether an `Accept` header permits an event stream.
+An explicit `text/event-stream;q=0` refuses streaming even with `*/*;q=1`.
+A specific media range takes precedence over its wildcard, following
+[HTTP quality and media-range rules](https://www.rfc-editor.org/rfc/rfc9110.html#section-12.5.1).
+The Rails adapter answers 406 before choosing a chat or reserving a run.
+
 ## Next Steps
 
 * [Validating Input]({% link _core_features/input-validation.md %}) - parse untrusted request data.

data/docs/_getting_started/getting-started.md

@@ -22,7 +22,7 @@ After reading this guide, you will know:
 {% if site.docs_unreleased %}bundle add ruby_llm-ag_ui --git https://github.com/yorzi/ruby_llm-ag-ui --branch main{% else %}bundle add ruby_llm-ag_ui --version {{ site.version }}{% endif %}
 ```
 
-The gem requires Ruby 3.2 or newer, RubyLLM 2.1 or newer, and `ag-ui-protocol` 0.2.x. The Rails adapter is optional. Provider credentials belong to your RubyLLM application; the parser example below needs none.
+The gem requires Ruby 3.3 or newer, RubyLLM 2.1 or newer, and `ag-ui-protocol` 0.2.x. The Rails adapter is optional. Provider credentials belong to your RubyLLM application; the parser example below needs none.
 
 The runtime dependencies select patched `cgi`, `resolv`, `uri`, and `zlib` gems. An older Ruby installation's default library versions do not override those dependency requirements.
 

data/docs/_getting_started/overview.md

@@ -111,7 +111,8 @@ reason.
    the events to write. The mapper is a state machine: a text message opens on
    its first non-empty chunk and closes before a tool call, a phase change or the
    terminal event; a tool call opens when its id and name are both known, streams
-   its argument deltas as received, and closes before it runs; one step per phase
+   argument deltas that concatenate to its JSON arguments, and closes before it
+   runs; one step per phase
    (`completion`, `tool`) so consecutive steps never overlap.
 6. **Write.** The emitter writes the events as SSE, advancing the run record's
    sequence by one per event.

data/docs/_getting_started/whats-new-in-1-0.md

@@ -0,0 +1,103 @@
+---
+layout: default
+title: "What's New in 1.0"
+nav_order: -1
+description: Install the stable 1.0 release, with streamed tool calls fixed across provider protocols, Ruby 3.3 or newer, and a rehearsed upgrade from 0.4.
+---
+
+# {{ page.title }}
+
+{{ page.description }}
+{: .fs-6 .fw-300 }
+
+After reading this guide, you will know:
+
+* What the 1.0 stability promise covers.
+* Which streamed tool-call fixes reach your client.
+* What changed for Rails boots, malformed input, and long-lived chats.
+
+## Install 1.0
+
+```ruby
+gem 'ruby_llm-ag_ui', '~> 1.0'
+```
+
+Version 1.0.0 keeps the public API, configuration, and store contract that 0.4
+proposed, with no new migration. From 1.0 on, that contract follows Semantic
+Versioning: a change that breaks it waits for 2.0. See the
+[Public API Contract]({% link _reference/public-api.md %}) for what it covers.
+Report a problem with the versions from `RubyLLM::AgUI.config.to_h`, as
+[Compatibility]({% link _reference/compatibility.md %}) describes.
+
+## Use Ruby 3.3 or Newer
+
+Ruby 3.2 reached end of life in March 2026, and 1.0 requires Ruby 3.3 or newer.
+CI tests Ruby 3.3, 3.4, and 4.0 with RubyLLM 2.1.0 and 2.1.1.
+
+## Stream Tool Calls Correctly Across Protocols
+
+A client assembles a tool call's arguments by joining its `TOOL_CALL_ARGS`
+deltas. Before this release, four provider shapes produced arguments the client
+could not parse or attribute:
+
+* A second tool round in one turn sent its arguments to the first round's ended
+  call. Chat Completions, OpenAI Responses, and Anthropic restart stream indexes
+  in every response.
+* Anthropic and Bedrock open a call with an empty input object before streaming
+  partial JSON, so the client received `{}{"query":"one"}`.
+* Gemini sends a whole call as a parsed object, which went out as Ruby
+  `Hash#to_s` output instead of JSON.
+* Some OpenAI-compatible servers send each parallel call whole at index 0. The
+  second call's arguments were appended to the first call. RubyLLM starts a new
+  call for each fragment with a new id, and so does the mapper now.
+
+Each call now opens once, and its deltas join to the JSON arguments the tool
+received. Intercepted-HTTP specs run a real RubyLLM chat for Chat Completions,
+Responses, Anthropic, and Gemini. Bedrock uses the same empty-object rule
+without its own HTTP spec. See [Streaming Runs]({% link _core_features/streaming-runs.md %}).
+
+## Boot Rails Without Loading Active Record Early
+
+Requiring the gem during `Bundler.require` no longer loads `ActiveRecord::Base`.
+The durable store's row class loads on first use, after your application's
+configuration. The generated initializer still assigns
+`RubyLLM::AgUI::Rails::ActiveRecordStore.new` as before.
+
+## Refuse an Unacceptable Stream Before Provider Work
+
+`SSEWriter.accepts?` honors quality values and media-range precedence. An
+explicit `text/event-stream;q=0` refuses SSE even with `*/*;q=1`. Empty media
+parameters do not raise a server error. Rails returns 406 before resolving a
+chat or reserving a run. Stream conflicts also return 409 in Rails hosts that
+do not load Active Record; unrelated host errors still propagate.
+
+## Refuse Malformed Text as a Client Error
+
+```ruby
+RubyLLM::AgUI::Input.parse(body)
+# => raises RubyLLM::AgUI::MalformedInputError (400)
+```
+
+A body whose text is not UTF-8, or that holds a number JSON cannot represent,
+is now refused as malformed input. The Rails adapter answers 400 instead of
+raising `JSON::GeneratorError` as a server error.
+
+## Reuse a Chat Across Turns
+
+RubyLLM cannot remove a callback, so each run's callbacks stay on a chat you
+reuse. A finished run now releases its response stream, and its callbacks map
+and write nothing. A redaction policy object that defines only `#call` also
+works now, alongside lambdas and methods.
+
+## Upgrade From 0.4
+
+Change the version in your Gemfile and run `bundle update ruby_llm-ag_ui`.
+Records written by 0.4 stay readable. The release rehearsal reconnects to a 0.4
+run and resumes a 0.4 interrupt with 1.0. Follow
+[Upgrading]({% link _reference/upgrading.md %}) for the steps.
+
+## Next Steps
+
+* [Compatibility]({% link _reference/compatibility.md %}) - read the 1.0 release evidence.
+* [Public API Contract]({% link _reference/public-api.md %}) - review the API 1.0 stabilizes.
+* [Release History]({% link _reference/release-history.md %}) - compare earlier releases.

data/docs/_reference/compatibility.md

@@ -23,11 +23,11 @@ dependency does.
 
 | Component | Range | Evidence |
 |---|---|---|
-| Ruby | `>= 3.2` | Recorded 0.4 CI passes on 3.2.11, 3.3.12, and 3.4.11 |
+| Ruby | `>= 3.3` | Recorded 0.4 CI passes on 3.3.12 and 3.4.11; 4.0.9 passes locally, and CI now includes 4.0. Ruby 3.2 is no longer supported |
 | RubyLLM | `>= 2.1`, `< 3.0` | 2.1.0 and 2.1.1 pass the 0.4 CI matrix; the recorded live session uses 2.1.1 |
 | `ag-ui-protocol` | `~> 0.2.0` | 0.2.0 |
 | JSON | `>= 2.0`, `< 3` | 2.21.2 passes both Rails lines; JSON 3 removes the `quirks_mode` option used by Rails 8.0 |
-| Rails (adapter only) | `railties`, `actionpack`, `activerecord` `>= 8.0` | Recorded 0.4 CI passes on 8.0.5.1 and 8.1.4 with Ruby 3.3/3.4 |
+| Rails (adapter only) | `railties`, `actionpack`, `activerecord` `>= 8.0` | Recorded 0.4 CI passes on 8.0.5.1 and 8.1.4 with Ruby 3.3/3.4; both pass locally on Ruby 4.0.9 |
 | AG-UI schema | pinned commit `89cedd3fd549feeee41e50e1d7c6d373e549241a` | vendored, SHA-256 recorded in [AG-UI Protocol Coverage]({% link _reference/protocol-coverage.md %}) |
 
 The pure-Ruby core uses `ruby_llm` and `ag-ui-protocol`, plus the patched
@@ -44,6 +44,8 @@ adapter is only loaded when `Rails::Railtie` is already defined.
 | The 31-type coverage map is the schema's own union | `spec/ruby_llm/ag_ui/coverage_spec.rb` compares the pinned list with `Coverage`, and the SDK enum at runtime |
 | The SDK's five legacy `THINKING_*` constants are never counted as 1.0 | the same spec asserts `LEGACY_SDK_ONLY` is absent from the map |
 | Text, tool and lifecycle sequences are ordered and closed | mapper specs, including partial arguments, a nil chunk, a tool that raises, and a thinking-only chunk |
+| Streamed tool arguments join to valid JSON for each call | `spec/integration/streamed_tool_calls_spec.rb` runs a real RubyLLM chat over intercepted Chat Completions, Responses, Anthropic, and Gemini streams, including two tool rounds in one turn |
+| A Rails boot does not load Active Record through the gem | `spec/integration/core_load_spec.rb` requires the gem after the Active Record railtie in a subprocess |
 | One outcome per run, and the outcome matches what happened | run specs: success, interrupt, cancelled, sanitized failure, unsupported pause |
 | `requires_approval` → interrupt → resume executes the tool once | run specs drive a fake chat through the pause, approve, deny, replay and expiry cases |
 | Identity is reserved, replayed and never re-executed | store specs (memory and ActiveRecord), run specs for conflict, reconnect and live-run refusal |
@@ -54,6 +56,120 @@ adapter is only loaded when `Rails::Railtie` is already defined.
 
 The RSpec suite runs offline with fakes and no provider credentials. Package verification uses the network only to install dependencies, then runs its core and Rails checks without a provider. Its advisory check includes the actual default-library gem versions activated by the isolated core install.
 
+## 1.0.0 Release Evidence
+
+Version 1.0.0 was rehearsed as the local, unpublished candidate 1.0.0.rc.1 and
+published after the maintainer's acceptance. The dated reviews below record that
+candidate. The 2026-10-21 evidence records the earlier rehearsal.
+
+### Release Verification on 2026-11-02
+
+The 1.0.0 release commit passes 321 offline examples with zero failures and two
+opt-in live checks skipped on Ruby 3.3.5, and lint passes on 100 files. The
+browser suite passes 18 workflows with all 242 consumed events schema-valid. The
+built gem passes both installed endpoints, clean core and Rails installation with
+the generator migrated up and down, and the activated-dependency advisory check.
+The upgrade from the published 0.4.0 artifact keeps the generated files,
+reconnects, runs an approval once, and denies with no effect.
+
+The OpenRouter rerun passes live streamed text and approval with reconnect, plus
+the offline and intercepted harness cases: six examples, zero failures.
+
+The development bundle audit uses 1,307 advisories at
+`79c0e052ade15d29d3ecc1e8d4fa59c337a86383`. Advisories published on 2026-11-01
+affected `addressable`, `rack`, and `sqlite3` in the development and test bundle
+only; after updating them to 2.9.2, 3.2.8, and 2.10.2 the audit reports no
+findings. None is a runtime dependency of the gem. The npm audit reports zero
+findings.
+
+### Candidate Review on 2026-11-02
+
+A review of every change since 0.4.0 found one more streamed tool-call defect.
+RubyLLM starts a new call for each fragment that carries an id, but the mapper
+continued the call already at that stream index. An OpenAI-compatible server
+that sends each parallel call whole at index 0 had the second call's arguments
+appended to the first. A real-chat intercepted-HTTP spec fails before the fix.
+
+The offline suite passes 321 examples with zero failures and two opt-in live
+checks skipped on Ruby 3.3.5, and lint passes on 100 files. Ruby 4.0.9 passes the
+same 321 examples twice: with RubyLLM 2.1.1 and Rails 8.1.4, and with RubyLLM
+2.1.0 and Rails 8.0.5.1. Malformed-input refusal holds on JSON 2.7.1, 2.9.1, and
+2.21.2. CI adds Ruby 4.0 to the core and Rails matrices; its remote results are
+separate evidence.
+
+The fix changes a packaged file, so the 2026-10-26 artifact below is superseded.
+The rebuilt candidate passes the installed-host checks for both endpoints and the
+generated RubyLLM models. Its upgrade from the published 0.4.0 artifact keeps the
+generated files, reconnects, runs an approval once, and denies with no effect.
+The browser suite passes 18 workflows with all 242 consumed events schema-valid;
+desktop approval progress and 390px mobile denial screenshots were inspected.
+
+### Final Local Review on 2026-10-26
+
+The offline suite passes 320 examples with zero failures and two opt-in live
+checks skipped, on Ruby 3.3.5 with RubyLLM 2.1.1 and Rails 8.1.4. Line coverage
+is 97.58 percent; this measures executed lines rather than complete behavior.
+The same 320 examples pass separately on the minimum RubyLLM 2.1.0.
+Lint passes on 100 files. Added regressions cover SSE quality and wildcard
+precedence, empty media parameters, and actual Rails requests without Active
+Record. Known missing-record errors still return 404; unrelated host errors
+propagate. The focused tests reproduce the defects before their fixes.
+
+The client still uses `@ag-ui/client` 1.0.3. After overriding Zod to 4.6.6,
+18 browser workflows pass with all 242 consumed events schema-valid. Desktop
+approval progress and 390px mobile denial screenshots were inspected. The
+2026-10-26 npm audit reports zero findings. Before the override, the audit
+reported four high findings from one transitive Zod advisory. This is a
+development bundle, not a JavaScript dependency shipped with the Ruby gem.
+
+The Ruby audit uses 1,269 advisories at
+`03da937a9e171e3fedebde6620e203559b7a60c0` and reports no findings after updating
+the local Rails dependency `crass` from 1.0.7 to 1.0.8. Existing applications
+need their own lockfile audit; installing this gem does not audit a host's
+Rails dependencies. CI now audits both the Ruby development bundle and npm.
+
+`bin/verify-upgrade` preserves this rehearsal as a repeatable command. It
+installs the published 0.4.0 artifact and the built candidate, then uses separate
+processes against one temporary SQLite database. Generated files are unchanged;
+0.4 completed outcomes reconnect, old approvals execute once, denial executes
+no effect, completed retries do not execute again, and scope isolation holds.
+Its scripted chat and existing development dependencies are separate evidence
+from clean installation and real-provider tests.
+
+The bounded OpenRouter rerun passes both live text and approval/resume checks
+with `openai/gpt-4.1-mini`, plus one offline harness case. No live browser,
+Rails/provider, denial, cancellation-timing, or additional-provider claim is made.
+
+### Earlier Local Rehearsal on 2026-10-21
+
+On 2026-10-21, the candidate passes 313 offline examples with zero failures
+and two opt-in provider skips on Ruby 3.3.5, RubyLLM 2.1.1, and Rails 8.1.4.
+Lint passes on 97 files. The browser suite passes 18 workflows with
+`@ag-ui/client` 1.0.3 and validates all 242 consumed events. Desktop approval
+and 390px mobile denial screenshots were inspected.
+
+The built artifact passes both installed endpoints, the generated RubyLLM
+models, a clean gem home with the activated-dependency audit, and Rails
+generator migration up and down. The root advisory audit reports no findings.
+
+An upgrade rehearsal installs the published 0.4.0 gem in an isolated gem home,
+generates and migrates its table in SQLite, and records a succeeded run and an
+interrupted run. The candidate artifact then reconnects to the 0.4 run without
+executing it, resumes the 0.4 interrupt with the original call id, runs the
+tool once, and reconnects without running it again. Its generated migration
+and initializer match 0.4.0.
+
+The rerun OpenRouter session uses `openai/gpt-4.1-mini` with RubyLLM 2.1.1.
+Both live examples pass: streamed text, and the synthetic approval/resume with
+reconnect. The same command runs four offline and intercepted harness examples,
+for six examples and zero failures.
+
+The audit for this candidate found streamed tool-call defects that the 0.4
+evidence did not exercise: a second tool round in one turn, Anthropic and
+Bedrock empty opening input, and Gemini whole-call arguments. Each defect has a
+real-chat intercepted-HTTP spec that fails before its fix. Remote CI is separate
+from that local record. No RC tag or publication is planned.
+
 ## 0.4 Release Acceptance
 
 The [2026-10-21 acceptance CI](https://github.com/yorzi/ruby_llm-ag-ui/actions/runs/39518735488)
@@ -71,6 +187,23 @@ The browser suite again passes 18 workflows and validates all 242 consumed
 events. Desktop approval progress and 390px mobile denial screenshots were
 inspected. The earlier candidate record below retains its own commit and counts.
 
+### Published 0.4.0 Artifact
+
+The [tag-source CI](https://github.com/yorzi/ruby_llm-ag-ui/actions/runs/39518971268)
+passes all 17 jobs at `23d9020`. The
+[0.4.0 release workflow](https://github.com/yorzi/ruby_llm-ag-ui/actions/runs/39519175592)
+passes its offline, browser, advisory, installed-host, and clean-install checks.
+The actual GitHub and RubyGems downloads have matching SHA-256 hashes, including
+the release checksum and RubyGems metadata. All 66 packaged files match the tag.
+The downloaded artifact independently passes both installed endpoints and fresh
+core, activated-dependency audit, and Rails generator migration up/down checks.
+
+The [stable documentation deployment](https://github.com/yorzi/ruby_llm-ag-ui/actions/runs/39519565224)
+passes. HTTP checks verify the stable guides, generated API, release history,
+and stable/Next installation commands and `llms.txt`. A fresh browser session
+shows 0.4.0 and switches to Next through the version menu; its screenshot was
+inspected. Publication checks do not expand the provider or database claims below.
+
 ## Local 0.4 Development Verification
 
 On 2026-10-21, the candidate passes 294 offline examples with zero failures
@@ -195,8 +328,10 @@ checks after download.
   recorded `@ag-ui/client` version have not been verified. Schema conformance
   does not establish that every UI renders the events correctly.
 - **Other live paths.** Only the recorded OpenRouter model's text and approval
-  workflow is verified live. Browser provider sessions, other providers,
-  cancellation timing, timeouts, and network-loss recovery need separate evidence.
+  workflow is verified live. Anthropic, Gemini, and OpenAI Responses streams are
+  checked with intercepted HTTP only. Browser provider sessions, other
+  providers, cancellation timing, timeouts, and network-loss recovery need
+  separate evidence.
 - **Every RubyLLM patch release in the `>= 2.1, < 3.0` range.** The upper bound
   is a dependency resolver bound; verified versions are 2.1.0 and 2.1.1. Future
   2.x releases need the same checks before a compatibility claim.

data/docs/_reference/protocol-coverage.md

@@ -61,7 +61,7 @@ Legend:
 | `TEXT_MESSAGE_CONTENT` | text | One delta per non-empty `chunk.content`, in order. |
 | `TEXT_MESSAGE_END` | text | Closed before a tool call, a phase change or the terminal event. |
 | `TOOL_CALL_START` | tool | Emitted when a call is observed before it runs. |
-| `TOOL_CALL_ARGS` | tool | Arguments as received; never re-synthesized. |
+| `TOOL_CALL_ARGS` | tool | Deltas that concatenate to the call's JSON arguments; streamed fragments unchanged. |
 | `TOOL_CALL_END` | tool | Closed before the call runs or the run ends. |
 | `TOOL_CALL_RESULT` | tool | The tool result, after the host redaction policy. |
 | `STATE_SNAPSHOT` | state | On a reconnect: the state the host gave the run. |

data/docs/_reference/public-api.md

@@ -2,7 +2,7 @@
 layout: default
 title: Public API Contract
 nav_order: 3
-description: Build against the application API and custom-store contract proposed for 1.0.
+description: Build against the application API and custom-store contract that 1.0 stabilizes.
 ---
 
 # {{ page.title }}
@@ -32,8 +32,9 @@ returns its stored outcome on an exact retry; it never repeats the turn.
 An active duplicate is refused. See
 [Reconnects]({% link _core_features/reconnects.md %}).
 
-Version 0.4 proposes the following application contract for 1.0. It is not a
-1.0 stability promise yet. Breaking changes before 1.0 have upgrade steps.
+Version 1.0.0 makes the following application contract a stability promise.
+It follows Semantic Versioning: a change that breaks it waits for 2.0 and ships
+with upgrade steps.
 
 | Entry point | Application contract |
 | --- | --- |

data/docs/_reference/release-history.md

@@ -17,7 +17,8 @@ description: Review RubyLLM AG-UI releases, newest first, with highlights and up
 
 | Release | Date | Highlights |
 | --- | --- | --- |
-| [0.4.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.4.0) | 2026-10-21 | [API and compatibility]({% link _getting_started/whats-new-in-0-4.md %}): effective configuration, immutable records, and real-chat approval verification |
+| [1.0.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v1.0.0) | 2026-11-02 | [Stable integration contract]({% link _getting_started/whats-new-in-1-0.md %}): streamed tool calls fixed across provider protocols, Ruby 3.3 or newer, and a rehearsed upgrade from 0.4 |
+| [0.4.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.4.0) | 2026-10-21 | [API and compatibility]({% link _reference/whats-new-in-0-4.md %}): effective configuration, immutable records, and real-chat approval verification |
 | [0.3.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.3.0) | 2026-10-20 | [Lifecycle and worker recovery]({% link _reference/whats-new-in-0-3.md %}): disconnect handling, scoped cancellation, and conditional durable writes |
 | [0.2.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.2.0) | 2026-10-19 | [Client workflows and tool progress]({% link _reference/whats-new-in-0-2.md %}): opt-in redacted progress, a real-client demo, and completed resume reconnect |
 | [0.1.0](https://github.com/yorzi/ruby_llm-ag-ui/releases/tag/v0.1.0) | 2026-10-18 | [First release]({% link _reference/whats-new-in-0-1.md %}): AG-UI event mapping, approval and resume, cancellation, reconnect, and the optional Rails adapter |

data/docs/_reference/releasing.md

@@ -40,6 +40,11 @@ so local and CI builds use the same navigation and parser.
 
 ## Review Release Scope
 
+Keep `released: false` on `main` between releases. For a release that changes
+the public contract or its upgrade path, build the artifact, run
+`bundle exec ruby bin/verify-upgrade` with the previous published gem, and
+install it in a real application before you tag.
+
 Use the repository's [roadmap](https://github.com/yorzi/ruby_llm-ag-ui/blob/main/ROADMAP.md)
 for proposed iterations and the 1.0 release conditions. Guides describe available
 behavior; the roadmap describes planned work. Check the release's conditions

data/docs/_reference/upgrading.md

@@ -15,6 +15,33 @@ After reading this guide, you will know:
 * How to move between versioned releases.
 * Where to find changes that need code updates.
 
+## Move from 0.4 to 1.0
+
+Update your Gemfile and dependency:
+
+```ruby
+gem 'ruby_llm-ag_ui', '~> 1.0'
+```
+
+```sh
+bundle update ruby_llm-ag_ui
+```
+
+1.0 keeps the 0.4 public API, configuration, and store
+contract. It needs no SQL migration, and the generated migration and
+initializer are unchanged. Records written by 0.4 stay readable: an exact retry
+reconnects to a 0.4 run, and a 0.4 interrupt can be resumed after the upgrade.
+
+Clients now receive tool argument deltas that join to valid JSON for every
+streamed call. If your client worked around the old `{}` prefix or Ruby
+`Hash#to_s` arguments, remove that workaround.
+
+Requiring the gem no longer loads `ActiveRecord::Base` during a Rails boot.
+Code that relied on the gem to load Active Record must load it itself.
+
+1.0 requires Ruby 3.3 or newer. Upgrade an application on Ruby 3.2 before you
+update the gem; Bundler refuses to install 1.0 on Ruby 3.2.
+
 ## Move from 0.3 to 0.4
 
 Update your Gemfile and dependency:

data/docs/{_getting_started → _reference}/whats-new-in-0-4.md

@@ -1,7 +1,8 @@
 ---
 layout: default
 title: "What's New in 0.4"
-nav_order: -1
+nav_order: 40
+parent: Release History
 description: Review the public integration contract and verified compatibility boundaries.
 ---
 

data/lib/ruby_llm/ag_ui/configuration.rb

@@ -96,7 +96,8 @@ module RubyLLM
         :custom
       end
 
-      # The run store, or nil when the host has not configured one.
+      # The configured run store. Raises ConfigurationError when the host has
+      # not configured one.
       def run_store!
         @run_store || raise(ConfigurationError, 'No run_store is configured. ' \
                                                 'Set RubyLLM::AgUI.config.run_store or pass store: to Run.new.')

data/lib/ruby_llm/ag_ui/input.rb

@@ -99,8 +99,8 @@ module RubyLLM
         @tools.filter_map { |tool| tool['name'] }
       end
 
-      # Whether the client supplied tool definitions. The first release never
-      # grants them; a run reports them and stops.
+      # Whether the client supplied tool definitions. Informational only: the
+      # gem never registers a client tool on the host's chat.
       def client_tools?
         !@tools.empty?
       end
@@ -133,10 +133,15 @@ module RubyLLM
           @parts = PartBuilder.new
         end
 
+        # The digest re-encodes the accepted values, so text that is not UTF-8
+        # or a number that overflowed to Infinity is refused here as malformed
+        # input rather than escaping as an encoder error.
         def parse
           document = strip_unknown_members(decode(read_body))
           validate_common(document)
           build(document)
+        rescue JSON::GeneratorError
+          raise MalformedInputError, 'The request body must be valid UTF-8 JSON.'
         end
 
         private

data/lib/ruby_llm/ag_ui/mapper.rb

@@ -47,12 +47,12 @@ module RubyLLM
         @run_id = run_id
         @redact = redact || RubyLLM::AgUI.config.redact
         @logger = logger || RubyLLM::AgUI.config.logger
-        @message_count = 0
-        @step_count = 0
+        @message_count = @step_count = 0
         @open_text_id = nil
         @last_message_id = nil
         @text_emitted = false
         @calls = {}
+        end_stream_keys
         @completed_tools = {}
         @open_step = nil
         @step_kind = nil
@@ -182,6 +182,7 @@ module RubyLLM
         events.concat(close_step)
         @last_message_id = nil
         @text_emitted = false
+        end_stream_keys
         events
       end
 
@@ -200,21 +201,47 @@ module RubyLLM
 
       # The record for one tool call, created on first sight.
       #
-      # A streamed delta is keyed by index and carries the id only on its first
-      # fragment; the complete message is keyed by id. Both keys point at the
-      # same record, so the call is opened once.
+      # A streamed delta is keyed by its provider stream index and carries the
+      # id only on its first fragment; the complete message is keyed by id. Both
+      # keys point at the same record, so the call is opened once. Providers
+      # restart stream indexes in every response, so an index names a call only
+      # until its completion ends. An unkeyed fragment continues the latest
+      # streamed call, and a fragment with a different id starts a new call
+      # under the same key, as RubyLLM's own accumulator does.
       def track(key, tool_call, streamed:)
-        record = @calls[key] || find_call(tool_call.id) || new_call
+        record = lookup_call(key, tool_call, streamed: streamed)
         record[:id] ||= tool_call.id
         record[:name] ||= tool_call.name
-        record[:streamed] ||= streamed
-        @calls[key] = record
+        remember_stream_call(key, record) if streamed
         @calls[record[:id]] = record if record[:id]
         record
       end
 
+      def lookup_call(key, tool_call, streamed:)
+        record = stream_call(key) if streamed
+        return record if record && continues?(record, tool_call)
+
+        find_call(tool_call.id) || new_call
+      end
+
+      def continues?(record, tool_call)
+        tool_call.id.nil? || record[:id].nil? || record[:id] == tool_call.id
+      end
+
+      def stream_call(key) = key.nil? ? @latest_stream_call : @stream_calls[key]
+
+      def remember_stream_call(key, record)
+        @stream_calls[key] = record unless key.nil?
+        @latest_stream_call = record
+      end
+
+      def end_stream_keys
+        @stream_calls = {}
+        @latest_stream_call = nil
+      end
+
       def new_call
-        { id: nil, name: nil, streamed: false, args_emitted: false, started: false, closed: false, buffered: nil }
+        { id: nil, name: nil, args_emitted: false, started: false, closed: false, buffered: nil }
       end
 
       def find_call(id)
@@ -260,19 +287,29 @@ module RubyLLM
       # A streamed chunk carries a fragment of the provider's own argument bytes
       # and goes out unchanged. A complete message carries the Hash RubyLLM
       # reconstructed from those bytes, so it is serialized once and only when
-      # the stream did not already deliver the fragments.
+      # the stream delivered no argument bytes for the call.
       def argument_delta(record, tool_call, streamed:)
-        return streamed_delta(tool_call) if streamed
-        return nil if record[:streamed] || record[:args_emitted]
+        delta = streamed ? streamed_delta(tool_call) : complete_delta(record, tool_call)
+        record[:args_emitted] = true unless delta.nil? || delta.empty?
+        delta
+      end
 
-        record[:args_emitted] = true
+      # Like RubyLLM's stream accumulator, an empty value carries no bytes:
+      # Anthropic and Bedrock open a call with an empty input object before
+      # streaming its partial JSON. Gemini streams a whole call as a parsed
+      # object, which is serialized as JSON.
+      def streamed_delta(tool_call)
         arguments = tool_call.arguments
+        return nil if arguments.nil? || (arguments.respond_to?(:empty?) && arguments.empty?)
+
         arguments.is_a?(String) ? arguments : Canonical.dump(arguments)
       end
 
-      def streamed_delta(tool_call)
+      def complete_delta(record, tool_call)
+        return nil if record[:args_emitted]
+
         arguments = tool_call.arguments
-        arguments.is_a?(String) ? arguments : arguments.to_s
+        arguments.is_a?(String) ? arguments : Canonical.dump(arguments)
       end
 
       def close_tool_calls

data/lib/ruby_llm/ag_ui/rails/active_record_store.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'record'
-
 module RubyLLM
   module AgUI
     module Rails
+      # Defining the row class loads ActiveRecord::Base. Defer it to first use,
+      # so requiring the gem during a Rails boot does not load Active Record
+      # before the host's configuration.
+      autoload :Record, File.expand_path('record', __dir__)
+
       # The durable run store: run identity in a table instead of a process.
       #
       # The in-process store is correct for one process only. A host that runs
@@ -43,8 +46,7 @@ module RubyLLM
         end
 
         def latest_interrupted(scope:, thread_id:)
-          interrupted = RunRecord::INTERRUPTED.to_s
-          thread_rows(scope, thread_id).reverse.find { |row| row.status == interrupted }&.as_run_record
+          interrupted_rows(scope, thread_id).last&.as_run_record
         end
 
         def save(record)
@@ -116,12 +118,19 @@ module RubyLLM
           Record.where(scope: scope, thread_id: thread_id).order(:id).to_a
         end
 
-        # An interrupt id is unique among a thread's runs, so the thread is
-        # searched newest first and the first row that knows the id wins. A
-        # thread holds few runs, and the alternative is a JSON query that would
-        # bind this store to one database.
+        # Only an interrupted run carries interrupts, and it keeps that status
+        # after they are answered. The status index finds those rows without
+        # loading every run on the thread.
+        def interrupted_rows(scope, thread_id)
+          Record.where(scope: scope, thread_id: thread_id, status: RunRecord::INTERRUPTED.to_s).order(:id).to_a
+        end
+
+        # An interrupt id is unique among a thread's runs, so the interrupted
+        # runs are searched newest first and the first row that knows the id
+        # wins. The alternative is a JSON query that would bind this store to
+        # one database.
         def row_for_interrupt(scope, thread_id, interrupt_id)
-          thread_rows(scope, thread_id).reverse.find { |row| row.as_run_record.interrupt(interrupt_id) }
+          interrupted_rows(scope, thread_id).reverse.find { |row| row.as_run_record.interrupt(interrupt_id) }
         end
       end
     end

data/lib/ruby_llm/ag_ui/rails/streaming.rb

@@ -66,10 +66,10 @@ module RubyLLM
           # identity claimed with different input or a resume that answers
           # nothing, 413 for a body past the configured bound.
           reject_ag_ui_request(e.http_status, e.message)
-        rescue ::ActiveRecord::RecordNotFound
-          reject_ag_ui_request(NOT_FOUND, 'There is no such thread.')
         rescue ::RubyLLM::AgUI::StreamError => e
           reject_ag_ui_request(CONFLICT, e.message)
+        rescue StandardError => e
+          reject_ag_ui_host_error(e)
         end
 
         # The tenant/actor key every reservation is bounded by.
@@ -89,6 +89,12 @@ module RubyLLM
 
         private
 
+        def reject_ag_ui_host_error(error)
+          raise error unless defined?(::ActiveRecord::RecordNotFound) && error.is_a?(::ActiveRecord::RecordNotFound)
+
+          reject_ag_ui_request(NOT_FOUND, 'There is no such thread.')
+        end
+
         # Whether this client can read an event stream. An AG-UI client asks for
         # `text/event-stream`; a request that asks for something else is told so
         # instead of being streamed at.

data/lib/ruby_llm/ag_ui/redaction.rb

@@ -51,8 +51,10 @@ module RubyLLM
 
       # Calls +callable+ with the arguments its arity takes, so a host can write
       # either `->(kind, payload) { ... }` or the terse `->(payload) { ... }`.
+      # A policy object that only defines #call is read the same way.
       def apply(callable, kind, payload)
-        callable.arity == 1 ? callable.call(payload) : callable.call(kind, payload)
+        arity = callable.respond_to?(:arity) ? callable.arity : callable.method(:call).arity
+        arity == 1 ? callable.call(payload) : callable.call(kind, payload)
       end
     end
   end

data/lib/ruby_llm/ag_ui/run.rb

@@ -97,7 +97,7 @@ module RubyLLM
       rescue StandardError => e
         @record = finalize { @emitter.fail(e) }
       ensure
-        finalize { @mapper&.close }
+        finalize { release }
       end
 
       def start_execution(record, to)
@@ -132,8 +132,15 @@ module RubyLLM
 
       def finalize(&) = @mutex.synchronize(&)
 
-      def project
-        @mutex.synchronize { @emitter.write(yield) }
+      # After release, a stale callback maps and writes nothing.
+      def project = @mutex.synchronize { @emitter&.write(yield) }
+
+      # The callbacks this run registered stay on the chat after it ends, and
+      # RubyLLM cannot remove them. The closed mapper maps nothing further, and
+      # dropping the emitter lets the response stream it writes to be freed.
+      def release
+        @mapper&.close
+        @emitter = nil
       end
 
       # A run that stopped for a human is an interrupt, never a success. Any
@@ -178,10 +185,7 @@ module RubyLLM
           raise ConfigurationError, 'chat must be a RubyLLM::Chat or act like one (it does not respond to #complete)'
         end
         raise ConfigurationError, 'input must be a RubyLLM::AgUI::Input' unless @input.is_a?(Input)
-
-        return if @scope.is_a?(String) && !@scope.empty?
-
-        raise ConfigurationError, Store::Base::SCOPE_MESSAGE
+        raise ConfigurationError, Store::Base::SCOPE_MESSAGE unless @scope.is_a?(String) && !@scope.empty?
       end
     end
   end

data/lib/ruby_llm/ag_ui/sse_writer.rb

@@ -48,14 +48,31 @@ module RubyLLM
       #
       # A host calls this before opening the stream. An explicit header that
       # cannot accept `text/event-stream` is a client that will not understand
-      # the response, so the host should answer 406 instead of streaming.
+      # the response, so the host should answer 406 instead of streaming. A zero
+      # quality refuses that range; a more specific range overrides a wildcard.
       def self.accepts?(accept)
         return true if accept.nil? || accept.strip.empty?
 
-        accept.split(',').any? do |range|
-          %w[text/event-stream text/* */*].include?(range.split(';').first.to_s.strip.downcase)
+        matches = accept.split(',').filter_map do |range|
+          media_type, *parameters = range.downcase.split(';').map(&:strip)
+          specificity = %w[*/* text/* text/event-stream].index(media_type)
+          next if specificity.nil?
+
+          [specificity, accept_quality(parameters)]
         end
+        return false if matches.empty?
+
+        matches.max.last.positive?
+      end
+
+      def self.accept_quality(parameters)
+        quality = parameters.find { |parameter| parameter.split('=', 2).first.to_s.strip == 'q' }
+        return 1.0 unless quality
+
+        value = quality.split('=', 2).last.to_s.strip
+        value.match?(/\A(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)\z/) ? value.to_f : 0.0
       end
+      private_class_method :accept_quality
 
       # The Content-Type for the response the host is about to open.
       def content_type

data/lib/ruby_llm/ag_ui/version.rb

@@ -3,6 +3,6 @@
 module RubyLLM
   module AgUI
     # The version of the ruby_llm-ag_ui gem, as a string.
-    VERSION = '0.4.0'
+    VERSION = '1.0.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-ag_ui
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Andy Wang
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-21 00:00:00.000000000 Z
+date: 2026-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ag-ui-protocol
@@ -176,7 +176,7 @@ files:
 - docs/_getting_started/configuration.md
 - docs/_getting_started/getting-started.md
 - docs/_getting_started/overview.md
-- docs/_getting_started/whats-new-in-0-4.md
+- docs/_getting_started/whats-new-in-1-0.md
 - docs/_reference/api-reference.md
 - docs/_reference/compatibility.md
 - docs/_reference/protocol-coverage.md
@@ -188,6 +188,7 @@ files:
 - docs/_reference/whats-new-in-0-1.md
 - docs/_reference/whats-new-in-0-2.md
 - docs/_reference/whats-new-in-0-3.md
+- docs/_reference/whats-new-in-0-4.md
 - docs/index.md
 - lib/generators/ruby_llm/ag_ui/install_generator.rb
 - lib/generators/ruby_llm/ag_ui/templates/create_ruby_llm_ag_ui_runs.rb.tt
@@ -240,7 +241,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="