regcode 0.6.2__tar.gz → 0.6.3__tar.gz

{regcode-0.6.2 → regcode-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: regcode
-Version: 0.6.2
+Version: 0.6.3
 Summary: Minimalistic coding agent with Python API and CLI
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0

{regcode-0.6.2 → regcode-0.6.3}/pyproject.toml

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

{regcode-0.6.2 → regcode-0.6.3}/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.6.2"
+__version__ = "0.6.3"

{regcode-0.6.2 → regcode-0.6.3}/regcode/main.py

@@ -263,7 +263,7 @@ class Agent:
             self._track_response_cost(response)
 
             choice = response.choices[0] # type: ignore
-            message_obj = choice.message
+            message_obj = choice.message # type: ignore
             response_message = {
                 "role": "assistant",
                 "content": message_obj.content or "",
@@ -513,231 +513,270 @@ class Agent:
         return "".join(parts)
 
     def _stream(
-        self,
-        messages: list[dict],
-        tool_definitions: list[dict[str, Any]] | None = None,
-        on_text_chunk: Callable[[str], None] | None = None,
-    ) -> str:
-        """Stream response with tool support.
-
-        Runs the same tool-call loop as chat() but streams the final
-        text response chunk-by-chunk. Tool calls are executed normally
-        and their results are communicated via the callbacks registered
-        on __init__ (status_callback / result_callback).
-
-        Args:
-            messages: The message list for the completion.
-            tool_definitions: Tool definitions for the LLM.
-            on_text_chunk: Optional callback invoked for each text chunk
-                from the LLM stream. Useful for the CLI to print
-                progressively.
-
-        Returns:
-            The complete final text response.
-        """
-        completion_kwargs = self.config.get_litellm_completion_kwargs()
-        completion_kwargs["messages"] = messages
-        if tool_definitions:
-            completion_kwargs["tools"] = tool_definitions
-            completion_kwargs["tool_choice"] = "auto"
+            self,
+            messages: list[dict],
+            tool_definitions: list[dict[str, Any]] | None = None,
+            on_text_chunk: Callable[[str], None] | None = None,
+            max_tool_calls: int = 10,
+        ) -> str:
+            """Stream response with tool support.
+
+            Runs the same tool-call loop as chat() but streams the final
+            text response chunk-by-chunk. Tool calls are executed normally
+            and their results are communicated via the callbacks registered
+            on __init__ (status_callback / result_callback).
+
+            Args:
+                messages: The message list for the completion.
+                tool_definitions: Tool definitions for the LLM.
+                on_text_chunk: Optional callback invoked for each text chunk
+                    from the LLM stream. Useful for the CLI to print
+                    progressively.
+
+            Returns:
+                The complete final text response.
+            """
+            completion_kwargs = self.config.get_litellm_completion_kwargs()
+            completion_kwargs["messages"] = messages
+            if tool_definitions:
+                completion_kwargs["tools"] = tool_definitions
+                completion_kwargs["tool_choice"] = "auto"
 
-        full_text = ""
-        final_text = ""
-        response_message: dict[str, Any] = {}
-        total_tool_calls = 0
+            full_text = ""
+            final_text = ""
+            response_message: dict[str, Any] = {}
+            total_tool_calls = 0
 
-        for _ in range(10):
-            # When budget is exhausted, rebuild system prompt without tools
-            if self._tool_budget_exhausted:
+            for _ in range(max_tool_calls):
                 system_prompt_text = self._build_system_prompt_no_tools()
                 messages = [
                     {"role": "system", "content": system_prompt_text},
                     *messages[1:],
                 ]
 
-            current_tool_defs = (
-                tool_definitions if not self._tool_budget_exhausted else None
-            )
-
-            if current_tool_defs:
-                completion_kwargs["tools"] = current_tool_defs
-                completion_kwargs["tool_choice"] = "auto"
-            elif self._tool_budget_exhausted:
-                completion_kwargs["tool_choice"] = "none"
-                # Remove tools key if present
-                completion_kwargs.pop("tools", None)
-
-            completion_kwargs["stream"] = True
-            completion_kwargs["messages"] = messages
-
-            response = litellm.completion(**completion_kwargs)
-
-            # Track cost and tokens from this response
-            self._track_response_cost(response)
-
-            # Stream the response — accumulate text and tool_calls
-            # across ALL chunks, not just the last one.
-            full_text = ""
-            # Accumulate delta tool calls by index so we can merge partial
-            # chunks (id in first chunk, function name in second, arguments
-            # accumulating in subsequent chunks) into a single per-call object.
-            accumulated_by_index: dict[int, dict[str, Any]] = {}
-            try:
-                for chunk in response:
-                    delta = chunk.choices[0].delta # type: ignore
-                    # Accumulate text content
-                    if delta.content:
-                        full_text += delta.content
-                        if on_text_chunk:
-                            on_text_chunk(delta.content)
-                    # Accumulate tool calls from any chunk
-                    if delta.tool_calls:
-                        for tc_delta in delta.tool_calls:
-                            idx = tc_delta.index  # type: ignore
-                            if idx not in accumulated_by_index:
-                                accumulated_by_index[idx] = {
-                                    "id": tc_delta.id or "",
-                                    "type": tc_delta.type or "function",
-                                    "function_name": "",
-                                    "function_arguments": "",
-                                }
-                            acc = accumulated_by_index[idx]
-                            if tc_delta.id is not None:
-                                acc["id"] = tc_delta.id
-                            if tc_delta.function is not None:
-                                if tc_delta.function.name:
-                                    acc["function_name"] = tc_delta.function.name
-                                if tc_delta.function.arguments:
-                                    acc["function_arguments"] += (
-                                        tc_delta.function.arguments
-                                    )
-            except Exception:
-                # Litellm's streaming iterator can crash on malformed responses
-                # or sentinel markers like [DONE]. If iteration fails, just use
-                # whatever text we accumulated so far.
-                pass
-
-            # Reconstruct tool call dicts from accumulated chunks and validate
-            valid_tool_calls = []
-            for idx, acc in accumulated_by_index.items():
-                if not acc.get("id") or not acc.get("function_name"):
-                    continue
-                valid_tool_calls.append({
-                    "id": acc["id"],
-                    "type": acc["type"],
-                    "index": idx,
-                    "function": {
-                        "name": acc["function_name"],
-                        "arguments": acc["function_arguments"],
-                    },
-                })
-
-            response_message = {
-                "role": "assistant",
-                "content": full_text or "",
-            }
-
-            # Attach only valid accumulated tool calls
-            if valid_tool_calls:
-                response_message["tool_calls"] = valid_tool_calls
-
-            messages.append(response_message)
-
-            if full_text:
-                final_text = full_text
+                current_tool_defs = (
+                    tool_definitions if not self._tool_budget_exhausted else None
+                )
 
-            if self._tool_budget_exhausted:
-                break
+                if current_tool_defs:
+                    completion_kwargs["tools"] = current_tool_defs
+                    completion_kwargs["tool_choice"] = "auto"
+                elif self._tool_budget_exhausted:
+                    completion_kwargs["tool_choice"] = "none"
+                    # Remove tools key if present
+                    completion_kwargs.pop("tools", None)
+
+                completion_kwargs["stream"] = True
+                completion_kwargs["messages"] = messages
+
+                response = litellm.completion(**completion_kwargs)
+
+                # Track cost and tokens from this response
+                self._track_response_cost(response)
+
+                # Stream the response — accumulate text and tool_calls
+                # across ALL chunks, not just the last one.
+                full_text = ""
+                # Accumulate delta tool calls by index so we can merge partial
+                # chunks (id in first chunk, function name in second, arguments
+                # accumulating in subsequent chunks) into a single per-call object.
+                accumulated_by_index: dict[int, dict[str, Any]] = {}
+                try:
+                    for chunk in response:
+                        delta = chunk.choices[0].delta # type: ignore
+                        # Accumulate text content
+                        if delta.content:
+                            full_text += delta.content
+                            if on_text_chunk:
+                                on_text_chunk(delta.content)
+                        # Accumulate tool calls from any chunk
+                        if delta.tool_calls:
+                            for tc_delta in delta.tool_calls:
+                                idx = tc_delta.index  # type: ignore
+                                if idx not in accumulated_by_index:
+                                    accumulated_by_index[idx] = {
+                                        "id": tc_delta.id or "",
+                                        "type": tc_delta.type or "function",
+                                        "function_name": "",
+                                        "function_arguments": "",
+                                    }
+                                acc = accumulated_by_index[idx]
+                                if tc_delta.id is not None:
+                                    acc["id"] = tc_delta.id
+                                if tc_delta.function is not None:
+                                    if tc_delta.function.name:
+                                        acc["function_name"] = tc_delta.function.name
+                                    if tc_delta.function.arguments:
+                                        acc["function_arguments"] += (
+                                            tc_delta.function.arguments
+                                        )
+                except Exception:
+                    # Litellm's streaming iterator can crash on malformed responses
+                    # or sentinel markers like [DONE]. If iteration fails, just use
+                    # whatever text we accumulated so far.
+                    pass
+
+                # Reconstruct tool call dicts from accumulated chunks and validate
+                valid_tool_calls = []
+                for idx, acc in accumulated_by_index.items():
+                    if not acc.get("id") or not acc.get("function_name"):
+                        continue
+                    valid_tool_calls.append({
+                        "id": acc["id"],
+                        "type": acc["type"],
+                        "index": idx,
+                        "function": {
+                            "name": acc["function_name"],
+                            "arguments": acc["function_arguments"],
+                        },
+                    })
+
+                response_message = {
+                    "role": "assistant",
+                    "content": full_text or "",
+                }
+
+                # Attach only valid accumulated tool calls
+                if valid_tool_calls:
+                    response_message["tool_calls"] = valid_tool_calls
+
+                messages.append(response_message)
+
+                if full_text:
+                    final_text = full_text
+
+                if self._tool_budget_exhausted:
+                    break
 
-            if valid_tool_calls:
-                for tc_dict in valid_tool_calls:
-                    tool_name = str(tc_dict["function"]["name"])
-                    tool_call_obj = ToolCall(tool_name, {})
+                if valid_tool_calls:
+                    for tc_dict in valid_tool_calls:
+                        tool_name = str(tc_dict["function"]["name"])
+                        tool_call_obj = ToolCall(tool_name, {})
+
+                        try:
+                            tool_args = json.loads(tc_dict["function"]["arguments"])
+                        except (json.JSONDecodeError, AttributeError):
+                            tool_args = {}
+                            if self._status_callback is not None:
+                                self._status_callback(
+                                    AgentStatus.TOOL_CALL, tool_call_obj
+                                )
+                            if self._result_callback is not None:
+                                self._result_callback(
+                                    AgentStatus.TOOL_RESULT,
+                                    (
+                                        f"Error: Failed to parse arguments for "
+                                        f"tool '{tool_name}'."
+                                    ),
+                                    True,
+                                    tool_call_obj,
+                                )
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": tc_dict["id"],
+                                "name": tool_name,
+                                "content": (
+                                    f"Error: Failed to parse arguments for "
+                                    f"tool '{tool_name}'."
+                                ),
+                            })
+                            total_tool_calls += 1
+                            continue
+
+                        if self._allowed_dir is not None:
+                            for arg_name in ["path", "file_path"]:
+                                if arg_name in tool_args:
+                                    arg_path = Path(tool_args[arg_name])
+                                    try:
+                                        if arg_path.is_absolute():
+                                            raise ValueError(
+                                                "Access denied: "
+                                                "absolute paths are not allowed"
+                                            )
+                                        if ".." in arg_path.parts:
+                                            raise ValueError(
+                                                "Access denied: "
+                                                "paths with '..' are not allowed"
+                                            )
+                                        if not arg_path.is_absolute():
+                                            arg_path = Path(
+                                                self._allowed_dir
+                                            ) / arg_path
+                                        arg_path = arg_path.resolve()
+                                        if not arg_path.is_relative_to(
+                                            Path(self._allowed_dir).resolve()
+                                        ):
+                                            raise ValueError(
+                                                (
+                                                    f"Access denied: "
+                                                    f"'{arg_path}' is outside "
+                                                    f"allowed directory "
+                                                    f"'{self._allowed_dir}'"
+                                                )
+                                            )
+                                    except ValueError as e:
+                                        messages.append(
+                                            {
+                                                "role": "tool",
+                                                "tool_call_id": tc_dict["id"],
+                                                "name": tool_name,
+                                                "content": str(e),
+                                            }
+                                        )
+                                        continue
 
