@newheap/platform-ai-chat 0.17.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newheap/platform-ai-chat",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "peerDependencies": {
     "@angular/cdk": "^20.2.14",
     "@angular/common": "^20.3.28",

package/push/nh-assistant-push-worker.js

@@ -8,7 +8,9 @@
  * It shows a notification only when no window of the application is focused; otherwise it
  * forwards the message to the open windows, which already show the conversation live. A click
  * focuses an open window and opens the conversation there, or opens `app` with the conversation
- * in the URL fragment. Notifications carry a conversation id and short texts only.
+ * in the URL fragment. A notification about the proposals of a run also carries the run, which the
+ * click forwards, so the application can open its inbox of the run (`openRun$`). Notifications
+ * carry a conversation id, a run id and short texts only.
  */
 const settings = new URL(self.location.href).searchParams;
 const appUrl = settings.get('app') || '/';
@@ -27,12 +29,13 @@ self.addEventListener('push', event => {
   if (!payload || payload.type !== 'nh-assistant' || typeof payload.conversationId !== 'string') {
     return;
   }
+  const runId = typeof payload.runId === 'string' ? payload.runId : undefined;
 
   event.waitUntil((async () => {
     const windows = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
     if (windows.some(client => client.focused && client.visibilityState === 'visible')) {
       for (const client of windows) {
-        client.postMessage({ type: 'nh-assistant.push', kind: payload.kind, conversationId: payload.conversationId });
+        client.postMessage({ type: 'nh-assistant.push', kind: payload.kind, conversationId: payload.conversationId, runId });
       }
       return;
     }
@@ -42,29 +45,33 @@ self.addEventListener('push', event => {
       tag: String(payload.tag || `nh-assistant:${payload.conversationId}`),
       renotify: true,
       icon: iconUrl,
-      data: { conversationId: payload.conversationId }
+      data: { conversationId: payload.conversationId, runId }
     });
   })());
 });
 
 self.addEventListener('notificationclick', event => {
   event.notification.close();
-  const conversationId = event.notification.data && event.notification.data.conversationId;
+  const data = event.notification.data || {};
+  const conversationId = data.conversationId;
   if (typeof conversationId !== 'string') {
     return;
   }
+  const runId = typeof data.runId === 'string' ? data.runId : undefined;
 
   event.waitUntil((async () => {
     const windows = await self.clients.matchAll({ type: 'window', includeUncontrolled: true });
     const target = windows.find(client => client.focused) || windows[0];
     if (target) {
       await target.focus();
-      target.postMessage({ type: 'nh-assistant.open-conversation', conversationId });
+      target.postMessage({ type: 'nh-assistant.open-conversation', conversationId, runId });
       return;
     }
 
     const url = new URL(appUrl, self.location.origin);
-    url.hash = `nh-assistant-conversation=${encodeURIComponent(conversationId)}`;
+    url.hash = runId
+      ? `nh-assistant-run=${encodeURIComponent(runId)}.${encodeURIComponent(conversationId)}`
+      : `nh-assistant-conversation=${encodeURIComponent(conversationId)}`;
     await self.clients.openWindow(url.href);
   })());
 });

