@newheap/platform-ai-chat 0.4.0 → 0.6.0

package/index.d.ts

@@ -13,7 +13,21 @@ interface AssistantStatus {
     };
     /** True when the caller also passes the admin policy and may use the `admin/*` endpoints. */
     canAdminister: boolean;
+    /** Sharing, live update and notification features; missing on servers without them. */
+    collaboration?: AssistantCollaboration | null;
 }
+interface AssistantCollaboration {
+    /** Owners can invite colleagues directly through the application's directory. */
+    directory: boolean;
+    /** Path of the SignalR hub for live updates, for example `/hub/assistant`; `null` when off. */
+    hubPath: string | null;
+    /** Web Push notifications are configured on the server. */
+    push: boolean;
+    /** Maximum participants per conversation, not counting the owner. */
+    maxParticipants: number;
+}
+/** The caller's relation to a conversation. */
+type ConversationRole = 'owner' | 'participant';
 interface AgentSummary {
     id: string;
     version: number;
@@ -28,18 +42,46 @@ interface ConversationSummary {
     status: ConversationStatus;
     createdAt: string;
     updatedAt: string;
+    /** Default `owner` for servers without sharing. */
+    role?: ConversationRole;
+    /** People the owner shared the conversation with. */
+    participantCount?: number;
+    /** Sequence of the latest message. */
+    lastMessageSequence?: number;
+    /** The caller's read position; the conversation is unread while it is lower than `lastMessageSequence`. */
+    lastReadSequence?: number;
+    /** The owner or participant whose turn runs or waits for approval. */
+    activeActorId?: string | null;
 }
 interface Conversation extends ConversationSummary {
     agentVersion: number;
     messages: Message[];
     pendingApproval: ApprovalPart | null;
+    /** The owner followed by the participants; empty while the conversation is not shared. */
+    members?: ConversationMember[];
+    /** The current invitation-link token; only for the owner. */
+    shareToken?: string | null;
+    /** The caller's actor id, to recognize the caller's own messages. */
+    currentActorId?: string | null;
 }
 type ConversationStatus = 'idle' | 'running' | 'waiting-for-approval' | 'failed' | 'archived';
+/** The owner or a participant of a shared conversation. */
+interface ConversationMember {
+    actorId: string;
+    /** `null` when the application provides no name. */
+    displayName: string | null;
+    role: ConversationRole;
+    joinedAt: string;
+}
 interface Message {
     id: string;
     role: 'user' | 'assistant' | 'tool';
     createdAt: string;
     parts: MessagePart[];
+    /** Position in the conversation; missing on optimistic messages and old servers. */
+    sequence?: number;
+    /** The writer of a user message. */
+    authorActorId?: string | null;
 }
 type MessagePart = TextPart | ToolCallPart | ApprovalPart;
 interface TextPart {
@@ -130,6 +172,34 @@ interface DecideApprovalRequest {
     expectedProposalHash: string;
     reason?: string;
 }
+/** Response of `POST conversations/{id}/share-link`. */
+interface ShareLink {
+    token: string;
+}
+/** A person the owner may invite, from the application's directory. */
+interface DirectoryEntry {
+    actorId: string;
+    displayName: string;
+    detail: string | null;
+}
+/** Response of `GET` and `PUT notifications`. */
+interface NotificationSettings {
+    /** The caller's choice; on by default. */
+    pushEnabled: boolean;
+    /** The server has Web Push configured. */
+    pushAvailable: boolean;
+    /** The VAPID key browsers subscribe with. */
+    publicKey: string | null;
+}
+/** Body of `PUT notifications/push-subscription`: `PushSubscription.toJSON()` plus the text language. */
+interface PushSubscriptionRequest {
+    endpoint: string;
+    keys: {
+        p256dh: string;
+        auth: string;
+    };
+    language?: string;
+}
 
 interface TurnStartedEvent {
     turnId: string;
@@ -204,9 +274,42 @@ declare const NhAssistantClientErrorCodes: {
     readonly invalidResponse: "assistant-invalid-response";
     readonly streamInterrupted: "assistant-stream-interrupted";
     readonly server: "assistant-server";
+    /** The open conversation was deleted by its owner, or the user left or was removed. */
+    readonly conversationRemoved: "assistant-conversation-removed";
 };
 type NhAssistantClientErrorCode = typeof NhAssistantClientErrorCodes[keyof typeof NhAssistantClientErrorCodes];
 
+/** `ConversationChanged`: status, title, active actor, latest message or participants changed. */
+interface LiveConversationChanged {
+    conversationId: string;
+    status: ConversationStatus;
+    title: string | null;
+    updatedAt: string;
+    activeActorId: string | null;
+    lastMessageSequence: number;
+    participantCount: number;
+}
+/** `ConversationRead`: the current user read the conversation, for example in another tab. */
+interface LiveConversationRead {
+    conversationId: string;
+    lastReadSequence: number;
+}
+/** `ConversationRemoved`: the conversation is no longer available to the current user. */
+interface LiveConversationRemoved {
+    conversationId: string;
+}
+/**
+ * `ConversationEvent`: one turn event with the same `type` and `data` as the server-sent events
+ * of the starting request, or `message.created` with a `Message` when a participant's message
+ * was stored.
+ */
+interface LiveConversationEvent {
+    conversationId: string;
+    actorId: string;
+    type: string;
+    data: unknown;
+}
+
 type AssistantStyle = 'default' | 'direct' | 'personal' | 'detailed';
 type AssistantAddressForm = 'informal' | 'formal';
 type AssistantResponseLength = 'short' | 'normal' | 'long';
@@ -357,6 +460,41 @@ interface NhAssistantConfig {
     markdown?: {
         enabled: boolean;
     };
+    /**
+     * Live updates of shared and parallel conversations through the server's SignalR hub, which
+     * `GET status` reports. Uses `@microsoft/signalr`, loaded on first use. Default `true`; when off
+     * or unavailable the assistant reloads snapshots instead.
+     */
+    liveUpdates?: boolean;
+    /**
+     * Base the server's hub path is appended to, for example `'/api'` when a proxy serves the API
+     * below a prefix, as for the NewHeap background operation hub. Default: the origin of `apiBaseUrl`.
+     */
+    hubBaseUrl?: string;
+    /**
+     * Web Push notifications for people who are away. Copy the bundled worker from
+     * `node_modules/@newheap/platform-ai-chat/push` into the application's assets and point
+     * `serviceWorkerUrl` to it. Without this setting the assistant never subscribes the browser.
+     */
+    push?: NhAssistantPushConfig;
+    /**
+     * Builds the invitation link an owner copies. Default: the current page with
+     * `#nh-assistant-join=<conversationId>.<token>`; the panel joins when the page opens with it.
+     */
+    buildShareLink?: (conversationId: string, token: string) => string;
+}
+interface NhAssistantPushConfig {
+    /** URL of the bundled worker, for example `/nh-assistant/nh-assistant-push-worker.js`. */
+    serviceWorkerUrl: string;
+    /**
+     * Scope of the worker. Default: the worker's folder. Keep it apart from an application service
+     * worker; the assistant worker only shows notifications and never controls pages.
+     */
+    scope?: string;
+    /** Page a notification opens when no window of the application is open. Default `/`. */
+    openUrl?: string;
+    /** Icon URL of the notifications. */
+    icon?: string;
 }
 declare const NH_ASSISTANT_CONFIG: InjectionToken<NhAssistantConfig>;
 declare const NH_ASSISTANT_ACCESS_POLICY: InjectionToken<NhAssistantAccessPolicy>;
@@ -455,6 +593,28 @@ declare class NhAssistantApiService {
     sendMessage(conversationId: string, request: SendMessageRequest): Observable<NhAssistantSseEvent>;
     decideApproval(conversationId: string, approvalId: string, request: DecideApprovalRequest): Observable<NhAssistantSseEvent>;
     cancel(conversationId: string): Observable<void>;
+    /** Raises the caller's read position to `sequence`, or to the latest message when omitted. */
+    markRead(conversationId: string, sequence?: number): Observable<void>;
+    /** Owner only: creates a new invitation link; an earlier link stops working. */
+    createShareLink(conversationId: string): Observable<ShareLink>;
+    /** Owner only: the invitation link stops working; people who joined stay. */
+    revokeShareLink(conversationId: string): Observable<void>;
+    /** Joins a shared conversation with the token of its invitation link. */
+    joinConversation(conversationId: string, token: string): Observable<Conversation>;
+    /** Owner only: searches the application's directory for people to invite. */
+    searchParticipantCandidates(conversationId: string, query: string): Observable<DirectoryEntry[]>;
+    /** Owner only: invites a person the directory returned. */
+    inviteParticipant(conversationId: string, actorId: string): Observable<void>;
+    /** The owner removes a participant, or a participant passes their own id to leave. */
+    removeParticipant(conversationId: string, actorId: string): Observable<void>;
+    /** The caller's notification choice and the server's Web Push key. */
+    getNotificationSettings(): Observable<NotificationSettings>;
+    /** Turns push notifications on or off for every browser of the caller. */
+    updateNotificationSettings(pushEnabled: boolean): Observable<NotificationSettings>;
+    /** Registers this browser's push subscription for the caller. */
+    subscribePush(subscription: PushSubscriptionRequest): Observable<void>;
+    /** Removes this browser's push subscription. */
+    unsubscribePush(endpoint: string): Observable<void>;
     /** The caller's own assistant preferences. */
     getPreferences(): Observable<AssistantPreferences>;
     /** Replaces the caller's own assistant preferences and returns the stored values. */
@@ -513,6 +673,13 @@ declare class NhAssistantAdminApiService {
 declare function applyNhAssistantEvent(conversation: Conversation, event: NhAssistantSseEvent, clientMessageId?: string): Conversation;
 /** Records the user's approval decision locally until the server state is reloaded. */
 declare function applyNhAssistantApprovalDecision(conversation: Conversation, approvalId: string, decision: 'approve' | 'reject'): Conversation;
+/**
+ * Applies a live update of another session: `message.created` adds a participant's message,
+ * the turn events behave exactly like the starting request's stream. Unknown types are ignored.
+ */
+declare function applyNhAssistantLiveEvent(conversation: Conversation, event: LiveConversationEvent): Conversation;
+/** Applies the shared state of a conversation that a live update announced. */
+declare function applyNhAssistantConversationChange(conversation: Conversation, change: LiveConversationChanged): Conversation;
 /**
  * True when an assistant message after the latest user message contains non-blank text,
  * so the latest turn produced a visible answer. Tool calls and approvals alone do not count.
@@ -538,6 +705,52 @@ declare function normalizeNhAssistantClientContext(value: unknown): ClientContex
 /** Short text for the page-context chip: the first entity's label, the title or the route. */
 declare function describeNhAssistantClientContext(context: ClientContext): string;
 
+type NhAssistantLiveState = 'off' | 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
+/**
+ * Live updates of the assistant hub: conversation changes, read positions, removals and the
+ * turn events of other sessions. Connects only while the store asks for it, reconnects on its
+ * own and emits `resync` after every (re)connect, because updates sent while disconnected are lost.
+ */
+declare class NhAssistantLiveService {
+    private readonly config;
+    private readonly injector;
+    private readonly browser;
+    private readonly changedSubject;
+    private readonly readSubject;
+    private readonly removedSubject;
+    private readonly eventSubject;
+    private readonly resyncSubject;
+    private readonly stateSignal;
+    private connection?;
+    private hubPath;
+    private hubUrl;
+    private revision;
+    private restartTimer?;
+    readonly changed$: Observable<LiveConversationChanged>;
+    readonly read$: Observable<LiveConversationRead>;
+    readonly removed$: Observable<LiveConversationRemoved>;
+    readonly events$: Observable<LiveConversationEvent>;
+    /** Reload snapshots: emitted after every (re)connect. */
+    readonly resync$: Observable<void>;
+    readonly state: _angular_core.Signal<NhAssistantLiveState>;
+    constructor();
+    /**
+     * Connects to the hub at `hubPath`, or disconnects when it is `null`. Calling it again with the
+     * same path keeps the connection; another path or `restart` reconnects, for example after the
+     * signed-in user changed.
+     */
+    connect(hubPath: string | null, restart?: boolean): Promise<void>;
+    stop(): Promise<void>;
+    private build;
+    /** Starts over after the automatic reconnect gave up or the first start failed. */
+    private scheduleRestart;
+    private token;
+    /** `hubBaseUrl` + `hubPath`, or the hub path on the origin of `apiBaseUrl`. */
+    private resolveUrl;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantLiveService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantLiveService>;
+}
+
 /** A user-facing assistant failure: a stable code and a translation key, never raw server text. */
 interface NhAssistantError {
     code: string;
@@ -551,8 +764,26 @@ type NhAssistantNotice = NhAssistantError;
 /** Notice code for a completed turn that produced no answer text and no server code. */
 declare const NH_ASSISTANT_NO_ANSWER_NOTICE_CODE = "assistant-no-answer";
 /**
- * Signal-based state of one assistant scope: availability, agents, the conversation list
- * and the active conversation with its streamed turn.
+ * A conversation that needs attention outside the open thread: a turn runs, an approval waits or
+ * there is something unread.
+ */
+interface NhAssistantActivity {
+    id: string;
+    title: string | null;
+    status: ConversationStatus;
+    unread: boolean;
+    shared: boolean;
+    /** True for the conversation shown in the panel. */
+    active: boolean;
+    updatedAt: string;
+}
+/** True when a conversation has messages the caller has not read. A running turn is not unread yet. */
+declare function nhAssistantIsUnread(summary: Pick<ConversationSummary, 'status' | 'lastMessageSequence' | 'lastReadSequence'>): boolean;
+/**
+ * Signal-based state of one assistant scope: availability, agents, the conversation list and
+ * every conversation this tab has opened. Several conversations can run turns at the same time;
+ * the public signals describe the conversation that is open in the panel. With live updates the
+ * store follows turns of other people and of the user's other tabs.
  */
 declare class NhAssistantStore {
     private readonly api;
@@ -560,6 +791,10 @@ declare class NhAssistantStore {
     private readonly injector;
     private readonly accessPolicy;
     private readonly uiState;
+    private readonly live;
+    private readonly push;
+    private readonly document;
+    private readonly browser;
     private readonly accessGrantedState;
     private readonly statusState;
     private readonly statusLoadingState;
@@ -567,24 +802,30 @@ declare class NhAssistantStore {
     private readonly conversationsState;
     private readonly conversationsTotalState;
     private readonly conversationsLoadingState;
-    private readonly activeConversationState;
+    private readonly sessionsState;
+    private readonly activeIdState;
     private readonly conversationLoadingState;
-    private readonly streamingState;
-    private readonly decidingState;
-    private readonly errorState;
-    private readonly noticeState;
-    private readonly lastUsageState;
+    /** The conversation a message is being prepared for; `''` while a new conversation is created. */
+    private readonly sendingState;
+    private readonly draftErrorState;
     private readonly restoredDraftState;
     private readonly pageContextState;
     private readonly pageContextExcludedState;
     private readonly restorePanelOpenState;
+    private readonly viewingState;
+    private readonly pageVisibleState;
+    private readonly streams;
+    private readonly cancelTimers;
+    private readonly pendingSendResolves;
+    private readonly markingRead;
+    private readonly liveSubscription;
     private accessSubscription?;
-    private streamSubscription?;
-    private cancelTimer?;
+    private refreshTimer?;
     private initialization?;
     private statusRevision;
     private accountRevision;
-    private pendingSendResolve?;
+    private collaborationKey;
+    private readonly activeSession;
     /** True when the access policy allows the user and the server reports the assistant as enabled. */
     readonly enabled: _angular_core.Signal<boolean>;
     readonly accessGranted: _angular_core.Signal<boolean | null>;
@@ -596,13 +837,17 @@ declare class NhAssistantStore {
         maxToolCallsPerTurn: number;
     } | null>;
     readonly agents: _angular_core.Signal<AgentSummary[]>;
+    /** Sharing, live update and notification features the server offers. */
+    readonly collaboration: _angular_core.Signal<AssistantCollaboration | null>;
     readonly selectedAgentId: _angular_core.Signal<string | null>;
     readonly selectedAgent: _angular_core.Signal<AgentSummary | null>;
     readonly conversations: _angular_core.Signal<ConversationSummary[]>;
     readonly conversationsTotal: _angular_core.Signal<number>;
     readonly conversationsLoading: _angular_core.Signal<boolean>;
+    /** The conversation open in the panel, or `null` for a new one. */
     readonly activeConversation: _angular_core.Signal<Conversation | null>;
     readonly conversationLoading: _angular_core.Signal<boolean>;
+    /** True while this tab sends a message or streams a turn of the open conversation. */
     readonly streaming: _angular_core.Signal<boolean>;
     readonly pendingApproval: _angular_core.Signal<ApprovalPart | null>;
     readonly deciding: _angular_core.Signal<boolean>;
@@ -620,29 +865,64 @@ declare class NhAssistantStore {
     readonly restorePanelOpen: _angular_core.Signal<boolean>;
     /** True while the user can send: enabled, an agent is chosen and no turn runs or waits. */
     readonly canSend: _angular_core.Signal<boolean>;
+    /** The owner and participants of the open conversation; empty while it is not shared. */
+    readonly members: _angular_core.Signal<ConversationMember[]>;
+    /** True when the current user owns the open conversation (or it is new). */
+    readonly isOwner: _angular_core.Signal<boolean>;
+    /** True when the current user may decide the pending approval: it belongs to their own turn. */
+    readonly canDecide: _angular_core.Signal<boolean>;
+    /** The member whose turn runs or waits in the open conversation, when it is someone else. */
+    readonly activeMember: _angular_core.Signal<ConversationMember | null>;
+    /** Conversations that need attention: running, waiting for approval or unread. Most recent first. */
+    readonly activity: _angular_core.Signal<NhAssistantActivity[]>;
+    readonly runningCount: _angular_core.Signal<number>;
+    readonly waitingCount: _angular_core.Signal<number>;
+    readonly unreadCount: _angular_core.Signal<number>;
+    /** Live update connection state. */
+    readonly liveState: _angular_core.Signal<NhAssistantLiveState>;
     constructor();
     /** Evaluates the access policy and loads the server status once. Safe to call repeatedly. */
     initialize(): Promise<void>;
     /** Reloads the server status, for example after the host changed the signed-in user. */
     reloadStatus(): Promise<void>;
     refreshConversations(): Promise<void>;
-    /** Chooses the agent for the next new conversation. Switching away from the active conversation's agent starts a new one. */
+    /** Chooses the agent for the next new conversation. Switching away from the open conversation's agent starts a new one. */
     selectAgent(agentId: string): void;
-    /** Leaves the active conversation; the next message creates a new one. */
+    /**
+     * Leaves the open conversation; the next message creates a new one. Turns of other
+     * conversations keep running in the background.
+     */
     startNewConversation(): void;
+    /** Opens a conversation; one that this tab already follows opens immediately. */
     openConversation(conversationId: string): Promise<void>;
-    private loadConversation;
+    /** Tells the store whether the user can see the open thread, so it can mark it as read. */
+    setViewing(viewing: boolean): void;
     deleteConversation(conversationId: string): Promise<void>;
     /**
-     * Sends a user message. Creates a conversation with the selected agent when none is
-     * active, shows the message optimistically and applies the streamed events.
-     * Resolves `false` when the message was not accepted.
+     * Sends a user message. Creates a conversation with the selected agent when none is open,
+     * shows the message optimistically and applies the streamed events. Other conversations keep
+     * their own turns. Resolves `false` when the message was not accepted.
      */
     send(text: string): Promise<boolean>;
     /** Approves or rejects the pending approval. Ignores repeated calls while a decision is in flight. */
     decide(decision: ApprovalDecision, reason?: string): void;
-    /** Asks the server to stop the running turn or to abandon a waiting approval. */
+    /** Asks the server to stop the running turn or to abandon a waiting approval of the open conversation. */
     cancel(): Promise<void>;
+    /** Joins a shared conversation with an invitation link and opens it. Resolves `false` on failure. */
+    joinConversation(conversationId: string, token: string): Promise<boolean>;
+    /** Owner only: creates a new invitation link for the open conversation and returns its token. */
+    createShareLink(): Promise<string | null>;
+    /** Owner only: the invitation link of the open conversation stops working. */
+    revokeShareLink(): Promise<boolean>;
+    /** Owner only: searches the application's directory for people to invite to the open conversation. */
+    searchParticipantCandidates(query: string): Promise<DirectoryEntry[]>;
+    /** Owner only: invites a person from the directory to the open conversation. */
+    inviteParticipant(actorId: string): Promise<boolean>;
+    /**
+     * The owner removes a participant of the open conversation; with the current user's own id a
+     * participant leaves it.
+     */
+    removeParticipant(actorId: string): Promise<boolean>;
     clearError(): void;
     clearNotice(): void;
     /** Persists only drawer visibility, never the page context or a message draft. */
@@ -653,6 +933,8 @@ declare class NhAssistantStore {
     setPageContextExcluded(excluded: boolean): void;
     /** Returns and clears the draft of a message that was not accepted. */
     consumeRestoredDraft(): string | null;
+    private loadConversation;
+    private setActive;
     /**
      * Page context for one message: `undefined` omits the field (no getter, getter failed or
      * invalid shape), `null` sends an explicit "none" (no context or left out by the user).
@@ -660,22 +942,101 @@ declare class NhAssistantStore {
     private contextForMessage;
     private readPageContext;
     private startInitialization;
+    /** Connects live updates and notifications once per account and server configuration. */
+    private startCollaboration;
+    /** Forgets everything about the previous account: turns, conversations, live updates and push. */
+    private resetAccount;
     private createConversation;
     private runStream;
-    private stopLocalTurn;
+    private stopAllTurns;
     private applyEvent;
-    /** A completed turn with a server code, or without any answer text, explains itself with a notice. */
-    private completionNotice;
     private afterTurn;
-    private reloadActiveConversation;
-    private updateActive;
+    private reloadSession;
+    private markActiveReadWhenSeen;
+    private onLiveChanged;
+    private onLiveRead;
+    private onLiveRemoved;
+    private onLiveEvent;
+    /** After a reconnect: updates sent while disconnected are lost, so reload what is shown. */
+    private resync;
+    private scheduleRefresh;
+    /** Stores a snapshot, keeping at most `maxSessions` idle conversations in memory. */
+    private upsertSession;
+    private patchSession;
+    private patchSummary;
+    /**
+     * Keeps local knowledge when the list is reloaded: the status of turns this tab streams, and a
+     * read position the server already confirmed, which a list response sent earlier may not show.
+     */
+    private withLocalState;
+    /** Removes a deleted, left or inaccessible conversation everywhere. */
+    private forget;
     private removeMessage;
     private selectInitialAgent;
+    /** Shows an error on a conversation, or on the new-conversation view for `null`. */
     private setError;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantStore, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantStore>;
 }
 
+/**
+ * Push state of this browser for the signed-in user:
+ * - `unavailable`: the server, the browser or the host configuration does not support Web Push;
+ * - `off`: the user turned notifications off;
+ * - `prompt`: on, but the browser has not asked for permission yet (it asks on the next message sent);
+ * - `blocked`: on, but the browser denied permission;
+ * - `on`: this browser receives notifications.
+ */
+type NhAssistantPushState = 'unavailable' | 'off' | 'prompt' | 'blocked' | 'on';
+/**
+ * Keeps this browser's Web Push subscription in line with the user's choice. Notifications are on
+ * by default; because browsers only ask for permission after a user action, the assistant asks
+ * when the user sends a message or turns notifications on. The bundled service worker shows a
+ * notification only when no window of the application is focused.
+ */
+declare class NhAssistantPushService {
+    private readonly api;
+    private readonly config;
+    private readonly translate;
+    private readonly browser;
+    private readonly settingsState;
+    private readonly permissionState;
+    private readonly subscribedState;
+    private readonly busyState;
+    private readonly openSubject;
+    private registration?;
+    private revision;
+    private readonly onWorkerMessage;
+    /** The caller's server-side choice, or `null` before it was loaded. */
+    readonly settings: _angular_core.Signal<NotificationSettings | null>;
+    readonly busy: _angular_core.Signal<boolean>;
+    /** Conversations a clicked notification asks to open. */
+    readonly openConversation$: Observable<string>;
+    readonly state: _angular_core.Signal<NhAssistantPushState>;
+    constructor();
+    /**
+     * Loads the user's choice and, when permission was granted before, renews this browser's
+     * subscription, which also moves it to the current user and to a rotated server key.
+     */
+    activate(serverSupportsPush: boolean): Promise<void>;
+    /**
+     * Forgets the user. The browser subscription is cancelled, so a previous user on a shared device
+     * stops receiving notifications even when the server cannot be told.
+     */
+    deactivate(): Promise<void>;
+    /** Asks for permission once, after a user action such as sending a message. */
+    onUserGesture(): Promise<void>;
+    /** Turns notifications on or off for every browser of the user. Call it from a user action. */
+    setEnabled(enabled: boolean): Promise<void>;
+    private subscribe;
+    private unsubscribe;
+    private register;
+    private scope;
+    private isSupported;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantPushService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantPushService>;
+}
+
 /** Drawer width on wider screens; below the mobile breakpoint the panel fills the screen. */
 declare const NH_ASSISTANT_PANEL_WIDTH = "420px";
 declare const NH_ASSISTANT_PANEL_MOBILE_QUERY = "(max-width: 599.98px)";
@@ -713,7 +1074,14 @@ declare class NhAssistantPanelService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantPanelService>;
 }
 
-type NhAssistantIconName = 'assistant' | 'close' | 'send' | 'stop' | 'plus' | 'list' | 'trash' | 'tool' | 'check' | 'x' | 'warning' | 'chevron-down' | 'clock' | 'settings' | 'admin' | 'edit' | 'refresh' | 'link' | 'page';
+/** Fragment the panel reads to join a shared conversation: `#nh-assistant-join=<id>.<token>`. */
+declare const NH_ASSISTANT_JOIN_FRAGMENT = "nh-assistant-join";
+/** Fragment a clicked notification opens: `#nh-assistant-conversation=<id>`. */
+declare const NH_ASSISTANT_CONVERSATION_FRAGMENT = "nh-assistant-conversation";
+/** Builds the default invitation link: the current page with the join fragment. */
+declare function nhAssistantShareLink(conversationId: string, token: string): string;
+
+type NhAssistantIconName = 'assistant' | 'close' | 'send' | 'stop' | 'plus' | 'list' | 'trash' | 'tool' | 'check' | 'x' | 'warning' | 'chevron-down' | 'clock' | 'settings' | 'admin' | 'edit' | 'refresh' | 'link' | 'page' | 'users' | 'copy' | 'bell' | 'leave';
 /**
  * Optional icon classes of the host's icon library, for example `{ close: 'ph ph-x' }`.
  * Icons without a class use the library's small built-in outline glyphs.
@@ -731,13 +1099,16 @@ declare class NhAssistantIconComponent {
 
 /**
  * Header button that opens the assistant panel. It renders nothing while the assistant is
- * disabled on the server or the access policy denies the user. A badge marks a conversation
- * that waits for approval. Projected content replaces the default icon.
+ * disabled on the server or the access policy denies the user. One small badge shows what needs
+ * attention, in this order: an approval that waits, the number of unread conversations, or a
+ * turn that runs. Projected content replaces the default icon.
  */
 declare class NhAssistantLauncherComponent {
     readonly store: NhAssistantStore;
     readonly panel: NhAssistantPanelService;
     readonly waitingForApproval: _angular_core.Signal<boolean>;
+    readonly badge: _angular_core.Signal<"running" | "unread" | "waiting" | null>;
+    readonly unreadLabel: _angular_core.Signal<string>;
     readonly label: _angular_core.Signal<"nh-assistant.launcher.close" | "nh-assistant.launcher.open">;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantLauncherComponent, never>;
@@ -746,11 +1117,13 @@ declare class NhAssistantLauncherComponent {
 
 /**
  * The assistant drawer. Place it once in the application layout; it renders nothing in
- * place and appears as an overlay when `NhAssistantPanelService.open()` is called.
+ * place and appears as an overlay when `NhAssistantPanelService.open()` is called. It opens
+ * by itself for an invitation link (`#nh-assistant-join=...`) and for a clicked notification.
  */
 declare class NhAssistantPanelComponent implements AfterViewInit, OnDestroy {
     readonly store: NhAssistantStore;
     readonly panel: NhAssistantPanelService;
+    private readonly push;
     private readonly config;
     private readonly viewContainerRef;
     private readonly router;
@@ -760,6 +1133,7 @@ declare class NhAssistantPanelComponent implements AfterViewInit, OnDestroy {
     readonly markdown: boolean;
     readonly showConversations: _angular_core.WritableSignal<boolean>;
     readonly showPreferences: _angular_core.WritableSignal<boolean>;
+    readonly showShare: _angular_core.WritableSignal<boolean>;
     readonly adminRoute: string | any[] | null;
     readonly conversation: _angular_core.Signal<Conversation | null>;
     private readonly conversationId;
@@ -768,6 +1142,12 @@ declare class NhAssistantPanelComponent implements AfterViewInit, OnDestroy {
     readonly busy: _angular_core.Signal<boolean>;
     readonly composerDisabled: _angular_core.Signal<boolean>;
     readonly composerStatus: _angular_core.Signal<"running" | "waiting-for-approval" | null>;
+    /** Name of another participant whose turn runs or waits, or `null`. */
+    readonly activeMemberName: _angular_core.Signal<string | null>;
+    /** The owner and the person who started the turn may stop it. */
+    readonly canStop: _angular_core.Signal<boolean>;
+    readonly shared: _angular_core.Signal<boolean>;
+    readonly canShare: _angular_core.Signal<boolean>;
     readonly errorKeys: _angular_core.Signal<string[]>;
     readonly noticeKeys: _angular_core.Signal<string[]>;
     constructor();
@@ -777,17 +1157,27 @@ declare class NhAssistantPanelComponent implements AfterViewInit, OnDestroy {
     describeContext(context: ClientContext): string;
     toggleConversations(): void;
     togglePreferences(): void;
+    toggleShare(): void;
     newConversation(): void;
     openConversation(conversationId: string): void;
     deleteConversation(conversationId: string): void;
     send(text: string): void;
+    /**
+     * Opens the panel for an invitation link or a clicked notification in the URL fragment and
+     * removes the fragment, so a reload or a shared screenshot does not reuse the token.
+     */
+    private openFromLocation;
     decide(decision: ApprovalDecision): void;
     cancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantPanelComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantPanelComponent, "nh-assistant-panel", never, {}, {}, never, never, true, never>;
 }
 
-/** The user's conversations with loading and empty states; selecting one opens it. */
+/**
+ * The user's own and shared conversations with loading and empty states; selecting one opens it.
+ * Each row marks a running turn, a waiting approval and unread messages. A participant leaves a
+ * shared conversation instead of deleting it.
+ */
 declare class NhAssistantConversationListComponent {
     readonly conversations: _angular_core.InputSignal<readonly ConversationSummary[]>;
     readonly total: _angular_core.InputSignal<number>;
@@ -795,8 +1185,11 @@ declare class NhAssistantConversationListComponent {
     readonly loading: _angular_core.InputSignal<boolean>;
     readonly disabled: _angular_core.InputSignal<boolean>;
     readonly conversationSelect: _angular_core.OutputEmitterRef<string>;
+    /** The owner deletes the conversation; a participant leaves it. */
     readonly conversationDelete: _angular_core.OutputEmitterRef<string>;
     readonly conversationCreate: _angular_core.OutputEmitterRef<void>;
+    unread(conversation: ConversationSummary): boolean;
+    indicator(conversation: ConversationSummary): 'running' | 'waiting' | 'unread' | null;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantConversationListComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantConversationListComponent, "nh-assistant-conversation-list", never, { "conversations": { "alias": "conversations"; "required": true; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "activeConversationId": { "alias": "activeConversationId"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "conversationSelect": "conversationSelect"; "conversationDelete": "conversationDelete"; "conversationCreate": "conversationCreate"; }, never, never, true, never>;
 }
@@ -805,8 +1198,9 @@ declare class NhAssistantConversationListComponent {
 declare const NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD = 200;
 /**
  * The messages of a conversation as a live log. Assistant text renders as sanitized
- * Markdown, tool calls and approvals as cards. The thread follows new content while the
- * user is at the bottom.
+ * Markdown, consecutive tool calls as one collapsible group that counts along, and
+ * approvals as cards. While a turn runs without visible progress, a working indicator
+ * shows the elapsed time. The thread follows new content while the user is at the bottom.
  */
 declare class NhAssistantThreadComponent {
     private readonly injector;
@@ -814,18 +1208,40 @@ declare class NhAssistantThreadComponent {
     readonly streaming: _angular_core.InputSignal<boolean>;
     readonly deciding: _angular_core.InputSignal<boolean>;
     readonly markdown: _angular_core.InputSignal<boolean>;
+    /** The owner and participants of a shared conversation; empty while it is not shared. */
+    readonly members: _angular_core.InputSignal<readonly ConversationMember[]>;
+    /** The current user, to tell their own messages from those of others. */
+    readonly currentActorId: _angular_core.InputSignal<string | null>;
+    /** False when the pending approval belongs to another participant's turn. */
+    readonly canDecide: _angular_core.InputSignal<boolean>;
+    /** Name of the participant who decides the pending approval, when it is someone else. */
+    readonly decisionOwner: _angular_core.InputSignal<string | null>;
     readonly approvalDecision: _angular_core.OutputEmitterRef<ApprovalDecision>;
+    private readonly names;
     readonly virtualThreshold = 200;
     readonly virtual: _angular_core.Signal<boolean>;
+    /**
+     * True while the turn runs and nothing else shows progress: before the first part and
+     * between tool calls while the model decides what to do next. Streaming text and a
+     * running tool group show their own progress; an approval waits for the user.
+     */
     readonly working: _angular_core.Signal<boolean>;
+    /** Whole seconds since the running turn started. */
+    readonly elapsedSeconds: _angular_core.Signal<number>;
+    private readonly turnStartedAt;
+    private readonly now;
     private readonly scroller;
     private readonly viewport;
     constructor();
     trackMessage(_index: number, message: Message): string;
+    /** True for a user message written by another person in a shared conversation. */
+    isOthers(message: Message): boolean;
+    /** Display name of another person's message, or `null` when the application provides none. */
+    authorName(message: Message): string | null;
     private scrollElement;
     private scrollToEnd;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantThreadComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantThreadComponent, "nh-assistant-thread", never, { "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; "markdown": { "alias": "markdown"; "required": false; "isSignal": true; }; }, { "approvalDecision": "approvalDecision"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantThreadComponent, "nh-assistant-thread", never, { "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; "markdown": { "alias": "markdown"; "required": false; "isSignal": true; }; "members": { "alias": "members"; "required": false; "isSignal": true; }; "currentActorId": { "alias": "currentActorId"; "required": false; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionOwner": { "alias": "decisionOwner"; "required": false; "isSignal": true; }; }, { "approvalDecision": "approvalDecision"; }, never, never, true, never>;
 }
 
 /**
@@ -841,6 +1257,10 @@ declare class NhAssistantComposerComponent {
     readonly busy: _angular_core.InputSignal<boolean>;
     /** Announces why sending is temporarily unavailable. */
     readonly status: _angular_core.InputSignal<"running" | "waiting-for-approval" | null>;
+    /** Name of the participant whose turn runs or waits, when it is someone else. */
+    readonly statusActor: _angular_core.InputSignal<string | null>;
+    /** False when the user may not stop the running turn, such as another participant's turn. */
+    readonly canStop: _angular_core.InputSignal<boolean>;
     readonly maxLength: _angular_core.InputSignal<number | null>;
     /** Text to put back into the input, for example a message the server did not accept. */
     readonly restore: _angular_core.InputSignal<string | null>;
@@ -867,7 +1287,7 @@ declare class NhAssistantComposerComponent {
     submit(): void;
     private restoreOwnedFocus;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantComposerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantComposerComponent, "nh-assistant-composer", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "sendDisabled": { "alias": "sendDisabled"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "restore": { "alias": "restore"; "required": false; "isSignal": true; }; }, { "send": "send"; "cancel": "cancel"; "restored": "restored"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantComposerComponent, "nh-assistant-composer", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "sendDisabled": { "alias": "sendDisabled"; "required": false; "isSignal": true; }; "busy": { "alias": "busy"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; "statusActor": { "alias": "statusActor"; "required": false; "isSignal": true; }; "canStop": { "alias": "canStop"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "restore": { "alias": "restore"; "required": false; "isSignal": true; }; }, { "send": "send"; "cancel": "cancel"; "restored": "restored"; }, never, never, true, never>;
 }
 
 /** Shows one tool invocation with its status and expandable input and result previews. */
@@ -882,6 +1302,29 @@ declare class NhAssistantToolCallCardComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantToolCallCardComponent, "nh-assistant-tool-call-card", never, { "part": { "alias": "part"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/** Overall state of a run of tool calls, from most to least urgent. */
+type NhAssistantToolCallGroupState = 'awaiting-approval' | 'running' | 'failed' | 'succeeded';
+/**
+ * Summarizes consecutive tool calls in one collapsed line that counts along live: the
+ * tool that runs now while the assistant works, and how many tools were used and failed
+ * afterwards. Expanding it shows every call as a card.
+ */
+declare class NhAssistantToolCallGroupComponent {
+    readonly calls: _angular_core.InputSignal<readonly ToolCallPart[]>;
+    readonly callsId: string;
+    readonly expanded: _angular_core.WritableSignal<boolean>;
+    /** The call that currently needs attention or runs; the latest one when several do. */
+    readonly current: _angular_core.Signal<ToolCallPart | null>;
+    readonly total: _angular_core.Signal<number>;
+    readonly finished: _angular_core.Signal<number>;
+    readonly failed: _angular_core.Signal<number>;
+    readonly state: _angular_core.Signal<NhAssistantToolCallGroupState>;
+    readonly stateIcon: _angular_core.Signal<NhAssistantIconName>;
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantToolCallGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantToolCallGroupComponent, "nh-assistant-tool-call-group", never, { "calls": { "alias": "calls"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
 /** Formats remaining milliseconds as `m:ss`, or `h:mm:ss` above one hour. */
 declare function formatNhAssistantCountdown(milliseconds: number): string;
 /**
@@ -893,6 +1336,13 @@ declare class NhAssistantApprovalCardComponent {
     readonly approval: _angular_core.InputSignal<ApprovalPart>;
     /** True while the host submits a decision; disables both buttons. */
     readonly deciding: _angular_core.InputSignal<boolean>;
+    /**
+     * False when the approval belongs to another participant's turn: only the person whose
+     * permissions the action would use may decide it.
+     */
+    readonly canDecide: _angular_core.InputSignal<boolean>;
+    /** Name of the participant who decides, shown when the current user cannot. */
+    readonly decisionOwner: _angular_core.InputSignal<string | null>;
     readonly decide: _angular_core.OutputEmitterRef<ApprovalDecision>;
     private readonly now;
     private readonly submitted;
@@ -906,7 +1356,7 @@ declare class NhAssistantApprovalCardComponent {
     constructor();
     choose(decision: ApprovalDecision): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantApprovalCardComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantApprovalCardComponent, "nh-assistant-approval-card", never, { "approval": { "alias": "approval"; "required": true; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; }, { "decide": "decide"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantApprovalCardComponent, "nh-assistant-approval-card", never, { "approval": { "alias": "approval"; "required": true; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionOwner": { "alias": "decisionOwner"; "required": false; "isSignal": true; }; }, { "decide": "decide"; }, never, never, true, never>;
 }
 
 /**
@@ -928,12 +1378,14 @@ declare class NhAssistantAgentPickerComponent {
 /** Maximum length of the user's own instructions. */
 declare const NH_ASSISTANT_MAX_CUSTOM_INSTRUCTIONS = 1000;
 /**
- * The user's own assistant preferences: style, form of address, answer length and
- * optional instructions. Preferences steer style only; the server keeps them below the
- * application context and agent instructions.
+ * The user's own assistant preferences: desktop notifications, style, form of address,
+ * answer length and optional instructions. Notifications apply immediately; the other
+ * preferences steer style only and are saved together, below the application context and
+ * agent instructions.
  */
 declare class NhAssistantPreferencesComponent {
     private readonly api;
+    readonly push: NhAssistantPushService;
     private subscription?;
     /** Emitted when the user leaves the preferences. */
     readonly closed: _angular_core.OutputEmitterRef<void>;
@@ -961,6 +1413,8 @@ declare class NhAssistantPreferencesComponent {
     readonly errorKeys: _angular_core.Signal<string[]>;
     constructor();
     load(): void;
+    /** Turns desktop notifications on or off; turning them on asks the browser for permission. */
+    toggleNotifications(event: Event): Promise<void>;
     onInstructionsInput(event: Event): void;
     choose<T>(target: {
         set(value: T): void;
@@ -971,6 +1425,61 @@ declare class NhAssistantPreferencesComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantPreferencesComponent, "nh-assistant-preferences", never, {}, { "closed": "closed"; "saved": "saved"; }, never, never, true, never>;
 }
 
+/**
+ * Sharing of the open conversation. The owner creates, copies, renews or stops an invitation
+ * link, invites colleagues through the application's directory when it offers one, and removes
+ * participants. A participant sees who takes part and can leave.
+ */
+declare class NhAssistantShareComponent {
+    readonly store: NhAssistantStore;
+    private readonly config;
+    private searchTimer?;
+    private searchRevision;
+    /** Emitted when the user leaves the view. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly id: string;
+    readonly conversation: _angular_core.Signal<Conversation | null>;
+    readonly isOwner: _angular_core.Signal<boolean>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly copied: _angular_core.WritableSignal<boolean>;
+    readonly query: _angular_core.WritableSignal<string>;
+    readonly searching: _angular_core.WritableSignal<boolean>;
+    readonly candidates: _angular_core.WritableSignal<DirectoryEntry[]>;
+    readonly invited: _angular_core.WritableSignal<string | null>;
+    readonly directory: _angular_core.Signal<boolean>;
+    readonly maxParticipants: _angular_core.Signal<number | null>;
+    readonly participants: _angular_core.Signal<ConversationMember[]>;
+    readonly link: _angular_core.Signal<string | null>;
+    readonly full: _angular_core.Signal<boolean>;
+    constructor();
+    createLink(): Promise<void>;
+    revokeLink(): Promise<void>;
+    copy(input: HTMLInputElement): Promise<void>;
+    onSearch(event: Event): void;
+    invite(entry: DirectoryEntry): Promise<void>;
+    remove(member: ConversationMember): Promise<void>;
+    leave(): Promise<void>;
+    isCurrentUser(member: ConversationMember): boolean;
+    private run;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantShareComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantShareComponent, "nh-assistant-share", never, {}, { "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * One slim row of the other conversations that need attention: a running turn, an approval that
+ * waits, or an unread answer. It renders nothing when there are none, so it costs no space in the
+ * usual case. Selecting a chip opens that conversation; its turn keeps running meanwhile.
+ */
+declare class NhAssistantActivityComponent {
+    readonly items: _angular_core.InputSignal<readonly NhAssistantActivity[]>;
+    readonly conversationSelect: _angular_core.OutputEmitterRef<string>;
+    /** The open conversation already shows its own state. */
+    readonly others: _angular_core.Signal<NhAssistantActivity[]>;
+    state(item: NhAssistantActivity): 'running' | 'waiting' | 'unread';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantActivityComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantActivityComponent, "nh-assistant-activity", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, { "conversationSelect": "conversationSelect"; }, never, never, true, never>;
+}
+
 /**
  * Translates the first key that has a translation and otherwise returns the fallback text.
  * Used for server-provided keys (agent names, error message keys, result codes) that the
@@ -996,5 +1505,5 @@ declare function nhAssistantErrorKeys(error: NhAssistantError | null): string[];
 /** Dash-case identifiers as the contract requires for agent and MCP server ids. */
 declare const NH_ASSISTANT_DASH_CASE: RegExp;
 
-export { NH_ASSISTANT_ACCESS_POLICY, NH_ASSISTANT_CONFIG, NH_ASSISTANT_FETCH, NH_ASSISTANT_ICONS, NH_ASSISTANT_MAX_CUSTOM_INSTRUCTIONS, NH_ASSISTANT_NO_ANSWER_NOTICE_CODE, NH_ASSISTANT_PAGE_CONTEXT_LIMITS, NH_ASSISTANT_PANEL_MOBILE_QUERY, NH_ASSISTANT_PANEL_WIDTH, NH_ASSISTANT_SSE_EVENT_TYPES, NH_ASSISTANT_TRANSLATIONS, NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD, NhAssistantAdminApiService, NhAssistantAgentPickerComponent, NhAssistantAllowAllAccessPolicy, NhAssistantApiError, NhAssistantApiService, NhAssistantApprovalCardComponent, NhAssistantClientErrorCodes, NhAssistantComposerComponent, NhAssistantConversationListComponent, NhAssistantLauncherComponent, NhAssistantPanelComponent, NhAssistantPanelService, NhAssistantPreferencesComponent, NhAssistantSseParser, NhAssistantStore, NhAssistantThreadComponent, NhAssistantToolCallCardComponent, NhAssistantTranslationMerger, applyNhAssistantApprovalDecision, applyNhAssistantEvent, describeNhAssistantClientContext, formatNhAssistantCountdown, nhAssistantCodeForStatus, nhAssistantErrorMessageKey, nhAssistantLatestTurnHasText, normalizeNhAssistantClientContext, provideNhAssistant, NH_ASSISTANT_DASH_CASE as ɵNH_ASSISTANT_DASH_CASE, NhAssistantIconComponent as ɵNhAssistantIconComponent, NhAssistantTranslatePipe as ɵNhAssistantTranslatePipe, nhAssistantErrorKeys as ɵnhAssistantErrorKeys, toNhAssistantError as ɵtoNhAssistantError };
-export type { AdminAgent, AdminAgentInput, AgentSummary, ApplicationContext, ApplicationContextVersion, ApprovalDecision, ApprovalPart, ApprovalPresentation, ApprovalPresentationField, ApprovalRequiredEvent, ApprovalStatus, AssistantAddressForm, AssistantAutonomy, AssistantErrorEvent, AssistantPreferences, AssistantResponseLength, AssistantStatus, AssistantStyle, ClientContext, ClientContextEntity, Conversation, ConversationPage, ConversationStatus, ConversationSummary, CreateConversationRequest, DecideApprovalRequest, McpAuthMode, McpServer, McpServerInput, McpServerTestResult, McpTool, McpToolEffect, McpToolStatus, Message, MessageDeltaEvent, MessagePart, NhAssistantAccessPolicy, NhAssistantClientContext, NhAssistantClientErrorCode, NhAssistantConfig, NhAssistantError, NhAssistantFetch, NhAssistantIconName, NhAssistantNotice, NhAssistantRawSseMessage, NhAssistantSseEvent, NhAssistantSseEventMap, NhAssistantSseEventType, NhAssistantStatusCodes, SendMessageRequest, TextPart, ToolCallPart, ToolCallStatus, ToolCatalogEffect, ToolCatalogEntry, ToolCompletedEvent, ToolStartedEvent, TurnCompletedEvent, TurnCompletionStatus, TurnStartedEvent, TurnUsage, UpdateAdminAgentRequest, UpdateApplicationContextRequest, UpdateMcpToolRequest };
+export { NH_ASSISTANT_ACCESS_POLICY, NH_ASSISTANT_CONFIG, NH_ASSISTANT_CONVERSATION_FRAGMENT, NH_ASSISTANT_FETCH, NH_ASSISTANT_ICONS, NH_ASSISTANT_JOIN_FRAGMENT, NH_ASSISTANT_MAX_CUSTOM_INSTRUCTIONS, NH_ASSISTANT_NO_ANSWER_NOTICE_CODE, NH_ASSISTANT_PAGE_CONTEXT_LIMITS, NH_ASSISTANT_PANEL_MOBILE_QUERY, NH_ASSISTANT_PANEL_WIDTH, NH_ASSISTANT_SSE_EVENT_TYPES, NH_ASSISTANT_TRANSLATIONS, NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD, NhAssistantActivityComponent, NhAssistantAdminApiService, NhAssistantAgentPickerComponent, NhAssistantAllowAllAccessPolicy, NhAssistantApiError, NhAssistantApiService, NhAssistantApprovalCardComponent, NhAssistantClientErrorCodes, NhAssistantComposerComponent, NhAssistantConversationListComponent, NhAssistantLauncherComponent, NhAssistantLiveService, NhAssistantPanelComponent, NhAssistantPanelService, NhAssistantPreferencesComponent, NhAssistantPushService, NhAssistantShareComponent, NhAssistantSseParser, NhAssistantStore, NhAssistantThreadComponent, NhAssistantToolCallCardComponent, NhAssistantToolCallGroupComponent, NhAssistantTranslationMerger, applyNhAssistantApprovalDecision, applyNhAssistantConversationChange, applyNhAssistantEvent, applyNhAssistantLiveEvent, describeNhAssistantClientContext, formatNhAssistantCountdown, nhAssistantCodeForStatus, nhAssistantErrorMessageKey, nhAssistantIsUnread, nhAssistantLatestTurnHasText, nhAssistantShareLink, normalizeNhAssistantClientContext, provideNhAssistant, NH_ASSISTANT_DASH_CASE as ɵNH_ASSISTANT_DASH_CASE, NhAssistantIconComponent as ɵNhAssistantIconComponent, NhAssistantTranslatePipe as ɵNhAssistantTranslatePipe, nhAssistantErrorKeys as ɵnhAssistantErrorKeys, toNhAssistantError as ɵtoNhAssistantError };
+export type { AdminAgent, AdminAgentInput, AgentSummary, ApplicationContext, ApplicationContextVersion, ApprovalDecision, ApprovalPart, ApprovalPresentation, ApprovalPresentationField, ApprovalRequiredEvent, ApprovalStatus, AssistantAddressForm, AssistantAutonomy, AssistantCollaboration, AssistantErrorEvent, AssistantPreferences, AssistantResponseLength, AssistantStatus, AssistantStyle, ClientContext, ClientContextEntity, Conversation, ConversationMember, ConversationPage, ConversationRole, ConversationStatus, ConversationSummary, CreateConversationRequest, DecideApprovalRequest, DirectoryEntry, LiveConversationChanged, LiveConversationEvent, LiveConversationRead, LiveConversationRemoved, McpAuthMode, McpServer, McpServerInput, McpServerTestResult, McpTool, McpToolEffect, McpToolStatus, Message, MessageDeltaEvent, MessagePart, NhAssistantAccessPolicy, NhAssistantActivity, NhAssistantClientContext, NhAssistantClientErrorCode, NhAssistantConfig, NhAssistantError, NhAssistantFetch, NhAssistantIconName, NhAssistantLiveState, NhAssistantNotice, NhAssistantPushConfig, NhAssistantPushState, NhAssistantRawSseMessage, NhAssistantSseEvent, NhAssistantSseEventMap, NhAssistantSseEventType, NhAssistantStatusCodes, NhAssistantToolCallGroupState, NotificationSettings, PushSubscriptionRequest, SendMessageRequest, ShareLink, TextPart, ToolCallPart, ToolCallStatus, ToolCatalogEffect, ToolCatalogEntry, ToolCompletedEvent, ToolStartedEvent, TurnCompletedEvent, TurnCompletionStatus, TurnStartedEvent, TurnUsage, UpdateAdminAgentRequest, UpdateApplicationContextRequest, UpdateMcpToolRequest };