THIRD_PARTY_LICENSES.md

Rama main · réplica de lectura del repositorio original.

# Third-party licenses — baked artifacts outside the dependency gate

`gate:licenses` (ADR-0004, `scripts/gates.mjs`) scans the resolved **npm** dependency
tree (`pnpm licenses list --json`) and every **Python** package an image installs
(`python-licenses.json`, `scripts/check-python-licenses.mjs`). Neither half
sees **non-dependency artifacts baked into the images** — model weights pulled from a model
hub, or a service binary built from source at image-build time. This file is the
packaging-side complement: every such artifact is recorded here with its license, mirrored
into the per-release SPDX SBOM (`scripts/sbom.mjs`), and — for baked binaries and pinned
container images — audited by **`gate:image-licenses`** against
[`image-licenses.json`](image-licenses.json) (#653).

The verbatim upstream license for each entry lives under [`licenses/`](licenses/) and is
copied into the image next to the artifact it covers, so the notice travels with the bytes.

The SPDX also inventories every package name in the Lite Dockerfile's final-stage `apt install`.
That is a source-level inventory: Docker source does not resolve Ubuntu package versions or
package licences, so those fields are emitted as `NOASSERTION` until an image-level scanner
enriches them. Builder-stage packages that do not cross into the final image are excluded.

## Baked service binaries

| Artifact | Version | License | Source | Baked into | In-image path |
| --- | --- | --- | --- | --- | --- |
| `valkey` | `8.1.9` | BSD-3-Clause | [github.com/valkey-io/valkey](https://github.com/valkey-io/valkey) | `vexaai/vexa-lite` | `/usr/local/bin/valkey-server`, `/usr/local/share/valkey/LICENSE` |

**`valkey`** — the internal cache / stream store (bus, scheduler, per-dispatch streams). Lite
builds `valkey-server` + `valkey-cli` from the pinned git tag in the `valkey-builder` stage of
[`deploy/lite/Dockerfile.lite`](deploy/lite/Dockerfile.lite) (glibc-matched to the final image;
an alpine/musl binary can't run there) and copies them onto `PATH`. Valkey is the Linux
Foundation's BSD-3-Clause fork of Redis 7.2.4 — it has `XAUTOCLAIM` (parity with compose/helm)
and keeps Lite off both jammy apt's stale Redis 6.0.16 and source-available Redis ≥7.4
(RSALv2/SSPLv1). compose and helm pin `valkey/valkey:8-alpine` (operator-pulled, recorded in
[`image-licenses.json`](image-licenses.json)). Full text:
[`licenses/valkey-8.1.9.COPYING.txt`](licenses/valkey-8.1.9.COPYING.txt).

> BSD-3-Clause is a Category-A (permissive) license under ADR-0004; baking it requires no
> exception, only that the notice be preserved — which this file and the in-image
> `/usr/local/share/valkey/LICENSE` satisfy.

## Vendored files

| Artifact | Version | License | Source | Shipped in | In-image path |
| --- | --- | --- | --- | --- | --- |
| `seccomp/default.json` (modified) | Docker Engine `29.6.2` | Apache-2.0 | [github.com/moby/profiles](https://github.com/moby/profiles) | `vexaai/vexa-runtime`, `vexaai/vexa-lite`; installed on Kubernetes nodes by the chart | `/app/src/runtime_kernel/seccomp-userns.json` (runtime), `/app/runtime/src/runtime_kernel/seccomp-userns.json` (Lite), each with `seccomp-userns.LICENSE.txt` beside it |

**`seccomp-userns.json`** — the seccomp profile meeting bots run under:
[`core/runtime/src/runtime_kernel/seccomp-userns.json`](core/runtime/src/runtime_kernel/seccomp-userns.json)
is Docker Engine 29.6.2's default profile (the Moby project's `seccomp/default.json`, as vendored
in that release), **modified**: one rule is added, commented in the file itself, letting a process
without `CAP_SYS_ADMIN` call `clone`/`unshare` for new namespaces and `chroot` (the kernel still
asks for the capability inside the caller's own namespace), which Chromium's sandbox needs.
Lite runs its container under it, the docker backend runs each bot's own container under it, and
the Helm chart writes it to the nodes for bot Pods. The licence is the Apache License 2.0, the
same as Vexa's; moby/profiles ships no NOTICE file. Full text:
[`licenses/moby-profiles.LICENSE.txt`](licenses/moby-profiles.LICENSE.txt), copied beside the
file in the runtime package (`seccomp-userns.LICENSE.txt`; the parity fact
`moby-profiles-licence` keeps the two copies identical).

> Apache-2.0 is a Category-A (permissive) license under ADR-0004; vendoring a modified file
> requires no exception, only the licence text, a statement that it was changed, and the
> attribution — which this file, the repository NOTICE and the in-image licence copy satisfy.

## Baked model weights

| Artifact | Version (revision) | License | Source | Baked into | In-image path |
| --- | --- | --- | --- | --- | --- |
| `onnx-community/pyannote-segmentation-3.0` | `main` | MIT | [huggingface.co](https://huggingface.co/onnx-community/pyannote-segmentation-3.0) | `vexaai/vexa-bot`, `vexaai/vexa-lite` | `/opt/hf-cache/LICENSE.pyannote-segmentation-3.0` |

**`onnx-community/pyannote-segmentation-3.0`** — the mixed (Zoom/Teams) speaker-diarization
lane segments speakers with this model, loaded OFFLINE from an image-baked HuggingFace cache
at `/opt/hf-cache` (see [`warm-hf-cache.mjs`](core/meetings/services/bot/warm-hf-cache.mjs)).
It is an ONNX conversion of the gated [`pyannote/segmentation-3.0`](https://huggingface.co/pyannote/segmentation-3.0);
the conversion is published MIT and **not** gated. The model card ships no LICENSE file of
its own, so the preserved notice is the [pyannote.audio](https://github.com/pyannote/pyannote-audio)
project's MIT license (`Copyright (c) 2020 CNRS`), whose copyright governs the weights. Full
text: [`licenses/onnx-community-pyannote-segmentation-3.0.LICENSE.txt`](licenses/onnx-community-pyannote-segmentation-3.0.LICENSE.txt).

> MIT is a Category-A (permissive) license under ADR-0004; baking it requires no exception,
> only that the copyright + permission notice be preserved — which this file and the baked
> `/opt/hf-cache/LICENSE.*` satisfy.

| Artifact | Version | License | Source | Shipped in | In-image path |
| --- | --- | --- | --- | --- | --- |
| MediaPipe selfie segmenter (`selfie_segmenter.tflite`, float16) | `1` (sha256 `191ac9529ae506ee0beefa6b2c945a172dab9d07d1e802a290a4e4038226658b`) | Apache-2.0 | [storage.googleapis.com/mediapipe-models](https://storage.googleapis.com/mediapipe-models/image_segmenter/selfie_segmenter/float16/1/selfie_segmenter.tflite) | `vexaai/vexa-terminal`, `vexaai/vexa-lite` | `/app/public/mediapipe/selfie_segmenter.tflite` (terminal), `/app/terminal/public/mediapipe/` (Lite), each with `selfie_segmenter.LICENSE.txt` beside it |

**MediaPipe selfie segmenter** — the terminal's in-call background blur
(`@livekit/track-processors` over `@mediapipe/tasks-vision`) segments the person from the
background with this model in the browser. It is vendored at
[`clients/terminal/vendor/mediapipe/`](clients/terminal/vendor/mediapipe/) and served by the
terminal itself at `/mediapipe/`, so no call fetches it from Google. Google's model card
("Model Card MediaPipe Selfie Segmentation", 2021-05-06) licenses it under the Apache License
2.0; the preserved text is the MediaPipe project's `LICENSE` at tag `v0.10.14` (the
`@mediapipe/tasks-vision` version in use, which declares `Apache-2.0` and ships no licence file).
Full text: [`licenses/mediapipe-selfie-segmenter.LICENSE.txt`](licenses/mediapipe-selfie-segmenter.LICENSE.txt).

> Apache-2.0 is a Category-A (permissive) license under ADR-0004; shipping the unmodified model
> requires no exception, only the licence text and attribution — which this file and the
> licence copy served beside the model satisfy.