@genesislcap/ai-assistant 14.409.0-FUI-2495.2 → 14.409.1

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

@@ -1,229 +0,0 @@
-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 the history for a given agent by masking tool call args and results
- * produced by other agents — preserving conversation structure without leaking
- * irrelevant domain data into the active agent's context.
- */
-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), { 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);
-        // 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);
-    }
-    loadHistory(messages) {
-        this.chatDriver.loadHistory(messages);
-    }
-    getRawHistory() {
-        return this.chatDriver.getHistory();
-    }
-    sendMessage(input, attachments) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const history = this.chatDriver.getHistory();
-            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] });
-        // Mask history from other agents before handing context to this specialist
-        const rawHistory = this.chatDriver.getHistory();
-        const maskedHistory = transformHistoryForAgent(rawHistory, agent.name);
-        // Inject an agent switch indicator when the active specialist changes
-        const previousAgent = this.activeAgent;
-        if (previousAgent && previousAgent.name !== agent.name) {
-            maskedHistory.push({ role: 'system-event', content: agent.name });
-        }
-        this.chatDriver.loadHistory(maskedHistory);
-        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

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

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

@@ -1,119 +0,0 @@
-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');
-        }
-        const unsubPopout = agenticActivityBus.subscribe('chat-popout', (_a) => __awaiter(this, [_a], void 0, function* ({ state }) {
-            if (this.isDocked || !this.dockProvider || !this.collapseEl)
-                return;
-            this.isDocked = true;
-            yield this.dockProvider.onDock(this.collapseEl, state);
-        }));
-        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

@@ -1,26 +0,0 @@
-/**
- * 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/src/components/ai-driver/ai-driver.ts

@@ -1,42 +0,0 @@
-import type { ChatAttachment, ChatDriverResult, ChatMessage } from '@genesislcap/foundation-ai';
-
-/**
- * Common interface implemented by both `ChatDriver` (single-agent) and
- * `OrchestratingDriver` (multi-agent). `FoundationAiAssistant` depends only
- * on this interface — the concrete class is chosen at startup based on how
- * many agents are configured.
- *
- * Extends `EventTarget` so consumers can subscribe to `history-updated` events
- * without knowing the concrete implementation.
- *
- * @beta
- */
-export interface AiDriver extends EventTarget {
-  /**
-   * Send a user message and run the tool loop to completion.
-   */
-  sendMessage(input: string, attachments?: ChatAttachment[]): Promise<ChatDriverResult>;
-
-  /**
-   * Continue the tool loop from the current history without appending a new
-   * user message. Used by `OrchestratingDriver` on agent handoffs — the
-   * handoff context is already in history; `transientPrimer` is injected as
-   * an invisible one-shot message for this call only.
-   */
-  continueFromHistory(transientPrimer?: ChatMessage[]): Promise<ChatDriverResult>;
-
-  /**
-   * Resolve a pending blocking interaction with the given result.
-   */
-  resolveInteraction(interactionId: string, result: unknown): void;
-
-  /**
-   * Seed the driver's message history (called on state restore / pop-in).
-   */
-  loadHistory(messages: ChatMessage[]): void;
-
-  /**
-   * Return the full, unredacted conversation history.
-   */
-  getRawHistory?(): readonly ChatMessage[];
-}

package/src/components/ai-driver/index.ts

@@ -1 +0,0 @@
-export type { AiDriver } from './ai-driver';

package/src/components/orchestrating-driver/index.ts

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