@agent-platform/ui 0.0.1

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

@@ -0,0 +1,22 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AgentContext } from './agent-context';
+import { useAgentChatInternal } from './use-agent-chat';
+/**
+ * エージェントチャット機能を提供する内部Provider
+ * 公開APIは AgentScreen / AgentPopupWidget を使用する。
+ */
+export function AgentProvider({ children, endpoint, agentId, apiBaseUrl, executeClientTool, onError, authToken, getAuthToken, }) {
+    const value = useAgentChatInternal({
+        config: {
+            endpoint,
+            agentId,
+            apiBaseUrl,
+            executeClientTool,
+            onError,
+            authToken,
+            getAuthToken,
+        },
+    });
+    return _jsx(AgentContext.Provider, { value: value, children: children });
+}

package/dist/components/agent/provider/index.d.ts

@@ -0,0 +1,4 @@
+export { useAgentContext } from './agent-context';
+export type { AgentProviderProps } from './agent-provider';
+export { AgentProvider } from './agent-provider';
+export type { AgentContextValue, AgentMessage, AgentProviderConfig, AgentStreamEvent, ClientToolExecutor, FinishPayload, MessageContentPart, ToolCallData, ToolCallState, ToolCallStatus, ToolResultData, } from './types';

package/dist/components/agent/provider/index.js

@@ -0,0 +1,2 @@
+export { useAgentContext } from './agent-context';
+export { AgentProvider } from './agent-provider';

package/dist/components/agent/provider/parse-sse-buffer.d.ts

@@ -0,0 +1,9 @@
+import type { AgentStreamEvent } from './types';
+export interface ParseResult {
+    events: AgentStreamEvent[];
+    remaining: string;
+}
+/**
+ * SSEバッファからイベントをパースする
+ */
+export declare function parseSSEBuffer(buffer: string): ParseResult;

package/dist/components/agent/provider/parse-sse-buffer.js

@@ -0,0 +1,23 @@
+/**
+ * SSEバッファからイベントをパースする
+ */
+export function parseSSEBuffer(buffer) {
+    const events = [];
+    const lines = buffer.split('\n');
+    const remaining = lines.pop() || '';
+    for (const line of lines) {
+        if (!line.startsWith('data: '))
+            continue;
+        const jsonStr = line.slice(6);
+        if (!jsonStr)
+            continue;
+        try {
+            const event = JSON.parse(jsonStr);
+            events.push(event);
+        }
+        catch (e) {
+            console.warn('Failed to parse SSE event:', e);
+        }
+    }
+    return { events, remaining };
+}

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

@@ -0,0 +1,58 @@
+export type { AgentStreamEvent, ToolCallData, ToolResultData, FinishPayload, MessageContentPart, AgentMessage, } from '@agent-platform/server';
+/**
+ * ツール実行状態
+ */
+export type ToolCallStatus = 'pending' | 'executing' | 'completed' | 'error';
+/**
+ * ツールコール状態（UI表示用）
+ */
+export interface ToolCallState {
+    toolCall: import('@agent-platform/server').ToolCallData;
+    status: ToolCallStatus;
+    result?: unknown;
+    error?: string;
+}
+/**
+ * クライアントツール実行関数型
+ */
+export type ClientToolExecutor = (toolCall: import('@agent-platform/server').ToolCallData) => Promise<{
+    output: unknown;
+    isError?: boolean;
+}>;
+/**
+ * AgentProvider設定
+ */
+export interface AgentProviderConfig {
+    endpoint: string;
+    agentId?: string;
+    /**
+     * クライアント実行ツールが呼び出すAPIのベースURL
+     * tool-callのapiEndpoint.pathと組み合わせて使用
+     * 例: apiBaseUrl="http://localhost:3001/api" + path="/candidates/{id}"
+     */
+    apiBaseUrl?: string;
+    /**
+     * @deprecated apiBaseUrlを使用してください。
+     * executeOn: 'client' のツールをブラウザ側で実行するコールバック
+     */
+    executeClientTool?: ClientToolExecutor;
+    onError?: (error: string) => void;
+    /** 静的なJWTトークン */
+    authToken?: string;
+    /** 動的にトークンを取得する関数（authTokenより優先） */
+    getAuthToken?: () => string | Promise<string>;
+}
+/**
+ * AgentContext値
+ */
+export interface AgentContextValue {
+    messages: import('@agent-platform/server').AgentMessage[];
+    threadId: string | null;
+    isLoading: boolean;
+    error: string | null;
+    pendingToolCalls: ToolCallState[];
+    sendMessage: (message: string) => Promise<void>;
+    loadThread: (threadId: string) => Promise<void>;
+    clearChat: () => void;
+    config: AgentProviderConfig;
+}

