@newheap/platform-ai-chat 0.17.0 → 0.19.0

package/index.d.ts

@@ -11,7 +11,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 +53,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;
     /**
@@ -103,8 +107,9 @@ interface AgentThreadLookup {
 interface AgentProposalDecisionRight {
     canDecide: boolean;
     /**
-     * Why the caller may not decide, for example `assistant-four-eyes-required` or
-     * `assistant-approval-policy-denied`; `null` when they may.
+     * Why the caller may not decide, for example `assistant-four-eyes-required`,
+     * `assistant-approval-policy-denied` or `assistant-consult-asker-decides` for a consultation's
+     * proposal that the person who asked decides in their own chat; `null` when they may.
      */
     reasonCode: string | null;
 }
@@ -439,11 +444,27 @@ 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`; it executes with that person's rights only.
+     * `initiatorActorId`; `consultationRoute` says who decides it and whose rights execute it.
      */
     consultationId?: string | null;
+    /**
+     * How a consultation's proposal is decided and whose rights execute it: `asker-decides`, the person
+     * who asked (`initiatorActorId`) decides it in their own chat, nobody decides it here;
+     * `subject-asker-rights`, the subject's approvers decide it and it runs with the asker's rights;
+     * `subject-agent-rights`, the subject's approvers other than the asker decide it and it runs with the
+     * agent's own rights (`grantSource`). `null` for a run's proposal; missing on older servers.
+     */
+    consultationRoute?: NhAssistantConsultationRoute | null;
     /** The caller's own feedback on the proposal; `null` when they gave none. Missing on older servers. */
     feedback?: AgentProposalFeedback | null;
     /**
@@ -588,6 +609,11 @@ interface AgentConsultation {
     proposalCount: number;
     createdAt: string;
     endedAt: string | null;
+    /**
+     * The proposals the consultation left per route, such as `{ 'asker-decides': 1 }`; routes without
+     * proposals are left out. Missing on older servers.
+     */
+    proposalsByRoute?: Partial<Record<NhAssistantConsultationRoute, number>>;
 }
 interface AgentConsultationList {
     items: AgentConsultation[];
@@ -693,8 +719,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`. */
@@ -824,6 +854,20 @@ interface AgentUploads {
     maxFileBytes: number;
     /** The most files of one message. */
     maxFiles: number;
+    /**
+     * The file name extensions the application mapped to one of `acceptedMediaTypes`
+     * (`NhAssistantUploadOptions.MapExtension` on the server). A file without a usable type takes the
+     * type of its extension from them before the platform's table, as on the server, and the file picker
+     * offers them. Empty, or missing from an older server, when the application maps none.
+     */
+    mappedExtensions?: AgentUploadExtension[] | null;
+}
+/** A file name extension the application mapped to an accepted media type for uploads. */
+interface AgentUploadExtension {
+    /** The extension in lowercase with its dot, for example `.dwg`. */
+    extension: string;
+    /** The accepted media type it names, for example `application/acad`. */
+    mediaType: string;
 }
 /**
  * A file the application keeps, as the upload endpoint returns it and a message names it in
@@ -918,7 +962,8 @@ interface ConversationMember {
 }
 interface Message {
     id: string;
-    role: 'user' | 'assistant' | 'tool';
+    /** `application` for a message the application posted into the conversation. */
+    role: 'user' | 'assistant' | 'tool' | 'application';
     createdAt: string;
     parts: MessagePart[];
     /** Position in the conversation; missing on optimistic messages and old servers. */
@@ -927,15 +972,40 @@ interface Message {
     authorActorId?: string | null;
     /**
      * Who wrote the message: a person or a trigger of an agent for user messages, `rule` for the
-     * summary an agent's rules wrote instead of the model; missing on old servers.
+     * summary an agent's rules wrote instead of the model, `application` for a message the
+     * application posted; missing on old servers.
      */
     authorKind?: MessageAuthorKind | null;
+    /** The title, sender, link and trusted flag of a message the application posted; missing for other messages. */
+    application?: ApplicationMessageDetails | null;
 }
 /**
  * `person` for a message a person wrote; `trigger` for one a trigger wrote into an agent thread;
- * `rule` for an assistant message the agent's rules wrote without a model.
+ * `rule` for an assistant message the agent's rules wrote without a model; `application` for a
+ * message the application posted into the conversation.
  */
