@newheap/platform-ai-chat 0.17.0 → 0.18.0

package/fesm2022/newheap-platform-ai-chat-testing.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { InjectionToken, inject, signal, Injectable, computed, DestroyRef, makeEnvironmentProviders } from '@angular/core';
-import { NH_ASSISTANT_UPLOAD_HEADER, NH_ASSISTANT_MAX_PROPOSAL_LOOKUP, NH_ASSISTANT_CONFIG, applyNhAssistantEvent, normalizeNhAssistantClientContext, applyNhAssistantApprovalDecision, NH_ASSISTANT_FETCH, NH_ASSISTANT_UPLOAD, NhAssistantLiveService, NH_ASSISTANT_MCP_AUTHORIZATION_WINDOW } from '@newheap/platform-ai-chat';
+import { NH_ASSISTANT_UPLOAD_HEADER, ɵnhAssistantMediaTypeOf as _nhAssistantMediaTypeOf, NH_ASSISTANT_MAX_PROPOSAL_LOOKUP, NH_ASSISTANT_CONFIG, applyNhAssistantEvent, normalizeNhAssistantClientContext, applyNhAssistantApprovalDecision, NH_ASSISTANT_FETCH, NH_ASSISTANT_UPLOAD, NhAssistantLiveService, NH_ASSISTANT_MCP_AUTHORIZATION_WINDOW } from '@newheap/platform-ai-chat';
 import { Observable, Subject } from 'rxjs';
 
 /**
@@ -83,6 +83,7 @@ const statusTable = {
         'assistant-board-not-found',
         'assistant-artifact-not-found',
         'assistant-trigger-not-found',
+        'assistant-consultation-not-found',
         'assistant-not-found',
         'assistant-context-not-found',
         'assistant-mcp-server-not-found',
@@ -107,6 +108,12 @@ const statusTable = {
         'assistant-moved-to-shadow',
         'assistant-shadow-variant',
         'assistant-service-account-not-used',
+        'assistant-consult-route-not-allowed',
+        'assistant-consult-proposal-refused',
+        'assistant-consult-asker-decides',
+        'assistant-consult-proposal-moved',
+        'assistant-consultation-in-code',
+        'assistant-consultations-not-allowed',
         'assistant-skill-in-code',
         'assistant-trigger-in-code',
         'assistant-skill-in-use',
@@ -283,7 +290,7 @@ class NhAssistantMockAccounts {
 
 /** The platform's type of the whole application. */
 const mockSystemSubjectType = 'nh-system';
-const subjectTypePattern = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+const subjectTypePattern$1 = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 const maxSubjectTypes = 20;
 const worksOnFields = ['worksOnSubjectTypes', 'worksOnAllSubjects', 'worksOnApplication', 'perDivision', 'runPolicy', 'viewPolicy'];
 /** An agent that does not say what it works on: every object type, not the application, app-wide. */
