@happyvertical/smrt-planner 0.0.0-stage → 0.0.2

package/dist/inference/byo.svelte.js

@@ -0,0 +1,295 @@
+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;
+        let sanitized = false;
+        if (isObject(value.entries)) {
+            for (const [id, entry] of Object.entries(value.entries)) {
+                if (isObject(entry) &&
+                    typeof entry.baseUrl === 'string' &&
+                    typeof entry.model === 'string') {
+                    const baseUrl = normalizeBaseUrl(entry.baseUrl) ?? '';
+                    sanitized ||= baseUrl !== entry.baseUrl;
+                    prefs.entries[id] = { baseUrl, model: entry.model };
+                }
+            }
+        }
+        if (sanitized) {
+            prefs.active = false;
+            storage?.setItem(BYO_PREFS_KEY, JSON.stringify(prefs));
+        }
+    }
+    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 in the configured credential store (tab memory for hosted
+ * policies, localStorage for the compatible standalone default) 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;
+    credentialStorage;
+    constructor(options) {
+        this.options = options;
+        this.credentialStorage =
+            options.credentialPersistence === 'memory' ? null : options.storage;
+        if (options.credentialPersistence === 'memory') {
+            // A hosted memory-only policy also removes a key an older local policy
+            // may have left on this origin. Endpoint/model preferences stay put.
+            try {
+                options.storage?.removeItem(BYO_KEYS_KEY);
+            }
+            catch {
+                // Storage can be unavailable; memory-only behavior still holds.
+            }
+        }
+        this.presets = resolvePresets(options.presets);
+        const prefs = loadByoPrefs(options.storage);
+        this.keys = loadByoKeys(this.credentialStorage);
+        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 entries = Object.fromEntries(Object.entries(this.entries).map(([id, entry]) => [
+                id,
+                {
+                    baseUrl: normalizeBaseUrl(entry.baseUrl) ?? '',
+                    model: entry.model,
+                },
+            ]));
+            const prefs = {
+                preset: this.presetId,
+                active: this.active,
+                entries,
+            };
+            this.options.storage?.setItem(BYO_PREFS_KEY, JSON.stringify(prefs));
+            this.credentialStorage?.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, credentialPersistence = 'local') {
+    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(credentialPersistence === 'memory' ? null : 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,
+    });
+}

package/dist/inference/config.d.ts

@@ -0,0 +1,77 @@
+import { type KitchenEndpoint } from '../kitchen/client.ts';
+/**
+ * Where the assistant's language model runs, chosen at runtime by
+ * `planner.config.json` (served next to the app, like a host page's own
+ * config file) or by a mounted `Planner`'s `inference` prop, which wins.
+ *
+ * - `browser`: a small model on this device (WebLLM). The default.
+ * - `host`: the host page's server endpoint; the server owns the prompt.
+ * - `byo`: the visitor's own OpenAI-compatible endpoint (Ollama, OpenRouter,
+ *   OpenAI, custom), configured on the AI page.
+ */
+export type InferenceMode = 'manual' | 'browser' | 'host' | 'byo';
+/** Where BYO provider credentials may live. Preferences are always separate. */
+export type CredentialPersistence = 'local' | 'memory';
+export declare const INFERENCE_MODES: readonly InferenceMode[];
+/** A bring-your-own endpoint the AI page offers. */
+export interface ByoPresetDefinition {
+    id: string;
+    label: string;
+    /** OpenAI-compatible base, e.g. `http://localhost:11434/v1`; `/chat/completions` is appended. */
+    baseUrl: string;
+    /** A model to suggest. */
+    model?: string;
+    /** The visitor types the base URL themselves. */
+    customUrl?: boolean;
+    /** No key is needed (a local server). */
+    keyless?: boolean;
+    /** Browser-access note shown with the preset. */
+    cors?: string;
+}
+export interface InferenceConfig {
+    mode: InferenceMode;
+    /** Other modes the visitor may deliberately select, in display order. */
+    alternatives?: InferenceMode[];
+    /** Defaults to `local` for compatibility. Hosted apps should use `memory`. */
+    credentialPersistence?: CredentialPersistence;
+    host?: {
+        endpoint: string;
+    };
+    byo?: {
+        /**
+         * Which presets to offer: ids of the built-in ones (`ollama`,
+         * `openrouter`, `openai`, `custom`) or full definitions. Default: all
+         * built-in presets.
+         */
+        presets?: (string | ByoPresetDefinition)[];
+    };
+}
+export declare const DEFAULT_INFERENCE: InferenceConfig;
+export declare const MANUAL_INFERENCE: InferenceConfig;
+/** The file name, served at `${base}/planner.config.json`. */
+export declare const CONFIG_FILE = "planner.config.json";
+export interface ConfigResult {
+    config: InferenceConfig;
+    /** The `kitchen` block (`smrt kitchen`), when the file has a usable one. */
+    kitchen?: KitchenEndpoint;
+    /** Shown when a present config was unusable and inference was disabled. */
+    notice?: string;
+}
+/** http(s) only; a path-only endpoint (`/api/planner/chat`) is the host's own origin. */
+export declare function isUsableEndpoint(value: unknown): value is string;
+/**
+ * Validate a parsed config. A missing config keeps the standalone browser
+ * default. A present but invalid config fails closed to manual planning with a
+ * visible notice; it never selects a provider or downloads a model.
+ */
+export declare function validateInferenceConfig(value: unknown): ConfigResult;
+/** Parse the file's text. */
+export declare function parseInferenceConfig(text: string): ConfigResult;
+/** The mounted component's prop, validated like the file. Invalid: browser plus a notice. */
+export declare function configFromProp(prop: unknown): ConfigResult;
+/**
+ * Fetch `${base}/planner.config.json`. A missing file (404, network error)
+ * means the defaults and no notice; a file that is there but unusable means
+ * `browser` and a notice.
+ */
+export declare function loadInferenceConfig(base?: string, fetcher?: typeof fetch): Promise<ConfigResult>;

