@independo/inderun-web 0.2.0-dev.1 → 0.2.0-dev.11

package/dist/providers/onnx/transformers-runtime.js

@@ -0,0 +1,210 @@
+import { OnnxRuntimeError } from "./runtime.js";
+const TEXT_GENERATION_TASK = "text-generation";
+/**
+ * Creates the default Web ONNX runtime, backed by Transformers.js (which runs ONNX models through
+ * `onnxruntime-web`).
+ *
+ * ONNX Runtime GenAI has no browser build, so Transformers.js fills the generative-loop role
+ * (tokenization, sampling, KV cache) behind the `OnnxTextGenerationRuntime` seam. Applications that
+ * need a different runtime implement the seam themselves and pass it to the provider.
+ *
+ * `@huggingface/transformers` is an optional dependency the application installs: when it is absent
+ * the runtime
+ * reports itself unavailable instead of throwing, so routing degrades to an explainable
+ * `capability_unavailable` rejection.
+ *
+ * @param options - Loader, backend, and model-resolution overrides.
+ */
+export function createTransformersJsRuntime(options = {}) {
+    let modulePromise;
+    let generatorPromise;
+    async function loadModule() {
+        modulePromise ??= (options.load ?? loadTransformersModule)();
+        return modulePromise;
+    }
+    async function loadGenerator(modelPackage) {
+        generatorPromise ??= (async () => {
+            const module = await loadModule();
+            const device = resolveDevice(options.device);
+            if (options.createGenerator) {
+                return options.createGenerator({ modelPackage, module, device });
+            }
+            const modelRef = getModelRef(modelPackage);
+            if (!modelRef) {
+                throw new OnnxRuntimeError("capability", "model source unavailable: the model package does not declare source.ref.");
+            }
+            applyEnvironment(module, modelPackage, options.localModelPath);
+            const pipelineOptions = {
+                device,
+                dtype: options.dtype ?? defaultDtype(device),
+                ...(options.pipelineOptions ?? {})
+            };
+            return module.pipeline(TEXT_GENERATION_TASK, modelRef, pipelineOptions);
+        })();
+        return generatorPromise;
+    }
+    return {
+        async prepare(modelPackage) {
+            let module;
+            try {
+                module = await loadModule();
+            }
+            catch (err) {
+                modulePromise = undefined;
+                return {
+                    available: false,
+                    reason: `runtime package unavailable: install the optional dependency @huggingface/transformers (${getErrorMessage(err)}).`
+                };
+            }
+            if (typeof module.pipeline !== "function") {
+                return {
+                    available: false,
+                    reason: "runtime initialization failed: @huggingface/transformers did not expose pipeline()."
+                };
+            }
+            if (modelPackage.format !== "onnx") {
+                return {
+                    available: false,
+                    reason: `unsupported model format: the Transformers.js runtime consumes ONNX weights, received '${modelPackage.format}'.`
+                };
+            }
+            const sourceType = modelPackage.source?.sourceType;
+            if (sourceType === "programmatic" && !options.createGenerator) {
+                return {
+                    available: false,
+                    reason: "model source unavailable: programmatic model packages require a createGenerator option."
+                };
+            }
+            if (!options.createGenerator && !getModelRef(modelPackage)) {
+                return {
+                    available: false,
+                    reason: "model source unavailable: the model package does not declare source.ref."
+                };
+            }
+            return { available: true };
+        },
+        async generate(input, signal) {
+            let generator;
+            try {
+                generator = await loadGenerator(input.modelPackage);
+            }
+            catch (err) {
+                generatorPromise = undefined;
+                if (err instanceof OnnxRuntimeError)
+                    throw err;
+                if (isResourceExhaustion(err)) {
+                    throw new OnnxRuntimeError("unavailable", `insufficient memory to load the model: ${getErrorMessage(err)}. Try a smaller model or a more aggressive dtype (for example 'q4').`, err);
+                }
+                throw new OnnxRuntimeError("capability", `model files missing or unreadable: ${getErrorMessage(err)}`, err);
+            }
+            if (signal?.aborted) {
+                throw new OnnxRuntimeError("timeout", "ONNX generation was aborted before it started.");
+            }
+            let raw;
+            try {
+                raw = await generator(input.messages, createGenerationOptions(input, signal));
+            }
+            catch (err) {
+                throw new OnnxRuntimeError("internal", `ONNX generation failed: ${getErrorMessage(err)}`, err);
+            }
+            const text = extractGeneratedText(raw);
+            if (text === undefined) {
+                throw new OnnxRuntimeError("internal", "model output malformed: the Transformers.js pipeline returned no text.");
+            }
+            return { text };
+        }
+    };
+}
+async function loadTransformersModule() {
+    // The specifier stays a literal so bundlers and dev servers resolve the bare package name; the
+    // `as string` cast keeps TypeScript from requiring the optional dependency's types here. Apps that
+    // do not install Transformers.js should pass their own `load` (or a different runtime) rather than
+    // relying on this default, which their bundler will fail to resolve.
+    return (await import("@huggingface/transformers"));
+}
+/**
+ * Browser-viable weight variant. Transformers.js defaults to `fp32`, which makes ONNX Runtime
+ * allocate the full-precision model and fail session creation with an allocation error for
+ * anything but tiny models.
+ */
+function defaultDtype(device) {
+    return device === "webgpu" ? "q4f16" : "q4";
+}
+function resolveDevice(configured) {
+    if (configured !== undefined)
+        return configured;
+    const gpu = globalThis.navigator?.gpu;
+    return gpu ? "webgpu" : "wasm";
+}
+function getModelRef(modelPackage) {
+    const ref = modelPackage.source?.ref;
+    return typeof ref === "string" && ref.length > 0 ? ref : undefined;
+}
+function applyEnvironment(module, modelPackage, localModelPath) {
+    const env = module.env;
+    if (!env)
+        return;
+    const sourceType = modelPackage.source?.sourceType;
+    if (sourceType === "bundled" || sourceType === "app_managed") {
+        env.allowLocalModels = true;
+        env.allowRemoteModels = false;
+        if (localModelPath !== undefined) {
+            env.localModelPath = localModelPath;
+        }
+    }
+}
+function createGenerationOptions(input, signal) {
+    const generation = input.generation;
+    const generationOptions = {};
+    if (generation?.maxOutputTokens !== undefined) {
+        generationOptions.max_new_tokens = generation.maxOutputTokens;
+    }
+    if (generation?.temperature !== undefined) {
+        generationOptions.temperature = generation.temperature;
+        generationOptions.do_sample = generation.temperature > 0;
+    }
+    if (generation?.topP !== undefined) {
+        generationOptions.top_p = generation.topP;
+    }
+    if (generation?.stop !== undefined && generation.stop.length > 0) {
+        generationOptions.stop_strings = generation.stop;
+    }
+    if (signal !== undefined) {
+        generationOptions.signal = signal;
+    }
+    return generationOptions;
+}
+function extractGeneratedText(raw) {
+    const first = Array.isArray(raw) ? raw[0] : raw;
+    if (!isRecord(first)) {
+        return typeof first === "string" ? first : undefined;
+    }
+    const generated = first.generated_text;
+    if (typeof generated === "string") {
+        return generated;
+    }
+    if (Array.isArray(generated)) {
+        const last = generated[generated.length - 1];
+        if (isRecord(last) && typeof last.content === "string") {
+            return last.content;
+        }
+    }
+    return undefined;
+}
+/**
+ * Detects out-of-memory failures surfaced by ONNX Runtime session creation, which arrive as
+ * allocation errors from the WASM/native layer rather than as typed errors.
+ */
+function isResourceExhaustion(error) {
+    const message = getErrorMessage(error).toLowerCase();
+    return (message.includes("bad_alloc") ||
+        message.includes("out of memory") ||
+        message.includes("failed to allocate") ||
+        message.includes("allocation failed"));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/{openai-provider.d.ts → providers/openai/provider.d.ts}

@@ -1,6 +1,6 @@
 import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
-import type { HostServices } from "./host.js";
-import type { ProviderAdapter, ProviderDescriptor, ProviderDynamicCapabilities, RunContext } from "./provider.js";
+import type { HostServices } from "../../core/host.js";
+import type { ProviderAdapter, ProviderDescriptor, ProviderDynamicCapabilities, RunContext } from "../../core/provider.js";
 export declare const DEFAULT_OPENAI_RESPONSES_ENDPOINT = "https://api.openai.com/v1/responses";
 /**
  * Configuration for the OpenAI Responses provider.
@@ -31,6 +31,17 @@ export interface OpenAIProviderOptions {
      * Optional HTTP timeout for the host transport attempt.
      */
     timeoutMs?: number;
+    /**
+     * Timeout for the endpoint reachability probe issued from `capabilities()`.
+     * Defaults to 3000ms. The OpenAI API has no dedicated health endpoint, so this
+     * is a cheap unauthenticated `GET` against the configured endpoint.
+     */
+    healthCheckTimeoutMs?: number;
+    /**
+     * How long a reachability probe result is cached before `capabilities()` re-probes.
+     * Defaults to 5000ms. Avoids re-probing on every routing decision and UI capability check.
+     */
+    healthCheckCacheMs?: number;
 }
 /**
  * Cloud provider adapter that executes Mode-1 text-to-text requests through the OpenAI Responses API.
@@ -44,6 +55,7 @@ export declare class OpenAIResponsesProvider implements ProviderAdapter {
     private readonly id;
     private readonly endpointUrl;
     private readonly auth;
+    private cachedHealth?;
     /**
      * Creates an OpenAI Responses provider.
      * @param options - Provider configuration, including required OpenAI model id.
@@ -55,9 +67,15 @@ export declare class OpenAIResponsesProvider implements ProviderAdapter {
     describe(): ProviderDescriptor;
     /**
      * Reports dynamic provider availability for the current host.
+     *
+     * After the static host-service checks pass, this probes endpoint reachability with a
+     * cheap unauthenticated `GET` against the configured endpoint (the OpenAI API has no
+     * dedicated health endpoint). The result is cached for `healthCheckCacheMs` so routing
+     * decisions and repeated UI capability checks don't re-probe on every call.
      * @param host - Host services available to the engine.
      */
     capabilities(host: HostServices): Promise<ProviderDynamicCapabilities>;
