@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/assistant/models.js

@@ -0,0 +1,57 @@
+export const DEFAULT_MODEL_ID = 'Qwen3-1.7B-q4f16_1-MLC';
+/** Small instruction-tuned models; the first is the default. */
+export const ASSISTANT_MODELS = [
+    {
+        id: DEFAULT_MODEL_ID,
+        label: 'Qwen3 1.7B (recommended)',
+        downloadMB: 1100,
+        vramMB: 2037,
+    },
+    {
+        id: 'Llama-3.2-1B-Instruct-q4f16_1-MLC',
+        label: 'Llama 3.2 1B (smallest)',
+        downloadMB: 700,
+        vramMB: 879,
+    },
+    {
+        id: 'Qwen3-4B-q4f16_1-MLC',
+        label: 'Qwen3 4B (smarter, larger)',
+        downloadMB: 2300,
+        vramMB: 3432,
+    },
+];
+export function getModel(id) {
+    return ASSISTANT_MODELS.find((model) => model.id === id);
+}
+/** "about 1.1 GB" / "about 700 MB". */
+export function formatSize(megabytes) {
+    return megabytes >= 1000
+        ? `about ${(megabytes / 1000).toFixed(1)} GB`
+        : `about ${megabytes} MB`;
+}
+/** The label without its advice: "Qwen3 1.7B (recommended)" -> "Qwen3 1.7B". */
+export function shortLabel(model) {
+    return model.label.replace(/\s*\(.*\)\s*$/, '');
+}
+/** The model to suggest when the graphics card has room for it. */
+export const ROOMY_MODEL_ID = 'Qwen3-4B-q4f16_1-MLC';
+/**
+ * Whether a graphics card whose largest single buffer is `maxBufferBytes` has
+ * room for the model (with some headroom). The default stays the default for
+ * small cards.
+ */
+export function hasRoomFor(model, maxBufferBytes) {
+    return maxBufferBytes >= model.vramMB * 1_000_000 * 1.2;
+}
+/** The largest buffer the graphics card allows, or 0 when unknown. */
+export async function graphicsBufferLimit(nav = typeof navigator === 'undefined'
+    ? undefined
+    : navigator) {
+    try {
+        const adapter = await nav?.gpu?.requestAdapter();
+        return adapter?.limits?.maxBufferSize ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/assistant/offers.svelte.d.ts

@@ -0,0 +1,36 @@
+import type { LibraryCookbook } from '../library/types.ts';
+export type OfferStatus = 'pending' | 'applied' | 'declined' | 'replaced' | 'failed';
+export interface Offer {
+    id: string;
+    cookbookId: string;
+    status: OfferStatus;
+    error: string;
+}
+/** What a chat message carries (`toolCallData`) to render its offer. */
+export interface OfferRef {
+    kind: 'cookbook-offer';
+    offerId: string;
+}
+export declare const isOfferRef: (value: unknown) => value is OfferRef;
+/** Applies a cookbook (the Cookbooks tab's path); returns an error or null. */
+export type CookbookApplier = (cookbook: LibraryCookbook) => string | null;
+/**
+ * Cookbooks the assistant proposed. Applying one replaces the recipes, menu
+ * and sample records, so an offer only ever applies from `accept`, which the
+ * person's click calls. A newer offer replaces a pending one (latest wins).
+ */
+export declare class CookbookOffers {
+    private readonly find;
+    offers: Record<string, Offer>;
+    /** Set by the component that can reach the data source. */
+    applier: CookbookApplier | null;
+    private counter;
+    constructor(find: (id: string) => LibraryCookbook | undefined);
+    pending(): Offer | undefined;
+    /** Whether a cookbook is already applied or waiting for the person's click. */
+    engaged(): boolean;
+    /** Propose a cookbook. Returns null when the same one is already pending. */
+    offer(cookbookId: string): OfferRef | null;
+    accept(offerId: string): void;
+    decline(offerId: string): void;
+}

package/dist/assistant/offers.svelte.js

@@ -0,0 +1,59 @@
+export const isOfferRef = (value) => !!value &&
+    typeof value === 'object' &&
+    value.kind === 'cookbook-offer' &&
+    typeof value.offerId === 'string';
+/**
+ * Cookbooks the assistant proposed. Applying one replaces the recipes, menu
+ * and sample records, so an offer only ever applies from `accept`, which the
+ * person's click calls. A newer offer replaces a pending one (latest wins).
+ */
+export class CookbookOffers {
+    find;
+    offers = $state({});
+    /** Set by the component that can reach the data source. */
+    applier = null;
+    counter = 0;
+    constructor(find) {
+        this.find = find;
+    }
+    pending() {
+        return Object.values(this.offers).find((o) => o.status === 'pending');
+    }
+    /** Whether a cookbook is already applied or waiting for the person's click. */
+    engaged() {
+        return Object.values(this.offers).some((o) => o.status === 'pending' || o.status === 'applied');
+    }
+    /** Propose a cookbook. Returns null when the same one is already pending. */
+    offer(cookbookId) {
+        const open = this.pending();
+        if (open?.cookbookId === cookbookId)
+            return null;
+        if (open)
+            open.status = 'replaced';
+        const id = `offer-${++this.counter}`;
+        this.offers[id] = { id, cookbookId, status: 'pending', error: '' };
+        return { kind: 'cookbook-offer', offerId: id };
+    }
+    accept(offerId) {
+        const offer = this.offers[offerId];
+        if (offer?.status !== 'pending')
+            return;
+        const cookbook = this.find(offer.cookbookId);
+        const error = !cookbook
+            ? 'Unknown cookbook.'
+            : !this.applier
+                ? 'Not ready yet.'
+                : this.applier(cookbook);
+        if (error || !cookbook) {
+            offer.status = 'failed';
+            offer.error = error ?? 'Could not set it up.';
+            return;
+        }
+        offer.status = 'applied';
+    }
+    decline(offerId) {
+        const offer = this.offers[offerId];
+        if (offer?.status === 'pending')
+            offer.status = 'declined';
+    }
+}

package/dist/assistant/prefs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A UI preference, not part of the cookbook: which model to use and which the
+ * visitor has agreed to download. Kept in localStorage; every access is
+ * guarded because it can throw or be empty (private windows, blocked storage).
+ */
+export interface AssistantPrefs {
+    modelId: string;
+    /** Models whose download the visitor has accepted. */
+    consented: string[];
+}
+export declare const PREFS_KEY = "smrt-planner:assistant:v1";
+export declare function defaultPrefs(): AssistantPrefs;
+export declare function loadPrefs(storage: Storage | null): AssistantPrefs;
+export declare function savePrefs(storage: Storage | null, prefs: AssistantPrefs): void;

package/dist/assistant/prefs.js

@@ -0,0 +1,32 @@
+import { DEFAULT_MODEL_ID, getModel } from "./models.js";
+export const PREFS_KEY = 'smrt-planner:assistant:v1';
+export function defaultPrefs() {
+    return { modelId: DEFAULT_MODEL_ID, consented: [] };
+}
+export function loadPrefs(storage) {
+    const prefs = defaultPrefs();
+    try {
+        const raw = storage?.getItem(PREFS_KEY);
+        if (!raw)
+            return prefs;
+        const value = JSON.parse(raw);
+        if (typeof value.modelId === 'string' && getModel(value.modelId)) {
+            prefs.modelId = value.modelId;
+        }
+        if (Array.isArray(value.consented)) {
+            prefs.consented = value.consented.filter((id) => typeof id === 'string' && !!getModel(id));
+        }
+    }
+    catch {
+        // Unreadable or unavailable: start from the defaults.
+    }
+    return prefs;
+}
+export function savePrefs(storage, prefs) {
+    try {
+        storage?.setItem(PREFS_KEY, JSON.stringify(prefs));
+    }
+    catch {
+        // Not saved; the choice still holds for this visit.
+    }
+}

package/dist/assistant/prompt.d.ts

@@ -0,0 +1,23 @@
+import type { LibraryCookbook } from '../library/types.ts';
+import type { Recipe } from '../recipes/types.ts';
+import type { AppSettings } from '../settings/app-settings.ts';
+import { type ThemeSetting } from '../theme/theme.ts';
+import type { Match } from './match.ts';
+/** The slice of a cookbook the model needs to pick one. */
+export type CookbookBrief = Pick<LibraryCookbook, 'id' | 'name' | 'summary'> & Partial<Pick<LibraryCookbook, 'keywords'>>;
+/** Tax is shown as a percent, the unit the person says it in. */
+export declare function formatTaxPercent(fraction: number): string;
+/**
+ * The system prompt: what the assistant is, how little to say, the recipes it
+ * may use, the cookbooks it may offer, the current settings and which recipes
+ * are on now. Short on purpose, for a 1-2B model.
+ *
+ * With `matches` (keyword matches for the person's message, possibly none) the
+ * prompt is focused: full lines (id, label, summary, synonyms) only for the
+ * matched and currently-on recipes and cookbooks, a compact list of the rest,
+ * and a hint line naming what looks relevant. Without it every item gets a
+ * full line. The response schema lists every id either way.
+ */
+export declare function buildSystemPrompt(recipes: readonly Recipe[], current: readonly string[], cookbooks?: readonly CookbookBrief[], settings?: AppSettings, matches?: readonly Match[], themeInfo?: {
+    current: ThemeSetting | undefined;
+}): string;

package/dist/assistant/prompt.js

@@ -0,0 +1,163 @@
+import { describeTheme } from "../theme/theme.js";
+/** Most matched items given full lines; the rest stay in the compact list. */
+const MAX_FOCUSED_RECIPES = 5;
+const MAX_FOCUSED_COOKBOOKS = 2;
+const EXAMPLES = [
+    {
+        says: 'I run a bakery',
+        cookbook: 'bakery',
+        answer: {
+            reply: 'The Bakery cookbook covers that.',
+            add: [],
+            remove: [],
+            cookbook: 'bakery',
+        },
+    },
+    {
+        says: 'I need to send invoices',
+        recipes: ['commerce.invoicing'],
+        answer: {
+            reply: 'Added invoicing for billing customers.',
+            add: ['commerce.invoicing'],
+            remove: [],
+        },
+    },
+    {
+        says: "we don't need the pipeline",
+        recipes: ['sales.pipeline'],
+        answer: {
+            reply: 'Removed leads and pipeline.',
+            add: [],
+            remove: ['sales.pipeline'],
+        },
+    },
+    {
+        says: "we're in Canada, 13% tax",
+        settings: true,
+        answer: {
+            reply: 'Set to Canadian dollars and 13% tax.',
+            add: [],
+            remove: [],
+            settings: { currency: 'CAD', taxRate: 13 },
+        },
+    },
+    {
+        says: 'make it warmer',
+        theme: true,
+        answer: {
+            reply: 'Gave it a warm amber brand colour.',
+            add: [],
+            remove: [],
+            theme: { primary: '#d97706' },
+        },
+    },
+    {
+        says: 'hello',
+        answer: { reply: 'Hi. What kind of business is it?', add: [], remove: [] },
+    },
+];
+function examples(recipeIds, cookbookIds, withSettings, withTheme) {
+    return EXAMPLES.filter((e) => (e.recipes ?? []).every((id) => recipeIds.has(id)) &&
+        (!e.cookbook || cookbookIds.has(e.cookbook)) &&
+        (!e.settings || withSettings) &&
+        (!e.theme || withTheme)).map((e) => `"${e.says}" -> ${JSON.stringify(e.answer)}`);
+}
+/** Tax is shown as a percent, the unit the person says it in. */
+export function formatTaxPercent(fraction) {
+    return `${Number((fraction * 100).toFixed(4))}%`;
+}
+/**
+ * The system prompt: what the assistant is, how little to say, the recipes it
+ * may use, the cookbooks it may offer, the current settings and which recipes
+ * are on now. Short on purpose, for a 1-2B model.
+ *
+ * With `matches` (keyword matches for the person's message, possibly none) the
+ * prompt is focused: full lines (id, label, summary, synonyms) only for the
+ * matched and currently-on recipes and cookbooks, a compact list of the rest,
+ * and a hint line naming what looks relevant. Without it every item gets a
+ * full line. The response schema lists every id either way.
+ */
+export function buildSystemPrompt(recipes, current, cookbooks = [], settings, matches, themeInfo) {
+    const focused = matches !== undefined;
+    const matchedRecipes = (matches ?? [])
+        .filter((m) => m.kind === 'recipe')
+        .slice(0, MAX_FOCUSED_RECIPES)
+        .map((m) => m.id);
+    const matchedCookbooks = (matches ?? [])
+        .filter((m) => m.kind === 'cookbook')
+        .slice(0, MAX_FOCUSED_COOKBOOKS)
+        .map((m) => m.id);
+    const fullRecipe = new Set([...matchedRecipes, ...current]);
+    const fullCookbook = new Set(matchedCookbooks);
+    const recipeLine = (recipe) => {
+        const also = recipe.synonyms.length
+            ? ` Also called: ${recipe.synonyms.join(', ')}.`
+            : '';
+        return `- ${recipe.id}: ${recipe.label}. ${recipe.summary}${also}`;
+    };
+    const out = [
+        'You help assemble a small business app. Reply as JSON.',
+        '"reply": answer what they just said in one sentence of 12 words or fewer. No greeting; never repeat a reply.',
+        '"add"/"remove": recipe ids, only what they ask to add or drop; else []. Dependencies are automatic.',
+    ];
+    if (cookbooks.length) {
+        out.push('"cookbook": id only if their business clearly fits, else null.');
+    }
+    if (settings) {
+        out.push('"settings": only what they state: currency (ISO), taxRate (percent), paymentTerms; else omit, and do not mention them otherwise.');
+    }
+    if (themeInfo) {
+        out.push('"theme": only if they ask for a look: {"preset": material|glass|studio|smrt|happyvertical} or {"primary": "#rrggbb"}, optional "colorScheme": light|dark; else omit.');
+    }
+    const shown = examples(new Set(recipes.map((r) => r.id)), new Set(cookbooks.map((c) => c.id)), Boolean(settings), Boolean(themeInfo));
+    if (shown.length)
+        out.push('', 'Examples:', ...shown);
+    const themeHint = !!themeInfo && (matches ?? []).some((m) => m.kind === 'theme');
+    if (matchedRecipes.length || matchedCookbooks.length || themeHint) {
+        const parts = [];
+        if (themeHint)
+            parts.push('theming (use "theme")');
+        if (matchedCookbooks.length) {
+            parts.push(`cookbook ${matchedCookbooks.join(', ')}`);
+        }
+        if (matchedRecipes.length) {
+            parts.push(`recipes ${matchedRecipes.join(', ')}`);
+        }
+        out.push('', `Looks relevant: ${parts.join('; ')}.`);
+    }
+    const cookbookLine = (c) => `- ${c.id}: ${c.name}. ${c.summary}`;
+    const compact = (items) => items.join(', ');
+    const fullRecipes = recipes.filter((r) => !focused || fullRecipe.has(r.id));
+    const otherRecipes = focused
+        ? recipes.filter((r) => !fullRecipe.has(r.id))
+        : [];
+    out.push('');
+    if (fullRecipes.length)
+        out.push('Recipes:', ...fullRecipes.map(recipeLine));
+    if (otherRecipes.length) {
+        out.push(`Other recipes: ${compact(otherRecipes.map((r) => `${r.id} (${r.label})`))}.`);
+    }
+    if (cookbooks.length) {
+        const fullBooks = cookbooks.filter((c) => !focused || fullCookbook.has(c.id));
+        const otherBooks = focused
+            ? cookbooks.filter((c) => !fullCookbook.has(c.id))
+            : [];
+        out.push('');
+        if (fullBooks.length)
+            out.push('Cookbooks:', ...fullBooks.map(cookbookLine));
+        if (otherBooks.length) {
+            out.push(`Other cookbooks: ${compact(otherBooks.map((c) => `${c.id} (${c.name})`))}.`);
+        }
+    }
+    out.push('', `Currently on: ${current.length ? current.join(', ') : 'none'}.`);
+    if (settings) {
+        const terms = settings.paymentTerms
+            ? `, terms ${settings.paymentTerms}`
+            : '';
+        out.push(`Settings: currency ${settings.currency}, tax ${formatTaxPercent(settings.taxRate)}${terms}.`);
+    }
+    if (themeInfo) {
+        out.push(`Theme: ${describeTheme(themeInfo.current)}.`);
+    }
+    return out.join('\n');
+}

package/dist/assistant/session.svelte.d.ts

@@ -0,0 +1,74 @@
+import type { InferenceMode } from '../inference/config.ts';
+import type { PlannerController } from '../planner/commands/index.ts';
+import type { Recipe } from '../recipes/types.ts';
+import type { RecipeStore, SettingsStore, ThemeStore } from './change.ts';
+import { type EngineHost, type LoadProgress } from './engine.ts';
+import { CookbookOffers } from './offers.svelte.ts';
+import { type AssistantPrefs } from './prefs.ts';
+import { ThemeUndos } from './theme-undo.svelte.ts';
+import { type BrowserAssistantTransport, type ChatModel } from './transport.ts';
+/**
+ * Qwen3 reasons before it answers unless told not to; its `/no_think` switch
+ * skips that, which is slow and pointless for a short structured reply. The
+ * grammar-constrained JSON already keeps any thinking out of the output.
+ */
+export declare function withoutThinking(chat: ChatModel, modelId: string): ChatModel;
+export type SessionStatus = 'unsupported' | 'idle' | 'loading' | 'ready' | 'error';
+export interface SessionOptions {
+    store: RecipeStore;
+    recipes: readonly Recipe[];
+    /** The app settings the assistant may change; omit to leave them out. */
+    settings?: SettingsStore;
+    /** The app theme the assistant may change (with Undo); omit to leave it out. */
+    theme?: ThemeStore;
+    /** The controller the assistant's changes go through; made from the slices if omitted. */
+    controller?: PlannerController;
+    storage: Storage | null;
+    /** Defaults to the browser's WebGPU check. */
+    webgpu?: () => boolean;
+    host?: EngineHost;
+    /** Called with each reply the model produced, e.g. to read it aloud. */
+    onReply?: (text: string) => void;
+}
+/**
+ * The assistant's lifecycle: nothing is downloaded until the visitor accepts
+ * the model's size (`start`), loading reports progress and can be cancelled,
+ * and `unload` frees the GPU. The transport talks to whatever is loaded.
+ */
+export declare class AssistantSession {
+    status: SessionStatus;
+    prefs: AssistantPrefs;
+    progress: LoadProgress;
+    error: string;
+    /** Where the model runs. `browser` loads WebLLM here; the others are remote. */
+    mode: InferenceMode;
+    /** Remote modes: what the visitor sees as the model, e.g. `gpt-4o-mini`. */
+    remoteLabel: string;
+    readonly transport: BrowserAssistantTransport;
+    /** Cookbooks the assistant proposed, applied only by the person's click. */
+    readonly offers: CookbookOffers;
+    /** Theme changes the assistant made, each undoable from the chat. */
+    readonly themeUndos: ThemeUndos | null;
+    private loaded;
+    private chat;
+    private abort;
+    private loadGeneration;
+    private readonly options;
+    constructor(options: SessionOptions);
+    /**
+     * Choose where the model runs. `host` and `byo` need no WebGPU and no
+     * download; the chat is set with `useRemote`.
+     */
+    setMode(mode: InferenceMode): void;
+    /** The remote chat model, or null when none is connected (byo, before setup). */
+    useRemote(chat: ChatModel | null, label: string): void;
+    /** Whether the visitor already accepted the selected model's download. */
+    get consented(): boolean;
+    select(modelId: string): void;
+    /** Load the selected model. The caller has shown its size and got consent. */
+    start(): Promise<void>;
+    /** Stop a download in progress. */
+    cancel(): void;
+    /** Free the model, for example to choose another. */
+    unload(): void;
+}

package/dist/assistant/session.svelte.js

@@ -0,0 +1,181 @@
+import { isWebGPUAvailable, WebLLMProvider } from '@happyvertical/ai/local';
+import { getLibraryCookbook, libraryCookbooks } from "../library/index.js";
+import { browserHost, loadModel, } from "./engine.js";
+import { getModel } from "./models.js";
+import { CookbookOffers } from "./offers.svelte.js";
+import { loadPrefs, savePrefs } from "./prefs.js";
+import { ThemeUndos } from "./theme-undo.svelte.js";
+import { createBrowserAssistantTransport, } from "./transport.js";
+/**
+ * Qwen3 reasons before it answers unless told not to; its `/no_think` switch
+ * skips that, which is slow and pointless for a short structured reply. The
+ * grammar-constrained JSON already keeps any thinking out of the output.
+ */
+export function withoutThinking(chat, modelId) {
+    if (!/^qwen3/i.test(modelId))
+        return chat;
+    return {
+        message: (text, options) => chat.message(`${text} /no_think`, options),
+    };
+}
+/**
+ * The assistant's lifecycle: nothing is downloaded until the visitor accepts
+ * the model's size (`start`), loading reports progress and can be cancelled,
+ * and `unload` frees the GPU. The transport talks to whatever is loaded.
+ */
+export class AssistantSession {
+    status = $state('idle');
+    prefs = $state({ modelId: '', consented: [] });
+    progress = $state({ progress: 0, text: '' });
+    error = $state('');
+    /** Where the model runs. `browser` loads WebLLM here; the others are remote. */
+    mode = $state('browser');
+    /** Remote modes: what the visitor sees as the model, e.g. `gpt-4o-mini`. */
+    remoteLabel = $state('');
+    transport;
+    /** Cookbooks the assistant proposed, applied only by the person's click. */
+    offers = new CookbookOffers(getLibraryCookbook);
+    /** Theme changes the assistant made, each undoable from the chat. */
+    themeUndos;
+    loaded = null;
+    chat = null;
+    abort = null;
+    loadGeneration = 0;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.prefs = loadPrefs(options.storage);
+        this.status = (options.webgpu ?? isWebGPUAvailable)()
+            ? 'idle'
+            : 'unsupported';
+        this.themeUndos = options.theme
+            ? new ThemeUndos(options.theme, options.controller)
+            : null;
+        this.transport = createBrowserAssistantTransport({
+            model: () => this.chat,
+            store: options.store,
+            recipes: options.recipes,
+            cookbooks: libraryCookbooks,
+            offers: this.offers,
+            settings: options.settings,
+            theme: options.theme,
+            controller: options.controller,
+            themeUndos: this.themeUndos ?? undefined,
+            acceptCommands: () => this.mode === 'host',
+            unavailable: () => this.mode === 'byo'
+                ? 'Connect your model on the AI page first, then I can help. The cards on the Planner page work without one.'
+                : this.mode === 'host'
+                    ? 'The assistant is not available right now. The cards on the Planner page work without it.'
+                    : this.mode === 'manual'
+                        ? 'Inference is off. The cards on the Planner page work without it.'
+                        : 'Download a model first, then I can help. The cards on the Planner page work without one.',
+            onReply: (text) => options.onReply?.(text),
+        });
+    }
+    /**
+     * Choose where the model runs. `host` and `byo` need no WebGPU and no
+     * download; the chat is set with `useRemote`.
+     */
+    setMode(mode) {
+        if (mode !== this.mode)
+            this.unload();
+        this.mode = mode;
+        if (mode !== 'browser') {
+            this.status = 'idle';
+        }
+        else if (!(this.options.webgpu ?? isWebGPUAvailable)()) {
+            this.status = 'unsupported';
+        }
+        else {
+            this.status = 'idle';
+        }
+    }
+    /** The remote chat model, or null when none is connected (byo, before setup). */
+    useRemote(chat, label) {
+        if (this.mode === 'browser')
+            return;
+        this.chat = chat;
+        this.remoteLabel = chat ? label : '';
+        this.status = chat ? 'ready' : 'idle';
+    }
+    /** Whether the visitor already accepted the selected model's download. */
+    get consented() {
+        return this.prefs.consented.includes(this.prefs.modelId);
+    }
+    select(modelId) {
+        if (!getModel(modelId) || this.status === 'loading')
+            return;
+        this.prefs = { ...this.prefs, modelId };
+        savePrefs(this.options.storage, this.prefs);
+    }
+    /** Load the selected model. The caller has shown its size and got consent. */
+    async start() {
+        if (this.status === 'loading' || this.status === 'unsupported')
+            return;
+        const modelId = this.prefs.modelId;
+        if (!getModel(modelId))
+            return;
+        this.status = 'loading';
+        this.error = '';
+        this.progress = { progress: 0, text: 'Starting' };
+        const abort = new AbortController();
+        const generation = ++this.loadGeneration;
+        this.abort = abort;
+        try {
+            const loaded = await loadModel(modelId, (report) => {
+                this.progress = report;
+            }, abort.signal, this.options.host ?? browserHost);
+            if (generation !== this.loadGeneration || this.mode !== 'browser') {
+                loaded.dispose();
+                return;
+            }
+            this.loaded = loaded;
+            // Consent is recorded only once the download completed: a cancelled or
+            // failed attempt must show the size and memory warning again.
+            this.prefs = {
+                ...this.prefs,
+                consented: [...new Set([...this.prefs.consented, modelId])],
+            };
+            savePrefs(this.options.storage, this.prefs);
+            this.chat = withoutThinking(new WebLLMProvider({
+                type: 'webllm',
+                engine: loaded.engine,
+                model: modelId,
+            }), modelId);
+            this.status = 'ready';
+        }
+        catch (error) {
+            if (generation !== this.loadGeneration)
+                return;
+            if (abort.signal.aborted) {
+                this.status = 'idle';
+            }
+            else {
+                this.error = error instanceof Error ? error.message : String(error);
+                this.status = 'error';
+            }
+        }
+        finally {
+            if (generation === this.loadGeneration)
+                this.abort = null;
+        }
+    }
+    /** Stop a download in progress. */
+    cancel() {
+        this.abort?.abort();
+    }
+    /** Free the model, for example to choose another. */
+    unload() {
+        // A load in progress is aborted too, which terminates its worker.
+        this.loadGeneration += 1;
+        const abort = this.abort;
+        this.abort = null;
+        abort?.abort();
+        this.transport.abort();
+        this.loaded?.dispose();
+        this.loaded = null;
+        this.chat = null;
+        if (this.status !== 'unsupported')
+            this.status = 'idle';
+    }
+}