adminizer 5.0.0-build.11 → 5.0.0-build.13

package/lib/ai-assistant/AiAssistantUiMethodHandler.js

@@ -0,0 +1,138 @@
+import { listAccessibleMenuItems } from '../../helpers/navigationAccessHelper.js';
+export class AiAssistantUiMethodHandler {
+    adminizer;
+    methods = new Map();
+    owners = new Map();
+    constructor(adminizer) {
+        this.adminizer = adminizer;
+        this.register({
+            id: 'navigate',
+            title: 'Open admin section',
+            description: 'Open an Adminizer page in the current browser tab using the Inertia router.'
+                + ' Pass `href` for a concrete link, or `template` plus `params` for a parametrized page'
+                + ' such as a single record. Both come from search-admin-links.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    href: { type: 'string', description: 'Adminizer-relative URL of a concrete page to open.' },
+                    template: { type: 'string', description: 'Id of a link template returned by search-admin-links.' },
+                    params: {
+                        type: 'object',
+                        description: 'Values for the template placeholders, e.g. {"id": "3860d321-…"}.',
+                        additionalProperties: { type: 'string' },
+                    },
+                },
+                additionalProperties: false,
+            },
+            action: 'navigate',
+        });
+        this.register({
+            id: 'search-admin-links',
+            title: 'Search admin sections and links',
+            description: 'Search the current user\'s accessible Adminizer navigation sections, links and'
+                + ' link templates (record pages, catalog items and other parametrized pages).',
+            inputSchema: {
+                type: 'object',
+                properties: { query: { type: 'string', description: 'Words to search in section, link and template titles.' } },
+                required: ['query'], additionalProperties: false,
+            },
+            action: 'search-admin-links',
+        });
+    }
+    register(method, owner) {
+        const id = method.id.trim().toLowerCase();
+        if (!/^[a-z][a-z0-9_-]*$/.test(id))
+            throw new Error(`Invalid AI assistant UI method id: ${method.id}`);
+        if (!method.title.trim() || !method.description.trim())
+            throw new Error(`AI assistant UI method "${id}" requires title and description`);
+        this.methods.set(id, { ...method, id });
+        if (owner)
+            this.owners.set(id, owner);
+        else
+            this.owners.delete(id);
+    }
+    unregister(id, owner) {
+        const normalized = id.trim().toLowerCase();
+        if (owner && this.owners.get(normalized) !== owner)
+            return;
+        this.methods.delete(normalized);
+        this.owners.delete(normalized);
+    }
+    getAvailable(user) {
+        return [...this.methods.values()]
+            .filter((method) => !method.accessRightsToken || this.adminizer.accessRightsHelper.hasPermission(method.accessRightsToken, user))
+            .map((method) => ({ ...method, inputSchema: { ...method.inputSchema } }));
+    }
+    /**
+     * Search exactly the navigation a user can open.  This intentionally uses
+     * MenuHelper rather than client-side markup, therefore a tool result is
+     * permission-safe and works when the assistant panel is not visible.
+     *
+     * Parametrized pages are returned as templates, so a record page is
+     * reachable even though its URL only exists once the id is known.
+     */
+    searchAdminLinks(user, query = '') {
+        const needle = this.slug(query);
+        const result = [];
+        const matches = (...values) => !needle || this.slug(values.filter(Boolean).join(' ')).includes(needle);
+        const add = (item, section) => {
+            if (!item?.link || !item?.title)
+                return;
+            const link = {
+                id: String(item.id || item.title), title: String(item.title), link: String(item.link),
+                section: item.section || section,
+            };
+            // A link with placeholders is surfaced as a template instead.
+            if (!/:[A-Za-z0-9_]+/.test(link.link) && matches(link.title, link.id, link.section))
+                result.push(link);
+            for (const child of item.actions ?? item.subItems ?? [])
+                add(child, link.section);
+        };
+        // Exactly the menu the sidebar renders for this user, sub-items included.
+        for (const item of listAccessibleMenuItems(this.adminizer, user))
+            add(item, item.section);
+        for (const template of this.adminizer.adminLinkHandler.listTemplates(user)) {
+            if (!matches(template.title, template.id, template.section, template.description, template.template))
+                continue;
+            result.push({
+                id: template.id,
+                title: template.title,
+                template: template.template,
+                params: template.params,
+                description: template.description,
+                section: template.section,
+                // A template without placeholders is already a usable link.
+                link: template.params.length ? undefined : template.template,
+            });
+        }
+        return result;
+    }
+    /**
+     * Validates what an agent asked to open and returns the concrete admin URL.
+     * Templates are resolved against this user's own permissions, so the LLM
+     * can only reach pages that user could reach by clicking.
+     */
+    resolveNavigation(user, target) {
+        const template = target.template?.trim();
+        if (template) {
+            return this.adminizer.adminLinkHandler.resolveTemplate(user, template, target.params ?? {});
+        }
+        const href = target.href?.trim();
+        if (!href)
+            throw new Error('Navigation requires either href or template');
+        const prefix = (this.adminizer.config.routePrefix || '').replace(/\/+$/, '');
+        if (href !== prefix && !href.startsWith(`${prefix}/`)) {
+            throw new Error('Only Adminizer-relative links may be opened.');
+        }
+        if (/:[A-Za-z0-9_]+/.test(href)) {
+            throw new Error('This link is a template: pass it as `template` together with `params`.');
+        }
+        if (this.adminizer.adminLinkHandler.isDestructivePath(href)) {
+            throw new Error('This page changes data and cannot be opened by the assistant.');
+        }
+        return href;
+    }
+    slug(value) {
+        return String(value ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '-');
+    }
+}

