@independo/capacitor-inderun 1.0.1-dev.1 → 1.1.0-dev.10

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorBridgeTests.swift

@@ -1,6 +1,7 @@
 import XCTest
 import Foundation
 import IndeRunContracts
+import IndeRunCore
 @testable import IndeRunCapacitorPlugin
 
 final class IndeRunCapacitorBridgeTests: XCTestCase {
@@ -86,6 +87,22 @@ final class IndeRunCapacitorBridgeTests: XCTestCase {
         XCTAssertEqual(options.allowDirectOpenAIEndpoint, true)
     }
 
+    /// `systemModel` and `onnx` are web-only bootstrap keys, like
+    /// `allowDirectOpenAIEndpoint`. Native registers its own on-device provider, so it must
+    /// ignore them rather than fail to decode the options object that carries them.
+    func testIgnoresTheWebOnlyProviderBootstrapKeys() throws {
+        let json: [String: Any] = [
+            "openAI": ["model": "gpt-5.2", "auth": "none"],
+            "systemModel": ["id": "local.system-model.web", "timeoutMs": 30_000],
+            "onnx": ["modelPackage": ["id": "demo", "format": "onnx"]]
+        ]
+        let data = try JSONSerialization.data(withJSONObject: json)
+        let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+
+        XCTAssertEqual(options.openAI?.model, "gpt-5.2")
+        XCTAssertEqual(options.openAI?.auth, "none")
+    }
+
     // MARK: - encode(error:)
 
     func testEncodesIndeRunErrorRequiredFieldsOnly() throws {
@@ -134,6 +151,223 @@ final class IndeRunCapacitorBridgeTests: XCTestCase {
         XCTAssertEqual(encoded["runId"] as? String, "run_abc")
     }
 
+    /// A routing refusal carries its plan diagnostics on `details`, and since inderun 0.3.0
+    /// it does so on iOS too, not just on the web SDK. The shape is nested — a
+    /// `rejectedProviders` array of objects each carrying its own `reasons` array — and it
+    /// crosses as `[String: JSONAny]`. This is the data a provider-refusal UI reads, so a
+    /// regression would be invisible until a demo showed an empty table.
+    func testEncodesNestedRoutePlanDiagnosticsInDetails() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let error = IndeRunError(
+            details: [
+                "failureCode": JSONAny("CapabilityMismatch"),
+                "rejectedProviders": JSONAny([
+                    [
+                        "providerId": "apple.foundation-models",
+                        "reasons": [["code": "capability_unavailable", "message": "Apple Intelligence unavailable."]]
+                    ],
+                    [
+                        "providerId": "openai",
+                        "reasons": [["code": "privacy_constraint", "message": "local_required forbids cloud."]]
+                    ]
+                ])
+            ],
+            errorClass: .CapabilityMismatch,
+            message: "No eligible provider can stream this request.",
+            providerId: nil,
+            retryable: nil,
+            retryAfterMs: nil,
+            runId: nil,
+            schemaVersion: .the10
+        )
+
+        let encoded = try bridge.encode(error: error)
+        let details = try XCTUnwrap(encoded["details"] as? [String: Any])
+        XCTAssertEqual(details["failureCode"] as? String, "CapabilityMismatch")
+
+        let rejected = try XCTUnwrap(details["rejectedProviders"] as? [[String: Any]])
+        XCTAssertEqual(rejected.count, 2)
+        XCTAssertEqual(rejected[0]["providerId"] as? String, "apple.foundation-models")
+
+        let reasons = try XCTUnwrap(rejected[0]["reasons"] as? [[String: Any]])
+        XCTAssertEqual(reasons[0]["code"] as? String, "capability_unavailable")
+        XCTAssertEqual(
+            (try XCTUnwrap(rejected[1]["reasons"] as? [[String: Any]]))[0]["code"] as? String,
+            "privacy_constraint"
+        )
+    }
+
+    // MARK: - encode(capabilities:)
+
+    private func makeSnapshot(
+        providerId: String,
+        type: ProviderDescriptor.ProviderType,
+        transport: ProviderDescriptor.TransportType,
+        streamingStyle: ProviderDescriptor.StreamingStyle? = nil,
+        streaming: Bool,
+        cancel: ProviderDescriptor.CancelSemantics,
+        limits: ProviderDescriptor.ResourceLimits? = nil,
+        privacy: ProviderDescriptor.PrivacyDescriptor? = nil,
+        capabilities: ProviderDynamicCapabilities
+    ) -> ProviderCapabilitySnapshot {
+        ProviderCapabilitySnapshot(
+            providerId: providerId,
+            descriptor: ProviderDescriptor(
+                id: providerId,
+                type: type,
+                transport: transport,
+                streamingStyle: streamingStyle,
+                supports: ProviderDescriptor.SupportsCapabilities(
+                    run: true,
+                    streaming: streaming,
+                    realtime: false,
+                    tools: false,
+                    reasoningEvents: false,
+                    structuredOutput: false,
+                    multimodal: false
+                ),
+                cancel: cancel,
+                tasks: ["text_to_text"],
+                limits: limits,
+                privacy: privacy
+            ),
+            capabilities: capabilities
+        )
+    }
+
+    func testEncodesCapabilitySnapshotsInsideTheProvidersEnvelope() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [
+            makeSnapshot(
+                providerId: "openai",
+                type: .cloud,
+                transport: .http,
+                streamingStyle: .tokens,
+                streaming: true,
+                cancel: .hard,
+                limits: ProviderDescriptor.ResourceLimits(maxInputTokens: 128_000, maxOutputTokens: 4_096),
+                privacy: ProviderDescriptor.PrivacyDescriptor(dataLeavesDevice: true, regions: ["us"]),
+                capabilities: ProviderDynamicCapabilities(available: true)
+            )
+        ])
+
+        let providers = try XCTUnwrap(encoded["providers"] as? [[String: Any]])
+        XCTAssertEqual(providers.count, 1)
+        XCTAssertEqual(providers[0]["providerId"] as? String, "openai")
+
+        let descriptor = try XCTUnwrap(providers[0]["descriptor"] as? [String: Any])
+        XCTAssertEqual(descriptor["id"] as? String, "openai")
+        XCTAssertEqual(descriptor["type"] as? String, "cloud")
+        XCTAssertEqual(descriptor["transport"] as? String, "http")
+        XCTAssertEqual(descriptor["streamingStyle"] as? String, "tokens")
+        XCTAssertEqual(descriptor["cancel"] as? String, "hard")
+        XCTAssertEqual(descriptor["tasks"] as? [String], ["text_to_text"])
+
+        let supports = try XCTUnwrap(descriptor["supports"] as? [String: Any])
+        XCTAssertEqual(supports["run"] as? Bool, true)
+        XCTAssertEqual(supports["streaming"] as? Bool, true)
+        XCTAssertEqual(supports["multimodal"] as? Bool, false)
+
+        let limits = try XCTUnwrap(descriptor["limits"] as? [String: Any])
+        XCTAssertEqual(limits["maxInputTokens"] as? Int, 128_000)
+        XCTAssertNil(limits["maxImageBytes"])
+
+        let privacy = try XCTUnwrap(descriptor["privacy"] as? [String: Any])
+        XCTAssertEqual(privacy["dataLeavesDevice"] as? Bool, true)
+        XCTAssertEqual(privacy["regions"] as? [String], ["us"])
+    }
+
+    /// `in_process` is the one descriptor constant a future upstream rename to Swift
+    /// casing would silently corrupt on the wire, since the JS union spells it out.
+    func testEncodesTheInProcessTransportWithItsWireSpelling() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [
+            makeSnapshot(
+                providerId: "local.onnx.genai.apple",
+                type: .local,
+                transport: .inProcess,
+                streaming: false,
+                cancel: .soft,
+                capabilities: ProviderDynamicCapabilities(available: false, reason: "No model package.")
+            )
+        ])
+
+        let providers = try XCTUnwrap(encoded["providers"] as? [[String: Any]])
+        let descriptor = try XCTUnwrap(providers[0]["descriptor"] as? [String: Any])
+        XCTAssertEqual(descriptor["transport"] as? String, "in_process")
+        XCTAssertNil(descriptor["streamingStyle"])
+
+        let capabilities = try XCTUnwrap(providers[0]["capabilities"] as? [String: Any])
+        XCTAssertEqual(capabilities["available"] as? Bool, false)
+        XCTAssertEqual(capabilities["reason"] as? String, "No model package.")
+    }
+
+    /// Absence means "inherit the static declaration". A null would be a third state
+    /// consumers do not have, so the unset optionals must not reach the wire at all.
+    func testOmitsUnsetDynamicCapabilityFlagsRatherThanEncodingNull() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [
+            makeSnapshot(
+                providerId: "apple.foundation-models",
+                type: .local,
+                transport: .systemService,
+                streamingStyle: .snapshots,
+                streaming: true,
+                cancel: .soft,
+                capabilities: ProviderDynamicCapabilities(available: true)
+            )
+        ])
+
+        let providers = try XCTUnwrap(encoded["providers"] as? [[String: Any]])
+        let descriptor = try XCTUnwrap(providers[0]["descriptor"] as? [String: Any])
+        XCTAssertEqual(descriptor["transport"] as? String, "system_service")
+        XCTAssertEqual(descriptor["streamingStyle"] as? String, "snapshots")
+        XCTAssertNil(descriptor["limits"])
+        XCTAssertNil(descriptor["privacy"])
+
+        let capabilities = try XCTUnwrap(providers[0]["capabilities"] as? [String: Any])
+        XCTAssertNil(capabilities["streamingAvailable"])
+        XCTAssertNil(capabilities["streamingUnavailableReason"])
+        XCTAssertNil(capabilities["cancellationAvailable"])
+        XCTAssertNil(capabilities["reason"])
+    }
+
+    func testEncodesStreamingTakenAwayAtRuntime() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [
+            makeSnapshot(
+                providerId: "openai",
+                type: .cloud,
+                transport: .http,
+                streamingStyle: .tokens,
+                streaming: true,
+                cancel: .hard,
+                capabilities: ProviderDynamicCapabilities(
+                    available: true,
+                    streamingAvailable: false,
+                    streamingUnavailableReason: "Host has no streaming HTTP client.",
+                    cancellationAvailable: true
+                )
+            )
+        ])
+
+        let providers = try XCTUnwrap(encoded["providers"] as? [[String: Any]])
+        let capabilities = try XCTUnwrap(providers[0]["capabilities"] as? [String: Any])
+        XCTAssertEqual(capabilities["streamingAvailable"] as? Bool, false)
+        XCTAssertEqual(
+            capabilities["streamingUnavailableReason"] as? String,
+            "Host has no streaming HTTP client."
+        )
+        XCTAssertEqual(capabilities["cancellationAvailable"] as? Bool, true)
+    }
+
+    func testEncodesAnEmptyRegistryAsAnEmptyProvidersArray() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(capabilities: [])
+
+        XCTAssertEqual(try XCTUnwrap(encoded["providers"] as? [[String: Any]]).count, 0)
+    }
+
     // MARK: - mapAuthMode
 
     func testMapAuthModeNoneString() {

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorStreamCodecTests.swift

@@ -0,0 +1,178 @@
+import XCTest
+import Foundation
+import IndeRunContracts
+import IndeRunCore
+@testable import IndeRunCapacitorPlugin
+
+/// Encoding is what the JS side actually consumes, so these assert the exact key
+/// sets rather than round-tripping: an optional that encodes as `null` instead of
+/// being absent changes which union branch the consumer reconstitutes.
+final class IndeRunCapacitorStreamCodecTests: XCTestCase {
+
+    private func event(
+        type: String,
+        sequence: Int = 0,
+        payload: Payload?,
+        runId: String = "run_1"
+    ) -> StreamEvent {
+        StreamEvent(
+            payload: payload,
+            runId: runId,
+            schemaVersion: .the10,
+            sequence: sequence,
+            timestamp: 1_700_000_000_000,
+            type: type
+        )
+    }
+
+    func testEncodesContentDeltaWithOnlyTheTextField() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(
+            streamEvent: event(type: "content_delta", payload: .content(text: "hello"))
+        )
+
+        XCTAssertEqual(encoded["schemaVersion"] as? String, "1.0")
+        XCTAssertEqual(encoded["runId"] as? String, "run_1")
+        XCTAssertEqual(encoded["sequence"] as? Int, 0)
+        XCTAssertEqual(encoded["type"] as? String, "content_delta")
+
+        let payload = try XCTUnwrap(encoded["payload"] as? [String: Any])
+        XCTAssertEqual(payload["text"] as? String, "hello")
+        XCTAssertEqual(Set(payload.keys), ["text"])
+    }
+
+    func testEncodesTerminalCompletedOutcome() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let outcome = StreamTerminalOutcome.completed(
+            runId: "run_1",
+            finalText: "all done",
+            finishReason: .stop,
+            usage: TaskResultUsage(inputTokens: 3, outputTokens: 5, totalTokens: 8),
+            telemetry: StreamTerminalOutcomeTelemetry(providerUsed: "openai", totalMs: 42)
+        )
+
+        let encoded = try bridge.encode(
+            streamEvent: event(type: "terminal", sequence: 4, payload: Payload(terminalOutcome: outcome))
+        )
+        let payload = try XCTUnwrap(encoded["payload"] as? [String: Any])
+
+        XCTAssertEqual(payload["outcome"] as? String, "completed")
+        XCTAssertEqual(payload["finalText"] as? String, "all done")
+        XCTAssertEqual(payload["finishReason"] as? String, "stop")
+        XCTAssertEqual((payload["usage"] as? [String: Any])?["totalTokens"] as? Int, 8)
+        XCTAssertEqual((payload["telemetry"] as? [String: Any])?["providerUsed"] as? String, "openai")
+        // The error/cancellation branches' fields must not leak into a completion.
+        XCTAssertNil(payload["error"])
+        XCTAssertNil(payload["partialText"])
+        XCTAssertNil(payload["reason"])
+    }
+
+    /// Terminal errors nest deeper than anything `run()` produces, which is the case
+    /// that would break `encodeObject`'s `as? JSObject` cast if a nil ever encoded as
+    /// NSNull.
+    func testEncodesTerminalErrorOutcomeWithNestedDetails() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let error = IndeRunError(
+            details: ["endpoint": JSONAny("https://example.test")],
+            errorClass: .RateLimited,
+            message: "Too many requests.",
+            providerId: "openai",
+            retryable: true,
+            retryAfterMs: 2_000,
+            runId: "run_1",
+            schemaVersion: .the10
+        )
+        let outcome = StreamTerminalOutcome.failed(runId: "run_1", error: error, partialText: "half ")
+
+        let encoded = try bridge.encode(
+            streamEvent: event(type: "terminal", sequence: 7, payload: Payload(terminalOutcome: outcome))
+        )
+        let payload = try XCTUnwrap(encoded["payload"] as? [String: Any])
+        let encodedError = try XCTUnwrap(payload["error"] as? [String: Any])
+
+        XCTAssertEqual(payload["outcome"] as? String, "error")
+        XCTAssertEqual(payload["partialText"] as? String, "half ")
+        XCTAssertEqual(encodedError["errorClass"] as? String, "RateLimited")
+        XCTAssertEqual(encodedError["retryAfterMs"] as? Int, 2_000)
+        XCTAssertEqual((encodedError["details"] as? [String: Any])?["endpoint"] as? String,
+                       "https://example.test")
+    }
+
+    func testEncodesTerminalCancelledOutcomeWithAndWithoutReason() throws {
+        let bridge = IndeRunCapacitorBridge()
+
+        let withReason = try bridge.encode(
+            streamEvent: event(
+                type: "terminal",
+                payload: Payload(
+                    terminalOutcome: .cancelled(runId: "run_1", partialText: "part", reason: "user left")
+                )
+            )
+        )
+        XCTAssertEqual((withReason["payload"] as? [String: Any])?["reason"] as? String, "user left")
+
+        let withoutReason = try bridge.encode(
+            streamEvent: event(
+                type: "terminal",
+                payload: Payload(
+                    terminalOutcome: .cancelled(runId: "run_1", partialText: "part", reason: nil)
+                )
+            )
+        )
+        let payload = try XCTUnwrap(withoutReason["payload"] as? [String: Any])
+        XCTAssertEqual(payload["outcome"] as? String, "cancelled")
+        XCTAssertEqual(payload["partialText"] as? String, "part")
+        // Absent, not null: a null would decode as a present-but-empty reason.
+        XCTAssertFalse(payload.keys.contains("reason"))
+    }
+
+    func testEncodesLifecyclePhase() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let payload = Payload(
+            text: nil, phase: .providerSelected, finalText: nil, finishReason: nil, outcome: nil,
+            runId: nil, schemaVersion: nil, telemetry: nil, usage: nil, error: nil,
+            partialText: nil, reason: nil
+        )
+
+        let encoded = try bridge.encode(streamEvent: event(type: "lifecycle", payload: payload))
+        XCTAssertEqual((encoded["payload"] as? [String: Any])?["phase"] as? String, "provider_selected")
+    }
+
+    /// The schema closes its union with an open catch-all branch; an unrecognized
+    /// type must cross the bridge untouched rather than be rejected.
+    func testEncodesAnUnknownEventTypeVerbatimWithoutPayload() throws {
+        let bridge = IndeRunCapacitorBridge()
+        let encoded = try bridge.encode(
+            streamEvent: event(type: "some_future_type", sequence: 2, payload: nil)
+        )
+
+        XCTAssertEqual(encoded["type"] as? String, "some_future_type")
+        XCTAssertFalse(encoded.keys.contains("payload"))
+    }
+
+    func testEncodesStreamRunHandleWithAndWithoutProviderId() throws {
+        let bridge = IndeRunCapacitorBridge()
+
+        let withProvider = try bridge.encode(
+            handle: StreamRunHandle(
+                providerId: "openai",
+                runId: "run_1",
+                schemaVersion: .the10,
+                startedAt: 1_700_000_000_000
+            )
+        )
+        XCTAssertEqual(withProvider["providerId"] as? String, "openai")
+        XCTAssertEqual(withProvider["runId"] as? String, "run_1")
+        XCTAssertEqual(withProvider["startedAt"] as? Double, 1_700_000_000_000)
+
+        let withoutProvider = try bridge.encode(
+            handle: StreamRunHandle(
+                providerId: nil,
+                runId: "run_1",
+                schemaVersion: .the10,
+                startedAt: 1_700_000_000_000
+            )
+        )
+        XCTAssertFalse(withoutProvider.keys.contains("providerId"))
+    }
+}

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorStreamPumpTests.swift

