ai_stream 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a2d50ba3d9bb262b476d90beaafce8b11a324f6239003efe3ce7edf6cb1c196e
+  data.tar.gz: 813ea5c8a9768269b65e7e7c4f275ed3be9d0c1567ac9e55228ff64569cc4bd7
+SHA512:
+  metadata.gz: c31fda77fe3a3fb48b105847a1556a3aa6b8490941b15c8d82bb7dc3dd04923cb72dea3490da1c7d3a000a9eff764f0a6a888e094b578f869f88543165b5146b
+  data.tar.gz: d2c4d97681e3afb524a093f6c646f00928b6bbc9f393632b02a2f1c82dc806c8bea3187c020cbde6e7ec5ca88863bab6dda8e0d275f6ec30353831e7149f3e39

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to this project are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-05-28
+
+### Added
+- `AiStream::Writer` — encoder for the Vercel AI SDK Data Stream / UI Message
+  Stream Protocol over Server-Sent Events. Covers the full documented part set:
+  - lifecycle: `start`, `start-step`, `finish-step`, `finish`, `abort`, `error`
+  - text: `text-start`, `text-delta`, `text-end` (+ `#text` convenience)
+  - reasoning: `reasoning-start`, `reasoning-delta`, `reasoning-end`
+  - tools: `tool-input-start`, `tool-input-delta`, `tool-input-available`,
+    `tool-output-available` (+ `#tool_call` convenience)
+  - sources/files: `source-url`, `source-document`, `file`
+  - custom: `data-*` parts
+  - low-level `#emit` for forward-compatibility with future part types
+- `AiStream::Stream` — lazy, re-enumerable, Rack-compatible response body that
+  runs a block against a `Writer`, frames each part as SSE, and appends the
+  `[DONE]` sentinel automatically.
+- `AiStream::HEADERS` — the required `x-vercel-ai-ui-message-stream: v1` header.
+- Pure Ruby, zero runtime dependencies.
+
+[Unreleased]: https://github.com/tachyurgy/ai_stream/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/tachyurgy/ai_stream/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Levelbrook Consulting
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,183 @@
+# ai_stream
+
+[![CI](https://github.com/tachyurgy/ai_stream/actions/workflows/ci.yml/badge.svg)](https://github.com/tachyurgy/ai_stream/actions/workflows/ci.yml)
+
+**Speak the Vercel AI SDK's streaming protocol from Ruby.**
+
+The [Vercel AI SDK](https://ai-sdk.dev) is the de-facto frontend toolkit for AI apps — its
+`useChat`, `useCompletion`, and `useObject` hooks power a huge share of the AI UIs shipping
+today. Those hooks consume a specific [Data Stream Protocol](https://ai-sdk.dev/docs/ai-sdk-ui/stream-protocol)
+(a.k.a. the **UI Message Stream Protocol**): a Server-Sent-Events wire format that is
+*language-agnostic by design* — Vercel documents Python/FastAPI backends speaking it.
+
+Ruby had nothing. If you wanted the polished Vercel `useChat` frontend in front of a Rails
+app, you had to hand-roll the SSE framing and the exact `text-start` / `text-delta` /
+`tool-input-available` / `finish` part encoding by reading the TypeScript source.
+
+`ai_stream` is a faithful, pure-Ruby, **zero-dependency** encoder for that protocol. It's
+**provider-agnostic**: it sits *downstream* of whatever produced the tokens
+([ruby_llm](https://github.com/crmne/ruby_llm), [ruby-openai](https://github.com/alexrudall/ruby-openai),
+a raw HTTP stream, or canned text), so it composes with the existing Ruby AI stack instead
+of competing with it.
+
+## Installation
+
+```ruby
+# Gemfile
+gem "ai_stream"
+```
+
+```sh
+bundle install
+```
+
+Or:
+
+```sh
+gem install ai_stream
+```
+
+## Quick start
+
+```ruby
+require "ai_stream"
+
+body = AiStream::Stream.new do |w|
+  w.start                      # {"type":"start","messageId":"..."}
+  id = w.text_start            # {"type":"text-start","id":"..."}
+  w.text_delta("Hello", id: id)
+  w.text_delta(" world", id: id)
+  w.text_end(id: id)
+  w.finish                     # {"type":"finish"}
+end
+
+puts body.to_s
+# data: {"type":"start","messageId":"..."}
+#
+# data: {"type":"text-start","id":"..."}
+#
+# data: {"type":"text-delta","id":"...","delta":"Hello"}
+#
+# data: {"type":"text-delta","id":"...","delta":" world"}
+#
+# data: {"type":"text-end","id":"..."}
+#
+# data: {"type":"finish"}
+#
+# data: [DONE]
+```
+
+## In Rails (streaming to `useChat`)
+
+```ruby
+class ChatController < ApplicationController
+  include ActionController::Live
+
+  def create
+    # Required header so the AI SDK treats this as a UI message stream:
+    AiStream::HEADERS.each { |k, v| response.headers[k] = v }
+    response.headers["Content-Type"] = "text/event-stream"
+
+    AiStream::Stream.new do |w|
+      w.start
+      id = w.text_start
+      # Pipe tokens from any source. Example with ruby_llm:
+      RubyLLM.chat.ask(params[:prompt]) do |chunk|
+        w.text_delta(chunk.content, id: id)
+      end
+      w.text_end(id: id)
+      w.finish
+    end.each { |frame| response.stream.write(frame) }
+  ensure
+    response.stream.close
+  end
+end
+```
+
+Frontend, unchanged from any Vercel AI SDK app:
+
+```tsx
+const { messages, sendMessage } = useChat({ api: "/chat" });
+```
+
+## In plain Rack
+
+`AiStream::Stream` is a valid Rack response body (it responds to `#each` and yields complete
+SSE frames):
+
+```ruby
+run lambda { |env|
+  body = AiStream::Stream.new do |w|
+    w.start
+    w.text("Hi from Rack")
+    w.finish
+  end
+  headers = AiStream::HEADERS.merge("content-type" => "text/event-stream")
+  [200, headers, body]
+}
+```
+
+## Tool calls
+
+The protocol streams tool calls as a lifecycle. For incrementally-produced arguments:
+
+```ruby
+AiStream::Stream.new do |w|
+  w.start
+  w.start_step
+  w.tool_input_start(tool_call_id: "t1", tool_name: "get_weather")
+  w.tool_input_delta(tool_call_id: "t1", delta: '{"city":')
+  w.tool_input_delta(tool_call_id: "t1", delta: '"SF"}')
+  w.tool_input_available(tool_call_id: "t1", tool_name: "get_weather", input: { city: "SF" })
+  w.tool_output_available(tool_call_id: "t1", output: { temp: 64 })
+  w.finish_step
+  w.start_step
+  w.text("It's 64°F in San Francisco.")
+  w.finish_step
+  w.finish
+end
+```
+
+When the input is already known, `#tool_call` collapses the two parts (and shares a
+`toolCallId`):
+
+```ruby
+w.tool_call(tool_name: "search", input: { q: "ruby" }, output: { hits: 3 })
+```
+
+## Supported parts
+
+Every part type from the AI SDK UI Stream Protocol:
+
+| Category | Writer methods |
+|---|---|
+| Lifecycle | `start`, `start_step`, `finish_step`, `finish`, `abort`, `error` |
+| Text | `text_start`, `text_delta`, `text_end`, `text` |
+| Reasoning | `reasoning_start`, `reasoning_delta`, `reasoning_end` |
+| Tools | `tool_input_start`, `tool_input_delta`, `tool_input_available`, `tool_output_available`, `tool_call` |
+| Sources / files | `source_url`, `source_document`, `file` |
+| Custom data | `data(name, payload)` → `data-<name>` |
+| Forward-compat | `emit(type:, ...)` for any part type added after this release |
+
+The stream is terminated with the SSE `data: [DONE]` sentinel automatically by
+`AiStream::Stream`; if you drive a `Writer` directly, call `#done` yourself.
+
+## Why a `Writer` *and* a `Stream`?
+
+- **`AiStream::Writer`** is the low-level encoder. Give it any sink that responds to `<<`
+  (a `String`, an `IO`, a Rack stream). It does no IO of its own, which makes it trivial to
+  unit-test — feed it a `String` and assert on the bytes. (That's exactly how this gem's own
+  tests work, with **no API key required**.)
+- **`AiStream::Stream`** wraps a `Writer` in a lazy, re-enumerable, Rack-compatible body and
+  handles the `[DONE]` terminator for you.
+
+## Development
+
+```sh
+bin/setup        # or: bundle install
+bundle exec rake test
+```
+
+## License
+
+[MIT](LICENSE) © [Levelbrook Consulting](https://consulting.levelbrook.com)

data/lib/ai_stream/stream.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module AiStream
+  # Stream is a lazy, Rack-compatible response body that produces UI Message
+  # Stream Protocol frames on demand.
+  #
+  # You pass a block that receives a Writer; the block runs the first time the
+  # body is enumerated (i.e. when Rack/Rails pulls bytes to send to the client),
+  # so nothing is buffered eagerly and the very first token can flush
+  # immediately. The terminating `data: [DONE]` frame is appended automatically
+  # unless the block already wrote it.
+  #
+  # Rack:
+  #
+  #   body = AiStream::Stream.new do |w|
+  #     w.start
+  #     w.text("Hello")
+  #     w.finish
+  #   end
+  #   [200, AiStream::HEADERS.merge("content-type" => "text/event-stream"), body]
+  #
+  # Rails (controller):
+  #
+  #   include ActionController::Live
+  #   def chat
+  #     AiStream::HEADERS.each { |k, v| response.headers[k] = v }
+  #     response.headers["Content-Type"] = "text/event-stream"
+  #     AiStream::Stream.new { |w| w.start; w.text("hi"); w.finish }.each { |chunk| response.stream.write(chunk) }
+  #   ensure
+  #     response.stream.close
+  #   end
+  #
+  # Or, even simpler, collect to a String for tests / non-streaming responses:
+  #
+  #   AiStream::Stream.new { |w| w.start; w.text("hi"); w.finish }.to_s
+  #
+  class Stream
+    include Enumerable
+
+    # @yieldparam writer [AiStream::Writer]
+    def initialize(&block)
+      raise ArgumentError, "AiStream::Stream requires a block" unless block
+
+      @block = block
+    end
+
+    # Rack body contract. Yields each SSE frame string. Re-enumerable: the block
+    # is run fresh on every #each so the same Stream can be rendered twice
+    # (handy in tests).
+    def each
+      return enum_for(:each) unless block_given?
+
+      sink = FrameSink.new { |frame| yield frame }
+      writer = Writer.new(sink)
+      @block.call(writer)
+      writer.done unless writer.closed?
+      self
+    end
+
+    # Materialize the whole stream into one String.
+    def to_s
+      buf = String.new
+      each { |frame| buf << frame }
+      buf
+    end
+
+    # A tiny sink adapter: turns Writer's `sink << frame` into a yielded chunk.
+    class FrameSink
+      def initialize(&on_frame)
+        @on_frame = on_frame
+      end
+
+      def <<(frame)
+        @on_frame.call(frame)
+        self
+      end
+    end
+  end
+end

data/lib/ai_stream/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AiStream
+  VERSION = "0.1.0"
+end

data/lib/ai_stream/writer.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+
+module AiStream
+  # Writer encodes the Vercel AI SDK "Data Stream Protocol" (a.k.a. UI Message
+  # Stream Protocol) onto an arbitrary sink.
+  #
+  # The protocol is a sequence of Server-Sent Events. Every event is a single
+  # JSON object framed as:
+  #
+  #   data: {"type":"text-delta","id":"...","delta":"Hi"}\n\n
+  #
+  # and the stream is terminated with the sentinel:
+  #
+  #   data: [DONE]\n\n
+  #
+  # A consuming frontend (Vercel AI SDK's useChat / useCompletion / useObject)
+  # expects the HTTP response header `x-vercel-ai-ui-message-stream: v1`
+  # (see AiStream::HEADERS).
+  #
+  # The sink is anything that responds to `<<` (a String, an IO, a Rack stream,
+  # an Array buffer, ...). The Writer never performs IO itself beyond `sink <<`,
+  # which keeps it trivially unit-testable: feed it a String and assert on bytes.
+  #
+  # Example:
+  #
+  #   buf = +""
+  #   w = AiStream::Writer.new(buf)
+  #   w.start
+  #   id = w.text_start
+  #   w.text_delta("Hello", id: id)
+  #   w.text_delta(" world", id: id)
+  #   w.text_end(id: id)
+  #   w.finish
+  #   w.done
+  #
+  class Writer
+    # Returns a freshly generated id when callers don't supply one. Exposed so
+    # text/reasoning/tool parts can share an id across their start/delta/end
+    # lifecycle.
+    def self.generate_id
+      SecureRandom.uuid
+    end
+
+    attr_reader :sink
+
+    # @param sink [#<<] anything that accepts string chunks (IO, String, Rack body, ...)
+    def initialize(sink)
+      @sink = sink
+      @closed = false
+    end
+
+    # --- Lifecycle -----------------------------------------------------------
+
+    # Emit the message-start frame. messageId is optional; one is generated when
+    # omitted so the frontend always has a stable id to key the message on.
+    def start(message_id: nil)
+      mid = message_id || self.class.generate_id
+      emit(type: "start", messageId: mid)
+      mid
+    end
+
+    # Multi-step runs (tool call -> tool result -> more text) are bracketed by
+    # start-step / finish-step pairs.
+    def start_step
+      emit(type: "start-step")
+    end
+
+    def finish_step
+      emit(type: "finish-step")
+    end
+
+    # Terminal message frame. Does NOT write the SSE [DONE] sentinel; call #done
+    # for that (kept separate so callers can finish a message but keep the HTTP
+    # connection open, which some multi-message flows want).
+    def finish
+      emit(type: "finish")
+    end
+
+    # Cooperative cancellation frame.
+    def abort(reason: nil)
+      part = { type: "abort" }
+      part[:reason] = reason unless reason.nil?
+      emit(part)
+    end
+
+    # Surface an error to the client. The frontend renders `errorText`.
+    def error(text)
+      emit(type: "error", errorText: text.to_s)
+    end
+
+    # --- Text ----------------------------------------------------------------
+
+    # Begin a text block. Returns the block id to thread through deltas/end.
+    def text_start(id: nil)
+      tid = id || self.class.generate_id
+      emit(type: "text-start", id: tid)
+      tid
+    end
+
+    def text_delta(delta, id:)
+      emit(type: "text-delta", id: id, delta: delta.to_s)
+    end
+
+    def text_end(id:)
+      emit(type: "text-end", id: id)
+    end
+
+    # Convenience: emit a whole text block (start + single delta + end) at once.
+    # Returns the block id.
+    def text(content, id: nil)
+      tid = text_start(id: id)
+      text_delta(content, id: tid)
+      text_end(id: tid)
+      tid
+    end
+
+    # --- Reasoning -----------------------------------------------------------
+
+    def reasoning_start(id: nil)
+      rid = id || self.class.generate_id
+      emit(type: "reasoning-start", id: rid)
+      rid
+    end
+
+    def reasoning_delta(delta, id:)
+      emit(type: "reasoning-delta", id: id, delta: delta.to_s)
+    end
+
+    def reasoning_end(id:)
+      emit(type: "reasoning-end", id: id)
+    end
+
+    # --- Sources & files -----------------------------------------------------
+
+    def source_url(url, source_id: nil, title: nil)
+      part = { type: "source-url", sourceId: source_id || self.class.generate_id, url: url }
+      part[:title] = title unless title.nil?
+      emit(part)
+    end
+
+    def source_document(media_type:, title:, source_id: nil)
+      emit(
+        type: "source-document",
+        sourceId: source_id || self.class.generate_id,
+        mediaType: media_type,
+        title: title
+      )
+    end
+
+    def file(url:, media_type:)
+      emit(type: "file", url: url, mediaType: media_type)
+    end
+
+    # --- Custom data parts ---------------------------------------------------
+
+    # Emits a `data-<name>` part. The frontend matches on the full type string,
+    # so a name of "weather" produces {"type":"data-weather","data":{...}}.
+    def data(name, payload)
+      emit(type: "data-#{name}", data: payload)
+    end
+
+    # --- Tool calls ----------------------------------------------------------
+
+    # Streaming tool-input lifecycle (when arguments are produced incrementally):
+    #   tool_input_start -> tool_input_delta* -> tool_input_available
+    def tool_input_start(tool_call_id:, tool_name:)
+      emit(type: "tool-input-start", toolCallId: tool_call_id, toolName: tool_name)
+    end
+
+    def tool_input_delta(tool_call_id:, delta:)
+      emit(type: "tool-input-delta", toolCallId: tool_call_id, inputTextDelta: delta.to_s)
+    end
+
+    # Final, parsed tool input. `input` is any JSON-serializable object.
+    def tool_input_available(tool_call_id:, tool_name:, input:)
+      emit(type: "tool-input-available", toolCallId: tool_call_id, toolName: tool_name, input: input)
+    end
+
+    # The result of executing the tool. `output` is any JSON-serializable object.
+    def tool_output_available(tool_call_id:, output:)
+      emit(type: "tool-output-available", toolCallId: tool_call_id, output: output)
+    end
+
+    # Convenience: emit a complete non-streamed tool call (input known up front
+    # plus its output) inside its own step.
+    def tool_call(tool_name:, input:, output:, tool_call_id: nil)
+      id = tool_call_id || self.class.generate_id
+      tool_input_available(tool_call_id: id, tool_name: tool_name, input: input)
+      tool_output_available(tool_call_id: id, output: output)
+      id
+    end
+
+    # --- Low level -----------------------------------------------------------
+
+    # Emit a raw, pre-shaped part hash. Validates that :type is present, JSON
+    # encodes it, and writes one SSE event. Useful for protocol part types added
+    # after this gem's release.
+    def emit(part)
+      raise ClosedError, "stream already terminated with [DONE]" if @closed
+
+      hash = part.is_a?(Hash) ? part : part.to_h
+      raise ArgumentError, "part must include a :type" unless hash[:type] || hash["type"]
+
+      write_frame(JSON.generate(hash))
+      self
+    end
+
+    # Write the SSE terminator. After this, further emits raise ClosedError.
+    def done
+      return self if @closed
+
+      write_frame("[DONE]")
+      @closed = true
+      self
+    end
+
+    def closed?
+      @closed
+    end
+
+    private
+
+    def write_frame(payload)
+      @sink << "data: #{payload}\n\n"
+    end
+  end
+end

data/lib/ai_stream.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "ai_stream/version"
+require_relative "ai_stream/writer"
+require_relative "ai_stream/stream"
+
+# AiStream is a pure-Ruby implementation of the Vercel AI SDK
+# "Data Stream Protocol" (UI Message Stream Protocol) — the Server-Sent-Events
+# wire format that drives the AI SDK's `useChat` / `useCompletion` / `useObject`
+# frontend hooks.
+#
+# The protocol is language-agnostic by design (Vercel documents non-JS backends
+# such as Python/FastAPI speaking it), but Ruby had no implementation. This gem
+# lets a Rails/Rack backend stream text, reasoning, tool calls, sources, files,
+# and custom data parts to a Vercel-AI-SDK frontend with the exact frames it
+# expects.
+#
+# AiStream is provider-agnostic: it sits downstream of whatever produced the
+# tokens (ruby_llm, ruby-openai, a raw HTTP stream, or canned text), so it
+# composes with the existing Ruby AI stack rather than competing with it.
+#
+# See AiStream::Writer for the encoder and AiStream::Stream for the lazy,
+# Rack-compatible response body.
+module AiStream
+  class Error < StandardError; end
+
+  # Raised when emitting onto a stream that already wrote the [DONE] sentinel.
+  class ClosedError < Error; end
+
+  # The HTTP response header the Vercel AI SDK requires to treat a response as a
+  # UI message stream. Merge this into your Rack/Rails headers.
+  HEADERS = {
+    "x-vercel-ai-ui-message-stream" => "v1"
+  }.freeze
+
+  # Protocol version implemented by this gem (the `v1` of the header above).
+  PROTOCOL_VERSION = "v1"
+
+  # The SSE terminator the frontend watches for to know the stream is complete.
+  DONE_SENTINEL = "[DONE]"
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: ai_stream
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Levelbrook Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: |-
+  A pure-Ruby, zero-dependency implementation of the Vercel AI SDK "Data Stream Protocol"
+  (UI Message Stream Protocol) — the Server-Sent-Events wire format that drives the AI SDK's
+  useChat / useCompletion / useObject frontend hooks. The protocol is language-agnostic by
+  design, but Ruby had no implementation; ai_stream lets a Rails/Rack backend stream text,
+  reasoning, tool calls, sources, files, and custom data parts to a Vercel-AI-SDK frontend
+  with the exact frames it expects. Provider-agnostic: it composes with ruby_llm, ruby-openai,
+  or any token source instead of competing with them.
+email:
+- levelbrookteam@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/ai_stream.rb
+- lib/ai_stream/stream.rb
+- lib/ai_stream/version.rb
+- lib/ai_stream/writer.rb
+homepage: https://consulting.levelbrook.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://consulting.levelbrook.com
+  source_code_uri: https://github.com/tachyurgy/ai_stream
+  changelog_uri: https://github.com/tachyurgy/ai_stream/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby encoder for the Vercel AI SDK Data Stream (UI Message Stream) Protocol.
+test_files: []