@genesislcap/ai-assistant 14.420.0 → 14.421.0

package/dist/esm/components/chat-interaction-wrapper/chat-interaction-wrapper.js

@@ -16,8 +16,8 @@ let AiChatInteractionWrapper = class AiChatInteractionWrapper extends GenesisEle
         this.componentName = '';
         /** @internal */
         this.interactionId = '';
-        /** When true, the interaction has already been resolved. Forwarded to the rendered component. @internal */
-        this.resolved = false;
+        /** The resolved result once the interaction has completed. Forwarded to the rendered component. @internal */
+        this.resolved = undefined;
     }
     connectedCallback() {
         super.connectedCallback();

package/dist/esm/components/chat-markdown/chat-markdown.js

@@ -71,7 +71,7 @@ const styles = css `
 let AiChatMarkdown = class AiChatMarkdown extends GenesisElement {
     constructor() {
         super(...arguments);
-        /** @internal */
+        /** The markdown string to render. */
         this.content = '';
     }
     /** @internal */

package/dist/esm/components/halo-overlay.js

@@ -2,6 +2,10 @@ var AiHaloOverlay_1;
 import { __decorate } from "tslib";
 import { attr, css, customElement, GenesisElement, html } from '@genesislcap/web-core';
 import { AI_COLOUR_AMBER, AI_COLOUR_CYAN, AI_COLOUR_PINK, AI_COLOUR_VIOLET, } from '../styles/ai-colours';
+const HALO_DEFAULT_SPEED = 1.5;
+const HALO_DEFAULT_BORDER_SIZE = 3;
+const HALO_DEFAULT_GLOW_OPACITY = 0.35;
+const HALO_DEFAULT_GLOW_SPREAD = 70;
 /**
  * Animated halo overlay — rotating conic-gradient border with an inward glow.
  *
@@ -19,8 +23,27 @@ let AiHaloOverlay = AiHaloOverlay_1 = class AiHaloOverlay extends GenesisElement
     constructor() {
         super(...arguments);
         this.active = false;
+        /** Rotation speed in degrees per frame. Default: 1.5 (≈ 4 s per full revolution at 60 fps). */
+        this.speed = HALO_DEFAULT_SPEED;
+        /** Rotation direction. Default: 'cw' (clockwise). */
+        this.direction = 'cw';
+        /** Border thickness in px. Default: 3. */
+        this.borderSize = HALO_DEFAULT_BORDER_SIZE;
+        /** Glow layer opacity (0–1). Default: 0.35. */
+        this.glowOpacity = HALO_DEFAULT_GLOW_OPACITY;
+        /** Transparent stop of the radial glow mask as a percentage (0–100). Higher = less spread. Default: 70. */
+        this.glowSpread = HALO_DEFAULT_GLOW_SPREAD;
         this.angle = 0;
     }
+    borderSizeChanged() {
+        this.style.setProperty('--halo-border-size', `${this.borderSize}px`);
+    }
+    glowOpacityChanged() {
+        this.style.setProperty('--halo-glow-opacity', String(this.glowOpacity));
+    }
+    glowSpreadChanged() {
+        this.style.setProperty('--halo-glow-spread', `${this.glowSpread}%`);
+    }
     connectedCallback() {
         super.connectedCallback();
         this.tick();
@@ -32,7 +55,9 @@ let AiHaloOverlay = AiHaloOverlay_1 = class AiHaloOverlay extends GenesisElement
         }
     }
     tick() {
-        this.angle = (this.angle + AiHaloOverlay_1.DEG_PER_FRAME) % AiHaloOverlay_1.FULL_ROTATION_DEG;
+        const step = this.direction === 'ccw' ? -this.speed : this.speed;
+        this.angle =
+            (this.angle + step + AiHaloOverlay_1.FULL_ROTATION_DEG) % AiHaloOverlay_1.FULL_ROTATION_DEG;
         this.style.setProperty('--halo-angle', `${this.angle}deg`);
         this.animFrame = requestAnimationFrame(() => this.tick());
     }
@@ -42,12 +67,25 @@ let AiHaloOverlay = AiHaloOverlay_1 = class AiHaloOverlay extends GenesisElement
 // 2. The loop ticks even when `active` is false (idle cost is negligible but non-zero).
 // Once @property inside Shadow DOM has solid cross-browser support, consider switching back
 // to a CSS @keyframes approach and removing connectedCallback/disconnectedCallback/tick().
-// 1.5° per frame @ 60 fps ≈ 4 s per full revolution
-AiHaloOverlay.DEG_PER_FRAME = 1.5;
 AiHaloOverlay.FULL_ROTATION_DEG = 360;
 __decorate([
     attr({ mode: 'boolean' })
 ], AiHaloOverlay.prototype, "active", void 0);
+__decorate([
+    attr({ converter: { fromView: Number, toView: String } })
+], AiHaloOverlay.prototype, "speed", void 0);
+__decorate([
+    attr
+], AiHaloOverlay.prototype, "direction", void 0);
+__decorate([
+    attr({ attribute: 'border-size', converter: { fromView: Number, toView: String } })
+], AiHaloOverlay.prototype, "borderSize", void 0);
+__decorate([
+    attr({ attribute: 'glow-opacity', converter: { fromView: Number, toView: String } })
+], AiHaloOverlay.prototype, "glowOpacity", void 0);
+__decorate([
+    attr({ attribute: 'glow-spread', converter: { fromView: Number, toView: String } })
+], AiHaloOverlay.prototype, "glowSpread", void 0);
 AiHaloOverlay = AiHaloOverlay_1 = __decorate([
     customElement({
         name: 'ai-halo-overlay',
@@ -76,7 +114,7 @@ AiHaloOverlay = AiHaloOverlay_1 = __decorate([
       position: absolute;
       inset: 0;
       border-radius: inherit;
-      padding: 3px;
+      padding: var(--halo-border-size, 3px);
       background: repeating-conic-gradient(
         from var(--halo-angle, 0deg),
         ${AI_COLOUR_AMBER},
@@ -109,9 +147,17 @@ AiHaloOverlay = AiHaloOverlay_1 = __decorate([
         ${AI_COLOUR_VIOLET},
         ${AI_COLOUR_AMBER}
       );
-      opacity: 0.35;
-      -webkit-mask-image: radial-gradient(ellipse at center, transparent 70%, black 100%);
-      mask-image: radial-gradient(ellipse at center, transparent 70%, black 100%);
+      opacity: var(--halo-glow-opacity, 0.35);
+      -webkit-mask-image: radial-gradient(
+        ellipse at center,
+        transparent var(--halo-glow-spread, 70%),
+        black 100%
+      );
+      mask-image: radial-gradient(
+        ellipse at center,
+        transparent var(--halo-glow-spread, 70%),
+        black 100%
+      );
     }
   `,
     })

