adminizer 5.0.0-build.10 → 5.0.0-build.12

package/index.d.ts

@@ -43,7 +43,15 @@ export * from "./lib/helper/jwt.js";
 export * from "./lib/notifications/AbstractNotificationService.js";
 export * from "./lib/POWCaptcha.js";
 export * from "./lib/ai-assistant/AbstractAiModelService.js";
+export * from "./lib/ai-assistant/AbstractAiConversationHistoryService.js";
 export * from "./lib/ai-assistant/AiAssistantHandler.js";
+export * from "./lib/ai-assistant/AiAgentRunManager.js";
+export * from "./lib/ai-assistant/jsonSafe.js";
+export * from "./lib/ai-assistant/AiAssistantUiMethodHandler.js";
+export * from "./lib/ai-assistant/AiAssistantAgentSkillHandler.js";
+export * from "./lib/admin-links/AdminLinkHandler.js";
+export * from "./helpers/modelResourceHelper.js";
+export * from "./helpers/navigationAccessHelper.js";
 export * from "./lib/DataAccessor.js";
 export * from "./lib/history-actions/AbstractHistoryAdapter.js";
 export * from "./lib/filters/CustomFilterHandler.js";

package/index.js

@@ -43,7 +43,15 @@ export * from "./lib/helper/jwt.js";
 export * from "./lib/notifications/AbstractNotificationService.js";
 export * from "./lib/POWCaptcha.js";
 export * from "./lib/ai-assistant/AbstractAiModelService.js";
+export * from "./lib/ai-assistant/AbstractAiConversationHistoryService.js";
 export * from "./lib/ai-assistant/AiAssistantHandler.js";
+export * from "./lib/ai-assistant/AiAgentRunManager.js";
+export * from "./lib/ai-assistant/jsonSafe.js";
+export * from "./lib/ai-assistant/AiAssistantUiMethodHandler.js";
+export * from "./lib/ai-assistant/AiAssistantAgentSkillHandler.js";
+export * from "./lib/admin-links/AdminLinkHandler.js";
+export * from "./helpers/modelResourceHelper.js";
+export * from "./helpers/navigationAccessHelper.js";
 export * from "./lib/DataAccessor.js";
 export * from "./lib/history-actions/AbstractHistoryAdapter.js";
 export * from "./lib/filters/CustomFilterHandler.js";

package/interfaces/types.d.ts

@@ -70,3 +70,154 @@ export interface AiAssistantModelInfo {
     name: string;
     description?: string;
 }
