regcode 0.12.0__tar.gz → 0.12.1__tar.gz

{regcode-0.12.0 → regcode-0.12.1}/GOALS.md

@@ -643,5 +643,55 @@ for the per-task mapping to tests.
     restoring it, so later tests received a second `AgentStatus` class and enum identity
     comparisons failed purely on execution order.
 
-11. ✅ **270 tests pass** (up from 231), `uv run ruff check` clean.
+11. ✅ **285 tests pass** (up from 231), `uv run ruff check` clean.
+
+## Fixed (2026-10-31 — CLI broke on the first real conversation)
+
+The rewrite passed every test but broke `regcode chat` as soon as the model said
+anything before calling a tool:
+
+```
+[ERROR] Agent error! litellm.BadRequestError: Hosted_vllmException - {"error":{"message":
+"3 validation errors for ValidatorIterator\n0.ChatCompletionContentPartTextParam.type\n
+Input should be 'text' [type=literal_error, input_value='output_text'...
+```
+
+Three separate regressions, all invisible to the existing suite because **every test
+made the model return *either* text *or* a tool call** — so the second turn, the one
+where the Runner replays the assistant's own output, never executed.
+
+1. ✅ **Responses-API items were leaking into chat-completions requests** — the Runner
+   hands the assistant's output back as `{"type": "message", "content": [{"type":
+   "output_text", ...}]}`, `function_call` and `function_call_output`. `_prepare_messages`
+   copied those dicts straight into `litellm.completion(messages=...)`, which the provider
+   rejects. It now runs them through `Converter.items_to_messages(items, model=...)`, the
+   same translation the SDK's own `LitellmModel` uses — which also merges an assistant's
+   text with the tool calls it asked for into a single turn.
+
+2. ✅ **Replayed history was structurally invalid** — `_update_history_from_sdk_result`
+   stored a `"Tool call: x"` label next to a `role: "tool"` result. A tool result is only
+   legal when an assistant turn carrying the matching `tool_calls` precedes it, so the
+   second `chat()` call would have been rejected by strict providers (vLLM among them).
+   History now stores the real `tool_calls` array (id, name, arguments). `ToolCallItem.raw_item`
+   is a `ResponseFunctionToolCall` **object** when the Runner builds it and a dict elsewhere;
+   reading it only as a dict silently produced `arguments: "{}"`, so a replayed turn claimed
+   the model had called a tool with no arguments. `_item_field()` handles both.
+
+3. ✅ **`python_code`, `run_script` and `web_crawl` were dead** — moving tool execution
+   under the Runner put them *inside* an event loop, where `asyncio.run()` raises
+   `cannot be called from a running event loop`. Every `python_code` call returned
+   `SANDBOX_ERROR: ...` and the model just got an error string back. Added
+   `regcode/async_utils.py::run_coroutine_blocking()`, which runs the coroutine on a
+   dedicated thread when a loop is already active.
+
+Also: `chat(messages=...)` is public API (`code_review`, GitKnecht, saved transcripts)
+and accepts plain chat-shaped dicts, which `Converter.items_to_messages` rejects outright.
+`_expand_input_items()` normalises `role: "tool"` and assistant `tool_calls` into Responses
+items before conversion.
+
+**Process lesson**: the new tests were written against the shapes the *tests* invented.
+`tests/test_task_regression.py` now pins the message shape of every turn handed to litellm
+(`_assert_chat_completions_shape`), covers text-plus-tool-call turns, a second `chat()`
+call, and tool execution under a running loop. Each was mutation-checked — revert the fix,
+watch it go red.
 

{regcode-0.12.0 → regcode-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: regcode
-Version: 0.12.0
+Version: 0.12.1
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.10
 Requires-Dist: boto3>=1.43.40

{regcode-0.12.0 → regcode-0.12.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "regcode"
-version = "0.12.0"
+version = "0.12.1"
 description = "Minimalistic coding agent with Python API and CLI"
 readme = "README.md"
 requires-python = ">=3.10"

{regcode-0.12.0 → regcode-0.12.1}/regcode/__init__.py

@@ -2,4 +2,4 @@ from regcode.config import Config
 from regcode.main import Agent, AgentStatus, ToolCall
 
 __all__ = ["Agent", "Config", "AgentStatus", "ToolCall"]
-__version__ = "0.12.0"
+__version__ = "0.12.1"

{regcode-0.12.0 → regcode-0.12.1}/regcode/agents_backend.py

@@ -103,6 +103,69 @@ def _base_response(model: str) -> Response:
     )
 
 
+def _output_text_part(text: str) -> dict[str, Any]:
+    """Build a Responses ``output_text`` content part."""
+    return {"annotations": [], "text": text, "type": "output_text"}
+
+
+def _expand_input_items(items: list[Any]) -> list[Any]:
+    """Normalise chat-completions-shaped dicts into Responses input items.
+
+    ``chat(messages=...)`` is public API and callers (``code_review``,
+    GitKnecht, saved transcripts) pass plain ``{"role": ..., "content": ...}``
+    dicts, including the ``role: "tool"`` entries older versions stored in
+    ``Agent.history``. ``Converter.items_to_messages`` only understands
+    Responses items and raises ``UserError`` on those, which would kill the
+    whole run. Plain ``{role, content}`` dicts pass through untouched.
+    """
+    expanded: list[Any] = []
+    for item in items:
+        if not isinstance(item, dict):
+            expanded.append(item)
+            continue
+
+        role = item.get("role")
+        tool_calls = item.get("tool_calls")
+
+        if role == "tool":
+            expanded.append(
+                {
+                    "type": "function_call_output",
+                    "call_id": item.get("tool_call_id") or "call_unknown",
+                    "output": item.get("content") or "",
+                }
+            )
+            continue
+
+        if tool_calls:
+            # A chat-shaped assistant turn bundles the text and the calls;
+            # Responses keeps them as separate items, calls first.
+            for call in tool_calls:
+                function = call.get("function") or {}
+                expanded.append(
+                    {
+                        "type": "function_call",
+                        "call_id": call.get("id") or "call_unknown",
+                        "name": function.get("name") or "",
+                        "arguments": function.get("arguments") or "{}",
+                    }
+                )
+            content = item.get("content")
+            if isinstance(content, str) and content:
+                expanded.append(
+                    {
+                        "type": "message",
+                        "role": "assistant",
+                        "status": "completed",
+                        "content": [_output_text_part(content)],
+                    }
+                )
+            continue
+
+        expanded.append(item)
+    return expanded
+
+
 class RegCodeModel(Model):
     """OpenAI Agents SDK ``Model`` backed by regcode's LiteLLM config.
 
@@ -279,7 +342,22 @@ class RegCodeModel(Model):
         input: str | list[TResponseInputItem],
         system_instructions: str | None,
     ) -> list[dict[str, Any]]:
-        """Convert SDK input items into LiteLLM message dicts.
+        """Convert SDK input items into LiteLLM chat-completions messages.
+
+        The Runner hands back the assistant's own output as **Responses API**
+        items (``{"type": "message", "content": [{"type": "output_text", ...}]}``,
+        ``function_call``, ``function_call_output``). Those must be translated
+        before they reach litellm: copying them through verbatim made the
+        second turn of every tool-using conversation fail with
+
+            3 validation errors for ValidatorIterator
+            .0.ChatCompletionContentPartTextParam.type
+              Input should be 'text' [input_value='output_text']
+
+        which surfaced in the CLI as an ``Agent error!`` the moment the model
+        said anything before calling a tool. ``Converter.items_to_messages`` is
+        the same translation the SDK's own ``LitellmModel`` uses, and it also
+        merges an assistant's text with the tool calls it asked for.
 
         The system turn is managed **by role**, never by position: an existing
         system message is replaced in place, and a caller list that starts with
@@ -290,19 +368,13 @@ class RegCodeModel(Model):
         """
         items: list[Any] = [{"role": "user", "content": input}] if isinstance(
             input, str
-        ) else list(input)
-
-        messages: list[dict[str, Any]] = []
-        for item in items:
-            if isinstance(item, dict):
-                messages.append(dict(item))
-            elif hasattr(item, "role"):
-                messages.append(
-                    {
-                        "role": item.role,
-                        "content": getattr(item, "content", ""),
-                    }
-                )
+        ) else _expand_input_items(list(input))
+
+        messages: list[dict[str, Any]] = list(
+            Converter.items_to_messages(
+                items, model=self.config.provider.model
+            )
+        )
 
         replacement = self._system_text(system_instructions)
         if replacement is None:

regcode-0.12.1/regcode/async_utils.py

@@ -0,0 +1,58 @@
+"""Run async code from synchronous tool implementations.
+
+Tools are invoked by the OpenAI Agents SDK ``Runner``, which drives the whole
+conversation inside an event loop. A synchronous tool that calls
+``asyncio.run()`` therefore dies with::
+
+    RuntimeError: asyncio.run() cannot be called from a running event loop
+
+That is exactly what silently broke ``python_code``, ``run_script`` (both via
+``MontySandbox``) and ``web_crawl`` once tool execution moved under the Runner.
+The fix has to live in one place, because every tool that needs an event loop
+has the same requirement.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from collections.abc import Callable
+from typing import Any
+
+
+def run_coroutine_blocking(factory: Callable[[], Any]) -> Any:
+    """Execute a coroutine to completion from sync code, loop present or not.
+
+    Args:
+        factory: Zero-argument callable returning a fresh coroutine. It is
+            called lazily so the coroutine is always created on the thread that
+            will run it.
+
+    Returns:
+        The coroutine's result.
+
+    Raises:
+        BaseException: Whatever the coroutine raised, re-raised on the calling
+            thread.
+    """
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        # No loop on this thread — the plain, cheap path.
+        return asyncio.run(factory())
+
+    box: dict[str, Any] = {}
+
+    def _worker() -> None:
+        try:
+            box["value"] = asyncio.run(factory())
+        except BaseException as exc:  # re-raised on the calling thread
+            box["error"] = exc
+
+    # A dedicated thread gets its own loop, leaving the Runner's loop alone.
+    thread = threading.Thread(target=_worker, daemon=True)
+    thread.start()
+    thread.join()
+    if "error" in box:
+        raise box["error"]
+    return box.get("value")

{regcode-0.12.0 → regcode-0.12.1}/regcode/main.py

@@ -761,11 +761,18 @@ class Agent:
     def _update_history_from_sdk_result(
         self, result, messages: list[dict[str, Any]]
     ) -> None:
-        """Extract conversation history from SDK RunResult and update _history."""
+        """Extract conversation history from SDK RunResult and update _history.
+
+        The result is stored in **chat-completions shape** because it is
+        replayed into the next ``chat()`` call. A ``role: "tool"`` entry is
+        only legal when an assistant turn carrying the matching ``tool_calls``
+        precedes it, so the tool call is recorded with its real id, name and
+        arguments rather than a ``"Tool call: x"`` label — strict providers
+        (vLLM among them) reject the orphaned tool result outright.
+        """
         from agents.items import MessageOutputItem, ToolCallItem, ToolCallOutputItem
 
         history = []
-        last_tool_name: str | None = None
         for item in getattr(result, "new_items", None) or []:
             if isinstance(item, MessageOutputItem):
                 # Extract text content from message
@@ -779,31 +786,40 @@ class Agent:
                         "content": " ".join(text_parts),
                     })
             elif isinstance(item, ToolCallItem):
-                # Add tool call as assistant message
-                last_tool_name = item.tool_name
+                call_id = (
+                    _item_field(item, "call_id") or f"call_{len(history)}"
+                )
+                name = item.tool_name or _item_field(item, "name") or ""
                 history.append({
                     "role": "assistant",
-                    "content": f"Tool call: {item.tool_name}",
+                    "content": None,
+                    "tool_calls": [
+                        {
+                            "id": call_id,
+                            "type": "function",
+                            "function": {
+                                "name": name,
+                                "arguments": (
+                                    _item_field(item, "arguments") or "{}"
+                                ),
+                            },
+                        }
+                    ],
                 })
             elif isinstance(item, ToolCallOutputItem):
-                # ``raw_item`` is a ``function_call_output`` dict, not an
-                # object — reading it by attribute raised AttributeError and
-                # wiped the history after every tool call. The tool name lives
-                # on the matching ToolCallItem, which the Runner emits just
-                # before this one.
-                raw = item.raw_item
-                if isinstance(raw, dict):
-                    call_id = raw.get("call_id") or raw.get("id")
-                else:
-                    call_id = getattr(raw, "call_id", None) or getattr(
-                        raw, "id", None
-                    )
+                # ``raw_item`` is a ``function_call_output`` — a dict in some
+                # paths and a pydantic model in others. Reading it by attribute
+                # alone raised AttributeError and wiped the history after every
+                # tool call; reading it as a dict alone silently yielded no
+                # call_id, orphaning the result.
+                call_id = _item_field(item, "call_id") or _item_field(
+                    item, "id"
+                )
                 output = item.output
                 history.append(
                     {
                         "role": "tool",
                         "tool_call_id": call_id,
-                        "name": last_tool_name,
                         "content": output
                         if isinstance(output, str)
                         else str(output),
@@ -1150,6 +1166,26 @@ def _safe_final_output(result: Any) -> str:
     return output if isinstance(output, str) else ""
 
 
+def _item_field(item: Any, name: str) -> Any:
+    """Read ``name`` off an SDK item whose ``raw_item`` may be dict or model.
+
+    ``ToolCallItem.raw_item`` is a ``ResponseFunctionToolCall`` object when the
+    Runner built it, and a plain ``function_call`` dict in other paths. Reading
+    only one of the two silently produced empty tool arguments, so a replayed
+    history told the model it had called a tool with ``{}``.
+    """
+    raw = getattr(item, "raw_item", None)
+    if isinstance(raw, dict):
+        value = raw.get(name)
+        if value is not None:
+            return value
+    elif raw is not None:
+        value = getattr(raw, name, None)
+        if value is not None:
+            return value
+    return getattr(item, name, None)
+
+
 def _run_coroutine(coro: Any) -> Any:
     """Run ``coro`` to completion from sync code, notebooks included.
 

{regcode-0.12.0 → regcode-0.12.1}/regcode/monty_sandbox.py

@@ -31,6 +31,8 @@ from pydantic_monty import (
     ResourceLimits,
 )
 
+from regcode.async_utils import run_coroutine_blocking
+
 
 @dataclass
 class MontySandboxConfig:
@@ -200,21 +202,21 @@ class MontySandbox:
             # Create Monty runner
             monty = Monty(code)
 
-            # Execute code - always use asyncio.run() for full isolation
-            # This avoids "no running event loop" errors that occur when
-            # the Monty library checks for a running loop at the process level
             # Create callback outside async scope so we can access .output
             cb = CollectString()
 
+            async def _async_run():
+                return await monty.run_async(
+                    external_functions=funcs,
+                    limits=limits,
+                    print_callback=cb,
+                )
+
             try:
-                async def _async_run():
-                    return await monty.run_async(
-                        external_functions=funcs,
-                        limits=limits,
-                        print_callback=cb,
-                    )
-
-                result = asyncio.run(_async_run())
+                # Must not call asyncio.run() directly: tools execute inside the
+                # SDK Runner's event loop, where a nested asyncio.run() raises
+                # "cannot be called from a running event loop".
+                result = run_coroutine_blocking(_async_run)
             except Exception as e:
                 return MontySandboxResult(
                     stdout=f"SANDBOX_ERROR: {str(e)}",

{regcode-0.12.0 → regcode-0.12.1}/regcode/tools/web_crawl.py

@@ -96,11 +96,14 @@ class WebCrawlerTool(BaseTool):
                 exit_code=1,
             )
 
-        import asyncio
+        from regcode.async_utils import run_coroutine_blocking
 
         try:
-            result = asyncio.run(
-                self._crawl_async(url, markdown, word_count_threshold, only_text)
+            # Loop-safe: this tool runs inside the SDK Runner's event loop.
+            result = run_coroutine_blocking(
+                lambda: self._crawl_async(
+                    url, markdown, word_count_threshold, only_text
+                )
             )
             return result
         except Exception as e:

{regcode-0.12.0 → regcode-0.12.1}/tests/test_clipboard.py

@@ -159,7 +159,15 @@ class TestAgentMultimodal:
             messages = mock_completion.call_args[1]["messages"]
             user_msg = [m for m in messages if m["role"] == "user"][0]
             assert isinstance(user_msg["content"], list)
-            assert user_msg["content"] == multimodal_content
+            # The SDK's converter normalises image parts (it fills in
+            # detail="auto"), so assert the payload survives rather than
+            # exact dict equality.
+            parts = user_msg["content"]
+            assert [p["type"] for p in parts] == ["image_url", "text"]
+            assert (
+                parts[0]["image_url"]["url"] == "data:image/png;base64,abc"
+            )
+            assert parts[1]["text"] == "Describe this image."
 
     def test_chat_with_invalid_message_type(self):
         from regcode.main import Agent

{regcode-0.12.0 → regcode-0.12.1}/tests/test_main.py

@@ -73,7 +73,14 @@ def test_agent_chat_with_tool_use():
         "assistant",
     ]
     assert agent.history[0]["content"] == "calculate 1+1"
-    assert agent.history[1]["content"] == "Tool call: python_code"
+    # The assistant turn must carry a real tool_calls entry: a role="tool"
+    # result is only legal when the matching call precedes it, and strict
+    # providers reject the orphan otherwise.
+    assert agent.history[1]["tool_calls"][0]["function"]["name"] == "python_code"
+    assert agent.history[1]["tool_calls"][0]["function"]["arguments"] == (
+        '{"code": "print(1)" }'
+    )
+    assert agent.history[2]["tool_call_id"] == "call_123"
     assert agent.history[3]["content"] == "Done!"
 
 

{regcode-0.12.0 → regcode-0.12.1}/tests/test_task_regression.py

@@ -461,3 +461,295 @@ def test_module_level_helpers_exist():
     for gone in ("_stream", "_chat_loop", "_execute_tool_calls"):
         assert not hasattr(Agent, gone), f"{gone} should have been removed"
     assert not hasattr(main_mod, "_convert_registry_tools_to_sdk_tools")
+
+
+# ── CLI regression: Responses items must never reach litellm ────────────
+
+# Keys that belong to the Responses API. If one of these appears in a message
+# handed to litellm, the provider answers
+#   "ChatCompletionContentPartTextParam.type Input should be 'text'
+#    [input_value='output_text']"
+# which surfaced in the CLI as "Agent error! litellm.BadRequestError".
+_RESPONSES_ONLY_KEYS = {"output_text", "function_call", "function_call_output"}
+
+
+def _assert_chat_completions_shape(messages: list[dict], turn: int) -> None:
+    """Fail loudly if any Responses-API item leaked into a litellm request."""
+    for msg in messages:
+        assert "type" not in msg or msg["type"] in (
+            "message",
+        ), f"turn {turn}: Responses item leaked: {msg}"
+        content = msg.get("content")
+        if isinstance(content, list):
+            for part in content:
+                assert part.get("type") not in _RESPONSES_ONLY_KEYS, (
+                    f"turn {turn}: Responses content part leaked: {part}"
+                )
+        if msg.get("role") == "tool":
+            assert msg.get("tool_call_id"), (
+                f"turn {turn}: tool result without tool_call_id: {msg}"
+            )
+
+
+class TestToolTurnMessageShape:
+    """The Runner replays the assistant's own output back to the model.
+
+    Every test that existed before made the model return *either* text *or* a
+    tool call, so the second turn — the one carrying the replayed assistant
+    item — never happened, and the CLI broke on the first real conversation.
+    """
+
+    def test_text_with_tool_call_replays_as_chat_messages(self):
+        agent = Agent(config=Config(), directory=".")
+        with patch("regcode.agents_backend.litellm.completion") as m:
+            m.side_effect = [
+                completion_response(
+                    "Let me take a quick peek.",
+                    tool_calls=[tool_call("c1", "system_info", "{}")],
+                ),
+                completion_response("done"),
+            ]
+            agent.chat("hi")
+            turns = [c.kwargs["messages"] for c in m.call_args_list]
+
+        assert len(turns) == 2, "the tool turn must be followed by a second call"
+        for i, messages in enumerate(turns):
+            _assert_chat_completions_shape(messages, i)
+
+        replayed = turns[1][2]
+        assert replayed["role"] == "assistant"
+        # The SDK's converter merges the text and the call into one turn.
+        assert replayed["content"] == "Let me take a quick peek."
+        assert replayed["tool_calls"][0]["id"] == "c1"
+        assert turns[1][3]["role"] == "tool"
+        assert turns[1][3]["tool_call_id"] == "c1"
+
+    def test_streaming_text_with_tool_call(self):
+        agent = Agent(config=Config(), directory=".")
+        chunks: list[str] = []
+        with patch(
+            "regcode.agents_backend.litellm.acompletion", new_callable=AsyncMock
+        ) as m:
+            m.side_effect = [
+                stream_chunks(
+                    "peeking", tool_calls=[tool_call("c1", "system_info", "{}")]
+                ),
+                stream_chunks("streamed done"),
+            ]
+            out = agent.chat("hi", stream=True, on_text_chunk=chunks.append)
+
+        assert out == "peekingstreamed done"
+        assert "".join(chunks) == out
+        for i, call in enumerate(m.call_args_list):
+            _assert_chat_completions_shape(call.kwargs["messages"], i)
+
+    def test_second_chat_call_replays_history_validly(self):
+        """Multi-turn is where the hand-built history was silently invalid.
+
+        A ``role: "tool"`` entry is only legal when an assistant turn carrying
+        the matching ``tool_calls`` precedes it; strict providers (vLLM) reject
+        the orphan outright.
+        """
+        agent = Agent(config=Config(), directory=".")
+        with patch("regcode.agents_backend.litellm.completion") as m:
+            m.side_effect = [
+                completion_response(
+                    "peeking", tool_calls=[tool_call("c1", "system_info", "{}")]
+                ),
+                completion_response("first done"),
+                completion_response(
+                    "looking again",
+                    tool_calls=[tool_call("c2", "list_dir", '{"path": "."}')],
+                ),
+                completion_response("second done"),
+            ]
+            assert agent.chat("hi") == "first done"
+            assert agent.chat("again") == "second done"
+            turns = [c.kwargs["messages"] for c in m.call_args_list]
+
+        for i, messages in enumerate(turns):
+            _assert_chat_completions_shape(messages, i)
+
+        last = turns[-1]
+        tool_entries = [msg for msg in last if msg.get("role") == "tool"]
+        assert tool_entries, "history should carry the earlier tool result"
+        assistant_with_calls = [
+            msg for msg in last if msg.get("role") == "assistant" and msg.get(
+                "tool_calls"
+            )
+        ]
+        known_ids = {
+            tc["id"]
+            for msg in assistant_with_calls
+            for tc in msg["tool_calls"]
+        }
+        for msg in tool_entries:
+            assert msg["tool_call_id"] in known_ids, (
+                f"orphaned tool result: {msg['tool_call_id']} not in {known_ids}"
+            )
+
+    def test_history_preserves_real_tool_arguments(self):
+        """A replayed history must not claim the tool was called with ``{}``."""
+        agent = Agent(config=Config(), directory=".")
+        with patch("regcode.agents_backend.litellm.completion") as m:
+            m.side_effect = [
+                completion_response(
+                    tool_calls=[
+                        tool_call("c1", "python_code", '{"code": "print(1)"}')
+                    ]
+                ),
+                completion_response("done"),
+            ]
+            agent.chat("calc")
+
+        call = agent.history[1]["tool_calls"][0]
+        assert call["function"]["arguments"] == '{"code": "print(1)"}'
+        assert call["function"]["name"] == "python_code"
+
+
+class TestLegacyMessageShapes:
+    """``chat(messages=...)`` is public API and accepts plain chat dicts."""
+
+    def test_role_tool_history_is_accepted(self):
+        from regcode.agents_backend import _expand_input_items
+
+        expanded = _expand_input_items(
+            [{"role": "tool", "tool_call_id": "c9", "content": "output text"}]
+        )
+        assert expanded == [
+            {
+                "type": "function_call_output",
+                "call_id": "c9",
+                "output": "output text",
+            }
+        ]
+
+    def test_assistant_tool_calls_are_split(self):
+        from regcode.agents_backend import _expand_input_items
+
+        expanded = _expand_input_items(
+            [
+                {
+                    "role": "assistant",
+                    "content": "thinking",
+                    "tool_calls": [
+                        {
+                            "id": "c1",
+                            "type": "function",
+                            "function": {
+                                "name": "read_file",
+                                "arguments": '{"path": "a"}',
+                            },
+                        }
+                    ],
+                }
+            ]
+        )
+        assert expanded[0]["type"] == "function_call"
+        assert expanded[0]["name"] == "read_file"
+        assert expanded[1]["content"][0]["text"] == "thinking"
+
+    def test_plain_dicts_pass_through(self):
+        from regcode.agents_backend import _expand_input_items
+
+        items = [{"role": "user", "content": "hi"}]
+        assert _expand_input_items(items) == items
+
+    def test_chat_with_prebuilt_messages_survives_tool_history(self):
+        """code_review()/GitKnecht pass messages built from saved history."""
+        agent = Agent(config=Config(), directory=".")
+        messages = [
+            {"role": "system", "content": "SYS"},
+            {"role": "user", "content": "start"},
+            {
+                "role": "assistant",
+                "content": None,
+                "tool_calls": [
+                    {
+                        "id": "c1",
+                        "type": "function",
+                        "function": {
+                            "name": "system_info",
+                            "arguments": "{}",
+                        },
+                    }
+                ],
+            },
+            {"role": "tool", "tool_call_id": "c1", "content": "OS: Linux"},
+        ]
+        with patch("regcode.agents_backend.litellm.completion") as m:
+            m.return_value = completion_response("ok")
+            agent.chat(messages=messages)
+            sent = m.call_args.kwargs["messages"]
+
+        _assert_chat_completions_shape(sent, 0)
+        assert any(msg.get("role") == "tool" for msg in sent)
+
+
+class TestToolsRunInsideEventLoop:
+    """Tools execute inside the Runner's loop, so asyncio.run() is illegal.
+
+    ``python_code``/``run_script`` (via MontySandbox) and ``web_crawl`` all
+    called ``asyncio.run()`` directly and every one of them returned
+    ``SANDBOX_ERROR: asyncio.run() cannot be called from a running event loop``.
+    """
+
+    def test_python_code_executes_under_runner(self):
+        agent = Agent(config=Config(), directory=".")
+        with patch("regcode.agents_backend.litellm.completion") as m:
+            m.side_effect = [
+                completion_response(
+                    tool_calls=[
+                        tool_call("c1", "python_code", '{"code": "print(42)"}')
+                    ]
+                ),
+                completion_response("done"),
+            ]
+            agent.chat("run it")
+
+        tool_msg = next(h for h in agent.history if h["role"] == "tool")
+        assert "SANDBOX_ERROR" not in tool_msg["content"]
+        assert "42" in tool_msg["content"]
+        assert "exit_code: 0" in tool_msg["content"]
+
+    def test_run_coroutine_blocking_outside_loop(self):
+        import asyncio
+
+        from regcode.async_utils import run_coroutine_blocking
+
+        async def work() -> int:
+            await asyncio.sleep(0)
+            return 7
+
+        assert run_coroutine_blocking(work) == 7
+
+    def test_run_coroutine_blocking_inside_loop(self):
+        import asyncio
+
+        from regcode.async_utils import run_coroutine_blocking
+
+        async def work() -> int:
+            await asyncio.sleep(0)
+            return 7
+
+        async def outer() -> int:
+            # A running loop must not make the nested call fail.
+            return run_coroutine_blocking(work)
+
+        assert asyncio.run(outer()) == 7
+
+    def test_run_coroutine_blocking_propagates_errors(self):
+        import asyncio
+
+        import pytest
+
+        from regcode.async_utils import run_coroutine_blocking
+
+        async def boom() -> None:
+            raise ValueError("kaboom")
+
+        async def outer() -> None:
+            run_coroutine_blocking(boom)
+
+        with pytest.raises(ValueError, match="kaboom"):
+            asyncio.run(outer())

{regcode-0.12.0 → regcode-0.12.1}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14' and sys_platform == 'win32'",
@@ -682,7 +682,7 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" }
 wheels = [
@@ -756,7 +756,7 @@ resolution-markers = [
     "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
     { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" }
@@ -1001,7 +1001,7 @@ name = "exceptiongroup"
 version = "1.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
 wheels = [
@@ -1496,7 +1496,7 @@ name = "gunicorn"
 version = "26.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "packaging", marker = "python_full_version < '3.12' or sys_platform != 'win32'" },
+    { name = "packaging" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/6d/b7/a4a3f632f823e432ce6bc65f62961b7980c898c77f075a2f7118cb3846fe/gunicorn-26.0.0.tar.gz", hash = "sha256:ca9346f85e3a4aeeb64d491045c16b9a35647abd37ea15efe53080eb8b090baf", size = 727286, upload-time = "2026-05-05T06:38:25.529Z" }
 wheels = [
@@ -2228,15 +2228,15 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "cycler", marker = "python_full_version < '3.11'" },
-    { name = "fonttools", marker = "python_full_version < '3.11'" },
-    { name = "kiwisolver", marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "packaging", marker = "python_full_version < '3.11'" },
-    { name = "pillow", marker = "python_full_version < '3.11'" },
-    { name = "pyparsing", marker = "python_full_version < '3.11'" },
-    { name = "python-dateutil", marker = "python_full_version < '3.11'" },
+    { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" } },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" }
 wheels = [
@@ -2308,16 +2308,16 @@ resolution-markers = [
     "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-    { name = "cycler", marker = "python_full_version >= '3.11'" },
-    { name = "fonttools", marker = "python_full_version >= '3.11'" },
-    { name = "kiwisolver", marker = "python_full_version >= '3.11'" },
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" } },
+    { name = "cycler" },
+    { name = "fonttools" },
+    { name = "kiwisolver" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
     { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "packaging", marker = "python_full_version >= '3.11'" },
-    { name = "pillow", marker = "python_full_version >= '3.11'" },
-    { name = "pyparsing", marker = "python_full_version >= '3.11'" },
-    { name = "python-dateutil", marker = "python_full_version >= '3.11'" },
+    { name = "packaging" },
+    { name = "pillow" },
+    { name = "pyparsing" },
+    { name = "python-dateutil" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/1f/24/080c99d223d158d3a8902769269ab6da5b50f7a0e6e072513907e02b7a6c/matplotlib-3.11.0.tar.gz", hash = "sha256:68c0c7be01b30dcca3638934f7f591df73401235cbdbf0d1ab1c71e7db7f8b57", size = 33251176, upload-time = "2026-06-12T02:29:15.508Z" }
 wheels = [
@@ -3962,7 +3962,7 @@ wheels = [
 
 [[package]]
 name = "regcode"
-version = "0.11.0"
+version = "0.12.1"
 source = { editable = "." }
 dependencies = [
     { name = "boto3" },
@@ -4481,10 +4481,10 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "joblib", marker = "python_full_version < '3.11'" },
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
-    { name = "threadpoolctl", marker = "python_full_version < '3.11'" },
+    { name = "joblib" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
+    { name = "scipy", version = "1.15.3", source = { registry = "https://pypi.org/simple" } },
+    { name = "threadpoolctl" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/98/c2/a7855e41c9d285dfe86dc50b250978105dce513d6e459ea66a6aeb0e1e0c/scikit_learn-1.7.2.tar.gz", hash = "sha256:20e9e49ecd130598f1ca38a1d85090e1a600147b9c02fa6f15d69cb53d968fda", size = 7193136, upload-time = "2025-09-09T08:21:29.075Z" }
 wheels = [
@@ -4532,13 +4532,13 @@ resolution-markers = [
     "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "joblib", marker = "python_full_version >= '3.11'" },
-    { name = "narwhals", marker = "python_full_version >= '3.11'" },
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "joblib" },
+    { name = "narwhals" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
     { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "scipy", version = "1.17.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
     { name = "scipy", version = "1.18.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
-    { name = "threadpoolctl", marker = "python_full_version >= '3.11'" },
+    { name = "threadpoolctl" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/fa/6f/37092bdb25f712817231799fc5674d8e704066a8a70c1d2d40517e18b4ab/scikit_learn-1.9.0.tar.gz", hash = "sha256:8833266989d3a5110178a9fae30783675460724d0e1efb13b14901d2c660c557", size = 7750767, upload-time = "2026-06-02T11:54:32.706Z" }
 wheels = [
@@ -4582,7 +4582,7 @@ resolution-markers = [
     "python_full_version < '3.11'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" }
 wheels = [
@@ -4641,7 +4641,7 @@ resolution-markers = [
     "python_full_version == '3.11.*'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" },
+    { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" }
 wheels = [
@@ -4718,7 +4718,7 @@ resolution-markers = [
     "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'win32'",
 ]
 dependencies = [
-    { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" } },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/a7/25/c2700dfaf6442b4effaa91af24ebce5dc9d31bb4a69706313aae70d72cd0/scipy-1.18.0.tar.gz", hash = "sha256:67b2ad2ad54c72ca6d04975a9b2df8c3638c34ddd5b28738e94fc2b57929d378", size = 30774447, upload-time = "2026-06-19T15:01:43.456Z" }
 wheels = [