@independo/inderun-web 0.1.0

package/dist/provider.d.ts

@@ -0,0 +1,118 @@
+import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
+import type { HostServices } from "./host.js";
+/**
+ * Static metadata descriptor defining the capabilities, requirements, and constraints
+ * of a provider. This is used by the routing engine and Router to select candidate providers.
+ */
+export interface ProviderDescriptor {
+    /**
+     * Unique identifier of the provider (e.g., 'openai', 'apple-foundation-models').
+     */
+    id: string;
+    /**
+     * Execution target type: 'local' (on-device), 'edge', or 'cloud'.
+     */
+    type: "local" | "edge" | "cloud";
+    /**
+     * Connection transport layer protocol.
+     */
+    transport: "in_process" | "system_service" | "http" | "sse" | "realtime";
+    /**
+     * Optional streaming style, if token or chunk streaming is supported.
+     */
+    streamingStyle?: "tokens" | "chunks" | "snapshots";
+    /**
+     * Flags representing the features and modes supported by this provider.
+     */
+    supports: {
+        /** Whether the provider supports Mode 1 run (request/response). */
+        run: boolean;
+        /** Whether the provider supports Mode 2 stream. */
+        streaming: boolean;
+        /** Whether the provider supports Mode 3 realtime session. */
+        realtime: boolean;
+        /** Whether the provider supports tool calling definition. */
+        tools: boolean;
+        /** Whether the provider outputs reasoning events alongside contents. */
+        reasoningEvents: boolean;
+        /** Whether the provider supports structured outputs (JSON schema constraints). */
+        structuredOutput: boolean;
+        /** Whether the provider supports multimodal inputs (images, audio, etc.). */
+        multimodal: boolean;
+    };
+    /**
+     * Cancellation capabilities support:
+     * - 'hard': fully stops processing and interrupts remote operations.
+     * - 'soft': stops reading the stream locally, but the remote execution continues.
+     * - 'none': cancellation is unsupported.
+     */
+    cancel: "hard" | "soft" | "none";
+    /**
+     * List of supported task kinds (e.g., 'text_to_text', 'embeddings').
+     */
+    tasks: string[];
+    /**
+     * Optional input/output resource boundaries.
+     */
+    limits?: {
+        maxInputTokens?: number;
+        maxOutputTokens?: number;
+        maxImageBytes?: number;
+        maxAudioSeconds?: number;
+    };
+    /**
+     * Privacy settings regarding data egress.
+     */
+    privacy?: {
+        /** Set to true if the model input leaves the host device. */
+        dataLeavesDevice: boolean;
+        /** Geographic regions where the cloud service executes. */
+        regions?: string[];
+    };
+}
+/**
+ * Dynamic capability snapshot evaluated at runtime.
+ */
+export interface ProviderDynamicCapabilities {
+    /**
+     * Whether the provider is available and functional on the host device now.
+     */
+    available: boolean;
+    /**
+     * Detail message if availability check fails.
+     */
+    reason?: string;
+}
+/**
+ * Execution context passed to provider run commands.
+ */
+export interface RunContext {
+    /**
+     * Unique execution run ID.
+     */
+    runId: string;
+    /**
+     * Host service boundary for provider adapters. Cloud adapters use this to
+     * resolve authContextRef through secure storage and dispatch HTTP requests.
+     */
+    hostServices: HostServices;
+}
+/**
+ * Pluggable execution adapter contract that wraps a specific model runtime
+ * (system frameworks, local runtimes, or cloud APIs) and exposes normalized APIs.
+ */
+export interface ProviderAdapter {
+    /**
+     * Returns static provider descriptor metadata.
+     */
+    describe(): ProviderDescriptor;
+    /**
+     * Performs dynamic capability check to determine if the provider can execute now.
+     */
+    capabilities(host: HostServices): Promise<ProviderDynamicCapabilities>;
+    /**
+     * Executes a task request in Mode 1 (request/response).
+     */
+    run(req: TaskRequest, ctx: RunContext): Promise<TaskResult>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;IACjC;;OAEG;IACH,SAAS,EAAE,YAAY,GAAG,gBAAgB,GAAG,MAAM,GAAG,KAAK,GAAG,UAAU,CAAC;IACzE;;OAEG;IACH,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAC;IAEnD;;OAEG;IACH,QAAQ,EAAE;QACR,mEAAmE;QACnE,GAAG,EAAE,OAAO,CAAC;QACb,mDAAmD;QACnD,SAAS,EAAE,OAAO,CAAC;QACnB,6DAA6D;QAC7D,QAAQ,EAAE,OAAO,CAAC;QAClB,6DAA6D;QAC7D,KAAK,EAAE,OAAO,CAAC;QACf,wEAAwE;QACxE,eAAe,EAAE,OAAO,CAAC;QACzB,kFAAkF;QAClF,gBAAgB,EAAE,OAAO,CAAC;QAC1B,6EAA6E;QAC7E,UAAU,EAAE,OAAO,CAAC;KACrB,CAAC;IAEF;;;;;OAKG;IACH,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAEjC;;OAEG;IACH,KAAK,EAAE,MAAM,EAAE,CAAC;IAEhB;;OAEG;IACH,MAAM,CAAC,EAAE;QACP,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;IAEF;;OAEG;IACH,OAAO,CAAC,EAAE;QACR,6DAA6D;QAC7D,gBAAgB,EAAE,OAAO,CAAC;QAC1B,2DAA2D;QAC3D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,QAAQ,IAAI,kBAAkB,CAAC;IAC/B;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACvE;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;CAC7D"}

package/dist/provider.js

@@ -0,0 +1 @@
+export {};

package/dist/registry.d.ts

@@ -0,0 +1,29 @@
+import type { ProviderAdapter } from "./provider.js";
+/**
+ * Registry class that holds and manages all active ProviderAdapter instances.
+ * Loaded adapters are queried by the Router to choose appropriate routes.
+ */
+export declare class ProviderRegistry {
+    private providers;
+    /**
+     * Registers a provider adapter in the registry.
+     * @param provider - The provider adapter instance to register.
+     * @throws {Error} If the provider does not have a valid ID.
+     * @throws {Error} If another provider is already registered with the same ID.
+     */
+    register(provider: ProviderAdapter): void;
+    /**
+     * Retrieves a registered provider by its ID.
+     * @param id - Unique provider identifier.
+     */
+    get(id: string): ProviderAdapter | undefined;
+    /**
+     * Returns a list of all registered provider adapters.
+     */
+    list(): ProviderAdapter[];
+    /**
+     * Clears all registered providers.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;GAGG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,SAAS,CAAsC;IAEvD;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IAWzC;;;OAGG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI5C;;OAEG;IACH,IAAI,IAAI,eAAe,EAAE;IAIzB;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd"}

package/dist/registry.js

@@ -0,0 +1,42 @@
+/**
+ * Registry class that holds and manages all active ProviderAdapter instances.
+ * Loaded adapters are queried by the Router to choose appropriate routes.
+ */
+export class ProviderRegistry {
+    providers = new Map();
+    /**
+     * Registers a provider adapter in the registry.
+     * @param provider - The provider adapter instance to register.
+     * @throws {Error} If the provider does not have a valid ID.
+     * @throws {Error} If another provider is already registered with the same ID.
+     */
+    register(provider) {
+        const descriptor = provider.describe();
+        if (!descriptor.id) {
+            throw new Error("Provider must have a non-empty ID.");
+        }
+        if (this.providers.has(descriptor.id)) {
+            throw new Error(`Provider with ID "${descriptor.id}" is already registered.`);
+        }
+        this.providers.set(descriptor.id, provider);
+    }
+    /**
+     * Retrieves a registered provider by its ID.
+     * @param id - Unique provider identifier.
+     */
+    get(id) {
+        return this.providers.get(id);
+    }
+    /**
+     * Returns a list of all registered provider adapters.
+     */
+    list() {
+        return Array.from(this.providers.values());
+    }
+    /**
+     * Clears all registered providers.
+     */
+    clear() {
+        this.providers.clear();
+    }
+}

package/dist/route-planner.d.ts

@@ -0,0 +1,54 @@
+import type { RoutePlan as SharedPlannerRoutePlan, RoutePlannerInput as SharedPlannerInput, TaskRequest } from "@independo/inderun-contracts";
+import type { HostServices } from "./host.js";
+import type { ProviderAdapter } from "./provider.js";
+export type { SharedPlannerInput, SharedPlannerRoutePlan };
+/**
+ * Minimal shape of the shared route-core module (the WASM wrapper), used to
+ * plan routes via JSON in/JSON out. `initSharedCore` initializes the WASM
+ * bindings when present.
+ */
+export interface SharedPlannerModule {
+    initSharedCore?: () => Promise<void>;
+    planRouteJson: (inputJson: string) => string | Promise<string>;
+}
+/**
+ * Strategy that turns planner input into a deterministic route plan, or `null`
+ * when the planner is unavailable (callers then fall back to local selection).
+ */
+export interface RoutePlanner {
+    planRoute(input: SharedPlannerInput): Promise<SharedPlannerRoutePlan | null>;
+}
+/**
+ * A provider paired with the descriptor/capability projection the shared route
+ * planner consumes.
+ */
+export interface ProviderRuntimeSnapshot {
+    provider: ProviderAdapter;
+    descriptor: SharedPlannerInput["providers"][number]["descriptor"];
+    capabilities: SharedPlannerInput["providers"][number]["capabilities"];
+}
+/**
+ * {@link RoutePlanner} backed by the Rust route core compiled to WASM. The
+ * module is imported lazily and memoized; if it cannot be loaded, `planRoute`
+ * resolves to `null` so the engine can fall back to local selection.
+ */
+export declare class WasmRoutePlanner implements RoutePlanner {
+    private readonly moduleSpecifier;
+    private modulePromise?;
+    constructor(moduleSpecifier?: string);
+    planRoute(input: SharedPlannerInput): Promise<SharedPlannerRoutePlan | null>;
+    private loadModule;
+    private importModule;
+}
+/**
+ * Describes each provider and evaluates its dynamic capabilities against the
+ * host, returning snapshots sorted by provider id for deterministic planning.
+ */
+export declare function collectProviderRuntimeSnapshots(registryProviders: ProviderAdapter[], hostServices: HostServices): Promise<ProviderRuntimeSnapshot[]>;
+/**
+ * Assembles the normalized {@link SharedPlannerInput} the shared route core
+ * consumes, applying default constraints/preferences and the current network
+ * state.
+ */
+export declare function buildSharedPlannerInput(request: TaskRequest, snapshots: ProviderRuntimeSnapshot[], networkOnline: boolean): SharedPlannerInput;
+//# sourceMappingURL=route-planner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"route-planner.d.ts","sourceRoot":"","sources":["../src/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;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAC;CAC9E;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;AAID;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,YAAY;IAGvC,OAAO,CAAC,QAAQ,CAAC,eAAe;IAF5C,OAAO,CAAC,aAAa,CAAC,CAAsC;gBAE/B,eAAe,GAAE,MAA+B;IAEvE,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC;YAWpE,UAAU;YAOV,YAAY;CAiB3B;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"}

package/dist/route-planner.js

@@ -0,0 +1,110 @@
+const DEFAULT_WASM_SPECIFIER = "@independo/inderun-route-core-wasm";
+/**
+ * {@link RoutePlanner} backed by the Rust route core compiled to WASM. The
+ * module is imported lazily and memoized; if it cannot be loaded, `planRoute`
+ * resolves to `null` so the engine can fall back to local selection.
+ */
+export class WasmRoutePlanner {
+    moduleSpecifier;
+    modulePromise;
+    constructor(moduleSpecifier = DEFAULT_WASM_SPECIFIER) {
+        this.moduleSpecifier = moduleSpecifier;
+    }
+    async planRoute(input) {
+        const module = await this.loadModule();
+        if (!module) {
+            return null;
+        }
+        const json = JSON.stringify(input);
+        const result = await module.planRouteJson(json);
+        return JSON.parse(result);
+    }
+    async loadModule() {
+        if (!this.modulePromise) {
+            this.modulePromise = this.importModule();
+        }
+        return this.modulePromise;
+    }
+    async importModule() {
+        try {
+            const mod = (await import(/* @vite-ignore */ this.moduleSpecifier));
+            if (mod.initSharedCore) {
+                await mod.initSharedCore();
+            }
+            if (typeof mod.planRouteJson !== "function") {
+                return null;
+            }
+            return mod;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Describes each provider and evaluates its dynamic capabilities against the
+ * host, returning snapshots sorted by provider id for deterministic planning.
+ */
+export async function collectProviderRuntimeSnapshots(registryProviders, hostServices) {
+    const snapshots = await Promise.all(registryProviders.map(async (provider) => {
+        const descriptor = provider.describe();
+        const capabilities = await provider.capabilities(hostServices);
+        return {
+            provider,
+            descriptor: toSharedPlannerDescriptor(descriptor),
+            capabilities: toSharedPlannerCapabilities(capabilities)
+        };
+    }));
+    return snapshots.sort((left, right) => left.descriptor.id.localeCompare(right.descriptor.id));
+}
+/**
+ * Assembles the normalized {@link SharedPlannerInput} the shared route core
+ * consumes, applying default constraints/preferences and the current network
+ * state.
+ */
+export function buildSharedPlannerInput(request, snapshots, networkOnline) {
+    const constraints = request.constraints ?? {};
+    const preferences = request.preferences ?? {};
+    return {
+        task: {
+            kind: request.task.kind
+        },
+        constraints: {
+            privacy: constraints.privacy ?? "cloud_allowed",
+            cloud: constraints.cloud ?? "allowed",
+            networkOnline,
+            ...(constraints.timeoutMs !== undefined ? { timeoutMs: constraints.timeoutMs } : {})
+        },
+        preferences: {
+            optimizeFor: preferences.optimizeFor ?? "balanced"
+        },
+        providers: snapshots.map((snapshot) => ({
+            descriptor: snapshot.descriptor,
+            capabilities: snapshot.capabilities
+        }))
+    };
+}
+function toSharedPlannerDescriptor(descriptor) {
+    return {
+        id: descriptor.id,
+        type: descriptor.type,
+        supports: {
+            run: descriptor.supports.run
+        },
+        tasks: descriptor.tasks,
+        ...(descriptor.privacy
+            ? {
+                privacy: {
+                    dataLeavesDevice: descriptor.privacy.dataLeavesDevice,
+                    ...(descriptor.privacy.regions ? { regions: descriptor.privacy.regions } : {})
+                }
+            }
+            : {})
+    };
+}
+function toSharedPlannerCapabilities(capabilities) {
+    return {
+        available: capabilities.available,
+        ...(capabilities.reason ? { reason: capabilities.reason } : {})
+    };
+}

package/dist/router.d.ts

@@ -0,0 +1,54 @@
+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 } from "./route-planner.js";
+/**
+ * Output structure from the Router containing the chosen provider and a route selection description.
+ */
+export interface RouteSelection {
+    /**
+     * The selected provider adapter to run.
+     */
+    provider: ProviderAdapter;
+    /**
+     * Ordered fallback providers to try if the primary provider fails before producing a final result.
+     */
+    fallbackProviders: ProviderAdapter[];
+    /**
+     * The shared route plan used to select this provider chain.
+     */
+    routePlan: SharedPlannerRoutePlan;
+    /**
+     * Explanation detailing the selection decision. Useful for debugging and telemetry.
+     */
+    explanation: string;
+}
+/**
+ * Routing engine module. Filters registered providers against task types, request constraints,
+ * and dynamic host capabilities (such as connectivity and battery/thermal constraints)
+ * to output deterministic execution pathways.
+ */
+export declare class Router {
+    private registry;
+    private planner;
+    constructor(registry: ProviderRegistry, planner?: RoutePlanner);
+    /**
+     * Selects an optimal and compatible execution provider based on the task request and host conditions.
+     * @param request - The canonical task request payload.
+     * @param hostServices - Host services containing network status and hardware indicators.
+     * @returns Resolves to the selected RouteSelection object.
+     * @throws {IndeRunException} Under the following routing failure rules:
+     *  - `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.
+     */
+    selectRoute(request: TaskRequest, hostServices: HostServices): Promise<RouteSelection>;
+    private selectFromSharedPlan;
+    private selectFallbackRoute;
+    private buildSelectionFromRoutePlan;
+    private createFallbackPlan;
+    private buildFallbackFailureSummary;
+    private routePlanFailure;
+}
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/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,EAE5B,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;CACrB;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;IAa3B,OAAO,CAAC,2BAA2B;IAuBnC,OAAO,CAAC,kBAAkB;IAuF1B,OAAO,CAAC,2BAA2B;IAiCnC,OAAO,CAAC,gBAAgB;CAYzB"}

package/dist/router.js

@@ -0,0 +1,164 @@
+import { createCapabilityMismatch, createInternal, createOffline, createUnavailable } from "./errors.js";
+import { buildSharedPlannerInput, collectProviderRuntimeSnapshots, WasmRoutePlanner } from "./route-planner.js";
+/**
+ * Routing engine module. Filters registered providers against task types, request constraints,
+ * and dynamic host capabilities (such as connectivity and battery/thermal constraints)
+ * to output deterministic execution pathways.
+ */
+export class Router {
+    registry;
+    planner;
+    constructor(registry, planner = new WasmRoutePlanner()) {
+        this.registry = registry;
+        this.planner = planner;
+    }
+    /**
+     * Selects an optimal and compatible execution provider based on the task request and host conditions.
+     * @param request - The canonical task request payload.
+     * @param hostServices - Host services containing network status and hardware indicators.
+     * @returns Resolves to the selected RouteSelection object.
+     * @throws {IndeRunException} Under the following routing failure rules:
+     *  - `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.
+     */
+    async selectRoute(request, hostServices) {
+        const online = await hostServices.connectivity.isOnline();
+        const snapshots = await collectProviderRuntimeSnapshots(this.registry.list(), hostServices);
+        const planInput = buildSharedPlannerInput(request, snapshots, online);
+        const routePlan = await this.planner.planRoute(planInput);
+        if (routePlan) {
+            return this.selectFromSharedPlan(snapshots, routePlan);
+        }
+        return this.selectFallbackRoute(request, snapshots, online);
+    }
+    selectFromSharedPlan(snapshots, routePlan) {
+        if (!routePlan.selectedProviderId) {
+            throw this.routePlanFailure(routePlan);
+        }
+        return this.buildSelectionFromRoutePlan(snapshots, routePlan);
+    }
+    selectFallbackRoute(request, snapshots, online) {
+        const plan = this.createFallbackPlan(request, snapshots, online);
+        if (!plan.selectedProviderId) {
+            throw this.routePlanFailure(plan);
+        }
+        return this.buildSelectionFromRoutePlan(snapshots, plan);
+    }
+    buildSelectionFromRoutePlan(snapshots, routePlan) {
+        const orderedProviders = routePlan.candidates
+            .map((candidate) => snapshots.find((snapshot) => snapshot.descriptor.id === candidate.providerId))
+            .filter((snapshot) => snapshot !== undefined);
+        const selected = orderedProviders[0];
+        if (!selected) {
+            throw createInternal("Route plan selected a provider that is no longer registered.");
+        }
+        return {
+            provider: selected.provider,
+            fallbackProviders: orderedProviders.slice(1).map((snapshot) => snapshot.provider),
+            routePlan,
+            explanation: routePlan.explanation.summary
+        };
+    }
+    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);
+        const localCandidates = eligible.filter((candidate) => candidate.descriptor.type !== "cloud");
+        const cloudCandidates = eligible.filter((candidate) => candidate.descriptor.type === "cloud");
+        const selected = eligible.find((candidate) => {
+            const descriptor = candidate.descriptor;
+            const constraints = planInput.constraints;
+            const 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" && !privacy) {
+                return false;
+            }
+            if (constraints.privacy === "cloud_required" && descriptor.type !== "cloud") {
+                return false;
+            }
+            if (!online && descriptor.type === "cloud") {
+                return false;
+            }
+            return candidate.capabilities.available;
+        });
+        const ordered = selected
+            ? [selected, ...eligible.filter((candidate) => candidate !== selected)]
+            : [];
+        if (ordered.length === 0) {
+            const failureSummary = this.buildFallbackFailureSummary({
+                online,
+                constraints: planInput.constraints,
+                localCandidates,
+                cloudCandidates
+            });
+            const failureCode = !online
+                ? "offline"
+                : planInput.constraints.cloud === "required" ||
+                    planInput.constraints.privacy === "cloud_required"
+                    ? "unavailable"
+                    : "capability_mismatch";
+            return {
+                fallbackProviderIds: [],
+                candidates: [],
+                rejectedProviders: [],
+                failureCode,
+                explanation: {
+                    summary: failureSummary
+                }
+            };
+        }
+        const selectedProviderId = ordered[0]?.descriptor.id;
+        return {
+            selectedProviderId,
+            fallbackProviderIds: ordered.slice(1).map((candidate) => candidate.descriptor.id),
+            candidates: ordered.map((candidate, index) => ({
+                providerId: candidate.descriptor.id,
+                order: index
+            })),
+            rejectedProviders: [],
+            explanation: {
+                summary: `Selected provider '${selectedProviderId}' deterministically from ${ordered.length} eligible candidate(s).`,
+                selectedProviderId
+            }
+        };
+    }
+    buildFallbackFailureSummary(input) {
+        const wantsCloud = input.constraints.cloud === "required" || input.constraints.privacy === "cloud_required";
+        const wantsLocal = input.constraints.privacy === "local_required";
+        if (!input.online && (wantsCloud || input.cloudCandidates.length > 0)) {
+            return "No network connection is available.";
+        }
+        if (wantsCloud) {
+            if (input.cloudCandidates.length === 0) {
+                return "No cloud provider found.";
+            }
+            return "No cloud provider is currently available.";
+        }
+        if (wantsLocal) {
+            if (input.localCandidates.length === 0) {
+                return "No on-device provider found.";
+            }
+            return "No on-device provider is currently available.";
+        }
+        return "No eligible provider found for the current routing constraints.";
+    }
+    routePlanFailure(routePlan) {
+        const message = routePlan.explanation.summary;
+        switch (routePlan.failureCode) {
+            case "offline":
+                throw createOffline(message);
+            case "unavailable":
+                throw createUnavailable(message);
+            case "capability_mismatch":
+            default:
+                throw createCapabilityMismatch(message);
+        }
+    }
+}

package/dist/telemetry.d.ts

@@ -0,0 +1,13 @@
+import type { TelemetryEvent, TelemetryService } from "@independo/inderun-contracts";
+export type { TelemetryEvent, TelemetryEventType, TelemetryService } from "@independo/inderun-contracts";
+/**
+ * Default no-op telemetry handler that discards all events.
+ */
+export declare class NoOpTelemetryService implements TelemetryService {
+    /**
+     * Discards the telemetry event.
+     * @param _event - The telemetry event to discard.
+     */
+    emit(_event: TelemetryEvent): void;
+}
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErF,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC;;GAEG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D;;;OAGG;IACH,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;CAGnC"}

package/dist/telemetry.js

@@ -0,0 +1,12 @@
+/**
+ * Default no-op telemetry handler that discards all events.
+ */
+export class NoOpTelemetryService {
+    /**
+     * Discards the telemetry event.
+     * @param _event - The telemetry event to discard.
+     */
+    emit(_event) {
+        // No-op
+    }
+}

package/dist/web-sdk.d.ts

@@ -0,0 +1,35 @@
+import { type CreateBrowserHostServicesOptions } from "./browser-host.js";
+import { IndeRun } from "./engine.js";
+import { type OpenAIProviderOptions } from "./openai-provider.js";
+/**
+ * Configuration for the default Web SDK factory.
+ */
+export interface CreateIndeRunWebOptions {
+    /**
+     * OpenAI Responses provider configuration registered by the factory.
+     */
+    openAI: OpenAIProviderOptions;
+    /**
+     * Optional browser host service overrides.
+     */
+    hostServices?: CreateBrowserHostServicesOptions;
+    /**
+     * Explicit opt-in for calling the public OpenAI endpoint directly from this Web SDK factory.
+     *
+     * Browser apps should leave this unset and use a proxy endpoint with `openAI.auth = "none"` instead.
+     * Direct calls can expose credentials to client-side code and are appropriate only for controlled
+     * non-production environments.
+     */
+    allowDirectOpenAIEndpoint?: boolean;
+}
+/**
+ * Creates a Web SDK instance with the OpenAI Responses provider registered.
+ *
+ * Use `openAI.auth = "none"` with a proxy endpoint for production browser apps so the OpenAI API key never ships
+ * to the client. Direct OpenAI calls require `allowDirectOpenAIEndpoint` and should resolve credentials through
+ * `authContextRef` and `SecureStorageService`.
+ *
+ * @param options - OpenAI provider configuration and optional host service overrides.
+ */
+export declare function createIndeRunWeb(options: CreateIndeRunWebOptions): IndeRun;
+//# sourceMappingURL=web-sdk.d.ts.map

package/dist/web-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-sdk.d.ts","sourceRoot":"","sources":["../src/web-sdk.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AAG9B;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,MAAM,EAAE,qBAAqB,CAAC;IAC9B;;OAEG;IACH,YAAY,CAAC,EAAE,gCAAgC,CAAC;IAChD;;;;;;OAMG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAO1E"}