-type MessageAuthorKind = 'person' | 'trigger' | 'rule';
+type MessageAuthorKind = 'person' | 'trigger' | 'rule' | 'application';
+/**
+ * What the application said about a message it posted, besides its text: an optional heading, who in
+ * the application posted it, where people continue and whether the assistant follows it. The text is
+ * the message's `text` part.
+ */
+interface ApplicationMessageDetails {
+    title: string | null;
+    senderName: string | null;
+    link: ApplicationMessageLink | null;
+    /**
+     * The assistant follows the message as the application's instruction (`Trusted` on the server);
+     * `false` for a message the assistant reads as information. The thread labels a trusted message.
+     */
+    trusted: boolean;
+}
+/** A path within the application, which the chat opens through the router, or an `https` address. */
+interface ApplicationMessageLink {
+    url: string;
+    /** The text of the link; the chat shows its own text without one. */
+    label: string | null;
+}
 type MessagePart = TextPart | ToolCallPart | ApprovalPart | ConnectionRequiredPart | FilePart;
 /**
  * A file a person attached to a message: its name, media type and size in bytes, never its content.
@@ -995,9 +1065,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;
@@ -1034,6 +1105,41 @@ interface ApprovalPart {
     rationale?: string;
     /** The newer proposal for the same objects that replaced this withdrawn one. Only sent then. */
     supersededByApprovalId?: string;