package/dist/inference/config.js

@@ -0,0 +1,205 @@
+import { parseKitchenConfig } from "../kitchen/client.js";
+export const INFERENCE_MODES = [
+    'manual',
+    'browser',
+    'host',
+    'byo',
+];
+export const DEFAULT_INFERENCE = { mode: 'browser' };
+export const MANUAL_INFERENCE = { mode: 'manual' };
+/** The file name, served at `${base}/planner.config.json`. */
+export const CONFIG_FILE = 'planner.config.json';
+const isObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+/** http(s) only; a path-only endpoint (`/api/planner/chat`) is the host's own origin. */
+export function isUsableEndpoint(value) {
+    if (typeof value !== 'string')
+        return false;
+    const text = value.trim();
+    if (!text)
+        return false;
+    try {
+        const relative = text.startsWith('/') && !text.startsWith('//');
+        const url = new URL(text, relative ? 'https://planner.invalid' : undefined);
+        if (!relative && url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return false;
+        }
+        if (url.username || url.password)
+            return false;
+        if (url.hash)
+            return false;
+        for (const name of url.searchParams.keys()) {
+            if (/^(?:api[-_]?key|key|token|authorization|secret|password)$/i.test(name)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parsePresetDefinition(value) {
+    if (!isObject(value))
+        return null;
+    const { id, label, baseUrl, model, keyless, cors } = value;
+    if (typeof id !== 'string' || !/^[a-z0-9][a-z0-9-]{0,31}$/.test(id)) {
+        return null;
+    }
+    if (typeof label !== 'string' || !label.trim())
+        return null;
+    if (!isUsableEndpoint(baseUrl) || baseUrl.startsWith('/'))
+        return null;
+    return {
+        id,
+        label: label.trim(),
+        baseUrl: baseUrl.trim(),
+        ...(typeof model === 'string' && model.trim()
+            ? { model: model.trim() }
+            : {}),
+        ...(keyless === true ? { keyless: true } : {}),
+        ...(typeof cors === 'string' && cors.trim() ? { cors: cors.trim() } : {}),
+    };
+}
+const fallback = (why) => ({
+    config: MANUAL_INFERENCE,
+    notice: `The assistant settings could not be used (${why}), so inference is off. The planner still works manually.`,
+});
+function parseAlternatives(value, initial) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length === 0)
+        return null;
+    const modes = [];
+    for (const entry of value) {
+        if (typeof entry !== 'string' ||
+            !INFERENCE_MODES.includes(entry) ||
+            entry === initial ||
+            modes.includes(entry)) {
+            return null;
+        }
+        modes.push(entry);
+    }
+    return modes;
+}
+function parseByo(value) {
+    if (value === undefined)
+        return {};
+    if (!isObject(value))
+        return null;
+    if (value.presets === undefined)
+        return {};
+    if (!Array.isArray(value.presets) || value.presets.length === 0)
+        return null;
+    const presets = [];
+    for (const entry of value.presets) {
+        if (typeof entry === 'string' && entry.trim()) {
+            presets.push(entry.trim());
+            continue;
+        }
+        const definition = parsePresetDefinition(entry);
+        if (!definition)
+            return null;
+        presets.push(definition);
+    }
+    return { presets };
+}
+/**
+ * Validate a parsed config. A missing config keeps the standalone browser
+ * default. A present but invalid config fails closed to manual planning with a
+ * visible notice; it never selects a provider or downloads a model.
+ */
+export function validateInferenceConfig(value) {
+    if (!isObject(value))
+        return fallback('not an object');
+    const inference = value.inference;
+    if (inference === undefined)
+        return { config: DEFAULT_INFERENCE };
+    if (!isObject(inference))
+        return fallback('"inference" is not an object');
+    const mode = inference.mode;
+    if (mode === undefined)
+        return { config: DEFAULT_INFERENCE };
+    if (!INFERENCE_MODES.includes(mode)) {
+        return fallback(`unknown mode "${String(mode)}"`);
+    }
+    const selected = mode;
+    const alternatives = parseAlternatives(inference.alternatives, selected);
+    if (!alternatives) {
+        return fallback('alternatives must be unique supported modes other than mode');
+    }
+    const credentialPersistence = inference.credentialPersistence;
+    if (credentialPersistence !== undefined &&
+        credentialPersistence !== 'local' &&
+        credentialPersistence !== 'memory') {
+        return fallback('credentialPersistence must be "local" or "memory"');
+    }
+    const modes = [selected, ...alternatives];
+    let host;
+    if (modes.includes('host')) {
+        const configuredHost = inference.host;
+        if (!isObject(configuredHost) ||
+            !isUsableEndpoint(configuredHost.endpoint)) {
+            return fallback('host mode needs host.endpoint, an http(s) URL or path');
+        }
+        host = { endpoint: configuredHost.endpoint.trim() };
+    }
+    let byo;
+    if (modes.includes('byo')) {
+        byo = parseByo(inference.byo) ?? undefined;
+        if (!byo)
+            return fallback('byo.presets must be a non-empty valid list');
+    }
+    return {
+        config: {
+            mode: selected,
+            ...(alternatives.length ? { alternatives } : {}),
+            ...(credentialPersistence ? { credentialPersistence } : {}),
+            ...(host ? { host } : {}),
+            ...(byo ? { byo } : {}),
+        },
+    };
+}
+/** Parse the file's text. */
+export function parseInferenceConfig(text) {
+    try {
+        const value = JSON.parse(text);
+        const result = validateInferenceConfig(value);
+        const kitchen = isObject(value)
+            ? parseKitchenConfig(value.kitchen)
+            : undefined;
+        return kitchen ? { ...result, kitchen } : result;
+    }
+    catch {
+        return fallback('it is not valid JSON');
+    }
+}
+/** The mounted component's prop, validated like the file. Invalid: browser plus a notice. */
+export function configFromProp(prop) {
+    return validateInferenceConfig({ inference: prop });
+}
+/**
+ * Fetch `${base}/planner.config.json`. A missing file (404, network error)
+ * means the defaults and no notice; a file that is there but unusable means
+ * `browser` and a notice.
+ */
+export async function loadInferenceConfig(base = '', fetcher = fetch) {
+    let response;
+    try {
+        response = await fetcher(`${base.replace(/\/$/, '')}/${CONFIG_FILE}`, {
+            headers: { accept: 'application/json' },
+            cache: 'no-cache',
+        });
+    }
+    catch {
+        return { config: DEFAULT_INFERENCE };
+    }
+    if (response.status === 404)
+        return { config: DEFAULT_INFERENCE };
+    if (!response.ok)
+        return fallback(`the file answered ${response.status}`);
+    const text = await response.text();
+    // A static host with a SPA fallback answers a missing file with HTML.
+    if (/^\s*</.test(text))
+        return { config: DEFAULT_INFERENCE };
+    return parseInferenceConfig(text);
+}

package/dist/inference/host.d.ts

@@ -0,0 +1,40 @@
+import type { ChatModel } from '../assistant/transport.ts';
+import type { PlanSnapshot } from '../planner/commands/types.ts';
+/** Wire contract version; see `docs/inference-host.md`. */
+export declare const HOST_WIRE_VERSION = 1;
+/** Recent turns sent along (the transport already keeps six). */
+export declare const HOST_HISTORY_TURNS = 6;
+/** Longest history entry sent; the rest is cut. */
+export declare const HOST_HISTORY_CHARS = 1000;
+/** Longest message sent. */
+export declare const HOST_MESSAGE_CHARS = 2000;
+/** What the planner POSTs to the host endpoint. */
+export interface HostRequest {
+    version: typeof HOST_WIRE_VERSION;
+    /** The visitor's text, and nothing else of the prompt. */
+    message: string;
+    /** The compact plan snapshot from the controller. */
+    snapshot: PlanSnapshot;
+    /** Bounded recent turns, oldest first. Never a system message. */
+    history?: {
+        role: 'user' | 'assistant';
+        content: string;
+    }[];
+}
+export interface HostChatOptions {
+    /** `http(s)://…` or a path on the page's own origin. */
+    endpoint: string;
+    /** The plan as it is now, read per turn. */
+    snapshot: () => PlanSnapshot;
+    fetch?: typeof fetch;
+    /** Extra request headers a host wants (a CSRF token, say). */
+    headers?: () => Record<string, string>;
+}
+/**
+ * A `ChatModel` that asks the host's server. The server owns the prompt: only
+ * the visitor's text, the compact snapshot and bounded recent turns leave the
+ * page. The system prompt the transport builds for local models is dropped,
+ * as is the response schema; the server answers with the same action JSON
+ * the assistant reads from a model (see `docs/inference-host.md`).
+ */
+export declare function createHostChat(options: HostChatOptions): ChatModel;

package/dist/inference/host.js

@@ -0,0 +1,57 @@
+/** Wire contract version; see `docs/inference-host.md`. */
+export const HOST_WIRE_VERSION = 1;
+/** Recent turns sent along (the transport already keeps six). */
+export const HOST_HISTORY_TURNS = 6;
+/** Longest history entry sent; the rest is cut. */
+export const HOST_HISTORY_CHARS = 1000;
+/** Longest message sent. */
+export const HOST_MESSAGE_CHARS = 2000;
+const REQUEST_TIMEOUT_MS = 60_000;
+const clip = (text, max) => text.length > max ? text.slice(0, max) : text;
+/**
+ * A `ChatModel` that asks the host's server. The server owns the prompt: only
+ * the visitor's text, the compact snapshot and bounded recent turns leave the
+ * page. The system prompt the transport builds for local models is dropped,
+ * as is the response schema; the server answers with the same action JSON
+ * the assistant reads from a model (see `docs/inference-host.md`).
+ */
+export function createHostChat(options) {
+    const doFetch = options.fetch ?? fetch;
+    return {
+        async message(text, callOptions) {
+            const history = (callOptions?.history ?? [])
+                .filter((turn) => turn.role === 'user' || turn.role === 'assistant')
+                .slice(-HOST_HISTORY_TURNS)
+                .map((turn) => ({
+                role: turn.role,
+                content: clip(turn.content, HOST_HISTORY_CHARS),
+            }));
+            const body = {
+                version: HOST_WIRE_VERSION,
+                message: clip(text, HOST_MESSAGE_CHARS),
+                snapshot: options.snapshot(),
+                ...(history.length ? { history } : {}),
+            };
+            const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+            const signal = callOptions?.signal
+                ? AbortSignal.any([callOptions.signal, timeout])
+                : timeout;
+            const response = await doFetch(options.endpoint, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                    ...options.headers?.(),
+                },
+                body: JSON.stringify(body),
+                signal,
+            });
+            if (!response.ok) {
+                throw new Error(`the server answered ${response.status}`);
+            }
+            const reply = await response.text();
+            // The body is the action object. Plain text is read as the reply itself.
+            return reply;
+        },
+    };
+}