@meshmakers/shared-ui 3.4.1480 → 3.5.0

package/types/meshmakers-shared-ui-assistant-core.d.ts

@@ -0,0 +1,732 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Type, Signal } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as _meshmakers_shared_ui_assistant_core from '@meshmakers/shared-ui/assistant-core';
+import { ActivatedRouteSnapshot } from '@angular/router';
+
+/**
+ * The single feature flag of the assistant (ui-concept §5.3, AB#5549).
+ * **Off by default.** While it is off nothing assistant-related renders or binds:
+ * no top-bar ✦ button, no Cmd/Ctrl+J, no "✦ Explain" affordances, and the command
+ * palette's `?` scope only shows "Assistant not available".
+ *
+ * Enable it for a host with `{ provide: ASSISTANT_ENABLED, useValue: true }`. The host gates its
+ * own affordances (top-bar toggle, Cmd/Ctrl+J, palette row) on `AssistantService.enabled`.
+ * Turning it on without a real {@link ASSISTANT_TRANSPORT} shows the panel with an
+ * honest "Assistant backend not available yet" state — never canned answers.
+ */
+declare const ASSISTANT_ENABLED: InjectionToken<boolean>;
+/** Connection state of the transport; only `ready` lets the composer send. */
+type AssistantTransportStatus = 'unavailable' | 'ready' | 'busy' | 'error';
+/** Kinds of context the panel sends as structured data (ids, not DOM). */
+type AssistantContextKind = 'tenant' | 'page' | 'entity';
+/** One removable chip of the context row. */
+interface AssistantContextChip {
+    /** Stable per value (`<kind>:<value>`) so a removed chip stays removed until the value changes. */
+    id: string;
+    kind: AssistantContextKind;
+    /** Visible text, e.g. "Integration › Adapters". */
+    label: string;
+    /** Structured value sent to the backend: tenant id, router URL, or entity id. */
+    value: string;
+    /** Optional CK type of an entity chip. */
+    ckTypeId?: string;
+}
+/** What an "✦ Explain" entry point asks about. */
+interface AssistantExplainTarget {
+    /** Human readable name of the object, e.g. "edge-plc-07" or "System.Communication/Adapter". */
+    label: string;
+    /** Runtime id of the object, when it is an entity. */
+    rtId?: string;
+    /** CK type id of the object (or the type itself for "explain this type"). */
+    ckTypeId?: string;
+    /** Overrides the composer prefill; defaults to `/explain <label>`. */
+    prompt?: string;
+}
+/** A request to open the panel. */
+interface AssistantOpenRequest {
+    /** Prefills the composer (never sent automatically). */
+    prompt?: string;
+    /** Adds (or replaces) the entity chip, e.g. from an Explain entry point. */
+    entity?: AssistantExplainTarget;
+}
+/** A write the assistant wants to perform; rendered as a proposal card. */
+interface AssistantProposal {
+    id: string;
+    title: string;
+    /** Markdown-free one-liner explaining the effect. */
+    description?: string;
+    /** MCP tool that would run on confirmation, e.g. `deploy_adapter`. */
+    toolName: string;
+    /** Parameter table shown on the card. */
+    parameters: {
+        name: string;
+        value: string;
+    }[];
+    /** True when the proposal writes to the tenant (the card says so). */
+    writes: boolean;
+}
+/**
+ * A tool call the assistant made, shown as a row of the thread. Structurally compatible with
+ * `AiToolCallDto` of `@meshmakers/octo-ai-console`, so its events can be passed on unchanged.
+ */
+interface AssistantToolCall {
+    readonly callId: string;
+    readonly toolName: string;
+    /** E.g. 'Pending' | 'Approved' | 'Rejected' | 'Succeeded' | 'Failed'. */
+    readonly status: string;
+    readonly sessionId?: string;
+    readonly arguments?: unknown;
+    readonly result?: unknown;
+    readonly startedAt?: string;
+    readonly completedAt?: string | null;
+    readonly durationMs?: number | null;
+}
+/**
+ * The component that renders one tool call in the thread. It must have a `call` input taking an
+ * {@link AssistantToolCall}. Default: a compact name + status row. An OctoMesh host passes
+ * `AiToolCallComponent` of `@meshmakers/octo-ai-console` (collapsible details):
+ * `{ provide: ASSISTANT_TOOL_CALL_COMPONENT, useValue: AiToolCallComponent }`.
+ */
+declare const ASSISTANT_TOOL_CALL_COMPONENT: InjectionToken<Type<unknown>>;
+/**
+ * Labels of the active area and tab of the shell, used for the "Page: Area › Tab" context chip.
+ * Optional; without it the page chip falls back to the first breadcrumb. With
+ * `@meshmakers/shared-ui/shell`:
+ *
+ * ```ts
+ * { provide: ASSISTANT_PAGE_CONTEXT, useFactory: () => {
+ *     const nav = inject(ShellNavigationService);
+ *     return { areaText: () => nav.activeArea()?.text ?? null, tabText: () => nav.activeTab()?.text ?? null };
+ * } }
+ * ```
+ *
+ * Read inside a computed, so signal-backed functions keep the chips up to date.
+ */
+interface AssistantPageContext {
+    areaText(): string | null;
+    tabText(): string | null;
+}
+declare const ASSISTANT_PAGE_CONTEXT: InjectionToken<AssistantPageContext>;
+/** One rendered item of the thread. */
+type AssistantThreadItem = {
+    kind: 'user';
+    id: string;
+    /** What was sent — for a slash command with `expand`, the expanded prompt. */
+    text: string;
+    attachments?: readonly AssistantAttachmentRef[];
+    /**
+     * The slash command as typed (e.g. `/open March`) when {@link text} is its expansion (AB#5621).
+     * The thread shows it as a subtle label above the prompt. A transport may store it and return it
+     * from `loadSession` so reopened chats show the label too; without it they show the prompt only.
+     */
+    slashCommand?: string;
+} | {
+    kind: 'assistant';
+    id: string;
+    markdown: string;
+    streaming: boolean;
+} | {
+    kind: 'tool-call';
+    id: string;
+    call: AssistantToolCall;
+} | {
+    kind: 'proposal';
+    id: string;
+    proposal: AssistantProposal;
+    decision: AssistantProposalDecisionKind | null;
+} | {
+    kind: 'error';
+    id: string;
+    text: string;
+};
+type AssistantProposalDecisionKind = 'run' | 'edit' | 'discard';
+/**
+ * A decision on a proposal card. The card only emits it; whatever executes the
+ * write (the backend's confirm round-trip, AB#5550) subscribes to
+ * `AssistantService.proposalDecisions$`. Nothing in this library executes a proposal.
+ */
+interface AssistantProposalDecision {
+    kind: AssistantProposalDecisionKind;
+    proposal: AssistantProposal;
+}
+/** What the composer hands to the transport. */
+interface AssistantSendRequest {
+    /** The typed text; may be empty when the turn only carries {@link files}. */
+    text: string;
+    /** The chips that remained after the user removed what they did not want to share. */
+    context: AssistantContextChip[];
+    /**
+     * Files attached in the composer. Only set when the transport declares
+     * {@link AssistantTransport.attachments} and the person attached at least one file
+     * (already checked against `accept`, `maxFiles` and `maxFileSizeBytes`).
+     */
+    files?: File[];
+    /**
+     * The slash command as typed (e.g. `/open March`) when {@link text} is the prompt its
+     * {@link AssistantSlashCommand.expand} produced (AB#5621). `text` is always what the model should
+     * read; store `text` as the turn so a reopened chat matches the live thread, and optionally keep
+     * this alongside it (returned as `slashCommand` on the restored user item) for the label.
+     */
+    slashCommand?: string;
+}
+/** Name (and size) of a file sent with a user turn, shown under the turn in the thread. */
+interface AssistantAttachmentRef {
+    name: string;
+    /** Bytes, when known. */
+    size?: number;
+}
+/**
+ * File attachments a transport accepts (AB#5621). Declaring {@link AssistantTransport.attachments}
+ * shows an "Attach file" button in the composer; without it there is no attachment UI.
+ */
+interface AssistantAttachmentOptions {
+    /**
+     * Accepted types, in the syntax of `<input type="file" accept>`: comma separated MIME types
+     * (`application/pdf`, `image/*`) and/or extensions (`.pdf`). Empty or omitted = any type.
+     */
+    accept?: string;
+    /** How many files one turn may carry (default 1). */
+    maxFiles?: number;
+    /** Largest accepted file in bytes; omitted = no limit in the UI. */
+    maxFileSizeBytes?: number;
+}
+/** A saved conversation of the person, as listed by {@link AssistantTransport.sessions}. */
+interface AssistantSessionSummary {
+    id: string;
+    title: string;
+    /** ISO 8601 timestamp; shown as a secondary line when present. */
+    createdAt?: string;
+}
+/** Starter questions as a transport can provide them: synchronously, as a promise or as an observable (first value counts). */
+type AssistantStarterQuestions = readonly string[] | Promise<readonly string[]> | Observable<readonly string[]>;
+/** A result a session method may return: a promise or an observable (its last value counts). */
+type AssistantAsyncResult<T> = Promise<T> | Observable<T>;
+/** Events a transport streams back for one send. */
+type AssistantStreamEvent = {
+    type: 'message-delta';
+    messageId: string;
+    text: string;
+} | {
+    type: 'message-end';
+    messageId: string;
+} | {
+    type: 'tool-call';
+    call: AssistantToolCall;
+} | {
+    type: 'proposal';
+    proposal: AssistantProposal;
+} | {
+    type: 'error';
+    message: string;
+};
+/**
+ * Where assistant turns come from. The library ships **no** implementation that
+ * answers: the default is {@link NotConnectedAssistantTransport}. A real one
+ * (e.g. the OctoMesh AI services, AB#5550 delegated-identity chat sessions) provides
+ * itself under {@link ASSISTANT_TRANSPORT}.
+ */
+interface AssistantTransport {
+    readonly status: Signal<AssistantTransportStatus>;
+    /** Shown in the panel when the status is not `ready`. */
+    readonly statusMessage: Signal<string | null>;
+    /** One user turn; completes when the assistant turn is complete. */
+    send(request: AssistantSendRequest): Observable<AssistantStreamEvent>;
+    /**
+     * Accepted file attachments. When set, the composer gets an "Attach file" button and
+     * {@link AssistantSendRequest.files} carries the files; a turn may then have empty text.
+     */
+    readonly attachments?: AssistantAttachmentOptions | null;
+    /**
+     * Example questions for an empty thread, in the UI language. Read each time the panel opens;
+     * clicking one sends it as if it had been typed. An observable need not complete: its first
+     * emitted value is taken (later emissions are ignored until the next opening).
+     */
+    starterQuestions?(): AssistantStarterQuestions;
+    /**
+     * Saved sessions of the signed-in person, newest first. Together with {@link loadSession} it
+     * enables the panel's chat list ("Chats" and "New chat" in the header).
+     */
+    readonly sessions?: Signal<readonly AssistantSessionSummary[]>;
+    /** The session the next send writes to; `null` = a fresh chat. Marks the current row in the list. */
+    readonly activeSessionId?: Signal<string | null>;
+    /** Reloads {@link sessions}; called when the chat list is opened. */
+    refreshSessions?(): AssistantAsyncResult<void>;
+    /** Makes a saved session active and returns its thread. */
+    loadSession?(id: string): AssistantAsyncResult<AssistantThreadItem[]>;
+    /** Deletes a saved session. Without it the chat list has no delete buttons. */
+    deleteSession?(id: string): AssistantAsyncResult<void>;
+    /** Starts a fresh chat: the next send creates a new session. */
+    newSession?(): void;
+}
+/** The assistant's transport; defaults to the honest "not connected" one. */
+declare const ASSISTANT_TRANSPORT: InjectionToken<AssistantTransport>;
+/** A composer slash command (ui-concept §5.3). */
+interface AssistantSlashCommand {
+    /** The command word with its slash, lower-case, e.g. `/explain`. */
+    command: string;
+    description: string;
+    /**
+     * Turns the typed command into the prompt that is sent (AB#5621). Called by
+     * `AssistantService.send` when the text is `<command>` or `<command> <args>`: `command` is this
+     * command's word, `args` the trimmed rest (`''` when none). The returned text — synchronously or
+     * as a promise — is what goes to the transport **and** what the live thread shows (with the typed
+     * command as a small label), so a chat reopened from the transport reads the same.
+     *
+     * If it throws, rejects or returns an empty text, nothing is sent: an error row is added and the
+     * draft is restored. Without `expand` the typed text is sent unchanged (default behaviour).
+     *
+     * ```ts
+     * { command: '/open', description: 'Open items',
+     *   expand: (_command, args) => args ? `Which items are open for ${args}?` : 'Which items are open?' }
+     * ```
+     */
+    expand?: (command: string, args: string) => string | Promise<string>;
+}
+/** The default slash commands (English descriptions). */
+declare const DEFAULT_ASSISTANT_SLASH_COMMANDS: readonly AssistantSlashCommand[];
+/** The composer's slash commands; provide your own list (or translated descriptions) to change them. */
+declare const ASSISTANT_SLASH_COMMANDS: InjectionToken<readonly AssistantSlashCommand[]>;
+/**
+ * Layout of `mm-assistant-panel` (AB#5621); every member is optional and the panel's inputs of the
+ * same name win. Defaults keep the original look: a docked panel 400 px wide (340 px ≤ 1180 px)
+ * that pushes the content, without a resize handle (opt in with `resizable: true`).
+ */
+interface AssistantPanelOptions {
+    /**
+     * `docked` (default): the panel takes its own column and pushes the content.
+     * `overlay`: it floats over the content at the right edge (`position: fixed`), from
+     * `--mm-assistant-overlay-top` (default 48 px, the shell's top bar) to the bottom.
+     */
+    mode?: AssistantPanelMode;
+    /**
+     * Shows the drag handle on the left edge (default `false`: no handle, no extra tab stop; never on
+     * phones). Only with it on does a persisted width apply.
+     */
+    resizable?: boolean;
+    /** Smallest width in px the handle allows (default {@link DEFAULT_ASSISTANT_PANEL_MIN_WIDTH}). */
+    minWidth?: number;
+    /**
+     * Largest width in px the handle allows (default {@link DEFAULT_ASSISTANT_PANEL_MAX_WIDTH});
+     * further capped so at least 240 px of the window stay free.
+     */
+    maxWidth?: number;
+    /**
+     * `localStorage` key of the width the person chose (default
+     * {@link DEFAULT_ASSISTANT_PANEL_STORAGE_KEY}); `null` = do not persist. Storage that is missing or
+     * throws (private mode, blocked site data) is ignored — the width then lasts as long as the panel.
+     */
+    storageKey?: string | null;
+}
+type AssistantPanelMode = 'docked' | 'overlay';
+declare const DEFAULT_ASSISTANT_PANEL_MIN_WIDTH = 320;
+declare const DEFAULT_ASSISTANT_PANEL_MAX_WIDTH = 720;
+declare const DEFAULT_ASSISTANT_PANEL_STORAGE_KEY = "mm-assistant-panel-width";
+/** App-wide {@link AssistantPanelOptions}; optional. */
+declare const ASSISTANT_PANEL_OPTIONS: InjectionToken<AssistantPanelOptions>;
+
+/**
+ * UI strings of the assistant (`mm-assistant-panel`, composer, thread, proposal card), the
+ * context chips and the default "not connected" transport.
+ *
+ * Provide translations app wide with {@link ASSISTANT_MESSAGES} or per component with the
+ * `messages` input (wins over the token). Missing, `undefined` or `null` members keep the English
+ * default of {@link DEFAULT_ASSISTANT_MESSAGES}; `{name}` placeholders are filled with
+ * {@link formatAssistantMessage}. Slash command descriptions come from `ASSISTANT_SLASH_COMMANDS`.
+ */
+interface AssistantMessages {
+    title: string;
+    /** Chip in the header while a backend is connected. */
+    readsWithYourPermissions: string;
+    closeAssistant: string;
+    /** `aria-label` of the context chip list. */
+    contextLabel: string;
+    /** `aria-label` of a chip's remove button; `{label}` = chip label. */
+    removeContext: string;
+    /** Fallback when the transport gives no status message. */
+    notAvailable: string;
+    /** Status message of the default transport (no backend). */
+    notConnected: string;
+    commandsLabel: string;
+    composerLabel: string;
+    composerPlaceholder: string;
+    send: string;
+    stop: string;
+    /** Greeting of an empty chat, next to the waving OctoBot (AB#3444). */
+    greeting: string;
+    /** Shown next to the thinking OctoBot while a reply streams (AB#3444). */
+    thinking: string;
+    conversationLabel: string;
+    /** Screen-reader prefix of user turns. */
+    youPrefix: string;
+    /** Screen-reader prefix of assistant turns. */
+    assistantPrefix: string;
+    /** Screen-reader prefix of error rows. */
+    errorPrefix: string;
+    /** Screen-reader prefix of the typed slash command shown above its expanded prompt. */
+    slashCommandPrefix: string;
+    /** Error row when a slash command's `expand` fails; `{command}` = command word. */
+    slashCommandFailed: string;
+    /** `aria-label` of a proposal card; `{title}` = proposal title. */
+    proposalLabel: string;
+    proposal: string;
+    /** Card header addition for writing proposals (after "Proposal ·"). */
+    writesToTenant: string;
+    tool: string;
+    runsAfterConfirm: string;
+    run: string;
+    edit: string;
+    discard: string;
+    runRequested: string;
+    editRequested: string;
+    discarded: string;
+    /** `{tenant}` = tenant id. */
+    contextTenant: string;
+    /** `{page}` = page label. */
+    contextPage: string;
+    /** Header icon button that opens the list of saved chats (tooltip + `aria-label`). */
+    sessions: string;
+    /** Header icon button that starts a fresh chat (tooltip + `aria-label`). */
+    newChat: string;
+    /** `aria-label` of the saved chats list. */
+    sessionsLabel: string;
+    /** Shown when there are no saved chats. */
+    noSessions: string;
+    /** Leaves the chat list without opening a chat. */
+    backToChat: string;
+    /** `aria-label` of a chat's delete button; `{title}` = chat title. */
+    deleteSession: string;
+    /** Inline confirmation; `{title}` = chat title. */
+    deleteSessionConfirm: string;
+    /** Confirms the deletion. */
+    delete: string;
+    cancel: string;
+    /** Error row when a saved chat cannot be opened. */
+    sessionLoadFailed: string;
+    /** Error row when a saved chat cannot be deleted. */
+    sessionDeleteFailed: string;
+    /** `aria-label` / tooltip of the attach button. */
+    attachFile: string;
+    /** `aria-label` of the attached files list. */
+    attachmentsLabel: string;
+    /** `aria-label` of an attachment's remove button; `{name}` = file name. */
+    removeAttachment: string;
+    /** `{name}` = file name. */
+    attachmentWrongType: string;
+    /** `{name}` = file name, `{max}` = size limit (e.g. "10 MB"). */
+    attachmentTooLarge: string;
+    /** `{max}` = most files per message. */
+    attachmentTooMany: string;
+    /** Heading above the starter questions of an empty chat. */
+    startersTitle: string;
+    /** `aria-label` / tooltip of the panel's resize handle. */
+    resizePanel: string;
+}
+declare const DEFAULT_ASSISTANT_MESSAGES: AssistantMessages;
+/** App-wide translations of the assistant (partial). */
+declare const ASSISTANT_MESSAGES: InjectionToken<Partial<AssistantMessages>>;
+/** Merges overrides over {@link DEFAULT_ASSISTANT_MESSAGES}, later sources winning; null/undefined members are ignored. */
+declare function resolveAssistantMessages(...overrides: (Partial<AssistantMessages> | null | undefined)[]): AssistantMessages;
+/** Replaces `{name}` placeholders; unknown placeholders stay as they are. */
+declare function formatAssistantMessage(message: string, values: Record<string, string | number>): string;
+/** The settled label of a proposal decision. */
+declare function proposalDecisionLabel(kind: AssistantProposalDecisionKind, messages: AssistantMessages): string;
+/**
+ * {@link ASSISTANT_MESSAGES} merged with a component input (the input wins).
+ * Call it in an injection context.
+ * @internal
+ */
+declare function assistantMessages(input: Signal<Partial<AssistantMessages> | null | undefined>): Signal<AssistantMessages>;
+
+/**
+ * State and entry points of the assistant panel (ui-concept §5.3, AB#5549).
+ *
+ * - **Flag.** Everything is gated by {@link ASSISTANT_ENABLED} (off by default):
+ *   while it is off every entry point is a no-op that returns `false`, and the
+ *   service does not even listen to the router.
+ * - **Entry points.** {@link open} (top-bar ✦, Cmd/Ctrl+J, palette `?` scope),
+ *   {@link requestExplain} ("✦ Explain <object>", AB#5545/5547), {@link toggle}.
+ *   They open the panel with a prefilled composer and context; they never send.
+ * - **Thread.** Survives closing the panel and navigating. Items only come from the
+ *   {@link ASSISTANT_TRANSPORT}; the default transport is not connected, so the
+ *   library itself never adds an assistant turn.
+ * - **Context.** Tenant (route param `tenantId`), page (`ASSISTANT_PAGE_CONTEXT`, else the first
+ *   breadcrumb of shared-services' `BreadCrumbService`) and entity chips; see {@link deriveAssistantContext}.
+ * - **Proposals.** Run / Edit / Discard are published on {@link proposalDecisions$}
+ *   and nothing else — executing a write is the backend's confirm round-trip (AB#5550).
+ * - **Optional transport capabilities (AB#5621).** Sessions ({@link sessionsSupported},
+ *   {@link openSession}, {@link deleteSession}, {@link newThread}), file attachments
+ *   ({@link attachments}, {@link draftFiles}) and starter questions ({@link starterQuestions}) are
+ *   only offered when the transport implements them; otherwise they are inert.
+ * - **Slash commands (AB#5621).** A command of `ASSISTANT_SLASH_COMMANDS` with `expand` is sent as
+ *   the prompt it returns; see {@link send}.
+ */
+declare class AssistantService {
+    /** The feature flag. Read it to gate any assistant affordance. */
+    readonly enabled: boolean;
+    private readonly transport;
+    private readonly router;
+    private readonly destroyRef;
+    /** Only resolved while enabled: a disabled assistant binds nothing. */
+    private readonly pageContext;
+    private readonly messages;
+    private readonly slashCommands;
+    private readonly _isOpen;
+    private readonly _draft;
+    private readonly _focusRequest;
+    private readonly _explicitEntity;
+    private readonly _removedChips;
+    private readonly _thread;
+    private readonly _sending;
+    private readonly _draftFiles;
+    private readonly _starterQuestions;
+    private starterRequest;
+    /** Bumped by every thread switch (open session, new chat, loadThread); stale session loads are dropped. */
+    private threadGeneration;
+    private readonly _routeTick;
+    private readonly _breadcrumbs;
+    private readonly decisions;
+    private returnFocusTo;
+    private pending;
+    private itemCounter;
+    /** Bumped by {@link stop}: an async slash-command expansion that resolves later is dropped. */
+    private expansionGeneration;
+    /** Whether the panel is shown. */
+    readonly isOpen: Signal<boolean>;
+    /** Composer text; prefilled by entry points. */
+    readonly draft: Signal<string>;
+    /** Bumped whenever an entry point wants the composer focused. */
+    readonly focusRequest: Signal<number>;
+    /** The rendered thread. */
+    readonly thread: Signal<AssistantThreadItem[]>;
+    /** A turn is streaming. */
+    readonly sending: Signal<boolean>;
+    readonly transportStatus: Signal<_meshmakers_shared_ui_assistant_core.AssistantTransportStatus>;
+    readonly transportMessage: Signal<string | null>;
+    /** The composer may send: the transport is ready and no turn is running. */
+    readonly canSend: Signal<boolean>;
+    /** The transport has saved sessions (`sessions` + `loadSession`): the panel shows its chat list. */
+    readonly sessionsSupported: boolean;
+    /** Saved sessions can be deleted (`deleteSession`). */
+    readonly sessionDeleteSupported: boolean;
+    /** Saved sessions of the transport (empty without session support). */
+    readonly sessions: Signal<readonly AssistantSessionSummary[]>;
+    /** The session the next send writes to (`null` = fresh chat or no session support). */
+    readonly activeSessionId: Signal<string | null>;
+    /** Accepted attachments, or `null` when the transport takes no files (no attach UI). */
+    readonly attachments: AssistantAttachmentOptions | null;
+    /** Files attached in the composer; sent and cleared with the next turn. */
+    readonly draftFiles: Signal<readonly File[]>;
+    /** Starter questions for an empty thread (see {@link loadStarterQuestions}). */
+    readonly starterQuestions: Signal<readonly string[]>;
+    /** Context of the current page minus the chips the person removed. */
+    readonly contextChips: Signal<AssistantContextChip[]>;
+    /** Run / Edit / Discard on proposal cards. Only emitted, never executed here. */
+    readonly proposalDecisions$: Observable<AssistantProposalDecision>;
+    constructor();
+    /** Opens the panel (or re-focuses it) with an optional prefill. Returns false while disabled. */
+    open(request?: AssistantOpenRequest): boolean;
+    /** "✦ Explain <object>": opens the panel with `/explain <label>` and the object as context chip. */
+    requestExplain(target: AssistantExplainTarget): boolean;
+    /** Hides the panel and gives focus back to where it was (the ✦ button if that is gone). */
+    close(): void;
+    /**
+     * Forgets an open panel without moving focus — the host calls it when the
+     * panel can no longer be shown (tenant left or denied, connection lost), so it
+     * does not pop up again later with a stale return-focus target.
+     */
+    dismiss(): void;
+    /** Opens when closed, closes when open. Returns false while disabled. */
+    toggle(): boolean;
+    setDraft(text: string): void;
+    /** Replaces the attached files (ignored while the transport takes no files). */
+    setDraftFiles(files: readonly File[]): void;
+    /**
+     * Asks the transport for its starter questions (the panel calls it when it opens).
+     * No-op without `starterQuestions`; a failing source leaves the list empty. Of an observable
+     * only the first emitted value counts (it need not complete); one that completes empty yields none.
+     */
+    loadStarterQuestions(): void;
+    /** Reloads the transport's session list. Resolves false without session support or on failure. */
+    refreshSessions(): Promise<boolean>;
+    /**
+     * Opens a saved session: stops a running turn, asks the transport for the session's thread and
+     * shows it. On failure the current thread stays and an error row is added. Resolves whether the
+     * session was opened.
+     */
+    openSession(id: string): Promise<boolean>;
+    /**
+     * Deletes a saved session; deleting the active one leaves an empty thread. On failure an error
+     * row is added. Resolves whether it was deleted.
+     */
+    deleteSession(id: string): Promise<boolean>;
+    /**
+     * Starts a fresh chat: stops a running turn, empties the thread and the attached files and tells
+     * the transport (`newSession`, when it has one). Works without session support too.
+     */
+    newThread(): void;
+    /** Replaces the thread, e.g. with a conversation the host restored itself. Stops a running turn. */
+    loadThread(items: readonly AssistantThreadItem[]): void;
+    /** Drops a context chip; it stays dropped until its value changes. */
+    removeChip(id: string): void;
+    /**
+     * Sends one user turn through the transport. Does nothing (returns false) unless
+     * the transport is `ready` — the default transport never is.
+     *
+     * With a transport that takes attachments, `files` (default: {@link draftFiles}) go along and
+     * the text may be empty; the attached files are cleared with the draft. Explicitly passed `files`
+     * are not checked again against {@link attachments} (`accept`, `maxFiles`, `maxFileSizeBytes`) —
+     * the composer validates on pick; a host passing files itself is responsible for them.
+     *
+     * **Slash commands (AB#5621).** When the text is `<command> [args]` and that command of
+     * `ASSISTANT_SLASH_COMMANDS` has `expand`, its result is sent instead and shown as the user turn,
+     * with the typed text as `slashCommand` (label in the thread, also on the send request). A
+     * promise-returning `expand` makes the turn start once it resolves (the composer is busy and Stop
+     * cancels meanwhile); returns true when the expansion started. If `expand` throws, rejects or yields
+     * an empty prompt, nothing is sent: an error row is added and the draft (text and files) comes back.
+     */
+    send(text: string, files?: readonly File[]): boolean;
+    /** Stops the running turn (the composer's stop button), including a pending slash-command expansion. */
+    stop(): void;
+    /**
+     * Records a decision on a proposal card and publishes it on
+     * {@link proposalDecisions$}. Run and Discard settle the card; Edit leaves it open.
+     * Nothing is executed here.
+     */
+    decideProposal(kind: AssistantProposalDecisionKind, proposal: AssistantProposal): void;
+    /** Appends the user turn and streams the transport's answer. */
+    private startTurn;
+    private apply;
+    private finishTurn;
+    private endMessage;
+    private append;
+    private nextId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssistantService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AssistantService>;
+}
+/**
+ * Cmd+J (macOS) / Ctrl+J toggles the assistant panel (ui-concept §4.3), also
+ * from text fields — it types nothing. Events another handler consumed and
+ * IME composition are ignored.
+ */
+declare function assistantHotkey(event: KeyboardEvent): boolean;
+
+/** The (English) text the panel shows while no backend exists. */
+declare const ASSISTANT_NOT_CONNECTED_MESSAGE: string;
+/**
+ * The default {@link AssistantTransport}: it is never `ready`, so the composer
+ * cannot send, and it never produces an answer. It exists so the panel can say
+ * honestly that there is no assistant backend (AB#5550) instead of faking one.
+ * The message follows `ASSISTANT_MESSAGES.notConnected`.
+ */
+declare class NotConnectedAssistantTransport implements AssistantTransport {
+    private readonly message;
+    readonly status: i0.Signal<"unavailable">;
+    readonly statusMessage: i0.Signal<string | null>;
+    send(_request: AssistantSendRequest): Observable<AssistantStreamEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotConnectedAssistantTransport, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotConnectedAssistantTransport>;
+}
+
+/**
+ * Test double for {@link AssistantTransport} (specs only — never provided by the app).
+ * Each `send` returns a Subject the spec drives with `emit` / `complete`.
+ */
+declare class FakeAssistantTransport implements AssistantTransport {
+    readonly status: i0.WritableSignal<AssistantTransportStatus>;
+    readonly statusMessage: i0.WritableSignal<string | null>;
+    readonly requests: AssistantSendRequest[];
+    private turn;
+    send(request: AssistantSendRequest): Observable<AssistantStreamEvent>;
+    emit(event: AssistantStreamEvent): void;
+    fail(error: Error): void;
+    complete(): void;
+}
+
+/** Inputs of {@link deriveAssistantContext}, all read from the shell. */
+interface AssistantContextSource {
+    /** Root of the router state snapshot. */
+    root: ActivatedRouteSnapshot | null | undefined;
+    /** Router URL of the page (query and fragment are dropped). */
+    url: string;
+    /** Breadcrumb labels of the page, root first. */
+    breadcrumbs: string[];
+    /** Active rail area and tab (see `ASSISTANT_PAGE_CONTEXT`). */
+    areaText?: string | null;
+    tabText?: string | null;
+    /** Entity set explicitly by an Explain entry point; wins over the route. */
+    explicitEntity?: AssistantExplainTarget | null;
+}
+/**
+ * Turns the current route into the panel's context chips (ui-concept §5.3):
+ * tenant, page ("Area › Tab", else the breadcrumb) and the selected entity — the
+ * one an Explain entry point named, otherwise the deepest id-like route param
+ * (labelled with the last breadcrumb). Pure, so it is tested without a router.
+ */
+declare function deriveAssistantContext(source: AssistantContextSource, messages?: Partial<AssistantMessages> | null): AssistantContextChip[];
+
+/** Result of {@link selectAssistantAttachments}. */
+interface AssistantAttachmentSelection {
+    /** The files that stay attached (previous ones first). */
+    files: File[];
+    /** One translated message per rejected file (or one for "too many"). */
+    errors: string[];
+}
+/** "512 B", "1.5 KB", "10 MB" — for the size-limit message. */
+declare function formatAssistantFileSize(bytes: number): string;
+/**
+ * Whether a file matches an `accept` list (`<input accept>` syntax: MIME types, `type/*`
+ * wildcards and `.ext` extensions, comma separated). An empty list accepts everything.
+ */
+declare function assistantFileAccepted(file: Pick<File, 'name' | 'type'>, accept: string | undefined): boolean;
+/**
+ * Adds newly picked files to the already attached ones, enforcing the transport's
+ * {@link AssistantAttachmentOptions}: wrong type and too large files are rejected individually,
+ * files beyond `maxFiles` (default 1) are dropped with one "too many" message. With
+ * `maxFiles: 1` a newly picked valid file replaces the attached one. Pure.
+ */
+declare function selectAssistantAttachments(current: readonly File[], added: readonly File[], options: AssistantAttachmentOptions, messages: AssistantMessages): AssistantAttachmentSelection;
+
+/**
+ * Default renderer of a tool call in the thread: tool name in mono plus its status.
+ * Replace it through `ASSISTANT_TOOL_CALL_COMPONENT`.
+ */
+declare class AssistantToolCallRowComponent {
+    readonly call: i0.InputSignal<AssistantToolCall>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssistantToolCallRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AssistantToolCallRowComponent, "mm-assistant-tool-call-row", never, { "call": { "alias": "call"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders its template only while the assistant is enabled — with the flag off
+ * the element is not in the DOM at all. Use it on every AI affordance:
+ *
+ * ```html
+ * <button *mmIfAssistant type="button" class="ai-action"
+ *         [mmAssistantExplain]="{ label: adapter.name, rtId: adapter.rtId, ckTypeId: 'System.Communication/Adapter' }">
+ *   ✦ Explain
+ * </button>
+ * ```
+ */
+declare class IfAssistantDirective {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IfAssistantDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IfAssistantDirective, "[mmIfAssistant]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * "✦ Explain <object>" entry point (ui-concept §5.4): a click opens the assistant
+ * panel with `/explain <label>` in the composer and the object as context chip.
+ * Nothing is sent. Pair it with {@link IfAssistantDirective} so the trigger does
+ * not exist while the assistant is disabled; code without a template (a
+ * `CommandItem.onClick`) calls `AssistantService.requestExplain()` instead.
+ */
+declare class AssistantExplainDirective {
+    protected readonly assistant: AssistantService;
+    readonly target: i0.InputSignal<AssistantExplainTarget>;
+    protected explain(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AssistantExplainDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AssistantExplainDirective, "[mmAssistantExplain]", never, { "target": { "alias": "mmAssistantExplain"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ASSISTANT_ENABLED, ASSISTANT_MESSAGES, ASSISTANT_NOT_CONNECTED_MESSAGE, ASSISTANT_PAGE_CONTEXT, ASSISTANT_PANEL_OPTIONS, ASSISTANT_SLASH_COMMANDS, ASSISTANT_TOOL_CALL_COMPONENT, ASSISTANT_TRANSPORT, AssistantExplainDirective, AssistantService, AssistantToolCallRowComponent, DEFAULT_ASSISTANT_MESSAGES, DEFAULT_ASSISTANT_PANEL_MAX_WIDTH, DEFAULT_ASSISTANT_PANEL_MIN_WIDTH, DEFAULT_ASSISTANT_PANEL_STORAGE_KEY, DEFAULT_ASSISTANT_SLASH_COMMANDS, FakeAssistantTransport, IfAssistantDirective, NotConnectedAssistantTransport, assistantFileAccepted, assistantHotkey, assistantMessages, deriveAssistantContext, formatAssistantFileSize, formatAssistantMessage, proposalDecisionLabel, resolveAssistantMessages, selectAssistantAttachments };
+export type { AssistantAsyncResult, AssistantAttachmentOptions, AssistantAttachmentRef, AssistantAttachmentSelection, AssistantContextChip, AssistantContextKind, AssistantContextSource, AssistantExplainTarget, AssistantMessages, AssistantOpenRequest, AssistantPageContext, AssistantPanelMode, AssistantPanelOptions, AssistantProposal, AssistantProposalDecision, AssistantProposalDecisionKind, AssistantSendRequest, AssistantSessionSummary, AssistantSlashCommand, AssistantStarterQuestions, AssistantStreamEvent, AssistantThreadItem, AssistantToolCall, AssistantTransport, AssistantTransportStatus };