@agent-platform/ui 0.0.12 → 0.0.14

package/dist/components/agent/provider/use-agent-chat.js

@@ -1,493 +0,0 @@
-'use client';
-import { useCallback, useRef, useState } from 'react';
-import { parseSSEBuffer } from './parse-sse-buffer';
-/** クライアントツール自動継続の最大回数 */
-const MAX_CONTINUE_ROUNDS = 10;
-function isLikelyJwtToken(token) {
-    const normalized = token.startsWith('Bearer ') ? token.slice(7) : token;
-    return normalized.split('.').length === 3;
-}
-function normalizeErrorMessage(error) {
-    if (typeof error === 'string' && error.trim().length > 0)
-        return error;
-    if (typeof error === 'object' &&
-        error !== null &&
-        'message' in error &&
-        typeof error.message === 'string') {
-        return error.message;
-    }
-    if (error !== undefined) {
-        try {
-            return JSON.stringify(error);
-        }
-        catch {
-            return String(error);
-        }
-    }
-    return 'Unknown error';
-}
-// --- イベントハンドラ ---
-function handleTextDelta(text, accumulatedText, toolCalls, assistantMessageId, setMessages) {
-    const newText = accumulatedText + text;
-    setMessages((prev) => {
-        const updated = [...prev];
-        const idx = updated.findIndex((m) => m.id === assistantMessageId);
-        const existing = idx >= 0 ? updated[idx] : undefined;
-        if (existing) {
-            const content = [{ type: 'text', text: newText }];
-            for (const tc of toolCalls) {
-                content.push({ type: 'tool-call', toolCall: tc });
-            }
-            updated[idx] = { id: existing.id, role: existing.role, content, isStreaming: true };
-        }
-        return updated;
-    });
-    return newText;
-}
-function handleToolCall(tc, accumulatedText, toolCalls, assistantMessageId, setMessages, setPendingToolCalls) {
-    toolCalls.push(tc);
-    setPendingToolCalls((prev) => {
-        const newMap = new Map(prev);
-        newMap.set(tc.toolCallId, { toolCall: tc, status: 'pending' });
-        return newMap;
-    });
-    setMessages((prev) => {
-        const updated = [...prev];
-        const idx = updated.findIndex((m) => m.id === assistantMessageId);
-        const existing = idx >= 0 ? updated[idx] : undefined;
-        if (existing) {
-            const content = [];
-            if (accumulatedText) {
-                content.push({ type: 'text', text: accumulatedText });
-            }
-            for (const t of toolCalls) {
-                content.push({ type: 'tool-call', toolCall: t });
-            }
-            updated[idx] = { id: existing.id, role: existing.role, content, isStreaming: true };
-        }
-        return updated;
-    });
-}
-function handleToolResult(tr, serverResolvedToolIds, setPendingToolCalls) {
-    serverResolvedToolIds.add(tr.toolCallId);
-    setPendingToolCalls((prev) => {
-        const newMap = new Map(prev);
-        const state = newMap.get(tr.toolCallId);
-        if (state) {
-            newMap.set(tr.toolCallId, {
-                ...state,
-                status: tr.isError ? 'error' : 'completed',
-                result: tr.result,
-                error: tr.isError ? normalizeErrorMessage(tr.result) : undefined,
-            });
-        }
-        return newMap;
-    });
-}
-function handleFinish(assistantMessageId, setMessages) {
-    setMessages((prev) => {
-        const updated = [...prev];
-        const idx = updated.findIndex((m) => m.id === assistantMessageId);
-        const existing = idx >= 0 ? updated[idx] : undefined;
-        if (existing) {
-            updated[idx] = {
-                id: existing.id,
-                role: existing.role,
-                content: existing.content,
-                isStreaming: false,
-            };
-        }
-        return updated;
-    });
-}
-// --- メインフック ---
-/**
- * apiEndpointからAPIを実行
- */
-async function executeApiEndpoint(toolCall, apiBaseUrl, authHeaders) {
-    console.log('[executeApiEndpoint] ─────────────────────────────────────────');
-    console.log('[executeApiEndpoint] toolCall:', JSON.stringify(toolCall, null, 2));
-    const { apiEndpoint, input } = toolCall;
-    if (!apiEndpoint) {
-        console.log('[executeApiEndpoint] ERROR: No API endpoint defined');
-        return { output: 'No API endpoint defined for this tool', isError: true };
-    }
-    console.log('[executeApiEndpoint] apiEndpoint:', JSON.stringify(apiEndpoint, null, 2));
-    console.log('[executeApiEndpoint] input:', JSON.stringify(input, null, 2));
-    const inputData = (input ?? {});
-    let path = apiEndpoint.path;
-    // パスパラメータを置換 (e.g., /candidates/{id} -> /candidates/123)
-    const pathParamRegex = /\{(\w+)\}/g;
-    let match;
-    const usedParams = new Set();
-    // biome-ignore lint/suspicious/noAssignInExpressions: 標準的なパターン
-    while ((match = pathParamRegex.exec(apiEndpoint.path)) !== null) {
-        const paramName = match[1];
-        if (!paramName)
-            continue;
-        const value = inputData[paramName];
-        if (value !== undefined) {
-            path = path.replace(`{${paramName}}`, encodeURIComponent(String(value)));
-            usedParams.add(paramName);
-        }
-    }
-    // クエリパラメータを構築 (GET/DELETE時)
-    let url = `${apiBaseUrl}${path}`;
-    const queryParams = {};
-    const bodyData = {};
-    for (const [key, value] of Object.entries(inputData)) {
-        if (usedParams.has(key) || value === undefined)
-            continue;
-        if (['GET', 'DELETE'].includes(apiEndpoint.method)) {
-            queryParams[key] = String(value);
-        }
-        else {
-            bodyData[key] = value;
-        }
-    }
-    const queryString = new URLSearchParams(queryParams).toString();
-    if (queryString)
-        url += `?${queryString}`;
-    console.log('[executeApiEndpoint] Final URL:', url);
-    console.log('[executeApiEndpoint] Method:', apiEndpoint.method);
-    console.log('[executeApiEndpoint] Query params:', JSON.stringify(queryParams, null, 2));
-    console.log('[executeApiEndpoint] Body data:', JSON.stringify(bodyData, null, 2));
-    try {
-        const fetchOptions = {
-            method: apiEndpoint.method,
-            headers: {
-                'Content-Type': 'application/json',
-                ...authHeaders,
-            },
-            credentials: 'include',
-        };
-        if (['POST', 'PUT', 'PATCH'].includes(apiEndpoint.method) && Object.keys(bodyData).length > 0) {
-            fetchOptions.body = JSON.stringify(bodyData);
-            console.log('[executeApiEndpoint] Request body:', fetchOptions.body);
-        }
-        console.log('[executeApiEndpoint] Sending request...');
-        const response = await fetch(url, fetchOptions);
-        const text = await response.text();
-        console.log('[executeApiEndpoint] Response status:', response.status);
-        console.log('[executeApiEndpoint] Response text:', text.slice(0, 500));
-        let data;
-        try {
-            data = JSON.parse(text);
-        }
-        catch {
-            data = { raw: text, status: response.status };
-        }
-        if (!response.ok) {
-            return { output: data, isError: true };
-        }
-        return { output: data };
-    }
-    catch (e) {
-        return {
-            output: e instanceof Error ? e.message : 'Network error',
-            isError: true,
-        };
-    }
-}
-export function useAgentChatInternal(options) {
-    const { config } = options;
-    const { endpoint, agentId = 'assistant', apiBaseUrl, executeClientTool, onError, authToken, getAuthToken, getAgentHeaders, disableToolApiAuthHeader = false, } = config;
-    const [messages, setMessages] = useState([]);
-    const [threadId, setThreadId] = useState(null);
-    const [isLoading, setIsLoading] = useState(false);
-    const [error, setError] = useState(null);
-    const [pendingToolCalls, setPendingToolCalls] = useState(new Map());
-    const abortControllerRef = useRef(null);
-    const buildAgentHeaders = useCallback(async () => {
-        const headers = { 'Content-Type': 'application/json' };
-        const token = getAuthToken ? await getAuthToken() : authToken;
-        console.log('[buildAgentHeaders] Building headers for agent request: ', token ? 'with auth' : 'no auth');
-        if (token) {
-            headers['Authorization'] = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
-        }
-        const customHeaders = getAgentHeaders ? await getAgentHeaders() : undefined;
-        if (customHeaders) {
-            for (const [key, value] of Object.entries(customHeaders)) {
-                if (value) {
-                    headers[key] = value;
-                }
-            }
-        }
-        return headers;
-    }, [authToken, getAuthToken, getAgentHeaders]);
-    const handleError = useCallback((errorInput) => {
-        const errorMessage = normalizeErrorMessage(errorInput);
-        setError(errorMessage);
-        onError?.(errorMessage);
-    }, [onError]);
-    const processStream = useCallback(async (response, assistantMessageId, onThreadId) => {
-        const reader = response.body?.getReader();
-        if (!reader)
-            return { clientToolResults: [], clientToolCalls: [] };
-        const decoder = new TextDecoder();
-        let buffer = '';
-        let accumulatedText = '';
-        const toolCalls = [];
-        const serverResolvedToolIds = new Set();
-        const clientToolResults = [];
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const { events, remaining } = parseSSEBuffer(buffer);
-                buffer = remaining;
-                for (const event of events) {
-                    switch (event.type) {
-                        case 'thread-id':
-                            onThreadId?.(event.payload.threadId);
-                            break;
-                        case 'text-delta':
-                            accumulatedText = handleTextDelta(event.payload.text, accumulatedText, toolCalls, assistantMessageId, setMessages);
-                            break;
-                        case 'tool-call':
-                            console.log('[processStream] Received tool-call event:', JSON.stringify(event.payload, null, 2));
-                            handleToolCall(event.payload, accumulatedText, toolCalls, assistantMessageId, setMessages, setPendingToolCalls);
-                            break;
-                        case 'tool-result':
-                            handleToolResult(event.payload, serverResolvedToolIds, setPendingToolCalls);
-                            break;
-                        case 'finish':
-                            handleFinish(assistantMessageId, setMessages);
-                            break;
-                        case 'error':
-                            handleError(event.payload.error);
-                            break;
-                    }
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-        // クライアントツール実行
-        // apiBaseUrl + apiEndpointがあれば自動実行、なければ従来のexecuteClientTool
-        console.log('[processStream] ═════════════════════════════════════════');
-        console.log('[processStream] Client tool execution phase');
-        console.log('[processStream] Total tool calls received:', toolCalls.length);
-        console.log('[processStream] Server resolved tool IDs:', Array.from(serverResolvedToolIds));
-        console.log('[processStream] apiBaseUrl:', apiBaseUrl);
-        const executedClientToolCalls = [];
-        const unresolvedCalls = toolCalls.filter((tc) => !serverResolvedToolIds.has(tc.toolCallId));
-        console.log('[processStream] Unresolved calls (to execute on client):', unresolvedCalls.length);
-        for (const tc of unresolvedCalls) {
-            console.log('[processStream]   - toolName:', tc.toolName, 'toolCallId:', tc.toolCallId);
-            console.log('[processStream]     input:', JSON.stringify(tc.input, null, 2));
-            console.log('[processStream]     apiEndpoint:', JSON.stringify(tc.apiEndpoint, null, 2));
-        }
-        // 認証ヘッダーを構築
-        const toolApiHeaders = {};
-        if (!disableToolApiAuthHeader) {
-            const token = getAuthToken ? await getAuthToken() : authToken;
-            // Tool APIはcredentials: 'include'でCookie送信されるため、
-            // 非JWT（例: ANON_KEY）はAuthorizationヘッダーに載せずCookie認証を優先する。
-            if (token && isLikelyJwtToken(token)) {
-                toolApiHeaders['Authorization'] = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
-            }
-        }
-        for (const tc of unresolvedCalls) {
-            // apiBaseUrlとapiEndpointがある場合は自動実行
-            const canAutoExecute = Boolean(tc.apiEndpoint);
-            // 従来のexecuteClientToolがある場合はそれを使用
-            const canLegacyExecute = executeClientTool;
-            if (!canAutoExecute && !canLegacyExecute) {
-                // 実行手段がない場合はスキップ
-                continue;
-            }
-            executedClientToolCalls.push(tc);
-            setPendingToolCalls((prev) => {
-                const newMap = new Map(prev);
-                const state = newMap.get(tc.toolCallId);
-                if (state) {
-                    newMap.set(tc.toolCallId, { ...state, status: 'executing' });
-                }
-                return newMap;
-            });
-            try {
-                let result;
-                if (canAutoExecute) {
-                    // 新しい自動実行パス
-                    result = await executeApiEndpoint(tc, apiBaseUrl, toolApiHeaders);
-                }
-                else if (canLegacyExecute) {
-                    // 従来のexecuteClientToolを使用（後方互換性）
-                    result = await executeClientTool(tc);
-                }
-                else {
-                    result = { output: 'No execution method available', isError: true };
-                }
-                const isError = result.isError ?? false;
-                setPendingToolCalls((prev) => {
-                    const newMap = new Map(prev);
-                    newMap.set(tc.toolCallId, {
-                        toolCall: tc,
-                        status: isError ? 'error' : 'completed',
-                        result: result.output,
-                        error: isError ? normalizeErrorMessage(result.output) : undefined,
-                    });
-                    return newMap;
-                });
-                clientToolResults.push({ toolCallId: tc.toolCallId, result: result.output, isError });
-            }
-            catch (e) {
-                const errorMsg = e instanceof Error ? e.message : 'Unknown error';
-                setPendingToolCalls((prev) => {
-                    const newMap = new Map(prev);
-                    newMap.set(tc.toolCallId, { toolCall: tc, status: 'error', error: errorMsg });
-                    return newMap;
-                });
-                clientToolResults.push({ toolCallId: tc.toolCallId, result: errorMsg, isError: true });
-            }
-        }
-        return { clientToolResults, clientToolCalls: executedClientToolCalls };
-    }, [apiBaseUrl, executeClientTool, authToken, getAuthToken, disableToolApiAuthHeader, handleError]);
-    const sendMessage = useCallback(async (message) => {
-        if (!message.trim() || isLoading)
-            return;
-        setIsLoading(true);
-        setError(null);
-        const userMessageId = `user-${Date.now()}`;
-        const userMessage = {
-            id: userMessageId,
-            role: 'user',
-            content: [{ type: 'text', text: message }],
-        };
-        setMessages((prev) => [...prev, userMessage]);
-        const assistantMessageId = `assistant-${Date.now()}`;
-        const assistantMessage = {
-            id: assistantMessageId,
-            role: 'assistant',
-            content: [],
-            isStreaming: true,
-        };
-        setMessages((prev) => [...prev, assistantMessage]);
-        try {
-            abortControllerRef.current = new AbortController();
-            const headers = await buildAgentHeaders();
-            const response = await fetch(`${endpoint}/chat`, {
-                method: 'POST',
-                headers,
-                credentials: 'include',
-                body: JSON.stringify({ threadId, message, agentId }),
-                signal: abortControllerRef.current.signal,
-            });
-            if (!response.ok) {
-                let errorMessage = 'Failed to send message';
-                try {
-                    const contentType = response.headers.get('content-type');
-                    if (contentType?.includes('application/json')) {
-                        const errorData = await response.json();
-                        errorMessage =
-                            typeof errorData?.error === 'string'
-                                ? errorData.error
-                                : typeof errorData?.message === 'string'
-                                    ? errorData.message
-                                    : errorMessage;
-                    }
-                }
-                catch (e) {
-                    console.warn('Failed to parse error response:', e);
-                }
-                throw new Error(errorMessage);
-            }
-            let streamResult = await processStream(response, assistantMessageId, setThreadId);
-            // ツール継続ループ
-            let continueRound = 0;
-            while (streamResult.clientToolResults.length > 0 && continueRound < MAX_CONTINUE_ROUNDS) {
-                continueRound++;
-                const continueMessageId = `assistant-${Date.now()}-${continueRound}`;
-                setMessages((prev) => [
-                    ...prev,
-                    { id: continueMessageId, role: 'assistant', content: [], isStreaming: true },
-                ]);
-                const continueHeaders = await buildAgentHeaders();
-                const continueResponse = await fetch(`${endpoint}/chat/continue`, {
-                    method: 'POST',
-                    headers: continueHeaders,
-                    credentials: 'include',
-                    body: JSON.stringify({
-                        threadId,
-                        agentId,
-                        toolResults: streamResult.clientToolResults,
-                        toolCalls: streamResult.clientToolCalls.map((tc) => ({
-                            toolCallId: tc.toolCallId,
-                            toolName: tc.toolName,
-                            args: tc.input,
-                        })),
-                    }),
-                    signal: abortControllerRef.current?.signal,
-                });
-                if (!continueResponse.ok) {
-                    throw new Error('Failed to continue agent after tool execution');
-                }
-                streamResult = await processStream(continueResponse, continueMessageId, setThreadId);
-            }
-            if (continueRound >= MAX_CONTINUE_ROUNDS && streamResult.clientToolResults.length > 0) {
-                handleError('Tool execution loop exceeded maximum rounds');
-            }
-        }
-        catch (e) {
-            if (e instanceof Error && e.name === 'AbortError')
-                return;
-            handleError(e);
-        }
-        finally {
-            setIsLoading(false);
-            abortControllerRef.current = null;
-        }
-    }, [isLoading, threadId, endpoint, agentId, processStream, handleError, buildAgentHeaders]);
-    const loadThread = useCallback(async (loadThreadId) => {
-        setIsLoading(true);
-        setError(null);
-        try {
-            const threadHeaders = await buildAgentHeaders();
-            const response = await fetch(`${endpoint}/threads/${loadThreadId}/messages`, {
-                headers: threadHeaders,
-                credentials: 'include',
-            });
-            if (!response.ok) {
-                throw new Error('Failed to load thread');
-            }
-            const data = await response.json();
-            setThreadId(loadThreadId);
-            setMessages(data.messages?.map((m) => ({
-                id: m.id,
-                role: m.role,
-                content: m.content,
-                isStreaming: false,
-            })) || []);
-        }
-        catch (e) {
-            setError(normalizeErrorMessage(e));
-        }
-        finally {
-            setIsLoading(false);
-        }
-    }, [endpoint, buildAgentHeaders]);
-    const clearChat = useCallback(() => {
-        if (abortControllerRef.current) {
-            abortControllerRef.current.abort();
-        }
-        setMessages([]);
-        setThreadId(null);
-        setError(null);
-        setPendingToolCalls(new Map());
-    }, []);
-    return {
-        messages,
-        threadId,
-        isLoading,
-        error,
-        pendingToolCalls: Array.from(pendingToolCalls.values()),
-        sendMessage,
-        loadThread,
-        clearChat,
-        config,
-    };
-}

package/dist/components/agent/tool-approval-panel.d.ts

@@ -1,9 +0,0 @@
-import type { ActiveToolApprovalRequest, ToolApprovalLabels } from './provider/types';
-interface ToolApprovalPanelProps {
-    activeApprovalRequest: ActiveToolApprovalRequest | null;
-    approveToolCall: () => void;
-    rejectToolCall: () => void;
-    toolApprovalLabels?: ToolApprovalLabels;
-}
-declare function ToolApprovalPanel({ activeApprovalRequest, approveToolCall, rejectToolCall, toolApprovalLabels, }: ToolApprovalPanelProps): import("react/jsx-runtime").JSX.Element;
-export { ToolApprovalPanel };

package/dist/components/agent/tool-approval-panel.js

@@ -1,11 +0,0 @@
-'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { cn } from '../../lib/utils';
-import { Button } from '../ui/button';
-import { resolveToolApprovalLabels, resolveToolApprovalPanelState } from './approval-ui-model';
-function ToolApprovalPanel({ activeApprovalRequest, approveToolCall, rejectToolCall, toolApprovalLabels, }) {
-    const approvalLabels = resolveToolApprovalLabels(toolApprovalLabels);
-    const panelState = resolveToolApprovalPanelState(activeApprovalRequest);
-    return (_jsx("div", { "data-slot": "agent-tool-approval", className: "w-full border-t border-border bg-muted px-3 pb-3 pt-2", children: _jsxs("div", { "data-state": panelState.isActionable ? 'actionable' : 'idle', className: cn('flex flex-col gap-2 rounded-lg border border-border bg-primary-foreground p-3 shadow-sm', !panelState.isActionable && 'opacity-75'), children: [_jsx("div", { className: "text-sm font-bold text-foreground text-balance", children: approvalLabels.title }), _jsxs("div", { className: "flex flex-col gap-2 pt-1", children: [_jsx(Button, { type: "button", variant: "outline", onClick: approveToolCall, disabled: !panelState.isActionable, className: "justify-start", children: approvalLabels.approveButton }), _jsx(Button, { type: "button", variant: "outline", onClick: rejectToolCall, disabled: !panelState.isActionable, className: "justify-start", children: approvalLabels.rejectButton })] })] }) }));
-}
-export { ToolApprovalPanel };

package/dist/components/agent/types.d.ts

@@ -1,44 +0,0 @@
-import type { ReactNode } from 'react';
-export interface AgentHeaderProps {
-    historyLabel?: string;
-    onHistoryClick?: () => void;
-    onSettingsClick?: () => void;
-    onNewChatClick?: () => void;
-    newChatLabel?: string;
-    settingsAriaLabel?: string;
-    className?: string;
-}
-export interface AgentGreetingProps {
-    greeting?: string;
-    subtext?: string;
-    className?: string;
-}
-export interface AgentHomeCardProps {
-    id: string;
-    icon: ReactNode;
-    title: string;
-    description: string;
-    onClick?: () => void;
-    className?: string;
-}
-export interface AgentInputProps {
-    value?: string;
-    onChange?: (value: string) => void;
-    onSend?: (message: string) => void;
-    onAttach?: () => void;
-    placeholder?: string;
-    disabled?: boolean;
-    isLoading?: boolean;
-    className?: string;
-}
-export interface AgentContainerProps {
-    cards?: AgentHomeCardProps[];
-    onCardClick?: (cardId: string) => void;
-    /**
-     * ツール名→日本語ラベルのマッピング
-     * DEFAULT_TOOL_NAME_LABELSとマージされる
-     */
-    toolNameLabels?: Record<string, string>;
-    inputProps?: Omit<AgentInputProps, 'className'>;
-    className?: string;
-}

package/dist/components/agent/types.js

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

package/dist/components/index.d.ts

@@ -1,7 +0,0 @@
-export * from './ui/button';
-export * from './ui/input';
-export * from './ui/label';
-export * from './ui/card';
-export * from './ui/badge';
-export * from './ui/separator';
-export * from './agent';

package/dist/components/index.js

@@ -1,9 +0,0 @@
-// UI Components
-export * from './ui/button';
-export * from './ui/input';
-export * from './ui/label';
-export * from './ui/card';
-export * from './ui/badge';
-export * from './ui/separator';
-// Agent Components
-export * from './agent';

package/dist/components/ui/badge.d.ts

@@ -1,9 +0,0 @@
-import * as React from "react";
-import { type VariantProps } from "class-variance-authority";
-declare const badgeVariants: (props?: ({
-    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
-    asChild?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
-export { Badge, badgeVariants };

package/dist/components/ui/badge.js

@@ -1,24 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { cva } from "class-variance-authority";
-import { Slot } from "radix-ui";
-import { cn } from "../../lib/utils";
-const badgeVariants = cva("inline-flex items-center justify-center rounded-full border border-transparent px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-[color,box-shadow] overflow-hidden", {
-    variants: {
-        variant: {
-            default: "bg-primary text-primary-foreground [a&]:hover:bg-primary/90",
-            secondary: "bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90",
-            destructive: "bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
-            outline: "border-border text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground",
-            ghost: "[a&]:hover:bg-accent [a&]:hover:text-accent-foreground",
-            link: "text-primary underline-offset-4 [a&]:hover:underline",
-        },
-    },
-    defaultVariants: {
-        variant: "default",
-    },
-});
-function Badge({ className, variant = "default", asChild = false, ...props }) {
-    const Comp = asChild ? Slot.Root : "span";
-    return (_jsx(Comp, { "data-slot": "badge", "data-variant": variant, className: cn(badgeVariants({ variant }), className), ...props }));
-}
-export { Badge, badgeVariants };

package/dist/components/ui/button.d.ts

@@ -1,10 +0,0 @@
-import { type VariantProps } from 'class-variance-authority';
-import type * as React from 'react';
-declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
-    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
-} & import("class-variance-authority/types").ClassProp) | undefined) => string;
-declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
-    asChild?: boolean;
-}): import("react/jsx-runtime").JSX.Element;
-export { Button, buttonVariants };

