regcode 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

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.1.0"
+__version__ = "0.4.0"

regcode/cli.py

@@ -61,6 +61,7 @@ def chat(model, config_path, stream, full, no_color):
         status_callback=ui.handle_status,
         result_callback=ui.handle_result,
         context_callback=ui.set_context_progress,
+        cost_callback=ui.handle_cost,
     )
 
     # Attach agent to the Textual app

regcode/config.py

@@ -44,7 +44,15 @@ default_system_prompt = dedent(
 logger = logging.getLogger(__name__)
 
 class AgentConfig(BaseModel):
-    model_config = ConfigDict(extra="allow")
+    """Configuration specific to the agent's behavior (not provider params).
+
+    Model, temperature, max_tokens belong in ProviderConfig where
+    litellm.completion expects them. AgentConfig only holds compaction
+    and context-window tuning — passing model params through this object
+    caused conflicts with different providers.
+    """
+
+    model_config = ConfigDict(extra="forbid")
     context_window: int = 128000
     compaction_threshold: float = 0.8  # Compact when context > 80% of window
     enable_compaction: bool = True
@@ -81,11 +89,30 @@ class SandboxConfig(BaseModel):
     type_check: bool = True
     allowed_imports: list[str] = []
 
+class TracingConfig(BaseModel):
+    """Configuration for tracing and logging."""
+
+    model_config = ConfigDict(extra="allow")
+    enable_tracing: bool = False
+    mlflow_url: str | None = None
+    mlflow_experiment_name: str | None = None
+    mlflow_async: bool = True
+    mlflow_requires_auth: bool = True
+    mlflow_username: str | None = None
+    mlflow_password: str | None = None
+
+    def tracing_enabled(self) -> bool:
+        """Check if tracing is fully configured and enabled."""
+        return (
+            self.enable_tracing
+            and self.mlflow_url is not None
+        )
 
 class Config(BaseModel):
     model_config = ConfigDict(extra="allow")
 
     agent: AgentConfig = AgentConfig()
+    tracing: TracingConfig = TracingConfig()
     provider: ProviderConfig = ProviderConfig()
     system_prompt: str = default_system_prompt
     tools: dict = {}
@@ -96,19 +123,29 @@ class Config(BaseModel):
     @classmethod
     def load(cls, path: str | None = None) -> "Config":
         # get default home dir for user first
+        _path = None
         if path is None:
-            logger.warning(
-                "No config path provided, looking for ~/.regcode/config.yaml"
-            )
-            alt_config_path = Path.home() / ".regcode" / "config.yaml"
-            if alt_config_path.exists():
-                logger.warning(f"Loading from config at {alt_config_path}")
-                _path = alt_config_path
-            else:
-                _path = Path("config.yaml")
+            possible_paths = [
+                Path("./config.yaml"), Path.home() / ".regcode" / "config.yaml"
+            ]
+            for p in possible_paths:
+                if p.exists():
+                    logger.info(f"Loading from config at {p}")
+                    _path = p
+                    break
+            if _path is None:
+                logger.warning(
+                    "No config file found, using default config, "
+                    "Use `regcode configure` to configure."
+                    )
+                return cls()
         else:
             _path = Path(path)
         if not _path.exists():
+            logger.warning(
+                f"Config file {path} not found, using default config, "
+                "Use `regcode configure` to configure."
+            )
             return cls()
         with open(_path) as f:
             data = yaml.safe_load(f)
@@ -135,17 +172,6 @@ class Config(BaseModel):
         result = self.provider.model_dump()
         if extra_kwargs:
             result.update(extra_kwargs)
-        # Agent-level config overrides provider defaults for known keys
-        if self.agent.context_window is not None:
-            result["context_window"] = self.agent.context_window
-        if hasattr(self.agent, "compaction_threshold"):
-            result["compaction_threshold"] = self.agent.compaction_threshold
-        if hasattr(self.agent, "enable_compaction"):
-            result["enable_compaction"] = self.agent.enable_compaction
-        # Apply agent-level extra fields (e.g. model, max_tokens, temperature
-        # from YAML agent section) as overrides over provider defaults
-        if hasattr(self.agent, "model_extra") and self.agent.model_extra:
-            result.update(self.agent.model_extra)
         return result
 
 

regcode/main.py

@@ -19,7 +19,9 @@ from regcode.tools.base import ToolResult
 from regcode.tools.builtins import create_default_tools
 from regcode.tools.registry import ToolRegistry
 from regcode.tools.review_notes import AddReviewNoteTool, ReadReviewNotesTool
+from regcode.tracing import setup_mlflow_tracing
 
+setup_mlflow_tracing()
 
 class _SafeEncoder(json.JSONEncoder):
     def default(self, o):
@@ -33,6 +35,7 @@ class AgentStatus(Enum):
 
     TOOL_CALL = "tool_call"
     TOOL_RESULT = "tool_result"
+    COMPACTION_START = "compaction_start"
     IDLE = "idle"
     BUDGET_EXHAUSTED = "budget_exhausted"
 
@@ -63,6 +66,7 @@ class Agent:
         )
         | None = None,
         context_callback: Callable[[int, int], None] | None = None,
