From 6d0fd1a0540ff74b79ae938e1f28c7fc2444cb4a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kr=C3=A6n=20Hansen?= <kraen@elevenlabs.io>
Date: Fri, 2 Oct 2026 14:34:29 +0200
Subject: [PATCH 1/6] Add community health files for the public repo

Issue forms, PR template, CODEOWNERS and SECURITY.md (under .github/ so
Unity doesn't import them), plus Support and License sections in the
README. Templates follow elevenlabs-python's issue forms, adapted for
Unity versions, build targets and logs.

Closes #20

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/CODEOWNERS                           |  1 +
 .github/ISSUE_TEMPLATE/1-bug_report.yml      | 79 ++++++++++++++++++++
 .github/ISSUE_TEMPLATE/2-feature_request.yml | 37 +++++++++
 .github/ISSUE_TEMPLATE/config.yml            | 11 +++
 .github/SECURITY.md                          | 24 ++++++
 .github/pull_request_template.md             | 23 ++++++
 README.md                                    | 12 ++-
 7 files changed, 186 insertions(+), 1 deletion(-)
 create mode 100644 .github/CODEOWNERS
 create mode 100644 .github/ISSUE_TEMPLATE/1-bug_report.yml
 create mode 100644 .github/ISSUE_TEMPLATE/2-feature_request.yml
 create mode 100644 .github/ISSUE_TEMPLATE/config.yml
 create mode 100644 .github/SECURITY.md
 create mode 100644 .github/pull_request_template.md

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000..4c965b9
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1 @@
+* @kraenhansen
diff --git a/.github/ISSUE_TEMPLATE/1-bug_report.yml b/.github/ISSUE_TEMPLATE/1-bug_report.yml
new file mode 100644
index 0000000..620d777
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/1-bug_report.yml
@@ -0,0 +1,79 @@
+name: Bug report
+description: Create a bug report for the ElevenAgents Unity SDK
+labels: [bug]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for reporting a bug with the **ElevenAgents Unity SDK**. Please fill out the sections below to help us understand and resolve the issue.
+
+        **Never paste an ElevenLabs API key, signed URL, or conversation token** into this issue.
+
+  - type: textarea
+    attributes:
+      label: Description
+      description: |
+        **Describe the bug in detail and provide clear steps to reproduce it.**
+
+        Include information such as:
+        - What you were trying to achieve.
+        - What happened instead.
+        - Any relevant `ConversationOptions` or agent configuration.
+      placeholder: |
+        **Steps to reproduce:**
+        1. ...
+        2. ...
+
+        **Expected behavior:**
+
+        **Actual behavior:**
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: Package version
+      description: The `io.elevenlabs.agents` version, or the git commit from `Packages/packages-lock.json`.
+      placeholder: 0.1.0 (or a commit SHA)
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: Unity version
+      placeholder: 6000.3.6f1
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: Where does it happen?
+      multiple: true
+      options:
+        - Editor (Play Mode)
+        - Standalone (macOS)
+        - Standalone (Windows)
+        - Standalone (Linux)
+        - WebGL
+        - iOS
+        - Android
+        - XR
+        - Other
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Code example
+      description: A minimal snippet (or a link to a small project) that reproduces the problem.
+      render: csharp
+  - type: textarea
+    attributes:
+      label: Logs
+      description: |
+        Relevant output from the Unity Console, `Editor.log` / `Player.log`, or the browser console for WebGL builds.
+      render: text
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context or screenshots about the problem here.
+      placeholder: |
+        - Related issues:
+        - Possible workaround:
+        - ...
diff --git a/.github/ISSUE_TEMPLATE/2-feature_request.yml b/.github/ISSUE_TEMPLATE/2-feature_request.yml
new file mode 100644
index 0000000..81ee730
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/2-feature_request.yml
@@ -0,0 +1,37 @@
+name: Feature request
+description: Propose a new feature for the ElevenAgents Unity SDK
+labels: [enhancement]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for taking the time to propose a new feature for the **ElevenAgents Unity SDK**. Please provide detailed information below to help us understand your proposal.
+
+        If the feature exists in another ElevenLabs SDK (such as `@elevenlabs/client`, Swift, or Android), mention it below. We aim for parity across SDKs.
+
+  - type: textarea
+    attributes:
+      label: Feature description
+      description: What is the feature, what problem does it solve, and how do you envision it working?
+      placeholder: |
+        - What is the feature?
+        - What problem does it solve?
+        - How do you envision it working?
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Use case
+      description: Describe the game or app scenario where this feature would be useful, including the target platforms.
+  - type: textarea
+    attributes:
+      label: Alternatives considered
+      description: Other ways you've tried or considered solving the problem, and why they fall short.
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Any extra information, references, or screenshots that might help us understand your feature request.
+      placeholder: |
+        - Related issues or discussions:
+        - Equivalent API in another ElevenLabs SDK:
+        - Relevant links:
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000..1e1e0d8
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,11 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Report a security vulnerability
+    url: https://github.com/elevenlabs/unity/security/advisories/new
+    about: Please report vulnerabilities privately, not as a public issue. See SECURITY.md.
+  - name: ElevenAgents documentation
+    url: https://elevenlabs.io/docs/eleven-agents/overview
+    about: Agent configuration, voices, tools, and platform questions.
+  - name: Ask a question (Discord)
+    url: https://discord.com/invite/elevenlabs
+    about: General questions and community help.
diff --git a/.github/SECURITY.md b/.github/SECURITY.md
new file mode 100644
index 0000000..a8c8930
--- /dev/null
+++ b/.github/SECURITY.md
@@ -0,0 +1,24 @@
+# Security policy
+
+## Reporting a vulnerability
+
+Please do not report security vulnerabilities through public GitHub issues, discussions, or pull requests.
+
+Report them privately through either channel:
+
+- **GitHub:** [Report a vulnerability](https://github.com/elevenlabs/unity/security/advisories/new) on this repository (Security tab → _Report a vulnerability_).
+- **ElevenLabs Vulnerability Disclosure Program:** [elevenlabs.io/security/report](https://elevenlabs.io/security/report) or [vulnerability_disclosure_program@elevenlabs.io](mailto:vulnerability_disclosure_program@elevenlabs.io).
+
+Include the affected package version (or commit), the Unity version and build target, and steps to reproduce. We will acknowledge your report, investigate, and keep you updated on the fix.
+
+ElevenLabs does not offer cash rewards for vulnerability reports at this time.
+
+## Supported versions
+
+The SDK is pre-1.0. Security fixes land on `main` and ship in the next release; older releases are not patched.
+
+## Scope
+
+This policy covers the code in this repository: the Unity package (`Runtime/`, `Editor/`, `Plugins/`, `Samples~/`) and its build tooling. Vulnerabilities in the ElevenLabs platform or API itself should go to the ElevenLabs Vulnerability Disclosure Program above.
+
+Never commit or share an ElevenLabs API key in a Unity project. Players can extract anything shipped in a build, so use a public agent or have your own backend mint signed URLs or conversation tokens.
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 0000000..9ca114c
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,23 @@
+<!-- Why is this change needed? Link the issue it fixes, e.g. "Fixes #123". -->
+
+## Changes
+
+<!-- One line per change. -->
+
+-
+
+## Verification
+
+<!-- Tick what you ran; see CONTRIBUTING.md → "Running the full verification suite". Leave unrelated layers unticked. -->
+
+- [ ] `dotnet csharpier check .`
+- [ ] `Bridge~` checks (`format:check`, `lint`, `typecheck`, `test`, `verify:primitives`, `verify:connection`)
+- [ ] `Codegen~` checks (`verify:protocol-dtos`, `round-trip`)
+- [ ] Edit Mode tests (`pnpm --dir TestProject run test`)
+- [ ] WebGL builds + browser integration tests (`IntegrationTests~`)
+- [ ] Manually tested in a Unity project. Platforms and Unity version:
+
+## Checklist
+
+- [ ] `CHANGELOG.md` updated under `[Unreleased]` for user-facing changes
+- [ ] Public API changes are called out above
diff --git a/README.md b/README.md
index db78d5b..abddf39 100644
--- a/README.md
+++ b/README.md
@@ -3,7 +3,7 @@
 > [!CAUTION]
 > ⚠️ **Early-stage SDK:** This package is under active development and APIs may change without notice. If you hit a bug or rough edge, please [open a GitHub issue](https://github.com/elevenlabs/unity/issues/new) - your reports directly shape what we fix next.
 
-Drop ElevenLabs voice agents into a Unity scene. Walk up to a cube, it greets you in character; walk out, the session ends — all driven by the same `Conversation` API on standalone, mobile, the Editor, and WebGL.
+Drop ElevenLabs voice agents into a Unity scene. Walk up to a cube, it greets you in character; walk out, the session ends — all driven by the same `Conversation` API in the Editor, desktop standalone players, and WebGL.
 
 <!-- Landing media: 30s screen recording of the GettingStarted sample (walk up → greet → walk out, with audio). Tracked separately; drop the file in here once recorded. -->
 
@@ -38,3 +38,13 @@ Import via **Window → Package Manager → ElevenAgents → Samples**.
 - [`Docs~/ARCHITECTURE.md`](./Docs~/ARCHITECTURE.md) — internal layout (transports, audio pipeline, codegen) for contributors.
 - [`CONTRIBUTING.md`](./CONTRIBUTING.md) — how to build, test, and submit changes.
 - [`CHANGELOG.md`](./CHANGELOG.md) — release notes.
+
+## Support
+
+- Bugs and feature requests: [GitHub issues](https://github.com/elevenlabs/unity/issues/new/choose).
+- Security vulnerabilities: report privately per [`SECURITY.md`](./.github/SECURITY.md).
+- Agent configuration and platform questions: [ElevenAgents docs](https://elevenlabs.io/docs/eleven-agents/overview) or [Discord](https://discord.com/invite/elevenlabs).
+
+## License
+
+[MIT](./LICENSE)

From d0fd56129fc4ab01124229b1d69673c595d7b758 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kr=C3=A6n=20Hansen?= <kraen@elevenlabs.io>
Date: Fri, 2 Oct 2026 14:34:30 +0200
Subject: [PATCH 2/6] Bring public docs in line with the shipped SDK

CHANGELOG 0.1.0 lists the API that actually exists, and folds in the
Unity 6.3 minimum (never released at 6000.0). ARCHITECTURE, CONTRIBUTING
and COMPATIBILITY describe the shipped native transport, asmdef layout,
test layers and builds, and limit platform claims to what's tested.
CONTRIBUTING gains a "Submitting changes" section.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .claude/CLAUDE.md             |   4 +-
 CHANGELOG.md                  |  23 +--
 COMPATIBILITY.md              |  20 +-
 CONTRIBUTING.md               |  86 ++++++---
 Docs~/ARCHITECTURE.md         | 346 ++++++++++++++++++----------------
 Samples~/QuickStart/README.md |   9 +-
 6 files changed, 276 insertions(+), 212 deletions(-)

diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
index b4d1947..32cb8bb 100644
--- a/.claude/CLAUDE.md
+++ b/.claude/CLAUDE.md
@@ -46,7 +46,7 @@ pnpm --dir Codegen~ run format:check         # Prettier
 pnpm --dir Codegen~ run lint                 # ESLint
 pnpm --dir Codegen~ run typecheck            # TypeScript
 pnpm --dir Codegen~ run generate             # Emit C# DTOs + CSharpier-format them
-pnpm --dir Codegen~ run round-trip           # Serialize/deserialize each DTO via System.Text.Json
+pnpm --dir Codegen~ run round-trip           # Serialize/deserialize each DTO via Newtonsoft.Json
 pnpm --dir Codegen~ run verify:protocol-dtos # Regenerate and assert no git drift
 ```
 
@@ -61,7 +61,7 @@ emit the models (same stack the JS SDK's codegen uses). On top of that:
   `{ type: string, const: foo }`, strip `enum` from string fields (keep them
   plain `string` instead of generating C# enums), break cycles introduced by
   the parser's reference-based inlining of recursive schemas.
-- Custom C# preset: PascalCase property names, `[JsonPropertyName("…")]`
+- Custom C# preset: PascalCase property names, `[JsonProperty("…")]`
   attributes, `const` schemas → `init`-only string literals, required reference
   types get `= null!` to silence CS8618.
 - Post-process: inject `: IncomingSocketEvent` / `: OutgoingSocketEvent` for
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8cc6b75..828e7bc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,21 +7,22 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Changed
-
-- **Breaking:** Minimum Unity version bumped from `6000.0` to `6000.3` (Unity 6.3 LTS). Required for the new native audio output engine built on [`Audio.IAudioGenerator`](https://docs.unity3d.com/6000.3/Documentation/ScriptReference/Audio.IAudioGenerator.html) / [`Audio.GeneratorInstance`](https://docs.unity3d.com/6000.3/Documentation/ScriptReference/Audio.GeneratorInstance.html), which eliminates the streaming-`AudioClip` pre-fill latency that older Unity versions imposed structurally. Unity 6.3 LTS is supported through December 2027.
-
 ## [0.1.0] - Unreleased
 
 ### Added
 
-- Core session management (`StartSession`, `EndSession`)
-- WebSocket transport for native platforms (desktop, mobile, XR)
-- `@elevenlabs/client` bridge transport for WebGL
-- Audio capture and playback (default mode) across all platforms
-- Core conversation events: `OnConnect`, `OnDisconnect`, `OnMessage`, `OnError`, `OnStatusChange`, `OnModeChange`
-- WebGL bridge primitives: Promise-as-Task, Observer, JS-initiated Promise
-- UPM distribution via git URL
+- `Conversation` session API: `Conversation.StartSessionAsync(ConversationOptions)` / `EndSession()`, with `ConversationId`, `Status`, `Mode`, and `CanSendFeedback`. Async members return Unity's `Awaitable`.
+- `ConversationOptions`: `AgentId` / `SignedUrl` / `ConversationToken`, `ConnectionType` (WebSocket, or WebRTC on WebGL), `Input` / `Output` device config, `OutputAudioSource`, `DynamicVariables`, `Overrides`, `UserId`, `CustomLlmExtraBody`, `EnableDebugLogging`.
+- Events: `Connected`, `Disconnected`, `ErrorOccurred`, `StatusChanged`, `ModeChanged`, `CanSendFeedbackChanged`, `InitiationMetadataReceived`, `UserTranscriptReceived`, `AgentResponded`, `AgentResponseCorrected`, `AgentResponseCompleted`, `AgentChatResponsePartReceived`, `AudioReceived`, `Interrupted`, `VadScoreUpdated`, `GuardrailTriggered`, `UnhandledClientToolCall`, `AgentToolRequested`, `AgentToolResponded`, `MCPToolCallReceived`, `MCPConnectionStatusChanged`.
+- Messaging: `SendUserMessage`, `SendContextualUpdate`, `SendUserActivity`, `SendMultimodalMessage`, `UploadFileAsync`, `SendFeedback`, `SendMCPToolApprovalResult`.
+- Client tools: `RegisterTool<TParams, TResult>` (sync and `Awaitable` handlers), `UnregisterTool`, and `ClientToolException` for reporting tool errors to the agent.
+- Audio control: `SetVolume`, `SetMicMuted`, `ChangeInputDevice`, `ChangeOutputDevice`, `GetInputVolume` / `GetOutputVolume`, `GetInputByteFrequencyData` / `GetOutputByteFrequencyData`.
+- Native transport for the Editor and desktop standalone players: WebSocket via `ClientWebSocket`, microphone capture via `UnityEngine.Microphone`, and low-latency playback through Unity 6.3's `IAudioGenerator`, optionally through a supplied (spatial) `AudioSource`.
+- WebGL transport wrapping `@elevenlabs/client` (WebSocket and WebRTC). WebSocket audio plays through a Web Audio graph that mirrors the supplied `AudioSource`'s volume, position, and spatial settings.
+- WebGL JS↔C# bridge primitives: `JsBridge`, `JsObject`, `JsFunction`, `BridgeCallback`, `BridgeException`.
+- Protocol DTOs and typed event-args records (`ElevenLabs.Protocol`), generated from the Agents AsyncAPI spec.
+- Samples: GettingStarted (walk-up-and-talk with spatial audio, dynamic variables, and overrides) and QuickStart (minimal transcript).
+- UPM distribution via git URL. Requires Unity 6.3 LTS (`6000.3`) or later; depends on Input System 1.18.0 and Newtonsoft.Json 3.2.1.
 
 [Unreleased]: https://github.com/elevenlabs/unity/compare/v0.1.0...HEAD
 [0.1.0]: https://github.com/elevenlabs/unity/releases/tag/v0.1.0
diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md
index 5d48f45..f0fd692 100644
--- a/COMPATIBILITY.md
+++ b/COMPATIBILITY.md
@@ -20,7 +20,19 @@ The SDK reads JS→C# callback payloads on WebGL via [`Marshal.PtrToStringUTF8`]
 
 ## Platform support
 
-The public API (`Runtime/`) is cross-platform. WebGL is the most mature target today; native targets (desktop, mobile, XR) are implemented under `Runtime/Native/` and ship in the same package — the right implementation is selected at compile time per platform.
+The public API (`Runtime/Core/`) is cross-platform. Two transports ship in the package, and the one matching the active build target is registered automatically:
+
+| Target | Transport | Connection types | Status |
+|---|---|---|---|
+| WebGL | `@elevenlabs/client` via the JS bridge | WebSocket, WebRTC | Supported, CI-tested in Chromium |
+| Editor (Play Mode), desktop standalone (macOS, Windows, Linux) | Native (`ClientWebSocket`, `UnityEngine.Microphone`, `IAudioGenerator`) | WebSocket only — `ConnectionType.WebRTC` throws `NotSupportedException` | Supported |
+| iOS, Android, XR | Native | WebSocket only | Untested. The SDK doesn't request microphone permission itself. |
+
+Editor Play Mode while the active build target is WebGL isn't supported yet ([#16](https://github.com/elevenlabs/unity/issues/16)); switch the build target to a desktop platform to iterate in the Editor.
+
+## Package dependencies
+
+Installed automatically by the Package Manager: `com.unity.inputsystem` 1.18.0 and `com.unity.nuget.newtonsoft-json` 3.2.1.
 
 ## Additional WebGL setup
 
@@ -51,9 +63,9 @@ When you pass an `AudioSource` to `ConversationOptions.OutputAudioSource`, the f
 | `maxDistance` | `PannerNode.maxDistance` | Direct |
 | `rolloffMode` (Linear / Logarithmic) | `PannerNode.distanceModel` | `AudioRolloffMode.Custom` falls back to Logarithmic with a one-time warning |
 | `panStereo` | `StereoPannerNode.pan` | Effective when `spatialBlend < 1` |
-| `dopplerLevel` | Sampled per-frame velocity → `PannerNode` position pre-emphasis | Approximate |
+| `dopplerLevel` | ❌ Not supported | Forwarded but has no effect — Web Audio has no doppler control |
 | `outputAudioMixerGroup` | ❌ Not supported | One-time warning when first observed as non-null |
-| Custom rolloff `AnimationCurve` | ❌ Not supported | One-time warning; falls back to `rolloffMode` |
+| Custom rolloff `AnimationCurve` | ❌ Not supported | Falls back to Logarithmic (see `rolloffMode` above) |
 | `bypassEffects`, `bypassListenerEffects`, `bypassReverbZones` | ❌ Not supported | Silently ignored — no Web Audio analog |
 | `priority`, `spread`, `reverbZoneMix` | ❌ Not supported | Silently ignored |
 
@@ -70,6 +82,6 @@ Use the SDK's cross-platform reading APIs instead — they're tuned to return co
 | What you want | Native-only API (silent on WebGL) | Cross-platform SDK API |
 |---|---|---|
 | Scalar volume `[0, 1]` for an envelope / meter / bob | `audioSource.GetOutputData(buf); rms(buf);` | `conversation.GetOutputVolume()` |
-| Frequency-domain magnitudes | `AudioSource.GetSpectrumData(...)` | `conversation.GetByteFrequencyData(buf)` |
+| Frequency-domain magnitudes | `AudioSource.GetSpectrumData(...)` | `conversation.GetOutputByteFrequencyData(buf)` |
 
 The shipped samples under `Samples~/` follow this rule — copy from them.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 65640eb..e9bcef8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -11,20 +11,24 @@ Runtime/          C# source compiled into the shipped package
                   internal IConnection / IInputController / IOutputController abstractions
                   the platform impls satisfy, and the generated protocol DTOs under
                   Protocol/*.g.cs. No platform restrictions.
-  WebGL/          Editor + WebGL asmdef `ElevenLabs.Agents.WebGL`. Carries the bridge
-                  primitives (JsObject, JsFunction, BridgeCallback handle types + their
+  WebGL/          Bridge primitives (JsObject, JsFunction, BridgeCallback handle types + their
                   IJsObject / IJsFunction interface seams) and the Bridged/ folder of
                   IConnection / IInputController / IOutputController implementations that
-                  wrap @elevenlabs/client.
-  (Native/        Phase 7 — not yet present. Will mirror Runtime/WebGL/ as an
-                  excludePlatforms=WebGL asmdef carrying native IConnection /
-                  IInputController / IOutputController implementations.)
-
-Editor/           Editor-only C# (HostBuild entry points for WebGL builds, inspectors,
-                  build post-processors, validation).
+                  wrap @elevenlabs/client. Compiled by the Editor + WebGL asmdef
+                  `ElevenLabs.Agents.WebGL`, which sits at `Runtime/` itself — so a new file
+                  dropped directly into `Runtime/` lands in that assembly.
+  Native/         excludePlatforms=WebGL asmdef `ElevenLabs.Agents.Native`: ClientWebSocket
+                  connection, UnityEngine.Microphone input, IAudioGenerator-based output
+                  (UnityAudioSourceOutput + the IAudioOutputEngine implementations), and
+                  NativeSessionLauncher.
+
+Editor/           Editor-only C#: HostBuild entry points for the WebGL and standalone smoke
+                  builds, a build preprocessor that validates WebGL Player Settings, and the
+                  link.xml injector.
 
 Tests/
-  Editor/         Unity Test Runner tests (Edit Mode — run headlessly in CI).
+  Editor/         Edit Mode tests (run headlessly in CI). Native/ is its own asmdef.
+  Runtime/Native/ PlayMode characterization tests for Unity's audio APIs (run manually).
 
 Plugins/
   WebGL/          .jslib bundles — Unity's required location for WebGL native plugins.
@@ -70,7 +74,7 @@ TestProject/      Embedded dev Unity host project. Used to (a) run the Edit Mode
                   integration tests. Not shipped with the package. Most of Assets/ is
                   gitignored so a fresh clone always opens to a known-good state.
 
-IntegrationTests~/  Vitest + Playwright tests that drive the two WebGL builds produced by
+IntegrationTests~/  Vitest + Playwright tests that drive the WebGL builds produced by
                     TestProject/ from a headless Chromium. Runs entirely outside Unity.
 
 Docs~/            Design documents and RFCs. Read these before making architectural changes;
@@ -102,7 +106,7 @@ with **pnpm**. Run commands with `pnpm --dir <workspace> run <script>` from the
 | Workspace | Purpose | Commands |
 |---|---|---|
 | [`Bridge~/`](Bridge~/) | JS↔C# primitives + connection bundles | `format:check`, `lint`, `typecheck`, `test`, `verify:primitives`, `verify:connection` |
-| [`Codegen~/`](Codegen~/) | Protocol DTO codegen from AsyncAPI spec | `format:check`, `lint`, `typecheck`, `generate`, `round-trip`, `verify:protocol-dtos` |
+| [`Codegen~/`](Codegen~/) | Protocol DTO codegen from AsyncAPI spec | `format:check`, `lint`, `typecheck`, `test`, `generate`, `round-trip`, `verify:protocol-dtos` |
 | [`TestProject/`](TestProject/) | Edit Mode test runner driver (`run-tests.ts`) | `typecheck`, `test` |
 | [`IntegrationTests~/`](IntegrationTests~/) | Vitest + Playwright browser-mode harness | `typecheck`, `test`, `setup` (one-time Chromium install) |
 
@@ -140,13 +144,14 @@ replaced with fakes; functions are called directly in Node and their side-effect
 ### 2 — Codegen round-trip (Node.js + `dotnet run`) — `Codegen~/round-trip/`
 
 **What:** the generated `Runtime/Core/Protocol/*.g.cs` DTOs round-trip cleanly through
-`System.Text.Json` — each outgoing event type serialises to the expected wire shape and each
+Newtonsoft.Json — each outgoing event type serialises to the expected wire shape and each
 incoming event type deserialises through the polymorphic converter.
 **How:** the generator re-emits the DTOs **and** a sibling `Codegen~/round-trip/Program.cs`
 that exercises every type; `dotnet run` compiles and runs it.
 **Run:** `pnpm --dir Codegen~ run round-trip`. The companion `pnpm --dir Codegen~ run
 verify:protocol-dtos` regenerates and asserts `git diff --exit-code` to catch drift between
-the AsyncAPI spec and the committed DTOs.
+the AsyncAPI spec and the committed DTOs; `pnpm --dir Codegen~ run test` unit-tests the
+generator's C# preset.
 
 ### 3 — C# Edit Mode tests (Unity Test Runner) — `Tests/Editor/`
 
@@ -165,21 +170,24 @@ stream Unity's log live). Failures are formatted for the VS Code problem matcher
 installed, `unity test TestProject --mode EditMode -- -nographics` runs the same suite against
 whichever editor matches `ProjectVersion.txt` (`--allow-install` fetches it if missing).
 
-### 4 — WebGL builds (Unity Test Runner via `HostBuild`) — `TestProject/build-*.sh`
+### 4 — Player builds (`HostBuild` via `-executeMethod`) — `TestProject/build-*.sh`
 
-**What:** that the C# + jslib code actually compiles into a working WebGL artifact via IL2CPP.
+**What:** that the C# + jslib code actually compiles into a working IL2CPP player.
 **How:** [`Editor/HostBuild.cs`](Editor/HostBuild.cs) constructs an empty scene with one of
 the smoke MonoBehaviours, runs `BuildPipeline.BuildPlayer`, and exits with the build result.
-Two entry points produce two artifacts under separate dirs so each browser test can run
-against its own build:
+Each entry point writes to its own directory so each browser test can run against its own
+build:
 
 | Script | Sample | Output |
 |---|---|---|
 | `bash TestProject/build-webgl.sh` | `Samples/BridgeSmokeTest/` (primitives) | `TestProject/Build/WebGL/` |
 | `bash TestProject/build-webgl-conversation.sh` | `Samples/ConversationSmokeTest/` | `TestProject/Build/WebGLConversationSmoke/` |
+| `bash TestProject/build-webgl-conversation-spatial.sh` | `Samples/ConversationSmokeTest/` (spatial) | `TestProject/Build/WebGLConversationSpatialSmoke/` |
+| `bash TestProject/build-standalone.sh` | `Samples/StandaloneSmokeTest/` | `TestProject/Build/Standalone/` |
 
-IL2CPP compilation is the bottleneck — expect each build to take several minutes. Both must
-exist for the browser tests below to run.
+IL2CPP compilation is the bottleneck — expect each build to take several minutes. The three
+WebGL builds must exist for the browser tests below to run. The standalone smoke is run by
+hand; see [`Samples/StandaloneSmokeTest/README.md`](Samples/StandaloneSmokeTest/README.md).
 
 ### 5 — Browser integration tests (Vitest + Playwright) — `IntegrationTests~/`
 
@@ -193,11 +201,15 @@ exist for the browser tests below to run.
   Playwright's `page.on('websocket')` to lock the on-wire protocol shape (handshake,
   `user_message` payload, `conversation_initiation_metadata` / `agent_response` / `audio`
   frame sequence).
+- The **spatial smoke** drives the spatial conversation build and asserts the Web Audio sink
+  mirrors the supplied `AudioSource`.
+- The **conversation shape** test statically inspects the conversation build's emitted
+  framework JS.
 
 **How:** [`IntegrationTests~/src/playwright-harness.ts`](IntegrationTests~/src/playwright-harness.ts)
 exposes a shared `runWebGLSmoke(opts)` helper — both test files declare pass / fail / skip
 matchers and let the helper resolve a typed outcome from the console + page-error streams.
-**Run:** `pnpm --dir IntegrationTests~ run test`. Requires both WebGL builds to exist on
+**Run:** `pnpm --dir IntegrationTests~ run test`. Requires the WebGL builds to exist on
 disk (a missing build surfaces an explicit error from the harness, not a confusing browser
 404).
 
@@ -227,6 +239,7 @@ pnpm --dir Codegen~ run format:check
 pnpm --dir Codegen~ run lint
 pnpm --dir Codegen~ run typecheck
 pnpm --dir Codegen~ run generate
+pnpm --dir Codegen~ run test
 pnpm --dir Codegen~ run round-trip
 pnpm --dir Codegen~ run verify:protocol-dtos
 
@@ -234,6 +247,7 @@ pnpm --dir TestProject run typecheck
 pnpm --dir TestProject run test
 bash TestProject/build-webgl.sh                # only when WebGL surface changed
 bash TestProject/build-webgl-conversation.sh   # only when WebGL or Conversation changed
+bash TestProject/build-webgl-conversation-spatial.sh   # only when WebGL audio output changed
 
 pnpm --dir IntegrationTests~ run typecheck
 pnpm --dir IntegrationTests~ run test
@@ -250,15 +264,25 @@ immediately visible.
   internal abstractions (`IConnection` / `IInputController` / `IOutputController`); platform
   asmdefs ship the implementations.
 - WebGL-specific C# lives under `Runtime/WebGL/` in `ElevenLabs.Agents.WebGL`, scoped to
-  `WebGL` + `Editor` platforms. Native C# (Phase 7) will live under `Runtime/Native/` in an
-  asmdef with no platform restriction and `excludePlatforms=WebGL`.
-- **Platform selection happens at runtime via a static delegate, not at compile time with
-  `#if`.** `Conversation.StartSessionAsync` calls a `internal static Func<ConversationOptions,
-  Awaitable<Conversation>>? SessionFactory` registered by each platform's launcher (see
-  [`Runtime/WebGL/Bridged/BridgedSessionLauncher.cs`](Runtime/WebGL/Bridged/BridgedSessionLauncher.cs)
-  for the WebGL registration via `[RuntimeInitializeOnLoadMethod]` and the Editor mirror via
-  `[InitializeOnLoadMethod]`). This pattern is what lets Core stay platform-free without
-  taking a build-time reference on either platform asmdef; each asmdef's `includePlatforms`
-  guarantees at most one launcher is included per build, so "last write wins" is harmless.
+  `WebGL` + `Editor` platforms. Native C# lives under `Runtime/Native/` in
+  `ElevenLabs.Agents.Native` (`excludePlatforms=WebGL`).
+- **Core never references a platform asmdef.** `Conversation.StartSessionAsync` calls an
+  `internal static Func<ConversationOptions, Awaitable<Conversation>>? SessionFactory` that
+  each platform's launcher assigns on load:
+  [`BridgedSessionLauncher.cs`](Runtime/WebGL/Bridged/BridgedSessionLauncher.cs) and
+  [`NativeSessionLauncher.cs`](Runtime/Native/NativeSessionLauncher.cs). Both asmdefs compile
+  in the Editor, so each launcher's registration is wrapped in `#if UNITY_WEBGL` /
+  `#if !UNITY_WEBGL` to make exactly one of them assign the factory for the active build
+  target.
 - `.jslib` files must be placed under `Plugins/WebGL/` for Unity's build pipeline to pick
   them up.
+
+## Submitting changes
+
+- For anything beyond a small fix, open an [issue](https://github.com/elevenlabs/unity/issues/new/choose) first so the approach can be agreed before you invest in it.
+- Branch from `main`, run the verification layers your change touches (see [Running the full verification suite](#running-the-full-verification-suite)), and fill in the pull request template.
+- Add an entry under `[Unreleased]` in [`CHANGELOG.md`](CHANGELOG.md) for user-facing changes, and call out any public API change in the PR description.
+- CI runs the lint lane (formatters, linters, typechecks, JS unit tests, generated-artefact drift) on every PR. The Unity lanes (Edit Mode tests, WebGL builds, browser integration tests) need Unity license secrets that GitHub doesn't expose to PRs from forks, so they fail there; a maintainer runs them before merging.
+- Report security vulnerabilities privately per [`SECURITY.md`](.github/SECURITY.md), not in issues or PRs.
+
+By contributing you agree that your contributions are licensed under the repository's [MIT license](LICENSE).
diff --git a/Docs~/ARCHITECTURE.md b/Docs~/ARCHITECTURE.md
index 6df478a..e61575b 100644
--- a/Docs~/ARCHITECTURE.md
+++ b/Docs~/ARCHITECTURE.md
@@ -1,130 +1,152 @@
 # Architecture
 
-> Living document. Captures the **to-be** shape of the ElevenLabs Unity SDK as we
-> build toward v0.1 and beyond. Update as decisions land. For implementation
-> sequencing, see [`plans/`](./plans/).
+> How the ElevenLabs Unity SDK is put together: assemblies, transports, audio
+> pipeline, and codegen. For in-flight design work, see [`plans/`](./plans/).
 
 ## Goal
 
-One public C# API for ElevenLabs Agents across every Unity target — desktop,
-mobile, XR, and WebGL — with no `#if UNITY_WEBGL` leaking past the
-infrastructure layer. The user writes a single `Conversation` against a single
-event/method surface and gets identical semantics regardless of where their
-game runs.
+One public C# API for ElevenLabs Agents across native Unity targets and WebGL.
+The user writes a single `Conversation` against a single event/method surface
+and gets the same semantics regardless of where their game runs. Desktop
+standalone, the Editor, and WebGL are built and tested; other native targets
+share the native implementation but are untested.
 
 ## Overview
 
 ```
 ┌──────────────────────────────────────────────────────────────────────────┐
-│  ElevenLabs.Agents        (public C# API — identical on every platform)  │
-│    Conversation, ConversationOptions, events, ClientTools                │
-└──────────────────────────────────────────────────────────────────────────┘
-                                    │
-                                    │   depends on
-                                    ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  ElevenLabs.Agents.Core   (internal abstractions, shared by all impls)   │
-│    IConnection            — mirrors @elevenlabs/client BaseConnection    │
-│    IInputController       — mirrors @elevenlabs/client InputController   │
-│    IOutputController      — mirrors @elevenlabs/client OutputController  │
-│    Protocol DTOs          — codegen from AsyncAPI (incoming + outgoing)  │
+│  ElevenLabs.Agents.Core   (asmdef; every platform)                       │
+│    public    Conversation, ConversationOptions, events, RegisterTool     │
+│              Protocol DTOs + *Args records in ElevenLabs.Protocol        │
+│              (codegen from AsyncAPI, incoming + outgoing)                │
+│    internal  IConnection        mirrors JS SDK BaseConnection            │
+│              IInputController   mirrors JS SDK InputController           │
+│              IOutputController  mirrors JS SDK OutputController          │
 └──────────────────────────────────────────────────────────────────────────┘
             │                                              │
-            │  #if !UNITY_WEBGL                            │  #if UNITY_WEBGL
+            │  excludePlatforms: [WebGL]                   │  includePlatforms: [Editor, WebGL]
             ▼                                              ▼
 ┌─────────────────────────────────────┐    ┌──────────────────────────────────┐
 │  ElevenLabs.Agents.Native           │    │  ElevenLabs.Agents.WebGL         │
 │    NativeWebSocketConnection        │    │    BridgedWebSocketConnection    │
 │    UnityMicrophoneInput             │    │    BridgedWebRTCConnection       │
 │    UnityAudioSourceOutput           │    │    BridgedInputController        │
-│  (future) NativeWebRTCConnection    │    │    BridgedOutputController       │
-└─────────────────────────────────────┘    └──────────────────────────────────┘
-                                                            │
-                                                            │  jslib via
-                                                            ▼
+│      └ IAudioOutputEngine           │    │    WebAudioBackedOutput (WS)     │
+│        └ UnityGeneratorAudio-       │    │    BridgedOutputController (RTC) │
+│          OutputEngine               │    └──────────────────────────────────┘
+│          + AgentAudioGenerator-     │                     │
+│            Component (IAudioGen.)   │                     │  jslib via
+└─────────────────────────────────────┘                     ▼
                                             ┌──────────────────────────────────┐
                                             │  WebGL Bridge (jslib)            │
                                             │    Primitives: JsObject /        │
                                             │                JsFunction /      │
                                             │                BridgeCallback    │
                                             │    Factories: @elevenlabs/client │
-                                            │                classes registered│
-                                            │                at module init    │
+                                            │                classes + Web     │
+                                            │                Audio sink,       │
+                                            │                registered at init│
                                             └──────────────────────────────────┘
 ```
 
 The same `Conversation` orchestrates `IConnection` + `IInputController` +
-`IOutputController` regardless of platform. The bridge moves *down* one layer:
-instead of bridging the conversation, the WebGL implementation bridges the
-three abstractions the conversation depends on, using a generic primitive
-layer that knows nothing about the SDK.
+`IOutputController` regardless of platform. Instead of bridging the
+conversation, the WebGL implementation bridges the three abstractions the
+conversation depends on, using a generic primitive layer that knows nothing
+about the SDK.
+
+### Platform selection
+
+The platform split is done by asmdef platform filters, not `#if` around
+implementation code. [`ElevenLabs.Agents.Native`](../Runtime/Native/ElevenLabs.Agents.Native.asmdef)
+excludes WebGL; [`ElevenLabs.Agents.WebGL`](../Runtime/ElevenLabs.Agents.WebGL.asmdef)
+(at the `Runtime/` root, covering `Runtime/WebGL/`) includes only Editor and
+WebGL, so its Edit Mode tests compile on any active build target. Both
+assemblies therefore load in the Editor. Each ships a launcher
+([`NativeSessionLauncher`](../Runtime/Native/NativeSessionLauncher.cs),
+[`BridgedSessionLauncher`](../Runtime/WebGL/Bridged/BridgedSessionLauncher.cs))
+that assigns `Conversation.SessionFactory` at startup; their registration is
+guarded by `#if !UNITY_WEBGL` / `#if UNITY_WEBGL` so exactly one wins. The
+remaining `#if` guards sit in the WebGL interop layer, swapping its
+`DllImport`s for throwing stubs outside a WebGL player.
 
 ## The C# Conversation
 
-Owns: lifecycle, status/mode tracking, message dispatch, interruption handling,
-client-tool invocation, feedback eligibility, server-tool routing.
+Owns: lifecycle, status/mode tracking, message dispatch, ping/pong,
+interruption handling, client-tool invocation, feedback eligibility, agent-tool
+and MCP event routing, file upload.
 
 Does **not** own: WebSocket framing, microphone access, audio playback. Those
 are behind the three abstractions below.
 
 The public surface mirrors `@elevenlabs/client`'s `Conversation` conceptually
-but is idiomatic C# (standard `event` keyword with `+=` / `-=`; `Awaitable<T>`
-for async methods; `IDisposable` for cleanup). Wire-level message shapes come
-from the same AsyncAPI spec the JS SDK consumes, so the two clients stay in
-lock-step at the protocol layer.
-
-Event subscribers register and deregister freely at any time. The C# `Conversation`
-holds standard .NET multicast delegates; the JS-side connection's single
-`onMessage` callback is wired once at session start (via a `BridgeCallback`)
-and the C# router fans out into the user's subscribed events. No "register all
-listeners before `StartSession`" constraint — that limitation belonged to the
-old design where the C# side was a façade over `@elevenlabs/client`'s
-`Conversation`.
+but is idiomatic C#: standard `event` keyword with `+=` / `-=`; `Awaitable` /
+`Awaitable<T>` for async methods (`StartSessionAsync`, `EndSession`,
+`UploadFileAsync`, …). Wire-level message shapes come from the same AsyncAPI
+spec the JS SDK consumes, so the two clients stay in lock-step at the protocol
+layer.
+
+Event subscribers register and deregister freely at any time. The connection's
+single `onMessage` callback is wired once at session start and the C# router
+fans out into the user's subscribed events.
 
 ## The three abstractions
 
-Each mirrors a class already proven in `@elevenlabs/client`. Keeping the
-C# shapes close to the JS shapes means the bridged WebGL implementations are
-near-passthrough, and divergence between the two transports stays small.
+Each mirrors a class in `@elevenlabs/client` and is `internal` to
+`ElevenLabs.Agents.Core`, exposed via `InternalsVisibleTo` to the Native and
+WebGL assemblies (and their tests). Supporting types referenced from the
+public surface (`Mode`, `FormatConfig`, `InputDeviceConfig`,
+`OutputDeviceConfig`, `DisconnectionDetails`) are `public`.
 
 ### IConnection
 
-Mirrors [`BaseConnection`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/utils/BaseConnection.ts):
+Mirrors [`BaseConnection`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/utils/BaseConnection.ts)
+([source](../Runtime/Core/IConnection.cs)):
 
 - Properties: `ConversationId`, `InputFormat`, `OutputFormat`
-- `Send(OutgoingSocketEvent)` — typed outgoing message
+- `void Send(OutgoingSocketEvent message)`
 - Events: `OnMessage(IncomingSocketEvent)`, `OnDisconnect(DisconnectionDetails)`, `OnModeChange(Mode)`
-- `Close()`
+- `void Close()` (idempotent)
 
 Implementations:
-- `NativeWebSocketConnection` — `System.Net.WebSockets.ClientWebSocket`
+
+- `NativeWebSocketConnection` — `System.Net.WebSockets.ClientWebSocket`; rejects `ConnectionType.WebRTC` with `NotSupportedException`
 - `BridgedWebSocketConnection` — wraps `@elevenlabs/client`'s `WebSocketConnection`
-- `BridgedWebRTCConnection` — wraps `@elevenlabs/client`'s `WebRTCConnection`
-- `NativeWebRTCConnection` — future (post-1.0)
+- `BridgedWebRTCConnection` — wraps `@elevenlabs/client`'s `WebRTCConnection` (WebGL only)
+
+The transport is chosen explicitly via `ConversationOptions.ConnectionType`
+(default `WebSocket`).
 
 ### IInputController
 
-Mirrors [`InputController`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/InputController.ts):
+Mirrors [`InputController`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/InputController.ts)
+([source](../Runtime/Core/IInputController.cs)):
 
-- `Close()`, `SetDevice(InputDeviceConfig)`, `SetMuted(bool)`, `IsMuted`
-- `GetVolume()`, `GetByteFrequencyData(byte[] buffer)`
-- Audio source for the connection (see "Audio routing" below)
+- `bool IsMuted`
+- `event Action<byte[]>? AudioChunkAvailable` — 16-bit LE PCM; native only
+- `Awaitable Close()`, `Awaitable SetDevice(InputDeviceConfig? config = null, FormatConfig? format = null)`, `Awaitable SetMuted(bool isMuted)`
+- `float GetVolume()`, `void GetByteFrequencyData(byte[] buffer)`
 
 Implementations:
-- `UnityMicrophoneInput` — `UnityEngine.Microphone` + an `AudioClip` PCM reader
-- `BridgedInputController` — wraps `@elevenlabs/client`'s `MediaDeviceInput`
+
+- `UnityMicrophoneInput` — `UnityEngine.Microphone` into a looping `AudioClip`, polled on the main thread every ~25 ms
+- `BridgedInputController` — wraps `@elevenlabs/client`'s `MediaDeviceInput` (WebSocket) or the WebRTC connection's coupled input
 
 ### IOutputController
 
-Mirrors [`OutputController`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/OutputController.ts):
+Mirrors [`OutputController`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/OutputController.ts)
+([source](../Runtime/Core/IOutputController.cs)):
 
-- `Close()`, `SetDevice(OutputDeviceConfig)`, `SetVolume(float)`, `Interrupt(int? resetMs)`
-- `GetVolume()`, `GetByteFrequencyData(byte[] buffer)`
-- Audio sink fed by the connection (see "Audio routing" below)
+- `Awaitable Close()`, `Awaitable SetDevice(OutputDeviceConfig? config = null, FormatConfig? format = null)`
+- `void PushAudio(byte[] pcm)` — 16-bit LE PCM; no-op on WebGL
+- `void SetVolume(float volume)`, `void Interrupt(int? resetDurationMs = null)`
+- `float GetVolume()`, `void GetByteFrequencyData(byte[] buffer)`
 
 Implementations:
-- `UnityAudioSourceOutput` — PCM into an `AudioClip` via `PCMReaderCallback`, played through an `AudioSource`
-- `BridgedOutputController` — wraps `@elevenlabs/client`'s `MediaDeviceOutput`
+
+- `UnityAudioSourceOutput` — decodes PCM into a ring buffer drained on the audio thread by an `IAudioOutputEngine` (see "Audio routing")
+- `WebAudioBackedOutput` — WebSocket arm on WebGL; drives the JS `createWebAudioSink`
+- `BridgedOutputController` — WebRTC arm on WebGL; wraps the connection's coupled output
 
 ## Bridge primitives
 
@@ -135,12 +157,11 @@ and one set of JSON marker conventions (`$ref` / `$fn` / `$cb`) for passing
 handles across the boundary.
 
 - **`JsObject`** — C# handle to a remote JS object. Construct via `JsBridge.InvokeFactoryAsync<JsObject>(name, args)` against factories the JS side registered at module init; call methods, read properties, dispose.
-- **`JsFunction`** — C# handle to a remote JS function (typically returned from a `JsObject` method, e.g. a `removeListener` returned by `addListener`); call sync or async, dispose.
-- **`BridgeCallback`** — C# delegate exposed to JS as a callable. Wrap a delegate, pass it as a method argument; JS sees a plain function. When JS calls it, SendMessage routes back to the bridge and the wrapped delegate runs on Unity's main thread.
+- **`JsFunction`** — C# handle to a remote JS function (typically returned from a `JsObject` method or factory, e.g. the detach function returned by `attachDefaultAudio`); call sync or async, dispose.
+- **`BridgeCallback`** — C# delegate exposed to JS as a callable. Wrap a delegate, pass it as a method argument; JS sees a plain function. JS invokes it through a function pointer registered at startup (`makeDynCall`), and the delegate runs on Unity's main thread. Fire-and-forget: JS gets no return value.
 
-Adding a method to the JS SDK requires **no new bridge code** — the C#
-façade just calls a new method name through the existing `JsObject`
-primitive.
+Calling a new method on an already-exposed JS object requires **no new bridge
+code** — the C# side just calls a new method name through `JsObject`.
 
 ## Audio routing
 
@@ -148,124 +169,129 @@ Identical from the consumer's perspective — same `Conversation`, same events,
 same `ConversationOptions.OutputAudioSource` — but each platform reaches the
 speakers differently.
 
-### Native (desktop / mobile / XR)
+### Native
 
-Input controller emits PCM frames → C# Conversation wraps them as
+Input controller emits PCM chunks → C# Conversation wraps them as
 `user_audio_chunk` → connection sends. Connection emits audio events → C#
-Conversation routes the chunk into the output controller →
-[`UnityAudioSourceOutput`](../Runtime/Native/UnityAudioSourceOutput.cs) feeds
-an `AudioClip` via `PCMReaderCallback` and plays it through the `AudioSource`
-(either a hidden host GameObject or the user-supplied
-`ConversationOptions.OutputAudioSource`). FMOD owns spatialisation, mixer
-routing, rolloff curves, and effects.
+Conversation decodes the payload and calls `PushAudio` →
+[`UnityAudioSourceOutput`](../Runtime/Native/UnityAudioSourceOutput.cs) writes
+it into a ring buffer. The production engine,
+[`UnityGeneratorAudioOutputEngine`](../Runtime/Native/UnityGeneratorAudioOutputEngine.cs),
+adds an [`AgentAudioGeneratorComponent`](../Runtime/Native/AgentAudioGeneratorComponent.cs)
+(Unity 6.3 `IAudioGenerator`) next to the `AudioSource` — either a hidden host
+GameObject or the user-supplied `ConversationOptions.OutputAudioSource` — and
+drains the ring on the audio thread, resampling to the device output rate.
+Unity's audio engine owns spatialisation, mixer routing, rolloff curves, and
+effects. The streaming-`AudioClip` engine
+([`UnityAudioOutputEngine`](../Runtime/Native/UnityAudioOutputEngine.cs)) is
+not used in production; it remains as a fallback covered by a PlayMode
+characterization test.
 
 ### WebGL
 
-Audio bytes **never cross the bridge** in either direction. Input ↔ connection
-↔ output are wired *inside JavaScript* using `@elevenlabs/client`'s existing
+Audio bytes **never cross the bridge** in either direction. On the WebSocket
+arm, input ↔ connection ↔ output are wired _inside JavaScript_ by the
+`attachDefaultAudio` factory
+([`audio-glue.ts`](../Bridge~/src/connection/audio-glue.ts)), which composes
+`@elevenlabs/client`'s
 [`attachInputToConnection`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/utils/attachInputToConnection.ts)
-and [`attachConnectionToOutput`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/utils/attachConnectionToOutput.ts)
-helpers — both compose against arbitrary sinks/sources, so no upstream changes
-are needed to swap in a Unity-specific output. The C# Conversation still
-receives audio events from the connection (for `event_id` tracking,
-interruption, mode/feedback), but with the `audio_base_64` payload stripped
-on the JS side.
-
-Spatial playback on the WebSocket arm goes through a parallel Web Audio graph
-([`Bridge~/src/connection/web-audio-sink.ts`](../Bridge~/src/connection/web-audio-sink.ts)
-→ `AudioWorkletNode` → `GainNode` → `PannerNode` / `StereoPannerNode` →
-`AudioContext.destination`). When `ConversationOptions.OutputAudioSource` is
-set, [`WebAudioBackedOutput`](../Runtime/WebGL/Bridged/WebAudioBackedOutput.cs)
+and [`attachConnectionToOutput`](https://github.com/elevenlabs/packages/blob/main/packages/client/src/utils/attachConnectionToOutput.ts).
+The C# Conversation still receives audio events from the connection (for
+`event_id` tracking, interruption, mode/feedback), but with the `audio_base_64`
+payload stripped on the JS side.
+
+Playback on the WebSocket arm always goes through a Web Audio graph
+([`web-audio-sink.ts`](../Bridge~/src/connection/web-audio-sink.ts):
+`AudioWorkletNode` → gain → analyser → `StereoPannerNode` / `PannerNode`
+crossfade → `AudioContext.destination`). When
+`ConversationOptions.OutputAudioSource` is set,
+[`WebAudioBackedOutput`](../Runtime/WebGL/Bridged/WebAudioBackedOutput.cs)
 mirrors a curated subset of the `AudioSource`'s properties (transform position
-in the active `AudioListener`'s local frame, `spatialBlend`, `minDistance`,
-`maxDistance`, `rolloffMode`, `panStereo`, `dopplerLevel`) onto the JS sink
-once per Unity frame. The `AudioSource` itself is *decorative* on WebGL — Unity
-never streams audio through it because Unity *can't* (no scriptable audio
-pipeline on WebGL — see
+in the active `AudioListener`'s local frame, `volume`, `spatialBlend`,
+`minDistance`, `maxDistance`, `rolloffMode`, `panStereo`) onto the JS sink
+once per Unity frame; without one, the sink plays unspatialized mono.
+`dopplerLevel` is pushed too but has no effect, since Web Audio has no doppler
+scalar. The `AudioSource` itself is _decorative_ on WebGL — Unity never streams
+audio through it because it can't (no scriptable audio pipeline on WebGL — see
 [`unity-issues/webgl-scriptable-audio-pipeline.md`](./unity-issues/webgl-scriptable-audio-pipeline.md)).
-The fidelity matrix (which `AudioSource` properties round-trip vs. degrade vs.
-warn-once) lives in [`COMPATIBILITY.md`](../COMPATIBILITY.md#webgl-audio-output-limitations);
-the full design and rationale live in
-[`plans/output-audio-source.md`](./plans/output-audio-source.md).
-
-WebRTC-on-WebGL is the one path still outstanding: LiveKit owns the audio
-pipeline via a remote `AudioTrack`, so feeding the supplied `AudioSource`
-needs a Unity-specific `WebRTCAudioAdapter` that exposes decoded PCM frames
-to the same Web Audio sink. Tracked under v0.3.
+The fidelity matrix lives in
+[`COMPATIBILITY.md`](../COMPATIBILITY.md#webgl-audio-output-limitations); the
+design lives in [`plans/output-audio-source.md`](./plans/output-audio-source.md).
 
-Latency cost on WebGL: zero on the audio path, ~1 Unity frame on
-control-plane operations and property mirroring (acceptable — network
-round-trips dominate).
+On the WebRTC arm, livekit-client owns audio playback through a remote audio
+track, so `OutputAudioSource` is ignored (with a one-time warning).
 
 ## Protocol DTOs
 
-Both `IConnection` implementations speak the same `IncomingSocketEvent` /
-`OutgoingSocketEvent` union. We codegen these C# DTOs from the AsyncAPI spec
-(same source the JS SDK consumes), commit the generated output, and gate
-freshness in CI. The same generated DTOs are used by `BridgedWebSocketConnection`
-when (de)serializing payloads that cross the jslib boundary.
+Both transports speak the same `IncomingSocketEvent` / `OutgoingSocketEvent`
+union. The C# DTOs under `Runtime/Core/Protocol/` are generated by
+[`Codegen~/`](../Codegen~/) from the vendored AsyncAPI spec (same source the
+JS SDK consumes), committed, and checked for drift in CI
+(`verify:protocol-dtos`). They serialize with Newtonsoft.Json
+(`[JsonProperty]`) and are also used when (de)serializing payloads that cross
+the jslib boundary.
 
-What we do **not** codegen: the JS-side wrappers under `Bridge~/src/`. They're
-small enough to hand-write and benefit from being shaped exactly for the
-bridge contract rather than mechanically translated.
+What is **not** generated: the JS-side wrappers under `Bridge~/src/`. They're
+small and shaped exactly for the bridge contract.
 
 ## JS-side artifacts shipped to consumers
 
-Two `.jslib` files under `Plugins/WebGL/`, both committed and CI-verified for
-freshness against their TypeScript sources:
+Two `.jslib` files under `Plugins/WebGL/`, both bundled by Rolldown from
+TypeScript, committed, and checked for drift in CI
+(`verify:primitives` / `verify:connection`):
 
-- `ElevenLabsBridge.jslib` — the three generic primitives; no SDK dependency
-- `ElevenLabsConnection.jslib` — registers `@elevenlabs/client`'s `WebSocketConnection`, `WebRTCConnection`, `MediaDeviceInput`, `MediaDeviceOutput` as factories with the primitive layer, plus the `attachDefaultAudio` composition helper. Bundles `@elevenlabs/client` itself. Contains zero `EL_*` `DllImport` entry points of its own — every interaction with these classes goes through the generic primitives.
+- `ElevenLabsBridge.jslib` — the three generic primitives; no SDK dependency.
+- `ElevenLabsConnection.jslib` — bundles `@elevenlabs/client` and registers its factories with the primitive layer at startup: `createWebSocketConnection`, `createWebRTCConnection`, `createConnection`, `createMediaDeviceInput` ([`factories.ts`](../Bridge~/src/connection/factories.ts)), `attachDefaultAudio`, and `createWebAudioSink`. Its only `DllImport` entry point is the no-op `EL_EnsureConnectionFactoriesLoaded`, called from `BridgedSessionLauncher` so Emscripten doesn't strip the bundle; every interaction with the factories goes through the generic primitives.
 
 Emscripten concatenates them at WebGL build time.
 
 ## Repository layout
 
 ```
-Docs~/
-  ARCHITECTURE.md                ← this file
-  plans/                         ← design plans (read these before architectural changes)
 package.json                     ← UPM manifest (io.elevenlabs.agents)
-
 Runtime/
-  ElevenLabs.Agents.asmdef       ← public API + Core abstractions
-  Conversation.cs
-  ConversationOptions.cs
-  Core/
-    IConnection.cs
-    IInputController.cs
-    IOutputController.cs
+  ElevenLabs.Agents.WebGL.asmdef ← covers Runtime/WebGL/ (Editor + WebGL)
+  Core/                          ← ElevenLabs.Agents.Core.asmdef
+    Conversation.cs, ConversationOptions.cs, ConnectionType.cs, …
+    IConnection.cs, IInputController.cs, IOutputController.cs
+    HttpFileUploader.cs
     Protocol/                    ← codegen output (committed)
-  WebGL/                         ← #if UNITY_WEBGL
-    BridgedWebSocketConnection.cs   ← thin wrapper around a JsObject
-    BridgedWebRTCConnection.cs      ← thin wrapper around a JsObject
-    BridgedInputController.cs       ← thin wrapper around a JsObject
-    BridgedOutputController.cs      ← thin wrapper around a JsObject
-    BridgedSession.cs               ← orchestrates the factory calls + attachDefaultAudio
-    WebGLBridge.cs                  ← primitives MonoBehaviour (existing scaffolding)
-    JsBridge.cs                     ← public InvokeFactory entry point
-    JsObject.cs
-    JsFunction.cs
-    BridgeCallback.cs
-  Native/                        ← #if !UNITY_WEBGL
-    NativeWebSocketConnection.cs
-    UnityMicrophoneInput.cs
-    UnityAudioSourceOutput.cs
-
+  Native/                        ← ElevenLabs.Agents.Native.asmdef (all but WebGL)
+    NativeSessionLauncher.cs, NativeWebSocketConnection.cs
+    UnityMicrophoneInput.cs, UnityAudioSourceOutput.cs
+    IAudioOutputEngine.cs, UnityGeneratorAudioOutputEngine.cs,
+    AgentAudioGeneratorComponent.cs, AgentAudioControl.cs,
+    AgentAudioRealtime.cs, AudioPcmRing.cs, UnityAudioOutputEngine.cs
+  WebGL/
+    JsBridge.cs, JsObject.cs, JsFunction.cs, BridgeCallback.cs
+    ElevenLabsBridgeNative.cs    ← DllImports into the .jslib files
+    Marshalling/, Internal/      ← marker encoding, handle registries
+    Bridged/                     ← BridgedSession(Launcher), Bridged*Connection,
+                                   BridgedInput/OutputController, WebAudioBackedOutput
+Editor/                          ← WebGL build preprocessor, link.xml injector, headless build entry points
 Plugins/WebGL/
-  ElevenLabsBridge.jslib         ← bundled from Bridge~/src/primitives/   (shipping)
-  ElevenLabsConnection.jslib     ← bundled from Bridge~/src/connection/   (Plan B)
+  ElevenLabsBridge.jslib         ← bundled from Bridge~/src/primitives/
+  ElevenLabsConnection.jslib     ← bundled from Bridge~/src/connection/
+Samples/                         ← in-repo smoke-test scenes (Bridge, Conversation, Standalone)
+Samples~/                        ← UPM-importable samples (GettingStarted, QuickStart)
+Tests/
+  Editor/                        ← Edit Mode: bridge primitives, Bridged/, Native/
+  Runtime/Native/                ← Play Mode: audio engine characterization tests
 
 Bridge~/                         ← Unity ignores `~` dirs; JS dev tooling
-  src/
-    primitives/                  ← generic JsObject / JsFunction / BridgeCallback layer
-    connection/                  ← Plan B — factory registrations + attachDefaultAudio helper
-  tests/                         ← Vitest
-
-Tests/Editor/                    ← Unity Test Runner (Edit Mode)
+  src/primitives/                ← generic JsObject / JsFunction / BridgeCallback layer
+  src/connection/                ← factory registrations, audio glue, Web Audio sink
+  build/                         ← Rolldown bundling + makeDynCall substitution
+                                   (Vitest tests are co-located as src/**/*.test.ts)
+Codegen~/                        ← AsyncAPI → C# DTO generator
+IntegrationTests~/               ← Playwright-driven WebGL smoke tests
+TestProject/                     ← host Unity project for headless test runs and builds
+Docs~/
+  ARCHITECTURE.md                ← this file
+  plans/                         ← design plans
+  unity-issues/                  ← Unity bug writeups
 ```
 
 ## Open architecture questions
 
-1. **Connection-aware vs. connection-agnostic Conversation.** Is the choice between WebSocket and WebRTC explicit on `ConversationOptions`, or inferred (as the JS SDK does via `determineConnectionType`)? Lean toward mirroring the JS SDK's inference rules to keep parity.
-2. **Public vs. internal surface of the three abstractions.** Settled in Phase 4.2 — `IConnection` / `IInputController` / `IOutputController` are `internal` to `ElevenLabs.Agents.Core`, exposed via `InternalsVisibleTo` to `ElevenLabs.Agents.WebGL` (and the future `ElevenLabs.Agents.Native`) so platform impls can satisfy them. Supporting types referenced from the public Conversation surface (`Mode`, `FormatConfig`, `InputDeviceConfig`, `OutputDeviceConfig`, `DisconnectionDetails` + friends) stay `public`. Revisit if users want to plug in custom transports (e.g. a relay); flipping `internal → public` is non-breaking.
+1. **Public vs. internal surface of the three abstractions.** They are `internal` today. Revisit if users want to plug in custom transports (e.g. a relay); flipping `internal → public` is non-breaking.
diff --git a/Samples~/QuickStart/README.md b/Samples~/QuickStart/README.md
index 949b344..0466dfa 100644
--- a/Samples~/QuickStart/README.md
+++ b/Samples~/QuickStart/README.md
@@ -50,7 +50,8 @@ Assumes the SDK is already installed in a Unity 6.3 LTS project — see the
      [`agents` skill](https://github.com/elevenlabs/skills/tree/main/agents)
      (`npx skills add elevenlabs/skills`). Leave `Signed Url` blank for
      public agents; fill it in for private agents that require a pre-signed
-     URL.
+     URL. Leave `Connection Type` on WebSocket unless you're building for
+     WebGL — WebRTC is only available there.
 
 3. **Open the imported scene** (`QuickStart.unity`) and press Play. The
    scene contains a single GameObject named `QuickStart` carrying the
@@ -63,8 +64,8 @@ nothing else happens, so your project still runs cleanly.
 
 ## Next steps
 
-Once the QuickStart is running, the other samples in this package layer one
-feature each on top of the same pattern: client tools, dynamic variables, and
-a microphone visualizer. The full conversation API surface lives on the
+Once the QuickStart is running, the GettingStarted sample builds on the same
+pattern with trigger-based sessions, dynamic variables, overrides, and spatial
+audio. The full conversation API surface lives on the
 `Conversation` class (`ElevenLabs.Agents`); see the XML documentation comments
 in `Runtime/Core/Conversation.cs` for the complete event and method list.

From 906e622a113b13d9658f12f804f4936c3692f1ba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kr=C3=A6n=20Hansen?= <kraen@elevenlabs.io>
Date: Fri, 2 Oct 2026 14:34:30 +0200
Subject: [PATCH 3/6] Fix stale references in public docs and errors

The missing-session-factory error named the native transport as a future
v0.2 addition, and OutputAudioSource's docs referenced a nonexistent
EndSessionAsync.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 Runtime/Core/Conversation.cs            | 4 ++--
 Runtime/Core/ConversationOptions.cs     | 2 +-
 Runtime/WebGL/Bridged/BridgedSession.cs | 5 -----
 3 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/Runtime/Core/Conversation.cs b/Runtime/Core/Conversation.cs
index 5f9418a..14a4295 100644
--- a/Runtime/Core/Conversation.cs
+++ b/Runtime/Core/Conversation.cs
@@ -292,8 +292,8 @@ public static Awaitable<Conversation> StartSessionAsync(ConversationOptions opti
             {
                 throw new InvalidOperationException(
                     "No session factory is registered for the current platform. "
-                        + "Ensure ElevenLabs.Agents.WebGL (or the native impl in v0.2) is "
-                        + "included in your build target."
+                        + "Ensure the ElevenLabs.Agents.WebGL or ElevenLabs.Agents.Native "
+                        + "assembly is included in your build target."
                 );
             }
             return factory(options);
diff --git a/Runtime/Core/ConversationOptions.cs b/Runtime/Core/ConversationOptions.cs
index a2feb6d..b9e19db 100644
--- a/Runtime/Core/ConversationOptions.cs
+++ b/Runtime/Core/ConversationOptions.cs
@@ -50,7 +50,7 @@ public sealed record ConversationOptions
         /// On native, audio plays through the supplied <see cref="AudioSource"/>
         /// with full FMOD fidelity. SDK-owned overwrites: <c>clip</c>,
         /// <c>loop</c>, and <c>volume</c> are captured at session start and
-        /// restored on <see cref="Conversation.EndSessionAsync"/>. Everything
+        /// restored on <see cref="Conversation.EndSession"/>. Everything
         /// else (<c>spatialBlend</c>, <c>outputAudioMixerGroup</c>, rolloff
         /// curves, transform position) is preserved untouched.
         /// </para>
diff --git a/Runtime/WebGL/Bridged/BridgedSession.cs b/Runtime/WebGL/Bridged/BridgedSession.cs
index 2063344..58804a1 100644
--- a/Runtime/WebGL/Bridged/BridgedSession.cs
+++ b/Runtime/WebGL/Bridged/BridgedSession.cs
@@ -35,11 +35,6 @@ namespace ElevenLabs.WebGL.Bridged
     /// <c>attachDefaultAudio</c> call.
     /// </description></item>
     /// </list>
-    /// <para>
-    /// Phase 5.4 wires <see cref="Conversation.StartSessionAsync"/> to delegate
-    /// here under <c>#if UNITY_WEBGL</c>; until then this class is consumed
-    /// only by tests and any explicit WebGL launcher experiments.
-    /// </para>
     /// </remarks>
     internal sealed class BridgedSession
     {

From a3ac41b46b840e1b24a7f9fce9f2064ec84c490b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kr=C3=A6n=20Hansen?= <kraen@elevenlabs.io>
Date: Fri, 2 Oct 2026 14:44:09 +0200
Subject: [PATCH 4/6] Skip Unity CI lanes on fork pull requests

GitHub withholds repo secrets from fork PRs, so game-ci's Unity
activation fails there. Skipping the Edit Mode and WebGL build jobs
(the integration job follows via `needs`) keeps outside contributors'
PRs from showing red checks; only the lint lane is a required check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/integration.yml | 2 ++
 .github/workflows/unity-tests.yml | 2 ++
 CONTRIBUTING.md                   | 2 +-
 3 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 2b27c12..5f748c2 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -26,6 +26,8 @@ permissions:
 jobs:
   build-webgl:
     name: Build WebGL — ${{ matrix.scene.name }} (Unity 6000.3.6f1)
+    # Fork PRs don't receive the UNITY_* secrets, so Unity activation would fail.
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
     runs-on: ubuntu-latest
     strategy:
       # Run both scenes in parallel on separate runners — each gets its own
diff --git a/.github/workflows/unity-tests.yml b/.github/workflows/unity-tests.yml
index fc8566a..66ea6b1 100644
--- a/.github/workflows/unity-tests.yml
+++ b/.github/workflows/unity-tests.yml
@@ -26,6 +26,8 @@ permissions:
 jobs:
   edit-mode:
     name: Edit Mode tests (Unity 6000.3.6f1)
+    # Fork PRs don't receive the UNITY_* secrets, so Unity activation would fail.
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e9bcef8..5e654f9 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -282,7 +282,7 @@ immediately visible.
 - For anything beyond a small fix, open an [issue](https://github.com/elevenlabs/unity/issues/new/choose) first so the approach can be agreed before you invest in it.
 - Branch from `main`, run the verification layers your change touches (see [Running the full verification suite](#running-the-full-verification-suite)), and fill in the pull request template.
 - Add an entry under `[Unreleased]` in [`CHANGELOG.md`](CHANGELOG.md) for user-facing changes, and call out any public API change in the PR description.
-- CI runs the lint lane (formatters, linters, typechecks, JS unit tests, generated-artefact drift) on every PR. The Unity lanes (Edit Mode tests, WebGL builds, browser integration tests) need Unity license secrets that GitHub doesn't expose to PRs from forks, so they fail there; a maintainer runs them before merging.
+- CI runs the lint lane (formatters, linters, typechecks, JS unit tests, generated-artefact drift) on every PR. The Unity lanes (Edit Mode tests, WebGL builds, browser integration tests) need Unity license secrets that GitHub doesn't expose to PRs from forks, so they're skipped there; maintainers verify them before merging.
 - Report security vulnerabilities privately per [`SECURITY.md`](.github/SECURITY.md), not in issues or PRs.
 
 By contributing you agree that your contributions are licensed under the repository's [MIT license](LICENSE).

From 7270a4f300f60149907c0fe3d690f7bc14464e24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kr=C3=A6n=20Hansen?= <kraen@elevenlabs.io>
Date: Fri, 2 Oct 2026 14:48:47 +0200
Subject: [PATCH 5/6] Run Unity CI on fork PRs after maintainer approval

GitHub withholds secrets from fork-triggered pull_request runs, even
after "Approve and run", so the Unity lanes can't activate there.
Same-repo PRs and pushes keep running unattended via pull_request.
Fork PRs run via pull_request_target, pinned to the PR head SHA, behind
the fork-ci environment's required reviewers. Runs inside forks are
skipped.

Fork runs execute untrusted editor code with license secrets, so they
also don't persist checkout credentials or save caches (caches written
under pull_request_target land in main's scope). Concurrency groups
include the event and PR number so fork runs don't cancel main's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/integration.yml | 37 +++++++++++++++++++++++++++----
 .github/workflows/unity-tests.yml | 32 +++++++++++++++++++++++---
 CONTRIBUTING.md                   |  2 +-
 3 files changed, 63 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 5f748c2..2f05a8a 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -14,9 +14,14 @@ on:
       - "Docs~/**"
       - "**.md"
       - ".claude/**"
+  pull_request_target:
+    paths-ignore:
+      - "Docs~/**"
+      - "**.md"
+      - ".claude/**"
 
 concurrency:
-  group: integration-${{ github.ref }}
+  group: integration-${{ github.event_name }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
 permissions:
@@ -26,8 +31,14 @@ permissions:
 jobs:
   build-webgl:
     name: Build WebGL — ${{ matrix.scene.name }} (Unity 6000.3.6f1)
-    # Fork PRs don't receive the UNITY_* secrets, so Unity activation would fail.
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
+    # Fork PRs get no secrets under pull_request, so they run via pull_request_target behind fork-ci approval.
+    if: >-
+      github.repository == 'elevenlabs/unity' && (
+        github.event_name == 'push' ||
+        (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository) ||
+        (github.event_name == 'pull_request_target' && github.event.pull_request.head.repo.full_name != github.repository)
+      )
+    environment: ${{ github.event_name == 'pull_request_target' && 'fork-ci' || '' }}
     runs-on: ubuntu-latest
     strategy:
       # Run both scenes in parallel on separate runners — each gets its own
@@ -52,6 +63,9 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.sha || '' }}
+          persist-credentials: false
 
       # Reclaim ~25 GB so the Unity image (~7 GB compressed, ~20 GB
       # extracted) fits on ubuntu-latest's ~14 GB root partition.
@@ -70,6 +84,7 @@ jobs:
           df -h /
 
       - name: Cache Unity Library
+        if: github.event_name != 'pull_request_target'
         uses: actions/cache@v5
         with:
           path: TestProject/Library
@@ -82,6 +97,17 @@ jobs:
             Library-TestProject-WebGL-
             Library-TestProject-
 
+      # Fork runs write caches into main's scope, so they only restore.
+      - name: Restore Unity Library
+        if: github.event_name == 'pull_request_target'
+        uses: actions/cache/restore@v5
+        with:
+          path: TestProject/Library
+          key: Library-TestProject-WebGL-${{ hashFiles('TestProject/Packages/packages-lock.json', 'TestProject/ProjectSettings/ProjectSettings.asset') }}
+          restore-keys: |
+            Library-TestProject-WebGL-
+            Library-TestProject-
+
       # `buildMethod` runs the same entry point as the corresponding
       # TestProject/build-webgl*.sh script (Build → primitives, BuildConversation → conversation).
       - name: Build WebGL
@@ -115,6 +141,9 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.sha || '' }}
+          persist-credentials: false
 
       - name: Download primitives WebGL build
         uses: actions/download-artifact@v7
@@ -143,7 +172,7 @@ jobs:
         uses: actions/setup-node@v6
         with:
           node-version: lts/krypton
-          cache: pnpm
+          cache: ${{ github.event_name != 'pull_request_target' && 'pnpm' || '' }}
           cache-dependency-path: IntegrationTests~/pnpm-lock.yaml
 
       - name: Install IntegrationTests~ dependencies
diff --git a/.github/workflows/unity-tests.yml b/.github/workflows/unity-tests.yml
index 66ea6b1..5ca72b6 100644
--- a/.github/workflows/unity-tests.yml
+++ b/.github/workflows/unity-tests.yml
@@ -14,9 +14,14 @@ on:
       - "Docs~/**"
       - "**.md"
       - ".claude/**"
+  pull_request_target:
+    paths-ignore:
+      - "Docs~/**"
+      - "**.md"
+      - ".claude/**"
 
 concurrency:
-  group: unity-tests-${{ github.ref }}
+  group: unity-tests-${{ github.event_name }}-${{ github.event.pull_request.number || github.ref }}
   cancel-in-progress: true
 
 permissions:
@@ -26,12 +31,21 @@ permissions:
 jobs:
   edit-mode:
     name: Edit Mode tests (Unity 6000.3.6f1)
-    # Fork PRs don't receive the UNITY_* secrets, so Unity activation would fail.
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
+    # Fork PRs get no secrets under pull_request, so they run via pull_request_target behind fork-ci approval.
+    if: >-
+      github.repository == 'elevenlabs/unity' && (
+        github.event_name == 'push' ||
+        (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository) ||
+        (github.event_name == 'pull_request_target' && github.event.pull_request.head.repo.full_name != github.repository)
+      )
+    environment: ${{ github.event_name == 'pull_request_target' && 'fork-ci' || '' }}
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v6
+        with:
+          ref: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.sha || '' }}
+          persist-credentials: false
 
       # Reclaim ~25 GB so the Unity image (~7 GB compressed, ~20 GB
       # extracted) fits on ubuntu-latest's ~14 GB root partition.
@@ -50,6 +64,7 @@ jobs:
           df -h /
 
       - name: Cache Unity Library
+        if: github.event_name != 'pull_request_target'
         uses: actions/cache@v5
         with:
           path: TestProject/Library
@@ -58,6 +73,17 @@ jobs:
             Library-TestProject-EditMode-
             Library-TestProject-
 
+      # Fork runs write caches into main's scope, so they only restore.
+      - name: Restore Unity Library
+        if: github.event_name == 'pull_request_target'
+        uses: actions/cache/restore@v5
+        with:
+          path: TestProject/Library
+          key: Library-TestProject-EditMode-${{ hashFiles('TestProject/Packages/packages-lock.json', 'TestProject/ProjectSettings/ProjectSettings.asset') }}
+          restore-keys: |
+            Library-TestProject-EditMode-
+            Library-TestProject-
+
       - name: Run Edit Mode tests
         id: tests
         uses: game-ci/unity-test-runner@0ff419b913a3630032cbe0de48a0099b5a9f0ed9 # v4.3.1
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5e654f9..9ba0860 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -282,7 +282,7 @@ immediately visible.
 - For anything beyond a small fix, open an [issue](https://github.com/elevenlabs/unity/issues/new/choose) first so the approach can be agreed before you invest in it.
 - Branch from `main`, run the verification layers your change touches (see [Running the full verification suite](#running-the-full-verification-suite)), and fill in the pull request template.
 - Add an entry under `[Unreleased]` in [`CHANGELOG.md`](CHANGELOG.md) for user-facing changes, and call out any public API change in the PR description.
-- CI runs the lint lane (formatters, linters, typechecks, JS unit tests, generated-artefact drift) on every PR. The Unity lanes (Edit Mode tests, WebGL builds, browser integration tests) need Unity license secrets that GitHub doesn't expose to PRs from forks, so they're skipped there; maintainers verify them before merging.
+- CI runs the lint lane (formatters, linters, typechecks, JS unit tests, generated-artefact drift) on every PR. The Unity lanes (Edit Mode tests, WebGL builds, browser integration tests) run with Unity license secrets, so on PRs from forks they wait until a maintainer has reviewed the changes and approved the run.
 - Report security vulnerabilities privately per [`SECURITY.md`](.github/SECURITY.md), not in issues or PRs.
 
 By contributing you agree that your contributions are licensed under the repository's [MIT license](LICENSE).

From d9949c30229f419457e953acd48324bfc274f06a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kr=C3=A6n=20Hansen?= <kraen@elevenlabs.io>
Date: Mon, 26 Oct 2026 11:21:03 +0100
Subject: [PATCH 6/6] Update README to remove early-stage SDK warning

Removed caution note about early-stage SDK from README.
---
 README.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/README.md b/README.md
index abddf39..3ed89ce 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,5 @@
 # ElevenAgents Unity SDK
 
-> [!CAUTION]
-> ⚠️ **Early-stage SDK:** This package is under active development and APIs may change without notice. If you hit a bug or rough edge, please [open a GitHub issue](https://github.com/elevenlabs/unity/issues/new) - your reports directly shape what we fix next.
-
 Drop ElevenLabs voice agents into a Unity scene. Walk up to a cube, it greets you in character; walk out, the session ends — all driven by the same `Conversation` API in the Editor, desktop standalone players, and WebGL.
 
 <!-- Landing media: 30s screen recording of the GettingStarted sample (walk up → greet → walk out, with audio). Tracked separately; drop the file in here once recorded. -->