package/dist/components/ui/button.js

@@ -1,35 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { cva } from 'class-variance-authority';
-import { Slot } from 'radix-ui';
-import { cn } from '../../lib/utils';
-const buttonVariants = cva("inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive", {
-    variants: {
-        variant: {
-            default: 'bg-primary text-primary-foreground hover:bg-primary/90',
-            destructive: 'bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60',
-            outline: 'border bg-background hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50',
-            secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
-            ghost: 'hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50',
-            link: 'text-primary underline-offset-4 hover:underline',
-        },
-        size: {
-            default: 'h-10 px-4 py-2 has-[>svg]:px-3',
-            xs: "h-6 gap-1 rounded-md px-2 text-xs has-[>svg]:px-1.5 [&_svg:not([class*='size-'])]:size-3",
-            sm: 'h-9 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5',
-            lg: 'h-11 rounded-md px-6 has-[>svg]:px-4',
-            icon: 'size-10',
-            'icon-xs': "size-6 rounded-md [&_svg:not([class*='size-'])]:size-3",
-            'icon-sm': "size-8 rounded-md [&_svg:not([class*='size-'])]:size-4",
-            'icon-lg': "size-10 rounded-md [&_svg:not([class*='size-'])]:size-5",
-        },
-    },
-    defaultVariants: {
-        variant: 'default',
-        size: 'default',
-    },
-});
-function Button({ className, variant = 'default', size = 'default', asChild = false, ...props }) {
-    const Comp = asChild ? Slot.Root : 'button';
-    return (_jsx(Comp, { "data-slot": "button", "data-variant": variant, "data-size": size, className: cn(buttonVariants({ variant, size, className })), ...props }));
-}
-export { Button, buttonVariants };