🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org
Python agentai-societiesartificial-intelligencecommunicative-aicooperative-aideep-learninglarge-language-modelsmulti-agent-systemsnatural-language-processing
enhance: add skill creator scripts and reference, update function naming (#3792)
Wendong-Fanb1b3595823e6
diff --git a/.camel/skills/skill-creator/SKILL.md b/.camel/skills/skill-creator/SKILL.mdindex bcef6b68c..9d59d1f6a 100644--- a/.camel/skills/skill-creator/SKILL.md+++ b/.camel/skills/skill-creator/SKILL.md@@ -261,12 +261,14 @@ Skip this step only if the skill being developed already exists, and iteration oWhen creating a new skill from scratch, always run the `init_skill.py` script. The script conveniently generates a new template skill directory that automatically includes everything a skill requires, making the skill creation process much more efficient and reliable.-Usage:+Usage (run from the skill-creator skill directory):```bash-scripts/init_skill.py <skill-name> --path <output-directory>+python scripts/init_skill.py <skill-name> --path <output-directory>```+Note: The scripts are located in this skill's `scripts/` directory. Use the full path if running from a different directory.+The script:- Creates the skill directory at the specified path@@ -319,18 +321,22 @@ Write instructions for using the skill and its bundled resources.### Step 5: Packaging a Skill-Once development of the skill is complete, it must be packaged into a distributable .skill file that gets shared with the user. The packaging process automatically validates the skill first to ensure it meets all requirements:+Once development of the skill is complete, it must be packaged into a distributable .skill file that gets shared with the user. The packaging process automatically validates the skill first to ensure it meets all requirements.++Usage (run from the skill-creator skill directory):```bash-scripts/package_skill.py <path/to/skill-folder>+python scripts/package_skill.py <path/to/skill-folder>```Optional output directory specification:```bash-scripts/package_skill.py <path/to/skill-folder> ./dist+python scripts/package_skill.py <path/to/skill-folder> ./dist```+Note: The scripts are located in this skill's `scripts/` directory. Use the full path if running from a different directory.+The packaging script will:1. **Validate** the skill automatically, checking:@@ -353,4 +359,4 @@ After testing the skill, users may request improvements. Often this happens righ1. Use the skill on real tasks2. Notice struggles or inefficiencies3. Identify how SKILL.md or bundled resources should be updated-4. Implement changes and test again\ No newline at end of file+4. Implement changes and test againdiff --git a/.camel/skills/skill-creator/references/output-patterns.md b/.camel/skills/skill-creator/references/output-patterns.mdnew file mode 100644index 000000000..f876d65a1--- /dev/null+++ b/.camel/skills/skill-creator/references/output-patterns.md@@ -0,0 +1,82 @@+# Output Patterns++Use these patterns when skills need to produce consistent, high-quality output.++## Template Pattern++Provide templates for output format. Match the level of strictness to your needs.++**For strict requirements (like API responses or data formats):**++```markdown+## Report structure++ALWAYS use this exact template structure:++# [Analysis Title]++## Executive summary+[One-paragraph overview of key findings]++## Key findings+- Finding 1 with supporting data+- Finding 2 with supporting data+- Finding 3 with supporting data++## Recommendations+1. Specific actionable recommendation+2. Specific actionable recommendation+```++**For flexible guidance (when adaptation is useful):**++```markdown+## Report structure++Here is a sensible default format, but use your best judgment:++# [Analysis Title]++## Executive summary+[Overview]++## Key findings+[Adapt sections based on what you discover]++## Recommendations+[Tailor to the specific context]++Adjust sections as needed for the specific analysis type.+```++## Examples Pattern++For skills where output quality depends on seeing examples, provide input/output pairs:++```markdown+## Commit message format++Generate commit messages following these examples:++**Example 1:**+Input: Added user authentication with JWT tokens+Output:+```+feat(auth): implement JWT-based authentication++Add login endpoint and token validation middleware+```++**Example 2:**+Input: Fixed bug where dates displayed incorrectly in reports+Output:+```+fix(reports): correct date formatting in timezone conversion++Use UTC timestamps consistently across report generation+```++Follow this style: type(scope): brief description, then detailed explanation.+```++Examples help agent understand the desired style and level of detail more clearly than descriptions alone.diff --git a/.camel/skills/skill-creator/references/workflows.md b/.camel/skills/skill-creator/references/workflows.mdnew file mode 100644index 000000000..1e47859e8--- /dev/null+++ b/.camel/skills/skill-creator/references/workflows.md@@ -0,0 +1,28 @@+# Workflow Patterns++## Sequential Workflows++For complex tasks, break operations into clear, sequential steps. It is often helpful to give agent an overview of the process towards the beginning of SKILL.md:++```markdown+Filling a PDF form involves these steps:++1. Analyze the form (run analyze_form.py)+2. Create field mapping (edit fields.json)+3. Validate mapping (run validate_fields.py)+4. Fill the form (run fill_form.py)+5. Verify output (run verify_output.py)+```++## Conditional Workflows++For tasks with branching logic, guide agent through decision points:++```markdown+1. Determine the modification type:+ **Creating new content?** → Follow "Creation workflow" below+ **Editing existing content?** → Follow "Editing workflow" below++2. Creation workflow: [steps]+3. Editing workflow: [steps]+```diff --git a/.camel/skills/skill-creator/scripts/init_skill.py b/.camel/skills/skill-creator/scripts/init_skill.pynew file mode 100644index 000000000..abdebc9c0--- /dev/null+++ b/.camel/skills/skill-creator/scripts/init_skill.py@@ -0,0 +1,370 @@+# Based on https://github.com/anthropics/skills+"""+Skill Initializer - Creates a new skill from template++Usage:+ init_skill.py <skill-name> --path <path>++Examples:+ init_skill.py my-new-skill --path skills/public+ init_skill.py my-api-helper --path skills/private+ init_skill.py custom-skill --path /custom/location+"""++import shutil+import sys+from pathlib import Path++# Import from same directory - add parent to path for module resolution+_script_dir = Path(__file__).parent.resolve()+if str(_script_dir) not in sys.path:+ sys.path.insert(0, str(_script_dir))++from quick_validate import validate_skill_name # noqa: E402++SKILL_TEMPLATE = """---+name: {skill_name}+description: "TODO: Complete and informative explanation of what the skill+ does and when to use it. Include WHEN to use this skill - specific scenarios,+ file types, or tasks that trigger it."+---++# {skill_title}++## Overview++[TODO: 1-2 sentences explaining what this skill enables]++## Structuring This Skill++[TODO: Choose the structure that best fits this skill's purpose. Common+patterns:++**1. Workflow-Based** (best for sequential processes)+- Works well when there are clear step-by-step procedures+- Example: DOCX skill with "Workflow Decision Tree" → "Reading" → "Creating" →+"Editing"+- Structure: ## Overview → ## Workflow Decision Tree → ## Step 1 → ## Step 2...++**2. Task-Based** (best for tool collections)+- Works well when the skill offers different operations/capabilities+- Example: PDF skill with "Quick Start" → "Merge PDFs" → "Split PDFs" →+"Extract Text"+- Structure: ## Overview → ## Quick Start → ## Task Category 1 → ## Task+Category 2...++**3. Reference/Guidelines** (best for standards or specifications)+- Works well for brand guidelines, coding standards, or requirements+- Example: Brand styling with "Brand Guidelines" → "Colors" → "Typography" →+"Features"+- Structure: ## Overview → ## Guidelines → ## Specifications → ## Usage...++**4. Capabilities-Based** (best for integrated systems)+- Works well when the skill provides multiple interrelated features+- Example: Product Management with "Core Capabilities" → numbered capability+list+- Structure: ## Overview → ## Core Capabilities → ### 1. Feature → ### 2.+Feature...++Patterns can be mixed and matched as needed. Most skills combine patterns (e.+g., start with task-based, add workflow for complex operations).++Delete this entire "Structuring This Skill" section when done - it's just+guidance.]++## [TODO: Replace with the first main section based on chosen structure]++[TODO: Add content here. See examples in existing skills:+- Code samples for technical skills+- Decision trees for complex workflows+- Concrete examples with realistic user requests+- References to scripts/templates/references as needed]++## Resources++This skill includes example resource directories that demonstrate how to+organize different types of bundled resources:++### scripts/+Executable code (Python/Bash/etc.) that can be run directly to perform+specific operations.++**Examples from other skills:**+- PDF skill: `fill_fillable_fields.py`, `extract_form_field_info.py` -+utilities for PDF manipulation+- DOCX skill: `document.py`, `utilities.py` - Python modules for document+processing++**Appropriate for:** Python scripts, shell scripts, or any executable code+that performs automation, data processing, or specific operations.++**Note:** Scripts may be executed without loading into context, but can still+be read by agent for patching or environment adjustments.++### references/+Documentation and reference material intended to be loaded into context to+inform agent's process and thinking.++**Examples from other skills:**+- Product management: `communication.md`, `context_building.md` - detailed+workflow guides+- BigQuery: API reference documentation and query examples+- Finance: Schema documentation, company policies++**Appropriate for:** In-depth documentation, API references, database schemas,+comprehensive guides, or any detailed information that agent should reference+while working.++### assets/+Files not intended to be loaded into context, but rather used within the+output agent produces.++**Examples from other skills:**+- Brand styling: PowerPoint template files (.pptx), logo files+- Frontend builder: HTML/React boilerplate project directories+- Typography: Font files (.ttf, .woff2)++**Appropriate for:** Templates, boilerplate code, document templates, images,+icons, fonts, or any files meant to be copied or used in the final output.++---++**Any unneeded directories can be deleted.** Not every skill requires all+three types of resources.+"""++EXAMPLE_SCRIPT = '''#!/usr/bin/env python3+"""+Example helper script for {skill_name}++This is a placeholder script that can be executed directly.+Replace with actual implementation or delete if not needed.++Example real scripts from other skills:+- pdf/scripts/fill_fillable_fields.py - Fills PDF form fields+- pdf/scripts/convert_pdf_to_images.py - Converts PDF pages to images+"""++def main():+ print("This is an example script for {skill_name}")+ # TODO: Add actual script logic here+ # This could be data processing, file conversion, API calls, etc.++if __name__ == "__main__":+ main()+'''++EXAMPLE_REFERENCE = """# Reference Documentation for {skill_title}++This is a placeholder for detailed reference documentation.+Replace with actual reference content or delete if not needed.++Example real reference docs from other skills:+- product-management/references/communication.md - Comprehensive guide for+status updates+- product-management/references/context_building.md - Deep-dive on gathering+context+- bigquery/references/ - API references and query examples++## When Reference Docs Are Useful++Reference docs are ideal for:+- Comprehensive API documentation+- Detailed workflow guides+- Complex multi-step processes+- Information too lengthy for main SKILL.md+- Content that's only needed for specific use cases++## Structure Suggestions++### API Reference Example+- Overview+- Authentication+- Endpoints with examples+- Error codes+- Rate limits++### Workflow Guide Example+- Prerequisites+- Step-by-step instructions+- Common patterns+- Troubleshooting+- Best practices+"""++EXAMPLE_ASSET = """# Example Asset File++This placeholder represents where asset files would be stored.+Replace with actual asset files (templates, images, fonts, etc.) or delete if+not needed.++Asset files are NOT intended to be loaded into context, but rather used within+the output agent produces.++Example asset files from other skills:+- Brand guidelines: logo.png, slides_template.pptx+- Frontend builder: hello-world/ directory with HTML/React boilerplate+- Typography: custom-font.ttf, font-family.woff2+- Data: sample_data.csv, test_dataset.json++## Common Asset Types++- Templates: .pptx, .docx, boilerplate directories+- Images: .png, .jpg, .svg, .gif+- Fonts: .ttf, .otf, .woff, .woff2+- Boilerplate code: Project directories, starter files+- Icons: .ico, .svg+- Data files: .csv, .json, .xml, .yaml++Note: This is a text placeholder. Actual assets can be any file type.+"""+++def title_case_skill_name(skill_name):+ r"""Convert hyphenated skill name to Title Case for display."""+ return ' '.join(word.capitalize() for word in skill_name.split('-'))+++def init_skill(skill_name, path):+ r"""Create a new skill directory with template SKILL.md.++ Args:+ skill_name: Name of the skill+ path: Path where the skill directory should be created++ Returns:+ Path to created skill directory, or None if error+ """+ # Validate skill name before proceeding+ is_valid, error_msg = validate_skill_name(skill_name)+ if not is_valid:+ print(f"❌ Error: {error_msg}")+ return None++ # Determine skill directory path+ skill_dir = Path(path).resolve() / skill_name++ # Check if directory already exists+ if skill_dir.exists():+ print(f"❌ Error: Skill directory already exists: {skill_dir}")+ return None++ # Create skill directory+ try:+ skill_dir.mkdir(parents=True, exist_ok=False)+ print(f"✅ Created skill directory: {skill_dir}")+ except Exception as e:+ print(f"❌ Error creating directory: {e}")+ return None++ # Create SKILL.md from template+ skill_title = title_case_skill_name(skill_name)+ skill_content = SKILL_TEMPLATE.format(+ skill_name=skill_name, skill_title=skill_title+ )++ skill_md_path = skill_dir / 'SKILL.md'+ try:+ skill_md_path.write_text(skill_content)+ print("✅ Created SKILL.md")+ except Exception as e:+ print(f"❌ Error creating SKILL.md: {e}")+ # Clean up on failure+ _cleanup_skill_dir(skill_dir)+ return None++ # Create resource directories with example files+ try:+ # Create scripts/ directory with example script+ scripts_dir = skill_dir / 'scripts'+ scripts_dir.mkdir(exist_ok=True)+ example_script = scripts_dir / 'example.py'+ example_script.write_text(EXAMPLE_SCRIPT.format(skill_name=skill_name))+ example_script.chmod(0o755)+ print("✅ Created scripts/example.py")++ # Create references/ directory with example reference doc+ references_dir = skill_dir / 'references'+ references_dir.mkdir(exist_ok=True)+ example_reference = references_dir / 'api_reference.md'+ example_reference.write_text(+ EXAMPLE_REFERENCE.format(skill_title=skill_title)+ )+ print("✅ Created references/api_reference.md")++ # Create assets/ directory with example asset placeholder+ assets_dir = skill_dir / 'assets'+ assets_dir.mkdir(exist_ok=True)+ example_asset = assets_dir / 'example_asset.txt'+ example_asset.write_text(EXAMPLE_ASSET)+ print("✅ Created assets/example_asset.txt")+ except Exception as e:+ print(f"❌ Error creating resource directories: {e}")+ # Clean up on failure+ _cleanup_skill_dir(skill_dir)+ return None++ # Print next steps+ print(f"\n✅ Skill '{skill_name}' initialized successfully at {skill_dir}")+ print("\nNext steps:")+ print(+ "1. Edit SKILL.md to complete the TODO items and update "+ "the description"+ )+ print(+ "2. Customize or delete the example files in scripts/, "+ "references/, and assets/"+ )+ print("3. Run the validator when ready to check the skill structure")++ return skill_dir+++def _cleanup_skill_dir(skill_dir):+ r"""Clean up a partially created skill directory.++ Args:+ skill_dir: Path to the skill directory to remove+ """+ try:+ if skill_dir.exists():+ shutil.rmtree(skill_dir)+ print(f"🧹 Cleaned up partial skill directory: {skill_dir}")+ except Exception as cleanup_error:+ print(+ f"⚠️ Warning: Could not clean up directory {skill_dir}: "+ f"{cleanup_error}"+ )+++def main():+ if len(sys.argv) < 4 or sys.argv[2] != '--path':+ print("Usage: init_skill.py <skill-name> --path <path>")+ print("\nSkill name requirements:")+ print(" - Kebab-case identifier (e.g., 'my-data-analyzer')")+ print(" - Lowercase letters, digits, and hyphens only")+ print(" - Max 64 characters")+ print(" - Must match directory name exactly")+ print("\nExamples:")+ print(" init_skill.py my-new-skill --path skills/public")+ print(" init_skill.py my-api-helper --path skills/private")+ print(" init_skill.py custom-skill --path /custom/location")+ sys.exit(1)++ skill_name = sys.argv[1]+ path = sys.argv[3]++ print(f"🚀 Initializing skill: {skill_name}")+ print(f" Location: {path}")+ print()++ result = init_skill(skill_name, path)++ if result:+ sys.exit(0)+ else:+ sys.exit(1)+++if __name__ == "__main__":+ main()diff --git a/.camel/skills/skill-creator/scripts/package_skill.py b/.camel/skills/skill-creator/scripts/package_skill.pynew file mode 100644index 000000000..d4ae40207--- /dev/null+++ b/.camel/skills/skill-creator/scripts/package_skill.py@@ -0,0 +1,179 @@+# Based on https://github.com/anthropics/skills+"""+Skill Packager - Creates a distributable .skill file of a skill folder++Usage:+ python package_skill.py <path/to/skill-folder> [output-directory]++Example:+ python package_skill.py skills/public/my-skill+ python package_skill.py skills/public/my-skill ./dist+"""++import sys+import zipfile+from pathlib import Path++# Files and directories to exclude from the packaged skill+EXCLUDED_PATTERNS = {+ '.DS_Store',+ '.git',+ '.gitignore',+ '.gitattributes',+ '__pycache__',+ '.pyc',+ '.pyo',+ '.pyd',+ '.so',+ '.egg-info',+ '.eggs',+ '.pytest_cache',+ '.mypy_cache',+ '.ruff_cache',+ '.coverage',+ '.env',+ '.venv',+ 'venv',+ '.idea',+ '.vscode',+ 'node_modules',+ '*.log',+ '.tox',+ 'dist',+ 'build',+}+++def _should_exclude(file_path: Path) -> bool:+ r"""Check if a file should be excluded from packaging.++ Args:+ file_path: Path to check++ Returns:+ True if the file should be excluded, False otherwise+ """+ # Check each part of the path+ for part in file_path.parts:+ # Check exact matches+ if part in EXCLUDED_PATTERNS:+ return True+ # Check suffix matches (e.g., .pyc files)+ for pattern in EXCLUDED_PATTERNS:+ if pattern.startswith('.') and part.endswith(pattern):+ return True+ if pattern.startswith('*') and part.endswith(pattern[1:]):+ return True+ return False+++# Import from same directory - add parent to path for module resolution+_script_dir = Path(__file__).parent.resolve()+if str(_script_dir) not in sys.path:+ sys.path.insert(0, str(_script_dir))++from quick_validate import validate_skill # noqa: E402+++def package_skill(skill_path, output_dir=None):+ r"""Package a skill folder into a .skill file.++ Args:+ skill_path: Path to the skill folder+ output_dir: Optional output directory for the .skill file (defaults to+ current directory)++ Returns:+ Path to the created .skill file, or None if error+ """+ skill_path = Path(skill_path).resolve()++ # Validate skill folder exists+ if not skill_path.exists():+ print(f"❌ Error: Skill folder not found: {skill_path}")+ return None++ if not skill_path.is_dir():+ print(f"❌ Error: Path is not a directory: {skill_path}")+ return None++ # Validate SKILL.md exists+ skill_md = skill_path / "SKILL.md"+ if not skill_md.exists():+ print(f"❌ Error: SKILL.md not found in {skill_path}")+ return None++ # Run validation before packaging+ print("🔍 Validating skill...")+ valid, message = validate_skill(skill_path)+ if not valid:+ print(f"❌ Validation failed: {message}")+ print(" Please fix the validation errors before packaging.")+ return None+ print(f"✅ {message}\n")++ # Determine output location+ skill_name = skill_path.name+ if output_dir:+ output_path = Path(output_dir).resolve()+ output_path.mkdir(parents=True, exist_ok=True)+ else:+ output_path = Path.cwd()++ skill_filename = output_path / f"{skill_name}.skill"++ # Create the .skill file (zip format)+ try:+ with zipfile.ZipFile(+ skill_filename, 'w', zipfile.ZIP_DEFLATED+ ) as zipf:+ # Walk through the skill directory+ for file_path in skill_path.rglob('*'):+ if file_path.is_file():+ # Skip excluded files+ rel_path = file_path.relative_to(skill_path)+ if _should_exclude(rel_path):+ print(f" Skipped: {rel_path}")+ continue+ # Calculate the relative path within the zip+ arcname = file_path.relative_to(skill_path.parent)+ zipf.write(file_path, arcname)+ print(f" Added: {arcname}")++ print(f"\n✅ Successfully packaged skill to: {skill_filename}")+ return skill_filename++ except Exception as e:+ print(f"❌ Error creating .skill file: {e}")+ return None+++def main():+ if len(sys.argv) < 2:+ print(+ "Usage: python package_skill.py "+ "<path/to/skill-folder> [output-directory]"+ )+ print("\nExample:")+ print(" python package_skill.py skills/public/my-skill")+ print(" python package_skill.py skills/public/my-skill ./dist")+ sys.exit(1)++ skill_path = sys.argv[1]+ output_dir = sys.argv[2] if len(sys.argv) > 2 else None++ print(f"📦 Packaging skill: {skill_path}")+ if output_dir:+ print(f" Output directory: {output_dir}")+ print()++ result = package_skill(skill_path, output_dir)++ if result:+ sys.exit(0)+ else:+ sys.exit(1)+++if __name__ == "__main__":+ main()diff --git a/.camel/skills/skill-creator/scripts/quick_validate.py b/.camel/skills/skill-creator/scripts/quick_validate.pynew file mode 100644index 000000000..8d5a4af7c--- /dev/null+++ b/.camel/skills/skill-creator/scripts/quick_validate.py@@ -0,0 +1,177 @@+# Based on https://github.com/anthropics/skills+"""+Quick validation script for skills - minimal version+"""++import re+import sys+from pathlib import Path++try:+ import yaml+except ImportError:+ print(+ "❌ Error: PyYAML is required but not installed.\n"+ " Install it with: pip install pyyaml"+ )+ sys.exit(1)+++def validate_skill_name(name):+ r"""Validate skill name format.++ Args:+ name: Name of the skill to validate (should already be stripped)++ Returns:+ Tuple of (is_valid, error_message). error_message is None if valid.+ """+ if not name:+ return False, "Name cannot be empty"++ # Check naming convention (kebab-case: lowercase with hyphens)+ if not re.match(r'^[a-z0-9-]+$', name):+ return (+ False,+ f"Name '{name}' should be kebab-case (lowercase "+ f"letters, digits, and hyphens only)",+ )++ if name.startswith('-') or name.endswith('-'):+ return False, f"Name '{name}' cannot start or end with hyphen"++ if '--' in name:+ return False, f"Name '{name}' cannot contain consecutive hyphens"++ # Check name length (max 64 characters per spec)+ if len(name) > 64:+ return (+ False,+ f"Name is too long ({len(name)} characters). Maximum is "+ f"64 characters.",+ )++ return True, None+++def validate_skill(skill_path):+ r"""Basic validation of a skill"""+ skill_path = Path(skill_path)++ # Check SKILL.md exists+ skill_md = skill_path / 'SKILL.md'+ if not skill_md.exists():+ return False, "SKILL.md not found"++ # Read and validate frontmatter+ content = skill_md.read_text()+ if not content.startswith('---'):+ return False, "No YAML frontmatter found"++ # Extract frontmatter+ match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)+ if not match:+ return False, "Invalid frontmatter format"++ frontmatter_text = match.group(1)++ # Parse YAML frontmatter+ try:+ frontmatter = yaml.safe_load(frontmatter_text)+ if not isinstance(frontmatter, dict):+ return False, "Frontmatter must be a YAML dictionary"+ except yaml.YAMLError as e:+ return False, f"Invalid YAML in frontmatter: {e}"++ # Define allowed properties+ ALLOWED_PROPERTIES = {+ 'name',+ 'description',+ 'license',+ 'allowed-tools',+ 'metadata',+ 'compatibility',+ }++ # Check for unexpected properties (excluding nested keys under metadata)+ unexpected_keys = set(frontmatter.keys()) - ALLOWED_PROPERTIES+ if unexpected_keys:+ return False, (+ f"Unexpected key(s) in SKILL.md frontmatter: "+ f"{', '.join(sorted(unexpected_keys))}. "+ f"Allowed properties are: {', '.join(sorted(ALLOWED_PROPERTIES))}"+ )++ # Check required fields+ if 'name' not in frontmatter:+ return False, "Missing 'name' in frontmatter"+ if 'description' not in frontmatter:+ return False, "Missing 'description' in frontmatter"++ # Extract name for validation+ name = frontmatter.get('name', '')+ if not isinstance(name, str):+ return False, f"Name must be a string, got {type(name).__name__}"+ name = name.strip()++ # Use shared validation function+ is_valid, error_msg = validate_skill_name(name)+ if not is_valid:+ return False, error_msg++ # Extract and validate description+ description = frontmatter.get('description', '')+ if not isinstance(description, str):+ return (+ False,+ f"Description must be a string, got {type(description).__name__}",+ )+ description = description.strip()+ if not description:+ return False, "Description cannot be empty"+ else:+ # Check for placeholder/TODO description+ if description.upper().startswith('TODO'):+ return (+ False,+ "Description appears to be a placeholder "+ "(starts with 'TODO'). Please provide a real description.",+ )+ # Check for angle brackets+ if '<' in description or '>' in description:+ return False, "Description cannot contain angle brackets (< or >)"+ # Check description length (max 1024 characters per spec)+ if len(description) > 1024:+ return (+ False,+ f"Description is too long ({len(description)} "+ f"characters). Maximum is 1024 characters.",+ )++ # Validate compatibility field if present (optional)+ compatibility = frontmatter.get('compatibility', '')+ if compatibility:+ if not isinstance(compatibility, str):+ return (+ False,+ f"Compatibility must be a string, got "+ f"{type(compatibility).__name__}",+ )+ if len(compatibility) > 500:+ return (+ False,+ f"Compatibility is too long ({len(compatibility)} "+ f"characters). Maximum is 500 characters.",+ )++ return True, "Skill is valid!"+++if __name__ == "__main__":+ if len(sys.argv) != 2:+ print("Usage: python quick_validate.py <skill_directory>")+ sys.exit(1)++ valid, message = validate_skill(sys.argv[1])+ print(message)+ sys.exit(0 if valid else 1)diff --git a/camel/toolkits/skill_toolkit.py b/camel/toolkits/skill_toolkit.pyindex 0944fe1be..f9b600105 100644--- a/camel/toolkits/skill_toolkit.py+++ b/camel/toolkits/skill_toolkit.py@@ -360,7 +360,7 @@ class SkillToolkit(BaseToolkit):return "\n".join(output_lines).strip()- def get_skill(self, name: Union[str, List[str]]) -> str:+ def load_skill(self, name: Union[str, List[str]]) -> str:r"""Load one or more skills by name.Args:@@ -382,8 +382,8 @@ class SkillToolkit(BaseToolkit):def get_tools(self) -> List[FunctionTool]:r"""Return the skill tools with injected available skills."""list_tool = FunctionTool(self.list_skills)- get_tool = FunctionTool(self.get_skill)- schema = get_tool.get_openai_tool_schema()+ load_tool = FunctionTool(self.load_skill)+ schema = load_tool.get_openai_tool_schema()schema["function"]["description"] = self._build_description()- get_tool.set_openai_tool_schema(schema)- return [list_tool, get_tool]+ load_tool.set_openai_tool_schema(schema)+ return [list_tool, load_tool]diff --git a/camel/types/enums.py b/camel/types/enums.pyindex 77c347246..abf706ae8 100644--- a/camel/types/enums.py+++ b/camel/types/enums.py@@ -2131,6 +2131,9 @@ class JinaRerankerModelType(str, Enum):JINA_COLBERT_V2 = "jina-colbert-v2"r"""ColBERT-based reranker for token-level matching."""+ JINA_RERANKER_V3 = "jina-reranker-v3"+ r"""Latest multilingual reranker with 131K context window (0.6B params)."""+class HuggingFaceRepoType(str, Enum):DATASET = "dataset"diff --git a/examples/toolkits/skill_toolkit.py b/examples/toolkits/skill_toolkit.pyindex f10dc3c20..2bacd1dca 100644--- a/examples/toolkits/skill_toolkit.py+++ b/examples/toolkits/skill_toolkit.py@@ -41,6 +41,6 @@ print(f"\nTools available: {[t.func.__name__ for t in tools]}")# Load a specific skill (if available)if skills:skill_name = skills[0]["name"]- content = skill_toolkit.get_skill(skill_name)+ content = skill_toolkit.load_skill(skill_name)print(f"\nLoaded skill '{skill_name}':")print(content[:200] + "...")diff --git a/test/toolkits/test_skill_toolkit.py b/test/toolkits/test_skill_toolkit.pyindex 54f83ea1f..d0fd9fc1a 100644--- a/test/toolkits/test_skill_toolkit.py+++ b/test/toolkits/test_skill_toolkit.py@@ -80,24 +80,24 @@ def test_list_skills(skill_toolkit):assert "another-skill" in names-def test_get_skill(skill_toolkit):- r"""Test getting a skill by name."""- skill_content = skill_toolkit.get_skill("test-skill")+def test_load_skill(skill_toolkit):+ r"""Test loading a skill by name."""+ skill_content = skill_toolkit.load_skill("test-skill")assert "## Skill: test-skill" in skill_contentassert "**Base directory**:" in skill_contentassert "This is a test skill body content." in skill_content-def test_get_skill_not_found(skill_toolkit):- r"""Test getting a non-existent skill returns error message."""- result = skill_toolkit.get_skill("non-existent-skill")+def test_load_skill_not_found(skill_toolkit):+ r"""Test loading a non-existent skill returns error message."""+ result = skill_toolkit.load_skill("non-existent-skill")assert "Error:" in resultassert "not found" in result-def test_get_multiple_skills(skill_toolkit):- r"""Test getting multiple skills at once."""- result = skill_toolkit.get_skill(["test-skill", "another-skill"])+def test_load_multiple_skills(skill_toolkit):+ r"""Test loading multiple skills at once."""+ result = skill_toolkit.load_skill(["test-skill", "another-skill"])assert "## Skill: test-skill" in resultassert "## Skill: another-skill" in resultassert "This is a test skill body content." in result@@ -112,7 +112,7 @@ def test_get_tools(skill_toolkit):assert len(tools) == 2tool_names = [t.func.__name__ for t in tools]assert "list_skills" in tool_names- assert "get_skill" in tool_names+ assert "load_skill" in tool_namesdef test_caching(skill_toolkit):