@independo/inderun-web 0.3.0-dev.4 → 0.3.0-dev.6

package/README.md

@@ -30,10 +30,49 @@ const result = await inderun.run({
 });
 ```
 
+## Streaming
+
+`stream()` returns the run handle, its canonical `StreamEvent` sequence, and a `cancel()` hook:
+
+```ts
+const { handle, events, cancel } = await inderun.stream({
+  schemaVersion: "1.0",
+  task: { kind: "text_to_text" },
+  prompt: "Write a one-sentence summary of IndeRun."
+});
+
+for await (const event of events) {
+  if (event.type === "content_delta") process.stdout.write(event.payload.text);
+  if (event.type === "terminal") console.log(event.payload.outcome);
+}
+```
+
+Order by `event.sequence`, not by arrival: it is the ordering authority for a run. Treat an
+unrecognized `event.type` as ignore-or-pass-through — the set is open and additive. Exactly one
+`terminal` event is produced per run, and `cancel()` is idempotent.
+
+Streaming needs a host that can deliver a response body incrementally.
+`createBrowserHostServices` provides one; a custom host without a
+`streamingHttpClient` still runs Mode 1, and a stream request is refused at routing
+time with a `streaming_unavailable` reason rather than failing later.
+
+### Custom OpenAI-compatible endpoints
+
+The adapter speaks the OpenAI **Responses** API, not chat completions. A custom endpoint must
+accept `"stream": true` and emit `text/event-stream` with the Responses event types —
+`response.output_text.delta`, and `response.completed` / `response.incomplete` carrying the
+response object. Unknown event types are ignored, so an endpoint that emits extra events is
+fine; one that emits a different vocabulary entirely is not.
+
 ## Security Model
 
 Browser apps should use a proxy endpoint and keep provider credentials server-side. `createIndeRunWeb` rejects direct calls to the public OpenAI Responses endpoint unless `allowDirectOpenAIEndpoint: true` is set for a controlled environment.
 
+This applies to streaming too, and is the reason `@independo/inderun-demo-proxy` relays event
+streams rather than buffering them: a browser cannot open its own authenticated connection to
+OpenAI without shipping the key in client code. Never embed a developer-owned API key in
+distributed client code — put it behind a trusted backend proxy and point `endpointUrl` at that.
+
 ## Advanced: registering the OpenAI provider directly
 
 `createIndeRunWeb` wires the OpenAI Responses provider for you. To register it

package/dist/core/browser-host.d.ts

@@ -1,4 +1,4 @@
-import type { ClockService, ConnectivityService, HostServices, HttpClientService, HttpRequest, HttpResponse } from "./host.js";
+import type { ClockService, ConnectivityService, HostServices, HttpClientService, HttpRequest, HttpResponse, HttpStreamResponse, HttpStreamingClientService } from "./host.js";
 /**
  * Configuration for the fetch-backed HTTP host service.
  */
@@ -49,12 +49,39 @@ export declare class FetchHttpClient implements HttpClientService {
      */
     send(request: HttpRequest): Promise<HttpResponse>;
 }
+/**
+ * Streaming HTTP client service that adapts `fetch` to IndeRun's incremental
+ * HTTP contract by handing back `Response.body` rather than buffering it.
+ *
+ * Two abort sources are merged onto one controller: `timeoutMs`, which bounds
+ * only the wait for the response head, and the caller's `signal`, which stays
+ * live for the whole body. The timeout timer is therefore cleared as soon as
+ * the head resolves — a stream that legitimately stays open for minutes must
+ * not be killed by a time-to-first-byte budget.
+ */
+export declare class FetchStreamingHttpClient implements HttpStreamingClientService {
+    private readonly fetchFn;
+    /**
+     * Creates a fetch-backed streaming HTTP client.
+     * @param options - Optional fetch implementation override.
+     * @throws Error when no fetch implementation is available.
+     */
+    constructor(options?: FetchHttpClientOptions);
+    /**
+     * Sends a normalized HTTP request and resolves once the response head is available.
+     * @param request - Normalized HTTP request payload.
+     * @param signal - Optional caller-driven cancellation covering the whole response.
+     * @returns Response head plus a lazily-consumed body chunk sequence.
+     */
+    stream(request: HttpRequest, signal?: AbortSignal): Promise<HttpStreamResponse>;
+}
 /**
  * Options for constructing default browser host services.
  */
 export interface CreateBrowserHostServicesOptions extends Partial<HostServices> {
     /**
-     * Optional fetch implementation used when `httpClient` is not supplied.
+     * Optional fetch implementation used when `httpClient`/`streamingHttpClient`
+     * are not supplied.
      */
     fetchFn?: typeof fetch;
 }

package/dist/core/browser-host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"browser-host.d.ts","sourceRoot":"","sources":["../../src/core/browser-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACb,MAAM,WAAW,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACxB;AAED;;GAEG;AACH,qBAAa,0BAA2B,YAAW,mBAAmB;IACpE;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;CAOnC;AAED;;GAEG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD;;OAEG;IACH,GAAG,IAAI,MAAM;IAIb;;OAEG;IACH,YAAY,IAAI,MAAM;CAOvB;AAED;;GAEG;AACH,qBAAa,eAAgB,YAAW,iBAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC;;;;OAIG;gBACS,OAAO,GAAE,sBAA2B;IAShD;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;CA0CxD;AAED;;GAEG;AACH,MAAM,WAAW,gCAAiC,SAAQ,OAAO,CAAC,YAAY,CAAC;IAC7E;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,YAAY,CA2Bd"}
+{"version":3,"file":"browser-host.d.ts","sourceRoot":"","sources":["../../src/core/browser-host.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,WAAW,CAAC;AAEnB;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACxB;AAED;;GAEG;AACH,qBAAa,0BAA2B,YAAW,mBAAmB;IACpE;;;OAGG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;CAOnC;AAED;;GAEG;AACH,qBAAa,kBAAmB,YAAW,YAAY;IACrD;;OAEG;IACH,GAAG,IAAI,MAAM;IAIb;;OAEG;IACH,YAAY,IAAI,MAAM;CAOvB;AAED;;GAEG;AACH,qBAAa,eAAgB,YAAW,iBAAiB;IACvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC;;;;OAIG;gBACS,OAAO,GAAE,sBAA2B;IAShD;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;CA0CxD;AAED;;;;;;;;;GASG;AACH,qBAAa,wBAAyB,YAAW,0BAA0B;IACzE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC;;;;OAIG;gBACS,OAAO,GAAE,sBAA2B;IAShD;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAwHtF;AAED;;GAEG;AACH,MAAM,WAAW,gCAAiC,SAAQ,OAAO,CAAC,YAAY,CAAC;IAC7E;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC,GAC7C,YAAY,CAmCd"}

package/dist/core/browser-host.js

@@ -93,6 +93,154 @@ export class FetchHttpClient {
         }
     }
 }
+/**
+ * Streaming HTTP client service that adapts `fetch` to IndeRun's incremental
+ * HTTP contract by handing back `Response.body` rather than buffering it.
+ *
+ * Two abort sources are merged onto one controller: `timeoutMs`, which bounds
+ * only the wait for the response head, and the caller's `signal`, which stays
+ * live for the whole body. The timeout timer is therefore cleared as soon as
+ * the head resolves — a stream that legitimately stays open for minutes must
+ * not be killed by a time-to-first-byte budget.
+ */
+export class FetchStreamingHttpClient {
+    fetchFn;
+    /**
+     * Creates a fetch-backed streaming HTTP client.
+     * @param options - Optional fetch implementation override.
+     * @throws Error when no fetch implementation is available.
+     */
+    constructor(options = {}) {
+        const fetchFn = options.fetchFn ?? globalThis.fetch?.bind(globalThis);
+        if (!fetchFn) {
+            throw new Error("FetchStreamingHttpClient requires a fetch implementation.");
+        }
+        this.fetchFn = fetchFn;
+    }
+    /**
+     * Sends a normalized HTTP request and resolves once the response head is available.
+     * @param request - Normalized HTTP request payload.
+     * @param signal - Optional caller-driven cancellation covering the whole response.
+     * @returns Response head plus a lazily-consumed body chunk sequence.
+     */
+    async stream(request, signal) {
+        const controller = typeof AbortController === "undefined" ? undefined : new AbortController();
+        let timeoutId;
+        let onAbort;
+        if (controller) {
+            if (request.timeoutMs !== undefined) {
+                timeoutId = setTimeout(() => controller.abort(), request.timeoutMs);
+            }
+            if (signal) {
+                if (signal.aborted) {
+                    controller.abort();
+                }
+                else {
+                    onAbort = () => controller.abort();
+                    signal.addEventListener("abort", onAbort, { once: true });
+                }
+            }
+        }
+        const clearTimeoutTimer = () => {
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+                timeoutId = undefined;
+            }
+        };
+        const releaseAbortListener = () => {
+            if (signal && onAbort) {
+                signal.removeEventListener("abort", onAbort);
+                onAbort = undefined;
+            }
+        };
+        let response;
+        try {
+            const init = { method: request.method };
+            if (request.headers) {
+                init.headers = request.headers;
+            }
+            if (request.body !== undefined) {
+                init.body = request.body;
+            }
+            if (controller) {
+                init.signal = controller.signal;
+            }
+            response = await this.fetchFn(request.url, init);
+        }
+        catch (error) {
+            clearTimeoutTimer();
+            releaseAbortListener();
+            throw error;
+        }
+        clearTimeoutTimer();
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key.toLowerCase()] = value;
+        });
+        const stream = response.body;
+        async function* iterate() {
+            try {
+                if (!stream) {
+                    // A bodyless response (204, HEAD) or a fetch polyfill without stream
+                    // support: fall back to the buffered text so callers still terminate.
+                    const text = await response.text();
+                    if (text.length > 0) {
+                        yield new TextEncoder().encode(text);
+                    }
+                    return;
+                }
+                const reader = stream.getReader();
+                // The body is also raced against `signal` directly, not just against the
+                // fetch-level abort: a fetch implementation is free not to error an
+                // in-flight body when its request signal fires, and the caller's
+                // cancellation guarantee must not depend on that.
+                let onBodyAbort;
+                const aborted = new Promise((_resolve, reject) => {
+                    if (!signal)
+                        return;
+                    onBodyAbort = () => reject(Object.assign(new Error("The stream was aborted."), { name: "AbortError" }));
+                    if (signal.aborted) {
+                        onBodyAbort();
+                    }
+                    else {
+                        signal.addEventListener("abort", onBodyAbort, { once: true });
+                    }
+                });
+                // Keeps an abort that arrives after the body finished from surfacing as
+                // an unhandled rejection; the race below still observes it.
+                void aborted.catch(() => undefined);
+                try {
+                    for (;;) {
+                        const { done, value } = await Promise.race([reader.read(), aborted]);
+                        if (done)
+                            return;
+                        if (value)
+                            yield value;
+                    }
+                }
+                catch (error) {
+                    await reader.cancel().catch(() => undefined);
+                    throw error;
+                }
+                finally {
+                    if (signal && onBodyAbort) {
+                        signal.removeEventListener("abort", onBodyAbort);
+                    }
+                    reader.releaseLock();
+                }
+            }
+            finally {
+                releaseAbortListener();
+            }
+        }
+        return {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            body: iterate()
+        };
+    }
+}
 /**
  * Creates a browser-oriented HostServices bundle for the Web SDK.
  * Supplied host services override the defaults; missing connectivity, clock, and HTTP services are created.
@@ -112,6 +260,15 @@ export function createBrowserHostServices(options = {}) {
     else {
         hostServices.httpClient = new FetchHttpClient();
     }
+    if (options.streamingHttpClient) {
+        hostServices.streamingHttpClient = options.streamingHttpClient;
+    }
+    else if (options.fetchFn) {
+        hostServices.streamingHttpClient = new FetchStreamingHttpClient({ fetchFn: options.fetchFn });
+    }
+    else {
+        hostServices.streamingHttpClient = new FetchStreamingHttpClient();
+    }
     if (options.deviceConstraints) {
         hostServices.deviceConstraints = options.deviceConstraints;
     }

package/dist/core/engine.d.ts

@@ -1,20 +1,15 @@
-import { type StreamEvent, type StreamRunHandle, type TaskRequest, type TaskResult } from "@independo/inderun-contracts";
+import { type TaskRequest, type TaskResult } from "@independo/inderun-contracts";
 import type { HostServices } from "./host.js";
-import type { ProviderCapabilitySnapshot } from "./provider.js";
+import type { ProviderCapabilitySnapshot, StreamRun } from "./provider.js";
 import type { IndeRunApi } from "./generated/inderun-api.js";
 import { ProviderRegistry } from "./registry.js";
 import { type TelemetryService } from "./telemetry.js";
 /**
- * Handle returned by IndeRun.stream(). `events` is the canonical StreamEvent
- * sequence for this run, terminating in exactly one terminal StreamEvent per the
- * Event Gate's guarantee. `cancel()` is idempotent: repeated or concurrent calls
- * produce exactly one `cancelled` terminal outcome.
+ * @deprecated Renamed to `StreamRun`, which is the name the generated
+ * `IndeRunApi` surface and the Swift/Kotlin SDKs use. Kept as an alias so the
+ * rename is not a breaking change.
  */
-export interface StreamHandleResult {
-    handle: StreamRunHandle;
-    events: AsyncIterable<StreamEvent>;
-    cancel(reason?: string): void;
-}
+export type StreamHandleResult = StreamRun;
 /**
  * Main orchestrator SDK entrypoint class.
  * Validates tasks, executes routing rules based on request constraints and connectivity,
@@ -54,17 +49,22 @@ export declare class IndeRun implements IndeRunApi {
     /**
      * Orchestrates a Mode 2 streaming execution of a TaskRequest.
      *
-     * Reuses the same route selection as run(), restricted to providers that declare
-     * `supports.streaming` and implement `stream()`. Fallback to the next provider is
-     * allowed only before the first content event has been admitted for the run; once
-     * one has been delivered, the run is committed to that provider and any later
-     * provider failure becomes a terminal error outcome rather than a silent provider
-     * swap. Cancellation always forecloses fallback, regardless of commit state, and
-     * is idempotent.
+     * Routes through the same planner as run(), asking it for a `stream` route: the
+     * planner rejects providers that do not declare `supports.streaming` or whose
+     * dynamic capability snapshot says they cannot stream here, and reports why. The
+     * whole returned chain is therefore mode-compatible and subject to the same
+     * privacy, locality, availability, and policy constraints as a Mode 1 route.
+     *
+     * Fallback to the next provider is allowed only before the first content event
+     * has been admitted for the run; once one has been delivered, the run is
+     * committed to that provider and any later provider failure becomes a terminal
+     * error outcome rather than a silent provider swap — partial output spliced from
+     * two providers is undetectable to the caller. Cancellation always forecloses
+     * fallback, regardless of commit state, and is idempotent.
      * @param request - The canonical task request containing prompts, tasks, and constraints.
      * @throws {IndeRunException} If validation fails or no eligible streaming provider exists.
      */
-    stream(request: TaskRequest): Promise<StreamHandleResult>;
+    stream(request: TaskRequest): Promise<StreamRun>;
     /**
      * Reports each registered provider's static descriptor and current dynamic capability check,
      * without executing a task. Useful for UI that shows live provider availability before a run.

package/dist/core/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,eAAe,EAEpB,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAmB,0BAA0B,EAAE,MAAM,eAAe,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAQjD,OAAO,EAAuB,KAAK,gBAAgB,EAAwB,MAAM,gBAAgB,CAAC;AAGlG;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,eAAe,CAAC;IACxB,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IACnC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,UAAU;IAWtC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,YAAY;IAXtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAmB;IAE3C;;;;;OAKG;gBAEO,QAAQ,EAAE,gBAAgB,EAC1B,YAAY,EAAE,YAAY,EAClC,gBAAgB,CAAC,EAAE,gBAAgB;IAOrC;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAShB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;;OAOG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAuIpD;;;;;;;;;;;;OAYG;IACG,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAsQ/D;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC;CASjE"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/core/engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAmB,0BAA0B,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAQjD,OAAO,EAAuB,KAAK,gBAAgB,EAAwB,MAAM,gBAAgB,CAAC;AAGlG;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,CAAC;AAE3C;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,UAAU;IAWtC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,YAAY;IAXtB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAmB;IAE3C;;;;;OAKG;gBAEO,QAAQ,EAAE,gBAAgB,EAC1B,YAAY,EAAE,YAAY,EAClC,gBAAgB,CAAC,EAAE,gBAAgB;IAOrC;;;OAGG;IACH,OAAO,CAAC,QAAQ;IAShB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;;;;;;OAOG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAuIpD;;;;;;;;;;;;;;;;;OAiBG;IACG,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;IA+QtD;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC;CASjE"}

package/dist/core/engine.js

@@ -87,7 +87,7 @@ export class IndeRun {
                 });
             }
             // 2. Select the route based on constraints and host capabilities
-            const routeSelection = await this.router.selectRoute(request, this.hostServices);
+            const routeSelection = await this.router.selectRoute(request, this.hostServices, "run");
             const providers = [routeSelection.provider, ...routeSelection.fallbackProviders];
             // Emit route_decided event
             this.safeEmit({
@@ -194,13 +194,18 @@ export class IndeRun {
     /**
      * Orchestrates a Mode 2 streaming execution of a TaskRequest.
      *
-     * Reuses the same route selection as run(), restricted to providers that declare
-     * `supports.streaming` and implement `stream()`. Fallback to the next provider is
-     * allowed only before the first content event has been admitted for the run; once
-     * one has been delivered, the run is committed to that provider and any later
-     * provider failure becomes a terminal error outcome rather than a silent provider
-     * swap. Cancellation always forecloses fallback, regardless of commit state, and
-     * is idempotent.
+     * Routes through the same planner as run(), asking it for a `stream` route: the
+     * planner rejects providers that do not declare `supports.streaming` or whose
+     * dynamic capability snapshot says they cannot stream here, and reports why. The
+     * whole returned chain is therefore mode-compatible and subject to the same
+     * privacy, locality, availability, and policy constraints as a Mode 1 route.
+     *
+     * Fallback to the next provider is allowed only before the first content event
+     * has been admitted for the run; once one has been delivered, the run is
+     * committed to that provider and any later provider failure becomes a terminal
+     * error outcome rather than a silent provider swap — partial output spliced from
+     * two providers is undetectable to the caller. Cancellation always forecloses
+     * fallback, regardless of commit state, and is idempotent.
      * @param request - The canonical task request containing prompts, tasks, and constraints.
      * @throws {IndeRunException} If validation fails or no eligible streaming provider exists.
      */
@@ -215,9 +220,17 @@ export class IndeRun {
                 .join("; ")}`;
             throw createInternal(message, { runId, details: { validationIssues } });
         }