package/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { AssistantStatus, AgentSummary, Conversation, ClientContext, AssistantPreferences, ToolCatalogEntry, AdminAgentInput, CodeRunSettings, AgentRunSettingsRequest, DataSkillRequest, DataTriggerRequest, McpServerInput, McpCustomAuthMode, McpDiscovery, RunCatalog, AssistantDataClassification, AssistantAccount, AgentRunStatus, AgentTriggerReceipt, AgentRunMcpSkip, ApprovalPresentation, AgentProposalStatus, AgentProposalOrigin, AgentProposalParent, NhAssistantMcpAuthorizationWindow, NhAssistantMcpAuthorizationOutcome, NhAssistantMcpAuthorizationHandle, LiveConversationChanged, LiveConversationRead, LiveConversationRemoved, LiveConversationEvent, LiveAgentWorkChanged, FileReference, NhAssistantUploadRequest, NhAssistantLiveService, NhAssistantLiveState } from '@newheap/platform-ai-chat';
+import { AssistantStatus, AgentSummary, Conversation, ClientContext, NhAssistantConsultationLeaveRoute, AssistantPreferences, ToolCatalogEntry, AdminAgentInput, NhAssistantConsultationRoute, DataConsultationRequest, CodeRunSettings, AgentRunSettingsRequest, DataSkillRequest, DataTriggerRequest, McpServerInput, McpCustomAuthMode, McpDiscovery, RunCatalog, AssistantDataClassification, AssistantAccount, AgentPackage, AgentRunStatus, AgentTriggerReceipt, AgentRunMcpSkip, ApprovalPresentation, AgentProposalStatus, AgentProposalOrigin, AgentProposalParent, AgentGrantSource, AgentConsultationStatus, NhAssistantMcpAuthorizationWindow, NhAssistantMcpAuthorizationOutcome, NhAssistantMcpAuthorizationHandle, LiveConversationChanged, LiveConversationRead, LiveConversationRemoved, LiveConversationEvent, LiveAgentWorkChanged, ApplicationMessageDetails, Message, FileReference, NhAssistantUploadRequest, NhAssistantLiveService, NhAssistantLiveState } from '@newheap/platform-ai-chat';
 import * as _angular_core from '@angular/core';
 import { InjectionToken, EnvironmentProviders } from '@angular/core';
 import { Observable } from 'rxjs';
