@independo/inderun-web 0.2.0-dev.6 → 0.2.0-dev.8

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"}

package/dist/providers/system-model/provider.js

@@ -0,0 +1,190 @@
+import { createCapabilityMismatch, createInternal, createTimeout, createUnavailable, toIndeRunException } from "../../core/errors.js";
+import { createChromePromptApiRuntime } from "./chrome-runtime.js";
+import { SystemModelRuntimeError } from "./runtime.js";
+/** Default provider id of the Web member of the system-model provider family. */
+export const DEFAULT_SYSTEM_MODEL_WEB_PROVIDER_ID = "local.system-model.web";
+/** Task kind this provider implements in Milestone 2 (Mode 1 only). */
+const TEXT_TO_TEXT = "text_to_text";
+/**
+ * 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 class SystemModelWebProvider {
+    options;
+    id;
+    runtime;
+    /**
+     * Creates a Web system-model provider.
+     * @param options - Optional id, runtime, and timeout overrides.
+     */
+    constructor(options = {}) {
+        this.options = options;
+        this.id = options.id ?? DEFAULT_SYSTEM_MODEL_WEB_PROVIDER_ID;
+        this.runtime = options.runtime ?? createChromePromptApiRuntime();
+    }
+    /**
+     * Returns static metadata used by the router for deterministic provider selection.
+     */
+    describe() {
+        return {
+            id: this.id,
+            type: "local",
+            transport: "system_service",
+            supports: {
+                run: true,
+                streaming: false,
+                realtime: false,
+                tools: false,
+                reasoningEvents: false,
+                structuredOutput: false,
+                multimodal: false
+            },
+            cancel: "soft",
+            tasks: [TEXT_TO_TEXT],
+            privacy: {
+                dataLeavesDevice: false
+            }
+        };
+    }
+    /**
+     * 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).
+     */
+    async capabilities(_host) {
+        const availability = await this.runtime.availability();
+        return toDynamicCapabilities(availability);
+    }
+    /**
+     * 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.
+     */
+    async run(request, context) {
+        const availability = await this.runtime.availability();
+        const capabilities = toDynamicCapabilities(availability);
+        if (!capabilities.available) {
+            throw createCapabilityMismatch(capabilities.reason ?? "Web system-model provider is unavailable on this host.", { providerId: this.id, runId: context.runId });
+        }
+        const messages = createMessages(request);
+        if (messages.length === 0) {
+            throw createInternal("Web system-model provider requires a prompt or messages.", {
+                providerId: this.id,
+                runId: context.runId
+            });
+        }
+        const timeoutMs = request.constraints?.timeoutMs ?? this.options.timeoutMs;
+        const controller = new AbortController();
+        const timer = timeoutMs !== undefined && timeoutMs > 0
+            ? setTimeout(() => controller.abort(), timeoutMs)
+            : undefined;
+        let output;
+        try {
+            output = await this.runtime.generate({
+                messages,
+                ...(request.generation !== undefined ? { generation: request.generation } : {})
+            }, controller.signal);
+        }
+        catch (err) {
+            throw this.mapRuntimeError(err, context);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+        if (typeof output.text !== "string" || output.text.length === 0) {
+            throw createInternal("Web system-model provider returned no text output.", {
+                providerId: this.id,
+                runId: context.runId
+            });
+        }
+        return {
+            schemaVersion: "1.0",
+            runId: context.runId,
+            output: {
+                type: "text",
+                text: output.text
+            },
+            finishReason: output.finishReason ?? "stop",
+            telemetry: {
+                providerUsed: this.id,
+                totalMs: 0
+            }
+        };
+    }
+    mapRuntimeError(error, context) {
+        const extra = { providerId: this.id, runId: context.runId };
+        if (error instanceof SystemModelRuntimeError) {
+            const details = error.originalError !== undefined
+                ? { details: { originalError: getErrorSummary(error.originalError) } }
+                : {};
+            switch (error.kind) {
+                case "capability":
+                    return createCapabilityMismatch(error.message, { ...extra, ...details });
+                case "unavailable":
+                    return createUnavailable(error.message, { ...extra, ...details });
+                case "timeout":
+                    return createTimeout(error.message, { ...extra, ...details });
+                default:
+                    return createInternal(error.message, { ...extra, ...details });
+            }
+        }
+        if (isAbortError(error)) {
+            return createTimeout("Web system-model generation timed out.", extra);
+        }
+        return toIndeRunException(error, extra);
+    }
+}
+const REASON_PREFIX = {
+    available: undefined,
+    downloadable: "model downloadable",
+    downloading: "model downloading",
+    model_unavailable: "model unavailable",
+    api_missing: "system model API missing",
+    browser_unsupported: "browser unsupported",
+    feature_disabled: "browser feature disabled",
+    hardware_unsupported: "hardware unsupported",
+    resource_constrained: "storage or network constraints",
+    unavailable: "provider temporarily unavailable"
+};
+function toDynamicCapabilities(availability) {
+    if (availability.kind === "available") {
+        return { available: true };
+    }
+    const prefix = REASON_PREFIX[availability.kind];
+    const reason = availability.reason
+        ? `${prefix}: ${availability.reason}`
+        : `${prefix}: the Web system-model provider is unavailable.`;
+    return { available: false, reason };
+}
+function createMessages(request) {
+    if (request.messages && request.messages.length > 0) {
+        return request.messages.map((message) => ({
+            role: message.role,
+            content: message.content
+        }));
+    }
+    const prompt = request.prompt;
+    return prompt !== undefined && prompt.length > 0 ? [{ role: "user", content: prompt }] : [];
+}
+function isAbortError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        error.name === "AbortError");
+}
+function getErrorSummary(error) {
+    if (error instanceof Error) {
+        return { name: error.name, message: error.message, stack: error.stack };
+    }
+    return { message: String(error) };
+}

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

