glirastes 0.4.0 → 0.5.0

package/dist/cjs/react/provider/chat-context.d.ts

@@ -1,5 +1,8 @@
 import type { CSSProperties } from 'react';
 import type { ChatMessage, PendingApproval, MentionResult, MentionData, MentionConfig, ChatClassNames, ChatComponents, ChatLocale, SuggestionsConfig, TruncationInfo, ToolResultDisplayConfig, ToolLabelConfig, VoiceInputConfig, PipelineStepReport, PipelineState, PipelineMessageTranslator, StepSummaryFormatter, SessionSummary } from '../types.js';
+import type { CompletionSearch } from '../completions/completion-search.js';
+import type { ChatInteractionRegistry, PendingChatCommand } from '../interactions/registry.js';
+import type { ToolResultRendererRegistry } from '../tool-renderers/registry.js';
 type MentionTrigger = '@' | '/' | null;
 export interface ChatContextValue {
     classNames: ChatClassNames;
@@ -17,9 +20,16 @@ export interface ChatContextValue {
      * `data-theme-effect={themeEffect}` on widget roots.
      */
     themeEffect: string | undefined;
+    /**
+     * True when the provider runs without the shipped styles. Render
+     * `data-unstyled={unstyled || undefined}` on widget roots.
+     */
+    unstyled: boolean;
     suggestions: SuggestionsConfig;
     toolLabels: ToolLabelConfig;
     toolResults: ToolResultDisplayConfig;
+    /** Custom result components; absent when none are configured. */
+    toolRendererRegistry?: ToolResultRendererRegistry;
     voice: VoiceInputConfig;
     mentionConfig?: MentionConfig;
     pipelineMessageTranslator?: PipelineMessageTranslator;
@@ -27,7 +37,14 @@ export interface ChatContextValue {
     messages: ChatMessage[];
     isLoading: boolean;
     error: Error | null;
-    send: (message: string) => void;
+    /**
+     * `mentions` replaces the provider's active mentions for this message.
+     * Returns false when the message is not taken (an approval is still open or
+     * the session is not ready); the composer should then keep the typed text.
+     */
+    send: (message: string, options?: {
+        mentions?: MentionData[];
+    }) => boolean;
     stop: () => void;
     clear: () => void;
     loadMore: () => void;
@@ -35,6 +52,11 @@ export interface ChatContextValue {
     pipelineSteps: PipelineStepReport[];
     pipelineState: PipelineState | null;
     pendingApprovals: PendingApproval[];
+    /**
+     * True after the user tried to send while an approval waits. Sending is held
+     * until the card is decided; show `locale.approvalPendingHint`.
+     */
+    approvalReminder: boolean;
     approve: (id: string) => void;
     reject: (id: string) => void;
     isProcessingApproval: boolean;
@@ -54,6 +76,33 @@ export interface ChatContextValue {
     clearActiveMentions: () => void;
     isMentionSearching: boolean;
     hasMentions: boolean;
+    completionSearch?: CompletionSearch;
+    hasCompletions: boolean;
+    /** `@` entities and `/` commands; absent without `chatInteractions`. */
+    interactions?: ChatInteractionRegistry;
+    /** A command or entity action waiting for arguments; the composer shows its form. */
+    pendingCommand: PendingChatCommand | null;
+    /**
+     * Runs the pending command with the form values (and picked entity labels), or keeps asking.
+     * True when the form is done (the command was sent and no longer pending); false when
+     * it is still pending (it keeps asking, or nothing could run right now).
+     */
+    submitPendingCommand: (values: Readonly<Record<string, string>>, valueLabels?: Readonly<Record<string, string>>) => boolean;
+    cancelPendingCommand: () => void;
+    /** Runs an entity action picked from the `@` list, without the model. */
+    runEntityAction: (entity: {
+        type: string;
+        id: string;
+        label: string;
+    }, actionId: string) => void;
+    /**
+     * Adds a reference to one entity to the composer, looked up by id through
+     * its definition's `resolve`. False when the entity is unknown or refused.
+     */
+    mentionEntity: (type: string, id: string) => Promise<boolean>;
+    /** References queued by `mentionEntity`, for the composer to insert. */
+    composerMentions: MentionData[];
+    consumeComposerMentions: () => void;
     suggestionChips: string[];
     selectSuggestion: (suggestion: string) => void;
     refreshSuggestions: () => void;
@@ -66,6 +115,8 @@ export interface ChatContextValue {
     sessionsSupported: boolean;
     /** `true` while session CRUD or loading is in flight. */
     isSessionsLoading: boolean;
+    /** Active generation or session mutation prevents changing the conversation. */
+    isSessionChangeBlocked?: boolean;
     /** Switch to an existing session. Reloads messages from `session.load`. */
     switchSession: (id: string) => Promise<void>;
     /** Create a new session, switch to it, refresh the list. */

package/dist/cjs/react/stt/controller.d.ts

@@ -0,0 +1,60 @@
+import { type SttSegment } from './segments.js';
+export type SttSessionPhase = 'idle' | 'requesting_permission' | 'connecting' | 'recording' | 'finalizing' | 'completed' | 'cancelled' | 'failed';
+export interface SttSessionSnapshot {
+    phase: SttSessionPhase;
+    displayTranscript: string;
+    finalTranscript: string;
+    interimTranscript: string;
+    error: string | null;
+}
+export interface SttProviderEvents {
+    onSegment: (segment: SttSegment) => void;
+    onError: (error: Error) => void;
+    onClosed: () => void;
+}
+export interface SttProviderConnection {
+    finalize(): Promise<void>;
+    cancel(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface SttProviderAdapter {
+    connect(input: {
+        stream: MediaStream;
+        language: string;
+        signal: AbortSignal;
+        events: SttProviderEvents;
+    }): Promise<SttProviderConnection>;
+}
+export interface SttSessionControllerOptions {
+    adapter: SttProviderAdapter;
+    language: string;
+    getUserMedia?: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+}
+type Listener = (snapshot: SttSessionSnapshot) => void;
+export declare class SttSessionController {
+    private readonly options;
+    private currentSnapshot;
+    private transcript;
+    private stream;
+    private connection;
+    private abortController;
+    private listeners;
+    private sessionGeneration;
+    private previousDraft;
+    private connectionClosed;
+    private stopOperation;
+    constructor(options: SttSessionControllerOptions);
+    get snapshot(): SttSessionSnapshot;
+    getStream(): MediaStream | null;
+    subscribe(listener: Listener): () => void;
+    start(previousDraft: string): Promise<void>;
+    retry(): Promise<void>;
+    stop(): Promise<string>;
+    private finishStop;
+    cancel(): Promise<string>;
+    dispose(): Promise<void>;
+    private fail;
+    private releaseResources;
+    private update;
+}
+export {};

package/dist/cjs/react/stt/controller.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SttSessionController = void 0;
+const segments_js_1 = require("./segments.js");
+class SttSessionController {
+    options;
+    currentSnapshot = {
+        phase: 'idle',
+        displayTranscript: '',
+        finalTranscript: '',
+        interimTranscript: '',
+        error: null,
+    };
+    transcript = (0, segments_js_1.createSttTranscript)();
+    stream = null;
+    connection = null;
+    abortController = null;
+    listeners = new Set();
+    sessionGeneration = 0;
+    previousDraft = '';
+    connectionClosed = false;
+    stopOperation = null;
+    constructor(options) {
+        this.options = options;
+    }
+    get snapshot() {
+        return this.currentSnapshot;
+    }
+    getStream() {
+        return this.stream;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async start(previousDraft) {
+        const generation = ++this.sessionGeneration;
+        this.previousDraft = previousDraft;
+        this.transcript = (0, segments_js_1.createSttTranscript)();
+        this.update({
+            phase: 'requesting_permission',
+            displayTranscript: '',
+            finalTranscript: '',
+            interimTranscript: '',
+            error: null,
+        });
+        let connectionError = null;
+        try {
+            if (generation !== this.sessionGeneration)
+                return;
+            await this.releaseResources();
+            if (generation !== this.sessionGeneration)
+                return;
+            const getUserMedia = this.options.getUserMedia
+                ?? ((constraints) => (navigator.mediaDevices.getUserMedia(constraints)));
+            const stream = await getUserMedia({
+                audio: { channelCount: 1, sampleRate: 16_000 },
+            });
+            if (generation !== this.sessionGeneration) {
+                for (const track of stream.getTracks())
+                    track.stop();
+                return;
+            }
+            this.stream = stream;
+            this.abortController = new AbortController();
+            this.connectionClosed = false;
+            this.update({ ...this.currentSnapshot, phase: 'connecting' });
+            if (generation !== this.sessionGeneration)
+                return;
+            const connection = await this.options.adapter.connect({
+                stream,
+                language: this.options.language,
+                signal: this.abortController.signal,
+                events: {
+                    onSegment: (segment) => {
+                        if (generation !== this.sessionGeneration)
+                            return;
+                        this.transcript = (0, segments_js_1.applySttSegment)(this.transcript, segment);
+                        this.update({
+                            ...this.currentSnapshot,
+                            displayTranscript: this.transcript.displayText,
+                            finalTranscript: this.transcript.finalText,
+                            interimTranscript: this.transcript.interimText,
+                        });
+                    },
+                    onError: (error) => {
+                        if (generation !== this.sessionGeneration)
+                            return;
+                        connectionError = error;
+                        void this.fail(error);
+                    },
+                    onClosed: () => {
+                        if (generation !== this.sessionGeneration)
+                            return;
+                        this.connectionClosed = true;
+                        if (this.currentSnapshot.phase === 'connecting'
+                            || this.currentSnapshot.phase === 'recording') {
+                            connectionError = new Error('Speech provider connection closed unexpectedly');
+                            void this.fail(connectionError);
+                        }
+                    },
+                },
+            });
+            if (connectionError) {
+                await connection.close();
+                throw connectionError;
+            }
+            if (generation !== this.sessionGeneration) {
+                await connection.close();
+                return;
+            }
+            this.connection = connection;
+            this.update({ ...this.currentSnapshot, phase: 'recording' });
+        }
+        catch (error) {
+            if (generation !== this.sessionGeneration) {
+                if (this.currentSnapshot.phase === 'failed')
+                    throw error;
+                return;
+            }
+            await this.fail(error);
+            throw error;
+        }
+    }
+    async retry() {
+        await this.start(this.previousDraft);
+    }
+    stop() {
+        if (this.stopOperation?.generation === this.sessionGeneration) {
+            return this.stopOperation.promise;
+        }
+        const fallback = this.transcript.finalText || this.transcript.displayText;
+        // Install the operation before notifying subscribers, which may also stop.
+        const operation = {
+            generation: this.sessionGeneration,
+            promise: Promise.resolve().then(() => this.finishStop(operation, fallback)),
+        };
+        this.stopOperation = operation;
+        const clear = () => {
+            if (this.stopOperation === operation)
+                this.stopOperation = null;
+        };
+        void operation.promise.then(clear, clear);
+        return operation.promise;
+    }
+    async finishStop(operation, fallback) {
+        if (operation.generation !== this.sessionGeneration)
+            return fallback;
+        if (!this.connection) {
+            const committed = this.transcript.finalText
+                || this.transcript.displayText;
+            if (this.currentSnapshot.phase === 'requesting_permission'
+                || this.currentSnapshot.phase === 'connecting') {
+                operation.generation = ++this.sessionGeneration;
+                await this.releaseResources();
+                if (operation.generation === this.sessionGeneration)
+                    this.update({
+                        phase: 'completed',
+                        displayTranscript: committed,
+                        finalTranscript: committed,
+                        interimTranscript: '',
+                        error: null,
+                    });
+            }
+            return committed;
+        }
+        const connection = this.connection;
+        this.update({ ...this.currentSnapshot, phase: 'finalizing' });
+        if (operation.generation !== this.sessionGeneration)
+            return fallback;
+        try {
+            await connection.finalize();
+            if (operation.generation !== this.sessionGeneration)
+                return fallback;
+            const committed = this.transcript.finalText || this.transcript.displayText;
+            operation.generation = ++this.sessionGeneration;
+            await this.releaseResources();
+            if (operation.generation === this.sessionGeneration)
+                this.update({
+                    phase: 'completed',
+                    displayTranscript: committed,
+                    finalTranscript: committed,
+                    interimTranscript: '',
+                    error: null,
+                });
+            return committed;
+        }
+        catch (error) {
+            if (operation.generation === this.sessionGeneration)
+                await this.fail(error);
+            throw error;
+        }
+    }
+    async cancel() {
+        const generation = ++this.sessionGeneration;
+        const previousDraft = this.previousDraft;
+        try {
+            if (this.connection)
+                await this.connection.cancel();
+            if (generation !== this.sessionGeneration)
+                return previousDraft;
+            await this.releaseResources();
+        }
+        catch (error) {
+            if (generation === this.sessionGeneration)
+                await this.fail(error);
+            throw error;
+        }
+        if (generation !== this.sessionGeneration)
+            return previousDraft;
+        this.transcript = (0, segments_js_1.createSttTranscript)();
+        this.update({
+            phase: 'cancelled',
+            displayTranscript: '',
+            finalTranscript: '',
+            interimTranscript: '',
+            error: null,
+        });
+        return previousDraft;
+    }
+    async dispose() {
+        this.sessionGeneration += 1;
+        await this.releaseResources();
+    }
+    async fail(error) {
+        const resolved = error instanceof Error ? error : new Error(String(error));
+        const generation = ++this.sessionGeneration;
+        try {
+            await this.releaseResources();
+        }
+        catch {
+            // Tracks are detached/stopped before provider cleanup. Preserve the
+            // original failure rather than emit an unhandled secondary close error.
+        }
+        if (generation === this.sessionGeneration)
+            this.update({
+                ...this.currentSnapshot,
+                phase: 'failed',
+                error: resolved.message,
+            });
+    }
+    async releaseResources() {
+        // Detach synchronously: awaiting an old provider must never expose or later
+        // read resources belonging to a newer recording. Stop tracks even if close
+        // rejects or remains pending.
+        const abortController = this.abortController;
+        this.abortController = null;
+        const connection = this.connection;
+        this.connection = null;
+        const connectionClosed = this.connectionClosed;
+        this.connectionClosed = true;
+        const stream = this.stream;
+        this.stream = null;
+        abortController?.abort();
+        if (stream) {
+            for (const track of stream.getTracks())
+                track.stop();
+        }
+        if (connection && !connectionClosed)
+            await connection.close();
+    }
+    update(snapshot) {
+        this.currentSnapshot = Object.freeze(snapshot);
+        for (const listener of this.listeners)
+            listener(this.currentSnapshot);
+    }
+}
+exports.SttSessionController = SttSessionController;

package/dist/cjs/react/stt/deepgram.d.ts

@@ -0,0 +1,30 @@
+import type { SttProviderAdapter, SttProviderConnection } from './controller.js';
+import type { SttSegment } from './segments.js';
+interface DeepgramMessage {
+    type?: string;
+    message?: string;
+    start?: number;
+    duration?: number;
+    is_final?: boolean;
+    speech_final?: boolean;
+    channel?: {
+        alternatives?: Array<{
+            transcript?: string;
+        }>;
+    };
+}
+export declare function createDeepgramSegmentParser(): (message: DeepgramMessage) => SttSegment | null;
+export interface DeepgramSttAdapterOptions {
+    baseUrl?: string;
+    getToken?: () => string | null | undefined;
+    connectTimeoutMs?: number;
+    finalizeGraceMs?: number;
+}
+/** Microphone audio as 16 kHz mono 16-bit PCM chunks; returns its stop function. */
+export declare function createPcmPipeline(stream: MediaStream, onAudio: (audio: ArrayBuffer) => void): Promise<() => Promise<void>>;
+export declare class DeepgramSttAdapter implements SttProviderAdapter {
+    private readonly options;
+    constructor(options?: DeepgramSttAdapterOptions);
+    connect(input: Parameters<SttProviderAdapter['connect']>[0]): Promise<SttProviderConnection>;
+}
+export {};

package/dist/cjs/react/stt/deepgram.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeepgramSttAdapter = void 0;
+exports.createDeepgramSegmentParser = createDeepgramSegmentParser;
+exports.createPcmPipeline = createPcmPipeline;
+function createDeepgramSegmentParser() {
+    const sequences = new Map();
+    let nextUntimedSequence = 0;
+    return (message) => {
+        const text = message.channel?.alternatives?.[0]?.transcript?.trim();
+        if (!text)
+            return null;
+        const hasProviderTimestamp = Number.isFinite(message.start);
+        const id = hasProviderTimestamp
+            ? `deepgram-${message.start}`
+            : `deepgram-sequence-${nextUntimedSequence}`;
+        let sequence = sequences.get(id);
+        if (sequence === undefined) {
+            sequence = hasProviderTimestamp
+                ? message.start
+                : 1_000_000_000 + nextUntimedSequence;
+            sequences.set(id, sequence);
+            if (!hasProviderTimestamp)
+                nextUntimedSequence += 1;
+        }
+        return {
+            id,
+            sequence,
+            text,
+            isFinal: message.is_final === true,
+        };
+    };
+}
+function resolveWebSocketUrl(baseUrl, language, token) {
+    const fallbackProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+    const fallback = `${fallbackProtocol}//${window.location.host}/api/ai/speech-stream`;
+    const url = new URL(baseUrl ?? fallback, window.location.href);
+    if (url.protocol === 'http:')
+        url.protocol = 'ws:';
+    if (url.protocol === 'https:')
+        url.protocol = 'wss:';
+    url.searchParams.set('language', language);
+    if (token)
+        url.searchParams.set('token', token);
+    return url.toString();
+}
+/** Microphone audio as 16 kHz mono 16-bit PCM chunks; returns its stop function. */
+async function createPcmPipeline(stream, onAudio) {
+    const AudioContextCtor = globalThis.AudioContext
+        ?? globalThis.webkitAudioContext;
+    if (!AudioContextCtor)
+        throw new Error('Browser does not support AudioContext');
+    const context = new AudioContextCtor({ sampleRate: 16_000 });
+    await context.audioWorklet.addModule('/audio-worklet-processor.js');
+    const source = context.createMediaStreamSource(stream);
+    const processor = new AudioWorkletNode(context, 'audio-processor');
+    processor.port.onmessage = (event) => {
+        onAudio(event.data.buffer);
+    };
+    source.connect(processor);
+    processor.connect(context.destination);
+    return async () => {
+        processor.port.onmessage = null;
+        processor.disconnect();
+        source.disconnect();
+        await context.close();
+    };
+}
+class DeepgramSttAdapter {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async connect(input) {
+        const token = this.options.getToken?.();
+        const url = resolveWebSocketUrl(this.options.baseUrl, input.language, token);
+        const socket = new WebSocket(url);
+        const parser = createDeepgramSegmentParser();
+        const connectTimeoutMs = this.options.connectTimeoutMs ?? 5_000;
+        const finalizeGraceMs = this.options.finalizeGraceMs ?? 750;
+        let disposed = false;
+        let closeAudio = null;
+        let finalizePromise = null;
+        let resolveFinalize = null;
+        let finalizeTimeout = null;
+        const settleFinalization = () => {
+            if (!resolveFinalize)
+                return;
+            if (finalizeTimeout)
+                clearTimeout(finalizeTimeout);
+            finalizeTimeout = null;
+            const resolve = resolveFinalize;
+            resolveFinalize = null;
+            resolve();
+        };
+        try {
+            await new Promise((resolve, reject) => {
+                const abort = () => finish('aborted');
+                const finish = (result) => {
+                    clearTimeout(timeout);
+                    input.signal.removeEventListener('abort', abort);
+                    if (result === 'open')
+                        resolve();
+                    if (result === 'error')
+                        reject(new Error('Speech provider connection failed'));
+                    if (result === 'aborted')
+                        reject(new Error('Speech provider connection cancelled'));
+                    if (result === 'timeout')
+                        reject(new Error('Speech provider connection timeout'));
+                };
+                const timeout = setTimeout(() => finish('timeout'), connectTimeoutMs);
+                socket.onopen = () => finish('open');
+                socket.onerror = () => finish('error');
+                input.signal.addEventListener('abort', abort, { once: true });
+            });
+        }
+        catch (error) {
+            socket.onopen = null;
+            socket.onerror = null;
+            if (socket.readyState === WebSocket.OPEN
+                || socket.readyState === WebSocket.CONNECTING) {
+                socket.close();
+            }
+            throw error;
+        }
+        socket.onmessage = (event) => {
+            if (typeof event.data !== 'string')
+                return;
+            try {
+                const message = JSON.parse(event.data);
+                if (message.type === 'error') {
+                    input.events.onError(new Error(message.message ?? 'Transcription failed'));
+                    return;
+                }
+                const segment = parser(message);
+                if (segment)
+                    input.events.onSegment(segment);
+                if (message.is_final === true || message.speech_final === true) {
+                    settleFinalization();
+                }
+            }
+            catch {
+                // Provider metadata may be non-JSON; it carries no transcript.
+            }
+        };
+        socket.onerror = () => input.events.onError(new Error('Speech provider connection failed'));
+        socket.onclose = () => {
+            settleFinalization();
+            input.events.onClosed();
+        };
+        const close = async () => {
+            if (disposed)
+                return;
+            disposed = true;
+            settleFinalization();
+            await closeAudio?.();
+            closeAudio = null;
+            socket.onopen = null;
+            socket.onmessage = null;
+            socket.onerror = null;
+            socket.onclose = null;
+            if (socket.readyState === WebSocket.OPEN
+                || socket.readyState === WebSocket.CONNECTING) {
+                socket.close();
+            }
+        };
+        input.signal.addEventListener('abort', () => {
+            void close();
+        }, { once: true });
+        try {
+            closeAudio = await createPcmPipeline(input.stream, (audio) => {
+                if (socket.readyState === WebSocket.OPEN)
+                    socket.send(audio);
+            });
+        }
+        catch (error) {
+            await close();
+            throw error;
+        }
+        return {
+            finalize: () => {
+                if (socket.readyState !== WebSocket.OPEN)
+                    return Promise.resolve();
+                if (finalizePromise)
+                    return finalizePromise;
+                finalizePromise = new Promise((resolve) => {
+                    resolveFinalize = resolve;
+                    finalizeTimeout = setTimeout(settleFinalization, finalizeGraceMs);
+                });
+                try {
+                    socket.send(JSON.stringify({ type: 'Finalize' }));
+                }
+                catch (error) {
+                    settleFinalization();
+                    return Promise.reject(error);
+                }
+                return finalizePromise;
+            },
+            cancel: close,
+            close,
+        };
+    }
+}
+exports.DeepgramSttAdapter = DeepgramSttAdapter;

package/dist/cjs/react/stt/recorded.d.ts

@@ -0,0 +1,29 @@
+import type { SttProviderAdapter, SttProviderConnection } from './controller.js';
+export interface RecordedSttAdapterOptions {
+    /** Endpoint that takes the WAV and answers `{ text }`. Default: `/api/ai/speech-recognize`. */
+    url?: string;
+    /** Extra request headers, read when the recording is sent. */
+    getHeaders?: () => Record<string, string> | undefined;
+    /** Longest recording kept, in seconds; later audio is dropped. Default: 120. */
+    maxSeconds?: number;
+    /** For tests and non-browser hosts. */
+    fetch?: typeof fetch;
+    /** Audio capture as 16 kHz mono PCM chunks; returns its stop function. */
+    capture?: (stream: MediaStream, onAudio: (audio: ArrayBuffer) => void) => Promise<() => Promise<void>>;
+}
+/** 16-bit mono PCM chunks as one WAV file. */
+export declare function encodeWav(chunks: ReadonlyArray<Int16Array>, sampleRate: number): ArrayBuffer;
+/**
+ * Speech input for a transcription model that takes a finished recording
+ * instead of a live stream (Parakeet, Whisper and the like): the audio is
+ * kept in the browser while the user speaks and sent once when they stop.
+ * There is no interim text; the transcript arrives as one final segment.
+ *
+ * The endpoint is the app's own route. It receives `audio/wav` (16 kHz, mono,
+ * 16 bit) with the language as a query parameter and answers `{ "text": … }`.
+ */
+export declare class RecordedSttAdapter implements SttProviderAdapter {
+    private readonly options;
+    constructor(options?: RecordedSttAdapterOptions);
+    connect(input: Parameters<SttProviderAdapter['connect']>[0]): Promise<SttProviderConnection>;
+}