@opengeni/react 0.15.0 → 0.23.0

package/dist/composer-CVm5uoUI.d.ts

@@ -0,0 +1,585 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { KeyboardEvent, ButtonHTMLAttributes, ClipboardEvent, RefObject, DragEvent, ChangeEvent, ComponentPropsWithoutRef, ReactNode } from 'react';
+import * as _opengeni_sdk from '@opengeni/sdk';
+import { Permission, SessionStatus, FileAsset, FileResourceRef, EffectiveSessionControl, ClientModel, TranscriptionLifecycleStatus, TranscriptionErrorCode, TranscriptionEvent, TranscriptionAdapter, WorkspaceTranscriptionPolicy, TranscriptionTargetSelection, TranscriptionDiagnostic, TranscriptionPolicyBlockReason } from '@opengeni/sdk';
+import { S as SessionClientLike, C as ClientOverride } from './session-context-rgrfElMl.js';
+import { C as ComposerState } from './use-composer-By1wn3MM.js';
+
+/**
+ * The slash-command registry. A command is a SESSION / OPERATOR control — an
+ * action on the session or the UI (clear, compact, pause the goal, show help) —
+ * NOT a structured way to talk to the agent. The human↔agent channel stays
+ * plain chat; the palette only recognizes a leading "/" and never sends a
+ * command to the model.
+ *
+ * Two kinds, modeled by where the handler does its work:
+ *  - CLIENT commands touch only the local UI (e.g. /help, /clear-view).
+ *  - SERVER commands call the API through the SDK (e.g. /clear, /compact,
+ *    /goal).
+ * Both are just `run(args, ctx)`; `ctx` exposes the client for server commands
+ * and the UI affordances (notice, openHelp, clearView, confirm) for both.
+ */
+/** A positional argument a command accepts after its name. */
+type SlashArg = {
+    name: string;
+    /** Enter runs only once every required arg is present; otherwise autocompletes. */
+    required?: boolean;
+    /** Closed value set (rendered as a hint; validated by the command itself). */
+    oneOf?: readonly string[];
+    description?: string;
+};
+/** Transient feedback surfaced in the composer (generalized error line). */
+type Notice = {
+    tone: "ok" | "error";
+    message: string;
+};
+/** Everything a command handler can reach. Assembled by the composer. */
+type CommandContext = {
+    /** SDK-shaped client for server commands. */
+    client: SessionClientLike;
+    workspaceId: string;
+    /** Null before a session exists (server commands should guard on this). */
+    sessionId: string | null;
+    status: SessionStatus | null;
+    /** The operator's permissions on this workspace (gates command visibility). */
+    permissions: Permission[];
+    /** Surface a transient ok/error notice in the composer. */
+    notice: (notice: Notice) => void;
+    /** Open the in-composer /help panel (rendered from the registry). */
+    openHelp: () => void;
+    /**
+     * Reset only the LOCAL timeline view — no server call. Returns whether a
+     * view-reset affordance was actually wired (and thus had an effect): the host
+     * surface supplies one via the composer's `onClearView` prop, and consoles
+     * that don't (no resettable local timeline) get `false`. The /clear-view
+     * command uses this to avoid reporting a false "cleared" success on a no-op.
+     */
+    clearView: () => boolean;
+    /** Show the danger confirm bar; resolves true once the operator confirms. */
+    confirm: () => Promise<boolean>;
+};
+type CommandResult = {
+    status: "ok" | "error";
+    message?: string;
+    /**
+     * Keep the composer draft instead of clearing it on an ok result. Used when a
+     * command resolves to a no-op the operator may want to retry — e.g. canceling
+     * the /clear confirm bar returns ok (no error) but must NOT wipe the typed
+     * "/clear" draft. Default false: a successful command clears the draft.
+     */
+    keepDraft?: boolean;
+};
+type SlashCommand = {
+    /** Primary token after the slash (no leading "/"). */
+    name: string;
+    /** Alternate tokens that resolve to this command. */
+    aliases?: readonly string[];
+    description: string;
+    args?: readonly SlashArg[];
+    /** Required permission; the command is hidden from the palette without it. */
+    permission?: Permission;
+    /** Destructive — the palette shows a confirm bar before running. */
+    danger?: boolean;
+    /**
+     * Dynamic availability beyond the permission gate (e.g. hide a server command
+     * until a session exists). Returning false hides the command.
+     */
+    available?: (ctx: Pick<CommandContext, "sessionId" | "status" | "permissions">) => boolean;
+    /** Execute the command. Throwing is caught and surfaced as an error notice. */
+    run: (args: string[], ctx: CommandContext) => Promise<CommandResult> | CommandResult;
+};
+
+/**
+ * Context the composer supplies for command execution and visibility. The
+ * composer owns the UI affordances (notice/openHelp/clearView/confirm), so they
+ * are NOT part of this slice — the hook closes over them via `handlers`.
+ */
+type SlashCommandContext = Pick<CommandContext, "client" | "workspaceId" | "sessionId" | "status" | "permissions">;
+/**
+ * UI affordances the composer supplies. `confirm` differs from the registry-
+ * facing {@link CommandContext.confirm} (which takes no args): the composer's
+ * confirm receives the command being run so the confirm bar renders from that
+ * exact command's identity. The hook bridges the two in {@link buildContext}.
+ */
+type SlashCommandHandlers = Pick<CommandContext, "notice" | "openHelp" | "clearView"> & {
+    confirm: (command: SlashCommand) => Promise<boolean>;
+};
+type ConfirmState = {
+    command: SlashCommand;
+    /** Resolve the pending confirm() promise. */
+    resolve: (confirmed: boolean) => void;
+} | null;
+type UseSlashCommandsOptions = {
+    commands: readonly SlashCommand[];
+    context: SlashCommandContext | undefined;
+    handlers: SlashCommandHandlers;
+    /** The current composer draft. */
+    value: string;
+    /** Replace the composer draft (autocomplete writes through this). */
+    setValue: (value: string) => void;
+};
+type UseSlashCommandsResult = {
+    /** Whether the palette is open (a command token is being typed). */
+    open: boolean;
+    /**
+     * Whether the draft is a slash-command attempt (matches a registered command)
+     * — true even after Escape dismisses the popover. The composer blocks its send
+     * path while this holds so a command can't be delivered to the agent as chat.
+     */
+    isCommandDraft: boolean;
+    /** Commands shown for the current token + context, in display order. */
+    items: SlashCommand[];
+    /** Index into `items` of the highlighted row. */
+    highlight: number;
+    setHighlight: (index: number) => void;
+    /** The matched command once the name is closed by a space (arg-hint mode). */
+    activeCommand: SlashCommand | null;
+    /** The arg hint string for the active command (footer), or "". */
+    activeArgHint: string;
+    /**
+     * Key handler for the textarea. Returns true when it consumed the event
+     * (the composer must then NOT run its send path). Only consumes while open.
+     */
+    onKeyDown: (event: KeyboardEvent<HTMLTextAreaElement>) => boolean;
+    /** Run the highlighted command (or the active command in arg-hint mode). */
+    runHighlighted: () => Promise<void>;
+    /**
+     * Run the command at an explicitly chosen index (a pointer click on a row).
+     * Bypasses the exact-match token heuristic that runHighlighted uses for
+     * keyboard Enter, so an explicit click always runs the clicked command.
+     */
+    runAt: (index: number) => Promise<void>;
+    /** Autocomplete the highlighted command name + a trailing space. */
+    autocompleteHighlighted: () => void;
+};
+declare function useSlashCommands(options: UseSlashCommandsOptions): UseSlashCommandsResult;
+
+type UseFileAttachmentsOptions = ClientOverride & {
+    /**
+     * Only files matching this predicate are accepted by {@link
+     * UseFileAttachmentsResult.addFromPaste} (the clipboard path). Defaults to
+     * `image/*` — the console's historical paste filter. {@link
+     * UseFileAttachmentsResult.addFiles} (the explicit picker / drop path)
+     * bypasses it.
+     */
+    pasteFilter?: ((file: File) => boolean) | undefined;
+};
+type FileAttachment = {
+    id: string;
+    name: string;
+    contentType: string;
+    sizeBytes: number;
+    status: "uploading" | "ready" | "failed";
+    /** The SDK `FileAsset` once the upload finishes. */
+    file?: FileAsset | undefined;
+    /** Object-URL for an inline preview; minted for `image/*` files only. */
+    previewUrl?: string | undefined;
+    error?: string | undefined;
+};
+type UseFileAttachmentsResult = {
+    attachments: FileAttachment[];
+    /**
+     * `FileResourceRef[]` for every attachment that finished uploading — feed
+     * straight into `useComposer`'s `sendExtras.resources`.
+     */
+    readyResources: FileResourceRef[];
+    /** True while any attachment is still uploading (drives the send-gate). */
+    uploading: boolean;
+    /** Explicit picker / drop path — uploads every file, no filter. */
+    addFiles: (files: Iterable<File>) => void;
+    /** Clipboard path — applies `pasteFilter` (default `image/*`) then uploads. */
+    addFromPaste: (event: {
+        clipboardData: DataTransfer | null;
+    }) => void;
+    /**
+     * Re-run the upload for a `failed` attachment, in place (same id, same
+     * source file). No-op for an id that isn't a known failed upload.
+     */
+    retry: (id: string) => void;
+    /** Remove one attachment; revokes its object-URL. */
+    remove: (id: string) => void;
+    /** Remove all; revokes every object-URL. Call from `useComposer`'s `onSent`. */
+    clear: () => void;
+};
+/**
+ * Upload-and-track state for files attached to the next message. Owns the
+ * full client-side upload layer: a per-file `uploading | ready | failed`
+ * status machine driven by the SDK's `client.uploadFile`, object-URL image
+ * previews with create/revoke lifecycle, the `image/*` clipboard paste filter,
+ * and a `FileResourceRef[]` projection that drops straight into a message's
+ * `resources`. Workspace-scoped, so it resolves both client and workspace from
+ * the {@link OpenGeniProvider} (or a per-call `{ client, workspaceId }`).
+ */
+declare function useFileAttachments(options?: UseFileAttachmentsOptions): UseFileAttachmentsResult;
+
+declare const OPEN_WORKSTREAM_CONTROL_EVENT = "opengeni:open-workstream-control";
+type ComposerDelivery = Pick<ComposerState, "value" | "setValue" | "send" | "steer" | "sending" | "canSend" | "error" | "clearError">;
+type ComposerDraftState = Pick<ComposerState, "draftConflict" | "draftSaving" | "resolveDraftConflict" | "restoredResources" | "removeRestoredResource">;
+type ComposerControlState = Pick<ComposerState, "pause" | "pausing" | "resume" | "resumeScope" | "resuming">;
+type ComposerControlLinks = {
+    workspaceHref?: string | undefined;
+    sessionHref?: ((sessionId: string) => string) | undefined;
+};
+type ChatComposerMessages = {
+    messagePlaceholder: string;
+    pausedPlaceholder: string;
+    inputLabel: string;
+    keyboardHint: string;
+    slashCommandBlocked: string;
+    controlChangedError: string;
+    sendFailedError: string;
+    dropFiles: string;
+    attachFiles: string;
+    pauseAriaLabel: string;
+    pauseTitle: string;
+    sendMessageAriaLabel: string;
+    sendAndResumeAriaLabel: string;
+    sendTitle: string;
+    sendAndResumeTitle: string;
+    workspacePaused: string;
+    pausedHere: string;
+    parentBlocker: string;
+    narrowerPause: string;
+    pausedBy: (displayName: string) => string;
+    queuedAhead: (count: number) => string;
+    resumingAndSending: string;
+    nextMessageResumes: string;
+    resumeThisWorkstream: string;
+    resumeShort: string;
+    hidePauseDetails: string;
+    showPauseDetails: string;
+    pauseReasonsLabel: string;
+    pausedByLabel: string;
+    alsoPausedByLabel: string;
+    resumeWorkspace: string;
+    resumeFromSession: string;
+    sessionCanRun: string;
+    stillPausedBy: (displayName: string) => string;
+    restoredResourcesLabel: string;
+    restoredFile: (fileId: string) => string;
+    removeRestoredResource: (index: number) => string;
+    uploading: string;
+    uploadFailed: string;
+    retryAttachment: (name: string) => string;
+    retryUpload: string;
+    removeAttachment: (name: string) => string;
+    confirmCommand: (name: string) => string;
+    confirmDescription: (command: SlashCommand) => string;
+    cancel: string;
+    runCommand: (name: string) => string;
+    commands: string;
+    slashCommandsLabel: string;
+    modelLabel: string;
+    close: string;
+    danger: string;
+    draftConflict: string;
+    useOtherDraft: string;
+    keepMine: string;
+    savingDraft: string;
+    formatBytes: (bytes: number) => string;
+    formatRelativeTime: (changedAt: string) => string;
+};
+declare const defaultChatComposerMessages: ChatComposerMessages;
+type ComposerSubmitMode = "queue" | "steer";
+type ComposerSubmitBlocker = "disabled" | "uploading" | "sending" | "command" | "empty" | null;
+type UseChatComposerControllerOptions = {
+    delivery: ComposerDelivery;
+    draft?: ComposerDraftState | undefined;
+    control?: ComposerControlState | undefined;
+    effectiveControl?: EffectiveSessionControl | null | undefined;
+    queuedAheadCount?: number | undefined;
+    canControlWorkspace?: boolean | undefined;
+    controlLinks?: ComposerControlLinks | undefined;
+    disabled?: boolean | undefined;
+    attachments?: UseFileAttachmentsResult | undefined;
+    commands?: readonly SlashCommand[] | undefined;
+    commandContext?: SlashCommandContext | undefined;
+    onClearView?: (() => void) | undefined;
+    onPaste?: ((event: ClipboardEvent<HTMLTextAreaElement>) => void) | undefined;
+    messages?: Partial<ChatComposerMessages> | undefined;
+};
+/**
+ * Headless interaction layer for a chat composer. It is the single owner of
+ * delivery guards, keyboard routing, command interception, drag/drop, focus,
+ * confirmation, and feedback state used by both the preset and primitives.
+ */
+declare function useChatComposerController({ delivery, draft, control, effectiveControl, queuedAheadCount, canControlWorkspace, controlLinks, disabled, attachments, commands, commandContext, onClearView, onPaste, messages: messageOverrides, }: UseChatComposerControllerOptions): {
+    id: string;
+    rootRef: RefObject<HTMLDivElement | null>;
+    textareaRef: RefObject<HTMLTextAreaElement | null>;
+    pauseButtonRef: RefObject<HTMLButtonElement | null>;
+    fileInputRef: RefObject<HTMLInputElement | null>;
+    listboxId: string;
+    effectiveControl: EffectiveSessionControl | null | undefined;
+    queuedAheadCount: number;
+    canControlWorkspace: boolean;
+    controlLinks: ComposerControlLinks | undefined;
+    disabled: boolean;
+    attachments: UseFileAttachmentsResult | undefined;
+    messages: {
+        messagePlaceholder: string;
+        pausedPlaceholder: string;
+        inputLabel: string;
+        keyboardHint: string;
+        slashCommandBlocked: string;
+        controlChangedError: string;
+        sendFailedError: string;
+        dropFiles: string;
+        attachFiles: string;
+        pauseAriaLabel: string;
+        pauseTitle: string;
+        sendMessageAriaLabel: string;
+        sendAndResumeAriaLabel: string;
+        sendTitle: string;
+        sendAndResumeTitle: string;
+        workspacePaused: string;
+        pausedHere: string;
+        parentBlocker: string;
+        narrowerPause: string;
+        pausedBy: (displayName: string) => string;
+        queuedAhead: (count: number) => string;
+        resumingAndSending: string;
+        nextMessageResumes: string;
+        resumeThisWorkstream: string;
+        resumeShort: string;
+        hidePauseDetails: string;
+        showPauseDetails: string;
+        pauseReasonsLabel: string;
+        pausedByLabel: string;
+        alsoPausedByLabel: string;
+        resumeWorkspace: string;
+        resumeFromSession: string;
+        sessionCanRun: string;
+        stillPausedBy: (displayName: string) => string;
+        restoredResourcesLabel: string;
+        restoredFile: (fileId: string) => string;
+        removeRestoredResource: (index: number) => string;
+        uploading: string;
+        uploadFailed: string;
+        retryAttachment: (name: string) => string;
+        retryUpload: string;
+        removeAttachment: (name: string) => string;
+        confirmCommand: (name: string) => string;
+        confirmDescription: (command: SlashCommand) => string;
+        cancel: string;
+        runCommand: (name: string) => string;
+        commands: string;
+        slashCommandsLabel: string;
+        modelLabel: string;
+        close: string;
+        danger: string;
+        draftConflict: string;
+        useOtherDraft: string;
+        keepMine: string;
+        savingDraft: string;
+        formatBytes: (bytes: number) => string;
+        formatRelativeTime: (changedAt: string) => string;
+    };
+    sending: boolean;
+    error: Error | null;
+    clearError: () => void;
+    hasDraftState: boolean;
+    draftConflict: Error | null;
+    draftSaving: boolean;
+    restoredResources: _opengeni_sdk.ResourceRef[];
+    removeRestoredResource: ((index: number) => void) | undefined;
+    resolveDraftConflict: ((choice: "keep_mine" | "use_remote") => Promise<void>) | undefined;
+    hasControl: boolean;
+    pausing: boolean;
+    resuming: boolean;
+    pause: (reason?: string) => Promise<boolean>;
+    resume: (reason?: string) => Promise<boolean>;
+    resumeScope: (option: EffectiveSessionControl["resumeOptions"][number]) => Promise<boolean>;
+    paused: boolean;
+    controlDetailsOpen: boolean;
+    setControlDetailsOpen: react.Dispatch<react.SetStateAction<boolean>>;
+    paletteMounted: boolean;
+    setPaletteMounted: react.Dispatch<react.SetStateAction<boolean>>;
+    dragging: boolean;
+    handleDragOver: (event: DragEvent<HTMLDivElement>) => void;
+    handleDragLeave: (event: DragEvent<HTMLDivElement>) => void;
+    handleDrop: (event: DragEvent<HTMLDivElement>) => void;
+    palette: UseSlashCommandsResult;
+    paletteEnabled: boolean;
+    commandDraftBlocked: boolean;
+    confirmState: ConfirmState;
+    settleConfirmation: (confirmed: boolean) => void;
+    helpOpen: boolean;
+    setHelpOpen: react.Dispatch<react.SetStateAction<boolean>>;
+    helpCommands: SlashCommand[];
+    activeNotice: Notice | null;
+    canSubmit: boolean;
+    submitBlocker: ComposerSubmitBlocker;
+    submit: (mode: ComposerSubmitMode) => Promise<boolean>;
+    handleKeyDown: (event: KeyboardEvent<HTMLTextAreaElement>) => void;
+    handlePaste: (event: ClipboardEvent<HTMLTextAreaElement>) => void;
+    handleFileChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    focusInput: () => void | undefined;
+    setValue: (value: string) => void;
+    value: string;
+};
+type ChatComposerController = ReturnType<typeof useChatComposerController>;
+type ChatComposerContextValue = Pick<ChatComposerController, "id" | "value" | "setValue" | "focusInput" | "submit" | "canSubmit" | "submitBlocker" | "disabled" | "sending" | "error" | "clearError" | "attachments" | "messages" | "effectiveControl" | "paused" | "hasControl" | "pausing" | "resuming" | "pause" | "resume" | "resumeScope">;
+/** Read the nearest compound composer's safe accessory-facing state and actions. */
+declare function useChatComposer(): ChatComposerContextValue;
+type ComposerRootProps = Omit<ComponentPropsWithoutRef<"div">, "children"> & {
+    controller: ChatComposerController;
+    children: ReactNode;
+};
+declare const Root: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
+    controller: ChatComposerController;
+    children: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+type ComposerFrameProps = ComponentPropsWithoutRef<"div">;
+declare const Frame: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+type ComposerCommandPaletteProps = {
+    className?: string | undefined;
+};
+declare function CommandPalette({ className }: ComposerCommandPaletteProps): react_jsx_runtime.JSX.Element | null;
+type OwnedSurfaceProps = "onDragOver" | "onDragLeave" | "onDrop";
+type ComposerSurfaceProps = Omit<ComponentPropsWithoutRef<"div">, OwnedSurfaceProps>;
+declare const Surface: react.ForwardRefExoticComponent<ComposerSurfaceProps & react.RefAttributes<HTMLDivElement>>;
+declare function PausedState(): react_jsx_runtime.JSX.Element | null;
+declare function RestoredResources(): react_jsx_runtime.JSX.Element | null;
+declare function Attachments(): react_jsx_runtime.JSX.Element | null;
+type OwnedInputProps = "value" | "defaultValue" | "onChange" | "onKeyDown" | "onPaste" | "disabled" | "aria-autocomplete" | "aria-controls" | "aria-activedescendant" | "aria-keyshortcuts";
+type ComposerInputProps = Omit<ComponentPropsWithoutRef<"textarea">, OwnedInputProps>;
+declare const Input: react.ForwardRefExoticComponent<ComposerInputProps & react.RefAttributes<HTMLTextAreaElement>>;
+declare function Confirmation(): react_jsx_runtime.JSX.Element | null;
+type ComposerFooterProps = ComponentPropsWithoutRef<"div">;
+declare const Footer: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+type ComposerControlsProps = ComponentPropsWithoutRef<"span">;
+declare const Controls: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+type ComposerHintProps = ComponentPropsWithoutRef<"span">;
+declare const Hint: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+type ComposerActionsProps = ComponentPropsWithoutRef<"span">;
+declare const Actions: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & react.RefAttributes<HTMLSpanElement>>;
+type OwnedButtonProps = "type" | "onClick" | "disabled";
+type ComposerAttachButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, OwnedButtonProps> & {
+    accept?: string | undefined;
+    multiple?: boolean | undefined;
+};
+declare const AttachButton: react.ForwardRefExoticComponent<Omit<ButtonHTMLAttributes<HTMLButtonElement>, OwnedButtonProps> & {
+    accept?: string | undefined;
+    multiple?: boolean | undefined;
+} & react.RefAttributes<HTMLButtonElement>>;
+type ComposerModelPickerProps = {
+    models: ClientModel[];
+    value?: string | undefined;
+    onChange?: ((modelId: string) => void) | undefined;
+    label?: string | undefined;
+    className?: string | undefined;
+};
+declare function ModelPicker({ models, value, onChange, label, className, }: ComposerModelPickerProps): react_jsx_runtime.JSX.Element;
+type ComposerPauseButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, OwnedButtonProps>;
+declare const PauseButton: react.ForwardRefExoticComponent<ComposerPauseButtonProps & react.RefAttributes<HTMLButtonElement>>;
+type ComposerSendButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, OwnedButtonProps>;
+declare const SendButton: react.ForwardRefExoticComponent<ComposerSendButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare function Help(): react_jsx_runtime.JSX.Element;
+declare function Status(): react_jsx_runtime.JSX.Element;
+
+type TranscriptionControlState = {
+    status: TranscriptionLifecycleStatus;
+    generation: number;
+    localSessionId: string | null;
+    providerSessionId: string | null;
+    lastSequence: number;
+    partial: string;
+    error: {
+        code: TranscriptionErrorCode;
+        recoverable: boolean;
+    } | null;
+    acceptedFinalIds: string[];
+    audioMilliseconds: number;
+    costUsd: number | null;
+};
+declare const INITIAL_TRANSCRIPTION_CONTROL_STATE: TranscriptionControlState;
+type TranscriptionControlAction = {
+    type: "start";
+    generation: number;
+    localSessionId: string;
+} | {
+    type: "event";
+    generation: number;
+    event: TranscriptionEvent;
+} | {
+    type: "start.failed";
+    generation: number;
+    code: TranscriptionErrorCode;
+} | {
+    type: "cancel";
+    generation: number;
+} | {
+    type: "cancel.settled";
+    generation: number;
+} | {
+    type: "reset";
+};
+type TranscriptionControlTransition = {
+    state: TranscriptionControlState;
+    /** A newly accepted final to append to the current editable draft once. */
+    commit: string | null;
+};
+declare function transitionTranscriptionControl(state: TranscriptionControlState, action: TranscriptionControlAction): TranscriptionControlTransition;
+declare function appendFinalTranscript(draft: string, transcript: string): string;
+type UseTranscriptionOptions = {
+    adapter: TranscriptionAdapter | null;
+    policy: WorkspaceTranscriptionPolicy;
+    selection?: TranscriptionTargetSelection | undefined;
+    value: string;
+    setValue: (value: string) => void;
+    focusInput: () => void;
+    disabled?: boolean | undefined;
+    createLocalSessionId?: (() => string) | undefined;
+    lifecycleTimeouts?: Partial<TranscriptionLifecycleTimeouts> | undefined;
+    /** Receives bounded, redacted diagnostics; this detail is never rendered by the hook. */
+    onDiagnostic?: ((diagnostic: TranscriptionDiagnostic) => void) | undefined;
+};
+type TranscriptionLifecycleTimeouts = {
+    startMs: number;
+    cleanupMs: number;
+};
+type UseTranscriptionResult = {
+    state: TranscriptionControlState;
+    available: boolean;
+    unavailableReason: TranscriptionPolicyBlockReason | "adapter_missing" | "composer_disabled" | null;
+    start: () => Promise<boolean>;
+    cancel: () => Promise<boolean>;
+    reset: () => void;
+};
+declare function useTranscription({ adapter, policy, selection, value, setValue, focusInput, disabled, createLocalSessionId, lifecycleTimeouts, onDiagnostic, }: UseTranscriptionOptions): UseTranscriptionResult;
+
+type ComposerTranscriptionMessages = {
+    start: string;
+    stop: string;
+    retry: string;
+    requestingPermission: string;
+    listening: string;
+    reconnecting: string;
+    cancelling: string;
+    unavailableDisabled: string;
+    unavailableAdapter: string;
+    unavailablePolicy: string;
+    errorPermissionDenied: string;
+    errorNotSupported: string;
+    errorNetwork: string;
+    errorProvider: string;
+    errorPolicyBlocked: string;
+    errorTimeout: string;
+    errorCancelled: string;
+    errorUnknown: string;
+};
+type ComposerTranscriptionControlProps = {
+    adapter: TranscriptionAdapter | null;
+    policy: WorkspaceTranscriptionPolicy;
+    selection?: TranscriptionTargetSelection | undefined;
+    messages?: Partial<ComposerTranscriptionMessages> | undefined;
+    className?: string | undefined;
+    lifecycleTimeouts?: Partial<TranscriptionLifecycleTimeouts> | undefined;
+    onDiagnostic?: ((diagnostic: TranscriptionDiagnostic) => void) | undefined;
+};
+/** One provider-neutral microphone control for the nearest editable composer. */
+declare function ComposerTranscriptionControl({ adapter, policy, selection, messages: overrides, className, lifecycleTimeouts, onDiagnostic, }: ComposerTranscriptionControlProps): react_jsx_runtime.JSX.Element;
+
+export { type ComposerSubmitMode as $, Actions as A, type ChatComposerController as B, type ComposerControlLinks as C, CommandPalette as D, type ComposerActionsProps as E, type FileAttachment as F, type ComposerAttachButtonProps as G, type ComposerCommandPaletteProps as H, INITIAL_TRANSCRIPTION_CONTROL_STATE as I, type ComposerControlState as J, type ComposerControlsProps as K, type ComposerDelivery as L, type ComposerDraftState as M, type Notice as N, OPEN_WORKSTREAM_CONTROL_EVENT as O, type ComposerFooterProps as P, type ComposerFrameProps as Q, type ComposerHintProps as R, type SlashCommand as S, type TranscriptionControlAction as T, type UseFileAttachmentsResult as U, type ComposerInputProps as V, type ComposerModelPickerProps as W, type ComposerPauseButtonProps as X, type ComposerRootProps as Y, type ComposerSendButtonProps as Z, type ComposerSubmitBlocker as _, type ComposerTranscriptionControlProps as a, type ComposerSurfaceProps as a0, Confirmation as a1, Controls as a2, Footer as a3, Frame as a4, Help as a5, Hint as a6, Input as a7, ModelPicker as a8, PauseButton as a9, PausedState as aa, RestoredResources as ab, Root as ac, SendButton as ad, Status as ae, Surface as af, type UseChatComposerControllerOptions as ag, useChatComposer as ah, useChatComposerController as ai, type SlashCommandContext as b, type ChatComposerMessages as c, type SlashArg as d, type CommandContext as e, type CommandResult as f, ComposerTranscriptionControl as g, type ComposerTranscriptionMessages as h, type ConfirmState as i, type SlashCommandHandlers as j, type TranscriptionControlState as k, type TranscriptionControlTransition as l, type UseFileAttachmentsOptions as m, type UseSlashCommandsOptions as n, type UseSlashCommandsResult as o, type UseTranscriptionOptions as p, type UseTranscriptionResult as q, appendFinalTranscript as r, defaultChatComposerMessages as s, transitionTranscriptionControl as t, useFileAttachments as u, useSlashCommands as v, useTranscription as w, AttachButton as x, Attachments as y, type ChatComposerContextValue as z };

package/dist/composer.d.ts

@@ -0,0 +1,6 @@
+export { A as Actions, x as AttachButton, y as Attachments, z as ChatComposerContextValue, B as ChatComposerController, c as ChatComposerMessages, D as CommandPalette, E as ComposerActionsProps, G as ComposerAttachButtonProps, H as ComposerCommandPaletteProps, C as ComposerControlLinks, J as ComposerControlState, K as ComposerControlsProps, L as ComposerDelivery, M as ComposerDraftState, P as ComposerFooterProps, Q as ComposerFrameProps, R as ComposerHintProps, V as ComposerInputProps, W as ComposerModelPickerProps, X as ComposerPauseButtonProps, Y as ComposerRootProps, Z as ComposerSendButtonProps, _ as ComposerSubmitBlocker, $ as ComposerSubmitMode, a0 as ComposerSurfaceProps, g as ComposerTranscriptionControl, a as ComposerTranscriptionControlProps, h as ComposerTranscriptionMessages, a1 as Confirmation, a2 as Controls, a3 as Footer, a4 as Frame, a5 as Help, a6 as Hint, a7 as Input, a8 as ModelPicker, O as OPEN_WORKSTREAM_CONTROL_EVENT, a9 as PauseButton, aa as PausedState, ab as RestoredResources, ac as Root, ad as SendButton, ae as Status, af as Surface, ag as UseChatComposerControllerOptions, s as defaultChatComposerMessages, ah as useChatComposer, ai as useChatComposerController } from './composer-CVm5uoUI.js';
+import 'react/jsx-runtime';
+import 'react';
+import '@opengeni/sdk';
+import './session-context-rgrfElMl.js';
+import './use-composer-By1wn3MM.js';

