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

package/android/src/test/kotlin/app/independo/inderun/capacitor/IndeRunSerializerStreamTest.kt

@@ -0,0 +1,226 @@
+package app.independo.inderun.capacitor
+
+import app.independo.inderun.contracts.FinishReason
+import app.independo.inderun.contracts.IndeRunErrorClass
+import app.independo.inderun.contracts.Outcome
+import app.independo.inderun.contracts.Payload
+import app.independo.inderun.contracts.PayloadError
+import app.independo.inderun.contracts.PayloadTelemetry
+import app.independo.inderun.contracts.PayloadUsage
+import app.independo.inderun.contracts.Phase
+import app.independo.inderun.contracts.SchemaVersion
+import app.independo.inderun.contracts.StreamEvent
+import app.independo.inderun.contracts.StreamRunHandle
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Encoding is what the JS side actually consumes, so these assert exact key sets: a
+ * field that encodes as null instead of being absent changes which union branch the
+ * consumer reconstitutes.
+ */
+class IndeRunSerializerStreamTest {
+
+    private fun event(
+        type: String,
+        payload: Payload?,
+        sequence: Long = 0,
+        runId: String = "run_1"
+    ): StreamEvent = StreamEvent(
+        payload = payload,
+        runId = runId,
+        schemaVersion = SchemaVersion.V1_0,
+        sequence = sequence,
+        timestamp = 1_700_000_000_000.0,
+        type = type
+    )
+
+    private fun keysOf(json: org.json.JSONObject): Set<String> =
+        json.keys().asSequence().toSet()
+
+    @Test
+    fun `encodes a content delta with only the text field`() {
+        val encoded = IndeRunSerializer.encodeStreamEvent(
+            event(type = "content_delta", payload = Payload(text = "hello"))
+        )
+
+        assertEquals("1.0", encoded.getString("schemaVersion"))
+        assertEquals("run_1", encoded.getString("runId"))
+        assertEquals(0L, encoded.getLong("sequence"))
+        assertEquals("content_delta", encoded.getString("type"))
+        assertEquals(setOf("text"), keysOf(encoded.getJSONObject("payload")))
+        assertEquals("hello", encoded.getJSONObject("payload").getString("text"))
+    }
+
+    @Test
+    fun `encodes a completed terminal outcome`() {
+        val payload = Payload(
+            finalText = "all done",
+            finishReason = FinishReason.STOP,
+            outcome = Outcome.Completed,
+            runId = "run_1",
+            schemaVersion = SchemaVersion.V1_0,
+            telemetry = PayloadTelemetry(providerUsed = "openai", totalMs = 42.0),
+            usage = PayloadUsage(inputTokens = 3, outputTokens = 5, totalTokens = 8)
+        )
+
+        val encoded = IndeRunSerializer.encodeStreamEvent(
+            event(type = "terminal", payload = payload, sequence = 4)
+        ).getJSONObject("payload")
+
+        assertEquals("completed", encoded.getString("outcome"))
+        assertEquals("all done", encoded.getString("finalText"))
+        assertEquals("stop", encoded.getString("finishReason"))
+        assertEquals(8L, encoded.getJSONObject("usage").getLong("totalTokens"))
+        assertEquals("openai", encoded.getJSONObject("telemetry").getString("providerUsed"))
+        // The other branches' fields must not leak into a completion.
+        assertFalse(encoded.has("error"))
+        assertFalse(encoded.has("partialText"))
+        assertFalse(encoded.has("reason"))
+    }
+
+    @Test
+    fun `encodes an error terminal outcome with its nested error`() {
+        val payload = Payload(
+            outcome = Outcome.Error,
+            runId = "run_1",
+            schemaVersion = SchemaVersion.V1_0,
+            error = PayloadError(
+                details = mapOf("endpoint" to "https://example.test"),
+                errorClass = IndeRunErrorClass.RateLimited,
+                message = "Too many requests.",
+                providerId = "openai",
+                retryable = true,
+                retryAfterMs = 2_000
+            ),
+            partialText = "half "
+        )
+
+        val encoded = IndeRunSerializer.encodeStreamEvent(
+            event(type = "terminal", payload = payload, sequence = 7)
+        ).getJSONObject("payload")
+
+        assertEquals("error", encoded.getString("outcome"))
+        assertEquals("half ", encoded.getString("partialText"))
+
+        val error = encoded.getJSONObject("error")
+        assertEquals("RateLimited", error.getString("errorClass"))
+        assertEquals(2_000L, error.getLong("retryAfterMs"))
+        assertTrue(error.getBoolean("retryable"))
+        assertEquals(
+            "https://example.test",
+            error.getJSONObject("details").getString("endpoint")
+        )
+    }
+
+    @Test
+    fun `omits the cancellation reason entirely when there is none`() {
+        val withReason = IndeRunSerializer.encodeStreamEvent(
+            event(
+                type = "terminal",
+                payload = Payload(
+                    outcome = Outcome.Cancelled,
+                    partialText = "part",
+                    reason = "user left"
+                )
+            )
+        ).getJSONObject("payload")
+        assertEquals("user left", withReason.getString("reason"))
+
+        val withoutReason = IndeRunSerializer.encodeStreamEvent(
+            event(
+                type = "terminal",
+                payload = Payload(outcome = Outcome.Cancelled, partialText = "part")
+            )
+        ).getJSONObject("payload")
+
+        assertEquals("cancelled", withoutReason.getString("outcome"))
+        assertEquals("part", withoutReason.getString("partialText"))
+        // Absent, not null: a null would decode as a present-but-empty reason.
+        assertFalse(withoutReason.has("reason"))
+    }
+
+    @Test
+    fun `encodes a lifecycle phase using its snake case wire value`() {
+        val encoded = IndeRunSerializer.encodeStreamEvent(
+            event(type = "lifecycle", payload = Payload(phase = Phase.ProviderSelected))
+        ).getJSONObject("payload")
+
+        assertEquals("provider_selected", encoded.getString("phase"))
+    }
+
+    /**
+     * The schema closes its union with an open catch-all branch, so an unrecognized
+     * type must cross the bridge untouched rather than be rejected — unlike the
+     * inbound request enums, which throw.
+     */
+    @Test
+    fun `passes an unknown event type through verbatim without a payload`() {
+        val encoded = IndeRunSerializer.encodeStreamEvent(
+            event(type = "some_future_type", payload = null, sequence = 2)
+        )
+
+        assertEquals("some_future_type", encoded.getString("type"))
+        assertFalse(encoded.has("payload"))
+    }
+
+    @Test
+    fun `encodes a diagnostic event with an empty payload object`() {
+        val encoded = IndeRunSerializer.encodeStreamEvent(
+            event(type = "diagnostic", payload = Payload())
+        )
+
+        assertTrue(encoded.has("payload"))
+        assertEquals(emptySet<String>(), keysOf(encoded.getJSONObject("payload")))
+    }
+
+    @Test
+    fun `encodes a stream run handle with and without a provider id`() {
+        val withProvider = IndeRunSerializer.encodeStreamRunHandle(
+            StreamRunHandle(
+                providerId = "openai",
+                runId = "run_1",
+                schemaVersion = SchemaVersion.V1_0,
+                startedAt = 1_700_000_000_000.0
+            )
+        )
+        assertEquals("openai", withProvider.getString("providerId"))
+        assertEquals("run_1", withProvider.getString("runId"))
+        assertEquals(1_700_000_000_000.0, withProvider.getDouble("startedAt"), 0.0)
+
+        val withoutProvider = IndeRunSerializer.encodeStreamRunHandle(
+            StreamRunHandle(
+                runId = "run_1",
+                schemaVersion = SchemaVersion.V1_0,
+                startedAt = 1_700_000_000_000.0
+            )
+        )
+        assertFalse(withoutProvider.has("providerId"))
+    }
+
+    /**
+     * Outcome and Phase are generated without a rawValue, so their wire strings are
+     * hand-written. If a regeneration adds a constant, the `when` stops compiling —
+     * and if one is ever mapped to the wrong casing, this catches it.
+     */
+    @Test
+    fun `every outcome and phase constant maps to a snake case wire value`() {
+        val outcomes = Outcome.entries.map { outcome ->
+            IndeRunSerializer.encodeStreamEvent(
+                event(type = "terminal", payload = Payload(outcome = outcome))
+            ).getJSONObject("payload").getString("outcome")
+        }
+        assertEquals(listOf("cancelled", "completed", "error"), outcomes)
+
+        val phases = Phase.entries.map { phase ->
+            IndeRunSerializer.encodeStreamEvent(
+                event(type = "lifecycle", payload = Payload(phase = phase))
+            ).getJSONObject("payload").getString("phase")
+        }
+        assertEquals(listOf("provider_selected", "started"), phases)
+
+        assertTrue((outcomes + phases).all { it.isNotEmpty() && it == it.lowercase() })
+    }
+}

package/android/src/test/kotlin/app/independo/inderun/capacitor/IndeRunSerializerTest.kt

@@ -142,6 +142,29 @@ class IndeRunSerializerTest {
 
     // --- encodeError ---
 
+    /**
+     * `systemModel` and `onnx` are web-only bootstrap keys, like
+     * `allowDirectOpenAIEndpoint`. Android registers its own on-device provider, so it must
+     * ignore them rather than fail on the options object that carries them.
+     */
+    @Test
+    fun `parseConfigureOptions ignores the web-only provider bootstrap keys`() {
+        val options = IndeRunSerializer.parseConfigureOptions(
+            JSONObject(
+                """
+                {
+                  "openAI": { "model": "gpt-5.2", "auth": "none" },
+                  "systemModel": { "id": "local.system-model.web", "timeoutMs": 30000 },
+                  "onnx": { "modelPackage": { "id": "demo", "format": "onnx" } }
+                }
+                """.trimIndent()
+            )
+        )
+
+        assertEquals("gpt-5.2", options.openAI?.model)
+        assertEquals("none", options.openAI?.auth)
+    }
+
     @Test
     fun `encodeError produces correct shape with required fields only`() {
         val encoded = IndeRunSerializer.encodeError(
@@ -177,4 +200,60 @@ class IndeRunSerializerTest {
         assertEquals(2000L, encoded.getLong("retryAfterMs"))
         assertEquals("run_abc", encoded.getString("runId"))
     }
+
+    /**
+     * A routing refusal carries its plan diagnostics on the error's `details`, and since
+     * inderun 0.3.0 it does so on iOS and Android too, not just on the web SDK. The shape
+     * is nested — a `rejectedProviders` array of objects, each with its own `reasons`
+     * array — and `encodeError` hands the whole map to `JSONObject(Map)`, which deep-wraps
+     * via `wrap()`. Nothing asserted that before; this is the data a provider-refusal UI
+     * actually reads, so a regression here would be invisible until a demo showed an empty
+     * table.
+     */
+    @Test
+    fun `encodeError preserves nested route-plan diagnostics in details`() {
+        val encoded = IndeRunSerializer.encodeError(
+            IndeRunError(
+                errorClass = IndeRunErrorClass.CapabilityMismatch,
+                message = "No eligible provider can stream this request.",
+                details = mapOf(
+                    "failureCode" to "CapabilityMismatch",
+                    "rejectedProviders" to listOf(
+                        mapOf(
+                            "providerId" to "android.mlkit.genai",
+                            "reasons" to listOf(
+                                mapOf(
+                                    "code" to "streaming_not_supported",
+                                    "message" to "Provider does not declare streaming."
+                                )
+                            )
+                        ),
+                        mapOf(
+                            "providerId" to "openai",
+                            "reasons" to listOf(
+                                mapOf("code" to "privacy_constraint", "message" to "local_required forbids cloud.")
+                            )
+                        )
+                    )
+                )
+            )
+        )
+
+        val details = encoded.getJSONObject("details")
+        assertEquals("CapabilityMismatch", details.getString("failureCode"))
+
+        val rejected = details.getJSONArray("rejectedProviders")
+        assertEquals(2, rejected.length())
+        assertEquals("android.mlkit.genai", rejected.getJSONObject(0).getString("providerId"))
+        assertEquals(
+            "streaming_not_supported",
+            rejected.getJSONObject(0).getJSONArray("reasons").getJSONObject(0).getString("code")
+        )
+        assertEquals("openai", rejected.getJSONObject(1).getString("providerId"))
+        assertEquals(
+            "privacy_constraint",
+            rejected.getJSONObject(1).getJSONArray("reasons").getJSONObject(0).getString("code")
+        )
+    }
+
 }

package/android/src/test/kotlin/app/independo/inderun/capacitor/IndeRunStreamRegistryTest.kt

@@ -0,0 +1,163 @@
+package app.independo.inderun.capacitor
+
+import app.independo.inderun.contracts.SchemaVersion
+import app.independo.inderun.contracts.StreamRunHandle
+import app.independo.inderun.core.StreamRun
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.emptyFlow
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class IndeRunStreamRegistryTest {
+
+    private fun run(record: (String?) -> Unit): StreamRun = StreamRun(
+        handle = StreamRunHandle(
+            runId = "run_1",
+            schemaVersion = SchemaVersion.V1_0,
+            startedAt = 1_700_000_000_000.0
+        ),
+        events = emptyFlow(),
+        onCancel = record
+    )
+
+    @Test
+    fun `attaches and closes by stream id`() {
+        val registry = IndeRunStreamRegistry()
+
+        registry.open("s1")
+        assertEquals(AttachOutcome.Attached, registry.attach("s1", run {}))
+        assertEquals(1, registry.activeCount)
+
+        registry.close("s1")
+        assertEquals(0, registry.activeCount)
+    }
+
+    /**
+     * A cancel can beat the engine's route selection. It must be held and applied when
+     * the run finally attaches, not dropped.
+     */
+    @Test
+    fun `cancel before attach is applied on attach with its reason`() {
+        val registry = IndeRunStreamRegistry()
+        val reasons = mutableListOf<String?>()
+
+        registry.open("s1")
+        registry.requestCancel("s1", "user left")
+        // Nothing to cancel yet, so nothing was called.
+        assertTrue(reasons.isEmpty())
+
+        val outcome = registry.attach("s1", run { reasons.add(it) })
+        assertEquals(AttachOutcome.CancelRequested("user left"), outcome)
+    }
+
+    @Test
+    fun `cancel after close is a no-op`() {
+        val registry = IndeRunStreamRegistry()
+        val reasons = mutableListOf<String?>()
+
+        registry.open("s1")
+        registry.attach("s1", run { reasons.add(it) })
+        registry.close("s1")
+
+        registry.requestCancel("s1", "too late")
+        assertTrue(reasons.isEmpty())
+    }
+
+    @Test
+    fun `cancel for an unknown stream id is a no-op`() {
+        val registry = IndeRunStreamRegistry()
+
+        registry.requestCancel("never_opened", null)
+        assertEquals(0, registry.activeCount)
+    }
+
+    @Test
+    fun `repeated cancel cancels the run exactly once`() {
+        val registry = IndeRunStreamRegistry()
+        val reasons = mutableListOf<String?>()
+
+        registry.open("s1")
+        registry.attach("s1", run { reasons.add(it) })
+
+        registry.requestCancel("s1", "first")
+        registry.requestCancel("s1", "second")
+
+        assertEquals(listOf("first"), reasons)
+    }
+
+    @Test
+    fun `concurrent streams are isolated`() {
+        val registry = IndeRunStreamRegistry()
+        val first = mutableListOf<String?>()
+        val second = mutableListOf<String?>()
+
+        registry.open("s1")
+        registry.open("s2")
+        registry.attach("s1", run { first.add(it) })
+        registry.attach("s2", run { second.add(it) })
+
+        registry.requestCancel("s1", "only the first")
+
+        assertEquals(listOf("only the first"), first)
+        assertTrue(second.isEmpty())
+        assertEquals(2, registry.activeCount)
+    }
+
+    @Test
+    fun `cancelAll cancels every run once and empties the registry`() {
+        val registry = IndeRunStreamRegistry()
+        val first = mutableListOf<String?>()
+        val second = mutableListOf<String?>()
+
+        registry.open("s1")
+        registry.open("s2")
+        registry.attach("s1", run { first.add(it) })
+        registry.attach("s2", run { second.add(it) })
+
+        registry.cancelAll("torn down")
+
+        assertEquals(listOf("torn down"), first)
+        assertEquals(listOf("torn down"), second)
+        assertEquals(0, registry.activeCount)
+    }
+
+    /**
+     * Teardown also cancels the collecting jobs — at that point nobody is left to
+     * receive a terminal event.
+     */
+    @Test
+    fun `cancelAll cancels the collecting job`() {
+        val registry = IndeRunStreamRegistry()
+        val job = Job()
+
+        registry.open("s1")
+        registry.attach("s1", run {})
+        registry.attachJob("s1", job)
+
+        assertFalse(job.isCancelled)
+        registry.cancelAll(null)
+        assertTrue(job.isCancelled)
+    }
+
+    @Test
+    fun `attach after teardown reports cancel requested`() {
+        val registry = IndeRunStreamRegistry()
+
+        registry.open("s1")
+        registry.cancelAll("torn down")
+
+        // The entry is gone, so the run that arrives late must be cancelled by its caller.
+        assertEquals(AttachOutcome.CancelRequested(null), registry.attach("s1", run {}))
+    }
+
+    @Test
+    fun `a job attached to a closed stream is cancelled immediately`() {
+        val registry = IndeRunStreamRegistry()
+        val job = Job()
+
+        registry.attachJob("never_opened", job)
+        assertTrue(job.isCancelled)
+    }
+}

package/dist/definitions.d.ts

@@ -1,4 +1,5 @@
-import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
+import type { PluginListenerHandle } from "@capacitor/core";
+import type { IndeRunError, ModelPackage, StreamEvent, StreamRunHandle, TaskRequest, TaskResult } from "@independo/inderun-contracts";
 export interface OpenAIProviderBootstrapOptions {
     model: string;
     endpointUrl?: string;
@@ -6,12 +7,185 @@ export interface OpenAIProviderBootstrapOptions {
     authContextRef?: string;
     timeoutMs?: number;
 }
+/**
+ * Bootstrap options for the browser-managed on-device provider (Chrome's Prompt API).
+ *
+ * **Web only**, and ignored on iOS and Android, which register their own on-device
+ * providers — Apple Foundation Models and ML Kit GenAI — from `configure()` regardless.
+ *
+ * The browser owns model availability, download and execution, so there is nothing to
+ * configure: registering it is the whole point, and it is what makes
+ * `constraints.privacy = "local_required"` routable in a browser. Mode 1 only — this
+ * provider does not stream, so a `local_required` *stream* on the web is still refused at
+ * routing time.
+ *
+ * The web SDK's `runtime` injection seam is deliberately not exposed: it is a function,
+ * and `configure()` has to survive a JSON bridge hop on native.
+ */
+export interface SystemModelProviderBootstrapOptions {
+    id?: string;
+    timeoutMs?: number;
+}
+/**
+ * Bootstrap options for the Web ONNX Runtime provider, for a developer-supplied local
+ * model.
+ *
+ * **Web only**, like `systemModel`, and Mode 1 only.
+ *
+ * Two caveats worth knowing before reaching for this. The consumer has to install the
+ * optional `@huggingface/transformers` peer dependency — this bridge does not declare it —
+ * and supply real model weights, because the web SDK's `runtime` seam is a function and so
+ * cannot cross the JSON bridge hop: only the default Transformers.js runtime is reachable
+ * from here, never the fixture runtime the upstream demos use offline. A registered
+ * provider that cannot load turns a clean routing refusal into a provider error, so
+ * register it only when the weights are actually there.
+ */
+export interface OnnxProviderBootstrapOptions {
+    id?: string;
+    modelPackage: ModelPackage;
+    timeoutMs?: number;
+}
 export interface ConfigureOptions {
     openAI?: OpenAIProviderBootstrapOptions;
+    /** Web only; native registers its own on-device provider. */
+    systemModel?: SystemModelProviderBootstrapOptions;
+    /** Web only; native registers its own on-device provider. */
+    onnx?: OnnxProviderBootstrapOptions;
     allowDirectOpenAIEndpoint?: boolean;
 }
+/**
+ * Bridge-local correlation id for one streaming run.
+ *
+ * Not a contract field, and never placed inside the `TaskRequest`: `runId` stays the
+ * engine's to mint. `startStream` resolves only *after* the engine has minted one, so
+ * keying the JS-side event sink on `runId` would leave a window in which native can
+ * emit events for a run JS has not yet heard of. The `streamId` is generated before
+ * the call instead, which lets the sink be bound first and makes `cancel()`
+ * well-defined even before a handle exists.
+ */
+export interface StartStreamOptions {
+    streamId: string;
+    request: TaskRequest;
+}
+export interface CancelStreamOptions {
+    streamId: string;
+    reason?: string;
+}
+/** Payload of `"indeRunStreamEvent"`. `event` is the canonical, unmodified `StreamEvent`. */
+export interface StreamEventNotification {
+    streamId: string;
+    event: StreamEvent;
+}
+/**
+ * Payload of `"indeRunStreamError"`: a failure of the *bridge*, not an outcome of the
+ * run. A run that fails ends in a terminal event with `payload.outcome === "error"`,
+ * delivered through `"indeRunStreamEvent"` like any other event.
+ */
+export interface StreamErrorNotification {
+    streamId: string;
+    error: IndeRunError;
+}
+/**
+ * Structurally identical to `StreamRun` in `@independo/inderun-web`, so bridge and
+ * direct-SDK consumers read the same. `events` terminates in exactly one terminal
+ * event and is single-use; `cancel()` is idempotent.
+ */
+export interface StreamRun {
+    handle: StreamRunHandle;
+    events: AsyncIterable<StreamEvent>;
+    cancel(reason?: string): void;
+}
+/**
+ * A provider's static capability declaration.
+ *
+ * Declared here rather than imported, because — unlike `TaskRequest`, `StreamEvent` and
+ * the rest — this shape is *not* a generated contract. There is no schema for it in
+ * `@independo/inderun-contracts` and no validator; each SDK declares it independently
+ * (`core/provider.d.ts` in `@independo/inderun-web`, `IndeRunCore/Provider.swift`,
+ * `core/Provider.kt`), and this is the fourth copy. Importing it from
+ * `@independo/inderun-web` is not an option either: that would make the native
+ * platforms' plugin contract depend on the web SDK.
+ *
+ * The drift guard is in `web.ts`, which returns the web SDK's value into this type
+ * uncast — so `tsc` proves the shapes still match on every build, the same way the
+ * `StreamRun` mirror below is checked. See the upstream follow-up asking for a schema.
+ */
+export interface ProviderDescriptor {
+    id: string;
+    type: "local" | "edge" | "cloud";
+    transport: "in_process" | "system_service" | "http" | "sse" | "realtime";
+    streamingStyle?: "tokens" | "chunks" | "snapshots";
+    supports: {
+        run: boolean;
+        streaming: boolean;
+        realtime: boolean;
+        tools: boolean;
+        reasoningEvents: boolean;
+        structuredOutput: boolean;
+        multimodal: boolean;
+    };
+    cancel: "hard" | "soft" | "none";
+    tasks: string[];
+    limits?: {
+        maxInputTokens?: number;
+        maxOutputTokens?: number;
+        maxImageBytes?: number;
+        maxAudioSeconds?: number;
+    };
+    privacy?: {
+        dataLeavesDevice: boolean;
+        regions?: string[];
+    };
+}
+/**
+ * A provider's live availability, as of the moment `checkCapabilities()` was called.
+ *
+ * `streamingAvailable` and `cancellationAvailable` are **absent**, not `null`, when the
+ * runtime has nothing to say: absence means *inherit the static declaration*
+ * (`descriptor.supports.streaming`, and `descriptor.cancel !== "none"`). Both native
+ * encoders omit the key rather than emitting null for exactly that reason.
+ */
+export interface ProviderDynamicCapabilities {
+    available: boolean;
+    reason?: string;
+    streamingAvailable?: boolean;
+    streamingUnavailableReason?: string;
+    cancellationAvailable?: boolean;
+}
+/** One registered provider's identity, static declaration, and live availability. */
+export interface ProviderCapabilitySnapshot {
+    providerId: string;
+    descriptor: ProviderDescriptor;
+    capabilities: ProviderDynamicCapabilities;
+}
+/**
+ * Envelope for `checkCapabilities()`. The array is wrapped because a Capacitor plugin
+ * method must resolve an object on both native platforms — `PluginCall.resolve(JSObject)`
+ * and `call.resolve([String: Any])` cannot carry a top-level array. `IndeRunCapacitor`
+ * and `createIndeRunCapacitor()` unwrap it, so app code sees the same
+ * `ProviderCapabilitySnapshot[]` the three platform SDKs return.
+ */
+export interface CheckCapabilitiesResult {
+    providers: ProviderCapabilitySnapshot[];
+}
 export interface IndeRunCapacitorPlugin {
     configure(options?: ConfigureOptions): Promise<void>;
     run(request: TaskRequest): Promise<TaskResult>;
+    /**
+     * Live snapshot of every registered provider, without executing a task. Availability
+     * changes between calls — a local model can unload, cloud credentials can expire — so
+     * do not cache it across a `run()` or `stream()`.
+     */
+    checkCapabilities(): Promise<CheckCapabilitiesResult>;
+    /**
+     * Unlike `run(request)`, which passes the request at the options root, this nests it
+     * under `request` so the envelope can also carry `streamId`. Both native decode sites
+     * carry a matching comment.
+     */
+    startStream(options: StartStreamOptions): Promise<StreamRunHandle>;
+    cancelStream(options: CancelStreamOptions): Promise<void>;
+    addListener(eventName: "indeRunStreamEvent", listenerFunc: (notification: StreamEventNotification) => void): Promise<PluginListenerHandle>;
+    addListener(eventName: "indeRunStreamError", listenerFunc: (notification: StreamErrorNotification) => void): Promise<PluginListenerHandle>;
+    removeAllListeners(): Promise<void>;
 }
 //# sourceMappingURL=definitions.d.ts.map

package/dist/definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../src/definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE5E,MAAM,WAAW,8BAA8B;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,8BAA8B,CAAC;IACxC,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAChD"}
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../src/definitions.ts"],"names":[],"mappings":"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"}