@meshmakers/shared-ui 3.4.1480 → 3.5.0

package/fesm2022/meshmakers-shared-ui-assistant-core.mjs

@@ -0,0 +1,940 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, computed, signal, Injectable, input, ChangeDetectionStrategy, Component, DestroyRef, ViewContainerRef, TemplateRef, Directive } from '@angular/core';
+import { throwError, isObservable, lastValueFrom, Subject, firstValueFrom } from 'rxjs';
+import { Router, NavigationEnd } from '@angular/router';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { BreadCrumbService } from '@meshmakers/shared-services';
+import { filter } from 'rxjs/operators';
+
+const DEFAULT_ASSISTANT_MESSAGES = {
+    title: 'Assistant',
+    readsWithYourPermissions: 'Reads with your permissions',
+    closeAssistant: 'Close assistant',
+    contextLabel: 'Context sent with your message',
+    removeContext: 'Remove context {label}',
+    notAvailable: 'Assistant not available',
+    notConnected: 'Assistant backend not available yet',
+    commandsLabel: 'Commands',
+    composerLabel: 'Message the assistant',
+    composerPlaceholder: 'Ask something or type / for commands…',
+    send: 'Send',
+    stop: 'Stop',
+    greeting: 'Hi! How can I help?',
+    thinking: 'Thinking…',
+    conversationLabel: 'Conversation',
+    youPrefix: 'You: ',
+    assistantPrefix: 'Assistant: ',
+    errorPrefix: 'Error: ',
+    slashCommandPrefix: 'Command: ',
+    slashCommandFailed: 'The command {command} could not be run.',
+    proposalLabel: 'Proposal: {title}',
+    proposal: 'Proposal',
+    writesToTenant: 'writes to the tenant',
+    tool: 'Tool',
+    runsAfterConfirm: 'runs only after you confirm',
+    run: 'Run',
+    edit: 'Edit',
+    discard: 'Discard',
+    runRequested: 'Run requested',
+    editRequested: 'Edit requested',
+    discarded: 'Discarded',
+    contextTenant: 'Tenant: {tenant}',
+    contextPage: 'Page: {page}',
+    sessions: 'Chats',
+    newChat: 'New chat',
+    sessionsLabel: 'Saved chats',
+    noSessions: 'No saved chats yet',
+    backToChat: 'Back to the chat',
+    deleteSession: 'Delete chat {title}',
+    deleteSessionConfirm: 'Delete “{title}”?',
+    delete: 'Delete',
+    cancel: 'Cancel',
+    sessionLoadFailed: 'The chat could not be opened.',
+    sessionDeleteFailed: 'The chat could not be deleted.',
+    attachFile: 'Attach file',
+    attachmentsLabel: 'Attached files',
+    removeAttachment: 'Remove attachment {name}',
+    attachmentWrongType: '{name} is not an accepted file type.',
+    attachmentTooLarge: '{name} is larger than {max}.',
+    attachmentTooMany: 'At most {max} file(s) per message.',
+    startersTitle: 'Try asking',
+    resizePanel: 'Resize assistant panel',
+};
+/** App-wide translations of the assistant (partial). */
+const ASSISTANT_MESSAGES = new InjectionToken('ASSISTANT_MESSAGES');
+/** Merges overrides over {@link DEFAULT_ASSISTANT_MESSAGES}, later sources winning; null/undefined members are ignored. */
+function resolveAssistantMessages(...overrides) {
+    const resolved = { ...DEFAULT_ASSISTANT_MESSAGES };
+    for (const messages of overrides) {
+        if (!messages) {
+            continue;
+        }
+        for (const key of Object.keys(messages)) {
+            const value = messages[key];
+            if (value !== undefined && value !== null) {
+                resolved[key] = value;
+            }
+        }
+    }
+    return resolved;
+}
+/** Replaces `{name}` placeholders; unknown placeholders stay as they are. */
+function formatAssistantMessage(message, values) {
+    return message.replace(/\{(\w+)\}/g, (match, key) => Object.prototype.hasOwnProperty.call(values, key) ? String(values[key]) : match);
+}
+/** The settled label of a proposal decision. */
+function proposalDecisionLabel(kind, messages) {
+    switch (kind) {
+        case 'run': return messages.runRequested;
+        case 'edit': return messages.editRequested;
+        case 'discard': return messages.discarded;
+    }
+}
+/**
+ * {@link ASSISTANT_MESSAGES} merged with a component input (the input wins).
+ * Call it in an injection context.
+ * @internal
+ */
+function assistantMessages(input) {
+    const injected = inject(ASSISTANT_MESSAGES, { optional: true });
+    return computed(() => resolveAssistantMessages(injected, input()));
+}
+
+/** The (English) text the panel shows while no backend exists. */
+const ASSISTANT_NOT_CONNECTED_MESSAGE = DEFAULT_ASSISTANT_MESSAGES.notConnected;
+/**
+ * The default {@link AssistantTransport}: it is never `ready`, so the composer
+ * cannot send, and it never produces an answer. It exists so the panel can say
+ * honestly that there is no assistant backend (AB#5550) instead of faking one.
+ * The message follows `ASSISTANT_MESSAGES.notConnected`.
+ */
+class NotConnectedAssistantTransport {
+    message = resolveAssistantMessages(inject(ASSISTANT_MESSAGES, { optional: true })).notConnected;
+    status = signal('unavailable').asReadonly();
+    statusMessage = signal(this.message).asReadonly();
+    send(_request) {
+        return throwError(() => new Error(this.message));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NotConnectedAssistantTransport, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NotConnectedAssistantTransport, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: NotConnectedAssistantTransport, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * Default renderer of a tool call in the thread: tool name in mono plus its status.
+ * Replace it through `ASSISTANT_TOOL_CALL_COMPONENT`.
+ */
+class AssistantToolCallRowComponent {
+    call = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "call" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: AssistantToolCallRowComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.1.5", type: AssistantToolCallRowComponent, isStandalone: true, selector: "mm-assistant-tool-call-row", inputs: { call: { classPropertyName: "call", publicName: "call", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: '<span class="tool-name">{{ call().toolName }}</span> <span class="tool-status">{{ call().status }}</span>', isInline: true, styles: [":host{display:inline-flex;gap:var(--theme-space-2, 8px);align-items:baseline}.tool-name{font-family:var(--theme-font-mono, monospace)}.tool-status{color:var(--theme-text-secondary)}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: AssistantToolCallRowComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'mm-assistant-tool-call-row', template: '<span class="tool-name">{{ call().toolName }}</span> <span class="tool-status">{{ call().status }}</span>', changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:inline-flex;gap:var(--theme-space-2, 8px);align-items:baseline}.tool-name{font-family:var(--theme-font-mono, monospace)}.tool-status{color:var(--theme-text-secondary)}\n"] }]
+        }], propDecorators: { call: [{ type: i0.Input, args: [{ isSignal: true, alias: "call", required: true }] }] } });
+
+/**
+ * The single feature flag of the assistant (ui-concept §5.3, AB#5549).
+ * **Off by default.** While it is off nothing assistant-related renders or binds:
+ * no top-bar ✦ button, no Cmd/Ctrl+J, no "✦ Explain" affordances, and the command
+ * palette's `?` scope only shows "Assistant not available".
+ *
+ * Enable it for a host with `{ provide: ASSISTANT_ENABLED, useValue: true }`. The host gates its
+ * own affordances (top-bar toggle, Cmd/Ctrl+J, palette row) on `AssistantService.enabled`.
+ * Turning it on without a real {@link ASSISTANT_TRANSPORT} shows the panel with an
+ * honest "Assistant backend not available yet" state — never canned answers.
+ */
+const ASSISTANT_ENABLED = new InjectionToken('ASSISTANT_ENABLED', {
+    providedIn: 'root',
+    factory: () => false
+});
+/**
+ * The component that renders one tool call in the thread. It must have a `call` input taking an
+ * {@link AssistantToolCall}. Default: a compact name + status row. An OctoMesh host passes
+ * `AiToolCallComponent` of `@meshmakers/octo-ai-console` (collapsible details):
+ * `{ provide: ASSISTANT_TOOL_CALL_COMPONENT, useValue: AiToolCallComponent }`.
+ */
+const ASSISTANT_TOOL_CALL_COMPONENT = new InjectionToken('ASSISTANT_TOOL_CALL_COMPONENT', {
+    providedIn: 'root',
+    factory: () => AssistantToolCallRowComponent
+});
+const ASSISTANT_PAGE_CONTEXT = new InjectionToken('ASSISTANT_PAGE_CONTEXT');
+/** The assistant's transport; defaults to the honest "not connected" one. */
+const ASSISTANT_TRANSPORT = new InjectionToken('ASSISTANT_TRANSPORT', {
+    providedIn: 'root',
+    factory: () => inject(NotConnectedAssistantTransport)
+});
+/** The default slash commands (English descriptions). */
+const DEFAULT_ASSISTANT_SLASH_COMMANDS = [
+    { command: '/explain', description: 'Explain the object in context' },
+    { command: '/query', description: 'Turn a question into a query' },
+    { command: '/summarise', description: 'Summarise events or a selection' },
+    { command: '/draft-pipeline', description: 'Draft a pipeline as a diff' }
+];
+/** The composer's slash commands; provide your own list (or translated descriptions) to change them. */
+const ASSISTANT_SLASH_COMMANDS = new InjectionToken('ASSISTANT_SLASH_COMMANDS', {
+    providedIn: 'root',
+    factory: () => DEFAULT_ASSISTANT_SLASH_COMMANDS
+});
+const DEFAULT_ASSISTANT_PANEL_MIN_WIDTH = 320;
+const DEFAULT_ASSISTANT_PANEL_MAX_WIDTH = 720;
+const DEFAULT_ASSISTANT_PANEL_STORAGE_KEY = 'mm-assistant-panel-width';
+/** App-wide {@link AssistantPanelOptions}; optional. */
+const ASSISTANT_PANEL_OPTIONS = new InjectionToken('ASSISTANT_PANEL_OPTIONS');
+
+/** Route params that name the object a page shows (detail pages, editors). */
+const ENTITY_PARAM = /^(rtId|id|[a-zA-Z]+Id|userName)$/;
+/** Params that are scope, not the object. */
+const SCOPE_PARAMS = new Set(['tenantId']);
+/**
+ * Turns the current route into the panel's context chips (ui-concept §5.3):
+ * tenant, page ("Area › Tab", else the breadcrumb) and the selected entity — the
+ * one an Explain entry point named, otherwise the deepest id-like route param
+ * (labelled with the last breadcrumb). Pure, so it is tested without a router.
+ */
+function deriveAssistantContext(source, messages) {
+    const m = resolveAssistantMessages(messages);
+    const params = collectParams(source.root);
+    const chips = [];
+    const tenantId = params.get('tenantId');
+    if (tenantId) {
+        chips.push({ id: `tenant:${tenantId}`, kind: 'tenant', label: formatAssistantMessage(m.contextTenant, { tenant: tenantId }), value: tenantId });
+    }
+    const path = source.url.split('#')[0].split('?')[0];
+    const pageLabel = source.areaText && source.tabText && source.tabText !== source.areaText
+        ? `${source.areaText} › ${source.tabText}`
+        : source.tabText ?? source.areaText ?? source.breadcrumbs[0] ?? null;
+    if (pageLabel && path) {
+        chips.push({ id: `page:${path}`, kind: 'page', label: formatAssistantMessage(m.contextPage, { page: pageLabel }), value: path });
+    }
+    const explicit = source.explicitEntity;
+    if (explicit) {
+        const value = explicit.rtId ?? explicit.ckTypeId ?? explicit.label;
+        chips.push({
+            id: `entity:${value}`, kind: 'entity', label: explicit.label, value,
+            ...(explicit.ckTypeId ? { ckTypeId: explicit.ckTypeId } : {})
+        });
+        return chips;
+    }
+    const entity = [...params.entries()].reverse().find(([name]) => !SCOPE_PARAMS.has(name) && ENTITY_PARAM.test(name));
+    if (entity) {
+        const [, value] = entity;
+        const crumbs = source.breadcrumbs;
+        const label = crumbs.length > 1 ? crumbs[crumbs.length - 1] : value;
+        chips.push({ id: `entity:${value}`, kind: 'entity', label, value });
+    }
+    return chips;
+}
+/** Params from the root to the deepest primary child, in that order (later wins on clashes). */
+function collectParams(root) {
+    const params = new Map();
+    let node = root;
+    while (node) {
+        for (const [name, value] of Object.entries(node.params ?? {})) {
+            if (typeof value === 'string' && value) {
+                params.delete(name);
+                params.set(name, value);
+            }
+        }
+        node = node.firstChild;
+    }
+    return params;
+}
+
+const NO_SESSIONS = signal([]).asReadonly();
+const NO_ACTIVE_SESSION = signal(null).asReadonly();
+/** Awaits a promise or the last value of an observable; an observable that completes empty (e.g. `EMPTY` for a void result) yields `undefined` instead of rejecting. */
+/** `/word rest` → the word (lower-case) and the trimmed rest; anything else → null. */
+function parseSlashCommand(text) {
+    const match = /^(\/[\w-]+)(?:\s+([\s\S]*))?$/.exec(text);
+    return match ? { word: match[1].toLowerCase(), args: (match[2] ?? '').trim() } : null;
+}
+function settle(result) {
+    return isObservable(result) ? lastValueFrom(result, { defaultValue: undefined }) : result;
+}
+/**
+ * State and entry points of the assistant panel (ui-concept §5.3, AB#5549).
+ *
+ * - **Flag.** Everything is gated by {@link ASSISTANT_ENABLED} (off by default):
+ *   while it is off every entry point is a no-op that returns `false`, and the
+ *   service does not even listen to the router.
+ * - **Entry points.** {@link open} (top-bar ✦, Cmd/Ctrl+J, palette `?` scope),
+ *   {@link requestExplain} ("✦ Explain <object>", AB#5545/5547), {@link toggle}.
+ *   They open the panel with a prefilled composer and context; they never send.
+ * - **Thread.** Survives closing the panel and navigating. Items only come from the
+ *   {@link ASSISTANT_TRANSPORT}; the default transport is not connected, so the
+ *   library itself never adds an assistant turn.
+ * - **Context.** Tenant (route param `tenantId`), page (`ASSISTANT_PAGE_CONTEXT`, else the first
+ *   breadcrumb of shared-services' `BreadCrumbService`) and entity chips; see {@link deriveAssistantContext}.
+ * - **Proposals.** Run / Edit / Discard are published on {@link proposalDecisions$}
+ *   and nothing else — executing a write is the backend's confirm round-trip (AB#5550).
+ * - **Optional transport capabilities (AB#5621).** Sessions ({@link sessionsSupported},
+ *   {@link openSession}, {@link deleteSession}, {@link newThread}), file attachments
+ *   ({@link attachments}, {@link draftFiles}) and starter questions ({@link starterQuestions}) are
+ *   only offered when the transport implements them; otherwise they are inert.
+ * - **Slash commands (AB#5621).** A command of `ASSISTANT_SLASH_COMMANDS` with `expand` is sent as
+ *   the prompt it returns; see {@link send}.
+ */
+class AssistantService {
+    /** The feature flag. Read it to gate any assistant affordance. */
+    enabled = inject(ASSISTANT_ENABLED);
+    transport = inject(ASSISTANT_TRANSPORT);
+    router = inject(Router);
+    destroyRef = inject(DestroyRef);
+    /** Only resolved while enabled: a disabled assistant binds nothing. */
+    pageContext = null;
+    messages = inject(ASSISTANT_MESSAGES, { optional: true });
+    slashCommands = inject(ASSISTANT_SLASH_COMMANDS);
+    _isOpen = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_isOpen" }] : /* istanbul ignore next */ []));
+    _draft = signal('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_draft" }] : /* istanbul ignore next */ []));
+    _focusRequest = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_focusRequest" }] : /* istanbul ignore next */ []));
+    _explicitEntity = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_explicitEntity" }] : /* istanbul ignore next */ []));
+    _removedChips = signal(new Set(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_removedChips" }] : /* istanbul ignore next */ []));
+    _thread = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_thread" }] : /* istanbul ignore next */ []));
+    _sending = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_sending" }] : /* istanbul ignore next */ []));
+    _draftFiles = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_draftFiles" }] : /* istanbul ignore next */ []));
+    _starterQuestions = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_starterQuestions" }] : /* istanbul ignore next */ []));
+    starterRequest = 0;
+    /** Bumped by every thread switch (open session, new chat, loadThread); stale session loads are dropped. */
+    threadGeneration = 0;
+    _routeTick = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_routeTick" }] : /* istanbul ignore next */ []));
+    _breadcrumbs = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_breadcrumbs" }] : /* istanbul ignore next */ []));
+    decisions = new Subject();
+    returnFocusTo = null;
+    pending = null;
+    itemCounter = 0;
+    /** Bumped by {@link stop}: an async slash-command expansion that resolves later is dropped. */
+    expansionGeneration = 0;
+    /** Whether the panel is shown. */
+    isOpen = this._isOpen.asReadonly();
+    /** Composer text; prefilled by entry points. */
+    draft = this._draft.asReadonly();
+    /** Bumped whenever an entry point wants the composer focused. */
+    focusRequest = this._focusRequest.asReadonly();
+    /** The rendered thread. */
+    thread = this._thread.asReadonly();
+    /** A turn is streaming. */
+    sending = this._sending.asReadonly();
+    transportStatus = this.transport.status;
+    transportMessage = this.transport.statusMessage;
+    /** The composer may send: the transport is ready and no turn is running. */
+    canSend = computed(() => this.transport.status() === 'ready' && !this._sending(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "canSend" }] : /* istanbul ignore next */ []));
+    /** The transport has saved sessions (`sessions` + `loadSession`): the panel shows its chat list. */
+    sessionsSupported = !!this.transport.sessions && typeof this.transport.loadSession === 'function';
+    /** Saved sessions can be deleted (`deleteSession`). */
+    sessionDeleteSupported = this.sessionsSupported && typeof this.transport.deleteSession === 'function';
+    /** Saved sessions of the transport (empty without session support). */
+    sessions = this.transport.sessions ?? NO_SESSIONS;
+    /** The session the next send writes to (`null` = fresh chat or no session support). */
+    activeSessionId = this.transport.activeSessionId ?? NO_ACTIVE_SESSION;
+    /** Accepted attachments, or `null` when the transport takes no files (no attach UI). */
+    attachments = this.transport.attachments ?? null;
+    /** Files attached in the composer; sent and cleared with the next turn. */
+    draftFiles = this._draftFiles.asReadonly();
+    /** Starter questions for an empty thread (see {@link loadStarterQuestions}). */
+    starterQuestions = this._starterQuestions.asReadonly();
+    /** Context of the current page minus the chips the person removed. */
+    contextChips = computed(() => {
+        this._routeTick();
+        const removed = this._removedChips();
+        return deriveAssistantContext({
+            root: this.router.routerState?.snapshot?.root,
+            url: this.router.url ?? '',
+            breadcrumbs: this._breadcrumbs(),
+            areaText: this.pageContext?.areaText() ?? null,
+            tabText: this.pageContext?.tabText() ?? null,
+            explicitEntity: this._explicitEntity()
+        }, this.messages).filter(chip => !removed.has(chip.id));
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "contextChips" }] : /* istanbul ignore next */ []));
+    /** Run / Edit / Discard on proposal cards. Only emitted, never executed here. */
+    proposalDecisions$ = this.decisions.asObservable();
+    constructor() {
+        if (!this.enabled) {
+            return;
+        }
+        this.pageContext = inject(ASSISTANT_PAGE_CONTEXT, { optional: true });
+        inject(BreadCrumbService).breadCrumbItems.pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(items => this._breadcrumbs.set(items.map(item => item.text ?? '').filter(text => text.length > 0)));
+        this.router.events.pipe(filter(event => event instanceof NavigationEnd), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            // An explicit Explain target belongs to the page it was requested on.
+            this._explicitEntity.set(null);
+            this._routeTick.update(tick => tick + 1);
+        });
+        this.destroyRef.onDestroy(() => this.pending?.unsubscribe());
+    }
+    /** Opens the panel (or re-focuses it) with an optional prefill. Returns false while disabled. */
+    open(request = {}) {
+        if (!this.enabled) {
+            return false;
+        }
+        if (!this._isOpen()) {
+            const active = document.activeElement;
+            this.returnFocusTo = active instanceof HTMLElement && active !== document.body ? active : null;
+        }
+        if (request.entity) {
+            this._explicitEntity.set(request.entity);
+            this._removedChips.update(removed => removed.size ? new Set() : removed);
+        }
+        if (request.prompt !== undefined) {
+            this._draft.set(request.prompt);
+        }
+        this._isOpen.set(true);
+        this._focusRequest.update(count => count + 1);
+        return true;
+    }
+    /** "✦ Explain <object>": opens the panel with `/explain <label>` and the object as context chip. */
+    requestExplain(target) {
+        return this.open({ prompt: target.prompt ?? `/explain ${target.label}`, entity: target });
+    }
+    /** Hides the panel and gives focus back to where it was (the ✦ button if that is gone). */
+    close() {
+        if (!this._isOpen()) {
+            return;
+        }
+        this._isOpen.set(false);
+        const target = this.returnFocusTo?.isConnected
+            ? this.returnFocusTo
+            : document.querySelector('[data-assistant-toggle]');
+        this.returnFocusTo = null;
+        target?.focus();
+    }
+    /**
+     * Forgets an open panel without moving focus — the host calls it when the
+     * panel can no longer be shown (tenant left or denied, connection lost), so it
+     * does not pop up again later with a stale return-focus target.
+     */
+    dismiss() {
+        this._isOpen.set(false);
+        this.returnFocusTo = null;
+    }
+    /** Opens when closed, closes when open. Returns false while disabled. */
+    toggle() {
+        if (!this.enabled) {
+            return false;
+        }
+        if (this._isOpen()) {
+            this.close();
+        }
+        else {
+            this.open();
+        }
+        return true;
+    }
+    setDraft(text) {
+        this._draft.set(text);
+    }
+    /** Replaces the attached files (ignored while the transport takes no files). */
+    setDraftFiles(files) {
+        if (this.attachments) {
+            this._draftFiles.set([...files]);
+        }
+    }
+    /**
+     * Asks the transport for its starter questions (the panel calls it when it opens).
+     * No-op without `starterQuestions`; a failing source leaves the list empty. Of an observable
+     * only the first emitted value counts (it need not complete); one that completes empty yields none.
+     */
+    loadStarterQuestions() {
+        const source = this.transport.starterQuestions;
+        if (!this.enabled || typeof source !== 'function') {
+            return;
+        }
+        const request = ++this.starterRequest;
+        const accept = (questions) => {
+            if (request === this.starterRequest) {
+                this._starterQuestions.set((questions ?? []).filter(q => typeof q === 'string' && q.trim().length > 0));
+            }
+        };
+        try {
+            const result = source.call(this.transport);
+            if (Array.isArray(result)) {
+                accept(result);
+            }
+            else if (isObservable(result)) {
+                // The first emitted value counts, so a never-completing source (BehaviorSubject, signal stream) works too.
+                firstValueFrom(result, { defaultValue: [] }).then(accept, () => accept([]));
+            }
+            else {
+                result.then(accept, () => accept([]));
+            }
+        }
+        catch {
+            accept([]);
+        }
+    }
+    /** Reloads the transport's session list. Resolves false without session support or on failure. */
+    async refreshSessions() {
+        if (!this.enabled || !this.sessionsSupported || typeof this.transport.refreshSessions !== 'function') {
+            return false;
+        }
+        try {
+            await settle(this.transport.refreshSessions());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Opens a saved session: stops a running turn, asks the transport for the session's thread and
+     * shows it. On failure the current thread stays and an error row is added. Resolves whether the
+     * session was opened.
+     */
+    async openSession(id) {
+        if (!this.enabled || !this.sessionsSupported) {
+            return false;
+        }
+        this.stop();
+        const generation = ++this.threadGeneration;
+        try {
+            const items = await settle(this.transport.loadSession(id));
+            if (generation !== this.threadGeneration) {
+                // Another session was opened (or a new chat started) meanwhile: that one wins.
+                return false;
+            }
+            this.loadThread(items ?? []);
+            return true;
+        }
+        catch {
+            if (generation === this.threadGeneration) {
+                this.append({ kind: 'error', id: this.nextId('error'), text: resolveAssistantMessages(this.messages).sessionLoadFailed });
+            }
+            return false;
+        }
+    }
+    /**
+     * Deletes a saved session; deleting the active one leaves an empty thread. On failure an error
+     * row is added. Resolves whether it was deleted.
+     */
+    async deleteSession(id) {
+        if (!this.enabled || !this.sessionDeleteSupported) {
+            return false;
+        }
+        const wasActive = this.activeSessionId() === id;
+        const generation = this.threadGeneration;
+        try {
+            await settle(this.transport.deleteSession(id));
+        }
+        catch {
+            this.append({ kind: 'error', id: this.nextId('error'), text: resolveAssistantMessages(this.messages).sessionDeleteFailed });
+            return false;
+        }
+        // Only clear when the thread still shows the deleted session (no switch while deleting).
+        if (wasActive && generation === this.threadGeneration) {
+            this.stop();
+            this.threadGeneration += 1;
+            this._thread.set([]);
+        }
+        return true;
+    }
+    /**
+     * Starts a fresh chat: stops a running turn, empties the thread and the attached files and tells
+     * the transport (`newSession`, when it has one). Works without session support too.
+     */
+    newThread() {
+        if (!this.enabled) {
+            return;
+        }
+        this.stop();
+        this.threadGeneration += 1;
+        this._thread.set([]);
+        this._draftFiles.set([]);
+        this.transport.newSession?.();
+        this.loadStarterQuestions();
+    }
+    /** Replaces the thread, e.g. with a conversation the host restored itself. Stops a running turn. */
+    loadThread(items) {
+        if (!this.enabled) {
+            return;
+        }
+        this.stop();
+        this.threadGeneration += 1;
+        this._thread.set([...items]);
+    }
+    /** Drops a context chip; it stays dropped until its value changes. */
+    removeChip(id) {
+        this._removedChips.update(removed => new Set(removed).add(id));
+    }
+    /**
+     * Sends one user turn through the transport. Does nothing (returns false) unless
+     * the transport is `ready` — the default transport never is.
+     *
+     * With a transport that takes attachments, `files` (default: {@link draftFiles}) go along and
+     * the text may be empty; the attached files are cleared with the draft. Explicitly passed `files`
+     * are not checked again against {@link attachments} (`accept`, `maxFiles`, `maxFileSizeBytes`) —
+     * the composer validates on pick; a host passing files itself is responsible for them.
+     *
+     * **Slash commands (AB#5621).** When the text is `<command> [args]` and that command of
+     * `ASSISTANT_SLASH_COMMANDS` has `expand`, its result is sent instead and shown as the user turn,
+     * with the typed text as `slashCommand` (label in the thread, also on the send request). A
+     * promise-returning `expand` makes the turn start once it resolves (the composer is busy and Stop
+     * cancels meanwhile); returns true when the expansion started. If `expand` throws, rejects or yields
+     * an empty prompt, nothing is sent: an error row is added and the draft (text and files) comes back.
+     */
+    send(text, files) {
+        const trimmed = text.trim();
+        const attached = this.attachments ? [...(files ?? this._draftFiles())] : [];
+        if (!this.enabled || (!trimmed && !attached.length) || !this.canSend()) {
+            return false;
+        }
+        const parsed = parseSlashCommand(trimmed);
+        const command = parsed ? this.slashCommands.find(c => c.command.toLowerCase() === parsed.word && typeof c.expand === 'function') : undefined;
+        if (!parsed || !command) {
+            this._draft.set('');
+            this._draftFiles.set([]);
+            this.startTurn(trimmed, attached);
+            return true;
+        }
+        const restoreDraft = () => {
+            if (!this._draft()) {
+                this._draft.set(text);
+            }
+            if (this.attachments && !this._draftFiles().length) {
+                this._draftFiles.set(attached);
+            }
+        };
+        const fail = () => {
+            this.append({
+                kind: 'error', id: this.nextId('error'),
+                text: formatAssistantMessage(resolveAssistantMessages(this.messages).slashCommandFailed, { command: command.command })
+            });
+            restoreDraft();
+        };
+        const accept = (prompt) => {
+            const expanded = typeof prompt === 'string' ? prompt.trim() : '';
+            if (!expanded) {
+                fail();
+                return false;
+            }
+            this.startTurn(expanded, attached, trimmed);
+            return true;
+        };
+        let result;
+        try {
+            result = command.expand(command.command, parsed.args);
+        }
+        catch {
+            fail();
+            return false;
+        }
+        this._draft.set('');
+        this._draftFiles.set([]);
+        if (typeof result === 'string' || !result || typeof result.then !== 'function') {
+            return accept(result);
+        }
+        // Async: busy until the prompt is there; stop() (or a thread switch) drops it.
+        const generation = ++this.expansionGeneration;
+        this._sending.set(true);
+        result.then(prompt => {
+            if (generation === this.expansionGeneration) {
+                this._sending.set(false);
+                accept(prompt);
+            }
+        }, () => {
+            if (generation === this.expansionGeneration) {
+                this._sending.set(false);
+                fail();
+            }
+        });
+        return true;
+    }
+    /** Stops the running turn (the composer's stop button), including a pending slash-command expansion. */
+    stop() {
+        this.expansionGeneration += 1;
+        this.pending?.unsubscribe();
+        this.finishTurn();
+    }
+    /**
+     * Records a decision on a proposal card and publishes it on
+     * {@link proposalDecisions$}. Run and Discard settle the card; Edit leaves it open.
+     * Nothing is executed here.
+     */
+    decideProposal(kind, proposal) {
+        if (kind !== 'edit') {
+            this._thread.update(items => items.map(item => item.kind === 'proposal' && item.proposal.id === proposal.id ? { ...item, decision: kind } : item));
+        }
+        this.decisions.next({ kind, proposal });
+    }
+    /** Appends the user turn and streams the transport's answer. */
+    startTurn(text, attached, slashCommand) {
+        const user = { kind: 'user', id: this.nextId('user'), text };
+        if (attached.length) {
+            user.attachments = attached.map(file => ({ name: file.name, size: file.size }));
+        }
+        if (slashCommand !== undefined) {
+            user.slashCommand = slashCommand;
+        }
+        this.append(user);
+        this._sending.set(true);
+        const request = { text, context: this.contextChips() };
+        if (attached.length) {
+            request.files = attached;
+        }
+        if (slashCommand !== undefined) {
+            request.slashCommand = slashCommand;
+        }
+        this.pending = this.transport.send(request).subscribe({
+            next: event => this.apply(event),
+            error: (error) => {
+                this.append({ kind: 'error', id: this.nextId('error'), text: error instanceof Error ? error.message : String(error) });
+                this.finishTurn();
+            },
+            complete: () => this.finishTurn()
+        });
+    }
+    apply(event) {
+        switch (event.type) {
+            case 'message-delta': {
+                const id = `assistant:${event.messageId}`;
+                const existing = this._thread().find(item => item.id === id);
+                if (existing?.kind === 'assistant') {
+                    this._thread.update(items => items.map(item => item.id === id && item.kind === 'assistant' ? { ...item, markdown: item.markdown + event.text } : item));
+                }
+                else {
+                    this.append({ kind: 'assistant', id, markdown: event.text, streaming: true });
+                }
+                break;
+            }
+            case 'message-end':
+                this.endMessage(`assistant:${event.messageId}`);
+                break;
+            case 'tool-call': {
+                const id = `tool:${event.call.callId}`;
+                if (this._thread().some(item => item.id === id)) {
+                    this._thread.update(items => items.map(item => item.id === id ? { ...item, call: event.call } : item));
+                }
+                else {
+                    this.append({ kind: 'tool-call', id, call: event.call });
+                }
+                break;
+            }
+            case 'proposal':
+                this.append({ kind: 'proposal', id: `proposal:${event.proposal.id}`, proposal: event.proposal, decision: null });
+                break;
+            case 'error':
+                this.append({ kind: 'error', id: this.nextId('error'), text: event.message });
+                break;
+        }
+    }
+    finishTurn() {
+        this.pending = null;
+        this._sending.set(false);
+        this._thread.update(items => items.map(item => item.kind === 'assistant' && item.streaming ? { ...item, streaming: false } : item));
+    }
+    endMessage(id) {
+        this._thread.update(items => items.map(item => item.id === id && item.kind === 'assistant' ? { ...item, streaming: false } : item));
+    }
+    append(item) {
+        this._thread.update(items => [...items, item]);
+    }
+    nextId(prefix) {
+        this.itemCounter += 1;
+        return `${prefix}:${this.itemCounter}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: AssistantService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: AssistantService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: AssistantService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+/**
+ * Cmd+J (macOS) / Ctrl+J toggles the assistant panel (ui-concept §4.3), also
+ * from text fields — it types nothing. Events another handler consumed and
+ * IME composition are ignored.
+ */
+function assistantHotkey(event) {
+    return !event.defaultPrevented && !event.isComposing && event.key?.toLowerCase() === 'j'
+        && (event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey;
+}
+
+/**
+ * Test double for {@link AssistantTransport} (specs only — never provided by the app).
+ * Each `send` returns a Subject the spec drives with `emit` / `complete`.
+ */
+class FakeAssistantTransport {
+    status = signal('ready', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+    statusMessage = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "statusMessage" }] : /* istanbul ignore next */ []));
+    requests = [];
+    turn = null;
+    send(request) {
+        this.requests.push(request);
+        this.turn = new Subject();
+        return this.turn.asObservable();
+    }
+    emit(event) {
+        this.turn?.next(event);
+    }
+    fail(error) {
+        this.turn?.error(error);
+    }
+    complete() {
+        this.turn?.complete();
+    }
+}
+
+/** "512 B", "1.5 KB", "10 MB" — for the size-limit message. */
+function formatAssistantFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    const units = ['KB', 'MB', 'GB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${Number.isInteger(value) ? value : value.toFixed(1)} ${units[unit]}`;
+}
+/**
+ * Whether a file matches an `accept` list (`<input accept>` syntax: MIME types, `type/*`
+ * wildcards and `.ext` extensions, comma separated). An empty list accepts everything.
+ */
+function assistantFileAccepted(file, accept) {
+    const patterns = (accept ?? '').split(',').map(p => p.trim().toLowerCase()).filter(p => p.length > 0);
+    if (!patterns.length) {
+        return true;
+    }
+    const name = file.name.toLowerCase();
+    const type = (file.type ?? '').toLowerCase();
+    return patterns.some(pattern => {
+        if (pattern.startsWith('.')) {
+            return name.endsWith(pattern);
+        }
+        if (pattern.endsWith('/*')) {
+            return type.startsWith(pattern.slice(0, -1));
+        }
+        return type === pattern;
+    });
+}
+/**
+ * Adds newly picked files to the already attached ones, enforcing the transport's
+ * {@link AssistantAttachmentOptions}: wrong type and too large files are rejected individually,
+ * files beyond `maxFiles` (default 1) are dropped with one "too many" message. With
+ * `maxFiles: 1` a newly picked valid file replaces the attached one. Pure.
+ */
+function selectAssistantAttachments(current, added, options, messages) {
+    const maxFiles = Math.max(1, options.maxFiles ?? 1);
+    let files = [...current];
+    if (maxFiles === 1 && added.length === 1) {
+        files = [];
+    }
+    const errors = [];
+    let tooMany = false;
+    for (const file of added) {
+        if (!assistantFileAccepted(file, options.accept)) {
+            errors.push(formatAssistantMessage(messages.attachmentWrongType, { name: file.name }));
+        }
+        else if (options.maxFileSizeBytes !== undefined && file.size > options.maxFileSizeBytes) {
+            errors.push(formatAssistantMessage(messages.attachmentTooLarge, { name: file.name, max: formatAssistantFileSize(options.maxFileSizeBytes) }));
+        }
+        else if (files.length >= maxFiles) {
+            tooMany = true;
+        }
+        else {
+            files.push(file);
+        }
+    }
+    if (maxFiles === 1 && added.length === 1 && !files.length) {
+        files = [...current];
+    }
+    if (tooMany) {
+        errors.push(formatAssistantMessage(messages.attachmentTooMany, { max: maxFiles }));
+    }
+    return { files, errors };
+}
+
+/**
+ * Renders its template only while the assistant is enabled — with the flag off
+ * the element is not in the DOM at all. Use it on every AI affordance:
+ *
+ * ```html
+ * <button *mmIfAssistant type="button" class="ai-action"
+ *         [mmAssistantExplain]="{ label: adapter.name, rtId: adapter.rtId, ckTypeId: 'System.Communication/Adapter' }">
+ *   ✦ Explain
+ * </button>
+ * ```
+ */
+class IfAssistantDirective {
+    constructor() {
+        if (inject(AssistantService).enabled) {
+            inject(ViewContainerRef).createEmbeddedView(inject(TemplateRef));
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: IfAssistantDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.5", type: IfAssistantDirective, isStandalone: true, selector: "[mmIfAssistant]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: IfAssistantDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[mmIfAssistant]' }]
+        }], ctorParameters: () => [] });
+/**
+ * "✦ Explain <object>" entry point (ui-concept §5.4): a click opens the assistant
+ * panel with `/explain <label>` in the composer and the object as context chip.
+ * Nothing is sent. Pair it with {@link IfAssistantDirective} so the trigger does
+ * not exist while the assistant is disabled; code without a template (a
+ * `CommandItem.onClick`) calls `AssistantService.requestExplain()` instead.
+ */
+class AssistantExplainDirective {
+    assistant = inject(AssistantService);
+    target = input.required({ ...(ngDevMode ? { debugName: "target" } : /* istanbul ignore next */ {}), alias: 'mmAssistantExplain' });
+    explain() {
+        this.assistant.requestExplain(this.target());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: AssistantExplainDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.5", type: AssistantExplainDirective, isStandalone: true, selector: "[mmAssistantExplain]", inputs: { target: { classPropertyName: "target", publicName: "mmAssistantExplain", isSignal: true, isRequired: true, transformFunction: null } }, host: { listeners: { "click": "explain()" }, properties: { "attr.aria-controls": "assistant.isOpen() ? \"assistant-panel\" : null" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.5", ngImport: i0, type: AssistantExplainDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mmAssistantExplain]',
+                    host: {
+                        '(click)': 'explain()',
+                        '[attr.aria-controls]': 'assistant.isOpen() ? "assistant-panel" : null'
+                    }
+                }]
+        }], propDecorators: { target: [{ type: i0.Input, args: [{ isSignal: true, alias: "mmAssistantExplain", required: true }] }] } });
+
+/*
+ * Public API Surface of @meshmakers/shared-ui/assistant-core (AB#5621)
+ */
+/**
+ * The startup part of the assistant: state ({@link AssistantService}), the Cmd/Ctrl+J hotkey,
+ * the injection tokens with their defaults, the "not connected" transport, models, messages and the
+ * "✦ Explain" directives. It never imports `marked` or the panel, so a host can wire the assistant
+ * in `app.config.ts` / its root component without pulling the panel into the initial bundle and load
+ * `AssistantPanelComponent` from `@meshmakers/shared-ui/assistant` lazily (e.g. with `@defer`).
+ *
+ * `@meshmakers/shared-ui/assistant` re-exports everything from here (same symbols, same tokens),
+ * so both entry points can be mixed freely.
+ */
+// --- Contract and tokens ---
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ASSISTANT_ENABLED, ASSISTANT_MESSAGES, ASSISTANT_NOT_CONNECTED_MESSAGE, ASSISTANT_PAGE_CONTEXT, ASSISTANT_PANEL_OPTIONS, ASSISTANT_SLASH_COMMANDS, ASSISTANT_TOOL_CALL_COMPONENT, ASSISTANT_TRANSPORT, AssistantExplainDirective, AssistantService, AssistantToolCallRowComponent, DEFAULT_ASSISTANT_MESSAGES, DEFAULT_ASSISTANT_PANEL_MAX_WIDTH, DEFAULT_ASSISTANT_PANEL_MIN_WIDTH, DEFAULT_ASSISTANT_PANEL_STORAGE_KEY, DEFAULT_ASSISTANT_SLASH_COMMANDS, FakeAssistantTransport, IfAssistantDirective, NotConnectedAssistantTransport, assistantFileAccepted, assistantHotkey, assistantMessages, deriveAssistantContext, formatAssistantFileSize, formatAssistantMessage, proposalDecisionLabel, resolveAssistantMessages, selectAssistantAttachments };
+//# sourceMappingURL=meshmakers-shared-ui-assistant-core.mjs.map