Add streaming responses (NDJSON / SSE / chunked) — 1.6.0

- New URLSessionStreamingProtocol with default URLSession conformance
  bridging URLSession.bytes(for:) into a Sendable AsyncThrowingStream<UInt8, Error>.
- New NetworkStreaming protocol and StreamingResponse value type with
  bytes / lines() / ndjson(as:decoder:) helpers (CRLF-aware, blank-line
  skipping, resilient to multi-byte UTF-8 split across chunks).
- New NetworkManager.stream(_:accessToken:) reusing the same request
  pipeline as send(_:): headers, Authorization, User-Agent, body, baseURL.
  Handles 401 via tokenRefresher (one retry before any byte is emitted),
  drains non-2xx body up to 1 MiB into HTTPError / errorDecoder.
- New StreamingError cases: invalidResponse, errorPayloadTooLarge.
- NetworkManager init gains optional streamingSession parameter; existing
  call sites stay source-compatible (URLSession satisfies the new protocol
  by default).
- Internal refactor: extracted buildURLRequest(_:accessToken:) as the
  single source of truth for URLRequest construction, shared by send and
  stream. No behaviour change for send (162 existing tests pass).
- 8 new tests for streaming pipeline (170 total).
- Documentation: CHANGELOG, API.md / API_RU.md (new "Streaming" section),
  README badges and Key Features, PROJECT_STRUCTURE.
- Version bumped 1.5.1 -> 1.6.0.

Author: emvakar

.github/workflows/swift.yml

@@ -191,50 +191,3 @@ jobs:
         echo "- Total lines: ${{ steps.calc.outputs.total }}" >> $GITHUB_STEP_SUMMARY
         echo "- Covered lines: ${{ steps.calc.outputs.covered }}" >> $GITHUB_STEP_SUMMARY
         echo "- Coverage: ${{ steps.calc.outputs.coverage }}%" >> $GITHUB_STEP_SUMMARY
-
-  release:
-    name: Tag and Release
-    runs-on: ubuntu-latest
-    needs: test
-    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-    permissions:
-      contents: write
-
-    steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-
-    - name: Read version
-      id: version
-      run: |
-        VERSION=$(sed -n 's/.*EKNetworkVersionString = "\(.*\)".*/\1/p' Sources/EKNetwork/Version.swift)
-        if [ -z "$VERSION" ]; then
-          echo "❌ Failed to read version from Version.swift"
-          exit 1
-        fi
-        echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-        echo "tag=v$VERSION" >> "$GITHUB_OUTPUT"
-
-    - name: Create tag
-      id: tag
-      run: |
-        TAG="${{ steps.version.outputs.tag }}"
-        if git rev-parse "$TAG" >/dev/null 2>&1; then
-          echo "exists=true" >> "$GITHUB_OUTPUT"
-          echo "Tag $TAG already exists, skipping tag creation."
-          exit 0
-        fi
-        git config user.name "github-actions[bot]"
-        git config user.email "github-actions[bot]@users.noreply.github.com"
-        git tag -a "$TAG" -m "Release $TAG"
-        git push origin "$TAG"
-        echo "exists=false" >> "$GITHUB_OUTPUT"
-
-    - name: Create GitHub release
-      if: steps.tag.outputs.exists == 'false'
-      uses: softprops/action-gh-release@v2
-      with:
-        tag_name: ${{ steps.version.outputs.tag }}
-        generate_release_notes: true

API.md

