@happyvertical/smrt-planner 0.0.0-stage → 0.0.1

package/dist/forms/variantGrid.js

@@ -0,0 +1,283 @@
+import { contextFrom, findRows, mappedValues, parseTarget, slug, startingValue, targetField, toWriteValues, } from "./shared.js";
+const comboKey = (values) => JSON.stringify(values);
+/**
+ * Split pasted lists on commas, trim, drop blanks and repeats
+ * (case-insensitively), keep the order.
+ */
+export function cleanValues(values) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of values.flatMap((value) => value.split(','))) {
+        const value = raw.trim();
+        const folded = value.toLowerCase();
+        if (!value || seen.has(folded))
+            continue;
+        seen.add(folded);
+        out.push(value);
+    }
+    return out;
+}
+/**
+ * Every combination of the axes' values, rows in axis order. An axis with no
+ * values is left out, so a product with only sizes still gets a cell per size;
+ * no values anywhere means no cells.
+ */
+export function combinations(axes) {
+    const used = axes
+        .map((axis) => ({ name: axis.name, values: cleanValues(axis.values) }))
+        .filter((axis) => axis.values.length > 0);
+    if (used.length === 0)
+        return [];
+    let combos = [[]];
+    for (const axis of used) {
+        combos = combos.flatMap((prefix) => axis.values.map((value) => [...prefix, { name: axis.name, value }]));
+    }
+    return combos.map((parts) => ({
+        key: comboKey(parts.map((p) => p.value)),
+        attributes: Object.fromEntries(parts.map((p) => [p.name, p.value])),
+        values: parts.map((p) => p.value),
+    }));
+}
+/** The grid's combinations for its current state. */
+export function gridCombos(form, state) {
+    return combinations(form.axes.map((axis) => ({
+        name: axis.name,
+        values: state.axes[axis.name] ?? [],
+    })));
+}
+/** Product inputs plus the per-cell inputs the extensions add. */
+export function gridParts(active) {
+    return {
+        productFields: active.form.fields,
+        cellFields: active.extensions.flatMap((ext) => ext.fields ?? []),
+        cellRecords: active.extensions.flatMap((ext) => ext.records ?? []),
+    };
+}
+/** Product inputs with the catalog field they map onto, for rendering. */
+export function gridProductInputs(active, models) {
+    return active.form.fields.map((field) => ({
+        field,
+        catalogField: targetField(field, [active.form.product], models),
+    }));
+}
+/** Cell inputs with the catalog field they map onto. */
+export function gridCellInputs(active, models) {
+    const { cellFields, cellRecords } = gridParts(active);
+    const records = [skuRecord(active.form), ...cellRecords];
+    return cellFields.map((field) => ({
+        field,
+        catalogField: targetField(field, records, models),
+    }));
+}
+const skuRecord = (form) => ({
+    as: 'sku',
+    model: form.skus,
+});
+/** An empty grid: starting values for the product inputs and every axis. */
+export function blankGrid(active, models) {
+    return {
+        values: Object.fromEntries(gridProductInputs(active, models).map(({ field, catalogField }) => [
+            field.id,
+            startingValue(field, catalogField),
+        ])),
+        axes: Object.fromEntries(active.form.axes.map((axis) => [axis.name, [...axis.values]])),
+        cells: {},
+    };
+}
+/** The starting inputs of one cell. */
+export function blankCell(active, models) {
+    return Object.fromEntries(gridCellInputs(active, models).map(({ field, catalogField }) => [
+        field.id,
+        startingValue(field, catalogField),
+    ]));
+}
+/** Parse a JSON-string field (`allowedValues`, `attributes`), leniently. */
+export function parseJson(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function attributesOf(sku) {
+    const parsed = parseJson(sku.attributes);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : {};
+}
+function skuKey(form, sku) {
+    const attributes = attributesOf(sku);
+    const parts = form.axes
+        .filter((axis) => axis.name in attributes)
+        .map((axis) => String(attributes[axis.name]));
+    return parts.length ? comboKey(parts) : undefined;
+}
+/** Load an existing product into a grid: its axes, then a cell per Sku. */
+export async function loadGrid(source, active, models, productId) {
+    const { form } = active;
+    const product = await source.get(models(form.product.model), productId);
+    if (!product)
+        return undefined;
+    const variants = (await source.list(models(form.variants))).filter((row) => row.productId === productId);
+    const skus = (await source.list(models(form.skus))).filter((row) => row.productId === productId);
+    const state = blankGrid(active, models);
+    for (const input of gridProductInputs(active, models)) {
+        const { field } = parseTarget(input.field.to);
+        const value = product[field];
+        if (value !== undefined)
+            state.values[input.field.id] = value;
+    }
+    for (const axis of form.axes) {
+        const row = variants.find((v) => v.axisName === axis.name);
+        const stored = parseJson(row?.allowedValues);
+        state.axes[axis.name] = row
+            ? Array.isArray(stored)
+                ? cleanValues(stored.map(String))
+                : []
+            : [];
+    }
+    const { cellFields, cellRecords } = gridParts(active);
+    const blank = blankCell(active, models);
+    for (const sku of skus) {
+        const key = skuKey(form, sku);
+        if (!key)
+            continue;
+        const rows = await findRows(source, [skuRecord(form), ...cellRecords], { product, sku }, models);
+        state.cells[key] = Object.fromEntries(cellFields.map((field) => {
+            const { alias, field: name } = parseTarget(field.to);
+            const value = rows[alias]?.[name];
+            return [field.id, value === undefined ? blank[field.id] : value];
+        }));
+    }
+    return { state, existing: { productId, variants, skus } };
+}
+/** The Sku code of a new cell: product, then each value, upper-cased. */
+export function skuCode(productName, combo) {
+    return [slug(productName) || 'SKU', ...combo.values.map(slug)]
+        .filter(Boolean)
+        .join('-');
+}
+/**
+ * The related writes that save a variant grid: the product, one
+ * `ProductVariant` per axis that has values (and a delete for one that no
+ * longer does), a `Sku` per combination with its `attributes` pinned (Skus of
+ * combinations that went away are deleted with the rows the extensions keep
+ * under them), then each extension's rows per cell. Pure; `apply` runs it
+ * all or nothing.
+ */
+export function planGridSave(active, models, state, existing) {
+    const { form } = active;
+    const { cellFields, cellRecords } = gridParts(active);
+    const writes = [];
+    const productContext = contextFrom(form.fields, state.values);
+    const productValues = mappedValues(form.fields, form.product.as, state.values);
+    writes.push({
+        op: 'save',
+        as: 'product',
+        model: models(form.product.model),
+        ...(existing ? { id: existing.productId } : {}),
+        onCreate: toWriteValues(form.product.values, productContext),
+        values: productValues,
+    });
+    const variantModel = models(form.variants);
+    form.axes.forEach((axis, index) => {
+        const values = cleanValues(state.axes[axis.name] ?? []);
+        const match = { productId: { ref: 'product' }, axisName: axis.name };
+        if (values.length === 0) {
+            writes.push({ op: 'delete', model: variantModel, match });
+            return;
+        }
+        writes.push({
+            op: 'save',
+            model: variantModel,
+            match,
+            onCreate: { label: axis.label.replace(/s$/i, '') },
+            values: { allowedValues: JSON.stringify(values), sortOrder: index },
+        });
+    });
+    const skuModel = models(form.skus);
+    const combos = gridCombos(form, state);
+    const wanted = new Set(combos.map((c) => c.key));
+    const byKey = new Map((existing?.skus ?? []).flatMap((sku) => {
+        const key = skuKey(form, sku);
+        return key ? [[key, sku]] : [];
+    }));
+    // Skus whose combination left the grid go, with what hangs off them.
+    for (const sku of existing?.skus ?? []) {
+        const key = skuKey(form, sku);
+        if (key && wanted.has(key))
+            continue;
+        for (const record of cellRecords) {
+            const match = Object.fromEntries(Object.entries(record.match ?? {}).flatMap(([field, value]) => typeof value === 'object' && value?.ref === 'sku'
+                ? [[field, sku.id]]
+                : []));
+            if (Object.keys(match).length) {
+                writes.push({ op: 'delete', model: models(record.model), match });
+            }
+        }
+        writes.push({ op: 'delete', model: skuModel, id: sku.id });
+    }
+    const productName = productContext['product.name'];
+    // Codes stay unique in the plan: values that slug alike get a numeric suffix
+    // instead of being found-and-merged as one Sku.
+    const usedCodes = new Set((existing?.skus ?? [])
+        .filter((row) => wanted.has(skuKey(form, row) ?? ''))
+        .map((row) => String(row.code ?? '')));
+    combos.forEach((combo, i) => {
+        const current = byKey.get(combo.key);
+        const label = combo.values.join(' / ');
+        const name = `${String(productName ?? '').trim() || 'Item'} (${label})`;
+        const baseCode = skuCode(productName, combo);
+        let code = baseCode;
+        for (let n = 2; !current && usedCodes.has(code); n++) {
+            code = `${baseCode}-${n}`;
+        }
+        usedCodes.add(code);
+        const skuAlias = `sku#${i}`;
+        const values = {
+            name,
+            attributes: JSON.stringify(combo.attributes),
+        };
+        writes.push(current
+            ? { op: 'save', as: skuAlias, model: skuModel, id: current.id, values }
+            : {
+                op: 'save',
+                as: skuAlias,
+                model: skuModel,
+                match: { productId: { ref: 'product' }, code },
+                onCreate: { active: true },
+                values,
+            });
+        const cell = {
+            ...blankCell(active, models),
+            ...(state.cells[combo.key] ?? {}),
+        };
+        const rename = (alias) => alias === 'product'
+            ? alias
+            : alias === 'sku'
+                ? skuAlias
+                : `${alias}#${i}`;
+        const context = {
+            ...productContext,
+            'sku.name': name,
+            'sku.code': current ? String(current.code ?? code) : code,
+        };
+        for (const record of cellRecords) {
+            const mapped = mappedValues(cellFields, record.as, cell);
+            writes.push({
+                op: 'save',
+                as: rename(record.as),
+                model: models(record.model),
+                ...(record.match
+                    ? { match: toWriteValues(record.match, context, rename) }
+                    : {}),
+                onCreate: toWriteValues(record.values, context, rename),
+                values: mapped,
+            });
+        }
+    });
+    return writes;
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * smrt planner as a package: mount the `Planner` component in a host layout,
+ * drive it with the typed command set (`./commands` has no UI in it), and read
+ * its plan as a compact snapshot.
+ *
+ * @module
+ */
+export { type ByoPresetDefinition, type ConfigResult, type InferenceConfig, type InferenceMode, loadInferenceConfig, parseInferenceConfig, } from './inference/config.ts';
+export { createHostChat, type HostChatOptions, type HostRequest, } from './inference/host.ts';
+export { createOpenAIChat, testConnection } from './inference/openai.ts';
+export { type KitchenConfig, type KitchenEndpoint, type KitchenOutcome, type KitchenResult, parseKitchenConfig, sendToKitchen, } from './kitchen/client.ts';
+export { KITCHEN_FRAGMENT_KEY, type KitchenFragment, readKitchenFragment, } from './kitchen/fragment.ts';
+export { createPlannerAssistant, type PlannerAssistant, type PlannerChatInference, type PlannerConfigInference, type PlannerInference, } from './planner/assistant.ts';
+export * from './planner/commands/index.ts';
+export { plannerController } from './planner/instance.ts';
+export { default as Planner } from './planner/Planner.svelte';
+export type { PlannerHandle, PlannerProps } from './planner/types.ts';

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * smrt planner as a package: mount the `Planner` component in a host layout,
+ * drive it with the typed command set (`./commands` has no UI in it), and read
+ * its plan as a compact snapshot.
+ *
+ * @module
+ */
+export { loadInferenceConfig, parseInferenceConfig, } from "./inference/config.js";
+export { createHostChat, } from "./inference/host.js";
+export { createOpenAIChat, testConnection } from "./inference/openai.js";
+export { parseKitchenConfig, sendToKitchen, } from "./kitchen/client.js";
+export { KITCHEN_FRAGMENT_KEY, readKitchenFragment, } from "./kitchen/fragment.js";
+export { createPlannerAssistant, } from "./planner/assistant.js";
+export * from "./planner/commands/index.js";
+export { plannerController } from "./planner/instance.js";
+export { default as Planner } from './planner/Planner.svelte';

package/dist/inference/byo.svelte.d.ts

@@ -0,0 +1,86 @@
+import type { ChatModel } from '../assistant/transport.ts';
+import type { ByoPresetDefinition } from './config.ts';
+import { type ConnectionResult } from './openai.ts';
+/** Choices (not the key): which endpoint, its address and model, and whether it is in use. */
+export declare const BYO_PREFS_KEY = "smrt-planner:inference:v1";
+/** The keys, apart from the choices so nothing that copies prefs copies a key. */
+export declare const BYO_KEYS_KEY = "smrt-planner:inference-key:v1";
+export interface ByoEntry {
+    baseUrl: string;
+    model: string;
+}
+interface ByoPrefs {
+    preset: string;
+    active: boolean;
+    entries: Record<string, ByoEntry>;
+}
+export declare function loadByoPrefs(storage: Storage | null): ByoPrefs;
+/** A saved key and the origin (scheme, host, port) it was entered for. */
+export interface ByoKey {
+    origin: string;
+    key: string;
+}
+export declare function loadByoKeys(storage: Storage | null): Record<string, ByoKey>;
+export type ByoTestStatus = 'idle' | 'testing' | 'ok' | 'failed';
+export interface ByoOptions {
+    storage: Storage | null;
+    /** The config's `byo.presets`; default all built-ins. */
+    presets?: readonly (string | ByoPresetDefinition)[];
+    fetch?: typeof fetch;
+    /** Called after "use" or "stop using", so the assistant follows. */
+    onChange?: () => void;
+}
+/**
+ * The visitor's own OpenAI-compatible endpoint: the preset they picked, its
+ * address, model and key, a connection test, and whether the assistant uses
+ * it. The key lives only in this browser's localStorage and is only ever sent
+ * as the Authorization header to the chosen address.
+ */
+export declare class ByoModel {
+    readonly presets: ByoPresetDefinition[];
+    presetId: string;
+    entries: Record<string, ByoEntry>;
+    keys: Record<string, ByoKey>;
+    active: boolean;
+    testStatus: ByoTestStatus;
+    testMessage: string;
+    private readonly options;
+    constructor(options: ByoOptions);
+    get preset(): ByoPresetDefinition | undefined;
+    get baseUrl(): string;
+    get model(): string;
+    /**
+     * The saved key, only while the address is the origin it was entered for:
+     * changing the address (or a config that reuses a preset id for another
+     * address) never sends the key somewhere new.
+     */
+    get key(): string;
+    /** A key is saved for this preset, but for another address. */
+    get keyForOtherAddress(): boolean;
+    /** Address valid, model named, and a key where the preset needs one (sendable there). */
+    get complete(): boolean;
+    select(id: string): void;
+    setBaseUrl(baseUrl: string): void;
+    setModel(model: string): void;
+    setKey(key: string): void;
+    /** Remove the saved key for the selected preset. */
+    forgetKey(): void;
+    /** The chat model for what is entered, or null while it is incomplete. */
+    chat(): ChatModel | null;
+    test(): Promise<ConnectionResult>;
+    /** Make the assistant use this endpoint. */
+    use(): boolean;
+    /** Stop using it; the entered values stay. */
+    stop(): void;
+    private resetTest;
+    /** An edit invalidates the last test and, if in use, what is in use. */
+    private edited;
+    private save;
+}
+/**
+ * The chat model for the endpoint a visitor already connected in this browser
+ * (a mounted `Planner` in byo mode has no AI page of its own). Null when none
+ * is connected or what was saved is incomplete.
+ */
+export declare function savedByoChat(storage: Storage | null, presets?: readonly (string | ByoPresetDefinition)[], fetcher?: typeof fetch): ChatModel | null;
+export {};

package/dist/inference/byo.svelte.js

@@ -0,0 +1,267 @@
+import { createOpenAIChat, keyMaySendTo, normalizeBaseUrl, originOf, testConnection, } from "./openai.js";
+import { resolvePresets } from "./presets.js";
+/** Choices (not the key): which endpoint, its address and model, and whether it is in use. */
+export const BYO_PREFS_KEY = 'smrt-planner:inference:v1';
+/** The keys, apart from the choices so nothing that copies prefs copies a key. */
+export const BYO_KEYS_KEY = 'smrt-planner:inference-key:v1';
+const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+export function loadByoPrefs(storage) {
+    const prefs = { preset: '', active: false, entries: {} };
+    try {
+        const raw = storage?.getItem(BYO_PREFS_KEY);
+        if (!raw)
+            return prefs;
+        const value = JSON.parse(raw);
+        if (!isObject(value))
+            return prefs;
+        if (typeof value.preset === 'string')
+            prefs.preset = value.preset;
+        prefs.active = value.active === true;
+        if (isObject(value.entries)) {
+            for (const [id, entry] of Object.entries(value.entries)) {
+                if (isObject(entry) &&
+                    typeof entry.baseUrl === 'string' &&
+                    typeof entry.model === 'string') {
+                    prefs.entries[id] = { baseUrl: entry.baseUrl, model: entry.model };
+                }
+            }
+        }
+    }
+    catch {
+        // Unreadable or unavailable: start empty.
+    }
+    return prefs;
+}
+export function loadByoKeys(storage) {
+    const keys = {};
+    try {
+        const raw = storage?.getItem(BYO_KEYS_KEY);
+        const value = raw ? JSON.parse(raw) : null;
+        if (isObject(value)) {
+            for (const [id, entry] of Object.entries(value)) {
+                // A key with no origin (the format before keys were bound to one) is
+                // not trusted with any address: it is dropped.
+                if (isObject(entry) &&
+                    typeof entry.key === 'string' &&
+                    entry.key &&
+                    typeof entry.origin === 'string' &&
+                    entry.origin) {
+                    keys[id] = { origin: entry.origin, key: entry.key };
+                }
+            }
+        }
+    }
+    catch {
+        // Unreadable or unavailable: no keys.
+    }
+    return keys;
+}
+/**
+ * The visitor's own OpenAI-compatible endpoint: the preset they picked, its
+ * address, model and key, a connection test, and whether the assistant uses
+ * it. The key lives only in this browser's localStorage and is only ever sent
+ * as the Authorization header to the chosen address.
+ */
+export class ByoModel {
+    presets;
+    presetId = $state('');
+    entries = $state({});
+    keys = $state({});
+    active = $state(false);
+    testStatus = $state('idle');
+    testMessage = $state('');
+    options;
+    constructor(options) {
+        this.options = options;
+        this.presets = resolvePresets(options.presets);
+        const prefs = loadByoPrefs(options.storage);
+        this.keys = loadByoKeys(options.storage);
+        this.entries = prefs.entries;
+        this.presetId = this.presets.some((p) => p.id === prefs.preset)
+            ? prefs.preset
+            : (this.presets[0]?.id ?? '');
+        this.active = prefs.active && this.complete;
+    }
+    get preset() {
+        return this.presets.find((p) => p.id === this.presetId);
+    }
+    get baseUrl() {
+        return this.entries[this.presetId]?.baseUrl ?? this.preset?.baseUrl ?? '';
+    }
+    get model() {
+        return this.entries[this.presetId]?.model ?? this.preset?.model ?? '';
+    }
+    /**
+     * The saved key, only while the address is the origin it was entered for:
+     * changing the address (or a config that reuses a preset id for another
+     * address) never sends the key somewhere new.
+     */
+    get key() {
+        const saved = this.keys[this.presetId];
+        return saved && saved.origin === originOf(this.baseUrl) ? saved.key : '';
+    }
+    /** A key is saved for this preset, but for another address. */
+    get keyForOtherAddress() {
+        const saved = this.keys[this.presetId];
+        return !!saved && saved.origin !== originOf(this.baseUrl);
+    }
+    /** Address valid, model named, and a key where the preset needs one (sendable there). */
+    get complete() {
+        const base = normalizeBaseUrl(this.baseUrl);
+        return (!!base &&
+            !!this.model.trim() &&
+            (!!this.preset?.keyless || (!!this.key.trim() && keyMaySendTo(base))));
+    }
+    select(id) {
+        if (!this.presets.some((p) => p.id === id))
+            return;
+        this.presetId = id;
+        this.resetTest();
+        this.save();
+    }
+    setBaseUrl(baseUrl) {
+        this.entries = {
+            ...this.entries,
+            [this.presetId]: { baseUrl, model: this.model },
+        };
+        this.edited();
+    }
+    setModel(model) {
+        this.entries = {
+            ...this.entries,
+            [this.presetId]: { baseUrl: this.baseUrl, model },
+        };
+        this.edited();
+    }
+    setKey(key) {
+        const origin = originOf(this.baseUrl);
+        const clean = key.trim();
+        if (!clean || !origin) {
+            this.forgetKey();
+            return;
+        }
+        this.keys = { ...this.keys, [this.presetId]: { origin, key: clean } };
+        this.edited();
+    }
+    /** Remove the saved key for the selected preset. */
+    forgetKey() {
+        const { [this.presetId]: _gone, ...rest } = this.keys;
+        this.keys = rest;
+        this.edited();
+    }
+    /** The chat model for what is entered, or null while it is incomplete. */
+    chat() {
+        if (!this.complete)
+            return null;
+        const baseUrl = normalizeBaseUrl(this.baseUrl);
+        if (!baseUrl)
+            return null;
+        return createOpenAIChat({
+            baseUrl,
+            model: this.model.trim(),
+            apiKey: this.preset?.keyless ? undefined : this.key,
+            fetch: this.options.fetch,
+        });
+    }
+    async test() {
+        const baseUrl = normalizeBaseUrl(this.baseUrl);
+        if (!baseUrl || !this.model.trim()) {
+            this.testStatus = 'failed';
+            this.testMessage = 'Enter an http(s) address and a model first.';
+            return { ok: false, message: this.testMessage };
+        }
+        if (!this.preset?.keyless && !this.key.trim()) {
+            this.testStatus = 'failed';
+            this.testMessage = this.keyForOtherAddress
+                ? 'The saved key was entered for another address. Enter it again for this one.'
+                : 'Enter a key first.';
+            return { ok: false, message: this.testMessage };
+        }
+        if (!this.preset?.keyless && !keyMaySendTo(baseUrl)) {
+            this.testStatus = 'failed';
+            this.testMessage =
+                'A key is only sent over https, or to this computer. Use an https address.';
+            return { ok: false, message: this.testMessage };
+        }
+        this.testStatus = 'testing';
+        this.testMessage = '';
+        const result = await testConnection({
+            baseUrl,
+            model: this.model.trim(),
+            apiKey: this.preset?.keyless ? undefined : this.key,
+            fetch: this.options.fetch,
+        });
+        this.testStatus = result.ok ? 'ok' : 'failed';
+        this.testMessage = result.message;
+        return result;
+    }
+    /** Make the assistant use this endpoint. */
+    use() {
+        if (!this.complete)
+            return false;
+        this.active = true;
+        this.save();
+        this.options.onChange?.();
+        return true;
+    }
+    /** Stop using it; the entered values stay. */
+    stop() {
+        this.active = false;
+        this.save();
+        this.options.onChange?.();
+    }
+    resetTest() {
+        this.testStatus = 'idle';
+        this.testMessage = '';
+    }
+    /** An edit invalidates the last test and, if in use, what is in use. */
+    edited() {
+        this.resetTest();
+        const wasActive = this.active;
+        if (wasActive && !this.complete)
+            this.active = false;
+        this.save();
+        if (wasActive)
+            this.options.onChange?.();
+    }
+    save() {
+        try {
+            const prefs = {
+                preset: this.presetId,
+                active: this.active,
+                entries: { ...this.entries },
+            };
+            this.options.storage?.setItem(BYO_PREFS_KEY, JSON.stringify(prefs));
+            this.options.storage?.setItem(BYO_KEYS_KEY, JSON.stringify(this.keys));
+        }
+        catch {
+            // Not saved; the choice still holds for this visit.
+        }
+    }
+}
+/**
+ * The chat model for the endpoint a visitor already connected in this browser
+ * (a mounted `Planner` in byo mode has no AI page of its own). Null when none
+ * is connected or what was saved is incomplete.
+ */
+export function savedByoChat(storage, presets, fetcher) {
+    const prefs = loadByoPrefs(storage);
+    if (!prefs.active)
+        return null;
+    const preset = resolvePresets(presets).find((p) => p.id === prefs.preset);
+    const entry = prefs.entries[prefs.preset];
+    const baseUrl = normalizeBaseUrl(entry?.baseUrl ?? preset?.baseUrl ?? '');
+    const model = (entry?.model ?? preset?.model ?? '').trim();
+    const saved = loadByoKeys(storage)[prefs.preset];
+    const key = saved && saved.origin === originOf(baseUrl ?? '') ? saved.key : '';
+    if (!preset || !baseUrl || !model)
+        return null;
+    if (!preset.keyless && (!key || !keyMaySendTo(baseUrl)))
+        return null;
+    return createOpenAIChat({
+        baseUrl,
+        model,
+        apiKey: preset.keyless ? undefined : key,
+        fetch: fetcher,
+    });
+}