@newheap/platform-ai-chat 0.12.0 → 0.14.0

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

@@ -3,6 +3,519 @@ import { InjectionToken, inject, signal, Injectable, DestroyRef, makeEnvironment
 import { NH_ASSISTANT_CONFIG, applyNhAssistantEvent, normalizeNhAssistantClientContext, applyNhAssistantApprovalDecision, NH_ASSISTANT_FETCH, NhAssistantLiveService } from '@newheap/platform-ai-chat';
 import { Subject, NEVER } from 'rxjs';
 
+const dashCase$1 = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const accountabilities = ['agent', 'subject-responsible', 'service-account'];
+const conflicts = ['coalesce', 'queue', 'supersede', 'ignore'];
+const maxDescription = 300;
+const maxInstructions$1 = 20_000;
+const maxMessage = 2_000;
+const maxReason = 500;
+/**
+ * In-memory run configuration as data of the mock API: run settings of agents created in the
+ * administration, skills defined as data with versions and candidates, and data triggers. Saving
+ * checks the names against the scenario's run catalog as the server checks them against the code;
+ * new skills and triggers start in shadow. The mock runs no agents, so a comparison counts nothing.
+ */
+class NhAssistantMockRunConfiguration {
+    constructor(scenario, agents, now) {
+        this.agents = agents;
+        this.now = now;
+        this.settings = new Map();
+        this.skills = new Map();
+        this.triggers = new Map();
+        this.catalog = {
+            triggerEvents: scenario.runCatalog?.triggerEvents ?? [],
+            subjectSets: scenario.runCatalog?.subjectSets ?? [],
+            ruleHandlers: scenario.runCatalog?.ruleHandlers ?? [],
+            approvalPolicies: scenario.runCatalog?.approvalPolicies ?? scenario.policies ?? [],
+            profiles: scenario.runCatalog?.profiles ?? []
+        };
+        this.codeTriggers = (scenario.codeTriggers ?? []).map(trigger => ({ ...trigger, skillId: trigger.skillId ?? null }));
+    }
+    /** `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.
+     */
+    handle(method, agentId, segments, body, query) {
+        const agent = this.agents.find(agentId);
+        const [area, id, action, child] = segments;
+        if (area === 'configuration' && segments.length === 1) {
+            return agent && method === 'GET' ? { status: 200, body: this.configuration(agent) } : failure$1(404, 'assistant-agent-not-found');
+        }
+        if (area === 'run-settings' && segments.length === 1) {
+            return agent ? this.runSettings(method, agent, body, query) : failure$1(404, 'assistant-agent-not-found');
+        }
+        if (area === 'skills' && id !== undefined && (segments.length === 2 || action === 'versions' || action === 'candidate')) {
+            if (!agent) {
+                return failure$1(404, 'assistant-agent-not-found');
+            }
+            if (action === 'versions' && segments.length === 3) {
+                return method === 'GET' ? { status: 200, body: this.versions(agent.id, id) } : { status: 405 };
+            }
+            if (action === 'candidate' && segments.length === 4) {
+                return this.candidate(method, agent, id, child, body);
+            }
+            return segments.length === 2 ? this.skill(method, agent, id, body, query) : null;
+        }
+        if (area === 'triggers' && id !== undefined && (segments.length === 2 || (segments.length === 3 && action === 'shadow'))) {
+            if (!agent) {
+                return failure$1(404, 'assistant-agent-not-found');
+            }
+            return action === 'shadow' ? this.triggerShadow(method, agent, id, body) : this.trigger(method, agent, id, body, query);
+        }
+        return null;
+    }
+    configuration(agent) {
+        const dataSkills = this.liveSkills(agent.id);
+        const dataSkillIds = new Set(dataSkills.map(skill => skill.skillId));
+        return {
+            agentId: agent.id,
+            toolSelectors: [...agent.toolSelectors],
+            codeSkills: agent.source === 'code'
+                ? (agent.skills ?? []).filter(skill => !dataSkillIds.has(skill.skillId)).map(skill => ({ skillId: skill.skillId, description: skill.description }))
+                : [],
+            dataSkills,
+            codeTriggers: this.codeTriggers.filter(trigger => trigger.agentId === agent.id).map(({ agentId, ...trigger }) => trigger),
+            dataTriggers: [...this.triggers.values()].filter(trigger => this.ownerOf(trigger) === agent.id).map(trigger => ({ ...trigger })),
+            problems: [],
+            source: agent.source,
+            runSettings: agent.source === 'admin' ? this.settings.get(agent.id) ?? null : null
+        };
+    }
+    runSettings(method, agent, body, query) {
+        if (agent.source === 'code') {
+            return failure$1(409, 'assistant-run-settings-in-code');
+        }
+        const current = this.settings.get(agent.id);
+        if (method === 'DELETE') {
+            if (!current) {
+                return failure$1(409, 'assistant-agent-not-configured');
+            }
+            if (!versionMatches(query, current.version)) {
+                return failure$1(409, 'assistant-version-conflict');
+            }
+            if (this.liveSkills(agent.id).length > 0 || [...this.triggers.values()].some(trigger => this.ownerOf(trigger) === agent.id)) {
+                return failure$1(409, 'assistant-run-settings-in-use');
+            }
+            this.settings.delete(agent.id);
+            return { status: 204 };
+        }
+        if (method !== 'PUT') {
+            return { status: 405 };
+        }
+        const request = (body ?? {});
+        const serviceAccount = text(request.serviceAccountActorId);
+        const errors = {};
+        if (!accountabilities.includes(request.accountability)) {
+            errors['accountability'] = [request.accountability ? 'invalid' : 'required'];
+        }
+        if ((request.accountability === 'service-account') !== (serviceAccount !== null)) {
+            errors['serviceAccountActorId'] = [serviceAccount === null ? 'required' : 'invalid'];
+        }
+        if (request.allowGatewayReads && request.accountability === 'agent') {
+            errors['allowGatewayReads'] = ['invalid'];
+        }
+        if (!inRange(request.retryCount, 0, 10)) {
+            errors['retryCount'] = ['invalid'];
+        }
+        if (!inRange(request.maxConcurrentRuns, 1, 100)) {
+            errors['maxConcurrentRuns'] = ['invalid'];
+        }
+        if (!inRange(request.maxRunsPerSubjectPerDay, 1, 1_000)) {
+            errors['maxRunsPerSubjectPerDay'] = ['invalid'];
+        }
+        if (!budgetValid(request.dailyToolCalls, request.dailyTokens)) {
+            errors['dailyBudget'] = ['invalid'];
+        }
+        this.requireKnown(errors, 'approvalPolicy', request.approvalPolicy, this.catalog.approvalPolicies);
+        this.requireKnown(errors, 'triageProfile', request.triageProfile, this.catalog.profiles);
+        this.requireKnown(errors, 'ruleHandler', request.ruleHandler, this.catalog.ruleHandlers.map(handler => handler.name));
+        if (Object.keys(errors).length > 0) {
+            return failure$1(400, 'assistant-validation', errors);
+        }
+        if (serviceAccount?.startsWith('unknown')) {
+            return failure$1(400, 'assistant-service-account-not-found');
+        }
+        if ((request.expectedVersion ?? null) !== (current?.version ?? null)) {
+            return failure$1(409, 'assistant-version-conflict');
+        }
+        const saved = {
+            version: (current?.version ?? 0) + 1,
+            accountability: request.accountability,
+            serviceAccountActorId: serviceAccount,
+            delegateFromInitiator: request.delegateFromInitiator ?? false,
+            allowGatewayReads: request.allowGatewayReads ?? false,
+            elevatedReads: request.elevatedReads ?? 'restricted',
+            approvalPolicy: text(request.approvalPolicy),
+            retryCount: request.retryCount ?? 3,
+            dailyToolCalls: request.dailyToolCalls ?? null,
+            dailyTokens: request.dailyTokens ?? null,
+            maxConcurrentRuns: request.maxConcurrentRuns ?? 4,
+            maxRunsPerSubjectPerDay: request.maxRunsPerSubjectPerDay ?? 10,
+            maxTokensPerRun: request.maxTokensPerRun ?? null,
+            triageProfile: text(request.triageProfile),
+            ruleHandler: text(request.ruleHandler),
+            changedAt: this.now(),
+            changedBy: 'current-user',
+            reason: text(request.reason),
+            inEffect: true,
+            problem: null
+        };
+        this.settings.set(agent.id, saved);
+        return { status: 200, body: saved };
+    }
+    skill(method, agent, skillId, body, query) {
+        if (agent.source === 'code' && (agent.skills ?? []).some(skill => skill.skillId === skillId) && !this.skills.has(key(agent.id, skillId))) {
+            return failure$1(409, 'assistant-skill-in-code');
+        }
+        if (!this.isConfigured(agent)) {
+            return failure$1(409, 'assistant-agent-not-configured');
+        }
+        const versions = this.skills.get(key(agent.id, skillId)) ?? [];
+        const live = versions.find(version => version.status === 'live');
+        if (method === 'DELETE') {
+            if (!live) {
+                return failure$1(404, 'assistant-skill-not-found');
+            }
+            if (!versionMatches(query, live.version)) {
+                return failure$1(409, 'assistant-version-conflict');
+            }
+            if ([...this.triggers.values()].some(trigger => this.ownerOf(trigger) === agent.id && trigger.skillId === skillId)) {
+                return failure$1(409, 'assistant-skill-in-use');
+            }
+            for (const version of versions) {
+                version.status = version.status === 'candidate' ? 'discarded' : version.status === 'live' ? 'superseded' : version.status;
+            }
+            this.agents.setDataSkill(agent.id, skillId, null);
+            return { status: 204 };
+        }
+        if (method !== 'PUT') {
+            return { status: 405 };
+        }
+        const request = (body ?? {});
+        const description = text(request.description);
+        const errors = {};
+        if (!dashCase$1.test(skillId)) {
+            errors['skillId'] = ['invalid'];
+        }
+        if (description === null) {
+            errors['description'] = ['required'];
+        }
+        else if (description.length > maxDescription) {
+            errors['description'] = ['too-long'];
+        }
+        if ((request.instructions ?? '').length > maxInstructions$1) {
+            errors['instructions'] = ['too-long'];
+        }
+        if ((request.tools ?? []).some(tool => !agent.toolSelectors.some(selector => covers(selector, tool)))) {
+            errors['tools'] = ['invalid'];
+        }
+        if (!inRange(request.maxTokensPerRun, 1, Number.MAX_SAFE_INTEGER)) {
+            errors['maxTokensPerRun'] = ['invalid'];
+        }
+        if (!budgetValid(request.dailyToolCalls, request.dailyTokens)) {
+            errors['dailyBudget'] = ['invalid'];
+        }
+        if (request.apply === 'shadow' && (request.expectedVersion ?? null) === null) {
+            errors['apply'] = ['invalid'];
+        }
+        this.requireKnown(errors, 'profile', request.profile, this.catalog.profiles);
+        this.requireKnown(errors, 'ruleHandler', request.ruleHandler, this.catalog.ruleHandlers.map(handler => handler.name));
+        this.requireKnown(errors, 'approvalPolicy', request.approvalPolicy, this.catalog.approvalPolicies);
+        if (Object.keys(errors).length > 0) {
+            return failure$1(400, 'assistant-validation', errors);
+        }
+        if ((request.expectedVersion ?? null) !== (live?.version ?? null)) {
+            return failure$1(409, 'assistant-version-conflict');
+        }
+        const candidate = request.apply === 'shadow';
+        for (const version of versions) {
+            if (version.status === 'candidate') {
+                version.status = 'discarded';
+            }
+            else if (version.status === 'live' && !candidate) {
+                version.status = 'superseded';
+            }
+        }
+        const instructions = text(request.instructions);
+        const saved = {
+            skillId,
+            version: versions.reduce((latest, version) => Math.max(latest, version.version), 0) + 1,
+            status: candidate ? 'candidate' : 'live',
+            description: description,
+            instructions,
+            instructionsHash: instructions === null ? null : hashText$1(instructions),
+            tools: [...new Set(request.tools ?? [])],
+            profile: text(request.profile),
+            ruleHandler: text(request.ruleHandler),
+            maxTokensPerRun: request.maxTokensPerRun ?? null,
+            dailyToolCalls: request.dailyToolCalls ?? null,
+            dailyTokens: request.dailyTokens ?? null,
+            approvalPolicy: text(request.approvalPolicy),
+            changedAt: this.now(),
+            changedBy: 'current-user',
+            reason: text(request.reason),
+            inEffect: true,
+            problem: null
+        };
+        this.skills.set(key(agent.id, skillId), [...versions, saved]);
+        if (!candidate) {
+            this.agents.setDataSkill(agent.id, skillId, saved.description);
+        }
+        return { status: 200, body: toSkill(saved) };
+    }
+    candidate(method, agent, skillId, action, body) {
+        const versions = this.skills.get(key(agent.id, skillId)) ?? [];
+        const candidate = versions.find(version => version.status === 'candidate');
+        const live = versions.find(version => version.status === 'live');
+        if (action === 'comparison' && method === 'GET') {
+            if (!candidate || !live) {
+                return failure$1(404, 'assistant-skill-candidate-not-found');
+            }
+            const comparison = {
+                agentId: agent.id,
+                skillId,
+                from: candidate.changedAt,
+                to: this.now(),
+                live: emptyStats(live.version),
+                candidate: emptyStats(candidate.version),
+                pairedEvents: 0,
+                tools: []
+            };
+            return { status: 200, body: comparison };
+        }
+        if ((action !== 'promote' && action !== 'discard') || method !== 'POST') {
+            return { status: 405 };
+        }
+        const request = body;
+        if (typeof request?.version !== 'number') {
+            return failure$1(400, 'assistant-validation', { version: ['required'] });
+        }
+        if (!candidate) {
+            return failure$1(404, 'assistant-skill-candidate-not-found');
+        }
+        if (candidate.version !== request.version) {
+            return failure$1(409, 'assistant-version-conflict');
+        }
+        if (action === 'discard') {
+            candidate.status = 'discarded';
+            return { status: 204 };
+        }
+        if (live) {
+            live.status = 'superseded';
+        }
+        candidate.status = 'live';
+        this.agents.setDataSkill(agent.id, skillId, candidate.description);
+        return { status: 200, body: toSkill(candidate) };
+    }
+    versions(agentId, skillId) {
+        return [...(this.skills.get(key(agentId, skillId)) ?? [])]
+            .sort((left, right) => right.version - left.version)
+            .map(version => ({
+            version: version.version,
+            status: version.status,
+            description: version.description,
+            instructionsHash: version.instructionsHash,
+            createdAt: version.changedAt,
+            createdBy: version.changedBy,
+            reason: version.reason
+        }));
+    }
+    trigger(method, agent, triggerId, body, query) {
+        if (this.codeTriggers.some(trigger => trigger.triggerId === triggerId)) {
+            return failure$1(409, 'assistant-trigger-in-code');
+        }
+        if (!this.isConfigured(agent)) {
+            return failure$1(409, 'assistant-agent-not-configured');
+        }
+        const existing = this.triggers.get(triggerId);
+        if (existing && this.ownerOf(existing) !== agent.id) {
+            return failure$1(400, 'assistant-validation', { triggerId: ['invalid'] });
+        }
+        if (method === 'DELETE') {
+            if (!existing) {
+                return failure$1(404, 'assistant-trigger-not-found');
+            }
+            if (!versionMatches(query, existing.version)) {
+                return failure$1(409, 'assistant-version-conflict');
+            }
+            this.triggers.delete(triggerId);
+            return { status: 204 };
+        }
+        if (method !== 'PUT') {
+            return { status: 405 };
+        }
+        const request = (body ?? {});
+        const schedule = request.source === 'schedule';
+        const errors = {};
+        if (!dashCase$1.test(triggerId)) {
+            errors['triggerId'] = ['invalid'];
+        }
+        if (request.source !== 'event' && request.source !== 'schedule') {
+            errors['source'] = [request.source ? 'invalid' : 'required'];
+        }
+        if (request.conflict && !conflicts.includes(request.conflict)) {
+            errors['conflict'] = ['invalid'];
+        }
+        if (!inRange(request.debounceSeconds, 0, 3_600)) {
+            errors['debounceSeconds'] = ['invalid'];
+        }
+        if (request.source === 'event') {
+            this.requireKnown(errors, 'event', request.event, this.catalog.triggerEvents.map(item => item.name), true);
+        }
+        if (schedule) {
+            if ((text(request.cron) ?? '').split(' ').filter(field => field.length > 0).length < 5) {
+                errors['cron'] = [text(request.cron) === null ? 'required' : 'invalid'];
+            }
+            this.requireKnown(errors, 'subjectSet', request.subjectSet, this.catalog.subjectSets.map(item => item.name), true);
+            const message = text(request.message);
+            if (message === null) {
+                errors['message'] = ['required'];
+            }
+            else if (message.length > maxMessage) {
+                errors['message'] = ['too-long'];
+            }
+        }
+        const skill = text(request.skill);
+        if (skill !== null && !this.skillIds(agent).includes(skill)) {
+            errors['skill'] = ['not-found'];
+        }
+        if (Object.keys(errors).length > 0) {
+            return failure$1(400, 'assistant-validation', errors);
+        }
+        if ((request.expectedVersion ?? null) !== (existing?.version ?? null)) {
+            return failure$1(409, 'assistant-version-conflict');
+        }
+        const saved = {
+            triggerId,
+            skillId: skill,
+            source: request.source,
+            event: schedule ? null : text(request.event),
+            cron: schedule ? text(request.cron) : null,
+            timeZone: schedule ? text(request.timeZone) : null,
+            subjectSet: schedule ? text(request.subjectSet) : null,
+            message: schedule ? text(request.message) : null,
+            conflict: request.conflict ?? (schedule ? 'ignore' : 'coalesce'),
+            debounceSeconds: schedule ? 0 : request.debounceSeconds ?? 120,
+            shadow: existing?.shadow ?? true,
+            version: (existing?.version ?? 0) + 1,
+            changedAt: this.now(),
+            changedBy: 'current-user',
+            reason: text(request.reason),
+            inEffect: true,
+            problem: null
+        };
+        this.triggers.set(triggerId, Object.assign(saved, { [ownerKey]: agent.id }));
+        return { status: 200, body: withoutOwner(saved) };
+    }
+    triggerShadow(method, agent, triggerId, body) {
+        if (method !== 'POST') {
+            return { status: 405 };
+        }
+        const existing = this.triggers.get(triggerId);
+        if (!existing || this.ownerOf(existing) !== agent.id) {
+            return failure$1(404, 'assistant-trigger-not-found');
+        }
+        const request = body;
+        if (request?.mode !== 'shadow' && request?.mode !== 'live') {
+            return failure$1(400, 'assistant-validation', { mode: [request?.mode === undefined ? 'required' : 'invalid'] });
+        }
+        if (typeof request.reason === 'string' && request.reason.length > maxReason) {
+            return failure$1(400, 'assistant-validation', { reason: ['too-long'] });
+        }
+        existing.shadow = request.mode === 'shadow';
+        existing.changedAt = this.now();
+        existing.changedBy = 'current-user';
+        existing.reason = typeof request.reason === 'string' && request.reason.trim().length > 0 ? request.reason.trim() : null;
+        return { status: 200, body: withoutOwner(existing) };
+    }
+    /** An agent in code has a run configuration; one created in the administration once it has run settings. */
+    isConfigured(agent) {
+        return agent.source === 'code' || this.settings.has(agent.id);
+    }
+    skillIds(agent) {
+        return [...(agent.skills ?? []).map(skill => skill.skillId), ...this.liveSkills(agent.id).map(skill => skill.skillId)];
+    }
+    liveSkills(agentId) {
+        const result = [];
+        for (const [stored, versions] of this.skills) {
+            if (!stored.startsWith(`${agentId}/`)) {
+                continue;
+            }
+            const live = versions.find(version => version.status === 'live');
+            if (live) {
+                const candidate = versions.find(version => version.status === 'candidate');
+                result.push({ ...toSkill(live), candidate: candidate ? toSkill(candidate) : null });
+            }
+        }
+        return result.sort((left, right) => left.skillId.localeCompare(right.skillId));
+    }
+    ownerOf(trigger) {
+        return trigger[ownerKey];
+    }
+    requireKnown(errors, field, value, known, required = false) {
+        const name = text(value);
+        if (name === null) {
+            if (required) {
+                errors[field] = ['required'];
+            }
+            return;
+        }
+        if (!known.includes(name)) {
+            errors[field] = ['not-found'];
+        }
+    }
+}
+const ownerKey = '__agentId';
+function key(agentId, skillId) {
+    return `${agentId}/${skillId}`;
+}
+function toSkill({ status, ...skill }) {
+    return { ...skill, tools: [...skill.tools] };
+}
+function withoutOwner(trigger) {
+    const { [ownerKey]: owner, ...rest } = trigger;
+    return { ...rest };
+}
+function emptyStats(version) {
+    return { version, runs: 0, completed: 0, failed: 0, proposals: 0, toolCalls: 0, tokens: 0 };
+}
+function text(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function inRange(value, min, max) {
+    return value === null || value === undefined || (Number.isInteger(value) && value >= min && value <= max);
+}
+function budgetValid(calls, tokens) {
+    const hasCalls = calls !== null && calls !== undefined;
+    const hasTokens = tokens !== null && tokens !== undefined;
+    return hasCalls === hasTokens && (!hasCalls || (calls >= 1 && tokens >= 1));
+}
+function versionMatches(query, version) {
+    const expected = query.get('expectedVersion');
+    return expected === null || Number(expected) === version;
+}
+/** The agent's selector covers the skill's: the same tool, or a prefix selector that includes it. */
+function covers(agentSelector, skillSelector) {
+    return agentSelector === skillSelector
+        || (agentSelector.endsWith('.*') && skillSelector.startsWith(agentSelector.slice(0, -1)));
+}
+function hashText$1(text) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index++) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193) >>> 0;
+    }
+    return `fnv1a:${hash.toString(16).padStart(8, '0')}`;
+}
+function failure$1(status, code, errors) {
+    return { status, body: { code, messageKey: `nh-assistant.errors.${code}`, ...(errors ? { errors } : {}) } };
+}
+
 const dashCase = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const styles = ['default', 'direct', 'personal', 'detailed'];
 const addressForms = ['informal', 'formal'];