package/dist/esm/components/orchestrating-driver/index.js

@@ -0,0 +1 @@
+export { OrchestratingDriver } from './orchestrating-driver';

package/dist/esm/components/orchestrating-driver/orchestrating-driver.js

@@ -0,0 +1,247 @@
+import { __awaiter } from "tslib";
+import { logger } from '../../utils/logger';
+import { ChatDriver, REQUEST_CONTINUATION_TOOL } from '../chat-driver/chat-driver';
+const DEFAULT_MAX_HANDOFFS = 3;
+const DEFAULT_CLASSIFIER_HISTORY_LENGTH = 4;
+const DEFAULT_CLASSIFIER_RETRIES = 2;
+const REQUEST_CONTINUATION_DEFINITION = {
+    name: REQUEST_CONTINUATION_TOOL,
+    description: "Call this when you have completed your part of the task but fulfilling the user's full request requires capabilities outside your domain. Do not call this if you can complete the request yourself. Pass a plain-language description of what still needs to be done — another specialist will be selected automatically.",
+    parameters: {
+        type: 'object',
+        required: ['summary', 'remaining_task'],
+        properties: {
+            summary: {
+                type: 'string',
+                description: 'What you found or did — passed as context to the next specialist.',
+            },
+            remaining_task: {
+                type: 'string',
+                description: 'What still needs to be done, in plain language. Used to route to the right specialist.',
+            },
+        },
+    },
+};
+function isSpecialist(agent) {
+    return !agent.fallback;
+}
+function isFallback(agent) {
+    return agent.fallback === true;
+}
+function buildFallbackSystemPrompt(fallback, specialists) {
+    const agentList = specialists.map((s) => `- ${s.name}: ${s.description}`).join('\n');
+    if (fallback.systemPrompt) {
+        return fallback.systemPrompt.replace('{{agents}}', agentList);
+    }
+    return `You are a helpful assistant. You cannot directly help with the user's request, but the following specialists are available:\n\n${agentList}\n\nPolitely let the user know what you can help with and invite them to rephrase their request.`;
+}
+/**
+ * Prepares history for the LLM only: masks tool call args and results from other
+ * agents so the active specialist is not confused by tools it does not have.
+ * Canonical history in `ChatDriver` stays unmasked for UI and logging.
+ */
+function transformHistoryForAgent(history, agentName) {
+    return history.map((msg) => {
+        var _a;
+        if (!msg.agentName || msg.agentName === agentName)
+            return msg;
+        if ((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length) {
+            return Object.assign(Object.assign({}, msg), { toolCalls: msg.toolCalls.map((tc) => (Object.assign(Object.assign({}, tc), { args: {} }))) });
+        }
+        if (msg.toolResult) {
+            return Object.assign(Object.assign({}, msg), { toolResult: Object.assign(Object.assign({}, msg.toolResult), { content: "[other agent's tool result omitted]" }) });
+        }
+        return msg;
+    });
+}
+/**
+ * Orchestrates multiple specialist agents. Sits between `FoundationAiAssistant`
+ * and `ChatDriver`, classifying each user message and routing it to the right
+ * specialist — each with its own focused system prompt, tools, and primer.
+ *
+ * @beta
+ */
+export class OrchestratingDriver extends EventTarget {
+    constructor(aiProvider, agents, options = {}) {
+        var _a, _b, _c;
+        super();
+        this.aiProvider = aiProvider;
+        this.agents = agents;
+        this.maxHandoffs = (_a = options.maxHandoffs) !== null && _a !== void 0 ? _a : DEFAULT_MAX_HANDOFFS;
+        this.classifierHistoryLength =
+            (_b = options.classifierHistoryLength) !== null && _b !== void 0 ? _b : DEFAULT_CLASSIFIER_HISTORY_LENGTH;
+        this.classifierRetries = (_c = options.classifierRetries) !== null && _c !== void 0 ? _c : DEFAULT_CLASSIFIER_RETRIES;
+        this.specialists = agents.filter(isSpecialist);
+        const fallbacks = agents.filter(isFallback);
+        if (fallbacks.length > 1) {
+            logger.warn('OrchestratingDriver: multiple fallback agents found — only the first will be used.');
+        }
+        const rawFallback = fallbacks[0];
+        this.fallback = rawFallback
+            ? Object.assign(Object.assign({}, rawFallback), { systemPrompt: buildFallbackSystemPrompt(rawFallback, this.specialists) }) : undefined;
+        this.chatDriver = new ChatDriver(aiProvider, {}, [], undefined, undefined, options.maxToolIterations, options.maxFoldOperations);
+        // Proxy history-updated events from the shared driver
+        this.chatDriver.addEventListener('history-updated', (e) => {
+            this.dispatchEvent(new CustomEvent('history-updated', { detail: e.detail }));
+        });
+    }
+    resolveInteraction(interactionId, result) {
+        this.chatDriver.resolveInteraction(interactionId, result);
+    }
+    isBusy() {
+        return this.chatDriver.isBusy();
+    }
+    loadHistory(messages) {
+        this.chatDriver.loadHistory(messages);
+    }
+    getRawHistory() {
+        return this.chatDriver.getHistory();
+    }
+    getSuggestions(history, prompt, count, allAgentInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const agentInfo = this.specialists.map((s) => {
+                var _a;
+                return ({
+                    name: s.name,
+                    description: s.description,
+                    tools: (_a = s.toolDefinitions) !== null && _a !== void 0 ? _a : [],
+                });
+            });
+            return this.chatDriver.getSuggestions(history, prompt, count, agentInfo);
+        });
+    }
+    sendMessage(input, attachments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const history = this.chatDriver.getHistory();
+            // Emit the user message immediately so the UI reflects it during the classify
+            // round-trip — without this the chat appears frozen until classify returns.
+            this.dispatchEvent(new CustomEvent('history-updated', {
+                detail: [...history, { role: 'user', content: input, attachments }],
+            }));
+            this.dispatchEvent(new CustomEvent('orchestrating-start'));
+            let currentAgent = yield this.classify(input, history);
+            let isHandoff = false;
+            let handoffs = 0;
+            let handoffSummary = '';
+            let remainingTask = '';
+            while (true) {
+                this.applyAgent(currentAgent);
+                let result;
+                if (isHandoff) {
+                    const contextPrimer = handoffSummary
+                        ? [{ role: 'user', content: `[Context from previous agent]: ${handoffSummary}` }]
+                        : [];
+                    // eslint-disable-next-line no-await-in-loop
+                    result = yield this.chatDriver.continueFromHistory(contextPrimer);
+                }
+                else {
+                    // eslint-disable-next-line no-await-in-loop
+                    result = yield this.chatDriver.sendMessage(input, attachments);
+                }
+                if (result.reason !== 'agent-handoff' || isFallback(currentAgent)) {
+                    break;
+                }
+                handoffs += 1;
+                if (handoffs > this.maxHandoffs) {
+                    this.appendInlineMessage(`I wasn't able to fully complete your request — the task required more hand-offs between specialists than allowed (max: ${this.maxHandoffs}). Please try breaking your request into smaller steps.`);
+                    break;
+                }
+                handoffSummary = result.summary;
+                remainingTask = result.remainingTask;
+                isHandoff = true;
+                const updatedHistory = this.chatDriver.getHistory();
+                this.dispatchEvent(new CustomEvent('orchestrating-start'));
+                // eslint-disable-next-line no-await-in-loop
+                currentAgent = yield this.classify(remainingTask, updatedHistory);
+            }
+            return { reason: 'done' };
+        });
+    }
+    continueFromHistory(transientPrimer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.chatDriver.continueFromHistory(transientPrimer);
+        });
+    }
+    applyAgent(agent) {
+        var _a;
+        // Fallback agents are terminal and should not hand off to other specialists
+        const agentToApply = isFallback(agent)
+            ? agent
+            : Object.assign(Object.assign({}, agent), { toolDefinitions: [...((_a = agent.toolDefinitions) !== null && _a !== void 0 ? _a : []), REQUEST_CONTINUATION_DEFINITION] });
+        const previousAgent = this.activeAgent;
+        if (previousAgent && previousAgent.name !== agent.name) {
+            const rawHistory = this.chatDriver.getHistory();
+            this.chatDriver.loadHistory([...rawHistory, { role: 'system-event', content: agent.name }]);
+        }
+        this.chatDriver.setProviderHistoryTransform((h) => transformHistoryForAgent(h, agent.name));
+        this.chatDriver.applyAgent(agentToApply);
+        this.activeAgent = agent;
+        this.dispatchEvent(new CustomEvent('orchestrating-stop'));
+        this.dispatchEvent(new CustomEvent('agent-changed', { detail: agent }));
+    }
+    classify(input, history) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.specialists.length === 0) {
+                return (_a = this.fallback) !== null && _a !== void 0 ? _a : { name: 'Assistant', fallback: true };
+            }
+            const agentList = this.specialists
+                .map((a, i) => `${i}: ${a.name} — ${a.description}`)
+                .join('\n');
+            const recentMessages = history
+                .filter((m) => m.role === 'user' || m.role === 'assistant')
+                .slice(-this.classifierHistoryLength)
+                .map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`)
+                .join('\n');
+            const classifierPrompt = `You are a routing classifier. Call select_agent with the index of the best matching agent for the user message. Use -1 only if the request is entirely unrelated to every agent listed — prefer the closest match when in doubt. If the request spans multiple agents, pick the one that should act first; I will re-classify and route again once that agent is done.\n\nAgents:\n${agentList}${recentMessages ? `\n\nRecent conversation:\n${recentMessages}` : ''}`;
+            const routingTool = {
+                name: 'select_agent',
+                description: 'Select the most appropriate agent for the user message.',
+                parameters: {
+                    type: 'object',
+                    required: ['agent_index'],
+                    properties: {
+                        agent_index: {
+                            type: 'integer',
+                            description: 'Zero-based index of the matching agent, or -1 if no agent matches.',
+                        },
+                    },
+                },
+            };
+            for (let attempt = 0; attempt <= this.classifierRetries; attempt += 1) {
+                try {
+                    const options = {
+                        systemPrompt: classifierPrompt,
+                        tools: [routingTool],
+                    };
+                    // eslint-disable-next-line no-await-in-loop
+                    const response = yield this.aiProvider.chat([], input, options);
+                    const tc = (_b = response.toolCalls) === null || _b === void 0 ? void 0 : _b[0];
+                    const index = (tc === null || tc === void 0 ? void 0 : tc.name) === 'select_agent' ? tc.args.agent_index : -1;
+                    if (index >= 0 && index < this.specialists.length) {
+                        return this.specialists[index];
+                    }
+                    // index === -1 — fall through to fallback
+                    break;
+                }
+                catch (e) {
+                    logger.warn(`OrchestratingDriver: classifier attempt ${attempt + 1} failed:`, e);
+                    if (attempt === this.classifierRetries) {
+                        logger.error('OrchestratingDriver: classifier failed after all retries, using fallback');
+                    }
+                }
+            }
+            if (this.fallback)
+                return this.fallback;
+            // No fallback configured — emit an inline response and return first specialist as no-op
+            const specialistNames = this.specialists.map((s) => s.name).join(', ');
+            this.appendInlineMessage(`I'm not sure how to help with that. I can assist with: ${specialistNames}.`);
+            return this.specialists[0];
+        });
+    }
+    appendInlineMessage(content) {
+        const history = this.chatDriver.getHistory();
+        this.chatDriver.loadHistory([...history, { role: 'assistant', content }]);
+        this.dispatchEvent(new CustomEvent('history-updated', { detail: this.chatDriver.getHistory() }));
+    }
+}