+        cost_callback: Callable[[float, int | None], None] | None = None,
     ) -> None:
         self.config = config or Config.load()
         self.system_prompt = self.config.system_prompt
@@ -71,10 +75,13 @@ class Agent:
         self._status_callback = status_callback
         self._result_callback = result_callback
         self._context_callback = context_callback
+        self._cost_callback = cost_callback
         self._allowed_dir = directory
         self._tool_budget = self.config.tool_budget
         self._tool_budget_remaining = self._tool_budget
         self._tool_budget_exhausted = False
+        self._cumulative_cost: float = 0.0
+        self._total_tokens: int = 0
 
         # Context window manager
         self.context_manager = ConversationManager()
@@ -212,6 +219,8 @@ class Agent:
             self.config.agent.enable_compaction
             and self.context_manager.should_compact()
         ):
+            if self._status_callback is not None:
+                self._status_callback(AgentStatus.COMPACTION_START, None)
             self.context_manager.compact()
             messages = self.context_manager.get_messages()
 
@@ -249,6 +258,9 @@ class Agent:
 
             response = litellm.completion(**completion_kwargs)
 
+            # Track cost and tokens from this response
+            self._track_response_cost(response)
+
             choice = response.choices[0] # type: ignore
             message_obj = choice.message
             response_message = {
@@ -510,6 +522,9 @@ class Agent:
 
             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 = ""
@@ -750,6 +765,36 @@ class Agent:
         except Exception:
             pass
 
+    def _track_response_cost(self, response) -> None:
+        """Track cost and token usage from a litellm completion response."""
+        if self._cost_callback is None:
+            return
+        try:
+            # Try to get cost from _hidden_params first
+            cost = 0.0
+            if hasattr(response, "_hidden_params") and response._hidden_params:
+                cost = response._hidden_params.get("response_cost", 0.0) or 0.0
+            # Fallback: compute from usage if available
+            if cost == 0.0 and hasattr(response, "usage") and response.usage:
+                usage = response.usage
+                prompt_tokens = getattr(usage, "prompt_tokens", 0) or 0
+                completion_tokens = getattr(usage, "completion_tokens", 0) or 0
+                total_tokens = getattr(usage, "total_tokens", 0) or 0
+                self._total_tokens += total_tokens
+                # Use litellm's cost calculator for the current model
+                try:
+                    cost = litellm.completion_cost(
+                        model=self.config.provider.model,
+                        prompt_tokens=prompt_tokens,
+                        completion_tokens=completion_tokens,
+                    )
+                except (KeyError, Exception):
+                    cost = 0.0
+            self._cumulative_cost += cost
+            self._cost_callback(self._cumulative_cost, self._total_tokens)
+        except Exception:
+            pass
+
     def reset(self) -> None:
         """Clear conversation history."""
         self._history = []