diff --git a/.github/workflows/build-runai-model-streamer-s3.yml b/.github/workflows/build-runai-model-streamer-s3.yml
new file mode 100644
index 00000000000..3a83e441020
--- /dev/null
+++ b/.github/workflows/build-runai-model-streamer-s3.yml
@@ -0,0 +1,484 @@
+# SPDX-FileCopyrightText: 2026 The RISE Project
+# SPDX-License-Identifier: MIT
+#
+# This workflow is based on: https://github.com/run-ai/runai-model-streamer/blob/master/Makefile
+# and https://github.com/run-ai/runai-model-streamer/blob/master/.devcontainer/Dockerfile
+---
+name: Build runai-model-streamer-s3 wheels (riscv64)
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version glob to (re)build; empty builds every version of docs/packages/runai-model-streamer-s3.yaml not released yet'
+        required: false
+        default: ''
+  pull_request:
+    branches: [main]
+    paths:
+      - '.github/workflows/build-runai-model-streamer-s3.yml'
+      - 'docs/packages/runai-model-streamer-s3.yaml'
+      - 'patches/runai-model-streamer-s3/**'
+  push:
+    branches: [main]
+    paths:
+      - '.github/workflows/build-runai-model-streamer-s3.yml'
+      - 'docs/packages/runai-model-streamer-s3.yaml'
+      - 'patches/runai-model-streamer-s3/**'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+env:
+  MANYLINUX_RISCV64_IMAGE: quay.io/pypa/manylinux_2_39_riscv64
+  BAZEL_VERSION: '7.6.1'
+  RULES_PYTHON_VERSION: '0.33.2'
+  RULES_JAVA_VERSION: '7.6.5'
+  OPENSSL_VERSION: '3.5.0'
+  CURL_VERSION: '8.13.0'
+  ZLIB_VERSION: '1.3.1'
+  AWS_SDK_CPP_VERSION: '1.11.584'
+  # dl.min.io no longer serves server binaries for any arch; built from the last release tag.
+  MINIO_VERSION: 'RELEASE.2025-10-15T17-29-55Z'
+
+jobs:
+  setup:
+    uses: $/.github/workflows/_setup.yml
+    with:
+      package: runai-model-streamer-s3
+      version: ${{ inputs.version }}
+
+  bazel:
+    needs: [setup]
+    if: needs.setup.outputs.versions != '[]'
+    name: Bootstrap bazel (riscv64)
+    runs-on: ubuntu-24.04-riscv
+    timeout-minutes: 120
+
+    steps:
+      - name: Restore bazel binary
+        id: cache
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9  # v6.1.0
+        with:
+          path: bazel-bin
+          key: bazel-${{ env.BAZEL_VERSION }}-manylinux_riscv64
+
+      - name: Bootstrap bazel ${{ env.BAZEL_VERSION }}
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: |
+          mkdir -p bazel-bin
+          docker run --rm -i --network=host \
+            -v "${GITHUB_WORKSPACE}:/work" \
+            -w /work \
+            -e BAZEL_VERSION="${BAZEL_VERSION}" \
+            -e RULES_PYTHON_VERSION="${RULES_PYTHON_VERSION}" \
+            -e RULES_JAVA_VERSION="${RULES_JAVA_VERSION}" \
+            "${MANYLINUX_RISCV64_IMAGE}" \
+            bash <<'SCRIPT'
+          set -eux
+
+          dnf install -y --setopt=install_weak_deps=False java-21-openjdk-devel zip unzip
+          JAVA_HOME="$(dirname "$(dirname "$(readlink -f "$(command -v javac)")")")"
+          export JAVA_HOME
+
+          # rules_python 0.33.2 has no riscv64 PLATFORMS entry (bazelbuild/bazel#23018).
+          mkdir -p /tmp/rules_python
+          curl -fsSLo /tmp/rules_python.tar.gz "https://github.com/bazel-contrib/rules_python/releases/download/${RULES_PYTHON_VERSION}/rules_python-${RULES_PYTHON_VERSION}.tar.gz"
+          tar -xzf /tmp/rules_python.tar.gz -C /tmp/rules_python --strip-components=1
+          sed -i 's|fail("No platform declared for host OS {} on arch {}".format(os_name, arch))|return "x86_64-unknown-linux-gnu"|' \
+            /tmp/rules_python/python/private/toolchains_repo.bzl
+
+          # rules_java 7.x maps riscv64 to a stray-colon include path for jni_md.h.
+          mkdir -p /tmp/rules_java
+          curl -fsSLo /tmp/rules_java.tar.gz "https://github.com/bazelbuild/rules_java/releases/download/${RULES_JAVA_VERSION}/rules_java-${RULES_JAVA_VERSION}.tar.gz"
+          tar -xzf /tmp/rules_java.tar.gz -C /tmp/rules_java
+          sed -i 's|\[":include/linux"\]|["include/linux"]|g' /tmp/rules_java/toolchains/BUILD
+
+          mkdir -p /tmp/bazel-src
+          cd /tmp/bazel-src
+          curl -fsSLo dist.zip "https://github.com/bazelbuild/bazel/releases/download/${BAZEL_VERSION}/bazel-${BAZEL_VERSION}-dist.zip"
+          unzip -q dist.zip
+
+          EXTRA_BAZEL_ARGS="--tool_java_runtime_version=local_jdk \
+            --override_module=rules_python=/tmp/rules_python \
+            --override_module=rules_java=/tmp/rules_java" \
+            bash ./compile.sh
+          install -m 0755 output/bazel /work/bazel-bin/bazel
+          SCRIPT
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
+        with:
+          name: bazel-${{ env.BAZEL_VERSION }}-riscv64
+          path: bazel-bin/bazel
+          if-no-files-found: error
+
+  minio:
+    needs: [setup]
+    if: needs.setup.outputs.versions != '[]'
+    name: Build MinIO (riscv64)
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+      - uses: actions/setup-go@b7ad1dad31e06c5925ef5d2fc7ad053ef454303e  # v7.0.0
+        with:
+          go-version: 'stable'
+          cache: false
+
+      - name: Build MinIO ${{ env.MINIO_VERSION }}
+        env:
+          CGO_ENABLED: '0'
+          GOOS: linux
+          GOARCH: riscv64
+        run: |
+          go install "github.com/minio/minio@${MINIO_VERSION}"
+          mkdir -p minio
+          cp "$(go env GOPATH)/bin/linux_riscv64/minio" minio/minio
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
+        with:
+          name: minio-riscv64
+          path: minio/minio
+          if-no-files-found: error
+
+  build_wheel:
+    name: Build runai-model-streamer-s3 ${{ matrix.version }} py3-none-manylinux_riscv64
+    needs: [setup, bazel]
+    if: needs.setup.outputs.versions != '[]'
+    runs-on: ubuntu-24.04-riscv
+    timeout-minutes: 300
+    strategy:
+      fail-fast: false
+      matrix:
+        version: ${{ fromJSON(needs.setup.outputs.versions) }}
+
+    env:
+      RUNAI_MODEL_STREAMER_VERSION: ${{ matrix.version }}
+
+    steps:
+      - name: Checkout runai-model-streamer ${{ env.RUNAI_MODEL_STREAMER_VERSION }}
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
+        with:
+          repository: run-ai/runai-model-streamer
+          ref: ${{ env.RUNAI_MODEL_STREAMER_VERSION }}
+          path: runai-model-streamer
+          persist-credentials: false
+
+      - name: Checkout python-wheels
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
+        with:
+          path: python-wheels
+          persist-credentials: false
+
+      - name: Patch runai-model-streamer source
+        working-directory: runai-model-streamer
+        run: git apply -v ../python-wheels/patches/runai-model-streamer-s3/${{ env.RUNAI_MODEL_STREAMER_VERSION }}/*.patch
+
+      - name: Download bazel
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
+        with:
+          name: bazel-${{ env.BAZEL_VERSION }}-riscv64
+          path: bazel-bin
+
+      - name: Restore OpenSSL, curl, zlib and the AWS SDK
+        id: deps-cache
+        uses: actions/cache/restore@55cc8345863c7cc4c66a329aec7e433d2d1c52a9  # v6.1.0
+        with:
+          path: deps
+          key: runai-model-streamer-s3-deps-manylinux_2_39_riscv64-${{ hashFiles('python-wheels/.github/workflows/build-runai-model-streamer-s3.yml') }}
+
+      - name: Build OpenSSL, curl, zlib and the AWS SDK
+        if: steps.deps-cache.outputs.cache-hit != 'true'
+        run: |
+          mkdir -p deps/riscv64-ssl deps/riscv64-curl deps/riscv64-zlib deps/riscv64-aws deps/licenses
+          docker run --rm -i --network=host \
+            -v "${GITHUB_WORKSPACE}:/work" \
+            -v "${GITHUB_WORKSPACE}/deps/riscv64-ssl:/opt/riscv64-ssl" \
+            -v "${GITHUB_WORKSPACE}/deps/riscv64-curl:/opt/riscv64-curl" \
+            -v "${GITHUB_WORKSPACE}/deps/riscv64-zlib:/opt/riscv64-zlib" \
+            -v "${GITHUB_WORKSPACE}/deps/riscv64-aws:/opt/riscv64-aws" \
+            -w /tmp \
+            -e OPENSSL_VERSION="${OPENSSL_VERSION}" \
+            -e CURL_VERSION="${CURL_VERSION}" \
+            -e ZLIB_VERSION="${ZLIB_VERSION}" \
+            -e AWS_SDK_CPP_VERSION="${AWS_SDK_CPP_VERSION}" \
+            "${MANYLINUX_RISCV64_IMAGE}" \
+            bash <<'SCRIPT'
+          set -eux
+
+          # OpenSSL's Configure needs perl modules the image's minimal perl-interpreter lacks.
+          dnf install -y --setopt=install_weak_deps=False perl
+          LICENSES=/work/deps/licenses
+
+          curl -fsSL -o "openssl-${OPENSSL_VERSION}.tar.gz" "https://www.openssl.org/source/openssl-${OPENSSL_VERSION}.tar.gz"
+          tar zxf "openssl-${OPENSSL_VERSION}.tar.gz"
+          cd "openssl-${OPENSSL_VERSION}"
+          ./Configure no-ssl2 no-zlib no-shared no-comp no-dynamic-engine enable-ec_nistp_64_gcc_128 \
+            --prefix=/opt/riscv64-ssl --openssldir=/opt/riscv64-ssl --libdir=lib linux64-riscv64
+          make -j"$(nproc)" > /dev/null
+          make install_sw > /dev/null
+          cp LICENSE.txt "$LICENSES/LICENSE.openssl"
+          cd /tmp
+
+          curl -fsSL -o "curl-${CURL_VERSION}.tar.gz" "https://github.com/curl/curl/releases/download/curl-${CURL_VERSION//./_}/curl-${CURL_VERSION}.tar.gz"
+          tar zxf "curl-${CURL_VERSION}.tar.gz"
+          cd "curl-${CURL_VERSION}"
+          # Keep libcurl.a to the libraries the @aws link line names, whatever -devel the image carries.
+          CPPFLAGS=-I/opt/riscv64-ssl/include \
+          LDFLAGS=-L/opt/riscv64-ssl/lib \
+          CFLAGS="-fPIC" \
+          ./configure --disable-shared --without-libpsl --with-openssl=/opt/riscv64-ssl --prefix=/opt/riscv64-curl \
+            --without-brotli --without-zstd --without-nghttp2 --without-libidn2
+          make -j"$(nproc)" > /dev/null
+          make install > /dev/null
+          cp COPYING "$LICENSES/LICENSE.curl"
+          cd /tmp
+
+          curl -fsSL -o "zlib-${ZLIB_VERSION}.tar.gz" "https://github.com/madler/zlib/releases/download/v${ZLIB_VERSION}/zlib-${ZLIB_VERSION}.tar.gz"
+          tar zxf "zlib-${ZLIB_VERSION}.tar.gz"
+          cd "zlib-${ZLIB_VERSION}"
+          # Upstream's Ubuntu gcc defaults to PIE, which is what lets its non-PIC libz.a link into a .so.
+          CFLAGS="-fPIC" ./configure --static --shared --prefix=/opt/riscv64-zlib
+          make -j"$(nproc)" > /dev/null
+          make install > /dev/null
+          cp LICENSE "$LICENSES/LICENSE.zlib"
+          cd /tmp
+
+          git clone --recurse-submodules --shallow-submodules --depth 1 --branch "${AWS_SDK_CPP_VERSION}" https://github.com/aws/aws-sdk-cpp /tmp/aws-sdk-cpp
+          cd /tmp/aws-sdk-cpp
+          # GNUInstallDirs would pick lib64 on this RHEL-family image; the @aws link line expects lib.
+          cmake -B build \
+                -DBUILD_ONLY="s3-crt" \
+                -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
+                -DCMAKE_PREFIX_PATH="/opt/riscv64-ssl;/opt/riscv64-curl" \
+                -DCMAKE_INSTALL_PREFIX="/opt/riscv64-aws" \
+                -DCMAKE_INSTALL_LIBDIR=lib \
+                -DFORCE_SHARED_CRT=OFF \
+                -DBUILD_SHARED_LIBS=OFF \
+                -DENABLE_TESTING=OFF \
+                -DAUTORUN_UNIT_TESTS=OFF \
+                -DZLIB_LIBRARY="/opt/riscv64-zlib/lib/libz.a" \
+                -DZLIB_INCLUDE_DIR="/opt/riscv64-zlib/include" \
+                -Dcrypto_LIBRARY="/opt/riscv64-ssl/lib/libcrypto.a" \
+                -Dcrypto_INCLUDE_DIR="/opt/riscv64-ssl/include" \
+                -DCURL_LIBRARY="/opt/riscv64-curl/lib/libcurl.a" \
+                -DCURL_INCLUDE_DIR="/opt/riscv64-curl/include" \
+                -DOPENSSL_CRYPTO_LIBRARY="/opt/riscv64-ssl/lib/libssl.a" \
+                -DOPENSSL_INCLUDE_DIR="/opt/riscv64-ssl/include"
+          cmake --build build -j"$(nproc)"
+          cmake --install build
+
+          for dir in /tmp/aws-sdk-cpp /tmp/aws-sdk-cpp/crt/aws-crt-cpp /tmp/aws-sdk-cpp/crt/aws-crt-cpp/crt/*; do
+            name="$(basename "$dir")"
+            if [ "$name" = aws-lc ]; then
+              continue
+            fi
+            if [ -f "$dir/LICENSE" ]; then
+              cp "$dir/LICENSE" "$LICENSES/LICENSE.$name"
+            fi
+            if [ -f "$dir/NOTICE" ]; then
+              cp "$dir/NOTICE" "$LICENSES/LICENSE.$name.NOTICE"
+            fi
+          done
+          ls -l /opt/riscv64-aws/lib "$LICENSES"
+          SCRIPT
+
+      - name: Save OpenSSL, curl, zlib and the AWS SDK
+        if: steps.deps-cache.outputs.cache-hit != 'true'
+        uses: actions/cache/save@55cc8345863c7cc4c66a329aec7e433d2d1c52a9  # v6.1.0
+        with:
+          path: deps
+          key: ${{ steps.deps-cache.outputs.cache-primary-key }}
+
+      - name: Build the S3 streamer library and package the wheel
+        run: |
+          mkdir -p dist
+          docker run --rm -i --network=host \
+            -v "${GITHUB_WORKSPACE}:/work" \
+            -v "${GITHUB_WORKSPACE}/deps/riscv64-ssl:/opt/riscv64-ssl" \
+            -v "${GITHUB_WORKSPACE}/deps/riscv64-curl:/opt/riscv64-curl" \
+            -v "${GITHUB_WORKSPACE}/deps/riscv64-zlib:/opt/riscv64-zlib" \
+            -v "${GITHUB_WORKSPACE}/deps/riscv64-aws:/opt/riscv64-aws" \
+            -w /work/runai-model-streamer \
+            -e PACKAGE_VERSION="${RUNAI_MODEL_STREAMER_VERSION}" \
+            "${MANYLINUX_RISCV64_IMAGE}" \
+            bash <<'SCRIPT'
+          set -eux
+
+          # cpp/toolchain links -l:libstdc++.a, which on this image is its own CRB package.
+          dnf install -y --setopt=install_weak_deps=False java-21-openjdk-devel libstdc++-static
+          JAVA_HOME="$(dirname "$(dirname "$(readlink -f "$(command -v javac)")")")"
+          export JAVA_HOME
+          install -m 0755 /work/bazel-bin/bazel /usr/local/bin/bazel
+          git config --global --add safe.directory '*'
+
+          # cpp/toolchain/rules.bzl expects the Debian cross-toolchain names; this image's gcc is native.
+          for tool in gcc g++ ar ld cpp gcov nm objdump strip; do
+            native="$(command -v "$tool" || true)"
+            [ -n "$native" ] && ln -sf "$native" "/usr/bin/riscv64-linux-gnu-$tool"
+          done
+
+          cd cpp
+          bazel build s3:libstreamers3.so --config=riscv64
+
+          cd ../py/runai_model_streamer_s3
+          cp /work/deps/licenses/LICENSE.* .
+          /opt/python/cp312-cp312/bin/pip install -q setuptools wheel
+          /opt/python/cp312-cp312/bin/python setup.py bdist_wheel --plat-name manylinux_2_39_riscv64
+          cp dist/*.whl /work/dist/
+          SCRIPT
+
+      - name: Verify the wheel ships a riscv64 shared object and its licences
+        run: |
+          python3 - dist/*.whl <<'EOF'
+          import sys, zipfile
+          with zipfile.ZipFile(sys.argv[1]) as zf:
+              names = zf.namelist()
+              so = next(n for n in names if n.endswith("libstreamer/lib/libstreamers3.so"))
+              header = zf.read(so)[:20]
+              assert header[:4] == b"\x7fELF", header
+              assert header[18] == 0xF3, header  # EM_RISCV
+              licenses = {n.rsplit("/", 1)[-1] for n in names if ".dist-info/licenses/" in n}
+              print(sorted(licenses))
+              for dep in ("openssl", "curl", "zlib", "aws-sdk-cpp", "aws-crt-cpp", "s2n", "aws-c-common"):
+                  assert f"LICENSE.{dep}" in licenses, dep
+          EOF
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
+        with:
+          name: runai-model-streamer-s3-${{ matrix.version }}-py3-none-manylinux_riscv64
+          path: dist/*.whl
+          if-no-files-found: error
+
+  test_wheel:
+    name: Test runai-model-streamer-s3 ${{ matrix.version }} on Python ${{ matrix.python-version }}
+    needs: [setup, build_wheel, minio]
+    if: needs.setup.outputs.versions != '[]'
+    runs-on: ubuntu-24.04-riscv
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        version: ${{ fromJSON(needs.setup.outputs.versions) }}
+        python-version: ['3.12', '3.13', '3.14']
+
+    env:
+      RUNAI_MODEL_STREAMER_VERSION: ${{ matrix.version }}
+
+    steps:
+      - name: Checkout runai-model-streamer ${{ env.RUNAI_MODEL_STREAMER_VERSION }}
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
+        with:
+          repository: run-ai/runai-model-streamer
+          ref: ${{ env.RUNAI_MODEL_STREAMER_VERSION }}
+          path: runai-model-streamer
+          persist-credentials: false
+
+      - name: Download wheel
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
+        with:
+          name: runai-model-streamer-s3-${{ env.RUNAI_MODEL_STREAMER_VERSION }}-py3-none-manylinux_riscv64
+          path: wheelhouse
+
+      - name: Download MinIO
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
+        with:
+          name: minio-riscv64
+          path: minio
+
+      - name: Install Python
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d  # v10.0.1
+        with:
+          python-version: ${{ matrix.python-version }}
+          activate-environment: true
+          enable-cache: false
+
+      - name: Install the wheel and upstream's test dependencies
+        env:
+          UV_EXTRA_INDEX_URL: https://pypi.riseproject.dev/simple/
+          UV_INDEX_STRATEGY: unsafe-best-match
+        # requirements.dev's numpy==1.24.4 has no riscv64 wheel and no longer builds on Python >=3.12.
+        run: |
+          echo "numpy>=1.26,<3" > "$RUNNER_TEMP/numpy-override.txt"
+          uv pip install --override "$RUNNER_TEMP/numpy-override.txt" \
+            -r runai-model-streamer/py/runai_model_streamer/requirements.dev \
+            pytest \
+            "runai-model-streamer[s3]==${RUNAI_MODEL_STREAMER_VERSION}" \
+            wheelhouse/*.whl
+
+      - name: Run the S3 package's unit tests against the installed wheel
+        run: |
+          site="$(python -c 'import runai_model_streamer_s3, os; print(os.path.dirname(os.path.dirname(runai_model_streamer_s3.__file__)))')"
+          cd "$site"
+          python -m unittest discover -b runai_model_streamer_s3
+
+      - name: Run upstream's S3 tests against MinIO
+        working-directory: runai-model-streamer/tests
+        env:
+          MINIO_ROOT_USER: minioadmin
+          MINIO_ROOT_PASSWORD: minioadmin
+          RUNAI_STREAMER_S3_USE_VIRTUAL_ADDRESSING: '0'
+          AWS_BUCKET: test-bucket
+          AWS_ENDPOINT_URL: http://127.0.0.2:9000
+          AWS_ACCESS_KEY_ID: minioadmin
+          AWS_SECRET_ACCESS_KEY: minioadmin
+        run: |
+          chmod +x "$GITHUB_WORKSPACE/minio/minio"
+          mkdir -p "$RUNNER_TEMP/minio/test-bucket"
+          "$GITHUB_WORKSPACE/minio/minio" server "$RUNNER_TEMP/minio" --address ":9000" &
+          trap 'kill $!' EXIT
+          pytest -v s3/
+
+  gpl_sources:
+    needs: [setup]
+    if: needs.setup.outputs.versions != '[]'
+    strategy:
+      fail-fast: false
+      matrix:
+        version: ${{ fromJSON(needs.setup.outputs.versions) }}
+    name: Collect GPL sources for runai-model-streamer-s3 ${{ matrix.version }}
+    runs-on: ubuntu-24.04-riscv
+
+    env:
+      RUNAI_MODEL_STREAMER_VERSION: ${{ matrix.version }}
+
+    steps:
+      - name: Checkout python-wheels
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
+        with:
+          persist-credentials: false
+
+      - uses: ./actions/collect-gpl-sources
+        with:
+          image: ${{ env.MANYLINUX_RISCV64_IMAGE }}
+          packages: gcc
+          output: gpl-sources.tar
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a  # v7.0.1
+        with:
+          name: runai-model-streamer-s3-${{ env.RUNAI_MODEL_STREAMER_VERSION }}-gpl-sources
+          path: gpl-sources.tar
+          if-no-files-found: error
+
+  publish:
+    name: Publish runai-model-streamer-s3 ${{ matrix.version }}
+    needs: [setup, build_wheel, test_wheel, gpl_sources]
+    if: needs.setup.outputs.versions != '[]'
+    strategy:
+      fail-fast: false
+      matrix:
+        version: ${{ fromJSON(needs.setup.outputs.versions) }}
+    permissions:
+      contents: write
+      pull-requests: write
+    uses: $/.github/workflows/_publish-wheel.yml
+    secrets:
+      app-private-key: ${{ secrets.RISEPROJECT_APP_PRIVATE_KEY }}
+    with:
+      artifact-pattern: runai-model-streamer-s3-${{ matrix.version }}-py3-none-manylinux_riscv64
+      gpl-sources-artifact: runai-model-streamer-s3-${{ matrix.version }}-gpl-sources
+      gpl-sources-description: gcc
diff --git a/docs/packages/runai-model-streamer-s3.yaml b/docs/packages/runai-model-streamer-s3.yaml
new file mode 100644
index 00000000000..38d270c6a91
--- /dev/null
+++ b/docs/packages/runai-model-streamer-s3.yaml
@@ -0,0 +1,5 @@
+package-name: runai-model-streamer-s3
+source-code: https://github.com/run-ai/runai-model-streamer
+license: Apache-2.0 AND curl AND Zlib
+versions:
+- version: 0.16.1
diff --git a/patches/runai-model-streamer-s3/0.16.1/0001-toolchain-add-riscv64-as-a-supported-architecture.patch b/patches/runai-model-streamer-s3/0.16.1/0001-toolchain-add-riscv64-as-a-supported-architecture.patch
new file mode 100644
index 00000000000..627eb0aadf1
--- /dev/null
+++ b/patches/runai-model-streamer-s3/0.16.1/0001-toolchain-add-riscv64-as-a-supported-architecture.patch
@@ -0,0 +1,50 @@
+From 820707245ffc7f9f363fc5de3f5375daacb0a8b9 Mon Sep 17 00:00:00 2001
+From: Ludovic Henry <git@ludovic.dev>
+Date: Thu, 24 Sep 2026 03:32:40 +0000
+Subject: [PATCH] toolchain: add riscv64 as a supported architecture
+
+configure_toolchain() and its per-arch .bazelrc block are already fully
+generic over the arch string (native.platform constraint is
+@platforms//cpu:<arch>, gcc tools are resolved as
+/usr/bin/<arch>-linux-gnu-<tool>) -- riscv64 was simply never added to
+either list.
+
+No -march flag is added for riscv64 (unlike aarch64's, which exists only
+for a google-cloud-cpp ARM dependency libstreamer.so does not build
+against): a native riscv64 build uses the compiler's own default target.
+
+Upstream-Status: To upstream [this port does not open issues/PRs against third-party repos; riscv64 toolchain support is exactly the kind of change upstream would want once a downstream build proves it works]
+---
+ cpp/.bazelrc                | 3 +++
+ cpp/toolchain/configure.bzl | 2 +-
+ 2 files changed, 4 insertions(+), 1 deletion(-)
+
+diff --git a/cpp/.bazelrc b/cpp/.bazelrc
+index 830e568..4a6ccd2 100644
+--- a/cpp/.bazelrc
++++ b/cpp/.bazelrc
+@@ -19,5 +19,8 @@ build:aarch64 --copt="-march=armv8-a+crc+crypto"
+ build:x86_64 --platform_suffix=x86_64
+ build:x86_64 --platforms=@toolchain//:x86_64
+ 
++build:riscv64 --platform_suffix=riscv64
++build:riscv64 --platforms=@toolchain//:riscv64
++
+ # Azurite testing support (enables AZURE_STORAGE_ACCOUNT_KEY for local testing)
+ build:azurite --define azurite_testing=true
+diff --git a/cpp/toolchain/configure.bzl b/cpp/toolchain/configure.bzl
+index 6b89f54..9a04125 100644
+--- a/cpp/toolchain/configure.bzl
++++ b/cpp/toolchain/configure.bzl
+@@ -4,7 +4,7 @@ load("//toolchain:rules.bzl", "get_target_triplet", "runai_crosstool_tools")
+ 
+ # This should map to the devcontainer Dockerfile
+ # We install gcc-x86-64-linux-gnu and gcc-aarch64-linux-gnu toolchains
+-ARCHITECTURES = ["x86_64", "aarch64"]
++ARCHITECTURES = ["x86_64", "aarch64", "riscv64"]
+ OS = "linux-gnu"
+ 
+ def _get_gcc_version(repository_ctx, arch):
+-- 
+2.43.0
+
diff --git a/patches/runai-model-streamer-s3/0.16.1/0002-toolchain-use-gcc-s-own-dumpmachine-triplet-for-builtin-include-dirs.patch b/patches/runai-model-streamer-s3/0.16.1/0002-toolchain-use-gcc-s-own-dumpmachine-triplet-for-builtin-include-dirs.patch
new file mode 100644
index 00000000000..367c1fc785b
--- /dev/null
+++ b/patches/runai-model-streamer-s3/0.16.1/0002-toolchain-use-gcc-s-own-dumpmachine-triplet-for-builtin-include-dirs.patch
@@ -0,0 +1,134 @@
+From 75c45793987328b8011252f0f24950e94456b336 Mon Sep 17 00:00:00 2001
+From: Ludovic Henry <git@ludovic.dev>
+Date: Thu, 24 Sep 2026 08:01:06 +0000
+Subject: [PATCH] toolchain: use gcc's own -dumpmachine triplet for builtin
+ include dirs
+
+configure_toolchain()'s cxx_builtin_include_directories are built from the
+same os+arch naming-convention triplet (<arch>-linux-gnu) used to resolve
+tool paths (/usr/bin/<arch>-linux-gnu-<tool>). That equivalence holds for a
+genuine Debian cross-toolchain package (a real x86_64-linux-gnu-gcc reports
+exactly that as its own -dumpmachine), but not when the tool path is a
+same-arch *native* compiler reachable only via a symlink under the expected
+name -- its own compiled-in builtin search path (/usr/lib/gcc/<real
+triplet>/<ver>/include, etc.) still uses its real vendor triplet regardless
+of what name it is invoked under.
+
+This is exactly riscv64's manylinux_riscv64 image: gcc is Red Hat's native
+riscv64-redhat-linux build, symlinked to /usr/bin/riscv64-linux-gnu-gcc so
+runai_crosstool_tools() finds it. Bazel's own absolute-path sandboxing then
+rejects gcc's builtin headers (e.g. stddef.h) because
+/usr/lib/gcc/riscv64-redhat-linux/<ver>/include is not in the declared
+riscv64-linux-gnu-based list.
+
+Thread the compiler's actual -dumpmachine output down as gcc_machine and use
+it (falling back to the naming-convention triplet when unset, so x86_64 and
+aarch64 are unaffected) for cxx_builtin_include_directories specifically,
+while tool_paths keeps using the naming-convention triplet the workflow's
+symlinks provide.
+
+Upstream-Status: To upstream [this port does not open issues/PRs against third-party repos; making cxx_builtin_include_directories match the compiler's own reported triplet is a general robustness fix upstream would likely want]
+---
+ cpp/toolchain/configure.bzl          |  7 ++++++-
+ cpp/toolchain/template/toolchain.bzl | 23 ++++++++++++++++++++---
+ 2 files changed, 26 insertions(+), 4 deletions(-)
+
+diff --git a/cpp/toolchain/configure.bzl b/cpp/toolchain/configure.bzl
+index 9a04125..510ef90 100644
+--- a/cpp/toolchain/configure.bzl
++++ b/cpp/toolchain/configure.bzl
+@@ -11,6 +11,10 @@ def _get_gcc_version(repository_ctx, arch):
+     gcc_tool = runai_crosstool_tools(get_target_triplet(OS, arch))["gcc"]
+     return repository_ctx.execute([gcc_tool, "-dumpversion"]).stdout.strip()
+ 
++def _get_gcc_machine(repository_ctx, arch):
++    gcc_tool = runai_crosstool_tools(get_target_triplet(OS, arch))["gcc"]
++    return repository_ctx.execute([gcc_tool, "-dumpmachine"]).stdout.strip()
++
+ def _get_host_arch(repository_ctx):
+     return repository_ctx.execute(["/usr/bin/uname", "-m"]).stdout.strip()
+ 
+@@ -18,9 +22,10 @@ def _cc_autoconf_toolchain_impl(repository_ctx):
+     define_statements = []
+     for arch in ARCHITECTURES:
+         gcc_version = _get_gcc_version(repository_ctx, arch)
++        gcc_machine = _get_gcc_machine(repository_ctx, arch)
+         host_arch = _get_host_arch(repository_ctx)
+         toolchain_name = arch
+-        define_statements.append('define_toolchain(name = "%s", os = "%s", host_arch = "%s", arch = "%s", gcc_version = "%s")' % (toolchain_name, OS, host_arch, arch, gcc_version))
++        define_statements.append('define_toolchain(name = "%s", os = "%s", host_arch = "%s", arch = "%s", gcc_version = "%s", gcc_machine = "%s")' % (toolchain_name, OS, host_arch, arch, gcc_version, gcc_machine))
+ 
+     repository_ctx.template(
+         "BUILD",
+diff --git a/cpp/toolchain/template/toolchain.bzl b/cpp/toolchain/template/toolchain.bzl
+index 6a4c6cf..36daffc 100644
+--- a/cpp/toolchain/template/toolchain.bzl
++++ b/cpp/toolchain/template/toolchain.bzl
+@@ -73,6 +73,15 @@ def _impl(ctx):
+     target_triplet = get_target_triplet(ctx.attr.os, ctx.attr.arch)
+     tool_paths = [tool_path(name = k, path = v) for k, v in runai_crosstool_tools(target_triplet).items()]
+ 
++    # gcc_machine is the triplet gcc itself reports (`gcc -dumpmachine`), which is
++    # what its own builtin include search path is actually built from. It is
++    # normally identical to target_triplet (a real x86_64-linux-gnu/aarch64-linux-gnu
++    # cross-gcc reports exactly that), but differs when the "gcc" behind
++    # target_triplet's tool path is a same-arch native compiler under a different
++    # vendor triplet (e.g. Red Hat's riscv64-redhat-linux) made reachable only by a
++    # symlink under the expected name.
++    include_triplet = ctx.attr.gcc_machine if ctx.attr.gcc_machine else target_triplet
++
+     # Documented at
+     # https://docs.bazel.build/versions/main/skylark/lib/cc_common.html#create_cc_toolchain_config_info.
+     #
+@@ -89,7 +98,7 @@ def _impl(ctx):
+         abi_version = "unknown",
+         abi_libc_version = "unknown",
+         tool_paths = tool_paths,
+-        cxx_builtin_include_directories = _get_include_directories(target_triplet, ctx.attr.gcc_version, ctx.attr.use_cross),
++        cxx_builtin_include_directories = _get_include_directories(include_triplet, ctx.attr.gcc_version, ctx.attr.use_cross),
+         features = features
+     )
+ 
+@@ -111,6 +120,11 @@ _toolchain_config = rule(
+             mandatory = True,
+             doc = "GCC major version to use (eg: 9)",
+         ),
++        "gcc_machine": attr.string(
++            mandatory = False,
++            default = "",
++            doc = "The triplet `gcc -dumpmachine` reports, if it differs from os/arch's own naming convention",
++        ),
+         "use_cross": attr.bool(
+             mandatory = False,
+             default = False,
+@@ -121,7 +135,7 @@ _toolchain_config = rule(
+ )
+ 
+ 
+-def define_toolchain(name, os, host_arch, arch, gcc_version):
++def define_toolchain(name, os, host_arch, arch, gcc_version, gcc_machine = ""):
+     """"define_toolchain creates rules for a cc_toolchain.
+ 
+     This expects toolchain tools to exist at a canonical path.
+@@ -134,6 +148,9 @@ def define_toolchain(name, os, host_arch, arch, gcc_version):
+       host_arch: The host architecture for this toolchain
+       arch: The target architecture for this toochain
+       gcc_version: The GCC version of this toolchain
++      gcc_machine: The triplet `gcc -dumpmachine` reports for this toolchain's
++        compiler, if it differs from the os/arch naming convention used for
++        the tool paths themselves
+     """
+ 
+     native.platform(
+@@ -145,7 +162,7 @@ def define_toolchain(name, os, host_arch, arch, gcc_version):
+     )
+ 
+     toolchain_config_name = "%s_toolchain_config" % name
+-    _toolchain_config(name = toolchain_config_name, os = os, arch = arch, gcc_version = gcc_version, use_cross = host_arch != arch)
++    _toolchain_config(name = toolchain_config_name, os = os, arch = arch, gcc_version = gcc_version, gcc_machine = gcc_machine, use_cross = host_arch != arch)
+ 
+     empty_target_name = "%s_empty" % name
+     empty_target_label = ":%s" % empty_target_name
+-- 
+2.43.0
+
diff --git a/patches/runai-model-streamer-s3/0.16.1/0003-third_party-add-riscv64-to-the-AWS-SDK-library-select.patch b/patches/runai-model-streamer-s3/0.16.1/0003-third_party-add-riscv64-to-the-AWS-SDK-library-select.patch
new file mode 100644
index 00000000000..41a8e3d4892
--- /dev/null
+++ b/patches/runai-model-streamer-s3/0.16.1/0003-third_party-add-riscv64-to-the-AWS-SDK-library-select.patch
@@ -0,0 +1,47 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ludovic Henry <git@ludovic.dev>
+Date: Sat, 26 Sep 2026 06:00:00 +0000
+Subject: [PATCH] third_party: add riscv64 to the AWS SDK library select
+
+The @aws alias selects a per-arch aws_library() (headers and static
+libraries under /opt/<arch>-aws, /opt/<arch>-ssl, ...) by target CPU, but
+only has x86_64 and aarch64 branches, so any other --config fails with
+"configurable attribute doesn't match this configuration". aws_library()
+itself is already generic over the arch string; add the matching
+config_setting and branch for riscv64.
+
+Upstream-Status: To upstream [this port does not open issues/PRs against third-party repos; riscv64 support in the S3 backend is exactly the kind of change upstream would want once a downstream build proves it works]
+---
+ cpp/third_party/aws.BUILD | 9 +++++++++
+ 1 file changed, 9 insertions(+)
+
+diff --git a/cpp/third_party/aws.BUILD b/cpp/third_party/aws.BUILD
+index 7cab4ea..c81e4ac 100644
+--- a/cpp/third_party/aws.BUILD
++++ b/cpp/third_party/aws.BUILD
+@@ -25,13 +25,22 @@ config_setting(
+     ],
+ )
+ 
++config_setting(
++    name = "target_riscv64",
++    constraint_values = [
++        "@platforms//cpu:riscv64",
++    ],
++)
++
+ aws_library(name = "aws_aarch", arch = "aarch64")
+ aws_library(name = "aws_x86_64", arch = "x86_64")
++aws_library(name = "aws_riscv64", arch = "riscv64")
+ 
+ alias(
+     name = "aws",
+     actual = select({
+         ":target_x86_64": ":aws_x86_64",
+         ":target_aarch64": ":aws_aarch",
++        ":target_riscv64": ":aws_riscv64",
+     }),
+ )
+-- 
+2.43.0
+
diff --git a/patches/runai-model-streamer-s3/0.16.1/0004-s3-ship-the-licences-of-the-statically-linked-dependencies.patch b/patches/runai-model-streamer-s3/0.16.1/0004-s3-ship-the-licences-of-the-statically-linked-dependencies.patch
new file mode 100644
index 00000000000..c299e56904a
--- /dev/null
+++ b/patches/runai-model-streamer-s3/0.16.1/0004-s3-ship-the-licences-of-the-statically-linked-dependencies.patch
@@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ludovic Henry <git@ludovic.dev>
+Date: Sat, 26 Sep 2026 06:00:00 +0000
+Subject: [PATCH] s3: ship the licences of the statically linked dependencies
+
+libstreamers3.so statically links the AWS SDK for C++ (and its CRT
+libraries, s2n-tls included), OpenSSL, libcurl and zlib, but the explicit
+license_files=("LICENSE",) only ships the project's own licence. curl's
+licence and the Apache-2.0 NOTICE files of the AWS libraries require
+their notices to travel with the binary. Also match LICENSE.* next to
+setup.py, where the build stages each dependency's licence text.
+
+Upstream-Status: To upstream [this port does not open issues/PRs against third-party repos; the upstream wheels have the same gap]
+---
+ py/runai_model_streamer_s3/setup.py | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/py/runai_model_streamer_s3/setup.py b/py/runai_model_streamer_s3/setup.py
+index ae0e820..00c7b9a 100644
+--- a/py/runai_model_streamer_s3/setup.py
++++ b/py/runai_model_streamer_s3/setup.py
+@@ -22,7 +22,7 @@ assert_lib_exists()
+ setup(
+     name="runai-model-streamer-s3",
+     version=VERSION,
+-    license_files=("LICENSE",),
++    license_files=("LICENSE", "LICENSE.*"),
+     packages=find_packages(),
+     install_requires=["boto3"],
+     data_files=[("/runai_model_streamer/libstreamer/lib/", [LIB])],
+-- 
+2.43.0
+
diff --git a/patches/runai-model-streamer-s3/0.16.1/0005-s3-fix-the-stale-_filter_allow-_filter_ignore-unit-tests.patch b/patches/runai-model-streamer-s3/0.16.1/0005-s3-fix-the-stale-_filter_allow-_filter_ignore-unit-tests.patch
new file mode 100644
index 00000000000..90a3683501c
--- /dev/null
+++ b/patches/runai-model-streamer-s3/0.16.1/0005-s3-fix-the-stale-_filter_allow-_filter_ignore-unit-tests.patch
@@ -0,0 +1,52 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ludovic Henry <git@ludovic.dev>
+Date: Sat, 26 Sep 2026 06:00:00 +0000
+Subject: [PATCH] s3: fix the stale _filter_allow/_filter_ignore unit tests
+
+Since #80 the S3 package's test_filter_allow and
+test_filter_allow_full_path call _filter_ignore() with an allow_pattern
+keyword, and test_filter_ignore passes ignore_pattern, but both helpers
+in files/files.py take (paths, patterns). All three raise TypeError
+against a stock 0.16.1 install (PyPI's x86_64 wheel included); upstream
+CI never notices because py/Makefile's test target only runs the
+runai_model_streamer package's tests. Only the stale-test hunk of the
+upstream commit is taken, aligning with the GCS/Azure copies.
+
+Upstream-Status: Backport [https://github.com/run-ai/runai-model-streamer/commit/c6a6543f195158ee3175b66504044dac1801de27]
+---
+ .../runai_model_streamer_s3/files/tests/test_files.py         | 10 +++++-----
+ 1 file changed, 5 insertions(+), 5 deletions(-)
+
+diff --git a/py/runai_model_streamer_s3/runai_model_streamer_s3/files/tests/test_files.py b/py/runai_model_streamer_s3/runai_model_streamer_s3/files/tests/test_files.py
+index eb8ba87..0722c09 100644
+--- a/py/runai_model_streamer_s3/runai_model_streamer_s3/files/tests/test_files.py
++++ b/py/runai_model_streamer_s3/runai_model_streamer_s3/files/tests/test_files.py
+@@ -9,23 +9,23 @@ import runai_model_streamer_s3.files.files as files
+ 
+ class TestFiles(unittest.TestCase):
+     def test_filter_allow(self):
+-        res = files._filter_ignore(
++        res = files._filter_allow(
+             ["test_file1.txt1", "test_file2.txt2", "test_file3.txt3"],
+-            allow_pattern=["*.txt2"]
++            patterns=["*.txt2"]
+         )
+         self.assertEqual(res, ["test_file2.txt2"])
+ 
+     def test_filter_allow_full_path(self):
+-        res = files._filter_ignore(
++        res = files._filter_allow(
+             ["test_file1.txt1", "dir/test_file2.txt2", "test_file3.txt3"],
+-            allow_pattern=["*.txt2"]
++            patterns=["*.txt2"]
+         )
+         self.assertEqual(res, ["dir/test_file2.txt2"])
+ 
+     def test_filter_ignore(self):
+         res = files._filter_ignore(
+             ["test_file1.txt1", "test_file2.txt2", "test_file3.txt3"],
+-            ignore_pattern=["*.txt2"]
++            patterns=["*.txt2"]
+         )
+         self.assertEqual(res, ["test_file1.txt1", "test_file3.txt3"])
+