llms-py 3.0.14__py3-none-any.whl → 3.0.16__py3-none-any.whl

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:

llms/extensions/tools/ui/index.mjs

@@ -21,7 +21,7 @@ const ToolResult = {
         <div class="not-prose py-2">
             <pre v-if="ext.prefs.toolFormat !== 'preview'" class="tool-output">{{ origResult }}</pre>
             <div v-else>
-                <ViewTypes v-if="Array.isArray(result)" :results="result" />
+                <ViewTypes v-if="Array.isArray(result) && result[0]?.type" :results="result" />
                 <ViewType v-else :result="result" />
             </div>
         </div>
@@ -76,10 +76,92 @@ const ToolResult = {
     }
 }
 
-const Tools = {
-    components: {
-        ToolResult
+const JsonInput = {
+    template: `
+    <div class="flex flex-col gap-1">
+        <div class="relative">
+            <textarea 
+                v-model="localJson" 
+                @input="validate"
+                rows="5"
+                class="w-full p-2 font-mono text-xs border rounded-md resize-y focus:outline-none focus:ring-2 transition-colors"
+                :class="error 
+                    ? 'border-red-300 dark:border-red-700 bg-red-50 dark:bg-red-900/10 focus:ring-red-500' 
+                    : 'border-gray-300 dark:border-gray-600 dark:bg-gray-700 dark:text-gray-100 focus:ring-blue-500'"
+                spellcheck="false"
+            ></textarea>
+            <div v-if="isValid" class="absolute bottom-2 right-2 text-green-500 bg-white dark:bg-gray-800 rounded-full p-1 shadow-sm">
+                <svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+                    <path fill-rule="evenodd" d="M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z" clip-rule="evenodd" />
+                </svg>
+            </div>
+        </div>
+        <div v-if="error" class="text-xs text-red-600 dark:text-red-400 font-medium px-1">
+            {{ error }}
+        </div>
+    </div>
+    `,
+    props: {
+        modelValue: {
+            required: true
+        }
     },
+    emits: ['update:modelValue'],
+    setup(props, { emit }) {
+        // Initialize with formatted JSON
+        const localJson = ref(
+            props.modelValue !== undefined
+                ? JSON.stringify(props.modelValue, null, 4)
+                : ''
+        )
+        const error = ref(null)
+        const isValid = ref(true)
+
+        function validate() {
+            try {
+                if (!localJson.value.trim()) {
+                    // Decide if empty string is valid object/array or undefined
+                    // For now, let's say empty is NOT valid if the prop expects object
+                    // But maybe we can treat it as valid undefined/null?
+                    // Let's enforce valid JSON.
+                    if (localJson.value === '') {
+                        error.value = null
+                        isValid.value = true
+                        emit('update:modelValue', undefined)
+                        return
+                    }
+                }
+
+                const parsed = JSON.parse(localJson.value)
+                error.value = null
+                isValid.value = true
+                emit('update:modelValue', parsed)
+            } catch (e) {
+                error.value = e.message
+                isValid.value = false
+                // Do not emit invalid values
+            }
+        }
+
+        // Watch external changes only if they differ significantly from local
+        /* 
+           Note: two-way binding with text representation is tricky.
+           If we watch props.modelValue, we might re-format user's in-progress typing if we aren't careful.
+           Usually better to only update localJson if the prop changes "from outside".
+           For this simple tool, initial value is likely enough, or we can watch with a deep compare check.
+           For now, let's stick to initial + internal validation. 
+        */
+
+        return {
+            localJson,
+            error,
+            isValid,
+            validate
+        }
+    }
+}
+
+const Tools = {
     template: `
     <div class="p-4 md:p-6 max-w-7xl mx-auto w-full relative">
         <div v-if="Object.keys($ctx.tools.toolPageHeaders).length">
@@ -153,6 +235,10 @@ const Tools = {
                                 </select>
                             </div>
 
+                            <div v-else-if="prop.type === 'object' || prop.type === 'array'">
+                                <JsonInput v-model="execForm[name]" />
+                            </div>
+
                             <div v-else>
                                 <input :type="prop.type === 'integer' || prop.type === 'number' ? 'number' : 'text'" 
                                        v-model="execForm[name]" 
@@ -615,6 +701,8 @@ export default {
         ctx.components({
             Tools,
             ToolSelector,
+            ToolResult,
+            JsonInput,
         })
 
         ctx.setGlobals({
@@ -656,7 +744,7 @@ export default {
             }
         })
 
-        ctx.chatRequestFilters.push(({ request, thread }) => {
+        ctx.chatRequestFilters.push(({ request, thread, context }) => {
             // Tool Preferences
             const prefs = ctx.prefs
             if (prefs.onlyTools != null) {

llms/main.py

@@ -23,6 +23,7 @@ import shutil
 import site
 import subprocess
 import sys
+import tempfile
 import time
 import traceback
 from datetime import datetime
@@ -56,7 +57,7 @@ try:
 except ImportError:
     HAS_PIL = False
 
-VERSION = "3.0.14"
+VERSION = "3.0.16"
 _ROOT = None
 DEBUG = os.getenv("DEBUG") == "1"
 MOCK = os.getenv("MOCK") == "1"
@@ -379,6 +380,46 @@ def get_literal_values(typ):
     return None
 
 
+def _py_type_to_json_type(param_type):
+    param_type_name = "string"
+    enum_values = None
+    items = None
+
+    # Check for Enum
+    if inspect.isclass(param_type) and issubclass(param_type, Enum):
+        enum_values = [e.value for e in param_type]
+    elif get_origin(param_type) is list or get_origin(param_type) is list:
+        param_type_name = "array"
+        args = get_args(param_type)
+        if args:
+            items_type, _, _ = _py_type_to_json_type(args[0])
+            items = {"type": items_type}
+    elif get_origin(param_type) is dict:
+        param_type_name = "object"
+    else:
+        # Check for Literal / Union[Literal]
+        enum_values = get_literal_values(param_type)
+
+    if enum_values:
+        # Infer type from the first value
+        value_type = type(enum_values[0])
+        if value_type is int:
+            param_type_name = "integer"
+        elif value_type is float:
+            param_type_name = "number"
+        elif value_type is bool:
+            param_type_name = "boolean"
+
+    elif param_type is int:
+        param_type_name = "integer"
+    elif param_type is float:
+        param_type_name = "number"
+    elif param_type is bool:
+        param_type_name = "boolean"
+
+    return param_type_name, enum_values, items
+
+
 def function_to_tool_definition(func):
     type_hints = get_type_hints(func, include_extras=True)
     signature = inspect.signature(func)
@@ -386,8 +427,6 @@ def function_to_tool_definition(func):
 
     for name, param in signature.parameters.items():
         param_type = type_hints.get(name, str)
-        param_type_name = "string"
-        enum_values = None
         description = None
 
         # Check for Annotated (for description)
@@ -399,35 +438,24 @@ def function_to_tool_definition(func):
                     description = arg
                     break
 
-        # Check for Enum
-        if inspect.isclass(param_type) and issubclass(param_type, Enum):
-            enum_values = [e.value for e in param_type]
-        else:
-            # Check for Literal / Union[Literal]
-            enum_values = get_literal_values(param_type)
+        # Unwrap Optional / Union[T, None]
+        origin = get_origin(param_type)
+        if origin is Union:
+            args = get_args(param_type)
+            # Filter out NoneType
+            non_none_args = [arg for arg in args if arg is not type(None)]
+            if len(non_none_args) == 1:
+                param_type = non_none_args[0]
 
-        if enum_values:
-            # Infer type from the first value
-            value_type = type(enum_values[0])
-            if value_type is int:
-                param_type_name = "integer"
-            elif value_type is float:
-                param_type_name = "number"
-            elif value_type is bool:
-                param_type_name = "boolean"
-
-        elif param_type is int:
-            param_type_name = "integer"
-        elif param_type is float:
-            param_type_name = "number"
-        elif param_type is bool:
-            param_type_name = "boolean"
+        param_type_name, enum_values, items = _py_type_to_json_type(param_type)
 
         prop = {"type": param_type_name}
         if description:
             prop["description"] = description
         if enum_values:
             prop["enum"] = enum_values
+        if items:
+            prop["items"] = items
         parameters["properties"][name] = prop
 
         if param.default == inspect.Parameter.empty:
@@ -857,7 +885,7 @@ def chat_to_prompt(chat):
     prompt = ""
     if "messages" in chat:
         for message in chat["messages"]:
-            if message["role"] == "user":
+            if message.get("role") == "user":
                 # if content is string
                 if isinstance(message["content"], str):
                     if prompt:
@@ -876,7 +904,7 @@ def chat_to_prompt(chat):
 def chat_to_system_prompt(chat):
     if "messages" in chat:
         for message in chat["messages"]:
-            if message["role"] == "system":
+            if message.get("role") == "system":
                 # if content is string
                 if isinstance(message["content"], str):
                     return message["content"]
@@ -904,7 +932,7 @@ def last_user_prompt(chat):
     prompt = ""
     if "messages" in chat:
         for message in chat["messages"]:
-            if message["role"] == "user":
+            if message.get("role") == "user":
                 # if content is string
                 if isinstance(message["content"], str):
                     prompt = message["content"]
@@ -1600,9 +1628,118 @@ def g_tool_result(result, function_name: Optional[str] = None, function_args: Op
     return text, resources
 
 
+def convert_tool_args(function_name, function_args):
+    """
+    Convert tool arg values to their specified types.
+    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,
+        },
+    ]
+    """
+    tool_def = g_app.get_tool_definition(function_name)
+    if not tool_def:
+        return function_args
+
+    if "function" in tool_def and "parameters" in tool_def["function"]:
+        parameters = tool_def.get("function", {}).get("parameters")
+        properties = parameters.get("properties", {})
+        required = parameters.get("required", [])
+        new_args = function_args.copy()
+
+        for key, value in function_args.items():
+            if key in properties and isinstance(value, str):
+                prop_type = properties[key].get("type")
+                str_val = value.strip()
+
+                if str_val == "":
+                    if prop_type in ("integer", "number"):
+                        new_args[key] = None
+                    else:
+                        new_args.pop(key)
+                    continue
+
+                if prop_type == "integer":
+                    with contextlib.suppress(ValueError, TypeError):
+                        new_args[key] = int(str_val)
+
+                elif prop_type == "number":
+                    with contextlib.suppress(ValueError, TypeError):
+                        new_args[key] = float(str_val)
+
+                elif prop_type == "boolean":
+                    lower_val = str_val.lower()
+                    if lower_val in ("true", "1", "yes"):
+                        new_args[key] = True
+                    elif lower_val in ("false", "0", "no"):
+                        new_args[key] = False
+
+                elif prop_type == "object":
+                    if str_val == "":
+                        new_args[key] = None
+                    else:
+                        with contextlib.suppress(json.JSONDecodeError, TypeError):
+                            new_args[key] = json.loads(str_val)
+
+                elif prop_type == "array":
+                    if str_val == "":
+                        new_args[key] = []
+                    else:
+                        # Simple CSV split for arrays; could be more robust with JSON parsing if wrapped in brackets
+                        # Check if it looks like a JSON array
+                        if str_val.startswith("[") and str_val.endswith("]"):
+                            with contextlib.suppress(json.JSONDecodeError):
+                                items = json.loads(str_val)
+                        else:
+                            items = [s.strip() for s in str_val.split(",")]
+                        item_type = properties[key].get("items", {}).get("type")
+                        if item_type == "integer":
+                            items = [int(i) for i in items]
+                        elif item_type == "number":
+                            items = [float(i) for i in items]
+                        new_args[key] = items
+
+        # Validate required parameters
+        missing = [key for key in required if key not in new_args]
+        if missing:
+            raise ValueError(f"Missing required arguments: {', '.join(missing)}")
+
+        return new_args
+
+    return function_args
+
+
 async def g_exec_tool(function_name, function_args):
+    _log(f"g_exec_tool: {function_name}")
     if function_name in g_app.tools:
         try:
+            # Type conversion based on tool definition
+            function_args = convert_tool_args(function_name, function_args)
+
             func = g_app.tools[function_name]
             is_async = inspect.iscoroutinefunction(func)
             _dbg(f"Executing {'async' if is_async else 'sync'} tool '{function_name}' with args: {function_args}")
@@ -1611,7 +1748,7 @@ async def g_exec_tool(function_name, function_args):
             else:
                 return g_tool_result(func(**function_args), function_name, function_args)
         except Exception as e:
-            return f"Error executing tool '{function_name}': {to_error_message(e)}", None
+            return f"Error executing tool '{function_name}':\n{to_error_message(e)}", None
     return f"Error: Tool '{function_name}' not found", None
 
 
@@ -1807,7 +1944,10 @@ async def g_chat_completion(chat, context=None):
     # If we get here, all providers failed
     if first_exception:
         raise first_exception
-    raise Exception("All providers failed")
+
+    e = Exception("All providers failed")
+    await g_app.on_chat_error(e, context or {"chat": chat})
+    raise e
 
 
 async def cli_chat(chat, tools=None, image=None, audio=None, file=None, args=None, raw=False):
@@ -2654,6 +2794,7 @@ class AppExtensions:
         self.tool_groups = {}
         self.index_headers = []
         self.index_footers = []
+        self.allowed_directories = []
         self.request_args = {
             "image_config": dict,  # e.g. { "aspect_ratio": "1:1" }
             "temperature": float,  # e.g: 0.7
@@ -2710,6 +2851,22 @@ class AppExtensions:
         self.config = config
         self.auth_enabled = self.config.get("auth", {}).get("enabled", False)
 
+    def set_allowed_directories(
+        self, directories: List[Annotated[str, "List of absolute paths that are allowed to be accessed."]]
+    ) -> None:
+        """Set the list of allowed directories."""
+        self.allowed_directories = [os.path.abspath(d) for d in directories]
+
+    def add_allowed_directory(self, path: str) -> None:
+        """Add an allowed directory."""
+        abs_path = os.path.abspath(path)
+        if abs_path not in self.allowed_directories:
+            self.allowed_directories.append(abs_path)
+
+    def get_allowed_directories(self) -> List[str]:
+        """Get the list of allowed directories."""
+        return self.allowed_directories
+
     # Authentication middleware helper
     def check_auth(self, request: web.Request) -> Tuple[bool, Optional[Dict[str, Any]]]:
         """Check if request is authenticated. Returns (is_authenticated, user_data)"""
@@ -2777,7 +2934,9 @@ class AppExtensions:
             context["stackTrace"] = traceback.format_exc()
         for filter_func in self.chat_error_filters:
             try:
-                await filter_func(e, context)
+                task = filter_func(e, context)
+                if asyncio.isfuture(task):
+                    await task
             except Exception as e:
                 _err("chat error filter failed", e)
 
@@ -2822,6 +2981,12 @@ class AppExtensions:
                         current_chat["tools"].append(tool_def)
         return current_chat
 
+    def get_tool_definition(self, name: str) -> Optional[Dict[str, Any]]:
+        for tool_def in self.tool_definitions:
+            if tool_def["function"]["name"] == name:
+                return tool_def
+        return None
+
 
 def handler_name(handler):
     if hasattr(handler, "__name__"):
@@ -2848,6 +3013,20 @@ class ExtensionContext:
         self.request_args = app.request_args
         self.disabled = False
 
+    def set_allowed_directories(
+        self, directories: List[Annotated[str, "List of absolute paths that are allowed to be accessed."]]
+    ) -> None:
+        """Set the list of allowed directories."""
+        self.app.set_allowed_directories(directories)
+
+    def add_allowed_directory(self, path: str) -> None:
+        """Add an allowed directory."""
+        self.app.add_allowed_directory(path)
+
+    def get_allowed_directories(self) -> List[str]:
+        """Get the list of allowed directories."""
+        return self.app.get_allowed_directories()
+
     def chat_to_prompt(self, chat: Dict[str, Any]) -> str:
         return chat_to_prompt(chat)
 
@@ -3094,10 +3273,7 @@ class ExtensionContext:
         self.app.tool_groups[group].append(name)
 
     def get_tool_definition(self, name: str) -> Optional[Dict[str, Any]]:
-        for tool_def in self.app.tool_definitions:
-            if tool_def["function"]["name"] == name:
-                return tool_def
-        return None
+        return self.app.get_tool_definition(name)
 
     def group_resources(self, resources: List[Dict[str, Any]]) -> Dict[str, List[Dict[str, Any]]]:
         return group_resources(resources)
@@ -3681,6 +3857,10 @@ def cli_exec(cli_args, extra_args):
         asyncio.run(update_extensions(cli_args.update))
         return ExitCode.SUCCESS
 
+    g_app.add_allowed_directory(home_llms_path(".agent"))  # info for agents, e.g: skills
+    g_app.add_allowed_directory(os.getcwd())  # add current directory
+    g_app.add_allowed_directory(tempfile.gettempdir())  # add temp directory
+
     g_app.extensions = install_extensions()
 
     # Use a persistent event loop to ensure async connections (like MCP)

llms/ui/ai.mjs

@@ -6,7 +6,7 @@ const headers = { 'Accept': 'application/json' }
 const prefsKey = 'llms.prefs'
 
 export const o = {
-    version: '3.0.14',
+    version: '3.0.16',
     base,
     prefsKey,
     welcome: 'Welcome to llms.py',