package/lib/ai-assistant/builtinAgentSkills.d.ts

@@ -0,0 +1,9 @@
+import type { Adminizer } from '../Adminizer.js';
+import type { AiAssistantAgentSkill } from './AiAssistantAgentSkillHandler.js';
+/**
+ * Skills every agent gets for free: who it is talking to, and read/edit access
+ * scoped to exactly the data that user may reach in the admin panel. Because
+ * every call re-checks the user's permissions, an agent built on them can be
+ * offered to non-administrator accounts as well.
+ */
+export declare function buildBuiltinAgentSkills(adminizer: Adminizer): AiAssistantAgentSkill[];

package/lib/ai-assistant/builtinAgentSkills.js

@@ -0,0 +1,256 @@
+import { listModelResources, resolveModelResource } from '../../helpers/modelResourceHelper.js';
+import { listAccessibleMenuItems } from '../../helpers/navigationAccessHelper.js';
+import { DataAccessor } from '../DataAccessor.js';
+import { toJsonSafe } from './jsonSafe.js';
+const MAX_RECORDS = 50;
+const DEFAULT_RECORDS = 10;
+/** What the current user may do with every configured model resource. */
+function listPermittedModels(adminizer, user) {
+    const has = (token) => adminizer.accessRightsHelper.hasPermission(token, user);
+    return listModelResources(adminizer)
+        .map((resource) => ({
+        resource,
+        canRead: has(`read-${resource.name}-model`),
+        canUpdate: has(`update-${resource.name}-model`),
+        canCreate: has(`create-${resource.name}-model`),
+    }))
+        .filter((entry) => entry.canRead || entry.canUpdate);
+}
+/**
+ * Resolves a model this user may use for `action`. Nothing outside the user's
+ * own permissions is reachable, which is what makes these skills safe to hand
+ * to non-administrator accounts.
+ */
+function requireModel(adminizer, user, name, action) {
+    const resource = resolveModelResource(adminizer, name);
+    if (!resource?.model)
+        throw new Error(`Model "${name}" is not available.`);
+    const token = action === 'read' ? `read-${resource.name}-model` : `update-${resource.name}-model`;
+    if (!adminizer.accessRightsHelper.hasPermission(token, user)) {
+        throw new Error(`You are not allowed to ${action} the "${resource.name}" model.`);
+    }
+    return resource;
+}
+function modelNames(adminizer, user, action) {
+    return listPermittedModels(adminizer, user)
+        .filter((entry) => (action === 'read' ? entry.canRead : entry.canUpdate))
+        .map((entry) => entry.resource.name);
+}
+/** Adds an `enum` of permitted models, so the agent cannot invent a model name. */
+function withModelEnum(schema, models) {
+    const properties = { ...schema.properties };
+    properties.model = { ...properties.model, enum: models };
+    return { ...schema, properties };
+}
+function identifierField(adminizer, resource) {
+    return resource.config?.identifierField
+        ?? adminizer.config.identifierField
+        ?? resource.model?.primaryKey
+        ?? 'id';
+}
+function parseCriteria(filter) {
+    if (filter === undefined || filter === null || filter === '')
+        return {};
+    if (typeof filter === 'object')
+        return filter;
+    try {
+        const parsed = JSON.parse(String(filter));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new Error('not an object');
+        return parsed;
+    }
+    catch {
+        throw new Error('filter must be a JSON object, e.g. {"title": "example"}');
+    }
+}
+function pickFields(record, fields) {
+    return Object.fromEntries(fields.filter((field) => field in record).map((field) => [field, record[field]]));
+}
+function slugify(value) {
+    return String(value ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '-');
+}
+/** A navigation entry as the agent sees it: the sub-actions of a menu item. */
+function describeNavigationActions(actions) {
+    return (actions ?? []).map((action) => ({
+        id: action.id || action.title,
+        title: action.title,
+        link: action.link,
+        icon: action.icon || undefined,
+        target: action.type === 'blank' ? 'blank' : undefined,
+        actions: action.subItems?.length ? describeNavigationActions(action.subItems) : undefined,
+    }));
+}
+function describeNavigationItem(item) {
+    return {
+        id: item.id,
+        title: item.title,
+        link: item.link,
+        icon: item.icon || undefined,
+        target: item.type === 'blank' ? 'blank' : undefined,
+        model: item.modelResourceName || undefined,
+        actions: item.actions?.length ? describeNavigationActions(item.actions) : undefined,
+    };
+}
+/** Field names of a model resource that this user may see or write. */
+function fieldNames(adminizer, user, resource, action) {
+    return Object.keys(new DataAccessor(adminizer, user, resource, action).getFieldsConfig());
+}
+/**
+ * Skills every agent gets for free: who it is talking to, and read/edit access
+ * scoped to exactly the data that user may reach in the admin panel. Because
+ * every call re-checks the user's permissions, an agent built on them can be
+ * offered to non-administrator accounts as well.
+ */
+export function buildBuiltinAgentSkills(adminizer) {
+    const currentUser = {
+        id: 'current_user',
+        description: 'Get the admin user this conversation belongs to: login, name, email, locale, groups and administrator flag.',
+        inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        execute: (_input, { userIdentity }) => userIdentity,
+    };
+    const listModels = {
+        id: 'list_data_models',
+        description: 'List the data models the current user may read or edit, with their fields, allowed operations and admin URLs.',
+        inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        execute: (_input, { user }) => ({
+            models: listPermittedModels(adminizer, user).map(({ resource, canRead, canUpdate, canCreate }) => ({
+                name: resource.name,
+                title: resource.config?.title ?? resource.name,
+                canRead,
+                canUpdate,
+                canCreate,
+                identifierField: identifierField(adminizer, resource),
+                listUrl: resource.uri,
+                recordUrlTemplate: canUpdate ? `${resource.uri}/edit/:id` : undefined,
+                fields: fieldNames(adminizer, user, resource, canUpdate ? 'edit' : 'list'),
+            })),
+        }),
+    };
+    const listNavigation = {
+        id: 'list_admin_navigation',
+        description: 'Show the admin panel navigation menu of the current user: sections, their links with sub-actions,'
+            + ' and the templates of parametrized pages such as a single record. Only entries this user may open are returned.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Optional words to filter menu items by title, section or path. Omit to get the whole menu.',
+                },
+            },
+            additionalProperties: false,
+        },
+        execute: (input, { user }) => {
+            const needle = slugify(input.query);
+            const matches = (...values) => !needle || slugify(values.filter(Boolean).join(' ')).includes(needle);
+            const sections = new Map();
+            for (const item of listAccessibleMenuItems(adminizer, user)) {
+                if (!matches(item.title, item.id, item.section, item.link, item.modelResourceName))
+                    continue;
+                const section = item.section || 'Platform';
+                if (!sections.has(section))
+                    sections.set(section, []);
+                sections.get(section).push(describeNavigationItem(item));
+            }
+            return {
+                sections: [...sections].map(([section, items]) => ({ section, items })),
+                // Record and other parametrized pages have no fixed URL, so the
+                // agent gets them as templates to fill in.
+                templates: adminizer.adminLinkHandler.listTemplates(user)
+                    .filter((template) => matches(template.title, template.id, template.section, template.description, template.template))
+                    .map((template) => ({
+                    id: template.id,
+                    title: template.title,
+                    template: template.template,
+                    description: template.description,
+                    section: template.section,
+                    params: template.params,
+                })),
+            };
+        },
+    };
+    const readRecords = {
+        id: 'read_model_records',
+        description: 'Read records of a data model the current user may read.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model: { type: 'string', description: 'Model name as returned by list_data_models.' },
+                filter: { type: 'string', description: 'Optional JSON criteria object, e.g. {"title": "example"}.' },
+                fields: { type: 'array', items: { type: 'string' }, description: 'Optional subset of fields to return.' },
+                limit: {
+                    type: 'integer', minimum: 1, maximum: MAX_RECORDS,
+                    description: `Maximum number of records to return (default ${DEFAULT_RECORDS}).`,
+                },
+            },
+            required: ['model'],
+            additionalProperties: false,
+        },
+        requiresUser: true,
+        describe: (user) => {
+            const models = modelNames(adminizer, user, 'read');
+            return {
+                description: `Read records of a data model the current user may read. Readable models: ${models.join(', ') || 'none'}.`,
+                inputSchema: withModelEnum(readRecords.inputSchema, models),
+            };
+        },
+        execute: async (input, { user }) => {
+            const resource = requireModel(adminizer, user, String(input.model ?? ''), 'read');
+            const criteria = parseCriteria(input.filter);
+            const limit = Math.min(Math.max(Math.trunc(Number(input.limit) || DEFAULT_RECORDS), 1), MAX_RECORDS);
+            const fields = Array.isArray(input.fields) ? input.fields.map(String) : [];
+            const accessor = new DataAccessor(adminizer, user, resource, 'list');
+            const records = await resource.model.find(criteria, accessor);
+            const limited = records.slice(0, limit);
+            return toJsonSafe({
+                model: resource.name,
+                total: records.length,
+                count: limited.length,
+                records: fields.length ? limited.map((record) => pickFields(record, fields)) : limited,
+            });
+        },
+    };
+    const updateRecord = {
+        id: 'update_model_record',
+        description: 'Update one record of a data model the current user may edit.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model: { type: 'string', description: 'Model name as returned by list_data_models.' },
+                id: { type: 'string', description: 'Identifier of the record to update.' },
+                values: {
+                    type: 'object',
+                    description: 'Field values to write, e.g. {"title": "new title"}. Fields this user may not edit are dropped by the panel.',
+                    additionalProperties: true,
+                },
+            },
+            required: ['model', 'id', 'values'],
+            additionalProperties: false,
+        },
+        requiresUser: true,
+        describe: (user) => {
+            const models = modelNames(adminizer, user, 'update');
+            return {
+                description: `Update one record of a data model the current user may edit. Editable models: ${models.join(', ') || 'none'}.`,
+                inputSchema: withModelEnum(updateRecord.inputSchema, models),
+            };
+        },
+        execute: async (input, { user }) => {
+            const resource = requireModel(adminizer, user, String(input.model ?? ''), 'update');
+            const id = String(input.id ?? '').trim();
+            if (!id)
+                throw new Error('id of the record to update is required');
+            const values = input.values && typeof input.values === 'object' && !Array.isArray(input.values)
+                ? input.values
+                : null;
+            if (!values || !Object.keys(values).length)
+                throw new Error('values must be a non-empty object of field values');
+            const accessor = new DataAccessor(adminizer, user, resource, 'edit');
+            const record = await resource.model.updateOne({ [identifierField(adminizer, resource)]: id }, values, accessor);
+            if (!record)
+                throw new Error(`Record "${id}" was not found in "${resource.name}".`);
+            return toJsonSafe({ model: resource.name, id, record });
+        },
+    };
+    return [currentUser, listNavigation, listModels, readRecords, updateRecord];
+}

