@opengeni/react 0.28.2 → 0.32.1

package/dist/client.d.ts

@@ -0,0 +1,33 @@
+import type { OpenGeniClient } from "@opengeni/sdk";
+/**
+ * The slice of `OpenGeniClient` the hooks depend on. Structural, so apps can
+ * pass the real SDK client, a proxy-backed client that routes through their
+ * own API, or a scripted client in tests/demos.
+ */
+export type SessionClientLike = Pick<OpenGeniClient, "getClientConfig" | "getSession" | "getSessionLineage" | "updateSession" | "updateSessionPin" | "listSessions" | "listSessionPage" | "sendMessage" | "steerMessage" | "pauseSession" | "resumeSession" | "sendApprovalDecision" | "listHumanInputRequests" | "getHumanInputRequest" | "submitHumanInputResponse" | "listEvents" | "streamEvents" | "getQueue" | "moveQueueItem" | "editQueueItem" | "steerQueueItem" | "deleteQueueItem" | "getComposerDraft" | "saveComposerDraft" | "listTurns" | "getGoal" | "updateGoal" | "deleteGoal" | "clearSessionContext" | "compactSessionContext" | "listScheduledTasks" | "uploadFile" | "getFile" | "createFileDownloadUrl" | "listVariableSets" | "createVariableSet" | "updateVariableSet" | "deleteVariableSet" | "setVariableSetVariable" | "deleteVariableSetVariable" | "listEnvironments" | "createEnvironment" | "updateEnvironment" | "deleteEnvironment" | "setEnvironmentVariable" | "deleteEnvironmentVariable" | "listRigs" | "createRig" | "getRig" | "updateRig" | "deleteRig" | "listRigVersions" | "activateRigVersion" | "listRigChanges" | "proposeRigChange" | "getRigChange" | "verifyRigChange" | "promoteRigChange" | "verifyRig" | "listPacks" | "registerPack" | "enablePack" | "deletePack" | "listWorkspaces" | "createWorkspace" | "updateWorkspace" | "setWorkspaceInferenceState" | "getWorkspace" | "getWorkspaceModelCatalog" | "listWorkspaceControlEvents" | "streamWorkspaceControlEvents" | "getBillingUsage" | "getClientConfig" | "getStreamCapabilities" | "acknowledgeStream" | "attachViewer" | "heartbeatViewer" | "detachViewer" | "fsList" | "fsRead" | "fsWrite" | "fsDelete" | "fsMove" | "fsMkdir" | "gitStatus" | "gitDiff" | "getWorkspaceCapture" | "getWorkspaceCaptureFile" | "terminalExec" | "terminalPtyOpen" | "terminalPtyWrite" | "terminalPtyResize" | "terminalPtyClose">;
+/**
+ * Tenant-safe client surface required by the session-only React entry.
+ *
+ * A host proxy can implement only these session-scoped operations instead of
+ * stubbing OpenGeni's workbench, billing, rig, file-system, and workspace
+ * administration APIs. Workspace-level resume is deliberately optional: a
+ * host that does not expose that authority still supports every session-local
+ * composer/control path.
+ */
+export type EmbeddedSessionClientLike = Pick<OpenGeniClient, "getSession" | "listEvents" | "streamEvents" | "getComposerDraft" | "saveComposerDraft" | "sendMessage" | "steerMessage" | "getQueue" | "moveQueueItem" | "editQueueItem" | "steerQueueItem" | "deleteQueueItem" | "pauseSession" | "resumeSession" | "sendApprovalDecision"> & {
+    setWorkspaceInferenceState?: OpenGeniClient["setWorkspaceInferenceState"] | undefined;
+};
+/** Event-read surface shared by hooks that optionally tail a session. */
+export type EmbeddedSessionEventClientLike = Pick<OpenGeniClient, "getSession" | "streamEvents">;
+/** Exact client surface required by {@link useSession}. */
+export type EmbeddedSessionReadClientLike = EmbeddedSessionEventClientLike & Pick<OpenGeniClient, "getSession" | "updateSession">;
+/** Exact client surface required by {@link useGoal}. */
+export type EmbeddedGoalClientLike = EmbeddedSessionEventClientLike & Pick<OpenGeniClient, "getGoal" | "updateGoal" | "deleteGoal">;
+/** Exact client surface required by {@link useSessionLineage}. */
+export type EmbeddedSessionLineageClientLike = EmbeddedSessionEventClientLike & Pick<OpenGeniClient, "getSessionLineage">;
+/** Exact client surface required by {@link useFileAttachments}. */
+export type EmbeddedFileAttachmentClientLike = Pick<OpenGeniClient, "uploadFile">;
+/** Exact client surface required by structured human-input hooks. */
+export type EmbeddedHumanInputSessionClientLike = EmbeddedSessionEventClientLike & Pick<OpenGeniClient, "listHumanInputRequests" | "submitHumanInputResponse">;
+/** Exact client surface required by MCP approval-policy hooks. */
+export type EmbeddedSessionMcpApprovalPolicyClientLike = EmbeddedSessionEventClientLike & Pick<OpenGeniClient, "updateSessionMcpApprovalPolicy">;

