@newheap/platform-ai-chat 0.8.1 → 0.10.0

package/index.d.ts

@@ -4,6 +4,327 @@ import { Observable } from 'rxjs';
 import { TranslationObject } from '@ngx-translate/core';
 import { TemplatePortal } from '@angular/cdk/portal';
 
+/**
+ * Contracts of the agent-run endpoints of `NewHeap.Platform.AI.Chat.AspNet`: threads about a
+ * subject, runs, proposals, the approval inbox, working memory and artifacts.
+ */
+/** The caller's role on the subject of a thread. */
+type AgentSubjectRole = 'none' | 'reader' | 'participant' | 'approver';
+type AgentRunStatus = 'queued' | 'running' | 'waiting-for-approval' | 'completed' | 'failed' | 'cancelled';
+type AgentProposalStatus = 'pending' | 'approved' | 'rejected' | 'expired' | 'withdrawn' | 'stale' | 'executing' | 'executed' | 'execution-failed' | 'execution-unknown' | 'resolved' | 'shadow';
+type AgentGrantSource = 'none' | 'delegated' | 'agent';
+/**
+ * How a run worked: `model` through the language model, `rule` through the agent's rules without a
+ * model, `rule-then-model` when the rules handed the run over to the model.
+ */
+type AgentRunKind = 'model' | 'rule' | 'rule-then-model';
+interface AgentRun {
+    id: string;
+    conversationId: string;
+    triggerId: string;
+    status: AgentRunStatus;
+    failureClass: string | null;
+    failureCode: string | null;
+    initiatorActorId: string | null;
+    accountableOwnerId: string;
+    attempt: number;
+    agentVersion: number;
+    toolCalls: number;
+    inputTokens: number;
+    outputTokens: number;
+    proposalCount: number;
+    summary: string | null;
+    shadow: boolean;
+    createdAt: string;
+    startedAt: string | null;
+    endedAt: string | null;
+    backgroundOperationId: string | null;
+    /** How the run worked. Missing on older servers, which only ran the model. */
+    kind?: AgentRunKind;
+}
+interface AgentRunList {
+    items: AgentRun[];
+    total: number;
+}
+interface AgentThread {
+    conversationId: string;
+    agentId: string;
+    subjectType: string;
+    subjectId: string;
+    subjectDisplayName: string | null;
+    accountability: string;
+    accountableOwnerId: string;
+    role: AgentSubjectRole;
+    activeRun: AgentRun | null;
+    waitingInputs: number;
+}
+interface AgentThreadLookup {
+    thread: AgentThread | null;
+    canStart: boolean;
+    role: AgentSubjectRole;
+}
+/** The caller's live right to decide one open proposal; the server checks every decision again. */
+interface AgentProposalDecisionRight {
+    canDecide: boolean;
+    /**
+     * Why the caller may not decide, for example `assistant-four-eyes-required` or
+     * `assistant-approval-policy-denied`; `null` when they may.
+     */
+    reasonCode: string | null;
+}
+/** One agent on a subject: its thread, `null` before it worked on the subject, and whether the caller may start it. */
+interface AgentSubjectWorkAgent {
+    agentId: string;
+    thread: AgentThread | null;
+    canStart: boolean;
+}
+/**
+ * A proposal on a subject with the caller's live decision right. Only a pending proposal can be
+ * decided; for every other status `canDecide` is `false` and `reasonCode` is `null`.
+ */
+interface AgentSubjectWorkProposal extends AgentProposalDecisionRight {
+    proposal: AgentProposal;
+}
+/** The most proposals one `POST approvals/lookup` reads. */
+declare const NH_ASSISTANT_MAX_PROPOSAL_LOOKUP = 100;
+/**
+ * Response of `POST approvals/lookup`: the requested proposals the caller may see, in the order of
+ * the request. Ids the caller may not see, or that do not exist, are left out.
+ */
+interface AgentProposalLookup {
+    items: AgentSubjectWorkProposal[];
+}
+/**
+ * All agent work on one subject as the caller may see it (`GET subjects/{type}/{id}/work`): every
+ * agent with a thread on the subject plus the requested agent, and the pending proposals of all
+ * those threads, the earliest expiry first.
+ */
+interface AgentSubjectWork {
+    subjectType: string;
+    subjectId: string;
+    subjectDisplayName: string | null;
+    /** The caller's live role. Without a role the server answers `404 assistant-subject-not-found`. */
+    role: Exclude<AgentSubjectRole, 'none'>;
+    agents: AgentSubjectWorkAgent[];
+    openProposals: AgentSubjectWorkProposal[];
+}
+/** The agent work on one subject for a list view (`POST subjects/{type}/summary`). */
+interface AgentSubjectSummary {
+    subjectId: string;
+    /** Proposals that wait for a decision on the subject. */
+    openProposals: number;
+    /** The open proposals the caller may decide, counted like the approval inbox. */
+    proposalsToDecide: number;
+    /** An agent works on the subject now. */
+    runActive: boolean;
+}
+/** One summary per requested subject, in request order; subjects without visible work count zero. */
+interface AgentSubjectSummaryList {
+    subjectType: string;
+    items: AgentSubjectSummary[];
+}
+/** Maximum number of subjects one `POST subjects/{type}/summary` request accepts. */
+declare const NH_ASSISTANT_MAX_SUBJECT_SUMMARY = 200;
+interface StartAgentRequest {
+    agentId: string;
+    subjectType: string;
+    subjectId: string;
+    message?: string | null;
+}
+interface AgentTriggerReceipt {
+    triggerId: string;
+    outcome: 'started' | 'queued' | 'coalesced' | 'superseded' | 'ignored' | 'deduplicated' | 'rejected';
+    runId: string | null;
+    conversationId: string | null;
+    reasonCode: string | null;
+}
+interface AgentProposal {
+    approvalId: string;
+    proposalId: string;
+    proposalHash: string;
+    conversationId: string;
+    runId: string | null;
+    agentId: string;
+    subjectType: string;
+    subjectId: string;
+    subjectDisplayName: string | null;
+    toolId: string;
+    summary: string;
+    /**
+     * The application's localized explanation, written when the proposal was recorded. Show it
+     * instead of `argumentsPreview`; `null` when no presenter handled the tool.
+     */
+    presentation: ApprovalPresentation | null;
+    argumentsPreview: string;
+    targets: string[];
+    status: AgentProposalStatus;
+    mode: 'inline' | 'deferred';
+    policyId: string | null;
+    grantSource: AgentGrantSource;
+    createdAt: string;
+    expiresAt: string;
+    initiatorActorId: string | null;
+    decidedByActorId: string | null;
+    /**
+     * The name of `decidedByActorId` from the subject's member snapshot; `null` when the snapshot
+     * does not know the person. Show `decidedByActorId` then. Missing on older servers.
+     */
+    decidedByDisplayName?: string | null;
+    decidedAt: string | null;
+    executionResultCode: string | null;
+    executedAt: string | null;
+    /**
+     * The consultation that proposed it, when another assistant consulted the agent for
+     * `initiatorActorId`; it executes with that person's rights only.
+     */
+    consultationId?: string | null;
+    /** The caller's own feedback on the proposal; `null` when they gave none. Missing on older servers. */
+    feedback?: AgentProposalFeedback | null;
+    /**
+     * Whether the caller may give or change feedback: the proposal was rejected, expired, withdrawn or
+     * closed as stale, and the caller decided it or is an approver of the subject. Missing on older servers.
+     */
+    canGiveFeedback?: boolean;
+    /**
+     * Why a stale proposal no longer fits; `null` for other statuses. Its reason code is
+     * `executionResultCode`. Missing on older servers.
+     */
+    staleKind?: StaleKind | null;
+    /**
+     * The application's explanation of a stale proposal in the caller's language, such as who already
+     * did the work; `null` when it gave none. Missing on older servers.
+     */
+    staleExplanation?: string | null;
+    /**
+     * Who made the proposal stale, when the application's guard named them; `null` otherwise.
+     * Missing on older servers.
+     */
+    staleByActorId?: string | null;
+    /** The name of `staleByActorId` from the subject's member snapshot; `null` when unknown. */
+    staleByDisplayName?: string | null;
+    /**
+     * The application objects the proposal changes, as its guards named them, so lists can group
+     * proposals by object. `targets` holds execution scopes instead. Missing on older servers.
+     */
+    objects?: AgentProposalObject[];
+    /**
+     * The newer proposal for the same objects that replaced this withdrawn one; `null` otherwise.
+     * Missing on older servers.
+     */
+    supersededByApprovalId?: string | null;
+    /**
+     * Why the agent's rules proposed it, in the caller's language; `null` for proposals of the model.
+     * Missing on older servers.
+     */
+    rationale?: string | null;
+}
+/** An application object a proposal changes, such as `{ type: 'project-task', id: '4711' }`. */
+interface AgentProposalObject {
+    type: string;
+    id: string;
+}
+/**
+ * Why a person rejected a proposal. `incorrect`, `wrong-value` and `not-needed` say the agent was
+ * wrong; `not-now` and `already-done` say it was right but not at this moment; `not-allowed` says
+ * it went beyond what the agent should do; `other` leaves the explanation to the text.
+ */
+type AgentProposalFeedbackCategory = 'incorrect' | 'wrong-value' | 'not-needed' | 'not-now' | 'already-done' | 'not-allowed' | 'other';
+/** The group of a feedback category. `right-but-not-now` never counts as "the agent was wrong". */
+type AgentProposalFeedbackGroup = 'wrong' | 'right-but-not-now' | 'not-allowed' | 'other';
+/** The feedback categories in the order people choose them. */
+declare const NH_ASSISTANT_FEEDBACK_CATEGORIES: readonly AgentProposalFeedbackCategory[];
+/** The group of each feedback category, as the server reports it. */
+declare const NH_ASSISTANT_FEEDBACK_GROUPS: Readonly<Record<AgentProposalFeedbackCategory, AgentProposalFeedbackGroup>>;
+/** Maximum length of the text of a feedback. */
+declare const NH_ASSISTANT_MAX_FEEDBACK_TEXT = 1000;
+/** Maximum number of proposals one `POST approvals/feedback` request accepts. */
+declare const NH_ASSISTANT_MAX_BULK_FEEDBACK = 50;
+/**
+ * One person's feedback on a rejected or otherwise closed proposal. It is separate from the
+ * decision's reason, arrives after the decision and can be changed by its author.
+ */
+interface AgentProposalFeedback {
+    approvalId: string;
+    category: AgentProposalFeedbackCategory;
+    group: AgentProposalFeedbackGroup;
+    text: string | null;
+    /** Given once for several proposals that were rejected together. */
+    bulk: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** The outcome of the feedback on one proposal of `POST approvals/feedback`. */
+interface AgentFeedbackOutcome {
+    approvalId: string;
+    succeeded: boolean;
+    /** For example `assistant-feedback-not-accepted`; `null` when it succeeded. */
+    code: string | null;
+}
+type AgentConsultationStatus = 'running' | 'completed' | 'failed';
+/**
+ * One consultation of a thread's agent by another assistant. It names who asked and through which
+ * assistant; the question and the answer stay in the asking conversation.
+ */
+interface AgentConsultation {
+    id: string;
+    askerActorId: string;
+    /** The asker's name from the subject's members, when known. */
+    askerDisplayName: string | null;
+    askingAgentId: string | null;
+    depth: number;
+    status: AgentConsultationStatus;
+    failureCode: string | null;
+    toolCalls: number;
+    inputTokens: number;
+    outputTokens: number;
+    proposalCount: number;
+    createdAt: string;
+    endedAt: string | null;
+}
+interface AgentConsultationList {
+    items: AgentConsultation[];
+    total: number;
+}
+interface AgentInbox {
+    items: AgentProposal[];
+    total: number;
+}
+interface AgentInboxFilter {
+    subjectType?: string;
+    agentId?: string;
+    divisionId?: string;
+    runId?: string;
+    page?: number;
+    itemsPerPage?: number;
+}
+type AgentProposalDecision = 'approve' | 'reject';
+interface AgentDecisionOutcome {
+    approvalId: string;
+    succeeded: boolean;
+    code: string | null;
+    status: AgentProposalStatus | null;
+}
+interface AgentThreadMemory {
+    configured: boolean;
+    schemaVersion: number;
+    memory: unknown;
+    updatedAt: string | null;
+}
+interface AgentArtifact {
+    id: string;
+    name: string;
+    version: number;
+    contentType: string;
+    sizeBytes: number;
+    createdAt: string;
+    runId: string | null;
+    restricted: boolean;
+}
+/** `resume` continues the run from its last checkpoint; `restart` starts a new run in the thread. */
+type AgentRunRetryMode = 'resume' | 'restart';
+/** `re-execute` runs the proposal again; `mark-resolved` confirms its outcome without running it. */
+type AgentExecutionResolution = 're-execute' | 'mark-resolved';
+
 interface AssistantStatus {
     enabled: boolean;
     agents: AgentSummary[];
@@ -63,6 +384,43 @@ interface Conversation extends ConversationSummary {
     shareToken?: string | null;
     /** The caller's actor id, to recognize the caller's own messages. */
     currentActorId?: string | null;
+    /** Default `chat` for servers without agent runs. */
+    kind?: ConversationKind;
+    /**
+     * The subject of an agent thread and the caller's standing in it, including who may decide its
+     * open proposals; `null` for a chat.
+     */
+    thread?: ConversationThread | null;
+}
+/** `chat` for a conversation people start; `thread` for the durable thread of an agent about one subject. */
+type ConversationKind = 'chat' | 'thread';
+/**
+ * The subject of an agent thread as the caller sees it. In a thread the subject's approvers decide
+ * the agent's proposals, not the author of a turn. The server checks the role on every request.
+ */
+interface ConversationThread {
+    subjectType: string;
+    subjectId: string;
+    subjectDisplayName: string | null;
+    /** The caller's live role on the subject. */
+    role: AgentSubjectRole;
+    /** Each open proposal of the thread and whether the caller may decide it now, oldest first. */
+    decisions: ConversationThreadDecision[];
+}
+/**
+ * The caller's right to decide one open proposal of an agent thread, checked like the decision
+ * itself: the approval policy, four-eyes and the tool's approve policy.
+ */
+interface ConversationThreadDecision {
+    approvalId: string;
+    /**
+     * The run that proposed it; such a proposal is decided with `POST approvals/{id}/decisions`.
+     * `null` for a proposal of a person's turn in the thread, decided in the conversation.
+     */
+    runId: string | null;
+    canDecide: boolean;
+    /** Why the caller may not decide, for example `assistant-four-eyes-required`; `null` when they may. */
+    reasonCode: string | null;
 }
 type ConversationStatus = 'idle' | 'running' | 'waiting-for-approval' | 'failed' | 'archived';
 /** The owner or a participant of a shared conversation. */
@@ -82,13 +440,29 @@ interface Message {
     sequence?: number;
     /** The writer of a user message. */
     authorActorId?: string | null;
+    /**
+     * Who wrote the message: a person or a trigger of an agent for user messages, `rule` for the
+     * summary an agent's rules wrote instead of the model; missing on old servers.
+     */
+    authorKind?: MessageAuthorKind | null;
 }
+/**
+ * `person` for a message a person wrote; `trigger` for one a trigger wrote into an agent thread;
+ * `rule` for an assistant message the agent's rules wrote without a model.
+ */
+type MessageAuthorKind = 'person' | 'trigger' | 'rule';
 type MessagePart = TextPart | ToolCallPart | ApprovalPart;
 interface TextPart {
     type: 'text';
     text: string;
 }
-type ToolCallStatus = 'running' | 'succeeded' | 'failed' | 'awaiting-approval' | 'rejected';
+/**
+ * `awaiting-approval` waits for a person. A call whose agent proposal closed without running ends
+ * as `rejected`, as `not-executed` when the proposal expired, was withdrawn or became stale, or as
+ * `failed` when its execution failed before it started; its `resultCode` is then
+ * `assistant-proposal-<approval status>`, for example `assistant-proposal-expired`.
+ */
+type ToolCallStatus = 'running' | 'succeeded' | 'failed' | 'awaiting-approval' | 'rejected' | 'not-executed';
 interface ToolCallPart {
     type: 'tool-call';
     invocationId: string;
@@ -99,8 +473,17 @@ interface ToolCallPart {
     argumentsPreview: string | null;
     resultPreview: string | null;
     resultCode: string | null;
+    /** `delegated` or `agent` when an agent used rights beyond the caller's own. */
+    grantSource?: 'delegated' | 'agent' | null;
+    /** The result came from the agent's own grant and is shielded from this viewer. */
+    restricted?: boolean;
 }
-type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired';
+/**
+ * Chat approvals are `pending`, `approved`, `rejected` or `expired`; proposals of agents that run on
+ * their own continue through execution (`executing`, `executed`, `execution-failed`,
+ * `execution-unknown`, `resolved`) or end as `withdrawn`, `stale` or `shadow`.
+ */
+type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired' | 'withdrawn' | 'stale' | 'executing' | 'executed' | 'execution-failed' | 'execution-unknown' | 'resolved' | 'shadow';
 interface ApprovalPresentationField {
     label: string;
     value: string;
@@ -111,6 +494,11 @@ interface ApprovalPresentation {
     fields: ApprovalPresentationField[];
     notice: string | null;
 }
+/**
+ * Why a stale proposal no longer fits: the work was already done another way, what it was based on
+ * changed, or it no longer applies.
+ */
+type StaleKind = 'already-done' | 'changed' | 'not-applicable';
 interface ApprovalPart {
     type: 'approval';
     approvalId: string;
@@ -124,6 +512,14 @@ interface ApprovalPart {
     targets: string[];
     expiresAt: string;
     status: ApprovalStatus;
+    /** Why a stale proposal no longer fits. Only sent for stale proposals; missing on older servers. */
+    staleKind?: StaleKind;
+    /** The application's explanation of a stale proposal in the reader's language, such as who did the work. */
+    staleExplanation?: string;
+    /** Why the agent's rules proposed it, in the reader's language. Only sent for rule proposals. */
+    rationale?: string;
+    /** The newer proposal for the same objects that replaced this withdrawn one. Only sent then. */
+    supersededByApprovalId?: string;
 }
 /** Response of `GET conversations?page=&itemsPerPage=`. */
 interface ConversationPage {
@@ -298,6 +694,23 @@ interface LiveConversationRead {
 interface LiveConversationRemoved {
     conversationId: string;
 }
+/** What changed in an agent thread: a run, a proposal or the feedback on a proposal. */
+type LiveAgentWorkReason = 'run' | 'proposal' | 'feedback';
+/**
+ * `AgentWorkChanged`: a run of an agent thread started, waits, ended or was cancelled, a proposal
+ * was decided, resolved, executed, closed, escalated or expired, or feedback was given. Sent to the
+ * thread's participants and everyone on its subject. It carries no content: reload the agent-run
+ * endpoints that show the thread, which check access again. It names the thread's subject, so
+ * lists and pages of the application refresh by subject without knowing conversation ids.
+ */
+interface LiveAgentWorkChanged {
+    conversationId: string;
+    reason: LiveAgentWorkReason;
+    approvalId: string | null;
+    runId: string | null;
+    subjectType: string;
+    subjectId: 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
@@ -418,6 +831,123 @@ interface UpdateMcpToolRequest {
     effect: McpToolEffect;
     descriptionOverride: string | null;
 }
+/**
+ * Filter of the feedback report of an agent. The server selects proposals by when they were made,
+ * defaults to the 30 days before `to` (now) and allows at most 366 days; it only reports scopes the
+ * caller administers.
+ */
+interface AgentFeedbackFilter {
+    /** Start of the period as an ISO 8601 date-time. */
+    from?: string;
+    /** End of the period, exclusive, as an ISO 8601 date-time. */
+    to?: string;
+    scopeKey?: string;
+    toolId?: string;
+    agentVersion?: number;
+}
+/** Filter and page of `GET admin/agents/{id}/feedback`. */
+interface AgentFeedbackListFilter extends AgentFeedbackFilter {
+    category?: AgentProposalFeedbackCategory;
+    page?: number;
+    /** At most 100. */
+    itemsPerPage?: number;
+}
+/** Filter of `GET admin/agents/{id}/feedback/export`. */
+interface AgentFeedbackExportFilter extends AgentFeedbackFilter {
+    category?: AgentProposalFeedbackCategory;
+    /** Maximum number of records; the server defaults to 10,000 and allows at most 50,000. */
+    limit?: number;
+}
+interface AgentFeedbackCategoryCount {
+    category: AgentProposalFeedbackCategory;
+    group: AgentProposalFeedbackGroup;
+    count: number;
+}
+/** The proposals of one tool and agent version in the period and what people said about them. */
+interface AgentFeedbackSummaryRow {
+    toolId: string;
+    /** The agent row version of the runs that proposed them; `null` for proposals of consultations. */
+    agentVersion: number | null;
+    pending: number;
+    /** Approved proposals, including those that executed, failed, closed as stale or were resolved. */
+    approved: number;
+    rejected: number;
+    expired: number;
+    withdrawn: number;
+    /** Approved proposals closed right before execution because they no longer fit; part of `approved`. */
+    stale: number;
+    /** Approved proposals whose execution failed; part of `approved`. */
+    executionFailed: number;
+    /** Rejected divided by approved plus rejected (0..1); `null` before anyone decided. */
+    rejectionRate: number | null;
+    /** Rejected proposals with at least one feedback. */
+    rejectedWithFeedback: number;
+    /** Proposals of any status with at least one feedback. */
+    feedbackProposals: number;
+    /** Different people who gave feedback, so one critical approver counts as one. */
+    feedbackAuthors: number;
+    categories: AgentFeedbackCategoryCount[];
+    /**
+     * Open proposals closed before anyone decided because they no longer fit, such as work a person
+     * already did. Neither approved nor rejected, and not part of `rejectionRate`. Missing on older servers.
+     */
+    invalidated?: number;
+    /** Why proposals closed as stale, per kind and reason code. Missing on older servers. */
+    invalidations?: AgentInvalidationCount[];
+}
+/** Proposals of one tool and agent version that closed as stale for one kind and reason. */
+interface AgentInvalidationCount {
+    kind: StaleKind;
+    /** The application guard's reason code. */
+    reasonCode: string;
+    /** True when the proposal closed right before execution, after its approval. */
+    afterApproval: boolean;
+    count: number;
+}
+/** Response of `GET admin/agents/{id}/feedback/summary`. */
+interface AgentFeedbackSummary {
+    agentId: string;
+    from: string;
+    /** Exclusive end of the period. */
+    to: string;
+    rows: AgentFeedbackSummaryRow[];
+}
+/** One feedback with the proposal it is about, as approvers read it. */
+interface AgentFeedbackItem {
+    id: string;
+    approvalId: string;
+    proposalId: string;
+    conversationId: string;
+    runId: string | null;
+    scopeKey: string;
+    subjectType: string;
+    subjectId: string;
+    subjectDisplayName: string | null;
+    toolId: string;
+    agentVersion: number | null;
+    /** The proposal's status when the feedback was given. */
+    approvalStatus: AgentProposalStatus;
+    /** The proposal's summary as the agent recorded it. */
+    summary: string;
+    presentation: ApprovalPresentation | null;
+    category: AgentProposalFeedbackCategory;
+    group: AgentProposalFeedbackGroup;
+    text: string | null;
+    authorActorId: string;
+    /**
+     * The name of `authorActorId` from the member snapshots; `null` when no snapshot knows the
+     * person. Show `authorActorId` then. Missing on older servers.
+     */
+    authorDisplayName?: string | null;
+    bulk: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Response of `GET admin/agents/{id}/feedback`, newest change first. */
+interface AgentFeedbackList {
+    items: AgentFeedbackItem[];
+    total: number;
+}
 
 /** Decides whether the current user may see and use the assistant. */
 interface NhAssistantAccessPolicy {
@@ -432,6 +962,29 @@ interface NhAssistantConfig {
      * `inject(...)`, for example `() => inject(MyAuthService).getAuthorization()?.token ?? null`.
      */
     getAccessToken: () => string | null | Promise<string | null>;
+    /**
+     * Returns extra headers for every assistant request, for example the NewHeap active division:
+     * `() => ({ 'X-NH-ActiveDivisionId': inject(MyAuthService).getAuthorization()?.activeDivision?.id ?? '' })`.
+     * Runs in the assistant's injection context before every request, like `getAccessToken`, and
+     * when the live-update connection starts. `Authorization`, `Accept`, `Accept-Language` and
+     * `Content-Type` stay under the library's control, and empty values are left out. Browsers send
+     * no custom headers with the WebSocket and server-sent event transports of the live connection;
+     * pass what the hub needs with `getHubQueryParameters`. Default: none.
+     */
+    getRequestHeaders?: () => Record<string, string> | null | Promise<Record<string, string> | null>;
+    /**
+     * Returns query parameters for the live-update hub URL: the values the hub needs that browsers
+     * cannot send as headers, because the WebSocket and server-sent event transports carry none.
+     * Without them a hub that requires such a value refuses those transports and the connection
+     * falls back to long polling. For example the NewHeap active division, which the platform's JWT
+     * handler copies from `divisionId` to `X-NH-ActiveDivisionId` on `/hub` paths:
+     * `() => ({ divisionId: inject(MyAuthService).getAuthorization()?.activeDivision?.id ?? '' })`.
+     * Runs in the assistant's injection context each time the connection starts. `access_token`,
+     * `id` and `negotiateVersion` stay under the control of the library and SignalR, empty values
+     * are left out and a failing getter only leaves the parameters out. Never return a secret: URLs
+     * appear in server and proxy logs. Default: none.
+     */
+    getHubQueryParameters?: () => Record<string, string> | null | Promise<Record<string, string> | null>;
     /**
      * Returns what the user has open, sent with each message as untrusted page context.
      * Runs in the assistant's injection context when the panel opens and before every
@@ -658,11 +1211,106 @@ declare class NhAssistantAdminApiService {
     syncMcpServer(serverId: string): Observable<McpTool[]>;
     getMcpTools(serverId: string): Observable<McpTool[]>;
     updateMcpTool(serverId: string, remoteName: string, request: UpdateMcpToolRequest): Observable<McpTool>;
+    /**
+     * The agent's proposals per tool and agent version in the period: decisions, the rejection rate,
+     * feedback per category and the number of different people who gave it.
+     */
+    getAgentFeedbackSummary(agentId: string, filter?: AgentFeedbackFilter): Observable<AgentFeedbackSummary>;
+    /** The feedback on the agent's proposals with the proposal as approvers read it, newest change first. */
+    getAgentFeedback(agentId: string, filter?: AgentFeedbackListFilter): Observable<AgentFeedbackList>;
+    /**
+     * Downloads the feedback as JSON Lines with the tool input of each proposal. The file holds
+     * subject data and the server audits the export. Rejects with `NhAssistantApiError`.
+     */
+    exportAgentFeedback(agentId: string, filter?: AgentFeedbackExportFilter): Promise<Blob>;
     private request;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAdminApiService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantAdminApiService>;
 }
 
+/**
+ * Client for the agent-run endpoints: the agent thread about a subject, its runs, proposals,
+ * working memory and artifacts, and the approval inbox. Access follows the caller's role on the
+ * subject, which the server checks on every request; failures error with `NhAssistantApiError`.
+ */
+declare class NhAssistantAgentRunApiService {
+    private readonly transport;
+    /** The agent's thread about the subject, the caller's role and whether the caller may start the agent. */
+    getThread(agentId: string, subjectType: string, subjectId: string): Observable<AgentThreadLookup>;
+    /**
+     * The agent's thread about the subject, created without starting a run when it is missing, so
+     * the caller can open the conversation and type there. Creating a thread needs the participant
+     * role; readers may open an existing one. Errors with `assistant-subject-access-denied` otherwise.
+     */
+    openThread(agentId: string, subjectType: string, subjectId: string): Observable<AgentThreadLookup>;
+    /** Starts the agent on the subject with the caller as initiator; needs the participant role. */
+    startAgent(request: StartAgentRequest): Observable<AgentTriggerReceipt>;
+    /**
+     * All agent work on one subject: the caller's role, every agent with a thread on it plus
+     * `agentId`, and the open proposals of all of them with the caller's live decision right. Errors
+     * with `assistant-subject-not-found` when the caller has no role on the subject.
+     */
+    getSubjectWork(subjectType: string, subjectId: string, agentId?: string): Observable<AgentSubjectWork>;
+    /**
+     * Counts the agent work on at most `NH_ASSISTANT_MAX_SUBJECT_SUMMARY` subjects of one type in one
+     * request, for badges in a list; one item per id in request order. `NhAssistantSubjectSummaryService`
+     * batches and caches these requests for many badges.
+     */
+    summarizeSubjects(subjectType: string, subjectIds: readonly string[]): Observable<AgentSubjectSummaryList>;
+    getRuns(conversationId: string): Observable<AgentRunList>;
+    /** Who consulted the thread's agent through another assistant, newest first. */
+    getConsultations(conversationId: string, page?: number, itemsPerPage?: number): Observable<AgentConsultationList>;
+    getProposals(conversationId: string): Observable<AgentProposal[]>;
+    /**
+     * One proposal of an agent thread in any status, with the caller's live right to decide it, for
+     * example the one an `AgentWorkChanged` update names. Fails with `assistant-approval-not-found`
+     * for an unknown proposal and for one the caller may not see.
+     */
+    getProposal(approvalId: string): Observable<AgentSubjectWorkProposal>;
+    /**
+     * The proposals among at most `NH_ASSISTANT_MAX_PROPOSAL_LOOKUP` ids that the caller may see, in
+     * the order of the ids, each with the caller's live right to decide it. The others are left out.
+     */
+    lookupProposals(approvalIds: readonly string[]): Observable<AgentProposalLookup>;
+    getMemory(conversationId: string): Observable<AgentThreadMemory>;
+    getArtifacts(conversationId: string): Observable<AgentArtifact[]>;
+    /** Downloads one artifact version with the host's credentials. */
+    downloadArtifact(conversationId: string, artifactId: string): Promise<Blob>;
+    /** Cancels a run at its next safe point and withdraws its open proposals; needs the participant role. */
+    cancelRun(runId: string): Observable<void>;
+    /** Resumes or restarts a failed or cancelled run; needs the approver role. */
+    retryRun(runId: string, mode: AgentRunRetryMode): Observable<AgentTriggerReceipt>;
+    /** Pending proposals the caller may decide, sorted by expiry. */
+    getInbox(filter?: AgentInboxFilter): Observable<AgentInbox>;
+    /**
+     * Decides one proposal, bound to the proposal hash the person saw; the server checks the approval
+     * policy and the tool's approve policy again. Accepts an inbox proposal or the approval part of an
+     * agent thread.
+     */
+    decide(proposal: Pick<AgentProposal, 'approvalId' | 'proposalHash'>, decision: AgentProposalDecision, reason?: string): Observable<AgentProposal>;
+    /** Decides several proposals; each one is checked and decided on its own. */
+    decideMany(approvalIds: string[], decision: AgentProposalDecision, reason?: string): Observable<{
+        results: AgentDecisionOutcome[];
+    }>;
+    /** Resolves an execution whose outcome is unknown. */
+    resolve(approvalId: string, action: AgentExecutionResolution, reason?: string): Observable<AgentProposal>;
+    /**
+     * Gives or changes the caller's feedback on a closed proposal (`canGiveFeedback`). Feedback is
+     * optional and separate from the decision; an empty text is sent as `null`. Fails with
+     * `assistant-feedback-not-accepted` while the proposal is pending or after it was approved.
+     */
+    giveFeedback(approvalId: string, category: AgentProposalFeedbackCategory, text?: string | null): Observable<AgentProposalFeedback>;
+    /**
+     * Gives the same feedback on at most `NH_ASSISTANT_MAX_BULK_FEEDBACK` proposals that were
+     * rejected together. Each proposal is checked on its own and stored as bulk feedback.
+     */
+    giveFeedbackMany(approvalIds: readonly string[], category: AgentProposalFeedbackCategory, text?: string | null): Observable<{
+        results: AgentFeedbackOutcome[];
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentRunApiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantAgentRunApiService>;
+}
+
 /**
  * Applies one assistant event to a conversation and returns the new conversation.
  * The input is never mutated, so the result can be stored in a signal directly.
@@ -707,9 +1355,10 @@ declare function describeNhAssistantClientContext(context: ClientContext): strin
 
 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.
+ * Live updates of the assistant hub: conversation changes, read positions, removals, the turn
+ * events of other sessions and changes to the work of agents that run on their own. 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;
@@ -719,6 +1368,7 @@ declare class NhAssistantLiveService {
     private readonly readSubject;
     private readonly removedSubject;
     private readonly eventSubject;
+    private readonly agentWorkSubject;
     private readonly resyncSubject;
     private readonly stateSignal;
     private connection?;
@@ -730,6 +1380,11 @@ declare class NhAssistantLiveService {
     readonly read$: Observable<LiveConversationRead>;
     readonly removed$: Observable<LiveConversationRemoved>;
     readonly events$: Observable<LiveConversationEvent>;
+    /**
+     * A run, proposal or feedback of an agent thread changed. It carries no content; components
+     * that show the thread reload it.
+     */
+    readonly agentWork$: Observable<LiveAgentWorkChanged>;
     /** Reload snapshots: emitted after every (re)connect. */
     readonly resync$: Observable<void>;
     readonly state: _angular_core.Signal<NhAssistantLiveState>;
@@ -745,6 +1400,11 @@ declare class NhAssistantLiveService {
     /** Starts over after the automatic reconnect gave up or the first start failed. */
     private scheduleRestart;
     private token;
+    /**
+     * The hub URL with the host's `getHubQueryParameters`, which reach the hub on every transport,
+     * unlike headers on WebSockets and server-sent events.
+     */
+    private withQueryParameters;
     /** `hubBaseUrl` + `hubPath`, or the hub path on the origin of `apiBaseUrl`. */
     private resolveUrl;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantLiveService, never>;
@@ -770,6 +1430,25 @@ interface NhAssistantQueuedMessage {
 }
 /** 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";
+/**
+ * Who decides an approval the current user cannot decide: `turn`, the person whose turn created
+ * it in a chat; `approver`, an approver of the agent thread's subject; `other-approver`, another
+ * approver, because the current user started the work and four-eyes applies.
+ */
+type NhAssistantApprovalWaitingFor = 'turn' | 'approver' | 'other-approver';
+/** The current user's right to decide, or to give feedback on, one approval of the open conversation. */
+interface NhAssistantApprovalRight {
+    canDecide: boolean;
+    /** Who decides when the current user cannot. */
+    waitingFor: NhAssistantApprovalWaitingFor;
+    /** Name of the person who decides a `turn` approval; `null` when unknown. */
+    decisionOwner: string | null;
+    /**
+     * True for an agent's proposal the current user rejected in this session, so the approval card
+     * offers the optional feedback question. Chat approvals never offer feedback.
+     */
+    canGiveFeedback?: boolean;
+}
 /**
  * A conversation that needs attention outside the open thread: a turn runs, an approval waits or
  * there is something unread.
@@ -794,6 +1473,7 @@ declare function nhAssistantIsUnread(summary: Pick<ConversationSummary, 'status'
  */
 declare class NhAssistantStore {
     private readonly api;
+    private readonly agentRuns;
     private readonly config;
     private readonly injector;
     private readonly accessPolicy;
@@ -826,9 +1506,13 @@ declare class NhAssistantStore {
     private readonly queueDispatchState;
     private readonly steeringState;
     private readonly submittingState;
+    /** Agent proposals the current user rejected in this session and may give feedback on. */
+    private readonly feedbackApprovalsState;
     private destroyed;
     private readonly streams;
     private readonly cancelTimers;
+    /** Pending reloads of agent threads after live agent-work updates, per conversation. */
+    private readonly agentWorkTimers;
     private readonly pendingSendResolves;
     private readonly markingRead;
     private readonly liveSubscription;
@@ -889,7 +1573,20 @@ declare class NhAssistantStore {
     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. */
+    /** True when the open conversation is the durable thread of an agent about a subject. */
+    readonly isAgentThread: _angular_core.Signal<boolean>;
+    /**
+     * The current user's right to decide each pending approval of the open conversation, by approval
+     * id. In a chat only the author of the waiting turn decides. In an agent thread the subject's
+     * approvers decide, as the server reports per proposal: the approval policy, four-eyes and the
+     * tool's approve policy, checked live. Proposals the user rejected in this session carry
+     * `canGiveFeedback`.
+     */
+    readonly approvalRights: _angular_core.Signal<ReadonlyMap<string, NhAssistantApprovalRight>>;
+    /**
+     * True when the current user may decide the pending approval: in a chat it belongs to their own
+     * turn, in an agent thread the server allows them as an approver.
+     */
     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>;
@@ -937,8 +1634,19 @@ declare class NhAssistantStore {
     steerQueuedMessage(id: string): Promise<void>;
     private dispatchQueued;
     private sendMessage;
-    /** Approves or rejects the pending approval. Ignores repeated calls while a decision is in flight. */
-    decide(decision: ApprovalDecision, reason?: string): void;
+    /**
+     * Approves or rejects an approval of the open conversation: `approvalId`, or the pending approval
+     * when it is left out. A proposal of an agent's run is decided with its proposal hash through the
+     * agent-run endpoint; other approvals resume their turn as a stream. Ignores calls the current
+     * user may not make and repeated calls while a decision is in flight.
+     */
+    decide(decision: ApprovalDecision, reason?: string, approvalId?: string): void;
+    /**
+     * Decides a proposal of an agent's run with `POST approvals/{id}/decisions`. An approved deferred
+     * proposal executes later as a background operation; an inline one wakes the waiting run. The
+     * reloaded snapshot shows the outcome and the proposals that remain open.
+     */
+    private decideProposal;
     /** Asks the server to stop the running turn or to abandon a waiting approval of the open conversation. */
     cancel(): Promise<void>;
     private cancelConversation;
@@ -991,6 +1699,13 @@ declare class NhAssistantStore {
     private onLiveRead;
     private onLiveRemoved;
     private onLiveEvent;
+    /**
+     * A run or proposal of an agent thread changed, for example a colleague decided a proposal in the
+     * inbox: reload the thread when this tab has it open, so its approval cards show the decision.
+     * A burst of updates reloads once. Feedback does not change the thread.
+     */
+    private onLiveAgentWork;
+    private clearAgentWorkTimers;
     /** After a reconnect: updates sent while disconnected are lost, so reload what is shown. */
     private resync;
     private scheduleRefresh;
@@ -1083,6 +1798,7 @@ declare const NH_ASSISTANT_PANEL_MOBILE_QUERY = "(max-width: 599.98px)";
 declare class NhAssistantPanelService {
     private readonly overlay;
     private readonly store;
+    private readonly agentRuns;
     private readonly injector;
     private readonly document;
     private readonly breakpoints;
@@ -1094,6 +1810,20 @@ declare class NhAssistantPanelService {
     readonly isOpen: Signal<boolean>;
     constructor();
     open(conversationId?: string): void;
+    /**
+     * Opens the panel on the conversation with an agent about a subject, for example the intake
+     * reviewer about one project. The server returns the agent's thread about the subject and creates
+     * it without starting a run when it is missing; people then type in the conversation, which runs
+     * a turn. Creating needs the participant role, readers may open an existing thread.
+     *
+     * Resolves with the lookup once the panel opens the conversation. A failure, such as
+     * `assistant-subject-access-denied`, rejects with `NhAssistantApiError` and leaves the panel as
+     * it is, so the caller shows the localized `messageKey` where the person asked.
+     */
+    openSubject(agentId: string, subject: {
+        type: string;
+        id: string;
+    }): Promise<AgentThreadLookup>;
     private showPanel;
     close(): void;
     toggle(): void;
@@ -1108,6 +1838,62 @@ declare class NhAssistantPanelService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantPanelService>;
 }
 
+/**
+ * Counts of agent work per subject for badges in lists and on pages. Every summary asked for in the
+ * same tick becomes one `POST subjects/{type}/summary` per subject type, in chunks of
+ * `NH_ASSISTANT_MAX_SUBJECT_SUMMARY`. Results are cached per subject and shared by everyone who
+ * shows it. Live agent-work updates refetch only the subjects they name, batched; a reconnect of
+ * the hub refetches every subject shown. Nothing is requested on the server or while the assistant
+ * is disabled or denied, and the cache clears when it becomes unavailable, for example on sign-out.
+ */
+declare class NhAssistantSubjectSummaryService {
+    private readonly api;
+    private readonly store;
+    private readonly live;
+    private readonly browser;
+    private readonly entries;
+    /** Subject ids per type that wait for the next request. */
+    private readonly queue;
+    /** Subjects named by live updates that wait for the end of the burst. */
+    private readonly changed;
+    private requests;
+    private readonly liveSubscription;
+    private flushScheduled;
+    private changedTimer?;
+    private requestRevision;
+    private destroyed;
+    constructor();
+    /**
+     * The agent work on one subject: `null` until it is known, then every update. Subscribing shows
+     * the subject; summaries of subjects that are shown stay current with live updates. The request
+     * starts in the next microtask, together with every other summary asked for until then.
+     */
+    summary(subjectType: string, subjectId: string): Observable<AgentSubjectSummary | null>;
+    /**
+     * Fetches the summaries of these subjects again, or of every subject of the type that is shown,
+     * for example after the application changed them without an agent.
+     */
+    refresh(subjectType: string, subjectIds?: readonly string[]): void;
+    private watch;
+    private unwatch;
+    private isCurrent;
+    /** Drops a summary nobody shows; the next subscriber fetches it again. */
+    private forget;
+    private enqueue;
+    private scheduleFlush;
+    /** Sends the queued subjects: one request per type and chunk. Waits while the assistant is unavailable. */
+    private flush;
+    private send;
+    private onAgentWork;
+    /** Refetches the shown subjects of a burst of live updates, together. */
+    private refetchChanged;
+    /** After a reconnect updates may have been missed: refetch what is shown, forget the rest. */
+    private refetchShown;
+    private onAvailabilityChanged;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantSubjectSummaryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NhAssistantSubjectSummaryService>;
+}
+
 /** 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>`. */
@@ -1149,6 +1935,79 @@ declare class NhAssistantLauncherComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantLauncherComponent, "nh-assistant-launcher", never, {}, {}, never, ["*"], true, never>;
 }
 
+/** A decision about one approval of the thread. */
+interface NhAssistantApprovalChoice {
+    approvalId: string;
+    decision: ApprovalDecision;
+}
+/** Above this number of messages the thread renders through CDK virtual scrolling. */
+declare const NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD = 200;
+/**
+ * The messages of a conversation as a live log. Assistant text renders as sanitized
+ * Markdown, consecutive tool calls as one collapsible group that counts along, and
+ * approvals as cards. Messages a trigger wrote into an agent thread read as events, not as
+ * a person. 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;
+    readonly messages: _angular_core.InputSignal<readonly Message[]>;
+    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>;
+    /**
+     * Who may decide each pending approval, by approval id, for example `NhAssistantStore.approvalRights`.
+     * An agent thread can hold several open proposals that the subject's approvers decide. Approvals
+     * without an entry use `canDecide` and `decisionOwner`. An entry with `canGiveFeedback` lets the
+     * card of a rejected proposal ask what was wrong.
+     */
+    readonly approvalRights: _angular_core.InputSignal<ReadonlyMap<string, NhAssistantApprovalRight> | null>;
+    /** The decision about an approval card, without the approval it belongs to. */
+    readonly approvalDecision: _angular_core.OutputEmitterRef<ApprovalDecision>;
+    /** The decision about an approval card together with its approval id. */
+    readonly approvalChoice: _angular_core.OutputEmitterRef<NhAssistantApprovalChoice>;
+    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 a trigger wrote into an agent thread. */
+    isTrigger(message: Message): boolean;
+    /** True for an assistant message the agent's rules wrote without a model. */
+    isRule(message: Message): boolean;
+    /** True for a user message written by another person in a shared conversation. */
+    isOthers(message: Message): boolean;
+    /** Whether and why the current user may decide an approval card. */
+    rightFor(approval: ApprovalPart): NhAssistantApprovalRight;
+    choose(approval: ApprovalPart, decision: ApprovalDecision): void;
+    /** 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; }; "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; }; "approvalRights": { "alias": "approvalRights"; "required": false; "isSignal": true; }; }, { "approvalDecision": "approvalDecision"; "approvalChoice": "approvalChoice"; }, never, never, true, never>;
+}
+
 /**
  * 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. It opens
@@ -1215,6 +2074,8 @@ declare class NhAssistantPanelComponent implements AfterViewInit, OnDestroy {
      */
     private openFromLocation;
     decide(decision: ApprovalDecision): void;
+    /** Decides the approval of a card; in an agent thread several proposals can be open. */
+    decideApproval(choice: NhAssistantApprovalChoice): void;
     cancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantPanelComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantPanelComponent, "nh-assistant-panel", never, {}, {}, never, never, true, never>;
@@ -1241,56 +2102,6 @@ declare class NhAssistantConversationListComponent {
     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>;
 }
 
-/** Above this number of messages the thread renders through CDK virtual scrolling. */
-declare const NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD = 200;
-/**
- * The messages of a conversation as a live log. Assistant text renders as sanitized
- * 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;
-    readonly messages: _angular_core.InputSignal<readonly Message[]>;
-    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; }; "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>;
-}
-
 /**
  * Message input. Enter sends when sending is available; Shift+Enter inserts a new line.
  * Drafting remains available while the assistant runs or waits for approval.
@@ -1351,8 +2162,12 @@ 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';
+/**
+ * Overall state of a run of tool calls, from most to least urgent. `not-executed` means that every
+ * call finished and at least one ended without running, because its proposal expired, was
+ * withdrawn or became stale.
+ */
+type NhAssistantToolCallGroupState = 'awaiting-approval' | 'running' | 'failed' | 'not-executed' | '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
@@ -1367,6 +2182,8 @@ declare class NhAssistantToolCallGroupComponent {
     readonly total: _angular_core.Signal<number>;
     readonly finished: _angular_core.Signal<number>;
     readonly failed: _angular_core.Signal<number>;
+    /** Calls that finished without running; they never wait. */
+    readonly notExecuted: _angular_core.Signal<number>;
     readonly state: _angular_core.Signal<NhAssistantToolCallGroupState>;
     readonly stateIcon: _angular_core.Signal<NhAssistantIconName>;
     toggle(): void;
@@ -1379,33 +2196,130 @@ declare function formatNhAssistantCountdown(milliseconds: number): string;
 /**
  * Asks the user to approve or reject a proposed mutation. Shows the summary, targets,
  * proposed arguments and a countdown to expiry. A decision is emitted at most once until
- * the host reports that it is no longer deciding.
+ * the host reports that it is no longer deciding. After the user rejected an agent's proposal
+ * (`canGiveFeedback`), a low-key action asks what was wrong. A proposal that closed because it no
+ * longer fits shows why, such as "Already done", with the application's explanation.
  */
 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.
+     * False when the current user may not decide: in a chat the approval belongs to another
+     * participant's turn, in an agent thread the user is no approver of the proposal.
      */
     readonly canDecide: _angular_core.InputSignal<boolean>;
-    /** Name of the participant who decides, shown when the current user cannot. */
+    /** Name of the participant who decides a `turn` approval, shown when the current user cannot. */
     readonly decisionOwner: _angular_core.InputSignal<string | null>;
+    /**
+     * Who decides when the current user cannot: the author of the turn (`turn`, the default), an
+     * approver of the agent thread's subject (`approver`), or another approver because the current
+     * user started the work (`other-approver`).
+     */
+    readonly waitingFor: _angular_core.InputSignal<NhAssistantApprovalWaitingFor>;
+    /**
+     * True when the current user rejected this agent proposal and may say what was wrong, for example
+     * from `NhAssistantStore.approvalRights`. Chat approvals never offer feedback.
+     */
+    readonly canGiveFeedback: _angular_core.InputSignal<boolean>;
     readonly decide: _angular_core.OutputEmitterRef<ApprovalDecision>;
     private readonly now;
     private readonly submitted;
+    /** The feedback question is expanded. */
+    readonly feedbackOpen: _angular_core.WritableSignal<boolean>;
+    /** The feedback was stored; the question thanks the person and the action disappears. */
+    readonly feedbackSaved: _angular_core.WritableSignal<boolean>;
+    private readonly feedbackToggle;
     readonly remainingMs: _angular_core.Signal<number>;
     readonly expired: _angular_core.Signal<boolean>;
     readonly effectiveStatus: _angular_core.Signal<ApprovalStatus>;
+    /**
+     * Translation key of the status: the kind of a stale proposal, "replaced" for a superseded one,
+     * otherwise the status itself.
+     */
+    readonly statusKey: _angular_core.Signal<string>;
+    /** Why the agent's rules proposed it; model proposals have none. */
+    readonly rationale: _angular_core.Signal<string | null>;
+    /** The application's explanation of a stale proposal, such as who already did the work. */
+    readonly staleExplanation: _angular_core.Signal<string | null>;
     readonly actionable: _angular_core.Signal<boolean>;
+    readonly succeeded: _angular_core.Signal<boolean>;
     readonly disabled: _angular_core.Signal<boolean>;
     readonly countdown: _angular_core.Signal<string>;
     readonly presentedSummary: _angular_core.Signal<string | null>;
+    readonly feedbackAvailable: _angular_core.Signal<boolean>;
+    readonly feedbackIds: _angular_core.Signal<string[]>;
+    readonly feedbackPanelId: string;
+    /** Translation key of the text shown instead of the buttons when the current user cannot decide. */
+    readonly waitingKey: _angular_core.Signal<"nh-assistant.approval.waiting-for-approver" | "nh-assistant.approval.waiting-for-other-approver" | "nh-assistant.approval.waiting-for" | "nh-assistant.approval.waiting-for-participant">;
     constructor();
     choose(decision: ApprovalDecision): void;
+    toggleFeedback(): void;
+    onFeedbackSaved(): void;
+    /** Collapses the question and returns focus to the action that opened it. */
+    onFeedbackDismissed(): 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; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionOwner": { "alias": "decisionOwner"; "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; }; "waitingFor": { "alias": "waitingFor"; "required": false; "isSignal": true; }; "canGiveFeedback": { "alias": "canGiveFeedback"; "required": false; "isSignal": true; }; }, { "decide": "decide"; }, never, never, true, never>;
+}
+
+/** What `nh-assistant-proposal-feedback` stored. */
+interface NhAssistantProposalFeedbackSaved {
+    /** The proposals whose feedback the server stored. */
+    approvalIds: string[];
+    category: AgentProposalFeedbackCategory;
+    text: string | null;
+}
+/**
+ * Asks, after a rejection, what was wrong with one or more agent proposals: a category from a fixed
+ * set and an optional text. It is optional and never blocks the decision; people skip it with one
+ * action. One proposal is sent with `PUT approvals/{id}/feedback`, several rejected together with
+ * `POST approvals/feedback` as bulk feedback. With `initial` it changes the caller's own feedback.
+ * After saving it thanks the person in place of the form; hosts remove it after `dismissed`.
+ */
+declare class NhAssistantProposalFeedbackComponent {
+    private readonly api;
+    private readonly host;
+    private readonly document;
+    private readonly injector;
+    private readonly thanks;
+    private subscription?;
+    /** The proposals the feedback is about; several when they were rejected together. */
+    readonly approvalIds: _angular_core.InputSignal<readonly string[]>;
+    /** The caller's current feedback, to change it; `null` for new feedback. */
+    readonly initial: _angular_core.InputSignal<AgentProposalFeedback | null>;
+    /** Emits after the server stored the feedback. */
+    readonly saved: _angular_core.OutputEmitterRef<NhAssistantProposalFeedbackSaved>;
+    /** Emits when the person skips the question. */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    readonly id: string;
+    readonly categories: readonly AgentProposalFeedbackCategory[];
+    readonly maxText = 1000;
+    /** A new question when the host passes other proposals or other initial feedback. */
+    private readonly question;
+    readonly category: _angular_core.WritableSignal<AgentProposalFeedbackCategory | null>;
+    readonly text: _angular_core.WritableSignal<string>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly done: _angular_core.WritableSignal<boolean>;
+    /** Set when a bulk request stored the feedback for only part of the proposals. */
+    readonly partial: _angular_core.WritableSignal<{
+        stored: number;
+        total: number;
+    } | null>;
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly errorKeys: _angular_core.Signal<string[]>;
+    readonly count: _angular_core.Signal<number>;
+    readonly textLength: _angular_core.Signal<number>;
+    readonly tooLong: _angular_core.Signal<boolean>;
+    readonly canSend: _angular_core.Signal<boolean>;
+    constructor();
+    choose(category: AgentProposalFeedbackCategory): void;
+    onText(event: Event): void;
+    dismiss(): void;
+    send(): void;
+    /** One proposal through its own endpoint; several in requests of at most the bulk limit. */
+    private request;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantProposalFeedbackComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantProposalFeedbackComponent, "nh-assistant-proposal-feedback", never, { "approvalIds": { "alias": "approvalIds"; "required": true; "isSignal": true; }; "initial": { "alias": "initial"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "dismissed": "dismissed"; }, never, never, true, never>;
 }
 
 /**
@@ -1533,6 +2447,30 @@ declare class NhAssistantActivityComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantActivityComponent, "nh-assistant-activity", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; }, { "conversationSelect": "conversationSelect"; }, never, never, true, never>;
 }
 
+/**
+ * A compact count of the agent work on one subject, for example on each row of a project list.
+ * It shows nothing while the subject has no work. Otherwise it shows the number of proposals the
+ * viewer may decide in the accent color, or, when they may decide none, a neutral count of the
+ * open proposals, and a small working indicator while an agent works on the subject. Its tooltip
+ * and accessible name say both counts. Badges on one page share one summary request per tick and
+ * refresh on live agent-work updates of their subject; see `NhAssistantSubjectSummaryService`.
+ */
+declare class NhAssistantSubjectBadgeComponent {
+    private readonly summaries;
+    private readonly summary;
+    /** The application's kind of subject, for example `project`. */
+    readonly subjectType: _angular_core.InputSignal<string>;
+    readonly subjectId: _angular_core.InputSignal<string>;
+    /** The summary while the subject has work to show; `null` otherwise. */
+    readonly work: _angular_core.Signal<AgentSubjectSummary | null>;
+    readonly count: _angular_core.Signal<number>;
+    readonly countLabel: _angular_core.Signal<string>;
+    readonly proposalsKey: _angular_core.Signal<"nh-assistant.subject-badge.to-decide" | "nh-assistant.subject-badge.open" | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantSubjectBadgeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantSubjectBadgeComponent, "nh-assistant-subject-badge", never, { "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "subjectId": { "alias": "subjectId"; "required": true; "isSignal": true; }; }, {}, 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
@@ -1551,6 +2489,14 @@ declare class NhAssistantTranslatePipe implements PipeTransform {
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<NhAssistantTranslatePipe, "nhAssistantTranslate", true>;
 }
 
+/**
+ * Calls `reload` once a burst of live agent-work updates that `matches` has settled, and after
+ * every (re)connect of the hub, because updates sent while it was disconnected are lost. Without a
+ * live service or a connected hub nothing arrives and the view keeps its manual refresh. Call it in
+ * an injection context, for example a component constructor; it stops when that context ends.
+ */
+declare function nhAssistantReloadOnAgentWork(matches: (change: LiveAgentWorkChanged) => boolean, reload: () => void): void;
+
 /** Converts any failure into a user-facing code and translation key, never raw text. */
 declare function toNhAssistantError(error: unknown): NhAssistantError;
 /** Translation keys for an error, from the most to the least specific. */
@@ -1558,5 +2504,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_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, NhAssistantQueuedMessage, NhAssistantRawSseMessage, NhAssistantSseEvent, NhAssistantSseEventMap, NhAssistantSseEventType, NhAssistantStatusCodes, NhAssistantToolCallGroupState, NotificationSettings, PushSubscriptionRequest, SendMessageRequest, ShareLink, 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_FEEDBACK_CATEGORIES, NH_ASSISTANT_FEEDBACK_GROUPS, NH_ASSISTANT_FETCH, NH_ASSISTANT_ICONS, NH_ASSISTANT_JOIN_FRAGMENT, NH_ASSISTANT_MAX_BULK_FEEDBACK, NH_ASSISTANT_MAX_CUSTOM_INSTRUCTIONS, NH_ASSISTANT_MAX_FEEDBACK_TEXT, NH_ASSISTANT_MAX_PROPOSAL_LOOKUP, NH_ASSISTANT_MAX_SUBJECT_SUMMARY, 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, NhAssistantAgentRunApiService, NhAssistantAllowAllAccessPolicy, NhAssistantApiError, NhAssistantApiService, NhAssistantApprovalCardComponent, NhAssistantClientErrorCodes, NhAssistantComposerComponent, NhAssistantConversationListComponent, NhAssistantLauncherComponent, NhAssistantLiveService, NhAssistantPanelComponent, NhAssistantPanelService, NhAssistantPreferencesComponent, NhAssistantProposalFeedbackComponent, NhAssistantPushService, NhAssistantShareComponent, NhAssistantSseParser, NhAssistantStore, NhAssistantSubjectBadgeComponent, NhAssistantSubjectSummaryService, 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, nhAssistantReloadOnAgentWork as ɵnhAssistantReloadOnAgentWork, toNhAssistantError as ɵtoNhAssistantError };
+export type { AdminAgent, AdminAgentInput, AgentArtifact, AgentConsultation, AgentConsultationList, AgentConsultationStatus, AgentDecisionOutcome, AgentExecutionResolution, AgentFeedbackCategoryCount, AgentFeedbackExportFilter, AgentFeedbackFilter, AgentFeedbackItem, AgentFeedbackList, AgentFeedbackListFilter, AgentFeedbackOutcome, AgentFeedbackSummary, AgentFeedbackSummaryRow, AgentGrantSource, AgentInbox, AgentInboxFilter, AgentInvalidationCount, AgentProposal, AgentProposalDecision, AgentProposalDecisionRight, AgentProposalFeedback, AgentProposalFeedbackCategory, AgentProposalFeedbackGroup, AgentProposalLookup, AgentProposalObject, AgentProposalStatus, AgentRun, AgentRunKind, AgentRunList, AgentRunRetryMode, AgentRunStatus, AgentSubjectRole, AgentSubjectSummary, AgentSubjectSummaryList, AgentSubjectWork, AgentSubjectWorkAgent, AgentSubjectWorkProposal, AgentSummary, AgentThread, AgentThreadLookup, AgentThreadMemory, AgentTriggerReceipt, ApplicationContext, ApplicationContextVersion, ApprovalDecision, ApprovalPart, ApprovalPresentation, ApprovalPresentationField, ApprovalRequiredEvent, ApprovalStatus, AssistantAddressForm, AssistantAutonomy, AssistantCollaboration, AssistantErrorEvent, AssistantPreferences, AssistantResponseLength, AssistantStatus, AssistantStyle, ClientContext, ClientContextEntity, Conversation, ConversationKind, ConversationMember, ConversationPage, ConversationRole, ConversationStatus, ConversationSummary, ConversationThread, ConversationThreadDecision, CreateConversationRequest, DecideApprovalRequest, DirectoryEntry, LiveAgentWorkChanged, LiveAgentWorkReason, LiveConversationChanged, LiveConversationEvent, LiveConversationRead, LiveConversationRemoved, McpAuthMode, McpServer, McpServerInput, McpServerTestResult, McpTool, McpToolEffect, McpToolStatus, Message, MessageAuthorKind, MessageDeltaEvent, MessagePart, NhAssistantAccessPolicy, NhAssistantActivity, NhAssistantApprovalChoice, NhAssistantApprovalRight, NhAssistantApprovalWaitingFor, NhAssistantClientContext, NhAssistantClientErrorCode, NhAssistantConfig, NhAssistantError, NhAssistantFetch, NhAssistantIconName, NhAssistantLiveState, NhAssistantNotice, NhAssistantProposalFeedbackSaved, NhAssistantPushConfig, NhAssistantPushState, NhAssistantQueuedMessage, NhAssistantRawSseMessage, NhAssistantSseEvent, NhAssistantSseEventMap, NhAssistantSseEventType, NhAssistantStatusCodes, NhAssistantToolCallGroupState, NotificationSettings, PushSubscriptionRequest, SendMessageRequest, ShareLink, StaleKind, StartAgentRequest, TextPart, ToolCallPart, ToolCallStatus, ToolCatalogEffect, ToolCatalogEntry, ToolCompletedEvent, ToolStartedEvent, TurnCompletedEvent, TurnCompletionStatus, TurnStartedEvent, TurnUsage, UpdateAdminAgentRequest, UpdateApplicationContextRequest, UpdateMcpToolRequest };