@newheap/platform-ai-chat 0.16.0 → 0.18.0

package/README.md

@@ -148,7 +148,9 @@ caller may decide each one. `NhAssistantStore.approvalRights` turns that into a
 approval card, `decide(decision, reason, approvalId)` decides a run's proposal with its
 proposal hash through `POST approvals/{id}/decisions` and reloads the thread, and cards
 the caller may not decide say who does (`waitingFor`: an approver, or another approver
-under four-eyes). Messages a trigger wrote (`authorKind: 'trigger'`) read as an event.
+under four-eyes). Messages a trigger wrote (`authorKind: 'trigger'`) read as an event, and
+messages the application posted (`role: 'application'`) as the application's, with their sender,
+title, Markdown text and a link within the application or to an `https` address.
 Custom layouts pass `[approvalRights]` to `nh-assistant-thread` and handle
 `(approvalChoice)`, which carries the approval id.
 
@@ -288,6 +290,19 @@ custom layouts. Opened in the panel, the thread offers its proposals to the same
 **Decided by** shows the name from the subject's member snapshot (`decidedByDisplayName`)
 and falls back to the actor id.
 
+The inbox also gives an overview. `divisionId` and `runId` filter it like `agentId` and
+`subjectType`; `[grouped]="true"` groups the proposals by the parent the server recorded for each
+proposal's subject (such as a project for its tasks) and by subject, `[groupByRun]="true"` also by
+run. A group says how many of its proposals the page shows and whether it continues on another page,
+and "Select group" selects only the shown proposals the person may decide. Proposals made since the
+person's last visit of the inbox are marked new, and showing the inbox records the visit (`markNew`
+and `recordVisit`, both on by default; turn `recordVisit` off for an inbox that shows only part of
+it). `nh-assistant-run-result` lets its reader decide the run's proposals together.
+
+```html
+<nh-assistant-agent-inbox [grouped]="true" [groupByRun]="true" [divisionId]="activeDivisionId" />
+```
+
 Subjects show the name of their type (`subjectTypeName`, such as "Project") and link to where
 the application shows them (`subjectLink`, from the server's `AddSubjectType(...).OpenAt(...)`).
 A link within the application navigates through the router; an `https` link leaves it. Replace
@@ -315,6 +330,14 @@ run for the whole application instead of a set of objects (sent as `subjectSet:
 division for an agent that works per division); the trigger list names it, and subject links name the
 whole application (`nh-system`, `isSystem` in the run catalog) once.
 
+An agent's run configuration lists its consultations: those in code read only, and those defined as
+data, which administrators add, change and remove within the agent's `consultationCeiling`
+(`saveDataConsultation`, `removeDataConsultation`), with only the routes, requests and limits that
+ceiling and the agent allow. Each consultation names the agents that ask it, with a link to their
+editors, and its problems; the route switches turn a route off for all consultations of the agent, and
+the flow's "When it runs" step names them. The mock API plays them with the scenario's
+`consultationsAsData`, an agent's `consultableAsData` and its `dataConsultations`.
+
 With live updates the inbox, the thread view and its tabs reload by themselves when the hub
 reports `AgentWorkChanged` for work they show, debounced, and after every reconnect. The
 update names the thread, its subject (`subjectType`, `subjectId`) and whether a run, a

package/admin/index.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { OnInit } from '@angular/core';
 import * as _newheap_platform_ai_chat from '@newheap/platform-ai-chat';
-import { NhAssistantStore, NhAssistantError, ApplicationContext, ApplicationContextVersion, AdminAgent, ToolCatalogEntry, McpServer, RunCatalog, SetAgentStateRequest, AgentSkillState, AgentShadowMode, AgentShadowState, AssistantAutonomy, AssistantDataClassification, AgentEvaluation, AgentReplay, AgentEvaluationCost, AgentProposalFeedbackCategory, AgentFeedbackSummaryRow, AgentFeedbackItem, AgentFeedbackCategoryCount, StaleKind, AgentProposalFeedbackGroup, AgentSubjectType, AgentRunStatus, ɵnhAssistantCodeKeys as _nhAssistantCodeKeys, AgentRunHistoryItem, DataSkill, AgentRunConfiguration, DataTrigger, SkillComparison, DataSkillVersion, ɵNhAssistantPickerOption as _NhAssistantPickerOption, McpServerTestResult, McpConnectionsSummary, McpBuiltInAuthMode, McpCustomAuthMode, McpAuthMode, McpTransport, McpConnectionScope, McpHeadlessUse, McpDiscovery, McpTool, McpToolEffect } from '@newheap/platform-ai-chat';
+import { NhAssistantStore, NhAssistantError, ApplicationContext, ApplicationContextVersion, AdminAgent, ToolCatalogEntry, McpServer, RunCatalog, SetAgentStateRequest, AgentSkillState, AgentShadowMode, AgentShadowState, AssistantAutonomy, AssistantDataClassification, AgentEvaluation, AgentReplay, AgentEvaluationCost, AgentProposalFeedbackCategory, AgentFeedbackSummaryRow, AgentFeedbackItem, AgentFeedbackCategoryCount, StaleKind, AgentProposalFeedbackGroup, AgentSubjectType, AgentRunStatus, ɵnhAssistantCodeKeys as _nhAssistantCodeKeys, AgentRunHistoryItem, NhAssistantConsultationRoute, DataConsultation, CodeConsultation, DataSkill, AgentRunConfiguration, DataTrigger, SkillComparison, DataSkillVersion, ɵNhAssistantPickerOption as _NhAssistantPickerOption, McpServerTestResult, McpConnectionsSummary, McpBuiltInAuthMode, McpCustomAuthMode, McpAuthMode, McpTransport, McpConnectionScope, McpHeadlessUse, McpDiscovery, McpTool, McpToolEffect } from '@newheap/platform-ai-chat';
 import { ɵNhAssistantRunNowAgent as _NhAssistantRunNowAgent } from '@newheap/platform-ai-chat/agent-runs';
 
 type NhAssistantAdminTab = 'context' | 'agents' | 'mcp-servers';
@@ -317,6 +317,12 @@ declare class NhAssistantAdminAgentsComponent {
     onWorkRequested(agent: AdminAgent): void;
     /** The flow of the agent's run configuration opens the editor; saving or cancelling returns there. */
     editFromRunConfiguration(agent: AdminAgent): void;
+    /**
+     * A consultation of the agent's run configuration opens the editor of an agent that asks it, whose
+     * tool selectors are the consultation's second key; saving or cancelling returns to the run
+     * configuration it came from.
+     */
+    askerFromRunConfiguration(agent: AdminAgent, askerId: string): void;
     /** The flow of the agent's run configuration opens its runs; going back returns there. */
     runsFromRunConfiguration(agent: AdminAgent): void;
     /** The flow of an agent in code opens the form that replaces its technical account on its card. */
@@ -325,7 +331,11 @@ declare class NhAssistantAdminAgentsComponent {
     onEditorSaved(agent: AdminAgent): void;
     /** The editor closed without saving: back to the run configuration that opened it, or to the list. */
     onEditorCancelled(): void;
-    /** Opens the run configuration again when its flow opened what closes now; `false` otherwise. */
+    /**
+     * Opens the run configuration again when its flow, or one of its consultations, opened what closes
+     * now; `false` otherwise. The editor of an agent that asks a consultation returns to the consulted
+     * agent's run configuration.
+     */
     private returnToRunConfiguration;
     /** What the agent works on, with its object types named as the run catalog names them. */
     worksOn(agent: AdminAgent): WorksOnSummary & {
@@ -787,6 +797,35 @@ declare class NhAssistantAgentRunHistoryComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentRunHistoryComponent, "nh-assistant-agent-run-history", never, { "agentId": { "alias": "agentId"; "required": true; "isSignal": true; }; "subjectTypes": { "alias": "subjectTypes"; "required": false; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
 }
 
+/** One consultation as the section and the flow list it: in code or defined as data. */
+interface ConsultationRow {
+    subjectType: string;
+    origin: 'code' | 'data';
+    description: string | null;
+    /** The routes in effect: those code allows, or those of the data that still fit. */
+    routes: NhAssistantConsultationRoute[];
+    /** It generates the request tool now. */
+    requests: boolean;
+    /** MCP clients see its tools. */
+    mcp: boolean;
+    consultToolId: string;
+    /** The agents whose tool selectors select its consult tool now. */
+    askingAgents: string[];
+    inEffect: boolean;
+    problems: string[];
+    /** The consultation defined as data; `null` for one in code. */
+    data: DataConsultation | null;
+    code: CodeConsultation | null;
+}
+/**
+ * Why administrators cannot add a consultation to the agent now, or `null` when they can:
+ * `application` when the application does not let them define consultations, `agent` when the agent
+ * is in code and not consultable as data, `needs-settings` while an agent created here has no run
+ * settings, `limit` when it has as many as the ceiling allows, and `no-types` when every kind of
+ * object it works on already has a consultation.
+ */
+type ConsultationsClosed = 'application' | 'agent' | 'needs-settings' | 'limit' | 'no-types';
+
 /**
  * What an entry point of the flow opens: the run configuration opens its own forms; the agent editor,
  * the technical account, the runs view and the MCP servers belong to the page that hosts it.
@@ -805,6 +844,11 @@ type AgentFlowEntry = {
 } | {
     kind: 'edit-trigger';
     triggerId: string;
+} | {
+    kind: 'add-consultation';
+} | {
+    kind: 'edit-consultation';
+    subjectType: string;
 } | {
     kind: 'edit-agent';
 } | {
@@ -815,6 +859,12 @@ type AgentFlowEntry = {
     kind: 'mcp-servers';
 };
 
+/** What a saved consultation form tells its host. */
+interface ConsultationFormSaved {
+    consultation: DataConsultation;
+    added: boolean;
+}
+
 /** What a saved skill form tells its host. */
 interface SkillFormSaved {
     skill: DataSkill;
@@ -823,10 +873,10 @@ interface SkillFormSaved {
     added: boolean;
 }
 
-type Form = 'setup' | 'settings' | 'skill' | 'trigger';
+type Form = 'setup' | 'settings' | 'skill' | 'trigger' | 'consultation';
 /** A removal, promotion or discard that waits for its confirmation. */
 interface Confirmation {
-    action: 'remove-settings' | 'remove-skill' | 'remove-trigger' | 'promote' | 'discard';
+    action: 'remove-settings' | 'remove-skill' | 'remove-trigger' | 'remove-consultation' | 'promote' | 'discard';
     id: string;
 }
 /**
@@ -841,7 +891,11 @@ interface Confirmation {
  * they compare with the live version and promote or discard; they add data triggers on the
  * application's events or on a schedule and put them live; a schedule without a subject set runs for
  * the whole application, or for every division of an agent that works per division. New skills and
- * triggers start in shadow; `changed` tells the agents page to reload the agent's skill states.
+ * triggers start in shadow; `changed` tells the agents page to reload the agent's skill states. Its
+ * consultations (AC20) show what other assistants may consult it about: those in code read only, and
+ * those defined as data, which administrators add, change and remove within the agent's ceiling in
+ * code, each with the agents that ask it (`openAgent` opens the editor of one) and its problems,
+ * followed by the switches that turn a route off for all of its consultations.
  */
 declare class NhAssistantAgentRunConfigurationComponent implements OnInit {
     private readonly admin;
@@ -863,6 +917,8 @@ declare class NhAssistantAgentRunConfigurationComponent implements OnInit {
      * `null` while unknown.
      */
     readonly servers: _angular_core.InputSignal<readonly McpServer[] | null>;
+    /** Every agent of the administration, to name the agents that ask the agent's consultations. */
+    readonly agents: _angular_core.InputSignal<readonly AdminAgent[]>;
     /** A change of the run configuration changed the agent's skills or state. */
     readonly changed: _angular_core.OutputEmitterRef<void>;
     /** The flow asks to open the agent editor: what it works on, its tools, MCP servers and groups. */
@@ -873,6 +929,8 @@ declare class NhAssistantAgentRunConfigurationComponent implements OnInit {
     readonly openRuns: _angular_core.OutputEmitterRef<void>;
     /** The flow asks to open the MCP servers, whose background use decides what runs without a person use. */
     readonly openMcpServers: _angular_core.OutputEmitterRef<void>;
+    /** Opens the editor of an agent that asks one of the agent's consultations, by its id. */
+    readonly openAgent: _angular_core.OutputEmitterRef<string>;
     readonly id: string;
     readonly maxReason: 500;
     readonly skillNameKeys: typeof skillNameKeys;
@@ -910,6 +968,10 @@ declare class NhAssistantAgentRunConfigurationComponent implements OnInit {
     readonly editingSkill: _angular_core.WritableSignal<DataSkill | null>;
     /** The trigger being changed; `null` with the trigger form open adds a new trigger. */
     readonly editingTrigger: _angular_core.WritableSignal<DataTrigger | null>;
+    /** The consultation being changed; `null` with the consultation form open adds a new one. */
+    readonly editingConsultation: _angular_core.WritableSignal<DataConsultation | null>;
+    /** Counts the loads, so the route switches read the agent's routes again after a change. */
+    readonly loads: _angular_core.WritableSignal<number>;
     readonly comparison: _angular_core.WritableSignal<{
         skillId: string;
         result: SkillComparison | null;
@@ -928,6 +990,18 @@ declare class NhAssistantAgentRunConfigurationComponent implements OnInit {
     readonly skillIds: _angular_core.Signal<string[]>;
     readonly triggerIds: _angular_core.Signal<string[]>;
     readonly problems: _angular_core.Signal<_newheap_platform_ai_chat.RunConfigurationProblem[]>;
+    /** The consultations in code and as data, by subject type. */
+    readonly consultationRows: _angular_core.Signal<ConsultationRow[]>;
+    readonly showConsultations: _angular_core.Signal<boolean>;
+    /** The ceiling within which administrators may define the agent's consultations; `null` for none. */
+    readonly consultationCeiling: _angular_core.Signal<_newheap_platform_ai_chat.ConsultationCeiling | null>;
+    /** Why administrators cannot add a consultation now, or `null` when they can. */
+    readonly consultationsClosed: _angular_core.Signal<ConsultationsClosed | null>;
+    /** The subject types the agent already has a consultation about. */
+    readonly consultationTypes: _angular_core.Signal<string[]>;
+    /** Whom the agent answers to, which decides whether a consultation may lend its rights. */
+    readonly accountability: _angular_core.Signal<_newheap_platform_ai_chat.AgentAccountability | null>;
+    readonly approvalPolicy: _angular_core.Signal<string | null>;
     /** What the run settings' approval policy means, in a sentence. */
     readonly settingsPolicy: _angular_core.Signal<string | null>;
     constructor();
@@ -949,6 +1023,18 @@ declare class NhAssistantAgentRunConfigurationComponent implements OnInit {
     editTrigger(trigger: DataTrigger): void;
     setTriggerShadow(trigger: DataTrigger, shadow: boolean): void;
     removeTrigger(trigger: DataTrigger): void;
+    addConsultation(): void;
+    editConsultation(consultation: DataConsultation): void;
+    removeConsultation(consultation: DataConsultation): void;
+    onConsultationSaved(result: ConsultationFormSaved): void;
+    /** The name of a subject type, as the run catalog names it in the reader's language. */
+    typeName(subjectType: string): string;
+    /** An agent's name: the translation of an agent in code, the administrator's text, or its id. */
+    agentNameOf(agentId: string): string;
+    /** Who may ask a consultation defined as data, in a sentence; `null` for one in code, whose code says it. */
+    askSentence(row: ConsultationRow): string | null;
+    /** What the consultation may do and who decides its proposals, by the routes in effect. */
+    decideSentence(row: ConsultationRow): string;
     /** A form saved: show what happened and reload, which every change may affect. */
     onSetupCompleted(live: boolean): void;
     onSettingsSaved(): void;
@@ -981,7 +1067,7 @@ declare class NhAssistantAgentRunConfigurationComponent implements OnInit {
     /** Runs a change and reloads the configuration, which every change may affect. */
     private run;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentRunConfigurationComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentRunConfigurationComponent, "nh-assistant-agent-run-configuration", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "startSetup": { "alias": "startSetup"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": false; "isSignal": true; }; "servers": { "alias": "servers"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "editAgent": "editAgent"; "changeAccount": "changeAccount"; "openRuns": "openRuns"; "openMcpServers": "openMcpServers"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentRunConfigurationComponent, "nh-assistant-agent-run-configuration", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "startSetup": { "alias": "startSetup"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": false; "isSignal": true; }; "servers": { "alias": "servers"; "required": false; "isSignal": true; }; "agents": { "alias": "agents"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "editAgent": "editAgent"; "changeAccount": "changeAccount"; "openRuns": "openRuns"; "openMcpServers": "openMcpServers"; "openAgent": "openAgent"; }, never, never, true, never>;
 }
 
 /** Result of the latest connection test per server. */

package/agent-runs/index.d.ts

@@ -1,6 +1,6 @@
 import * as _angular_core from '@angular/core';
 import * as _newheap_platform_ai_chat from '@newheap/platform-ai-chat';
-import { AgentProposal, AgentThreadLookup, AgentTriggerReceipt, NhAssistantError, AgentProposalDecisionRight, AgentProposalFeedback, AgentProposalOrigin, AgentProposalDecision, AgentExecutionResolution, AgentSubjectRole, AgentRun, ɵnhAssistantCodeKeys as _nhAssistantCodeKeys, AgentRunRetryMode, AgentThreadMemory, AgentArtifact, AgentConsultation, AgentSubjectWork, AgentSubjectWorkAgent, AgentSubjectType, ɵNhAssistantPickerOption as _NhAssistantPickerOption, NhAssistantAgentRunApiService, AgentObjectAgents, AgentObjectAgent, AgentRunResult, AgentBoard, AgentBoardAgent } from '@newheap/platform-ai-chat';
+import { AgentProposal, AgentInboxGroup, AgentThreadLookup, AgentProposalDecisionRight, AgentTriggerReceipt, NhAssistantError, AgentProposalFeedback, AgentProposalOrigin, AgentProposalDecision, AgentExecutionResolution, AgentSubjectRole, AgentRun, ɵnhAssistantCodeKeys as _nhAssistantCodeKeys, AgentRunRetryMode, AgentThreadMemory, AgentArtifact, AgentConsultation, NhAssistantConsultationRoute, AgentSubjectWork, AgentSubjectWorkAgent, AgentSubjectType, ɵNhAssistantPickerOption as _NhAssistantPickerOption, NhAssistantAgentRunApiService, AgentObjectAgents, AgentObjectAgent, AgentRunResult, AgentBoard, AgentBoardAgent } from '@newheap/platform-ai-chat';
 import { Observable } from 'rxjs';
 
 /**
@@ -14,15 +14,49 @@ import { Observable } from 'rxjs';
  * longer fits, for example because someone did the work by hand, stays as a closed card with the
  * reason until it is dismissed. A proposal a run placed at its object from another subject, such as a
  * run for the whole application, names that run; `openConversation` emits its conversation.
+ *
+ * `agentId`, `subjectType`, `divisionId` and `runId` filter the inbox; changing a filter, or `grouped`,
+ * reloads it from the first page. With `grouped` the inbox shows the proposals per parent, such as a
+ * project with its own proposals and those of its tasks, and per subject, optionally per run
+ * (`groupByRun`); a group that goes on on another page says so, and "Select group" selects only its
+ * proposals shown here. With `markNew` (on by default) it marks the proposals made since the person's
+ * last visit of the inbox in its scope, the whole application or the division of `divisionId`, and
+ * those that arrive while it is shown; with `recordVisit` (on by default) showing it records the
+ * visit. Turn `recordVisit` off for an inbox that shows only part of the scope, such as one agent's
+ * proposals, so the person's next visit of the whole inbox still marks what they have not seen.
  */
 declare class NhAssistantAgentInboxComponent {
     private readonly api;
     private readonly proposalList;
     private subscription?;
+    private visitSubscription?;
+    /** The scope whose visit this view recorded; the visit is recorded once per scope shown. */
+    private visited;
+    /**
+     * What the first read of the shown scope found: the visit before this one and the proposals that
+     * were new since. Later reads, after live updates, paging or a decision, compare with both, so what
+     * was new when the inbox was opened stays new while it is shown.
+     */
+    private opened;
     /** Limits the inbox to one agent. */
     readonly agentId: _angular_core.InputSignal<string | undefined>;
     /** Limits the inbox to one kind of subject, for example `project`. */
     readonly subjectType: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Limits the inbox to the subjects of one division, for example the active division; its visits are
+     * then those of that division.
+     */
+    readonly divisionId: _angular_core.InputSignal<string | null | undefined>;
+    /** Limits the inbox to the proposals of one run. */
+    readonly runId: _angular_core.InputSignal<string | null | undefined>;
+    /** Groups the proposals per parent and subject instead of listing them by expiry alone. */
+    readonly grouped: _angular_core.InputSignal<boolean>;
+    /** In a grouped inbox, also shows a header per run within a subject. */
+    readonly groupByRun: _angular_core.InputSignal<boolean>;
+    /** Marks the proposals made since the person's last visit of the inbox, and those that arrive while it is shown. */
+    readonly markNew: _angular_core.InputSignal<boolean>;
+    /** Records the person's visit of the inbox in its scope when it is shown. */
+    readonly recordVisit: _angular_core.InputSignal<boolean>;
     readonly itemsPerPage: _angular_core.InputSignal<number>;
     /**
      * Emits the conversation of the run that placed a proposal at its object from another subject, so
@@ -36,6 +70,15 @@ declare class NhAssistantAgentInboxComponent {
     readonly loadFailed: _angular_core.WritableSignal<boolean>;
     readonly items: _angular_core.WritableSignal<AgentProposal[]>;
     readonly total: _angular_core.WritableSignal<number>;
+    /** The groups of the page in a grouped inbox; `null` for the flat inbox. */
+    readonly groups: _angular_core.WritableSignal<AgentInboxGroup[] | null>;
+    /** The proposals of the page marked as new. */
+    readonly newIds: _angular_core.WritableSignal<ReadonlySet<string>>;
+    /**
+     * The person's visit of the shown scope before the inbox was opened: `null` before their first
+     * visit, `undefined` while unknown or when new proposals are not marked.
+     */
+    readonly previousVisit: _angular_core.WritableSignal<string | null | undefined>;
     readonly pages: _angular_core.Signal<number>;
     constructor();
     load(): void;
@@ -47,8 +90,19 @@ declare class NhAssistantAgentInboxComponent {
      */
     private refresh;
     private fetch;
+    /**
+     * Marks what is new: what the server marks since the visit this view recorded, and what was made
+     * after the person's visit before the inbox was opened, on any page. Before the first visit
+     * everything is new. A server without visits marks nothing.
+     */
+    private markNewOf;
+    /**
+     * Records the visit of the shown scope after its first read, so that read still marks what arrived
+     * since the visit before.
+     */
+    private recordVisitOf;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentInboxComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentInboxComponent, "nh-assistant-agent-inbox", never, { "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "subjectType": { "alias": "subjectType"; "required": false; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentInboxComponent, "nh-assistant-agent-inbox", never, { "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; "subjectType": { "alias": "subjectType"; "required": false; "isSignal": true; }; "divisionId": { "alias": "divisionId"; "required": false; "isSignal": true; }; "runId": { "alias": "runId"; "required": false; "isSignal": true; }; "grouped": { "alias": "grouped"; "required": false; "isSignal": true; }; "groupByRun": { "alias": "groupByRun"; "required": false; "isSignal": true; }; "markNew": { "alias": "markNew"; "required": false; "isSignal": true; }; "recordVisit": { "alias": "recordVisit"; "required": false; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
 }
 
 type NhAssistantAgentThreadTab = 'proposals' | 'runs' | 'consultations' | 'memory' | 'artifacts';
@@ -64,6 +118,7 @@ declare class NhAssistantAgentThreadViewComponent {
     private readonly proposalList;
     private subscription?;
     private proposalSubscription?;
+    private rightsSubscription?;
     private startSubscription?;
     readonly agentId: _angular_core.InputSignal<string>;
     readonly subjectType: _angular_core.InputSignal<string>;
@@ -78,6 +133,13 @@ declare class NhAssistantAgentThreadViewComponent {
     readonly loadFailed: _angular_core.WritableSignal<boolean>;
     readonly lookup: _angular_core.WritableSignal<AgentThreadLookup | null>;
     readonly proposals: _angular_core.WritableSignal<AgentProposal[]>;
+    /**
+     * The caller's live right to decide each pending proposal, as the server checks it for the decision:
+     * four-eyes keeps the person who asked for a consultation's proposal out, also as an approver, and
+     * nobody decides here what the asker decides in their own chat. Without an answer the caller's role
+     * decides what is offered; the server checks every decision again.
+     */
+    readonly rights: _angular_core.WritableSignal<ReadonlyMap<string, AgentProposalDecisionRight> | null>;
     readonly message: _angular_core.WritableSignal<string>;
     readonly starting: _angular_core.WritableSignal<boolean>;
     readonly receipt: _angular_core.WritableSignal<AgentTriggerReceipt | null>;
@@ -105,10 +167,54 @@ declare class NhAssistantAgentThreadViewComponent {
     private refresh;
     private fetch;
     private fetchProposals;
+    /**
+     * Reads the caller's live right to decide each pending proposal, in batches of
+     * `NH_ASSISTANT_MAX_PROPOSAL_LOOKUP`, as the run result and the subject's work do.
+     */
+    private readRights;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentThreadViewComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentThreadViewComponent, "nh-assistant-agent-thread-view", never, { "agentId": { "alias": "agentId"; "required": true; "isSignal": true; }; "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "subjectId": { "alias": "subjectId"; "required": true; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
 }
 
+/** The proposals of one run within a subject of a grouped list, in the order the list gave them. */
+interface NhAssistantRunSection {
+    key: string;
+    runId: string | null;
+    agentId: string;
+    /** When the run's first proposal on the page was made. */
+    proposedAt: string;
+    items: AgentProposal[];
+}
+/** One subject within a group of a grouped list. */
+interface NhAssistantSubjectSection {
+    key: string;
+    subjectType: string;
+    subjectId: string;
+    label: string;
+    typeName: string | null;
+    link: string | null;
+    /** The group's own subject, whose proposals stand directly under the group's header. */
+    own: boolean;
+    count: number;
+    total: number;
+    runs: NhAssistantRunSection[];
+}
+/** One group of a grouped list, such as a parent subject of the grouped inbox. */
+interface NhAssistantGroupSection {
+    key: string;
+    subjectType: string;
+    subjectId: string;
+    label: string;
+    typeName: string | null;
+    link: string | null;
+    count: number;
+    total: number;
+    continuesFromPreviousPage: boolean;
+    continuesOnNextPage: boolean;
+    subjects: NhAssistantSubjectSection[];
+    /** The group's pending proposals on this page that the caller may decide: what "Select group" selects. */
+    selectableIds: string[];
+}
 /** A feedback question: after a rejection above the list, or from a card's own action. */
 interface NhAssistantFeedbackRequest {
     approvalIds: string[];
@@ -132,7 +238,13 @@ interface NhAssistantFeedbackRequest {
  * replaced, as a closed card when it closes while shown, or when an approval is refused because of
  * it, until the person dismisses it. It reads those proposals by id with one lookup, never through
  * their threads. A proposal that a run placed here from another subject, such as a run for the whole
- * application, says so and offers that run's conversation through `openConversation`.
+ * application, says so and offers that run's conversation through `openConversation`. With `groups`
+ * from the grouped inbox the list shows a header per group and per subject, optionally per run
+ * (`groupByRun`), and "Select group" selects only the group's pending proposals in this list that
+ * the caller may decide, never those on another page. `newIds` marks proposals as new. A proposal of
+ * a consultation names who asked and its route: one the person who asked decides in their own chat
+ * (`asker-decides`) waits for them without actions here; one that runs with the agent's own rights
+ * (`subject-agent-rights`) says so, and the person who asked reads why another approver decides.
  */
 declare class NhAssistantAgentProposalsComponent {
     private readonly api;
@@ -154,6 +266,16 @@ declare class NhAssistantAgentProposalsComponent {
      * it closes.
      */
     readonly holdClosedCards: _angular_core.InputSignal<boolean>;
+    /**
+     * The groups of the grouped inbox (`AgentInbox.groups`) for `proposals` in the order the inbox gave
+     * them: the first `count` proposals belong to the first group, and so on. Without groups, or when
+     * they do not describe `proposals`, the list is flat.
+     */
+    readonly groups: _angular_core.InputSignal<readonly AgentInboxGroup[] | null>;
+    /** Shows a header per run within a subject of a grouped list. */
+    readonly groupByRun: _angular_core.InputSignal<boolean>;
+    /** Proposals to mark as new, by approval id, for example those made since the last visit of the inbox. */
+    readonly newIds: _angular_core.InputSignal<ReadonlySet<string> | null>;
     /** Emits after a proposal or its feedback changed, so the host reloads its list. */
     readonly changed: _angular_core.OutputEmitterRef<void>;
     /**
@@ -175,6 +297,11 @@ declare class NhAssistantAgentProposalsComponent {
     /** The held closed cards first, then the proposals the host gave. */
     readonly shown: _angular_core.Signal<AgentProposal[]>;
     private readonly lookups;
+    /**
+     * The grouped list: the held closed cards stay above it; `null` for a flat list, or when the groups
+     * do not describe the proposals.
+     */
+    readonly sections: _angular_core.Signal<NhAssistantGroupSection[] | null>;
     constructor();
     /**
      * The translation key of a proposal's status: the kind of a stale proposal, "replaced" for a
@@ -189,6 +316,16 @@ declare class NhAssistantAgentProposalsComponent {
         key: string;
         params: Record<string, string>;
     };
+    /** Whether the proposal is marked as new. */
+    isNew(proposal: AgentProposal): boolean;
+    /** Whether every proposal "Select group" would select in the group is selected. */
+    groupSelected(group: NhAssistantGroupSection): boolean;
+    /**
+     * Selects the group's pending proposals in this list that the caller may decide, or deselects them
+     * when all are selected. Proposals of the group on another page are never selected: an approver
+     * decides only what they see.
+     */
+    toggleGroup(group: NhAssistantGroupSection): void;
     /** True when the newer proposal that replaced this one is in the list. */
     hasSuccessor(proposal: AgentProposal): boolean;
     /** Moves focus to the newer proposal that replaced this one. */
@@ -202,13 +339,28 @@ declare class NhAssistantAgentProposalsComponent {
      * the shown pending proposals that left the list because they closed as stale or were replaced.
      */
     holdClosed(previous: readonly AgentProposal[], next: readonly AgentProposal[]): void;
-    /** Whether the caller may decide this proposal: its own right when one was given, otherwise `canDecide`. */
+    /**
+     * Whether the caller may decide this proposal: its own right when one was given, otherwise
+     * `canDecide`. Nobody decides a proposal here that the person who asked decides in their own chat.
+     */
     mayDecide(proposal: AgentProposal): boolean;
+    /**
+     * Whether a pending proposal of a consultation waits for the person who asked, who decides it in
+     * their own chat: its route says so, or the server's reason for the caller's right.
+     */
+    waitsForAsker(proposal: AgentProposal): boolean;
     /**
      * Who decides a pending proposal that has a right the caller lacks: another approver when
-     * four-eyes keeps out the person who started the work, otherwise an approver.
+     * four-eyes keeps out the person who started the work, which for a consultation's proposal that
+     * runs with the agent's own rights is the person who asked, otherwise an approver. A proposal that
+     * waits for the person who asked says so on its own (`waitsForAsker`).
      */
     waitingForKey(proposal: AgentProposal): string | null;
+    /**
+     * The badge of a consultation's proposal that runs with the agent's own rights: those of a technical
+     * account when the agent answers to one, otherwise the agent's own; `null` for other proposals.
+     */
+    agentRightsKey(proposal: AgentProposal): string | null;
     toggle(proposal: AgentProposal): void;
     toggleAll(): void;
     decide(proposal: AgentProposal, decision: AgentProposalDecision): void;
@@ -224,6 +376,7 @@ declare class NhAssistantAgentProposalsComponent {
     onFeedbackSaved(): void;
     /** Closes the question; from a card, focus returns to the card's feedback action. */
     onFeedbackDismissed(): void;
+    private groupSection;
     private ask;
     /**
      * Reads `proposals` again by id and keeps those that closed as stale or were replaced as closed
@@ -232,7 +385,7 @@ declare class NhAssistantAgentProposalsComponent {
     private holdStale;
     private run;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentProposalsComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentProposalsComponent, "nh-assistant-agent-proposals", never, { "proposals": { "alias": "proposals"; "required": true; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionRights": { "alias": "decisionRights"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "holdClosedCards": { "alias": "holdClosedCards"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "openConversation": "openConversation"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentProposalsComponent, "nh-assistant-agent-proposals", never, { "proposals": { "alias": "proposals"; "required": true; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionRights": { "alias": "decisionRights"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "holdClosedCards": { "alias": "holdClosedCards"; "required": false; "isSignal": true; }; "groups": { "alias": "groups"; "required": false; "isSignal": true; }; "groupByRun": { "alias": "groupByRun"; "required": false; "isSignal": true; }; "newIds": { "alias": "newIds"; "required": false; "isSignal": true; }; }, { "changed": "changed"; "openConversation": "openConversation"; }, never, never, true, never>;
 }
 
 /**
@@ -333,9 +486,9 @@ declare class NhAssistantAgentArtifactsComponent {
 
 /**
  * Who consulted the thread's agent through another assistant, newest first: the person whose rights
- * were used, the asking assistant, the outcome, the usage and the proposals left for approvers. The
- * question and the answer stay in the asking conversation and are never shown here. With live
- * updates the list reloads by itself when a run or proposal of the thread changes.
+ * were used, the asking assistant, the outcome, the usage and the proposals it left, with their
+ * number per route. The question and the answer stay in the asking conversation and are never shown
+ * here. With live updates the list reloads by itself when a run or proposal of the thread changes.
  */
 declare class NhAssistantAgentConsultationsComponent {
     private readonly api;
@@ -348,6 +501,11 @@ declare class NhAssistantAgentConsultationsComponent {
     readonly codeKeys: typeof _nhAssistantCodeKeys;
     constructor();
     load(): void;
+    /** The proposals the consultation left per route, in a fixed order; routes without proposals are left out. */
+    routeCounts(consultation: AgentConsultation): {
+        route: NhAssistantConsultationRoute;
+        count: number;
+    }[];
     /** A quiet load, after a live update, shows no loading state and keeps the list when it fails. */
     private fetch;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentConsultationsComponent, never>;
@@ -690,11 +848,18 @@ interface RunDuration {
  * its object, for the whole application the agent's view policy, administrators every run. The
  * thread view's run timeline and the administration's runs view open it; an application may show
  * it anywhere with a run id. With live updates it reloads by itself while the run works.
+ *
+ * The run's pending proposals that the reader may decide, by the same live check as the inbox and the
+ * subject's work (`POST approvals/lookup`), can be decided in place, one by one or selected together
+ * with "Select all"; a pending proposal the reader may not decide says who does, and a reader who may
+ * decide none sees no selection. After a rejection the list asks, optionally, what was wrong, and a
+ * proposal refused because it no longer fits stays as a closed card with the reason until dismissed.
  */
 declare class NhAssistantRunResultComponent {
     private readonly api;
     private readonly document;
     private subscription?;
+    private rightsSubscription?;
     /** The run to show. */
     readonly runId: _angular_core.InputSignal<string>;
     /**
@@ -718,11 +883,25 @@ declare class NhAssistantRunResultComponent {
     /** The text of the download's failure, then the text that a file could not be downloaded. */
     readonly downloadErrorKeys: _angular_core.Signal<string[]>;
     readonly codeKeys: typeof _nhAssistantCodeKeys;
+    /**
+     * The reader's live right to decide each pending proposal of the run, by approval id; `null` until
+     * it is known, when nobody may decide.
+     */
+    readonly rights: _angular_core.WritableSignal<ReadonlyMap<string, AgentProposalDecisionRight> | null>;
+    /** Whether the reader may decide at least one of the run's proposals: only then can they select. */
+    readonly decidable: _angular_core.Signal<boolean>;
     readonly duration: _angular_core.Signal<RunDuration | null>;
     readonly tokens: _angular_core.Signal<number>;
     constructor();
     load(): void;
+    /** A proposal was decided or its feedback given: the run's proposals and the rights are read again. */
+    onProposalsChanged(): void;
     download(artifact: AgentArtifact): Promise<void>;
+    /**
+     * Reads the reader's live right to decide each pending proposal of the run, as the server checks it
+     * for every decision. Without an answer nobody may decide here; the server checks again anyway.
+     */
+    private readRights;
     /**
      * Reads the run. A quiet reload, after a live update, keeps what is shown when it fails and shows
      * no loading state.