package/dist/esm/components/popout-manager/index.js

@@ -0,0 +1 @@
+export * from './popout-manager';

package/dist/esm/components/popout-manager/popout-manager.js

@@ -0,0 +1,126 @@
+import { __awaiter, __decorate } from "tslib";
+import { customElement, GenesisElement, html, observable } from '@genesislcap/web-core';
+import { agenticActivityBus } from '../../channel/ai-activity-bus';
+/**
+ * App-shell component that owns the pop-out/pop-in lifecycle for the AI assistant bubble.
+ *
+ * @remarks
+ * Place this in the persistent app shell, wrapping a `foundation-ai-chat-bubble` that
+ * contains an AI assistant element in the `dialog-content` slot. The component will
+ * auto-create a matching collapse-mode element for docking into pages, and will
+ * control the expand button visibility based on whether a dock provider is registered.
+ *
+ * Pages that support docking call `aiPopoutManager.registerDockProvider()` on mount
+ * and `aiPopoutManager.deregisterDockProvider()` on unmount.
+ *
+ * @example
+ * ```html
+ * <foundation-ai-popout-manager>
+ *   <foundation-ai-chat-bubble title="My Assistant">
+ *     <my-assistant slot="dialog-content"></my-assistant>
+ *   </foundation-ai-chat-bubble>
+ * </foundation-ai-popout-manager>
+ * ```
+ *
+ * @beta
+ */
+let FoundationAiPopoutManager = class FoundationAiPopoutManager extends GenesisElement {
+    constructor() {
+        super(...arguments);
+        /** True when a dock provider is registered — controls expand button visibility. */
+        this.canDock = false;
+        this.collapseEl = null;
+        this.dockProvider = null;
+        this.isDocked = false;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        _aiPopoutManager = this;
+        const bubble = this.querySelector('foundation-ai-chat-bubble');
+        const assistantEl = bubble === null || bubble === void 0 ? void 0 : bubble.querySelector('[slot="dialog-content"]');
+        if (assistantEl) {
+            this.collapseEl = document.createElement(assistantEl.tagName.toLowerCase());
+            this.collapseEl.setAttribute('popout-mode', 'collapse');
+            // Copy identity attributes so the collapse element shares the same session
+            // store and driver registry key as the expand-mode element in the bubble.
+            const headerTitle = assistantEl.getAttribute('header-title');
+            if (headerTitle)
+                this.collapseEl.setAttribute('header-title', headerTitle);
+            if (assistantEl.id)
+                this.collapseEl.id = assistantEl.id;
+        }
+        const unsubPopout = agenticActivityBus.subscribe('chat-popout', () => __awaiter(this, void 0, void 0, function* () {
+            if (this.isDocked || !this.dockProvider || !this.collapseEl)
+                return;
+            this.isDocked = true;
+            yield this.dockProvider.onDock(this.collapseEl);
+        }));
+        const unsubPopin = agenticActivityBus.subscribe('chat-popin', () => {
+            var _a;
+            this.isDocked = false;
+            (_a = this.dockProvider) === null || _a === void 0 ? void 0 : _a.onUndock();
+        });
+        this.unsubBus = () => {
+            unsubPopout();
+            unsubPopin();
+        };
+    }
+    disconnectedCallback() {
+        var _a;
+        super.disconnectedCallback();
+        (_a = this.unsubBus) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.unsubBus = undefined;
+        _aiPopoutManager = undefined;
+    }
+    canDockChanged() {
+        const bubble = this.querySelector('foundation-ai-chat-bubble');
+        const assistantEl = bubble === null || bubble === void 0 ? void 0 : bubble.querySelector('[slot="dialog-content"]');
+        if (this.canDock) {
+            assistantEl === null || assistantEl === void 0 ? void 0 : assistantEl.setAttribute('popout-mode', 'expand');
+        }
+        else {
+            assistantEl === null || assistantEl === void 0 ? void 0 : assistantEl.removeAttribute('popout-mode');
+        }
+    }
+    registerDockProvider(provider) {
+        this.dockProvider = provider;
+        this.canDock = true;
+    }
+    deregisterDockProvider() {
+        this.isDocked = false;
+        this.dockProvider = null;
+        this.canDock = false;
+    }
+    /**
+     * If the assistant is currently docked, collapses it back into the bubble.
+     * Await this in `onBeforeNavButtonClick` to ensure cleanup before navigation.
+     */
+    collapseIfDocked() {
+        if (!this.isDocked || !this.dockProvider)
+            return Promise.resolve();
+        this.dockProvider.initiateCollapse();
+        return Promise.resolve();
+    }
+};
+__decorate([
+    observable
+], FoundationAiPopoutManager.prototype, "canDock", void 0);
+FoundationAiPopoutManager = __decorate([
+    customElement({
+        name: 'foundation-ai-popout-manager',
+        template: html `
+    <slot></slot>
+  `,
+    })
+], FoundationAiPopoutManager);
+export { FoundationAiPopoutManager };
+let _aiPopoutManager;
+/**
+ * Returns the active `FoundationAiPopoutManager` instance, or `undefined` if none is mounted.
+ * Import this in pages to call `registerDockProvider` / `deregisterDockProvider`.
+ *
+ * @beta
+ */
+export function getAiPopoutManager() {
+    return _aiPopoutManager;
+}

