localcode 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"

localcode/agent/context.py

@@ -412,7 +412,8 @@ def _redact_duplicate_reads(messages: list[dict]) -> list[dict]:
             if not tc_id:
                 continue
             try:
-                args = json.loads((tc.get("function") or {}).get("arguments") or "{}")
+                _raw = (tc.get("function") or {}).get("arguments") or "{}"
+                args = _raw if isinstance(_raw, dict) else json.loads(_raw)
             except Exception:
                 continue
             path = args.get("path")
@@ -629,7 +630,8 @@ def _compact_history_summary(messages: list[dict]) -> str:
             fn = tc.get("function") or {}
             name = str(fn.get("name") or "").strip()
             try:
-                args = json.loads(fn.get("arguments") or "{}")
+                _raw = fn.get("arguments") or "{}"
+                args = _raw if isinstance(_raw, dict) else json.loads(_raw)
             except Exception:
                 args = {}
             path = args.get("path") or args.get("file_path")
@@ -769,8 +771,13 @@ def _compact_messages(messages: list[dict], out: "OutputManager") -> list[dict]:
                 fn = tc.get("function", {})
                 name = fn.get("name", "")
                 try:
-                    args = json.loads(fn.get("arguments", "{}"))
-                except json.JSONDecodeError:
+                    # `arguments` may be a JSON string OR an already-decoded
+                    # dict (some providers/parsers do that) — json.loads on a
+                    # dict raises TypeError, which used to escape and kill the
+                    # turn with E3102 during compaction.
+                    _raw = fn.get("arguments", "{}")
+                    args = _raw if isinstance(_raw, dict) else json.loads(_raw)
+                except (json.JSONDecodeError, TypeError, ValueError):
                     args = {}
                 if name in ("write_file", "append_file", "edit_file"):
                     files_modified.add(args.get("path", "?"))

localcode/agent/loop.py

@@ -24,6 +24,7 @@ you hit them.
 from __future__ import annotations
 
 import json
+import os
 import re
 import sys
 import time