package/dist/composer.js

@@ -0,0 +1,56 @@
+import {
+  Actions,
+  AttachButton,
+  Attachments,
+  CommandPalette2 as CommandPalette,
+  ComposerTranscriptionControl,
+  Confirmation,
+  Controls,
+  Footer,
+  Frame,
+  Help,
+  Hint,
+  Input,
+  ModelPicker2 as ModelPicker,
+  OPEN_WORKSTREAM_CONTROL_EVENT,
+  PauseButton,
+  PausedState,
+  RestoredResources,
+  Root,
+  SendButton,
+  Status,
+  Surface,
+  defaultChatComposerMessages,
+  useChatComposer,
+  useChatComposerController
+} from "./chunk-CATATY77.js";
+import "./chunk-TK7G6XLT.js";
+import "./chunk-UQS7OQDE.js";
+import "./chunk-I3BJZIG5.js";
+export {
+  Actions,
+  AttachButton,
+  Attachments,
+  CommandPalette,
+  ComposerTranscriptionControl,
+  Confirmation,
+  Controls,
+  Footer,
+  Frame,
+  Help,
+  Hint,
+  Input,
+  ModelPicker,
+  OPEN_WORKSTREAM_CONTROL_EVENT,
+  PauseButton,
+  PausedState,
+  RestoredResources,
+  Root,
+  SendButton,
+  Status,
+  Surface,
+  defaultChatComposerMessages,
+  useChatComposer,
+  useChatComposerController
+};
+//# sourceMappingURL=composer.js.map

package/dist/composer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}