@newheap/platform-ai-chat 0.18.0 → 0.20.0

package/index.d.ts

@@ -3,6 +3,7 @@ import { InjectionToken, Type, EnvironmentProviders, Signal, AfterViewInit, OnDe
 import { Observable } from 'rxjs';
 import { TranslationObject } from '@ngx-translate/core';
 import { TemplatePortal } from '@angular/cdk/portal';
+import { SafeHtml } from '@angular/platform-browser';
 
 /**
  * Contracts of the agent-run endpoints of `NewHeap.Platform.AI.Chat.AspNet`: threads about a
@@ -11,7 +12,7 @@ import { TemplatePortal } from '@angular/cdk/portal';
 /** The caller's role on the subject of a thread. */
 type AgentSubjectRole = 'none' | 'reader' | 'participant' | 'approver';
 type AgentRunStatus = 'queued' | 'running' | 'waiting-for-approval' | 'completed' | 'failed' | 'cancelled';
-type AgentProposalStatus = 'pending' | 'approved' | 'rejected' | 'expired' | 'withdrawn' | 'stale' | 'executing' | 'executed' | 'execution-failed' | 'execution-unknown' | 'resolved' | 'shadow';
+type AgentProposalStatus = 'pending' | 'approved' | 'rejected' | 'expired' | 'withdrawn' | 'stale' | 'executing' | 'awaiting-application' | 'executed' | 'execution-failed' | 'execution-unknown' | 'resolved' | 'shadow';
 type AgentGrantSource = 'none' | 'delegated' | 'agent' | 'delegated-read' | 'accountable';
 /**
  * How a run worked: `model` through the language model, `rule` through the agent's rules without a
@@ -53,6 +54,10 @@ interface AgentRun {
     skillVersion?: number | null;
     /** The run evaluated a candidate version of its skill in the shadow thread. */
     skillCandidate?: boolean;
+    /** The version of the trigger defined as data that started the run; absent for a trigger in code. */
+    triggerVersion?: number | null;
+    /** The run evaluated a candidate version of its data trigger in the shadow thread. */
+    triggerCandidate?: boolean;
     /** The agent that handed the run's work off; missing or null for a run no agent asked for. */
     requestedByAgentId?: string | null;
     /**
@@ -440,6 +445,14 @@ interface AgentProposal {
     decidedAt: string | null;
     executionResultCode: string | null;
     executedAt: string | null;
+    /**
+     * For a proposal the application executes (`ExecuteInApplication`), until when its report of the
+     * latest hand-off is due: while it is `awaiting-application` the moment it becomes
+     * `execution-unknown`, afterwards the sign that an approver resolves it with `hand-to-application`
+     * instead of `re-execute`. `null` for a proposal never handed to the application; missing on older
+     * servers.
+     */
+    executionReportDueAt?: string | null;
     /**
      * The consultation that proposed it, when another assistant consulted the agent for
      * `initiatorActorId`; `consultationRoute` says who decides it and whose rights execute it.
@@ -610,6 +623,8 @@ interface AgentConsultationList {
 interface AgentInbox {
     items: AgentProposal[];
     total: number;
+    /** The status the page lists. Missing on older servers, which list pending proposals only. */
+    status?: AgentInboxStatus;
     /**
      * The scope whose visits mark what is new: `global`, or `division:{id}` for an inbox filtered on a
      * division. Missing on older servers.
@@ -665,7 +680,18 @@ interface AgentInboxSubjectGroup {
     continuesFromPreviousPage: boolean;
     continuesOnNextPage: boolean;
 }
+/**
+ * What the approval inbox lists (`AgentInboxFilter.status`): proposals that wait for a decision
+ * (the default), approved proposals of tools the application executes that wait for its report, and
+ * proposals whose execution is uncertain until an approver resolves it.
+ */
+type AgentInboxStatus = 'pending' | 'awaiting-application' | 'execution-unknown';
 interface AgentInboxFilter {
+    /**
+     * The status the inbox lists, with the same visibility: `pending` by expiry (the default),
+     * `awaiting-application` by report deadline, `execution-unknown` by decision.
+     */
+    status?: AgentInboxStatus;
     subjectType?: string;
     agentId?: string;
     /** Only proposals on subjects of this division; the inbox's visits are then those of the division. */
@@ -707,8 +733,12 @@ interface AgentArtifact {
 }
 /** `resume` continues the run from its last checkpoint; `restart` starts a new run in the thread. */
 type AgentRunRetryMode = 'resume' | 'restart';
-/** `re-execute` runs the proposal again; `mark-resolved` confirms its outcome without running it. */
-type AgentExecutionResolution = 're-execute' | 'mark-resolved';
+/**
+ * `re-execute` runs the proposal again; `hand-to-application` hands a proposal the application
+ * executes (one with `executionReportDueAt`) to the application again; `mark-resolved` confirms its
+ * outcome without running it.
+ */
+type AgentExecutionResolution = 're-execute' | 'hand-to-application' | 'mark-resolved';
 /** A board of a group of agents the caller may open (`getBoards`). */
 interface AgentBoardSummary {
     /** The group id, such as `project-management`. */
@@ -887,6 +917,11 @@ interface Conversation extends ConversationSummary {
     agentVersion: number;
     messages: Message[];
     pendingApproval: ApprovalPart | null;
+    /**
+     * The question the waiting turn asked with `ask_question` and waits for (`run.AllowQuestions()` on
+     * the server); missing when the conversation waits for no question and on older servers.
+     */
+    pendingQuestion?: QuestionPart | null;
     /** The owner followed by the participants; empty while the conversation is not shared. */
     members?: ConversationMember[];
     /** The current invitation-link token; only for the owner. */
@@ -962,6 +997,11 @@ interface Message {
     authorKind?: MessageAuthorKind | null;
     /** The title, sender, link and trusted flag of a message the application posted; missing for other messages. */
     application?: ApplicationMessageDetails | null;
+    /**
+     * The skill an agent message of a person's chat worked in at its end (`run.SkillsInChat()` on the
+     * server); missing for a message without a skill.
+     */
+    skillId?: string | null;
 }
 /**
  * `person` for a message a person wrote; `trigger` for one a trigger wrote into an agent thread;
@@ -990,7 +1030,38 @@ interface ApplicationMessageLink {
     /** The text of the link; the chat shows its own text without one. */
     label: string | null;
 }
-type MessagePart = TextPart | ToolCallPart | ApprovalPart | ConnectionRequiredPart | FilePart;
+type MessagePart = TextPart | ToolCallPart | ApprovalPart | ConnectionRequiredPart | FilePart | QuestionPart;
+/**
+ * `pending` while the turn waits for the answer; `answered` once the addressee chose; `expired` when
+ * nobody answered within the turn's wait limit; `cancelled` when the turn was stopped.
+ */
+type QuestionStatus = 'pending' | 'answered' | 'expired' | 'cancelled';
+/**
+ * A question the agent asked with `ask_question` in a person's chat. Only the addressee answers it,
+ * with `NhAssistantApiService.answerQuestion`; the turn waits for the answer as for an approval and
+ * continues with it. Everyone else sees it read-only.
+ */
+interface QuestionPart {
+    type: 'question';
+    questionId: string;
+    question: string;
+    /** Two to six answers, in order; the answer names the index of one. */
+    choices: string[];
+    /** The person who answers: by default the person whose turn asked. */
+    addresseeActorId: string;
+    /** After this moment an answer is refused with `assistant-question-expired`. */
+    expiresAt: string;
+    status: QuestionStatus;
+    /** The zero-based index of the chosen answer; only sent once it was answered. */
+    answerIndex?: number | null;
+    /** When it was answered, expired or cancelled; only sent then. */
+    closedAt?: string | null;
+}
+/** Body of `POST conversations/{id}/questions/{questionId}/answer`. */
+interface AnswerQuestionRequest {
+    /** The zero-based index of the chosen answer. */
+    choice: number;
+}
 /**
  * A file a person attached to a message: its name, media type and size in bytes, never its content.
  * The application keeps the file; a later turn opens it again with the rights of that turn.
@@ -1025,9 +1096,10 @@ interface TextPart {
  * `awaiting-approval` waits for a person. A call whose agent proposal closed without running ends
  * as `rejected`, as `not-executed` when the proposal expired, was withdrawn or became stale, or as
  * `failed` when its execution failed before it started; its `resultCode` is then
- * `assistant-proposal-<approval status>`, for example `assistant-proposal-expired`.
+ * `assistant-proposal-<approval status>`, for example `assistant-proposal-expired`. An `ask_question`
+ * call waits as `awaiting-answer` for the person it asked.
  */
-type ToolCallStatus = 'running' | 'succeeded' | 'failed' | 'awaiting-approval' | 'rejected' | 'not-executed';
+type ToolCallStatus = 'running' | 'succeeded' | 'failed' | 'awaiting-approval' | 'awaiting-answer' | 'rejected' | 'not-executed';
 interface ToolCallPart {
     type: 'tool-call';
     invocationId: string;
@@ -1049,9 +1121,10 @@ interface ToolCallPart {
 /**
  * Chat approvals are `pending`, `approved`, `rejected` or `expired`; proposals of agents that run on
  * their own continue through execution (`executing`, `executed`, `execution-failed`,
- * `execution-unknown`, `resolved`) or end as `withdrawn`, `stale` or `shadow`.
+ * `execution-unknown`, `resolved`, and `awaiting-application` while the application executes the
+ * proposal of a tool it declared with `ExecuteInApplication`) or end as `withdrawn`, `stale` or `shadow`.
  */
-type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired' | 'withdrawn' | 'stale' | 'executing' | 'executed' | 'execution-failed' | 'execution-unknown' | 'resolved' | 'shadow';
+type ApprovalStatus = 'pending' | 'approved' | 'rejected' | 'expired' | 'withdrawn' | 'stale' | 'executing' | 'awaiting-application' | 'executed' | 'execution-failed' | 'execution-unknown' | 'resolved' | 'shadow';
 interface ApprovalPresentationField {
     label: string;
     value: string;
@@ -1094,6 +1167,29 @@ interface ApprovalPart {
      * in the person's own request with their own rights. Missing for the conversation's own proposals.
      */
     consultation?: ApprovalConsultation | null;
+    /**
+     * The result of the execution, such as the application's code or `report-overdue`. Only sent once the
+     * proposal executed or was handed to the application; missing on older servers.
+     */
+    executionResultCode?: string;
+    /** Until when the application's report is due, for a proposal handed to the application. Only sent then. */
+    executionReportDueAt?: string;
+    /**
+     * `true` when the current user may resolve this uncertain execution in the chat (`resolveApproval`):
+     * they approved it here, it was handed to the application and its outcome is unknown. Only sent then.
+     */
+    canResolve?: boolean;
+}
+/**
+ * How the person who approved a proposal in their chat resolves its uncertain hand-off: hand it to the
+ * application again, with a new attempt and report deadline, or confirm its outcome without running it.
+ */
+type ApprovalResolution = 'hand-to-application' | 'mark-resolved';
+/** Body of `POST conversations/{id}/approvals/{approvalId}/resolve`. */
+interface ResolveApprovalRequest {
+    action: ApprovalResolution;
+    /** Why, at most 500 characters. */
+    reason?: string;
 }
 /**
  * How a consulted agent's proposal is decided and whose rights execute it: `asker-decides`, the person
@@ -1229,6 +1325,10 @@ interface ToolCompletedEvent {
     resultPreview: string | null;
 }
 type ApprovalRequiredEvent = ApprovalPart;
+/** The agent asked a person of the conversation a question; the turn waits for the answer. */
+type QuestionAskedEvent = QuestionPart;
+/** The addressee answered the question; the turn continues with the answer. */
+type QuestionAnsweredEvent = QuestionPart;
 /** The person who asked has to connect an MCP server before the agent can use it. */
 interface ConnectionRequiredEvent {
     serverId: string;
@@ -1264,6 +1364,8 @@ interface NhAssistantSseEventMap {
     'tool.started': ToolStartedEvent;
     'tool.completed': ToolCompletedEvent;
     'approval.required': ApprovalRequiredEvent;
+    'question.asked': QuestionAskedEvent;
+    'question.answered': QuestionAnsweredEvent;
     'connection.required': ConnectionRequiredEvent;
     'turn.completed': TurnCompletedEvent;
     'error': AssistantErrorEvent;
@@ -1365,6 +1467,346 @@ interface LiveConversationEvent {
     data: unknown;
 }
 
+/**
+ * Agent packages (S7-2): several agents with their configuration as data in one versioned package,
+ * exported with `POST admin/agent-packages/export`, previewed and imported on another host with
+ * `POST admin/agent-packages/preview` and `.../import` through the same validators as saving, and
+ * parts the package locks against local changes until an administrator unlinks them with
+ * `POST admin/agents/{id}/package/unlink`. The names are those of the server's JSON (camelCase).
+ */
+
+/** The `format` of every agent package. */
+declare const NH_ASSISTANT_AGENT_PACKAGE_FORMAT = "newheap.assistant.agent-package";
+/** The format version this library reads and writes; a newer one is refused. */
+declare const NH_ASSISTANT_AGENT_PACKAGE_FORMAT_VERSION = 1;
+/** The largest package in bytes of its UTF-8 JSON: 1 MB (`assistant-package-too-large` above). */
+declare const NH_ASSISTANT_AGENT_PACKAGE_MAX_BYTES = 1048576;
+/** The most agents of one package. */
+declare const NH_ASSISTANT_AGENT_PACKAGE_MAX_AGENTS = 20;
+/**
+ * The kinds of part of an agent in a package. A part key is `agent`, `runSettings`, or
+ * `{kind}:{id}` for a skill or trigger id, the subject type of a consultation or hand-off and the
+ * name of an entry of agent metadata, such as `skill:triage`.
+ */
+type AgentPackagePartKind = 'agent' | 'runSettings' | 'skill' | 'trigger' | 'consultation' | 'handOff' | 'metadata';
+/** The lock of a whole part, instead of a list of its fields. */
+declare const NH_ASSISTANT_PACKAGE_LOCK_ALL = "*";
+/**
+ * The fields a package may lock per part kind (`NhAssistantPackageLockFields`). A save that changes a
+ * locked field is refused with the field error `{field}: locked`, named as here; `worksOn`,
+ * `dailyBudget`, `files` and `limits` each stand for the fields the forms show together. An agent in
+ * code carries only the first six fields of `agent`.
+ */
+declare const NH_ASSISTANT_PACKAGE_LOCK_FIELDS: Readonly<Record<AgentPackagePartKind, readonly string[]>>;
+/**
+ * A versioned agent package: several agents with what belongs to each of them as data. It never holds
+ * history, candidates, runs, feedback, run state, shadow overrides, MCP server definitions, the
+ * technical account or secrets; references travel as names. The server reads it strictly: an unknown
+ * property, a missing required one, another `format` or a newer `formatVersion` is refused with
+ * `assistant-package-format-unsupported`.
+ */
+interface AgentPackage {
+    /** Always `newheap.assistant.agent-package`. */
+    format: string;
+    formatVersion: number;
+    package: AgentPackageInfo;
+    /** 1 to 20 agents, each id once. */
+    agents: PackageAgent[];
+}
+/** The identity of an agent package. */
+interface AgentPackageInfo {
+    /** A dash-case id, at most 128 characters; by default the first agent's id. */
+    id: string;
+    /** 1 or higher; an upgrade of a linked package has a higher version. */
+    version: number;
+    /** What the package is for, at most 500 characters. */
+    description?: string | null;
+}
+/**
+ * One agent in a package: an agent created in the administration travels whole, an agent in code as
+ * an overlay of what data may change on it, which the import applies to the same agent in code.
+ */
+interface PackageAgent {
+    /** The agent's id, kept on import. */
+    id: string;
+    /** `admin` for an agent created in the administration, `code` for an overlay of an agent in code. */
+    source: 'admin' | 'code';
+    /** The definition of an agent created here, or the overrides of an agent in code (part `agent`). */
+    definition?: PackageAgentDefinition | null;
+    /** The run settings of an agent created here, without the technical account (part `runSettings`). */
+    runSettings?: PackageRunSettings | null;
+    skills?: PackageSkill[] | null;
+    triggers?: PackageTrigger[] | null;
+    consultations?: PackageConsultation[] | null;
+    /** The hand-offs defined as data that the agent accepts. */
+    handOffs?: PackageHandOff[] | null;
+    /** Its values of entries of agent metadata by name; for an agent in code only overrides of editable entries. */
+    metadata?: Record<string, unknown> | null;
+    /** The groups of agents it is in, by id. */
+    groups?: string[] | null;
+    /** The locked fields per part key, each `['*']` or fields of `NH_ASSISTANT_PACKAGE_LOCK_FIELDS`. */
+    locks?: Record<string, string[]> | null;
+    /** The SHA-256 of each part's canonical JSON by part key, lowercase hex; optional for a package a tool writes. */
+    hashes?: Record<string, string> | null;
+}
+/**
+ * The definition of an agent. For an agent in code only `displayName`, `description`, `instructions`,
+ * `toolSelectors`, `requiredPolicy` and `autonomy` apply; a missing value keeps the code's.
+ */
+interface PackageAgentDefinition {
+    displayName?: string | null;
+    description?: string | null;
+    instructions?: string | null;
+    instructionsAsset?: InstructionAssetReference | null;
+    toolSelectors?: string[] | null;
+    requiredPolicy?: string | null;
+    autonomy?: AssistantAutonomy | null;
+    offeredInChat?: boolean | null;
+    worksOnSubjectTypes?: string[] | null;
+    worksOnAllSubjects?: boolean | null;
+    worksOnApplication?: boolean | null;
+    perDivision?: boolean | null;
+    runPolicy?: string | null;
+    viewPolicy?: string | null;
+    profile?: string | null;
+    dataClassification?: AssistantDataClassification | null;
+    /** For a new agent: it starts off. */
+    startsOff?: boolean | null;
+    /** For a new agent: it starts in shadow. */
+    startsInShadow?: boolean | null;
+    /** The live agent a data shadow variant belongs to: another agent of the package or one the host has. */
+    shadowOf?: string | null;
+}
+/** The run settings of an agent created in the administration; the technical account never travels. */
+interface PackageRunSettings {
+    accountability: AgentAccountability;
+    delegateFromInitiator?: boolean;
+    allowGatewayReads?: boolean;
+    elevatedReads?: AgentElevatedReads | null;
+    approvalPolicy?: string | null;
+    retryCount?: number | null;
+    dailyToolCalls?: number | null;
+    dailyTokens?: number | null;
+    maxConcurrentRuns?: number | null;
+    maxRunsPerSubjectPerDay?: number | null;
+    maxTokensPerRun?: number | null;
+    triageProfile?: string | null;
+    ruleHandler?: string | null;
+    acceptsFiles?: boolean;
+    maxFileBytes?: number | null;
+    maxFilePages?: number | null;
+    maxFilesPerTurn?: number | null;
+    maxFileTokensPerTurn?: number | null;
+}
+/** The live version of a data skill. */
+interface PackageSkill {
+    id: string;
+    description: string;
+    instructions?: string | null;
+    instructionsAsset?: InstructionAssetReference | null;
+    tools?: string[] | null;
+    profile?: string | null;
+    ruleHandler?: string | null;
+    maxTokensPerRun?: number | null;
+    dailyToolCalls?: number | null;
+    dailyTokens?: number | null;
+    approvalPolicy?: string | null;
+    dataClassification?: AssistantDataClassification | null;
+    acceptsFiles?: boolean;
+    maxFileBytes?: number | null;
+    maxFilePages?: number | null;
+    maxFilesPerTurn?: number | null;
+    maxFileTokensPerTurn?: number | null;
+    /** For a new skill: it starts off. */
+    startsOff?: boolean | null;
+}
+/** The live version of a data trigger; its id stays on import. */
+interface PackageTrigger {
+    id: string;
+    source: 'event' | 'schedule';
+    skill?: string | null;
+    event?: string | null;
+    filters?: string[] | null;
+    cron?: string | null;
+    timeZone?: string | null;
+    subjectSet?: string | null;
+    message?: string | null;
+    conflict?: TriggerConflict | null;
+    debounceSeconds?: number | null;
+}
+/** A consultation defined as data. */
+interface PackageConsultation {
+    subjectType: string;
+    description: string;
+    instructions?: string | null;
+    minimumRole?: ConsultationSubjectRole | null;
+    askerPolicy?: string | null;
+    routes?: NhAssistantConsultationRoute[] | null;
+    proposalRole?: ConsultationSubjectRole | null;
+    proposalPolicy?: string | null;
+    toolSelectors?: string[] | null;
+    maxToolCalls?: number | null;
+    timeoutSeconds?: number | null;
+    maxAnswerChars?: number | null;
+    maxHistoryMessages?: number | null;
+    allowRequests?: boolean;
+    exposeToMcp?: boolean;
+    dataClassification?: AssistantDataClassification | null;
+    /** For a new consultation: it starts off. */
+    startsOff?: boolean | null;
+}
+/** A hand-off defined as data that the agent accepts; a source may be another agent of the package. */
+interface PackageHandOff {
+    subjectType: string;
+    sources: string[];
+    description?: string | null;
+    notifySource?: boolean;
+    maxPerSubjectPerDay?: number | null;
+}
+/** How an export builds its package. */
+interface AgentPackageExportOptions {
+    /** By default the id of the package the first agent is linked to, otherwise the first agent's id. */
+    packageId?: string | null;
+    /** By default the next version after the linked package's, otherwise 1. */
+    version?: number | null;
+    /** At most 500 characters. */
+    description?: string | null;
+    /** Per agent id, the locked fields per part key, each `['*']` or lockable fields of the part's kind. */
+    locks?: Record<string, Record<string, string[]>> | null;
+}
+/** Body of `POST admin/agent-packages/export`. */
+interface AgentPackageExportRequest {
+    /** The agents to export, 1 to 20; exactly these. */
+    agentIds: string[];
+    options?: AgentPackageExportOptions | null;
+}
+/** What a reference to an agent outside the exported selection is. */
+type AgentPackageWarningCode = 'hand-off-source' | 'shadow-of' | 'consultation-asker' | 'shadow-variant' | (string & {});
+/** A reference of an exported agent to an agent outside the selection, which must exist where the package is imported. */
+interface AgentPackageWarning {
+    /** The exported agent. */
+    agentId: string;
+    /** The part that makes the reference, such as `handOff:project`. */
+    part: string;
+    code: AgentPackageWarningCode;
+    /** The agent outside the selection. */
+    referencedAgentId: string;
+}
+/**
+ * An exported package as `exportAgentPackage` answers it: the package, its JSON exactly as the server
+ * wrote it for the download, and the references to agents outside the selection.
+ */
+interface AgentPackageExport {
+    package: AgentPackage;
+    /** The JSON of the download, `agent-package-{packageId}.json`. */
+    json: string;
+    /** Every reference to an agent outside the selection (header `X-NewHeap-Package-Warnings`). */
+    warnings: AgentPackageWarning[];
+}
+/** A part of an agent; without `part` every part of the agent. */
+interface PackagePartReference {
+    agentId: string;
+    part?: string | null;
+}
+/** How an import applies a package. */
+interface AgentPackageImportOptions {
+    /**
+     * Per agent id, the technical account on this host for run settings that answer to one; without it
+     * such run settings are refused with `serviceAccountActorId: required`.
+     */
+    serviceAccounts?: Record<string, string> | null;
+    /**
+     * `live` (default): a changed skill or trigger becomes its new live version; `shadow`: its candidate
+     * next to the live version. New skills and triggers start in shadow either way.
+     */
+    apply?: SkillApplyMode | null;
+    /** Unlinked parts that take the package's version again instead of staying `kept-local`. */
+    relink?: PackagePartReference[] | null;
+}
+/** Body of `POST admin/agent-packages/preview` and `POST admin/agent-packages/import`. */
+interface AgentPackageImportRequest {
+    /** The package as JSON; the server reads it strictly. */
+    package: AgentPackage;
+    options?: AgentPackageImportOptions | null;
+}
+/** What an import does or did with one part. */
+type AgentPackagePartOutcome = 'created' | 'changed' | 'unchanged' | 'kept-local' | 'left-behind' | 'refused';
+/** The outcome of one part in a preview or an import. */
+interface AgentPackagePart {
+    agentId: string;
+    /** The part key, such as `agent` or `skill:triage`. */
+    part: string;
+    outcome: AgentPackagePartOutcome;
+    /** The host's part changed after the last import: the import overwrites its unlocked fields. */
+    changedLocally: boolean;
+    /** For a refused part without field errors: its failure code, such as `assistant-agent-exists`. */
+    code: string | null;
+    /** For a refused part: the field errors of the save validators, by field. */
+    errors: Record<string, string[]> | null;
+    /** The fields the package locks on the part, `['*']` for all. */
+    lockedFields: string[];
+    /** For a skill or trigger an import makes a candidate of (`apply: shadow`): the candidate's version. */
+    candidateVersion?: number | null;
+}
+/** What an import would do: the parts per agent in dependency order, left-behind agents and parts last. */
+interface AgentPackagePreview {
+    packageId: string;
+    packageVersion: number;
+    /** The version of the package the host has; `null` for a package it does not have. */
+    installedVersion: number | null;
+    /** No part is refused. */
+    importable: boolean;
+    parts: AgentPackagePart[];
+}
+/** What an import did: every part's outcome, as the preview showed it. */
+interface AgentPackageImport {
+    packageId: string;
+    packageVersion: number;
+    /** The SHA-256 of the package's canonical JSON, lowercase hex, as audited. */
+    hash: string;
+    parts: AgentPackagePart[];
+}
+/** Body of `POST admin/agents/{id}/package/unlink`. */
+interface AgentPackageUnlinkRequest {
+    /** The part key to unlink; `null` or missing unlinks the whole agent. */
+    part?: string | null;
+    /** At most 500 characters. */
+    reason?: string | null;
+}
+/** The parts an unlink took out of their package. */
+interface AgentPackageUnlink {
+    agentId: string;
+    packageId: string;
+    /** The part keys that are now local. */
+    parts: string[];
+}
+/**
+ * The package link of one part, as the administration shows it next to the part: the package it came
+ * from and the fields that stay read-only.
+ */
+interface PackagePartLink {
+    part: string;
+    packageId: string;
+    /** The version of the package the part was imported from. */
+    packageVersion: number;
+    /** The locked fields, `['*']` for all; empty when the package locks none. */
+    lockedFields: string[];
+    /** The SHA-256 of the part's canonical JSON at import. */
+    hash: string;
+    /** The part changed after its import; the next upgrade overwrites its unlocked fields. */
+    changedLocally: boolean;
+    linkedAt: string;
+    linkedBy: string;
+}
+/** The package an agent belongs to, with the link of every part that is still linked. */
+interface AgentPackageLink {
+    packageId: string;
+    /** The version of the package the host has. */
+    packageVersion: number;
+    /** The linked parts, ordered by part key. */
+    parts: PackagePartLink[];
+}
+
 type AssistantStyle = 'default' | 'direct' | 'personal' | 'detailed';
 type AssistantAddressForm = 'informal' | 'formal';
 type AssistantResponseLength = 'short' | 'normal' | 'long';
@@ -1486,6 +1928,20 @@ interface AdminAgentInput {
      * update.
      */
     startsOff?: boolean;
+    /**
+     * On create only: the new agent starts in shadow, so once it has run settings, also when they are
+     * saved right after, its runs work in its shadow threads, where nobody is notified and nothing
+     * executes, until someone puts it live with `setAgentShadow`. Omitted starts it live; ignored on
+     * update.
+     */
+    startsInShadow?: boolean;
+    /**
+     * For an agent created in the administration: values of the run catalog's `agentMetadata` entries
+     * by name, saved with the definition's version; `null` removes one, entries left out keep theirs.
+     * Field errors are `metadata.<name>`. An agent in code changes its editable entries one by one with
+     * `saveAgentMetadata`.
+     */
+    metadata?: Record<string, unknown>;
     /**
      * For an agent created in the administration: the model profile of its model calls, one of the run
      * catalog's `profiles` (`profile: not-found` otherwise). Omitted keeps it on update; a new agent uses
@@ -1499,6 +1955,66 @@ interface AdminAgentInput {
      * Agents in code take it from their code.
      */
     dataClassification?: AssistantDataClassification | null;
+    /**
+     * On create only: the live agent the new agent is a data shadow variant of, within the ceiling in
+     * code (`UseShadowVariantsAsData`). The variant receives every trigger of the live agent once it has
+     * run settings, always works in shadow, is never offered in the chat and never changes its live
+     * agent. Outside the ceiling it fails with `assistant-shadow-variants-not-allowed`, beyond its number
+     * of variants with `assistant-configuration-limit`, and with the field errors `shadowOf: not-found`
+     * and `shadowOf: invalid` for a live agent without a run configuration or one that is no live agent.
+     * Ignored on update.
+     */
+    shadowOf?: string | null;
+    /**
+     * For an agent created in the administration, when the run catalog reports `instructionAssets`:
+     * the application's asset its instructions come from instead of `instructions`, which is then
+     * empty. The save checks it with the application (`instructionsAsset: not-found`,
+     * `instructionsAsset.hash: invalid`). Omitted or `null` keeps or makes the instructions text.
+     */
+    instructionsAsset?: InstructionAssetReference | null;
+}
+/**
+ * The asset of the application a skill version or an agent created in the administration takes its
+ * instructions from: its id, exact version and the SHA-256 of its content. A new version of the asset
+ * takes effect only when an administrator saves it as the next version.
+ */
+interface InstructionAssetReference {
+    assetId: string;
+    version: number;
+    /** The SHA-256 of the asset's content, lowercase hex. */
+    hash: string;
+}
+/**
+ * Why instructions from an asset are not available: the application no longer has a source, the asset
+ * is missing, its text changed since it was saved, it cannot be instructions, or the source failed.
+ */
+type InstructionAssetProblem = 'no-asset-source' | 'asset-missing' | 'asset-changed' | 'asset-invalid' | 'asset-unavailable';
+/** One of the application's assets, without its content (`GET admin/instruction-assets`). */
+interface InstructionAssetSummary {
+    assetId: string;
+    version: number;
+    /** The hash its manifest states; a save checks it against the content. */
+    hash: string;
+    /** The asset that replaces it, when the application deprecated it. */
+    replacedByAssetId?: string | null;
+    deprecatedAt?: string | null;
+}
+/** The application's assets an administrator may choose as instructions. */
+interface InstructionAssetList {
+    /** Whether the application registered a text asset source. */
+    supported: boolean;
+    /** The assets it lists, in its order; empty when it lists none, so the id and version are typed. */
+    assets: InstructionAssetSummary[];
+}
+/** The text of one asset, read-only (`GET admin/instruction-assets/{id}/versions/{version}`). */
+interface InstructionAssetText {
+    assetId: string;
+    version: number;
+    /** The SHA-256 of `content`: the hash a reference stores. */
+    hash: string;
+    content: string;
+    /** `asset-invalid` when the asset cannot be instructions, so a save refuses it. */
+    problem?: InstructionAssetProblem | null;
 }
 /** Body of `PUT admin/agents/{id}`. */
 type UpdateAdminAgentRequest = AdminAgentInput & {
@@ -1580,6 +2096,18 @@ interface AdminAgent extends AdminAgentInput {
      * its classification. A warning never refuses a save; missing on older servers.
      */
     warnings?: AssistantConfigurationWarning[];
+    /**
+     * Why the instructions of `instructionsAsset` are not available: the agent then starts no model
+     * turn and `instructions` is empty. `null` when they resolve; missing on older servers. With an
+     * asset that resolves, `instructions` is its text, read-only.
+     */
+    instructionsProblem?: InstructionAssetProblem | null;
+    /**
+     * The agent package the agent belongs to, with every linked part and its locked fields, which the
+     * administration shows read-only; missing for an agent that belongs to none. Its part `agent` locks
+     * fields of the definition.
+     */
+    package?: AgentPackageLink | null;
 }
 /** The groups one agent is in, as `setAgentGroups` answers. */
 interface AdminAgentGroups {
@@ -2262,6 +2790,78 @@ interface RunCatalog {
      * older servers.
      */
     consultationCeiling?: ConsultationCeiling | null;
+    /**
+     * The entries of agent metadata the application registers with `AddAgentMetadata`, ordered by name:
+     * the slots of the agent editor; missing on older servers.
+     */
+    agentMetadata?: AgentMetadataEntry[];
+    /**
+     * Whether the application registered a text asset source, so skills and agents created here may take
+     * their instructions from its assets; missing on older servers.
+     */
+    instructionAssets?: boolean;
+}
+/** An entry of agent metadata registered in code with `AddAgentMetadata`. */
+interface AgentMetadataEntry {
+    /** The entry's dash-case name. */
+    name: string;
+    /** Administrators may change it on agents in code, as an override. */
+    editable: boolean;
+    /** The largest value in bytes of its JSON. */
+    maxBytes: number;
+    /** It declares a searchable value with `IndexBy`, or several with `IndexByEach`. */
+    indexed: boolean;
+    /** It declares several searchable values with `IndexByEach`. */
+    indexedByEach?: boolean;
+}
+/** Where the value of an agent's metadata entry comes from. */
+type AgentMetadataSource = 'code' | 'override' | 'data';
+/**
+ * One entry of agent metadata of one agent (`GET admin/agents/{id}/metadata`): the application's own
+ * data about the agent, which NewHeap stores and checks but never interprets.
+ */
+interface AgentMetadata {
+    name: string;
+    /**
+     * Whether it changes here: always for an agent created here, for an agent in code only when the
+     * entry is editable.
+     */
+    editable: boolean;
+    maxBytes: number;
+    /** Where the value in effect comes from; `null` without a value. */
+    source: AgentMetadataSource | null;
+    /** The value in effect, in the shape of the entry's type; `null` without one. */
+    value: unknown;
+    /**
+     * The version a change sends as `expectedVersion`: the agent's version for an agent created here,
+     * the override's version for an agent in code, `null` while it has no override.
+     */
+    version: number | null;
+    /** The agent's version: a change of an agent created here makes its next version. */
+    agentVersion: number;
+    /** The value in code of an agent in code, next to an override. */
+    codeValue?: unknown;
+    indexed?: boolean;
+    /** The searchable value of the value in effect, trimmed and in lowercase. */
+    indexValue?: string | null;
+    /** Whether the entry declares several searchable values with `IndexByEach`. */
+    indexedByEach?: boolean;
+    /** The searchable values of an `IndexByEach` entry's value in effect, trimmed, in lowercase and ordered. */
+    indexValues?: string[];
+    changedAt?: string | null;
+    changedBy?: string | null;
+    /**
+     * The link of the entry (part `metadata:{name}`) to the agent package it was imported from, with its locked
+     * fields, which the administration shows read-only; missing when it is not linked.
+     */
+    package?: PackagePartLink | null;
+}
+/** Body of `PUT admin/agents/{id}/metadata/{name}`. */
+interface AgentMetadataRequest {
+    /** The value in the shape of the entry's type (camelCase); required. */
+    value: unknown;
+    /** The entry's `version` the change was made on; `null` for a new override of an agent in code. */
+    expectedVersion: number | null;
 }
 /**
  * A ceiling in code of consultations defined as data: the routes their proposals may use (empty allows
@@ -2284,6 +2884,11 @@ interface ConsultationCeiling {
     maxConsultations: number;
     /** The longest instructions of a consultation defined as data. */
     maxInstructionsLength: number;
+    /**
+     * Every new consultation defined as data starts off until an administrator switches it on
+     * (`StartOff()` in code); missing on older servers.
+     */
+    startsOff?: boolean;
 }
 /**
  * File limits: the largest file in bytes, the most pages of one file, the most files of one turn and
@@ -2366,7 +2971,7 @@ interface AssistantAccount {
     detail: string | null;
 }
 /** Which part of the run configuration a problem concerns. */
-type RunConfigurationProblemKind = 'agent' | 'skill' | 'candidate' | 'trigger' | 'consultation';
+type RunConfigurationProblemKind = 'agent' | 'skill' | 'candidate' | 'trigger' | 'trigger-candidate' | 'consultation' | 'hand-off';
 /**
  * Data that is out of effect because it no longer fits the code, for example after a deploy removed
  * a profile, policy, rule handler, event or subject set it names. A consultation defined as data may
@@ -2414,6 +3019,11 @@ interface AgentRunSettings extends LowerFileLimits {
      * agent.
      */
     acceptsFiles?: boolean;
+    /**
+     * The link of the run settings (part `runSettings`) to the agent package it was imported from, with its locked
+     * fields, which the administration shows read-only; missing when it is not linked.
+     */
+    package?: PackagePartLink | null;
 }
 /** Body of `PUT admin/agents/{id}/run-settings`. */
 interface AgentRunSettingsRequest extends LowerFileLimits {
@@ -2539,6 +3149,17 @@ interface DataSkill extends LowerFileLimits {
      * classification, or else its agent's. A warning never refuses a save; missing on older servers.
      */
     warnings?: AssistantConfigurationWarning[];
+    /**
+     * The application's asset the version takes its instructions from; `null` for inline instructions
+     * or none, missing on older servers. `problem` says when it no longer resolves to
+     * `instructionsHash`; read its text with `getInstructionAsset`.
+     */
+    instructionsAsset?: InstructionAssetReference | null;
+    /**
+     * The link of the skill (part `skill:{id}`) to the agent package it was imported from, with its locked
+     * fields, which the administration shows read-only; missing when it is not linked, and on a candidate.
+     */
+    package?: PackagePartLink | null;
 }
 /** How a change of a skill takes effect: at once, or as a candidate in shadow next to the live version. */
 type SkillApplyMode = 'live' | 'shadow';
@@ -2573,6 +3194,13 @@ interface DataSkillRequest extends LowerFileLimits {
     dataClassification?: AssistantDataClassification | null;
     /** A run in the skill reads files when its agent accepts them too; `false` by default. */
     acceptsFiles?: boolean;
+    /**
+     * The application's asset the version takes its instructions from, instead of `instructions`
+     * (`instructions: not-allowed` next to it), when the run catalog reports `instructionAssets`. The
+     * save checks it with the application: `instructionsAsset: not-found`, `instructionsAsset.hash:
+     * invalid` and `instructionsAsset: invalid`.
+     */
+    instructionsAsset?: InstructionAssetReference | null;
 }
 type DataSkillVersionStatus = 'live' | 'candidate' | 'superseded' | 'discarded';
 /** One version in the history of a skill defined as data. */
@@ -2584,6 +3212,8 @@ interface DataSkillVersion {
     createdAt: string;
     createdBy: string;
     reason: string | null;
+    /** The application's asset the version takes its instructions from; missing on older servers. */
+    instructionsAsset?: InstructionAssetReference | null;
 }
 /** Body of `POST admin/agents/{id}/skills/{skillId}/candidate/promote` and `.../discard`. */
 interface SkillCandidateRequest {
@@ -2658,6 +3288,20 @@ interface DataTrigger {
      * Missing on older servers.
      */
     filters?: string[];
+    /**
+     * The candidate version that fires in shadow next to this live version, for the trigger's own agent
+     * and into its shadow threads; missing or null without one. Its `inEffect` and `problem` are its own
+     * (kind `trigger-candidate`), and its `shadow` is always `true`.
+     */
+    candidate?: DataTrigger | null;
+    /** When the version was stored and by whom; missing on older servers. */
+    createdAt?: string;
+    createdBy?: string;
+    /**
+     * The link of the trigger (part `trigger:{id}`) to the agent package it was imported from, with its locked
+     * fields, which the administration shows read-only; missing when it is not linked, and on a candidate.
+     */
+    package?: PackagePartLink | null;
 }
 /** Body of `PUT admin/agents/{id}/triggers/{triggerId}`. */
 interface DataTriggerRequest {
@@ -2689,6 +3333,52 @@ interface DataTriggerRequest {
      * `assistant-trigger-filter-not-found`; a schedule takes none.
      */
     filters?: string[] | null;
+    /**
+     * For a change of a trigger, `live` by default: the version takes effect at once in the trigger's
+     * mode; `shadow` makes it the candidate that fires in shadow next to the live version, which keeps
+     * working, until it is promoted or discarded. A new trigger fails with `apply: invalid`.
+     */
+    apply?: SkillApplyMode;
+}
+/** One version in the history of a trigger defined as data, with its definition. */
+interface DataTriggerVersion {
+    version: number;
+    status: DataSkillVersionStatus;
+    skillId: string | null;
+    source: 'event' | 'schedule';
+    event: string | null;
+    filters: string[];
+    cron: string | null;
+    timeZone: string | null;
+    subjectSet: string | null;
+    message: string | null;
+    conflict: TriggerConflict;
+    debounceSeconds: number;
+    createdAt: string;
+    createdBy: string;
+    reason: string | null;
+}
+/** Body of `POST admin/agents/{id}/triggers/{triggerId}/candidate/promote` and `.../discard`. */
+type TriggerCandidateRequest = SkillCandidateRequest;
+/**
+ * Response of `GET admin/agents/{id}/triggers/{triggerId}/candidate/comparison`: the live version and
+ * the candidate on the runs they started, with the version statistics of the skill comparison. Counts
+ * only.
+ */
+interface TriggerComparison {
+    agentId: string;
+    triggerId: string;
+    from: string;
+    to: string;
+    live: SkillVersionStats;
+    candidate: SkillVersionStats;
+    /** The events both versions started a run for. */
+    pairedEvents: number;
+    /** The events only the live version started a run for, such as those a filter of the candidate refuses. */
+    liveOnlyEvents: number;
+    /** The events only the candidate started a run for. */
+    candidateOnlyEvents: number;
+    tools: SkillComparisonTool[];
 }
 /** Body of `POST admin/agents/{id}/triggers/{triggerId}/shadow`. */
 interface DataTriggerShadowRequest {
@@ -2750,6 +3440,11 @@ interface CodeConsultation {
     requestToolId: string | null;
     /** The agents whose tool selectors select the consult tool now, by id. */
     askingAgents: string[];
+    /**
+     * The tools the consulted agent is offered, from `Tools(...)` in code; `null` offers every tool of the
+     * agent. Missing on older servers.
+     */
+    toolSelectors?: string[] | null;
 }
 /**
  * A consultation defined as data: other assistants may consult the agent about subjects of one type.
@@ -2799,6 +3494,14 @@ interface DataConsultation {
     problems: string[];
     /** The routes in effect: those saved that still fit the ceiling and the agent, before its route switches. */
     routesInEffect: NhAssistantConsultationRoute[];
+    /** The tool selection as saved; `null` offers every tool of the agent. Missing on older servers. */
+    toolSelectors?: string[] | null;
+    /**
+     * The tool selection in effect: the saved selectors the agent's own selectors still cover. `null`
+     * offers every tool of the agent; empty offers none, when every selector dropped with the problem
+     * `tools-not-allowed`, or while the consultation is out of effect. Missing on older servers.
+     */
+    toolSelectorsInEffect?: string[] | null;
     /** The id of the generated consult tool, which asking agents select. */
     consultToolId: string;
     /** The id of the generated request tool while requests are in effect. */
@@ -2807,6 +3510,24 @@ interface DataConsultation {
     askingAgents: string[];
     createdAt: string;
     createdBy: string;
+    /**
+     * The consultation is switched off: it is not offered until an administrator switches it on with
+     * `setDataConsultationState`; `inEffect` is then `false` without a problem. Missing on older servers.
+     */
+    off?: boolean;
+    /**
+     * The link of the consultation (part `consultation:{subjectType}`) to the agent package it was imported from, with its locked
+     * fields, which the administration shows read-only; missing when it is not linked.
+     */
+    package?: PackagePartLink | null;
+}
+/** The state of a consultation defined as data an administrator switches. */
+type DataConsultationState = 'on' | 'off';
+/** Body of `POST admin/agents/{id}/consultations/{subjectType}/state`. */
+interface DataConsultationStateRequest {
+    state: DataConsultationState;
+    /** Optional, at most 500 characters. */
+    reason?: string | null;
 }
 /**
  * Body of `PUT admin/agents/{id}/consultations/{subjectType}`. Limits left out start at the code's
@@ -2831,6 +3552,12 @@ interface DataConsultationRequest {
     proposalRole?: ConsultationSubjectRole | null;
     /** A registered approval policy; `null` uses the agent's. */
     proposalPolicy?: string | null;
+    /**
+     * The tools the consulted agent is offered, by id or `prefix.*` selector, each covered by the
+     * agent's own selectors; one outside them fails with `toolSelectors: not-allowed`. `null` or empty
+     * offers every tool of the agent.
+     */
+    toolSelectors?: string[] | null;
     /** 0 to 32, at most the ceiling's. */
     maxToolCalls?: number | null;
     /** 1 to 600, at most the ceiling's. */
@@ -2849,6 +3576,201 @@ interface DataConsultationRequest {
     expectedVersion?: number | null;
     /** Optional, at most 500 characters. */
     reason?: string | null;
+    /**
+     * For a new consultation only: it starts off, so it is not offered until an administrator switches it
+     * on, also when the ceiling does not make every new one start off. A change fails with
+     * `startsOff: invalid`; it keeps whether the consultation is on.
+     */
+    startsOff?: boolean;
+}
+
+/**
+ * Hand-offs defined as data and the shadow variants of an agent, as the administration reads and
+ * changes them (`admin/agents/{id}/hand-offs` and `admin/agents/{id}/shadow-variants`).
+ */
+
+/** A hand-off the agent accepts in code (`AcceptHandOffs`), read only. */
+interface CodeHandOff {
+    subjectType: string;
+    /** The agents that may hand work off, by id. */
+    sources: string[];
+    description: string | null;
+    /** The source gets a follow-up when the agent's run for the hand-off ends. */
+    notifySource: boolean;
+    /** Hand-offs one source may make about one subject per 24 hours. */
+    maxPerSubjectPerDay: number;
+    /** The generated tool the sources' tool selectors select. */
+    toolId: string;
+}
+/**
+ * A hand-off defined as data within the ceiling in code (`UseHandOffsAsData`). It works as one in
+ * code; one that no longer fits the ceiling or the code is out of effect as a whole.
+ */
+interface DataHandOff extends CodeHandOff {
+    version: number;
+    changedAt: string;
+    changedBy: string;
+    reason: string | null;
+    /** `false` with `problem` when it no longer fits the ceiling or the code. */
+    inEffect: boolean;
+    /** Such as `outside-ceiling`, `unknown-source` or `limit-above-ceiling`. */
+    problem: string | null;
+    createdAt: string;
+    createdBy: string;
+    /**
+     * The link of the hand-off (part `handOff:{subjectType}`) to the agent package it was imported from, with its locked
+     * fields, which the administration shows read-only; missing when it is not linked.
+     */
+    package?: PackagePartLink | null;
+}
+/** The agents the ceiling lets hand work about one subject type to the agent. */
+interface HandOffAllowance {
+    subjectType: string;
+    /** The agents with a run configuration that may hand off now, by id; never the agent itself. */
+    sources: string[];
+    /** Every agent created in the administration with run settings may hand off, also those created later. */
+    sourcesCreatedInAdministration: boolean;
+}
+/** What the ceiling in code lets the agent accept as data. */
+interface HandOffCeiling {
+    subjectTypes: HandOffAllowance[];
+    /** The highest daily limit per source and subject. */
+    maxPerSubjectPerDay: number;
+    /** The most hand-offs defined as data of one agent. */
+    maxHandOffs: number;
+    /** The most sources of one hand-off. */
+    maxSources: number;
+    maxDescriptionLength: number;
+}
+/** `GET admin/agents/{id}/hand-offs`. */
+interface AgentHandOffs {
+    agentId: string;
+    codeHandOffs: CodeHandOff[];
+    dataHandOffs: DataHandOff[];
+    /** `null` when the agent may accept no hand-offs as data. */
+    ceiling: HandOffCeiling | null;
+    /** Whether the agent has the run configuration a hand-off needs. */
+    configured: boolean;
+}
+/** Body of `PUT admin/agents/{id}/hand-offs/{subjectType}`. */
+interface DataHandOffRequest {
+    /** 1 to the ceiling's `maxSources` agents within the ceiling. */
+    sources: string[];
+    /** At most the ceiling's `maxDescriptionLength` characters. */
+    description?: string | null;
+    notifySource?: boolean;
+    /** 1 to the ceiling's `maxPerSubjectPerDay`; 5 by default. */
+    maxPerSubjectPerDay?: number | null;
+    /** The hand-off's current version; `null` for a new one. */
+    expectedVersion?: number | null;
+    /** Optional, at most 500 characters. */
+    reason?: string | null;
+}
+/** One shadow variant of a live agent. */
+interface ShadowVariant {
+    agentId: string;
+    displayName: string;
+    /** `code` for `ShadowOf`, `data` for a variant created in the administration. */
+    source: 'code' | 'data';
+    /** A data variant receives the live agent's triggers only with run settings. */
+    hasRunSettings: boolean;
+    /** Whether the variant receives the live agent's triggers now. */
+    inEffect: boolean;
+    /** Why a data variant with run settings is out of effect, such as `outside-ceiling`. */
+    problem: string | null;
+    /** The version of the variant's definition, which a promotion sends as `expectedVariantVersion`. */
+    version?: number;
+}
+/** `GET admin/agents/{id}/shadow-variants`. */
+interface AgentShadowVariants {
+    agentId: string;
+    /** Whether administrators may create variants of the agent as data (`UseShadowVariantsAsData`). */
+    allowsDataVariants: boolean;
+    /** The most data variants the agent may have; 0 when it may have none. */
+    maxDataVariants: number;
+    /** The variants in code first, then the data variants. */
+    variants: ShadowVariant[];
+}
+/** `POST admin/agents/{id}/promote`: a data shadow variant becomes its live agent's next version. */
+interface ShadowVariantPromotionRequest {
+    /** The live agent's version the promotion was decided on. */
+    expectedVersion: number;
+    /**
+     * The variant's data skills become the next live versions of the live agent's skills with the same
+     * id, or new skills, which start in shadow; otherwise they go with the variant.
+     */
+    moveSkills?: boolean;
+    /** The variant's version that was evaluated; omitted skips the check. */
+    expectedVariantVersion?: number | null;
+    /** Optional, at most 500 characters, stored with the skill versions the promotion saves. */
+    reason?: string | null;
+}
+/** The answer of a promotion: the live agent after it, and what moved. */
+interface ShadowVariantPromotion {
+    /** The live agent with the variant's definition as its new version. */
+    agent: AdminAgent;
+    /** The variant, which was deleted: it never goes live itself. */
+    variantId: string;
+    /** The skills that moved to the live agent, ordered by id. */
+    movedSkills: string[];
+}
+
+/**
+ * Draws diagrams of fenced code blocks for `nh-assistant-document`, such as ```` ```mermaid ````.
+ * The application supplies it and loads its drawing library lazily inside `render`, so a page
+ * without diagrams never downloads it; the library itself depends on no diagram package.
+ */
+interface NhAssistantDiagramRenderer {
+    /**
+     * The languages of the fenced code blocks it draws, compared without case, for example
+     * `['mermaid']`. Blocks of other languages stay code.
+     */
+    readonly languages: readonly string[];
+    /**
+     * Draws one diagram as SVG markup. The document sanitizes the result before it shows it, so
+     * scripts, event handlers, foreign content and external references never run or load.
+     * Reject, or throw, with a short reason when the source cannot be drawn: the document then
+     * shows the source with that reason.
+     *
+     * @param source The text of the block, untrusted like the rest of the document.
+     * @param language The block's language in lower case.
+     */
+    render(source: string, language: string): Promise<string>;
+}
+/** A heading of the rendered document, in document order, for example for a table of contents. */
+interface NhAssistantDocumentHeading {
+    /** The element id of the heading in the page, unique per document component. */
+    readonly id: string;
+    /** The fragment that links to it within the document, as in `[Setup](#setup)`. */
+    readonly fragment: string;
+    /** 1 to 6. */
+    readonly level: number;
+    /** The heading as plain text. */
+    readonly text: string;
+}
+/**
+ * What a link of the document leads to:
+ * - `document`: another document of the bundle, one of the sibling paths;
+ * - `anchor`: a heading of this document;
+ * - `external`: an `https:`, `http:` or `mailto:` address, which opens in a new tab.
+ */
+type NhAssistantDocumentLinkKind = 'document' | 'anchor' | 'external';
+/**
+ * A link the reader activated. For `document` and `anchor` links the document prevents the
+ * browser's navigation: the application opens the sibling document, and the document scrolls
+ * to its own heading. An `external` link opens unless the handler calls
+ * `event.preventDefault()`.
+ */
+interface NhAssistantDocumentLinkEvent {
+    readonly kind: NhAssistantDocumentLinkKind;
+    /** The address as rendered: the bundle path with its fragment, `#fragment` or the external URL. */
+    readonly href: string;
+    /** The sibling path for a `document` link, otherwise `null`. */
+    readonly path: string | null;
+    /** The fragment without `#`, or `null`. */
+    readonly fragment: string | null;
+    /** The click, so the handler can prevent an external link from opening. */
+    readonly event: MouseEvent;
 }
 
 /** Decides whether the current user may see and use the assistant. */
@@ -3140,6 +4062,19 @@ declare class NhAssistantApiService {
      */
     uploadFile(conversationId: string, file: Blob, name: string): Observable<NhAssistantUploadEvent>;
     decideApproval(conversationId: string, approvalId: string, request: DecideApprovalRequest): Observable<NhAssistantSseEvent>;
+    /**
+     * Answers the question the chat's waiting turn asked with `ask_question` with the index of one of
+     * its choices, and streams the resumed turn like a decision. Only the question's addressee answers;
+     * the server refuses others with `assistant-question-forbidden` and a question whose wait ended with
+     * `assistant-question-expired`.
+     */
+    answerQuestion(conversationId: string, questionId: string, request: AnswerQuestionRequest): Observable<NhAssistantSseEvent>;
+    /**
+     * Resolves an uncertain hand-off of a proposal the caller approved in this chat (`canResolve`):
+     * `hand-to-application` hands it to the application again, `mark-resolved` confirms its outcome.
+     * Returns the conversation as it is afterwards.
+     */
+    resolveApproval(conversationId: string, approvalId: string, request: ResolveApprovalRequest): Observable<Conversation>;
     cancel(conversationId: string): Observable<void>;
     /** Raises the caller's read position to `sequence`, or to the latest message when omitted. */
     markRead(conversationId: string, sequence?: number): Observable<void>;
@@ -3254,6 +4189,23 @@ declare class NhAssistantAdminApiService {
      * on `groups` for an unknown group and with `assistant-shadow-variant` for a shadow variant.
      */
     setAgentGroups(agentId: string, groups: readonly string[]): Observable<AdminAgentGroups>;
+    /**
+     * Every entry of agent metadata the application registers, with the agent's value in effect, where
+     * it comes from and whether it changes here (`GET admin/agents/{id}/metadata`).
+     */
+    getAgentMetadata(agentId: string): Observable<AgentMetadata[]>;
+    /**
+     * Saves the agent's value of one metadata entry after the checks in code: field errors `value` or
+     * `value.<field>`. For an agent created here it makes the agent's next version (`expectedVersion` is
+     * the agent's version); for an agent in code only an editable entry changes, as an override with a
+     * version of its own (`assistant-metadata-read-only` otherwise).
+     */
+    saveAgentMetadata(agentId: string, name: string, request: AgentMetadataRequest): Observable<AgentMetadata>;
+    /**
+     * Removes the agent's stored value of one metadata entry, so an agent in code uses its value in code
+     * again; answers the entry as it is now.
+     */
+    removeAgentMetadata(agentId: string, name: string, expectedVersion: number | null): Observable<AgentMetadata>;
     /** Deletes an admin agent. Code agents cannot be deleted; stop them instead. */
     deleteAgent(agentId: string): Observable<void>;
     getMcpServers(): Observable<McpServer[]>;
@@ -3326,6 +4278,17 @@ declare class NhAssistantAdminApiService {
     getAgentReplays(variantId: string): Observable<AgentReplayList>;
     /** The building blocks in code that run settings, skills and triggers defined as data can name. */
     getRunCatalog(): Observable<RunCatalog>;
+    /**
+     * The application's assets an administrator may choose as instructions, without their content
+     * (`GET admin/instruction-assets`). Fails with `assistant-instructions-asset-unavailable` when the
+     * application's source fails.
+     */
+    listInstructionAssets(): Observable<InstructionAssetList>;
+    /**
+     * The text of one asset, read-only, with the hash a reference stores. Fails with
+     * `assistant-instructions-asset-not-found` for an asset or version the application does not have.
+     */
+    getInstructionAsset(assetId: string, version: number): Observable<InstructionAssetText>;
     /**
      * Accounts whose name or e-mail address contains `query` (2 to 100 characters), at most `limit`.
      * Fails with `assistant-account-search-unavailable` when the application offers no search; the
@@ -3356,7 +4319,10 @@ declare class NhAssistantAdminApiService {
      * `assistant-agent-not-found` for an unknown agent.
      */
     getAgentRuns(agentId: string, filter?: Omit<AgentRunFilter, 'agentId'>): Observable<AgentRunHistory>;
-    /** Removes the run settings; while data skills or triggers belong to the agent, `assistant-run-settings-in-use`. */
+    /**
+     * Removes the run settings; while data skills, triggers, consultations or hand-offs defined as data
+     * belong to the agent, `assistant-run-settings-in-use`.
+     */
     removeRunSettings(agentId: string, removal?: RunConfigurationRemoval): Observable<void>;
     /**
      * Adds a skill defined as data, which starts in shadow, or stores its next version: with `apply`
@@ -3373,8 +4339,20 @@ declare class NhAssistantAdminApiService {
     discardSkillCandidate(agentId: string, skillId: string, request: SkillCandidateRequest): Observable<void>;
     /** Compares the candidate with the live version on the runs they made in the period. */
     compareSkillCandidate(agentId: string, skillId: string, filter?: SkillComparisonFilter): Observable<SkillComparison>;
-    /** Adds a trigger defined as data, which starts in shadow, or changes one in the mode it has. */
+    /**
+     * Adds a trigger defined as data, which starts in shadow, or stores its next version: with `apply`
+     * `live` (default) it takes effect at once in the trigger's mode; with `shadow` it becomes the
+     * candidate that fires next to the live version until it is promoted or discarded.
+     */
     saveDataTrigger(agentId: string, triggerId: string, request: DataTriggerRequest): Observable<DataTrigger>;
+    /** Every version of a trigger defined as data, newest first, with its definition. */
+    getDataTriggerVersions(agentId: string, triggerId: string): Observable<DataTriggerVersion[]>;
+    /** Makes the candidate the live version of its trigger, in the trigger's mode. */
+    promoteTriggerCandidate(agentId: string, triggerId: string, request: TriggerCandidateRequest): Observable<DataTrigger>;
+    /** Discards the candidate of a trigger; it stays as history and fires no more. */
+    discardTriggerCandidate(agentId: string, triggerId: string, request: TriggerCandidateRequest): Observable<void>;
+    /** Compares the trigger's candidate with its live version on the runs they started in the period. */
+    compareTriggerCandidate(agentId: string, triggerId: string, filter?: SkillComparisonFilter): Observable<TriggerComparison>;
     removeDataTrigger(agentId: string, triggerId: string, removal?: RunConfigurationRemoval): Observable<void>;
     /** Puts a trigger defined as data in shadow or live. */
     setDataTriggerShadow(agentId: string, triggerId: string, request: DataTriggerShadowRequest): Observable<DataTrigger>;
@@ -3389,12 +4367,87 @@ declare class NhAssistantAdminApiService {
      * a route outside the ceiling.
      */
     saveDataConsultation(agentId: string, subjectType: string, request: DataConsultationRequest): Observable<DataConsultation>;
+    /**
+     * Switches a consultation defined as data on or off, without a new version. Off, it is not offered,
+     * while its recorded proposals can still be decided. Fails with `assistant-consultation-not-found`
+     * without one and with `assistant-consultation-in-code` for a consultation in code.
+     */
+    setDataConsultationState(agentId: string, subjectType: string, request: DataConsultationStateRequest): Observable<DataConsultation>;
     /**
      * Removes a consultation defined as data: its tools disappear, while its recorded proposals can still
      * be decided. Fails with `assistant-consultation-not-found` without one and with
      * `assistant-consultation-in-code` for a consultation in code.
      */
     removeDataConsultation(agentId: string, subjectType: string, removal?: RunConfigurationRemoval): Observable<void>;
+    /**
+     * The hand-offs the agent accepts, in code and as data with their problems, and what the ceiling in
+     * code (`UseHandOffsAsData`) lets administrators add; `ceiling` is `null` when it may accept none.
+     */
+    getAgentHandOffs(agentId: string): Observable<AgentHandOffs>;
+    /**
+     * Adds or changes the hand-off defined as data that the agent accepts about one subject type, within
+     * the ceiling: in effect once saved, as one in code. An agent the ceiling connects to no agent fails
+     * with `assistant-handoffs-not-allowed`, a type it accepts in code with `assistant-handoff-in-code`,
+     * an agent without run configuration with `assistant-agent-not-configured`, more than the ceiling's
+     * `maxHandOffs` with `assistant-configuration-limit`, a stale `expectedVersion` with
+     * `assistant-version-conflict` and invalid input with field errors, such as `sources: not-allowed`
+     * for a source outside the ceiling.
+     */
+    saveDataHandOff(agentId: string, subjectType: string, request: DataHandOffRequest): Observable<DataHandOff>;
+    /**
+     * Removes a hand-off defined as data; its tool disappears from the sources' next turns. Fails with
+     * `assistant-handoff-not-found` without one and with `assistant-handoff-in-code` for one in code.
+     */
+    removeDataHandOff(agentId: string, subjectType: string, removal?: RunConfigurationRemoval): Observable<void>;
+    /**
+     * The agent's shadow variants, in code and created as data, and whether administrators may create
+     * more (`UseShadowVariantsAsData`). Create a data variant with `createAgent` and `shadowOf`.
+     */
+    getShadowVariants(agentId: string): Observable<AgentShadowVariants>;
+    /**
+     * Promotes the data shadow variant `variantId` onto its live agent (`POST admin/agents/{id}/promote`):
+     * its definition becomes the live agent's next version through the update path, with its checks,
+     * locks and audit, its data skills move along when asked, and the variant is deleted. The live agent
+     * keeps its name, MCP servers, metadata, run settings, triggers, state and shadow mode; an agent in
+     * code takes only the fields it can override. Fails with `assistant-not-shadow-variant`,
+     * `assistant-shadow-variants-not-allowed`, `assistant-version-conflict` and `assistant-skill-in-code`.
+     */
+    promoteShadowVariant(variantId: string, request: ShadowVariantPromotionRequest): Observable<ShadowVariantPromotion>;
+    /**
+     * Exports exactly `agentIds` (1 to 20) as one agent package (`POST admin/agent-packages/export`):
+     * agents created here whole, agents in code as an overlay of what data changes on them; never
+     * history, candidates, runs, run state, shadow overrides, MCP servers, the technical account or
+     * secrets. The options set the package id, version and locks; left out, the id of the package the
+     * first agent is linked to and its next version, otherwise the first agent's id and 1. Answers the
+     * package, its JSON exactly as the server wrote it for the download, and every reference to an agent
+     * outside the selection, which must exist where the package is imported. Fails with
+     * `assistant-agent-not-found` for an unknown agent and with field errors for invalid options; the
+     * server audits the export.
+     */
+    exportAgentPackage(agentIds: readonly string[], options?: AgentPackageExportOptions): Observable<AgentPackageExport>;
+    /**
+     * What importing the package would do, per agent and part (`POST admin/agent-packages/preview`):
+     * `created`, `changed`, `unchanged`, `kept-local`, `left-behind` or `refused` with the field
+     * errors of the save validators, after one check of the whole package against this host as it would
+     * be after the import. Changes nothing. The server reads the package strictly: a package it does not
+     * read fails with `assistant-package-format-unsupported`, one above 1 MB or 20 agents with
+     * `assistant-package-too-large`.
+     */
+    previewAgentPackageImport(agentPackage: AgentPackage, options?: AgentPackageImportOptions): Observable<AgentPackagePreview>;
+    /**
+     * Imports the package in one transaction (`POST admin/agent-packages/import`): every agent and part
+     * of it, or nothing. Fails as `previewAgentPackageImport` does, and with `assistant-package-refused`
+     * and the field error `parts: invalid` when the check refuses a part; preview again to see which part
+     * and why. Every part is audited as its save.
+     */
+    importAgentPackage(agentPackage: AgentPackage, options?: AgentPackageImportOptions): Observable<AgentPackageImport>;
+    /**
+     * Unlinks one part of the agent, or without `part` the whole agent, from its package
+     * (`POST admin/agents/{id}/package/unlink`): its locks no longer hold and the next upgrade keeps it as
+     * `kept-local` unless the import relinks it. Fails with `assistant-package-not-linked` for an agent
+     * or part without a link and with the field error `part: invalid` for an unknown part key.
+     */
+    unlinkAgentPackage(agentId: string, request?: AgentPackageUnlinkRequest): Observable<AgentPackageUnlink>;
     private download;
     private request;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantAdminApiService, never>;
@@ -3517,7 +4570,9 @@ declare class NhAssistantAgentRunApiService {
     retryRun(runId: string, mode: AgentRunRetryMode): Observable<AgentTriggerReceipt>;
     /**
      * Pending proposals the caller may decide, sorted by expiry, or with `grouped` by parent and subject,
-     * with what is new since the caller's last visit (`visitInbox`).
+     * with what is new since the caller's last visit (`visitInbox`). `status` lists the proposals that
+     * wait for the application's report (`awaiting-application`) or for an approver to resolve an
+     * uncertain execution (`execution-unknown`) instead, with the same visibility.
      */
     getInbox(filter?: AgentInboxFilter): Observable<AgentInbox>;
     /**
@@ -3570,6 +4625,11 @@ declare function applyNhAssistantEvent(conversation: Conversation, event: NhAssi
  * closes it, rejected in this conversation, and can no longer be left; the waiting tool call goes on.
  */
 declare function applyNhAssistantApprovalDecision(conversation: Conversation, approvalId: string, decision: ApprovalDecision): Conversation;
+/**
+ * Records the addressee's answer to a question locally until the server state is reloaded: the
+ * question reads as answered with the chosen index and the turn runs again.
+ */
+declare function applyNhAssistantQuestionAnswer(conversation: Conversation, questionId: string, choice: number): Conversation;
 /**
  * Applies a live update of another session: `message.created` adds a participant's or the
  * application's message once, where its sequence number puts it; the turn events behave exactly
@@ -3916,6 +4976,13 @@ declare class NhAssistantStore {
      * turn, in an agent thread the server allows them as an approver.
      */
     readonly canDecide: _angular_core.Signal<boolean>;
+    /**
+     * True when the current user may answer the question the open chat waits for: it is addressed to
+     * them and still pending (`ask_question`, `run.AllowQuestions()` on the server).
+     */
+    readonly canAnswer: _angular_core.Signal<boolean>;
+    /** The member a pending question of the open conversation is addressed to, when it is someone else. */
+    readonly questionAddressee: _angular_core.Signal<ConversationMember | null>;
     /** The member whose turn runs or waits in the open conversation, when it is someone else. */
     readonly activeMember: _angular_core.Signal<ConversationMember | null>;
     /** Conversations that need attention: running, waiting for approval or unread. Most recent first. */
@@ -3979,12 +5046,26 @@ declare class NhAssistantStore {
      * repeated calls while a decision is in flight.
      */
     decide(decision: ApprovalDecision, reason?: string, approvalId?: string): void;
+    /**
+     * Answers the question the open chat waits for with the choice at `choice` and streams the resumed
+     * turn, as a decision does. Ignores another question, a question addressed to someone else, a choice
+     * the question does not offer and calls while a turn or a decision is in flight. A refused answer,
+     * such as an expired question, shows its error and reads the conversation again.
+     */
+    answerQuestion(questionId: string, choice: number): void;
     /**
      * Decides a proposal of an agent's run with `POST approvals/{id}/decisions`. An approved deferred
      * proposal executes later as a background operation; an inline one wakes the waiting run. The
      * reloaded snapshot shows the outcome and the proposals that remain open.
      */
     private decideProposal;
+    /**
+     * Resolves an uncertain hand-off in the open chat that the current user approved (`canResolve`):
+     * `hand-to-application` hands it to the application again with a new report deadline,
+     * `mark-resolved` confirms its outcome. The conversation the server returns replaces the shown one.
+     * Ignores approvals the user may not resolve and calls while a decision or a turn is in flight.
+     */
+    resolveApproval(approvalId: string, resolution: ApprovalResolution, reason?: string): Promise<void>;
     /** Asks the server to stop the running turn or to abandon a waiting approval of the open conversation. */
     cancel(): Promise<void>;
     private cancelConversation;
@@ -4117,16 +5198,36 @@ declare class NhAssistantPushService {
     private readonly subscribedState;
     private readonly busyState;
     private readonly openSubject;
+    private readonly openRunSubject;
     private registration?;
     private revision;
     private readonly onWorkerMessage;
     /** The caller's server-side choice, or `null` before it was loaded. */
     readonly settings: _angular_core.Signal<NotificationSettings | null>;
     readonly busy: _angular_core.Signal<boolean>;
-    /** Conversations a clicked notification asks to open. */
+    /**
+     * Conversations a clicked notification asks to open; the assistant panel opens them. A
+     * notification about the proposals of a run goes to `openRun$` instead while the application
+     * subscribes to it.
+     */
     readonly openConversation$: Observable<string>;
+    /**
+     * Runs whose proposals a clicked notification is about, for the application to open its inbox of
+     * the run, for example `nh-assistant-agent-inbox` with `[runId]`, which lists every proposal of the
+     * run the person may decide. While the application subscribes, such a click emits the run here
+     * instead of opening the conversation in the panel; without a subscriber it opens the conversation
+     * as before. Subscribe in the application shell, so a notification that opens a new window finds
+     * the subscription.
+     */
+    readonly openRun$: Observable<string>;
     readonly state: _angular_core.Signal<NhAssistantPushState>;
     constructor();
+    /**
+     * Opens what a clicked notification is about: the run through `openRun$` when the notification
+     * names one and the application subscribes, otherwise the conversation through
+     * `openConversation$`. The bundled worker and the panel's notification fragments call it.
+     */
+    openNotification(conversationId: string, runId?: string): void;
     /**
      * Loads the user's choice and, when permission was granted before, renews this browser's
      * subscription, which also moves it to the current user and to a rotated server key.
@@ -4262,6 +5363,12 @@ declare class NhAssistantSubjectSummaryService {
 declare const NH_ASSISTANT_JOIN_FRAGMENT = "nh-assistant-join";
 /** Fragment a clicked notification opens: `#nh-assistant-conversation=<id>`. */
 declare const NH_ASSISTANT_CONVERSATION_FRAGMENT = "nh-assistant-conversation";
+/**
+ * Fragment a clicked notification about the proposals of a run opens:
+ * `#nh-assistant-run=<runId>.<conversationId>`. The run goes to `NhAssistantPushService.openRun$`
+ * while the application subscribes; otherwise the panel opens the conversation.
+ */
+declare const NH_ASSISTANT_RUN_FRAGMENT = "nh-assistant-run";
 /** Builds the default invitation link: the current page with the join fragment. */
 declare function nhAssistantShareLink(conversationId: string, token: string): string;
 
@@ -4402,7 +5509,7 @@ declare function nhAssistantCodeKeys(code: string | null | undefined): string[];
 /** Dash-case identifiers as the contract requires for agent and MCP server ids. */
 declare const NH_ASSISTANT_DASH_CASE: RegExp;
 
-type NhAssistantIconName = 'assistant' | 'close' | 'send' | 'stop' | 'plus' | 'list' | 'trash' | 'tool' | 'check' | 'x' | 'warning' | 'chevron-down' | 'clock' | 'settings' | 'admin' | 'edit' | 'refresh' | 'link' | 'page' | 'users' | 'copy' | 'bell' | 'leave' | 'attach' | 'file';
+type NhAssistantIconName = 'assistant' | 'close' | 'send' | 'stop' | 'plus' | 'list' | 'trash' | 'tool' | 'check' | 'x' | 'warning' | 'chevron-down' | 'clock' | 'settings' | 'admin' | 'edit' | 'refresh' | 'link' | 'page' | 'users' | 'copy' | 'bell' | 'leave' | 'attach' | 'file' | 'lock';
 /**
  * Optional icon classes of the host's icon library, for example `{ close: 'ph ph-x' }`.
  * Icons without a class use the library's small built-in outline glyphs.
@@ -4441,6 +5548,17 @@ interface NhAssistantApprovalChoice {
     approvalId: string;
     decision: ApprovalDecision;
 }
+/** The answer the user chose for a question of the thread. */
+interface NhAssistantQuestionAnswer {
+    questionId: string;
+    /** The zero-based index of the chosen answer. */
+    choice: number;
+}
+/** How the user resolves the uncertain hand-off of one approval they made in this chat. */
+interface NhAssistantApprovalResolutionChoice {
+    approvalId: string;
+    resolution: ApprovalResolution;
+}
 /** Above this number of messages the thread renders through CDK virtual scrolling. */
 declare const NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD = 200;
 /**
@@ -4492,6 +5610,13 @@ declare class NhAssistantThreadComponent {
     readonly approvalDecision: _angular_core.OutputEmitterRef<ApprovalDecision>;
     /** The decision about an approval card together with its approval id. */
     readonly approvalChoice: _angular_core.OutputEmitterRef<NhAssistantApprovalChoice>;
+    /** How the user resolves an uncertain hand-off they approved in this chat, with its approval id. */
+    readonly approvalResolution: _angular_core.OutputEmitterRef<NhAssistantApprovalResolutionChoice>;
+    /**
+     * The answer the user chose for a question addressed to them, for example for
+     * `NhAssistantStore.answerQuestion`. Only the addressee of a pending question gets choice buttons.
+     */
+    readonly questionAnswer: _angular_core.OutputEmitterRef<NhAssistantQuestionAnswer>;
     /**
      * The question to ask again after the viewer connected an MCP server from a connection card: the
      * text of the user message the card answered. The panel sends it.
@@ -4535,12 +5660,18 @@ declare class NhAssistantThreadComponent {
     /** Whether and why the current user may decide an approval card. */
     rightFor(approval: ApprovalPart): NhAssistantApprovalRight;
     choose(approval: ApprovalPart, decision: ApprovalDecision): void;
+    resolveApproval(approval: ApprovalPart, resolution: ApprovalResolution): void;
+    /** Whether the current user may answer the question: it waits and is addressed to them. */
+    canAnswer(question: QuestionPart): boolean;
+    /** The name of the person a question is addressed to, or `null` when the application provides none. */
+    addresseeName(question: QuestionPart): string | null;
+    answerQuestion(question: QuestionPart, choice: number): void;
     /** Display name of another person's message, or `null` when the application provides none. */
     authorName(message: Message): string | null;
     private scrollElement;
     private scrollToEnd;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantThreadComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantThreadComponent, "nh-assistant-thread", never, { "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; "markdown": { "alias": "markdown"; "required": false; "isSignal": true; }; "members": { "alias": "members"; "required": false; "isSignal": true; }; "currentActorId": { "alias": "currentActorId"; "required": false; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionOwner": { "alias": "decisionOwner"; "required": false; "isSignal": true; }; "approvalRights": { "alias": "approvalRights"; "required": false; "isSignal": true; }; "writingMessageId": { "alias": "writingMessageId"; "required": false; "isSignal": true; }; }, { "approvalDecision": "approvalDecision"; "approvalChoice": "approvalChoice"; "retryMessage": "retryMessage"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantThreadComponent, "nh-assistant-thread", never, { "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; "markdown": { "alias": "markdown"; "required": false; "isSignal": true; }; "members": { "alias": "members"; "required": false; "isSignal": true; }; "currentActorId": { "alias": "currentActorId"; "required": false; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionOwner": { "alias": "decisionOwner"; "required": false; "isSignal": true; }; "approvalRights": { "alias": "approvalRights"; "required": false; "isSignal": true; }; "writingMessageId": { "alias": "writingMessageId"; "required": false; "isSignal": true; }; }, { "approvalDecision": "approvalDecision"; "approvalChoice": "approvalChoice"; "approvalResolution": "approvalResolution"; "questionAnswer": "questionAnswer"; "retryMessage": "retryMessage"; }, never, never, true, never>;
 }
 
 /**
@@ -4582,7 +5713,12 @@ declare class NhAssistantPanelComponent implements AfterViewInit, OnDestroy {
     readonly queuedDraft: _angular_core.WritableSignal<string>;
     private resumeAfterEditing;
     readonly validQueuedDraft: _angular_core.Signal<boolean>;
-    readonly composerStatus: _angular_core.Signal<"running" | "waiting-for-approval" | null>;
+    readonly composerStatus: _angular_core.Signal<"running" | "waiting-for-approval" | "waiting-for-answer" | null>;
+    /**
+     * Who the composer says the conversation waits for, when it is someone else: the addressee of a
+     * pending question, otherwise the person whose turn waits.
+     */
+    readonly composerStatusActor: _angular_core.Signal<string | null>;
     /** Name of another participant whose turn runs or waits, or `null`. */
     readonly activeMemberName: _angular_core.Signal<string | null>;
     /** The owner and the person who started the turn may stop it. */
@@ -4615,12 +5751,17 @@ declare class NhAssistantPanelComponent implements AfterViewInit, OnDestroy {
     cancelQueueEdit(): void;
     /**
      * Opens the panel for an invitation link or a clicked notification in the URL fragment and
-     * removes the fragment, so a reload or a shared screenshot does not reuse the token.
+     * removes the fragment, so a reload or a shared screenshot does not reuse the token. A clicked
+     * notification about the proposals of a run goes to `NhAssistantPushService.openRun$` while the
+     * application subscribes, and otherwise opens its conversation.
      */
     private openFromLocation;
     decide(decision: ApprovalDecision): void;
     /** Decides the approval of a card; in an agent thread several proposals can be open. */
     decideApproval(choice: NhAssistantApprovalChoice): void;
+    resolveApproval(choice: NhAssistantApprovalResolutionChoice): void;
+    /** Answers the question the conversation waits for; only its addressee gets the choices. */
+    answerQuestion(answer: NhAssistantQuestionAnswer): void;
     cancel(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantPanelComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantPanelComponent, "nh-assistant-panel", never, {}, {}, never, never, true, never>;
@@ -4663,9 +5804,12 @@ declare class NhAssistantComposerComponent {
     readonly busy: _angular_core.InputSignal<boolean>;
     /** Keeps the send action available next to Stop so the host can queue messages. */
     readonly queueWhileBusy: _angular_core.InputSignal<boolean>;
-    /** Announces why sending is temporarily unavailable. */
-    readonly status: _angular_core.InputSignal<"running" | "waiting-for-approval" | null>;
-    /** Name of the participant whose turn runs or waits, when it is someone else. */
+    /**
+     * Announces why sending is temporarily unavailable: a running turn, a turn that waits for an
+     * approval, or one that waits for the answer to a question the agent asked.
+     */
+    readonly status: _angular_core.InputSignal<"running" | "waiting-for-approval" | "waiting-for-answer" | null>;
+    /** Name of the participant whose turn runs or waits, or who answers the question, when it is someone else. */
     readonly statusActor: _angular_core.InputSignal<string | null>;
     /** False when the user may not stop the running turn, such as another participant's turn. */
     readonly canStop: _angular_core.InputSignal<boolean>;
@@ -4747,9 +5891,9 @@ declare class NhAssistantToolCallCardComponent {
 /**
  * Overall state of a run of tool calls, from most to least urgent. `not-executed` means that every
  * call finished and at least one ended without running, because its proposal expired, was
- * withdrawn or became stale.
+ * withdrawn or became stale. `awaiting-answer` waits for the answer to a question the agent asked.
  */
-type NhAssistantToolCallGroupState = 'awaiting-approval' | 'running' | 'failed' | 'not-executed' | 'succeeded';
+type NhAssistantToolCallGroupState = 'awaiting-approval' | 'awaiting-answer' | 'running' | 'failed' | 'not-executed' | 'succeeded';
 /**
  * Summarizes consecutive tool calls in one collapsed line that counts along live: the
  * tool that runs now while the assistant works, and how many tools were used and failed
@@ -4784,7 +5928,9 @@ declare function formatNhAssistantCountdown(milliseconds: number): string;
  * another agent the assistant consulted (`consultation`) names that agent and the subject, offers the
  * agent's answer and says that approving runs it with the user's own rights; with a
  * `consultation.leaveRoute` a third action leaves it for the subject's approvers (`leave`), after which
- * the card says that it waits for them.
+ * the card says that it waits for them. A proposal the user approved in their chat whose hand-off to the
+ * application has an unknown outcome (`canResolve`) offers to hand it to the application again or to mark
+ * it resolved (`resolve`).
  */
 declare class NhAssistantApprovalCardComponent {
     /** Names the consulted agent as the status does; the card also works outside `provideNhAssistant`. */
@@ -4811,6 +5957,8 @@ declare class NhAssistantApprovalCardComponent {
      */
     readonly canGiveFeedback: _angular_core.InputSignal<boolean>;
     readonly decide: _angular_core.OutputEmitterRef<ApprovalDecision>;
+    /** How the user resolves an uncertain execution they approved in this chat (`canResolve`). */
+    readonly resolve: _angular_core.OutputEmitterRef<ApprovalResolution>;
     private readonly now;
     private readonly submitted;
     /** The decision this card sent last, so a proposal left for the approvers reads as such at once. */
@@ -4854,6 +6002,11 @@ declare class NhAssistantApprovalCardComponent {
     /** The route at the subject the pending proposal may be left for; `null` when it can only be approved or rejected. */
     readonly leaveRoute: _angular_core.Signal<NhAssistantConsultationLeaveRoute | null>;
     readonly leaveHintId: string;
+    /** The user may resolve this uncertain hand-off: the server says so for the person who approved it. */
+    readonly resolvable: _angular_core.Signal<boolean>;
+    readonly resolveDisabled: _angular_core.Signal<boolean>;
+    readonly resolveHintId: string;
+    private readonly resolving;
     readonly countdown: _angular_core.Signal<string>;
     readonly presentedSummary: _angular_core.Signal<string | null>;
     readonly feedbackAvailable: _angular_core.Signal<boolean>;
@@ -4862,6 +6015,8 @@ declare class NhAssistantApprovalCardComponent {
     /** Translation key of the text shown instead of the buttons when the current user cannot decide. */
     readonly waitingKey: _angular_core.Signal<"nh-assistant.approval.waiting-for-approver" | "nh-assistant.approval.waiting-for-other-approver" | "nh-assistant.approval.waiting-for-asker" | "nh-assistant.approval.waiting-for" | "nh-assistant.approval.waiting-for-participant">;
     constructor();
+    /** Emits a resolution of an uncertain hand-off, at most once until the host reports it is done. */
+    chooseResolution(resolution: ApprovalResolution): void;
     /** Emits a decision; `leave` only for a consulted agent's proposal with a route at the subject. */
     choose(decision: ApprovalDecision): void;
     toggleFeedback(): void;
@@ -4869,7 +6024,43 @@ declare class NhAssistantApprovalCardComponent {
     /** Collapses the question and returns focus to the action that opened it. */
     onFeedbackDismissed(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantApprovalCardComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantApprovalCardComponent, "nh-assistant-approval-card", never, { "approval": { "alias": "approval"; "required": true; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionOwner": { "alias": "decisionOwner"; "required": false; "isSignal": true; }; "waitingFor": { "alias": "waitingFor"; "required": false; "isSignal": true; }; "canGiveFeedback": { "alias": "canGiveFeedback"; "required": false; "isSignal": true; }; }, { "decide": "decide"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantApprovalCardComponent, "nh-assistant-approval-card", never, { "approval": { "alias": "approval"; "required": true; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionOwner": { "alias": "decisionOwner"; "required": false; "isSignal": true; }; "waitingFor": { "alias": "waitingFor"; "required": false; "isSignal": true; }; "canGiveFeedback": { "alias": "canGiveFeedback"; "required": false; "isSignal": true; }; }, { "decide": "decide"; "resolve": "resolve"; }, never, never, true, never>;
+}
+
+/**
+ * A question the agent asked with `ask_question`: the question with one button per choice for the
+ * person it is addressed to (`canAnswer`), and read-only for everyone else, who sees whom it waits
+ * for. It counts down to the end of its wait. Once answered it marks the chosen answer; an expired or
+ * cancelled question says so. An answer is emitted at most once until the host reports that it is no
+ * longer answering.
+ */
+declare class NhAssistantQuestionCardComponent {
+    readonly question: _angular_core.InputSignal<QuestionPart>;
+    /** True when the current user is the addressee and may answer, for example `NhAssistantStore.canAnswer`. */
+    readonly canAnswer: _angular_core.InputSignal<boolean>;
+    /** Name of the person the question is addressed to, shown to everyone else; `null` when unknown. */
+    readonly addresseeName: _angular_core.InputSignal<string | null>;
+    /** True while the host submits an answer; disables the choices. */
+    readonly answering: _angular_core.InputSignal<boolean>;
+    /** The zero-based index of the chosen answer. */
+    readonly answer: _angular_core.OutputEmitterRef<number>;
+    readonly questionId: string;
+    private readonly now;
+    private readonly submitted;
+    readonly remainingMs: _angular_core.Signal<number>;
+    /** A pending question whose wait ended reads as expired before the server says so. */
+    readonly effectiveStatus: _angular_core.Signal<QuestionStatus>;
+    readonly actionable: _angular_core.Signal<boolean>;
+    readonly statusIcon: _angular_core.Signal<NhAssistantIconName>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    readonly chosen: _angular_core.Signal<number | null>;
+    readonly chosenText: _angular_core.Signal<string | null>;
+    readonly countdown: _angular_core.Signal<string>;
+    constructor();
+    /** Emits the chosen answer once. */
+    choose(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantQuestionCardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantQuestionCardComponent, "nh-assistant-question-card", never, { "question": { "alias": "question"; "required": true; "isSignal": true; }; "canAnswer": { "alias": "canAnswer"; "required": false; "isSignal": true; }; "addresseeName": { "alias": "addresseeName"; "required": false; "isSignal": true; }; "answering": { "alias": "answering"; "required": false; "isSignal": true; }; }, { "answer": "answer"; }, never, never, true, never>;
 }
 
 /** What `nh-assistant-proposal-feedback` stored. */
@@ -5151,6 +6342,61 @@ declare class NhAssistantSubjectBadgeComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantSubjectBadgeComponent, "nh-assistant-subject-badge", never, { "subjectType": { "alias": "subjectType"; "required": true; "isSignal": true; }; "subjectId": { "alias": "subjectId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+type DocumentPart = {
+    readonly kind: 'html';
+    readonly html: SafeHtml;
+} | {
+    readonly kind: 'diagram';
+    readonly language: string;
+    readonly source: string;
+};
+/**
+ * Renders an untrusted Markdown document, for example one file of a skill or knowledge bundle,
+ * with the assistant's safety defaults: inline HTML shows as text, images as their alt text, and
+ * a link keeps its address only for a heading of the document, a sibling of the bundle or an
+ * `https:`, `http:` or `mailto:` address; `javascript:`, `data:` and every other scheme show as
+ * text. Relative links resolve from the document's `path` against `siblingPaths`.
+ *
+ * Fenced code blocks of the languages of `diagramRenderer` become diagrams: the application's
+ * renderer draws them, the document sanitizes its SVG and shows it in a shadow root, and a block
+ * it cannot draw shows its source with the reason. Without a renderer they stay code.
+ *
+ * `linkClick` reports every link the reader activates; `headingsChange` the headings once they
+ * are in the page. The texts are `nh-assistant.document.*`, which `provideNhAssistant` merges;
+ * an application without it starts `NhAssistantTranslationMerger` or translates the keys itself.
+ */
+declare class NhAssistantDocumentComponent {
+    private readonly markdownRenderer;
+    private readonly sanitizer;
+    private readonly host;
+    private readonly idPrefix;
+    /** The document's Markdown. Treated as untrusted. */
+    readonly markdown: _angular_core.InputSignal<string>;
+    /** The document's own path in its bundle, for example `guides/setup.md`. */
+    readonly path: _angular_core.InputSignal<string | null>;
+    /** The paths of the other documents in the bundle that its links may open. */
+    readonly siblingPaths: _angular_core.InputSignal<readonly string[]>;
+    /** Draws the bundle's diagrams; the application loads its drawing library lazily. */
+    readonly diagramRenderer: _angular_core.InputSignal<NhAssistantDiagramRenderer | null>;
+    /** A link the reader activated; see `NhAssistantDocumentLinkEvent`. */
+    readonly linkClick: _angular_core.OutputEmitterRef<NhAssistantDocumentLinkEvent>;
+    /** The headings, in document order, each time they changed and are in the page. */
+    readonly headingsChange: _angular_core.OutputEmitterRef<readonly NhAssistantDocumentHeading[]>;
+    private readonly rendered;
+    /** The headings of the rendered document. */
+    readonly headings: _angular_core.Signal<readonly NhAssistantDocumentHeading[]>;
+    readonly parts: _angular_core.Signal<readonly DocumentPart[]>;
+    constructor();
+    /**
+     * Scrolls to a heading of the document by its fragment and focuses it; false when the
+     * document has no such heading.
+     */
+    scrollToHeading(fragment: string): boolean;
+    onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantDocumentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantDocumentComponent, "nh-assistant-document", never, { "markdown": { "alias": "markdown"; "required": true; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; "siblingPaths": { "alias": "siblingPaths"; "required": false; "isSignal": true; }; "diagramRenderer": { "alias": "diagramRenderer"; "required": false; "isSignal": true; }; }, { "linkClick": "linkClick"; "headingsChange": "headingsChange"; }, never, never, true, never>;
+}
+
 /**
  * Translates the first key that has a translation and otherwise returns the fallback text.
  * Used for server-provided keys (agent names, error message keys, result codes) that the
@@ -5318,5 +6564,5 @@ declare class NhAssistantMarkdownPipe implements PipeTransform {
  */
 declare function nhAssistantMediaTypeOf(file: Pick<File, 'name' | 'type'>, acceptedMediaTypes: readonly string[], mappedExtensions?: readonly AgentUploadExtension[] | null): string;
 
-export { NH_ASSISTANT_ACCESS_POLICY, NH_ASSISTANT_CONFIG, NH_ASSISTANT_CONVERSATION_FRAGMENT, NH_ASSISTANT_ERROR_CODES, NH_ASSISTANT_FEEDBACK_CATEGORIES, NH_ASSISTANT_FEEDBACK_GROUPS, NH_ASSISTANT_FETCH, NH_ASSISTANT_ICONS, NH_ASSISTANT_JOIN_FRAGMENT, NH_ASSISTANT_MAX_BULK_FEEDBACK, NH_ASSISTANT_MAX_CUSTOM_INSTRUCTIONS, NH_ASSISTANT_MAX_FEEDBACK_TEXT, NH_ASSISTANT_MAX_PROPOSAL_LOOKUP, NH_ASSISTANT_MAX_SUBJECT_SUMMARY, NH_ASSISTANT_MCP_AUTHORIZATION_MESSAGE, NH_ASSISTANT_MCP_AUTHORIZATION_WINDOW, NH_ASSISTANT_MESSAGE_QUEUED_NOTICE_CODE, NH_ASSISTANT_NO_ANSWER_NOTICE_CODE, NH_ASSISTANT_PAGE_CONTEXT_LIMITS, NH_ASSISTANT_PANEL_MOBILE_QUERY, NH_ASSISTANT_PANEL_WIDTH, NH_ASSISTANT_RESULT_PREVIEW_LENGTH, NH_ASSISTANT_RUN_HISTORY_MAX_PAGE, NH_ASSISTANT_RUN_RESULT_MAX_LENGTH, NH_ASSISTANT_SERVER_ERROR_CODES, NH_ASSISTANT_SSE_EVENT_TYPES, NH_ASSISTANT_SUBJECT_SEARCH, NH_ASSISTANT_SYSTEM_GLOBAL_ID, NH_ASSISTANT_SYSTEM_SUBJECT_TYPE, NH_ASSISTANT_TRANSLATIONS, NH_ASSISTANT_UPLOAD, NH_ASSISTANT_UPLOAD_HEADER, NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD, NhAssistantActivityComponent, NhAssistantAdminApiService, NhAssistantAgentPickerComponent, NhAssistantAgentRunApiService, NhAssistantAllowAllAccessPolicy, NhAssistantApiError, NhAssistantApiService, NhAssistantApprovalCardComponent, NhAssistantClientErrorCodes, NhAssistantComposerComponent, NhAssistantConnectionRequiredComponent, NhAssistantConversationListComponent, NhAssistantLauncherComponent, NhAssistantLiveService, NhAssistantMcpConnectService, NhAssistantMcpConnectionsComponent, NhAssistantMcpPopupAuthorizationWindow, NhAssistantPanelComponent, NhAssistantPanelService, NhAssistantPreferencesComponent, NhAssistantProposalFeedbackComponent, NhAssistantPushService, NhAssistantShareComponent, NhAssistantSseParser, NhAssistantStore, NhAssistantSubjectBadgeComponent, NhAssistantSubjectSummaryService, NhAssistantThreadComponent, NhAssistantToolCallCardComponent, NhAssistantToolCallGroupComponent, NhAssistantTranslationMerger, applyNhAssistantApprovalDecision, applyNhAssistantConversationChange, applyNhAssistantEvent, applyNhAssistantLiveEvent, describeNhAssistantClientContext, formatNhAssistantCountdown, nhAssistantCodeForStatus, nhAssistantConnectMcp, nhAssistantErrorMessageKey, nhAssistantIsUnread, nhAssistantLatestTurnHasText, nhAssistantMcpAuthorizationFromFragment, nhAssistantShareLink, nhAssistantXhrUpload, normalizeNhAssistantClientContext, provideNhAssistant, toNhAssistantError, NH_ASSISTANT_DASH_CASE as ɵNH_ASSISTANT_DASH_CASE, NhAssistantIconComponent as ɵNhAssistantIconComponent, NhAssistantMarkdownPipe as ɵNhAssistantMarkdownPipe, NhAssistantPickerComponent as ɵNhAssistantPickerComponent, NhAssistantSubjectLinkComponent as ɵNhAssistantSubjectLinkComponent, NhAssistantTranslatePipe as ɵNhAssistantTranslatePipe, nhAssistantCodeKeys as ɵnhAssistantCodeKeys, nhAssistantErrorKeys as ɵnhAssistantErrorKeys, nhAssistantErrorOf as ɵnhAssistantErrorOf, nhAssistantMediaTypeOf as ɵnhAssistantMediaTypeOf, nhAssistantReloadOnAgentWork as ɵnhAssistantReloadOnAgentWork, nhAssistantWatchAgentWork as ɵnhAssistantWatchAgentWork, toNhAssistantError as ɵtoNhAssistantError };
-export type { AdminAgent, AdminAgentGroups, AdminAgentInput, AgentAccountability, AgentArtifact, AgentBoard, AgentBoardAgent, AgentBoardList, AgentBoardSubjectType, AgentBoardSummary, AgentBoardVisit, AgentBoardWorksOn, AgentConsultation, AgentConsultationList, AgentConsultationRouteState, AgentConsultationRouteSwitch, AgentConsultationRoutesState, AgentConsultationStatus, AgentDecisionOutcome, AgentElevatedReads, AgentEvaluation, AgentEvaluationCost, AgentEvaluationDecisions, AgentEvaluationDifference, AgentEvaluationFilter, AgentEvaluationRouting, AgentEvaluationRuns, AgentEvaluationTool, AgentExecutionResolution, AgentFeedbackCategoryCount, AgentFeedbackExportFilter, AgentFeedbackFilter, AgentFeedbackItem, AgentFeedbackList, AgentFeedbackListFilter, AgentFeedbackOutcome, AgentFeedbackSummary, AgentFeedbackSummaryRow, AgentGrantSource, AgentGroup, AgentInbox, AgentInboxFilter, AgentInboxGroup, AgentInboxSubjectGroup, AgentInboxVisit, AgentInvalidationCount, AgentLatestRun, AgentObjectAgent, AgentObjectAgents, AgentProposal, AgentProposalDecision, AgentProposalDecisionRight, AgentProposalFeedback, AgentProposalFeedbackCategory, AgentProposalFeedbackGroup, AgentProposalLookup, AgentProposalObject, AgentProposalOrigin, AgentProposalParent, AgentProposalStatus, AgentReplay, AgentReplayList, AgentReplayRequest, AgentRun, AgentRunConfiguration, AgentRunFilter, AgentRunHistory, AgentRunHistoryItem, AgentRunKind, AgentRunList, AgentRunMcpSkip, AgentRunResult, AgentRunRetryMode, AgentRunSettings, AgentRunSettingsRequest, AgentRunState, AgentRunStatus, AgentServiceAccountState, AgentShadowMode, AgentShadowState, AgentSkillChooser, AgentSkillState, AgentState, AgentSubjectRole, AgentSubjectSearch, AgentSubjectSearchResult, AgentSubjectSummary, AgentSubjectSummaryList, AgentSubjectType, AgentSubjectWork, AgentSubjectWorkAgent, AgentSubjectWorkProposal, AgentSummary, AgentThread, AgentThreadLookup, AgentThreadMemory, AgentTriggerOutcome, AgentTriggerReceipt, AgentUploadExtension, AgentUploads, ApplicationContext, ApplicationContextVersion, ApplicationMessageDetails, ApplicationMessageLink, ApprovalConsultation, ApprovalDecision, ApprovalPart, ApprovalPolicySummary, ApprovalPresentation, ApprovalPresentationField, ApprovalRequiredEvent, ApprovalStatus, ApproverSummary, AssistantAccount, AssistantAddressForm, AssistantAutonomy, AssistantCollaboration, AssistantConfigurationWarning, AssistantDataClassification, AssistantErrorEvent, AssistantPreferences, AssistantResponseLength, AssistantStatus, AssistantStyle, ClientContext, ClientContextEntity, CodeConsultation, CodeRunSettings, CodeSkill, CodeTrigger, ConnectionRequiredEvent, ConnectionRequiredPart, ConnectionRequiredReason, ConsultationCeiling, ConsultationExposure, ConsultationSubjectRole, Conversation, ConversationKind, ConversationMember, ConversationPage, ConversationRole, ConversationStatus, ConversationSummary, ConversationThread, ConversationThreadDecision, CreateConversationRequest, DataConsultation, DataConsultationRequest, DataSkill, DataSkillRequest, DataSkillVersion, DataSkillVersionStatus, DataTrigger, DataTriggerRequest, DataTriggerShadowRequest, DecideApprovalRequest, DirectoryEntry, FileLimits, FilePart, FileReference, LiveAgentWorkChanged, LiveAgentWorkReason, LiveAgentWorkWatch, LiveConversationChanged, LiveConversationEvent, LiveConversationRead, LiveConversationRemoved, LowerFileLimits, McpAuthMode, McpAuthorization, McpAuthorizationStart, McpAuthorizeRequest, McpBuiltInAuthMode, McpCompleteRequest, McpCompletion, McpConnection, McpConnectionScope, McpConnectionStatus, McpConnectionsSummary, McpCustomAuthMode, McpDiscoverRequest, McpDiscovery, McpHeadlessUse, McpOAuthInput, McpOAuthSettings, McpOrganizationConnection, McpReader, McpReaderInput, McpServer, McpServerInput, McpServerTestResult, McpTool, McpToolEffect, McpToolStatus, McpTransport, Message, MessageAuthorKind, MessageDeltaEvent, MessagePart, MessageQueuedEvent, NhAssistantAccessPolicy, NhAssistantActivity, NhAssistantApprovalChoice, NhAssistantApprovalRight, NhAssistantApprovalWaitingFor, NhAssistantAttachment, NhAssistantClientContext, NhAssistantClientErrorCode, NhAssistantConfig, NhAssistantConsultationLeaveRoute, NhAssistantConsultationRoute, NhAssistantError, NhAssistantFetch, NhAssistantIconName, NhAssistantLiveState, NhAssistantMcpAuthorizationHandle, NhAssistantMcpAuthorizationOutcome, NhAssistantMcpAuthorizationWindow, NhAssistantMcpReturnOutcome, NhAssistantMessageEvent, NhAssistantNotice, NhAssistantProposalFeedbackSaved, NhAssistantPushConfig, NhAssistantPushState, NhAssistantQueuedMessage, NhAssistantRawSseMessage, NhAssistantSseEvent, NhAssistantSseEventMap, NhAssistantSseEventType, NhAssistantStatusCodes, NhAssistantSubjectLinkBuilder, NhAssistantSubjectRef, NhAssistantToolCallGroupState, NhAssistantUpload, NhAssistantUploadEvent, NhAssistantUploadRequest, NotificationSettings, PushSubscriptionRequest, RunBlock, RunCatalog, RunConfigurationProblem, RunConfigurationProblemKind, RunConfigurationRemoval, SendMessageRequest, SetAgentConsultationRoutesRequest, SetAgentServiceAccountRequest, SetAgentShadowRequest, SetAgentStateRequest, ShareLink, SkillApplyMode, SkillCandidateRequest, SkillComparison, SkillComparisonFilter, SkillComparisonTool, SkillVersionStats, StaleKind, StartAgentRequest, TextPart, ToolCallPart, ToolCallStatus, ToolCatalogEffect, ToolCatalogEntry, ToolCompletedEvent, ToolStartedEvent, TriggerConflict, TurnCompletedEvent, TurnCompletionStatus, TurnStartedEvent, TurnUsage, UpdateAdminAgentRequest, UpdateApplicationContextRequest, UpdateMcpConnectionRequest, UpdateMcpToolRequest, NhAssistantPickerOption as ɵNhAssistantPickerOption };
+export { NH_ASSISTANT_ACCESS_POLICY, NH_ASSISTANT_AGENT_PACKAGE_FORMAT, NH_ASSISTANT_AGENT_PACKAGE_FORMAT_VERSION, NH_ASSISTANT_AGENT_PACKAGE_MAX_AGENTS, NH_ASSISTANT_AGENT_PACKAGE_MAX_BYTES, NH_ASSISTANT_CONFIG, NH_ASSISTANT_CONVERSATION_FRAGMENT, NH_ASSISTANT_ERROR_CODES, NH_ASSISTANT_FEEDBACK_CATEGORIES, NH_ASSISTANT_FEEDBACK_GROUPS, NH_ASSISTANT_FETCH, NH_ASSISTANT_ICONS, NH_ASSISTANT_JOIN_FRAGMENT, NH_ASSISTANT_MAX_BULK_FEEDBACK, NH_ASSISTANT_MAX_CUSTOM_INSTRUCTIONS, NH_ASSISTANT_MAX_FEEDBACK_TEXT, NH_ASSISTANT_MAX_PROPOSAL_LOOKUP, NH_ASSISTANT_MAX_SUBJECT_SUMMARY, NH_ASSISTANT_MCP_AUTHORIZATION_MESSAGE, NH_ASSISTANT_MCP_AUTHORIZATION_WINDOW, NH_ASSISTANT_MESSAGE_QUEUED_NOTICE_CODE, NH_ASSISTANT_NO_ANSWER_NOTICE_CODE, NH_ASSISTANT_PACKAGE_LOCK_ALL, NH_ASSISTANT_PACKAGE_LOCK_FIELDS, NH_ASSISTANT_PAGE_CONTEXT_LIMITS, NH_ASSISTANT_PANEL_MOBILE_QUERY, NH_ASSISTANT_PANEL_WIDTH, NH_ASSISTANT_RESULT_PREVIEW_LENGTH, NH_ASSISTANT_RUN_FRAGMENT, NH_ASSISTANT_RUN_HISTORY_MAX_PAGE, NH_ASSISTANT_RUN_RESULT_MAX_LENGTH, NH_ASSISTANT_SERVER_ERROR_CODES, NH_ASSISTANT_SSE_EVENT_TYPES, NH_ASSISTANT_SUBJECT_SEARCH, NH_ASSISTANT_SYSTEM_GLOBAL_ID, NH_ASSISTANT_SYSTEM_SUBJECT_TYPE, NH_ASSISTANT_TRANSLATIONS, NH_ASSISTANT_UPLOAD, NH_ASSISTANT_UPLOAD_HEADER, NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD, NhAssistantActivityComponent, NhAssistantAdminApiService, NhAssistantAgentPickerComponent, NhAssistantAgentRunApiService, NhAssistantAllowAllAccessPolicy, NhAssistantApiError, NhAssistantApiService, NhAssistantApprovalCardComponent, NhAssistantClientErrorCodes, NhAssistantComposerComponent, NhAssistantConnectionRequiredComponent, NhAssistantConversationListComponent, NhAssistantDocumentComponent, NhAssistantLauncherComponent, NhAssistantLiveService, NhAssistantMcpConnectService, NhAssistantMcpConnectionsComponent, NhAssistantMcpPopupAuthorizationWindow, NhAssistantPanelComponent, NhAssistantPanelService, NhAssistantPreferencesComponent, NhAssistantProposalFeedbackComponent, NhAssistantPushService, NhAssistantQuestionCardComponent, NhAssistantShareComponent, NhAssistantSseParser, NhAssistantStore, NhAssistantSubjectBadgeComponent, NhAssistantSubjectSummaryService, NhAssistantThreadComponent, NhAssistantToolCallCardComponent, NhAssistantToolCallGroupComponent, NhAssistantTranslationMerger, applyNhAssistantApprovalDecision, applyNhAssistantConversationChange, applyNhAssistantEvent, applyNhAssistantLiveEvent, applyNhAssistantQuestionAnswer, describeNhAssistantClientContext, formatNhAssistantCountdown, nhAssistantCodeForStatus, nhAssistantConnectMcp, nhAssistantErrorMessageKey, nhAssistantIsUnread, nhAssistantLatestTurnHasText, nhAssistantMcpAuthorizationFromFragment, nhAssistantShareLink, nhAssistantXhrUpload, normalizeNhAssistantClientContext, provideNhAssistant, toNhAssistantError, NH_ASSISTANT_DASH_CASE as ɵNH_ASSISTANT_DASH_CASE, NhAssistantIconComponent as ɵNhAssistantIconComponent, NhAssistantMarkdownPipe as ɵNhAssistantMarkdownPipe, NhAssistantPickerComponent as ɵNhAssistantPickerComponent, NhAssistantSubjectLinkComponent as ɵNhAssistantSubjectLinkComponent, NhAssistantTranslatePipe as ɵNhAssistantTranslatePipe, nhAssistantCodeKeys as ɵnhAssistantCodeKeys, nhAssistantErrorKeys as ɵnhAssistantErrorKeys, nhAssistantErrorOf as ɵnhAssistantErrorOf, nhAssistantMediaTypeOf as ɵnhAssistantMediaTypeOf, nhAssistantReloadOnAgentWork as ɵnhAssistantReloadOnAgentWork, nhAssistantWatchAgentWork as ɵnhAssistantWatchAgentWork, toNhAssistantError as ɵtoNhAssistantError };
+export type { AdminAgent, AdminAgentGroups, AdminAgentInput, AgentAccountability, AgentArtifact, AgentBoard, AgentBoardAgent, AgentBoardList, AgentBoardSubjectType, AgentBoardSummary, AgentBoardVisit, AgentBoardWorksOn, AgentConsultation, AgentConsultationList, AgentConsultationRouteState, AgentConsultationRouteSwitch, AgentConsultationRoutesState, AgentConsultationStatus, AgentDecisionOutcome, AgentElevatedReads, AgentEvaluation, AgentEvaluationCost, AgentEvaluationDecisions, AgentEvaluationDifference, AgentEvaluationFilter, AgentEvaluationRouting, AgentEvaluationRuns, AgentEvaluationTool, AgentExecutionResolution, AgentFeedbackCategoryCount, AgentFeedbackExportFilter, AgentFeedbackFilter, AgentFeedbackItem, AgentFeedbackList, AgentFeedbackListFilter, AgentFeedbackOutcome, AgentFeedbackSummary, AgentFeedbackSummaryRow, AgentGrantSource, AgentGroup, AgentHandOffs, AgentInbox, AgentInboxFilter, AgentInboxGroup, AgentInboxStatus, AgentInboxSubjectGroup, AgentInboxVisit, AgentInvalidationCount, AgentLatestRun, AgentMetadata, AgentMetadataEntry, AgentMetadataRequest, AgentMetadataSource, AgentObjectAgent, AgentObjectAgents, AgentPackage, AgentPackageExport, AgentPackageExportOptions, AgentPackageExportRequest, AgentPackageImport, AgentPackageImportOptions, AgentPackageImportRequest, AgentPackageInfo, AgentPackageLink, AgentPackagePart, AgentPackagePartKind, AgentPackagePartOutcome, AgentPackagePreview, AgentPackageUnlink, AgentPackageUnlinkRequest, AgentPackageWarning, AgentPackageWarningCode, AgentProposal, AgentProposalDecision, AgentProposalDecisionRight, AgentProposalFeedback, AgentProposalFeedbackCategory, AgentProposalFeedbackGroup, AgentProposalLookup, AgentProposalObject, AgentProposalOrigin, AgentProposalParent, AgentProposalStatus, AgentReplay, AgentReplayList, AgentReplayRequest, AgentRun, AgentRunConfiguration, AgentRunFilter, AgentRunHistory, AgentRunHistoryItem, AgentRunKind, AgentRunList, AgentRunMcpSkip, AgentRunResult, AgentRunRetryMode, AgentRunSettings, AgentRunSettingsRequest, AgentRunState, AgentRunStatus, AgentServiceAccountState, AgentShadowMode, AgentShadowState, AgentShadowVariants, AgentSkillChooser, AgentSkillState, AgentState, AgentSubjectRole, AgentSubjectSearch, AgentSubjectSearchResult, AgentSubjectSummary, AgentSubjectSummaryList, AgentSubjectType, AgentSubjectWork, AgentSubjectWorkAgent, AgentSubjectWorkProposal, AgentSummary, AgentThread, AgentThreadLookup, AgentThreadMemory, AgentTriggerOutcome, AgentTriggerReceipt, AgentUploadExtension, AgentUploads, AnswerQuestionRequest, ApplicationContext, ApplicationContextVersion, ApplicationMessageDetails, ApplicationMessageLink, ApprovalConsultation, ApprovalDecision, ApprovalPart, ApprovalPolicySummary, ApprovalPresentation, ApprovalPresentationField, ApprovalRequiredEvent, ApprovalResolution, ApprovalStatus, ApproverSummary, AssistantAccount, AssistantAddressForm, AssistantAutonomy, AssistantCollaboration, AssistantConfigurationWarning, AssistantDataClassification, AssistantErrorEvent, AssistantPreferences, AssistantResponseLength, AssistantStatus, AssistantStyle, ClientContext, ClientContextEntity, CodeConsultation, CodeHandOff, CodeRunSettings, CodeSkill, CodeTrigger, ConnectionRequiredEvent, ConnectionRequiredPart, ConnectionRequiredReason, ConsultationCeiling, ConsultationExposure, ConsultationSubjectRole, Conversation, ConversationKind, ConversationMember, ConversationPage, ConversationRole, ConversationStatus, ConversationSummary, ConversationThread, ConversationThreadDecision, CreateConversationRequest, DataConsultation, DataConsultationRequest, DataConsultationState, DataConsultationStateRequest, DataHandOff, DataHandOffRequest, DataSkill, DataSkillRequest, DataSkillVersion, DataSkillVersionStatus, DataTrigger, DataTriggerRequest, DataTriggerShadowRequest, DataTriggerVersion, DecideApprovalRequest, DirectoryEntry, FileLimits, FilePart, FileReference, HandOffAllowance, HandOffCeiling, InstructionAssetList, InstructionAssetProblem, InstructionAssetReference, InstructionAssetSummary, InstructionAssetText, LiveAgentWorkChanged, LiveAgentWorkReason, LiveAgentWorkWatch, LiveConversationChanged, LiveConversationEvent, LiveConversationRead, LiveConversationRemoved, LowerFileLimits, McpAuthMode, McpAuthorization, McpAuthorizationStart, McpAuthorizeRequest, McpBuiltInAuthMode, McpCompleteRequest, McpCompletion, McpConnection, McpConnectionScope, McpConnectionStatus, McpConnectionsSummary, McpCustomAuthMode, McpDiscoverRequest, McpDiscovery, McpHeadlessUse, McpOAuthInput, McpOAuthSettings, McpOrganizationConnection, McpReader, McpReaderInput, McpServer, McpServerInput, McpServerTestResult, McpTool, McpToolEffect, McpToolStatus, McpTransport, Message, MessageAuthorKind, MessageDeltaEvent, MessagePart, MessageQueuedEvent, NhAssistantAccessPolicy, NhAssistantActivity, NhAssistantApprovalChoice, NhAssistantApprovalResolutionChoice, NhAssistantApprovalRight, NhAssistantApprovalWaitingFor, NhAssistantAttachment, NhAssistantClientContext, NhAssistantClientErrorCode, NhAssistantConfig, NhAssistantConsultationLeaveRoute, NhAssistantConsultationRoute, NhAssistantDiagramRenderer, NhAssistantDocumentHeading, NhAssistantDocumentLinkEvent, NhAssistantDocumentLinkKind, NhAssistantError, NhAssistantFetch, NhAssistantIconName, NhAssistantLiveState, NhAssistantMcpAuthorizationHandle, NhAssistantMcpAuthorizationOutcome, NhAssistantMcpAuthorizationWindow, NhAssistantMcpReturnOutcome, NhAssistantMessageEvent, NhAssistantNotice, NhAssistantProposalFeedbackSaved, NhAssistantPushConfig, NhAssistantPushState, NhAssistantQuestionAnswer, NhAssistantQueuedMessage, NhAssistantRawSseMessage, NhAssistantSseEvent, NhAssistantSseEventMap, NhAssistantSseEventType, NhAssistantStatusCodes, NhAssistantSubjectLinkBuilder, NhAssistantSubjectRef, NhAssistantToolCallGroupState, NhAssistantUpload, NhAssistantUploadEvent, NhAssistantUploadRequest, NotificationSettings, PackageAgent, PackageAgentDefinition, PackageConsultation, PackageHandOff, PackagePartLink, PackagePartReference, PackageRunSettings, PackageSkill, PackageTrigger, PushSubscriptionRequest, QuestionAnsweredEvent, QuestionAskedEvent, QuestionPart, QuestionStatus, ResolveApprovalRequest, RunBlock, RunCatalog, RunConfigurationProblem, RunConfigurationProblemKind, RunConfigurationRemoval, SendMessageRequest, SetAgentConsultationRoutesRequest, SetAgentServiceAccountRequest, SetAgentShadowRequest, SetAgentStateRequest, ShadowVariant, ShadowVariantPromotion, ShadowVariantPromotionRequest, ShareLink, SkillApplyMode, SkillCandidateRequest, SkillComparison, SkillComparisonFilter, SkillComparisonTool, SkillVersionStats, StaleKind, StartAgentRequest, TextPart, ToolCallPart, ToolCallStatus, ToolCatalogEffect, ToolCatalogEntry, ToolCompletedEvent, ToolStartedEvent, TriggerCandidateRequest, TriggerComparison, TriggerConflict, TurnCompletedEvent, TurnCompletionStatus, TurnStartedEvent, TurnUsage, UpdateAdminAgentRequest, UpdateApplicationContextRequest, UpdateMcpConnectionRequest, UpdateMcpToolRequest, NhAssistantPickerOption as ɵNhAssistantPickerOption };