@@ -336,10 +343,10 @@ function mockWorksOnErrors(worksOn, knownTypes, agentPolicies, divisions) {
     if (types.length > maxSubjectTypes) {
         add('worksOnSubjectTypes', 'too-long');
     }
-    if (types.some(type => !subjectTypePattern.test(type))) {
+    if (types.some(type => !subjectTypePattern$1.test(type))) {
         add('worksOnSubjectTypes', 'invalid');
     }
-    if (types.some(type => subjectTypePattern.test(type) && (type.startsWith('nh-') || !knownTypes.includes(type)))) {
+    if (types.some(type => subjectTypePattern$1.test(type) && (type.startsWith('nh-') || !knownTypes.includes(type)))) {
         add('worksOnSubjectTypes', 'not-found');
     }
     if (worksOn.perDivision && !divisions) {
@@ -364,6 +371,12 @@ function mockWorksOnCovers(agent, subjectType) {
     return agent.worksOnAllSubjects !== false || (agent.worksOnSubjectTypes ?? []).includes(subjectType);
 }
 
+/** The routes in the order the server lists them, with the field of the request that switches each. */
+const consultationRoutes = [
+    ['asker-decides', 'askerDecides'],
+    ['subject-agent-rights', 'subjectAgentRights'],
+    ['subject-asker-rights', 'subjectAskerRights']
+];
 /** The profile of an agent that did not choose one, as the application's chat profile. */
 const mockChatProfile = 'chat';
 const autonomyLevels = ['observe', 'explain', 'propose', 'simulate', 'execute'];
@@ -384,7 +397,7 @@ class NhAssistantMockAdminAgents {
         const agents = admin.agents
             ?? scenario.agents.map(agent => ({ ...codeAgentFromSummary(agent), source: 'code' }));
         // How an agent runs, in code or as data, belongs to its run configuration, not to the agent.
-        for (const { source, skills, shadowOf, shadow, serviceAccount, worksOnDeclared, knownSubjectTypes, codeRunSettings: _, runConfiguration: __, ...input } of agents) {
+        for (const { source, skills, shadowOf, shadow, serviceAccount, worksOnDeclared, knownSubjectTypes, consultations, consultationDescriptions, codeRunSettings: _, runConfiguration: __, consultableAsData: ___, dataConsultations: ____, ...input } of agents) {
             const agentShadow = shadowOf !== undefined || shadow === true;
             const initial = this.toAgent(input, source, 1, false);
             this.agents.set(input.id, {
@@ -415,7 +428,11 @@ class NhAssistantMockAdminAgents {
                         shadow: shadowState(agentShadow || skill.shadow === true, skill.shadow === true, null, shadowOf !== undefined)
                     }))
                 },
-                codeDefinition: source === 'code' ? structuredClone(input) : null
+                codeDefinition: source === 'code' ? structuredClone(input) : null,
+                // Consultations in code belong to agents in code; every agent may get consultations as data.
+                consultations: noSwitches(source === 'code' && (consultations !== undefined || consultationDescriptions !== undefined)
+                    ? structuredClone(consultations ?? {})
+                    : null)
             });
         }
     }
@@ -456,7 +473,10 @@ class NhAssistantMockAdminAgents {
         }
         return result;
     }
-    /** `admin/agents`, `admin/agents/{id}` and their `reset`, `state`, `shadow`, `service-account` and `kill-switch`. */
+    /**
+     * `admin/agents`, `admin/agents/{id}` and their `reset`, `state`, `shadow`, `service-account`,
+     * `consultation-routes` and `kill-switch`.
+     */
     agentsEndpoint(method, id, action, body, length) {
         if (id === undefined) {
             if (method === 'GET') {
@@ -474,7 +494,7 @@ class NhAssistantMockAdminAgents {
                 return mockFailure('assistant-agent-exists');
             }
             const agent = this.toAgent(input, 'admin', 1, false);
-            this.agents.set(agent.id, { agent, codeDefinition: null });
+            this.agents.set(agent.id, { agent, codeDefinition: null, consultations: noSwitches(null) });
             return { status: 201, body: agent };
         }
         const stored = this.agents.get(id);
@@ -497,6 +517,9 @@ class NhAssistantMockAdminAgents {
         if (length === 4 && action === 'service-account' && method === 'POST') {
             return this.serviceAccountEndpoint(stored, body);
         }
+        if (length === 4 && action === 'consultation-routes' && method === 'POST') {
+            return this.consultationRoutesEndpoint(stored, body);
+        }
         if (length === 4 && action === 'kill-switch' && method === 'POST') {
             const engaged = body?.engaged;
             if (typeof engaged !== 'boolean') {
@@ -504,7 +527,7 @@ class NhAssistantMockAdminAgents {
             }
             // Releasing never switches on an agent that was off, as on the server: one that was off when
             // it stopped goes back off, and one that is off stays off.
-            const released = stored.agent.runState === 'off' || stored.offBeforeStop === true ? 'off' : 'active';
+            const released = stored.agent.runState === 'off' || stored.agent.offBeforeStop === true ? 'off' : 'active';
             const changed = this.agentStateEndpoint(stored, 'POST', { state: engaged ? 'stopped' : released });
             return changed.status === 200
                 ? {
@@ -765,7 +788,7 @@ class NhAssistantMockAdminAgents {
                 skills: (stored.agent.skills ?? []).map(skill => ({ ...skill, shadow: withAgentShadow(skill.shadow, shadow) }))
             };
         }
-        return { status: 200, body: toAgentState(stored.agent) };
+        return { status: 200, body: this.toAgentState(stored) };
     }
     /**
      * `POST admin/agents/{id}/service-account`: the technical account of an agent that answers to
@@ -802,7 +825,96 @@ class NhAssistantMockAdminAgents {
                 }
             };
         }
-        return { status: 200, body: toAgentState(stored.agent) };
+        return { status: 200, body: this.toAgentState(stored) };
+    }
+    /**
+     * `POST admin/agents/{id}/consultation-routes`: each route on, off or back to what the consultations
+     * allow; a route left out keeps its switch. The consultations in code and as data in effect are the
+     * ceiling, as on the server: switching on a route that none of them allows, or switching an agent
+     * nobody can consult, answers `409 assistant-consult-route-not-allowed`.
+     */
+    consultationRoutesEndpoint(stored, body) {
+        const request = body;
+        if (!request || typeof request !== 'object') {
+            return mockValidationFailure();
+        }
+        for (const [, field] of consultationRoutes) {
+            const value = request[field];
+            if (value !== undefined && value !== null && value !== 'on' && value !== 'off' && value !== 'code') {
+                return mockValidationFailure(field);
+            }
+        }
+        const reason = typeof request['reason'] === 'string' && request['reason'].trim().length > 0 ? request['reason'].trim() : null;
+        if ((request['reason'] !== undefined && request['reason'] !== null && typeof request['reason'] !== 'string')
+            || (reason !== null && reason.length > mockMaxStateReason)) {
+            return mockValidationFailure('reason');
+        }
+        const current = stored.consultations;
+        const allowed = this.allowedRoutes(stored);
+        if (this.consultationRoutesState(stored) === null
+            || !consultationRoutes.some(([route]) => (allowed[route]?.length ?? 0) > 0)
+            || consultationRoutes.some(([route, field]) => request[field] === 'on' && (allowed[route]?.length ?? 0) === 0)) {
+            return mockFailure('assistant-consult-route-not-allowed');
+        }
+        const overrides = { ...current.overrides };
+        for (const [route, field] of consultationRoutes) {
+            const value = request[field];
+            if (value === 'on' || value === 'off') {
+                overrides[route] = value === 'on';
+            }
+            else if (value === 'code') {
+                delete overrides[route];
+            }
+        }
+        const changed = consultationRoutes.some(([route]) => overrides[route] !== current.overrides[route]);
+        if (changed) {
+            stored.consultations = { ...current, overrides, changedAt: this.now(), changedBy: 'current-user', reason };
+        }
+        return { status: 200, body: this.toAgentState(stored) };
+    }
+    /**
+     * The subject types whose consultation allows each route: in code, and as data with the routes in
+     * effect, as the server reads both from the agent's options in effect.
+     */
+    allowedRoutes(stored) {
+        const allowed = structuredClone(stored.consultations.allowed ?? {});
+        for (const consultation of this.rules.dataConsultations(stored.agent.id)) {
+            for (const route of consultation.routes) {
+                allowed[route] = [...(allowed[route] ?? []), consultation.subjectType];
+            }
+        }
+        return allowed;
+    }
+    /**
+     * The routes of an agent's consultations as the server reports them; `null` for an agent nobody can
+     * consult: it has no consultation in code and none as data in effect.
+     */
+    consultationRoutesState(stored) {
+        const switches = stored.consultations;
+        if (switches.allowed === null && this.rules.dataConsultations(stored.agent.id).length === 0) {
+            return null;
+        }
+        const allowed = this.allowedRoutes(stored);
+        return {
+            routes: consultationRoutes.map(([route]) => {
+                const types = allowed[route] ?? [];
+                const override = switches.overrides[route] ?? null;
+                return {
+                    route,
+                    allowed: types.length > 0,
+                    override,
+                    on: types.length > 0 && override !== false,
+                    subjectTypes: [...types]
+                };
+            }),
+            changedAt: switches.changedAt,
+            changedBy: switches.changedBy,
+            reason: switches.reason
+        };
+    }
+    /** The agent's state with the routes of its consultations. */
+    toAgentState(stored) {
+        return { ...toAgentState(stored), consultationRoutes: this.consultationRoutesState(stored) };
     }
     /**
      * `GET` and `POST admin/agents/{id}/state`. The mock runs no agents on their own, so a pause
@@ -811,7 +923,7 @@ class NhAssistantMockAdminAgents {
      */
     agentStateEndpoint(stored, method, body) {
         if (method === 'GET') {
-            return { status: 200, body: toAgentState(stored.agent) };
+            return { status: 200, body: this.toAgentState(stored) };
         }
         if (method !== 'POST') {
             return { status: 405 };
@@ -830,21 +942,21 @@ class NhAssistantMockAdminAgents {
         if (stored.agent.runState === 'configured-off') {
             return request.state === 'active'
                 ? mockFailure('assistant-agent-configured-off')
-                : { status: 200, body: toAgentState(stored.agent) };
+                : { status: 200, body: this.toAgentState(stored) };
         }
         if (stored.agent.runState !== request.state) {
-            // A stop remembers whether the agent was off, for the kill switch; every other change forgets it.
-            stored.offBeforeStop = request.state === 'stopped' && stored.agent.runState === 'off';
             stored.agent = {
                 ...stored.agent,
                 isEnabled: request.state !== 'stopped',
                 runState: request.state,
+                // A stop remembers whether the agent was off, for the kill switch; every other change forgets it.
+                offBeforeStop: request.state === 'stopped' && stored.agent.runState === 'off',
                 stateChangedAt: this.now(),
                 stateChangedBy: 'current-user',
                 stateReason: reason
             };
         }
-        return { status: 200, body: toAgentState(stored.agent) };
+        return { status: 200, body: this.toAgentState(stored) };
     }
     /**
      * The contract failure for an invalid agent, or null when the agent is valid. What an agent created
@@ -925,6 +1037,7 @@ class NhAssistantMockAdminAgents {
             shadowOf: previous?.shadowOf ?? null,
             shadow: previous?.shadow ?? shadowState(false, false, null, false),
             serviceAccount: previous?.serviceAccount ?? null,
+            offBeforeStop: previous?.offBeforeStop ?? false,
             // Code decides for its agents; an agent created here keeps its choice when it is omitted.
             offeredInChat: source === 'code' && previous
                 ? previous.offeredInChat ?? true
@@ -960,7 +1073,8 @@ function codeAgentFromSummary(agent) {
         autonomy: agent.canMutate ? 'execute' : 'explain'
     };
 }
-function toAgentState(agent) {
+function toAgentState(stored) {
+    const agent = stored.agent;
     return {
         agentId: agent.id,
         runState: agent.runState,
@@ -974,9 +1088,15 @@ function toAgentState(agent) {
         skills: agent.skills ?? [],
         shadowOf: agent.shadowOf ?? null,
         shadow: agent.shadow ?? shadowState(false, false, null, false),
-        serviceAccount: agent.serviceAccount ?? null
+        serviceAccount: agent.serviceAccount ?? null,
+        offBeforeStop: agent.runState === 'stopped' && agent.offBeforeStop === true,
+        consultationRoutes: null
     };
 }
+/** The route switches of an agent nobody switched yet, with the routes its consultations in code allow. */
+function noSwitches(allowed) {
+    return { allowed, overrides: {}, changedAt: null, changedBy: null, reason: null };
+}
 function shadowState(shadow, configured, override, locked) {
     return { shadow, configured, override, locked, changedAt: null, changedBy: null, reason: null };
 }
@@ -1034,7 +1154,7 @@ const maxReaders = 16;
 const maxReaderMediaTypes = 16;
 const maxReaderToolName = 128;
 const readerPriority = { min: -1000, max: 1000 };
-const classifications = ['public', 'internal', 'confidential', 'restricted'];
+const classifications$1 = ['public', 'internal', 'confidential', 'restricted'];
 const mediaTypePattern$1 = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/;
 const controlCharacters = /[\u0000-\u001f\u007f]/;
 /**
@@ -2107,7 +2227,7 @@ function checkReaders(input, stored, add) {
         if (classification === null || classification === undefined) {
             add(field('maxClassification'), 'required');
         }
-        else if (!classifications.includes(classification)) {
+        else if (!classifications$1.includes(classification)) {
             add(field('maxClassification'), 'invalid');
         }
         const priority = reader?.priority ?? 0;
@@ -2215,6 +2335,457 @@ function kebab(value) {
         .toLowerCase();
 }
 
+/** The bounds of `AllowConsultation`, within which a ceiling may only lower the maxima. */
+const bounds = {
+    toolCalls: { min: 0, max: 32, initial: 4 },
+    timeoutSeconds: { min: 1, max: 600, initial: 60 },
+    answerChars: { min: 200, max: 32_000, initial: 4_000 },
+    history: { min: 0, max: 200, initial: 20 }
+};
+const maxDescription$2 = 1_000;
+const maxInstructions$1 = 4_000;
+const maxConsultations = 20;
+const roles = ['reader', 'participant', 'approver'];
+const allRoutes = ['asker-decides', 'subject-agent-rights', 'subject-asker-rights'];
+const classifications = ['public', 'internal', 'confidential', 'restricted'];
+const subjectTypePattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+/**
+ * Consultations of the mock API's agents: those in code from the scenario, read-only, and those
+ * defined as data, saved and removed as on the server within the ceilings in code
+ * (`consultationsAsData` for the application, `consultableAsData` for an agent in code). A save
+ * checks a consultation as the server does and refuses with the same codes and field errors; every
+ * read checks it again, so a consultation that no longer fits, for example after the run settings
+ * changed whom the agent answers to, stays with its problems. Data consultations in effect generate
+ * their consult and request tools in the tool list and count for the agent's route switches.
+ */
+class NhAssistantMockConsultations {
+    constructor(application, agents, rules, now) {
+        this.rules = rules;
+        this.now = now;
+        this.stored = new Map();
+        this.codeAllowed = new Map();
+        this.codeDescriptions = new Map();
+        this.agentCeilings = new Map();
+        this.applicationCeiling = application ? ceilingOf(application) : null;
+        for (const agent of agents) {
+            if (agent.source !== 'code') {
+                continue;
+            }
+            if (agent.consultations !== undefined || agent.consultationDescriptions !== undefined) {
+                this.codeAllowed.set(agent.id, agent.consultations ?? {});
+                this.codeDescriptions.set(agent.id, agent.consultationDescriptions ?? {});
+            }
+            if (agent.consultableAsData !== undefined) {
+                this.agentCeilings.set(agent.id, agent.consultableAsData);
+            }
+        }
+    }
+    /**
+     * The ceiling of the agent: the application's for an agent created in the administration, the
+     * application's and its own together for a consultable agent in code, none otherwise.
+     */
+    ceilingOf(agent) {
+        const application = this.applicationCeiling;
+        if (!application) {
+            return null;
+        }
+        if (agent.source === 'admin') {
+            return application;
+        }
+        const own = this.agentCeilings.get(agent.id);
+        if (!own) {
+            return null;
+        }
+        const narrowed = ceilingOf(own);
+        return {
+            ...application,
+            routes: application.routes.filter(route => narrowed.routes.includes(route)),
+            allowRequests: application.allowRequests && narrowed.allowRequests,
+            allowMcp: application.allowMcp && narrowed.allowMcp,
+            maxToolCalls: Math.min(application.maxToolCalls, narrowed.maxToolCalls),
+            maxTimeoutSeconds: Math.min(application.maxTimeoutSeconds, narrowed.maxTimeoutSeconds),
+            maxAnswerChars: Math.min(application.maxAnswerChars, narrowed.maxAnswerChars),
+            maxHistoryMessages: Math.min(application.maxHistoryMessages, narrowed.maxHistoryMessages)
+        };
+    }
+    /** The agent's consultations in code, by subject type. */
+    codeConsultations(agent) {
+        const allowed = this.codeAllowed.get(agent.id);
+        if (!allowed) {
+            return [];
+        }
+        const descriptions = this.codeDescriptions.get(agent.id) ?? {};
+        const types = new Set([...Object.values(allowed).flat(), ...Object.keys(descriptions)]);
+        return [...types].sort().map(subjectType => {
+            const consultToolId = consultToolOf(agent.id, subjectType);
+            return {
+                subjectType,
+                description: descriptions[subjectType] ?? null,
+                allowedRoutes: allRoutes.filter(route => (allowed[route] ?? []).includes(subjectType)),
+                allowRequests: false,
+                exposure: ['local', 'agent'],
+                consultToolId,
+                requestToolId: null,
+                askingAgents: this.askersOf(agent.id, consultToolId)
+            };
+        });
+    }
+    /** The agent's consultations defined as data, by subject type, each with what is in effect of it. */
+    dataConsultations(agent) {
+        return this.storedOf(agent.id).map(stored => this.toConsultation(agent, stored));
+    }
+    /** The problems of kind `consultation` of the agent's data consultations. */
+    problems(agent) {
+        return this.storedOf(agent.id).flatMap(stored => this.check(agent, stored).problems.map(code => ({
+            agentId: agent.id,
+            kind: 'consultation',
+            id: stored.subjectType,
+            code
+        })));
+    }
+    /** The agent's data consultations in effect with their routes in effect, for its route switches. */
+    inEffect(agentId) {
+        const agent = this.rules.find(agentId);
+        if (!agent) {
+            return [];
+        }
+        return this.storedOf(agentId)
+            .map(stored => ({ subjectType: stored.subjectType, check: this.check(agent, stored) }))
+            .filter(item => item.check.inEffect)
+            .map(item => ({ subjectType: item.subjectType, routes: item.check.routes }));
+    }
+    /** Whether data consultations belong to the agent, which keeps its run settings. */
+    has(agentId) {
+        return this.storedOf(agentId).length > 0;
+    }
+    /** The generated tools of the data consultations in effect, as `GET admin/tools` lists them. */
+    tools() {
+        const tools = [];
+        for (const stored of [...this.stored.values()].sort((left, right) => key$2(left.agentId, left.subjectType).localeCompare(key$2(right.agentId, right.subjectType)))) {
+            const agent = this.rules.find(stored.agentId);
+            const check = agent ? this.check(agent, stored) : null;
+            if (!check?.inEffect) {
+                continue;
+            }
+            tools.push({ id: consultToolOf(stored.agentId, stored.subjectType), source: 'local', effect: 'read-only', description: stored.description, subjectType: null });
+            if (check.allowRequests) {
+                tools.push({ id: requestToolOf(stored.agentId, stored.subjectType), source: 'local', effect: 'idempotent-mutation', description: stored.description, subjectType: null });
+            }
+        }
+        return tools;
+    }
+    /** `PUT` and `DELETE admin/agents/{id}/consultations/{subjectType}`. */
+    handle(method, agent, subjectType, body, query) {
+        if (method === 'DELETE') {
+            return this.remove(agent, subjectType, query);
+        }
+        return method === 'PUT' ? this.save(agent, subjectType, body) : { status: 405 };
+    }
+    save(agent, subjectType, body) {
+        const request = (body ?? {});
+        const reason = text$1(request.reason);
+        if (reason !== null && reason.length > mockMaxStateReason) {
+            return mockFailure('assistant-validation', { reason: ['too-long'] });
+        }
+        const ceiling = this.ceilingOf(agent);
+        if (!ceiling) {
+            return mockFailure('assistant-consultations-not-allowed');
+        }
+        if (!this.rules.isConfigured(agent)) {
+            return mockFailure('assistant-agent-not-configured');
+        }
+        if (this.inCode(agent.id, subjectType)) {
+            return mockFailure('assistant-consultation-in-code');
+        }
+        // A new consultation starts with the defaults of code, capped by the ceiling.
+        const description = text$1(request.description);
+        const instructions = text$1(request.instructions);
+        const minimumRole = (text$1(request.minimumRole) ?? 'reader');
+        const proposalRole = (text$1(request.proposalRole) ?? 'participant');
+        const routes = (request.routes ?? []).map(route => (typeof route === 'string' ? route.trim() : ''));
+        const classification = text$1(request.dataClassification);
+        const limits = {
+            maxToolCalls: request.maxToolCalls ?? Math.min(bounds.toolCalls.initial, ceiling.maxToolCalls),
+            timeoutSeconds: request.timeoutSeconds ?? Math.min(bounds.timeoutSeconds.initial, ceiling.maxTimeoutSeconds),
+            maxAnswerChars: request.maxAnswerChars ?? Math.min(bounds.answerChars.initial, ceiling.maxAnswerChars),
+            maxHistoryMessages: request.maxHistoryMessages ?? Math.min(bounds.history.initial, ceiling.maxHistoryMessages)
+        };
+        const errors = {};
+        const add = (field, code) => {
+            errors[field] = [...(errors[field] ?? []), code];
+        };
+        if (!subjectTypePattern.test(subjectType)) {
+            add('subjectType', 'invalid');
+        }
+        if (description === null) {
+            add('description', 'required');
+        }
+        else if (description.length > maxDescription$2) {
+            add('description', 'too-long');
+        }
+        if ((instructions ?? '').length > maxInstructions$1) {
+            add('instructions', 'too-long');
+        }
+        if (!roles.includes(minimumRole)) {
+            add('minimumRole', 'invalid');
+        }
+        if (!roles.includes(proposalRole)) {
+            add('proposalRole', 'invalid');
+        }
+        if (!validRoutes(routes)) {
+            add('routes', 'invalid');
+        }
+        if (!within(limits.maxToolCalls, bounds.toolCalls)
+            || !within(limits.timeoutSeconds, bounds.timeoutSeconds)
+            || !within(limits.maxAnswerChars, bounds.answerChars)
+            || !within(limits.maxHistoryMessages, bounds.history)) {
+            add('limits', 'invalid');
+        }
+        if (classification !== null && !classifications.includes(classification)) {
+            add('dataClassification', 'invalid');
+        }
+        if (Object.keys(errors).length > 0) {
+            return mockFailure('assistant-validation', errors);
+        }
+        const existing = this.stored.get(key$2(agent.id, subjectType));
+        const now = this.now();
+        const row = {
+            agentId: agent.id,
+            subjectType,
+            version: (existing?.version ?? 0) + 1,
+            description: description,
+            instructions,
+            minimumRole,
+            askerPolicy: text$1(request.askerPolicy),
+            routes,
+            proposalRole,
+            proposalPolicy: text$1(request.proposalPolicy),
+            ...limits,
+            allowRequests: request.allowRequests === true,
+            exposeToMcp: request.exposeToMcp === true,
+            dataClassification: classification,
+            createdAt: existing?.createdAt ?? now,
+            createdBy: existing?.createdBy ?? 'current-user',
+            changedAt: now,
+            changedBy: 'current-user',
+            reason
+        };
+        // The same check as every read, refused here instead of degraded.
+        const check = this.check(agent, row);
+        if (check.problems.length > 0) {
+            return fieldFailure(check.problems);
+        }
+        if (request.expectedVersion == null && !existing && this.storedOf(agent.id).length >= maxConsultations) {
+            return mockFailure('assistant-configuration-limit');
+        }
+        if ((request.expectedVersion ?? null) !== (existing?.version ?? null)) {
+            return mockFailure('assistant-version-conflict');
+        }
+        this.stored.set(key$2(agent.id, subjectType), row);
+        return { status: 200, body: this.toConsultation(agent, row) };
+    }
+    remove(agent, subjectType, query) {
+        const reason = query.get('reason');
+        if (reason !== null && reason.trim().length > mockMaxStateReason) {
+            return mockFailure('assistant-validation', { reason: ['too-long'] });
+        }
+        if (this.inCode(agent.id, subjectType)) {
+            return mockFailure('assistant-consultation-in-code');
+        }
+        const existing = this.stored.get(key$2(agent.id, subjectType));
+        if (!existing) {
+            return mockFailure('assistant-consultation-not-found');
+        }
+        const expected = query.get('expectedVersion');
+        if (expected !== null && Number(expected) !== existing.version) {
+            return mockFailure('assistant-version-conflict');
+        }
+        this.stored.delete(key$2(agent.id, subjectType));
+        return { status: 204 };
+    }
+    /**
+     * Checks a consultation against the ceilings and the agent as the server does on save and on every
+     * load: out of effect when the agent may get none, the type is unknown or not worked on or the
+     * asker policy is no longer listed; otherwise without the routes, requests and MCP exposure that
+     * no longer fit and with limits capped at the ceiling, each with a problem.
+     */
+    check(agent, row) {
+        const out = (problem) => ({ inEffect: false, problems: [problem], routes: [], allowRequests: false });
+        const ceiling = this.ceilingOf(agent);
+        if (!ceiling) {
+            return out('not-consultable');
+        }
+        if (!this.rules.knownSubjectTypes().includes(row.subjectType)) {
+            return out('unknown-subject-type');
+        }
+        if (!mockWorksOnCovers(agent, row.subjectType)) {
+            return out('not-worked-on');
+        }
+        if (this.inCode(agent.id, row.subjectType)) {
+            return out('conflicts-with-code');
+        }
+        if (row.askerPolicy !== null && !this.rules.agentPolicyNames().includes(row.askerPolicy)) {
+            return out('unknown-agent-policy');
+        }
+        const problems = [];
+        const addOnce = (problem) => {
+            if (!problems.includes(problem)) {
+                problems.push(problem);
+            }
+        };
+        const accountability = this.rules.accountabilityOf(agent);
+        let kept = [];
+        for (const route of row.routes) {
+            const agentRights = route === 'subject-agent-rights';
+            if (!ceiling.routes.includes(route) || (agentRights && row.subjectType === mockSystemSubjectType)) {
+                addOnce('route-not-allowed');
+                continue;
+            }
+            if (agentRights && accountability === 'subject-responsible') {
+                addOnce('agent-answers-to-person');
+                continue;
+            }
+            // An agent created here that answers for itself has no grants; one in code is assumed to have them.
+            if (agentRights && agent.source === 'admin' && accountability === 'agent') {
+                addOnce('agent-has-no-rights');
+                continue;
+            }
+            kept.push(route);
+        }
+        if (row.proposalPolicy !== null && !this.rules.approvalPolicies().includes(row.proposalPolicy)) {
+            // Without its policy nobody knows who decides a proposal: the consultation only answers.
+            addOnce('unknown-policy');
+            kept = [];
+        }
+        const policies = [row.proposalPolicy, this.rules.approvalPolicyOf(agent)].filter((policy) => policy !== null);
+        if (kept.includes('subject-agent-rights') && policies.some(policy => this.namesOnlyTheInitiator(policy))) {
+            addOnce('no-approver');
+            kept = kept.filter(route => route !== 'subject-agent-rights');
+        }
+        let allowRequests = row.allowRequests;
+        if (allowRequests && !ceiling.allowRequests) {
+            problems.push('requests-not-allowed');
+            allowRequests = false;
+        }
+        if (row.exposeToMcp && !ceiling.allowMcp) {
+            problems.push('mcp-not-allowed');
+        }
+        if (row.maxToolCalls > ceiling.maxToolCalls
+            || row.timeoutSeconds > ceiling.maxTimeoutSeconds
+            || row.maxAnswerChars > ceiling.maxAnswerChars
+            || row.maxHistoryMessages > ceiling.maxHistoryMessages) {
+            problems.push('limit-above-ceiling');
+        }
+        return { inEffect: true, problems, routes: kept, allowRequests };
+    }
+    namesOnlyTheInitiator(policy) {
+        const summary = this.rules.approvalPolicySummaries().find(item => item.name === policy);
+        return summary !== undefined && summary.approvers.length > 0 && summary.approvers.every(approver => approver.kind === 'initiator');
+    }
+    toConsultation(agent, row) {
+        const check = this.check(agent, row);
+        const consultToolId = consultToolOf(agent.id, row.subjectType);
+        const { agentId, ...stored } = row;
+        return {
+            ...stored,
+            routes: [...row.routes],
+            instructionsHash: row.instructions === null ? null : mockHashText(row.instructions),
+            inEffect: check.inEffect,
+            problem: check.problems[0] ?? null,
+            problems: check.problems,
+            routesInEffect: check.routes,
+            consultToolId,
+            requestToolId: check.allowRequests ? requestToolOf(agent.id, row.subjectType) : null,
+            askingAgents: this.askersOf(agent.id, consultToolId)
+        };
+    }
+    /** The other agents whose tool selectors select the tool now, by id: the consultation's second key. */
+    askersOf(agentId, toolId) {
+        return this.rules.all()
+            .filter(agent => agent.id !== agentId && agent.toolSelectors.some(selector => covers$1(selector, toolId)))
+            .map(agent => agent.id)
+            .sort();
+    }
+    inCode(agentId, subjectType) {
+        const allowed = this.codeAllowed.get(agentId);
+        return allowed !== undefined
+            && (Object.values(allowed).some(types => types?.includes(subjectType)) || subjectType in (this.codeDescriptions.get(agentId) ?? {}));
+    }
+    storedOf(agentId) {
+        return [...this.stored.values()]
+            .filter(stored => stored.agentId === agentId)
+            .sort((left, right) => left.subjectType.localeCompare(right.subjectType));
+    }
+}
+/** A ceiling of the scenario with the defaults of the ceiling builder. */
+function ceilingOf(ceiling) {
+    return {
+        routes: [...(ceiling.routes ?? [])],
+        allowRequests: ceiling.allowRequests ?? false,
+        allowMcp: ceiling.allowMcp ?? false,
+        maxToolCalls: ceiling.maxToolCalls ?? bounds.toolCalls.max,
+        maxTimeoutSeconds: ceiling.maxTimeoutSeconds ?? bounds.timeoutSeconds.max,
+        maxAnswerChars: ceiling.maxAnswerChars ?? bounds.answerChars.max,
+        maxHistoryMessages: ceiling.maxHistoryMessages ?? bounds.history.max,
+        maxConsultations,
+        maxInstructionsLength: maxInstructions$1
+    };
+}
+/** The field error of each problem a consultation would have, as the server maps them on save. */
+function fieldFailure(problems) {
+    if (problems.includes('not-consultable')) {
+        return mockFailure('assistant-consultations-not-allowed');
+    }
+    if (problems.includes('conflicts-with-code')) {
+        return mockFailure('assistant-consultation-in-code');
+    }
+    const fields = {
+        'unknown-subject-type': ['subjectType', 'not-found'],
+        'not-worked-on': ['subjectType', 'invalid'],
+        'unknown-agent-policy': ['askerPolicy', 'not-found'],
+        'route-not-allowed': ['routes', 'not-allowed'],
+        'agent-answers-to-person': ['routes', 'invalid'],
+        'agent-has-no-rights': ['routes', 'invalid'],
+        'unknown-policy': ['proposalPolicy', 'not-found'],
+        'no-approver': ['proposalPolicy', 'invalid'],
+        'limit-above-ceiling': ['limits', 'not-allowed'],
+        'requests-not-allowed': ['allowRequests', 'not-allowed'],
+        'mcp-not-allowed': ['exposeToMcp', 'not-allowed']
+    };
+    const errors = {};
+    for (const problem of problems) {
+        const [field, code] = fields[problem] ?? ['subjectType', 'invalid'];
+        errors[field] = [...(errors[field] ?? []), code];
+    }
+    return mockFailure('assistant-validation', errors);
+}
+/** Known routes, each once, and at most one of the two routes at the subject. */
+function validRoutes(routes) {
+    return routes.every(route => allRoutes.includes(route))
+        && new Set(routes).size === routes.length
+        && !(routes.includes('subject-agent-rights') && routes.includes('subject-asker-rights'));
+}
+function within(value, range) {
+    return Number.isInteger(value) && value >= range.min && value <= range.max;
+}
+function consultToolOf(agentId, subjectType) {
+    return `assistant.consult.${agentId}.${subjectType}`;
+}
+function requestToolOf(agentId, subjectType) {
+    return `assistant.request.${agentId}.${subjectType}`;
+}
+/** The agent's selector covers the tool: the same tool, or a pattern with `*` that matches it. */
+function covers$1(selector, toolId) {
+    const pattern = selector.split('*').map(part => part.replace(/[.+?^${}()|[\]\\]/g, '\\$&')).join('.*');
+    return new RegExp(`^${pattern}$`).test(toolId);
+}
+function key$2(agentId, subjectType) {
+    return `${agentId}/${subjectType}`;
+}
+function text$1(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+
 const dashCase$4 = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 const dataClassifications = ['public', 'internal', 'confidential', 'restricted'];
 const accountabilities = ['agent', 'subject-responsible', 'service-account'];
@@ -2252,6 +2823,17 @@ class NhAssistantMockRunConfiguration {
         this.skills = new Map();
         this.triggers = new Map();
         const approvalPolicies = scenario.runCatalog?.approvalPolicies ?? scenario.policies ?? [];
+        this.consultations = new NhAssistantMockConsultations(scenario.consultationsAsData, scenario.agents ?? [], {
+            find: agentId => this.agents.find(agentId),
+            all: () => this.agents.all(),
+            knownSubjectTypes: () => this.agents.knownSubjectTypes(),
+            isConfigured: agent => this.isConfigured(agent),
+            accountabilityOf: agent => agent.source === 'admin' ? this.settings.get(agent.id)?.accountability ?? null : this.codeSettingsOf(agent).accountability,
+            approvalPolicyOf: agent => agent.source === 'admin' ? this.settings.get(agent.id)?.approvalPolicy ?? null : this.codeSettingsOf(agent).approvalPolicy,
+            approvalPolicies: () => this.catalog.approvalPolicies,
+            approvalPolicySummaries: () => this.catalog.approvalPolicySummaries ?? [],
+            agentPolicyNames: () => this.agentPolicyNames
+        }, now);
         this.catalog = {
             // A trigger event lists its named filters, none unless the scenario's application registers some.
             triggerEvents: (scenario.runCatalog?.triggerEvents ?? []).map(event => ({ ...event, filters: event.filters ?? [] })),
@@ -2271,7 +2853,8 @@ class NhAssistantMockRunConfiguration {
             agentPolicies: scenario.runCatalog?.agentPolicies ?? [],
             divisions: scenario.runCatalog?.divisions ?? false,
             // The platform's default file limits, unless the scenario's application chose its own.
-            fileLimits: scenario.runCatalog?.fileLimits ?? defaultFileLimits
+            fileLimits: scenario.runCatalog?.fileLimits ?? defaultFileLimits,
+            consultationCeiling: this.consultations.applicationCeiling
         };
         this.codeTriggers = (scenario.codeTriggers ?? []).map(trigger => ({
             ...trigger,
@@ -2295,13 +2878,25 @@ class NhAssistantMockRunConfiguration {
     get profileNames() {
         return [...this.catalog.profiles];
     }
+    /**
+     * The agent's consultations defined as data in effect with their routes in effect, which count for
+     * its route switches.
+     */
+    consultationsInEffect(agentId) {
+        return this.consultations.inEffect(agentId);
+    }
+    /** The generated consult and request tools of the data consultations in effect. */
+    consultationTools() {
+        return this.consultations.tools();
+    }
     /** `GET admin/run-catalog`. */
     runCatalog(method) {
         return method === 'GET' ? { status: 200, body: this.catalog } : { status: 405 };
     }
     /**
-     * `admin/agents/{id}/configuration`, `run-settings`, `skills/{skillId}[/...]` and
-     * `triggers/{triggerId}[/shadow]`; `segments` start after the agent id.
+     * `admin/agents/{id}/configuration`, `run-settings`, `skills/{skillId}[/...]`,
+     * `triggers/{triggerId}[/shadow]` and `consultations/{subjectType}`; `segments` start after the
+     * agent id.
      */
     handle(method, agentId, segments, body, query) {
         const agent = this.agents.find(agentId);
@@ -2330,6 +2925,9 @@ class NhAssistantMockRunConfiguration {
             }
             return action === 'shadow' ? this.triggerShadow(method, agent, id, body) : this.trigger(method, agent, id, body, query);
         }
+        if (area === 'consultations' && id !== undefined && segments.length === 2) {
+            return agent ? this.consultations.handle(method, agent, id, body, query) : mockFailure('assistant-agent-not-found');
+        }
         return null;
     }
     configuration(agent) {
@@ -2350,12 +2948,18 @@ class NhAssistantMockRunConfiguration {
             dataSkills,
             codeTriggers: this.codeTriggers.filter(trigger => trigger.agentId === agent.id).map(({ agentId, ...trigger }) => trigger),
             dataTriggers,
-            problems: dataTriggers
-                .filter(trigger => trigger.problem !== null)
-                .map(trigger => ({ agentId: agent.id, kind: 'trigger', id: trigger.triggerId, code: trigger.problem })),
+            problems: [
+                ...dataTriggers
+                    .filter(trigger => trigger.problem !== null)
+                    .map(trigger => ({ agentId: agent.id, kind: 'trigger', id: trigger.triggerId, code: trigger.problem })),
+                ...this.consultations.problems(agent)
+            ],
             source: agent.source,
             runSettings: agent.source === 'admin' ? this.settings.get(agent.id) ?? null : null,
-            codeRunSettings: agent.source === 'code' ? this.codeSettingsOf(agent) : null
+            codeRunSettings: agent.source === 'code' ? this.codeSettingsOf(agent) : null,
+            codeConsultations: this.consultations.codeConsultations(agent),
+            dataConsultations: this.consultations.dataConsultations(agent),
+            consultationCeiling: this.consultations.ceilingOf(agent)
         };
     }
     /**
@@ -2402,7 +3006,9 @@ class NhAssistantMockRunConfiguration {
             if (!versionMatches(query, current.version)) {
                 return mockFailure('assistant-version-conflict');
             }
-            if (this.liveSkills(agent.id).length > 0 || [...this.triggers.values()].some(trigger => this.ownerOf(trigger) === agent.id)) {
+            if (this.liveSkills(agent.id).length > 0
+                || [...this.triggers.values()].some(trigger => this.ownerOf(trigger) === agent.id)
+                || this.consultations.has(agent.id)) {
                 return mockFailure('assistant-run-settings-in-use');
             }
             this.settings.delete(agent.id);
@@ -2925,11 +3531,14 @@ class NhAssistantMockAdmin {
             hasServer: serverId => this.mcp.hasServer(serverId),
             agentPolicyNames: () => this.runConfiguration.agentPolicyNames,
             divisionsListed: () => this.runConfiguration.divisionsListed,
-            profileNames: () => this.runConfiguration.profileNames
+            profileNames: () => this.runConfiguration.profileNames,
+            dataConsultations: agentId => this.runConfiguration.consultationsInEffect(agentId)
         });
         this.accounts = new NhAssistantMockAccounts(admin);
         this.runConfiguration = new NhAssistantMockRunConfiguration(admin, {
             find: agentId => this.agents.find(agentId),
+            all: () => this.agents.all(),
+            knownSubjectTypes: () => [...(scenario.subjectTypes ?? []).map(type => type.id), mockSystemSubjectType],
             setDataSkill: (agentId, skillId, description, startsOff) => this.agents.setDataSkill(agentId, skillId, description, startsOff)
         }, now, this.accounts);
         this.mcp = new NhAssistantMockAdminMcp(scenario, now, {
@@ -3090,7 +3699,8 @@ class NhAssistantMockAdmin {
     /**
      * Saves the run configuration the scenario gives agents created in the administration through the
      * mock's own endpoints, as an administrator would: the run settings, then each skill and trigger,
-     * put live when the scenario says so. A part the mock refuses fails the scenario at once.
+     * put live when the scenario says so, and then the consultations defined as data of every agent. A
+     * part the mock refuses fails the scenario at once.
      */
     presetRunConfigurations(agents) {
         const query = new URLSearchParams();
@@ -3116,11 +3726,21 @@ class NhAssistantMockAdmin {
                 }
             }
         }
+        for (const agent of agents) {
+            for (const { subjectType, ...consultation } of agent.dataConsultations ?? []) {
+                presetStep(agent.id, `consultation about '${subjectType}'`, this.runConfiguration.handle('PUT', agent.id, ['consultations', subjectType], consultation, query));
+            }
+        }
     }
-    /** The scenario's tools, with the object type they name as the server reports it, and the enabled MCP tools. */
+    /**
+     * The scenario's tools, with the object type they name as the server reports it, the generated tools
+     * of the consultations defined as data in effect, read live as the server reads its catalogs, and
+     * the enabled MCP tools.
+     */
     toolCatalog() {
         return [
             ...(this.scenario.admin?.tools ?? []).map(tool => ({ ...tool, subjectType: tool.subjectType ?? null })),
+            ...this.runConfiguration.consultationTools(),
             ...this.mcp.catalogEntries()
         ];
     }
@@ -3138,14 +3758,50 @@ function toContext(version) {
 /** The longest file name a reference takes, as on the server. */
 const maxNameLength = 256;
 const mediaTypePattern = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/;
+const zipSignature = [0x50, 0x4b, 0x03, 0x04];
+const pngSignature = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+const jpegSignature = [0xff, 0xd8, 0xff];
+/**
+ * The binary formats a text upload may be in disguise, as on the server: an OLE2 compound file (Word,
+ * Excel and PowerPoint 97 to 2003), a ZIP package (also an empty one), a PDF, PNG, JPEG or GIF.
+ */
+const binarySignatures = [
+    [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1],
+    zipSignature,
+    [0x50, 0x4b, 0x05, 0x06],
+    [0x25, 0x50, 0x44, 0x46, 0x2d],
+    pngSignature,
+    jpegSignature,
+    [0x47, 0x49, 0x46, 0x38, 0x37, 0x61],
+    [0x47, 0x49, 0x46, 0x38, 0x39, 0x61]
+];
 /** How files of the platform's types start; other accepted types are the application's to check. */
 const signatures = {
     'application/pdf': head => indexOf(head, [0x25, 0x50, 0x44, 0x46, 0x2d]) >= 0,
-    'image/png': head => startsWith(head, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
-    'image/jpeg': head => startsWith(head, [0xff, 0xd8, 0xff]),
-    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': head => startsWith(head, [0x50, 0x4b, 0x03, 0x04]),
-    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': head => startsWith(head, [0x50, 0x4b, 0x03, 0x04])
+    'image/png': head => startsWith(head, pngSignature),
+    'image/jpeg': head => startsWith(head, jpegSignature),
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': head => startsWith(head, zipSignature),
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': head => startsWith(head, zipSignature),
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation': head => startsWith(head, zipSignature)
 };
+/**
+ * Whether the content starts as files of the media type do: the signature of a platform type, and for
+ * text (`text/*`, JSON and XML, also with a `+json` or `+xml` suffix) no binary signature. UTF-16 text
+ * passes: there is no NUL-byte check.
+ */
+function matchesSignature(head, mediaType) {
+    if (isTextMediaType(mediaType)) {
+        return !binarySignatures.some(signature => startsWith(head, signature));
+    }
+    return signatures[mediaType]?.(head) ?? true;
+}
+function isTextMediaType(mediaType) {
+    return mediaType.startsWith('text/')
+        || mediaType === 'application/json'
+        || mediaType === 'application/xml'
+        || mediaType.endsWith('+json')
+        || mediaType.endsWith('+xml');
+}
 /**
  * The files of the mock API: `POST conversations/{id}/files` with the server's checks, and the
  * attachments of a message, which a turn opens again as the server's file source would.
@@ -3185,7 +3841,8 @@ class NhAssistantMockFiles {
         if (name === null || file.size === 0) {
             return mockFailure('assistant-file-upload-invalid');
         }
-        const mediaType = normalizeMediaType(file.type);
+        // A missing or generic type takes the accepted type of the file name's extension, as on the server.
+        const mediaType = normalizeMediaType(_nhAssistantMediaTypeOf({ name, type: file.type }, uploads.acceptedMediaTypes, uploads.mappedExtensions));
         if (mediaType === null || !uploads.acceptedMediaTypes.includes(mediaType)) {
             return mockFailure('assistant-file-type-not-accepted');
         }
@@ -3193,7 +3850,7 @@ class NhAssistantMockFiles {
             return mockFailure('assistant-file-too-large');
         }
         const head = new Uint8Array(await file.slice(0, 1024).arrayBuffer());
-        if (!(signatures[mediaType]?.(head) ?? true)) {
+        if (!matchesSignature(head, mediaType)) {
             return mockFailure('assistant-file-type-not-accepted');
         }
         const upload = { conversationId, name, mediaType, size: file.size };
@@ -3714,7 +4371,9 @@ class NhAssistantMockAgentRuns {
             return method === 'GET' ? this.lookup(query, language) : { status: 405 };
         }
         if (segments.length === 3 && method === 'GET') {
-            const listed = segments[2] === 'proposals' ? this.context.threadProposals?.(segments[1]) ?? null : null;
+            const listed = segments[2] === 'proposals'
+                ? this.context.threadProposals?.(segments[1]) ?? null
+                : segments[2] === 'consultations' ? this.context.threadConsultations?.(segments[1]) ?? null : null;
             if (listed) {
                 return { status: 200, body: listed };
             }
@@ -4682,6 +5341,10 @@ const guid = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$
 const lifetimeMs = 3 * 24 * 60 * 60 * 1000;
 /** The platform's subject type of the whole application. */
 const systemType = 'nh-system';
+/** The person who asked decides a consultation's proposal in their own chat; nobody decides it in the thread. */
+const askerDecidesCode = 'assistant-consult-asker-decides';
+/** Someone other than the person who started the work decides it. */
+const fourEyesCode = 'assistant-four-eyes-required';
 /**
  * The proposals the scenario lists, which the mock's agents left, for example one a run for the whole
  * application placed at a project (`placedBy`). The mock runs no agents: it serves them as the server
@@ -4691,7 +5354,10 @@ const systemType = 'nh-system';
  * with the server's validation and statuses. An approved proposal executes at once. A proposal of the
  * whole application (`nh-system`) exists only for the approvers of the whole application who pass the
  * agent's view policy (`mayDecideApplication`): for anybody else the inbox leaves it out, reading it
- * answers `404` and deciding it `404 assistant-approval-not-found`.
+ * answers `404` and deciding it `404 assistant-approval-not-found`. A consultation's proposal that the
+ * person who asked decides in their own chat (`asker-decides`) waits inline and is refused here with
+ * `assistant-consult-asker-decides`; one that runs with the agent's own rights refuses its asker with
+ * `assistant-four-eyes-required`.
  */
 class NhAssistantMockProposals {
     constructor(scenario = [], actorId, now, mayDecideApplication = () => true, decided = () => undefined, mayWorkIn = () => true) {
@@ -4711,6 +5377,12 @@ class NhAssistantMockProposals {
             if (!dashCase.test(item.subjectType)) {
                 throw new Error(`Mock proposal '${item.approvalId}' names subject type '${item.subjectType}', which is not dash-case.`);
             }
+            if (item.consultationRoute && !item.consultationId) {
+                throw new Error(`Mock proposal '${item.approvalId}' names a consultation route without its consultation.`);
+            }
+            const route = item.consultationRoute ?? null;
+            const refusal = consultationRefusal(route, item.initiatorActorId ?? null, actorId());
+            const canDecide = item.canDecide ?? refusal === null;
             this.proposals.set(item.approvalId, {
                 proposal: {
                     approvalId: item.approvalId,
@@ -4730,12 +5402,12 @@ class NhAssistantMockProposals {
                     argumentsPreview: '{}',
                     targets: [],
                     status: item.status ?? 'pending',
-                    mode: 'deferred',
+                    mode: route === 'asker-decides' ? 'inline' : 'deferred',
                     policyId: null,
-                    grantSource: 'agent',
+                    grantSource: item.grantSource ?? (route === 'subject-asker-rights' ? 'delegated' : 'agent'),
                     createdAt: item.createdAt ?? new Date(created).toISOString(),
                     expiresAt: item.expiresAt ?? new Date(Date.parse(item.createdAt ?? new Date(created).toISOString()) + lifetimeMs).toISOString(),
-                    initiatorActorId: null,
+                    initiatorActorId: item.initiatorActorId ?? null,
                     decidedByActorId: null,
                     decidedAt: null,
                     executionResultCode: null,
@@ -4743,11 +5415,13 @@ class NhAssistantMockProposals {
                     rationale: item.rationale ?? null,
                     placedBy: item.placedBy ?? null,
                     parent: item.parent ?? null,
-                    canGiveFeedback: false
+                    canGiveFeedback: false,
+                    consultationId: item.consultationId ?? null,
+                    consultationRoute: route
                 },
                 divisionId: item.divisionId ?? null,
-                canDecide: item.canDecide ?? true,
-                reasonCode: item.canDecide === false ? item.reasonCode ?? 'assistant-approval-policy-denied' : null
+                canDecide,
+                reasonCode: canDecide ? null : item.reasonCode ?? refusal ?? 'assistant-approval-policy-denied'
             });
         }
     }
@@ -4781,6 +5455,21 @@ class NhAssistantMockProposals {
             .reverse();
         return items.length === 0 ? null : items;
     }
+    /** The proposals a consultation left per route; routes without proposals are left out. */
+    consultationCounts(consultationId) {
+        const byRoute = {};
+        let total = 0;
+        for (const { proposal } of this.proposals.values()) {
+            if (proposal.consultationId !== consultationId) {
+                continue;
+            }
+            total++;
+            if (proposal.consultationRoute) {
+                byRoute[proposal.consultationRoute] = (byRoute[proposal.consultationRoute] ?? 0) + 1;
+            }
+        }
+        return { total, byRoute };
+    }
     /** The proposals of a run the caller may see, in the order the scenario lists them. */
     ofRun(runId) {
         return this.visible()
@@ -4946,6 +5635,17 @@ class NhAssistantMockProposals {
         };
     }
 }
+/**
+ * Why nobody, or not the caller, decides a consultation's proposal here: the person who asked decides
+ * an `asker-decides` proposal in their own chat, and four-eyes keeps the asker out of a proposal that
+ * runs with the agent's own rights; `null` when the route does not keep the caller out.
+ */
+function consultationRefusal(route, initiatorActorId, actorId) {
+    if (route === 'asker-decides') {
+        return askerDecidesCode;
+    }
+    return route === 'subject-agent-rights' && initiatorActorId === actorId ? fourEyesCode : null;
+}
 /** The scope of the inbox's visits: `global`, or the scope key of a division. */
 function scopeKeyOf(divisionId) {
     return divisionId === null ? 'global' : `division:${divisionId.replaceAll('-', '').toLowerCase()}`;
@@ -5080,6 +5780,8 @@ const NH_ASSISTANT_MOCK_SCENARIO = new InjectionToken('NH_ASSISTANT_MOCK_SCENARI
 const NH_ASSISTANT_MOCK_HUB_PATH = '/hub/assistant-mock';
 const defaultLimits = { maxMessageChars: 4_000, maxToolCallsPerTurn: 8 };
 const defaultUser = { actorId: 'mock-user', displayName: 'You' };
+/** When the scenario's consultations started, when they name no time. */
+const consultationStart = new Date().toISOString();
 class RunStopped extends Error {
 }
 /**
@@ -5112,6 +5814,7 @@ class NhAssistantMockBackend {
             agents: () => this.admin.allAgents(),
             administers: () => this.admin.administers,
             threadProposals: conversationId => this.proposals.ofThread(conversationId),
+            threadConsultations: conversationId => this.consultationsOf(conversationId),
             runProposals: runId => this.proposals.ofRun(runId),
             workChanged: (change, agentId) => this.publishAgentWork(change, agentId)
         }, () => new Date().toISOString());
@@ -5232,6 +5935,37 @@ class NhAssistantMockBackend {
         const turn = this.findTurn(text, conversation.agentId, null);
         await this.playSteps(conversationId, assistantMessageId, turn?.steps ?? [], emit);
     }
+    /**
+     * 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, text, details = {}) {
+        const conversation = this.conversations.get(conversationId);
+        if (!conversation || conversation.status === 'archived') {
+            return null;
+        }
+        const message = {
+            id: this.nextId(),
+            role: 'application',
+            createdAt: new Date().toISOString(),
+            parts: [{ type: 'text', text }],
+            authorActorId: null,
+            authorKind: 'application',
+            application: {
+                title: details.title ?? null,
+                senderName: details.senderName ?? null,
+                link: details.link ?? null,
+                trusted: details.trusted ?? false
+            }
+        };
+        this.update(conversationId, current => ({ ...current, messages: [...current.messages, message] }));
+        const stored = this.conversations.get(conversationId).messages.find(item => item.id === message.id);
+        this.emitLive({ kind: 'event', data: { conversationId, actorId: 'application', type: 'message.created', data: stored } });
+        this.emitChanged(conversationId);
+        return stored;
+    }
     /** Switches the simulated `NewHeap:AI:Assistant:Enabled` flag. */
     setEnabled(enabled) {
         this.enabledState.set(enabled);
@@ -5480,6 +6214,12 @@ class NhAssistantMockBackend {
             await this.playSteps(conversation.id, assistantMessageId, steps, emit);
         });
     }
+    /**
+     * `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.
+     */
     decide(conversation, approvalId, request) {
         const pending = this.pendingApprovals.get(conversation.id);
         if (!pending || pending.approval.approvalId !== approvalId) {
@@ -5489,16 +6229,29 @@ class NhAssistantMockBackend {
         if (decider && decider !== this.currentUser.actorId) {
             return this.error('assistant-approval-forbidden');
         }
-        if (request?.expectedProposalHash !== pending.approval.proposalHash) {
+        const decision = request?.decision;
+        if (decision !== 'approve' && decision !== 'reject' && decision !== 'leave') {
+            return this.error('assistant-approval-decision-invalid');
+        }
+        if (decision === 'leave' && !pending.approval.consultation) {
+            return this.error('assistant-approval-decision-invalid');
+        }
+        if (decision === 'leave' && !pending.approval.consultation?.leaveRoute) {
+            return this.error('assistant-consult-proposal-refused');
+        }
+        if (request.expectedProposalHash !== pending.approval.proposalHash) {
             return this.empty(409);
         }
         if (Date.parse(pending.approval.expiresAt) <= Date.now()) {
             return this.empty(409);
         }
         this.pendingApprovals.delete(conversation.id);
-        const decision = request.decision;
         const lastUser = [...conversation.messages].reverse().find(message => message.role === 'user');
         this.update(conversation.id, current => applyNhAssistantApprovalDecision(current, approvalId, decision));
+        if (decision === 'leave') {
+            const movedToApprovalId = this.nextId();
+            this.update(conversation.id, current => withMovedApproval(current, approvalId, movedToApprovalId));
+        }
         return this.stream(conversation.id, async (emit) => {
             await emit({
                 type: 'turn.started',
@@ -5511,6 +6264,14 @@ class NhAssistantMockBackend {
                 });
                 await this.playSteps(conversation.id, pending.assistantMessageId, pending.step.approved, emit);
             }
+            else if (decision === 'leave') {
+                // The consult call ends: its proposal now waits for the subject's approvers.
+                await emit({
+                    type: 'tool.completed',
+                    data: { invocationId: pending.invocationId, status: 'succeeded', resultCode: 'assistant-consult-proposal-moved', resultPreview: null }
+                });
+                await this.playSteps(conversation.id, pending.assistantMessageId, pending.step.left ?? [], emit);
+            }
             else {
                 await this.playSteps(conversation.id, pending.assistantMessageId, pending.step.rejected, emit);
             }
@@ -5620,7 +6381,21 @@ class NhAssistantMockBackend {
             argumentsPreview: step.argumentsPreview,
             targets: step.targets,
             expiresAt: new Date(Date.now() + (step.expiresInSeconds ?? 300) * 1000).toISOString(),
-            status: 'pending'
+            status: 'pending',
+            ...(step.consultation
+                ? {
+                    consultation: {
+                        consultationId: step.consultation.consultationId ?? this.nextId(),
+                        agentId: step.consultation.agentId,
+                        subjectType: step.consultation.subjectType,
+                        subjectId: step.consultation.subjectId,
+                        subjectDisplayName: step.consultation.subjectDisplayName ?? null,
+                        leaveRoute: step.consultation.leaveRoute ?? null,
+                        answer: step.consultation.answer ?? null,
+                        movedToApprovalId: null
+                    }
+                }
+                : {})
         };
         this.pendingApprovals.set(conversationId, { approval, invocationId, assistantMessageId, step });
         await emit({ type: 'approval.required', data: approval });
@@ -5876,6 +6651,40 @@ class NhAssistantMockBackend {
         const policy = agent?.viewPolicy ?? agent?.requiredPolicy ?? null;
         return policy === null || (this.scenario.callerPolicies?.includes(policy) ?? true);
     }
+    /**
+     * 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.
+     */
+    consultationsOf(conversationId) {
+        const listed = (this.scenario.consultations ?? []).filter(item => item.conversationId === conversationId);
+        if (listed.length === 0) {
+            return null;
+        }
+        const items = listed
+            .map(item => {
+            const proposals = this.proposals.consultationCounts(item.id);
+            const createdAt = item.createdAt ?? consultationStart;
+            const status = item.status ?? 'completed';
+            return {
+                id: item.id,
+                askerActorId: item.askerActorId,
+                askerDisplayName: item.askerDisplayName ?? null,
+                askingAgentId: item.askingAgentId ?? null,
+                depth: 1,
+                status,
+                failureCode: status === 'failed' ? 'assistant-consult-failed' : null,
+                toolCalls: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                proposalCount: proposals.total,
+                createdAt,
+                endedAt: status === 'running' ? null : createdAt,
+                proposalsByRoute: proposals.byRoute
+            };
+        })
+            .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+        return { items, total: items.length };
+    }
     nextId() {
         this.sequence++;
         const suffix = this.sequence.toString(16).padStart(12, '0');
@@ -5917,6 +6726,19 @@ function languageOf(headers) {
 function delay(milliseconds) {
     return new Promise(resolve => setTimeout(resolve, milliseconds));
 }
+/**
+ * A consulted agent's proposal the person left for the subject's approvers, as the server reads it
+ * afterwards: closed here and naming the proposal that waits at the subject.
+ */
+function withMovedApproval(conversation, approvalId, movedToApprovalId) {
+    const moved = (part) => part.type === 'approval' && part.approvalId === approvalId && part.consultation
+        ? { ...part, status: 'rejected', consultation: { ...part.consultation, leaveRoute: null, movedToApprovalId } }
+        : part;
+    return {
+        ...conversation,
+        messages: conversation.messages.map(message => ({ ...message, parts: message.parts.map(moved) }))
+    };
+}
 /** Like the server: a new message starts in an idle conversation or after a failed turn. */
 function acceptsMessage(status) {
     return status === 'idle' || status === 'failed';