-                    try:
-                        tool_args = json.loads(tc_dict["function"]["arguments"])
-                    except (json.JSONDecodeError, AttributeError):
-                        tool_args = {}
+                        tool_call_obj = ToolCall(tool_name, tool_args)
+                        if self._status_callback is not None:
+                            self._status_callback(
+                                AgentStatus.TOOL_CALL, tool_call_obj
+                            )
+                        result = self.registry.execute(tool_name, **tool_args)
+                        result_str = str(result)
                         if self._status_callback is not None:
-                            self._status_callback(AgentStatus.TOOL_CALL, tool_call_obj)
+                            self._status_callback(
+                                AgentStatus.TOOL_RESULT, tool_call_obj
+                            )
                         if self._result_callback is not None:
+                            is_error = (
+                                "Error" in result_str
+                                or "Traceback" in result_str
+                            )
                             self._result_callback(
                                 AgentStatus.TOOL_RESULT,
-                                (
-                                    f"Error: Failed to parse arguments for "
-                                    f"tool '{tool_name}'."
-                                ),
-                                True,
+                                result_str,
+                                is_error,
                                 tool_call_obj,
                             )
-                        messages.append({
-                            "role": "tool",
-                            "tool_call_id": tc_dict["id"],
-                            "name": tool_name,
-                            "content": (
-                                f"Error: Failed to parse arguments for "
-                                f"tool '{tool_name}'."
-                            ),
-                        })
-                        total_tool_calls += 1
-                        continue
 
