@tencent-rtc/mcp 1.3.8 → 1.3.9

package/tools/definitions/get_native_live_uikit_integration_def.js

@@ -1,45 +1,71 @@
 const TOOL_DESCRIPTION = `
-[CORE PURPOSE]:
-A professional Native live streaming AtomicXCore integration assistant, designed to provide Agent workflow instructions and aggregated documentation for implementing live streaming features on Native platforms (Android/iOS/Flutter/RN).
+[TOOL DEFINITION]:
+Mobile **Video Live / Voice Chat Room** basic feature integrator. Designed to provide Agent with workflow instructions and real-time aggregated documentation for implementing basic broadcasting/viewing/list features on Android/iOS/Flutter/uni-app platforms.
 
-[KEYWORDS]: 'AtomicXCore', 'LiveKit', 'Live Streaming', 'Broadcasting', 'Viewing', 'Live List', 'Android', 'iOS', 'Flutter', 'React Native', 'LiveCoreView'.
+[KEYWORDS]: 'AtomicXCore', 'LiveKit', 'Video Live', 'Voice Chat Room', 'Broadcasting', 'Viewing', 'Room List'.
 
 [WORKFLOW GUIDANCE]:
-Agents should use the 'llm_code_generation_instructions_md' field returned by this tool, which includes:
-1. Core workflow instructions (from workflow.md, including call to get_usersig tool for test credential generation).
-2. Official documentation content corresponding to the user's required features (Goals).
+When handling user requirements, Agent should use the 'llm_code_generation_instructions_md' field returned by this tool. This field contains:
+1. Core workflow instructions (from workflow.md, including closed-loop flow for calling get_usersig tool to auto-generate test credentials and inject into code).
+2. Latest, real-time fetched official documentation content corresponding to user's required features (Goals).
 
-LLM MUST prioritize and exclusively use the documentation content returned by this tool for code generation.
+LLM MUST prioritize and exclusively use the real-time documentation content returned by this tool for code generation, avoiding direct access to external URLs.
 
 [FUNCTIONAL SCOPE]:
-Designed for building Native live streaming products, including:
+Designed for building Native live streaming/voice chat room products, including:
 1. **Authentication**: SDK initialization and LoginStore login/authentication.
-2. **Host Broadcasting**: Host creates a room and starts broadcasting.
-3. **Audience Viewing**: Audience joins a room and watches the live stream.
-4. **Live List**: Retrieve live room list, display room info, and navigate to rooms.
+2. **Host/Room Owner Broadcasting**: Create room and start streaming.
+3. **Audience/Listener Viewing**: Join room and start playback.
+4. **Room List**: Fetch room list, display room info, click to navigate.
 
-[SUPPORTED PLATFORMS]: Android, iOS, Flutter, React Native (returns corresponding documentation based on the 'platform' parameter).
+[SUPPORTED SCENARIOS & PLATFORMS]:
+- **Video Live (live) / Voice Chat Room (voice)**: Android, iOS, Flutter, uni-app
 
-[CONSTRAINTS]:
-1. **Platform Selection Constraint**: If the platform (Android/iOS/Flutter/React Native) is not specified, you MUST call the 'present_framework_choice' tool first.
+[TYPICAL USE CASES (Few-Shot Examples)]:
+LLM should learn the following mapping between user instructions and parameters:
 
-[TYPICAL SCENARIOS]:
-1. "Use AtomicXCore to implement host broadcasting on Android" -> call tool, platform='android', goals=['host_streaming']
-2. "Use AtomicXCore to implement audience viewing on iOS" -> call tool, platform='ios', goals=['audience_streaming']
-3. "Use AtomicXCore to implement a room list on Flutter" -> call tool, platform='flutter', goals=['live_list']
-4. "Implement host broadcasting, room list, and audience viewing on Android" -> call tool, platform='android', goals=['host_streaming', 'live_list', 'audience_streaming']
-5. "Implement live streaming features" (no platform specified) -> Call 'present_framework_choice' first.
+1. **Explicit Scenario & Platform**:
+   - User: "Use AtomicXCore to implement video live host broadcasting on Android"
+   - Call: scenario='live', platform='android', goals=['host_streaming']
+
+   - User: "Use AtomicXCore to implement voice chat room audience viewing on iOS"
+   - Call: scenario='voice', platform='ios', goals=['audience_streaming']
+
+   - User: "Use AtomicXCore to implement video live list on Flutter"
+   - Call: scenario='live', platform='flutter', goals=['live_list']
+
+   - User: "Use AtomicXCore to implement voice chat room features on uni-app"
+   - Call: scenario='voice', platform='uni-app', goals=['host_streaming', 'audience_streaming', 'live_list']
+
+2. **Multi-Feature Combination**:
+   - User: "Implement complete video live features on Android (broadcasting + viewing + list)"
+   - Call: scenario='live', platform='android', goals=['host_streaming', 'audience_streaming', 'live_list']
+
+3. **Exception Interception (Missing Platform)**:
+   - User: "Use AtomicXCore to implement live streaming features"
+   - Action: ❌ No guessing allowed, **MUST call 'present_framework_choice' first** to let user select platform.
+
+4. **Exception Interception (Missing Scenario)**:
+   - User: "Use AtomicXCore to implement host broadcasting", "Implement room list features"
+   - Action: ❌ No guessing allowed, **MUST call 'present_scenario_choice' first** to let user select scenario (Video Live / Voice Chat Room).
+
+[WORKFLOW MECHANISM]:
+This tool returns 'llm_code_generation_instructions_md'. You MUST strictly write code based on the returned Context and check API links at the bottom of documentation to confirm field names (guessing is prohibited).
 `;
 const PARAMETER_DESCRIPTIONS = {
-    platform: `[REQUIRED] Target platform: 'android', 'ios', 'flutter', 'rn'.
-  - MUST prompt the user to choose if not specified.
-  - The tool returns documentation and code examples based on this parameter.`,
-    goals: `List of features to implement: ['host_streaming', 'audience_streaming', 'live_list'].
-  - 'host_streaming': Host broadcasting (auth, create room, start push).
-  - 'audience_streaming': Audience viewing (auth, join room, start play).
-  - 'live_list': Live room list (fetch list, display info, navigation).
-  
-  💡 Can be combined, e.g., ['host_streaming', 'live_list', 'audience_streaming'] for a complete scenario.`
+    scenario: `[REQUIRED] Scenario type.
+  - 'live': Video Live (keywords: live streaming, show live, video, e-commerce live).
+  - 'voice': Voice Chat Room (keywords: voice chat, voice room, radio, audio room).
+  *Strategy: If user does not specify explicitly, **default values are strictly prohibited**, MUST call 'present_scenario_choice' first.`,
+    platform: `[REQUIRED] Development platform.
+  - Video Live (live) supports: 'android', 'ios', 'flutter', 'uni-app'
+  - Voice Chat Room (voice) supports: 'android', 'ios', 'flutter', 'uni-app'
+  *Strategy: If user does not specify explicitly, **default values are strictly prohibited**, MUST call 'present_framework_choice' first.`,
+    goals: `[REQUIRED] Feature module list (Array):
+  - 'host_streaming': Host/Room owner broadcasting (includes authentication, create room, start streaming).
+  - 'audience_streaming': Audience/Listener viewing (includes authentication, join room, start playback).
+  - 'live_list': Room list feature (fetch room list, display room info, click to navigate).
+  *Strategy: Multiple selections allowed, e.g., ['host_streaming', 'audience_streaming', 'live_list'] for complete scenario.`
 };
 export const GET_NATIVE_LIVE_UIKIT_INTEGRATION_DEFINITION = {
     name: 'get_native_live_uikit_integration',

package/tools/definitions/get_native_live_uikit_integration_def.js.map

@@ -1 +1 @@
-{"version":3,"file":"get_native_live_uikit_integration_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_native_live_uikit_integration_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,QAAQ,EAAE;;8EAEkE;IAC5E,KAAK,EAAE;;;;;2GAKkG;CAC1G,CAAC;AAEF,MAAM,CAAC,MAAM,4CAA4C,GAAG;IAC1D,IAAI,EAAE,mCAAmC;IACzC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}
+{"version":3,"file":"get_native_live_uikit_integration_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_native_live_uikit_integration_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,QAAQ,EAAE;;;yIAG6H;IAEvI,QAAQ,EAAE;;;0IAG8H;IAExI,KAAK,EAAE;;;;6HAIoH;CAC5H,CAAC;AAEF,MAAM,CAAC,MAAM,4CAA4C,GAAG;IAC1D,IAAI,EAAE,mCAAmC;IACzC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}

package/tools/definitions/get_native_live_uikit_interaction_def.js

@@ -1,70 +1,59 @@
 const TOOL_DESCRIPTION = `
-[CORE PURPOSE]:
-A professional Native live streaming interaction integration assistant, designed to help implement interactive features on Android/iOS/Flutter/React Native platforms, including: Co-guesting (audience applying for seat), Co-hosting (cross-room connection), Host PK, and Audience List management.
+[TOOL DEFINITION]:
+Mobile **Video Live / Voice Chat Room** advanced interaction feature integrator. Designed for adding co-guesting, PK, audience management and other interactive features on top of Android/iOS/Flutter/uni-app projects that already have basic streaming capabilities.
 
-[KEYWORDS]: 'AtomicXCore', 'LiveKit', 'Co-guesting', 'Apply for Seat', 'Voice Chat Room Seat', 'Co-hosting', 'Host PK', 'Audience List', 'CoGuestStore', 'CoHostStore', 'BattleStore', 'LiveAudienceStore', 'Android', 'iOS', 'Flutter', 'React Native'.
+[⚠️ CRITICAL DEPENDENCY CHAIN]:
+1. **Non-Empty Project Principle**: Strictly prohibited to run directly in an empty project!
+   - Must confirm project already includes basic features (i.e., 'get_native_live_uikit_integration' has been successfully executed).
+   - If not included, **MUST call 'get_native_live_uikit_integration' first** to build the foundation.
+2. **Credential Closure**: After code generation, must automatically execute 'get_usersig' to generate test credentials.
 
-[WORKFLOW GUIDANCE]:
-Agents should use the 'llm_code_generation_instructions_md' field returned by this tool, which includes:
-1. Core workflow instructions (from workflow.md, including call to get_usersig tool for test credential generation).
-2. Official documentation content corresponding to the user's required features (Goals).
+[TYPICAL USE CASES (Few-Shot Examples)]:
+LLM should learn the following mapping between user instructions and parameters:
 
-LLM MUST prioritize and exclusively use the documentation content returned by this tool for code generation.
+1. **Explicit Scenario & Platform**:
+   - User: "Use AtomicXCore to implement video live co-guesting on Android"
+   - Call: scenario='live', platform='android', goals=['co_guest_interaction']
 
-[⚠️ CRITICAL PREREQUISITES]:
-**Interaction features depend on basic live streaming features**:
-- Co-guesting, Host PK, and Audience List management MUST be implemented on top of a project that already has Host Broadcasting and Audience Viewing.
-- If the user requests interaction features in an empty project, the Agent MUST:
-  1. Call 'get_native_live_uikit_integration' first to implement basic live streaming (Host Broadcasting + Audience Viewing).
-  2. Then call this tool to implement interaction features.
-  3. Ensure the code includes role selection logic (Host/Audience) for testing.
+   - User: "Use AtomicXCore to implement video live host cross-room connection and PK on iOS"
+   - Call: scenario='live', platform='ios', goals=['co_host_interaction']
 
-[FUNCTIONAL SCOPE]:
-Designed for Native live streaming interaction scenarios:
+   - User: "Use AtomicXCore to implement voice chat room host cross-room connection and PK on iOS"
+   - Call: scenario='voice', platform='ios', goals=['co_host_interaction']
 
-1. **Co-guesting Management** (co_guest_interaction):
-   - Audience applying for seat (referred to as "Apply for Seat" in voice chat, "Co-guesting" in live streaming).
-   - Host inviting audience to seat.
-   - Audience side: Apply, receive invitation, respond, leave seat, cancel application.
-   - Host side: Receive application, display application list, handle application, invite, listen for response.
+   - User: "Use AtomicXCore to implement voice chat room audience list management on Flutter"
+   - Call: scenario='voice', platform='flutter', goals=['audience_list']
 
-2. **Co-hosting & PK** (co_host_interaction):
-   - Co-hosting (CoHostStore): Cross-room connection between hosts.
-   - Host PK (BattleStore): Competitive interaction between hosts.
-   - Inviter: Send invitation, listen for result, start PK, listen for PK state.
-   - Invitee: Receive invitation, respond, receive PK challenge, respond.
-   - UI Customization: Nickname display, PK score progress bar, PK state display.
+   - User: "Use AtomicXCore to implement voice chat room seat features on uni-app"
+   - Call: scenario='voice', platform='uni-app', goals=['co_guest_interaction']
 
-3. **Audience List Management** (audience_list):
-   - Real-time audience list display.
-   - Audience count statistics.
-   - Audience events (Join/Leave).
-   - Administrator management (Set/Revoke admin).
-   - Room management (Kick out).
-   - Advanced: Welcome messages in barrage area.
+2. **Multi-Feature Combination**:
+   - User: "Implement both co-guesting and audience list in Android live room"
+   - Call: scenario='live', platform='android', goals=['co_guest_interaction', 'audience_list']
 
-[SUPPORTED PLATFORMS]: Android, iOS, Flutter, React Native (returns documentation based on 'platform' parameter).
+3. **Exception Interception (Missing Platform)**:
+   - User: "Use AtomicXCore to implement voice chat room interaction features"
+   - Action: ❌ No guessing allowed, **MUST call 'present_framework_choice' first** to let user select platform.
 
-[CONSTRAINTS]:
-1. **Platform Selection Constraint**: If the platform is not specified, you MUST call 'present_framework_choice' first.
-2. **MUST Check API Docs for Field Names**:
-   - When using data models (LiveUserInfo, SeatUserInfo, BattleUser), you MUST visit the API documentation links provided to confirm field names.
-   - DO NOT guess field names (e.g., use 'userName' instead of guessing 'name').
-3. **Result Recording Constraint**: Call 'record_result' after successful integration.
+4. **Exception Interception (Missing Scenario)**:
+   - User: "Use AtomicXCore to implement host connection and PK features", "Implement host broadcasting features"
+   - Action: ❌ No guessing allowed, **MUST call 'present_scenario_choice' first** to let user select scenario (Video Live / Voice Chat Room).
+
+[WORKFLOW MECHANISM]:
+This tool returns 'llm_code_generation_instructions_md'. You MUST strictly write code based on the returned Context and check API links at the bottom of documentation to confirm field names (guessing is prohibited).
 `;
 const PARAMETER_DESCRIPTIONS = {
-    platform: `[REQUIRED] Target platform: 'android', 'ios', 'flutter', 'rn'.
-  - MUST prompt the user to choose if not specified.
-  - The tool returns documentation and code examples based on this parameter.`,
-    goals: `List of interaction features: ['co_guest_interaction', 'co_host_interaction', 'audience_list'].
-  - 'co_guest_interaction': Co-guesting management (Apply for seat, invite, etc.).
-    * APIs: CoGuestStore.applyForSeat(), inviteToSeat(), acceptApplication(), disconnect().
-  - 'co_host_interaction': Co-hosting & PK.
-    * APIs: CoHostStore.requestHostConnection(), BattleStore.requestBattle().
-  - 'audience_list': Audience list management.
-    * APIs: LiveAudienceStore.fetchAudienceList(), kickUserOutOfRoom(), setAdministrator().
-  
-  💡 Can be combined, e.g., ['co_guest_interaction', 'co_host_interaction', 'audience_list'] for complete interaction.`
+    scenario: `[REQUIRED] Scenario type.
+  - 'live': Video Live (keywords: live streaming, show live, video, e-commerce live).
+  - 'voice': Voice Chat Room (keywords: voice chat, voice room, radio, audio room).
+  *Strategy: If user does not specify explicitly, **default values are strictly prohibited**, MUST call 'present_scenario_choice' first.`,
+    platform: `[REQUIRED] Development platform (android/ios/flutter/uni-app).
+  *Strategy: If user does not specify explicitly, **default values are strictly prohibited**, MUST call 'present_framework_choice' first.`,
+    goals: `[REQUIRED] Feature module list (Array):
+  - 'co_guest_interaction': Co-guesting/Seat management (includes apply, invite, leave seat).
+  - 'co_host_interaction': Host/Room owner cross-room connection, PK battle (⚠️ Flutter/uni-app not supported in Voice scenario).
+  - 'audience_list': Member list, count statistics, administrator permissions.
+  *Strategy: Multiple selections allowed, e.g., ['co_guest_interaction', 'audience_list'].`
 };
 export const GET_NATIVE_LIVE_UIKIT_INTERACTION_DEFINITION = {
     name: 'get_native_live_uikit_interaction',

package/tools/definitions/get_native_live_uikit_interaction_def.js.map

@@ -1 +1 @@
-{"version":3,"file":"get_native_live_uikit_interaction_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_native_live_uikit_interaction_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,QAAQ,EAAE;;8EAEkE;IAC5E,KAAK,EAAE;;;;;;;;uHAQ8G;CACtH,CAAC;AAEF,MAAM,CAAC,MAAM,4CAA4C,GAAG;IAC1D,IAAI,EAAE,mCAAmC;IACzC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}
+{"version":3,"file":"get_native_live_uikit_interaction_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_native_live_uikit_interaction_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,QAAQ,EAAE;;;yIAG6H;IAEvI,QAAQ,EAAE;0IAC8H;IAExI,KAAK,EAAE;;;;2FAIkF;CAC1F,CAAC;AAEF,MAAM,CAAC,MAAM,4CAA4C,GAAG;IAC1D,IAAI,EAAE,mCAAmC;IACzC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}

package/tools/definitions/get_web_room_feature_detail_def.js

@@ -1,90 +1,87 @@
 const TOOL_DESCRIPTION = `
-[Core Purpose]: This is a **highest-priority** Web RoomKit atomized feature query tool, specifically designed to help developers use TUIRoomKit (Atomicx version) atomized components and APIs to customize and implement meeting features. This tool provides complete feature implementation guides, code examples, and best practices, supporting developers to flexibly build personalized meeting applications based on Atomicx atomized components.
+【Core Purpose】: This is a Web RoomKit **custom UI development** tool, specifically designed to help developers use TUIRoomKit (Atomicx version) atomic components and APIs to **implement conference interfaces themselves**. This tool provides complete feature implementation guides, code examples, and best practices.
 
-**Important Note**: RoomKit State API (including useRoomState, useDeviceState, useRoomParticipantState, etc.) **fully supports H5 mobile devices**, runs normally in mobile browsers, and enables complete audio/video meeting functionality.
+⚠️⚠️⚠️ **Important: This tool is not the first choice** ⚠️⚠️⚠️
+- If users only say "develop conference app", "H5 conference", "PC conference", etc., **please prioritize using the 'get_web_room_uikit_integration' tool**
+- **Only call this tool when users explicitly express the following intentions**:
+  - Explicitly say "custom UI", "implement interface myself", "don't use pre-built components"
+  - Explicitly say "deep customization", "custom business process"
+  - Need to integrate **individual feature modules** (such as screen sharing, beauty) into **existing applications**
+  - Ask about specific API usage (such as useRoomState, useDeviceState)
 
-[Applicable Scenarios]:
-- **H5 Audio/Video Meeting Application Development**: Develop mobile H5 audio/video meeting applications, supporting mobile browsers such as WeChat Browser, Safari, Chrome, etc.
-- **PC Web Audio/Video Meeting Application Development**: Develop desktop Web audio/video meeting applications, supporting modern browsers such as Chrome, Edge, Safari, etc.
-- **Custom Meeting Interface**: Users want to implement meeting features themselves based on RoomKit atomized capabilities, rather than directly using the complete TUIRoomKit preset pages
-- **Modular Feature Integration**: Only need to integrate a specific feature module (such as screen sharing, beauty filters, chat, etc.) into existing applications
-- **Deep Customization Requirements**: Need to customize UI, business processes, interaction logic, breaking through the limitations of preset components
-- **Technical Implementation Consultation**: Learn how to use Atomicx atomized APIs (such as useRoomState, useDeviceState) to implement specific features
+【Applicable Scenarios - Custom Requirements Only】:
+- **Custom Conference Interface**: Users **explicitly indicate** they want to implement conference functionality based on RoomKit atomic capabilities themselves, rather than directly using complete TUIRoomKit pre-built pages
+- **Feature Modular Integration**: Only need to integrate specific feature modules (such as screen sharing, beauty, chat, etc.) into **existing applications**
+- **Deep Customization Requirements**: Users **explicitly say** they need custom UI, business processes, interaction logic, breaking through pre-built component limitations
+- **API Usage Consultation**: Understanding how to use Atomicx atomic APIs (such as useRoomState, useDeviceState) to implement specific functions
 
-[Feature Scope]: This tool covers all atomized feature capabilities of Web Room TUIKit (Atomicx version), including:
+【Feature Scope】: This tool covers all atomic functional capabilities of Web Room TUIKit (Atomicx version), including:
 
 **📋 Core Feature Modules:**
-1. **Device Detection & Management** (device-detection, device-state): Testing, switching, and state management of cameras, microphones, speakers, and network quality monitoring
+1. **Device Detection and Management** (device-detection, device-state): Camera, microphone, speaker testing, switching and state management, network quality monitoring
 2. **Room Lifecycle Management** (room-state): Create room, join room, leave room, destroy room, room information updates, exception handling
-3. **Member Management** (room-participant-state): Member list display, permission control, set administrator, media device management, mute all/disable all videos, kick out
-4. **Video Layout Rendering** (room-view): Grid layout, sidebar layout, top bar layout, video widget UI customization, speaker mode
-5. **In-Meeting Chat** (room-chat): Message sending/receiving, emoji/image/file, read receipts, mute management, unread count
+3. **Member Management** (room-participant-state): Member list display, permission control, set administrator, media device management, mute all/disable video for all, kick out
+4. **Video Layout Rendering** (room-view): Grid layout, sidebar layout, top bar layout, video widget UI customization, presenter mode
+5. **In-Meeting Chat** (room-chat): Message sending and receiving, emoji image files, read receipts, mute management, unread count
 6. **Screen Sharing** (screen-share): Start/stop screen sharing, system audio sharing, permission control, automatic layout switching, error handling
-7. **Schedule Room** (schedule-room): Create scheduled meeting, get scheduled list, modify/cancel schedule, meeting password handling, event listening
-8. **In-Meeting Call** (call-user-to-room): Initiate meeting invitation, accept/reject invitation, cancel invitation, timeout handling, multi-device sync
-9. **Basic Beauty Filters** (free-beauty-panel): Skin smoothing, whitening, rosy adjustment, real-time preview, remote effect
+7. **Scheduled Rooms** (schedule-room): Create scheduled meetings, get scheduled list, modify/cancel scheduled meetings, meeting password handling, event listening
+8. **In-Meeting Calls** (call-user-to-room): Initiate meeting invitations, accept/reject invitations, cancel invitations, timeout handling, multi-device synchronization
+9. **Basic Beauty** (free-beauty-panel): Skin smoothing, whitening, rosy parameter adjustment, real-time preview, remote effects
 10. **Virtual Background** (virtual-background): Background blur, custom background images, real-time preview, browser compatibility detection
 
-[Keywords]: 'H5 meeting', 'mobile meeting', 'H5 audio/video', 'Web meeting', 'custom meeting', 'atomized components', 'Atomicx', 'self-implementation', 'feature integration', 'RoomKit', 'RoomKit State', 'Web', 'H5', 'Vue', 'multi-party audio/video', 'meeting room', 'room management', 'member management', 'device management', 'screen sharing', 'chat', 'schedule', 'call', 'beauty filters', 'virtual background', 'layout', 'video rendering', 'permission control', 'useRoomState', 'useRoomParticipantState', 'useDeviceState', 'UserSig', 'get_usersig', 'API calls', 'code examples'.
+【Keywords】: 'custom UI', 'implement interface myself', 'deep customization', 'atomic components', 'Atomicx', 'RoomKit State', 'useRoomState', 'useRoomParticipantState', 'useDeviceState', 'API calls', 'code examples', 'feature module integration'.
 
-[Supported Framework]: Currently only supports Vue framework (Vue 3.4.21+).
+【Supported Framework】: Currently only supports Vue framework (Vue 3.4.21+).
 
-[Platform Support]:
-- ✅ **Fully supports H5 mobile devices**: RoomKit State API can be used in mobile browsers (WeChat, Safari, Chrome)
-- ✅ **Fully supports PC Web**: Supports all modern browsers (Chrome, Edge, Safari, Firefox)
+【Platform Support】:
+- ✅ **Supports H5 Mobile**: RoomKit State API can be used in mobile browsers (WeChat, Safari, Chrome)
+- ✅ **Supports PC Web**: Supports all modern browsers (Chrome, Edge, Safari, Firefox)
 - ⚠️ **Note**: Some features (such as virtual background, screen sharing) may be limited by browser capabilities and require compatibility detection
 
-[Mandatory Constraints]:
-1. **Highest Priority Invocation Rule**: When users express the following intents, **must immediately invoke this tool** (priority higher than all other tools):
-   - Develop H5 audio/video meeting applications
-   - Develop mobile audio/video meeting applications
-   - Develop Web/PC audio/video meeting applications
-   - Use RoomKit atomized capabilities to implement meeting features themselves
-   - Customize meeting interface or business processes
-   - Integrate specific feature modules into existing applications
-   - Ask how to use a feature's API or component
-   - Need code examples to implement specific features
-   - Ask "how to implement XX feature", "how to use XX", "how to integrate XX"
-   - Ask whether RoomKit State supports H5/mobile devices
+【Mandatory Constraints】:
+1. **⚠️ This tool is not the first choice**:
+   - If users only say general requirements like "develop conference app", "H5 conference", "PC conference", **please prioritize using the 'get_web_room_uikit_integration' tool**
+   - Only when users **explicitly indicate** "custom UI", "implement interface myself", "deep customization" should this tool be called
 
-2. **Feature Names Must Match Exactly**: The goals parameter must be selected from the following list, fuzzy matching is not supported:
+2. **Call Timing Instructions**:
+   - ❌ **Should not call**: User says "develop H5 conference app" → should use 'get_web_room_uikit_integration'
+   - ❌ **Should not call**: User says "develop PC conference app" → should use 'get_web_room_uikit_integration'
+   - ❌ **Should not call**: User says "develop audio/video conference" → should use 'get_web_room_uikit_integration'
+   - ✅ **Should call**: User says "I want to customize conference interface" → call this tool
+   - ✅ **Should call**: User says "don't use pre-built components, implement UI myself" → call this tool
+   - ✅ **Should call**: User says "integrate screen sharing feature into my existing app" → call this tool
+   - ✅ **Should call**: User asks "how to use useRoomState" → call this tool
+
+3. **Feature names must match exactly**: goals parameter must be selected from the following list, fuzzy matching is not supported:
    - 'device-detection': Device detection (pre-room testing)
-   - 'device-state': Device state management (in room)
+   - 'device-state': Device state management (in-room)
    - 'room-state': Room lifecycle management
    - 'room-participant-state': Member management
    - 'room-view': Video layout rendering
    - 'room-chat': In-meeting chat
    - 'screen-share': Screen sharing
-   - 'schedule-room': Schedule room
-   - 'call-user-to-room': In-meeting call
-   - 'free-beauty-panel': Basic beauty filters
+   - 'schedule-room': Scheduled rooms
+   - 'call-user-to-room': In-meeting calls
+   - 'free-beauty-panel': Basic beauty
    - 'virtual-background': Virtual background
 
-3. **Invocation Timing Description**:
-   - ✅ **Must invoke**: User wants to develop H5/mobile audio/video meeting applications
-   - ✅ **Must invoke**: User wants to develop Web/PC audio/video meeting applications
-   - ✅ **Must invoke**: User wants to implement meeting features themselves, ask about API usage, need code examples, integrate specific feature modules
-   - ✅ **Must invoke**: User mentions specific feature names (such as "screen sharing", "beauty filters", "scheduled meeting", "device management")
-   - ✅ **Must invoke**: User asks whether RoomKit State supports H5 or mobile devices
-   - ❌ **No need to invoke**: Pure theoretical concept consultation, product selection suggestions, discussions not involving specific implementation
-
-**Important Note**: Detailed descriptions and code examples for login authentication are included in the workflow document (workflow.md), and the Agent will automatically include complete login guidance when returning results.
+**Important Note**: Detailed login authentication instructions and code examples are included in the workflow documentation (workflow.md), and Agent will automatically include complete login guidance when returning results.
 `;
 const PARAMETER_DESCRIPTIONS = {
     framework: 'Framework type supported by Web Room TUIKit, currently only supports vue (Vue 3.4.21+)',
-    goals: `List of features requested by the user to implement, for example ['device-detection', 'room-state', 'screen-share']. The tool will concurrently fetch corresponding dedicated documentation content based on this list.
+    goals: `List of features requested by the user to implement, for example ['device-detection', 'room-state', 'screen-share']. The tool will concurrently retrieve corresponding dedicated documentation content based on this list.
 
 Available values:
 - 'device-detection': Device detection (pre-room testing of camera, microphone, speaker)
-- 'device-state': Device state management (in-room device control, switching, state listening)
+- 'device-state': Device state management (device control, switching, state monitoring within room)
 - 'room-state': Room lifecycle management (create, join, leave, destroy room)
 - 'room-participant-state': Member management (member list, permission control, mute/disable video, kick out)
-- 'room-view': Video layout rendering (grid layout, sidebar layout, video widget)
-- 'room-chat': In-meeting chat (message sending/receiving, emoji/file, read receipts)
+- 'room-view': Video layout rendering (grid layout, sidebar layout, video widgets)
+- 'room-chat': In-meeting chat (message sending/receiving, emoji files, read receipts)
 - 'screen-share': Screen sharing (start/stop sharing, system audio, permission control)
-- 'schedule-room': Schedule room (create schedule, get list, modify/cancel schedule)
-- 'call-user-to-room': In-meeting call (initiate invitation, accept/reject, cancel invitation)
-- 'free-beauty-panel': Basic beauty filters (skin smoothing, whitening, rosy adjustment)
+- 'schedule-room': Scheduled rooms (create scheduled meetings, get list, modify/cancel scheduled meetings)
+- 'call-user-to-room': In-meeting calls (initiate invitations, accept/reject, cancel invitations)
+- 'free-beauty-panel': Basic beauty (skin smoothing, whitening, rosy parameter adjustment)
 - 'virtual-background': Virtual background (background blur, custom images, compatibility detection)`
 };
 export const GET_WEB_ROOM_FEATURE_DETAIL_DEFINITION = {

package/tools/definitions/get_web_room_feature_detail_def.js.map

@@ -1 +1 @@
-{"version":3,"file":"get_web_room_feature_detail_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_web_room_feature_detail_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuExB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,wFAAwF;IACnG,KAAK,EAAE;;;;;;;;;;;;;qGAa4F;CACpG,CAAC;AAEF,MAAM,CAAC,MAAM,sCAAsC,GAAG;IACpD,IAAI,EAAE,6BAA6B;IACnC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}
+{"version":3,"file":"get_web_room_feature_detail_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_web_room_feature_detail_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoExB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,wFAAwF;IACnG,KAAK,EAAE;;;;;;;;;;;;;qGAa4F;CACpG,CAAC;AAEF,MAAM,CAAC,MAAM,sCAAsC,GAAG;IACpD,IAAI,EAAE,6BAA6B;IACnC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}

package/tools/definitions/get_web_room_uikit_integration_def.js

@@ -1,40 +1,56 @@
 const TOOL_DESCRIPTION = `
-[Core Purpose]: As a professional Web audio/video meeting TUIRoomKit (Atomicx version) integration assistant, this tool is specifically designed to provide Agents with workflow action instructions and real-time aggregated latest documentation content to guide LLM in helping users implement audio/video meeting features.
+【Core Purpose】: As a professional Web audio/video conference TUIRoomKit (Atomicx version) integration assistant, this tool is specifically designed to provide Agent with workflow action instructions and real-time aggregated latest documentation content to guide LLM in helping users implement audio/video conference functionality.
 
-[Feature Description]:
-TUIRoomKit (Atomicx version) provides a complete audio/video meeting solution by default, including:
-- **Meeting Entry Page (home.vue)**: Device detection, room creation/join functionality
-- **Meeting Room Page (room.vue)**: Complete header, video layout, control bar, and sidebar panels
-- **Applicable Scenarios**: Enterprise meetings, online education, remote collaboration, multi-party video calls, etc.
+⭐⭐⭐ **Default First Choice Tool** ⭐⭐⭐
+Whether users have PC or H5 mobile requirements, this tool should be **called first**! This tool provides out-of-the-box UI component solutions with completed PC + H5 responsive adaptation.
+Only when users **explicitly indicate the need for custom UI interface** should the 'get_web_room_feature_detail' tool be considered.
 
-[Keywords]:
-'TUIRoomKit', 'Atomicx', 'audio/video meeting', 'TRTC', 'Vue3', 'PC', 'meeting room', 'video call', 'screen sharing', 'device detection', 'room management', 'grid layout', 'sidebar layout', 'source code integration', 'atomized components'.
+【Feature Description】:
+TUIRoomKit (Atomicx version) provides a complete audio/video conference solution by default, including:
+- **Conference Entry Page (home.vue)**: Device detection, room creation/joining functionality
+- **Conference Room Page (room.vue)**: Complete header, video layout, control bar and side panels
+- **Applicable Scenarios**: Enterprise meetings, online education, remote collaboration, multi-person video calls, etc.
 
-[Technical Features]:
+【Platform Support】:
+- **PC**: ✅ Full feature support, including conference entry page, conference room page, device detection, screen sharing, etc.
+- **H5 Mobile**: ✅ Full support! UI components are adapted for H5, can directly use pre-built UI components in mobile browsers to implement audio/video conference functionality
+
+【Tool Call Priority - Important】:
+- ✅ **This tool is the default first choice**: When users say "develop conference app", "H5 conference", "PC conference", "audio/video conference" → call this tool
+- ✅ **This tool takes priority**: When users don't explicitly say they want "custom UI" → call this tool
+- ❌ **Only use get_web_room_feature_detail in the following cases**: Users explicitly say "custom interface", "implement UI myself", "don't use pre-built components", "deep customization"
+
+【Keywords】:
+'TUIRoomKit', 'Atomicx', 'audio/video conference', 'TRTC', 'Vue3', 'PC', 'H5', 'mobile', 'conference room', 'video call', 'screen sharing', 'device detection', 'room management', 'grid layout', 'sidebar layout', 'source code integration', 'atomic components', 'conference application', 'Web conference', 'mobile conference'.
+
+【Technical Features】:
 - **Source Code Integration Method**: Clone repository from GitHub and copy core source code files (not npm package method)
-- **Atomicx Atomized Component Architecture**: Developers can flexibly combine atomized components to build personalized meeting interfaces
-- **PC Vue3 Projects Only**: Currently does not support Vue2.x framework or H5 platform
+- **Atomicx Atomic Component Architecture**: Developers can flexibly combine atomic components to build personalized conference interfaces
+- **PC + H5 Full Platform Support**: UI components have completed responsive adaptation, same codebase supports both PC and H5
 - **TypeScript + SCSS**: Requires TypeScript and SCSS development environment configuration
 
-[Action Instructions & Workflow Guidance]:
-When handling user requirements, Agent should use the llm_code_generation_instructions_md field returned by this tool. This field contains:
-1. Core workflow instructions: Including environment preparation, dependency installation, source code cloning & copying, routing configuration, UserSig authentication, and other complete processes.
-2. Real-time documentation content: Provides the latest content from official integration guides, including all configuration details and code examples.
+【Action Instructions and Workflow Guidance】:
+When Agent processes user requirements, it should use the llm_code_generation_instructions_md field returned by this tool. This field contains:
+1. Core workflow instructions: Including environment preparation, dependency installation, source code cloning and copying, routing configuration, authentication UserSig and other complete processes.
+2. Real-time documentation content: Provides the latest content of official integration guides, including all configuration details and code examples.
+
+LLM must prioritize and exclusively use the real-time content returned by this tool to generate code, avoiding accessing external URLs independently.
 
-LLM must prioritize and exclusively use the real-time content returned by this tool to generate code, avoiding accessing external URLs on its own.
+【Mandatory Constraints】:
+1. **This tool is the default first choice for PC/H5 conference requirements**: When users have audio/video conference needs (whether PC or H5), call this tool first.
+2. Framework limitation: TUIRoomKit (Atomicx version) only supports Vue3 framework (Vue 3.4.21 and above), does not support Vue2.x.
+3. Source code integration method: Must clone TUIRoomKit repository from GitHub and copy core source code files, cannot use simple npm install method.
+4. Authentication credential configuration: Read SDKAppID and SDKSecretKey from MCP environment variables, configure to src/config/basic-info-config.js file.
+5. Security warning: Must inform users that client-side UserSig generation is only suitable for local testing, production environment must generate UserSig on server side.
+6. Result recording constraint: After TUIRoomKit integration is completed and project starts successfully, must call 'record_result' tool to record integration results.
+7. **Only when users explicitly request custom UI**, guide them to use 'get_web_room_feature_detail' tool. Otherwise, use this tool's UI component solution by default.
 
-[Mandatory Constraints]:
-1. Platform Limitation: TUIRoomKit (Atomicx version) only supports PC Vue3 projects, does not support Vue2.x or H5 platform.
-2. Source Code Integration Method: Must clone TUIRoomKit repository from GitHub and copy core source code files, cannot use simple npm install method.
-3. Authentication Credential Configuration: Read SDKAppID and SDKSecretKey from MCP environment variables, configure them in src/config/basic-info-config.js file.
-4. Security Warning: Must inform users that client-side UserSig generation is only suitable for local testing, production environment must generate UserSig on server side.
-5. Result Recording Constraint: After TUIRoomKit integration is complete and project starts successfully, must call 'record_result' tool to record integration results.
-6. Default Full Integration: TUIRoomKit (Atomicx version) provides a complete meeting solution by default, no need to distinguish integration modes.
+【Supported Framework】: vue3 (only supports Vue 3.4.21 and above).
 
-[Supported Framework]: vue3 (Only supports Vue 3.4.21 and above).
+【Supported Platforms】: PC, H5 mobile (UI components have completed responsive adaptation, ready to use out of the box).
 `;
 const PARAMETER_DESCRIPTIONS = {
-    framework: 'TUIRoomKit (Atomicx version) framework type. Fixed value: vue3 (PC Vue3 project).',
+    framework: 'TUIRoomKit (Atomicx version) framework type. Fixed value: vue3 (supports PC and H5 mobile).',
 };
 export const GET_WEB_ROOM_UIKIT_INTEGRATION_DEFINITION = {
     name: 'get_web_room_uikit_integration',

package/tools/definitions/get_web_room_uikit_integration_def.js.map

@@ -1 +1 @@
-{"version":3,"file":"get_web_room_uikit_integration_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_web_room_uikit_integration_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,mFAAmF;CAC/F,CAAC;AAEF,MAAM,CAAC,MAAM,yCAAyC,GAAG;IACvD,IAAI,EAAE,gCAAgC;IACtC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}
+{"version":3,"file":"get_web_room_uikit_integration_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_web_room_uikit_integration_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,6FAA6F;CACzG,CAAC;AAEF,MAAM,CAAC,MAAM,yCAAyC,GAAG;IACvD,IAAI,EAAE,gCAAgC;IACtC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}

package/tools/definitions/present_scenario_choice_def.js

@@ -0,0 +1,53 @@
+const TOOL_DESCRIPTION = `
+【Core Purpose】:
+Acts as a **mandatory decision gate** in the AtomicXCore/LiveKit integration workflow. When user requirements involve basic features (streaming/viewing) or interactive features (co-guest/PK/seat management) but **media type is undefined** (video vs audio-only), this tool must be invoked to intercept and require user to choose one.
+
+【⚠️ Mandatory Constraints】:
+1. **No Default Selection**: AI is strictly prohibited from deciding scenario on behalf of user.
+2. **Scenario Exclusivity**: Video Live (live) and Voice Chat Room (voice) have fundamental differences in underlying SDK logic and platform compatibility, must be clarified.
+3. **Pre-requisite Call**: Before this tool receives explicit user response, subsequent code generation tools must not be called.
+
+【Applicable Scope】:
+This tool only applies to scenario selection for the following two tools:
+1. **get_native_live_uikit_integration**: Basic feature integration (host streaming, audience viewing, live list)
+2. **get_native_live_uikit_interaction**: Interactive feature integration (co-guest, PK, audience management)
+
+⚠️ The following tools **do not require scenario distinction**, do not trigger this tool:
+- **get_native_live_uikit_extra_features**: Extended features (beauty, audio effects, barrage, gifts) are universal across video live and voice chat room scenarios
+
+【Trigger Decision Logic】:
+✅ **Should Trigger** cases:
+- User says "Use AtomicXCore to implement host streaming/audience viewing" -> Trigger (Video live or voice chat room?)
+- User says "Use AtomicXCore to implement host connection and PK" -> Trigger (Video co-guest or voice seat management?)
+- User says "Implement live room co-guest/seat features" -> Trigger (Video co-guest or voice seat management?)
+- User says "I want to build a live streaming App" -> Trigger (Video live or voice chat room?)
+
+❌ **Should Not Trigger** cases:
+- User says "Implement live room beauty/audio effects/barrage/gift features" -> Don't trigger (Extended features don't require scenario)
+- User explicitly says "video live", "show live", "e-commerce live" -> Don't trigger (Already clarified as live scenario)
+- User explicitly says "voice chat room", "voice room", "voice social" -> Don't trigger (Already clarified as voice scenario)
+`;
+const SELECTION_PROMPT_TEXT = `
+To provide you with an accurate AtomicXCore integration solution, please first clarify your business scenario:
+
+### 1. Video Live (Scenario: live)
+* **Core Experience**: Camera-based video streaming (show live, e-commerce, gaming).
+* **Interactive Features**: Supports **video** co-guest, cross-room **PK (with video comparison)**.
+* **Platform Support**: Android, iOS, Flutter, React Native.
+
+### 2. Voice Chat Room (Scenario: voice)
+* **Core Experience**: Audio-only interaction (voice social, multi-person radio, Werewolf).
+* **Interactive Features**: Supports **seat** management (join/leave seat).
+* **Platform Support**: Android, iOS, Flutter, uni-app.
+* **⚠️ Limitation**: Flutter and uni-app currently do not support host cross-room connection and PK.
+
+---
+**Please tell me which scenario you choose? (Video Live / Voice Chat Room)**
+`;
+export const PRESENT_SCENARIO_CHOICE_DEFINITION = {
+    name: 'present_scenario_choice',
+    description: TOOL_DESCRIPTION,
+    selectionText: SELECTION_PROMPT_TEXT, // 供 Agent 直接输出给用户的文案
+    parameter_descriptions: {}, // 此工具为交互引导类，无需入参
+};
+//# sourceMappingURL=present_scenario_choice_def.js.map

package/tools/definitions/present_scenario_choice_def.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"present_scenario_choice_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/present_scenario_choice_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BxB,CAAC;AAEF,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;CAgB7B,CAAC;AAEF,MAAM,CAAC,MAAM,kCAAkC,GAAG;IAChD,IAAI,EAAE,yBAAyB;IAC/B,WAAW,EAAE,gBAAgB;IAC7B,aAAa,EAAE,qBAAqB,EAAE,qBAAqB;IAC3D,sBAAsB,EAAE,EAAE,EAAE,iBAAiB;CAC9C,CAAC"}