package/dist/commands/index.d.ts

@@ -0,0 +1,3 @@
+export type { CommandContext, CommandResult, Notice, SlashArg, SlashCommand } from "./types";
+export { argHint, defaultCommands, filterCommands, firstMissingRequiredArg, hasPermission, matchCommand, parseCommandLine, } from "./registry";
+export type { ParsedCommandLine } from "./registry";

package/dist/commands/registry.d.ts

@@ -0,0 +1,41 @@
+import type { Permission } from "@opengeni/sdk";
+import type { CommandContext, SlashArg, SlashCommand } from "./types";
+/**
+ * Parse a composer value into a command name + the rest. A command is
+ * recognized ONLY when the value's first character is "/" (the start token);
+ * anything else is plain chat and returns null.
+ *
+ * "/cl"        -> { name: "cl", rest: "", hasTrailingSpace: false }
+ * "/goal "     -> { name: "goal", rest: "", hasTrailingSpace: true }
+ * "/goal pause"-> { name: "goal", rest: "pause", hasTrailingSpace: false }
+ */
+export type ParsedCommandLine = {
+    name: string;
+    rest: string;
+    /** True when the name token is closed by a space — arg-hint mode. */
+    hasTrailingSpace: boolean;
+    args: string[];
+};
+export declare function parseCommandLine(value: string): ParsedCommandLine | null;
+/** Whether the operator's permission set satisfies a command's gate. */
+export declare function hasPermission(required: Permission | undefined, permissions: Permission[]): boolean;
+/** Match a command (by name or alias) against the value. */
+export declare function matchCommand(commands: readonly SlashCommand[], value: string): SlashCommand | null;
+type FilterCtx = Pick<CommandContext, "sessionId" | "status" | "permissions">;
+/**
+ * The commands visible for the current token + context. Permission-absent and
+ * `available()===false` commands are dropped entirely (a gated command is never
+ * shown, not shown-disabled). Filtering is a prefix match on name/alias.
+ */
+export declare function filterCommands(commands: readonly SlashCommand[], token: string, ctx: FilterCtx): SlashCommand[];
+/** Render a command's arg hint for the palette footer / help, e.g. "<pause|resume>". */
+export declare function argHint(args: readonly SlashArg[] | undefined): string;
+/** The first required arg that has not yet been supplied, if any. */
+export declare function firstMissingRequiredArg(command: SlashCommand, args: string[]): SlashArg | null;
+/**
+ * The default command set. Adding a command is one object literal here; the
+ * palette list, filter, arg-hint footer, and /help all render from this array.
+ * Apps concat their own commands via the ChatComposer `commands` prop.
+ */
+export declare const defaultCommands: readonly SlashCommand[];
+export {};

package/dist/commands/types.d.ts

@@ -0,0 +1,85 @@
+import type { Permission, SessionStatus } from "@opengeni/sdk";
+import type { SessionClientLike } from "../client";
+/**
+ * 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. */
+export 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). */
+export type Notice = {
+    tone: "ok" | "error";
+    message: string;
+};
+/** Everything a command handler can reach. Assembled by the composer. */
+export 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>;
+};
+export 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;
+};
+export 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;
+};

package/dist/components/approval-surface.d.ts

