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

package/dist/core/router.d.ts

@@ -2,7 +2,7 @@ import type { TaskRequest } from "@independo/inderun-contracts";
 import type { HostServices } from "./host.js";
 import type { ProviderAdapter } from "./provider.js";
 import type { ProviderRegistry } from "./registry.js";
-import { type RoutePlanner, type SharedPlannerRoutePlan, type WasmUnavailableReason } from "./route-planner.js";
+import { type InteractionMode, type RoutePlanner, type SharedPlannerRoutePlan, type WasmUnavailableReason } from "./route-planner.js";
 /**
  * Output structure from the Router containing the chosen provider and a route selection description.
  */
@@ -52,13 +52,47 @@ export declare class Router {
      *  - `CapabilityMismatch` when `execution === 'on_device'` but no local provider is registered or available.
      *  - `Offline` when `execution === 'cloud'` but the device lacks internet connectivity.
      *  - `Unavailable` when `execution === 'cloud'` but no cloud provider is registered or functional.
+     *
+     * The requested `interactionMode` is a planning input, not a post-filter: the
+     * shared planner rejects providers that cannot satisfy it and says why, so the
+     * whole returned chain is mode-compatible.
      */
-    selectRoute(request: TaskRequest, hostServices: HostServices): Promise<RouteSelection>;
+    selectRoute(request: TaskRequest, hostServices: HostServices, interactionMode?: InteractionMode): Promise<RouteSelection>;
     private selectFromSharedPlan;
     private selectFallbackRoute;
     private buildSelectionFromRoutePlan;
+    /**
+     * Hand-written mirror of the shared Rust planner (`rust/inderun-route-core/src/planner.rs`),
+     * used when the WASM core cannot be loaded. It reproduces the same rejection
+     * codes and messages so route explanations stay comparable across both paths.
+     *
+     * Known, deliberate divergence: this mirror keeps the id-sorted snapshot order
+     * instead of reproducing the Rust placement/preference ranks, so `optimizeFor`
+     * does not influence ordering here.
+     */
     private createFallbackPlan;
+    /**
+     * Mirrors `infer_failure_code` in the shared Rust planner. The offline class is
+     * derived from the rejection reasons rather than from the connectivity flag
+     * alone: an offline host whose only provider is local and non-streaming failed
+     * on capability, not on connectivity, and reporting `Offline` there would
+     * contradict the explanation shipped alongside it.
+     */
+    private inferFallbackFailureCode;
+    /**
+     * Mirrors `evaluate_provider` in the shared Rust planner: it accumulates every
+     * violated rule rather than short-circuiting, so a rejected provider carries a
+     * complete explanation. The streaming checks are ordered static-before-dynamic
+     * for the same reason as in Rust — a provider that never declared streaming
+     * must not also be reported as dynamically unavailable.
+     */
+    private evaluateFallbackCandidate;
     private buildFallbackFailureSummary;
+    /**
+     * Routing failure throws before any `route_decided` telemetry is emitted, so the
+     * plan's diagnostics are attached to the exception — that is the only channel
+     * through which a caller learns *why* each provider was rejected.
+     */
     private routePlanFailure;
 }
 //# sourceMappingURL=router.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/core/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAOtD,OAAO,EAIL,KAAK,YAAY,EAEjB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAE3B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,QAAQ,EAAE,eAAe,CAAC;IAC1B;;OAEG;IACH,iBAAiB,EAAE,eAAe,EAAE,CAAC;IACrC;;OAEG;IACH,SAAS,EAAE,sBAAsB,CAAC;IAClC;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,aAAa,EAAE,MAAM,GAAG,UAAU,CAAC;IACnC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,qBAAqB,CAAC;CAClD;AAED;;;;GAIG;AACH,qBAAa,MAAM;IAEf,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;gBADP,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,YAAqC;IAGxD;;;;;;;;;OASG;IACG,WAAW,CAAC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;IAc5F,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,mBAAmB;IAc3B,OAAO,CAAC,2BAA2B;IA2BnC,OAAO,CAAC,kBAAkB;IA0F1B,OAAO,CAAC,2BAA2B;IAiCnC,OAAO,CAAC,gBAAgB;CAYzB"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/core/router.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAOtD,OAAO,EAGL,KAAK,eAAe,EAEpB,KAAK,YAAY,EAEjB,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAE3B,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,QAAQ,EAAE,eAAe,CAAC;IAC1B;;OAEG;IACH,iBAAiB,EAAE,eAAe,EAAE,CAAC;IACrC;;OAEG;IACH,SAAS,EAAE,sBAAsB,CAAC;IAClC;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,aAAa,EAAE,MAAM,GAAG,UAAU,CAAC;IACnC;;;OAGG;IACH,wBAAwB,CAAC,EAAE,qBAAqB,CAAC;CAClD;AAED;;;;GAIG;AACH,qBAAa,MAAM;IAEf,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;gBADP,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,YAAqC;IAGxD;;;;;;;;;;;;;OAaG;IACG,WAAW,CACf,OAAO,EAAE,WAAW,EACpB,YAAY,EAAE,YAAY,EAC1B,eAAe,GAAE,eAAuB,GACvC,OAAO,CAAC,cAAc,CAAC;IAoB1B,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,mBAAmB;IAe3B,OAAO,CAAC,2BAA2B;IA2BnC;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;IAwE1B;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAsBhC;;;;;;OAMG;IACH,OAAO,CAAC,yBAAyB;IA4FjC,OAAO,CAAC,2BAA2B;IAyCnC;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;CAkBzB"}