@@ -0,0 +1,110 @@
+import type { TaskRequest, TaskResult } from "@independo/inderun-contracts";
+/**
+ * Capability state reported by a system-model runtime.
+ *
+ * The `reason` string uses the provider-internal capability vocabulary documented in
+ * `docs/architecture/web-system-model-provider-family.md`. It is not a public enum: the provider
+ * flattens every non-`available` kind into a single `capability_unavailable` route rejection and
+ * carries the reason as human-readable text.
+ */
+export type SystemModelAvailabilityKind = "available" | "downloadable" | "downloading" | "model_unavailable" | "api_missing" | "browser_unsupported" | "feature_disabled" | "hardware_unsupported" | "resource_constrained" | "unavailable";
+/**
+ * Availability snapshot reported by a system-model runtime.
+ */
+export interface SystemModelAvailability {
+    /** The specific availability state the runtime observed. */
+    kind: SystemModelAvailabilityKind;
+    /** Human-readable detail describing the state; expected for every non-`available` kind. */
+    reason?: string;
+}
+/**
+ * Normalized conversation turn handed to a system-model runtime.
+ */
+export interface SystemModelPromptMessage {
+    /** The role of the author of this turn. */
+    role: "system" | "user" | "assistant";
+    /** Plain-text content of this turn. */
+    content: string;
+}
+/**
+ * Normalized generation request handed to a system-model runtime.
+ */
+export interface SystemModelGenerationInput {
+    /** Conversation turns, normalized from `prompt` or `messages` by the provider. */
+    messages: SystemModelPromptMessage[];
+    /** Optional generation controls copied from the task request. */
+    generation?: NonNullable<TaskRequest["generation"]>;
+}
+/**
+ * Normalized generation result returned by a system-model runtime.
+ */
+export interface SystemModelGenerationOutput {
+    /** The generated text. */
+    text: string;
+    /** Optional normalized finish reason; the provider defaults to `stop`. */
+    finishReason?: TaskResult["finishReason"];
+}
+/**
+ * Failure category a runtime can signal so the provider maps it onto the IndeRun error taxonomy.
+ *
+ * - `capability`: the browser or hardware cannot serve this request (`CapabilityMismatch`).
+ * - `unavailable`: resource exhaustion or transient failure (`Unavailable`).
+ * - `timeout`: generation exceeded its budget or was aborted (`Timeout`).
+ * - `internal`: unexpected runtime failure (`Internal`).
+ */
+export type SystemModelRuntimeErrorKind = "capability" | "unavailable" | "timeout" | "internal";
+/**
+ * Error type system-model runtime implementations throw to steer IndeRun error normalization.
+ *
+ * Anything else thrown by a runtime is normalized to `Internal`.
+ */
+export declare class SystemModelRuntimeError extends Error {
+    /** Failure category used by the provider to select an IndeRun error class. */
+    readonly kind: SystemModelRuntimeErrorKind;
+    /** Optional underlying error captured for telemetry details. */
+    readonly originalError?: unknown;
+    constructor(kind: SystemModelRuntimeErrorKind, message: string, originalError?: unknown);
+}
+/**
+ * Injectable seam between the IndeRun Web system-model provider and the browser's on-device model
+ * API.
+ *
+ * IndeRun ships a Chrome Prompt API-backed implementation as the default and a deterministic
+ * fixture for tests. The seam exposes only Mode-1 generation (no session object, no streaming
+ * method) so streaming/session support cannot leak in even as unused scaffolding.
+ */
+export interface SystemModelRuntime {
+    /**
+     * Checks browser API presence and model readiness. Implementations must resolve with an
+     * availability snapshot rather than throwing.
+     */
+    availability(): Promise<SystemModelAvailability>;
+    /**
+     * Runs one Mode-1 generation. Implementations should honor `signal` where the underlying API
+     * allows it.
+     */
+    generate(input: SystemModelGenerationInput, signal?: AbortSignal): Promise<SystemModelGenerationOutput>;
+}
+/**
+ * Configuration for the deterministic fixture runtime.
+ */
+export interface FixtureSystemModelRuntimeOptions {
+    /** Availability snapshot returned by `availability`. Defaults to `{ kind: "available" }`. */
+    availability?: SystemModelAvailability;
+    /** Text or full output produced by `generate`. Defaults to a deterministic echo. */
+    respond?: (input: SystemModelGenerationInput) => string | SystemModelGenerationOutput;
+    /** Error thrown by `generate` instead of producing output. */
+    failWith?: unknown;
+    /** Artificial generation delay in milliseconds, used to exercise timeouts. */
+    delayMs?: number;
+}
+/**
+ * Creates a deterministic in-memory system-model runtime.
+ *
+ * This is the test seam for the Web system-model provider family: it proves capability checks,
+ * routing, and error normalization without depending on a real browser Prompt API implementation.
+ *
+ * @param options - Scripted availability, response, failure, and delay behavior.
+ */
+export declare function createFixtureSystemModelRuntime(options?: FixtureSystemModelRuntimeOptions): SystemModelRuntime;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/providers/system-model/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;;;;;GAOG;AACH,MAAM,MAAM,2BAA2B,GACnC,WAAW,GACX,cAAc,GACd,aAAa,GACb,mBAAmB,GACnB,aAAa,GACb,qBAAqB,GACrB,kBAAkB,GAClB,sBAAsB,GACtB,sBAAsB,GACtB,aAAa,CAAC;AAElB;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,4DAA4D;IAC5D,IAAI,EAAE,2BAA2B,CAAC;IAClC,2FAA2F;IAC3F,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,2CAA2C;IAC3C,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;IACtC,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,kFAAkF;IAClF,QAAQ,EAAE,wBAAwB,EAAE,CAAC;IACrC,iEAAiE;IACjE,UAAU,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC;CACrD;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,0EAA0E;IAC1E,YAAY,CAAC,EAAE,UAAU,CAAC,cAAc,CAAC,CAAC;CAC3C;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,2BAA2B,GAAG,YAAY,GAAG,aAAa,GAAG,SAAS,GAAG,UAAU,CAAC;AAEhG;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,2BAA2B,CAAC;IAC3C,gEAAgE;IAChE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;gBAErB,IAAI,EAAE,2BAA2B,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO;CAQxF;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,YAAY,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACjD;;;OAGG;IACH,QAAQ,CACN,KAAK,EAAE,0BAA0B,EACjC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,2BAA2B,CAAC,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAC/C,6FAA6F;IAC7F,YAAY,CAAC,EAAE,uBAAuB,CAAC;IACvC,oFAAoF;IACpF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,MAAM,GAAG,2BAA2B,CAAC;IACtF,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,GAAE,gCAAqC,GAC7C,kBAAkB,CA0BpB"}

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

