@newheap/platform-ai-chat 0.14.0 → 0.16.0

package/agent-runs/index.d.ts

@@ -1,6 +1,7 @@
 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, AgentProposalDecision, AgentExecutionResolution, AgentSubjectRole, AgentRun, AgentRunRetryMode, AgentThreadMemory, AgentArtifact, AgentConsultation, AgentSubjectWork, AgentSubjectWorkAgent } 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 { Observable } from 'rxjs';
 
 /**
  * The approval inbox: pending agent proposals across subjects that the signed-in person may
@@ -8,9 +9,11 @@ import { AgentProposal, AgentThreadLookup, AgentTriggerReceipt, NhAssistantError
  * server checks each decision against the proposal's approval policy again. After a rejection the
  * inbox asks, optionally, what was wrong, also when the rejected proposals have left the list.
  * With live updates the inbox reloads by itself when agent work changes, for example when a
- * colleague decided a proposal or a run proposed a new one. A proposal that closes because it no
+ * colleague decided a proposal or a run proposed a new one; it watches the work of agents for the
+ * whole application, whose approvers are no members of it, while it is shown. A proposal that closes because it no
  * longer fits, for example because someone did the work by hand, stays as a closed card with the
- * reason until it is dismissed.
+ * 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.
  */
 declare class NhAssistantAgentInboxComponent {
     private readonly api;
@@ -21,6 +24,11 @@ declare class NhAssistantAgentInboxComponent {
     /** Limits the inbox to one kind of subject, for example `project`. */
     readonly subjectType: _angular_core.InputSignal<string | undefined>;
     readonly itemsPerPage: _angular_core.InputSignal<number>;
+    /**
+     * Emits the conversation of the run that placed a proposal at its object from another subject, so
+     * the host opens it, for example in the assistant panel.
+     */
+    readonly openConversation: _angular_core.OutputEmitterRef<string>;
     readonly page: _angular_core.WritableSignal<number>;
     readonly loading: _angular_core.WritableSignal<boolean>;
     /** True after the first successful load; later loads keep the list, and an open feedback question, in place. */
@@ -40,7 +48,7 @@ declare class NhAssistantAgentInboxComponent {
     private refresh;
     private fetch;
     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; }; }, {}, 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; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
 }
 
 type NhAssistantAgentThreadTab = 'proposals' | 'runs' | 'consultations' | 'memory' | 'artifacts';
