@windrun-huaiin/third-ui 15.1.1 → 16.0.1

package/dist/ai/ai-status-indicator.js

@@ -0,0 +1,51 @@
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var utils = require('@windrun-huaiin/lib/utils');
+
+function getLabel(status) {
+    switch (status) {
+        case 'streaming':
+            return 'Streaming';
+        case 'completed':
+            return 'Completed';
+        case 'stopped':
+            return 'Stopped';
+        case 'timeout':
+            return 'Timeout';
+        case 'request_aborted':
+            return 'Aborted';
+        case 'failed':
+            return 'Failed';
+        default:
+            return null;
+    }
+}
+function getStatusClassName(status) {
+    switch (status) {
+        case 'completed':
+            return 'border-emerald-200 bg-emerald-50 text-emerald-700 dark:border-emerald-900/60 dark:bg-emerald-950/40 dark:text-emerald-300';
+        case 'streaming':
+            return 'border-sky-200 bg-sky-50 text-sky-700 dark:border-sky-900/60 dark:bg-sky-950/40 dark:text-sky-300';
+        case 'stopped':
+            return 'border-rose-200 bg-rose-50 text-rose-700 dark:border-rose-900/60 dark:bg-rose-950/40 dark:text-rose-300';
+        case 'timeout':
+            return 'border-amber-200 bg-amber-50 text-amber-700 dark:border-amber-900/60 dark:bg-amber-950/40 dark:text-amber-300';
+        case 'request_aborted':
+            return 'border-orange-200 bg-orange-50 text-orange-700 dark:border-orange-900/60 dark:bg-orange-950/40 dark:text-orange-300';
+        case 'failed':
+            return 'border-red-200 bg-red-50 text-red-700 dark:border-red-900/60 dark:bg-red-950/40 dark:text-red-300';
+        default:
+            return 'border-border bg-background text-muted-foreground';
+    }
+}
+function AIStatusIndicator({ message, className }) {
+    const label = getLabel(message.status);
+    if (!label) {
+        return null;
+    }
+    return (jsxRuntime.jsx("span", { className: utils.cn('inline-flex items-center rounded-full border px-2 py-0.5 text-[11px] uppercase tracking-[0.12em]', getStatusClassName(message.status), className), children: label }));
+}
+
+exports.AIStatusIndicator = AIStatusIndicator;

package/dist/ai/ai-status-indicator.mjs

@@ -0,0 +1,49 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { cn } from '@windrun-huaiin/lib/utils';
+
+function getLabel(status) {
+    switch (status) {
+        case 'streaming':
+            return 'Streaming';
+        case 'completed':
+            return 'Completed';
+        case 'stopped':
+            return 'Stopped';
+        case 'timeout':
+            return 'Timeout';
+        case 'request_aborted':
+            return 'Aborted';
+        case 'failed':
+            return 'Failed';
+        default:
+            return null;
+    }
+}
+function getStatusClassName(status) {
+    switch (status) {
+        case 'completed':
+            return 'border-emerald-200 bg-emerald-50 text-emerald-700 dark:border-emerald-900/60 dark:bg-emerald-950/40 dark:text-emerald-300';
+        case 'streaming':
+            return 'border-sky-200 bg-sky-50 text-sky-700 dark:border-sky-900/60 dark:bg-sky-950/40 dark:text-sky-300';
+        case 'stopped':
+            return 'border-rose-200 bg-rose-50 text-rose-700 dark:border-rose-900/60 dark:bg-rose-950/40 dark:text-rose-300';
+        case 'timeout':
+            return 'border-amber-200 bg-amber-50 text-amber-700 dark:border-amber-900/60 dark:bg-amber-950/40 dark:text-amber-300';
+        case 'request_aborted':
+            return 'border-orange-200 bg-orange-50 text-orange-700 dark:border-orange-900/60 dark:bg-orange-950/40 dark:text-orange-300';
+        case 'failed':
+            return 'border-red-200 bg-red-50 text-red-700 dark:border-red-900/60 dark:bg-red-950/40 dark:text-red-300';
+        default:
+            return 'border-border bg-background text-muted-foreground';
+    }
+}
+function AIStatusIndicator({ message, className }) {
+    const label = getLabel(message.status);
+    if (!label) {
+        return null;
+    }
+    return (jsx("span", { className: cn('inline-flex items-center rounded-full border px-2 py-0.5 text-[11px] uppercase tracking-[0.12em]', getStatusClassName(message.status), className), children: label }));
+}
+
+export { AIStatusIndicator };

