lmcoding-local 3.2.0__tar.gz → 3.2.1__tar.gz

{lmcoding_local-3.2.0 → lmcoding_local-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lmcoding-local
-Version: 3.2.0
+Version: 3.2.1
 Summary: Agente de programación local para LM Studio con interfaz tipo Codex y seguridad por workspace
 Author: TV Ofertas Ecuador
 License-Expression: MIT
@@ -21,7 +21,7 @@ Requires-Dist: openai>=1.40.0
 Requires-Dist: rich>=13.7.0
 Dynamic: license-file
 
-# llmCodex 3.2.0
+# llmCodex 3.2.1
 
 Agente de programación local para **LM Studio**, con experiencia de terminal inspirada en agentes modernos tipo Codex, colores violeta propios y herramientas para inspeccionar, editar, verificar y reparar proyectos.
 
@@ -94,13 +94,13 @@ Y agrega al PATH:
 ## Instalar el wheel manualmente
 
 ```powershell
-py -m pip install dist\lmcoding_local-3.2.0-py3-none-any.whl
+py -m pip install dist\lmcoding_local-3.2.1-py3-none-any.whl
 ```
 
 Para aplicaciones CLI es recomendable usar `pipx`:
 
 ```powershell
-pipx install dist\lmcoding_local-3.2.0-py3-none-any.whl
+pipx install dist\lmcoding_local-3.2.1-py3-none-any.whl
 ```
 
 ## Preparar LM Studio
@@ -342,3 +342,8 @@ Y selecciona **Build → Compile**.
 ## Límites reales
 
 El sistema puede detectar, probar, corregir y revertir muchos errores, pero ningún agente puede garantizar reparar absolutamente cualquier bug. Puede necesitar credenciales, servicios externos, hardware, datos privados o una especificación más precisa. llmCodex evita declarar éxito cuando sus verificaciones siguen fallando y puede restaurar el checkpoint anterior.
+
+
+## Corrección 3.2.1
+
+Incluye un parser de compatibilidad para modelos que devuelven llamadas de herramientas como texto en lugar de `tool_calls` estructurados.

{lmcoding_local-3.2.0 → lmcoding_local-3.2.1}/README.md

@@ -1,4 +1,4 @@
-# llmCodex 3.2.0
+# llmCodex 3.2.1
 
 Agente de programación local para **LM Studio**, con experiencia de terminal inspirada en agentes modernos tipo Codex, colores violeta propios y herramientas para inspeccionar, editar, verificar y reparar proyectos.
 
@@ -71,13 +71,13 @@ Y agrega al PATH:
 ## Instalar el wheel manualmente
 
 ```powershell
-py -m pip install dist\lmcoding_local-3.2.0-py3-none-any.whl
+py -m pip install dist\lmcoding_local-3.2.1-py3-none-any.whl
 ```
 
 Para aplicaciones CLI es recomendable usar `pipx`:
 
 ```powershell
-pipx install dist\lmcoding_local-3.2.0-py3-none-any.whl
+pipx install dist\lmcoding_local-3.2.1-py3-none-any.whl
 ```
 
 ## Preparar LM Studio
@@ -319,3 +319,8 @@ Y selecciona **Build → Compile**.
 ## Límites reales
 
 El sistema puede detectar, probar, corregir y revertir muchos errores, pero ningún agente puede garantizar reparar absolutamente cualquier bug. Puede necesitar credenciales, servicios externos, hardware, datos privados o una especificación más precisa. llmCodex evita declarar éxito cuando sus verificaciones siguen fallando y puede restaurar el checkpoint anterior.
+
+
+## Corrección 3.2.1
+
+Incluye un parser de compatibilidad para modelos que devuelven llamadas de herramientas como texto en lugar de `tool_calls` estructurados.

{lmcoding_local-3.2.0 → lmcoding_local-3.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lmcoding-local"
-version = "3.2.0"
+version = "3.2.1"
 description = "Agente de programación local para LM Studio con interfaz tipo Codex y seguridad por workspace"
 readme = "README.md"
 requires-python = ">=3.10"

{lmcoding_local-3.2.0 → lmcoding_local-3.2.1}/src/lmcoding/__init__.py

@@ -1,3 +1,3 @@
 """llmCodex / LMCoding package."""
 
-__version__ = "3.2.0"
+__version__ = "3.2.1"

{lmcoding_local-3.2.0 → lmcoding_local-3.2.1}/src/lmcoding/agent.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import re
 import time
+import uuid
 from collections import Counter
 from typing import Any
 
@@ -29,6 +30,8 @@ Reglas obligatorias:
 8. No declares que está corregido mientras las verificaciones sigan fallando.
 9. Resume archivos modificados, pruebas ejecutadas y problemas pendientes.
 10. Responde en el idioma del usuario y no reveles razonamiento privado paso a paso.
+11. Solicita herramientas usando únicamente sus nombres exactos, sin prefijos como file_manager.
+12. Nunca muestres etiquetas internas como <|tool_call>, <tool_call> o [TOOL_REQUEST] al usuario.
 """
 
 
@@ -96,23 +99,189 @@ class LMCodingAgent:
         self.session.save()
 
     @staticmethod
-    def _repair_json(raw: str) -> dict[str, Any]:
-        text = raw.strip()
+    def _split_top_level(text: str, delimiter: str = ",") -> list[str]:
+        parts: list[str] = []
+        start = 0
+        depth = 0
+        quote: str | None = None
+        escaped = False
+        for index, char in enumerate(text):
+            if quote is not None:
+                if escaped:
+                    escaped = False
+                elif char == "\\":
+                    escaped = True
+                elif char == quote:
+                    quote = None
+                continue
+            if char in {"\"", "'"}:
+                quote = char
+            elif char in "[{(":
+                depth += 1
+            elif char in "]})":
+                depth = max(0, depth - 1)
+            elif char == delimiter and depth == 0:
+                parts.append(text[start:index].strip())
+                start = index + 1
+        tail = text[start:].strip()
+        if tail:
+            parts.append(tail)
+        return parts
+
+    @classmethod
+    def _parse_loose_value(cls, raw: str) -> Any:
+        value = raw.strip()
+        value = value.replace('<|"|>', '"').replace("<|'|>", "'")
+        if not value:
+            return ""
+        if value[0:1] in {"\"", "'"} and value[-1:] == value[0]:
+            # Preserve Windows paths such as C:\\Users\\name instead of treating
+            # backslashes as JSON escape sequences.
+            inner = value[1:-1]
+            return inner.replace(r'\"', '"').replace(r"\'", "'")
+        if value.startswith("{") and value.endswith("}"):
+            result: dict[str, Any] = {}
+            body = value[1:-1].strip()
+            if not body:
+                return result
+            for item in cls._split_top_level(body):
+                key_value = cls._split_key_value(item)
+                if key_value is None:
+                    continue
+                key, item_value = key_value
+                result[key] = cls._parse_loose_value(item_value)
+            return result
+        if value.startswith("[") and value.endswith("]"):
+            body = value[1:-1].strip()
+            return [] if not body else [cls._parse_loose_value(item) for item in cls._split_top_level(body)]
+        lowered = value.lower()
+        if lowered == "true":
+            return True
+        if lowered == "false":
+            return False
+        if lowered in {"null", "none"}:
+            return None
+        try:
+            return int(value)
+        except ValueError:
+            try:
+                return float(value)
+            except ValueError:
+                return value
+
+    @staticmethod
+    def _split_key_value(item: str) -> tuple[str, str] | None:
+        depth = 0
+        quote: str | None = None
+        escaped = False
+        for index, char in enumerate(item):
+            if quote is not None:
+                if escaped:
+                    escaped = False
+                elif char == "\\":
+                    escaped = True
+                elif char == quote:
+                    quote = None
+                continue
+            if char in {"\"", "'"}:
+                quote = char
+            elif char in "[{(":
+                depth += 1
+            elif char in "]})":
+                depth = max(0, depth - 1)
+            elif char == ":" and depth == 0:
+                key = item[:index].strip().strip("\"'")
+                return key, item[index + 1:].strip()
+        return None
+
+    @classmethod
+    def _repair_json(cls, raw: str) -> dict[str, Any]:
+        text = (raw or "{}").strip()
+        text = text.replace('<|"|>', '"').replace("<|'|>", "'")
         try:
             value = json.loads(text or "{}")
             return value if isinstance(value, dict) else {}
-        except json.JSONDecodeError:
+        except (json.JSONDecodeError, TypeError):
             pass
         match = re.search(r"\{.*\}", text, re.DOTALL)
-        if match:
-            candidate = match.group(0)
-            candidate = re.sub(r",\s*([}\]])", r"\1", candidate)
-            try:
-                value = json.loads(candidate)
-                return value if isinstance(value, dict) else {}
-            except json.JSONDecodeError:
-                return {}
-        return {}
+        if not match:
+            return {}
+        candidate = match.group(0)
+        value = cls._parse_loose_value(candidate)
+        return value if isinstance(value, dict) else {}
+
+    def _canonical_tool_name(self, raw_name: str) -> str:
+        name = raw_name.strip().removeprefix("call:")
+        aliases = {
+            "file_manager.apply_patch": "apply_edits",
+            "apply_patch": "apply_edits",
+            "patch_file": "apply_edits",
+            "terminal.exec": "run_command",
+            "terminal.run": "run_command",
+            "shell.exec": "run_command",
+            "shell.run": "run_command",
+        }
+        if name in aliases:
+            return aliases[name]
+        if name in self.toolbox.functions:
+            return name
+        tail = re.split(r"[.:/]", name)[-1]
+        return aliases.get(tail, tail)
+
+    def _parse_tool_block(self, block: str, call_id: str) -> dict[str, Any] | None:
+        cleaned = block.strip()
+        cleaned = cleaned.replace('<|"|>', '"').replace("<|'|>", "'")
+
+        # Format emitted by some local models:
+        # call:file_manager.list_files{path:"C:\\project"}
+        direct = re.match(r"(?:call:)?(?P<name>[A-Za-z_][\w.:-]*)\s*(?P<args>\{.*\})\s*$", cleaned, re.DOTALL)
+        if direct:
+            name = self._canonical_tool_name(direct.group("name"))
+            arguments = self._repair_json(direct.group("args"))
+            return {"id": call_id, "name": name, "arguments": arguments}
+
+        payload = self._repair_json(cleaned)
+        if not payload:
+            return None
+        function_payload = payload.get("function") if isinstance(payload.get("function"), dict) else {}
+        raw_name = payload.get("name") or function_payload.get("name")
+        if not isinstance(raw_name, str):
+            return None
+        raw_arguments = payload.get("arguments", function_payload.get("arguments", {}))
+        if isinstance(raw_arguments, str):
+            arguments = self._repair_json(raw_arguments)
+        elif isinstance(raw_arguments, dict):
+            arguments = raw_arguments
+        else:
+            arguments = {}
+        return {
+            "id": call_id,
+            "name": self._canonical_tool_name(raw_name),
+            "arguments": arguments,
+        }
+
+    def _extract_text_tool_calls(self, content: str, step: int) -> tuple[list[dict[str, Any]], str]:
+        if not content:
+            return [], content
+        patterns = [
+            re.compile(r"<\|tool_call>(.*?)<tool_call\|>", re.DOTALL | re.IGNORECASE),
+            re.compile(r"<tool_call>(.*?)</tool_call>", re.DOTALL | re.IGNORECASE),
+            re.compile(r"\[TOOL_REQUEST\](.*?)\[END_TOOL_REQUEST\]", re.DOTALL | re.IGNORECASE),
+        ]
+        calls: list[dict[str, Any]] = []
+        visible = content
+        for pattern in patterns:
+            matches = list(pattern.finditer(visible))
+            for match in matches:
+                call = self._parse_tool_block(
+                    match.group(1),
+                    f"fallback_{step}_{len(calls) + 1}_{uuid.uuid4().hex[:8]}",
+                )
+                if call is not None:
+                    calls.append(call)
+            if matches:
+                visible = pattern.sub("", visible)
+        return calls, visible.strip()
 
     def _completion(self):
         last_error: Exception | None = None
@@ -153,40 +322,62 @@ class LMCodingAgent:
             with console.status(f"[brand]llmCodex trabajando · paso {step}[/brand]", spinner="dots"):
                 response = self._completion()
             message = response.choices[0].message
-            tool_calls = message.tool_calls or []
-            assistant_payload: dict[str, Any] = {"role": "assistant", "content": message.content or ""}
-            if tool_calls:
+            content = message.content or ""
+            normalized_calls: list[dict[str, Any]] = []
+
+            for call in message.tool_calls or []:
+                normalized_calls.append({
+                    "id": call.id or f"structured_{step}_{uuid.uuid4().hex[:8]}",
+                    "name": self._canonical_tool_name(call.function.name),
+                    "arguments": self._repair_json(call.function.arguments or "{}"),
+                })
+
+            # LM Studio documents that malformed calls can fall back into
+            # message.content. Recover common native/default formats here.
+            if not normalized_calls and content:
+                normalized_calls, content = self._extract_text_tool_calls(content, step)
+
+            assistant_payload: dict[str, Any] = {"role": "assistant", "content": content}
+            if normalized_calls:
                 assistant_payload["tool_calls"] = [
                     {
-                        "id": call.id,
+                        "id": call["id"],
                         "type": "function",
-                        "function": {"name": call.function.name, "arguments": call.function.arguments},
+                        "function": {
+                            "name": call["name"],
+                            "arguments": json.dumps(call["arguments"], ensure_ascii=False),
+                        },
                     }
-                    for call in tool_calls
+                    for call in normalized_calls
                 ]
             self.session.messages.append(assistant_payload)
 
-            if not tool_calls:
-                final_text = message.content or "(sin respuesta)"
+            if not normalized_calls:
+                final_text = content or "(sin respuesta)"
                 if render:
                     console.print(Panel(Markdown(final_text), title="[brand]llmCodex[/brand]", border_style="magenta"))
                 self.session.save()
                 return final_text
 
-            for call in tool_calls:
-                name = call.function.name
-                arguments = self._repair_json(call.function.arguments or "{}")
+            for call in normalized_calls:
+                name = call["name"]
+                arguments = call["arguments"]
                 signature = f"{name}:{json.dumps(arguments, sort_keys=True, ensure_ascii=False)}"
                 self.call_signatures[signature] += 1
                 if self.call_signatures[signature] >= 4:
                     result = "ERROR: bucle detectado; esta llamada idéntica ya se repitió varias veces. Cambia de estrategia."
+                elif name not in self.toolbox.functions:
+                    result = (
+                        f"ERROR: herramienta desconocida: {name}. "
+                        f"Herramientas válidas: {', '.join(sorted(self.toolbox.functions))}"
+                    )
                 else:
                     if render:
                         console.print(f"[accent]› {name}[/accent] [muted]{truncate(json.dumps(arguments, ensure_ascii=False), 700)}[/muted]")
                     result = self.toolbox.execute(name, arguments)
                     if render:
                         console.print(Panel(truncate(result, 3500), border_style="grey35", title="resultado"))
-                self.session.messages.append({"role": "tool", "tool_call_id": call.id, "content": result})
+                self.session.messages.append({"role": "tool", "tool_call_id": call["id"], "content": result})
 
         final_text = "Se alcanzó el máximo de pasos. Revisa el estado y pide continuar."
         self.session.save()

{lmcoding_local-3.2.0 → lmcoding_local-3.2.1}/src/lmcoding_local.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lmcoding-local
-Version: 3.2.0
+Version: 3.2.1
 Summary: Agente de programación local para LM Studio con interfaz tipo Codex y seguridad por workspace
 Author: TV Ofertas Ecuador
 License-Expression: MIT
@@ -21,7 +21,7 @@ Requires-Dist: openai>=1.40.0
 Requires-Dist: rich>=13.7.0
 Dynamic: license-file
 
-# llmCodex 3.2.0
+# llmCodex 3.2.1
 
 Agente de programación local para **LM Studio**, con experiencia de terminal inspirada en agentes modernos tipo Codex, colores violeta propios y herramientas para inspeccionar, editar, verificar y reparar proyectos.
 
@@ -94,13 +94,13 @@ Y agrega al PATH:
 ## Instalar el wheel manualmente
 
 ```powershell
-py -m pip install dist\lmcoding_local-3.2.0-py3-none-any.whl
+py -m pip install dist\lmcoding_local-3.2.1-py3-none-any.whl
 ```
 
 Para aplicaciones CLI es recomendable usar `pipx`:
 
 ```powershell
-pipx install dist\lmcoding_local-3.2.0-py3-none-any.whl
+pipx install dist\lmcoding_local-3.2.1-py3-none-any.whl
 ```
 
 ## Preparar LM Studio
@@ -342,3 +342,8 @@ Y selecciona **Build → Compile**.
 ## Límites reales
 
 El sistema puede detectar, probar, corregir y revertir muchos errores, pero ningún agente puede garantizar reparar absolutamente cualquier bug. Puede necesitar credenciales, servicios externos, hardware, datos privados o una especificación más precisa. llmCodex evita declarar éxito cuando sus verificaciones siguen fallando y puede restaurar el checkpoint anterior.
+
+
+## Corrección 3.2.1
+
+Incluye un parser de compatibilidad para modelos que devuelven llamadas de herramientas como texto en lugar de `tool_calls` estructurados.

{lmcoding_local-3.2.0 → lmcoding_local-3.2.1}/tests/test_core.py

@@ -4,6 +4,7 @@ import tempfile
 import unittest
 from pathlib import Path
 
+from lmcoding.agent import LMCodingAgent
 from lmcoding.checkpoints import CheckpointManager
 from lmcoding.permissions import ApprovalPolicy, PermissionMode, Risk, classify_command
 from lmcoding.tools import ToolBox
@@ -89,5 +90,33 @@ class VerifierTests(unittest.TestCase):
             self.assertTrue(verifier.verify("quick").ok)
 
 
+class ToolCallFallbackTests(unittest.TestCase):
+    def make_agent(self):
+        agent = object.__new__(LMCodingAgent)
+        agent.toolbox = type("FakeToolbox", (), {"functions": {"list_files": lambda: None, "run_command": lambda: None, "apply_edits": lambda: None}})()
+        return agent
+
+    def test_recovers_reported_lmstudio_format(self):
+        agent = self.make_agent()
+        content = r'<|tool_call>call:file_manager.list_files{path:<|"|>C:\Users\tyler\Downloads\GemAI<|"|>}<tool_call|>'
+        calls, visible = agent._extract_text_tool_calls(content, 1)
+        self.assertEqual(visible, "")
+        self.assertEqual(len(calls), 1)
+        self.assertEqual(calls[0]["name"], "list_files")
+        self.assertEqual(calls[0]["arguments"]["path"], r"C:\Users\tyler\Downloads\GemAI")
+
+    def test_recovers_lmstudio_default_tool_request(self):
+        agent = self.make_agent()
+        content = '[TOOL_REQUEST]{"name":"run_command","arguments":{"command":"python -m pytest"}}[END_TOOL_REQUEST]'
+        calls, visible = agent._extract_text_tool_calls(content, 2)
+        self.assertEqual(visible, "")
+        self.assertEqual(calls[0]["name"], "run_command")
+        self.assertEqual(calls[0]["arguments"]["command"], "python -m pytest")
+
+    def test_aliases_apply_patch(self):
+        agent = self.make_agent()
+        self.assertEqual(agent._canonical_tool_name("file_manager.apply_patch"), "apply_edits")
+
+
 if __name__ == "__main__":
     unittest.main()