@@ -60,7 +68,10 @@ declare class NhAssistantAgentThreadViewComponent {
     readonly agentId: _angular_core.InputSignal<string>;
     readonly subjectType: _angular_core.InputSignal<string>;
     readonly subjectId: _angular_core.InputSignal<string>;
-    /** Emits the thread's conversation id, so the host can open it in the assistant panel. */
+    /**
+     * Emits the thread's conversation id, so the host can open it in the assistant panel; also the
+     * conversation of a run that placed one of the thread's proposals here from another subject.
+     */
     readonly openConversation: _angular_core.OutputEmitterRef<string>;
     readonly tab: _angular_core.WritableSignal<NhAssistantAgentThreadTab>;
     readonly loading: _angular_core.WritableSignal<boolean>;
@@ -120,7 +131,8 @@ interface NhAssistantFeedbackRequest {
  * With `holdClosedCards`, a list of open proposals keeps such a proposal, or one a newer proposal
  * 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.
+ * 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`.
  */
 declare class NhAssistantAgentProposalsComponent {
     private readonly api;
@@ -144,6 +156,11 @@ declare class NhAssistantAgentProposalsComponent {
     readonly holdClosedCards: _angular_core.InputSignal<boolean>;
     /** Emits after a proposal or its feedback changed, so the host reloads its list. */
     readonly changed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits the conversation of the run that placed a proposal here from another subject, so the host
+     * opens it, for example in the assistant panel. The server checks the reader's access again.
+     */
+    readonly openConversation: _angular_core.OutputEmitterRef<string>;
     readonly busy: _angular_core.WritableSignal<boolean>;
     readonly selected: _angular_core.WritableSignal<ReadonlySet<string>>;
     readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
@@ -164,6 +181,14 @@ declare class NhAssistantAgentProposalsComponent {
      * superseded one, otherwise its status.
      */
     statusKey(proposal: AgentProposal): string;
+    /**
+     * The translation key and parameters that say where a placed proposal came from: the whole
+     * application, a division of it, or another object, named only by its kind.
+     */
+    originText(origin: AgentProposalOrigin): {
+        key: string;
+        params: Record<string, string>;
+    };
     /** 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. */
@@ -207,14 +232,16 @@ 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"; }, 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; }; }, { "changed": "changed"; "openConversation": "openConversation"; }, never, never, true, never>;
 }
 
 /**
  * The runs of an agent thread, newest first: trigger, status, failure, usage, proposals and the
- * summary the next run starts from, and the agent that handed a run its work. Participants cancel
- * an open run; approvers resume or restart a failed or cancelled one. With live updates it reloads
- * by itself when a run or proposal of the thread changes.
+ * summary the next run starts from, and the agent that handed a run its work. "Show the result"
+ * opens a run's whole result, proposals and files in `nh-assistant-run-result`. Participants cancel
+ * an open run; approvers resume or restart a failed or cancelled one, and a restart shows what became
+ * of it like a start by hand. A run's failure reads as its translated code. With live updates it
+ * reloads by itself when a run or proposal of the thread changes.
  */
 declare class NhAssistantRunTimelineComponent {
     private readonly api;
@@ -226,16 +253,23 @@ declare class NhAssistantRunTimelineComponent {
     readonly changed: _angular_core.OutputEmitterRef<void>;
     /** Emits the thread of the agent that handed a run its work, so the host can open it. */
     readonly openConversation: _angular_core.OutputEmitterRef<string>;
+    readonly id: string;
     readonly loading: _angular_core.WritableSignal<boolean>;
     readonly loadFailed: _angular_core.WritableSignal<boolean>;
     readonly runs: _angular_core.WritableSignal<AgentRun[]>;
+    /** The run whose result is shown; one at a time. */
+    readonly openedRunId: _angular_core.WritableSignal<string | null>;
     readonly busyRunId: _angular_core.WritableSignal<string | null>;
     readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
     readonly errorKeys: _angular_core.Signal<string[]>;
+    /** What became of the latest restart. */
+    readonly receipt: _angular_core.WritableSignal<AgentTriggerReceipt | null>;
+    readonly codeKeys: typeof _nhAssistantCodeKeys;
     readonly canCancel: _angular_core.Signal<boolean>;
     readonly canRetry: _angular_core.Signal<boolean>;
     constructor();
     load(): void;
+    toggleResult(run: AgentRun): void;
     isOpen(run: AgentRun): boolean;
     canRetryRun(run: AgentRun): boolean;
     cancel(run: AgentRun): void;
@@ -280,7 +314,12 @@ declare class NhAssistantAgentArtifactsComponent {
     readonly conversationId: _angular_core.InputSignal<string>;
     readonly loading: _angular_core.WritableSignal<boolean>;
     readonly loadFailed: _angular_core.WritableSignal<boolean>;
-    readonly downloadFailed: _angular_core.WritableSignal<boolean>;
+    /** Why the latest download failed, as a code and translation key; `null` after one that worked. */
+    readonly downloadError: _angular_core.WritableSignal<NhAssistantError | null>;
+    /** Whether the latest download failed. */
+    readonly downloadFailed: _angular_core.Signal<boolean>;
+    /** The text of the download's failure, then the text that a file could not be downloaded. */
+    readonly downloadErrorKeys: _angular_core.Signal<string[]>;
     readonly artifacts: _angular_core.WritableSignal<AgentArtifact[]>;
     readonly downloadingId: _angular_core.WritableSignal<string | null>;
     constructor();
@@ -306,6 +345,7 @@ declare class NhAssistantAgentConsultationsComponent {
     readonly loadFailed: _angular_core.WritableSignal<boolean>;
     readonly consultations: _angular_core.WritableSignal<AgentConsultation[]>;
     readonly total: _angular_core.WritableSignal<number>;
+    readonly codeKeys: typeof _nhAssistantCodeKeys;
     constructor();
     load(): void;
     /** A quiet load, after a live update, shows no loading state and keeps the list when it fails. */
@@ -327,7 +367,8 @@ interface NhAssistantStartedAgent {
  * whose conversation the host offers also before it worked on the subject. With live updates the
  * view reloads by itself when agent work on its subject changes; a proposal that closes because it
  * no longer fits stays as a closed card with the reason until it is dismissed. Opening a
- * conversation uses `NhAssistantPanelService.openSubject` and emits `conversationOpened` afterwards.
+ * conversation uses `NhAssistantPanelService.openSubject` and emits `conversationOpened` afterwards;
+ * opening the conversation of a run that placed a proposal here emits `runConversationOpened`.
  */
 declare class NhAssistantSubjectSuggestionsComponent {
     private readonly api;
@@ -344,6 +385,11 @@ declare class NhAssistantSubjectSuggestionsComponent {
     readonly agentId: _angular_core.InputSignal<string | undefined>;
     /** Emits once the panel opens the conversation, so a host in a dialog can make room for it. */
     readonly conversationOpened: _angular_core.OutputEmitterRef<AgentThreadLookup>;
+    /**
+     * Emits once the panel opens the conversation of a run that placed a proposal here from another
+     * subject, so a host in a dialog can make room for it.
+     */
+    readonly runConversationOpened: _angular_core.OutputEmitterRef<string>;
     readonly headingId: string;
     readonly loading: _angular_core.WritableSignal<boolean>;
     /** True after the first successful load; later loads keep the list, and an open feedback question, in place. */
@@ -365,10 +411,19 @@ declare class NhAssistantSubjectSuggestionsComponent {
     readonly decisionRights: _angular_core.Signal<ReadonlyMap<string, AgentProposalDecisionRight>>;
     constructor();
     load(): void;
-    /** The translation keys of an agent's name: from the server's status, then the convention. */
-    agentNameKeys(agentId: string): string[];
+    /**
+     * The translation keys of an agent's name: the name the subject's work gives, which names an agent
+     * kept out of the chat as well (the text itself for an agent created in the administration), then
+     * the server's status, then the convention.
+     */
+    agentNameKeys(agent: AgentSubjectWorkAgent): string[];
     /** Readers may open an existing conversation; creating one needs the participant role. */
     canOpen(agent: AgentSubjectWorkAgent): boolean;
+    /**
+     * Opens the conversation of the run that placed a proposal here, such as a run for the whole
+     * application, in the assistant panel; the server checks the reader's access to it.
+     */
+    openRunConversation(conversationId: string): void;
     open(agent: AgentSubjectWorkAgent): Promise<void>;
     start(agent: AgentSubjectWorkAgent): void;
     /**
@@ -379,8 +434,386 @@ declare class NhAssistantSubjectSuggestionsComponent {
     private refresh;
     private fetch;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantSubjectSuggestionsComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantSubjectSuggestionsComponent, "nh-assistant-subject-suggestions", never, { "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "subjectId": { "alias": "subjectId"; "required": true; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; }, { "conversationOpened": "conversationOpened"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantSubjectSuggestionsComponent, "nh-assistant-subject-suggestions", never, { "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "subjectId": { "alias": "subjectId"; "required": true; "isSignal": true; }; "agentId": { "alias": "agentId"; "required": false; "isSignal": true; }; }, { "conversationOpened": "conversationOpened"; "runConversationOpened": "runConversationOpened"; }, never, never, true, never>;
+}
+
+/** A subject chosen in the subject picker, with the name the application gives it. */
+interface NhAssistantChosenSubject {
+    type: string;
+    id: string;
+    displayName: string | null;
+}
+/**
+ * The search of the picker for the subjects of one type: the subjects the caller may read whose
+ * name matches, from `GET subjects/{type}/search` (internal).
+ */
+declare function nhAssistantSubjectSearch(api: NhAssistantAgentRunApiService, subjectType: string, limit?: number): (query: string) => Observable<_NhAssistantPickerOption[]>;
+/**
+ * Chooses one subject of a type (internal). A searchable type is a combobox that searches the
+ * caller's readable subjects by name; for any other type people give the id, and the picker shows
+ * the name the application gives that subject, or why it was not found, below the field, with
+ * the translated code and, when asking again can help, a button that looks it up again. The
+ * platform's type of the whole application (`isSystem`) is "The whole application" itself for an
+ * app-wide agent, chosen as soon as the type is, and a search of the divisions by name for an agent
+ * that works per division (`perDivision`).
+ */
+declare class NhAssistantSubjectPickerComponent {
+    private readonly api;
+    private lookup?;
+    /** The id of the field, for the label's `for`. */
+    readonly inputId: _angular_core.InputSignal<string>;
+    readonly subjectType: _angular_core.InputSignal<AgentSubjectType>;
+    /**
+     * For the whole application: choose one of the application's divisions, for an agent that works
+     * per division, instead of the whole application app-wide.
+     */
+    readonly perDivision: _angular_core.InputSignal<boolean>;
+    /** The chosen subject's id. */
+    readonly value: _angular_core.InputSignal<string | null>;
+    /** The name of the chosen subject, when the host knows it. */
+    readonly selectedLabel: _angular_core.InputSignal<string | null>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly describedBy: _angular_core.InputSignal<string | null>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    /** The chosen subject, or `null` when the choice was cleared or the id was not found. */
+    readonly subjectChange: _angular_core.OutputEmitterRef<NhAssistantChosenSubject | null>;
+    readonly hintId: string;
+    /** The whole application app-wide: nothing to choose beyond the type itself. */
+    readonly wholeApplication: _angular_core.Signal<boolean>;
+    readonly search: _angular_core.Signal<((query: string) => Observable<_NhAssistantPickerOption[]>) | null>;
+    readonly placeholderKey: _angular_core.Signal<"nh-assistant.subject-picker.division-placeholder" | "nh-assistant.subject-picker.search-placeholder">;
+    readonly typedId: _angular_core.WritableSignal<string>;
+    readonly lookingUp: _angular_core.WritableSignal<boolean>;
+    readonly found: _angular_core.WritableSignal<NhAssistantChosenSubject | null>;
+    /** Why the typed id could not be looked up; `null` while there is no failure. */
+    readonly lookupError: _angular_core.WritableSignal<NhAssistantError | null>;
+    /** An unknown subject reads as such; any other failure with its own text and the generic fallback. */
+    readonly lookupErrorKeys: _angular_core.Signal<string[]>;
+    /** Looking the same id up again can help after a failure of the connection or the server. */
+    readonly lookupRetryable: _angular_core.Signal<boolean>;
+    readonly fieldDescribedBy: _angular_core.Signal<string>;
+    constructor();
+    choose(option: _NhAssistantPickerOption | null): void;
+    onIdInput(event: Event): void;
+    /** Looks the typed id up again after a failure that asking again may resolve. */
+    lookUpAgain(): void;
+    /** Looks the typed id up; the server names the subject when the caller may read it. */
+    lookUp(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantSubjectPickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantSubjectPickerComponent, "nh-assistant-subject-picker", never, { "inputId": { "alias": "inputId"; "required": true; "isSignal": true; }; "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "perDivision": { "alias": "perDivision"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectedLabel": { "alias": "selectedLabel"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "describedBy": { "alias": "describedBy"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "subjectChange": "subjectChange"; }, never, never, true, never>;
+}
+
+/** The agent the dialog runs: its id, its name as people read it and what it works on. */
+interface NhAssistantRunNowAgent {
+    id: string;
+    /** The agent's name in the reader's language, or the text an administrator gave it. */
+    name: string;
+    /** The object types it works on; with `worksOnAllSubjects` every type the application registers. */
+    worksOnSubjectTypes?: readonly string[] | null;
+    worksOnAllSubjects?: boolean | null;
+    /** It works on the whole application. */
+    worksOnApplication?: boolean | null;
+    /** Its work for the whole application exists per division. */
+    perDivision?: boolean | null;
+}
+/** A subject the dialog runs the agent on without asking, such as the object of the page. */
+interface NhAssistantRunNowSubject {
+    type: string;
+    id: string;
+    displayName?: string | null;
+    typeName?: string | null;
+    link?: string | null;
+}
+/** What a run by hand was started on, with the receipt of `POST threads/start`. */
+interface NhAssistantRunNowStarted {
+    receipt: AgentTriggerReceipt;
+    subject: NhAssistantChosenSubject;
+}
+/** One answer to "What should the agent work on?". */
+interface RunNowTarget {
+    key: string;
+    type: AgentSubjectType;
+    /** For the whole application: the agent works per division, so a division is chosen. */
+    perDivision: boolean;
+}
+/** The longest instruction the dialog sends with a run. */
+declare const NH_ASSISTANT_RUN_NOW_MAX_MESSAGE = 4000;
+/**
+ * Runs an agent now, by hand (internal to the library; the administration's "Run now", the run now
+ * of `nh-assistant-object-agents` and the board's tile use it, so it lives in the `agent-runs` entry
+ * point and stays out of the chat's initial bundle). A modal dialog asks what the agent
+ * works on this time, unless the host gives the subject: the whole application, in a division for an
+ * agent that works per division, or an object of one of its types through the subject picker; and an
+ * optional instruction. It sends `POST threads/start` with the caller as initiator, shows the
+ * server's refusal at the form with its translated code, and ends with the receipt: what happens
+ * now (a warning while the agent or its skill is paused, information while the start waits for the
+ * application's change to be saved), the subject and the conversation to open. The server decides
+ * who may run the agent: on an object the participant role, on the whole application the agent's
+ * run policy.
+ *
+ * The host renders it when people ask to run the agent; it opens itself and emits `closed` when it
+ * closes, after which the host removes it. Escape closes it, and focus returns to what opened it.
+ */
+declare class NhAssistantRunNowDialogComponent {
+    private readonly api;
+    private readonly translate;
+    private readonly injector;
+    private readonly host;
+    private readonly dialog;
+    private subscription?;
+    readonly agent: _angular_core.InputSignal<NhAssistantRunNowAgent>;
+    /** The application's subject types from the run catalog, for choosing an object type. */
+    readonly subjectTypes: _angular_core.InputSignal<readonly AgentSubjectType[]>;
+    /** Whether the application lists its divisions, so a per-division agent can be run in one. */
+    readonly divisions: _angular_core.InputSignal<boolean>;
+    /** Runs the agent on this subject without asking, such as the object of the page. */
+    readonly subject: _angular_core.InputSignal<NhAssistantRunNowSubject | null>;
+    /** The run started, with its receipt. */
+    readonly started: _angular_core.OutputEmitterRef<NhAssistantRunNowStarted>;
+    /** People want to open the agent's conversation; the dialog has closed. */
+    readonly openConversation: _angular_core.OutputEmitterRef<string>;
+    /** The dialog closed; the host removes it. */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    readonly id: string;
+    readonly maxMessage = 4000;
+    readonly targetKey: _angular_core.WritableSignal<string | null>;
+    readonly chosen: _angular_core.WritableSignal<NhAssistantChosenSubject | null>;
+    readonly message: _angular_core.WritableSignal<string>;
+    readonly starting: _angular_core.WritableSignal<boolean>;
+    readonly subjectMissing: _angular_core.WritableSignal<boolean>;
+    readonly receipt: _angular_core.WritableSignal<NhAssistantRunNowStarted | null>;
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    /** A refusal of the start explained for running an agent, then as the server names it. */
+    readonly errorKeys: _angular_core.Signal<string[]>;
+    /** The whole application as the run catalog names it, or in the reader's language without one. */
+    private readonly systemType;
+    /** What the agent can be run on: the whole application when it works on it, then its object types. */
+    readonly targets: _angular_core.Signal<RunNowTarget[]>;
+    /** The chosen answer, by default the first: the whole application when the agent works on it. */
+    readonly target: _angular_core.Signal<RunNowTarget>;
+    /** A per-division agent cannot be run while the application lists no divisions. */
+    readonly divisionUnavailable: _angular_core.Signal<boolean>;
+    readonly subjectFieldId: _angular_core.Signal<string>;
+    readonly subjectErrorId: _angular_core.Signal<string>;
+    constructor();
+    chooseTarget(key: string): void;
+    onSubject(subject: NhAssistantChosenSubject | null): void;
+    onMessage(event: Event): void;
+    /** The subject the run is for: the host's, or the one chosen in the form. */
+    subjectOfRun(): NhAssistantChosenSubject | null;
+    submit(): void;
+    open(conversationId: string): void;
+    close(): void;
+    /** The native dialog closed, by a button or by Escape. */
+    onClosed(): void;
+    /** The name of the subject in the receipt, when the server's type name adds something. */
+    receiptTypeName(started: NhAssistantRunNowStarted): string | null;
+    receiptLink(started: NhAssistantRunNowStarted): string | null;
+    private focusFirst;
+    private focusSubject;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantRunNowDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantRunNowDialogComponent, "nh-assistant-run-now-dialog", never, { "agent": { "alias": "agent"; "required": true; "isSignal": true; }; "subjectTypes": { "alias": "subjectTypes"; "required": false; "isSignal": true; }; "divisions": { "alias": "divisions"; "required": false; "isSignal": true; }; "subject": { "alias": "subject"; "required": false; "isSignal": true; }; }, { "started": "started"; "openConversation": "openConversation"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * The agents that work on one object, for the object's page, for example on a project: per agent its
+ * latest run with the beginning of its result, the whole result on demand in `nh-assistant-run-result`,
+ * its open proposals, "Run now" for people who may run it (the participants of the object; for the
+ * whole application, `nh-system`, the agent's run policy), and on demand its work on the object in
+ * `nh-assistant-agent-thread-view`. The server lists only the agents that work on the object and that
+ * the person may use, and checks every start again. A failed load reads as its translated code, such as
+ * an object that does not exist or that the person may not see, with "Try again" where asking again
+ * can help. With live updates the list reloads by itself when an agent's work on the object changes.
+ */
+declare class NhAssistantObjectAgentsComponent {
+    private readonly api;
+    private readonly translate;
+    private subscription?;
+    /** The object's type, such as `project`, or `nh-system` for the whole application. */
+    readonly subjectType: _angular_core.InputSignal<string>;
+    /** The object's id, or `global` (or `division-…`) for the whole application. */
+    readonly subjectId: _angular_core.InputSignal<string>;
+    /** Emits the conversation id of an agent's thread, so the host can open it in the assistant panel. */
+    readonly openConversation: _angular_core.OutputEmitterRef<string>;
+    readonly id: string;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    /** Why the agents could not be read; `null` after a load that worked. */
+    readonly loadError: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly loadErrorKeys: _angular_core.Signal<string[]>;
+    /** Loading again can help after a failure of the connection or the server, not of the object. */
+    readonly loadRetryable: _angular_core.Signal<boolean>;
+    readonly codeKeys: typeof _nhAssistantCodeKeys;
+    readonly listing: _angular_core.WritableSignal<AgentObjectAgents | null>;
+    readonly agents: _angular_core.Signal<AgentObjectAgent[]>;
+    /** The agent whose work on the object is shown; one at a time. */
+    readonly expanded: _angular_core.WritableSignal<string | null>;
+    /** The agent whose latest result is shown in full; one at a time. */
+    readonly resultShown: _angular_core.WritableSignal<string | null>;
+    /** The agent the run-now dialog runs; `null` while it is closed. */
+    readonly runningNow: _angular_core.WritableSignal<AgentObjectAgent | null>;
+    readonly runNowAgent: _angular_core.Signal<NhAssistantRunNowAgent | null>;
+    /** The object of the page: the run-now dialog runs on it without asking. */
+    readonly runNowSubject: _angular_core.Signal<NhAssistantRunNowSubject | null>;
+    constructor();
+    load(): void;
+    /** The agent's name: a translation key of an agent in code, or the text of one created as data. */
+    nameOf(agent: AgentObjectAgent): string;
+    toggleResult(agent: AgentObjectAgent): void;
+    toggleWork(agent: AgentObjectAgent): void;
+    runNow(agent: AgentObjectAgent): void;
+    /** A run started: the list shows it as the agent's latest run. */
+    onStarted(): void;
+    proposalsKey(count: number): string;
+    /** Whether a live update concerns the object: its runs, proposals or feedback changed. */
+    private concerns;
+    /**
+     * Reads the agents. A quiet reload, after a live update or a start, keeps what is shown when it
+     * fails and shows no loading state.
+     */
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantObjectAgentsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantObjectAgentsComponent, "nh-assistant-object-agents", never, { "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "subjectId": { "alias": "subjectId"; "required": true; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
+}
+
+/** How long a run took, for people to read: a text key and its number. */
+interface RunDuration {
+    key: string;
+    value: number;
+}
+/**
+ * One run of an agent with its result: what it worked on, how it was started and ended, its usage
+ * and duration, its whole answer, the proposals it made (also those it placed at other objects the
+ * reader may read) and the files it saved. The answer is model output: it is rendered with the
+ * assistant's safe Markdown rendering, which shows inline HTML as text and keeps only a strict set
+ * of tags and links, never as HTML. The server decides who sees a run (`GET runs/{id}`): readers of
+ * 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.
+ */
+declare class NhAssistantRunResultComponent {
+    private readonly api;
+    private readonly document;
+    private subscription?;
+    /** The run to show. */
+    readonly runId: _angular_core.InputSignal<string>;
+    /**
+     * Whether to offer the run's conversation; leave it off where that conversation is already shown,
+     * as in its thread's run timeline.
+     */
+    readonly conversationLink: _angular_core.InputSignal<boolean>;
+    /** Emits the run's thread conversation, or the one of a run that placed a proposal, so the host can open it. */
+    readonly openConversation: _angular_core.OutputEmitterRef<string>;
+    readonly id: string;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    /** The run does not exist or the reader may not see it. */
+    readonly notFound: _angular_core.WritableSignal<boolean>;
+    readonly detail: _angular_core.WritableSignal<AgentRunResult | null>;
+    readonly downloadingId: _angular_core.WritableSignal<string | null>;
+    /** Why the latest download failed, as a code and translation key; `null` after one that worked. */
+    readonly downloadError: _angular_core.WritableSignal<NhAssistantError | null>;
+    /** Whether the latest download failed. */
+    readonly downloadFailed: _angular_core.Signal<boolean>;
+    /** 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;
+    readonly duration: _angular_core.Signal<RunDuration | null>;
+    readonly tokens: _angular_core.Signal<number>;
+    constructor();
+    load(): void;
+    download(artifact: AgentArtifact): Promise<void>;
+    /**
+     * Reads the run. A quiet reload, after a live update, keeps what is shown when it fails and shows
+     * no loading state.
+     */
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantRunResultComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantRunResultComponent, "nh-assistant-run-result", never, { "runId": { "alias": "runId"; "required": true; "isSignal": true; }; "conversationLink": { "alias": "conversationLink"; "required": false; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
+}
+
+/** What a board tile shows below the agent: its latest result, its proposals or its history. */
+type NhAssistantBoardPanel = 'result' | 'proposals' | 'history';
+/**
+ * The board of one group of agents, for a page of the application such as "Project management"
+ * (K15): per agent a tile with what it works on, its latest result for the whole application rendered
+ * with the assistant's safe Markdown rendering, "New" for what arrived since the person's last visit
+ * (K16), "Run now" for people who may run it, its open proposals in the inbox, and its history with
+ * every result on demand. Showing the board records the visit, so the next visit marks what is new
+ * after this one. The server decides which agents the person sees: an agent that works on the whole
+ * application by its view policy, by default its required policy. With `divisionId` the board shows
+ * the work of agents that work per division in that division. With live updates the board reloads by
+ * itself when its agents' work changes.
+ */
+declare class NhAssistantAgentBoardComponent {
+    private readonly api;
+    private readonly translate;
+    private subscription?;
+    private visitSubscription?;
+    /** The board and scope whose visit this view recorded; the visit is recorded once per board shown. */
+    private visited;
+    /**
+     * What the first read of the shown board found: the visit before this one and the agents that were
+     * new then. Later reads, after live updates or a start, compare with the visit this view recorded,
+     * so the view keeps both: what was new when the board was opened stays new while it is shown.
+     */
+    private opened;
+    /** The group whose board is shown, such as `project-management`, as the application registered it. */
+    readonly group: _angular_core.InputSignal<string>;
+    /** The division whose board is shown; without it the board of the whole application. */
+    readonly divisionId: _angular_core.InputSignal<string | null>;
+    /** Emits a conversation a result or proposal offers to open, so the host can open it in the assistant panel. */
+    readonly openConversation: _angular_core.OutputEmitterRef<string>;
+    readonly id: string;
+    readonly codeKeys: typeof _nhAssistantCodeKeys;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    /** The board does not exist or the person sees none of its agents. */
+    readonly notFound: _angular_core.WritableSignal<boolean>;
+    /** The board as shown: new since the visit before this one, also after the visit was recorded. */
+    readonly board: _angular_core.WritableSignal<AgentBoard | null>;
+    readonly agents: _angular_core.Signal<AgentBoardAgent[]>;
+    /** Per agent what its tile shows below it; one panel per tile. */
+    readonly panels: _angular_core.WritableSignal<Readonly<Record<string, NhAssistantBoardPanel>>>;
+    /** The agent the run-now dialog runs; `null` while it is closed. */
+    readonly runningNow: _angular_core.WritableSignal<AgentBoardAgent | null>;
+    readonly runNowAgent: _angular_core.Signal<NhAssistantRunNowAgent | null>;
+    /** The whole application in the board's scope: the run-now dialog runs on it without asking. */
+    readonly runNowSubject: _angular_core.Signal<NhAssistantRunNowSubject | null>;
+    constructor();
+    load(): void;
+    /** The agent's name: a translation key of an agent in code, or the text of one created as data. */
+    nameOf(agent: AgentBoardAgent): string;
+    /** What the agent works on, in the reader's language. */
+    worksOnOf(agent: AgentBoardAgent): string;
+    panelOf(agent: AgentBoardAgent): NhAssistantBoardPanel | null;
+    toggle(agent: AgentBoardAgent, panel: NhAssistantBoardPanel): void;
+    runNow(agent: AgentBoardAgent): void;
+    /** A run started: the board shows it as the agent's latest run. */
+    onStarted(): void;
+    proposalsKey(count: number): string;
+    /** The beginning of a result as Markdown, marked when the result goes on. */
+    previewOf(result: string, truncated: boolean): string;
+    /**
+     * Whether a live update concerns the board: the work in one of its agents' threads, or a run of the
+     * whole application that may have started an agent's first thread.
+     */
+    private concerns;
+    /**
+     * Reads the board. A quiet reload, after a live update or a start, keeps what is shown when it
+     * fails and shows no loading state. The first time a board is shown, its visit is recorded after it
+     * was read, so it still marks what arrived since the visit before.
+     */
+    private fetch;
+    /**
+     * The board read compared with the visit before the board was opened: the first read of a board
+     * keeps its previous visit and new agents; later reads keep showing them as new.
+     */
+    private asOpened;
+    private recordVisit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentBoardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentBoardComponent, "nh-assistant-agent-board", never, { "group": { "alias": "group"; "required": true; "isSignal": true; }; "divisionId": { "alias": "divisionId"; "required": false; "isSignal": true; }; }, { "openConversation": "openConversation"; }, never, never, true, never>;
 }
 
-export { NhAssistantAgentArtifactsComponent, NhAssistantAgentConsultationsComponent, NhAssistantAgentInboxComponent, NhAssistantAgentMemoryComponent, NhAssistantAgentProposalsComponent, NhAssistantAgentThreadViewComponent, NhAssistantRunTimelineComponent, NhAssistantSubjectSuggestionsComponent };
-export type { NhAssistantAgentThreadTab };
+export { NhAssistantAgentArtifactsComponent, NhAssistantAgentBoardComponent, NhAssistantAgentConsultationsComponent, NhAssistantAgentInboxComponent, NhAssistantAgentMemoryComponent, NhAssistantAgentProposalsComponent, NhAssistantAgentThreadViewComponent, NhAssistantObjectAgentsComponent, NhAssistantRunResultComponent, NhAssistantRunTimelineComponent, NhAssistantSubjectSuggestionsComponent, NH_ASSISTANT_RUN_NOW_MAX_MESSAGE as ɵNH_ASSISTANT_RUN_NOW_MAX_MESSAGE, NhAssistantRunNowDialogComponent as ɵNhAssistantRunNowDialogComponent, NhAssistantSubjectPickerComponent as ɵNhAssistantSubjectPickerComponent, nhAssistantSubjectSearch as ɵnhAssistantSubjectSearch };
+export type { NhAssistantAgentThreadTab, NhAssistantBoardPanel, NhAssistantChosenSubject as ɵNhAssistantChosenSubject, NhAssistantRunNowAgent as ɵNhAssistantRunNowAgent, NhAssistantRunNowStarted as ɵNhAssistantRunNowStarted, NhAssistantRunNowSubject as ɵNhAssistantRunNowSubject };