teddy-cli 0.2.2.dev1452__tar.gz → 0.2.2.dev1454__tar.gz

{teddy_cli-0.2.2.dev1452 → teddy_cli-0.2.2.dev1454}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.2.2.dev1452
+Version: 0.2.2.dev1454
 Summary: The local-first, test-driven agentic engineering harness. Because you should own the means of development.
 Author: Raphael Atteritano
 License: AGPL-3.0-only

{teddy_cli-0.2.2.dev1452 → teddy_cli-0.2.2.dev1454}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "teddy-cli"
-version = "0.2.2.dev1452"
+version = "0.2.2.dev1454"
 description = "The local-first, test-driven agentic engineering harness. Because you should own the means of development."
 readme = "README.md"
 keywords = [

{teddy_cli-0.2.2.dev1452 → teddy_cli-0.2.2.dev1454}/src/teddy_executor/adapters/inbound/session_cli_handlers.py

@@ -836,6 +836,11 @@ def handle_new_session(  # noqa: PLR0913
     _start_background_update_check()
 
     try:
+        # 0. An empty or whitespace-only -m means the flag was omitted: the
+        # interactive opening prompt fires, and pipeline mode errors on empty.
+        if message is not None and not message.strip():
+            message = None
+
         # 0. Pipeline mode requires an initial message
         if pipeline and message is None:
             raise ValueError(

{teddy_cli-0.2.2.dev1452 → teddy_cli-0.2.2.dev1454}/src/teddy_executor/adapters/outbound/litellm_adapter.py

@@ -1,4 +1,5 @@
 import logging
+import math
 from typing import Any, Dict, List, Optional, Protocol
 from teddy_executor.core.ports.outbound.config_service import IConfigService
 from teddy_executor.core.domain.models.exceptions import ConfigurationError
@@ -274,12 +275,25 @@ class LiteLLMAdapter(ILlmClient):
     def get_completion_cost(
         self, completion_response: Any, model_override: Optional[str] = None
     ) -> float:
-        """Calculates the precise USD cost of a completion response."""
+        """Calculates the precise USD cost of a completion response.
+
+        Prefers the cost the provider already reported on the response (litellm
+        stores it in ``_hidden_params["response_cost"]``) because it reflects the
+        vendor that actually served the request. Falls back to the registry
+        recompute when no reported cost is present.
+        """
+        reported = self._reported_cost(completion_response)
+        if reported is not None:
+            self._mark_cost_recorded(completion_response)
+            return reported
+
         litellm = self._get_litellm()
         try:
-            return float(
+            cost = float(
                 litellm.completion_cost(completion_response=completion_response)
             )
+            self._mark_cost_recorded(completion_response)
+            return cost
         except (Exception, TypeError) as e:
             if "This model isn't mapped yet" in str(e) and self._hydrator:
                 candidates = set()
@@ -291,11 +305,13 @@ class LiteLLMAdapter(ILlmClient):
 
                 if self._hydrate_all_candidates(candidates):
                     try:
-                        return float(
+                        cost = float(
                             litellm.completion_cost(
                                 completion_response=completion_response
                             )
                         )
+                        self._mark_cost_recorded(completion_response)
+                        return cost
                     except (Exception, TypeError) as retry_error:
                         self._log_cost_failure(
                             retry_error, completion_response, model_override
@@ -306,6 +322,70 @@ class LiteLLMAdapter(ILlmClient):
             self._log_cost_failure(e, completion_response, model_override)
             return 0.0
 
+    def _reported_cost(self, completion_response: Any) -> Optional[float]:
+        """Returns the cost the provider reported on the response, if any.
+
+        litellm writes the vendor-reported spend to
+        ``_hidden_params["response_cost"]``; when that key is absent, the same
+        reported spend may instead be carried by the OpenRouter response-cost
+        header under ``_hidden_params["additional_headers"]``, exactly as the
+        litellm ``get_response_cost_from_hidden_params`` helper reads it. A
+        non-dict holder, an absent key, a ``None`` value, or an unconvertible or
+        non-finite value all mean "no reported cost" from that source, so the
+        read falls through to the next source and ultimately the recompute. A
+        ``0.0`` reported cost is a valid free-model price and is returned as-is.
+        """
+        hidden = getattr(completion_response, "_hidden_params", None)
+        if not isinstance(hidden, dict):
+            return None
+
+        direct = self._finite_cost(hidden.get("response_cost"))
+        if direct is not None:
+            return direct
+
+        additional_headers = hidden.get("additional_headers")
+        if isinstance(additional_headers, dict):
+            header_cost = self._finite_cost(
+                additional_headers.get("llm_provider-x-litellm-response-cost")
+            )
+            if header_cost is not None:
+                return header_cost
+
+        return None
+
+    @staticmethod
+    def _finite_cost(value: Any) -> Optional[float]:
+        """Converts a reported value to a finite float, or None when unusable.
+
+        A ``NaN`` or infinite reported cost cannot be a spend, so it is treated
+        as absent. The graph at the call site depends only on which price source
+        is authoritative, never on a non-finite anomaly.
+        """
+        if value is None:
+            return None
+        try:
+            number = float(value)
+        except (TypeError, ValueError):
+            return None
+        return number if math.isfinite(number) else None
+
+    @staticmethod
+    def _mark_cost_recorded(completion_response: Any) -> None:
+        """Flags the response so the display can trust the recorded cost.
+
+        A real price was used whenever a reported value is returned or the
+        registry recompute succeeds, including a valid free-model ``0.0``. The
+        fallback ``0.0`` (a recompute failure) is deliberately NOT marked, so
+        the display keeps its ``$???`` placeholder for a genuinely unpriced
+        model. A response that forbids attribute assignment still yields its
+        cost; only the display hint is lost.
+        """
+        try:
+            completion_response._teddy_cost_recorded = True
+        except (AttributeError, TypeError):
+            # Only the display hint is affected; the cost itself is unaffected.
+            pass
+
     def _log_cost_failure(
         self, error: Exception, completion_response: Any, model_override: Optional[str]
     ) -> None:
@@ -347,12 +427,20 @@ class LiteLLMAdapter(ILlmClient):
     def _resolve_cost_model(
         self, completion_response: Any, model_override: Optional[str]
     ) -> Optional[str]:
-        """Resolves the model identity used by cost-failure diagnostics."""
-        if model_override:
-            return str(model_override)
+        """Resolves the model identity used by cost-failure diagnostics.
+
+        Prefers ``completion_response.model`` because that is the identity the
+        registry recompute actually prices against. A configured override names
+        the routing alias (e.g. ``openrouter/foo``), which need not be present in
+        the registry, so naming it would both mislabel the anomaly summary and
+        pick the wrong log tier — silently downgrading a real priced-model
+        failure to DEBUG instead of WARNING.
+        """
         model_id = getattr(completion_response, "model", None)
         if model_id:
             return str(model_id)
+        if model_override:
+            return str(model_override)
         config_model = self._config_service.get_setting("llm.model")
         return str(config_model) if config_model else None
 

{teddy_cli-0.2.2.dev1452 → teddy_cli-0.2.2.dev1454}/src/teddy_executor/core/services/execution_orchestrator.py

@@ -97,6 +97,24 @@ class ExecutionOrchestrator(IRunPlanUseCase):
                     halt_execution = True
         return action_logs
 
+    def _emit_preexecuted_console_log(
+        self, action: ActionData, action_log: ActionLog
+    ) -> None:
+        """Emit the console lines a freshly dispatched action would log.
+
+        Actions executed manually in the TUI run silently, so on plan
+        submission the orchestrator re-emits the same progress lines
+        ``ActionDispatcher`` logs for freshly dispatched actions
+        (``{ACTION} - {description}`` then the uppercase status). MESSAGE
+        actions stay silent, matching the dispatcher.
+        """
+        action_name = action.type.upper()
+        if action_name == "MESSAGE":
+            return
+        log_desc = f" - {action.description}" if action.description else ""
+        logger.info(f"{action_name}{log_desc}")
+        logger.info(action_log.status.value.upper())
+
     def _handle_action_in_loop(
         self,
         action: ActionData,
@@ -116,6 +134,7 @@ class ExecutionOrchestrator(IRunPlanUseCase):
             )
 
         if action.executed and action.action_log:
+            self._emit_preexecuted_console_log(action, action.action_log)
             should_halt = (
                 action.action_log.status == ActionStatus.FAILURE
                 and not action.params.get("allow_failure")

{teddy_cli-0.2.2.dev1452 → teddy_cli-0.2.2.dev1454}/src/teddy_executor/core/services/planning_service.py

@@ -98,6 +98,13 @@ class PlanningService(IPlanningUseCase):
             lambda: self._run_planning_phase(messages, model, meta)
         )
 
+        # Persist the explicit recorded-cost signal (Option B): a real price was
+        # used for this turn whenever the adapter marked the response, so a
+        # later turn can show the accumulated figure even for an unpriced model.
+        # The `is True` guard keeps an auto-specced Mock response from counting.
+        if getattr(response, "_teddy_cost_recorded", False) is True:
+            meta["cost_recorded"] = True
+
         cost_val = self._prompt_manager.log_telemetry(token_count, turn_cost)
         plan_path = (turn_path / "plan.md").as_posix()
         self._file_system_manager.write_file(plan_path, plan_content)
@@ -229,9 +236,13 @@ class PlanningService(IPlanningUseCase):
         )
 
         pricing_supported = self._llm_client.supports_pricing(model=model)
+        # Option B: gate on an explicit recorded-cost signal, never on
+        # `cumulative_cost > 0`, because a free model legitimately records 0.0
+        # and cannot be distinguished from "no cost" by cost > 0.
+        cost_recorded = meta.get("cost_recorded") is True
         cost_str = (
             f"${cumulative_cost:.4f}"
-            if context_window > 0 and pricing_supported
+            if context_window > 0 and (pricing_supported or cost_recorded)
             else "$???"
         )
         self._user_interactor.display_message(

{teddy_cli-0.2.2.dev1452 → teddy_cli-0.2.2.dev1454}/src/teddy_executor/core/services/session_lifecycle_manager.py

@@ -21,6 +21,11 @@ from teddy_executor.core.utils.markdown import embed_in_fence
 
 logger = logging.getLogger(__name__)
 
+# The prompt shown when a resume injects a present-but-blank `-m` and the run is
+# interactive. Mirrors the start-boundary opening prompt so both entry points
+# present the same question.
+_NEXT_INSTRUCTION_PROMPT = "What are we working on?"
+
 if TYPE_CHECKING:
     from teddy_executor.core.domain.models.planning_ports import (
         SessionPorts,
@@ -106,6 +111,42 @@ class SessionLifecycleManager:
                 )
             return (session_name, report)
 
+        if state in (SessionState.EMPTY, SessionState.COMPLETE_TURN):
+            return self._resume_ready_turn(
+                session_name,
+                state,
+                turn_path,
+                orchestrator,
+                interactive,
+                project_context,
+                pipeline,
+                message,
+            )
+
+        return (session_name, None)
+
+    def _resume_ready_turn(  # noqa: PLR0913  # threads the resume state-machine inputs
+        self,
+        session_name: str,
+        state: SessionState,
+        turn_path: str,
+        orchestrator: IRunPlanUseCase,
+        interactive: bool,
+        project_context: Optional[Any],
+        pipeline: bool,
+        message: Optional[str],
+    ) -> tuple[str, Optional[ExecutionReport]]:
+        """Drive resume for an EMPTY or COMPLETE_TURN session ready to plan.
+
+        A present-but-blank message is resolved first (interactive prompt, empty
+        reply terminates; non-interactive normalizes to absent). An EMPTY turn
+        appends the message to the initial request or the previous report, then
+        plans in place. A COMPLETE_TURN turn appends a ``## User Request``
+        section, transitions to the next turn, then plans.
+        """
+        message, terminated = self._resolve_blank_message(message, interactive)
+        if terminated:
+            return (session_name, None)
         if state == SessionState.EMPTY:
             if message:
                 if Path(turn_path).name == "01":
@@ -120,22 +161,38 @@ class SessionLifecycleManager:
                 pipeline=pipeline,
                 message=message,
             )
+        if message:
+            self._append_user_request(turn_path, message)
+        next_turn_dir = self._session_service.transition_to_next_turn(
+            plan_path=f"{turn_path}/plan.md"
+        )
+        return self._handle_planning_and_execution(
+            next_turn_dir,
+            orchestrator,
+            interactive,
+            project_context=project_context,
+            message=message,
+        )
 
-        if state == SessionState.COMPLETE_TURN:
-            if message:
-                self._append_user_request(turn_path, message)
-            next_turn_dir = self._session_service.transition_to_next_turn(
-                plan_path=f"{turn_path}/plan.md"
-            )
-            return self._handle_planning_and_execution(
-                next_turn_dir,
-                orchestrator,
-                interactive,
-                project_context=project_context,
-                message=message,
-            )
+    def _resolve_blank_message(
+        self, message: Optional[str], interactive: bool
+    ) -> tuple[Optional[str], bool]:
+        """Resolve a present-but-blank message in the EMPTY/COMPLETE_TURN branches.
 
-        return (session_name, None)
+        A blank ``-m`` must not seed a turn with no real instruction. When the
+        run is interactive, the user is prompted for the next instruction and an
+        empty reply terminates the session (abort idiom, reported by ``True``).
+        A non-interactive run cannot block, so the message normalizes to absent.
+        A present-and-non-blank or absent message is returned unchanged.
+        """
+        if message is None or message.strip():
+            return message, False
+        if not interactive:
+            return None, False
+        reply = self._user_interactor.ask_question(_NEXT_INSTRUCTION_PROMPT)
+        if not reply or not reply.strip():
+            return None, True
+        return reply, False
 
     def _parse_pending_plan(
         self, turn_path: str, plan_path: str, message: Optional[str]

{teddy_cli-0.2.2.dev1452 → teddy_cli-0.2.2.dev1454}/src/teddy_executor/core/services/session_service.py

@@ -488,6 +488,11 @@ class SessionService(ISessionManager):
             if key in current_meta:
                 meta[key] = current_meta[key]
 
+        # A recorded cost stays recorded for the rest of the session, so an
+        # unpriced model keeps showing its accumulated figure, not "$???".
+        if current_meta.get("cost_recorded") is True:
+            meta["cost_recorded"] = True
+
         if is_validation_failure:
             meta["is_replan"] = True
             if "user_request" in current_meta: