agent-client-sdk 0.1.0

package/dist/index.esm.js

@@ -0,0 +1,950 @@
+import { ref, computed, readonly, getCurrentInstance, onMounted, onUnmounted } from 'vue';
+
+/**
+ * 类型定义
+ */
+/** 消息类型 */
+var MessageType;
+(function (MessageType) {
+    // 客户端 -> 服务端
+    MessageType["CLIENT_HANDSHAKE"] = "CLIENT_HANDSHAKE";
+    MessageType["CLIENT_UPDATE"] = "CLIENT_UPDATE";
+    MessageType["CLIENT_INPUT"] = "CLIENT_INPUT";
+    MessageType["CLIENT_RESULT"] = "CLIENT_RESULT";
+    MessageType["CLIENT_HEARTBEAT"] = "CLIENT_HEARTBEAT";
+    // 服务端 -> 客户端
+    MessageType["AGENT_MESSAGE"] = "AGENT_MESSAGE";
+    MessageType["AGENT_COMMAND"] = "AGENT_COMMAND";
+    MessageType["SERVER_ACK"] = "SERVER_ACK";
+    MessageType["SERVER_ERROR"] = "SERVER_ERROR";
+    MessageType["SERVER_HEARTBEAT"] = "SERVER_HEARTBEAT";
+})(MessageType || (MessageType = {}));
+/** 连接状态 */
+var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus["DISCONNECTED"] = "disconnected";
+    ConnectionStatus["CONNECTING"] = "connecting";
+    ConnectionStatus["CONNECTED"] = "connected";
+    ConnectionStatus["RECONNECTING"] = "reconnecting";
+    ConnectionStatus["ERROR"] = "error";
+})(ConnectionStatus || (ConnectionStatus = {}));
+
+/**
+ * Agent客户端核心类
+ *
+ * 管理WebSocket连接、消息收发、命令执行
+ */
+class AgentClient {
+    constructor(config) {
+        this.ws = null;
+        this.status = ConnectionStatus.DISCONNECTED;
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.heartbeatTimer = null;
+        this.messageListeners = [];
+        this.statusListeners = [];
+        this.commandHandlers = new Map();
+        this.chatMessages = [];
+        this.messageListenersChat = [];
+        this.pendingCommands = new Map();
+        this.messageQueue = [];
+        this.config = { ...AgentClient.DEFAULT_CONFIG, ...config };
+        this.sessionId = this.config.sessionId || this.generateSessionId();
+        // 注册默认命令处理器
+        this.registerDefaultCommandHandlers();
+    }
+    /**
+     * 生成会话ID
+     */
+    generateSessionId() {
+        // 优先从 localStorage 获取
+        const stored = typeof window !== 'undefined'
+            ? localStorage.getItem('agent_session_id')
+            : null;
+        if (stored)
+            return stored;
+        // 生成新的并存储
+        const newId = `session_${Date.now().toString(36)}_${Math.random().toString(36).substr(2, 5)}`;
+        if (typeof window !== 'undefined') {
+            localStorage.setItem('agent_session_id', newId);
+        }
+        return newId;
+    }
+    /**
+     * 日志输出
+     */
+    log(...args) {
+        if (this.config.debug) {
+            console.log('[AgentClient]', ...args);
+        }
+    }
+    /**
+     * 注册默认命令处理器
+     */
+    registerDefaultCommandHandlers() {
+        // 页面导航
+        this.commandHandlers.set('navigate', async (command) => {
+            const { target, params } = command;
+            this.log('Navigating to:', target, params);
+            try {
+                // 构建URL
+                let url = target;
+                if (params?.queryParams) {
+                    const query = new URLSearchParams(params.queryParams).toString();
+                    if (query) {
+                        url += (url.includes('?') ? '&' : '?') + query;
+                    }
+                }
+                // 使用Vue Router或原生导航
+                if (typeof window !== 'undefined') {
+                    if (window.$router) {
+                        await window.$router.push(url);
+                    }
+                    else {
+                        window.location.href = url;
+                    }
+                }
+                return { success: true, result: { url } };
+            }
+            catch (error) {
+                return { success: false, error: String(error) };
+            }
+        });
+        // 填充表单
+        this.commandHandlers.set('fillForm', async (command) => {
+            const { target, params } = command;
+            this.log('Filling form:', target, params);
+            try {
+                const form = document.querySelector(target);
+                if (!form) {
+                    return { success: false, error: `Form not found: ${target}` };
+                }
+                const data = params?.data || {};
+                for (const [key, value] of Object.entries(data)) {
+                    const input = form.querySelector(`[name="${key}"], #${key}`);
+                    if (input) {
+                        input.value = String(value);
+                        input.dispatchEvent(new Event('input', { bubbles: true }));
+                        input.dispatchEvent(new Event('change', { bubbles: true }));
+                    }
+                }
+                // 自动提交
+                if (params?.submit) {
+                    const submitBtn = form.querySelector('button[type="submit"], input[type="submit"]');
+                    if (submitBtn) {
+                        submitBtn.click();
+                    }
+                    else {
+                        form.submit();
+                    }
+                }
+                return { success: true, result: { filled: Object.keys(data) } };
+            }
+            catch (error) {
+                return { success: false, error: String(error) };
+            }
+        });
+        // 点击元素
+        this.commandHandlers.set('click', async (command) => {
+            const { target, params } = command;
+            this.log('Clicking element:', target);
+            try {
+                const element = document.querySelector(target);
+                if (!element) {
+                    return { success: false, error: `Element not found: ${target}` };
+                }
+                element.click();
+                // 等待导航（如果需要）
+                if (params?.waitForNavigation) {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
+                return { success: true };
+            }
+            catch (error) {
+                return { success: false, error: String(error) };
+            }
+        });
+        // 设置值
+        this.commandHandlers.set('setValue', async (command) => {
+            const { target, params } = command;
+            this.log('Setting value:', target, params?.value);
+            try {
+                const element = document.querySelector(target);
+                if (!element) {
+                    return { success: false, error: `Element not found: ${target}` };
+                }
+                element.value = String(params?.value || '');
+                if (params?.triggerChange !== false) {
+                    element.dispatchEvent(new Event('input', { bubbles: true }));
+                    element.dispatchEvent(new Event('change', { bubbles: true }));
+                }
+                return { success: true };
+            }
+            catch (error) {
+                return { success: false, error: String(error) };
+            }
+        });
+        // 滚动页面
+        this.commandHandlers.set('scroll', async (command) => {
+            const { target, params } = command;
+            this.log('Scrolling:', target, params);
+            try {
+                const amount = params?.amount || 500;
+                switch (target) {
+                    case 'up':
+                        window.scrollBy({ top: -amount, behavior: 'smooth' });
+                        break;
+                    case 'down':
+                        window.scrollBy({ top: amount, behavior: 'smooth' });
+                        break;
+                    case 'top':
+                        window.scrollTo({ top: 0, behavior: 'smooth' });
+                        break;
+                    case 'bottom':
+                        window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' });
+                        break;
+                    default:
+                        return { success: false, error: `Unknown scroll direction: ${target}` };
+                }
+                return { success: true };
+            }
+            catch (error) {
+                return { success: false, error: String(error) };
+            }
+        });
+    }
+    /**
+     * 连接到WebSocket服务器
+     */
+    connect() {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.log('Already connected');
+            return;
+        }
+        this.setStatus(ConnectionStatus.CONNECTING);
+        try {
+            const url = new URL(this.config.serverUrl);
+            url.searchParams.set('session_id', this.sessionId);
+            this.ws = new WebSocket(url.toString());
+            this.ws.onopen = () => {
+                this.log('WebSocket connected');
+                this.reconnectAttempts = 0;
+                this.setStatus(ConnectionStatus.CONNECTED);
+                this.startHeartbeat();
+                this.sendHandshake();
+                // 发送缓存的消息
+                while (this.messageQueue.length > 0) {
+                    const msg = this.messageQueue.shift();
+                    if (msg)
+                        this.sendMessage(msg);
+                }
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const message = JSON.parse(event.data);
+                    this.handleMessage(message);
+                }
+                catch (error) {
+                    this.log('Failed to parse message:', error);
+                }
+            };
+            this.ws.onclose = () => {
+                this.log('WebSocket closed');
+                this.stopHeartbeat();
+                this.setStatus(ConnectionStatus.DISCONNECTED);
+                this.attemptReconnect();
+            };
+            this.ws.onerror = (error) => {
+                this.log('WebSocket error:', error);
+                this.setStatus(ConnectionStatus.ERROR);
+            };
+        }
+        catch (error) {
+            this.log('Failed to connect:', error);
+            this.setStatus(ConnectionStatus.ERROR);
+            this.attemptReconnect();
+        }
+    }
+    /**
+     * 断开连接
+     */
+    disconnect() {
+        this.stopHeartbeat();
+        this.clearReconnectTimer();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.setStatus(ConnectionStatus.DISCONNECTED);
+    }
+    /**
+     * 尝试重连
+     */
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+            this.log('Max reconnect attempts reached');
+            return;
+        }
+        this.reconnectAttempts++;
+        this.setStatus(ConnectionStatus.RECONNECTING);
+        this.log(`Reconnecting... (${this.reconnectAttempts}/${this.config.maxReconnectAttempts})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.connect();
+        }, this.config.reconnectInterval);
+    }
+    /**
+     * 清除重连定时器
+     */
+    clearReconnectTimer() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    /**
+     * 启动心跳
+     */
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            this.sendMessage({
+                type: MessageType.CLIENT_HEARTBEAT,
+                sessionId: this.sessionId,
+                timestamp: new Date().toISOString(),
+                payload: {},
+            });
+        }, this.config.heartbeatInterval);
+    }
+    /**
+     * 停止心跳
+     */
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    /**
+     * 发送握手消息
+     */
+    sendHandshake() {
+        this.sendMessage({
+            type: MessageType.CLIENT_HANDSHAKE,
+            sessionId: this.sessionId,
+            timestamp: new Date().toISOString(),
+            payload: {
+                routes: this.config.routes,
+                capabilities: [],
+                userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : '',
+                url: typeof window !== 'undefined' ? window.location.href : '',
+            },
+        });
+    }
+    /**
+     * 发送消息
+     */
+    sendMessage(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+            return true;
+        }
+        // 连接未建立时，缓存消息
+        this.messageQueue.push(message);
+        return false;
+    }
+    /**
+     * 处理接收到的消息
+     */
+    handleMessage(message) {
+        this.log('Received message:', message.type);
+        // 通知所有监听器
+        this.messageListeners.forEach(listener => listener(message));
+        switch (message.type) {
+            case MessageType.SERVER_ACK:
+                this.log('Server acknowledged:', message.payload);
+                break;
+            case MessageType.SERVER_ERROR:
+                console.error('[AgentClient] Server error:', message.payload);
+                break;
+            case MessageType.SERVER_HEARTBEAT:
+                // 心跳响应，无需处理
+                break;
+            case MessageType.AGENT_MESSAGE:
+                this.handleAgentMessage(message);
+                break;
+            case MessageType.AGENT_COMMAND:
+                this.handleAgentCommand(message);
+                break;
+            default:
+                this.log('Unknown message type:', message.type);
+        }
+    }
+    /**
+     * 处理Agent消息
+     */
+    handleAgentMessage(message) {
+        const payload = message.payload;
+        const chatMessage = {
+            id: `${Date.now()}_${Math.random().toString(36).substr(2, 5)}`,
+            role: 'agent',
+            content: payload.text || '',
+            timestamp: Date.now(),
+            type: 'text',
+        };
+        this.chatMessages.push(chatMessage);
+        this.notifyChatListeners();
+    }
+    /**
+     * 处理Agent控制指令
+     */
+    async handleAgentCommand(message) {
+        const command = message.payload;
+        // 添加到聊天消息
+        const chatMessage = {
+            id: command.commandId,
+            role: 'agent',
+            content: command.description,
+            timestamp: Date.now(),
+            type: 'command',
+            command: command,
+        };
+        this.chatMessages.push(chatMessage);
+        this.notifyChatListeners();
+        // 执行命令
+        const handler = this.commandHandlers.get(command.action);
+        let result;
+        if (handler) {
+            try {
+                result = await handler(command);
+            }
+            catch (error) {
+                result = { success: false, error: String(error) };
+            }
+        }
+        else {
+            result = { success: false, error: `Unknown command action: ${command.action}` };
+        }
+        // 发送执行结果
+        this.sendMessage({
+            type: MessageType.CLIENT_RESULT,
+            sessionId: this.sessionId,
+            timestamp: new Date().toISOString(),
+            payload: {
+                commandId: command.commandId,
+                success: result.success,
+                result: result.result,
+                error: result.error,
+            },
+        });
+    }
+    /**
+     * 发送用户输入
+     */
+    sendInput(text, context) {
+        // 添加到本地聊天记录
+        const chatMessage = {
+            id: `${Date.now()}_${Math.random().toString(36).substr(2, 5)}`,
+            role: 'user',
+            content: text,
+            timestamp: Date.now(),
+            type: 'text',
+        };
+        this.chatMessages.push(chatMessage);
+        this.notifyChatListeners();
+        // 发送到服务器
+        this.sendMessage({
+            type: MessageType.CLIENT_INPUT,
+            sessionId: this.sessionId,
+            timestamp: new Date().toISOString(),
+            payload: {
+                text,
+                context,
+            },
+        });
+    }
+    /**
+     * 更新页面能力
+     */
+    updateCapabilities(action, currentRoute, capabilities) {
+        this.sendMessage({
+            type: MessageType.CLIENT_UPDATE,
+            sessionId: this.sessionId,
+            timestamp: new Date().toISOString(),
+            payload: {
+                action,
+                currentRoute,
+                capabilities,
+            },
+        });
+    }
+    /**
+     * 设置连接状态
+     */
+    setStatus(status) {
+        this.status = status;
+        this.statusListeners.forEach(listener => listener(status));
+    }
+    /**
+     * 获取当前连接状态
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * 获取会话ID
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * 获取聊天记录
+     */
+    getChatMessages() {
+        return [...this.chatMessages];
+    }
+    /**
+     * 清空聊天记录
+     */
+    clearChatMessages() {
+        this.chatMessages = [];
+        this.notifyChatListeners();
+    }
+    /**
+     * 注册消息监听器
+     */
+    onMessage(listener) {
+        this.messageListeners.push(listener);
+        return () => {
+            const index = this.messageListeners.indexOf(listener);
+            if (index > -1) {
+                this.messageListeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * 注册状态监听器
+     */
+    onStatusChange(listener) {
+        this.statusListeners.push(listener);
+        return () => {
+            const index = this.statusListeners.indexOf(listener);
+            if (index > -1) {
+                this.statusListeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * 注册聊天消息监听器
+     */
+    onChatMessages(listener) {
+        this.messageListenersChat.push(listener);
+        return () => {
+            const index = this.messageListenersChat.indexOf(listener);
+            if (index > -1) {
+                this.messageListenersChat.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * 通知聊天监听器
+     */
+    notifyChatListeners() {
+        this.messageListenersChat.forEach(listener => listener([...this.chatMessages]));
+    }
+    /**
+     * 注册自定义命令处理器
+     */
+    registerCommandHandler(action, handler) {
+        this.commandHandlers.set(action, handler);
+    }
+    /**
+     * 注销命令处理器
+     */
+    unregisterCommandHandler(action) {
+        this.commandHandlers.delete(action);
+    }
+}
+// 默认配置
+AgentClient.DEFAULT_CONFIG = {
+    serverUrl: '',
+    routes: [],
+    reconnectInterval: 3000,
+    maxReconnectAttempts: 5,
+    heartbeatInterval: 30000,
+    debug: false,
+    sessionId: '',
+};
+// 单例实例
+let globalClient = null;
+/**
+ * 获取全局AgentClient实例
+ */
+function getGlobalClient() {
+    return globalClient;
+}
+/**
+ * 设置全局AgentClient实例
+ */
+function setGlobalClient(client) {
+    globalClient = client;
+}
+
+/**
+ * Agent全局状态管理组合式函数
+ *
+ * 提供响应式的连接状态、聊天记录等全局状态
+ */
+// 全局状态（跨组件共享）
+const globalStatus = ref(ConnectionStatus.DISCONNECTED);
+const globalMessages = ref([]);
+const globalIsConnected = computed(() => globalStatus.value === ConnectionStatus.CONNECTED);
+/**
+ * 使用Agent全局状态
+ *
+ * @param config - 可选的配置，仅在首次调用时生效
+ * @returns Agent状态和操作方法
+ *
+ * @example
+ * ```ts
+ * // 在main.ts中初始化
+ * const { connect } = useAgent({
+ *   serverUrl: 'ws://localhost:8987/ws/agent',
+ *   routes: [...]
+ * });
+ * connect();
+ *
+ * // 在组件中使用
+ * const { status, messages, sendMessage } = useAgent();
+ * ```
+ */
+function useAgent(config) {
+    let client = getGlobalClient();
+    // 如果提供了配置且全局客户端不存在，则创建
+    if (config && !client) {
+        client = new AgentClient(config);
+        setGlobalClient(client);
+        // 同步全局状态
+        client.onStatusChange((status) => {
+            globalStatus.value = status;
+        });
+        client.onChatMessages((messages) => {
+            globalMessages.value = messages;
+        });
+    }
+    // 如果客户端已存在，同步当前状态到全局
+    if (client) {
+        globalStatus.value = client.getStatus();
+        globalMessages.value = client.getChatMessages();
+    }
+    const sendMessage = (text) => {
+        if (client) {
+            client.sendInput(text);
+        }
+        else {
+            console.warn('[useAgent] AgentClient not initialized');
+        }
+    };
+    const clearMessages = () => {
+        if (client) {
+            client.clearChatMessages();
+        }
+    };
+    const connect = () => {
+        if (client) {
+            client.connect();
+        }
+        else {
+            console.warn('[useAgent] AgentClient not initialized, please provide config first');
+        }
+    };
+    const disconnect = () => {
+        if (client) {
+            client.disconnect();
+        }
+    };
+    return {
+        status: readonly(globalStatus),
+        isConnected: readonly(globalIsConnected),
+        messages: readonly(globalMessages),
+        sendMessage,
+        clearMessages,
+        connect,
+        disconnect,
+    };
+}
+/**
+ * 初始化AgentClient
+ *
+ * 应在应用入口（如main.ts）中调用一次
+ *
+ * @param config - SDK配置
+ * @returns AgentClient实例
+ *
+ * @example
+ * ```ts
+ * // main.ts
+ * import { createApp } from 'vue';
+ * import { initAgent } from 'agent-client-sdk';
+ * import App from './App.vue';
+ * import router from './router';
+ *
+ * const app = createApp(App);
+ * app.use(router);
+ *
+ * // 初始化Agent
+ * initAgent({
+ *   serverUrl: 'ws://localhost:8987/ws/agent',
+ *   routes: router.getRoutes().map(r => ({
+ *     path: r.path,
+ *     name: String(r.name || r.path),
+ *     title: r.meta?.title || String(r.name || r.path)
+ *   })),
+ *   debug: true
+ * });
+ *
+ * app.mount('#app');
+ * ```
+ */
+function initAgent(config) {
+    const client = new AgentClient(config);
+    setGlobalClient(client);
+    // 设置到 window，方便路由变化监听使用
+    if (typeof window !== 'undefined') {
+        window.$agentClient = client;
+    }
+    // 同步全局状态
+    client.onStatusChange((status) => {
+        globalStatus.value = status;
+    });
+    client.onChatMessages((messages) => {
+        globalMessages.value = messages;
+    });
+    // 自动连接
+    client.connect();
+    return client;
+}
+
+/**
+ * 组件能力注册组合式函数
+ *
+ * 在Vue组件中注册页面能力，供Agent调用
+ */
+/**
+ * 注册组件能力给Agent
+ *
+ * 在组件挂载时自动注册能力，卸载时自动注销
+ *
+ * @param capabilities - 页面能力列表
+ * @param options - 配置选项
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useAgentAction } from 'agent-client-sdk';
+ *
+ * // 注册表单能力
+ * useAgentAction([
+ *   {
+ *     id: 'profile-form',
+ *     type: 'form',
+ *     name: '个人资料表单',
+ *     description: '用于编辑用户个人资料信息',
+ *     selector: '#profile-form',
+ *     actions: ['fill', 'submit'],
+ *     metadata: {
+ *       fields: ['name', 'email', 'phone']
+ *     }
+ *   }
+ * ]);
+ * </script>
+ *
+ * <template>
+ *   <form id="profile-form">
+ *     <input name="name" />
+ *     <input name="email" />
+ *     <button type="submit">保存</button>
+ *   </form>
+ * </template>
+ * ```
+ */
+function useAgentAction(capabilities, options = {}) {
+    const { autoRegister = true, autoUnregister = true, route, } = options;
+    const client = getGlobalClient();
+    const instance = getCurrentInstance();
+    // 生成组件唯一标识
+    const componentId = instance
+        ? `${instance.uid}_${Date.now().toString(36)}`
+        : `anonymous_${Date.now().toString(36)}`;
+    // 为能力添加组件标识
+    const taggedCapabilities = capabilities.map((cap) => ({
+        ...cap,
+        id: `${componentId}_${cap.id}`,
+        metadata: {
+            ...cap.metadata,
+            _componentId: componentId,
+            _originalId: cap.id,
+        },
+    }));
+    const register = () => {
+        if (!client) {
+            console.warn('[useAgentAction] AgentClient not initialized');
+            return;
+        }
+        client.updateCapabilities('mount', route, taggedCapabilities);
+    };
+    const unregister = () => {
+        if (!client) {
+            return;
+        }
+        client.updateCapabilities('unmount', route, taggedCapabilities);
+    };
+    const update = (newCapabilities) => {
+        if (!client) {
+            console.warn('[useAgentAction] AgentClient not initialized');
+            return;
+        }
+        const newTaggedCapabilities = newCapabilities.map((cap) => ({
+            ...cap,
+            id: `${componentId}_${cap.id}`,
+            metadata: {
+                ...cap.metadata,
+                _componentId: componentId,
+                _originalId: cap.id,
+            },
+        }));
+        client.updateCapabilities('update', route, newTaggedCapabilities);
+    };
+    // 自动注册/注销
+    if (autoRegister) {
+        onMounted(() => {
+            register();
+        });
+    }
+    if (autoUnregister) {
+        onUnmounted(() => {
+            unregister();
+        });
+    }
+    return {
+        register,
+        unregister,
+        update,
+    };
+}
+/**
+ * 注册按钮能力
+ *
+ * 便捷方法，用于快速注册按钮点击能力
+ *
+ * @param id - 按钮ID
+ * @param name - 按钮名称
+ * @param description - 按钮描述
+ * @param selector - CSS选择器（可选，默认使用ID）
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useAgentButton } from 'agent-client-sdk';
+ *
+ * useAgentButton('save-btn', '保存按钮', '点击保存表单数据');
+ * </script>
+ *
+ * <template>
+ *   <button id="save-btn">保存</button>
+ * </template>
+ * ```
+ */
+function useAgentButton(id, name, description, selector) {
+    useAgentAction([
+        {
+            id,
+            type: 'button',
+            name,
+            description,
+            selector: selector || `#${id}`,
+            actions: ['click'],
+        },
+    ]);
+}
+/**
+ * 注册表单能力
+ *
+ * 便捷方法，用于快速注册表单填充能力
+ *
+ * @param id - 表单ID
+ * @param name - 表单名称
+ * @param description - 表单描述
+ * @param fields - 表单字段列表
+ * @param selector - CSS选择器（可选，默认使用ID）
+ * @param options - 额外选项
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useAgentForm } from 'agent-client-sdk';
+ *
+ * useAgentForm(
+ *   'profile-form',
+ *   '个人资料表单',
+ *   '编辑用户个人资料',
+ *   ['name', 'email', 'phone'],
+ *   '#profile-form',
+ *   { canSubmit: true }
+ * );
+ * </script>
+ * ```
+ */
+function useAgentForm(id, name, description, fields, selector, options = {}) {
+    const actions = ['fill'];
+    if (options.canSubmit !== false) {
+        actions.push('submit');
+    }
+    useAgentAction([
+        {
+            id,
+            type: 'form',
+            name,
+            description,
+            selector: selector || `#${id}`,
+            actions,
+            metadata: { fields },
+        },
+    ]);
+}
+/**
+ * 注册输入框能力
+ *
+ * 便捷方法，用于快速注册输入框设置值能力
+ *
+ * @param id - 输入框ID
+ * @param name - 输入框名称
+ * @param description - 输入框描述
+ * @param selector - CSS选择器（可选，默认使用ID）
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { useAgentInput } from 'agent-client-sdk';
+ *
+ * useAgentInput('username', '用户名', '输入用户名');
+ * </script>
+ *
+ * <template>
+ *   <input id="username" name="username" />
+ * </template>
+ * ```
+ */
+function useAgentInput(id, name, description, selector) {
+    useAgentAction([
+        {
+            id,
+            type: 'input',
+            name,
+            description,
+            selector: selector || `#${id}`,
+            actions: ['setValue'],
+        },
+    ]);
+}
+
+export { AgentClient, ConnectionStatus, MessageType, getGlobalClient, initAgent, setGlobalClient, useAgent, useAgentAction, useAgentButton, useAgentForm, useAgentInput };
+//# sourceMappingURL=index.esm.js.map