package/lib/ai-assistant/jsonSafe.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts arbitrary values (ORM records, Dates, Buffers, cyclic graphs) into
+ * plain JSON data.
+ *
+ * Tool results are stored verbatim in the agent's message history and are
+ * re-validated by the AI SDK against its `ModelMessage[]` schema on every
+ * subsequent turn. A single non-JSON value — a `Date` from a Sequelize record,
+ * for example — therefore does not fail the call that produced it: it poisons
+ * the session and every later turn dies with `Invalid prompt: The messages do
+ * not match the ModelMessage[] schema`. Passing tool output through this
+ * helper keeps that class of failure out of the history.
+ */
+export declare function toJsonSafe<T>(value: T): unknown;

package/lib/ai-assistant/jsonSafe.js

@@ -0,0 +1,81 @@
+/**
+ * Converts arbitrary values (ORM records, Dates, Buffers, cyclic graphs) into
+ * plain JSON data.
+ *
+ * Tool results are stored verbatim in the agent's message history and are
+ * re-validated by the AI SDK against its `ModelMessage[]` schema on every
+ * subsequent turn. A single non-JSON value — a `Date` from a Sequelize record,
+ * for example — therefore does not fail the call that produced it: it poisons
+ * the session and every later turn dies with `Invalid prompt: The messages do
+ * not match the ModelMessage[] schema`. Passing tool output through this
+ * helper keeps that class of failure out of the history.
+ */
+const MAX_DEPTH = 12;
+export function toJsonSafe(value) {
+    return convert(value, new WeakSet(), 0);
+}
+function convert(value, seen, depth) {
+    if (value === null)
+        return null;
+    switch (typeof value) {
+        case 'string':
+        case 'boolean':
+            return value;
+        case 'number':
+            return Number.isFinite(value) ? value : null;
+        case 'bigint':
+            return value.toString();
+        case 'undefined':
+        case 'function':
+        case 'symbol':
+            return undefined;
+    }
+    const object = value;
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? null : value.toISOString();
+    if (value instanceof Error)
+        return value.message;
+    if (value instanceof RegExp)
+        return value.toString();
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value))
+        return `<binary ${value.length} bytes>`;
+    if (ArrayBuffer.isView(value))
+        return `<binary ${value.byteLength} bytes>`;
+    if (value instanceof ArrayBuffer)
+        return `<binary ${value.byteLength} bytes>`;
+    if (seen.has(object))
+        return '[Circular]';
+    if (depth >= MAX_DEPTH)
+        return '[MaxDepth]';
+    seen.add(object);
+    try {
+        if (Array.isArray(value)) {
+            // JSON.stringify turns array holes and `undefined` items into null.
+            return value.map((item) => {
+                const converted = convert(item, seen, depth + 1);
+                return converted === undefined ? null : converted;
+            });
+        }
+        if (value instanceof Set)
+            return convert([...value], seen, depth);
+        if (value instanceof Map) {
+            return convert(Object.fromEntries([...value].map(([key, item]) => [String(key), item])), seen, depth);
+        }
+        // Sequelize instances, Decimal, Luxon and friends: let them describe
+        // themselves first, then normalize whatever they produced.
+        const toJSON = value.toJSON;
+        if (typeof toJSON === 'function') {
+            return convert(toJSON.call(value), seen, depth + 1);
+        }
+        const result = {};
+        for (const [key, item] of Object.entries(value)) {
+            const converted = convert(item, seen, depth + 1);
+            if (converted !== undefined)
+                result[key] = converted;
+        }
+        return result;
+    }
+    finally {
+        seen.delete(object);
+    }
+}

