@albionlabs/chat-widget 0.1.0

package/dist/stores/chat.js

@@ -0,0 +1,387 @@
+import { writable, get } from 'svelte/store';
+import { fetchNpv, fetchOrderbook, fetchTokenMetadata, fetchTrades, lookupToken, setGatewayConfig } from '../services/gateway-api.js';
+const initial = {
+    messages: [],
+    connected: false,
+    reconnecting: false,
+    sessionId: null,
+    loading: false,
+    thinkingStatus: null,
+    backendVersion: null
+};
+export const chat = writable(initial);
+let ws = null;
+let messageCounter = 0;
+let streamingAssistantMessageId = null;
+let reconnectAttempts = 0;
+let reconnectTimer = null;
+let lastGatewayUrl = null;
+let lastToken = null;
+let lastApiKey = null;
+let intentionalClose = false;
+const MAX_RECONNECT_ATTEMPTS = 10;
+const BASE_RECONNECT_DELAY_MS = 1000;
+const MAX_RECONNECT_DELAY_MS = 30000;
+function getReconnectDelay() {
+    const delay = Math.min(BASE_RECONNECT_DELAY_MS * Math.pow(2, reconnectAttempts), MAX_RECONNECT_DELAY_MS);
+    // Add jitter (±25%) to avoid thundering herd
+    return delay * (0.75 + Math.random() * 0.5);
+}
+function scheduleReconnect() {
+    if (intentionalClose || !lastGatewayUrl || !lastToken)
+        return;
+    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS)
+        return;
+    reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        if (intentionalClose || !lastGatewayUrl || !lastToken)
+            return;
+        reconnectAttempts++;
+        connectInternal(lastGatewayUrl, lastToken);
+    }, getReconnectDelay());
+}
+function clearReconnectTimer() {
+    if (reconnectTimer !== null) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+    }
+}
+function connectInternal(gatewayUrl, token) {
+    if (ws) {
+        ws.onclose = null;
+        ws.onerror = null;
+        ws.close();
+    }
+    chat.update((s) => ({ ...s, reconnecting: true }));
+    let url = `${gatewayUrl}/api/chat?token=${encodeURIComponent(token)}`;
+    if (lastApiKey) {
+        url += `&apiKey=${encodeURIComponent(lastApiKey)}`;
+    }
+    ws = new WebSocket(url);
+    ws.onopen = () => {
+        // Don't reset reconnectAttempts here – wait for the server's 'connected'
+        // message which confirms the agent is reachable. Otherwise the backoff
+        // resets on every TCP-level open and AGENT_UNAVAILABLE causes a tight loop.
+    };
+    ws.onmessage = (event) => {
+        try {
+            const msg = JSON.parse(event.data);
+            if (msg.type === 'connected') {
+                reconnectAttempts = 0;
+                chat.update((s) => ({
+                    ...s,
+                    connected: true,
+                    reconnecting: false,
+                    backendVersion: msg.version ?? null
+                }));
+                return;
+            }
+            if (msg.type === 'progress' && msg.status) {
+                chat.update((s) => ({
+                    ...s,
+                    thinkingStatus: msg.status ?? null,
+                    sessionId: msg.sessionId ?? s.sessionId,
+                    loading: true
+                }));
+            }
+            else if (msg.type === 'stream' && msg.delta) {
+                chat.update((s) => {
+                    const messages = [...s.messages];
+                    const now = Date.now();
+                    const delta = msg.delta ?? '';
+                    const idx = streamingAssistantMessageId
+                        ? messages.findIndex((m) => m.id === streamingAssistantMessageId)
+                        : -1;
+                    if (idx >= 0) {
+                        messages[idx] = {
+                            ...messages[idx],
+                            content: `${messages[idx].content}${delta}`,
+                            timestamp: now
+                        };
+                    }
+                    else {
+                        streamingAssistantMessageId = `msg-${++messageCounter}`;
+                        messages.push({
+                            id: streamingAssistantMessageId,
+                            role: 'assistant',
+                            content: delta,
+                            timestamp: now
+                        });
+                    }
+                    return {
+                        ...s,
+                        messages,
+                        thinkingStatus: null,
+                        sessionId: msg.sessionId ?? s.sessionId,
+                        loading: true
+                    };
+                });
+            }
+            else if (msg.type === 'message' && msg.content) {
+                chat.update((s) => {
+                    const role = msg.role ?? 'assistant';
+                    const now = Date.now();
+                    let messages;
+                    if (!streamingAssistantMessageId) {
+                        messages = [
+                            ...s.messages,
+                            {
+                                id: `msg-${++messageCounter}`,
+                                role,
+                                content: msg.content ?? '',
+                                timestamp: now
+                            }
+                        ];
+                    }
+                    else {
+                        messages = s.messages.map((m) => m.id === streamingAssistantMessageId
+                            ? { ...m, role, content: msg.content ?? m.content, timestamp: now }
+                            : m);
+                    }
+                    return { ...s, messages, sessionId: msg.sessionId ?? s.sessionId, loading: false, thinkingStatus: null };
+                });
+                streamingAssistantMessageId = null;
+            }
+            else if (msg.type === 'error') {
+                // AGENT_UNAVAILABLE is sent right before the server closes the
+                // socket; the client will auto-reconnect so don't spam the UI.
+                if (msg.code === 'AGENT_UNAVAILABLE')
+                    return;
+                const hint = msg.code === 'AGENT_ERROR'
+                    ? ' You can retry by sending your message again.'
+                    : '';
+                const errorMsg = {
+                    id: `msg-${++messageCounter}`,
+                    role: 'system',
+                    content: `Error: ${msg.message ?? 'Unknown error'}${hint}`,
+                    timestamp: Date.now()
+                };
+                chat.update((s) => ({
+                    ...s,
+                    messages: [...s.messages, errorMsg],
+                    loading: false,
+                    thinkingStatus: null
+                }));
+                streamingAssistantMessageId = null;
+            }
+        }
+        catch {
+            // ignore parse errors
+        }
+    };
+    ws.onclose = () => {
+        chat.update((s) => ({ ...s, connected: false, reconnecting: false, loading: false }));
+        ws = null;
+        streamingAssistantMessageId = null;
+        scheduleReconnect();
+    };
+    ws.onerror = () => {
+        chat.update((s) => ({ ...s, connected: false, reconnecting: false }));
+    };
+}
+export function connect(gatewayUrl, token, apiKey) {
+    intentionalClose = false;
+    reconnectAttempts = 0;
+    lastGatewayUrl = gatewayUrl;
+    lastToken = token;
+    lastApiKey = apiKey ?? null;
+    setGatewayConfig(gatewayUrl, token, apiKey);
+    clearReconnectTimer();
+    connectInternal(gatewayUrl, token);
+    // Reconnect when the browser regains network or tab visibility
+    if (typeof window !== 'undefined') {
+        window.addEventListener('online', reconnectIfDisconnected);
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+    }
+}
+export function reconnect() {
+    if (!lastGatewayUrl || !lastToken)
+        return;
+    reconnectAttempts = 0;
+    clearReconnectTimer();
+    connectInternal(lastGatewayUrl, lastToken);
+}
+function reconnectIfDisconnected() {
+    if (intentionalClose)
+        return;
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+        reconnectAttempts = 0;
+        clearReconnectTimer();
+        if (lastGatewayUrl && lastToken) {
+            connectInternal(lastGatewayUrl, lastToken);
+        }
+    }
+}
+function handleVisibilityChange() {
+    if (document.visibilityState === 'visible') {
+        reconnectIfDisconnected();
+    }
+}
+function appendMessage(role, content) {
+    const displayMsg = {
+        id: `msg-${++messageCounter}`,
+        role,
+        content,
+        timestamp: Date.now()
+    };
+    chat.update((s) => ({ ...s, messages: [...s.messages, displayMsg] }));
+}
+function parseSide(value) {
+    const normalized = (value ?? 'both').toLowerCase();
+    if (normalized === 'buy' || normalized === 'bid')
+        return 'buy';
+    if (normalized === 'sell' || normalized === 'ask')
+        return 'sell';
+    return 'both';
+}
+function parseDirectCommand(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith('/'))
+        return null;
+    const parts = trimmed.split(/\s+/);
+    const command = parts[0]?.toLowerCase();
+    switch (command) {
+        case '/token':
+            return parts[1] ? { kind: 'token', query: parts[1] } : { kind: 'help' };
+        case '/orderbook':
+            return parts[1]
+                ? {
+                    kind: 'orderbook',
+                    tokenAddress: parts[1],
+                    side: parseSide(parts[2])
+                }
+                : { kind: 'help' };
+        case '/trades': {
+            if (!parts[1])
+                return { kind: 'help' };
+            const parsedLimit = parts[2] ? parseInt(parts[2], 10) : 20;
+            const limit = Number.isFinite(parsedLimit) ? parsedLimit : 20;
+            return { kind: 'trades', tokenAddress: parts[1], limit };
+        }
+        case '/metadata': {
+            if (!parts[1])
+                return { kind: 'help' };
+            const parsedLimit = parts[2] ? parseInt(parts[2], 10) : 1;
+            const limit = Number.isFinite(parsedLimit) ? parsedLimit : 1;
+            return { kind: 'metadata', tokenAddress: parts[1], limit };
+        }
+        case '/npv': {
+            if (parts.length < 4)
+                return { kind: 'help' };
+            const discountRate = Number(parts[1]);
+            const cashFlows = parts.slice(2).map((value) => Number(value));
+            if (!Number.isFinite(discountRate) || cashFlows.some((value) => !Number.isFinite(value))) {
+                return { kind: 'help' };
+            }
+            return { kind: 'npv', discountRate, cashFlows };
+        }
+        case '/help':
+            return { kind: 'help' };
+        default:
+            return null;
+    }
+}
+function directCommandHelpText() {
+    return [
+        'Direct commands (LLM bypass):',
+        '/token <symbol|address>',
+        '/orderbook <tokenAddress> [buy|sell|both]',
+        '/trades <tokenAddress> [limit]',
+        '/metadata <tokenAddress> [limit]',
+        '/npv <discountRate> <cashFlow1> <cashFlow2> ...'
+    ].join('\n');
+}
+async function executeDirectCommand(command) {
+    switch (command.kind) {
+        case 'help':
+            return directCommandHelpText();
+        case 'token': {
+            const response = await lookupToken(command.query);
+            const { token } = response;
+            return `Token: ${token.symbol} (${token.name})\nAddress: ${token.address}\nDecimals: ${token.decimals}`;
+        }
+        case 'orderbook': {
+            const response = await fetchOrderbook(command.tokenAddress, command.side);
+            return [
+                `Orderbook (${command.side}) ${response.tokenAddress}`,
+                `Best bid: ${response.bestBid ?? 'n/a'}`,
+                `Best ask: ${response.bestAsk ?? 'n/a'}`,
+                `Spread: ${response.spread ?? 'n/a'}`,
+                `Counts: bids=${response.bidCount}, asks=${response.askCount}`
+            ].join('\n');
+        }
+        case 'trades': {
+            const response = await fetchTrades(command.tokenAddress, command.limit);
+            return `Trades ${response.tokenAddress}: total=${response.total}\n${response.display}`;
+        }
+        case 'metadata': {
+            const response = await fetchTokenMetadata(command.tokenAddress, command.limit);
+            const decoded = response.latest?.decodedData;
+            const preview = decoded && typeof decoded === 'object'
+                ? Object.entries(decoded)
+                    .slice(0, 6)
+                    .map(([key, value]) => `${key}: ${String(value)}`)
+                    .join('\n')
+                : 'No decoded metadata available.';
+            return `Metadata ${response.address}\n${preview}`;
+        }
+        case 'npv': {
+            const response = await fetchNpv(command.cashFlows, command.discountRate);
+            return `NPV=${response.npv}${response.irr !== undefined ? `, IRR=${response.irr}` : ''}`;
+        }
+        default:
+            return 'Unsupported command.';
+    }
+}
+export function sendMessage(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return;
+    streamingAssistantMessageId = null;
+    appendMessage('user', trimmed);
+    chat.update((s) => ({ ...s, loading: true }));
+    const directCommand = parseDirectCommand(trimmed);
+    if (directCommand) {
+        void executeDirectCommand(directCommand)
+            .then((result) => {
+            appendMessage('assistant', result);
+        })
+            .catch((error) => {
+            appendMessage('system', `Error: ${error instanceof Error ? error.message : 'Request failed'}`);
+        })
+            .finally(() => {
+            chat.update((s) => ({ ...s, loading: false }));
+        });
+        return;
+    }
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+        appendMessage('system', 'Error: Chat connection is not available');
+        chat.update((s) => ({ ...s, loading: false }));
+        return;
+    }
+    const state = get(chat);
+    const msg = {
+        type: 'message',
+        content: trimmed,
+        sessionId: state.sessionId ?? undefined
+    };
+    ws.send(JSON.stringify(msg));
+}
+export function disconnect() {
+    intentionalClose = true;
+    clearReconnectTimer();
+    if (typeof window !== 'undefined') {
+        window.removeEventListener('online', reconnectIfDisconnected);
+        document.removeEventListener('visibilitychange', handleVisibilityChange);
+    }
+    if (ws) {
+        ws.close();
+        ws = null;
+    }
+    streamingAssistantMessageId = null;
+    lastGatewayUrl = null;
+    lastToken = null;
+    lastApiKey = null;
+    reconnectAttempts = 0;
+    chat.set(initial);
+}