+    private checkEndpointReachable;
     /**
      * Executes a normalized text-to-text task using the OpenAI Responses API.
      * @param request - Canonical IndeRun task request.
@@ -77,4 +95,4 @@ export declare class OpenAIResponsesProvider implements ProviderAdapter {
      */
     private mapHttpError;
 }
-//# sourceMappingURL=openai-provider.d.ts.map
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +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"}

package/dist/{openai-provider.js → providers/openai/provider.js}

@@ -1,5 +1,7 @@
-import { createAuthError, createInternal, createRateLimited, createTimeout, createUnavailable } from "./errors.js";
+import { createAuthError, createInternal, createRateLimited, createTimeout, createUnavailable } from "../../core/errors.js";
 export const DEFAULT_OPENAI_RESPONSES_ENDPOINT = "https://api.openai.com/v1/responses";
+const DEFAULT_HEALTH_CHECK_TIMEOUT_MS = 3000;
+const DEFAULT_HEALTH_CHECK_CACHE_MS = 5000;
 /**
  * Cloud provider adapter that executes Mode-1 text-to-text requests through the OpenAI Responses API.
  *
@@ -12,6 +14,7 @@ export class OpenAIResponsesProvider {
     id;
     endpointUrl;
     auth;
+    cachedHealth;
     /**
      * Creates an OpenAI Responses provider.
      * @param options - Provider configuration, including required OpenAI model id.
@@ -48,6 +51,11 @@ export class OpenAIResponsesProvider {
     }
     /**
      * Reports dynamic provider availability for the current host.
+     *
+     * After the static host-service checks pass, this probes endpoint reachability with a
+     * cheap unauthenticated `GET` against the configured endpoint (the OpenAI API has no
+     * dedicated health endpoint). The result is cached for `healthCheckCacheMs` so routing
+     * decisions and repeated UI capability checks don't re-probe on every call.
      * @param host - Host services available to the engine.
      */
     async capabilities(host) {
@@ -63,7 +71,39 @@ export class OpenAIResponsesProvider {
                 reason: "OpenAI Responses provider requires a SecureStorageService when auth is enabled."
             };
         }