package/dist/components/agent/provider/types.js

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

package/dist/components/agent/provider/use-agent-chat.d.ts

@@ -0,0 +1,6 @@
+import type { AgentContextValue, AgentProviderConfig } from './types';
+interface UseAgentChatOptions {
+    config: AgentProviderConfig;
+}
+export declare function useAgentChatInternal(options: UseAgentChatOptions): AgentContextValue;
+export {};

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

@@ -0,0 +1,452 @@
+'use client';
+import { useCallback, useRef, useState } from 'react';
+import { parseSSEBuffer } from './parse-sse-buffer';
+/** クライアントツール自動継続の最大回数 */
+const MAX_CONTINUE_ROUNDS = 10;
+// --- イベントハンドラ ---
+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 ? String(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 } = 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 buildHeaders = useCallback(async () => {
+        const headers = { 'Content-Type': 'application/json' };
+        const token = getAuthToken ? await getAuthToken() : authToken;
+        if (token) {
+            headers['Authorization'] = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
+        }
+        return headers;
+    }, [authToken, getAuthToken]);
+    const handleError = useCallback((errorMessage) => {
+        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 authHeaders = {};
+        const token = getAuthToken ? await getAuthToken() : authToken;
+        if (token) {
+            authHeaders['Authorization'] = token.startsWith('Bearer ') ? token : `Bearer ${token}`;
+        }
+        for (const tc of unresolvedCalls) {
+            // apiBaseUrlとapiEndpointがある場合は自動実行
+            const canAutoExecute = apiBaseUrl && 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, authHeaders);
+                }
+                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 ? String(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, 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 buildHeaders();
+            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 buildHeaders();
+                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;
+            const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+            handleError(errorMessage);
+        }
+        finally {
+            setIsLoading(false);
+            abortControllerRef.current = null;
+        }
+    }, [isLoading, threadId, endpoint, agentId, processStream, handleError, buildHeaders]);
+    const loadThread = useCallback(async (loadThreadId) => {
+        setIsLoading(true);
+        setError(null);
+        try {
+            const threadHeaders = await buildHeaders();
+            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(e instanceof Error ? e.message : 'Unknown error');
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [endpoint, buildHeaders]);
+    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/types.d.ts

@@ -0,0 +1,56 @@
+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 {
+    showHeader?: boolean;
+    headerProps?: Omit<AgentHeaderProps, "className">;
+    showGreeting?: boolean;
+    greetingProps?: AgentGreetingProps;
+    showHomeCards?: boolean;
+    cards?: AgentHomeCardProps[];
+    onCardClick?: (cardId: string) => void;
+    /**
+     * ツール名→日本語ラベルのマッピング
+     * DEFAULT_TOOL_NAME_LABELSとマージされる
+     */
+    toolNameLabels?: Record<string, string>;
+    /**
+     * メッセージが存在する場合に自動でMessageList+errorを表示するか
+     * デフォルト: true
+     */
+    autoShowMessages?: boolean;
+    showInput?: boolean;
+    inputProps?: Omit<AgentInputProps, "className">;
+    className?: string;
+    children?: ReactNode;
+}

package/dist/components/agent/types.js

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

package/dist/components/index.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,9 @@
+// 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

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | 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 };