+/**
+ * Streaming agent contract.
+ *
+ * A model service that only implements `generateReply` stays a plain chat
+ * model; services that also implement the optional agent members below are
+ * driven by the streaming UI (tool calls, reasoning, attachments, per-user
+ * server-side session). See AbstractAiModelService.
+ */
+/** One SSE frame of a run. `type` drives how the UI folds it into the thread. */
+export type AiAgentStreamEvent = {
+    type: 'text.delta' | 'text.done' | 'reasoning.delta' | 'reasoning.done' | 'tool.start' | 'tool.done' | 'tool.error' | 'step.done' | 'turn.done' | 'done' | 'error' | string;
+    [key: string]: unknown;
+};
+export type AiAgentPublish = (event: AiAgentStreamEvent) => void;
+export interface AiAgentTokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+/** One selectable LLM inside an agent service. */
+export interface AiAgentModelOption {
+    id: string;
+    contextWindow: number | null;
+    maxOutputTokens: number | null;
+    vision: boolean;
+    /** Relative spend multiplier (×1 = median-priced model); null if unknown. */
+    costCoefficient: number | null;
+    [key: string]: unknown;
+}
+/** State of the user's server-side agent session. */
+export interface AiAgentSessionMeta {
+    model: string;
+    contextWindow: number;
+    vision: boolean;
+    turns: number;
+    contextTokens: number;
+    totalUsage: AiAgentTokenUsage;
+    [key: string]: unknown;
+}
+/**
+ * Whether the service can talk to its LLM yet. Services that need no
+ * provisioning simply omit `getConnectionStatus()` and are treated as ready.
+ */
+export interface AiAgentConnectionStatus {
+    state: 'ready' | 'registering' | 'waiting_retry' | 'setup_required' | 'error';
+    provider?: string;
+    baseUrl?: string;
+    source?: string | null;
+    nextAttemptAt?: string | null;
+    lastError?: string | null;
+    expiresAt?: string | null;
+    [key: string]: unknown;
+}
+/** States for which an agent can describe its connection screen. */
+export type AiAgentConnectionState = Exclude<AiAgentConnectionStatus['state'], 'ready'>;
+/**
+ * Declarative connection screen supplied by an agent service. The shared panel
+ * owns rendering, while the agent owns its copy, CTA and which status details
+ * are useful to expose.
+ */
+export interface AiAgentConnectionScreen {
+    title?: string;
+    description?: string;
+    icon?: 'spinner' | 'bot' | 'error';
+    action?: {
+        label: string;
+        href: string;
+    };
+    /** Status values the agent wants to render on this screen. */
+    details?: Array<{
+        field: string;
+        label?: string;
+        format?: 'text' | 'local-time';
+        tone?: 'muted' | 'error';
+    }>;
+}
+/** Normalized budget / rate limits of the provider key, when it exposes them. */
+export interface AiAgentLimits {
+    provider: string;
+    supported: boolean;
+    overBudget?: boolean;
+    message?: string;
+    maxBudgetUsd?: number | null;
+    spentUsd?: number | null;
+    remainingBudgetUsd?: number | null;
+    budgetResetAt?: string | null;
+    burstMaxBudgetUsd?: number | null;
+    burstSpentUsd?: number | null;
+    burstRemainingBudgetUsd?: number | null;
+    burstResetAt?: string | null;
+    burstDurationLabel?: string | null;
+    rpmLimit?: number | null;
+    tpmLimit?: number | null;
+    fetchedAt?: string;
+    [key: string]: unknown;
+}
+/**
+ * Copy the panel shows instead of its neutral defaults. `getUiHints(locale)`
+ * receives the admin user's locale, so agents can return localized copy.
+ */
+export interface AiAgentUiHints {
+    title?: string;
+    welcomeHint?: string;
+    composerPlaceholder?: string;
+    suggestions?: string[];
+    /** Setting an operator must fill in before the service can connect. */
+    setupSetting?: string;
+    /** Where to fill it in; rendered as a button on the connection loader. */
+    setupUrl?: string;
+    /**
+     * Per-state pages rendered while this agent is not ready. `default` is
+     * used for any state without its own screen.
+     */
+    connectionScreens?: Partial<Record<AiAgentConnectionState | 'default', AiAgentConnectionScreen>>;
+    [key: string]: unknown;
+}
+/** A browser-side capability which an agent may call through `ui.method`. */
+export interface AiAgentUiMethod {
+    id: string;
+    title: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    action: string;
+    accessRightsToken?: string;
+}
+/** Declarative UI contract consumed by the shared assistant panel. */
+export interface AiAgentUiSchema extends AiAgentUiHints {
+    commands: Array<{
+        id: string;
+        description?: string;
+    }>;
+    uiMethods?: AiAgentUiMethod[];
+    panels: {
+        history: boolean;
+        models: boolean;
+        limits: boolean;
+    };
+}
+/** An uploaded file as handed to the agent service (multer memory storage). */
+export interface AiAgentUploadedFile {
+    originalname: string;
+    mimetype: string;
+    size: number;
+    buffer: Buffer;
+}
+/** What the service reports back about a stored upload, if it stores them. */
+export interface AiAgentSavedFile {
+    id?: string;
+    name?: string;
+    [key: string]: unknown;
+}

package/lib/Adminizer.d.ts

@@ -27,6 +27,9 @@ import { ControllerHandler } from "./app-manager/ControllerHandler.js";
 import { AssetHandler } from "./app-manager/AssetHandler.js";
 import { ConfigLayerHandler } from "./app-manager/ConfigLayerHandler.js";
 import { AccessRightsHandler } from "./access-rights/AccessRightsHandler.js";
