@tencent-rtc/mcp 1.3.8 → 1.3.9

package/resource/doc/tuicallkit/android/workflow.md

@@ -0,0 +1,441 @@
+# Android TUICallKit Audio/Video Call Application Code Generation Workflow Instructions
+
+## 🌐 Language Requirements
+
+**IMPORTANT**: All generated code, UI text, comments, and user interface elements **MUST be in English**. This includes:
+- Variable names, method names, class names
+- UI text (button labels, hints, error messages, etc.)
+- Code comments and documentation
+- Log messages and debug output
+- User-facing strings and prompts
+
+## 📋 Instruction Purpose
+
+Provide Agent with a **code generation blueprint for implementing Android TUICallKit audio/video call core functionality**, and guide Agent to **prioritize using real-time latest documentation content obtained from tools**, specifically for Android audio/video call application scenarios.
+
+---
+
+## 🛑 Agent Execution Hard Constraints (Guardrails)
+
+Agent must strictly follow these instructions when generating code:
+
+### 0. 🚨 Core Principles (Highest Priority)
+
+- ✅ Strictly generate code according to examples in integration documentation, do not modify arbitrarily
+- ✅ Fully implement login, single-person call, and multi-person call functionality
+- ✅ Use `get_usersig` tool to generate UserSig for test accounts
+- ✅ Use source code method to import components (clone `tuicallkit-kt` and `atomic_x` from GitHub)
+
+### 1. Documentation-Driven Integration
+- Strictly follow the steps in `llm_code_generation_instructions_md` returned by tools
+- Follow best practices and example code from integration documentation
+
+### 2. Component Import Method
+- **Source Code Import Method**: Clone code from GitHub, copy `tuicallkit-kt` and `atomic_x` directories to project
+  ```bash
+  # Clone TUIKit_Android repository
+  git clone https://github.com/Tencent-RTC/TUIKit_Android.git
+  # Copy atomic_x and call/tuicallkit-kt directories to project app sibling directory
+  ```
+- **settings.gradle.kts configuration**:
+  ```kotlin
+  include(":tuicallkit-kt")
+  include(":atomic_x")
+  ```
+- **settings.gradle configuration**:
+  ```groovy
+  include ':tuicallkit-kt'
+  include ':atomic_x'
+  ```
+- **app/build.gradle.kts dependency configuration**:
+  ```kotlin
+  dependencies {
+      api(project(":tuicallkit-kt"))
+  }
+  ```
+- **app/build.gradle dependency configuration**:
+  ```groovy
+  dependencies {
+      api project(':tuicallkit-kt')
+  }
+  ```
+
+### 3. Silent Integration Execution
+- After all code writing is completed, automatically sync Gradle and build project in the final step
+- **Gradle Command Execution Strategy (Multi-level Fallback to Ensure Success)**:
+  1. **First Priority**: Try executing `./gradlew build` directly
+  2. **Second Priority**: If failed, try `./gradlew assembleDebug`
+  3. **Third Priority**: If still failed, **guide user to manually sync in Android Studio** (see guidance below)
+- After successful build, prompt user to run application on emulator or real device
+
+#### 📋 Manual Execution Fallback Guidance
+
+**When automatic execution fails, guide user to execute manually**:
+
+1. Click **File → Sync Project with Gradle Files** in Android Studio
+2. Wait for Gradle sync to complete
+3. Click **Run** button to run application
+
+**Common Issues**: Gradle sync failure → Check JDK version (requires JDK 17+); Compilation failure → Check Android SDK version
+
+### 4. Authentication Credential Configuration (Important)
+- Call `get_usersig` tool to get SDKAppID, UserID, UserSig
+- Generate UserSig for 4 test accounts (user001/002/003/004)
+- Authentication information can be hardcoded during testing phase, but must be annotated as test-only
+- ⚠️ Security Warning: Inform user that UserSig must be generated on server side in production environment
+
+### 5. LoginActivity Implementation Constraints 🔴
+
+**⚠️ Priority Check Item: Check if login page already exists in project**:
+- Before implementing login page, **must first check if login page already exists in project**
+- If login page already exists, **must ask user if they want to execute default behavior**:
+  - **Option 1**: Use default behavior (create new LoginActivity, including dropdown, 4 test accounts, etc.)
+  - **Option 2**: Modify based on existing login page (retain user's UI and interaction logic, only add necessary TUILogin login logic)
+- If user chooses Option 2, should:
+  - Retain user's existing login page UI and interaction logic
+  - Only call `TUILogin.login` for secondary login after successful login
+  - Do not force use of dropdown and 4 test accounts
+- If no login page exists in project, or user chooses Option 1, implement according to default behavior below
+
+**Default Login Page Implementation Requirements**:
+- **Must implement login page**, including the following functionality:
+  1. **Dropdown to select UserID**: Provide four options: user001, user002, user003, user004
+  2. **Display SDKAppID**: Get from `get_usersig` and display (read-only, not editable)
+  3. **Auto-generate UserSig**: Automatically match from pre-generated UserSig based on selected UserID
+  4. **Login button**: Call `TUILogin.login` to login
+- **Login interface must call `TUILogin.login`**, passing complete credentials obtained from `get_usersig`
+- Automatically navigate to main page (MainActivity/HomePage) after successful login
+
+**LoginActivity Core Implementation Points (Kotlin)**:
+
+```kotlin
+// 1. Import necessary classes
+import com.tencent.qcloud.tuicore.TUILogin
+import com.tencent.qcloud.tuicore.interfaces.TUICallback
+
+// 2. Define test account mapping table (get from get_usersig)
+val userSigMap = mapOf(
+    "user001" to "xxx",
+    "user002" to "xxx",
+    "user003" to "xxx",
+    "user004" to "xxx"
+)
+
+// 3. UI components
+// - SDKAppID display (read-only TextView)
+// - UserID dropdown (Spinner, options generated from userSigMap.keys)
+// - Login button
+
+// 4. Login logic
+TUILogin.login(context, sdkAppId, userId, userSig, object : TUICallback() {
+    override fun onSuccess() {
+        // Navigate to MainActivity
+    }
+    override fun onError(errorCode: Int, errorMessage: String) {
+        // Display error message
+    }
+})
+```
+
+### 6. MainActivity/HomePage Implementation Constraints 🔴
+
+**Must implement main page**, including the following functionality:
+
+1. **Display current logged-in UserID**
+2. **Audio/Video Call Functionality** (unified user selection):
+   - **User List (multi-select)**: Display selectable users (user002, user003, user004, excluding current logged-in user)
+   - **Smart Call Type Detection**:
+     - Select **1 user** → Automatically initiate **single-person call**
+     - Select **multiple users** → Automatically initiate **multi-person call**
+   - **Voice Call Button**: Call `TUICallKit.createInstance(context).calls` to initiate voice call
+   - **Video Call Button**: Call `TUICallKit.createInstance(context).calls` to initiate video call
+   - **Implementation Method**: Use CheckBox list, support single and multi-selection
+3. **Logout Button**: Call `TUILogin.logout` to logout
+
+**MainActivity Core Implementation Points (Kotlin)**:
+
+```kotlin
+// 1. Import necessary classes
+import com.tencent.qcloud.tuikit.tuicallkit.TUICallKit
+import io.trtc.tuikit.atomicxcore.api.call.CallMediaType
+import io.trtc.tuikit.atomicxcore.api.call.CallParams
+
+// 2. Display current logged-in user (TextView)
+
+// 3. User selection area (unified single/multi-person call)
+// - User list: val availableUsers = listOf("user002", "user003", "user004").filter { it != currentUserId }
+// - Multi-select box: CheckBox (support selecting 1 or multiple users)
+// - Selected users: val selectedUsers = mutableListOf<String>()
+
+// 4. Call button area
+// - Voice call button: Button
+// - Video call button: Button
+
+// 5. Initiate call logic
+val params = CallParams()
+TUICallKit.createInstance(context).calls(selectedUsers, CallMediaType.Audio, params, object : CompletionHandler {
+    override fun onSuccess() {
+        // Success callback
+    }
+    override fun onFailure(code: Int, desc: String) {
+        // Failure callback
+    }
+})
+
+// 6. Logout logic
+TUILogin.logout(object : TUICallback() {
+    override fun onSuccess() {
+        // Navigate back to LoginActivity
+    }
+    override fun onError(errorCode: Int, errorMessage: String) {
+        // Display error message
+    }
+})
+```
+
+### 7. Project Configuration Constraints 🔴
+
+**Must complete the following project configurations**:
+
+1. **Obfuscation Rules Configuration**: Add to the end of `app/proguard-rules.pro` file:
+   ```proguard
+   -keep class com.tencent.** { *; }
+   ```
+
+2. **AndroidManifest.xml Configuration**: Add `tools:replace="android:allowBackup"` in application node:
+   ```xml
+   <application
+       android:name=".BaseApplication"
+       android:allowBackup="false"
+       android:icon="@drawable/app_ic_launcher"
+       android:label="@string/app_name"
+       android:largeHeap="true"
+       android:theme="@style/AppTheme"
+       tools:replace="android:allowBackup">
+   ```
+
+3. **Gradle JDK Version**: AGP 8.0+ requires Gradle runtime to use Java 17 or higher
+
+### 8. Build Script Syntax Check (Important) 🔴
+
+**⚠️ Before configuring build scripts, must first check the build script type used by the project**, choose correct syntax based on actual situation:
+
+| Build Script File | Syntax Type | Example |
+|-------------|---------|------|
+| `settings.gradle` | Groovy DSL | `include ':tuicallkit-kt'` |
+| `settings.gradle.kts` | Kotlin DSL | `include(":tuicallkit-kt")` |
+| `build.gradle` | Groovy DSL | `api project(':tuicallkit-kt')` |
+| `build.gradle.kts` | Kotlin DSL | `api(project(":tuicallkit-kt"))` |
+
+**Check Steps**:
+1. Check build script file names in project root directory and `app/` directory
+2. If ends with `.gradle` → Use Groovy syntax
+3. If ends with `.gradle.kts` → Use Kotlin DSL syntax
+
+### 9. Android Project Standards
+- Android version requirement: Android 5.0 (SDK API Level 21) and above
+- Gradle version requirement: Gradle 4.2.1 and above
+- Use Kotlin language (recommended), also supports Java
+
+### 10. Environment Dependency Preparation
+- Ensure user has installed Android Studio
+- Ensure user has configured Android SDK
+- JDK 17+ version (AGP 8.0+ requirement)
+- **If automatic build fails, must guide user to manually sync Gradle in Android Studio**
+
+---
+
+## 📦 Core Version Requirements
+
+| Tool/Platform | Minimum Version Requirement |
+|----------|-------------|
+| **Android** | >= 5.0 (API Level 21) |
+| **Gradle** | >= 4.2.1 |
+| **JDK** | >= 17 (AGP 8.0+) |
+
+**For detailed tool version requirements, please refer to the "Preparation Work - Environment Requirements" section in the integration documentation**
+
+---
+
+## 📦 Automated Execution Commands
+
+After Agent code generation is completed, execute automatically in order:
+
+```bash
+# 1. Clone TUIKit_Android repository (if not already cloned)
+git clone https://github.com/Tencent-RTC/TUIKit_Android.git
+
+# 2. Copy components to project directory
+cp -r TUIKit_Android/atomic_x ./
+cp -r TUIKit_Android/call/tuicallkit-kt ./
+
+# 3. Build project
+./gradlew assembleDebug
+```
+
+**Fallback Strategy**: `./gradlew` failure → Guide user to manually sync Gradle in Android Studio
+
+---
+
+## 📱 Real Device Debugging Guidance (User Guide)
+
+### Android Real Device Debugging
+1. USB connect device
+2. Enable developer mode (tap version number 7 times) + USB debugging
+3. Device authorize USB debugging (allow)
+4. Execute `adb devices` to verify connection
+5. Click Run button in Android Studio, select target device
+
+### Android Emulator Debugging
+1. Open Android Studio → Device Manager
+2. Create or start emulator
+3. Click Run button to run application
+
+---
+
+## 🔄 Complete Automation Workflow
+
+```mermaid
+graph TD
+    A[Receive User Requirements] --> B[Check Android Development Environment]
+    B --> C[Clone TUIKit_Android Repository]
+    C --> D[Copy tuicallkit-kt and atomic_x to Project]
+    D --> E[Configure settings.gradle: Add include]
+    E --> F[Configure app/build.gradle: Add Dependencies]
+    F --> G[Configure Obfuscation Rules: proguard-rules.pro]
+    G --> H[Configure AndroidManifest.xml]
+    H --> I[Call get_usersig Tool to Generate UserSig for 4 Accounts]
+    I --> J[Implement LoginActivity: Dropdown Select UserID]
+    J --> K[Implement MainActivity: Single-person Call and Multi-person Call]
+    K --> L[Call record_result to Record Integration Results]
+    L --> M[Execute Gradle Build]
+    M --> N{Build Successful?}
+    N -->|Yes| O[Guide User to Connect Device and Run]
+    N -->|No| P[Guide User to Manually Sync in Android Studio]
+    O --> Q[Project Launch Successful]
+    P --> Q
+```
+
+---
+
+## 📝 Key Points Summary
+
+| Category | Requirement |
+|------|------|
+| **Android Version** | Android 5.0 (API Level 21) and above |
+| **Integration Method** | Source code method (clone `tuicallkit-kt` and `atomic_x` from GitHub) |
+| **Documentation Priority** | ⚠️ Strictly follow example code in integration documentation, do not modify arbitrarily |
+| **Silent Integration** | Automatically build project after code writing is completed |
+| **Credential Acquisition** | ⚠️ Must use `get_usersig` tool to generate UserSig for 4 test accounts (user001/002/003/004) |
+| **Login Page** | ⚠️ Must implement dropdown to select UserID, automatically match UserSig, prohibit manual input |
+| **Main Page** | ⚠️ Must support unified user list, selecting 1 user automatically initiates single-person call, selecting multiple users automatically initiates multi-person call |
+| **Security Notice** | ⚠️ Must inform user: Client-generated UserSig is only suitable for testing, production environment must generate UserSig on server side |
+| **Result Recording** | ⚠️ Must call `record_result` tool to record results after integration completion |
+| **Project Configuration** | ⚠️ Must configure obfuscation rules and AndroidManifest.xml |
+
+---
+
+## 🎯 Agent Execution Checklist
+
+After completing code generation, Agent must confirm all the following items:
+
+### Component Import
+- [ ] Cloned TUIKit_Android repository
+- [ ] Copied `tuicallkit-kt` and `atomic_x` to project app sibling directory
+- [ ] Configured `settings.gradle(.kts)` to add include
+- [ ] Configured `app/build.gradle(.kts)` to add dependencies
+
+### Project Configuration
+- [ ] Configured `proguard-rules.pro` obfuscation rules
+- [ ] Configured `AndroidManifest.xml` to add `tools:replace`
+
+### Code Generation
+- [ ] Called `get_usersig` tool to generate UserSig for 4 accounts
+- [ ] Implemented LoginActivity (dropdown select UserID, no manual input box)
+- [ ] Implemented MainActivity (unified user list, select 1 for single-person call, select multiple for multi-person call)
+
+### Final Check
+- [ ] Called `record_result` tool to record integration results
+- [ ] Executed Gradle build or guided user to manually sync
+- [ ] Prompted user to select device to run application
+- [ ] Informed user: Production environment must generate UserSig on server side
+
+---
+
+## ❓ Having Issues? AI Can Help You Solve Them Quickly
+
+**When dependency sync or compilation errors occur, please provide complete error information to AI, which can help you quickly locate and solve problems.**
+
+### 📋 Common Error Scenarios
+
+| Error Type | Description | AI Can Help You |
+|---------|------|-----------|
+| **Gradle Sync Failure** | Dependency download failure, version conflicts, repository connection timeout, etc. | Analyze dependency conflicts, recommend mirror sources, fix version compatibility |
+| **Compilation Errors** | Class not found, method signature mismatch, API version incompatibility, etc. | Locate missing dependencies, fix import statements, adapt API changes |
+| **Runtime Crashes** | Null pointer, missing permissions, initialization order errors, etc. | Analyze stack information, check permission configuration, fix initialization logic |
+| **Obfuscation Issues** | Release package functionality abnormal, classes incorrectly obfuscated, etc. | Supplement obfuscation rules, locate obfuscated classes |
+
+### 💡 How to Efficiently Report Errors
+
+To help AI solve problems more quickly and accurately, please provide the following information:
+
+1. **Complete Error Log**: Copy complete error information from Android Studio's Build Output or Logcat
+2. **Error Timing**: Explain whether it occurred during Gradle sync, compilation, or runtime
+3. **Operation Steps**: Briefly describe what operations you performed before the error occurred
+
+**Example Feedback Format**:
+```
+Error Timing: During Gradle sync
+Error Information:
+> Could not resolve com.tencent.liteav:LiteAVSDK_TRTC:xxx
+> Repository connection failed: xxx
+
+Attempted Operations: Re-sync, clear cache
+```
+
+### 🔧 Common Issues Quick Self-Check
+
+Before reporting to AI, you can try the following operations first:
+
+1. **Gradle Sync Failure**:
+   - File → Invalidate Caches / Restart
+   - Check network connection, try using VPN or configure domestic mirror sources
+   - Check if JDK version is 17+
+
+2. **Class/Method Not Found**:
+   - Confirm `tuicallkit-kt` and `atomic_x` directories have been correctly copied to project root directory
+   - Confirm include configuration has been added in `settings.gradle(.kts)`
+   - Click File → Sync Project with Gradle Files to re-sync
+
+3. **Version Compatibility Issues**:
+   - Check `compileSdk` and `targetSdk` versions (recommended 34+)
+   - Check Gradle Plugin version and Gradle version matching relationship
+
+---
+
+## 🔗 Required Tools to Use
+
+### `get_usersig` - Get Test Authentication Information
+Get SDKAppID, UserID (user001/002/003/004), UserSig.
+- LoginActivity: Dropdown select UserID
+- MainActivity: Display selectable user list (excluding current logged-in user)
+- Prohibit manual input of SDKAppID/SecretKey/UserSig
+
+### `record_result` - Record Integration Results
+Call after completing all integration steps and successfully building project
+
+---
+
+## 📚 Related Resource Links
+
+- **TUICallKit Android GitHub**: https://github.com/Tencent-RTC/TUIKit_Android
+- **Tencent Cloud Real-Time Communication TRTC Console**: https://console.cloud.tencent.com/trtc
+- **Server-side UserSig Generation**: https://cloud.tencent.com/document/product/647/17275
+- **Enable TRTC Service**: https://cloud.tencent.com/document/product/647/16788
+- **Android Developer Official Documentation**: https://developer.android.com/docs
+
+---
+
+**Applicable Platform**: Android  
+**TUICallKit Version**: tuicallkit-kt (latest version)  
+**Minimum Requirements**: Android 5.0 (API Level 21), Gradle 4.2.1, JDK 17+

package/tools/common/present-scenario-choice.js

@@ -0,0 +1,16 @@
+import { PRESENT_SCENARIO_CHOICE_DEFINITION } from '../definitions/present_scenario_choice_def.js';
+const registryPresentScenarioChoiceTool = (mcpServer) => {
+    const { name, description, selectionText } = PRESENT_SCENARIO_CHOICE_DEFINITION;
+    mcpServer.tool(name, description, {}, () => {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: selectionText,
+                }
+            ]
+        };
+    });
+};
+export { registryPresentScenarioChoiceTool };
+//# sourceMappingURL=present-scenario-choice.js.map