@@ -37,11 +550,16 @@ class NhAssistantMockAdmin {
         this.contextVersions.push({ version: 1, hash: hashText(admin.context ?? ''), updatedAt: now(), updatedBy: null, text: admin.context ?? '' });
         const agents = admin.agents
             ?? scenario.agents.map(agent => ({ ...codeAgentFromSummary(agent), source: 'code' }));
-        for (const { source, skills, shadowOf, ...input } of agents) {
+        for (const { source, skills, shadowOf, shadow, serviceAccount, ...input } of agents) {
+            const agentShadow = shadowOf !== undefined || shadow === true;
             this.agents.set(input.id, {
                 agent: {
                     ...this.toAgent(input, source, 1, false),
                     shadowOf: shadowOf ?? null,
+                    shadow: shadowState(agentShadow, shadowOf !== undefined || shadow === true, null, shadowOf !== undefined),
+                    serviceAccount: serviceAccount === undefined
+                        ? null
+                        : { actorId: serviceAccount, configuredActorId: serviceAccount, overridden: false, changedAt: null, changedBy: null, reason: null },
                     skills: (skills ?? []).map((skill) => ({
                         skillId: skill.skillId,
                         description: skill.description,
@@ -55,12 +573,17 @@ class NhAssistantMockAdmin {
                         dailyToolCalls: null,
                         dailyTokens: null,
                         cancelledRuns: 0,
-                        startedRuns: 0
+                        startedRuns: 0,
+                        shadow: shadowState(agentShadow || skill.shadow === true, skill.shadow === true, null, shadowOf !== undefined)
                     }))
                 },
                 codeDefinition: source === 'code' ? structuredClone(input) : null
             });
         }
+        this.runConfiguration = new NhAssistantMockRunConfiguration(admin, {
+            find: agentId => this.agents.get(agentId)?.agent,
+            setDataSkill: (agentId, skillId, description) => this.setDataSkill(agentId, skillId, description)
+        }, now);
         for (const { remoteTools, secret, ...input } of admin.mcpServers ?? []) {
             this.servers.set(input.id, {
                 server: { ...toServerFields(input), lastSyncAt: null, lastSyncStatus: null },
@@ -135,6 +658,8 @@ class NhAssistantMockAdmin {
                 return this.context(method, id, body);
             case 'tools':
                 return method === 'GET' && segments.length === 2 ? { status: 200, body: this.toolCatalog() } : failure(404, 'assistant-not-found');
+            case 'run-catalog':
+                return segments.length === 2 ? this.runConfiguration.runCatalog(method) : failure(404, 'assistant-not-found');
             case 'agents':
                 if (id !== undefined && action === 'feedback') {
                     return this.agentFeedback(method, id, child, segments.length);
@@ -145,9 +670,18 @@ class NhAssistantMockAdmin {
                 if (id !== undefined && (action === 'replay' || action === 'replays') && segments.length === 4) {
                     return this.agentReplay(method, id, action, body);
                 }
+                if (id !== undefined && action !== undefined) {
+                    const configured = this.runConfiguration.handle(method, id, segments.slice(3), body, query);
+                    if (configured) {
+                        return configured;
+                    }
+                }
                 if (id !== undefined && action === 'skills' && child !== undefined && segments[5] === 'state' && segments.length === 6) {
                     return this.skillStateEndpoint(method, id, child, body);
                 }
+                if (id !== undefined && action === 'skills' && child !== undefined && segments[5] === 'shadow' && segments.length === 6) {
+                    return this.skillShadowEndpoint(method, id, child, body);
+                }
                 return this.agentsEndpoint(method, id, action, body, segments.length);
             case 'mcp-servers':
                 return this.serversEndpoint(method, id, action, child, body, segments.length);
@@ -228,6 +762,12 @@ class NhAssistantMockAdmin {
         if (length === 4 && action === 'state') {
             return this.agentStateEndpoint(stored, method, body);
         }
+        if (length === 4 && action === 'shadow' && method === 'POST') {
+            return this.agentShadowEndpoint(stored, body);
+        }
+        if (length === 4 && action === 'service-account' && method === 'POST') {
+            return this.serviceAccountEndpoint(stored, body);
+        }
         if (length === 4 && action === 'kill-switch' && method === 'POST') {
             const engaged = body?.engaged;
             if (typeof engaged !== 'boolean') {
@@ -286,6 +826,106 @@ class NhAssistantMockAdmin {
         stored.agent = { ...stored.agent, skills: stored.agent.skills.map(item => item.skillId === skillId ? changed : item) };
         return { status: 200, body: changed };
     }
+    /**
+     * `POST admin/agents/{id}/shadow`: the agent's shadow mode as an override of the code. A
+     * variant always works in shadow; the skills' effective modes follow the agent's.
+     */
+    agentShadowEndpoint(stored, body) {
+        const request = shadowRequest(body);
+        if (request === null) {
+            return validationFailure();
+        }
+        const current = stored.agent.shadow ?? shadowState(false, false, null, false);
+        if (current.locked) {
+            return failure(409, 'assistant-shadow-variant');
+        }
+        const override = request.mode === 'code' ? null : request.mode === 'shadow';
+        if (current.override !== override) {
+            const shadow = override ?? current.configured;
+            stored.agent = {
+                ...stored.agent,
+                shadow: { ...current, shadow, override, changedAt: this.now(), changedBy: 'current-user', reason: request.reason },
+                skills: (stored.agent.skills ?? []).map(skill => ({ ...skill, shadow: withAgentShadow(skill.shadow, shadow) }))
+            };
+        }
+        return { status: 200, body: toAgentState(stored.agent) };
+    }
+    /**
+     * `POST admin/agents/{id}/skills/{skillId}/shadow`: one skill's shadow mode; a skill of an agent
+     * in shadow works in shadow whatever its own mode.
+     */
+    skillShadowEndpoint(method, agentId, skillId, body) {
+        const stored = this.agents.get(agentId);
+        const skill = stored?.agent.skills?.find(item => item.skillId === skillId);
+        if (!stored || !skill) {
+            return failure(404, 'assistant-skill-not-found');
+        }
+        if (method !== 'POST') {
+            return { status: 405 };
+        }
+        const request = shadowRequest(body);
+        if (request === null) {
+            return validationFailure();
+        }
+        const agentShadow = stored.agent.shadow ?? shadowState(false, false, null, false);
+        if (agentShadow.locked) {
+            return failure(409, 'assistant-shadow-variant');
+        }
+        const current = skill.shadow ?? shadowState(agentShadow.shadow, false, null, false);
+        const override = request.mode === 'code' ? null : request.mode === 'shadow';
+        const changed = current.override === override
+            ? skill
+            : {
+                ...skill,
+                shadow: {
+                    ...current,
+                    shadow: agentShadow.shadow || (override ?? current.configured),
+                    override,
+                    changedAt: this.now(),
+                    changedBy: 'current-user',
+                    reason: request.reason
+                }
+            };
+        stored.agent = { ...stored.agent, skills: stored.agent.skills.map(item => item.skillId === skillId ? changed : item) };
+        return { status: 200, body: changed };
+    }
+    /**
+     * `POST admin/agents/{id}/service-account`: the technical account of an agent that answers to
+     * one in code. The mock accepts every account id except those starting with `unknown`.
+     */
+    serviceAccountEndpoint(stored, body) {
+        const current = stored.agent.serviceAccount;
+        if (!current) {
+            return failure(409, 'assistant-service-account-not-used');
+        }
+        const request = body;
+        if (request === undefined || (request.actorId !== null && request.actorId !== undefined && typeof request.actorId !== 'string')) {
+            return validationFailure();
+        }
+        const actorId = typeof request.actorId === 'string' && request.actorId.trim().length > 0 ? request.actorId.trim() : null;
+        if (actorId !== null && (actorId.length > 256 || actorId.startsWith('unknown'))) {
+            return actorId.length > 256 ? validationFailure() : failure(400, 'assistant-service-account-not-found');
+        }
+        const reason = typeof request.reason === 'string' && request.reason.trim().length > 0 ? request.reason.trim() : null;
+        if (reason !== null && reason.length > maxStateReason) {
+            return validationFailure();
+        }
+        const overridden = actorId !== null;
+        if ((current.overridden ? current.actorId : null) !== actorId) {
+            stored.agent = {
+                ...stored.agent,
+                serviceAccount: {
+                    ...current,
+                    actorId: actorId ?? current.configuredActorId,
+                    overridden,
+                    changedAt: this.now(),
+                    changedBy: 'current-user',
+                    reason
+                }
+            };
+        }
+        return { status: 200, body: toAgentState(stored.agent) };
+    }
     /**
      * `GET` and `POST admin/agents/{id}/state`. The mock runs no agents on their own, so a pause
      * collects no waiting events and a stop cancels no runs; the version never changes.
@@ -631,7 +1271,42 @@ class NhAssistantMockAdmin {
             stateReason: previous?.stateReason ?? null,
             waitingInputs: previous?.waitingInputs ?? 0,
             skills: previous?.skills ?? [],
-            shadowOf: previous?.shadowOf ?? null
+            shadowOf: previous?.shadowOf ?? null,
+            shadow: previous?.shadow ?? shadowState(false, false, null, false),
+            serviceAccount: previous?.serviceAccount ?? null
+        };
+    }
+    /**
+     * A skill defined as data shows among the agent's skills as a skill in shadow by default, as the
+     * server shows it; removing it takes its state along.
+     */
+    setDataSkill(agentId, skillId, description) {
+        const stored = this.agents.get(agentId);
+        if (!stored) {
+            return;
+        }
+        const others = (stored.agent.skills ?? []).filter(skill => skill.skillId !== skillId);
+        const existing = (stored.agent.skills ?? []).find(skill => skill.skillId === skillId);
+        stored.agent = {
+            ...stored.agent,
+            skills: description === null
+                ? others
+                : [...others, existing ? { ...existing, description } : {
+                        skillId,
+                        description,
+                        runState: 'active',
+                        changedAt: null,
+                        changedBy: null,
+                        reason: null,
+                        waitingInputs: 0,
+                        toolCallsToday: 0,
+                        tokensToday: 0,
+                        dailyToolCalls: null,
+                        dailyTokens: null,
+                        cancelledRuns: 0,
+                        startedRuns: 0,
+                        shadow: shadowState(true, true, null, stored.agent.shadow?.locked ?? false)
+                    }]
         };
     }
     toServer(stored) {
@@ -668,9 +1343,27 @@ function toAgentState(agent) {
         cancelledRuns: 0,
         startedRuns: 0,
         skills: agent.skills ?? [],
-        shadowOf: agent.shadowOf ?? null
+        shadowOf: agent.shadowOf ?? null,
+        shadow: agent.shadow ?? shadowState(false, false, null, false),
+        serviceAccount: agent.serviceAccount ?? null
     };
 }
+function shadowState(shadow, configured, override, locked) {
+    return { shadow, configured, override, locked, changedAt: null, changedBy: null, reason: null };
+}
+/** A skill's mode after its agent's mode changed: the agent's shadow comes on top of its own. */
+function withAgentShadow(skill, agentShadow) {
+    const own = skill?.override ?? skill?.configured ?? false;
+    return { ...(skill ?? shadowState(false, false, null, false)), shadow: agentShadow || own };
+}
+function shadowRequest(body) {
+    const request = body;
+    if (request?.mode !== 'shadow' && request?.mode !== 'live' && request?.mode !== 'code') {
+        return null;
+    }
+    const reason = typeof request.reason === 'string' && request.reason.trim().length > 0 ? request.reason.trim() : null;
+    return reason !== null && reason.length > maxStateReason ? null : { mode: request.mode, reason };
+}
 function toServerFields(input) {
     return {
         id: input.id,
@@ -796,7 +1489,7 @@ class NhAssistantMockBackend {
      */
     async simulateParticipantTurn(conversationId, person, text) {
         const conversation = this.conversations.get(conversationId);
-        if (!conversation || conversation.status !== 'idle') {
+        if (!conversation || !acceptsMessage(conversation.status)) {
             return;
         }
         this.addMember(conversationId, person, 'participant');
@@ -979,7 +1672,7 @@ class NhAssistantMockBackend {
         if (text.length === 0 || text.length > limit || !request.clientMessageId) {
             return this.empty(400);
         }
-        if (conversation.status !== 'idle') {
+        if (!acceptsMessage(conversation.status)) {
             return this.empty(409);
         }
         // Like the server: an invalid page context is dropped, never a 400.
@@ -1362,6 +2055,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.33", ngImpo
 function delay(milliseconds) {
     return new Promise(resolve => setTimeout(resolve, milliseconds));
 }
+/** Like the server: a new message starts in an idle conversation or after a failed turn. */
+function acceptsMessage(status) {
+    return status === 'idle' || status === 'failed';
+}
 /** Numbers messages in order, as the server does, keeping numbers that are already set. */
 function withSequences(conversation) {
     let next = lastSequence(conversation);