-        return { available: true };
+        return this.checkEndpointReachable(host.httpClient, host.clock);
+    }
+    async checkEndpointReachable(httpClient, clock) {
+        const now = clock ? clock.now() : Date.now();
+        const cacheMs = this.options.healthCheckCacheMs ?? DEFAULT_HEALTH_CHECK_CACHE_MS;
+        if (this.cachedHealth && now - this.cachedHealth.checkedAt < cacheMs) {
+            return this.cachedHealth.result;
+        }
+        let result;
+        try {
+            const response = await httpClient.send({
+                method: "GET",
+                url: this.endpointUrl,
+                timeoutMs: this.options.healthCheckTimeoutMs ?? DEFAULT_HEALTH_CHECK_TIMEOUT_MS
+            });
+            result =
+                response.status >= 500
+                    ? {
+                        available: false,
+                        reason: `OpenAI Responses endpoint returned HTTP ${response.status}.`
+                    }
+                    : { available: true };
+        }
+        catch (err) {
+            result = {
+                available: false,
+                reason: isAbortError(err)
+                    ? "OpenAI Responses endpoint health check timed out."
+                    : "OpenAI Responses endpoint is unreachable."
+            };
+        }
+        this.cachedHealth = { result, checkedAt: now };
+        return result;
     }
     /**
      * Executes a normalized text-to-text task using the OpenAI Responses API.

package/dist/providers/system-model/chrome-runtime.d.ts

@@ -0,0 +1,48 @@
+import { type SystemModelRuntime } from "./runtime.js";
+/**
+ * Structural view of the Chrome/Edge Prompt API's `LanguageModel` global this runtime uses.
+ *
+ * Typed structurally (not imported from `@types/dom`) since the Prompt API is not yet part of
+ * stable browser type definitions. See https://developer.chrome.com/docs/ai/prompt-api.
+ */
+export interface PromptApiLanguageModel {
+    availability: (options?: Record<string, unknown>) => Promise<string>;
+    create: (options?: Record<string, unknown>) => Promise<PromptApiSession>;
+}
+/** Structural view of a Prompt API session. */
+export interface PromptApiSession {
+    prompt: (input: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<string>;
+    destroy: () => void;
+}
+/**
+ * Generation controls forwarded to `LanguageModel.availability()` and `LanguageModel.create()`.
+ *
+ * Chrome's docs require passing the same options to both calls, since availability can depend on
+ * the requested configuration.
+ */
+export interface ChromePromptApiGenerationOptions {
+    temperature?: number;
+    topK?: number;
+}
+/**
+ * Configuration for the Chrome Prompt API-backed system-model runtime.
+ */
+export interface ChromePromptApiRuntimeOptions {
+    /** Generation controls passed to both `availability()` and `create()`. */
+    generation?: ChromePromptApiGenerationOptions;
+}
+/**
+ * Creates the default Web system-model runtime, backed by Chrome's built-in Prompt API
+ * (`LanguageModel`).
+ *
+ * The browser owns model availability, download, and execution; this runtime never bundles or
+ * fetches a model itself. When `LanguageModel` is not defined (unsupported browser, disabled
+ * flag, or origin trial not enrolled) the runtime reports itself unavailable instead of throwing,
+ * so routing degrades to an explainable `capability_unavailable` rejection.
+ *
+ * @param options - Generation control overrides forwarded to the Prompt API.
+ */
+export declare function createChromePromptApiRuntime(options?: ChromePromptApiRuntimeOptions): SystemModelRuntime;
+//# sourceMappingURL=chrome-runtime.d.ts.map

package/dist/providers/system-model/chrome-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chrome-runtime.d.ts","sourceRoot":"","sources":["../../../src/providers/system-model/chrome-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,kBAAkB,EACxB,MAAM,cAAc,CAAC;AAEtB;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACrE,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC1E;AAED,+CAA+C;AAC/C,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/E,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,gCAAgC;IAC/C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C,0EAA0E;IAC1E,UAAU,CAAC,EAAE,gCAAgC,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,GAAE,6BAAkC,GAC1C,kBAAkB,CA+EpB"}

package/dist/providers/system-model/chrome-runtime.js

@@ -0,0 +1,137 @@
+import { SystemModelRuntimeError } from "./runtime.js";
+/**
+ * Creates the default Web system-model runtime, backed by Chrome's built-in Prompt API
+ * (`LanguageModel`).
+ *
+ * The browser owns model availability, download, and execution; this runtime never bundles or
+ * fetches a model itself. When `LanguageModel` is not defined (unsupported browser, disabled
+ * flag, or origin trial not enrolled) the runtime reports itself unavailable instead of throwing,
+ * so routing degrades to an explainable `capability_unavailable` rejection.
+ *
+ * @param options - Generation control overrides forwarded to the Prompt API.
+ */
+export function createChromePromptApiRuntime(options = {}) {
+    const promptOptions = toPromptApiOptions(options.generation);
+    return {
+        async availability() {
+            const languageModel = getLanguageModel();
+            if (!languageModel) {
+                return {
+                    kind: "api_missing",
+                    reason: "system model API missing: 'LanguageModel' is not defined on this browser. See https://developer.chrome.com/docs/ai/prompt-api."
+                };
+            }
+            let result;
+            try {
+                result = await languageModel.availability(promptOptions);
+            }
+            catch (err) {
+                return mapAvailabilityError(err);
+            }
+            switch (result) {
+                case "available":
+                    return { kind: "available" };
+                case "downloadable":
+                    return {
+                        kind: "downloadable",
+                        reason: "model downloadable: the model can be downloaded but is not installed yet."
+                    };
+                case "downloading":
+                    return {
+                        kind: "downloading",
+                        reason: "model downloading: the model is currently downloading."
+                    };
+                case "unavailable":
+                    return {
+                        kind: "model_unavailable",
+                        reason: "model unavailable: the model is unavailable on this device."
+                    };
+                default:
+                    return {
+                        kind: "unavailable",
+                        reason: `provider temporarily unavailable: unrecognized availability result '${result}'.`
+                    };
+            }
+        },
+        async generate(input, signal) {
+            const languageModel = getLanguageModel();
+            if (!languageModel) {
+                throw new SystemModelRuntimeError("capability", "system model API missing: 'LanguageModel' is not defined on this browser.");
+            }
+            let session;
+            try {
+                session = await languageModel.create({ ...promptOptions, signal });
+            }
+            catch (err) {
+                throw mapGenerateError(err);
+            }
+            try {
+                const text = await session.prompt(toPromptText(input), signal !== undefined ? { signal } : {});
+                return { text };
+            }
+            catch (err) {
+                throw mapGenerateError(err);
+            }
+            finally {
+                session.destroy();
+            }
+        }
+    };
+}
+function getLanguageModel() {
+    return globalThis.LanguageModel;
+}
+function toPromptApiOptions(generation) {
+    const promptOptions = {};
+    if (generation?.temperature !== undefined)
+        promptOptions.temperature = generation.temperature;
+    if (generation?.topK !== undefined)
+        promptOptions.topK = generation.topK;
+    return promptOptions;
+}
+function toPromptText(input) {
+    return input.messages.map((message) => `${message.role}: ${message.content}`).join("\n");
+}
+function mapAvailabilityError(error) {
+    const name = getDomExceptionName(error);
+    if (name === "NotSupportedError") {
+        return {
+            kind: "browser_unsupported",
+            reason: `browser unsupported: ${getErrorMessage(error)}`
+        };
+    }
+    if (name === "NotAllowedError" || name === "SecurityError") {
+        return {
+            kind: "feature_disabled",
+            reason: `browser feature disabled: ${getErrorMessage(error)}`
+        };
+    }
+    return {
+        kind: "unavailable",
+        reason: `provider temporarily unavailable: ${getErrorMessage(error)}`
+    };
+}
+function mapGenerateError(error) {
+    if (error instanceof SystemModelRuntimeError)
+        return error;
+    const name = getDomExceptionName(error);
+    switch (name) {
+        case "NotSupportedError":
+            return new SystemModelRuntimeError("capability", `hardware unsupported: ${getErrorMessage(error)}`, error);
+        case "NotAllowedError":
+        case "SecurityError":
+            return new SystemModelRuntimeError("capability", `browser feature disabled: ${getErrorMessage(error)}`, error);
+        case "QuotaExceededError":
+            return new SystemModelRuntimeError("unavailable", `storage or network constraints: ${getErrorMessage(error)}`, error);
+        case "AbortError":
+            return new SystemModelRuntimeError("timeout", `system model generation was aborted: ${getErrorMessage(error)}`, error);
+        default:
+            return new SystemModelRuntimeError("internal", `system model generation failed: ${getErrorMessage(error)}`, error);
+    }
+}
+function getDomExceptionName(error) {
+    return error instanceof DOMException ? error.name : undefined;
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/providers/system-model/provider.d.ts

@@ -0,0 +1,67 @@
+import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
+import type { HostServices } from "../../core/host.js";
+import { type SystemModelRuntime } from "./runtime.js";
+import type { ProviderAdapter, ProviderDescriptor, ProviderDynamicCapabilities, RunContext } from "../../core/provider.js";
+/** Default provider id of the Web member of the system-model provider family. */
+export declare const DEFAULT_SYSTEM_MODEL_WEB_PROVIDER_ID = "local.system-model.web";
+/**
+ * Configuration for the Web system-model provider.
+ */
+export interface SystemModelProviderOptions {
+    /**
+     * Provider id exposed in telemetry and routing explanations.
+     */
+    id?: string;
+    /**
+     * Runtime implementation used to check availability and execute generation. Defaults to
+     * `createChromePromptApiRuntime()`; pass `createFixtureSystemModelRuntime()` from
+     * `system-model.js` for tests and offline demos.
+     */
+    runtime?: SystemModelRuntime;
+    /**
+     * Optional generation timeout in milliseconds. A request-level `constraints.timeoutMs` wins.
+     */
+    timeoutMs?: number;
+}
+/**
+ * Local provider adapter that executes Mode-1 text-to-text requests against a browser-managed
+ * on-device model (for example Chrome's Prompt API / Gemini Nano).
+ *
+ * Unlike the ONNX Runtime provider family, this provider takes no developer-supplied model: the
+ * browser owns model availability, download, and execution. The adapter owns the IndeRun-facing
+ * contract (descriptor, capability checks, error taxonomy) and delegates everything else to an
+ * injectable {@link SystemModelRuntime}.
+ */
+export declare class SystemModelWebProvider implements ProviderAdapter {
+    private readonly options;
+    private readonly id;
+    private readonly runtime;
+    /**
+     * Creates a Web system-model provider.
+     * @param options - Optional id, runtime, and timeout overrides.
+     */
+    constructor(options?: SystemModelProviderOptions);
+    /**
+     * Returns static metadata used by the router for deterministic provider selection.
+     */
+    describe(): ProviderDescriptor;
+    /**
+     * Reports dynamic provider availability for the current host.
+     *
+     * Every failure below is provider-internal detail: the shared route planner flattens it into a
+     * single `capability_unavailable` rejection carrying the returned reason.
+     *
+     * @param _host - Host services available to the engine (unused; the browser owns execution).
+     */
+    capabilities(_host: HostServices): Promise<ProviderDynamicCapabilities>;
+    /**
+     * Executes a normalized text-to-text task against the browser-managed on-device model.
+     * @param request - Canonical IndeRun task request.
+     * @param context - Engine execution context containing run id and host services.
+     * @returns Normalized IndeRun task result.
+     * @throws IndeRunException mapped to the standard error taxonomy.
+     */
+    run(request: TaskRequest, context: RunContext): Promise<TaskResult>;
+    private mapRuntimeError;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/providers/system-model/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/providers/system-model/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAS5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EACV,eAAe,EACf,kBAAkB,EAClB,2BAA2B,EAC3B,UAAU,EACX,MAAM,wBAAwB,CAAC;AAEhC,iFAAiF;AACjF,eAAO,MAAM,oCAAoC,2BAA2B,CAAC;AAK7E;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC;;OAEG;IACH,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,YAAW,eAAe;IAQhD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAPpC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C;;;OAGG;gBAC0B,OAAO,GAAE,0BAA+B;IAKrE;;OAEG;IACH,QAAQ,IAAI,kBAAkB;IAsB9B;;;;;;;OAOG;IACG,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAK7E;;;;;;OAMG;IACG,GAAG,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IA8DzE,OAAO,CAAC,eAAe;CA2BxB"}