adminizer 5.0.0-build.2 → 5.0.0-build.21

package/lib/ai-assistant/AiAssistantHandler.js

@@ -3,15 +3,46 @@ import { Adminizer } from '../Adminizer.js';
 export class AiAssistantHandler {
     adminizer;
     models = new Map();
+    owners = new Map();
     history = new Map();
     constructor(adminizer) {
         this.adminizer = adminizer;
     }
-    registerModel(service) {
+    /**
+     * @param owner App name when the model belongs to an app. Models without an
+     * owner belong to the host application and are never removed automatically.
+     */
+    registerModel(service, owner) {
         if (this.models.has(service.id)) {
             Adminizer.log.warn(`AI assistant model with id "${service.id}" is already registered. Overwriting.`);
         }
+        service.attachAdminizer(this.adminizer);
         this.models.set(service.id, service);
+        if (owner) {
+            this.owners.set(service.id, owner);
+        }
+        else {
+            this.owners.delete(service.id);
+        }
+    }
+    /**
+     * @param owner When passed, the model is kept if it is owned by someone
+     * else, so a disabled app never removes another owner's model.
+     */
+    unregisterModel(id, owner) {
+        if (!this.models.has(id)) {
+            return;
+        }
+        if (owner && this.owners.get(id) !== owner) {
+            return;
+        }
+        this.models.delete(id);
+        this.owners.delete(id);
+        for (const key of this.history.keys()) {
+            if (key.endsWith(`:${id}`)) {
+                this.history.delete(key);
+            }
+        }
     }
     getModel(id) {
         return this.models.get(id);
@@ -25,6 +56,9 @@ export class AiAssistantHandler {
     resetHistory(userId, modelId) {
         this.history.delete(this.getSessionKey(userId, modelId));
     }
+    replaceHistory(userId, modelId, history) {
+        this.history.set(this.getSessionKey(userId, modelId), history);
+    }
     async sendMessage(user, modelId, prompt) {
         const service = this.getModel(modelId);
         if (!service) {

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

@@ -0,0 +1,60 @@
+import type { User } from '../../models/User.js';
+import type { Adminizer } from '../Adminizer.js';
+import type { AdminLinkTemplateParam } from '../admin-links/AdminLinkHandler.js';
+export interface AiAssistantAdminLink {
+    id: string;
+    title: string;
+    /** Concrete page, ready for `navigate`. Absent for templates. */
+    link?: string;
+    /** Parametrized page: pass `template` plus `params` to `navigate`. */
+    template?: string;
+    /** Placeholders that must be filled to open a template. */
+    params?: AdminLinkTemplateParam[];
+    description?: string;
+    section?: string;
+}
+/**
+ * A browser capability an AI service may expose as a tool.  The agent emits
+ * `ui.method` with this id; the assistant panel performs the browser action.
+ */
+export interface AiAssistantUiMethod {
+    id: string;
+    title: string;
+    description: string;
+    /** JSON Schema consumed by tool-capable model services. */
+    inputSchema: Record<string, unknown>;
+    /** Built-in browser executor understood by the shared assistant panel. */
+    action: 'navigate' | 'search-admin-links' | string;
+    accessRightsToken?: string;
+}
+/** What the agent may ask to open: a concrete link or a template plus values. */
+export interface AiAssistantNavigationTarget {
+    href?: string;
+    template?: string;
+    params?: Record<string, unknown>;
+}
+export declare class AiAssistantUiMethodHandler {
+    private readonly adminizer;
+    private readonly methods;
+    private readonly owners;
+    constructor(adminizer: Adminizer);
+    register(method: AiAssistantUiMethod, owner?: string): void;
+    unregister(id: string, owner?: string): void;
+    getAvailable(user: User): AiAssistantUiMethod[];
+    /**
+     * 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: User, query?: string): AiAssistantAdminLink[];
+    /**
+     * 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: User, target: AiAssistantNavigationTarget): string;
+    private slug;
+}

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);
+    }
+}