package/lib/app-manager/AdminizerApp.d.ts

@@ -8,6 +8,9 @@ import type { Config, ControlType } from "../controls/Control.js";
 import type { User } from "../../models/User.js";
 import type { DataAccessor } from "../DataAccessor.js";
 import type { AbstractAiModelService } from "../ai-assistant/AbstractAiModelService.js";
+import type { AiAssistantUiMethod } from '../ai-assistant/AiAssistantUiMethodHandler.js';
+import type { AdminLink, AdminLinkTemplate } from '../admin-links/AdminLinkHandler.js';
+import type { AiAssistantAgentSkill } from '../ai-assistant/AiAssistantAgentSkillHandler.js';
 export type AppDisposer = () => void | Promise<void>;
 export type AppEventName = string | symbol;
 export type AppEventHandler<TPayload = any> = (payload: TPayload, runtime: AppRuntime) => void | Promise<void>;
@@ -173,10 +176,26 @@ export interface AppAiAssistantContext {
     resolveModelResource(modelName: string): ModelResource | undefined;
     hasPermission(token: string, user: User): boolean;
     createDataAccessor(modelResource: ModelResource, user: User, action: ActionType): DataAccessor;
+    /** UI tools available to this user, including methods registered by apps. */
+    getUiMethods(user: User): AiAssistantUiMethod[];
 }
 export interface AppAiAssistantResource {
     models: Array<(context: AppAiAssistantContext) => AbstractAiModelService | Promise<AbstractAiModelService>>;
 }
