@independo/capacitor-inderun 1.0.0 → 1.1.0-dev.1

package/ios/Sources/IndeRunCapacitorPlugin/IndeRunCapacitorStreamRegistry.swift

@@ -0,0 +1,121 @@
+import Foundation
+import IndeRunCore
+
+/// Tracks the streaming runs the bridge is currently pumping, keyed by the
+/// bridge-local `streamId`.
+///
+/// Two things make this more than a dictionary. A cancel can arrive before the run
+/// it refers to exists — `startStream` has to reach route selection before there is
+/// anything to cancel — so a cancel requested in that window is recorded and applied
+/// on attach. And cancelling a run is *not* cancelling the pump task: the engine
+/// answers a cancel with its one `cancelled` terminal event, which the pump still has
+/// to deliver. Task cancellation is reserved for teardown, where the webview is going
+/// away and nobody is left to receive a terminal.
+///
+/// Deliberately free of any Capacitor dependency, so it is exercised by `swift test`
+/// on macOS where `canImport(Capacitor)` is false.
+final class StreamRegistry {
+    enum AttachOutcome: Equatable {
+        case attached
+        /// A cancel arrived before the run did; the caller must apply it.
+        case cancelRequested(reason: String?)
+    }
+
+    private struct Entry {
+        var run: StreamRun?
+        var task: Task<Void, Never>?
+        var cancelRequested = false
+        var cancelReason: String?
+    }
+
+    private let lock = NSLock()
+    private var entries: [String: Entry] = [:]
+
+    var activeCount: Int {
+        lock.lock()
+        defer { lock.unlock() }
+        return entries.count
+    }
+
+    /// Reserves the id so a cancel arriving before the run can be recorded rather
+    /// than dropped as unknown.
+    func open(streamId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        if entries[streamId] == nil {
+            entries[streamId] = Entry()
+        }
+    }
+
+    func attach(streamId: String, run: StreamRun) -> AttachOutcome {
+        lock.lock()
+        guard var entry = entries[streamId] else {
+            // Torn down while the engine was still selecting a route.
+            lock.unlock()
+            return .cancelRequested(reason: nil)
+        }
+        if entry.cancelRequested {
+            let reason = entry.cancelReason
+            lock.unlock()
+            return .cancelRequested(reason: reason)
+        }
+        entry.run = run
+        entries[streamId] = entry
+        lock.unlock()
+        return .attached
+    }
+
+    func store(task: Task<Void, Never>, for streamId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        guard var entry = entries[streamId] else {
+            task.cancel()
+            return
+        }
+        entry.task = task
+        entries[streamId] = entry
+    }
+
+    /// Cancels the run if it has attached, otherwise records the request for attach.
+    /// An unknown id — already finished, or never started — is a silent no-op, which
+    /// is what makes cancelling after the terminal harmless.
+    func requestCancel(streamId: String, reason: String?) {
+        lock.lock()
+        guard var entry = entries[streamId] else {
+            lock.unlock()
+            return
+        }
+        if entry.cancelRequested {
+            lock.unlock()
+            return
+        }
+        entry.cancelRequested = true
+        entry.cancelReason = reason
+        let run = entry.run
+        entries[streamId] = entry
+        lock.unlock()
+
+        // Never under the lock: cancel reaches into engine code.
+        run?.cancel(reason: reason)
+    }
+
+    func finish(streamId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        entries.removeValue(forKey: streamId)
+    }
+
+    /// Teardown. Cancels each run first so providers unwind, then the pump tasks,
+    /// which at this point have nobody left to deliver to.
+    func cancelAll(reason: String?) {
+        lock.lock()
+        let draining = entries
+        entries.removeAll()
+        lock.unlock()
+
+        for (_, entry) in draining {
+            entry.run?.cancel(reason: reason)
+            entry.task?.cancel()
+        }
+    }
+}

package/ios/Tests/IndeRunCapacitorTests/IndeRunCapacitorBridgeTests.swift

@@ -11,7 +11,7 @@ final class IndeRunCapacitorBridgeTests: XCTestCase {
         let json: [String: Any] = [
             "openAI": [
                 "model": "gpt-5.2",
-                "endpointURL": "/api/inderun/openai-responses",
+                "endpointUrl": "/api/inderun/openai-responses",
                 "auth": "none",
                 "authContextRef": "openai/main",
                 "timeoutMs": 30_000
@@ -28,6 +28,36 @@ final class IndeRunCapacitorBridgeTests: XCTestCase {
         XCTAssertNil(options.allowDirectOpenAIEndpoint)
     }
 
+    // Regression: the wire key is `endpointUrl` (what src/definitions.ts and
+    // IndeRunSerializer.kt both use). iOS previously decoded `endpointURL`, so a
+    // TypeScript-supplied endpoint was dropped and the provider silently fell back to
+    // the default OpenAI Responses endpoint.
+    func testDecodesEndpointUrlUsingTheTypeScriptWireKey() throws {
+        let json: [String: Any] = [
+            "openAI": [
+                "model": "gpt-5.2",
+                "endpointUrl": "https://proxy.example/api/openai-responses"
+            ]
+        ]
+        let data = try JSONSerialization.data(withJSONObject: json)
+        let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+
+        XCTAssertEqual(options.openAI?.endpointURL, "https://proxy.example/api/openai-responses")
+    }
+
+    func testIgnoresTheLegacySwiftCasedEndpointKey() throws {
+        let json: [String: Any] = [
+            "openAI": [
+                "model": "gpt-5.2",
+                "endpointURL": "https://proxy.example/api/openai-responses"
+            ]
+        ]
+        let data = try JSONSerialization.data(withJSONObject: json)
+        let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)
+
+        XCTAssertNil(options.openAI?.endpointURL)
+    }
+
     func testDecodesConfigureOptionsWithAllOptionalFieldsAbsent() throws {
         let data = try JSONSerialization.data(withJSONObject: [String: Any]())
         let options = try JSONDecoder().decode(CapacitorRunOptions.self, from: data)

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"])
+    }
+}