+import { AiAssistantUiMethodHandler } from './ai-assistant/AiAssistantUiMethodHandler.js';
+import { AdminLinkHandler } from './admin-links/AdminLinkHandler.js';
+import { AiAssistantAgentSkillHandler } from './ai-assistant/AiAssistantAgentSkillHandler.js';
 export declare function createAdminizerLogger(): winston.Logger;
 export interface EmitAsyncOptions {
     /**
@@ -54,6 +57,9 @@ export declare class Adminizer {
     notificationHandler: NotificationHandler;
     historyHandler: HistoryHandler;
     private _aiAssistantHandler?;
+    aiAssistantUiMethodHandler: AiAssistantUiMethodHandler;
+    adminLinkHandler: AdminLinkHandler;
+    aiAssistantAgentSkillHandler: AiAssistantAgentSkillHandler;
     modelHandler: ModelHandler;
     widgetHandler: WidgetHandler;
     customFilterHandler: CustomFilterHandler;

package/lib/Adminizer.js

@@ -43,6 +43,9 @@ import { ControllerHandler } from "./app-manager/ControllerHandler.js";
 import { AssetHandler } from "./app-manager/AssetHandler.js";
 import { ConfigLayerHandler } from "./app-manager/ConfigLayerHandler.js";
 import { AccessRightsHandler } from "./access-rights/AccessRightsHandler.js";
+import { AiAssistantUiMethodHandler } from './ai-assistant/AiAssistantUiMethodHandler.js';
+import { AdminLinkHandler } from './admin-links/AdminLinkHandler.js';
+import { AiAssistantAgentSkillHandler } from './ai-assistant/AiAssistantAgentSkillHandler.js';
 const logFilePath = "logs/app.log";
 function ensureLogDirectory(filePath) {
     const logDirectory = path.dirname(filePath);
@@ -109,6 +112,9 @@ export class Adminizer {
     notificationHandler;
     historyHandler;
     _aiAssistantHandler;
+    aiAssistantUiMethodHandler;
+    adminLinkHandler;
+    aiAssistantAgentSkillHandler;
     modelHandler;
     widgetHandler;
     customFilterHandler;
@@ -141,6 +147,9 @@ export class Adminizer {
         this.catalogTemplateComponentHandler = new CatalogTemplateComponentHandler();
         this.mediaManagerHandler = new MediaManagerHandler();
         this.feedbackHandler = new FeedbackHandler(this);
+        this.aiAssistantUiMethodHandler = new AiAssistantUiMethodHandler(this);
+        this.adminLinkHandler = new AdminLinkHandler(this);
+        this.aiAssistantAgentSkillHandler = new AiAssistantAgentSkillHandler(this);
         this.controllerHandler = new ControllerHandler(this);
         this.assetHandler = new AssetHandler(this);
         this.configLayerHandler = new ConfigLayerHandler(this);

package/lib/admin-links/AdminLinkHandler.d.ts

@@ -0,0 +1,72 @@
+import type { User } from '../../models/User.js';
+import type { Adminizer } from '../Adminizer.js';
+export interface AdminLink {
+    id: string;
+    type: string;
+    name: string;
+    link: string;
+    title?: string;
+    section?: string;
+    accessRightsToken?: string;
+}
+export interface ResolvedAdminLink extends AdminLink {
+    owner: string;
+    title: string;
+}
+/** A placeholder of an admin link template, e.g. `id` in `/model/Test/edit/:id`. */
+export interface AdminLinkTemplateParam {
+    name: string;
+    description?: string;
+}
+/**
+ * A parametrized admin page, e.g. `/admin/model/Test/edit/:id`. Templates are
+ * what makes a record page reachable: the concrete URL only exists once the
+ * caller knows the record id.
+ */
+export interface AdminLinkTemplate {
+    id: string;
+    title: string;
+    /** Absolute admin path with `:param` placeholders. */
+    template: string;
+    description?: string;
+    section?: string;
+    accessRightsToken?: string;
+    /** Placeholder descriptions; placeholders absent here are still required. */
+    params?: AdminLinkTemplateParam[];
+}
+export interface ResolvedAdminLinkTemplate extends AdminLinkTemplate {
+    owner: string;
+    params: AdminLinkTemplateParam[];
+}
+/** Server-side registry of standalone admin pages contributed by applications. */
+export declare class AdminLinkHandler {
+    private readonly adminizer;
+    private readonly links;
+    private readonly templates;
+    constructor(adminizer: Adminizer);
+    add(link: AdminLink, owner?: string): string;
+    remove(id: string, owner?: string): boolean;
+    list(user: User, type?: string): ResolvedAdminLink[];
+    resolve(user: User, type: string, name: string): ResolvedAdminLink | undefined;
+    addTemplate(template: AdminLinkTemplate, owner?: string): string;
+    removeTemplate(id: string, owner?: string): boolean;
+    /**
+     * Every parametrized page this user may open: model record pages, catalog
+     * items, templates registered by apps and any navigation link that carries
+     * placeholders of its own.
+     */
+    listTemplates(user: User): ResolvedAdminLinkTemplate[];
+    /**
+     * Turns a template id (or its title) plus placeholder values into a real
+     * admin URL, rejecting templates this user may not open.
+     */
+    resolveTemplate(user: User, id: string, params?: Record<string, unknown>): string;
+    /** Fills the placeholders of a template with url-encoded values. */
+    buildHref(template: ResolvedAdminLinkTemplate, params?: Record<string, unknown>): string;
+    /** True for paths that change data and therefore must never be navigated to. */
+    isDestructivePath(path: string): boolean;
+    /** Templates derived from the current configuration, catalogs and navigation. */
+    private builtinTemplates;
+    private describeParams;
+    private slug;
+}

package/lib/admin-links/AdminLinkHandler.js

@@ -0,0 +1,175 @@
+/** Segments no template may point at: opening one mutates data. */
+const DESTRUCTIVE_PATH = /\/model\/[^/]+\/remove(\/|$)/i;
+/** Server-side registry of standalone admin pages contributed by applications. */
+export class AdminLinkHandler {
+    adminizer;
+    links = new Map();
+    templates = new Map();
+    constructor(adminizer) {
+        this.adminizer = adminizer;
+    }
+    add(link, owner = 'host') {
+        const type = link.type.trim();
+        const name = link.name.trim();
+        const href = link.link.trim();
+        if (!type || !name || !href)
+            throw new Error('Admin link requires type, name and link');
+        if (!href.startsWith('/'))
+            throw new Error(`Admin link "${name}" must use an absolute admin path`);
+        const id = `${this.slug(type)}:${this.slug(name)}`;
+        if (this.links.has(id))
+            throw new Error(`Admin link "${id}" is already registered`);
+        this.links.set(id, {
+            ...link, id, type, name, link: href, owner,
+            title: link.title?.trim() || name,
+            section: link.section?.trim() || undefined,
+        });
+        return id;
+    }
+    remove(id, owner) {
+        const link = this.links.get(id);
+        if (!link || (owner && link.owner !== owner))
+            return false;
+        return this.links.delete(id);
+    }
+    list(user, type) {
+        const wanted = type ? this.slug(type) : null;
+        return [...this.links.values()].filter((link) => (!wanted || this.slug(link.type) === wanted)
+            && (!link.accessRightsToken || this.adminizer.accessRightsHelper.hasPermission(link.accessRightsToken, user)));
+    }
+    resolve(user, type, name) {
+        const wanted = this.slug(name);
+        return this.list(user, type).find((link) => this.slug(link.name) === wanted || this.slug(link.title) === wanted);
+    }
+    addTemplate(template, owner = 'host') {
+        const id = template.id.trim();
+        const title = template.title.trim();
+        const path = template.template.trim();
+        if (!id || !title || !path)
+            throw new Error('Admin link template requires id, title and template');
+        if (!path.startsWith('/'))
+            throw new Error(`Admin link template "${id}" must use an absolute admin path`);
+        if (this.templates.has(id))
+            throw new Error(`Admin link template "${id}" is already registered`);
+        this.templates.set(id, {
+            ...template, id, title, template: path, owner,
+            description: template.description?.trim() || undefined,
+            section: template.section?.trim() || undefined,
+            params: this.describeParams(path, template.params),
+        });
+        return id;
+    }
+    removeTemplate(id, owner) {
+        const template = this.templates.get(id);
+        if (!template || (owner && template.owner !== owner))
+            return false;
+        return this.templates.delete(id);
+    }
+    /**
+     * Every parametrized page this user may open: model record pages, catalog
+     * items, templates registered by apps and any navigation link that carries
+     * placeholders of its own.
+     */
+    listTemplates(user) {
+        const templates = [];
+        const push = (template) => {
+            if (DESTRUCTIVE_PATH.test(template.template))
+                return;
+            if (template.accessRightsToken && !this.adminizer.accessRightsHelper.hasPermission(template.accessRightsToken, user))
+                return;
+            if (templates.some((existing) => existing.template === template.template || existing.id === template.id))
+                return;
+            templates.push(template);
+        };
+        for (const template of this.builtinTemplates(user))
+            push(template);
+        for (const template of this.templates.values())
+            push(template);
+        return templates;
+    }
+    /**
+     * Turns a template id (or its title) plus placeholder values into a real
+     * admin URL, rejecting templates this user may not open.
+     */
+    resolveTemplate(user, id, params = {}) {
+        const wanted = this.slug(id);
+        const available = this.listTemplates(user);
+        const template = available.find((candidate) => this.slug(candidate.id) === wanted)
+            ?? available.find((candidate) => this.slug(candidate.title) === wanted || this.slug(candidate.template) === wanted);
+        if (!template)
+            throw new Error(`Admin link template "${id}" is not available`);
+        return this.buildHref(template, params);
+    }
+    /** Fills the placeholders of a template with url-encoded values. */
+    buildHref(template, params = {}) {
+        return template.template.replace(/:([A-Za-z0-9_]+)/g, (_match, name) => {
+            const value = params[name];
+            if (value === undefined || value === null || value === '') {
+                throw new Error(`Admin link template "${template.id}" requires the "${name}" parameter`);
+            }
+            return encodeURIComponent(String(value));
+        });
+    }
+    /** True for paths that change data and therefore must never be navigated to. */
+    isDestructivePath(path) {
+        return DESTRUCTIVE_PATH.test(path);
+    }
+    /** Templates derived from the current configuration, catalogs and navigation. */
+    builtinTemplates(user) {
+        const prefix = (this.adminizer.config.routePrefix || '').replace(/\/+$/, '');
+        const templates = [];
+        const builtin = (id, title, path, accessRightsToken, description, section, params = []) => {
+            templates.push({
+                id, title, template: path, accessRightsToken, description, section, owner: 'host',
+                params: this.describeParams(path, params),
+            });
+        };
+        const recordId = [
+            { name: 'id', description: 'Identifier of the record, as returned when reading its data.' },
+        ];
+        for (const [model, config] of Object.entries(this.adminizer.config.models ?? {})) {
+            const title = typeof config === 'object' && config?.title ? config.title : model;
+            const section = typeof config === 'object' ? config?.navbar?.section : undefined;
+            builtin(`model-${model}-edit`, `${title}: open record`, `${prefix}/model/${model}/edit/:id`, `update-${model}-model`, `Open the edit page of a single ${title} record by its id.`, section, recordId);
+            builtin(`model-${model}-add`, `${title}: create record`, `${prefix}/model/${model}/add`, `create-${model}-model`, `Open the create form of ${title}.`, section);
+        }
+        for (const catalog of this.adminizer.catalogHandler.getAll()) {
+            if (!catalog?.slug)
+                continue;
+            builtin(`catalog-${catalog.slug}-item`, `${catalog.name || catalog.slug}: open item`, `${prefix}/catalog/${catalog.slug}/:id`, `catalog-${catalog.slug}`, `Open a single item of the ${catalog.name || catalog.slug} catalog by its id.`, undefined, recordId);
+        }
+        // Navigation links may carry placeholders themselves (app pages, custom
+        // tools). Such a link cannot be opened as-is, so it is a template.
+        const fromNavigation = (item, section) => {
+            const path = typeof item?.link === 'string' ? item.link : '';
+            if (path.startsWith('/') && /:[A-Za-z0-9_]+/.test(path) && item.title) {
+                templates.push({
+                    id: `link-${this.slug(String(item.id || item.title))}`,
+                    title: String(item.title),
+                    template: path,
+                    section: item.section || section,
+                    accessRightsToken: item.accessRightsToken || undefined,
+                    owner: 'host',
+                    params: this.describeParams(path),
+                });
+            }
+            for (const child of item?.actions ?? item?.subItems ?? [])
+                fromNavigation(child, item?.section || section);
+        };
+        for (const item of this.adminizer.menuHelper.getMenuItems(user))
+            fromNavigation(item, item.section);
+        for (const link of this.links.values())
+            fromNavigation(link, link.section);
+        return templates;
+    }
+    describeParams(path, described = []) {
+        const names = [...path.matchAll(/:([A-Za-z0-9_]+)/g)].map((match) => match[1]);
+        return [...new Set(names)].map((name) => ({
+            name,
+            description: described.find((param) => param.name === name)?.description,
+        }));
+    }
+    slug(value) {
+        return String(value).trim().toLowerCase().replace(/[\s_-]+/g, '-');
+    }
+}

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

@@ -0,0 +1,39 @@
+import type { Adminizer } from '../Adminizer.js';
+import type { AbstractAiModelService } from './AbstractAiModelService.js';
+import type { User } from '../../models/User.js';
+export interface AiConversation {
+    id: string;
+    title: string;
+    createdAt: string;
+    updatedAt: string;
+    messages: Array<Record<string, unknown>>;
+}
+/**
+ * Storage contract for an agent's dialogs. Applications can extend this class
+ * to persist conversations in their own database instead of process memory.
+ */
+export declare abstract class AbstractAiConversationHistoryService {
+    protected agent: AbstractAiModelService;
+    protected adminizer: Adminizer;
+    initialize(agent: AbstractAiModelService, adminizer: Adminizer): void;
+    abstract list(user: User): AiConversation[];
+    abstract getActive(user: User): AiConversation;
+    abstract create(user: User, title?: string): AiConversation;
+    abstract select(user: User, conversationId: string): AiConversation | undefined;
+    abstract remove(user: User, conversationId: string): boolean;
+    abstract saveActive(user: User, messages: Array<Record<string, unknown>>, title?: string): AiConversation;
+}
+/** Default storage used when an agent does not provide a database-backed one. */
+export declare class InMemoryAiConversationHistoryService extends AbstractAiConversationHistoryService {
+    private readonly conversations;
+    private readonly activeConversationIds;
+    list(user: User): AiConversation[];
+    getActive(user: User): AiConversation;
+    create(user: User, title?: string): AiConversation;
+    select(user: User, conversationId: string): AiConversation | undefined;
+    remove(user: User, conversationId: string): boolean;
+    saveActive(user: User, messages: Array<Record<string, unknown>>, title?: string): AiConversation;
+    private getConversations;
+    private getKey;
+    private findFirstUserText;
+}

package/lib/ai-assistant/AbstractAiConversationHistoryService.js

@@ -0,0 +1,98 @@
+/**
+ * Storage contract for an agent's dialogs. Applications can extend this class
+ * to persist conversations in their own database instead of process memory.
+ */
+export class AbstractAiConversationHistoryService {
+    agent;
+    adminizer;
+    initialize(agent, adminizer) {
+        this.agent = agent;
+        this.adminizer = adminizer;
+    }
+}
+/** Default storage used when an agent does not provide a database-backed one. */
+export class InMemoryAiConversationHistoryService extends AbstractAiConversationHistoryService {
+    conversations = new Map();
+    activeConversationIds = new Map();
+    list(user) {
+        return [...this.getConversations(user)]
+            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    }
+    getActive(user) {
+        const key = this.getKey(user);
+        const conversations = this.getConversations(user);
+        const activeId = this.activeConversationIds.get(key);
+        const active = conversations.find((conversation) => conversation.id === activeId);
+        if (active)
+            return active;
+        const conversation = this.create(user);
+        this.activeConversationIds.set(key, conversation.id);
+        return conversation;
+    }
+    create(user, title = 'New conversation') {
+        const now = new Date().toISOString();
+        const conversation = {
+            id: `conversation-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+            title,
+            createdAt: now,
+            updatedAt: now,
+            messages: [],
+        };
+        this.getConversations(user).push(conversation);
+        this.activeConversationIds.set(this.getKey(user), conversation.id);
+        return conversation;
+    }
+    select(user, conversationId) {
+        const conversation = this.getConversations(user).find((item) => item.id === conversationId);
+        if (conversation)
+            this.activeConversationIds.set(this.getKey(user), conversation.id);
+        return conversation;
+    }
+    remove(user, conversationId) {
+        const conversations = this.getConversations(user);
+        const index = conversations.findIndex((conversation) => conversation.id === conversationId);
+        if (index < 0)
+            return false;
+        conversations.splice(index, 1);
+        if (this.activeConversationIds.get(this.getKey(user)) === conversationId) {
+            this.activeConversationIds.delete(this.getKey(user));
+        }
+        return true;
+    }
+    saveActive(user, messages, title) {
+        const conversation = this.getActive(user);
+        conversation.messages = messages;
+        conversation.updatedAt = new Date().toISOString();
+        if (title)
+            conversation.title = title;
+        else if (conversation.title === 'New conversation') {
+            const firstText = this.findFirstUserText(messages);
+            if (firstText)
+                conversation.title = firstText.slice(0, 80);
+        }
+        return conversation;
+    }
+    getConversations(user) {
+        const key = this.getKey(user);
+        let conversations = this.conversations.get(key);
+        if (!conversations) {
+            conversations = [];
+            this.conversations.set(key, conversations);
+        }
+        return conversations;
+    }
+    getKey(user) {
+        return `${user.id}:${this.agent.id}`;
+    }
+    findFirstUserText(messages) {
+        const message = messages.find((item) => item.role === 'user');
+        const content = message?.content;
+        if (typeof content === 'string')
+            return content.trim();
+        if (Array.isArray(content)) {
+            const text = content.find((part) => part && typeof part === 'object' && part.type === 'text');
+            return typeof text?.text === 'string' ? text.text.trim() : undefined;
+        }
+        return undefined;
+    }
+}