@@ -32,7 +32,10 @@ interface NhAssistantMockToolStep {
 /**
  * Pauses the turn for approval: `tool.started`, `approval.required` and
  * `turn.completed` with status `waiting-for-approval`. The decision resumes the turn with
- * the `approved` or `rejected` steps.
+ * the `approved` or `rejected` steps. With `consultation` the approval is a consulted agent's
+ * proposal that the person who asked decides in their own chat (`asker-decides`); with its
+ * `leaveRoute` the decision `leave` leaves it for the subject's approvers and resumes the turn with
+ * the `left` steps.
  */
 interface NhAssistantMockApprovalStep {
     approval: {
@@ -57,8 +60,26 @@ interface NhAssistantMockApprovalStep {
         resultPreview?: string | null;
         approved: NhAssistantMockStep[];
         rejected: NhAssistantMockStep[];
+        /** The consultation that proposed it; without it the approval is the conversation's own. */
+        consultation?: NhAssistantMockApprovalConsultation;
+        /** The steps after the person left the proposal for the subject's approvers. Default none. */
+        left?: NhAssistantMockStep[];
     };
 }
+/** Where a consulted agent's proposal of a mock turn comes from. */
+interface NhAssistantMockApprovalConsultation {
+    /** Default a generated id. */
+    consultationId?: string;
+    /** The consulted agent that proposed it. */
+    agentId: string;
+    subjectType: string;
+    subjectId: string;
+    subjectDisplayName?: string | null;
+    /** The route at the subject the person may leave it for; default none, so they only approve or reject it. */
+    leaveRoute?: NhAssistantConsultationLeaveRoute | null;
+    /** The consulted agent's answer. Default none. */
+    answer?: string | null;
+}
 /** Ends the stream with an `error` event. */
 interface NhAssistantMockErrorStep {
     error: {
@@ -115,6 +136,31 @@ interface NhAssistantMockMcpServer extends McpServerInput {
     /** A server each person connects to starts with the caller's own account connected. */
     personalConnected?: boolean;
 }
+/**
+ * An entry of agent metadata as the application registers it with `AddAgentMetadata`: its name,
+ * whether administrators may override it on agents in code, its size limit, its searchable value and
+ * its checks.
+ */
+interface NhAssistantMockAgentMetadataEntry {
+    /** The entry's dash-case name. */
+    name: string;
+    /** Administrators may override it on agents in code, as `Editable()`. */
+    editable?: boolean;
+    /** The largest value in bytes of its JSON; 4,096 by default. */
+    maxBytes?: number;
+    /** The field of the value whose text is its searchable value, as `IndexBy`. */
+    indexBy?: string;
+    /**
+     * The fields of the entry's type: a value with another field is refused with `value: invalid`, as
+     * the server refuses JSON that does not fit the type. Without it every field is accepted.
+     */
+    fields?: string[];
+    /**
+     * Checks a value as the application's validators do: codes by field path, `''` for the whole value,
+     * such as `{ code: ['unknown-code'] }`; `null` or an empty record accepts it.
+     */
+    validate?: (value: Record<string, unknown>) => Record<string, string[]> | null;
+}
 /**
  * A preconfigured agent. Code agents default to the scenario's chat agents. `startsOff` starts it
  * off, as `StartsOff()` in code does for an agent in code.
@@ -131,12 +177,46 @@ interface NhAssistantMockAdminAgent extends AdminAgentInput {
         shadow?: boolean;
         startsOff?: boolean;
     }[];
-    /** The live agent this code agent is a shadow variant of. */
-    shadowOf?: string;
+    /**
+     * The live agent this code agent is a shadow variant of, as `ShadowOf` in code. A data variant is
+     * created with `POST admin/agents` and `shadowOf` instead.
+     */
+    shadowOf?: string | null;
     /** The agent starts in shadow, as with `Shadow()` in code. */
     shadow?: boolean;
     /** The technical account in code, as with `ServiceAccount(actorId)`. */
     serviceAccount?: string;
+    /**
+     * The routes that the consultations of a code agent allow, with the subject types whose
+     * consultation allows each, as `AllowConsultation` in code, such as
+     * `{ 'asker-decides': ['project'], 'subject-asker-rights': ['project'] }`; a route without types is
+     * not allowed. Without it nobody can consult the agent and its state has no `consultationRoutes`.
+     */
+    consultations?: Partial<Record<NhAssistantConsultationRoute, string[]>>;
+    /**
+     * The descriptions of a code agent's consultations in code, by subject type, as `Description` in
+     * `AllowConsultation`. A type listed here and in no route of `consultations` is a consultation in
+     * code that only answers.
+     */
+    consultationDescriptions?: Record<string, string>;
+    /**
+     * The tool selections of a code agent's consultations in code, by subject type, as `Tools` in
+     * `AllowConsultation`; a type without one offers every tool of the agent.
+     */
+    consultationTools?: Record<string, string[]>;
+    /**
+     * The ceiling of a code agent that administrators may make consultable as data, as
+     * `ConsultableAsData` in code; it applies together with the scenario's `consultationsAsData`. `{}`
+     * allows answers only, as `ConsultableAsData()` without a configuration does. Without it a code
+     * agent gets no consultations as data.
+     */
+    consultableAsData?: NhAssistantMockConsultationCeiling;
+    /**
+     * The consultations defined as data the agent starts with, as administrators saved them. The mock
+     * saves them through its own endpoint after the agent's run configuration, so each is checked as an
+     * administrator's save is; a consultation the mock refuses fails the scenario at once.
+     */
+    dataConsultations?: NhAssistantMockDataConsultation[];
     /**
      * Whether a code agent says what it works on, as with `WorksOn`; by default it does when the
      * scenario gives `worksOnSubjectTypes`, `worksOnAllSubjects` or `worksOnApplication`.
@@ -156,6 +236,69 @@ interface NhAssistantMockAdminAgent extends AdminAgentInput {
      * the administration offers the guided setup.
      */
     runConfiguration?: NhAssistantMockRunConfigurationPreset;
+    /**
+     * The hand-offs a code agent accepts in code, as `AcceptHandOffs`; they cannot change in the
+     * administration, and a hand-off as data about the same type is refused.
+     */
+    codeHandOffs?: NhAssistantMockCodeHandOff[];
+}
+/** A hand-off a code agent of the scenario accepts in code. */
+interface NhAssistantMockCodeHandOff {
+    subjectType: string;
+    sources: string[];
+    description?: string;
+    notifySource?: boolean;
+    /** 5 by default, as in code. */
+    maxPerSubjectPerDay?: number;
+}
+/**
+ * The ceiling in code of hand-offs defined as data, as `UseHandOffsAsData`: per subject type the
+ * agents that may accept them as data and the agents that may hand off, and the highest daily limit
+ * (100 by default).
+ */
+interface NhAssistantMockHandOffCeiling {
+    rules: NhAssistantMockHandOffRule[];
+    maxPerSubjectPerDay?: number;
+}
+/** One connection of the ceiling, as `Allow(subjectType, rule => rule.To(...).From(...))`. */
+interface NhAssistantMockHandOffRule {
+    subjectType: string;
+    to?: string[];
+    toAgentsCreatedInAdministration?: boolean;
+    from?: string[];
+    fromAgentsCreatedInAdministration?: boolean;
+}
+/**
+ * The ceiling in code of shadow variants created as data, as `UseShadowVariantsAsData`: the live agents
+ * in code that may get them, whether agents created in the administration may too, and how many each
+ * (3 by default).
+ */
+interface NhAssistantMockShadowVariantCeiling {
+    of?: string[];
+    ofAgentsCreatedInAdministration?: boolean;
+    maxPerAgent?: number;
+}
+/**
+ * A ceiling in code of consultations defined as data, as `NhAssistantConsultationCeilingBuilder`
+ * configures one: the routes data may use (none by default, which allows answers only), whether data
+ * may generate request tools and offer them to MCP clients (both off by default), and the highest
+ * limits (by default the bounds of `AllowConsultation`: 32 tool calls, 600 seconds, 32,000
+ * characters and 200 messages).
+ */
+interface NhAssistantMockConsultationCeiling {
+    routes?: NhAssistantConsultationRoute[];
+    allowRequests?: boolean;
+    allowMcp?: boolean;
+    maxToolCalls?: number;
+    maxTimeoutSeconds?: number;
+    maxAnswerChars?: number;
+    maxHistoryMessages?: number;
+    /** Every new consultation defined as data starts off until an administrator switches it on (`StartOff()`). */
+    startsOff?: boolean;
+}
+/** A consultation defined as data an agent of the scenario starts with. */
+interface NhAssistantMockDataConsultation extends DataConsultationRequest {
+    subjectType: string;
 }
 /**
  * The run configuration as data an agent created in the administration starts with. The mock saves it
@@ -227,6 +370,29 @@ interface NhAssistantMockAdminScenario {
      * administration work per division, as an application that lists its divisions does.
      */
     runCatalog?: Partial<RunCatalog>;
+    /**
+     * The entries of agent metadata the application registers in code with `AddAgentMetadata`, which
+     * the run catalog lists as `agentMetadata`; the scenario's agents give their values in
+     * `metadata`, in code for an agent in code and stored for an agent created as data. Default none.
+     */
+    agentMetadata?: NhAssistantMockAgentMetadataEntry[];
+    /**
+     * Lets administrators define consultations as data within this ceiling, as `UseConsultationsAsData`
+     * in code: agents created in the administration with run settings get it, and code agents with
+     * `consultableAsData` get it together with their own. The run catalog reports it as
+     * `consultationCeiling`. Without it consultations exist in code only.
+     */
+    consultationsAsData?: NhAssistantMockConsultationCeiling;
+    /**
+     * Lets administrators define hand-offs as data within this ceiling, as `UseHandOffsAsData` in code.
+     * Without it hand-offs exist in code only.
+     */
+    handOffsAsData?: NhAssistantMockHandOffCeiling;
+    /**
+     * Lets administrators create shadow variants as data within this ceiling, as
+     * `UseShadowVariantsAsData` in code. Without it shadow variants exist in code only.
+     */
+    shadowVariantsAsData?: NhAssistantMockShadowVariantCeiling;
     /**
      * The data classifications each model profile and its fallbacks permit together, by profile name.
      * An agent or skill whose classification its profile does not permit is saved with the warning
@@ -251,6 +417,36 @@ interface NhAssistantMockAdminScenario {
      * unavailable and any id that does not start with `unknown` is accepted.
      */
     accounts?: AssistantAccount[];
+    /**
+     * The application's text assets for instructions, as its `INhAiTextAssetSource` supplies them
+     * (`UseTextAssetSource`): the run catalog reports `instructionAssets`, `GET admin/instruction-assets`
+     * lists them, and skills and agents created in the administration may name one instead of inline
+     * instructions. Without it the application offers none. Change them afterwards with
+     * `NhAssistantMockBackend.setInstructionAsset` and `removeInstructionAsset`.
+     */
+    instructionAssets?: NhAssistantMockInstructionAsset[];
+    /**
+     * Agent packages the host imported before the mock starts, in order, as `POST
+     * admin/agent-packages/import` imports them after the scenario's agents and run configurations:
+     * their parts are linked and the parts they lock show read-only. A package the import refuses fails
+     * the scenario at once.
+     */
+    agentPackages?: NhAssistantMockAgentPackage[];
+}
+/** An agent package the mock's host imported, with the options of its import. */
+interface NhAssistantMockAgentPackage {
+    package: AgentPackage;
+    /** The technical account per agent whose run settings answer to one. */
+    serviceAccounts?: Record<string, string>;
+}
+/** One version of a text asset of the mock's application. */
+interface NhAssistantMockInstructionAsset {
+    assetId: string;
+    version: number;
+    content: string;
+    /** The asset that replaces it, when the application deprecated it. */
+    replacedByAssetId?: string;
+    deprecatedAt?: string;
 }
 /** A person in the simulated organization. */
 interface NhAssistantMockPerson {
@@ -454,6 +650,12 @@ interface NhAssistantMockScenario {
      * the approval inbox, their thread and their subject's work list them, and people decide them.
      */
     proposals?: NhAssistantMockProposal[];
+    /**
+     * Consultations of agents by other assistants, as the consulted agent's thread lists them
+     * (`GET threads/{id}/consultations`), newest first. Their proposals are those of `proposals` that
+     * name them (`consultationId`), counted per route.
+     */
+    consultations?: NhAssistantMockConsultation[];
     /**
      * The application's own answer to an upload that passed the assistant's checks: `null` stores it,
      * a code refuses it as the server passes the file source's refusal on, for example
@@ -470,9 +672,27 @@ interface NhAssistantMockScenario {
      */
     scanUpload?: (upload: NhAssistantMockUpload) => 'refused' | 'failed' | null;
 }
+/** A consultation of an agent by another assistant, as the consulted agent's thread lists it. */
+interface NhAssistantMockConsultation {
+    id: string;
+    /** The consulted agent's thread. */
+    conversationId: string;
+    askerActorId: string;
+    askerDisplayName?: string | null;
+    askingAgentId?: string | null;
+    /** Default `completed`. */
+    status?: AgentConsultationStatus;
+    /** When it started, an ISO date. Default when the mock started. */
+    createdAt?: string;
+}
 /**
  * A proposal an agent left, as the mock serves it; the mock fills what it leaves out. With
  * `placedBy` a run placed it here from another subject, such as a run for the whole application.
+ * With `consultationId` another assistant consulted the agent for `initiatorActorId`, and
+ * `consultationRoute` says who decides it: an `asker-decides` proposal waits inline for the person who
+ * asked and nobody decides it here (`assistant-consult-asker-decides`); a `subject-agent-rights`
+ * proposal runs with the agent's own rights and its asker may not decide it
+ * (`assistant-four-eyes-required`).
  */
 interface NhAssistantMockProposal {
     approvalId: string;
@@ -510,6 +730,31 @@ interface NhAssistantMockProposal {
     canDecide?: boolean;
     /** Why not, when `canDecide` is `false`. Default `assistant-approval-policy-denied`. */
     reasonCode?: string | null;
+    /** The consultation that proposed it. Default none. */
+    consultationId?: string | null;
+    /** Who decides a consultation's proposal and whose rights run it. Default none. */
+    consultationRoute?: NhAssistantConsultationRoute | null;
+    /** The person who asked through the consultation, or who started the run. Default none. */
+    initiatorActorId?: string | null;
+    /**
+     * Whose rights execute it. Default `agent`, and `delegated` for a consultation's proposal that runs
+     * with the asker's rights.
+     */
+    grantSource?: AgentGrantSource;
+    /**
+     * Whether the application executes the proposal's tool (`ExecuteInApplication` on the server).
+     * Default `false`. Approved, such a proposal waits as `awaiting-application` until its report is due,
+     * four hours later; an `execution-unknown` one is handed to the application again
+     * (`POST approvals/{id}/resolve` with `hand-to-application`) instead of running again.
+     */
+    executedByApplication?: boolean;
+    /**
+     * When the application's report is due, an ISO date, for a proposal listed as `awaiting-application`
+     * or `execution-unknown` that the application executes. Default four hours after it was made.
+     */
+    executionReportDueAt?: string | null;
+    /** The execution's result code, such as `report-overdue`. Default none. */
+    executionResultCode?: string | null;
 }
 /** One request the mock API received, for assertions in tests. */
 interface NhAssistantMockRequest {
@@ -578,6 +823,9 @@ declare class NhAssistantMockBackend {
     private readonly subjects;
     private readonly agentRuns;
     private readonly boards;
+    private readonly agentMetadata;
+    /** Agent packages: their endpoints, and the locks and links of every other administration request. */
+    private readonly agentPackages;
     private readonly canAdministerState;
     private readonly members;
     private readonly readPositions;
@@ -600,6 +848,13 @@ declare class NhAssistantMockBackend {
      * answer arrive as live updates. Resolves when the turn ends.
      */
     simulateParticipantTurn(conversationId: string, person: NhAssistantMockPerson, text: string): Promise<void>;
+    /**
+     * Posts a message of the application into a conversation, as `INhAssistantConversationMessages`
+     * does on the server: it gets the next position in the conversation and reaches the people of the
+     * conversation as a live update. `trusted` marks an instruction for the assistant, as `Trusted`
+     * does on the server. Returns the stored message, or `null` for an unknown or archived conversation.
+     */
+    postApplicationMessage(conversationId: string, text: string, details?: Partial<ApplicationMessageDetails>): Message | null;
     /** Switches the simulated `NewHeap:AI:Assistant:Enabled` flag. */
     setEnabled(enabled: boolean): void;
     /** Switches whether the caller passes the admin policy (`canAdminister`, `admin/*`). */
@@ -618,6 +873,13 @@ declare class NhAssistantMockBackend {
      * (`reauthorization-required`) or another authorization server (`issuer-changed`).
      */
     setMcpConnectionStatus(serverId: string, status: 'reauthorization-required' | 'issuer-changed'): void;
+    /**
+     * Publishes or changes one version of a text asset of the application. A skill or agent that names
+     * this version with another hash then reports `asset-changed`, as after the server's next load.
+     */
+    setInstructionAsset(asset: NhAssistantMockInstructionAsset): void;
+    /** Removes one version of a text asset; what names it reports `asset-missing`. */
+    removeInstructionAsset(assetId: string, version: number): void;
     /** The files people uploaded, oldest first, as the application's file source stored them. */
     get uploads(): readonly {
         conversationId: string;
@@ -637,6 +899,12 @@ declare class NhAssistantMockBackend {
     private list;
     private create;
     private sendMessage;
+    /**
+     * `POST conversations/{id}/approvals/{approvalId}/decide`: approves or rejects the approval the
+     * turn waits for, or leaves a consulted agent's proposal with a `leaveRoute` for the subject's
+     * approvers (`leave`). Leaving closes it here, names the proposal that now waits at the subject
+     * (`consultation.movedToApprovalId`) and resumes the turn with the step's `left` steps.
+     */
     private decide;
     private cancel;
     private playSteps;
@@ -679,7 +947,19 @@ declare class NhAssistantMockBackend {
     /** Whether the caller passes the agent's view policy, by default its required policy. */
     private readsApplicationWork;
     private decidesForApplication;
+    /**
+     * The scenario's consultations of a thread's agent, newest first, each with the proposals of the
+     * scenario that name it, counted per route; `null` when the scenario lists none there.
+     */
+    private consultationsOf;
     private nextId;
+    /**
+     * The answer of an administration endpoint (`admin/...`) as its area gives it, with the groups of
+     * agents and the run catalog in the request's language, without the package locks and links.
+     */
+    private adminResult;
+    /** An administration request of the agent packages, as `adminResult` answers it, for a path with its query. */
+    private adminCall;
     /** An administration answer about agents with each agent's groups, as the server answers it. */
     private withGroups;
     private groupsOf;
@@ -737,4 +1017,4 @@ declare class NhAssistantMockLiveService implements NhAssistantLiveSurface {
 declare function provideNhAssistantMockApi(script: NhAssistantMockScenario): EnvironmentProviders;
 
 export { NH_ASSISTANT_MOCK_HUB_PATH, NH_ASSISTANT_MOCK_SCENARIO, NhAssistantMockAuthorizationWindow, NhAssistantMockBackend, NhAssistantMockLiveService, provideNhAssistantMockApi };
-export type { NhAssistantMockAdminAgent, NhAssistantMockAdminScenario, NhAssistantMockAgentGroup, NhAssistantMockApprovalStep, NhAssistantMockCollaboration, NhAssistantMockConnectionStep, NhAssistantMockDataSkill, NhAssistantMockDataTrigger, NhAssistantMockDivision, NhAssistantMockErrorStep, NhAssistantMockFailStep, NhAssistantMockLiveMessage, NhAssistantMockMcpServer, NhAssistantMockPerson, NhAssistantMockProposal, NhAssistantMockRemoteTool, NhAssistantMockRequest, NhAssistantMockRun, NhAssistantMockRunConfigurationPreset, NhAssistantMockRunNow, NhAssistantMockScenario, NhAssistantMockStep, NhAssistantMockSubject, NhAssistantMockSubjectType, NhAssistantMockTextStep, NhAssistantMockTiming, NhAssistantMockToolStep, NhAssistantMockTurn, NhAssistantMockUpload };
+export type { NhAssistantMockAdminAgent, NhAssistantMockAdminScenario, NhAssistantMockAgentGroup, NhAssistantMockAgentMetadataEntry, NhAssistantMockAgentPackage, NhAssistantMockApprovalConsultation, NhAssistantMockApprovalStep, NhAssistantMockCodeHandOff, NhAssistantMockCollaboration, NhAssistantMockConnectionStep, NhAssistantMockConsultation, NhAssistantMockConsultationCeiling, NhAssistantMockDataConsultation, NhAssistantMockDataSkill, NhAssistantMockDataTrigger, NhAssistantMockDivision, NhAssistantMockErrorStep, NhAssistantMockFailStep, NhAssistantMockHandOffCeiling, NhAssistantMockHandOffRule, NhAssistantMockInstructionAsset, NhAssistantMockLiveMessage, NhAssistantMockMcpServer, NhAssistantMockPerson, NhAssistantMockProposal, NhAssistantMockRemoteTool, NhAssistantMockRequest, NhAssistantMockRun, NhAssistantMockRunConfigurationPreset, NhAssistantMockRunNow, NhAssistantMockScenario, NhAssistantMockShadowVariantCeiling, NhAssistantMockStep, NhAssistantMockSubject, NhAssistantMockSubjectType, NhAssistantMockTextStep, NhAssistantMockTiming, NhAssistantMockToolStep, NhAssistantMockTurn, NhAssistantMockUpload };