package/tools/common/present-scenario-choice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-scenario-choice.js","sourceRoot":"","sources":["../../../src/tools/common/present-scenario-choice.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kCAAkC,EAAE,MAAM,+CAA+C,CAAC;AAEnG,MAAM,iCAAiC,GAAG,CAAC,SAAoB,EAAE,EAAE;IACjE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,aAAa,EAAE,GAAG,kCAAkC,CAAC;IAChF,SAAS,CAAC,IAAI,CACZ,IAAI,EACJ,WAAW,EACX,EAAE,EACF,GAAG,EAAE;QACH,OAAO;YACL,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,aAAa;iBACpB;aACF;SACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACP,CAAC,CAAC;AAEF,OAAO,EAAE,iCAAiC,EAAE,CAAC"}

package/tools/definitions/get_native_call_uikit_integration_def.js

@@ -1,27 +1,43 @@
 const TOOL_DESCRIPTION = `
-【Core Purpose】: As a professional Native audio/video call TUICallKit 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 mobile audio/video call features.
+【Core Purpose】: As a professional Native audio/video call TUICallKit 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 mobile audio/video call functionality.
+
+【⚠️ Important Parameter Reminder】:
+The platform parameter name for this tool is "framework", not "platform"!
+- ✅ Correct call: {"framework": "android"}
+- ❌ Incorrect call: {"platform": "android"}
 
 【Functional Goals】:
-Integrate complete audio/video call features. Including one-on-one calls, group calls, call answering, call interface, etc. **Suitable for building WeChat/WeCom-style audio/video call applications, supporting one-on-one and group call scenarios.**
+Integrate complete audio/video call functionality. Including single-person calls, multi-person calls, call answering, call interface, etc. **Suitable for building WeChat/Enterprise WeChat style audio/video call applications, supporting one-on-one and multi-person call scenarios.**
 
 【Keywords】:
-'Native', 'Mobile', 'Call', 'TUICallKit', 'Audio/Video Call', 'Video Call', 'Voice Call', 'WeChat', 'WeCom', 'Flutter', 'Android', 'iOS', 'Integration', 'One-on-One Call', 'Group Call', 'Call', 'Answer'.
+'Native', 'Mobile', 'Call', 'TUICallKit', 'Audio/Video Call', 'Video Call', 'Voice Call', 'WeChat', 'Enterprise WeChat', 'Flutter', 'Android', 'iOS', 'Integration', 'Single-person Call', 'Multi-person Call', 'Call', 'Answer'.
 
 【Action Instructions and Workflow Guidance】:
-When handling user requirements, Agents 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, SDK initialization, UserSig authentication, and component version information.
-2. Real-time documentation content: Providing the latest content from official integration guides.
+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, SDK initialization, UserSig authentication, and component version descriptions.
+2. Real-time documentation content: providing the latest content from official integration guides.
 
 LLM must prioritize and exclusively use the real-time content returned by this tool to generate code, avoiding accessing external URLs independently.
 
+【Parameter Description】:
+- **framework** (Required): Target development platform. Note the parameter name is "framework" not "platform"
+  - "flutter": Flutter cross-platform development
+  - "android": Android native development  
+  - "ios": iOS native development
+
+【Call Examples】:
+- Android integration: {"framework": "android"}
+- iOS integration: {"framework": "ios"}
+- Flutter integration: {"framework": "flutter"}
+
 【Mandatory Constraints】:
-1. Platform Selection Constraint: If the user has not explicitly specified a platform, or the intent is unclear, must first call the 'present_framework_choice' tool to guide the user to choose among flutter, android, ios.
-2. Result Recording Constraint: After TUICallKit component integration is complete and the project starts successfully, must call the 'record_result' tool to record integration results.
+1. Platform selection constraint: Parameter name must use "framework" (not platform). If user does not clearly specify platform, or intent is unclear, must prioritize calling 'present_framework_choice' tool to guide user in choosing among flutter, android, ios.
+2. Result recording constraint: After TUICallKit component integration is completed and project starts successfully, must call 'record_result' tool to record integration results.
 
 【Supported Platforms】: flutter, android, ios.
 `;
 const PARAMETER_DESCRIPTIONS = {
-    framework: 'Native audio/video call TUICallKit platform type. Available values: flutter (Flutter cross-platform), android (Android native), ios (iOS native).',
+    framework: '【Important】Native audio/video call TUICallKit platform type. Note: parameter name is "framework" not "platform"! Available values: flutter (Flutter cross-platform), android (Android native), ios (iOS native).',
 };
 export const GET_NATIVE_CALL_UIKIT_DEFINITION = {
     name: 'get_native_call_uikit_integration',

package/tools/definitions/get_native_call_uikit_integration_def.js.map

@@ -1 +1 @@
-{"version":3,"file":"get_native_call_uikit_integration_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_native_call_uikit_integration_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;CAqBxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,mJAAmJ;CAC/J,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG;IAC9C,IAAI,EAAE,mCAAmC;IACzC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}
+{"version":3,"file":"get_native_call_uikit_integration_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_native_call_uikit_integration_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,kNAAkN;CAC9N,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG;IAC9C,IAAI,EAAE,mCAAmC;IACzC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}

package/tools/definitions/get_native_chat_uikit_integration_def.js

@@ -1,29 +1,51 @@
 const TOOL_DESCRIPTION = `
-【Core Purpose】: As a professional Native chat TUIKit 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 mobile instant messaging (IM) features.
+【Core Purpose】: As a professional Native chat TUIKit 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 mobile instant messaging (IM) functionality.
 
-【Feature Goals】:
-1. full-featured: Integrate full functionality. Includes conversation list, chat window, group management, personal center, etc. **Suitable for building complete mobile applications in WeChat/Enterprise WeChat style, or as a core Tab module of an App.**
-2. chat-only: Integrate chat window only. **Suitable for lightweight conversation scenarios such as customer service consultation, online medical consultation, private chat on order details page, etc.**
+【⚠️ Important Parameter Reminder】:
+The platform parameter name for this tool is "framework", not "platform"!
+- ✅ Correct call: {"framework": "android", "goals": ["full-featured"]}
+- ❌ Wrong call: {"platform": "android", "goals": ["full-featured"]}
+\n
+
+【Function Goals】:
+1. full-featured: Integrate full functionality. Includes conversation list, chat window, group management, personal center, etc. **Suitable for building WeChat/Enterprise WeChat style complete mobile applications, or as core Tab modules of Apps.**
+2. chat-only: Integrate chat window only. **Suitable for customer service consultation, medical online consultation, order detail page private chat and other lightweight conversation scenarios.**
+
+【Parameter Description】:
+- **framework** (Required): Target development platform. Note the parameter name is "framework" not "platform"
+  - "flutter": Flutter cross-platform development
+  - "android": Android native development  
+  - "ios": iOS native development
+- **goals** (Required): Function goal list
+  - ["full-featured"]: Complete application functionality
+  - ["chat-only"]: Chat window only
+
+【Call Examples】:
+- Android full-featured integration: {"framework": "android", "goals": ["full-featured"]}
+- iOS chat window: {"framework": "ios", "goals": ["chat-only"]}
+- Flutter full-featured: {"framework": "flutter", "goals": ["full-featured"]}
 
 【Keywords】:
-'Native', 'mobile', 'Chat', 'TUIKit', 'chat', 'instant messaging', 'WeChat', 'Enterprise WeChat', 'Flutter', 'Android', 'iOS', 'integration', 'customer service', 'medical consultation', 'TabBar', 'message entry', 'conversation list', 'dialog box'.
+'Native', 'Mobile', 'Chat', 'TUIKit', 'Chat', 'Instant Messaging', 'WeChat', 'Enterprise WeChat', 
+'framework=flutter', 'framework=android', 'framework=ios', 
+'Integration', 'Customer Service', 'Medical Consultation', 'TabBar', 'Message Entry', 'Conversation List', 'Dialog Box'.
 
-【Action Instructions and Workflow Guidance】:
-When processing user requirements, the 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, SDK initialization, UserSig authentication, and component version descriptions.
-2. Real-time documentation content: dynamically returns corresponding official integration guides based on the selected goals.
+【Action Instructions and Workflow Guidance】:\n
+When processing 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, SDK initialization, UserSig authentication and component version descriptions.
+2. Real-time documentation content: Dynamically returns corresponding official integration guides based on selected goals.
 
-LLM must prioritize and exclusively use the real-time content returned by this tool to generate code, avoiding accessing external URLs on its own.
+LLM must prioritize and exclusively use the real-time content returned by this tool to generate code, avoiding accessing external URLs independently.\n
 
 【Mandatory Constraints】:
-1. Platform Selection Constraint: If the user does not explicitly specify a platform, or the intent is unclear, the 'present_framework_choice' tool must be called first to guide the user to choose among flutter, android, and ios.
-2. Result Recording Constraint: After TUIKit component integration is completed and the project starts successfully, the 'record_result' tool must be called to record the integration result.
+1. Platform selection constraint: Parameter name must use "framework" (not platform). If the user does not clearly specify a platform, or the intention is unclear, must prioritize calling the 'present_framework_choice' tool to guide users to choose among flutter, android, ios.
+2. Result recording constraint: After TUIKit component integration is completed and the project starts successfully, must call the 'record_result' tool to record integration results.
 
 【Supported Platforms】: flutter, android, ios.
 `;
 const PARAMETER_DESCRIPTIONS = {
-    framework: 'Native chat TUIKit platform type. Options: flutter (Flutter cross-platform), android (Android native), ios (iOS native).',
-    goals: "List of feature goals requested by the user. Options: ['full-featured'] (standard application), ['chat-only'] (customer service/consultation/popup).",
+    framework: '⚠️ Note the parameter name is "framework" not "platform"! Native chat TUIKit platform type. Options: flutter (Flutter cross-platform), android (Android native), ios (iOS native).',
+    goals: "List of functional goals requested by user to implement. Options: ['full-featured'] (standard application), ['chat-only'] (customer service/consultation/popup).",
 };
 export const GET_NATIVE_CHAT_UIKIT_INTEGRATION_DEFINITION = {
     name: 'get_native_chat_uikit_integration',

package/tools/definitions/get_native_chat_uikit_integration_def.js.map

@@ -1 +1 @@
-{"version":3,"file":"get_native_chat_uikit_integration_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_native_chat_uikit_integration_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;CAsBxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,0HAA0H;IACrI,KAAK,EAAE,sJAAsJ;CAC9J,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_chat_uikit_integration_def.js","sourceRoot":"","sources":["../../../src/tools/definitions/get_native_chat_uikit_integration_def.ts"],"names":[],"mappings":"AAAA,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CxB,CAAC;AAEF,MAAM,sBAAsB,GAAG;IAC7B,SAAS,EAAE,oLAAoL;IAC/L,KAAK,EAAE,kKAAkK;CAC1K,CAAC;AAEF,MAAM,CAAC,MAAM,4CAA4C,GAAG;IAC1D,IAAI,EAAE,mCAAmC;IACzC,WAAW,EAAE,gBAAgB;IAC7B,sBAAsB,EAAE,sBAAsB;CAC/C,CAAC"}