package/dist/ai/index.d.ts

@@ -0,0 +1,11 @@
+export { getMessageText, getTextParts, type ConversationMessage, type MessagePart } from '@windrun-huaiin/contracts/ai';
+export * from './types';
+export * from './use-ai-conversation';
+export * from './ai-chat-composer';
+export * from './ai-message-list';
+export * from './ai-message-bubble';
+export * from './ai-markdown';
+export * from './ai-message-content';
+export * from './ai-message-meta';
+export * from './ai-message-actions';
+export * from './ai-status-indicator';

package/dist/ai/index.js

@@ -0,0 +1,33 @@
+"use client";
+'use strict';
+
+var ai = require('@windrun-huaiin/contracts/ai');
+var useAiConversation = require('./use-ai-conversation.js');
+var aiChatComposer = require('./ai-chat-composer.js');
+var aiMessageList = require('./ai-message-list.js');
+var aiMessageBubble = require('./ai-message-bubble.js');
+var aiMarkdown = require('./ai-markdown.js');
+var aiMessageContent = require('./ai-message-content.js');
+var aiMessageMeta = require('./ai-message-meta.js');
+var aiMessageActions = require('./ai-message-actions.js');
+var aiStatusIndicator = require('./ai-status-indicator.js');
+
+
+
+Object.defineProperty(exports, "getMessageText", {
+	enumerable: true,
+	get: function () { return ai.getMessageText; }
+});
+Object.defineProperty(exports, "getTextParts", {
+	enumerable: true,
+	get: function () { return ai.getTextParts; }
+});
+exports.useAIConversation = useAiConversation.useAIConversation;
+exports.AIChatComposer = aiChatComposer.AIChatComposer;
+exports.AIMessageList = aiMessageList.AIMessageList;
+exports.AIMessageBubble = aiMessageBubble.AIMessageBubble;
+exports.AIMarkdown = aiMarkdown.AIMarkdown;
+exports.AIMessageContent = aiMessageContent.AIMessageContent;
+exports.AIMessageMeta = aiMessageMeta.AIMessageMeta;
+exports.AIMessageActions = aiMessageActions.AIMessageActions;
+exports.AIStatusIndicator = aiStatusIndicator.AIStatusIndicator;

package/dist/ai/index.mjs

@@ -0,0 +1,11 @@
+"use client";
+export { getMessageText, getTextParts } from '@windrun-huaiin/contracts/ai';
+export { useAIConversation } from './use-ai-conversation.mjs';
+export { AIChatComposer } from './ai-chat-composer.mjs';
+export { AIMessageList } from './ai-message-list.mjs';
+export { AIMessageBubble } from './ai-message-bubble.mjs';
+export { AIMarkdown } from './ai-markdown.mjs';
+export { AIMessageContent } from './ai-message-content.mjs';
+export { AIMessageMeta } from './ai-message-meta.mjs';
+export { AIMessageActions } from './ai-message-actions.mjs';
+export { AIStatusIndicator } from './ai-status-indicator.mjs';

package/dist/ai/types.d.ts

@@ -0,0 +1,110 @@
+import type { AIRuntimeRequest, AIStreamEvent, ConversationMessage, MessagePart } from '@windrun-huaiin/contracts/ai';
+import type { ComponentType, ReactNode, RefObject } from 'react';
+export type AIConversationTransport = (input: AIRuntimeRequest, signal: AbortSignal) => Promise<Response>;
+export type AIConversationState = {
+    sessionId?: string;
+    messages: ConversationMessage[];
+    isStreaming: boolean;
+    error?: string;
+};
+export type AIConversationOptions = {
+    endpoint: string;
+    initialSessionId?: string;
+    initialMessages?: ConversationMessage[];
+    modelName?: string;
+    metadata?: Record<string, unknown>;
+    transport?: AIConversationTransport;
+    onEvent?: (event: AIStreamEvent) => void;
+    onError?: (error: Error) => void;
+};
+export type SendMessageInput = {
+    text: string;
+    metadata?: Record<string, unknown>;
+};
+export type AIChatComposerProps = {
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit: () => void;
+    onStop?: () => void;
+    disabled?: boolean;
+    isStreaming?: boolean;
+    placeholder?: string;
+    className?: string;
+    leftSlot?: ReactNode;
+    attachments?: ReactNode;
+    helper?: ReactNode;
+    submitLabel?: string;
+    stopLabel?: string;
+    minHeight?: number;
+    maxHeight?: number;
+    submitOnEnter?: boolean;
+    shellClassName?: string;
+    textareaClassName?: string;
+    submitControl?: ReactNode;
+    stopControl?: ReactNode;
+    textareaRef?: RefObject<HTMLTextAreaElement | null>;
+    secondaryActions?: ReactNode;
+    actionLayout?: 'inline' | 'stacked';
+};
+export type AIMessageBubbleProps = {
+    message: ConversationMessage;
+    className?: string;
+    cardClassName?: string;
+    contentClassName?: string;
+    footerClassName?: string;
+    maxWidthClassName?: string;
+    showRoleLabel?: boolean;
+    markdownComponents?: AIMarkdownComponentMap;
+    showFooter?: boolean;
+    renderContent?: (message: ConversationMessage) => ReactNode;
+    renderMeta?: (message: ConversationMessage) => ReactNode;
+    renderActions?: (message: ConversationMessage) => ReactNode;
+};
+export type AIMessageListProps = {
+    messages: ConversationMessage[];
+    className?: string;
+    contentClassName?: string;
+    emptyText?: string;
+    emptyState?: ReactNode;
+    autoScroll?: boolean;
+    scrollBehavior?: ScrollBehavior;
+    renderMessage?: (message: ConversationMessage) => ReactNode;
+};
+export type AIStatusIndicatorProps = {
+    message: ConversationMessage;
+    className?: string;
+};
+export type AIMessageContentProps = {
+    message: ConversationMessage;
+    className?: string;
+    markdownComponents?: AIMarkdownComponentMap;
+};
+export type AIMessageMetaProps = {
+    message: ConversationMessage;
+    className?: string;
+    showTime?: boolean;
+    showStatus?: boolean;
+    showRuntime?: boolean;
+    showFailureReason?: boolean;
+};
+export type AIMessageActionsProps = {
+    className?: string;
+    children?: ReactNode;
+};
+export type AIMarkdownComponentMap = Record<string, ComponentType<any>>;
+export type AIMarkdownProps = {
+    content: string;
+    className?: string;
+    components?: AIMarkdownComponentMap;
+};
+export type TextMessagePart = Extract<MessagePart, {
+    type: 'text';
+}>;
+export type AIMessageRuntimeMetadata = {
+    requestStartedAt?: number;
+    streamStartedAt?: number;
+    firstTokenAt?: number;
+    firstTokenMs?: number;
+    completedAt?: number;
+    totalMs?: number;
+};

package/dist/ai/use-ai-conversation.d.ts

@@ -0,0 +1,13 @@
+import { type ConversationMessage } from '@windrun-huaiin/contracts/ai';
+import type { AIConversationOptions, SendMessageInput } from './types';
+export declare function useAIConversation(options: AIConversationOptions): {
+    sendMessage: (input: SendMessageInput) => Promise<void>;
+    stopGeneration: () => void;
+    resetConversation: () => void;
+    removeMessage: (messageId: string) => void;
+    loadConversation: (messages: ConversationMessage[], sessionId?: string) => void;
+    sessionId?: string;
+    messages: ConversationMessage[];
+    isStreaming: boolean;
+    error?: string;
+};

package/dist/ai/use-ai-conversation.js