package/dist/core/router.js

@@ -21,16 +21,20 @@ export class Router {
      *  - `CapabilityMismatch` when `execution === 'on_device'` but no local provider is registered or available.
      *  - `Offline` when `execution === 'cloud'` but the device lacks internet connectivity.
      *  - `Unavailable` when `execution === 'cloud'` but no cloud provider is registered or functional.
+     *
+     * The requested `interactionMode` is a planning input, not a post-filter: the
+     * shared planner rejects providers that cannot satisfy it and says why, so the
+     * whole returned chain is mode-compatible.
      */
-    async selectRoute(request, hostServices) {
+    async selectRoute(request, hostServices, interactionMode = "run") {
         const online = await hostServices.connectivity.isOnline();
         const snapshots = await collectProviderRuntimeSnapshots(this.registry.list(), hostServices);
-        const planInput = buildSharedPlannerInput(request, snapshots, online);
+        const planInput = buildSharedPlannerInput(request, snapshots, online, interactionMode);
         const outcome = await this.planner.planRoute(planInput);
         if (outcome.routePlan) {
             return this.selectFromSharedPlan(snapshots, outcome.routePlan);
         }
-        return this.selectFallbackRoute(request, snapshots, online, outcome.unavailableReason);
+        return this.selectFallbackRoute(request, snapshots, online, interactionMode, outcome.unavailableReason);
     }
     selectFromSharedPlan(snapshots, routePlan) {
         if (!routePlan.selectedProviderId) {
@@ -38,8 +42,8 @@ export class Router {
         }
         return this.buildSelectionFromRoutePlan(snapshots, routePlan, "wasm");
     }
-    selectFallbackRoute(request, snapshots, online, plannerUnavailableReason) {
-        const plan = this.createFallbackPlan(request, snapshots, online);
+    selectFallbackRoute(request, snapshots, online, interactionMode, plannerUnavailableReason) {
+        const plan = this.createFallbackPlan(request, snapshots, online, interactionMode);
         if (!plan.selectedProviderId) {
             throw this.routePlanFailure(plan);
         }
@@ -62,58 +66,48 @@ export class Router {
             ...(plannerUnavailableReason ? { plannerUnavailableReason } : {})
         };
     }
-    createFallbackPlan(request, snapshots, online) {
-        const planInput = buildSharedPlannerInput(request, snapshots, online);
-        const eligible = snapshots
-            .filter((candidate) => candidate.descriptor.tasks.includes(planInput.task.kind))
-            .filter((candidate) => candidate.descriptor.supports.run);
+    /**
+     * Hand-written mirror of the shared Rust planner (`rust/inderun-route-core/src/planner.rs`),
+     * used when the WASM core cannot be loaded. It reproduces the same rejection
+     * codes and messages so route explanations stay comparable across both paths.
+     *
+     * Known, deliberate divergence: this mirror keeps the id-sorted snapshot order
+     * instead of reproducing the Rust placement/preference ranks, so `optimizeFor`
+     * does not influence ordering here.
+     */
+    createFallbackPlan(request, snapshots, online, interactionMode) {
+        const planInput = buildSharedPlannerInput(request, snapshots, online, interactionMode);
+        const eligible = snapshots.filter((candidate) => candidate.descriptor.tasks.includes(planInput.task.kind));
         const localCandidates = eligible.filter((candidate) => candidate.descriptor.type !== "cloud");
         const cloudCandidates = eligible.filter((candidate) => candidate.descriptor.type === "cloud");
         // Constraint filtering must apply to the whole candidate list, not just the selected provider:
         // the remainder becomes the engine's fallback chain, and a fallback that violates the request
         // constraints would let a `local_required` run be retried against a cloud provider.
-        const admissible = eligible.filter((candidate) => {
-            const descriptor = candidate.descriptor;
-            const constraints = planInput.constraints;
-            // Mirrors `is_data_private` in the shared Rust planner: a provider is private when it
-            // declares that data does not leave the device, defaulting to non-cloud providers.
-            const isDataPrivate = descriptor.privacy
-                ? !descriptor.privacy.dataLeavesDevice
-                : descriptor.type !== "cloud";
-            if (constraints.cloud === "forbidden" && descriptor.type === "cloud") {
-                return false;
-            }
-            if (constraints.cloud === "required" && descriptor.type !== "cloud") {
-                return false;
-            }
-            if (constraints.privacy === "local_required" && !isDataPrivate) {
-                return false;
-            }
-            if (constraints.privacy === "cloud_required" && descriptor.type !== "cloud") {
-                return false;
+        const admissible = [];
+        const rejectedProviders = [];
+        for (const candidate of snapshots) {
+            const reasons = this.evaluateFallbackCandidate(candidate, planInput, interactionMode);
+            if (reasons.length === 0) {
+                admissible.push(candidate);
             }
-            if (!online && descriptor.type === "cloud") {
-                return false;
+            else {
+                rejectedProviders.push({ providerId: candidate.descriptor.id, reasons });
             }
-            return candidate.capabilities.available;
-        });
+        }
         if (admissible.length === 0) {
             const failureSummary = this.buildFallbackFailureSummary({
                 online,
+                interactionMode,
+                taskKind: planInput.task.kind,
                 constraints: planInput.constraints,
                 localCandidates,
                 cloudCandidates
             });
-            const failureCode = !online
-                ? "offline"
-                : planInput.constraints.cloud === "required" ||
-                    planInput.constraints.privacy === "cloud_required"
-                    ? "unavailable"
-                    : "capability_mismatch";
+            const failureCode = this.inferFallbackFailureCode(planInput, rejectedProviders);
             return {
                 fallbackProviderIds: [],
                 candidates: [],
-                rejectedProviders: [],
+                rejectedProviders,
                 failureCode,
                 explanation: {
                     summary: failureSummary
@@ -121,6 +115,9 @@ export class Router {
             };
         }
         const selectedProviderId = admissible[0]?.descriptor.id;
+        const summary = interactionMode === "stream"
+            ? `Selected streaming provider '${selectedProviderId}' deterministically from ${admissible.length} eligible candidate(s).`
+            : `Selected provider '${selectedProviderId}' deterministically from ${admissible.length} eligible candidate(s).`;
         return {
             selectedProviderId,
             fallbackProviderIds: admissible.slice(1).map((candidate) => candidate.descriptor.id),
@@ -128,13 +125,113 @@ export class Router {
                 providerId: candidate.descriptor.id,
                 order: index
             })),
-            rejectedProviders: [],
+            rejectedProviders,
             explanation: {
-                summary: `Selected provider '${selectedProviderId}' deterministically from ${admissible.length} eligible candidate(s).`,
+                summary,
                 selectedProviderId
             }
         };
     }
+    /**
+     * Mirrors `infer_failure_code` in the shared Rust planner. The offline class is
+     * derived from the rejection reasons rather than from the connectivity flag
+     * alone: an offline host whose only provider is local and non-streaming failed
+     * on capability, not on connectivity, and reporting `Offline` there would
+     * contradict the explanation shipped alongside it.
+     */
+    inferFallbackFailureCode(planInput, rejectedProviders) {
+        if (rejectedProviders.some((rejected) => rejected.reasons.some((reason) => reason.code === "offline"))) {
+            return "offline";
+        }
+        if (planInput.constraints.cloud === "required" ||
+            planInput.constraints.privacy === "cloud_required") {
+            return "unavailable";
+        }
+        return "capability_mismatch";
+    }
+    /**
+     * Mirrors `evaluate_provider` in the shared Rust planner: it accumulates every
+     * violated rule rather than short-circuiting, so a rejected provider carries a
+     * complete explanation. The streaming checks are ordered static-before-dynamic
+     * for the same reason as in Rust — a provider that never declared streaming
+     * must not also be reported as dynamically unavailable.
+     */
+    evaluateFallbackCandidate(candidate, planInput, interactionMode) {
+        const descriptor = candidate.descriptor;
+        const capabilities = candidate.capabilities;
+        const constraints = planInput.constraints;
+        const wantsStream = interactionMode === "stream";
+        const reasons = [];
+        // Mirrors `is_data_private` in the shared Rust planner: a provider is private when it
+        // declares that data does not leave the device, defaulting to non-cloud providers.
+        const isDataPrivate = descriptor.privacy
+            ? !descriptor.privacy.dataLeavesDevice
+            : descriptor.type !== "cloud";
+        if (!descriptor.tasks.includes(planInput.task.kind)) {
+            reasons.push({
+                code: "task_not_supported",
+                message: `Provider '${descriptor.id}' does not support task '${planInput.task.kind}'.`
+            });
+        }
+        if (!wantsStream && !descriptor.supports.run) {
+            reasons.push({
+                code: "run_not_supported",
+                message: `Provider '${descriptor.id}' does not support run().`
+            });
+        }
+        if (wantsStream) {
+            if (!descriptor.supports.streaming) {
+                reasons.push({
+                    code: "streaming_not_supported",
+                    message: `Provider '${descriptor.id}' does not support streaming (Mode 2).`
+                });
+            }
+            else if (capabilities.streamingAvailable === false) {
+                reasons.push({
+                    code: "streaming_unavailable",
+                    message: capabilities.streamingUnavailableReason ??
+                        `Provider '${descriptor.id}' cannot stream in the current host environment.`
+                });
+            }
+        }
+        if (constraints.privacy === "local_required" && !isDataPrivate) {
+            reasons.push({
+                code: "privacy_constraint",
+                message: `Provider '${descriptor.id}' does not satisfy local-required privacy.`
+            });
+        }
+        if (constraints.privacy === "cloud_required" && descriptor.type !== "cloud") {
+            reasons.push({
+                code: "privacy_constraint",
+                message: `Provider '${descriptor.id}' does not satisfy cloud-required privacy.`
+            });
+        }
+        if (constraints.cloud === "forbidden" && descriptor.type === "cloud") {
+            reasons.push({
+                code: "cloud_constraint",
+                message: `Provider '${descriptor.id}' is cloud-based but cloud execution is forbidden.`
+            });
+        }
+        if (constraints.cloud === "required" && descriptor.type !== "cloud") {
+            reasons.push({
+                code: "cloud_constraint",
+                message: `Provider '${descriptor.id}' is not cloud-based but cloud execution is required.`
+            });
+        }
+        if (constraints.networkOnline === false && descriptor.type === "cloud") {
+            reasons.push({
+                code: "offline",
+                message: `Provider '${descriptor.id}' requires cloud connectivity, but the host is offline.`
+            });
+        }
+        if (!capabilities.available) {
+            reasons.push({
+                code: "capability_unavailable",
+                message: capabilities.reason ?? `Provider '${descriptor.id}' is currently unavailable.`
+            });
+        }
+        return reasons;
+    }
     buildFallbackFailureSummary(input) {
         const wantsCloud = input.constraints.cloud === "required" || input.constraints.privacy === "cloud_required";
         const wantsLocal = input.constraints.privacy === "local_required";
@@ -153,18 +250,34 @@ export class Router {
             }
             return "No on-device provider is currently available.";
         }
+        if (input.interactionMode === "stream") {
+            // Kept verbatim in sync with the shared Rust planner's stream-mode failure
+            // summary so the message a caller sees does not depend on which planner ran.
+            return `No provider capable of streaming was found for task '${input.taskKind}'.`;
+        }
         return "No eligible provider found for the current routing constraints.";
     }
+    /**
+     * Routing failure throws before any `route_decided` telemetry is emitted, so the
+     * plan's diagnostics are attached to the exception — that is the only channel
+     * through which a caller learns *why* each provider was rejected.
+     */
     routePlanFailure(routePlan) {
         const message = routePlan.explanation.summary;
+        const details = {
+            details: {
+                failureCode: routePlan.failureCode,
+                rejectedProviders: routePlan.rejectedProviders
+            }
+        };
         switch (routePlan.failureCode) {
             case "offline":
-                throw createOffline(message);
+                throw createOffline(message, details);
             case "unavailable":
-                throw createUnavailable(message);
+                throw createUnavailable(message, details);
             case "capability_mismatch":
             default:
-                throw createCapabilityMismatch(message);
+                throw createCapabilityMismatch(message, details);
         }
     }
 }

package/dist/core/sse.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A single dispatched server-sent event.
+ *
+ * `event` and `id` are `undefined` when the stream did not carry those fields.
+ * `data` is the accumulated data payload with its trailing newline removed, and
+ * is passed through verbatim — sentinels such as OpenAI's `[DONE]` are the
+ * caller's concern, not the framing layer's.
+ */
+export interface SseEvent {
+    event?: string;
+    data: string;
+    id?: string;
+}
+/**
+ * Frames a raw byte stream into server-sent events.
+ *
+ * Follows the WHATWG server-sent events stream parsing rules, minus
+ * reconnection: `retry` is parsed as a field and ignored, and there is no
+ * Last-Event-ID reconnect logic. Concretely that means:
+ *
+ * - lines end with LF, CRLF, or bare CR;
+ * - a line beginning with `:` is a comment (servers send these as keep-alives);
+ * - `field: value` strips exactly one leading space from the value, and a line
+ *   with no colon is that field with an empty value;
+ * - `data` fields accumulate, joined by newlines;
+ * - a blank line dispatches the accumulated event, or resets without
+ *   dispatching if no data was accumulated;
+ * - a stream that ends mid-event does **not** dispatch the partial event, since
+ *   a truncated event must never be reported as a complete one.
+ *
+ * Chunk boundaries are meaningless: this decodes incrementally (`stream: true`)
+ * so a boundary may fall inside a multi-byte UTF-8 sequence or mid-line.
+ *
+ * Held to `contracts/fixtures/streaming/sse-framing.json` together with the
+ * Swift and Kotlin implementations of the same protocol.
+ *
+ * @param chunks - Raw response body chunks, in arrival order.
+ */
+export declare function parseSseStream(chunks: AsyncIterable<Uint8Array>): AsyncGenerator<SseEvent>;
+//# sourceMappingURL=sse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../src/core/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAuB,cAAc,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,cAAc,CAAC,QAAQ,CAAC,CAsFjG"}

package/dist/core/sse.js

@@ -0,0 +1,118 @@
+/**
+ * Frames a raw byte stream into server-sent events.
+ *
+ * Follows the WHATWG server-sent events stream parsing rules, minus
+ * reconnection: `retry` is parsed as a field and ignored, and there is no
+ * Last-Event-ID reconnect logic. Concretely that means:
+ *
+ * - lines end with LF, CRLF, or bare CR;
+ * - a line beginning with `:` is a comment (servers send these as keep-alives);
+ * - `field: value` strips exactly one leading space from the value, and a line
+ *   with no colon is that field with an empty value;
+ * - `data` fields accumulate, joined by newlines;
+ * - a blank line dispatches the accumulated event, or resets without
+ *   dispatching if no data was accumulated;
+ * - a stream that ends mid-event does **not** dispatch the partial event, since
+ *   a truncated event must never be reported as a complete one.
+ *
+ * Chunk boundaries are meaningless: this decodes incrementally (`stream: true`)
+ * so a boundary may fall inside a multi-byte UTF-8 sequence or mid-line.
+ *
+ * Held to `contracts/fixtures/streaming/sse-framing.json` together with the
+ * Swift and Kotlin implementations of the same protocol.
+ *
+ * @param chunks - Raw response body chunks, in arrival order.
+ */
+export async function* parseSseStream(chunks) {
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    let eventType;
+    let data;
+    let id;
+    const takeEvent = () => {
+        const dispatched = data === undefined ? undefined : buildEvent(eventType, data, id);
+        eventType = undefined;
+        data = undefined;
+        id = undefined;
+        return dispatched;
+    };
+    const handleLine = (line) => {
+        if (line.length === 0)
+            return takeEvent();
+        if (line.startsWith(":"))
+            return undefined;
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        let value = colon === -1 ? "" : line.slice(colon + 1);
+        if (value.startsWith(" "))
+            value = value.slice(1);
+        switch (field) {
+            case "event":
+                eventType = value;
+                break;
+            case "data":
+                data = data === undefined ? value : `${data}\n${value}`;
+                break;
+            case "id":
+                // Per the SSE spec an id containing a NUL is ignored outright.
+                if (!value.includes("\0"))
+                    id = value;
+                break;
+            default:
+                // `retry` and anything unrecognized are dropped rather than erroring.
+                break;
+        }
+        return undefined;
+    };
+    for await (const chunk of chunks) {
+        buffer += decoder.decode(chunk, { stream: true });
+        for (;;) {
+            const line = takeLine();
+            if (line === undefined)
+                break;
+            const dispatched = handleLine(line);
+            if (dispatched)
+                yield dispatched;
+        }
+    }
+    // A trailing bare CR is ambiguous until the stream ends: it could still have
+    // been the first half of a CRLF.
+    buffer += decoder.decode();
+    for (;;) {
+        const line = takeLine(true);
+        if (line === undefined)
+            break;
+        const dispatched = handleLine(line);
+        if (dispatched)
+            yield dispatched;
+    }
+    function takeLine(atEnd = false) {
+        for (let index = 0; index < buffer.length; index += 1) {
+            const char = buffer[index];
+            if (char === "\n") {
+                const line = buffer.slice(0, index);
+                buffer = buffer.slice(index + 1);
+                return line;
+            }
+            if (char === "\r") {
+                const isLast = index === buffer.length - 1;
+                // Withhold a trailing CR until we know whether an LF follows, unless
+                // the stream is over and no LF can arrive.
+                if (isLast && !atEnd)
+                    return undefined;
+                const skip = buffer[index + 1] === "\n" ? 2 : 1;
+                const line = buffer.slice(0, index);
+                buffer = buffer.slice(index + skip);
+                return line;
+            }
+        }
+        return undefined;
+    }
+}
+function buildEvent(eventType, data, id) {
+    return {
+        ...(eventType !== undefined ? { event: eventType } : {}),
+        data,
+        ...(id !== undefined ? { id } : {})
+    };
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { type ConnectivityService, type DeviceConstraintsService, type SecureStorageService, type ClockService, type HttpClientService, type HttpRequest, type HttpResponse, type HostServices, type ThermalState } from "./core/host.js";
-export { type ProviderDescriptor, type ProviderDynamicCapabilities, type ProviderCapabilitySnapshot, type RunContext, type ProviderAdapter, type ProviderStreamContext, type ProviderStreamEvent } from "./core/provider.js";
+export { type AbortSignalLike, type ConnectivityService, type DeviceConstraintsService, type SecureStorageService, type ClockService, type HttpClientService, type HttpRequest, type HttpResponse, type HttpStreamResponse, type HttpStreamingClientService, type HostServices, type ThermalState } from "./core/host.js";
+export { type ProviderDescriptor, type ProviderDynamicCapabilities, type ProviderCapabilitySnapshot, type RunContext, type ProviderAdapter, type ProviderStreamContext, type ProviderStreamEvent, type StreamRun } from "./core/provider.js";
 export { EventGate } from "./core/event-gate.js";
 export { ProviderRegistry } from "./core/registry.js";
 export { type RouteSelection, Router } from "./core/router.js";
@@ -8,6 +8,6 @@ export { type IndeRunExceptionParams, IndeRunException, createCapabilityMismatch
 export { IndeRun, type StreamHandleResult } from "./core/engine.js";
 export type { IndeRunApi } from "./core/generated/inderun-api.js";
 export { type TelemetryEventType, type TelemetryEvent, type TelemetryService, NoOpTelemetryService } from "./core/telemetry.js";
-export { BrowserConnectivityService, FetchHttpClient, SystemClockService, createBrowserHostServices, type CreateBrowserHostServicesOptions, type FetchHttpClientOptions } from "./core/browser-host.js";
+export { BrowserConnectivityService, FetchHttpClient, FetchStreamingHttpClient, SystemClockService, createBrowserHostServices, type CreateBrowserHostServicesOptions, type FetchHttpClientOptions } from "./core/browser-host.js";
 export { createIndeRunWeb, type CreateIndeRunWebOptions } from "./web-sdk.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,wBAAwB,EACxB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACpE,YAAY,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACf,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC3B,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,KAAK,sBAAsB,EAC3B,gBAAgB,EAChB,wBAAwB,EACxB,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACpE,YAAY,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAElE,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,0BAA0B,EAC1B,eAAe,EACf,wBAAwB,EACxB,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,gCAAgC,EACrC,KAAK,sBAAsB,EAC5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -7,7 +7,7 @@ export { WasmRoutePlanner } from "./core/route-planner.js";
 export { IndeRunException, createCapabilityMismatch, createOffline, createAuthError, createRateLimited, createTimeout, createUnavailable, createInternal, toIndeRunException } from "./core/errors.js";
 export { IndeRun } from "./core/engine.js";
 export { NoOpTelemetryService } from "./core/telemetry.js";
-export { BrowserConnectivityService, FetchHttpClient, SystemClockService, createBrowserHostServices } from "./core/browser-host.js";
+export { BrowserConnectivityService, FetchHttpClient, FetchStreamingHttpClient, SystemClockService, createBrowserHostServices } from "./core/browser-host.js";
 export { createIndeRunWeb } from "./web-sdk.js";
 // The OpenAI Responses adapter is provider-specific and intentionally excluded
 // from this unified index. Import it from "@independo/inderun-web/openai".

package/dist/providers/openai/provider.d.ts

@@ -1,6 +1,6 @@
 import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
 import type { HostServices } from "../../core/host.js";
-import type { ProviderAdapter, ProviderDescriptor, ProviderDynamicCapabilities, RunContext } from "../../core/provider.js";
+import type { ProviderAdapter, ProviderDescriptor, ProviderDynamicCapabilities, ProviderStreamContext, ProviderStreamEvent, RunContext } from "../../core/provider.js";
 export declare const DEFAULT_OPENAI_RESPONSES_ENDPOINT = "https://api.openai.com/v1/responses";
 /**
  * Configuration for the OpenAI Responses provider.
@@ -84,6 +84,49 @@ export declare class OpenAIResponsesProvider implements ProviderAdapter {
      * @throws IndeRunException mapped to the standard error taxonomy.
      */
     run(request: TaskRequest, context: RunContext): Promise<TaskResult>;
+    /**
+     * Executes a normalized text-to-text task in Mode 2 against the OpenAI
+     * Responses API's server-sent event stream.
+     *
+     * The request is the Mode 1 body plus `"stream": true`, so both modes stay a
+     * single code path up to the transport. The response head is classified
+     * before the body is read: a non-2xx is drained to text and run through the
+     * same `mapHttpError` as Mode 1, because a 429 must surface as RateLimited
+     * rather than as a malformed event stream.
+     *
+     * Event mapping, from the Responses API's typed SSE events to the canonical
+     * provider vocabulary:
+     *
+     * - `response.output_text.delta` becomes a delta;
+     * - `response.completed` and `response.incomplete` become the terminal done,
+     *   with `finalText`, `usage`, and `finishReason` read off the embedded
+     *   response object by the same helpers Mode 1 uses — it has the same shape;
+     * - `response.failed` and `error` become a terminal error;
+     * - every other event type is ignored, since the set is open and additive.
+     *
+     * @param request - Canonical IndeRun task request.
+     * @param context - Engine stream context: run id, host services, abort signal.
+     */
+    stream(request: TaskRequest, context: ProviderStreamContext): AsyncGenerator<ProviderStreamEvent>;
+    /**
+     * Maps a `response.failed` / `error` stream event onto the error taxonomy.
+     * These arrive over an HTTP 200 body, so there is no status code to classify
+     * from; OpenAI reports rate limiting and auth failures here with the same
+     * `code` values it uses in unary error bodies.
+     *
+     * Two payload shapes exist and both are accepted: the standalone `error`
+     * event carries `code`/`message` at its root, while `response.failed` nests
+     * them under `response.error`. The root `type` is the event name rather than
+     * an error type, so it is never read as one.
+     */
+    private mapStreamError;
+    /**
+     * Resolves the request headers, including the bearer token behind
+     * `authContextRef`. Shared by `run` and `stream`: the credential never travels
+     * in the request payload, only the slot id does, so both modes must resolve it
+     * the same way.
+     */
+    private resolveHeaders;
     private createRequestBody;
     /**
      * Maps an OpenAI HTTP error response onto the IndeRun error taxonomy:

package/dist/providers/openai/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/providers/openai/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ5E,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,2BAA2B,EAC3B,UAAU,EACX,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,iCAAiC,wCAAwC,CAAC;AAKvF;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IACjC;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAwBD;;;;;;GAMG;AACH,qBAAa,uBAAwB,YAAW,eAAe;IAUjD,OAAO,CAAC,QAAQ,CAAC,OAAO;IATpC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IACjD,OAAO,CAAC,YAAY,CAAC,CAA6D;IAElF;;;OAGG;gBAC0B,OAAO,EAAE,qBAAqB;IAM3D;;OAEG;IACH,QAAQ,IAAI,kBAAkB;IAsB9B;;;;;;;;OAQG;IACG,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,CAAC;YAkB9D,sBAAsB;IAuCpC;;;;;;OAMG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAkHzE,OAAO,CAAC,iBAAiB;IAuBzB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;CAmErB"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/providers/openai/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ5E,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,2BAA2B,EAC3B,qBAAqB,EACrB,mBAAmB,EACnB,UAAU,EACX,MAAM,wBAAwB,CAAC;AA4BhC,eAAO,MAAM,iCAAiC,wCAAwC,CAAC;AAKvF;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IACjC;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AA6BD;;;;;;GAMG;AACH,qBAAa,uBAAwB,YAAW,eAAe;IAUjD,OAAO,CAAC,QAAQ,CAAC,OAAO;IATpC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IACjD,OAAO,CAAC,YAAY,CAAC,CAA6D;IAElF;;;OAGG;gBAC0B,OAAO,EAAE,qBAAqB;IAM3D;;OAEG;IACH,QAAQ,IAAI,kBAAkB;IAuB9B;;;;;;;;OAQG;IACG,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,CAAC;YA+B9D,sBAAsB;IAuCpC;;;;;;OAMG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAiFzE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,MAAM,CACX,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAAC,mBAAmB,CAAC;IAiGtC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;IAmBtB;;;;;OAKG;YACW,cAAc;IA2C5B,OAAO,CAAC,iBAAiB;IA2BzB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;CAmErB"}