+    /**
+     * The consultation that proposed it, when the conversation's assistant consulted another agent and
+     * the person who asked decides that agent's proposal here (`asker-decides`). Approving executes it
+     * in the person's own request with their own rights. Missing for the conversation's own proposals.
+     */
+    consultation?: ApprovalConsultation | null;
+}
+/**
+ * How a consulted agent's proposal is decided and whose rights execute it: `asker-decides`, the person
+ * who asked decides it in their own chat and it runs with their own rights; `subject-agent-rights`, the
+ * subject's approvers other than the asker decide it and it runs with the agent's own rights;
+ * `subject-asker-rights`, the subject's approvers decide it and it runs with the asker's rights.
+ */
+type NhAssistantConsultationRoute = 'asker-decides' | 'subject-agent-rights' | 'subject-asker-rights';
+/** The routes at the subject a person may leave a consulted agent's proposal for (`decision: 'leave'`). */
+type NhAssistantConsultationLeaveRoute = Exclude<NhAssistantConsultationRoute, 'asker-decides'>;
+/** Where a proposal the person who asked decides in their own conversation comes from. */
+interface ApprovalConsultation {
+    /** The consultation record in the consulted agent's thread. */
+    consultationId: string;
+    /** The consulted agent that proposed it. */
+    agentId: string;
+    subjectType: string;
+    subjectId: string;
+    /** The subject's name as the consulted agent's thread knows it; `null` when unknown. */
+    subjectDisplayName: string | null;
+    /**
+     * The route at the subject the person may leave the pending proposal for with the decision `leave`;
+     * `null` when they can only approve or reject it.
+     */
+    leaveRoute: NhAssistantConsultationLeaveRoute | null;
+    /** The consulted agent's answer, bounded, when the consultation's classification allows a preview. */
+    answer: string | null;
+    /** The proposal that waits at the subject since the person left this one for its approvers. */
+    movedToApprovalId: string | null;
 }
 /** Response of `GET conversations?page=&itemsPerPage=`. */
 interface ConversationPage {
@@ -1077,7 +1183,11 @@ interface SendMessageRequest {
     /** Files the person attaches, as `POST conversations/{id}/files` returned them. */
     files?: FileReference[];
 }
-type ApprovalDecision = 'approve' | 'reject';
+/**
+ * `approve` or `reject`; for a consulted agent's proposal with a `consultation.leaveRoute` also
+ * `leave`, which leaves it for the subject's approvers instead of deciding it.
+ */
+type ApprovalDecision = 'approve' | 'reject' | 'leave';
 /** Body of `POST conversations/{id}/approvals/{approvalId}/decide`. */
 interface DecideApprovalRequest {
     decision: ApprovalDecision;
@@ -1272,6 +1382,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';
@@ -1393,6 +1843,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
@@ -1406,6 +1870,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 & {
@@ -1434,6 +1958,11 @@ interface AdminAgent extends AdminAgentInput {
     stateReason: string | null;
     /** Events that wait while the agent is paused. */
     waitingInputs: number;
+    /**
+     * `true` while the agent is stopped and was off when it stopped: releasing the kill switch switches
+     * it back off, while resuming switches it on. `false` otherwise; missing on older servers.
+     */
+    offBeforeStop?: boolean;
     /** The agent's skills with their states and today's usage; missing or empty without skills. */
     skills?: AgentSkillState[];
     /** The live agent this agent is a shadow variant of; missing or null for an agent that is no variant. */
@@ -1482,6 +2011,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 {
@@ -1556,11 +2097,58 @@ interface AgentState {
     cancelledRuns: number;
     /** The runs this change started for waiting events by resuming the agent. */
     startedRuns: number;
+    /**
+     * `true` while the agent is stopped and was off when it stopped: releasing the kill switch switches
+     * it back off, while resuming switches it on. `false` otherwise; missing on older servers.
+     */
+    offBeforeStop?: boolean;
     skills?: AgentSkillState[];
     shadowOf?: string | null;
     /** `null` for an agent without runs, which only chats. */
     shadow?: AgentShadowState | null;
     serviceAccount?: AgentServiceAccountState | null;
+    /**
+     * The routes of the agent's consultations, as its consultations in code and as data allow them and
+     * an administrator switched them; `null` when nobody can consult the agent: it has no consultation
+     * in code and none defined as data in effect. Missing on older servers.
+     */
+    consultationRoutes?: AgentConsultationRoutesState | null;
+}
+/**
+ * The routes of an agent's consultations: one entry per route, and the last change at runtime. The
+ * consultations are the ceiling: a route none of them allows can never be switched on.
+ */
+interface AgentConsultationRoutesState {
+    routes: AgentConsultationRouteState[];
+    /** When the routes last changed at runtime; `null` while they follow the code. */
+    changedAt: string | null;
+    changedBy: string | null;
+    reason: string | null;
+}
+/** One route of an agent's consultations. */
+interface AgentConsultationRouteState {
+    route: NhAssistantConsultationRoute;
+    /** Whether a consultation of the agent, in code or as data in effect, allows the route: the ceiling. */
+    allowed: boolean;
+    /** The switch an administrator set: `true` on, `false` off, `null` following the code. */
+    override: boolean | null;
+    /** Whether consultations use the route now: allowed and not switched off. */
+    on: boolean;
+    /** The subject types whose consultation allows the route. */
+    subjectTypes: string[];
+}
+/** A switch of a consultation route: on, off, or back to the setting in code. */
+type AgentConsultationRouteSwitch = 'on' | 'off' | 'code';
+/**
+ * Body of `POST admin/agents/{id}/consultation-routes`. A route left out keeps its switch; switching
+ * on a route that code does not allow fails with `409 assistant-consult-route-not-allowed`.
+ */
+interface SetAgentConsultationRoutesRequest {
+    askerDecides?: AgentConsultationRouteSwitch;
+    subjectAgentRights?: AgentConsultationRouteSwitch;
+    subjectAskerRights?: AgentConsultationRouteSwitch;
+    /** Optional, at most 500 characters. */
+    reason?: string | null;
 }
 /** Body of `POST admin/agents/{id}/shadow` and `POST admin/agents/{id}/skills/{skillId}/shadow`. */
 interface SetAgentShadowRequest {
@@ -2111,6 +2699,105 @@ interface RunCatalog {
      * can only lower them; missing on older servers.
      */
     fileLimits?: FileLimits | null;
+    /**
+     * The application's ceiling of consultations defined as data (`UseConsultationsAsData`): what agents
+     * created here may be consulted with. `null` while consultations exist in code only; missing on
+     * 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`. */
+    indexed: 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;
+    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
+ * answers only), whether they may generate the request tool and be seen by MCP clients, and their
+ * highest limits.
+ */
+interface ConsultationCeiling {
+    routes: NhAssistantConsultationRoute[];
+    allowRequests: boolean;
+    allowMcp: boolean;
+    /** The most tool calls of one consultation. */
+    maxToolCalls: number;
+    /** The longest consultation, in seconds. */
+    maxTimeoutSeconds: number;
+    /** The longest answer, in characters. */
+    maxAnswerChars: number;
+    /** The most thread messages a consulted agent reads. */
+    maxHistoryMessages: number;
+    /** The most consultations defined as data of one agent. */
+    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
@@ -2193,15 +2880,16 @@ interface AssistantAccount {
     detail: string | null;
 }
 /** Which part of the run configuration a problem concerns. */
-type RunConfigurationProblemKind = 'agent' | 'skill' | 'candidate' | 'trigger';
+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 profile, policy, rule handler, event or subject set it names. A consultation defined as data may
+ * also stay in effect without the parts that no longer fit, each with a problem.
  */
 interface RunConfigurationProblem {
     agentId: string;
     kind: RunConfigurationProblemKind;
-    /** The agent, skill or trigger id. */
+    /** The agent, skill or trigger id; the subject type of a consultation. */
     id: string;
     /** Such as `unknown-event` or `tool-not-covered`. */
     code: string;
@@ -2240,6 +2928,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 {
@@ -2365,6 +3058,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';
@@ -2399,6 +3103,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. */
@@ -2410,6 +3121,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 {
@@ -2484,6 +3197,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 {
@@ -2515,13 +3242,59 @@ 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 {
     mode: 'shadow' | 'live';
     reason?: string | null;
 }
-/** Query of the removals of run settings, data skills and data triggers. */
+/** Query of the removals of run settings, data skills, data triggers and data consultations. */
 interface RunConfigurationRemoval {
     expectedVersion?: number | null;
     reason?: string | null;
@@ -2544,6 +3317,286 @@ interface AgentRunConfiguration {
     runSettings: AgentRunSettings | null;
     /** How an agent in code runs, as its code says; `null` for an agent created here, missing on older servers. */
     codeRunSettings?: CodeRunSettings | null;
+    /** The consultations the agent allows in code, read-only, by subject type; missing on older servers. */
+    codeConsultations?: CodeConsultation[];
+    /** The consultations of the agent defined as data, by subject type; missing on older servers. */
+    dataConsultations?: DataConsultation[];
+    /**
+     * The ceiling within which the agent may get consultations as data: the application's for an agent
+     * created here, the application's and its own together for an agent in code that is consultable as
+     * data. `null` when it may get none; missing on older servers.
+     */
+    consultationCeiling?: ConsultationCeiling | null;
+}
+/** The role a person needs on the subject: to ask a consulted agent, or before it may propose. */
+type ConsultationSubjectRole = Exclude<AgentSubjectRole, 'none'>;
+/** Where the generated tools of a consultation are offered. */
+type ConsultationExposure = 'local' | 'agent' | 'mcp';
+/**
+ * A consultation the agent allows in code with `AllowConsultation`; it cannot change here, apart from
+ * the agent's route switches.
+ */
+interface CodeConsultation {
+    subjectType: string;
+    description: string | null;
+    /** The routes its registration allows, before the agent's route switches. */
+    allowedRoutes: NhAssistantConsultationRoute[];
+    allowRequests: boolean;
+    exposure: ConsultationExposure[];
+    /** The id of the generated consult tool, which asking agents select. */
+    consultToolId: string;
+    /** The id of the generated request tool; `null` without requests. */
+    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.
+ * It is in effect once saved and answers only when an asking agent selects its consult tool.
+ */
+interface DataConsultation {
+    subjectType: string;
+    version: number;
+    /** What the asking model reads about when to consult the agent. */
+    description: string;
+    /** Extra instructions of the consulted agent. */
+    instructions: string | null;
+    instructionsHash: string | null;
+    /** The role the asking person needs on the subject. */
+    minimumRole: ConsultationSubjectRole;
+    /**
+     * The policy the asking person must pass, one the application lists with `AddAgentPolicy`; `null`
+     * uses the agent's required policy, else the assistant's access policy.
+     */
+    askerPolicy: string | null;
+    /** The routes as saved; empty for a consultation that only answers. */
+    routes: NhAssistantConsultationRoute[];
+    /** The role the asking person needs before the agent may propose. */
+    proposalRole: ConsultationSubjectRole;
+    /** The approval policy of its proposals; `null` uses the agent's. */
+    proposalPolicy: string | null;
+    maxToolCalls: number;
+    timeoutSeconds: number;
+    maxAnswerChars: number;
+    maxHistoryMessages: number;
+    allowRequests: boolean;
+    /** MCP clients may see its tools, while the ceiling allows MCP. */
+    exposeToMcp: boolean;
+    /** The classification of its answers; `null` uses the agent's. */
+    dataClassification: AssistantDataClassification | null;
+    changedAt: string;
+    changedBy: string;
+    reason: string | null;
+    /** `false` with `problem` when the consultation no longer fits the code. */
+    inEffect: boolean;
+    /** The first problem: the reason it is out of effect when it is. */
+    problem: string | null;
+    /**
+     * Every problem: the reason it is out of effect, or each part that no longer fits and was dropped or
+     * capped, such as `route-not-allowed` or `limit-above-ceiling`.
+     */
+    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. */
+    requestToolId: string | null;
+    /** The agents whose tool selectors select the consult tool now, by id: the consultation's second key. */
+    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
+ * defaults within the ceiling.
+ */
+interface DataConsultationRequest {
+    /** Required, at most 1,000 characters. */
+    description: string;
+    /** At most the ceiling's `maxInstructionsLength`, 4,000 characters. */
+    instructions?: string | null;
+    /** `reader` by default. */
+    minimumRole?: ConsultationSubjectRole | null;
+    /** A policy of the run catalog's `agentPolicies`; `null` uses the agent's required policy. */
+    askerPolicy?: string | null;
+    /**
+     * `asker-decides` and at most one of `subject-asker-rights` and `subject-agent-rights`, within the
+     * ceiling; empty keeps the consultation read-only. A route outside the ceiling fails with
+     * `routes: not-allowed`.
+     */
+    routes?: NhAssistantConsultationRoute[];
+    /** `participant` by default. */
+    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. */
+    timeoutSeconds?: number | null;
+    /** 200 to 32,000, at most the ceiling's. */
+    maxAnswerChars?: number | null;
+    /** 0 to 200, at most the ceiling's. */
+    maxHistoryMessages?: number | null;
+    /** Also generates the request tool; only when the ceiling allows requests. */
+    allowRequests?: boolean;
+    /** MCP clients may see its tools; only when the ceiling allows MCP. */
+    exposeToMcp?: boolean;
+    /** `null` uses the agent's. */
+    dataClassification?: AssistantDataClassification | null;
+    /** The consultation's current version; `null` for a new consultation. */
+    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;
+}
+/** `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[];
 }
 
 /** Decides whether the current user may see and use the assistant. */
@@ -2936,12 +3989,36 @@ declare class NhAssistantAdminApiService {
      * account that does not exist or may not sign in.
      */
     setServiceAccount(agentId: string, request: SetAgentServiceAccountRequest): Observable<AgentState>;
+    /**
+     * Switches the routes of the agent's consultations on, off or back to the setting in code; a route
+     * left out keeps its switch. Code is the ceiling: switching on a route that no consultation in code
+     * allows fails with `assistant-consult-route-not-allowed`. Returns the agent's state with its
+     * `consultationRoutes`.
+     */
+    setConsultationRoutes(agentId: string, request: SetAgentConsultationRoutesRequest): Observable<AgentState>;
     /**
      * Puts an agent, in code or created here, in exactly `groups` of the run catalog's `agentGroups`
      * and out of the others. The choice wins over the agent's `InGroup` in code. Fails with a field error
      * 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[]>;
@@ -3014,6 +4091,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
@@ -3044,7 +4132,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`
@@ -3061,11 +4152,106 @@ 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>;
+    /**
+     * Adds or changes the consultation defined as data of an agent about one subject type, within the
+     * agent's `consultationCeiling`. It is in effect once saved and answers when an asking agent selects
+     * its consult tool. An agent that may get none fails with `assistant-consultations-not-allowed`, an
+     * agent created here without run settings with `assistant-agent-not-configured`, a type the agent
+     * allows consultation about in code with `assistant-consultation-in-code`, more than the ceiling's
+     * `maxConsultations` with `assistant-configuration-limit`, a stale `expectedVersion` with
+     * `assistant-version-conflict` and invalid input with field errors, such as `routes: not-allowed` for
+     * 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>;
+    /**
+     * 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>;
@@ -3235,11 +4421,16 @@ declare class NhAssistantAgentRunApiService {
  * replaced by the server's `userMessageId` when `turn.started` arrives.
  */
 declare function applyNhAssistantEvent(conversation: Conversation, event: NhAssistantSseEvent, clientMessageId?: string): Conversation;
-/** Records the user's approval decision locally until the server state is reloaded. */
-declare function applyNhAssistantApprovalDecision(conversation: Conversation, approvalId: string, decision: 'approve' | 'reject'): Conversation;
 /**
- * Applies a live update of another session: `message.created` adds a participant's message,
- * the turn events behave exactly like the starting request's stream. Unknown types are ignored.
+ * Records the user's approval decision locally until the server state is reloaded. A consulted
+ * agent's proposal that the user left for the subject's approvers (`leave`) closes here as the server
+ * 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;
+/**
+ * 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
+ * like the starting request's stream. Unknown types are ignored.
  */
 declare function applyNhAssistantLiveEvent(conversation: Conversation, event: LiveConversationEvent): Conversation;
 /** Applies the shared state of a conversation that a live update announced. */
@@ -3399,9 +4590,10 @@ declare const NH_ASSISTANT_MESSAGE_QUEUED_NOTICE_CODE = "assistant-message-queue
 /**
  * Who decides an approval the current user cannot decide: `turn`, the person whose turn created
  * it in a chat; `approver`, an approver of the agent thread's subject; `other-approver`, another
- * approver, because the current user started the work and four-eyes applies.
+ * approver, because the current user started the work and four-eyes applies; `asker`, the person
+ * who consulted the thread's agent, in their own chat.
  */
-type NhAssistantApprovalWaitingFor = 'turn' | 'approver' | 'other-approver';
+type NhAssistantApprovalWaitingFor = 'turn' | 'approver' | 'other-approver' | 'asker';
 /** The current user's right to decide, or to give feedback on, one approval of the open conversation. */
 interface NhAssistantApprovalRight {
     canDecide: boolean;
@@ -3523,6 +4715,12 @@ declare class NhAssistantStore {
     /** Non-blocking remark about the latest completed turn; shown only while no error is shown. */
     readonly notice: _angular_core.Signal<NhAssistantError | null>;
     readonly lastUsage: _angular_core.Signal<TurnUsage | null>;
+    /**
+     * The answer the running turn of the open conversation writes, while this tab streams the turn or
+     * follows it live; `null` otherwise. Pass it to `nh-assistant-thread` as `writingMessageId`, so
+     * the working indicator stays under that answer when a message arrives after it during the turn.
+     */
+    readonly writingMessageId: _angular_core.Signal<string | null>;
     /** Text of a message the server did not accept, so the composer can offer it again. */
     readonly restoredDraft: _angular_core.Signal<string | null>;
     /** Page context that the next message would send, for the transparency chip. */
@@ -3631,8 +4829,11 @@ declare class NhAssistantStore {
     /**
      * Approves or rejects an approval of the open conversation: `approvalId`, or the pending approval
      * when it is left out. A proposal of an agent's run is decided with its proposal hash through the
-     * agent-run endpoint; other approvals resume their turn as a stream. Ignores calls the current
-     * user may not make and repeated calls while a decision is in flight.
+     * agent-run endpoint; other approvals resume their turn as a stream. `leave` leaves a consulted
+     * agent's proposal that has a `consultation.leaveRoute` for the subject's approvers; it resumes the
+     * turn like a decision and reads the conversation again, which then names the proposal that waits
+     * at the subject. Ignores calls the current user may not make, `leave` for other approvals and
+     * repeated calls while a decision is in flight.
      */
     decide(decision: ApprovalDecision, reason?: string, approvalId?: string): void;
     /**
@@ -3713,6 +4914,11 @@ declare class NhAssistantStore {
     private onLiveChanged;
     private onLiveRead;
     private onLiveRemoved;
+    /**
+     * Applies a live turn event or message to a conversation this tab shows. While the tab streams a
+     * turn of the conversation, its stream brings the turn's events and its own message, so it applies
+     * only messages that others stored meanwhile: the application's and other people's.
+     */
     private onLiveEvent;
     /**
      * A run or proposal of an agent thread changed, for example a colleague decided a proposal in the
@@ -3768,16 +4974,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.
@@ -3913,6 +5139,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;
 
@@ -4053,7 +5285,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.
@@ -4098,9 +5330,12 @@ declare const NH_ASSISTANT_VIRTUAL_SCROLL_THRESHOLD = 200;
  * The messages of a conversation as a live log. Assistant text renders as sanitized
  * Markdown, consecutive tool calls as one collapsible group that counts along, and
  * approvals as cards. The files a person attached show by name, type and size. Messages a
- * trigger wrote into an agent thread read as events, not as a person. While a turn runs
- * without visible progress, a working indicator shows the elapsed time. The thread follows
- * new content while the user is at the bottom.
+ * trigger wrote into an agent thread read as events, not as a person, and a message the application
+ * posted reads as the application's, with its sender, title, Markdown text and link, and a label when
+ * the assistant follows it as an instruction. While a turn runs without visible progress, a working
+ * indicator shows the elapsed time: under the answer `writingMessageId` names, also when the
+ * application's or another person's message arrived after it, and at the end without it. The thread
+ * follows new content while the user is at the bottom.
  */
 declare class NhAssistantThreadComponent {
     private readonly injector;
@@ -4129,6 +5364,13 @@ declare class NhAssistantThreadComponent {
      * card of a rejected proposal ask what was wrong.
      */
     readonly approvalRights: _angular_core.InputSignal<ReadonlyMap<string, NhAssistantApprovalRight> | null>;
+    /**
+     * The answer the running turn writes, for example `NhAssistantStore.writingMessageId`. The working
+     * indicator stays under that answer, also when the application's or a colleague's message arrives
+     * after it during the turn. Without it, or when it names no message of `messages`, the indicator
+     * shows at the end of the thread.
+     */
+    readonly writingMessageId: _angular_core.InputSignal<string | null>;
     /** The decision about an approval card, without the approval it belongs to. */
     readonly approvalDecision: _angular_core.OutputEmitterRef<ApprovalDecision>;
     /** The decision about an approval card together with its approval id. */
@@ -4146,9 +5388,17 @@ declare class NhAssistantThreadComponent {
     /**
      * True while the turn runs and nothing else shows progress: before the first part and
      * between tool calls while the model decides what to do next. Streaming text and a
-     * running tool group show their own progress; an approval waits for the user.
+     * running tool group show their own progress; an approval waits for the user. With
+     * `writingMessageId`, the answer it names decides, as if the messages after it were not there.
      */
     readonly working: _angular_core.Signal<boolean>;
+    /**
+     * The message in whose row the working indicator shows: the answer `writingMessageId` names.
+     * `null` puts the indicator at the end of the thread.
+     */
+    readonly workingAfterId: _angular_core.Signal<string | null>;
+    /** While a turn runs: the answer `writingMessageId` names, when `messages` holds it. */
+    private readonly answerBeingWritten;
     /** Whole seconds since the running turn started. */
     readonly elapsedSeconds: _angular_core.Signal<number>;
     private readonly turnStartedAt;
@@ -4159,6 +5409,8 @@ declare class NhAssistantThreadComponent {
     trackMessage(_index: number, message: Message): string;
     /** True for a user message a trigger wrote into an agent thread. */
     isTrigger(message: Message): boolean;
+    /** True for a message the application posted into the conversation. */
+    isApplication(message: Message): boolean;
     /** True for an assistant message the agent's rules wrote without a model. */
     isRule(message: Message): boolean;
     /** True for a user message written by another person in a shared conversation. */
@@ -4171,7 +5423,7 @@ declare class NhAssistantThreadComponent {
     private scrollElement;
     private scrollToEnd;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NhAssistantThreadComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NhAssistantThreadComponent, "nh-assistant-thread", never, { "messages": { "alias": "messages"; "required": true; "isSignal": true; }; "streaming": { "alias": "streaming"; "required": false; "isSignal": true; }; "deciding": { "alias": "deciding"; "required": false; "isSignal": true; }; "markdown": { "alias": "markdown"; "required": false; "isSignal": true; }; "members": { "alias": "members"; "required": false; "isSignal": true; }; "currentActorId": { "alias": "currentActorId"; "required": false; "isSignal": true; }; "canDecide": { "alias": "canDecide"; "required": false; "isSignal": true; }; "decisionOwner": { "alias": "decisionOwner"; "required": false; "isSignal": true; }; "approvalRights": { "alias": "approvalRights"; "required": false; "isSignal": true; }; }, { "approvalDecision": "approvalDecision"; "approvalChoice": "approvalChoice"; "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"; "retryMessage": "retryMessage"; }, never, never, true, never>;
 }
 
 /**
@@ -4246,7 +5498,9 @@ 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;
@@ -4334,7 +5588,7 @@ declare class NhAssistantComposerComponent {
     /** True while a file of the next message still uploads. */
     readonly uploading: _angular_core.Signal<boolean>;
     readonly canSend: _angular_core.Signal<boolean>;
-    /** The `accept` attribute of the file input. */
+    /** The `accept` attribute of the file input, with the extensions the application mapped. */
     readonly accept: _angular_core.Signal<string>;
     /** The values the attachment texts name: the accepted types, the largest size and the most files. */
     readonly uploadParams: _angular_core.Signal<{
@@ -4411,9 +5665,15 @@ declare function formatNhAssistantCountdown(milliseconds: number): string;
  * proposed arguments and a countdown to expiry. A decision is emitted at most once until
  * the host reports that it is no longer deciding. After the user rejected an agent's proposal
  * (`canGiveFeedback`), a low-key action asks what was wrong. A proposal that closed because it no
- * longer fits shows why, such as "Already done", with the application's explanation.
+ * longer fits shows why, such as "Already done", with the application's explanation. A proposal of
+ * 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.
  */
 declare class NhAssistantApprovalCardComponent {
+    /** Names the consulted agent as the status does; the card also works outside `provideNhAssistant`. */
+    private readonly store;
     readonly approval: _angular_core.InputSignal<ApprovalPart>;
     /** True while the host submits a decision; disables both buttons. */
     readonly deciding: _angular_core.InputSignal<boolean>;
@@ -4438,6 +5698,8 @@ declare class NhAssistantApprovalCardComponent {
     readonly decide: _angular_core.OutputEmitterRef<ApprovalDecision>;
     private readonly now;
     private readonly submitted;
+    /** The decision this card sent last, so a proposal left for the approvers reads as such at once. */
+    private readonly chosen;
     /** The feedback question is expanded. */
     readonly feedbackOpen: _angular_core.WritableSignal<boolean>;
     /** The feedback was stored; the question thanks the person and the action disappears. */
@@ -4446,9 +5708,25 @@ declare class NhAssistantApprovalCardComponent {
     readonly remainingMs: _angular_core.Signal<number>;
     readonly expired: _angular_core.Signal<boolean>;
     readonly effectiveStatus: _angular_core.Signal<ApprovalStatus>;
+    /** Where a consulted agent's proposal comes from; `null` for the conversation's own proposals. */
+    readonly consultation: _angular_core.Signal<ApprovalConsultation | null>;
+    /**
+     * The translation keys of the consulted agent's name: the name the assistant's status gives it,
+     * then the convention `nh-assistant.agents.{id}.name`; the id when neither translates.
+     */
+    readonly consultedAgentKeys: _angular_core.Signal<string[]>;
+    /** The subject the consulted agent was asked about, by name or else by id. */
+    readonly consultedSubject: _angular_core.Signal<string | null>;
+    /**
+     * The user left the consulted agent's proposal for the subject's approvers: the server names the
+     * proposal that waits there, or this card just sent the decision and it was accepted.
+     */
+    readonly leftForApprovers: _angular_core.Signal<boolean>;
+    /** The status the card shows: `moved` for a proposal left for the subject's approvers. */
+    readonly shownStatus: _angular_core.Signal<ApprovalStatus | "moved">;
     /**
      * Translation key of the status: the kind of a stale proposal, "replaced" for a superseded one,
-     * otherwise the status itself.
+     * "left for approvers" for a consulted agent's proposal the user left, otherwise the status itself.
      */
     readonly statusKey: _angular_core.Signal<string>;
     /** Why the agent's rules proposed it; model proposals have none. */
@@ -4458,14 +5736,18 @@ declare class NhAssistantApprovalCardComponent {
     readonly actionable: _angular_core.Signal<boolean>;
     readonly succeeded: _angular_core.Signal<boolean>;
     readonly disabled: _angular_core.Signal<boolean>;
+    /** 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;
     readonly countdown: _angular_core.Signal<string>;
     readonly presentedSummary: _angular_core.Signal<string | null>;
     readonly feedbackAvailable: _angular_core.Signal<boolean>;
     readonly feedbackIds: _angular_core.Signal<string[]>;
     readonly feedbackPanelId: string;
     /** Translation key of the text shown instead of the buttons when the current user cannot decide. */
-    readonly waitingKey: _angular_core.Signal<"nh-assistant.approval.waiting-for-approver" | "nh-assistant.approval.waiting-for-other-approver" | "nh-assistant.approval.waiting-for" | "nh-assistant.approval.waiting-for-participant">;
+    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 decision; `leave` only for a consulted agent's proposal with a route at the subject. */
     choose(decision: ApprovalDecision): void;
     toggleFeedback(): void;
     onFeedbackSaved(): void;
@@ -4910,5 +6192,16 @@ declare class NhAssistantMarkdownPipe implements PipeTransform {
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<NhAssistantMarkdownPipe, "nhAssistantMarkdown", true>;
 }
 
-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, 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, 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, AgentUploads, ApplicationContext, ApplicationContextVersion, ApprovalDecision, ApprovalPart, ApprovalPolicySummary, ApprovalPresentation, ApprovalPresentationField, ApprovalRequiredEvent, ApprovalStatus, ApproverSummary, AssistantAccount, AssistantAddressForm, AssistantAutonomy, AssistantCollaboration, AssistantConfigurationWarning, AssistantDataClassification, AssistantErrorEvent, AssistantPreferences, AssistantResponseLength, AssistantStatus, AssistantStyle, ClientContext, ClientContextEntity, CodeRunSettings, CodeSkill, CodeTrigger, ConnectionRequiredEvent, ConnectionRequiredPart, ConnectionRequiredReason, Conversation, ConversationKind, ConversationMember, ConversationPage, ConversationRole, ConversationStatus, ConversationSummary, ConversationThread, ConversationThreadDecision, CreateConversationRequest, 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, 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, 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 };
+/**
+ * The media type a chosen file uploads as, lowercase and without parameters, by the same rule as the
+ * server. A browser gives no type, or a generic one, for a file its system does not know, and some
+ * systems name an extension after the program that opens it, such as `application/vnd.ms-excel` for
+ * a `.csv` file; the file name's extension then names the type, but only a type of
+ * `acceptedMediaTypes`: the type the application mapped the extension to (`mappedExtensions`),
+ * otherwise the platform's. A specific type stays as it is, so a type that is not accepted is refused
+ * whatever the extension. Without a type and an accepted extension, `application/octet-stream`.
+ */
+declare function nhAssistantMediaTypeOf(file: Pick<File, 'name' | 'type'>, acceptedMediaTypes: readonly string[], mappedExtensions?: readonly AgentUploadExtension[] | null): string;
+
+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, 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, AgentHandOffs, AgentInbox, AgentInboxFilter, AgentInboxGroup, 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, 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, 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, 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, PackageAgent, PackageAgentDefinition, PackageConsultation, PackageHandOff, PackagePartLink, PackagePartReference, PackageRunSettings, PackageSkill, PackageTrigger, PushSubscriptionRequest, RunBlock, RunCatalog, RunConfigurationProblem, RunConfigurationProblemKind, RunConfigurationRemoval, SendMessageRequest, SetAgentConsultationRoutesRequest, SetAgentServiceAccountRequest, SetAgentShadowRequest, SetAgentStateRequest, ShadowVariant, 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 };