@@ -0,0 +1,215 @@
+import XCTest
+import Foundation
+import IndeRunContracts
+import IndeRunCore
+@testable import IndeRunCapacitorPlugin
+
+/// Collects what the pump hands to its sinks.
+private final class SinkRecorder: @unchecked Sendable {
+    private let lock = NSLock()
+    private var events: [JSObject] = []
+    private var errors: [JSObject] = []
+
+    func recordEvent(_ event: JSObject) {
+        lock.lock()
+        defer { lock.unlock() }
+        events.append(event)
+    }
+
+    func recordError(_ error: JSObject) {
+        lock.lock()
+        defer { lock.unlock() }
+        errors.append(error)
+    }
+
+    var eventTypes: [String] {
+        lock.lock()
+        defer { lock.unlock() }
+        return events.compactMap { $0["type"] as? String }
+    }
+
+    var eventSequences: [Int] {
+        lock.lock()
+        defer { lock.unlock() }
+        return events.compactMap { $0["sequence"] as? Int }
+    }
+
+    var errorClasses: [String] {
+        lock.lock()
+        defer { lock.unlock() }
+        return errors.compactMap { $0["errorClass"] as? String }
+    }
+}
+
+final class IndeRunCapacitorStreamPumpTests: XCTestCase {
+
+    private func event(_ sequence: Int, type: String = "content_delta") -> StreamEvent {
+        StreamEvent(
+            payload: .content(text: "chunk\(sequence)"),
+            runId: "run_1",
+            schemaVersion: .the10,
+            sequence: sequence,
+            timestamp: 1_700_000_000_000,
+            type: type
+        )
+    }
+
+    private func cancelledTerminal(_ sequence: Int) -> StreamEvent {
+        StreamEvent(
+            payload: Payload(
+                terminalOutcome: .cancelled(runId: "run_1", partialText: "part", reason: "stopped")
+            ),
+            runId: "run_1",
+            schemaVersion: .the10,
+            sequence: sequence,
+            timestamp: 1_700_000_000_000,
+            type: "terminal"
+        )
+    }
+
+    private func makeRun(
+        continuation: inout AsyncThrowingStream<StreamEvent, Error>.Continuation?,
+        cancel: @escaping @Sendable (String?) -> Void = { _ in }
+    ) -> StreamRun {
+        let (events, made) = AsyncThrowingStream<StreamEvent, Error>.makeStream()
+        continuation = made
+        return StreamRun(
+            handle: StreamRunHandle(
+                providerId: nil,
+                runId: "run_1",
+                schemaVersion: .the10,
+                startedAt: 1_700_000_000_000
+            ),
+            events: events,
+            cancel: cancel
+        )
+    }
+
+    private func pump(_ bridge: IndeRunCapacitorBridge, _ run: StreamRun, _ recorder: SinkRecorder) -> Task<Void, Never> {
+        Task {
+            await bridge.pump(
+                streamId: "s1",
+                run: run,
+                onEvent: { _, event in recorder.recordEvent(event) },
+                onError: { _, error in recorder.recordError(error) }
+            )
+        }
+    }
+
+    func testForwardsEveryEventInOrderAndFinishesTheRegistryEntry() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation)
+
+        bridge.streams.open(streamId: "s1")
+        bridge.streams.attach(streamId: "s1", run: run)
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0))
+        continuation?.yield(event(1))
+        continuation?.finish()
+        await task.value
+
+        XCTAssertEqual(recorder.eventSequences, [0, 1])
+        XCTAssertTrue(recorder.errorClasses.isEmpty)
+        XCTAssertEqual(bridge.streams.activeCount, 0)
+    }
+
+    /// A provider failure is already a terminal event by the time it reaches the
+    /// pump; anything actually thrown out of the sequence is a bridge fault.
+    func testMapsAThrownStreamErrorToASingleNormalizedErrorSink() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation)
+
+        bridge.streams.open(streamId: "s1")
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0))
+        continuation?.finish(
+            throwing: IndeRunException(errorClass: .Internal, message: "pump blew up")
+        )
+        await task.value
+
+        XCTAssertEqual(recorder.eventSequences, [0])
+        XCTAssertEqual(recorder.errorClasses, ["Internal"])
+        XCTAssertEqual(bridge.streams.activeCount, 0)
+    }
+
+    /// Cancelling a run must not stop the pump: the engine answers a cancel with its
+    /// one `cancelled` terminal, and that still has to be delivered.
+    func testCancelDuringEmitStillForwardsTheCancelledTerminal() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+
+        // Stand in for the engine: a cancel produces the cancelled terminal and ends
+        // the sequence.
+        nonisolated(unsafe) var capture: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation, cancel: { _ in
+            capture?.yield(
+                StreamEvent(
+                    payload: Payload(
+                        terminalOutcome: .cancelled(runId: "run_1", partialText: "chunk0", reason: "stopped")
+                    ),
+                    runId: "run_1",
+                    schemaVersion: .the10,
+                    sequence: 1,
+                    timestamp: 1_700_000_000_000,
+                    type: "terminal"
+                )
+            )
+            capture?.finish()
+        })
+        capture = continuation
+
+        bridge.streams.open(streamId: "s1")
+        bridge.streams.attach(streamId: "s1", run: run)
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0))
+        bridge.streams.requestCancel(streamId: "s1", reason: "stopped")
+        await task.value
+
+        XCTAssertEqual(recorder.eventTypes, ["content_delta", "terminal"])
+        XCTAssertTrue(recorder.errorClasses.isEmpty)
+    }
+
+    /// Teardown cancels the pump task itself. That is our own doing, with no one left
+    /// to receive anything, so it must not be reported as a bridge failure.
+    func testOwnTaskCancellationProducesNoErrorSink() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation)
+
+        bridge.streams.open(streamId: "s1")
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0))
+        continuation?.finish(throwing: CancellationError())
+        await task.value
+
+        XCTAssertEqual(recorder.eventSequences, [0])
+        XCTAssertTrue(recorder.errorClasses.isEmpty)
+    }
+
+    func testForwardsAnUnknownEventTypeWithoutTreatingItAsTerminal() async {
+        let bridge = IndeRunCapacitorBridge()
+        let recorder = SinkRecorder()
+        var continuation: AsyncThrowingStream<StreamEvent, Error>.Continuation?
+        let run = makeRun(continuation: &continuation)
+
+        bridge.streams.open(streamId: "s1")
+        let task = pump(bridge, run, recorder)
+
+        continuation?.yield(event(0, type: "some_future_type"))
+        continuation?.yield(cancelledTerminal(1))
+        continuation?.finish()
+        await task.value
+
+        XCTAssertEqual(recorder.eventTypes, ["some_future_type", "terminal"])
+    }
+}