@@ -0,0 +1,73 @@
+/**
+ * Error type system-model runtime implementations throw to steer IndeRun error normalization.
+ *
+ * Anything else thrown by a runtime is normalized to `Internal`.
+ */
+export class SystemModelRuntimeError extends Error {
+    /** Failure category used by the provider to select an IndeRun error class. */
+    kind;
+    /** Optional underlying error captured for telemetry details. */
+    originalError;
+    constructor(kind, message, originalError) {
+        super(message);
+        this.name = "SystemModelRuntimeError";
+        this.kind = kind;
+        if (originalError !== undefined)
+            this.originalError = originalError;
+        Object.setPrototypeOf(this, SystemModelRuntimeError.prototype);
+    }
+}
+/**
+ * Creates a deterministic in-memory system-model runtime.
+ *
+ * This is the test seam for the Web system-model provider family: it proves capability checks,
+ * routing, and error normalization without depending on a real browser Prompt API implementation.
+ *
+ * @param options - Scripted availability, response, failure, and delay behavior.
+ */
+export function createFixtureSystemModelRuntime(options = {}) {
+    const availability = options.availability ?? { kind: "available" };
+    return {
+        async availability() {
+            return availability;
+        },
+        async generate(input, signal) {
+            if (options.delayMs !== undefined && options.delayMs > 0) {
+                await delay(options.delayMs, signal);
+            }
+            throwIfAborted(signal);
+            if (options.failWith !== undefined) {
+                throw options.failWith;
+            }
+            const response = options.respond ? options.respond(input) : createFixtureText(input.messages);
+            return typeof response === "string" ? { text: response } : response;
+        }
+    };
+}
+function createFixtureText(messages) {
+    const lastUserMessage = [...messages].reverse().find((message) => message.role === "user");
+    const prompt = lastUserMessage?.content ?? "";
+    return `[fixture:system-model] ${prompt}`;
+}
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        function onAbort() {
+            clearTimeout(timer);
+            reject(new SystemModelRuntimeError("timeout", "Fixture system-model generation was aborted."));
+        }
+        if (signal?.aborted) {
+            onAbort();
+            return;
+        }
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new SystemModelRuntimeError("timeout", "Fixture system-model generation was aborted.");
+    }
+}

