Spaces:
Running
Running
| import type { ReactNode } from 'react'; | |
| import type { Action, ActionRegistry, ActionsLayout } from './core/actions'; | |
| import type { HubArrangement, HubLayout, UIFProfile } from './core/profile'; | |
| import type { SendContext } from './core/context'; | |
| /** chat: the generic input/response mode; terminal: T mode, commands; persona: a host's persona mode (named by the | |
| * `persona` prop, e.g. sAGI for Savante), which sends like chat with `meta.mode` = 'persona'. */ | |
| export type UIFMode = 'chat' | 'terminal' | 'persona'; | |
| export type DockEdge = 'top' | 'bottom' | 'left' | 'right'; | |
| export interface Rect { | |
| x: number; | |
| y: number; | |
| width: number; | |
| height: number; | |
| } | |
| export interface OutputMessage { | |
| id: string; | |
| role: 'user' | 'assistant' | 'system'; | |
| text: string; | |
| pending?: boolean; | |
| /** Never read aloud, even in an output with speak on (an engine marks a reply it does not vouch for). */ | |
| silent?: boolean; | |
| /** A video or image the reply carries (an object URL or a link), shown under its text with a save link. */ | |
| media?: { kind: 'video' | 'image'; url: string; name?: string }; | |
| /** What a system line is: the delivery under an answer (tokens, speed, where it ran, the receipt's verdict), a | |
| * footer the page adds (never the model's words), or a status while the answer is on its way. */ | |
| kind?: 'delivery' | 'footer' | 'status'; | |
| /** ok: delivered, a receipt that matched; bad: no delivery, an error; working: downloading, reading, streaming. */ | |
| tone?: 'ok' | 'bad' | 'working'; | |
| /** The reply was not delivered by the model (no completion tokens, an error, stopped): it says so in place of an | |
| * answer, and the exchange is kept out of .history. */ | |
| undelivered?: boolean; | |
| } | |
| export interface OutputField { | |
| id: string; | |
| title: string; | |
| color: string; | |
| placement: 'inline' | 'popout'; | |
| rect: Rect; | |
| messages: OutputMessage[]; | |
| /** Last reported screen geometry of a popped-out window. */ | |
| screenGeom?: Rect; | |
| /** Replies in this output are read aloud (speech synthesis, the system's audio output). */ | |
| speak?: boolean; | |
| /** Shown on another display through the Presentation API (a second screen, a cast device). */ | |
| presented?: boolean; | |
| /** Filling the whole screen; `rect` is kept, so shrinking back returns it where it was. */ | |
| maximized?: boolean; | |
| } | |
| /** Where a spawned output goes besides this page: its own window, a given monitor, a display, the speakers. */ | |
| export interface SpawnTarget { | |
| window?: boolean; | |
| /** 1-based monitor number (needs screen access: the `screens` command). */ | |
| screen?: number; | |
| present?: boolean; | |
| speak?: boolean; | |
| } | |
| export interface ScreenInfoLine { | |
| index: number; | |
| label: string; | |
| primary: boolean; | |
| current: boolean; | |
| width: number; | |
| height: number; | |
| } | |
| export interface OutputsApi { | |
| list(): OutputField[]; | |
| activeId: string | null; | |
| setActive(id: string): void; | |
| spawn(title?: string, target?: SpawnTarget): string; | |
| close(id: string): void; | |
| /** Close every output (in the page and popped out). */ | |
| closeAll(): void; | |
| /** Empty every output's messages; the windows stay. */ | |
| clearAll(): void; | |
| /** Fill the whole screen with an output, or shrink it back (toggles when `on` is not given). */ | |
| maximize(id: string, on?: boolean): void; | |
| /** Arrange the in-page outputs in a grid that fills the screen. */ | |
| tile(): void; | |
| /** Stack the in-page outputs diagonally, each a step down and right of the last. */ | |
| cascade(): void; | |
| /** Open the output in its own window; with `screen`, on that monitor. Returns a note when something fell back. */ | |
| popOut(id: string, opts?: { screen?: number }): string | void; | |
| /** Show the output on another display or cast device (Presentation API). Resolves with what happened. */ | |
| present(id: string): Promise<string>; | |
| /** Read this output's replies aloud, or stop. Returns what happened. */ | |
| setSpeak(id: string, on: boolean): string; | |
| /** The monitors, once screen access was granted (`screens`); null before. */ | |
| screens(): ScreenInfoLine[] | null; | |
| callHome(id: string | 'all'): void; | |
| ping(id: string): void; | |
| clear(id: string): void; | |
| rename(id: string, title: string): void; | |
| append(id: string, message: Omit<OutputMessage, 'id'>): string; | |
| update(id: string, messageId: string, patch: Partial<OutputMessage>): void; | |
| /** Resolve an id, a 1-based index or a title to an output id. */ | |
| resolve(ref: string | undefined): string | undefined; | |
| } | |
| export type LogKind = 'cmd' | 'out' | 'err'; | |
| /** A section of a terminal report: a heading that opens to its lines (an accordion in the T-mode log). */ | |
| export interface LogSection { | |
| title: string; | |
| lines: string[]; | |
| /** ok, warn or bad: the heading's mark and colour. */ | |
| level?: 'ok' | 'warn' | 'bad'; | |
| open?: boolean; | |
| } | |
| /** Named layouts (`.profile`) and the reset to the standard layout. */ | |
| export interface LayoutApi { | |
| /** Saved profile names, sorted. */ | |
| list(): string[]; | |
| /** The profile last saved or loaded, or 'standard' after a reset. */ | |
| active: string | null; | |
| /** The current layout as a profile, without saving it. */ | |
| capture(name: string): UIFProfile; | |
| save(name: string): UIFProfile; | |
| /** Apply a saved profile; 'standard' resets. Returns false when there is no such profile. */ | |
| load(name: string): boolean; | |
| remove(name: string): boolean; | |
| /** Back to the standard layout. Saved profiles are kept. */ | |
| reset(): void; | |
| /** Download a profile as `<name>.profile` (the current layout when no saved name is given). */ | |
| exportProfile(name?: string): void; | |
| /** Read a `.profile` file's text, save it and apply it. Returns its name; throws when the file is invalid. */ | |
| importProfile(text: string, fileName?: string): string; | |
| } | |
| /** The input field registers this so profiles can read and set its layout. */ | |
| export interface HubLayoutHandle { | |
| get(): HubLayout; | |
| /** Apply a layout; null means the standard (default) layout. */ | |
| set(layout: HubLayout | null): void; | |
| } | |
| export interface ActionContext { | |
| args: string[]; | |
| print(text: string, kind?: LogKind): void; | |
| /** Print a report into the T-mode log: a heading line, then sections that open and close (an accordion). */ | |
| printSections(title: string, sections: LogSection[]): void; | |
| clearLog(): void; | |
| send(text: string): void; | |
| runCommand(line: string): void; | |
| mode: UIFMode; | |
| setMode(mode: UIFMode | 'toggle'): void; | |
| docked: DockEdge | null; | |
| dock(edge: DockEdge | null): void; | |
| strings: boolean; | |
| setStrings(on: boolean | 'toggle'): void; | |
| outputs: OutputsApi; | |
| registry: ActionRegistry; | |
| layout: LayoutApi; | |
| /** Open, close or toggle the context windows (.history, .memory, .prompt, .persona, .model). */ | |
| windows: { isOpen(id: string): boolean; show(id: string): void; hide(id: string): void; toggle(id: string): void }; | |
| /** Add a note to .memory. */ | |
| remember(text: string): Promise<void>; | |
| /** The button row: part of the field, or isolated as its own floating bar; and how the field is arranged. */ | |
| bar: { | |
| isolated: boolean; | |
| isolate(opts?: { vertical?: boolean }): void; | |
| join(): void; | |
| arrangement: HubArrangement; | |
| arrange(a: HubArrangement): void; | |
| /** The mode now showing on the bar (each mode has its own face: the rolodex). */ | |
| face: UIFMode; | |
| /** A mode's face of the bar: its layout (the registry's when it is the face showing), replaced (saved, and shown | |
| * when it is the face showing), or the standard one the field starts with. */ | |
| faces: { | |
| get(mode: UIFMode): ActionsLayout; | |
| set(mode: UIFMode, layout: ActionsLayout): void; | |
| standard(mode: UIFMode): ActionsLayout; | |
| }; | |
| }; | |
| requestScreens(): Promise<void>; | |
| } | |
| export interface SendMeta { | |
| outputId: string; | |
| /** The mode the message was sent in: 'chat' (generic) or 'persona' (the host's persona mode). */ | |
| mode?: UIFMode; | |
| /** | |
| * The context to call a model with: the composed system prompt | |
| * (.prompt or the persona's, plus persona lines and the .memory block), | |
| * ready-made chat `messages` (system, this output's recent exchanges, the | |
| * new message), and the parsed .persona, .memory and .model. | |
| */ | |
| context: SendContext; | |
| /** | |
| * Add fields to this exchange's .history record, e.g. `{ receipt }` from a | |
| * verifying engine (bankML's savante.history keeps one per answer). Later | |
| * calls merge; a field named like a standard one (model, prompt) replaces it. | |
| */ | |
| annotate(fields: Record<string, unknown>): void; | |
| /** | |
| * Change this exchange's reply message while (or after) it streams, e.g. `{ silent: true }` so an output with | |
| * speak on does not read a reply the engine could not verify. Calls before the reply exists are kept for it. | |
| */ | |
| markReply(patch: ReplyMarks): void; | |
| /** Aborted when the visitor presses Stop: an engine can close its request, and a wrapper knows the answer was cut. */ | |
| signal?: AbortSignal; | |
| } | |
| /** What an engine may say about its own reply: not to be read aloud; not delivered, with the text that says so. */ | |
| export type ReplyMarks = Pick<Partial<OutputMessage>, 'silent' | 'undelivered' | 'text'>; | |
| export type SendResult = void | string | Promise<string | void> | AsyncIterable<string>; | |
| export interface UltimateInputFieldProps extends UIFProviderOptions { | |
| /** Controlled value. Omit to let the field manage its own text. */ | |
| value?: string; | |
| onChange?: (value: string) => void; | |
| /** | |
| * Called in chat mode. A returned string, promise or async iterable is | |
| * written (or streamed) into the active output field. | |
| */ | |
| onSend?: (text: string, meta: SendMeta) => SendResult; | |
| /** Called for terminal commands that match no action. A returned string is printed. */ | |
| onCommand?: (name: string, args: string[], ctx: ActionContext) => string | void; | |
| /** Called after any action runs, from a button or a command. */ | |
| onAction?: (action: Action, args: string[]) => void; | |
| /** The buttons each mode's bar starts with (ids, in order) until the visitor arranges it; MODE_BAR otherwise. A host | |
| * puts its own button set here (a persona's carriers and rooms) beside the generic ones. */ | |
| modeBar?: Partial<Record<UIFMode, readonly string[]>>; | |
| /** A third mode beside chat and T: the host's persona (e.g. `{ label: 'sAGI' }` for Savante). A button beside T | |
| * switches to it, as does typing its label alone; `>` goes back to the generic mode. */ | |
| persona?: { label: string; placeholder?: string; title?: string }; | |
| onModeChange?: (mode: UIFMode) => void; | |
| /** Extra actions to register alongside the built-ins. */ | |
| actions?: Action[]; | |
| isLoading?: boolean; | |
| className?: string; | |
| placeholder?: string; | |
| /** The placeholder in T (terminal) mode; `placeholder` is the ask (chat) mode's. */ | |
| terminalPlaceholder?: string; | |
| disabled?: boolean; | |
| /** Initial mode. `'text'` is accepted as an alias for `'chat'`. */ | |
| mode?: UIFMode | 'text'; | |
| initialPosition?: { x: number; y: number }; | |
| initialSize?: { width: number; height: number }; | |
| minWidth?: number; | |
| maxWidth?: number; | |
| minHeight?: number; | |
| maxHeight?: number; | |
| draggable?: boolean; | |
| resizable?: boolean; | |
| dockable?: boolean; | |
| glowEffect?: boolean; | |
| glassEffect?: boolean; | |
| /** A 🎤 button where the browser has speech recognition (off until pressed; the browser's own engine hears it, | |
| * nothing is recorded or sent by the page). Default true; false hides it. */ | |
| voice?: boolean; | |
| /** The field grows with its text (up to 45% of the screen) and shrinks back when it is sent. Default true. */ | |
| autoGrow?: boolean; | |
| /** Keys that focus the input from anywhere on the page: "/" (outside a text field) and Ctrl/⌘+K. Default true. */ | |
| focusKeys?: boolean; | |
| /** Modules rendered on either side of the field (see UltimateBar). */ | |
| left?: ReactNode; | |
| right?: ReactNode; | |
| } | |
| export interface UIFProviderOptions { | |
| /** Modules that add windows and actions (the context module is always there). Read once. */ | |
| modules?: import('./core/modules').UIFModule[]; | |
| /** Namespaces localStorage keys and the BroadcastChannel. */ | |
| storageKey?: string; | |
| /** URL the pop-out windows load. Defaults to the current page. */ | |
| popoutUrl?: string; | |
| /** Whether tethers and beacons start visible. */ | |
| defaultStrings?: boolean; | |
| /** Where the page's own top matter ends (px from the viewport's top, read when a response window opens): with no | |
| * room beside the field, a response window opens between this and the field, as wide as the field, instead of | |
| * over the page's header. */ | |
| outputTop?: () => number; | |
| /** The part of the viewport's width response windows open in (px from the left, read when one opens): a page with | |
| * sidebars keeps them clear of its panels. Default: the whole width. */ | |
| outputArea?: () => { left: number; right: number }; | |
| } | |