package/dist/stores/wallet.d.ts

@@ -0,0 +1,9 @@
+import type { TxSignRequestPayload, WalletProvider } from '../types.js';
+export declare const walletProvider: import("svelte/store").Writable<WalletProvider | null>;
+export declare function setWalletProvider(provider: WalletProvider | null): void;
+export declare function clearWalletProvider(): void;
+export declare function signTransactionRequest(request: TxSignRequestPayload): Promise<string>;
+export declare function waitForTransactionConfirmation(txHash: string, { timeoutMs, pollIntervalMs }?: {
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+}): Promise<boolean>;

package/dist/stores/wallet.js

@@ -0,0 +1,90 @@
+import { get, writable } from 'svelte/store';
+export const walletProvider = writable(null);
+export function setWalletProvider(provider) {
+    walletProvider.set(provider);
+}
+export function clearWalletProvider() {
+    walletProvider.set(null);
+}
+function isAddress(value) {
+    return /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+function normalizeHexData(data) {
+    if (!data.startsWith('0x')) {
+        throw new Error('Transaction data must be a hex string');
+    }
+    if ((data.length - 2) % 2 !== 0) {
+        throw new Error('Transaction data has invalid hex length');
+    }
+    return data;
+}
+function toHexFromWei(value) {
+    const wei = value.trim() === '' ? 0n : BigInt(value);
+    return `0x${wei.toString(16)}`;
+}
+function toHexChainId(chainId) {
+    if (!Number.isInteger(chainId) || chainId <= 0) {
+        throw new Error('Invalid chainId for signing request');
+    }
+    return `0x${chainId.toString(16)}`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isLikelyMinedReceipt(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return typeof candidate.blockNumber === 'string' && candidate.blockNumber !== '0x0';
+}
+export async function signTransactionRequest(request) {
+    const provider = get(walletProvider);
+    if (!provider) {
+        throw new Error('Wallet provider is not available. Please reconnect Dynamic.');
+    }
+    if (request.kind !== 'evm_send_transaction') {
+        throw new Error(`Unsupported sign request kind: ${request.kind}`);
+    }
+    if (!isAddress(request.from)) {
+        throw new Error('Invalid signer address in sign request');
+    }
+    if (!isAddress(request.to)) {
+        throw new Error('Invalid target address in sign request');
+    }
+    const txRequest = {
+        from: request.from,
+        to: request.to,
+        data: normalizeHexData(request.data),
+        value: toHexFromWei(request.value ?? '0'),
+        chainId: toHexChainId(request.chainId)
+    };
+    const result = await provider.request({
+        method: 'eth_sendTransaction',
+        params: [txRequest]
+    });
+    if (typeof result !== 'string' || !result.startsWith('0x')) {
+        throw new Error('Wallet provider returned an invalid transaction hash');
+    }
+    return result;
+}
+export async function waitForTransactionConfirmation(txHash, { timeoutMs = 180_000, pollIntervalMs = 3_000 } = {}) {
+    const provider = get(walletProvider);
+    if (!provider) {
+        throw new Error('Wallet provider is not available. Please reconnect Dynamic.');
+    }
+    if (!/^0x[a-fA-F0-9]{64}$/.test(txHash)) {
+        throw new Error('Invalid transaction hash');
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const receipt = await provider.request({
+            method: 'eth_getTransactionReceipt',
+            params: [txHash]
+        });
+        if (isLikelyMinedReceipt(receipt)) {
+            return true;
+        }
+        await sleep(pollIntervalMs);
+    }
+    return false;
+}

package/dist/types.d.ts

@@ -0,0 +1,44 @@
+export interface DisplayMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: number;
+}
+export interface WalletProvider {
+    request: (args: {
+        method: string;
+        params?: unknown[];
+    }) => Promise<unknown>;
+}
+export interface TxSignRequestPayload {
+    kind: 'evm_send_transaction';
+    chainId: number;
+    from: string;
+    to: string;
+    data: string;
+    value: string;
+    summary?: {
+        to?: string;
+        valueWei?: string;
+        dataBytes?: number;
+    };
+}
+export interface ChatWidgetConfig {
+    gatewayUrl: string;
+    token?: string;
+}
+export interface FloatingChatWidgetConfig {
+    gatewayUrl: string;
+    apiKey: string;
+    position?: 'bottom-right' | 'bottom-left';
+    offset?: {
+        x: number;
+        y: number;
+    };
+    startOpen?: boolean;
+}
+export interface FloatingChatCallbacks {
+    onRequestWalletConnect?: () => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@albionlabs/chat-widget",
+  "version": "0.1.0",
+  "type": "module",
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "@sveltejs/package": "^2.3.0",
+    "svelte": "^5.0.0",
+    "svelte-check": "^4.0.0",
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "typescript": "^5.9.3",
+    "vite": "^6.3.0",
+    "@quant-bot/config": "0.0.1"
+  },
+  "scripts": {
+    "build": "svelte-package",
+    "check": "svelte-check --tsconfig ./tsconfig.json",
+    "lint": "eslint src/"
+  }
+}