package/dist/system-model.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Provider-specific entry point for the Web member of the system-model provider family.
+ *
+ * Kept out of the unified SDK index (`@independo/inderun-web`) so the top-level
+ * surface stays provider-agnostic. Import from `@independo/inderun-web/system-model`
+ * when registering the adapter manually or when implementing a custom
+ * `SystemModelRuntime`; most browser apps should pass `systemModel` to
+ * `createIndeRunWeb` from the main entry point instead.
+ */
+export { DEFAULT_SYSTEM_MODEL_WEB_PROVIDER_ID, SystemModelWebProvider, type SystemModelProviderOptions } from "./providers/system-model/provider.js";
+export { SystemModelRuntimeError, createFixtureSystemModelRuntime, type FixtureSystemModelRuntimeOptions, type SystemModelAvailability, type SystemModelAvailabilityKind, type SystemModelGenerationInput, type SystemModelGenerationOutput, type SystemModelPromptMessage, type SystemModelRuntime, type SystemModelRuntimeErrorKind } from "./providers/system-model/runtime.js";
+export { createChromePromptApiRuntime, type ChromePromptApiGenerationOptions, type ChromePromptApiRuntimeOptions, type PromptApiLanguageModel, type PromptApiSession } from "./providers/system-model/chrome-runtime.js";
+//# sourceMappingURL=system-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"system-model.d.ts","sourceRoot":"","sources":["../src/system-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EACL,oCAAoC,EACpC,sBAAsB,EACtB,KAAK,0BAA0B,EAChC,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EACL,uBAAuB,EACvB,+BAA+B,EAC/B,KAAK,gCAAgC,EACrC,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,2BAA2B,EACjC,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,4BAA4B,EAC5B,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACtB,MAAM,4CAA4C,CAAC"}