+export interface AppAiAssistantUiMethodResource extends AiAssistantUiMethod {
+    id: string;
+}
+export interface AppAiAssistantAgentSkillResource extends AiAssistantAgentSkill {
+}
+/** Skills contributed by an app. UI methods are browser skills; agent skills run on the server. */
+export interface AppSkills {
+    uiMethod(method: AppAiAssistantUiMethodResource): void;
+    agent(skill: AppAiAssistantAgentSkillResource): void;
+}
+export interface AppAdminLinkResource extends AdminLink {
+}
+export interface AppAdminLinkTemplateResource extends AdminLinkTemplate {
+}
 /**
  * Resource registration API provided while an app is being enabled.
  *
@@ -197,6 +216,11 @@ export interface AppSetupContext {
     model(model: AppModelResource): void;
     modelAccess(access: AppModelAccessResource): void;
     aiAssistant(resource: AppAiAssistantResource): void;
+    skills: AppSkills;
+    /** Register a standalone server page in the admin navigation and agent search. */
+    adminLink(link: AppAdminLinkResource): void;
+    /** Register a parametrized page (e.g. `/admin/orders/:id/invoice`) the assistant may open. */
+    adminLinkTemplate(template: AppAdminLinkTemplateResource): void;
     listener(event: AppEventName, handler: AppEventHandler): void;
 }
 /**

package/lib/app-manager/AppManager.js

@@ -1,5 +1,6 @@
 import { Adminizer } from "../Adminizer.js";
 import { DataAccessor } from "../DataAccessor.js";
+import { listModelResources, resolveModelResource } from "../../helpers/modelResourceHelper.js";
 class RuntimeAppSetupContext {
     adminizer;
     appName;
@@ -7,6 +8,8 @@ class RuntimeAppSetupContext {
     pendingModelRegistrations = [];
     pendingModelAccessRegistrations = [];
     pendingAiAssistantRegistrations = [];
+    pendingAiAssistantUiMethodRegistrations = [];
+    pendingAiAssistantAgentSkillRegistrations = [];
     pendingMediaManagerRegistrations = [];
     pendingCatalogRegistrations = [];
     configLayerIndex = 0;
@@ -14,7 +17,12 @@ class RuntimeAppSetupContext {
     constructor(adminizer, appName) {
         this.adminizer = adminizer;
         this.appName = appName;
+        this.skills = {
+            uiMethod: (method) => this.registerAiAssistantUiMethod(method),
+            agent: (skill) => this.registerAiAssistantAgentSkill(skill),
+        };
     }
+    skills;
     asset(asset) {
         const resourceId = `${this.appName}:${asset.id}`;
         const url = this.adminizer.assetHandler.register(this.appName, asset);
@@ -114,6 +122,32 @@ class RuntimeAppSetupContext {
     aiAssistant(resource) {
         this.pendingAiAssistantRegistrations.push(() => this.registerAiAssistant(resource));
     }
+    registerAiAssistantUiMethod(method) {
+        this.pendingAiAssistantUiMethodRegistrations.push(async () => {
+            this.adminizer.aiAssistantUiMethodHandler.register(method, this.appName);
+            this.disposers.push(() => this.adminizer.aiAssistantUiMethodHandler.unregister(method.id, this.appName));
+        });
+    }
+    registerAiAssistantAgentSkill(skill) {
+        this.pendingAiAssistantAgentSkillRegistrations.push(async () => {
+            this.adminizer.aiAssistantAgentSkillHandler.add(skill, this.appName);
+            this.disposers.push(() => {
+                this.adminizer.aiAssistantAgentSkillHandler.remove(skill.id, this.appName);
+            });
+        });
+    }
+    adminLink(link) {
+        const resourceId = this.adminizer.adminLinkHandler.add(link, this.appName);
+        this.disposers.push(() => {
+            this.adminizer.adminLinkHandler.remove(resourceId, this.appName);
+        });
+    }
+    adminLinkTemplate(template) {
+        const resourceId = this.adminizer.adminLinkHandler.addTemplate(template, this.appName);
+        this.disposers.push(() => {
+            this.adminizer.adminLinkHandler.removeTemplate(resourceId, this.appName);
+        });
+    }
     listener(event, handler) {
         const resourceId = `${this.appName}:${event.toString()}:${this.disposers.length + 1}`;
         const listener = (payload) => handler(payload, this.adminizer.appManager.createRuntime(this.appName));
@@ -136,6 +170,8 @@ class RuntimeAppSetupContext {
         await this.runRegistrationPhase(this.pendingModelRegistrations);
         await this.runRegistrationPhase(this.pendingModelAccessRegistrations);
         await this.runRegistrationPhase(this.pendingAiAssistantRegistrations);
+        await this.runRegistrationPhase(this.pendingAiAssistantUiMethodRegistrations);
+        await this.runRegistrationPhase(this.pendingAiAssistantAgentSkillRegistrations);
         await this.runRegistrationPhase(this.pendingMediaManagerRegistrations);
         await this.runRegistrationPhase(this.pendingCatalogRegistrations);
     }
@@ -350,52 +386,13 @@ class RuntimeAppSetupContext {
         return {
             runtime: this.adminizer.appManager.createRuntime(this.appName),
             routePrefix: this.adminizer.config.routePrefix,
-            getModelResources: () => this.getModelResources(),
-            resolveModelResource: (modelName) => this.resolveModelResource(modelName),
+            getModelResources: () => listModelResources(this.adminizer),
+            resolveModelResource: (modelName) => resolveModelResource(this.adminizer, modelName),
             hasPermission: (token, user) => this.adminizer.accessRightsHelper.hasPermission(token, user),
             createDataAccessor: (modelResource, user, action) => new DataAccessor(this.adminizer, user, modelResource, action),
+            getUiMethods: (user) => this.adminizer.aiAssistantUiMethodHandler.getAvailable(user),
         };
     }
-    getModelResources() {
-        const resources = [];
-        for (const [configName, configValue] of Object.entries(this.adminizer.config.models ?? {})) {
-            const normalizedConfig = this.normalizeModelConfig(configName, configValue);
-            const model = this.adminizer.modelHandler.model.get(normalizedConfig.model.toLowerCase());
-            if (!model) {
-                continue;
-            }
-            resources.push({
-                name: configName,
-                uri: `${this.adminizer.config.routePrefix}/model/${configName}`,
-                config: normalizedConfig,
-                model,
-            });
-        }
-        return resources;
-    }
-    resolveModelResource(modelName) {
-        const loweredName = modelName.toLowerCase();
-        return this.getModelResources().find((resource) => {
-            const modelId = resource.config.model?.toLowerCase();
-            return resource.name.toLowerCase() === loweredName || modelId === loweredName;
-        });
-    }
-    normalizeModelConfig(name, config) {
-        const baseConfig = {
-            model: name,
-            icon: "description",
-            title: name,
-            list: true,
-            add: true,
-            edit: true,
-            remove: true,
-            view: true,
-        };
-        if (typeof config === "boolean") {
-            return config ? baseConfig : { ...baseConfig, list: false, add: false, edit: false, remove: false, view: false };
-        }
-        return { ...baseConfig, ...config };
-    }
 }
 export class AppManager {
     adminizer;