llms-py 3.0.10__py3-none-any.whl → 3.0.18__py3-none-any.whl

llms/extensions/skills/validator.py

@@ -0,0 +1,177 @@
+"""Skill validation logic."""
+
+import unicodedata
+from pathlib import Path
+from typing import Optional
+
+from .errors import ParseError
+from .parser import find_skill_md, parse_frontmatter
+
+MAX_SKILL_NAME_LENGTH = 64
+MAX_DESCRIPTION_LENGTH = 1024
+MAX_COMPATIBILITY_LENGTH = 500
+
+# Allowed frontmatter fields per Agent Skills Spec
+ALLOWED_FIELDS = {
+    "name",
+    "description",
+    "license",
+    "allowed-tools",
+    "metadata",
+    "compatibility",
+}
+
+
+def _validate_name(name: str, skill_dir: Path) -> list[str]:
+    """Validate skill name format and directory match.
+
+    Skill names support i18n characters (Unicode letters) plus hyphens.
+    Names must be lowercase and cannot start/end with hyphens.
+    """
+    errors = []
+
+    if not name or not isinstance(name, str) or not name.strip():
+        errors.append("Field 'name' must be a non-empty string")
+        return errors
+
+    name = unicodedata.normalize("NFKC", name.strip())
+
+    if len(name) > MAX_SKILL_NAME_LENGTH:
+        errors.append(
+            f"Skill name '{name}' exceeds {MAX_SKILL_NAME_LENGTH} character limit "
+            f"({len(name)} chars)"
+        )
+
+    if name != name.lower():
+        errors.append(f"Skill name '{name}' must be lowercase")
+
+    if name.startswith("-") or name.endswith("-"):
+        errors.append("Skill name cannot start or end with a hyphen")
+
+    if "--" in name:
+        errors.append("Skill name cannot contain consecutive hyphens")
+
+    if not all(c.isalnum() or c == "-" for c in name):
+        errors.append(
+            f"Skill name '{name}' contains invalid characters. "
+            "Only letters, digits, and hyphens are allowed."
+        )
+
+    if skill_dir:
+        dir_name = unicodedata.normalize("NFKC", skill_dir.name)
+        if dir_name != name:
+            errors.append(
+                f"Directory name '{skill_dir.name}' must match skill name '{name}'"
+            )
+
+    return errors
+
+
+def _validate_description(description: str) -> list[str]:
+    """Validate description format."""
+    errors = []
+
+    if not description or not isinstance(description, str) or not description.strip():
+        errors.append("Field 'description' must be a non-empty string")
+        return errors
+
+    if len(description) > MAX_DESCRIPTION_LENGTH:
+        errors.append(
+            f"Description exceeds {MAX_DESCRIPTION_LENGTH} character limit "
+            f"({len(description)} chars)"
+        )
+
+    return errors
+
+
+def _validate_compatibility(compatibility: str) -> list[str]:
+    """Validate compatibility format."""
+    errors = []
+
+    if not isinstance(compatibility, str):
+        errors.append("Field 'compatibility' must be a string")
+        return errors
+
+    if len(compatibility) > MAX_COMPATIBILITY_LENGTH:
+        errors.append(
+            f"Compatibility exceeds {MAX_COMPATIBILITY_LENGTH} character limit "
+            f"({len(compatibility)} chars)"
+        )
+
+    return errors
+
+
+def _validate_metadata_fields(metadata: dict) -> list[str]:
+    """Validate that only allowed fields are present."""
+    errors = []
+
+    extra_fields = set(metadata.keys()) - ALLOWED_FIELDS
+    if extra_fields:
+        errors.append(
+            f"Unexpected fields in frontmatter: {', '.join(sorted(extra_fields))}. "
+            f"Only {sorted(ALLOWED_FIELDS)} are allowed."
+        )
+
+    return errors
+
+
+def validate_metadata(metadata: dict, skill_dir: Optional[Path] = None) -> list[str]:
+    """Validate parsed skill metadata.
+
+    This is the core validation function that works on already-parsed metadata,
+    avoiding duplicate file I/O when called from the parser.
+
+    Args:
+        metadata: Parsed YAML frontmatter dictionary
+        skill_dir: Optional path to skill directory (for name-directory match check)
+
+    Returns:
+        List of validation error messages. Empty list means valid.
+    """
+    errors = []
+    errors.extend(_validate_metadata_fields(metadata))
+
+    if "name" not in metadata:
+        errors.append("Missing required field in frontmatter: name")
+    else:
+        errors.extend(_validate_name(metadata["name"], skill_dir))
+
+    if "description" not in metadata:
+        errors.append("Missing required field in frontmatter: description")
+    else:
+        errors.extend(_validate_description(metadata["description"]))
+
+    if "compatibility" in metadata:
+        errors.extend(_validate_compatibility(metadata["compatibility"]))
+
+    return errors
+
+
+def validate(skill_dir: Path) -> list[str]:
+    """Validate a skill directory.
+
+    Args:
+        skill_dir: Path to the skill directory
+
+    Returns:
+        List of validation error messages. Empty list means valid.
+    """
+    skill_dir = Path(skill_dir)
+
+    if not skill_dir.exists():
+        return [f"Path does not exist: {skill_dir}"]
+
+    if not skill_dir.is_dir():
+        return [f"Not a directory: {skill_dir}"]
+
+    skill_md = find_skill_md(skill_dir)
+    if skill_md is None:
+        return ["Missing required file: SKILL.md"]
+
+    try:
+        content = skill_md.read_text()
+        metadata, _ = parse_frontmatter(content)
+    except ParseError as e:
+        return [str(e)]
+
+    return validate_metadata(metadata, skill_dir)

