fauna-api 0.0.0-stage → 1.0.676

package/dist/src/ui/talk.js

@@ -0,0 +1,560 @@
+import { Fauna } from 'fauna-api';
+import gsap from 'gsap';
+import { createDemographic, createSelector, stampModelAvatar, stampUserAvatar } from './generative.js';
+const MIC_RATE = 16000;
+const PLAY_RATE = 24000;
+function observeMemoryTool(credentials, onMemory) {
+    return {
+        function: {
+            name: 'observe_memory',
+            description: 'Store a memory for long-term recall across conversations. Call this when: (1) the user shares a surprising or non-obvious fact about themselves, their preferences, or their world, (2) the user describes a personal experience, story, or emotional moment, (3) the user reveals latent intent, what they actually care about beneath what they said, (4) the user corrects you or clarifies something important, (5) you notice a pattern in what the user values or how they think. Do NOT store trivial small talk or things that are obvious from context. The observation should be a concise, standalone statement that would be useful to recall later without the original conversation.',
+            parameters: {
+                type: 'OBJECT',
+                properties: {
+                    observation: {
+                        type: 'STRING',
+                        description: 'A concise, standalone observation worth remembering. Write it as a fact or insight, not as a quote.',
+                    },
+                },
+                required: ['observation'],
+            },
+            behavior: 'BLOCKING',
+        },
+        evaluate: async (params) => {
+            const observation = String(params?.observation ?? '').trim();
+            if (!observation)
+                return JSON.stringify({ error: 'observation required.' });
+            await Fauna.Parrot.Agent.observe(credentials, observation);
+            onMemory(observation);
+            return JSON.stringify({ ok: true });
+        },
+    };
+}
+class PcmPlayer {
+    constructor() {
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "next", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "closed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.ctx = new AudioContext({ sampleRate: PLAY_RATE });
+        void this.ctx.resume();
+    }
+    push(bytes) {
+        if (this.closed || this.ctx.state === 'closed' || bytes.length < 2)
+            return;
+        const samples = Math.floor(bytes.length / 2);
+        const buffer = this.ctx.createBuffer(1, samples, PLAY_RATE);
+        const channel = buffer.getChannelData(0);
+        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        for (let i = 0; i < samples; i++)
+            channel[i] = view.getInt16(i * 2, true) / 32768;
+        const source = this.ctx.createBufferSource();
+        source.buffer = buffer;
+        source.connect(this.ctx.destination);
+        const now = this.ctx.currentTime;
+        if (this.next < now)
+            this.next = now;
+        source.start(this.next);
+        this.next += buffer.duration;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        void this.ctx.close();
+    }
+}
+function resample(input, fromRate, toRate) {
+    if (fromRate === toRate)
+        return input;
+    const ratio = fromRate / toRate;
+    const out = new Float32Array(Math.max(1, Math.floor(input.length / ratio)));
+    for (let i = 0; i < out.length; i++) {
+        const src = i * ratio;
+        const j = Math.floor(src);
+        const frac = src - j;
+        const a = input[j] ?? 0;
+        const b = input[j + 1] ?? a;
+        out[i] = a + (b - a) * frac;
+    }
+    return out;
+}
+function encodePcm16(samples) {
+    const out = new Uint8Array(samples.length * 2);
+    const view = new DataView(out.buffer);
+    for (let i = 0; i < samples.length; i++) {
+        const sample = Math.max(-1, Math.min(1, samples[i]));
+        view.setInt16(i * 2, sample < 0 ? sample * 0x8000 : sample * 0x7fff, true);
+    }
+    return out;
+}
+async function* captureMic(signal) {
+    const stream = await navigator.mediaDevices.getUserMedia({
+        audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true },
+        video: false,
+    });
+    const ctx = new AudioContext();
+    void ctx.resume();
+    const source = ctx.createMediaStreamSource(stream);
+    const node = ctx.createScriptProcessor(4096, 1, 1);
+    const mute = ctx.createGain();
+    mute.gain.value = 0;
+    const pending = [];
+    let wake;
+    node.onaudioprocess = (event) => {
+        const pcm = encodePcm16(resample(event.inputBuffer.getChannelData(0), ctx.sampleRate, MIC_RATE));
+        if (pcm.length === 0)
+            return;
+        pending.push(pcm);
+        wake?.();
+    };
+    source.connect(node);
+    node.connect(mute);
+    mute.connect(ctx.destination);
+    const onAbort = () => wake?.();
+    signal.addEventListener('abort', onAbort);
+    try {
+        while (!signal.aborted) {
+            if (pending.length === 0) {
+                await new Promise((resolve) => { wake = resolve; });
+                continue;
+            }
+            yield pending.shift();
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+        node.disconnect();
+        source.disconnect();
+        mute.disconnect();
+        for (const track of stream.getTracks())
+            track.stop();
+        void ctx.close();
+    }
+}
+async function startVoiceSession(credentials, model, hooks = {}, voice) {
+    const controller = new AbortController();
+    const player = new PcmPlayer();
+    const observe = observeMemoryTool(credentials, (observation) => hooks.onMemory?.(observation));
+    void (async () => {
+        try {
+            const audio = captureMic(controller.signal);
+            for await (const event of Fauna.Parrot.Generative.generateVoice(credentials, model, {
+                audio,
+                tools: observe,
+                voice,
+                signal: controller.signal,
+            })) {
+                if (event.event === 'audio')
+                    player.push(event.delta);
+                else if (event.event === 'input_transcript')
+                    hooks.onInput?.(event.delta);
+                else if (event.event === 'output_transcript')
+                    hooks.onOutput?.(event.delta);
+                else if (event.event === 'speech_started')
+                    hooks.onSpeechStart?.();
+                else if (event.event === 'speech_stopped')
+                    hooks.onSpeechStop?.();
+                else if (event.event === 'error')
+                    hooks.onError?.(event.message);
+            }
+        }
+        catch (err) {
+            if (!controller.signal.aborted)
+                hooks.onError?.(err?.message ?? String(err));
+        }
+        finally {
+            player.close();
+            if (!controller.signal.aborted)
+                controller.abort();
+            hooks.onDone?.();
+        }
+    })();
+    return {
+        hangUp: () => {
+            if (!controller.signal.aborted)
+                controller.abort();
+            player.close();
+        },
+    };
+}
+function statusLabel(phase) {
+    if (phase === 'connecting')
+        return 'Connecting';
+    if (phase === 'listening')
+        return 'Listening';
+    if (phase === 'talking')
+        return 'Talking';
+    return 'Voice';
+}
+function profileFromCredentials(credentials) {
+    if (!('email' in credentials))
+        return undefined;
+    return { email: credentials.email, displayName: credentials.displayName, icon: credentials.icon };
+}
+export function createTalk(container, options) {
+    const assistantLabel = options.assistantLabel ?? 'Assistant';
+    let phase = 'idle';
+    let generation = 0;
+    let starting = false;
+    let session;
+    let model = Fauna.Parrot.Generative.Voice.GPT_REALTIME;
+    let voice = { age: 35 };
+    let modelIcons = {};
+    const userProfile = profileFromCredentials(options.credentials);
+    const turns = [];
+    const root = document.createElement('div');
+    root.className = 'talk';
+    const stage = document.createElement('div');
+    stage.className = 'talk-stage';
+    const orb = document.createElement('div');
+    orb.className = 'talk-orb talk-orb-idle';
+    orb.setAttribute('aria-hidden', 'true');
+    const ringA = document.createElement('span');
+    ringA.className = 'talk-orb-ring';
+    const ringB = document.createElement('span');
+    ringB.className = 'talk-orb-ring';
+    const core = document.createElement('span');
+    core.className = 'talk-orb-core';
+    orb.append(ringA, ringB, core);
+    const status = document.createElement('p');
+    status.className = 'talk-status';
+    status.textContent = 'Voice';
+    const error = document.createElement('p');
+    error.className = 'talk-error';
+    error.hidden = true;
+    const controls = document.createElement('div');
+    controls.className = 'talk-controls';
+    const selectorEl = document.createElement('div');
+    const demographicEl = document.createElement('div');
+    const action = document.createElement('button');
+    action.type = 'button';
+    action.className = 'talk-start';
+    action.textContent = 'Start Listening';
+    controls.append(selectorEl, demographicEl, action);
+    stage.append(orb, status, error, controls);
+    const log = document.createElement('div');
+    log.className = 'talk-log';
+    root.append(stage, log);
+    container.appendChild(root);
+    const paintPhase = () => {
+        orb.className = `talk-orb talk-orb-${phase}`;
+        status.textContent = statusLabel(phase);
+        const live = phase !== 'idle';
+        action.textContent = live ? 'Hang up' : 'Start Listening';
+        action.className = live ? 'talk-hang-up' : 'talk-start';
+    };
+    const setPhase = (next) => {
+        phase = next;
+        paintPhase();
+    };
+    const setError = (message) => {
+        error.textContent = message;
+        error.hidden = !message;
+    };
+    const scrollLog = () => {
+        log.scrollTop = log.scrollHeight;
+    };
+    const stopReveal = (turn) => {
+        if (turn.raf === null)
+            return;
+        cancelAnimationFrame(turn.raf);
+        turn.raf = null;
+    };
+    const paintChunk = (turn, chunk) => {
+        if (!chunk)
+            return;
+        const bit = document.createElement('span');
+        bit.className = 'talk-type';
+        bit.textContent = chunk;
+        turn.body.appendChild(bit);
+    };
+    const tickReveal = (turn) => {
+        turn.raf = null;
+        const remaining = turn.text.length - turn.shown;
+        if (remaining <= 0)
+            return;
+        const step = remaining > 36 ? Math.ceil(remaining / 4) : remaining > 10 ? 3 : 1;
+        const chunk = turn.text.slice(turn.shown, turn.shown + step);
+        turn.shown += chunk.length;
+        paintChunk(turn, chunk);
+        scrollLog();
+        if (turn.shown < turn.text.length) {
+            turn.raf = requestAnimationFrame(() => tickReveal(turn));
+        }
+    };
+    const feedTurn = (turn, delta) => {
+        if (!delta)
+            return;
+        turn.text += delta;
+        if (turn.raf === null)
+            turn.raf = requestAnimationFrame(() => tickReveal(turn));
+    };
+    const plopMessage = (el, role) => {
+        const origin = role === 'user' ? '100% 100%' : role === 'memory' ? '50% 100%' : '0% 100%';
+        gsap.killTweensOf(el);
+        gsap.fromTo(el, {
+            autoAlpha: 0,
+            scale: role === 'memory' ? 0.84 : 0.9,
+            y: 16,
+            transformOrigin: origin,
+        }, {
+            duration: 0.46,
+            autoAlpha: 1,
+            scale: 1,
+            y: 0,
+            ease: 'back.out(1.8)',
+            clearProps: 'transform',
+        });
+    };
+    const seal = () => {
+        const last = turns[turns.length - 1];
+        if (last)
+            last.live = false;
+    };
+    const appendTurn = (role, text) => {
+        if (!text)
+            return;
+        const last = turns[turns.length - 1];
+        if (last && last.role === role && last.live) {
+            feedTurn(last, text);
+            return;
+        }
+        const el = document.createElement('div');
+        const body = document.createElement(role === 'memory' ? 'span' : 'p');
+        body.className = role === 'memory' ? 'talk-memory-text' : 'talk-bubble-text';
+        if (role === 'memory') {
+            el.className = 'talk-memory';
+            const icon = document.createElement('span');
+            icon.className = 'material-symbols-outlined';
+            icon.textContent = 'psychology';
+            el.append(icon, body);
+        }
+        else {
+            el.className = `talk-bubble talk-bubble-${role}`;
+            el.setAttribute('aria-label', role === 'user' ? (userProfile?.displayName ?? 'You') : assistantLabel);
+            el.append(body);
+            if (role === 'user')
+                stampUserAvatar(el, userProfile);
+            else
+                stampModelAvatar(el, model, modelIcons);
+        }
+        log.appendChild(el);
+        const turn = { role, text: '', shown: 0, live: role !== 'memory', el, body, raf: null };
+        turns.push(turn);
+        plopMessage(el, role);
+        feedTurn(turn, text);
+        scrollLog();
+    };
+    const clearLog = () => {
+        for (const turn of turns) {
+            stopReveal(turn);
+            gsap.killTweensOf(turn.el);
+        }
+        turns.length = 0;
+        log.innerHTML = '';
+    };
+    const hangUp = () => {
+        generation += 1;
+        starting = false;
+        session?.hangUp();
+        session = undefined;
+        setPhase('idle');
+    };
+    let pulsed = false;
+    const stopPulse = () => {
+        gsap.killTweensOf(action);
+        gsap.set(action, { scale: 1 });
+    };
+    const startPulse = () => {
+        gsap.to(action, {
+            scale: 1.025,
+            duration: 0.9,
+            yoyo: true,
+            repeat: -1,
+            ease: 'sine.inOut',
+        });
+    };
+    let split = false;
+    const revealStage = () => {
+        if (split)
+            return;
+        split = true;
+        gsap.fromTo(root, {
+            gridTemplateColumns: '100% 0%',
+        }, {
+            duration: 0.7,
+            ease: 'power2.inOut',
+            gridTemplateColumns: '38% 62%',
+            onComplete: () => root.classList.add('is-split'),
+        });
+        gsap.to(log, {
+            opacity: 1,
+            duration: 0.45,
+            delay: 0.18,
+            ease: 'power2.out',
+        });
+    };
+    const start = async () => {
+        if (session || starting)
+            return;
+        if (!pulsed) {
+            pulsed = true;
+            stopPulse();
+            revealStage();
+        }
+        const token = generation + 1;
+        generation = token;
+        starting = true;
+        clearLog();
+        setError('');
+        setPhase('connecting');
+        try {
+            const next = await startVoiceSession(options.credentials, model, {
+                onInput: (delta) => {
+                    if (generation !== token)
+                        return;
+                    appendTurn('user', delta);
+                },
+                onOutput: (delta) => {
+                    if (generation !== token)
+                        return;
+                    setPhase('talking');
+                    appendTurn('assistant', delta);
+                },
+                onSpeechStart: () => {
+                    if (generation !== token)
+                        return;
+                    seal();
+                    setPhase('listening');
+                },
+                onSpeechStop: () => {
+                    if (generation !== token)
+                        return;
+                    seal();
+                    if (phase === 'listening')
+                        setPhase('talking');
+                },
+                onMemory: (observation) => {
+                    if (generation !== token)
+                        return;
+                    seal();
+                    appendTurn('memory', observation);
+                },
+                onError: (message) => {
+                    if (generation !== token)
+                        return;
+                    console.error(message);
+                    setError(message);
+                },
+                onDone: () => {
+                    if (generation !== token)
+                        return;
+                    session = undefined;
+                    starting = false;
+                    setPhase('idle');
+                },
+            }, voice);
+            if (generation !== token) {
+                next.hangUp();
+                return;
+            }
+            session = next;
+            starting = false;
+            setPhase('listening');
+        }
+        catch (err) {
+            if (generation !== token)
+                return;
+            session = undefined;
+            starting = false;
+            setPhase('idle');
+            setError(err?.message ?? 'Could not start voice.');
+        }
+    };
+    const restart = () => {
+        if (phase === 'idle' && !starting && !session)
+            return;
+        hangUp();
+        void start();
+    };
+    const selector = createSelector(selectorEl, {
+        value: model,
+        onChange: (value) => {
+            const next = value;
+            if (next === model)
+                return;
+            model = next;
+            restart();
+        },
+    });
+    const demographic = createDemographic(demographicEl, {
+        value: voice,
+        omit: ['income'],
+        onChange: (next) => {
+            voice = next;
+            restart();
+        },
+    });
+    void Fauna.Parrot.Routing.getAll()
+        .then(({ voice: rows }) => {
+        const icons = {};
+        for (const row of rows ?? []) {
+            if (row.icon)
+                icons[row.model] = row.icon;
+        }
+        modelIcons = icons;
+        selector.setOptions((rows ?? []).map((row) => ({
+            value: row.model,
+            name: row.name,
+            icon: row.icon,
+        })));
+        const first = rows?.[0]?.model;
+        if (first) {
+            model = first;
+            selector.setValue(first);
+        }
+        for (const el of log.querySelectorAll('.talk-bubble-assistant')) {
+            stampModelAvatar(el, model, modelIcons);
+        }
+    })
+        .catch((err) => console.error('Failed to load voice models:', err));
+    action.onclick = () => {
+        if (phase === 'idle')
+            void start();
+        else {
+            hangUp();
+            options.onHangUp?.();
+        }
+    };
+    paintPhase();
+    startPulse();
+    return {
+        start,
+        hangUp,
+        destroy: () => {
+            stopPulse();
+            gsap.killTweensOf(root);
+            gsap.killTweensOf(log);
+            clearLog();
+            hangUp();
+            selector.destroy();
+            demographic.destroy();
+            root.remove();
+        },
+    };
+}

package/dist/src/ui/tickets.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { Fauna } from "fauna-api";
+export type TicketsOptions = {
+    credentials: Fauna.Authentification.Credentials;
+    source?: string;
+    ticketId?: string;
+    onClose?: () => void;
+};
+export declare function Tickets(props: TicketsOptions): React.JSX.Element;
+export declare function Support(props: TicketsOptions): React.JSX.Element;
+export declare function createTickets(container: HTMLElement, options: TicketsOptions): {
+    destroy: () => void;
+};