-                    if self._allowed_dir is not None:
-                        for arg_name in ["path", "file_path"]:
-                            if arg_name in tool_args:
-                                arg_path = Path(tool_args[arg_name])
-                                try:
-                                    if arg_path.is_absolute():
-                                        raise ValueError(
-                                            "Access denied: "
-                                            "absolute paths are not allowed"
-                                        )
-                                    if ".." in arg_path.parts:
-                                        raise ValueError(
-                                            "Access denied: "
-                                            "paths with '..' are not allowed"
-                                        )
-                                    if not arg_path.is_absolute():
-                                        arg_path = Path(self._allowed_dir) / arg_path
-                                    arg_path = arg_path.resolve()
-                                    if not arg_path.is_relative_to(
-                                        Path(self._allowed_dir).resolve()
-                                    ):
-                                        raise ValueError(
-                                            f"Access denied: '{arg_path}' is outside "
-                                            f"allowed directory '{self._allowed_dir}'"
-                                        )
-                                except ValueError as e:
-                                    messages.append(
-                                        {
-                                            "role": "tool",
-                                            "tool_call_id": tc_dict["id"],
-                                            "name": tool_name,
-                                            "content": str(e),
-                                        }
-                                    )
-                                    continue
-
-                    tool_call_obj = ToolCall(tool_name, tool_args)
-                    if self._status_callback is not None:
-                        self._status_callback(AgentStatus.TOOL_CALL, tool_call_obj)
-                    result = self.registry.execute(tool_name, **tool_args)
-                    result_str = str(result)
-                    if self._status_callback is not None:
-                        self._status_callback(AgentStatus.TOOL_RESULT, tool_call_obj)
-                    if self._result_callback is not None:
-                        is_error = "Error" in result_str or "Traceback" in result_str
-                        self._result_callback(
-                            AgentStatus.TOOL_RESULT, result_str, is_error, tool_call_obj
-                        )
-
-                    self._tool_budget_remaining -= 1
-                    if self._tool_budget_remaining <= 0:
-                        self._tool_budget_exhausted = True
-                        if self._status_callback is not None:
-                            self._status_callback(
-                                AgentStatus.BUDGET_EXHAUSTED, tool_call_obj
+                        self._tool_budget_remaining -= 1
+                        if self._tool_budget_remaining <= 0:
+                            self._tool_budget_exhausted = True
+                            if self._status_callback is not None:
+                                self._status_callback(
+                                    AgentStatus.BUDGET_EXHAUSTED, tool_call_obj
+                                )
+                            messages.append(
+                                {
+                                    "role": "tool",
+                                    "tool_call_id": tc_dict["id"],
+                                    "name": tool_name,
+                                    "content": str(result),
+                                }
                             )
+                            messages.append(
+                                {
+                                    "role": "user",
+                                    "content": (
+                                        "You have exhausted your tool budget. "
+                                        "Provide your final answer in plain text only. "
+                                        "Do not use any special formatting, tags, or "
+                                        "code markers. Just the answer."
+                                    ),
+                                }
+                            )
+                            total_tool_calls += 1
+                            continue
+
                         messages.append(
                             {
                                 "role": "tool",
@@ -746,61 +785,39 @@ class Agent:
                                 "content": str(result),
                             }
                         )
-                        messages.append(
-                            {
-                                "role": "user",
-                                "content": (
-                                    "You have exhausted your tool budget. "
-                                    "Provide your final answer in plain text only. "
-                                    "Do not use any special formatting, tags, or "
-                                    "code markers. Just the answer."
-                                ),
-                            }
-                        )
                         total_tool_calls += 1
-                        continue
+                        self._update_context_progress(messages)
+                    if total_tool_calls >= 30:
+                        break
+                    continue
 
+                # Model returned neither text content nor tool calls — re-prompt it
+                # to force an answer with the current context state.
+                if not full_text and (
+                    not response_message.get("tool_calls") or
+                    len(response_message.get("tool_calls", [])) == 0
+                ):
+                    if total_tool_calls >= 5:
+                        # After 5 empty responses, just give up and return empty
+                        break
                     messages.append(
                         {
-                            "role": "tool",
-                            "tool_call_id": tc_dict["id"],
-                            "name": tool_name,
-                            "content": str(result),
+                            "role": "user",
+                            "content": (
+                                "You returned an empty response with no tool calls. "
+                                "Please provide your answer now based on the current "
+                                "conversation state. Respond in plain text only."
+                            ),
                         }
                     )
                     total_tool_calls += 1
-                    self._update_context_progress(messages)
-                if total_tool_calls >= 30:
-                    break
-                continue
-
-            # Model returned neither text content nor tool calls — re-prompt it
-            # to force an answer with the current context state.
-            if not full_text and (
-                not response_message.get("tool_calls") or
-                len(response_message.get("tool_calls", [])) == 0
-            ):
-                if total_tool_calls >= 5:
-                    # After 5 empty responses, just give up and return empty
-                    break
-                messages.append(
-                    {
-                        "role": "user",
-                        "content": (
-                            "You returned an empty response with no tool calls. "
-                            "Please provide your answer now based on the current "
-                            "conversation state. Respond in plain text only."
-                        ),
-                    }
-                )
-                total_tool_calls += 1
-                continue
+                    continue
 
-            break
+                break
 
-        self._update_context_progress(messages)
-        self._history = [m for m in messages if m.get("role") != "system"]
-        return final_text or response_message.get("content", "") or ""
+            self._update_context_progress(messages)
+            self._history = [m for m in messages if m.get("role") != "system"]
+            return final_text or response_message.get("content", "") or ""
 
     def _update_context_progress(self, messages: list[dict[str, Any]]) -> None:
         """Estimate token usage and report progress via context_callback."""

{regcode-0.6.2 → regcode-0.6.3}/uv.lock

@@ -3805,7 +3805,7 @@ wheels = [
 
 [[package]]
 name = "regcode"
-version = "0.6.2"
+version = "0.6.3"
 source = { editable = "." }
 dependencies = [
     { name = "click" },