package/dist/system-model.js

@@ -0,0 +1,12 @@
+/**
+ * Provider-specific entry point for the Web member of the system-model provider family.
+ *
+ * Kept out of the unified SDK index (`@independo/inderun-web`) so the top-level
+ * surface stays provider-agnostic. Import from `@independo/inderun-web/system-model`
+ * when registering the adapter manually or when implementing a custom
+ * `SystemModelRuntime`; most browser apps should pass `systemModel` to
+ * `createIndeRunWeb` from the main entry point instead.
+ */
+export { DEFAULT_SYSTEM_MODEL_WEB_PROVIDER_ID, SystemModelWebProvider } from "./providers/system-model/provider.js";
+export { SystemModelRuntimeError, createFixtureSystemModelRuntime } from "./providers/system-model/runtime.js";
+export { createChromePromptApiRuntime } from "./providers/system-model/chrome-runtime.js";

package/dist/web-sdk.d.ts

@@ -1,7 +1,8 @@
-import { type CreateBrowserHostServicesOptions } from "./browser-host.js";
-import { IndeRun } from "./engine.js";
-import { type OnnxProviderOptions } from "./onnx-provider.js";
-import { type OpenAIProviderOptions } from "./openai-provider.js";
+import { type CreateBrowserHostServicesOptions } from "./core/browser-host.js";
+import { IndeRun } from "./core/engine.js";
+import { type OnnxProviderOptions } from "./providers/onnx/provider.js";
+import { type OpenAIProviderOptions } from "./providers/openai/provider.js";
+import { type SystemModelProviderOptions } from "./providers/system-model/provider.js";
 /**
  * Configuration for the default Web SDK factory.
  */
@@ -15,6 +16,12 @@ export interface CreateIndeRunWebOptions {
      * local models. Registering it is what makes `constraints.privacy = "local_required"` routable.
      */
     onnx?: OnnxProviderOptions;
+    /**
+     * Web system-model provider configuration registered by the factory, for browser-managed
+     * on-device models (for example Chrome's Prompt API). Unlike `onnx`, this provider takes no
+     * developer-supplied model: the browser owns model availability, download, and execution.
+     */
+    systemModel?: SystemModelProviderOptions;
     /**
      * Optional browser host service overrides.
      */
@@ -31,8 +38,9 @@ export interface CreateIndeRunWebOptions {
 /**
  * Creates a Web SDK instance with the configured providers registered.
  *
- * Pass `openAI` for cloud execution, `onnx` for developer-supplied local models, or both to let
- * routing choose between them; at least one is required.
+ * Pass `openAI` for cloud execution, `onnx` for developer-supplied local models, `systemModel` for
+ * browser-managed on-device models, or any combination to let routing choose between them; at
+ * least one is required.
  *
  * 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

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

@@ -1 +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,EAA0B,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACtF,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AAG9B;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B;;;OAGG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B;;OAEG;IACH,YAAY,CAAC,EAAE,gCAAgC,CAAC;IAChD;;;;;;OAMG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAmB1E"}
+{"version":3,"file":"web-sdk.d.ts","sourceRoot":"","sources":["../src/web-sdk.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gCAAgC,EACtC,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAChG,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,sCAAsC,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B;;;OAGG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B;;;;OAIG;IACH,WAAW,CAAC,EAAE,0BAA0B,CAAC;IACzC;;OAEG;IACH,YAAY,CAAC,EAAE,gCAAgC,CAAC;IAChD;;;;;;OAMG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAuB1E"}