@newheap/platform-ai-chat 0.13.0 → 0.15.0

package/admin/index.d.ts

@@ -1,5 +1,8 @@
 import * as _angular_core from '@angular/core';
-import { NhAssistantStore, NhAssistantError, ApplicationContext, ApplicationContextVersion, AdminAgent, ToolCatalogEntry, McpServer, SetAgentStateRequest, AgentShadowMode, AgentSkillState, AgentShadowState, AssistantAutonomy, AgentEvaluation, AgentReplay, AgentEvaluationCost, AgentProposalFeedbackCategory, AgentFeedbackSummaryRow, AgentFeedbackItem, AgentFeedbackCategoryCount, StaleKind, AgentProposalFeedbackGroup, McpServerTestResult, McpAuthMode, McpToolEffect, McpTool } from '@newheap/platform-ai-chat';
+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, AgentShadowMode, AgentSkillState, AgentShadowState, AssistantAutonomy, 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, McpToolEffect, McpTool } from '@newheap/platform-ai-chat';
+import { ɵNhAssistantRunNowAgent as _NhAssistantRunNowAgent } from '@newheap/platform-ai-chat/agent-runs';
 
 type NhAssistantAdminTab = 'context' | 'agents' | 'mcp-servers';
 /**
@@ -9,6 +12,7 @@ type NhAssistantAdminTab = 'context' | 'agents' | 'mcp-servers';
  */
 declare class NhAssistantAdminComponent {
     private readonly host;
+    private readonly injector;
     readonly store: NhAssistantStore;
     /** Tab shown first. */
     readonly initialTab: _angular_core.InputSignal<NhAssistantAdminTab>;
@@ -19,12 +23,53 @@ declare class NhAssistantAdminComponent {
     constructor();
     selected(): NhAssistantAdminTab;
     select(tab: NhAssistantAdminTab): void;
+    /**
+     * Shows the MCP servers, for example from an agent's flow that explains why a server is not used in
+     * runs without a person, and moves the focus to their tab.
+     */
+    showMcpServers(): void;
     /** Arrow keys, Home and End move between tabs as the ARIA tabs pattern describes. */
     onTabKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAdminComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAdminComponent, "nh-assistant-admin", never, { "initialTab": { "alias": "initialTab"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * The names the application knows for account ids, for the screens of the administration
+ * (internal). A screen shows the name only; it shows the id, labeled as an account ID, only while
+ * no name is known. When the lookup fails, `error` says why with the failure's code and `retry` asks
+ * for the names that are still missing, so a failure never hides behind the ids. Create it in an
+ * injection context, such as a component's field.
+ */
+declare class NhAssistantAccountNames {
+    private readonly admin;
+    private readonly translate;
+    private readonly subscriptions;
+    /** The ids whose names were asked for, also the ones the application does not know. */
+    private readonly asked;
+    /** The ids of failed lookups, which `retry` asks for again. */
+    private failed;
+    /** The names found so far, by account id. */
+    readonly names: _angular_core.WritableSignal<ReadonlyMap<string, string>>;
+    /** Why the latest lookup failed; `null` while none did. */
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    constructor();
+    /**
+     * The name of an account for a sentence, or its id labeled as an account ID ("account ID …")
+     * while the application knows no name for it.
+     */
+    nameOf(actorId: string | null | undefined): string;
+    /**
+     * The account ID as a tooltip for a name shown in its place; `null` while no name is known,
+     * because the text shows the id then.
+     */
+    idTitleOf(actorId: string | null | undefined): string | null;
+    /** Looks up the names of the ids that were not asked for yet. */
+    load(actorIds: readonly (string | null | undefined)[]): void;
+    /** Asks again for the names whose lookup failed. */
+    retry(): void;
+}
+
 /** Maximum length of the application context and of agent instructions. */
 declare const NH_ASSISTANT_MAX_INSTRUCTIONS = 20000;
 /**
@@ -50,45 +95,119 @@ declare class NhAssistantAdminContextComponent {
     readonly canSave: _angular_core.Signal<boolean>;
     readonly errorKeys: _angular_core.Signal<string[]>;
     readonly history: _angular_core.Signal<ApplicationContextVersion[]>;
+    /** The names of the people who changed the context, once known, and why they are not. */
+    readonly accountNames: NhAssistantAccountNames;
     constructor();
     /** Loads the latest version; with `keepDraft` the user's unsaved text stays in the editor. */
     load(keepDraft: boolean): void;
+    /** A person's name, or the id when the application does not know it. */
+    nameOf(actorId: string | null | undefined): string;
+    /** The account ID as the tooltip of a name shown in its place. */
+    accountTitle(actorId: string | null | undefined): string | null;
     onInput(event: Event): void;
     save(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAdminContextComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAdminContextComponent, "nh-assistant-admin-context", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * Translation keys for the texts the administration shows about agents, skills and policies. Each
+ * list goes through `nhAssistantTranslate` with the text itself as fallback, so a missing
+ * translation shows what the server sent.
+ */
+/**
+ * The key of a text of an agent in code, which names and describes itself with translation keys;
+ * none for an agent created in the administration, whose texts are what the administrator typed.
+ */
+declare function codeTextKeys(source: string, text: string | null | undefined): string[];
+/** The key an application may translate a skill's name with. */
+declare function skillNameKeys(agentId: string, skillId: string): string[];
+/**
+ * The key an application may translate a skill's description with. Skills in code describe
+ * themselves in the language triage reads; the screen shows a translation when there is one.
+ */
+declare function skillDescriptionKeys(agentId: string, skillId: string): string[];
+/** The key an application may translate an authorization policy's name with. */
+declare function policyKeys(policy: string | null | undefined): string[];
+/** A readable name for a dash-case id: `task-follow-up` reads "Task follow up". */
+declare function readableId(id: string): string;
+/** What an agent works on, ready to show: object types by name, all objects and the application. */
+interface WorksOnSummary {
+    /** The names of the object types it works on; empty with `all`. */
+    types: string[];
+    /** It works on every object type. */
+    all: boolean;
+    /** It works on the whole application. */
+    application: boolean;
+    perDivision: boolean;
+    /** An agent in code that does not say what it works on. */
+    undeclared: boolean;
+    /** The names of the object types it is known to work on, as a hint next to "All objects". */
+    known: string[];
+    runPolicy: string | null;
+    viewPolicy: string | null;
+}
+
 type AgentStateAction = SetAgentStateRequest['state'];
 /**
  * Agent administration: code agents (override, reset) and agents created here (edit, delete),
  * and for every agent its run state with pause, stop and resume, its shadow mode and that of each
  * skill, and the technical account of an agent that answers to one, each with an optional reason.
  * Editing opens `nh-assistant-admin-agent-editor`; the feedback action opens
- * `nh-assistant-agent-feedback-report` for the agent, and the evaluation action of an agent with
- * shadow variants opens `nh-assistant-agent-evaluation`.
+ * `nh-assistant-agent-feedback-report` for the agent, the evaluation action of an agent with
+ * shadow variants opens `nh-assistant-agent-evaluation`, and the run configuration action opens
+ * `nh-assistant-agent-run-configuration` for the skills, triggers and run settings defined as data.
+ * "Run now" on an agent that runs on its own opens the run-now dialog: the whole application (or a
+ * division of it) or an object of one of its types, and an optional instruction; the receipt opens
+ * the agent's conversation in the assistant panel. "Runs" opens `nh-assistant-agent-run-history`, the
+ * agent's runs with their results. When the run catalog cannot be read, the page says why with its
+ * code and offers to read it again; until then it offers no "Run now" and the editor leaves what an
+ * agent works on and its groups as they are. The run configuration opens with the agent's flow, whose
+ * entry points open the editor, the runs and the technical account here and return to the run
+ * configuration afterwards; `openMcpServers` asks the host to show the MCP servers.
  */
 declare class NhAssistantAdminAgentsComponent {
     private readonly admin;
     private readonly store;
+    private readonly panel;
+    private readonly translate;
     private readonly injector;
     private readonly host;
     private readonly backButton;
     private readonly reasonInput;
     private subscription?;
     private actionSubscription?;
+    private catalogSubscription?;
     readonly id: string;
     readonly loading: _angular_core.WritableSignal<boolean>;
     readonly loadFailed: _angular_core.WritableSignal<boolean>;
     readonly agents: _angular_core.WritableSignal<AdminAgent[]>;
     readonly tools: _angular_core.WritableSignal<ToolCatalogEntry[]>;
     readonly servers: _angular_core.WritableSignal<McpServer[]>;
+    /** The run catalog: object types by name, policies and divisions; `null` when it could not be read. */
+    readonly catalog: _angular_core.WritableSignal<RunCatalog | null>;
+    /** Why the run catalog could not be read; `null` once it was. */
+    readonly catalogError: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly catalogErrorKeys: _angular_core.Signal<string[]>;
+    /** The run catalog is being read again after a failure. */
+    readonly catalogLoading: _angular_core.WritableSignal<boolean>;
     /** `undefined`: list; `null`: new agent; an agent: editing that agent. */
     readonly editing: _angular_core.WritableSignal<AdminAgent | null | undefined>;
     /** The agent whose feedback report is shown instead of the list. */
     readonly reporting: _angular_core.WritableSignal<AdminAgent | null>;
     /** The agent whose comparison with its shadow variants is shown instead of the list. */
     readonly evaluating: _angular_core.WritableSignal<AdminAgent | null>;
+    /** The agent whose run configuration is shown instead of the list. */
+    readonly configuring: _angular_core.WritableSignal<AdminAgent | null>;
+    /** The agent whose runs are shown instead of the list. */
+    readonly viewingRuns: _angular_core.WritableSignal<AdminAgent | null>;
+    /**
+     * The agent whose run configuration opened the editor or the runs from its flow; closing them
+     * returns to its run configuration instead of the list.
+     */
+    readonly returnTo: _angular_core.WritableSignal<string | null>;
+    /** The flow of a run configuration asks to show the MCP servers, whose background use it explains. */
+    readonly openMcpServers: _angular_core.OutputEmitterRef<void>;
     readonly confirming: _angular_core.WritableSignal<{
         agentId: string;
         action: "delete" | "reset";
@@ -112,12 +231,40 @@ declare class NhAssistantAdminAgentsComponent {
         mode: "set" | "code";
     } | null>;
     readonly accountId: _angular_core.WritableSignal<string>;
+    /** Why the account of the open account form was refused, shown at the account field. */
+    readonly accountError: _angular_core.WritableSignal<NhAssistantError | null>;
+    /** The text of the account field's error: the refused field value, then the code. */
+    readonly accountErrorKeys: _angular_core.Signal<string[]>;
+    /** Whether the application offers an account search for the technical account. */
+    readonly accountSearch: _angular_core.WritableSignal<boolean>;
+    /**
+     * The names of the technical accounts and of the people who changed an agent, once known, and why
+     * they are not.
+     */
+    readonly accountNameLookup: NhAssistantAccountNames;
+    /** The names of the technical accounts in the list, by account id. */
+    readonly accountNames: _angular_core.Signal<ReadonlyMap<string, string>>;
+    /** The agent whose last action failed, so its error shows on its card. */
+    readonly errorAgentId: _angular_core.WritableSignal<string | null>;
+    /** The agent the run-now dialog runs; `null` while it is closed. */
+    readonly runningNow: _angular_core.WritableSignal<AdminAgent | null>;
+    /** The agent of the run-now dialog as the dialog needs it: its name and what it works on. */
+    readonly runNowAgent: _angular_core.Signal<_NhAssistantRunNowAgent | null>;
+    /** The run configuration opens with the guided setup, for an agent created to work on its own. */
+    readonly setupOnOpen: _angular_core.WritableSignal<boolean>;
     readonly stateReason: _angular_core.WritableSignal<string>;
     readonly maxReason = 500;
     readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
     readonly errorKeys: _angular_core.Signal<string[]>;
+    readonly codeTextKeys: typeof codeTextKeys;
+    readonly skillNameKeys: typeof skillNameKeys;
+    readonly skillDescriptionKeys: typeof skillDescriptionKeys;
+    readonly policyKeys: typeof policyKeys;
+    readonly readableId: typeof readableId;
     constructor();
     load(): void;
+    /** Reads the run catalog again after it could not be read. */
+    retryCatalog(): void;
     create(): void;
     edit(agent: AdminAgent): void;
     /** Shows what people said when they rejected the agent's proposals. */
@@ -126,10 +273,60 @@ declare class NhAssistantAdminAgentsComponent {
     variantsOf(agent: AdminAgent): string[];
     /** Compares the agent with its shadow variants. */
     openEvaluation(agent: AdminAgent): void;
+    /**
+     * Whether the agent can run on its own and so has a run configuration: an agent in code with runs,
+     * or any agent created here, which gets run settings as data.
+     */
+    hasRunConfiguration(agent: AdminAgent): boolean;
+    /**
+     * Whether the agent can be run now: it runs on its own, so it has a run configuration, it is
+     * neither stopped nor disabled in code, and the run catalog names what it can run on. The server
+     * decides the rest when the run starts.
+     */
+    canRunNow(agent: AdminAgent): boolean;
+    /** Opens the run-now dialog of the agent. */
+    runNow(agent: AdminAgent): void;
+    /** Opens the conversation the run works in, in the assistant panel. */
+    openConversation(conversationId: string): void;
+    /** Shows the agent's skills, triggers and run settings defined as data. */
+    openRunConfiguration(agent: AdminAgent, setup?: boolean): void;
+    /** Returns to the list, refreshed, and to the run configuration action of the agent. */
+    closeRunConfiguration(): void;
+    /** Shows the agent's runs with their results. */
+    openRuns(agent: AdminAgent): void;
+    /**
+     * Returns to the run configuration whose flow opened the runs, or to the list and the runs action of
+     * the agent whose runs were open.
+     */
+    closeRuns(): void;
     /** Returns to the list and to the evaluation action of the agent whose comparison was open. */
     closeEvaluation(): void;
     /** Returns to the list and to the feedback action of the agent whose report was open. */
     closeReport(): void;
+    /** A new agent meant to work on its own continues in its run configuration's guided setup. */
+    onWorkRequested(agent: AdminAgent): void;
+    /** The flow of the agent's run configuration opens the editor; saving or cancelling returns there. */
+    editFromRunConfiguration(agent: AdminAgent): 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. */
+    accountFromRunConfiguration(agent: AdminAgent): void;
+    /** The editor saved: back to the run configuration that opened it, or to the list. */
+    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. */
+    private returnToRunConfiguration;
+    /** What the agent works on, with its object types named as the run catalog names them. */
+    worksOn(agent: AdminAgent): WorksOnSummary & {
+        only: 'all' | 'types' | 'application';
+    };
+    /** The groups the agent is in, named as the run catalog names them; `null` for none. */
+    groupNames(agent: AdminAgent): string | null;
+    /** The name of an account or person, or the id when the application does not know it. */
+    accountName(actorId: string | null | undefined): string;
+    /** The account ID as the tooltip of a name shown in its place. */
+    accountTitle(actorId: string | null | undefined): string | null;
     onSaved(agent: AdminAgent): void;
     /** The state changes the agent allows: none for an agent that is disabled in code. */
     stateActions(agent: AdminAgent): AgentStateAction[];
@@ -145,11 +342,26 @@ declare class NhAssistantAdminAgentsComponent {
     shadowActions(shadow: AgentShadowState | null | undefined): AgentShadowMode[];
     /** Opens the reason form of a shadow mode change of the agent or, with a skill, of that skill. */
     askShadow(agent: AdminAgent, mode: AgentShadowMode, skill?: AgentSkillState): void;
+    /**
+     * The label of a shadow action. An agent created here has no code: returning to its "code" mode
+     * means returning to the mode it was set up with.
+     */
+    shadowActionKey(agent: AdminAgent, mode: AgentShadowMode): string;
+    /** The explanation of a shadow change of the agent or one of its skills. */
+    shadowExplainKey(agent: AdminAgent, mode: AgentShadowMode, skill: boolean): string;
+    /** The mode the agent, or one of its skills, was set up with: what returning to it means. */
+    ownShadowModeKey(agent: AdminAgent, skillId?: string): string;
     isChangingShadow(agentId: string, mode: AgentShadowMode, skillId?: string): boolean;
     applyShadow(agent: AdminAgent): void;
     /** Opens the form that changes the technical account, or returns to the one in code. */
     askAccount(agent: AdminAgent, mode: 'set' | 'code'): void;
+    /** A changed account clears the error of the one before. */
+    onAccountChange(actorId: string): void;
     isChangingAccount(agentId: string, mode: 'set' | 'code'): boolean;
+    /**
+     * Changes the technical account. The form stays open while the server decides, so a missing or
+     * refused account shows at the account field, which takes the focus.
+     */
     applyAccount(agent: AdminAgent): void;
     isChangingState(agentId: string, state: AgentStateAction, skillId?: string): boolean;
     applyState(agent: AdminAgent): void;
@@ -159,30 +371,67 @@ declare class NhAssistantAdminAgentsComponent {
     reset(agent: AdminAgent): void;
     remove(agent: AdminAgent): void;
     private run;
+    /** Looks up the names of the technical accounts and of the people who changed an agent's state. */
+    private loadAccountNames;
+    /** The run catalog, or why it could not be read; it never errors. */
+    private readCatalog;
+    private applyCatalog;
+    private focusAccount;
     /** Closes the open confirmation and change forms before another opens; one is open at a time. */
     private closeForms;
     private replace;
+    /**
+     * Reloads the agents behind the visible list, for example their skills after the run
+     * configuration changed; the list stays as it is when that fails.
+     */
+    private refreshAgents;
     /** Agent changes affect the agent picker of the panel. */
     private refreshChat;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAdminAgentsComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAdminAgentsComponent, "nh-assistant-admin-agents", never, {}, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAdminAgentsComponent, "nh-assistant-admin-agents", never, {}, { "openMcpServers": "openMcpServers"; }, never, never, true, never>;
 }
 
 /** True when a tool id matches a selector glob (`*` matches any characters). */
 declare function nhAssistantSelectorMatches(toolId: string, selector: string): boolean;
+/** How an agent created in the administration is used: chosen in the chat, working on its own, or both. */
+type AgentUse = 'chat' | 'background' | 'both';
+/** Whether an agent created in the administration works on every object type or on chosen ones. */
+type WorksOnScope = 'all' | 'types';
 /**
- * Creates or edits one agent: texts, autonomy, policy, tool selectors chosen from the tool
- * catalog or typed as patterns, and assigned MCP servers.
+ * Creates or edits one agent: how it is used (offered in the chat, working on its own, or both),
+ * what it works on (all objects or chosen object types, the whole application, per division when
+ * the application lists divisions, and who may run it and see its results for the whole
+ * application), texts, autonomy, policy, tool selectors chosen from the tool catalog or typed as
+ * patterns, and assigned MCP servers. A new agent meant to work on its own continues with
+ * `workRequested`. An agent in code names and describes itself with translation keys: the editor
+ * shows their translation and sends the key back unless the administrator changed the text, so the
+ * agent stays translated; what it works on comes from its code and is not edited here.
  */
 declare class NhAssistantAdminAgentEditorComponent {
     private readonly admin;
+    private readonly translate;
     private subscription?;
+    private keyedName;
+    private keyedDescription;
     /** The agent to edit, or null for a new agent. */
     readonly agent: _angular_core.InputSignal<AdminAgent | null>;
     readonly tools: _angular_core.InputSignal<readonly ToolCatalogEntry[]>;
     readonly servers: _angular_core.InputSignal<readonly McpServer[]>;
+    /** The run catalog: the object types by name, the policies to choose and whether divisions are listed. */
+    readonly catalog: _angular_core.InputSignal<RunCatalog | null>;
+    /**
+     * The run catalog could not be read: the editor then leaves out what the agent works on and its
+     * groups, which depend on it, and a save keeps them as they are.
+     */
+    readonly catalogUnavailable: _angular_core.InputSignal<boolean>;
     readonly saved: _angular_core.OutputEmitterRef<AdminAgent>;
+    /**
+     * A new agent meant to work on its own was created; the host continues with its run
+     * configuration's guided setup. `saved` is not emitted for it.
+     */
+    readonly workRequested: _angular_core.OutputEmitterRef<AdminAgent>;
     readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    readonly uses: readonly AgentUse[];
     readonly id: string;
     readonly max = 20000;
     readonly autonomyLevels: readonly AssistantAutonomy[];
@@ -191,19 +440,68 @@ declare class NhAssistantAdminAgentEditorComponent {
     readonly description: _angular_core.WritableSignal<string>;
     readonly instructions: _angular_core.WritableSignal<string>;
     readonly autonomy: _angular_core.WritableSignal<AssistantAutonomy>;
+    /** How the agent is used: in the chat, on its own, or both. */
+    readonly use: _angular_core.WritableSignal<AgentUse>;
     readonly requiredPolicy: _angular_core.WritableSignal<string>;
     readonly toolSelectors: _angular_core.WritableSignal<string[]>;
     readonly mcpServerIds: _angular_core.WritableSignal<string[]>;
+    /** What the agent works on: all objects or the chosen object types. */
+    readonly worksOnScope: _angular_core.WritableSignal<WorksOnScope>;
+    readonly worksOnTypes: _angular_core.WritableSignal<string[]>;
+    readonly worksOnApplication: _angular_core.WritableSignal<boolean>;
+    readonly perDivision: _angular_core.WritableSignal<boolean>;
+    readonly runPolicy: _angular_core.WritableSignal<string>;
+    readonly viewPolicy: _angular_core.WritableSignal<string>;
+    /** The groups of agents the agent is in, by id. */
+    readonly groups: _angular_core.WritableSignal<string[]>;
     readonly newSelector: _angular_core.WritableSignal<string>;
     readonly catalogFilter: _angular_core.WritableSignal<string>;
     readonly submitted: _angular_core.WritableSignal<boolean>;
     readonly saving: _angular_core.WritableSignal<boolean>;
     readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    /**
+     * A new agent that was created while its groups could not be saved yet: the next save completes it
+     * as an existing agent.
+     */
+    private readonly created;
+    /** The agent the next save updates; `null` while a new agent is not created yet. */
+    private readonly editing;
     readonly isNew: _angular_core.Signal<boolean>;
+    /** Only agents created here choose whether they are offered in the chat; code decides for the others. */
+    readonly choosesUse: _angular_core.Signal<boolean>;
     readonly idInvalid: _angular_core.Signal<boolean>;
     readonly nameMissing: _angular_core.Signal<boolean>;
     readonly tooLong: _angular_core.Signal<boolean>;
     readonly selectorInvalid: _angular_core.Signal<boolean>;
+    /**
+     * The application's own object types, by name; the platform's types, such as the whole
+     * application, are chosen otherwise. A stored type the application no longer registers stays
+     * listed by its id, so it can be unticked.
+     */
+    readonly subjectTypes: _angular_core.Signal<{
+        id: string;
+        name: string;
+        pluralName: string | null;
+    }[]>;
+    readonly agentPolicies: _angular_core.Signal<_newheap_platform_ai_chat.RunBlock[]>;
+    /** The groups of agents the application registers, which boards show. */
+    readonly agentGroups: _angular_core.Signal<_newheap_platform_ai_chat.AgentGroup[]>;
+    /** The groups the agent joins in code. */
+    readonly codeGroups: _angular_core.Signal<string[]>;
+    /** A shadow variant works for administrators only and joins no group. */
+    readonly isVariant: _angular_core.Signal<boolean>;
+    /** The server's refusal of the groups, as a translation key. */
+    readonly groupsError: _angular_core.Signal<string | null>;
+    /** Per division is offered only when the application lists its divisions. */
+    readonly divisionsListed: _angular_core.Signal<boolean>;
+    /** The object types the agent is known to work on, by name, as a hint next to "All objects". */
+    readonly knownTypes: _angular_core.Signal<string[]>;
+    /** What the agent works on is edited here: an agent created here, while the run catalog is known. */
+    readonly editsWorksOn: _angular_core.Signal<boolean>;
+    /** Chosen object types without a type, and not the application either: the agent would work on nothing. */
+    readonly worksOnMissing: _angular_core.Signal<boolean>;
+    readonly tooManyTypes: _angular_core.Signal<boolean>;
+    readonly policyKeys: typeof policyKeys;
     readonly valid: _angular_core.Signal<boolean>;
     readonly errorKeys: _angular_core.Signal<string[]>;
     readonly filteredTools: _angular_core.Signal<ToolCatalogEntry[]>;
@@ -215,13 +513,21 @@ declare class NhAssistantAdminAgentEditorComponent {
     addSelector(): void;
     onSelectorKeydown(event: KeyboardEvent): void;
     removeSelector(selector: string): void;
+    toggleWorksOnType(typeId: string, checked: boolean): void;
+    toggleGroup(groupId: string, checked: boolean): void;
     toggleServer(serverId: string, checked: boolean): void;
     value(event: Event): string;
     checked(event: Event): boolean;
+    /** The first error the server reported for a field, as a translation key. */
+    fieldError(field: string): string | null;
     save(): void;
+    /** What the agent works on, as the six fields the server reads together. */
+    private worksOnInput;
     private reset;
+    /** The translation of a key of an agent in code, or `null` when the text is not a key with a translation. */
+    private keyed;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAdminAgentEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAdminAgentEditorComponent, "nh-assistant-admin-agent-editor", never, { "agent": { "alias": "agent"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": false; "isSignal": true; }; "servers": { "alias": "servers"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "cancelled": "cancelled"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAdminAgentEditorComponent, "nh-assistant-admin-agent-editor", never, { "agent": { "alias": "agent"; "required": false; "isSignal": true; }; "tools": { "alias": "tools"; "required": false; "isSignal": true; }; "servers": { "alias": "servers"; "required": false; "isSignal": true; }; "catalog": { "alias": "catalog"; "required": false; "isSignal": true; }; "catalogUnavailable": { "alias": "catalogUnavailable"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "workRequested": "workRequested"; "cancelled": "cancelled"; }, never, never, true, never>;
 }
 
 /** Periods the evaluation offers, in days before now; the server allows at most 92. */
@@ -370,17 +676,294 @@ declare class NhAssistantAgentFeedbackReportComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAgentFeedbackReportComponent, "nh-assistant-agent-feedback-report", never, { "agentId": { "alias": "agentId"; "required": true; "isSignal": true; }; "itemsPerPage": { "alias": "itemsPerPage"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/** A filter value as the form holds it: the empty string means "any". */
+interface RunHistoryForm {
+    subjectType: string;
+    subjectId: string;
+    status: AgentRunStatus | '';
+    from: string;
+    to: string;
+}
+/**
+ * The runs view of one agent for administrators (`GET admin/agents/{id}/runs`): every run of the
+ * agent, shadow runs marked, newest first, filtered by the kind of object, one object, the whole
+ * application, the status and the period. Per run its time, trigger, object, the beginning of its
+ * result, its proposals, usage and duration; "Show the result" opens the run's whole result, its
+ * proposals and its files in `nh-assistant-run-result`. The administration's agent cards open it with
+ * "Runs". A filter the server refuses (`assistant-run-filter-invalid`) shows each refused part at its
+ * field, and a run's failure reads as its translated code.
+ */
+declare class NhAssistantAgentRunHistoryComponent {
+    private readonly admin;
+    private readonly injector;
+    private readonly host;
+    private subscription?;
+    /** The agent whose runs are shown. */
+    readonly agentId: _angular_core.InputSignal<string>;
+    /** The kinds of objects of the application, from the run catalog, to filter by. */
+    readonly subjectTypes: _angular_core.InputSignal<readonly AgentSubjectType[]>;
+    /** Emits the conversation of a run, so the host can open it in the assistant panel. */
+    readonly openConversation: _angular_core.OutputEmitterRef<string>;
+    readonly id: string;
+    readonly statuses: readonly AgentRunStatus[];
+    readonly systemType = "nh-system";
+    /** The kinds of objects, the whole application left out: it has an option of its own. */
+    readonly objectTypes: _angular_core.Signal<AgentSubjectType[]>;
+    readonly form: _angular_core.WritableSignal<RunHistoryForm>;
+    /** The period ends before it starts. */
+    readonly periodInvalid: _angular_core.WritableSignal<boolean>;
+    /** One object can be chosen once a kind of object is. */
+    readonly objectChoosable: _angular_core.Signal<boolean>;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadingMore: _angular_core.WritableSignal<boolean>;
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly errorKeys: _angular_core.Signal<string[]>;
+    /** The refused filter fields the form shows, with the server's first value per field. */
+    readonly fieldErrors: _angular_core.Signal<Partial<Record<string, string>>>;
+    readonly codeKeys: typeof _nhAssistantCodeKeys;
+    readonly items: _angular_core.WritableSignal<AgentRunHistoryItem[]>;
+    readonly total: _angular_core.WritableSignal<number>;
+    readonly page: _angular_core.WritableSignal<number>;
+    readonly hasMore: _angular_core.Signal<boolean>;
+    /** The run whose whole result is shown instead of the list. */
+    readonly opened: _angular_core.WritableSignal<AgentRunHistoryItem | null>;
+    private applied;
+    constructor();
+    /** The text of the server's error of a filter field; a refused end of the period reads as such. */
+    fieldErrorKeys(field: string): string[];
+    /** The ids a filter field describes itself with: its hint and its error while there is one. */
+    describedBy(hintId: string | null, field: string): string | null;
+    update(field: keyof RunHistoryForm, event: Event): void;
+    /** Reads the runs that match the form, from the first page. */
+    apply(): void;
+    /** Clears the filters and reads every run again. */
+    clear(): void;
+    /** Narrows the view to the runs on the object of one run. */
+    onlyObject(run: AgentRunHistoryItem): void;
+    loadMore(): void;
+    open(run: AgentRunHistoryItem): void;
+    /** Returns to the list and to the result action of the run that was open. */
+    close(): void;
+    /** How long the run took, as a text key and its number; `null` while it runs. */
+    durationOf(run: AgentRunHistoryItem): {
+        key: string;
+        value: number;
+    } | null;
+    /** Moves the focus to the first filter field the server refused. */
+    private focusRefusedField;
+    private fetch;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAgentRunHistoryComponent, never>;
+    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>;
+}
+
+/**
+ * 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.
+ */
+type AgentFlowEntry = {
+    kind: 'setup';
+} | {
+    kind: 'settings';
+} | {
+    kind: 'add-skill';
+} | {
+    kind: 'edit-skill';
+    skillId: string;
+} | {
+    kind: 'add-trigger';
+} | {
+    kind: 'edit-trigger';
+    triggerId: string;
+} | {
+    kind: 'edit-agent';
+} | {
+    kind: 'account';
+} | {
+    kind: 'runs';
+} | {
+    kind: 'mcp-servers';
+};
+
+/** What a saved skill form tells its host. */
+interface SkillFormSaved {
+    skill: DataSkill;
+    /** The change runs as the skill's candidate in shadow. */
+    candidate: boolean;
+    added: boolean;
+}
+
+type Form = 'setup' | 'settings' | 'skill' | 'trigger';
+/** A removal, promotion or discard that waits for its confirmation. */
+interface Confirmation {
+    action: 'remove-settings' | 'remove-skill' | 'remove-trigger' | 'promote' | 'discard';
+    id: string;
+}
+/**
+ * The run configuration of one agent as data: the run settings of an agent created in the
+ * administration, its skills and triggers in code (read only) and as data, and the data that no
+ * longer fits the code. It opens with the agent's flow: what it works on, when it runs, how it works,
+ * whom it answers to, who approves and its results, each step with its problems and an entry point
+ * to the form below that changes it; the agent editor (`editAgent`), the technical account of an
+ * agent in code (`changeAccount`), the runs view (`openRuns`) and the MCP servers (`openMcpServers`)
+ * belong to the page that hosts it. An agent created here that only chats gets a guided setup that
+ * lets it work on its own. Administrators add and change data skills, live at once or as a candidate in shadow that
+ * 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.
+ */
+declare class NhAssistantAgentRunConfigurationComponent implements OnInit {
+    private readonly admin;
+    private readonly translate;
+    private readonly injector;
+    private readonly host;
+    private loadSubscription?;
+    private actionSubscription?;
+    private detailSubscription?;
+    /** The flow's entry point that opened the form, which takes the focus back when the form closes. */
+    private returnFocus;
+    readonly agent: _angular_core.InputSignal<AdminAgent>;
+    /** Opens the guided setup at once, for an agent that was just created to work on its own. */
+    readonly startSetup: _angular_core.InputSignal<boolean>;
+    /** The tool catalog, to show what the agent's tool selectors offer in the skill forms and the flow. */
+    readonly tools: _angular_core.InputSignal<readonly ToolCatalogEntry[]>;
+    /**
+     * The MCP servers, so the flow shows whether the agent's servers are used in runs without a person;
+     * `null` while unknown.
+     */
+    readonly servers: _angular_core.InputSignal<readonly McpServer[] | null>;
+    /** 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. */
+    readonly editAgent: _angular_core.OutputEmitterRef<void>;
+    /** The flow asks to change the technical account of an agent in code. */
+    readonly changeAccount: _angular_core.OutputEmitterRef<void>;
+    /** The flow asks to open the agent's runs. */
+    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>;
+    readonly id: string;
+    readonly maxReason: 500;
+    readonly skillNameKeys: typeof skillNameKeys;
+    readonly skillDescriptionKeys: typeof skillDescriptionKeys;
+    readonly readableId: typeof readableId;
+    readonly loading: _angular_core.WritableSignal<boolean>;
+    readonly loadFailed: _angular_core.WritableSignal<boolean>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly catalog: _angular_core.WritableSignal<RunCatalog | null>;
+    readonly configuration: _angular_core.WritableSignal<AgentRunConfiguration | null>;
+    readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly errorKeys: _angular_core.Signal<string[]>;
+    readonly saved: _angular_core.WritableSignal<string | null>;
+    readonly form: _angular_core.WritableSignal<Form | null>;
+    readonly confirming: _angular_core.WritableSignal<Confirmation | null>;
+    readonly reason: _angular_core.WritableSignal<string>;
+    /** The item whose action failed, so its error shows next to it: `settings`, `skill:{id}` or `trigger:{id}`. */
+    readonly actionTarget: _angular_core.WritableSignal<string | null>;
+    /**
+     * The names of the account the agent answers to and of the people who changed skills, once known,
+     * and why they are not.
+     */
+    readonly accountNames: NhAssistantAccountNames;
+    /**
+     * The name of the account the agent answers to, once known: the technical account of its run
+     * settings, or of an agent in code.
+     */
+    readonly accountName: _angular_core.Signal<string | null>;
+    /** The agent's name; an agent in code names itself with a translation key. */
+    readonly agentName: _angular_core.Signal<string>;
+    /** The skill being changed; `null` with the skill form open adds a new skill. */
+    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>;
+    readonly comparison: _angular_core.WritableSignal<{
+        skillId: string;
+        result: SkillComparison | null;
+        failed: boolean;
+    } | null>;
+    readonly versions: _angular_core.WritableSignal<{
+        skillId: string;
+        items: DataSkillVersion[] | null;
+        failed: boolean;
+    } | null>;
+    private readonly language;
+    readonly isAdminAgent: _angular_core.Signal<boolean>;
+    /** An agent created in the administration gets skills and triggers once it has run settings. */
+    readonly canAddRunData: _angular_core.Signal<boolean>;
+    readonly skillOptions: _angular_core.Signal<_NhAssistantPickerOption[]>;
+    readonly skillIds: _angular_core.Signal<string[]>;
+    readonly triggerIds: _angular_core.Signal<string[]>;
+    readonly problems: _angular_core.Signal<_newheap_platform_ai_chat.RunConfigurationProblem[]>;
+    /** What the run settings' approval policy means, in a sentence. */
+    readonly settingsPolicy: _angular_core.Signal<string | null>;
+    constructor();
+    ngOnInit(): void;
+    load(openSetup?: boolean): void;
+    openSetup(): void;
+    editSettings(): void;
+    removeSettings(): void;
+    addSkill(): void;
+    editSkill(skill: DataSkill): void;
+    removeSkill(skill: DataSkill): void;
+    promote(skill: DataSkill): void;
+    discard(skill: DataSkill): void;
+    /** Shows or hides the comparison of a skill's candidate with its live version. */
+    toggleComparison(skill: DataSkill): void;
+    /** Shows or hides the version history of a skill. */
+    toggleVersions(skill: DataSkill): void;
+    addTrigger(): void;
+    editTrigger(trigger: DataTrigger): void;
+    setTriggerShadow(trigger: DataTrigger, shadow: boolean): void;
+    removeTrigger(trigger: DataTrigger): void;
+    /** A form saved: show what happened and reload, which every change may affect. */
+    onSetupCompleted(live: boolean): void;
+    onSettingsSaved(): void;
+    onSkillSaved(result: SkillFormSaved): void;
+    onTriggerSaved(added: boolean): void;
+    confirm(action: Confirmation['action'], id: string): void;
+    isConfirming(action: Confirmation['action'], id: string): boolean;
+    /**
+     * An entry point of the flow: the forms of the run configuration open below with the focus in them;
+     * the editor, the account, the runs and the MCP servers belong to the host.
+     */
+    onFlowEntry(entry: AgentFlowEntry): void;
+    cancel(): void;
+    value(event: Event): string;
+    /** A skill's name: the application's translation, or a readable form of its id. */
+    skillName(skillId: string | null | undefined): string;
+    /** A person's name, or the id when the application does not know it. */
+    nameOf(actorId: string | null | undefined): string;
+    /** The account ID as the tooltip of a name shown in its place. */
+    accountTitle(actorId: string | null | undefined): string | null;
+    /** The first of the keys with a translation, or the fallback. */
+    private translated;
+    /** Opens a form for the flow and remembers the entry point that opened it. */
+    private openFromFlow;
+    private finish;
+    /** Opens one form at a time and moves the focus into it. */
+    private open;
+    /** Whether the last failed action concerned this item, so its error shows there. */
+    failed(target: string): boolean;
+    /** 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>;
+}
+
 /** Result of the latest connection test per server. */
 interface TestState {
     running: boolean;
     result: McpServerTestResult | null;
 }
 /**
- * MCP server administration: list, connection test, tool sync, the server editor and the
- * tool table of one server.
+ * MCP server administration: list, connection test, tool sync, the organization's OAuth connection,
+ * the server editor and the tool table of one server. The personal connections are counted and
+ * revoked only for servers each person connects to with OAuth; a count that could not be read shows
+ * its translated code at the server.
  */
 declare class NhAssistantAdminMcpServersComponent {
     private readonly admin;
+    private readonly connector;
     private subscription?;
     private readonly actions;
     readonly id: string;
@@ -392,6 +975,19 @@ declare class NhAssistantAdminMcpServersComponent {
     readonly toolsOf: _angular_core.WritableSignal<McpServer | null>;
     readonly tests: _angular_core.WritableSignal<Record<string, TestState>>;
     readonly confirmingDelete: _angular_core.WritableSignal<string | null>;
+    /** The server whose organization connection is being authorized. */
+    readonly connecting: _angular_core.WritableSignal<string | null>;
+    readonly confirmingDisconnect: _angular_core.WritableSignal<string | null>;
+    readonly confirmingRevokeAll: _angular_core.WritableSignal<string | null>;
+    /** The personal connections per status of each server people connect to themselves. */
+    readonly summaries: _angular_core.WritableSignal<Record<string, McpConnectionsSummary>>;
+    /** Why the personal connections of a server could not be counted, per server. */
+    readonly summaryErrors: _angular_core.WritableSignal<Record<string, NhAssistantError>>;
+    /** The latest connection result to announce, per server. */
+    readonly notice: _angular_core.WritableSignal<{
+        serverId: string;
+        key: string;
+    } | null>;
     readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
     readonly errorKeys: _angular_core.Signal<string[]>;
     constructor();
@@ -404,6 +1000,27 @@ declare class NhAssistantAdminMcpServersComponent {
     test(server: McpServer): void;
     testState(serverId: string): TestState | null;
     testErrorKeys(code: string | null): string[];
+    /** The text of a server's failed count of personal connections. */
+    summaryErrorKeys(serverId: string): string[];
+    /** Whether an administrator connects the organization's account to the server. */
+    authorizesOrganization(server: McpServer): boolean;
+    /** Whether each person connects their own account to the server. */
+    connectsPeople(server: McpServer): boolean;
+    summary(server: McpServer): McpConnectionsSummary | null;
+    /** Revokes every person's connection of the server; each person connects again. */
+    revokeAll(server: McpServer): void;
+    /** Counts the personal connections of the servers each person connects to with OAuth; only those have them. */
+    private loadSummaries;
+    /** Counts the personal connections of one server again. */
+    retrySummary(server: McpServer): void;
+    /**
+     * Authorizes the organization's account, or for a server people connect to themselves the
+     * administrator's own account, in a window opened right away, so popup blockers allow it, and
+     * completes the connection with this administrator's session.
+     */
+    connect(server: McpServer): void;
+    /** Removes the organization connection; the server revokes its tokens. */
+    disconnect(server: McpServer): void;
     remove(server: McpServer): void;
     private setTest;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAdminMcpServersComponent, never>;
@@ -412,19 +1029,57 @@ declare class NhAssistantAdminMcpServersComponent {
 
 /**
  * What happens to the stored secret on save. `keep` omits `secret`, `replace` sends the
- * new value and `clear` sends `""`. The stored value is never shown.
+ * new value and `clear` sends `""`. The stored value is never shown. The editor offers no `clear`:
+ * the API refuses a mode with a secret that has none, so a stored secret goes by choosing a reference
+ * or a mode without a secret.
  */
 type NhAssistantSecretAction = 'keep' | 'replace' | 'clear';
-/** Creates or edits one MCP server with a write-only secret. */
+/** Where the secret is: stored here, encrypted, or a reference to a secret of the application. */
+type NhAssistantSecretSource = 'stored' | 'reference';
+/**
+ * Creates or edits one MCP server: the authentication with a write-only secret or a reference to
+ * one, OAuth with discovery the administrator confirms, an optional client certificate, the
+ * transport and the use in background runs. Every field stops at the length the server accepts; a
+ * refused save shows each of the server's field errors at its field, for example a secret reference
+ * the application cannot resolve (`not-found`), and moves the focus to the first of them.
+ */
 declare class NhAssistantAdminMcpServerEditorComponent {
     private readonly admin;
+    private readonly host;
+    private readonly injector;
     private subscription?;
+    private discoverySubscription?;
+    private modesSubscription?;
+    /** Fields whose server error the administrator changed since the refused save. */
+    private readonly touched;
     /** The server to edit, or null for a new server. */
     readonly server: _angular_core.InputSignal<McpServer | null>;
     readonly saved: _angular_core.OutputEmitterRef<McpServer>;
     readonly cancelled: _angular_core.OutputEmitterRef<void>;
     readonly id: string;
-    readonly authModes: readonly McpAuthMode[];
+    readonly limits: {
+        readonly id: 40;
+        readonly displayName: 200;
+        readonly url: 2048;
+        readonly headerName: 128;
+        readonly secret: 2000;
+        readonly secretReference: 233;
+        readonly userName: 256;
+        readonly clientCertificateReference: 100;
+        readonly requiredPolicy: 256;
+        readonly scopes: 1024;
+        readonly clientId: 512;
+        readonly clientSecret: 2000;
+        readonly organizationAccountLabel: 200;
+    };
+    readonly builtInAuthModes: readonly McpBuiltInAuthMode[];
+    /** The modes the application registered in code; none until they are loaded or when loading fails. */
+    readonly customAuthModes: _angular_core.WritableSignal<readonly McpCustomAuthMode[]>;
+    /** The built-in modes, the application's own and, kept selectable, a stored mode no longer registered. */
+    readonly authModes: _angular_core.Signal<readonly McpAuthMode[]>;
+    readonly transports: readonly McpTransport[];
+    readonly secretSources: readonly NhAssistantSecretSource[];
+    readonly connectionScopes: readonly McpConnectionScope[];
     readonly serverId: _angular_core.WritableSignal<string>;
     readonly displayName: _angular_core.WritableSignal<string>;
     readonly url: _angular_core.WritableSignal<string>;
@@ -432,28 +1087,121 @@ declare class NhAssistantAdminMcpServerEditorComponent {
     readonly headerName: _angular_core.WritableSignal<string>;
     readonly requiredPolicy: _angular_core.WritableSignal<string>;
     readonly isEnabled: _angular_core.WritableSignal<boolean>;
+    readonly headlessUse: _angular_core.WritableSignal<McpHeadlessUse>;
+    readonly userName: _angular_core.WritableSignal<string>;
+    readonly secretSource: _angular_core.WritableSignal<NhAssistantSecretSource>;
+    readonly secretReference: _angular_core.WritableSignal<string>;
+    readonly clientCertificateReference: _angular_core.WritableSignal<string>;
+    readonly transport: _angular_core.WritableSignal<McpTransport>;
     readonly secretAction: _angular_core.WritableSignal<NhAssistantSecretAction>;
     /** The new secret while typing. Never filled from the server. */
     readonly secret: _angular_core.WritableSignal<string>;
+    readonly connectionScope: _angular_core.WritableSignal<McpConnectionScope>;
+    readonly oauthClientId: _angular_core.WritableSignal<string>;
+    readonly oauthScopes: _angular_core.WritableSignal<string>;
+    readonly organizationAccountLabel: _angular_core.WritableSignal<string>;
+    readonly oauthSecretSource: _angular_core.WritableSignal<NhAssistantSecretSource>;
+    readonly oauthSecretReference: _angular_core.WritableSignal<string>;
+    readonly oauthSecretAction: _angular_core.WritableSignal<NhAssistantSecretAction>;
+    /** The new client secret while typing. Never filled from the server. */
+    readonly oauthSecret: _angular_core.WritableSignal<string>;
+    /** What discovery found for the address; the administrator confirms it on save. */
+    readonly discovery: _angular_core.WritableSignal<McpDiscovery | null>;
+    readonly discovering: _angular_core.WritableSignal<boolean>;
+    readonly discoveryError: _angular_core.WritableSignal<NhAssistantError | null>;
+    readonly confirmAuthorization: _angular_core.WritableSignal<boolean>;
     readonly submitted: _angular_core.WritableSignal<boolean>;
     readonly saving: _angular_core.WritableSignal<boolean>;
     readonly error: _angular_core.WritableSignal<NhAssistantError | null>;
     readonly isNew: _angular_core.Signal<boolean>;
+    /** A stored secret that a save keeps; a reference replaces it. */
     readonly hasSecret: _angular_core.Signal<boolean>;
+    /** The server's own secret; OAuth modes have a client secret instead. */
     readonly usesSecret: _angular_core.Signal<boolean>;
+    readonly usesReference: _angular_core.Signal<boolean>;
+    /**
+     * The organization's credential may serve background runs; a forwarded user token only as the
+     * short-lived token of the person a run acts for, after that person allowed it.
+     */
+    readonly headlessUses: _angular_core.Signal<readonly McpHeadlessUse[]>;
+    readonly isOAuth: _angular_core.Signal<boolean>;
+    readonly isClientCredentials: _angular_core.Signal<boolean>;
+    /** One authorization of the organization's account that everyone uses. */
+    readonly isOrganizationOAuth: _angular_core.Signal<boolean>;
+    /** Whose credential the application's own mode sends; null for a built-in mode. */
+    readonly customOwnership: _angular_core.Signal<"organization" | "person" | null>;
+    /**
+     * The server runs with each person's own account: a forwarded sign-in, a personal OAuth connection
+     * or a mode of the application that sends a person's credential.
+     */
+    readonly personalCredential: _angular_core.Signal<boolean>;
+    readonly hasOAuthSecret: _angular_core.Signal<boolean>;
+    readonly usesOAuthReference: _angular_core.Signal<boolean>;
+    readonly showOAuthSecretInput: _angular_core.Signal<boolean>;
+    /**
+     * The confirmed authorization server stays valid while the address and the OAuth use stay; a new
+     * server, a new address or a switch to OAuth needs discovery and the administrator's confirmation.
+     */
+    readonly needsConfirmation: _angular_core.Signal<boolean>;
+    readonly pkceMissing: _angular_core.Signal<boolean>;
+    readonly confirmMissing: _angular_core.Signal<boolean>;
+    readonly scopesInvalid: _angular_core.Signal<boolean>;
+    readonly clientIdMissing: _angular_core.Signal<boolean>;
+    readonly labelMissing: _angular_core.Signal<boolean>;
+    readonly oauthReferenceInvalid: _angular_core.Signal<boolean>;
+    /** The registration discovery offers when no client id is entered. */
+    readonly registration: _angular_core.Signal<"manual" | "metadata-document" | "dynamic" | null>;
+    readonly effectiveHeadlessUse: _angular_core.Signal<McpHeadlessUse>;
     readonly showSecretInput: _angular_core.Signal<boolean>;
     readonly idInvalid: _angular_core.Signal<boolean>;
     readonly nameMissing: _angular_core.Signal<boolean>;
     readonly urlInvalid: _angular_core.Signal<boolean>;
+    readonly userNameInvalid: _angular_core.Signal<boolean>;
+    readonly secretReferenceInvalid: _angular_core.Signal<boolean>;
+    readonly certificateInvalid: _angular_core.Signal<boolean>;
+    readonly oauthInvalid: _angular_core.Signal<boolean>;
+    readonly headerNameInvalid: _angular_core.Signal<boolean>;
     readonly valid: _angular_core.Signal<boolean>;
     readonly errorKeys: _angular_core.Signal<string[]>;
+    /** The server's first error per field of the refused save, until the administrator changes the field. */
+    readonly serverErrors: _angular_core.Signal<Readonly<Record<string, string>>>;
+    /** Field errors of fields the editor does not show, listed with the form's error. */
+    readonly otherServerErrors: _angular_core.Signal<{
+        field: string;
+        keys: string[];
+    }[]>;
+    readonly discoveryErrorKeys: _angular_core.Signal<string[]>;
     constructor();
     value(event: Event): string;
+    /** Whether the server refused the field in the last save. */
+    serverInvalid(field: string): boolean;
+    /** The text of the server's error of a field: the text of its value, then the generic text. */
+    serverErrorKeys(field: string): string[];
+    /** The id of a field's error, for `aria-describedby`. */
+    errorId(field: string): string;
+    /** The ids a control describes itself with: its hint and, while the server refused it, its error. */
+    describedBy(hintId: string | null, field: string): string | null;
+    /** The administrator changed a field; its server error no longer applies. */
+    touch(field: string): void;
     checked(event: Event): boolean;
     setSecretAction(action: NhAssistantSecretAction): void;
+    setSecretSource(source: NhAssistantSecretSource): void;
     onSecretInput(event: Event): void;
+    /** A new address makes earlier discovery meaningless. */
+    onUrlInput(event: Event): void;
+    setOAuthSecretSource(source: NhAssistantSecretSource): void;
+    onOAuthSecretInput(event: Event): void;
+    /** Reads the authorization of the address; the administrator confirms what it found. */
+    discover(): void;
     save(): void;
+    private focusFirstInvalid;
+    private valueKeys;
     private reset;
+    /**
+     * The OAuth settings as the editor shows them: every value is sent, so an emptied field clears the
+     * stored value. The client secret is write-only: sent only when replaced.
+     */
+    private oauthInput;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAdminMcpServerEditorComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAdminMcpServerEditorComponent, "nh-assistant-admin-mcp-server-editor", never, { "server": { "alias": "server"; "required": false; "isSignal": true; }; }, { "saved": "saved"; "cancelled": "cancelled"; }, never, never, true, never>;
 }
@@ -502,5 +1250,5 @@ declare class NhAssistantAdminMcpToolsComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantAdminMcpToolsComponent, "nh-assistant-admin-mcp-tools", never, { "server": { "alias": "server"; "required": true; "isSignal": true; }; }, { "closed": "closed"; "synced": "synced"; }, never, never, true, never>;
 }
 
-export { NH_ASSISTANT_MAX_INSTRUCTIONS, NhAssistantAdminAgentEditorComponent, NhAssistantAdminAgentsComponent, NhAssistantAdminComponent, NhAssistantAdminContextComponent, NhAssistantAdminMcpServerEditorComponent, NhAssistantAdminMcpServersComponent, NhAssistantAdminMcpToolsComponent, NhAssistantAgentEvaluationComponent, NhAssistantAgentFeedbackReportComponent, nhAssistantSelectorMatches };
-export type { NhAssistantAdminTab, NhAssistantEvaluationPeriod, NhAssistantFeedbackPeriod, NhAssistantSecretAction };
+export { NH_ASSISTANT_MAX_INSTRUCTIONS, NhAssistantAdminAgentEditorComponent, NhAssistantAdminAgentsComponent, NhAssistantAdminComponent, NhAssistantAdminContextComponent, NhAssistantAdminMcpServerEditorComponent, NhAssistantAdminMcpServersComponent, NhAssistantAdminMcpToolsComponent, NhAssistantAgentEvaluationComponent, NhAssistantAgentFeedbackReportComponent, NhAssistantAgentRunConfigurationComponent, NhAssistantAgentRunHistoryComponent, nhAssistantSelectorMatches };
+export type { AgentUse, NhAssistantAdminTab, NhAssistantEvaluationPeriod, NhAssistantFeedbackPeriod, NhAssistantSecretAction, NhAssistantSecretSource, WorksOnScope };