@pipedog/core 0.0.0 → 0.2.0

package/dist/processors/frameworks/rtvi/models.js

@@ -0,0 +1,1807 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/processors/frameworks/rtvi/models.py
+import { KeypadEntry as KeypadEntryValues } from "../../../audio/dtmf/types.js";
+import { BotCapabilities } from "../../../pipeline/capabilities.js";
+// -- Constants --
+export const PROTOCOL_VERSION = "2.2.0";
+// -- Version compatibility --
+// Any 1.x client is deprecated but still supported with the old bot-output format.
+export const LEGACY_SUPPORTED_MAJOR = 1;
+export const MESSAGE_LABEL = "rtvi-ai";
+/** Raised when data does not match a model, like pydantic's `ValidationError`. */
+// `Error` is shadowed in this module by the RTVI `Error` model below.
+const BuiltinError = globalThis.Error;
+export class ValidationError extends BuiltinError {
+    name = "ValidationError";
+    title;
+    details;
+    constructor(title, details) {
+        const lines = details.map((d) => `${d.loc.join(".")}\n  ${d.msg}`);
+        super(`${details.length} validation error${details.length === 1 ? "" : "s"} for ${title}\n${lines.join("\n")}`);
+        this.title = title;
+        this.details = details;
+    }
+    /** The list of problems (pydantic `ValidationError.errors()`). */
+    errors() {
+        return this.details;
+    }
+}
+class FieldError extends BuiltinError {
+    detail;
+    constructor(detail) {
+        super(detail.map((d) => d.msg).join("; "));
+        this.detail = detail;
+    }
+}
+function fail(msg, loc = []) {
+    throw new FieldError([{ loc, msg }]);
+}
+function field(parse, defaultValue, key) {
+    const spec = { parse };
+    if (defaultValue)
+        spec.default = defaultValue;
+    if (key)
+        spec.key = key;
+    return spec;
+}
+function wireKey(name, spec) {
+    return spec.key ?? name.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const P = {
+    any: () => (v) => v,
+    str: () => (v) => typeof v === "string" ? v : fail("Input should be a valid string"),
+    int: () => (v) => typeof v === "number" && Number.isInteger(v) ? v : fail("Input should be a valid integer"),
+    float: () => (v) => typeof v === "number" && Number.isFinite(v) ? v : fail("Input should be a valid number"),
+    bool: () => (v) => typeof v === "boolean" ? v : fail("Input should be a valid boolean"),
+    dict: () => (v) => isPlainObject(v) ? v : fail("Input should be a valid dictionary"),
+    literal: (...values) => (v) => values.includes(v)
+        ? v
+        : fail(`Input should be ${values.map((x) => JSON.stringify(x)).join(" or ")}`),
+    optional: (parse) => (v, wire) => v === null || v === undefined ? null : parse(v, wire),
+    list: (parse, options = {}) => (v, wire) => {
+        if (!Array.isArray(v))
+            fail("Input should be a valid list");
+        if (options.minLength !== undefined && v.length < options.minLength) {
+            fail(`List should have at least ${options.minLength} item after validation, not ${v.length}`);
+        }
+        const details = [];
+        const out = v.map((item, i) => {
+            try {
+                return parse(item, wire);
+            }
+            catch (e) {
+                if (!(e instanceof FieldError))
+                    throw e;
+                for (const d of e.detail)
+                    details.push({ loc: [i, ...d.loc], msg: d.msg });
+                return undefined;
+            }
+        });
+        if (details.length > 0)
+            throw new FieldError(details);
+        return out;
+    },
+    union: (...parsers) => (v, wire) => {
+        const details = [];
+        for (const parse of parsers) {
+            try {
+                return parse(v, wire);
+            }
+            catch (e) {
+                if (!(e instanceof FieldError))
+                    throw e;
+                details.push(...e.detail);
+            }
+        }
+        throw new FieldError(details);
+    },
+    model: (cls) => (v, wire) => {
+        const c = cls();
+        if (v instanceof c)
+            return v;
+        if (!isPlainObject(v))
+            fail(`Input should be a valid dictionary or instance of ${c.name}`);
+        try {
+            return (wire ? c.modelValidate(v) : new c(v));
+        }
+        catch (e) {
+            if (e instanceof ValidationError)
+                throw new FieldError(e.details);
+            throw e;
+        }
+    },
+};
+const EXTRA = Symbol("pipecat.rtvi.extra");
+const WIRE = Symbol("pipecat.rtvi.wire");
+function dumpValue(value, options) {
+    if (value instanceof BaseModel)
+        return value.modelDump(options);
+    if (typeof value === "object" &&
+        value !== null &&
+        typeof value.modelDump === "function") {
+        return value.modelDump(options);
+    }
+    if (Array.isArray(value))
+        return value.map((v) => dumpValue(v, options));
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, dumpValue(v, options)]));
+    }
+    return value;
+}
+/**
+ * Base class of the RTVI models (pydantic `BaseModel`).
+ *
+ * Subclasses declare their fields with `declare` and describe them in the
+ * static `fields` table. The constructor validates camelCase options;
+ * `modelValidate()` validates wire (snake_case) data; `modelDump()` produces
+ * wire data.
+ */
+export class BaseModel {
+    /** Field table: name, parser, default and wire key. */
+    static fields = {};
+    /** What to do with unknown wire keys: drop them, or keep them in `modelExtra`. */
+    static extra = "ignore";
+    /** Unknown keys kept by models created with `extra = "allow"` (pydantic `model_extra`). */
+    modelExtra = null;
+    constructor(options = {}) {
+        const cls = new.target;
+        const input = cls._beforeValidate({ ...options });
+        const details = [];
+        const self = this;
+        const wire = options[WIRE] === true;
+        for (const [name, spec] of Object.entries(cls.fields)) {
+            const raw = input[name];
+            const key = wireKey(name, spec);
+            if (raw === undefined) {
+                if (spec.default) {
+                    self[name] = spec.default();
+                }
+                else {
+                    details.push({ loc: [key], msg: "Field required" });
+                }
+                continue;
+            }
+            try {
+                self[name] = spec.parse(raw, wire);
+            }
+            catch (e) {
+                if (!(e instanceof FieldError))
+                    throw e;
+                for (const d of e.detail)
+                    details.push({ loc: [key, ...d.loc], msg: d.msg });
+            }
+        }
+        if (details.length > 0) {
+            throw new ValidationError(cls.name, details);
+        }
+        if (cls.extra === "allow") {
+            const extra = {
+                ...(options[EXTRA] ?? {}),
+            };
+            for (const [k, v] of Object.entries(options)) {
+                if (!(k in cls.fields))
+                    extra[k] = v;
+            }
+            this.modelExtra = extra;
+        }
+    }
+    /**
+     * Hook run on the (camelCase) input before the fields are validated, like
+     * pydantic's `@model_validator(mode="before")`.
+     */
+    static _beforeValidate(data) {
+        return data;
+    }
+    /**
+     * Validate wire data (snake_case keys) into a model (pydantic `model_validate`).
+     *
+     * @throws ValidationError If the data does not match the model.
+     */
+    static modelValidate(data) {
+        // `this` is the subclass modelValidate() is called on, as with a classmethod.
+        // biome-ignore lint/complexity/noThisInStatic: polymorphic static.
+        const cls = this;
+        // biome-ignore lint/complexity/noThisInStatic: polymorphic static.
+        const ctor = this;
+        if (data instanceof cls)
+            return data;
+        if (!isPlainObject(data)) {
+            throw new ValidationError(cls.name, [
+                { loc: [], msg: `Input should be a valid dictionary or instance of ${cls.name}` },
+            ]);
+        }
+        const options = {};
+        const known = new Set();
+        for (const [name, spec] of Object.entries(cls.fields)) {
+            const key = wireKey(name, spec);
+            known.add(key);
+            if (key in data)
+                options[name] = data[key];
+        }
+        if (cls.extra === "allow") {
+            const extra = {};
+            for (const [k, v] of Object.entries(data)) {
+                if (!known.has(k))
+                    extra[k] = v;
+            }
+            options[EXTRA] = extra;
+        }
+        options[WIRE] = true;
+        return new ctor(options);
+    }
+    /**
+     * The wire form of the model, with upstream's snake_case keys (pydantic
+     * `model_dump`). Nested models are dumped too.
+     */
+    modelDump(options = {}) {
+        const cls = this.constructor;
+        const self = this;
+        const dump = {};
+        for (const [name, spec] of Object.entries(cls.fields)) {
+            const value = self[name];
+            if (options.excludeNone && (value === null || value === undefined))
+                continue;
+            dump[wireKey(name, spec)] = dumpValue(value, options);
+        }
+        if (this.modelExtra) {
+            for (const [k, v] of Object.entries(this.modelExtra)) {
+                if (options.excludeNone && (v === null || v === undefined))
+                    continue;
+                dump[k] = dumpValue(v, options);
+            }
+        }
+        return dump;
+    }
+    /** Serialize with the wire keys, as pydantic does. */
+    toJSON() {
+        return this.modelDump();
+    }
+}
+const LABEL_FIELD = field(P.literal(MESSAGE_LABEL), () => MESSAGE_LABEL);
+function typeField(type) {
+    return field(P.literal(type), () => type);
+}
+/**
+ * Base RTVI message structure.
+ *
+ * Represents the standard format for RTVI protocol messages.
+ */
+export class Message extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: field(P.str()),
+        id: field(P.str()),
+        data: field(P.optional(P.dict()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Data structure expected from client messages sent to the RTVI server. */
+export class RawClientMessageData extends BaseModel {
+    static fields = {
+        t: field(P.str()),
+        d: field(P.optional(P.any()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Cleansed data structure for client messages for handling. */
+export class ClientMessage extends BaseModel {
+    static fields = {
+        msgId: field(P.str()),
+        type: field(P.str()),
+        data: field(P.optional(P.any()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Data structure for server responses to client messages. */
+export class RawServerResponseData extends BaseModel {
+    static fields = {
+        t: field(P.str()),
+        d: field(P.optional(P.any()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * The RTVI-formatted message response from the server to the client.
+ *
+ * This message is used to respond to custom messages sent by the client.
+ */
+export class ServerResponse extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("server-response"),
+        id: field(P.str()),
+        data: field(P.model(() => RawServerResponseData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data about the RTVI client.
+ *
+ * Contains information about the client, including which RTVI library it is
+ * using, what platform it is on and any additional details, if available.
+ */
+export class AboutClientData extends BaseModel {
+    static fields = {
+        library: field(P.str()),
+        libraryVersion: field(P.optional(P.str()), () => null),
+        platform: field(P.optional(P.str()), () => null),
+        platformVersion: field(P.optional(P.str()), () => null),
+        platformDetails: field(P.optional(P.any()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data format of client ready messages.
+ *
+ * Contains the RTVI protocol version and client information.
+ */
+export class ClientReadyData extends BaseModel {
+    static fields = {
+        version: field(P.str()),
+        about: field(P.model(() => AboutClientData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for an RTVI error response.
+ *
+ * Contains the error message to send back to the client.
+ */
+export class ErrorResponseData extends BaseModel {
+    static fields = {
+        error: field(P.str()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * RTVI error response message.
+ *
+ * RTVI formatted error response message for relaying failed client requests.
+ */
+export class ErrorResponse extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("error-response"),
+        id: field(P.str()),
+        data: field(P.model(() => ErrorResponseData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for an RTVI error event.
+ *
+ * Contains error information including whether it's fatal.
+ */
+export class ErrorData extends BaseModel {
+    static fields = {
+        error: field(P.str()),
+        fatal: field(P.bool()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * RTVI error event message.
+ *
+ * RTVI formatted error message for relaying errors in the pipeline.
+ */
+// biome-ignore lint/suspicious/noShadowRestrictedNames: upstream name (RTVI.Error).
+export class Error extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("error"),
+        data: field(P.model(() => ErrorData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+const botCapabilitiesParser = (v, wire) => {
+    if (v instanceof BotCapabilities)
+        return v;
+    if (!isPlainObject(v))
+        fail("Input should be a valid dictionary or instance of BotCapabilities");
+    if (!wire)
+        return new BotCapabilities(v);
+    const optBool = (key) => {
+        const x = v[key];
+        if (x === undefined || x === null)
+            return null;
+        if (typeof x !== "boolean")
+            fail("Input should be a valid boolean", [key]);
+        return x;
+    };
+    return new BotCapabilities({
+        audioIn: optBool("audio_in"),
+        audioOut: optBool("audio_out"),
+        videoIn: optBool("video_in"),
+        screenIn: optBool("screen_in"),
+        videoOut: optBool("video_out"),
+        metrics: optBool("metrics"),
+    });
+};
+/**
+ * Data for bot ready notification.
+ *
+ * Contains protocol version and initial configuration.
+ *
+ * - `version`: the RTVI protocol version the bot speaks with this client.
+ * - `about`: information about the bot, such as the Pipecat library and version.
+ * - `capabilities`: what the bot does in this session (media sent and
+ *   received, metrics), so the client can show only the UI that applies.
+ *   Added in protocol 2.2.0.
+ */
+export class BotReadyData extends BaseModel {
+    static fields = {
+        version: field(P.str()),
+        about: field(P.optional(P.dict()), () => null),
+        capabilities: field(P.optional(botCapabilitiesParser), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message indicating bot is ready for interaction.
+ *
+ * Sent after bot initialization is complete.
+ */
+export class BotReady extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-ready"),
+        id: field(P.str()),
+        data: field(P.model(() => BotReadyData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Options for sending text input to the LLM.
+ *
+ * Contains options for how the pipeline should process the text input.
+ */
+export class SendTextOptions extends BaseModel {
+    static fields = {
+        runImmediately: field(P.bool(), () => true),
+        audioResponse: field(P.bool(), () => true),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Data format for sending text input to the LLM.
+ *
+ * Contains the text content to send and any options for how the pipeline
+ * should process it.
+ */
+export class SendTextData extends BaseModel {
+    static fields = {
+        content: field(P.str()),
+        options: field(P.optional(P.model(() => SendTextOptions)), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+const fileSourceTypeParser = P.literal("bytes", "url");
+/** Base class for RTVI file sources. */
+export class FileSource extends BaseModel {
+    static fields = {
+        type: field(fileSourceTypeParser),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** File source as base64-encoded bytes. */
+export class FileBytes extends FileSource {
+    static fields = {
+        type: field(fileSourceTypeParser, () => "bytes"),
+        bytes: field(P.str()),
+        width: field(P.optional(P.int()), () => null),
+        height: field(P.optional(P.int()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * File source as a URL.
+ *
+ * - `url`: the file's URL: whatever the `POST /files` upload endpoint
+ *   returned (`pipecat:<id>` with the default local storage, or a URL minted
+ *   by a custom storage backend), a cloud-storage URI (`s3://`, `gs://`), or a
+ *   plain `http(s)` URL. The URL is resolved at completion time: the LLM
+ *   provider fetches it itself when it can (public URLs, its own cloud IAM),
+ *   and otherwise the LLM service's `FileResolver` downloads the bytes and
+ *   inlines them.
+ */
+export class FileUrl extends FileSource {
+    static fields = {
+        type: field(fileSourceTypeParser, () => "url"),
+        url: field(P.str()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** File data structure for RTVI file sending. */
+export class File extends BaseModel {
+    static fields = {
+        format: field(P.str()),
+        name: field(P.optional(P.str()), () => null),
+        source: field(P.union(P.model(() => FileBytes), P.model(() => FileUrl))),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Options for sending a file to the LLM. */
+export class SendFileOptions extends BaseModel {
+    static fields = {
+        runImmediately: field(P.bool(), () => true),
+        audioResponse: field(P.bool(), () => true),
+        customOptions: field(P.optional(P.dict()), () => null),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Data format for sending a file to the LLM.
+ *
+ * Contains the information of the file to send and any options for how the
+ * pipeline should process it.
+ */
+export class SendFileData extends BaseModel {
+    static fields = {
+        content: field(P.str()),
+        file: field(P.model(() => File)),
+        options: field(P.optional(P.model(() => SendFileOptions)), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data format for DTMF keypresses sent from the client.
+ *
+ * Carries one or more keypad entries (`0`-`9`, `*`, `#`), delivered in order,
+ * so the bot's DTMF handling (e.g. a `DTMFAggregator`) sees them exactly as a
+ * telephony transport would deliver rapid keypresses.
+ *
+ * Protocol 2.1.0 replaced the single `button` field with `buttons`.
+ */
+export class DTMFInputData extends BaseModel {
+    static fields = {
+        buttons: field(P.list(P.literal(...Object.values(KeypadEntryValues)), { minLength: 1 })),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for LLM function call start notification.
+ *
+ * Contains the function name being called. Fields may be omitted based on the
+ * configured function_call_report_level for security.
+ *
+ * - `functionName`: name of the function called.
+ */
+export class LLMFunctionCallStartMessageData extends BaseModel {
+    static fields = {
+        functionName: field(P.optional(P.str()), () => null),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Message notifying that an LLM function call has started.
+ *
+ * Sent when the LLM begins a function call.
+ */
+export class LLMFunctionCallStartMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("llm-function-call-started"),
+        data: field(P.model(() => LLMFunctionCallStartMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for LLM function call result.
+ *
+ * Contains function call details and result.
+ */
+export class LLMFunctionCallResultData extends BaseModel {
+    static fields = {
+        functionName: field(P.str()),
+        toolCallId: field(P.str()),
+        arguments: field(P.dict()),
+        result: field(P.union(P.dict(), P.str())),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for LLM function call in-progress notification.
+ *
+ * Contains function call details including name, ID, and arguments. Fields
+ * may be omitted based on the configured function_call_report_level for
+ * security.
+ *
+ * - `toolCallId`: unique identifier of the call.
+ * - `functionName`: name of the function called.
+ * - `arguments`: arguments passed to the function.
+ */
+export class LLMFunctionCallInProgressMessageData extends BaseModel {
+    static fields = {
+        toolCallId: field(P.str()),
+        functionName: field(P.optional(P.str()), () => null),
+        arguments: field(P.optional(P.dict()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message notifying that an LLM function call is in progress.
+ *
+ * Sent when the LLM function call execution begins.
+ */
+export class LLMFunctionCallInProgressMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("llm-function-call-in-progress"),
+        data: field(P.model(() => LLMFunctionCallInProgressMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for LLM function call stopped notification.
+ *
+ * Contains details about the function call that stopped, including whether
+ * it was cancelled or completed with a result. Fields may be omitted based on
+ * the configured function_call_report_level for security.
+ *
+ * - `toolCallId`: unique identifier of the call.
+ * - `cancelled`: whether the call was cancelled rather than completed.
+ * - `functionName`: name of the function called.
+ * - `result`: the result, when the call completed with one.
+ */
+export class LLMFunctionCallStoppedMessageData extends BaseModel {
+    static fields = {
+        toolCallId: field(P.str()),
+        cancelled: field(P.bool()),
+        functionName: field(P.optional(P.str()), () => null),
+        result: field(P.optional(P.any()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message notifying that an LLM function call has stopped.
+ *
+ * Sent when a function call completes (with result) or is cancelled.
+ */
+export class LLMFunctionCallStoppedMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("llm-function-call-stopped"),
+        data: field(P.model(() => LLMFunctionCallStoppedMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Message indicating bot LLM processing has started. */
+export class BotLLMStartedMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-llm-started"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/** Message indicating bot LLM processing has stopped. */
+export class BotLLMStoppedMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-llm-stopped"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/** Message indicating bot TTS processing has started. */
+export class BotTTSStartedMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-tts-started"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/** Message indicating bot TTS processing has stopped. */
+export class BotTTSStoppedMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-tts-stopped"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Data for text-based RTVI messages.
+ *
+ * Contains text content.
+ */
+export class TextMessageData extends BaseModel {
+    static fields = {
+        text: field(P.str()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Word-level TTS progress within a spoken segment.
+ *
+ * - `accumulatedText`: text already spoken in this segment, including the
+ *   current word.
+ * - `remainingText`: text not yet spoken in this segment.
+ */
+export class SpokenProgressData extends BaseModel {
+    static fields = {
+        accumulatedText: field(P.str()),
+        remainingText: field(P.str()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Return type for bot output transform functions.
+ *
+ * - `text`: the transformed full text of the segment.
+ * - `accumulatedText`: transformed spoken-so-far portion. Only populated when
+ *   the transform is called from a progress context.
+ * - `remainingText`: transformed not-yet-spoken portion. Only populated when
+ *   the transform is called from a progress context.
+ */
+export class BotOutputTransformResult extends BaseModel {
+    static fields = {
+        text: field(P.str()),
+        accumulatedText: field(P.optional(P.str()), () => null),
+        remainingText: field(P.optional(P.str()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for bot output RTVI messages.
+ *
+ * Extends TextMessageData to include metadata about the output.
+ *
+ * This class supports both protocol v1 (1.4.x) and v2 (2.0.0+) clients. The
+ * observer populates different field subsets depending on the negotiated
+ * version; `sendRtviMessage` serialises with `excludeNone: true` so each
+ * client only sees the fields relevant to its version.
+ *
+ * - `textType`: what form the text is in (e.g., sentence, code, etc.).
+ * - `aggregatedBy`: what form the text is in, always the same as `textType`.
+ *   Deprecated upstream since 1.13.0 (use `textType`); kept because it is
+ *   still on the wire.
+ * - `segmentId`: ID of the source AggregatedTextFrame.
+ * - `spoken`: **(v1 only)** whether the text has been spoken by TTS.
+ * - `willBeSpoken`: **(v2+)** whether the text will be spoken by TTS.
+ * - `spokenStatus`: **(v2+)** lifecycle status of the segment: `"new"` on its
+ *   first message, the only one for text that isn't spoken; `"in-progress"`
+ *   as each of its words is spoken, for TTS services with word timestamps;
+ *   `"completed"` once its last word is spoken.
+ * - `spokenProgress`: **(v2+)** accumulated / remaining text breakdown.
+ *   Present when `willBeSpoken` is true.
+ */
+export class BotOutputMessageData extends TextMessageData {
+    static fields = {
+        ...TextMessageData.fields,
+        textType: field(P.str()),
+        aggregatedBy: field(P.optional(P.str()), () => null),
+        segmentId: field(P.optional(P.int()), () => null),
+        spoken: field(P.optional(P.bool()), () => null),
+        willBeSpoken: field(P.optional(P.bool()), () => null),
+        spokenStatus: field(P.optional(P.literal("new", "in-progress", "completed")), () => null),
+        spokenProgress: field(P.optional(P.model(() => SpokenProgressData)), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+    /** Fill whichever of `textType` and `aggregatedBy` is missing from the other. */
+    static _beforeValidate(data) {
+        if (data.textType === undefined && data.aggregatedBy !== undefined) {
+            return { ...data, textType: data.aggregatedBy };
+        }
+        else if (data.aggregatedBy === undefined && data.textType !== undefined) {
+            return { ...data, aggregatedBy: data.textType };
+        }
+        return data;
+    }
+}
+/**
+ * Message containing bot output text.
+ *
+ * An event meant to holistically represent what the bot is outputting, along
+ * with metadata about the output and if it has been spoken.
+ */
+export class BotOutputMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-output"),
+        data: field(P.model(() => BotOutputMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message containing bot transcription text.
+ *
+ * Sent when the bot's speech is transcribed.
+ */
+export class BotTranscriptionMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-transcription"),
+        data: field(P.model(() => TextMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message containing bot LLM text output.
+ *
+ * Sent when the bot's LLM generates text.
+ *
+ * Deprecated upstream since 1.13.0 (use `LLMRawTextMessage`); kept because
+ * the observer still sends it while `botLlmEnabled` is on.
+ */
+export class BotLLMTextMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-llm-text"),
+        data: field(P.model(() => TextMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for a bot LLM marker message.
+ *
+ * - `text`: the marker as the LLM produced it; empty when the response
+ *   carried none.
+ * - `kind`: what the marker means, in the emitter's vocabulary (the
+ *   turn-completion mixin's `complete`, `short` or `long`), or `null` when the
+ *   emitter gave none.
+ * - `raw`: the response's text as the LLM produced it, markers included.
+ * - `markers`: every marker the emitter recognizes.
+ */
+export class BotLLMMarkerMessageData extends BaseModel {
+    static fields = {
+        text: field(P.str()),
+        kind: field(P.optional(P.str()), () => null),
+        raw: field(P.str(), () => ""),
+        markers: field(P.list(P.str()), () => []),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message reporting the sideband marker the bot's LLM emitted in a response.
+ *
+ * A marker is structured assistant output kept out of the spoken text, such
+ * as the turn-completion markers of `filterIncompleteUserTurns`. Sent once
+ * per response, when it ends, and only when the observer's
+ * `botLlmMarkerEnabled` is on.
+ */
+export class BotLLMMarkerMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-llm-marker"),
+        data: field(P.model(() => BotLLMMarkerMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message containing bot TTS text output.
+ *
+ * Sent when text is being processed by TTS.
+ *
+ * Deprecated upstream since 1.13.0 (use `TTSRawTextMessage`); kept because
+ * the observer still sends it while `botTtsEnabled` is on.
+ */
+export class BotTTSTextMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-tts-text"),
+        data: field(P.model(() => TextMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for audio-based RTVI messages.
+ *
+ * Contains audio data and metadata.
+ */
+export class AudioMessageData extends BaseModel {
+    static fields = {
+        audio: field(P.str()),
+        sampleRate: field(P.int()),
+        numChannels: field(P.int()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message containing bot TTS audio output.
+ *
+ * Sent when the bot's TTS generates audio.
+ */
+export class BotTTSAudioMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-tts-audio"),
+        data: field(P.model(() => AudioMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for user transcription messages.
+ *
+ * Contains transcription text and metadata.
+ *
+ * Deprecated upstream since 1.13.0 (use `STTRawTextMessageData`); kept
+ * because the observer still sends `user-transcription` messages.
+ */
+export class UserTranscriptionMessageData extends BaseModel {
+    static fields = {
+        text: field(P.str()),
+        userId: field(P.str()),
+        timestamp: field(P.str()),
+        final: field(P.bool()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message containing user transcription.
+ *
+ * Sent when user speech is transcribed.
+ *
+ * Deprecated upstream since 1.13.0 (use `STTRawTextMessage`, or
+ * `UserInputMessage` for what the user said); kept because the observer
+ * still sends it.
+ */
+export class UserTranscriptionMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("user-transcription"),
+        data: field(P.model(() => UserTranscriptionMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for user input messages.
+ *
+ * - `text`: what the user said or typed.
+ * - `inputType`: what kind of input it is: `"transcription"` for speech
+ *   transcribed by the STT, `"chat"` for text the client sent, or
+ *   `"backchannel"` for a short acknowledgment the user said while the bot
+ *   talks, such as "mhm".
+ * - `timestamp`: when the user said or sent it.
+ * - `final`: whether the text is final. Only an interim transcription isn't.
+ * - `userId`: identifier for the user who spoke or typed. For chat, set only
+ *   when the transport knows the sender, such as Daily and LiveKit.
+ * - `msgId`: for chat, the id of the client's `send-text` message.
+ */
+export class UserInputMessageData extends BaseModel {
+    static fields = {
+        text: field(P.str()),
+        inputType: field(P.literal("transcription", "chat", "backchannel")),
+        timestamp: field(P.str()),
+        final: field(P.bool()),
+        userId: field(P.optional(P.str()), () => null),
+        msgId: field(P.optional(P.str()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message containing what the user said or typed.
+ *
+ * The user's counterpart of `bot-output`. A backchannel doesn't interrupt the
+ * bot or reach the LLM.
+ */
+export class UserInputMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("user-input"),
+        data: field(P.model(() => UserInputMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Message containing user text input for LLM.
+ *
+ * Sent when user text is processed by the LLM.
+ */
+export class UserLLMTextMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("user-llm-text"),
+        data: field(P.model(() => TextMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Data for STT raw text messages.
+ *
+ * - `text`: the transcribed text.
+ * - `userId`: identifier for the user who spoke.
+ * - `timestamp`: when the user said it.
+ * - `final`: whether the transcription is final, as opposed to interim.
+ */
+export class STTRawTextMessageData extends BaseModel {
+    static fields = {
+        text: field(P.str()),
+        userId: field(P.str()),
+        timestamp: field(P.str()),
+        final: field(P.bool()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Message reporting a transcription as the STT produced it, interim ones included. */
+export class STTRawTextMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("stt-raw-text"),
+        data: field(P.model(() => STTRawTextMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Message reporting a chunk of text as the LLM streamed it. */
+export class LLMRawTextMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("llm-raw-text"),
+        data: field(P.model(() => TextMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Message reporting text the TTS speaks, as it is spoken. */
+export class TTSRawTextMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("tts-raw-text"),
+        data: field(P.model(() => TextMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Message indicating user has started speaking. */
+export class UserStartedSpeakingMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("user-started-speaking"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/** Message indicating user has stopped speaking. */
+export class UserStoppedSpeakingMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("user-stopped-speaking"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Message indicating VAD detected the user started speaking.
+ *
+ * Raw VAD signal, emitted independently of turn finalization (unlike
+ * `user-started-speaking`, which a turn strategy may gate or defer).
+ */
+export class VADUserStartedSpeakingMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("vad-user-started-speaking"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Message indicating VAD detected the user stopped speaking.
+ *
+ * Raw VAD signal, emitted independently of turn finalization (unlike
+ * `user-stopped-speaking`, which a turn strategy may gate or defer).
+ */
+export class VADUserStoppedSpeakingMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("vad-user-stopped-speaking"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/** Message indicating user has been muted. */
+export class UserMuteStartedMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("user-mute-started"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/** Message indicating user has been unmuted. */
+export class UserMuteStoppedMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("user-mute-stopped"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/** Message indicating bot has started speaking. */
+export class BotStartedSpeakingMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-started-speaking"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/** Message indicating bot has stopped speaking. */
+export class BotStoppedSpeakingMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-stopped-speaking"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Message indicating the bot was interrupted and its in-flight output cut off.
+ *
+ * Fires for any pipeline interruption (a VAD-detected user barge-in or a
+ * programmatic interrupt, e.g. `send-text` with `run_immediately`) so a
+ * client can drop whatever the bot was mid-saying.
+ */
+export class BotInterruptedMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-interrupted"),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Message containing performance metrics.
+ *
+ * Sent to provide performance and usage metrics.
+ */
+export class MetricsMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("metrics"),
+        data: field(P.dict()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Generic server message.
+ *
+ * Used for custom server-to-client messages.
+ */
+export class ServerMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("server-message"),
+        // `Any` without a default: the key is required, but `null` is accepted.
+        data: field(P.any()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Data format for sending audio levels. */
+export class AudioLevelMessageData extends BaseModel {
+    static fields = {
+        value: field(P.float()),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Message indicating user audio level. */
+export class UserAudioLevelMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("user-audio-level"),
+        data: field(P.model(() => AudioLevelMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Message indicating bot audio level. */
+export class BotAudioLevelMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("bot-audio-level"),
+        data: field(P.model(() => AudioLevelMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** Message including a system log. */
+export class SystemLogMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("system-log"),
+        data: field(P.model(() => TextMessageData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Inner `data` for a `ui-event` message.
+ *
+ * - `event`: app-defined event.
+ * - `payload`: app-defined payload, schemaless by design.
+ */
+export class UIEventData extends BaseModel {
+    static fields = {
+        event: field(P.str()),
+        payload: field(P.optional(P.any()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Inner `data` for a `ui-command` message.
+ *
+ * - `command`: app-defined command.
+ * - `payload`: app-defined payload (already a plain object by the time it
+ *   lands on the wire). The standard command payload models below produce the
+ *   right shape via `modelDump()`.
+ */
+export class UICommandData extends BaseModel {
+    static fields = {
+        command: field(P.str()),
+        payload: field(P.optional(P.any()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * One node in the UI accessibility snapshot tree.
+ *
+ * Mirrors the client-side `A11yNode` wire shape. Extra fields are allowed
+ * (kept in `modelExtra`) so clients can add platform-specific or future
+ * metadata without breaking older servers.
+ *
+ * - `ref`: stable client-assigned element reference.
+ * - `role`: ARIA-style role for the node.
+ * - `name`: optional accessible name.
+ * - `value`: optional current value for inputs/progress/etc.
+ * - `state`: optional short state tags (e.g. `"focused"`, `"disabled"`,
+ *   `"offscreen"`).
+ * - `level`: optional heading level.
+ * - `colcount`: optional column count for grid-like containers.
+ * - `rowcount`: optional row count for grid-like containers.
+ * - `children`: optional child nodes.
+ */
+export class A11yNode extends BaseModel {
+    static extra = "allow";
+    static fields = {
+        ref: field(P.str()),
+        role: field(P.str()),
+        name: field(P.optional(P.str()), () => null),
+        value: field(P.optional(P.str()), () => null),
+        state: field(P.optional(P.list(P.str())), () => null),
+        level: field(P.optional(P.int()), () => null),
+        colcount: field(P.optional(P.int()), () => null),
+        rowcount: field(P.optional(P.int()), () => null),
+        children: field(P.optional(P.list(P.model(() => A11yNode))), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * The user's current text selection in the UI snapshot.
+ *
+ * Extra fields are allowed for forward compatibility with client snapshot
+ * additions.
+ *
+ * - `ref`: ref of the element that carries the selection.
+ * - `text`: selected text.
+ * - `startOffset`: optional selection start offset.
+ * - `endOffset`: optional selection end offset.
+ */
+export class A11ySelection extends BaseModel {
+    static extra = "allow";
+    static fields = {
+        ref: field(P.str()),
+        text: field(P.str()),
+        startOffset: field(P.optional(P.int()), () => null),
+        endOffset: field(P.optional(P.int()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Client accessibility snapshot sent in a `ui-snapshot` message.
+ *
+ * Mirrors the client-side `A11ySnapshot` wire shape. Extra fields are allowed
+ * so clients can add compatible metadata over time.
+ *
+ * - `root`: root accessibility node.
+ * - `capturedAt`: client-side epoch milliseconds when captured.
+ * - `selection`: optional current text selection.
+ */
+export class A11ySnapshot extends BaseModel {
+    static extra = "allow";
+    static fields = {
+        root: field(P.model(() => A11yNode)),
+        capturedAt: field(P.int()),
+        selection: field(P.optional(P.model(() => A11ySelection)), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Inner `data` for a `ui-snapshot` message.
+ *
+ * The accessibility snapshot tree mirrors the client-side `A11ySnapshot` wire
+ * shape and is kept forward-compatible by allowing extra fields on the
+ * snapshot models.
+ *
+ * - `tree`: the serialized accessibility tree.
+ */
+export class UISnapshotData extends BaseModel {
+    static fields = {
+        tree: field(P.model(() => A11ySnapshot)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Inner `data` for a `ui-cancel-job-group` message.
+ *
+ * - `jobId`: the job group id the client wants cancelled.
+ * - `reason`: optional human-readable reason.
+ */
+export class UICancelJobGroupData extends BaseModel {
+    static fields = {
+        jobId: field(P.str()),
+        reason: field(P.optional(P.str()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * `data` for a `ui-job-group` envelope with kind `group_started`.
+ *
+ * - `kind`: always `"group_started"`.
+ * - `jobId`: shared job-group identifier for the group.
+ * - `workers`: names of the workers the work was dispatched to.
+ * - `label`: optional human-readable label for the group.
+ * - `cancellable`: whether the client may request cancellation.
+ * - `at`: epoch milliseconds when the group started.
+ */
+export class UIJobGroupStartedData extends BaseModel {
+    static fields = {
+        kind: field(P.literal("group_started"), () => "group_started"),
+        jobId: field(P.str()),
+        workers: field(P.optional(P.list(P.str())), () => null),
+        label: field(P.optional(P.str()), () => null),
+        cancellable: field(P.bool(), () => true),
+        at: field(P.int(), () => 0),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * `data` for a `ui-job-group` envelope with kind `job_update`.
+ *
+ * - `kind`: always `"job_update"`.
+ * - `jobId`: the shared job-group identifier.
+ * - `workerName`: the worker that produced the update.
+ * - `data`: the worker's update payload, forwarded verbatim.
+ * - `at`: epoch milliseconds when the update was emitted.
+ */
+export class UIJobUpdateData extends BaseModel {
+    static fields = {
+        kind: field(P.literal("job_update"), () => "job_update"),
+        jobId: field(P.str()),
+        workerName: field(P.str()),
+        data: field(P.optional(P.any()), () => null),
+        at: field(P.int(), () => 0),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * `data` for a `ui-job-group` envelope with kind `job_completed`.
+ *
+ * - `kind`: always `"job_completed"`.
+ * - `jobId`: the shared job-group identifier.
+ * - `workerName`: the worker that produced the response.
+ * - `status`: completion status string.
+ * - `response`: the worker's response payload.
+ * - `at`: epoch milliseconds when the response was received.
+ */
+export class UIJobCompletedData extends BaseModel {
+    static fields = {
+        kind: field(P.literal("job_completed"), () => "job_completed"),
+        jobId: field(P.str()),
+        workerName: field(P.str()),
+        status: field(P.str()),
+        response: field(P.optional(P.any()), () => null),
+        at: field(P.int(), () => 0),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * `data` for a `ui-job-group` envelope with kind `group_completed`.
+ *
+ * - `kind`: always `"group_completed"`.
+ * - `jobId`: the shared job-group identifier.
+ * - `at`: epoch milliseconds when the group completed.
+ */
+export class UIJobGroupCompletedData extends BaseModel {
+    static fields = {
+        kind: field(P.literal("group_completed"), () => "group_completed"),
+        jobId: field(P.str()),
+        at: field(P.int(), () => 0),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+const uiJobGroupDataParser = P.union(P.model(() => UIJobGroupStartedData), P.model(() => UIJobUpdateData), P.model(() => UIJobCompletedData), P.model(() => UIJobGroupCompletedData));
+/** RTVI `ui-event` message (client -> server). */
+export class UIEventMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("ui-event"),
+        id: field(P.str()),
+        data: field(P.model(() => UIEventData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** RTVI `ui-command` message (server -> client). */
+export class UICommandMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("ui-command"),
+        data: field(P.model(() => UICommandData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** RTVI `ui-snapshot` message (client -> server). */
+export class UISnapshotMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("ui-snapshot"),
+        id: field(P.str()),
+        data: field(P.model(() => UISnapshotData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/** RTVI `ui-cancel-job-group` message (client -> server). */
+export class UICancelJobGroupMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("ui-cancel-job-group"),
+        id: field(P.str()),
+        data: field(P.model(() => UICancelJobGroupData)),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * RTVI `ui-job-group` message (server -> client).
+ *
+ * The `data` field is one of the four job-group lifecycle shapes,
+ * discriminated by the `kind` field.
+ */
+export class UIJobGroupMessage extends BaseModel {
+    static fields = {
+        label: LABEL_FIELD,
+        type: typeField("ui-job-group"),
+        data: field(uiJobGroupDataParser),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * A transient notification surface shown on the client.
+ *
+ * - `title`: required headline.
+ * - `subtitle`: optional second line beneath the title.
+ * - `description`: optional body text.
+ * - `imageUrl`: optional leading image.
+ * - `durationMs`: optional dismiss timer. Client default applies when null.
+ */
+export class Toast extends BaseModel {
+    static fields = {
+        title: field(P.str()),
+        subtitle: field(P.optional(P.str()), () => null),
+        description: field(P.optional(P.str()), () => null),
+        imageUrl: field(P.optional(P.str()), () => null),
+        durationMs: field(P.optional(P.int()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Client-side navigation to a named view.
+ *
+ * - `view`: app-defined view name (route, screen id, tab key, etc.).
+ * - `params`: optional view-specific parameters.
+ */
+export class Navigate extends BaseModel {
+    static fields = {
+        view: field(P.str()),
+        params: field(P.optional(P.dict()), () => null),
+    };
+    constructor(options) {
+        super(options);
+    }
+}
+/**
+ * Scroll a target element into view.
+ *
+ * The client resolves the target by `ref` first (a snapshot ref like `"e42"`
+ * assigned by the a11y walker), then falls back to `targetId`
+ * (`document.getElementById`). Supply whichever you have; `ref` is the normal
+ * choice when acting on a node from `<ui_state>`.
+ *
+ * - `ref`: snapshot ref from `<ui_state>`.
+ * - `targetId`: element id registered on the client.
+ * - `behavior`: optional scroll behavior hint. Typical values: `"smooth"` or
+ *   `"instant"`. Clients may ignore.
+ */
+export class ScrollTo extends BaseModel {
+    static fields = {
+        ref: field(P.optional(P.str()), () => null),
+        targetId: field(P.optional(P.str()), () => null),
+        behavior: field(P.optional(P.str()), () => null),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Briefly emphasize a target element (flash, glow, pulse).
+ *
+ * - `ref`: snapshot ref from `<ui_state>`.
+ * - `targetId`: element id registered on the client.
+ * - `durationMs`: optional highlight duration. Client default applies when
+ *   null.
+ */
+export class Highlight extends BaseModel {
+    static fields = {
+        ref: field(P.optional(P.str()), () => null),
+        targetId: field(P.optional(P.str()), () => null),
+        durationMs: field(P.optional(P.int()), () => null),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Move input focus to a target element.
+ *
+ * - `ref`: snapshot ref from `<ui_state>`.
+ * - `targetId`: element id registered on the client.
+ */
+export class Focus extends BaseModel {
+    static fields = {
+        ref: field(P.optional(P.str()), () => null),
+        targetId: field(P.optional(P.str()), () => null),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Click an element on the client.
+ *
+ * Closes the form-fill loop for non-text inputs (checkboxes, radios) and
+ * exposes the rest of the action vocabulary (submit buttons, links,
+ * app-specific clickable nodes). The standard handler silently no-ops on
+ * `disabled` targets so the worker can't bypass UI affordances the user is
+ * meant to control.
+ *
+ * For native `<select>`, prefer `SetInputValue` (clicking options doesn't
+ * reliably change the selection); for custom comboboxes (ARIA listbox +
+ * popup), apps wire their own command matching the library's interaction
+ * model.
+ *
+ * - `ref`: snapshot ref from `<ui_state>`.
+ * - `targetId`: element id registered on the client. Used as a fallback when
+ *   `ref` is not set or has gone stale.
+ */
+export class Click extends BaseModel {
+    static fields = {
+        ref: field(P.optional(P.str()), () => null),
+        targetId: field(P.optional(P.str()), () => null),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Write a value into a text input or textarea on the client.
+ *
+ * Use this for form-filling: the worker has decided what should go into a
+ * field (clarifying answer, tax form entry, etc.) and asks the client to
+ * populate it. With `replace: true` (the default), the existing value is
+ * overwritten; with `replace: false` the value is appended.
+ *
+ * The standard handler silently no-ops on `disabled`, `readonly`, and
+ * `<input type="hidden">` targets so the worker can't write into fields the
+ * user can't.
+ *
+ * - `value`: the text to write.
+ * - `ref`: snapshot ref from `<ui_state>`. Typically the ref of an `<input>`
+ *   or `<textarea>`.
+ * - `targetId`: element id registered on the client. Used as a fallback when
+ *   `ref` is not set or has gone stale.
+ * - `replace`: when true (the default), overwrite the current value. When
+ *   false, append to it.
+ */
+export class SetInputValue extends BaseModel {
+    static fields = {
+        value: field(P.str(), () => ""),
+        ref: field(P.optional(P.str()), () => null),
+        targetId: field(P.optional(P.str()), () => null),
+        replace: field(P.bool(), () => true),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+/**
+ * Select text on the page so the user can see what the worker means.
+ *
+ * Mirror of the `selection` field surfaced in the snapshot. Use this to point
+ * the user's attention at a specific paragraph or range after the worker has
+ * decided what it's referring to.
+ *
+ * With `startOffset` and `endOffset` omitted, the entire target's text
+ * content is selected (`Range.selectNodeContents` for document elements;
+ * `el.select()` for `<input>` / `<textarea>`).
+ *
+ * - `ref`: snapshot ref from `<ui_state>`. Typically the ref of a paragraph
+ *   or input element.
+ * - `targetId`: element id registered on the client. Used as a fallback when
+ *   `ref` is not set or has gone stale.
+ * - `startOffset`: character offset within the target's text where the
+ *   selection should start. For `<input>` and `<textarea>` this is the value
+ *   offset; for document elements it is computed against the concatenation of
+ *   descendant text nodes in document order.
+ * - `endOffset`: end character offset, exclusive. Same coordinate system as
+ *   `startOffset`.
+ */
+export class SelectText extends BaseModel {
+    static fields = {
+        ref: field(P.optional(P.str()), () => null),
+        targetId: field(P.optional(P.str()), () => null),
+        startOffset: field(P.optional(P.int()), () => null),
+        endOffset: field(P.optional(P.int()), () => null),
+    };
+    constructor(options = {}) {
+        super(options);
+    }
+}
+//# sourceMappingURL=models.js.map