@@ -1328,8 +1329,12 @@ def run_agent_loop(
             fn = tc.get("function", {})
             tool_name = fn.get("name", "unknown")
             try:
-                args = json.loads(fn.get("arguments", "{}"))
-            except json.JSONDecodeError:
+                _raw_args = fn.get("arguments", "{}")
+                # `arguments` is normally a JSON string, but some providers/
+                # parsers hand back an already-decoded dict — json.loads on a
+                # dict raises TypeError, which used to escape and crash the loop.
+                args = _raw_args if isinstance(_raw_args, dict) else json.loads(_raw_args)
+            except (json.JSONDecodeError, TypeError, ValueError):
                 args = {}
                 out.print_info(f"Warning: malformed args for {tool_name}")
 
@@ -1337,6 +1342,16 @@ def run_agent_loop(
             stage = _tool_stage_label(tool_name, args)
             out.set_stage(stage)
             idx = out.log_tool(tool_name, _summarize_args(args))
+            # RL trace fidelity: the normal `tool_start` event carries only a
+            # summarized + 200-char-truncated arg preview. When capturing
+            # trajectories for fine-tuning we need the FULL arguments (e.g. the
+            # whole write_file body). Env-gated so normal TUI/headless runs are
+            # unaffected; dev/rl/collect sets LOCALCODE_TRACE_FULL_ARGS=1.
+            if os.environ.get("LOCALCODE_TRACE_FULL_ARGS"):
+                out._emit_event(
+                    "tool_call_full", index=str(idx),
+                    name=tool_name, arguments=args,
+                )
 
             # Safety: confirm destructive commands (honors current autonomy
             # level so /permissions toggles take effect immediately).

localcode/agent/prompts.py

@@ -57,7 +57,7 @@ How to work:
 - MATCH THE PROJECT'S LANGUAGE AND CONVENTIONS. Code MUST be valid for the file's actual language. Never write Python syntax (triple-quoted docstrings, snake_case, `import x`/`from x import y`) in a .ts/.tsx/.js/.jsx/.go/.rs or other non-Python file. Use that language's real comment, naming, and import/module syntax, and mirror the patterns already present in the project (imports, formatting, framework idioms).
 - For new projects, create a small multi-file structure by default. Keep entrypoints thin; move reusable logic, styles, data/config, templates, and assets into focused files. Use one large file only if requested.
 - Prefer edit_file for existing files. Use write_file when creating a new file or doing a deliberate full rewrite.
-- When a tool returns an error, read it, fix the specific problem, and retry. Don't give up after one failed call.
+- When a tool returns an error, read it, fix the specific problem, and retry with DIFFERENT input. Never repeat an identical failing call: if the same call fails or returns the same result twice, change the arguments or the approach, or move on — do not loop. Don't give up after one failed call, but don't spin on it either.
 - DON'T CONFABULATE. If the user names a person, song, place, term, library, command, or concept you do not recognize, your FIRST move is to say "I don't recognize that" — NOT to invent a plausible-sounding meaning by phonetic association. Phonetic fits ("Alombasi sounds Bantu so it must be a Zambian chant", "Pyfoo sounds like a Python library so it must do X") are exactly the failure mode. If a web search would help, run it BEFORE asserting facts; if results are empty, say so plainly. Never write paragraph-length cultural/etymological/technical descriptions of something you can't actually source — "I'd love to know more, what's it from?" is the correct answer. Doubling down when the user repeats the unknown term is also forbidden; repetition is not evidence.
 
 Runtime facts (true today; rely on these instead of guessing):

localcode/agent/tool_orchestration.py

@@ -31,7 +31,8 @@ def prefetch_parallel_tool_calls(
         fn = tc.get("function", {}) or {}
         name = (fn.get("name", "") or "").strip()
         try:
-            args = json.loads(fn.get("arguments", "{}"))
+            _raw = fn.get("arguments", "{}")
+            args = _raw if isinstance(_raw, dict) else json.loads(_raw)
         except Exception:
             continue
         if not is_concurrency_safe(name, args):

localcode/app.py

@@ -744,399 +744,6 @@ class LocalCodeApp:
         self._thinking_buffer = ""
         self._thinking_revealed = 0
 
-    def _run_tool_loop_streaming(self, composed_messages: list[dict], stream: bool = True, _indicator: ThinkingIndicator | None = None) -> str:
-        """Tool-calling loop with clean display."""
-        working_messages = composed_messages
-
-        # Route tools based on user message
-        user_text = ""
-        for msg in reversed(composed_messages):
-            if msg.get("role") == "user":
-                user_text = str(msg.get("content", ""))
-                break
-        routing = route_tools(
-            user_text,
-            self.toolkit.list_tool_names(),
-            conversation_history=self.session.messages[-4:],
-            online=is_online(),
-        )
-        if self.logger:
-            self.logger.log_user_input(user_text, intent=",".join(routing.intents))
-        if not routing.tool_names:
-            return self._run_stream_simple(composed_messages, stream)
-        if stream:
-            route_bits = ", ".join(routing.intents[:3]) or "chat"
-            tool_bits = ", ".join(routing.tool_names[:3])
-            self.out.print_info(f"route: {route_bits}")
-            if tool_bits:
-                self.out.print_info(f"tool lane: {tool_bits}")
-
-        ctx_size = self._select_task_context(user_text, routing.intents)
-        output_budget = self._select_task_output_budget(user_text, routing.intents)
-
-        # ── Speed optimization: speculative pre-execution ──
-        # Start running predicted tools NOW while model thinks
-        if hasattr(self, '_spec_executor'):
-            self._spec_executor.predict_and_prefetch(user_text, routing.tool_names)
-
-        # DIRECT FILE EDIT: if intent is edit and we can identify the file,
-        # skip the model tool-call loop entirely. Read file, ask model for
-        # updated content, write it. One shot. No multi-round failures.
-        # Also trigger if recent conversation was about editing a file
-        recent_edit_file = self._get_recent_edit_file()
-        is_question = "?" in user_text
-        is_edit_intent = ("file_edit" in routing.intents or "file_write" in routing.intents) and not is_question
-        is_followup_edit = (
-            bool(recent_edit_file)
-            and not is_edit_intent
-            and not is_question
-            and any(w in user_text.lower() for w in [
-                "add", "change", "remove", "update", "make",
-                "modify", "replace", "delete", "insert",
-                "improve", "fix", "refactor", "optimize", "rewrite",
-                "just", "dunno", "better", "clean",
-            ])
-        )
-        if (is_edit_intent or is_followup_edit) and self.profile.feature_variant in ("compact", "balanced"):
-            if stream and (recent_edit_file if is_followup_edit else True):
-                target = recent_edit_file if is_followup_edit else "resolved from request"
-                self.out.print_info(f"edit path: direct file edit ({target})")
-            result = self._direct_file_edit(
-                user_text, stream,
-                force_file=recent_edit_file if is_followup_edit else None,
-            )
-            if result is not None:
-                return result
-
-        use_minimal = self.profile.feature_variant == "compact"
-        all_schemas = self.toolkit.schemas(minimal=use_minimal)
-        tools = [t for t in all_schemas if t["function"]["name"] in routing.tool_names]
-        # Use centralized output manager
-        out = self.out
-
-        try:
-            consecutive_errors = 0
-            last_tool_call = ""
-            max_rounds = 20  # safety cap — agent has none but we need one for local models
-            for _round in range(max_rounds):
-                thinking_parts: list[str] = []
-                content_parts: list[str] = []
-                tool_calls_found: list[dict] = []
-                content_started = False
-                round_started = time.time()
-                first_token_s: float | None = None
-
-                # ── Thinking mode ──
-                # Reasoning mode (/switch): think on every round
-                # Fast mode: never think
-                from .thinking import should_use_thinking
-                goal_type = infer_goal_state(user_text).goal_type
-                use_think = should_use_thinking(
-                    self.config.runtime.laptop_26b_runtime_mode,
-                    self.config.runtime.internal_thinking_mode,
-                    goal_type=goal_type,
-                    task_stage=getattr(getattr(self.session, "current_task", None), "current_stage", ""),
-                    user_text=user_text,
-                )
-                round_budget = output_budget if _round == 0 else min(800, output_budget)
-                for event in self.engine.stream_chat_events(
-                    working_messages,
-                    tools=tools,
-                    think=use_think,
-                    num_ctx=ctx_size,
-                    num_predict=round_budget,
-                ):
-                    if event["type"] == "thinking":
-                        chunk = str(event["content"])
-                        thinking_parts.append(chunk)
-                        if stream:
-                            out.feed_thinking(chunk)
-                            peek = " ".join("".join(thinking_parts).split())[-120:]
-                            if peek:
-                                out.set_thinking_peek(peek)
-                    elif event["type"] == "content":
-                        chunk = str(event["content"])
-                        # Filter special tokens
-                        if "<|" in chunk or "|>" in chunk:
-                            from .tool_parsing import parse_tool_calls as _ptc
-                            parsed = _ptc(chunk)
-                            if parsed.has_tools:
-                                tool_calls_found = parsed.to_ollama_format()
-                                break
-                            import re as _re
-                            chunk = _re.sub(r'<\|[^>]*\|>', '', chunk)
-                        if not chunk.strip():
-                            continue
-                        if first_token_s is None:
-                            first_token_s = time.time() - round_started
-                        content_parts.append(chunk)
-                        if stream:
-                            out.stream(chunk)
-                            content_started = True
-                    elif event["type"] == "tool_calls":
-                        tool_calls_found = event["tool_calls"]
-                        break
-
-                thinking = "".join(thinking_parts)
-                content = "".join(content_parts).strip()
-                self._record_runtime_sample(first_token_s=first_token_s, total_s=time.time() - round_started)
-                self.stats.record(self.engine.last_response_meta)
-
-                # Check if content contains a text-format tool call (model output it as text)
-                if not tool_calls_found and content:
-                    import re as _re
-                    # Match: write_file(path='x', content='...') or similar
-                    tc_match = _re.search(r'(write_file|read_file|edit_file|bash)\s*\(', content)
-                    if tc_match:
-                        from .tool_parsing import parse_tool_calls as _ptc
-                        parsed = _ptc(content)
-                        if parsed.has_tools:
-                            tool_calls_found = parsed.to_ollama_format()
-                            content = parsed.content  # strip tool call from display
-
-                if not content_started and stream:
-                    out.done()
-
-                if tool_calls_found:
-                    # Dedup: don't repeat the same tool call
-                    call_sig = str([(t.get("function",{}).get("name",""), t.get("function",{}).get("arguments","")) for t in tool_calls_found])
-                    if call_sig == last_tool_call:
-                        break
-                    last_tool_call = call_sig
-
-                    # Permission check + execute each tool
-                    tool_messages = []
-                    for tc in tool_calls_found:
-                        f = tc.get("function", {})
-                        name = f.get("name", "")
-                        args = f.get("arguments", {})
-                        if isinstance(args, str):
-                            import json as _json
-                            try: args = _json.loads(args)
-                            except: args = {}
-
-                        # Lifecycle hook: pre-tool
-                        hook = self.hooks.on_pre_tool_use(name, args)
-                        if hook.blocked:
-                            if stream:
-                                out.log_tool(name, f"BLOCKED by hook: {hook.output or hook.error}")
-                            tool_messages.append({"role": "tool", "content": f"Blocked by hook: {hook.output or hook.error}"})
-                            continue
-
-                        allowed, reason = self.perms.check(name, args)
-                        if not allowed:
-                            if stream:
-                                out.log_tool(name, f"SKIPPED: {reason}")
-                            tool_messages.append({"role": "tool", "content": f"Denied: {reason}"})
-                            continue
-
-                        if stream:
-                            out.log_tool(name, str(args)[:60])
-                        # Check speculative cache first — instant if pre-fetched
-                        spec_result = self._spec_executor.get_if_ready(name, args)
-                        if spec_result is not None:
-                            result = {"role": "tool", "content": spec_result}
-                        else:
-                            result = self.toolkit._execute_one(tc)
-                        is_err = result["content"].startswith("Error") or result["content"].startswith("Tool error")
-                        if stream:
-                            out.tool_result(result["content"][:120], error=is_err)
-                        if self.logger:
-                            self.logger.log_tool_call(name, args, result["content"], duration_ms=0)
-                        self.hooks.on_post_tool_use(name, args, result["content"], is_err)
-                        # Track file changes for turn diff
-                        if name in ("write_file", "edit_file") and "path" in args:
-                            self.turn_tracker.track_file(str(args["path"]))
-                        tool_messages.append(result)
-
-                    # Check for errors — if too many consecutive, break and force-edit
-                    all_errors = all(
-                        m["content"].startswith("Error") or m["content"].startswith("Tool error")
-                        for m in tool_messages
-                    )
-                    if all_errors:
-                        consecutive_errors += 1
-                    else:
-                        consecutive_errors = 0
-
-                    if stream:
-                        for item in tool_messages:
-                            is_err = item["content"].startswith("Error") or item["content"].startswith("Tool error")
-                            out.tool_result(item["content"], error=is_err)
-
-                    # If ANY file tool error, do the edit ourselves immediately
-                    if consecutive_errors >= 1 and bool({"file_edit", "file_write"} & set(routing.intents)):
-                        if stream:
-                            ResponseDisplay.print_info("applying edit directly...")
-                        # Find the file being edited
-                        import re as _re
-                        fpath = None
-                        for tc in tool_calls_found:
-                            args = tc.get("function", {}).get("arguments", {})
-                            if "path" in args:
-                                fpath = args["path"]
-                                break
-                        if not fpath:
-                            fpath_match = _re.search(r'(\w+\.(?:py|js|ts|json|md|txt|html|css))', user_text + " " + thinking)
-                            fpath = fpath_match.group(1) if fpath_match else None
-                        if fpath and (self.repo_root / fpath).is_file():
-                            old = (self.repo_root / fpath).read_text(errors="replace")
-                            code_r = self.engine.chat_once([
-                                {"role": "user", "content": f"Current {fpath}:\n```\n{old}\n```\n\nApply this change: {user_text}\n\nIMPORTANT: Make MINIMAL changes. Keep ALL existing code. Only modify what was requested.\nReturn the COMPLETE file with the small change applied. No explanation."}
-                            ])
-                            new = code_r.get("message", {}).get("content", "").strip()
-                            new = _re.sub(r'^```\w*\n', '', new)
-                            new = _re.sub(r'\n```\s*$', '', new)
-                            if new and new != old:
-                                self.toolkit.changes.snapshot_before(fpath, "direct_edit")
-                                (self.repo_root / fpath).write_text(new)
-                                if stream:
-                                    out.log_tool("write_file", f"path={fpath}")
-                                    out.tool_result(f"Edited {fpath}")
-                                return f"I've updated {fpath} with the requested changes."
-                        break
-
-                    if stream:
-                        out.start_thinking()  # restart indicator for next round
-
-                    working_messages = [
-                        *working_messages,
-                        {"role": "assistant", "content": content, "tool_calls": tool_calls_found},
-                        *tool_messages,
-                        {"role": "user", "content": f"Good. Now do the NEXT step. Original task: {user_text}"},
-                    ]
-                    continue
-
-                # Force tool if model didn't call one but should have
-                if _round <= 1 and not tool_calls_found:
-                    content_lower = content.lower()
-                    # Check if file write/edit was expected but not done
-                    file_intents = {"file_write", "file_edit"}
-                    file_tools_called = any(
-                        t.get("function", {}).get("name", "") in ("write_file", "edit_file")
-                        for t in tool_calls_found
-                    )
-                    should_force = (
-                        not content.strip()  # empty response
-                        or any(p in content_lower for p in [
-                            "i do not have access", "i cannot", "i don't have",
-                            "i recommend using", "beyond my", "not able to",
-                            "i am unable", "i'm unable", "cannot directly",
-                            "i will now", "i will edit", "i will update",  # says it will but didn't
-                        ])
-                        or (bool(file_intents & set(routing.intents)) and not file_tools_called)  # edit/write intent but no tool
-                    )
-                    if should_force and thinking:
-                        thinking_lower = thinking.lower()
-                        # Try each tool — match name or name with underscores replaced
-                        forced = False
-                        for ts in tools:
-                            tname = ts["function"]["name"]
-                            readable = tname.replace("_", " ")
-                            if tname in thinking_lower or readable in thinking_lower or f"`{tname}`" in thinking_lower:
-                                forced_args = self._extract_args_from_thinking(tname, thinking, user_text)
-                                if forced_args is None:
-                                    import re as _re
-                                    if tname in ("write_file", "edit_file"):
-                                        # e2b can't call file tools — generate code, write ourselves
-                                        path_match = _re.search(r'(\w+\.(?:py|js|ts|json|md|txt|html|css))', user_text + " " + thinking)
-                                        fpath = path_match.group(1) if path_match else "output.py"
-                                        existing = (self.repo_root / fpath)
-                                        if existing.is_file() and tname == "edit_file":
-                                            # Edit: ask model for the UPDATED version of the file
-                                            old_content = existing.read_text(errors="replace")
-                                            if stream:
-                                                ResponseDisplay.print_info(f"generating edit for {fpath}...")
-                                            code_r = self.engine.chat_once([
-                                                {"role": "user", "content": f"Here is the current content of {fpath}:\n```\n{old_content}\n```\n\nModify it to: {user_text}\n\nReturn ONLY the complete updated file. No explanation."}
-                                            ])
-                                        else:
-                                            if stream:
-                                                ResponseDisplay.print_info(f"generating code for {fpath}...")
-                                            code_r = self.engine.chat_once([
-                                                {"role": "user", "content": f"Write ONLY the code for {fpath}. No explanation, just the code. Task: {user_text}"}
-                                            ])
-                                        code_content = code_r.get("message", {}).get("content", "").strip()
-                                        code_content = _re.sub(r'^```\w*\n', '', code_content)
-                                        code_content = _re.sub(r'\n```\s*$', '', code_content)
-                                        if code_content:
-                                            forced_args = {"path": fpath, "content": code_content}
-                                            forced_calls = [{"function": {"name": "write_file", "arguments": forced_args}}]
-                                        else:
-                                            continue
-                                    else:
-                                        continue
-                                else:
-                                    forced_calls = [{"function": {"name": tname, "arguments": forced_args}}]
-                                tool_msgs = self.toolkit.execute_tool_calls(forced_calls)
-                                if stream:
-                                    out.log_tool(tname, str(forced_args)[:60])
-                                    for item in tool_msgs:
-                                        out.tool_result(item["content"])
-                                    out.start_thinking()  # restart indicator for next round
-                                working_messages = [
-                                    *working_messages,
-                                    {"role": "assistant", "content": "", "tool_calls": forced_calls},
-                                    *tool_msgs,
-                                    {"role": "user", "content": f"Good. Now do the NEXT step. Original task: {user_text}"},
-                                ]
-                                forced = True
-                                break
-                        if forced and len(working_messages) > len(composed_messages):
-                            continue
-                        # Last resort: retry with ultra-short prompt (no system context)
-                        if not forced and not content.strip():
-                            retry_msgs = [
-                                {"role": "system", "content": "Use tools. Always call tools."},
-                                {"role": "user", "content": user_text},
-                            ]
-                            r = self.engine.chat_once(retry_msgs, tools=tools)
-                            tc = r.get("message", {}).get("tool_calls", [])
-                            if tc:
-                                tool_msgs = self.toolkit.execute_tool_calls(tc)
-                                if stream:
-                                    for t in tc:
-                                        f = t.get("function", {})
-                                        out.log_tool(f.get("name", ""), str(f.get("arguments", ""))[:60])
-                                    for item in tool_msgs:
-                                        out.tool_result(item["content"])
-                                    out.start_thinking()  # restart indicator for next round
-                                working_messages = [
-                                    *working_messages,
-                                    r["message"],
-                                    *tool_msgs,
-                                    {"role": "user", "content": f"Answer: {user_text}"},
-                                ]
-                                continue
-                            content = r.get("message", {}).get("content", "")
-
-                # Auto-save: if response contains a code block with a filename, write it
-                if content and "```" in content:
-                    import re as _re
-                    # Look for patterns like "save to pong.py" or "file named pong.py" in the text
-                    file_hint = _re.search(r'(?:save|file|named|called|create)\s+(?:it\s+(?:as|to)\s+)?[`*]*(\w+\.(?:py|js|ts|html|css|json|md|sh))[`*]*', content, _re.IGNORECASE)
-                    if file_hint:
-                        fname = file_hint.group(1)
-                        # Extract the code block
-                        code_match = _re.search(r'```(?:\w+)?\n(.*?)```', content, _re.DOTALL)
-                        if code_match:
-                            code = code_match.group(1).strip()
-                            if len(code) > 20:
-                                fpath = self.repo_root / fname
-                                self.toolkit.changes.snapshot_before(fname, "auto_write")
-                                fpath.parent.mkdir(parents=True, exist_ok=True)
-                                fpath.write_text(code)
-                                if stream:
-                                    self.console.print(f"\n  [green]✓[/] Auto-saved to {fname} ({len(code.splitlines())} lines)")
-
-                if stream:
-                    pass  # output handled by out.done()
-                return content
-
-            return ""
-        finally:
-            out.done()
-
     def _get_recent_edit_file(self) -> str | None:
         """Check if we recently edited/read a file (for follow-up edits)."""
         for event in reversed(self.session.events[-10:]):