-        const routeSelection = await this.router.selectRoute(request, this.hostServices);
-        const allProviders = [routeSelection.provider, ...routeSelection.fallbackProviders];
-        const providers = allProviders.filter((p) => p.describe().supports.streaming && typeof p.stream === "function");
+        // Route selection failures are the one class of stream error that surfaces as a
+        // rejected promise instead of a terminal event, so they must still carry the
+        // runId — there is no handle for the caller to correlate them with otherwise.
+        let routeSelection;
+        try {
+            routeSelection = await this.router.selectRoute(request, this.hostServices, "stream");
+        }
+        catch (error) {
+            throw toIndeRunException(error, { runId });
+        }
+        const providers = [routeSelection.provider, ...routeSelection.fallbackProviders];
         this.safeEmit({
             type: "route_decided",
             runId,
@@ -235,6 +248,9 @@ export class IndeRun {
                 plannerUnavailableReason: routeSelection.plannerUnavailableReason ?? null
             }
         });
+        // Defensive only: streaming eligibility is decided by the route planner, which
+        // throws with its own rejection reasons when nothing can stream. Reaching here
+        // means a planned provider was unregistered between planning and selection.
         if (providers.length === 0) {
             throw createCapabilityMismatch("No eligible provider supports streaming for this request.", {
                 runId,
@@ -319,6 +335,7 @@ export class IndeRun {
                             schemaVersion: "1.0",
                             finalText: ev.finalText,
                             telemetry: { providerUsed: providerId, totalMs: now() - startTime },
+                            ...(ev.finishReason !== undefined ? { finishReason: ev.finishReason } : {}),
                             ...(ev.usage !== undefined ? { usage: ev.usage } : {})
                         };
                         const terminal = gate.terminate(outcome, now());

package/dist/core/generated/inderun-api.d.ts

@@ -1,10 +1,14 @@
 import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
-import type { ProviderCapabilitySnapshot } from "../provider.js";
+import type { StreamRun, ProviderCapabilitySnapshot } from "../provider.js";
 export interface IndeRunApi {
     /**
      * Executes a Mode 1 (request/response) text-to-text task against a routed provider and returns the completed TaskResult. Routing (local vs. cloud, which provider) is decided internally from TaskRequest.constraints/preferences — the caller does not select a provider directly. Rejects the request up front on validation failure; otherwise throws an IndeRunException (carrying an IndeRunError) if no eligible provider is found or every attempted provider fails. There is no partial or streaming result in this mode: run() either resolves with a complete TaskResult or throws.
      */
     run(request: TaskRequest): Promise<TaskResult>;
+    /**
+     * Executes a Mode 2 (streaming) text-to-text task and returns a handle to the run, its canonical StreamEvent sequence, and a cancel hook. The requested interaction mode is a routing input rather than a filter applied after routing: providers that cannot stream are rejected during planning with a normalized reason, so a stream and a run over the same registry may legitimately resolve to different provider chains. Two failure surfaces exist deliberately — validation and route-selection failures reject this call, since there is no handle to correlate them with yet, while provider failure, cancellation, and completion all arrive as the single terminal StreamEvent in the returned sequence. Fallback is narrower than run()'s: a provider failure is only fallback-eligible before the first content event has been delivered; once one has, the run is committed to that provider and a later failure becomes a terminal error rather than a silent provider swap. Cancellation forecloses both at any commit state and always produces exactly one cancelled outcome.
+     */
+    stream(request: TaskRequest): Promise<StreamRun>;
     /**
      * Returns a live snapshot of every registered provider's static descriptor and current dynamic availability, without executing a task or producing any side effects. Call this before run() when you need to show which providers/models are currently available — for example a settings screen or provider picker. Availability can change between calls (a local model can unload, cloud credentials can expire), so don't cache the result across a run() call.
      */

package/dist/core/generated/inderun-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inderun-api.d.ts","sourceRoot":"","sources":["../../../src/core/generated/inderun-api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAEjE,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/C;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAAC;CAC5D"}
+{"version":3,"file":"inderun-api.d.ts","sourceRoot":"","sources":["../../../src/core/generated/inderun-api.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAE5E,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC/C;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACjD;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAAC;CAC5D"}

package/dist/core/host.d.ts

@@ -1,2 +1,2 @@
-export type { ClockService, ConnectivityService, DeviceConstraintsService, HostServices, HttpClientService, HttpRequest, HttpResponse, SecureStorageService, TelemetryService, ThermalState } from "@independo/inderun-contracts";
+export type { AbortSignalLike, ClockService, ConnectivityService, DeviceConstraintsService, HostServices, HttpClientService, HttpRequest, HttpResponse, HttpStreamResponse, HttpStreamingClientService, SecureStorageService, TelemetryService, ThermalState } from "@independo/inderun-contracts";
 //# sourceMappingURL=host.d.ts.map

package/dist/core/host.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/core/host.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAC"}
+{"version":3,"file":"host.d.ts","sourceRoot":"","sources":["../../src/core/host.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,kBAAkB,EAClB,0BAA0B,EAC1B,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAC"}

package/dist/core/provider.d.ts

@@ -1,4 +1,4 @@
-import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
+import type { StreamEvent, StreamRunHandle, TaskRequest, TaskResult } from "@independo/inderun-contracts";
 import type { HostServices } from "./host.js";
 /**
  * Static metadata descriptor defining the capabilities, requirements, and constraints
@@ -82,6 +82,25 @@ export interface ProviderDynamicCapabilities {
      * Detail message if availability check fails.
      */
     reason?: string;
+    /**
+     * Whether the provider can stream (Mode 2) right now on this host. Leave
+     * undefined to inherit the static `descriptor.supports.streaming` value —
+     * only set it when the runtime environment can take streaming away from a
+     * provider that otherwise declares it (e.g. the host has no chunked HTTP
+     * capability).
+     */
+    streamingAvailable?: boolean;
+    /**
+     * Detail message used when `streamingAvailable` is false. Omit to let the
+     * route planner synthesize a generic message.
+     */
+    streamingUnavailableReason?: string;
+    /**
+     * Whether cancellation is honored right now on this host. Leave undefined to
+     * inherit the static `descriptor.cancel` value (anything other than `"none"`
+     * means available).
+     */
+    cancellationAvailable?: boolean;
 }
 /**
  * One registered provider's identity, fixed capabilities, and live availability,
@@ -149,6 +168,12 @@ export type ProviderStreamEvent = {
 } | {
     kind: "done";
     finalText: string;
+    /**
+     * How generation ended, when the provider reports it. Mirrors
+     * `TaskResult.finishReason` for Mode 1 and surfaces on the `completed`
+     * terminal outcome; omit when the provider gives no signal.
+     */
+    finishReason?: TaskResult["finishReason"];
     usage?: TaskResult["usage"];
 } | {
     kind: "error";
@@ -177,4 +202,18 @@ export interface ProviderAdapter {
      */
     stream?(req: TaskRequest, ctx: ProviderStreamContext): AsyncIterable<ProviderStreamEvent>;
 }
+/**
+ * What `IndeRun.stream()` returns: the run's identity, its canonical event
+ * sequence, and a cancel hook.
+ *
+ * `events` terminates in exactly one terminal `StreamEvent`, per the Event
+ * Gate's guarantee, and is single-use — the run is driven once, not restarted
+ * per consumer. `cancel()` is idempotent: repeated or concurrent calls produce
+ * exactly one `cancelled` terminal outcome.
+ */
+export interface StreamRun {
+    handle: StreamRunHandle;
+    events: AsyncIterable<StreamEvent>;
+    cancel(reason?: string): void;
+}
 //# sourceMappingURL=provider.d.ts.map

package/dist/core/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/core/provider.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/core/provider.ts"],"names":[],"mappings":"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"}

package/dist/core/route-planner.d.ts

@@ -2,6 +2,11 @@ import type { RoutePlan as SharedPlannerRoutePlan, RoutePlannerInput as SharedPl
 import type { HostServices } from "./host.js";
 import type { ProviderAdapter } from "./provider.js";
 export type { SharedPlannerInput, SharedPlannerRoutePlan };
+/**
+ * Interaction mode the caller is requesting a route for. Passed to the shared
+ * planner, which rejects providers that cannot satisfy it.
+ */
+export type InteractionMode = NonNullable<SharedPlannerInput["interactionMode"]>;
 /**
  * Minimal shape of the shared route-core module (the WASM wrapper), used to
  * plan routes via JSON in/JSON out. `initSharedCore` initializes the WASM
@@ -73,5 +78,5 @@ export declare function collectProviderRuntimeSnapshots(registryProviders: Provi
  * consumes, applying default constraints/preferences and the current network
  * state.
  */
-export declare function buildSharedPlannerInput(request: TaskRequest, snapshots: ProviderRuntimeSnapshot[], networkOnline: boolean): SharedPlannerInput;
+export declare function buildSharedPlannerInput(request: TaskRequest, snapshots: ProviderRuntimeSnapshot[], networkOnline: boolean, interactionMode?: InteractionMode): SharedPlannerInput;
 //# sourceMappingURL=route-planner.d.ts.map

package/dist/core/route-planner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"route-planner.d.ts","sourceRoot":"","sources":["../../src/core/route-planner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,IAAI,sBAAsB,EACnC,iBAAiB,IAAI,kBAAkB,EACvC,WAAW,EACZ,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EACV,eAAe,EAGhB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC;AAE3D;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAChE;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC/B,eAAe,GAAG,sBAAsB,GAAG,aAAa,GAAG,aAAa,CAAC;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACzC,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC;IAC/B,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;CAC3C;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAC/D;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;IAClE,YAAY,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,CAAC;CACvE;AAED;;;;;;;;;GASG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IACnD,OAAO,CAAC,aAAa,CAAC,CAAsC;IAC5D,OAAO,CAAC,iBAAiB,CAAC,CAAwB;IAClD,OAAO,CAAC,SAAS,CAAS;IAEpB,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;YAkBrD,UAAU;YAOV,YAAY;IA6B1B,OAAO,CAAC,QAAQ;CAUjB;AAED;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,iBAAiB,EAAE,eAAe,EAAE,EACpC,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAepC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,uBAAuB,EAAE,EACpC,aAAa,EAAE,OAAO,GACrB,kBAAkB,CAsBpB"}
+{"version":3,"file":"route-planner.d.ts","sourceRoot":"","sources":["../../src/core/route-planner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,IAAI,sBAAsB,EACnC,iBAAiB,IAAI,kBAAkB,EACvC,WAAW,EACZ,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EACV,eAAe,EAGhB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC;AAE3D;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC,CAAC;AAEjF;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAChE;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC/B,eAAe,GAAG,sBAAsB,GAAG,aAAa,GAAG,aAAa,CAAC;AAE3E;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACzC,MAAM,EAAE,MAAM,GAAG,aAAa,CAAC;IAC/B,iBAAiB,CAAC,EAAE,qBAAqB,CAAC;CAC3C;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CAC/D;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;IAClE,YAAY,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,cAAc,CAAC,CAAC;CACvE;AAED;;;;;;;;;GASG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IACnD,OAAO,CAAC,aAAa,CAAC,CAAsC;IAC5D,OAAO,CAAC,iBAAiB,CAAC,CAAwB;IAClD,OAAO,CAAC,SAAS,CAAS;IAEpB,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;YAkBrD,UAAU;YAOV,YAAY;IA6B1B,OAAO,CAAC,QAAQ;CAUjB;AAED;;;GAGG;AACH,wBAAsB,+BAA+B,CACnD,iBAAiB,EAAE,eAAe,EAAE,EACpC,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAepC;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,uBAAuB,EAAE,EACpC,aAAa,EAAE,OAAO,EACtB,eAAe,GAAE,eAAuB,GACvC,kBAAkB,CAuBpB"}

package/dist/core/route-planner.js

@@ -81,7 +81,7 @@ export async function collectProviderRuntimeSnapshots(registryProviders, hostSer
         return {
             provider,
             descriptor: toSharedPlannerDescriptor(descriptor),
-            capabilities: toSharedPlannerCapabilities(capabilities)
+            capabilities: toSharedPlannerCapabilities(capabilities, descriptor, provider)
         };
     }));
     return snapshots.sort((left, right) => left.descriptor.id.localeCompare(right.descriptor.id));
@@ -91,13 +91,14 @@ export async function collectProviderRuntimeSnapshots(registryProviders, hostSer
  * consumes, applying default constraints/preferences and the current network
  * state.
  */
-export function buildSharedPlannerInput(request, snapshots, networkOnline) {
+export function buildSharedPlannerInput(request, snapshots, networkOnline, interactionMode = "run") {
     const constraints = request.constraints ?? {};
     const preferences = request.preferences ?? {};
     return {
         task: {
             kind: request.task.kind
         },
+        interactionMode,
         constraints: {
             privacy: constraints.privacy ?? "cloud_allowed",
             cloud: constraints.cloud ?? "allowed",
@@ -118,8 +119,10 @@ function toSharedPlannerDescriptor(descriptor) {
         id: descriptor.id,
         type: descriptor.type,
         supports: {
-            run: descriptor.supports.run
+            run: descriptor.supports.run,
+            streaming: descriptor.supports.streaming
         },
+        cancel: descriptor.cancel,
         tasks: descriptor.tasks,
         ...(descriptor.privacy
             ? {
@@ -131,9 +134,30 @@ function toSharedPlannerDescriptor(descriptor) {
             : {})
     };
 }
-function toSharedPlannerCapabilities(capabilities) {
+/**
+ * Projects the dynamic capability snapshot for the planner.
+ *
+ * `stream()` being absent from the adapter is folded in here rather than
+ * filtered out downstream: an adapter that declares `supports.streaming` but
+ * never implemented the method is not streaming-capable, and saying so as a
+ * planner-visible reason is what lets the route explanation name the provider
+ * instead of silently dropping it.
+ */
+function toSharedPlannerCapabilities(capabilities, descriptor, provider) {
+    const declaresStreaming = capabilities.streamingAvailable ?? descriptor.supports.streaming;
+    const implementsStream = typeof provider.stream === "function";
+    const streamingAvailable = declaresStreaming && implementsStream;
+    const streamingUnavailableReason = capabilities.streamingUnavailableReason ??
+        (declaresStreaming && !implementsStream
+            ? `Provider '${descriptor.id}' declares streaming but does not implement stream().`
+            : undefined);
     return {
         available: capabilities.available,
-        ...(capabilities.reason ? { reason: capabilities.reason } : {})
+        ...(capabilities.reason ? { reason: capabilities.reason } : {}),
+        streamingAvailable,
+        ...(!streamingAvailable && streamingUnavailableReason ? { streamingUnavailableReason } : {}),
+        ...(capabilities.cancellationAvailable !== undefined
+            ? { cancellationAvailable: capabilities.cancellationAvailable }
+            : {})
     };
 }