package/dist/esm/config/fallback-agents.js

@@ -0,0 +1,26 @@
+/**
+ * A warm, conversational fallback agent. Acknowledges it can't help directly,
+ * explains what the available specialists can do, and invites the user to retry.
+ *
+ * The system prompt is generated at runtime by `OrchestratingDriver` from the
+ * specialist list — no manual authoring required.
+ *
+ * @beta
+ */
+export const friendlyFallbackAgent = {
+    name: 'Assistant',
+    fallback: true,
+    systemPrompt: `You are a warm, friendly assistant. For general conversation like "Hi" or "How are you", you can have a friendly chat. For anything more complex, you cannot directly help, but you can explain what specialists are available. The available specialists are:\n\n{{agents}}\n\nPolitely let the user know what you can help with and invite them to rephrase their request if it is outside your scope.`,
+};
+/**
+ * A brief, professional fallback agent. States what is available without
+ * elaboration. The `{{agents}}` placeholder is replaced at runtime by
+ * `OrchestratingDriver` with the generated specialist list.
+ *
+ * @beta
+ */
+export const strictFallbackAgent = {
+    name: 'Assistant',
+    fallback: true,
+    systemPrompt: `You are a concise assistant. The user's request is outside your scope. Respond with a single short sentence stating what you can assist with. Do not elaborate. The available specialists are: {{agents}}.`,
+};

package/dist/esm/config/index.js

@@ -1 +1,2 @@
 export * from './config';
+export * from './fallback-agents';

package/dist/esm/index.js

@@ -1,7 +1,13 @@
 export * from './main/main';
 export * from './main/main.types';
 export * from './main/main.template';
+export * from './components/ai-driver';
 export * from './components/chat-driver';
+export * from './components/orchestrating-driver';
+export * from './components/popout-manager';
 export * from './channel/ai-activity-channel';
 export * from './channel/ai-activity-bus';
 export * from './config/config';
+export * from './config/fallback-agents';
+export * from './utils/tool-fold';
+export { AiChatMarkdown } from './components/chat-markdown/chat-markdown';