@@ -12,6 +12,7 @@ Complete API documentation for EKNetwork library.
 - [RetryPolicy](#retrypolicy)
 - [NetworkProgress](#networkprogress)
 - [TokenRefreshProvider](#tokenrefreshprovider)
+- [Streaming (NDJSON / SSE)](#streaming-ndjson--sse)
 - [Error Types](#error-types)
 - [Response Types](#response-types)
 - [UserAgentConfiguration](#useragentconfiguration)
@@ -28,6 +29,7 @@ The main class for managing network requests.
 public init(
     baseURL: @escaping (() -> URL),
     session: URLSessionProtocol = URLSession.shared,
+    streamingSession: URLSessionStreamingProtocol? = nil,
     loggerSubsystem: String = "com.yourapp.networking",
     userAgentConfiguration: UserAgentConfiguration? = nil,
     responseDecoderProvider: (() -> JSONDecoder)? = nil
@@ -37,6 +39,7 @@ public init(
 **Parameters:**
 - `baseURL`: Closure that returns the base URL for each request. Use `{ myURL }` for a fixed URL or a closure that reads from config/environment for dynamic base URL (avoids race conditions when switching environments).
 - `session`: The `URLSessionProtocol` to use for making requests (defaults to `URLSession.shared`)
+- `streamingSession`: Optional session used by `stream(_:accessToken:)` for byte-stream responses (NDJSON / SSE / chunked transfer). When `nil` (default) the manager reuses `session` if it conforms to `URLSessionStreamingProtocol` (default `URLSession` does), otherwise falls back to `URLSession.shared`. Added in 1.6.0; existing call sites stay source-compatible.
 - `loggerSubsystem`: The subsystem identifier for the `Logger` instance
 - `userAgentConfiguration`: Optional User-Agent configuration
 - `responseDecoderProvider`: Optional global JSON decoder provider for responses (overrides per-request decoding when enabled)
@@ -407,6 +410,113 @@ class TokenManager: TokenRefreshProvider {
 
 ---
 
+## Streaming (NDJSON / SSE)
+
+> Available since **1.6.0**.
+
+`send(_:accessToken:)` is designed for endpoints that return a complete `Decodable` body. For endpoints that emit data incrementally — newline-delimited JSON, Server-Sent Events, chunked log/inference streams — use `stream(_:accessToken:)`. The streaming entry point reuses the **exact same** request-construction pipeline (headers, `Authorization`, `User-Agent`, body, base URL), so app-level code never has to build a `URLRequest` by hand and risk dropping required headers like `X-Device-ID` or custom auth.
+
+### NetworkStreaming protocol
+
+```swift
+public protocol NetworkStreaming: AnyObject {
+    func stream<T: NetworkRequest>(
+        _ request: T,
+        accessToken: (() -> String?)?
+    ) async throws -> StreamingResponse
+}
+```
+
+`NetworkManager` conforms to both `NetworkManaging` and `NetworkStreaming`. Existing mocks of `NetworkManaging` are unaffected.
+
+### StreamingResponse
+
+```swift
+public struct StreamingResponse: Sendable {
+    public let statusCode: Int
+    public let headers: [String: String]
+    public let bytes: AsyncThrowingStream<UInt8, Error>
+
+    public func lines() -> AsyncThrowingStream<String, Error>
+    public func ndjson<Item: Decodable & Sendable>(
+        as itemType: Item.Type,
+        decoder: JSONDecoder = JSONDecoder()
+    ) -> AsyncThrowingStream<Item, Error>
+}
+```
+
+- `bytes` — raw octet stream, one `UInt8` per element, in arrival order.
+- `lines()` — UTF-8 lines split on `\n`, trailing `\r` trimmed (CRLF-aware), blank lines skipped. Resilient to multi-byte sequences split across TCP segments.
+- `ndjson(as:decoder:)` — one `Decodable` record per non-empty line. A bad line throws and finishes the stream.
+
+Cancellation propagates automatically: breaking out of iteration or cancelling the surrounding `Task` cancels the underlying network task.
+
+### URLSessionStreamingProtocol
+
+```swift
+public protocol URLSessionStreamingProtocol: Sendable {
+    func byteStream(for request: URLRequest) async throws -> (AsyncThrowingStream<UInt8, Error>, URLResponse)
+}
+```
+
+`URLSession` conforms by default (bridges `URLSession.bytes(for:)` into a fully `Sendable` stream). Implement this protocol for unit-testing the streaming pipeline without hitting the network.
+
+### Behaviour summary
+
+| Concern | `send(_:)` | `stream(_:)` |
+|---|---|---|
+| Headers, body, auth | `buildURLRequest` | `buildURLRequest` (same path) |
+| 401 → token refresh + retry | once, when `allowsRetry == true` | once, before any body byte is emitted |
+| Mid-stream 401 | n/a | not retried (body has already started) |
+| Non-2xx error | `HTTPError` / `errorDecoder` | drain ≤1 MiB, then `HTTPError` / `errorDecoder` |
+| Retry policy (`RetryPolicy`) | applied | not applied (streams cannot be replayed deterministically) |
+| Progress (`NetworkProgress`) | applied | not applied |
+
+### StreamingError
+
+```swift
+public enum StreamingError: Error, Equatable {
+    case invalidResponse                 // response was not an HTTPURLResponse
+    case errorPayloadTooLarge(limitBytes: Int)  // non-2xx body exceeded 1 MiB cap
+}
+```
+
+### Example: NDJSON search
+
+```swift
+struct PlayerSearchRequest: NetworkRequest {
+    typealias Response = EmptyResponse  // unused for streaming
+    var path: String { "/api/v1/players/search" }
+    var method: HTTPMethod { .get }
+    var queryParameters: [String: String]? { ["q": query, "stream": "true"] }
+    var headers: [String: String]? { DeviceHeaders.current() }
+    let query: String
+}
+
+let response = try await manager.stream(
+    PlayerSearchRequest(query: "Bobr"),
+    accessToken: { TokenStore.shared.accessToken }
+)
+
+for try await item in response.ndjson(as: SearchEvent.self) {
+    handle(item)            // render incrementally as items arrive
+    if case .end = item { break }
+}
+```
+
+### Example: Server-Sent Events
+
+```swift
+let response = try await manager.stream(MyEventsRequest(), accessToken: nil)
+for try await line in response.lines() {
+    guard line.hasPrefix("data:") else { continue }
+    let payload = line.dropFirst("data:".count).trimmingCharacters(in: .whitespaces)
+    process(payload)
+}
+```
+
+---
+
 ## Error Types
 
 ### NonRetriableError

API_RU.md

@@ -12,6 +12,7 @@
 - [RetryPolicy](#retrypolicy)
 - [NetworkProgress](#networkprogress)
 - [TokenRefreshProvider](#tokenrefreshprovider)
+- [Стриминг (NDJSON / SSE)](#стриминг-ndjson--sse)
 - [Типы ошибок](#типы-ошибок)
 - [Типы ответов](#типы-ответов)
 - [UserAgentConfiguration](#useragentconfiguration)
@@ -28,6 +29,7 @@
 public init(
     baseURL: @escaping (() -> URL),
     session: URLSessionProtocol = URLSession.shared,
+    streamingSession: URLSessionStreamingProtocol? = nil,
     loggerSubsystem: String = "com.yourapp.networking",
     userAgentConfiguration: UserAgentConfiguration? = nil,
     responseDecoderProvider: (() -> JSONDecoder)? = nil
@@ -37,6 +39,7 @@ public init(
 **Параметры:**
 - `baseURL`: Замыкание, возвращающее базовый URL для каждого запроса. Используйте `{ myURL }` для фиксированного URL или замыкание, читающее из конфига/окружения, для динамического базового URL (без гонок при переключении окружений).
 - `session`: `URLSessionProtocol` для выполнения запросов (по умолчанию `URLSession.shared`)
+- `streamingSession`: Опциональная сессия для `stream(_:accessToken:)` (NDJSON / SSE / chunked transfer). Если не передана, менеджер использует `session`, если та поддерживает `URLSessionStreamingProtocol` (`URLSession` поддерживает по умолчанию), иначе — `URLSession.shared`. Добавлено в 1.6.0; существующие вызовы инициализатора остаются совместимыми.
 - `loggerSubsystem`: Идентификатор подсистемы для экземпляра `Logger`
 - `userAgentConfiguration`: Опциональная конфигурация User-Agent
 - `responseDecoderProvider`: Опциональный глобальный JSON-декодер для ответов (может переопределять декодирование запросов)
@@ -404,6 +407,113 @@ class TokenManager: TokenRefreshProvider {
 
 ---
 
+## Стриминг (NDJSON / SSE)
+
+> Доступно начиная с **1.6.0**.
+
+`send(_:accessToken:)` рассчитан на эндпоинты, отдающие тело целиком одним `Decodable`-объектом. Для эндпоинтов, которые отдают данные постепенно — newline-delimited JSON, Server-Sent Events, chunked-логи / inference-стримы — используйте `stream(_:accessToken:)`. Стриминг переиспользует **тот же самый** пайплайн построения запроса (заголовки, `Authorization`, `User-Agent`, тело, baseURL), что и `send(_:)`. То есть прикладному коду никогда не нужно собирать `URLRequest` вручную и рисковать потерять обязательные заголовки вроде `X-Device-ID` или кастомной авторизации.
+
+### Протокол NetworkStreaming
+
+```swift
+public protocol NetworkStreaming: AnyObject {
+    func stream<T: NetworkRequest>(
+        _ request: T,
+        accessToken: (() -> String?)?
+    ) async throws -> StreamingResponse
+}
+```
+
+`NetworkManager` соответствует и `NetworkManaging`, и `NetworkStreaming`. Существующие моки `NetworkManaging` остаются рабочими.
+
+### StreamingResponse
+
+```swift
+public struct StreamingResponse: Sendable {
+    public let statusCode: Int
+    public let headers: [String: String]
+    public let bytes: AsyncThrowingStream<UInt8, Error>
+
+    public func lines() -> AsyncThrowingStream<String, Error>
+    public func ndjson<Item: Decodable & Sendable>(
+        as itemType: Item.Type,
+        decoder: JSONDecoder = JSONDecoder()
+    ) -> AsyncThrowingStream<Item, Error>
+}
+```
+
+- `bytes` — поток сырых байт (по одному `UInt8`), в порядке прихода.
+- `lines()` — UTF-8 строки, разделённые `\n`, с обрезкой `\r` (CRLF-aware), пустые строки пропускаются. Корректно собирает многобайтовые UTF-8 последовательности, разрезанные TCP-сегментами.
+- `ndjson(as:decoder:)` — по одному `Decodable`-объекту на каждую непустую строку. Битая строка — стрим завершается ошибкой.
+
+Отмена пробрасывается автоматически: выход из `for try await` или отмена внешнего `Task` отменяет сетевую задачу.
+
+### URLSessionStreamingProtocol
+
+```swift
+public protocol URLSessionStreamingProtocol: Sendable {
+    func byteStream(for request: URLRequest) async throws -> (AsyncThrowingStream<UInt8, Error>, URLResponse)
+}
+```
+
+`URLSession` соответствует протоколу по умолчанию (мостит `URLSession.bytes(for:)` в полностью `Sendable`-стрим). Реализуйте этот протокол в моках, если хотите тестировать стриминговый пайплайн без сети.
+
+### Поведение в сравнении с `send(_:)`
+
+| Аспект | `send(_:)` | `stream(_:)` |
+|---|---|---|
+| Заголовки, тело, авторизация | `buildURLRequest` | `buildURLRequest` (та же точка) |
+| 401 → refresh + retry | один раз, если `allowsRetry == true` | один раз, до того как пришёл хоть один байт тела |
+| 401 в середине стрима | n/a | не ретраится (тело уже начали отдавать) |
+| Не-2xx ошибка | `HTTPError` / `errorDecoder` | drain ≤1 МиБ, затем `HTTPError` / `errorDecoder` |
+| RetryPolicy | применяется | не применяется (стрим нельзя детерминированно проиграть заново) |
+| NetworkProgress | применяется | не применяется |
+
+### StreamingError
+
+```swift
+public enum StreamingError: Error, Equatable {
+    case invalidResponse                          // ответ не HTTPURLResponse
+    case errorPayloadTooLarge(limitBytes: Int)    // тело не-2xx ответа превысило 1 МиБ
+}
+```
+
+### Пример: NDJSON-поиск
+
+```swift
+struct PlayerSearchRequest: NetworkRequest {
+    typealias Response = EmptyResponse  // не используется в стриминге
+    var path: String { "/api/v1/players/search" }
+    var method: HTTPMethod { .get }
+    var queryParameters: [String: String]? { ["q": query, "stream": "true"] }
+    var headers: [String: String]? { DeviceHeaders.current() }
+    let query: String
+}
+
+let response = try await manager.stream(
+    PlayerSearchRequest(query: "Бобр"),
+    accessToken: { TokenStore.shared.accessToken }
+)
+
+for try await item in response.ndjson(as: SearchEvent.self) {
+    handle(item)            // отрисовка по мере поступления
+    if case .end = item { break }
+}
+```
+
+### Пример: Server-Sent Events
+
+```swift
+let response = try await manager.stream(MyEventsRequest(), accessToken: nil)
+for try await line in response.lines() {
+    guard line.hasPrefix("data:") else { continue }
+    let payload = line.dropFirst("data:".count).trimmingCharacters(in: .whitespaces)
+    process(payload)
+}
+```
+
+---
+
 ## Типы ошибок
 
 ### NetworkError

CHANGELOG.md

@@ -11,6 +11,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+## [1.6.0] - 2026-05-09
+
+### Added
+- **Streaming responses** — first-class support for endpoints that emit data as it is produced (NDJSON, Server-Sent Events, chunked transfer):
+  - New `URLSessionStreamingProtocol` with default `URLSession` conformance (bridges `URLSession.bytes(for:)` into a `Sendable` `AsyncThrowingStream<UInt8, Error>`).
+  - New `NetworkStreaming` protocol exposing `stream(_:accessToken:)`.
+  - New `StreamingResponse` value type with `bytes`, `lines()` (UTF-8 lines, CRLF/LF aware, blank lines skipped) and `ndjson(as:decoder:)` helpers.
+  - New `StreamingError` cases: `invalidResponse`, `errorPayloadTooLarge`.
+  - `NetworkManager.stream(_:accessToken:)` reuses the same request-construction pipeline as `send(_:)` (headers, access token, body, User-Agent, base URL) — no duplication of header logic in app code.
+  - Streaming requests handle 401 by calling `tokenRefresher` and retrying once when `request.allowsRetry == true` (mid-stream 401s are not retried).
+  - Non-2xx streaming responses drain up to 1 MiB into `HTTPError` (or run `request.errorDecoder` if provided), so error handling matches `send(_:)`.
+- **`NetworkManager` initializer** gained a new optional `streamingSession: URLSessionStreamingProtocol? = nil` parameter. When omitted, the manager reuses the regular `session` if it conforms to streaming (default `URLSession` does), otherwise falls back to `URLSession.shared`. Existing initializer call sites stay source-compatible.
+- **Tests**: 8 new tests covering streaming pipeline, NDJSON decoding across chunk boundaries, CRLF handling, 401 + token refresh, custom `errorDecoder`, and default-session resolution. Total **170 tests**.
+
+### Changed
+- **Internal refactor (no behaviour change)**: extracted `NetworkManager.buildURLRequest(_:accessToken:)` so both `send(_:)` and `stream(_:accessToken:)` share a single `URLRequest`-construction routine. Existing test suite (162 tests) passes unchanged.
+
+### Migration (1.5.x → 1.6.0)
+- **No source changes required**. All previous code keeps compiling and behaving identically.
+- To stream a response, call `manager.stream(MyRequest(), accessToken: { token })` instead of `manager.send(...)` and consume `response.ndjson(as: Item.self)` / `response.lines()` / `response.bytes`. Headers and authentication are applied via the same `NetworkRequest.headers` and `accessToken` you already use.
+
 ## [1.5.0] - 2026-02-11
 
 ### Added