@@ -0,0 +1,276 @@
+"use client";
+'use strict';
+
+var tslib = require('tslib');
+var React = require('react');
+
+function createId(prefix) {
+    try {
+        return `${prefix}-${crypto.randomUUID()}`;
+    }
+    catch (_a) {
+        return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    }
+}
+function getAssistantMessageText(message) {
+    return message.parts
+        .flatMap((part) => (part.type === 'text' ? [part.text] : []))
+        .join('');
+}
+function createUserMessage(input) {
+    return {
+        id: createId('user'),
+        role: 'user',
+        parts: [{ type: 'text', text: input.text }],
+        createdAt: Date.now(),
+        metadata: input.metadata,
+    };
+}
+function getRuntimeMetadata(message) {
+    var _a;
+    const metadata = (_a = message.metadata) === null || _a === void 0 ? void 0 : _a.aiRuntime;
+    if (!metadata || typeof metadata !== 'object') {
+        return {};
+    }
+    return metadata;
+}
+function withRuntimeMetadata(message, nextMetadata) {
+    var _a;
+    return Object.assign(Object.assign({}, message), { metadata: Object.assign(Object.assign({}, ((_a = message.metadata) !== null && _a !== void 0 ? _a : {})), { aiRuntime: Object.assign(Object.assign({}, getRuntimeMetadata(message)), nextMetadata) }) });
+}
+function createAssistantPlaceholder(requestStartedAt) {
+    return {
+        id: createId('assistant'),
+        role: 'assistant',
+        parts: [{ type: 'text', text: '' }],
+        status: 'streaming',
+        createdAt: Date.now(),
+        metadata: {
+            aiRuntime: {
+                requestStartedAt,
+            },
+        },
+    };
+}
+function defaultTransport(endpoint) {
+    return (input, signal) => tslib.__awaiter(this, void 0, void 0, function* () {
+        return fetch(endpoint, {
+            method: 'POST',
+            signal,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(input),
+        });
+    });
+}
+function updateAssistantText(messages, messageId, textDelta) {
+    return messages.map((message) => {
+        if (message.id !== messageId) {
+            return message;
+        }
+        const currentText = getAssistantMessageText(message);
+        const runtimeMetadata = getRuntimeMetadata(message);
+        const now = Date.now();
+        return withRuntimeMetadata(Object.assign(Object.assign({}, message), { parts: [{ type: 'text', text: currentText + textDelta }], status: 'streaming' }), runtimeMetadata.firstTokenAt
+            ? {}
+            : {
+                firstTokenAt: now,
+                firstTokenMs: runtimeMetadata.requestStartedAt
+                    ? now - runtimeMetadata.requestStartedAt
+                    : undefined,
+            });
+    });
+}
+function updateMessageStarted(messages, placeholderId, messageId) {
+    return messages.map((message) => {
+        if (message.id !== placeholderId) {
+            return message;
+        }
+        return withRuntimeMetadata(Object.assign(Object.assign({}, message), { id: messageId }), {
+            streamStartedAt: Date.now(),
+        });
+    });
+}
+function updateMessageStatus(messages, messageId, status) {
+    return messages.map((message) => {
+        if (message.id !== messageId) {
+            return message;
+        }
+        const now = Date.now();
+        const runtimeMetadata = getRuntimeMetadata(message);
+        return withRuntimeMetadata(Object.assign(Object.assign({}, message), { status }), {
+            completedAt: now,
+            totalMs: runtimeMetadata.requestStartedAt
+                ? now - runtimeMetadata.requestStartedAt
+                : undefined,
+        });
+    });
+}
+function applyErrorToLatestAssistant(messages, error) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message.role !== 'assistant') {
+            continue;
+        }
+        const nextMessages = [...messages];
+        const now = Date.now();
+        const runtimeMetadata = getRuntimeMetadata(message);
+        nextMessages[index] = withRuntimeMetadata(Object.assign(Object.assign({}, message), { status: error.status, failureReason: error.failureReason, errorMessage: error.error, upstreamStatusCode: error.upstreamStatusCode }), {
+            completedAt: now,
+            totalMs: runtimeMetadata.requestStartedAt
+                ? now - runtimeMetadata.requestStartedAt
+                : undefined,
+        });
+        return nextMessages;
+    }
+    return messages;
+}
+function consumeEventStream(response, onEvent) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!response.body) {
+            throw new Error('Missing response body');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        for (;;) {
+            const chunk = yield reader.read();
+            if (chunk.done) {
+                break;
+            }
+            buffer += decoder.decode(chunk.value, { stream: true });
+            const frames = buffer.split('\n\n');
+            buffer = (_a = frames.pop()) !== null && _a !== void 0 ? _a : '';
+            for (const frame of frames) {
+                const line = frame
+                    .split('\n')
+                    .find((item) => item.startsWith('data: '));
+                if (!line) {
+                    continue;
+                }
+                onEvent(JSON.parse(line.slice(6)));
+            }
+        }
+    });
+}
+function useAIConversation(options) {
+    var _a, _b;
+    const transport = (_a = options.transport) !== null && _a !== void 0 ? _a : defaultTransport(options.endpoint);
+    const [state, setState] = React.useState({
+        sessionId: options.initialSessionId,
+        messages: (_b = options.initialMessages) !== null && _b !== void 0 ? _b : [],
+        isStreaming: false,
+    });
+    const abortRef = React.useRef(null);
+    const sendMessage = (input) => tslib.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const text = input.text.trim();
+        if (!text || state.isStreaming) {
+            return;
+        }
+        const userMessage = createUserMessage(input);
+        const requestStartedAt = Date.now();
+        const assistantMessage = createAssistantPlaceholder(requestStartedAt);
+        React.startTransition(() => {
+            setState((current) => (Object.assign(Object.assign({}, current), { messages: [...current.messages, userMessage, assistantMessage], isStreaming: true, error: undefined })));
+        });
+        const controller = new AbortController();
+        abortRef.current = controller;
+        try {
+            const response = yield transport({
+                sessionId: state.sessionId,
+                messages: [...state.messages, userMessage],
+                modelName: options.modelName,
+                metadata: Object.assign(Object.assign({}, ((_a = options.metadata) !== null && _a !== void 0 ? _a : {})), ((_b = input.metadata) !== null && _b !== void 0 ? _b : {})),
+            }, controller.signal);
+            if (!response.ok) {
+                const payload = (yield response.json());
+                throw new Error(payload.error || 'AI request failed');
+            }
+            yield consumeEventStream(response, (event) => {
+                var _a;
+                (_a = options.onEvent) === null || _a === void 0 ? void 0 : _a.call(options, event);
+                React.startTransition(() => {
+                    setState((current) => {
+                        if (event.type === 'message_started') {
+                            return Object.assign(Object.assign({}, current), { messages: updateMessageStarted(current.messages, assistantMessage.id, event.messageId) });
+                        }
+                        if (event.type === 'text_delta') {
+                            return Object.assign(Object.assign({}, current), { messages: updateAssistantText(current.messages, event.messageId, event.text) });
+                        }
+                        if (event.type === 'part') {
+                            return Object.assign(Object.assign({}, current), { messages: current.messages.map((message) => {
+                                    if (message.id !== event.messageId) {
+                                        return message;
+                                    }
+                                    return Object.assign(Object.assign({}, message), { parts: [...message.parts, event.part] });
+                                }) });
+                        }
+                        if (event.type === 'message_completed') {
+                            return Object.assign(Object.assign({}, current), { isStreaming: false, messages: updateMessageStatus(current.messages, event.messageId, 'completed') });
+                        }
+                        if (event.type === 'error') {
+                            return Object.assign(Object.assign({}, current), { isStreaming: false, error: event.error.error, messages: applyErrorToLatestAssistant(current.messages, event.error) });
+                        }
+                        return current;
+                    });
+                });
+            });
+            React.startTransition(() => {
+                setState((current) => (Object.assign(Object.assign({}, current), { isStreaming: false })));
+            });
+        }
+        catch (error) {
+            const nextError = error instanceof Error ? error : new Error('AI request failed');
+            (_c = options.onError) === null || _c === void 0 ? void 0 : _c.call(options, nextError);
+            React.startTransition(() => {
+                setState((current) => (Object.assign(Object.assign({}, current), { isStreaming: false, error: nextError.message, messages: applyErrorToLatestAssistant(current.messages, {
+                        error: nextError.message,
+                        status: controller.signal.aborted ? 'request_aborted' : 'failed',
+                        failureReason: 'unknown',
+                        upstreamStatusCode: controller.signal.aborted ? 499 : 500,
+                    }) })));
+            });
+        }
+        finally {
+            abortRef.current = null;
+        }
+    });
+    const stopGeneration = () => {
+        var _a;
+        (_a = abortRef.current) === null || _a === void 0 ? void 0 : _a.abort();
+    };
+    const resetConversation = () => {
+        React.startTransition(() => {
+            var _a;
+            setState({
+                sessionId: options.initialSessionId,
+                messages: (_a = options.initialMessages) !== null && _a !== void 0 ? _a : [],
+                isStreaming: false,
+            });
+        });
+    };
+    const removeMessage = (messageId) => {
+        React.startTransition(() => {
+            setState((current) => (Object.assign(Object.assign({}, current), { messages: current.messages.filter((message) => message.id !== messageId) })));
+        });
+    };
+    const loadConversation = (messages, sessionId) => {
+        React.startTransition(() => {
+            setState({
+                sessionId,
+                messages,
+                isStreaming: false,
+            });
+        });
+    };
+    return Object.assign(Object.assign({}, state), { sendMessage,
+        stopGeneration,
+        resetConversation,
+        removeMessage,
+        loadConversation });
+}
+
+exports.useAIConversation = useAIConversation;