@@ -0,0 +1,28 @@
+import { type ReactNode } from "react";
+import type { PendingApproval } from "../approvals";
+export type ApprovalSurfaceMessages = {
+    title: string;
+    description: string;
+    approve: string;
+    reject: string;
+    approving: string;
+    rejecting: string;
+    formatToolName: (name: string) => string;
+};
+export declare const defaultApprovalSurfaceMessages: ApprovalSurfaceMessages;
+export type ApprovalSurfaceProps = {
+    approvals: PendingApproval[];
+    onApprove: (approval: PendingApproval) => void | Promise<void>;
+    onReject: (approval: PendingApproval) => void | Promise<void>;
+    responding?: boolean | undefined;
+    error?: string | Error | null | undefined;
+    messages?: Partial<ApprovalSurfaceMessages> | undefined;
+    renderApproval?: ((approval: PendingApproval) => ReactNode) | undefined;
+    className?: string | undefined;
+};
+/**
+ * Host-neutral approval presentation backed by the native pending-approval
+ * projection and control callbacks. It owns only presentation and duplicate
+ * click fencing; OpenGeni remains the authority for approval state.
+ */
+export declare function ApprovalSurface({ approvals, onApprove, onReject, responding, error, messages: overrides, renderApproval, className, }: ApprovalSurfaceProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/chat-composer.d.ts

@@ -0,0 +1,51 @@
+import type { ClientModel, EffectiveSessionControl } from "@opengeni/sdk";
+import type { ClipboardEvent, ReactNode } from "react";
+import type { SlashCommand } from "../commands/types";
+import type { ComposerState } from "../hooks/use-composer";
+import type { UseFileAttachmentsResult } from "../hooks/use-file-attachments";
+import type { SlashCommandContext } from "../hooks/use-slash-commands";
+import { OPEN_WORKSTREAM_CONTROL_EVENT, type ChatComposerMessages, type ComposerControlLinks } from "./composer";
+import { type ComposerTranscriptionControlProps } from "./composer-transcription-control";
+export { OPEN_WORKSTREAM_CONTROL_EVENT };
+export type ChatComposerProps = {
+    composer: ComposerState;
+    /** Canonical workstream control, separate from lifecycle status. */
+    effectiveControl?: EffectiveSessionControl | null | undefined;
+    /** Waiting prompts already ahead of a normal Send. */
+    queuedAheadCount?: number | undefined;
+    /** Whether broader Workspace Resume is authorized for this viewer. */
+    canControlWorkspace?: boolean | undefined;
+    /** Optional host routes used to navigate from effective Pause blockers. */
+    controlLinks?: ComposerControlLinks | undefined;
+    placeholder?: string | undefined;
+    disabled?: boolean | undefined;
+    autoFocus?: boolean | undefined;
+    /** Replaces the default keyboard hint under the field. */
+    hint?: string | undefined;
+    /** App controls in the footer row, replacing the hint. */
+    controlsStart?: ReactNode | undefined;
+    /** Provider-neutral speech capability. Provider configuration stays in workspace settings. */
+    transcription?: ComposerTranscriptionControlProps | undefined;
+    /** Content rendered above the textarea, inside the field chrome. */
+    header?: ReactNode | undefined;
+    /** Paste hook composed with the attachment paste path. */
+    onPaste?: ((event: ClipboardEvent<HTMLTextAreaElement>) => void) | undefined;
+    /** Opt-in file attachment state, typically from `useFileAttachments`. */
+    attachments?: UseFileAttachmentsResult | undefined;
+    /** Opt-in model picker choices. */
+    models?: ClientModel[] | undefined;
+    selectedModel?: string | undefined;
+    onSelectModel?: ((modelId: string) => void) | undefined;
+    className?: string | undefined;
+    commands?: readonly SlashCommand[] | undefined;
+    commandContext?: SlashCommandContext | undefined;
+    onClearView?: (() => void) | undefined;
+    /** Partial overrides for all composer-owned visible and accessible copy. */
+    messages?: Partial<ChatComposerMessages> | undefined;
+};
+/**
+ * Batteries-included chat composer. This preset is assembled exclusively from
+ * the public controller and compound primitives exported by the composer
+ * subpath, so custom and default layouts share one behavioral implementation.
+ */
+export declare function ChatComposer({ composer, effectiveControl, queuedAheadCount, canControlWorkspace, controlLinks, placeholder, disabled, autoFocus, hint, controlsStart, transcription, header, onPaste, attachments, models, selectedModel, onSelectModel, className, commands, commandContext, onClearView, messages, }: ChatComposerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/code-editor.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from "react";
+/** Language grammar loaders, keyed by the extension class we infer from the path. */
+declare const LANGUAGE_LOADERS: Record<string, () => Promise<unknown>>;
+/** Map a filename to a grammar key (or null for plain text — still fully editable). */
+export declare function languageForPath(path: string): keyof typeof LANGUAGE_LOADERS | null;
+export type CodeEditorProps = {
+    /** Workspace-relative path — drives language inference (and the save target upstream). */
+    path: string;
+    /** The decoded text contents to seed the editor with. */
+    initialContents: string;
+    /** Persist the current buffer. Resolves when the write lands; rejects to surface an error. */
+    onSave: (contents: string) => Promise<unknown>;
+    /** Explicitly overwrite after a visible expected-content conflict. */
+    onOverwrite?: ((contents: string) => Promise<unknown>) | undefined;
+    /** Re-read the selected file after a visible save conflict. */
+    onReload?: (() => void) | undefined;
+    /** Fired once when the buffer FIRST diverges from its baseline (the first real
+     *  keystroke) — the wake-on-edit intent. The host warms the box on this so the
+     *  eventual save lands fast; merely opening the file for reading never fires it. */
+    onEditIntent?: (() => void) | undefined;
+    /** Read-only mode (e.g. a truncated/too-large file shown for reference only). */
+    readOnly?: boolean | undefined;
+    themeType?: "dark" | "light" | undefined;
+    /** Rendered while the (lazy) CodeMirror bundle loads. */
+    loading?: ReactNode | undefined;
+    /** Rendered if `@uiw/react-codemirror` is not installed / fails to import. */
+    fallback?: ReactNode | undefined;
+    className?: string | undefined;
+};
+/**
+ * The EDITABLE single-file pane: CodeMirror 6 with a per-language grammar chosen
+ * from the filename, og-* themed, with dirty tracking and a save path wired to
+ * `Cmd/Ctrl+S` *and* an explicit Save button. The viewer (Pierre `File`) stays
+ * the read-only complement — this is only mounted when the user opts to edit.
+ *
+ * Save semantics: the buffer is "dirty" the moment it diverges from the last
+ * saved baseline; a successful `onSave` clears dirty and re-baselines. A failed
+ * save keeps the buffer dirty (nothing is lost) and surfaces the error inline.
+ * `readOnly` suppresses every mutation path so a truncated/binary file can never
+ * be saved back (which would corrupt it by writing the truncated prefix).
+ */
+export declare function CodeEditor({ path, initialContents, onSave, onOverwrite, onReload, onEditIntent, readOnly, themeType, loading, fallback, className, }: CodeEditorProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/command-palette.d.ts

@@ -0,0 +1,25 @@
+import type { SlashCommand } from "../commands/types";
+export type CommandPaletteProps = {
+    open: boolean;
+    items: SlashCommand[];
+    highlight: number;
+    /** Hover/click selects a row. */
+    onHighlight: (index: number) => void;
+    /** Click runs the row (same path as Enter). */
+    onRun: (index: number) => void;
+    /** Footer arg hint shown in arg-hint mode (e.g. "<pause|resume>"). */
+    argHintText: string;
+    /** id used for aria-activedescendant wiring from the textarea. */
+    listboxId: string;
+    /** Accessible list label. Defaults to "Slash commands". */
+    label?: string | undefined;
+    /** Badge shown for destructive commands. Defaults to "danger". */
+    dangerLabel?: string | undefined;
+};
+/**
+ * The slash-command palette: a popover anchored above the textarea, rendered
+ * entirely from the filtered registry. Dark-first, Linear/Vercel-calm, using
+ * the opengeni#46 design tokens. Full keyboard nav lives in useSlashCommands;
+ * this component is presentational + aria.
+ */
+export declare function CommandPalette({ open, items, highlight, onHighlight, onRun, argHintText, listboxId, label, dangerLabel, }: CommandPaletteProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/composer-transcription-control.d.ts

@@ -0,0 +1,36 @@
+import type { ClientVoiceInputConfig, OpenGeniClient, TranscriptionAdapter, WorkspaceTranscriptionPolicy } from "@opengeni/sdk";
+export type ComposerTranscriptionMessages = {
+    start: string;
+    stop: string;
+    cancel: string;
+    retry: string;
+    requestingPermission: string;
+    recording: string;
+    transcribing: string;
+    unavailableDisabled: string;
+    unavailable: string;
+    errorPermissionDenied: string;
+    errorNotSupported: string;
+    errorUnavailable: string;
+    errorTooLarge: string;
+    errorInvalidAudio: string;
+    errorUnknown: string;
+};
+export type ComposerTranscriptionControlProps = {
+    client?: OpenGeniClient | null | undefined;
+    workspaceId?: string | undefined;
+    capability?: ClientVoiceInputConfig | null | undefined;
+    workspaceEnabled?: boolean | undefined;
+    /** @deprecated Native MediaRecorder input no longer uses host adapters. */
+    adapter?: TranscriptionAdapter | null | undefined;
+    /** @deprecated Native MediaRecorder input no longer uses host policies. */
+    policy?: WorkspaceTranscriptionPolicy | undefined;
+    /** @deprecated Native input uses the server capability duration limit. */
+    lifecycleTimeouts?: unknown;
+    /** @deprecated Native input does not expose provider diagnostics. */
+    onDiagnostic?: unknown;
+    messages?: Partial<ComposerTranscriptionMessages> | undefined;
+    className?: string | undefined;
+};
+/** One provider-neutral microphone control for the nearest editable composer. */
+export declare function ComposerTranscriptionControl({ client, workspaceId, capability, workspaceEnabled, messages: overrides, className, }: ComposerTranscriptionControlProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/composer.d.ts

@@ -0,0 +1,277 @@
+import type { ClientModel, EffectiveSessionControl } from "@opengeni/sdk";
+import { type ButtonHTMLAttributes, type ChangeEvent, type ClipboardEvent, type ComponentPropsWithoutRef, type DragEvent, type KeyboardEvent, type ReactNode, type RefObject } from "react";
+import type { Notice, SlashCommand } from "../commands/types";
+import type { ComposerState } from "../hooks/use-composer";
+import type { UseFileAttachmentsResult } from "../hooks/use-file-attachments";
+import { type ConfirmState, type SlashCommandContext } from "../hooks/use-slash-commands";
+import type { PickerModelRow } from "../model-policy";
+export declare const OPEN_WORKSTREAM_CONTROL_EVENT = "opengeni:open-workstream-control";
+export type ComposerDelivery = Pick<ComposerState, "value" | "setValue" | "send" | "steer" | "sending" | "canSend" | "error" | "clearError">;
+export type ComposerDraftState = Pick<ComposerState, "draftConflict" | "draftSaving" | "resolveDraftConflict" | "restoredResources" | "removeRestoredResource">;
+export type ComposerControlState = Pick<ComposerState, "pause" | "pausing" | "resume" | "resumeScope" | "resuming">;
+export type ComposerControlLinks = {
+    workspaceHref?: string | undefined;
+    sessionHref?: ((sessionId: string) => string) | undefined;
+};
+export 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;
+};
+export declare const defaultChatComposerMessages: ChatComposerMessages;
+export type ComposerSubmitMode = "queue" | "steer";
+export type ComposerSubmitBlocker = "disabled" | "attachment" | "sending" | "command" | "empty" | null;
+export 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.
+ */
+export 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: import("@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: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    paletteMounted: boolean;
+    setPaletteMounted: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    dragging: boolean;
+    handleDragOver: (event: DragEvent<HTMLDivElement>) => void;
+    handleDragLeave: (event: DragEvent<HTMLDivElement>) => void;
+    handleDrop: (event: DragEvent<HTMLDivElement>) => void;
+    palette: import("..").UseSlashCommandsResult;
+    paletteEnabled: boolean;
+    commandDraftBlocked: boolean;
+    confirmState: ConfirmState;
+    settleConfirmation: (confirmed: boolean) => void;
+    helpOpen: boolean;
+    setHelpOpen: import("react").Dispatch<import("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;
+};
+export type ChatComposerController = ReturnType<typeof useChatComposerController>;
+export 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. */
+export declare function useChatComposer(): ChatComposerContextValue;
+export type ComposerRootProps = Omit<ComponentPropsWithoutRef<"div">, "children"> & {
+    controller: ChatComposerController;
+    children: ReactNode;
+};
+export declare const Root: import("react").ForwardRefExoticComponent<Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
+    controller: ChatComposerController;
+    children: ReactNode;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export type ComposerFrameProps = ComponentPropsWithoutRef<"div">;
+export declare const Frame: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export type ComposerCommandPaletteProps = {
+    className?: string | undefined;
+};
+export declare function CommandPalette({ className }: ComposerCommandPaletteProps): import("react/jsx-runtime").JSX.Element | null;
+type OwnedSurfaceProps = "onDragOver" | "onDragLeave" | "onDrop";
+export type ComposerSurfaceProps = Omit<ComponentPropsWithoutRef<"div">, OwnedSurfaceProps>;
+export declare const Surface: import("react").ForwardRefExoticComponent<ComposerSurfaceProps & import("react").RefAttributes<HTMLDivElement>>;
+export declare function PausedState(): import("react/jsx-runtime").JSX.Element | null;
+export declare function RestoredResources(): import("react/jsx-runtime").JSX.Element | null;
+export declare function Attachments(): import("react/jsx-runtime").JSX.Element | null;
+type OwnedInputProps = "value" | "defaultValue" | "onChange" | "onKeyDown" | "onPaste" | "disabled" | "aria-autocomplete" | "aria-controls" | "aria-activedescendant" | "aria-keyshortcuts";
+export type ComposerInputProps = Omit<ComponentPropsWithoutRef<"textarea">, OwnedInputProps>;
+export declare const Input: import("react").ForwardRefExoticComponent<ComposerInputProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+export declare function Confirmation(): import("react/jsx-runtime").JSX.Element | null;
+export type ComposerFooterProps = ComponentPropsWithoutRef<"div">;
+export declare const Footer: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export type ComposerControlsProps = ComponentPropsWithoutRef<"span">;
+export declare const Controls: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+export type ComposerHintProps = ComponentPropsWithoutRef<"span">;
+export declare const Hint: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+export type ComposerActionsProps = ComponentPropsWithoutRef<"span">;
+export declare const Actions: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+type OwnedButtonProps = "type" | "onClick" | "disabled";
+export type ComposerAttachButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, OwnedButtonProps> & {
+    accept?: string | undefined;
+    multiple?: boolean | undefined;
+};
+export declare const AttachButton: import("react").ForwardRefExoticComponent<Omit<ButtonHTMLAttributes<HTMLButtonElement>, OwnedButtonProps> & {
+    accept?: string | undefined;
+    multiple?: boolean | undefined;
+} & import("react").RefAttributes<HTMLButtonElement>>;
+export type ComposerModelPickerProps = {
+    models?: ClientModel[] | undefined;
+    /** Catalog-backed rows preferred over legacy provider-grouped models. */
+    rows?: PickerModelRow[] | undefined;
+    value?: string | undefined;
+    onChange?: ((modelId: string) => void) | undefined;
+    label?: string | undefined;
+    className?: string | undefined;
+    /** Filter to Codex models for remote_v2-locked sessions. */
+    codexOnly?: boolean | undefined;
+};
+export declare function ModelPicker({ models, rows, value, onChange, label, className, codexOnly, }: ComposerModelPickerProps): import("react/jsx-runtime").JSX.Element;
+export type ComposerPauseButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, OwnedButtonProps>;
+export declare const PauseButton: import("react").ForwardRefExoticComponent<ComposerPauseButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export type ComposerSendButtonProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, OwnedButtonProps>;
+export declare const SendButton: import("react").ForwardRefExoticComponent<ComposerSendButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare function Help(): import("react/jsx-runtime").JSX.Element;
+export declare function Status(): import("react/jsx-runtime").JSX.Element;
+export {};