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

llms/extensions/core_tools/__init__.py

@@ -102,24 +102,6 @@ def write_file(path: str, content: str) -> bool:
     return True
 
 
-def edit_file(path: str, old_str: str, new_str: str) -> Dict[str, Any]:
-    """
-    Replaces first occurrence of old_str with new_str in file. If old_str is empty,
-    create/overwrite file with new_str.
-    :return: A dictionary with the path to the file and the action taken.
-    """
-    safe_path = _resolve_safe_path(path)
-    if old_str == "":
-        safe_path.write_text(new_str, encoding="utf-8")
-        return {"path": str(safe_path), "action": "created_file"}
-    original = safe_path.read_text(encoding="utf-8")
-    if original.find(old_str) == -1:
-        return {"path": str(safe_path), "action": "old_str not found"}
-    edited = original.replace(old_str, new_str, 1)
-    safe_path.write_text(edited, encoding="utf-8")
-    return {"path": str(safe_path), "action": "edited"}
-
-
 def list_directory(path: str) -> str:
     """List directory contents"""
     safe_path = _resolve_safe_path(path)
@@ -545,26 +527,6 @@ def install(ctx):
     # ctx.register_tool(semantic_search) # TODO: implement
     ctx.register_tool(read_file, group=group)
     ctx.register_tool(write_file, group=group)
-    ctx.register_tool(
-        edit_file,
-        {
-            "type": "function",
-            "function": {
-                "name": "edit_file",
-                "description": "Replaces first occurrence of old_str with new_str in file. If old_str is empty, create/overwrite file with new_str.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "path": {"type": "string", "description": "Path to the file to edit."},
-                        "old_str": {"type": "string", "description": "String to replace."},
-                        "new_str": {"type": "string", "description": "String to replace with."},
-                    },
-                    "required": ["path", "old_str", "new_str"],
-                },
-            },
-        },
-        group=group,
-    )
     ctx.register_tool(list_directory, group=group)
     ctx.register_tool(glob_paths, group=group)
     ctx.register_tool(calc, group=group)

llms/extensions/providers/google.py

@@ -1,3 +1,4 @@
+import asyncio
 import base64
 import io
 import json
@@ -360,36 +361,62 @@ def install_google(ctx):
                 ctx.log(gemini_chat_summary(gemini_chat))
                 started_at = time.time()
 
-                if ctx.MOCK and "modalities" in chat:
-                    print("Mocking Google Gemini Image")
-                    with open(f"{ctx.MOCK_DIR}/gemini-image.json") as f:
-                        obj = json.load(f)
-                else:
-                    try:
-                        async with session.post(
-                            gemini_chat_url,
-                            headers=self.headers,
-                            data=json.dumps(gemini_chat),
-                            timeout=aiohttp.ClientTimeout(total=120),
-                        ) as res:
-                            obj = await self.response_json(res)
-                            if context is not None:
-                                context["providerResponse"] = obj
-                    except Exception as e:
-                        ctx.log(f"Error: {res.status} {res.reason}: {e}")
-                        text = await res.text()
+                max_retries = 3
+                for attempt in range(max_retries):
+                    if ctx.MOCK and "modalities" in chat:
+                        print("Mocking Google Gemini Image")
+                        with open(f"{ctx.MOCK_DIR}/gemini-image.json") as f:
+                            obj = json.load(f)
+                    else:
+                        res = None
                         try:
-                            obj = json.loads(text)
-                        except:
-                            ctx.log(text)
-                            raise e
-
-                if "error" in obj:
-                    ctx.log(f"Error: {obj['error']}")
-                    raise Exception(obj["error"]["message"])
-
-                if ctx.debug:
-                    ctx.dbg(json.dumps(gemini_response_summary(obj), indent=2))
+                            if attempt > 0:
+                                await asyncio.sleep(attempt * 0.5)
+                                ctx.log(f"Retrying request (attempt {attempt + 1}/{max_retries})...")
+
+                            async with session.post(
+                                gemini_chat_url,
+                                headers=self.headers,
+                                data=json.dumps(gemini_chat),
+                                timeout=aiohttp.ClientTimeout(total=120),
+                            ) as res:
+                                obj = await self.response_json(res)
+                                if context is not None:
+                                    context["providerResponse"] = obj
+                        except Exception as e:
+                            if res:
+                                ctx.err(f"{res.status} {res.reason}", e)
+                                try:
+                                    text = await res.text()
+                                    obj = json.loads(text)
+                                except Exception as parseEx:
+                                    ctx.err("Failed to parse error response:\n" + text, parseEx)
+                                    raise e from None
+                            else:
+                                ctx.err(f"Request failed: {str(e)}")
+                                raise e from None
+
+                    if "error" in obj:
+                        ctx.log(f"Error: {obj['error']}")
+                        raise Exception(obj["error"]["message"])
+
+                    if ctx.debug:
+                        ctx.dbg(json.dumps(gemini_response_summary(obj), indent=2))
+
+                    # Check for empty response "anomaly"
+                    has_candidates = obj.get("candidates") and len(obj["candidates"]) > 0
+                    if has_candidates:
+                        candidate = obj["candidates"][0]
+                        raw_content = candidate.get("content", {})
+                        raw_parts = raw_content.get("parts", [])
+
+                        if not raw_parts and attempt < max_retries - 1:
+                            # It's an empty response candidates list
+                            ctx.dbg("Empty candidates parts detected. Retrying...")
+                            continue
+
+                    # If we got here, it's either a good response or we ran out of retries
+                    break
 
                 # calculate cost per generation
                 cost = None
@@ -504,7 +531,7 @@ def install_google(ctx):
                         "finish_reason": candidate.get("finishReason", "stop"),
                         "message": {
                             "role": role,
-                            "content": content if content else None,
+                            "content": content if content else "",
                         },
                     }
                     if reasoning:

llms/extensions/skills/ui/index.mjs

@@ -1,4 +1,5 @@
 import { ref, inject, computed } from "vue"
+import { leftPart } from "@servicestack/client"
 
 let ext
 
@@ -319,6 +320,32 @@ export default {
             context.requiredSystemPrompts.push(skillsPrompt)
         })
 
+        ctx.setThreadFooters({
+            skills: {
+                component: {
+                    template: `
+                        <div class="mt-2 w-full flex justify-center">
+                            <button type="button" @click="$ctx.chat.sendUserMessage('proceed')"
+                                class="px-3 py-1 rounded-md text-xs font-medium border border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800 text-gray-700 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-gray-700 transition-colors select-none">
+                                proceed
+                            </button>
+                        </div>
+                    `
+                },
+                show({ thread }) {
+                    if (thread.messages.length < 2) return false
+                    const msgRoles = thread.messages.map(m => m.role)
+                    if (msgRoles[msgRoles.length - 1] != "assistant") return false
+                    const hasSkillToolCall = thread.messages.some(m =>
+                        m.tool_calls?.some(tc => tc.type == "function" && tc.function.name == "skill"))
+                    const systemPrompt = thread.messages.find(m => m.role == "system")?.content.toLowerCase() || ''
+                    const line1 = leftPart(systemPrompt.trim(), "\n")
+                    const hasPlanSystemPrompt = line1.includes("plan") || systemPrompt.includes("# plan")
+                    return hasSkillToolCall || hasPlanSystemPrompt
+                }
+            }
+        })
+
         ctx.setState({
             skills: {}
         })

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({