@genesislcap/ai-assistant 14.403.0-ai-assistant.1

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

@@ -0,0 +1,209 @@
+import { __awaiter } from "tslib";
+import { MalformedFunctionCallError } from '@genesislcap/foundation-ai';
+import { logger } from '../../utils/logger';
+const MAX_TOOL_ITERATIONS = 10;
+const MAX_MALFORMED_RETRIES = 2;
+/**
+ * Plain TS class that drives a multi-turn chat conversation, including the tool-call loop.
+ * Owned by `FoundationAiAssistant` — created in `connectedCallback`, torn down in `disconnectedCallback`.
+ *
+ * Dispatches `'history-updated'` events on itself so the owning element can observe changes.
+ *
+ * @beta
+ */
+export class ChatDriver extends EventTarget {
+    constructor(aiProvider, toolHandlers = {}, toolDefinitions = [], systemPrompt) {
+        super();
+        this.aiProvider = aiProvider;
+        this.toolHandlers = toolHandlers;
+        this.toolDefinitions = toolDefinitions;
+        this.systemPrompt = systemPrompt;
+        this.history = [];
+        this.busy = false;
+        this.pendingInteractions = new Map();
+    }
+    getHistory() {
+        return this.history;
+    }
+    isBusy() {
+        return this.busy;
+    }
+    /**
+     * Request a custom UI interaction. Emits a new message with the interaction.
+     * Tool handlers can call this to pause execution until the user completes the UI interaction.
+     *
+     * @param componentName - The custom element name to render.
+     * @param data - Data to pass to the component.
+     */
+    requestInteraction(componentName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const interactionId = crypto.randomUUID();
+            return new Promise((resolve, reject) => {
+                this.pendingInteractions.set(interactionId, { resolve, reject });
+                this.appendToHistory({
+                    role: 'assistant',
+                    content: '',
+                    interaction: { interactionId, componentName, data },
+                });
+            });
+        });
+    }
+    /**
+     * Resolve a pending interaction. The wrapper component calls this on completion.
+     * Marks the interaction message as resolved so it renders read-only on re-render.
+     */
+    resolveInteraction(interactionId, result) {
+        const interaction = this.pendingInteractions.get(interactionId);
+        if (interaction) {
+            // Mark the message as resolved before resolving the promise so the next
+            // history-updated event carries the updated flag.
+            const msg = this.history.find((m) => { var _a; return ((_a = m.interaction) === null || _a === void 0 ? void 0 : _a.interactionId) === interactionId; });
+            if (msg === null || msg === void 0 ? void 0 : msg.interaction) {
+                msg.interaction.resolved = true;
+                this.dispatchEvent(new CustomEvent('history-updated', {
+                    detail: this.history,
+                }));
+            }
+            interaction.resolve(result);
+            this.pendingInteractions.delete(interactionId);
+        }
+        else {
+            logger.warn(`Interaction with ID ${interactionId} not found.`);
+        }
+    }
+    /**
+     * Seeds the driver with a prior conversation history so a new component instance
+     * can continue an existing conversation. Call this before the first user message.
+     */
+    loadHistory(messages) {
+        this.history = [...messages];
+    }
+    sendMessage(userInput, attachments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.busy || (!userInput.trim() && !(attachments === null || attachments === void 0 ? void 0 : attachments.length)))
+                return;
+            if (!this.aiProvider.chat) {
+                logger.warn('ChatDriver: AIProvider does not implement chat()');
+                return;
+            }
+            this.busy = true;
+            this.appendToHistory({ role: 'user', content: userInput, attachments });
+            try {
+                yield this.runToolLoop(userInput, attachments);
+            }
+            catch (e) {
+                logger.error('ChatDriver error:', e);
+                this.appendToHistory({ role: 'assistant', content: 'Sorry, something went wrong.' });
+            }
+            finally {
+                this.busy = false;
+            }
+        });
+    }
+    runToolLoop(userInput, attachments) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            const baseOptions = {
+                systemPrompt: this.systemPrompt,
+                tools: this.toolDefinitions.length ? this.toolDefinitions : undefined,
+            };
+            // History has the user message at the end — pass everything before it as history,
+            // and the user input as the userMessage argument.
+            let currentInput = userInput;
+            let currentAttachments = attachments;
+            let iterations = 0;
+            let malformedAttempts = 0;
+            while (iterations < MAX_TOOL_ITERATIONS) {
+                iterations += 1;
+                // On the first iteration, the last item in history is the user message which is
+                // passed separately as currentInput — exclude it. On subsequent iterations, the
+                // full history (including tool results) should be sent and currentInput is empty.
+                const historyForCall = iterations === 1 ? this.history.slice(0, -1) : [...this.history];
+                // On malformed-call retries, augment the system prompt to steer the model
+                // away from generating Python-style batched function call syntax.
+                const systemPrompt = malformedAttempts > 0
+                    ? `${(_a = baseOptions.systemPrompt) !== null && _a !== void 0 ? _a : ''}\n\nIMPORTANT: Use only the structured function-call API to invoke tools. Do not write Python code or use Python-style syntax to call tools.`
+                    : baseOptions.systemPrompt;
+                const options = Object.assign(Object.assign({}, baseOptions), { systemPrompt, attachments: currentAttachments });
+                let response;
+                try {
+                    // eslint-disable-next-line no-await-in-loop
+                    response = yield this.aiProvider.chat(historyForCall, currentInput, options);
+                }
+                catch (e) {
+                    if (e instanceof MalformedFunctionCallError) {
+                        malformedAttempts += 1;
+                        if (malformedAttempts < MAX_MALFORMED_RETRIES) {
+                            logger.warn(`ChatDriver: MALFORMED_FUNCTION_CALL, retrying (${malformedAttempts}/${MAX_MALFORMED_RETRIES})`);
+                            iterations -= 1; // don't consume an iteration budget slot for a failed attempt
+                            continue;
+                        }
+                        logger.error('ChatDriver: MALFORMED_FUNCTION_CALL, max retries reached');
+                        this.appendToHistory({
+                            role: 'assistant',
+                            content: "I'm sorry, I wasn't able to complete that request. Please try rephrasing or breaking it into smaller steps.",
+                        });
+                        return;
+                    }
+                    throw e;
+                }
+                currentAttachments = undefined; // attachments only sent on first call
+                const isThinkingStep = response.content && ((_b = response.toolCalls) === null || _b === void 0 ? void 0 : _b.length);
+                const isEmptyResponse = !((_c = response.content) === null || _c === void 0 ? void 0 : _c.trim()) && !((_d = response.toolCalls) === null || _d === void 0 ? void 0 : _d.length);
+                if (isEmptyResponse) {
+                    // Do nothing, discard empty/whitespace-only responses
+                }
+                else if (isThinkingStep) {
+                    // Separate thinking message and tool call message
+                    this.appendToHistory(Object.assign(Object.assign({}, response), { toolCalls: undefined, thinking: true }));
+                    this.appendToHistory(Object.assign(Object.assign({}, response), { content: '' }));
+                }
+                else {
+                    this.appendToHistory(response);
+                }
+                if (!((_e = response.toolCalls) === null || _e === void 0 ? void 0 : _e.length)) {
+                    // Terminal text response — done
+                    break;
+                }
+                // Execute all tool calls for this iteration concurrently, then append results in order
+                // eslint-disable-next-line no-await-in-loop
+                const toolResults = yield Promise.all(response.toolCalls.map((tc) => __awaiter(this, void 0, void 0, function* () {
+                    const handler = this.toolHandlers[tc.name];
+                    if (!handler) {
+                        logger.warn(`ChatDriver: no handler registered for tool "${tc.name}"`);
+                        return { toolCallId: tc.id, content: `Unknown tool: ${tc.name}` };
+                    }
+                    try {
+                        const result = yield handler(tc.args, {
+                            requestInteraction: (componentName, data) => this.requestInteraction(componentName, data),
+                        });
+                        const content = typeof result === 'string' ? result : JSON.stringify(result);
+                        return { toolCallId: tc.id, content };
+                    }
+                    catch (e) {
+                        logger.error(`ChatDriver tool "${tc.name}" failed:`, e);
+                        return { toolCallId: tc.id, content: `Tool error: ${e.message}` };
+                    }
+                })));
+                for (const result of toolResults) {
+                    this.appendToHistory({
+                        role: 'tool',
+                        content: '',
+                        toolResult: result,
+                    });
+                }
+                // Next iteration sends an empty string — the tool results are in history
+                currentInput = '';
+            }
+            if (iterations >= MAX_TOOL_ITERATIONS) {
+                logger.warn('ChatDriver: reached max tool iterations, stopping');
+            }
+        });
+    }
+    appendToHistory(message) {
+        this.history = [...this.history, message];
+        this.dispatchEvent(new CustomEvent('history-updated', {
+            detail: this.history,
+        }));
+    }
+}

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

@@ -0,0 +1 @@
+export * from './chat-driver';

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

@@ -0,0 +1,90 @@
+import { __decorate } from "tslib";
+import { customElement, GenesisElement, observable } from '@genesislcap/web-core';
+import { logger } from '../../utils/logger';
+import { AiChatInteractionWrapperStyles } from './chat-interaction-wrapper.styles';
+import { AiChatInteractionWrapperTemplate } from './chat-interaction-wrapper.template';
+let AiChatInteractionWrapper = class AiChatInteractionWrapper extends GenesisElement {
+    constructor() {
+        super(...arguments);
+        this.componentName = '';
+        this.interactionId = '';
+        /** When true, the interaction has already been resolved. Forwarded to the rendered component. */
+        this.resolved = false;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.renderComponent();
+    }
+    componentNameChanged() {
+        this.renderComponent();
+    }
+    resolvedChanged() {
+        var _a;
+        // TODO: switch to FAST ref() or slotted children directives instead of querying the container
+        // imperatively — this would allow property bindings to flow naturally through the template.
+        const container = (_a = this.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('.container');
+        const element = container === null || container === void 0 ? void 0 : container.firstElementChild;
+        if (element) {
+            element.resolved = this.resolved;
+        }
+    }
+    renderComponent() {
+        var _a;
+        const container = (_a = this.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector('.container');
+        if (!container || !this.componentName)
+            return;
+        // Clear children without using innerHTML
+        container.replaceChildren();
+        if (!customElements.get(this.componentName)) {
+            logger.warn(`Interactive component "\${this.componentName}" is not registered in the customElements registry.`);
+            const errorDiv = document.createElement('div');
+            errorDiv.textContent = `Error: Component "\${this.componentName}" is not available in this application.`;
+            container.appendChild(errorDiv);
+            return;
+        }
+        try {
+            const element = document.createElement(this.componentName);
+            // Pass data and resolved state to the component
+            if (this.data) {
+                element.data = this.data;
+            }
+            element.resolved = this.resolved;
+            // Handle completion from the inner component.
+            // Guard against re-emission if the interaction was already resolved
+            // (e.g. auto-resolve components fire on connectedCallback when rendering history).
+            element.addEventListener('interaction-completed', (e) => {
+                e.stopPropagation();
+                if (this.resolved)
+                    return;
+                this.$emit('interaction-completed', Object.assign({ interactionId: this.interactionId }, e.detail));
+            });
+            container.appendChild(element);
+        }
+        catch (e) {
+            logger.error(`Failed to create interactive component: \${this.componentName}`, e);
+            const errorDiv = document.createElement('div');
+            errorDiv.textContent = `Error: Could not load component \${this.componentName}`;
+            container.appendChild(errorDiv);
+        }
+    }
+};
+__decorate([
+    observable
+], AiChatInteractionWrapper.prototype, "componentName", void 0);
+__decorate([
+    observable
+], AiChatInteractionWrapper.prototype, "data", void 0);
+__decorate([
+    observable
+], AiChatInteractionWrapper.prototype, "interactionId", void 0);
+__decorate([
+    observable
+], AiChatInteractionWrapper.prototype, "resolved", void 0);
+AiChatInteractionWrapper = __decorate([
+    customElement({
+        name: 'ai-chat-interaction-wrapper',
+        template: AiChatInteractionWrapperTemplate,
+        styles: AiChatInteractionWrapperStyles,
+    })
+], AiChatInteractionWrapper);
+export { AiChatInteractionWrapper };

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

@@ -0,0 +1,6 @@
+import { css } from '@genesislcap/web-core';
+export const AiChatInteractionWrapperStyles = css `
+  :host {
+    display: block;
+  }
+`;

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

@@ -0,0 +1,4 @@
+import { html } from '@genesislcap/web-core';
+export const AiChatInteractionWrapperTemplate = html `
+  <div class="container" part="container"></div>
+`;

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

@@ -0,0 +1,3 @@
+export * from './chat-interaction-wrapper';
+export * from './chat-interaction-wrapper.styles';
+export * from './chat-interaction-wrapper.template';

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

@@ -0,0 +1,95 @@
+import { __decorate } from "tslib";
+import { css, customElement, GenesisElement, html, observable } from '@genesislcap/web-core';
+import DOMPurify from 'dompurify';
+import { marked } from 'marked';
+const styles = css `
+  :host {
+    display: block;
+    font-size: var(--type-ramp-base-font-size);
+    line-height: var(--type-ramp-base-line-height);
+  }
+
+  p {
+    margin: 0 0 calc(var(--design-unit, 4) * 2px);
+  }
+
+  p:last-child {
+    margin-bottom: 0;
+  }
+
+  ul,
+  ol {
+    margin: 0 0 calc(var(--design-unit, 4) * 2px);
+    padding-left: calc(var(--design-unit, 4) * 5px);
+  }
+
+  code {
+    background-color: var(--neutral-fill-rest);
+    padding: 2px 4px;
+    border-radius: calc(var(--design-unit, 4) * 0.5px);
+    font-family: monospace;
+  }
+
+  pre {
+    background-color: var(--neutral-fill-rest);
+    padding: calc(var(--design-unit, 4) * 2px);
+    border-radius: calc(var(--design-unit, 4) * 1px);
+    overflow-x: auto;
+    border: 1px solid var(--neutral-stroke-rest);
+    margin: calc(var(--design-unit, 4) * 2px) 0;
+  }
+
+  pre code {
+    background-color: transparent;
+    padding: 0;
+    border-radius: 0;
+    border: none;
+    font-family: inherit;
+    color: inherit;
+  }
+
+  table {
+    display: block;
+    overflow-x: auto;
+    border-collapse: collapse;
+    max-width: 100%;
+    margin: calc(var(--design-unit, 4) * 2px) 0;
+  }
+
+  th,
+  td {
+    border: 1px solid var(--neutral-stroke-rest);
+    padding: calc(var(--design-unit, 4) * 1px) calc(var(--design-unit, 4) * 2.5px);
+    white-space: nowrap;
+  }
+
+  th {
+    background-color: var(--neutral-fill-stealth-rest);
+    font-weight: 600;
+  }
+`;
+let AiChatMarkdown = class AiChatMarkdown extends GenesisElement {
+    constructor() {
+        super(...arguments);
+        this.content = '';
+    }
+    renderMarkdown() {
+        if (!this.content)
+            return '';
+        const rawHtml = marked.parse(this.content);
+        return DOMPurify.sanitize(rawHtml);
+    }
+};
+__decorate([
+    observable
+], AiChatMarkdown.prototype, "content", void 0);
+AiChatMarkdown = __decorate([
+    customElement({
+        name: 'ai-chat-markdown',
+        template: html `
+    <div :innerHTML="${(x) => x.renderMarkdown()}"></div>
+  `,
+        styles,
+    })
+], AiChatMarkdown);
+export { AiChatMarkdown };

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

@@ -0,0 +1 @@
+export * from './chat-markdown';

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

@@ -0,0 +1,118 @@
+var AiHaloOverlay_1;
+import { __decorate } from "tslib";
+import { attr, css, customElement, GenesisElement, html } from '@genesislcap/web-core';
+/**
+ * Animated halo overlay — rotating conic-gradient border with an inward glow.
+ *
+ * Drop inside any `position: relative; overflow: hidden` container and toggle
+ * the `active` attribute to show/hide the effect.
+ *
+ * @example
+ * ```html
+ * <ai-halo-overlay ?active="${(x) => x.isLoading}"></ai-halo-overlay>
+ * ```
+ *
+ * @beta
+ */
+let AiHaloOverlay = AiHaloOverlay_1 = class AiHaloOverlay extends GenesisElement {
+    constructor() {
+        super(...arguments);
+        this.active = false;
+        this.angle = 0;
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.tick();
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        if (this.animFrame !== undefined) {
+            cancelAnimationFrame(this.animFrame);
+        }
+    }
+    tick() {
+        this.angle = (this.angle + AiHaloOverlay_1.DEG_PER_FRAME) % AiHaloOverlay_1.FULL_ROTATION_DEG;
+        this.style.setProperty('--halo-angle', `${this.angle}deg`);
+        this.animFrame = requestAnimationFrame(() => this.tick());
+    }
+};
+// TODO: The rAF loop is fine for demos but has two drawbacks vs a pure CSS @property animation:
+// 1. It runs on the main thread, so heavy JS work can cause the animation to stutter.
+// 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);
+AiHaloOverlay = AiHaloOverlay_1 = __decorate([
+    customElement({
+        name: 'ai-halo-overlay',
+        template: html `
+    <slot></slot>
+  `,
+        styles: css `
+    :host {
+      display: block;
+      position: absolute;
+      inset: 0;
+      border-radius: inherit;
+      pointer-events: none;
+      z-index: 1000;
+      opacity: 0;
+      transition: opacity 0.4s ease;
+    }
+
+    :host([active]) {
+      opacity: 1;
+    }
+
+    /* Rotating solid border */
+    :host::before {
+      content: '';
+      position: absolute;
+      inset: 0;
+      border-radius: inherit;
+      padding: 3px;
+      background: repeating-conic-gradient(
+        from var(--halo-angle, 0deg),
+        #feb60a,
+        #ff0062,
+        #00dbf9,
+        #da00f7,
+        #feb60a
+      );
+      -webkit-mask:
+        linear-gradient(#000 0 0) content-box,
+        linear-gradient(#000 0 0);
+      mask:
+        linear-gradient(#000 0 0) content-box,
+        linear-gradient(#000 0 0);
+      -webkit-mask-composite: destination-out;
+      mask-composite: exclude;
+    }
+
+    /* Inward glow — radial mask makes centre transparent, edges coloured */
+    :host::after {
+      content: '';
+      position: absolute;
+      inset: 0;
+      border-radius: inherit;
+      background: repeating-conic-gradient(
+        from var(--halo-angle, 0deg),
+        #feb60a,
+        #ff0062,
+        #00dbf9,
+        #da00f7,
+        #feb60a
+      );
+      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%);
+    }
+  `,
+    })
+], AiHaloOverlay);
+export { AiHaloOverlay };

package/dist/esm/config/config.js

@@ -0,0 +1,16 @@
+import { DI } from '@genesislcap/web-core';
+/**
+ * Default AiAssistantConfig DI implementation.
+ *
+ * @beta
+ */
+export const defaultAiAssistantConfig = {
+    name: 'foundation-ai-assistant',
+    chatConfig: {},
+};
+/**
+ * AiAssistantConfig DI key.
+ *
+ * @internal
+ */
+export const AiAssistantConfig = DI.createInterface((x) => x.instance(defaultAiAssistantConfig));

package/dist/esm/config/index.js

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

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+export * from './main/main';
+export * from './main/main.types';
+export * from './main/main.template';
+export * from './components/chat-bubble';
+export * from './components/chat-driver';
+export * from './components/activity-halo/activity-halo';
+export * from './channel/ai-activity-channel';
+export * from './config/config';

package/dist/esm/main/index.js

@@ -0,0 +1,4 @@
+export * from './main.template';
+export * from '../styles';
+export * from './main';
+export * from './main.types';