llms/extensions/system_prompts/ui/index.mjs

@@ -163,7 +163,7 @@ const SystemPromptEditor = {
                 </div>
             </div>
             <div v-if="hasMessages" class="w-full rounded-md border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100 px-3 py-2 text-sm">
-                {{$threads.currentThread.value?.systemPrompt || 'No System Prompt was used' }}
+                <TextViewer prefsName="systemPrompt" :text="$threads.getCurrentThreadSystemPrompt() || 'No System Prompt was used'" />
             </div>
             <div v-else>
                 <textarea
@@ -251,21 +251,17 @@ export default {
             }
         })
 
-        ctx.chatRequestFilters.push(({ request, thread }) => {
+        ctx.chatRequestFilters.push(({ request, thread, context }) => {
 
-            const hasSystemPrompt = request.messages.find(x => x.role === 'system')
+            const hasSystemPrompt = !!context.systemPrompt
+            console.log('system_prompts chatRequestFilters', hasSystemPrompt)
             if (hasSystemPrompt) {
                 console.log('Already has system prompt', hasSystemPrompt.content)
                 return
             }
 
-            // Only add the selected system prompt for new requests
-            if (ext.prefs.systemPrompt && request.messages.length <= 1) {
-                // add message to start
-                request.messages.unshift({
-                    role: 'system',
-                    content: ext.prefs.systemPrompt
-                })
+            if (ext.prefs.systemPrompt) {
+                context.systemPrompt = ext.prefs.systemPrompt
             }
         })
 

llms/extensions/tools/__init__.py

@@ -14,72 +14,6 @@ def install(ctx):
 
     ctx.add_get("", tools_handler)
 
-    def prop_def_types(prop_def):
-        prop_type = prop_def.get("type")
-        if not prop_type:
-            any_of = prop_def.get("anyOf")
-            if any_of:
-                return [item.get("type") for item in any_of]
-            else:
-                return []
-        return [prop_type]
-
-    def tool_prop_value(value, prop_def):
-        """
-        Convert a value to the specified type.
-        types: string, number, integer, boolean, object, array, null
-        example prop_def = [
-            {
-                "type": "string"
-            },
-            {
-                "default": "name",
-                "type": "string",
-                "enum": ["name", "size"]
-            },
-            {
-                "default": [],
-                "type": "array",
-                "items": {
-                    "type": "string"
-                }
-            },
-            {
-                "anyOf": [
-                    {
-                        "type": "string"
-                    },
-                    {
-                        "type": "null"
-                    }
-                ],
-                "default": null,
-            },
-        ]
-        """
-        if value is None:
-            default = prop_def.get("default")
-            if default is not None:
-                default = tool_prop_value(default, prop_def)
-            return default
-
-        prop_types = prop_def_types(prop_def)
-        if "integer" in prop_types:
-            return int(value)
-        elif "number" in prop_types:
-            return float(value)
-        elif "boolean" in prop_types:
-            return bool(value)
-        elif "object" in prop_types:
-            return value if isinstance(value, dict) else json.loads(value)
-        elif "array" in prop_types:
-            return value if isinstance(value, list) else value.split(",")
-        else:
-            enum = prop_def.get("enum")
-            if enum and value not in enum:
-                raise Exception(f"'{value}' is not in {enum}")
-            return value
-
     async def exec_handler(request):
         name = request.match_info.get("name")
         args = await request.json()
@@ -93,27 +27,16 @@ def install(ctx):
             raise Exception(f"Tool '{name}' of type '{type}' is not supported")
 
         ctx.dbg(f"Executing tool '{name}' with args:\n{json.dumps(args, indent=2)}")
+
+        # Filter args against tool properties
         function_args = {}
         parameters = tool_def.get("function", {}).get("parameters")
         if parameters:
             properties = parameters.get("properties")
-            required_props = parameters.get("required", [])
             if properties:
-                for prop_name, prop_def in properties.items():
-                    prop_title = prop_def.get("title", prop_name)
-                    prop_types = prop_def_types(prop_def)
-                    value = None
-                    if prop_name in args:
-                        value = tool_prop_value(args[prop_name], prop_def)
-                    elif prop_name in required_props:
-                        if "null" in prop_types:
-                            value = None
-                        elif "default" in prop_def:
-                            value = tool_prop_value(prop_def["default"], prop_def)
-                        else:
-                            raise Exception(f"Missing required parameter '{prop_title}' for tool '{name}'")
-                    if value is not None or "null" in prop_types:
-                        function_args[prop_name] = value
+                for key in args:
+                    if key in properties:
+                        function_args[key] = args[key]
             else:
                 ctx.dbg(f"tool '{name}' has no properties:\n{json.dumps(tool_def, indent=2)}")
         else: