teddy-cli 0.1.17.dev1396__tar.gz → 0.1.17.dev1397__tar.gz

{teddy_cli-0.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.1.17.dev1396
+Version: 0.1.17.dev1397
 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.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/pyproject.toml

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

{teddy_cli-0.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/src/teddy_executor/__main__.py

@@ -112,31 +112,6 @@ def _resolve_setup_api_key(
     return system_env.isatty() and not pipeline
 
 
-def _run_init_setup_gates(container) -> None:
-    """Run the interactive setup gates after ``teddy init`` scaffolding.
-
-    Bare ``teddy init`` and ``teddy init config`` scaffold (or reset) the
-    ``.teddy`` configuration, then run the SAME one-time setup as ``teddy
-    start``: the required LLM API-key prompt (when the key is missing and the
-    configured model requires one) and the optional editor selection (when no
-    editor is configured). Both gates reuse the existing preflight helpers, so
-    no prompt logic is duplicated. The gates are TTY-gated: a non-interactive
-    run (stdin is not a TTY) prompts for neither, keeping automated and CI
-    invocations clean.
-    """
-    from teddy_executor.adapters.inbound.session_cli_handlers import (
-        _ensure_api_key_configured,
-        _validate_editor_config,
-    )
-
-    system_env = container.resolve(ISystemEnvironment)
-    if not system_env.isatty():
-        return
-    config_service = container.resolve(IConfigService)
-    _ensure_api_key_configured(config_service, setup_api_key=True)
-    _validate_editor_config(container)
-
-
 def _display_init_drift(container) -> None:
     """Print the prompt/template drift advice after bare ``teddy init``.
 
@@ -144,8 +119,7 @@ def _display_init_drift(container) -> None:
     "unchanged" summary cannot mislead: it flags drifted prompts and missing
     templates and names the actionable ``teddy init prompts`` /
     ``teddy init templates`` commands. The two shared helpers are imported
-    lazily, mirroring ``_run_init_setup_gates``, and they are advisory only --
-    they never block the command.
+    lazily, and they are advisory only -- they never block the command.
     """
     from teddy_executor.adapters.inbound.session_cli_handlers import (
         _display_checks_footer,
@@ -262,9 +236,6 @@ def start(  # noqa: PLR0913
         ),
     ),
     model: Optional[str] = typer.Option(None, "--model", help="LLM model override."),
-    api_key: Optional[str] = typer.Option(
-        None, "--api-key", help="LLM API key override."
-    ),
     max_turns: Optional[int] = OPT_MAX_TURNS,
     max_cost: Optional[float] = OPT_MAX_COST,
 ):
@@ -297,7 +268,6 @@ def start(  # noqa: PLR0913
         pipeline=pipeline,
         additional_context=additional_context,
         model=model,
-        api_key=api_key,
         max_turns=max_turns,
         max_cost=max_cost,
     )
@@ -326,7 +296,6 @@ def init_callback(ctx: typer.Context):
     summary = init_use_case.ensure_initialized()
     typer.echo(f"TeDDy initialized in .teddy folder. {summary}")
     _display_init_drift(container)
-    _run_init_setup_gates(container)
 
 
 @init_app.command()
@@ -353,7 +322,6 @@ def config():
     init_use_case = container.resolve(IInitUseCase)
     status = init_use_case.ensure_config_initialized(overwrite=True)
     typer.echo(status)
-    _run_init_setup_gates(container)
 
 
 @init_app.command()
@@ -542,9 +510,6 @@ def resume(  # noqa: PLR0913
     ),
     no_copy: bool = OPT_NO_COPY,
     model: Optional[str] = typer.Option(None, "--model", help="LLM model override."),
-    api_key: Optional[str] = typer.Option(
-        None, "--api-key", help="LLM API key override."
-    ),
     agent: Optional[str] = typer.Option(
         None,
         "--agent",
@@ -587,7 +552,6 @@ def resume(  # noqa: PLR0913
         setup_api_key=_resolve_setup_api_key(system_env, pipeline=pipeline),
         no_copy=no_copy,
         model=model,
-        api_key=api_key,
         agent=agent,
         message=message,
         pipeline=pipeline,

{teddy_cli-0.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/src/teddy_executor/adapters/inbound/session_cli_handlers.py

@@ -666,7 +666,6 @@ def handle_new_session(  # noqa: PLR0913
     pipeline: bool = False,
     additional_context: Optional[list[str]] = None,
     model: Optional[str] = None,
-    api_key: Optional[str] = None,
     setup_editor: Optional[bool] = None,
     setup_api_key: Optional[bool] = None,
     max_turns: Optional[int] = None,
@@ -712,7 +711,6 @@ def handle_new_session(  # noqa: PLR0913
             initial_request=message,
             additional_context=additional_context or [],
             model=model,
-            api_key=api_key,
         )
         session_dir = session_manager.create_session(options)
         typer.echo(f"Session created at: {session_dir}")
@@ -790,8 +788,7 @@ def _run_cli_preflight_check(
 
     # API-key setup runs BEFORE the LLM client is resolved so its transient
     # config-service instance reads the freshly-persisted on-disk state. The
-    # gate itself is single-sourced in ``_ensure_api_key_configured`` so the
-    # ``init`` command shares identical gating.
+    # gate itself is single-sourced in ``_ensure_api_key_configured``.
     config_service = container.resolve(IConfigService)
     _ensure_api_key_configured(config_service, setup_api_key)
 
@@ -829,20 +826,24 @@ def _ensure_api_key_configured(
     config_service: IConfigService,
     setup_api_key: Optional[bool],
 ) -> None:
-    """Runs the interactive API-key gate when the key is missing and required.
-
-    The gate fires only when ``setup_api_key`` is truthy, the resolved
-    ``llm.api_key`` is absent or blank, AND the configured model actually
-    requires a provider key (key-requiredness is delegated to litellm). It is
-    ADDITIVE and inert by default (``setup_api_key`` of ``None``/``False`` ->
-    skip), so callers that never opt in are unaffected. Single-sourced so
-    ``_run_cli_preflight_check`` and the ``init`` command share identical gating.
+    """Runs the API-key gate when the key is missing and a key may be required.
+
+    The gate fires only when ``setup_api_key`` is truthy and the resolved
+    ``llm.api_key`` is absent or blank. A local endpoint short-circuits the
+    prompt with a persisted placeholder key, because a server on the developer
+    machine never needs a real credential. Otherwise the interactive prompt
+    fires when the configured model actually requires a provider key
+    (key-requiredness is delegated to litellm). It is ADDITIVE and inert by
+    default (``setup_api_key`` of ``None``/``False`` -> skip), so callers that
+    never opt in are unaffected. Single-sourced so both session entry points
+    share identical gating.
     """
-    if (
-        setup_api_key
-        and _is_llm_api_key_missing(config_service)
-        and _llm_model_requires_api_key(config_service)
-    ):
+    if not setup_api_key or not _is_llm_api_key_missing(config_service):
+        return
+    if _is_local_endpoint(config_service):
+        _persist_local_placeholder_key(config_service)
+        return
+    if _llm_model_requires_api_key(config_service):
         _prompt_for_api_key(config_service)
 
 
@@ -895,29 +896,49 @@ def _prompt_for_api_key(config_service: IConfigService) -> None:
     The key is written to ``.teddy/.env`` (never ``os.environ``) and the config
     is migrated to the ``${TEDDY_LLM_API_KEY}`` interpolation form so the
     transient ``IConfigService`` instance held by ``ILlmClient`` resolves it on
-    the same run. A truly empty entry re-prompts (Click's native loop, now that
-    no default is supplied); a whitespace-only entry is ignored, and an aborted
+    the same run. The warning names the resolved provider and the stripped model
+    so the user knows which credential to paste. An empty line skips the prompt
+    with a notice, a whitespace-only entry persists nothing, and an aborted
     prompt (Ctrl-C / Ctrl-D) returns WITHOUT raising so the downstream
     validation error can surface the missing key with its own hint.
     """
+    provider, model = _resolve_model_identity(config_service)
+    api_base = config_service.get_setting("llm.api_base")
+    remote_api_base = (
+        api_base if isinstance(api_base, str) and api_base.strip() else None
+    )
+
     typer.echo("", err=True)
     typer.secho("LLM API Key", fg=typer.colors.CYAN, bold=True, err=True)
     typer.echo("", err=True)
-    typer.secho(
-        "\u26a0 No LLM API key configured. Paste your key below.\n"
-        "OpenRouter is the default provider. To use a different provider, change llm.model in .teddy/config.yaml.",
-        fg=typer.colors.YELLOW,
-        err=True,
-    )
+    warning_lines = ["\u26a0 No LLM API key configured."]
+    if remote_api_base:
+        warning_lines.append(f"  Endpoint: {remote_api_base}")
+    elif provider:
+        warning_lines.append(f"  Provider: {provider}")
+    if model:
+        warning_lines.append(f"  Model:    {model}")
+    typer.secho("\n".join(warning_lines), fg=typer.colors.YELLOW, err=True)
+    typer.echo("", err=True)
+
+    instructions = ["Paste your key below, or press Enter on an empty line to skip."]
+    if not remote_api_base:
+        instructions.append(
+            "To use a different provider, change llm.model in .teddy/config.yaml."
+        )
+    typer.secho("\n".join(instructions), fg=typer.colors.YELLOW, err=True)
     typer.echo("", err=True)
 
     try:
-        value = typer.prompt("LLM API key", hide_input=True)
+        value = typer.prompt(
+            "LLM API key", hide_input=True, default="", show_default=False
+        )
     except (EOFError, typer.Abort):
         return
 
     value = value.strip()
     if not value:
+        typer.secho("\u2139 No key saved.", fg=typer.colors.YELLOW, err=True)
         return
 
     config_service.set_env_variable("TEDDY_LLM_API_KEY", value)
@@ -930,6 +951,121 @@ def _prompt_for_api_key(config_service: IConfigService) -> None:
     )
 
 
+def _resolve_model_identity(
+    config_service: IConfigService,
+) -> tuple[Optional[str], str]:
+    """Resolves the provider name and the prefix-stripped model for the prompt.
+
+    litellm is the single source of truth for provider resolution. A failed
+    resolution prints the provider list to stdout, so the call runs inside a
+    stdout redirect. An unresolvable model falls back to the configured string
+    with no provider, so the prompt still shows which model the key belongs to.
+    """
+    import contextlib
+    import io
+    import logging
+
+    model = config_service.get_setting("llm.model")
+    if not (isinstance(model, str) and model.strip()):
+        return None, ""
+    api_base = config_service.get_setting("llm.api_base")
+    resolved_api_base = (
+        api_base if isinstance(api_base, str) and api_base.strip() else None
+    )
+    try:
+        import litellm
+
+        with contextlib.redirect_stdout(io.StringIO()):
+            resolved_model, provider, _dynamic_key, _resolved_base = (
+                litellm.get_llm_provider(model, api_base=resolved_api_base)
+            )
+        return str(provider), str(resolved_model)
+    except Exception:
+        logging.getLogger(__name__).warning(
+            "Could not resolve a provider for model '%s'; showing the configured "
+            "name instead.",
+            model,
+            exc_info=True,
+        )
+        return None, model.strip()
+
+
+_LOCAL_PLACEHOLDER_KEY = "dummy-key-custom-endpoints"
+
+
+def _is_local_endpoint(config_service: IConfigService) -> bool:
+    """True when ``llm.api_base`` points at the developer machine.
+
+    A local host means no real credential can be required, so the gate writes a
+    placeholder instead of prompting. Host classification performs no DNS
+    lookup, so an unresolvable name never blocks startup.
+    """
+    api_base = config_service.get_setting("llm.api_base")
+    if not (isinstance(api_base, str) and api_base.strip()):
+        return False
+    return _host_is_local(_api_base_host(api_base))
+
+
+def _api_base_host(api_base: str) -> Optional[str]:
+    """Extracts the host from an ``api_base`` value, tolerating a missing scheme."""
+    from urllib.parse import urlsplit
+
+    value = api_base.strip()
+    candidate = value if "://" in value else f"//{value}"
+    try:
+        return urlsplit(candidate).hostname
+    except ValueError:
+        return None
+
+
+def _host_is_local(host: Optional[str]) -> bool:
+    """True when a host names the developer machine or a private network.
+
+    Loopback names, the ``host.docker.internal`` alias, and ``.local`` names all
+    address the developer machine. Loopback, link-local, and private address
+    ranges cannot be a public provider. No DNS lookup runs, so an unresolvable
+    name never blocks startup.
+    """
+    import ipaddress
+
+    if not host:
+        return False
+    normalized = host.strip("[]").casefold()
+    if normalized == "localhost" or normalized.endswith(".localhost"):
+        return True
+    if normalized == "host.docker.internal" or normalized.endswith(".local"):
+        return True
+    try:
+        address = ipaddress.ip_address(normalized)
+    except ValueError:
+        return False
+    return address.is_loopback or address.is_link_local or address.is_private
+
+
+def _persist_local_placeholder_key(config_service: IConfigService) -> None:
+    """Writes the placeholder key for a local endpoint and prints the notice (stderr).
+
+    The placeholder is written to ``.teddy/.env`` and the config migrates to the
+    ``${TEDDY_LLM_API_KEY}`` interpolation form, mirroring the interactive
+    prompt path so a server that checks the Authorization header still starts.
+    """
+    config_service.set_env_variable("TEDDY_LLM_API_KEY", _LOCAL_PLACEHOLDER_KEY)
+    config_service.set_setting("llm.api_key", "${TEDDY_LLM_API_KEY}")
+    api_base = config_service.get_setting("llm.api_base") or ""
+    typer.echo("", err=True)
+    typer.secho(
+        f"\u2139 Local endpoint detected: {api_base}",
+        fg=typer.colors.CYAN,
+        err=True,
+    )
+    typer.secho(
+        f'  Saved placeholder API key "{_LOCAL_PLACEHOLDER_KEY}" to .teddy/.env.\n'
+        "  Replace TEDDY_LLM_API_KEY there if the server checks the Authorization header.",
+        fg=typer.colors.YELLOW,
+        err=True,
+    )
+
+
 def _persist_editor_choice(config_service: IConfigService, value: str) -> None:
     """Persists the editor choice and prints the green save confirmation (stderr)."""
     config_service.set_setting("editor", value)
@@ -1167,7 +1303,6 @@ def _sync_and_display_session_meta(
     container: Container,
     session_name: str,
     model: Optional[str] = None,
-    api_key: Optional[str] = None,
     agent: Optional[str] = None,
 ) -> None:
     """Reads latest turn meta.yaml, syncs config overrides, and clears actual_model.
@@ -1201,9 +1336,6 @@ def _sync_and_display_session_meta(
     elif config_model != "unknown" and meta.get("model") != config_model:
         meta["model"] = config_model
         changed = True
-    if api_key:
-        meta["api_key"] = api_key
-        changed = True
     if changed:
         repository.save_meta(f"{latest_turn_path}/meta.yaml", meta)
 
@@ -1214,7 +1346,6 @@ def handle_resume_session(  # noqa: PLR0913
     interactive: bool = True,
     no_copy: bool = False,
     model: Optional[str] = None,
-    api_key: Optional[str] = None,
     agent: Optional[str] = None,
     message: Optional[str] = None,
     pipeline: bool = False,
@@ -1240,7 +1371,7 @@ def handle_resume_session(  # noqa: PLR0913
 
         # 3. Display actual_model and sync config overrides
         _sync_and_display_session_meta(
-            container, session_name, model=model, api_key=api_key, agent=agent
+            container, session_name, model=model, agent=agent
         )
 
         # 4. Display session path (below the Agent/Model identity block).

{teddy_cli-0.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/src/teddy_executor/adapters/outbound/litellm_adapter.py

@@ -108,7 +108,9 @@ class LiteLLMAdapter(ILlmClient):
             resolved = "gpt-4o"
         return str(resolved)
 
-    def get_completion(
+    # Request, retry, and hydration form one linear flow whose branching is
+    # inherent to the provider protocol. Extracting it is outside this change.
+    def get_completion(  # noqa: C901
         self, messages: List[Dict[str, str]], model: Optional[str] = None, **kwargs: Any
     ) -> Any:
         """
@@ -414,29 +416,82 @@ class LiteLLMAdapter(ILlmClient):
                 "(or your shell environment)."
             )
 
-        # 3. Optional Remote Check: Verify key validity/expiration
-        if not errors and include_remote and is_api_key_provided:
-            from concurrent.futures import TimeoutError
-
-            executor = self._get_executor()
-            future = executor.submit(
-                litellm.check_valid_key, model=model, api_key=api_key
-            )
-            try:
-                is_valid = future.result(timeout=10.0)
-                if not is_valid:
-                    errors.append(
-                        "The API key appears to be invalid, expired, or deactivated."
-                    )
-            except TimeoutError:
-                errors.append(
-                    "The remote connectivity check timed out after 10 seconds."
+        # 2. Provider resolution: a bare model name cannot be routed, so the
+        # failure surfaces at preflight with a paste-ready fix instead of at the
+        # first completion. Skipped when an earlier error already explains the
+        # configuration problem.
+        if not errors:
+            errors.extend(self._provider_resolution_errors(model))
+
+        # 3. Optional remote check: verify key validity and expiration.
+        if not errors:
+            errors.extend(
+                self._remote_check_errors(
+                    model, api_key, include_remote, is_api_key_provided
                 )
-            except Exception as e:
-                errors.append(f"Remote connectivity check failed: {str(e)}")
+            )
 
         return errors
 
+    def _provider_resolution_errors(self, model: str) -> List[str]:
+        """Returns the paste-ready error when litellm cannot infer a provider.
+
+        A custom ``api_base`` is left to the user's endpoint, so no resolution
+        runs there. The library prints its provider list to stdout on failure,
+        so that output is captured and never reaches the CLI. The list shape lets
+        the caller extend unconditionally and keeps its branching flat.
+        """
+        import contextlib
+        import io
+
+        if self._config_service.get_setting("llm.api_base"):
+            return []
+
+        litellm = self._get_litellm()
+        try:
+            with contextlib.redirect_stdout(io.StringIO()):
+                litellm.get_llm_provider(model=model)
+        except Exception:
+            # A resolution failure is the signal; the library raises several
+            # exception types depending on the model string and provider table.
+            return [
+                f"Cannot infer a provider for model '{model}'. "
+                "Change llm.model in .teddy/config.yaml to prefix it with the "
+                f"provider, e.g. 'openai/{model}'."
+            ]
+        return []
+
+    def _remote_check_errors(
+        self,
+        model: str,
+        api_key: Any,
+        include_remote: bool,
+        is_api_key_provided: bool,
+    ) -> List[str]:
+        """Validates the key against the provider when a remote check is due.
+
+        Returns zero or one error. A missing request, an absent key, or a valid
+        key all yield an empty list, so the caller can extend unconditionally and
+        the request path stays flat.
+        """
+        if not (include_remote and is_api_key_provided):
+            return []
+
+        from concurrent.futures import TimeoutError
+
+        litellm = self._get_litellm()
+        executor = self._get_executor()
+        future = executor.submit(litellm.check_valid_key, model=model, api_key=api_key)
+        try:
+            is_valid = future.result(timeout=10.0)
+            if not is_valid:
+                return ["The API key appears to be invalid, expired, or deactivated."]
+        except TimeoutError:
+            return ["The remote connectivity check timed out after 10 seconds."]
+        except Exception as e:
+            return [f"Remote connectivity check failed: {str(e)}"]
+        return []
+
     def get_context_window(self, model: Optional[str] = None) -> int:
         """
         Returns the maximum context window size (tokens) for the specified model.

{teddy_cli-0.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/src/teddy_executor/core/domain/models/session.py

@@ -14,4 +14,3 @@ class SessionOptions:
     additional_context: list[str] = field(default_factory=list)
     model: Optional[str] = None
     provider: Optional[str] = None
-    api_key: Optional[str] = None

{teddy_cli-0.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/src/teddy_executor/core/services/planning_service.py

@@ -111,7 +111,6 @@ class PlanningService(IPlanningUseCase):
         response, plan_content, turn_cost = self._perform_generation_with_retry(
             messages,
             model=model,
-            api_key=meta.get("api_key"),
         )
 
         cost_val = self._prompt_manager.log_telemetry(token_count, turn_cost)
@@ -132,7 +131,6 @@ class PlanningService(IPlanningUseCase):
         self,
         messages: list[Dict[str, str]],
         model: str,
-        api_key: Optional[str] = None,
     ) -> tuple[Any, str, float]:
         """Implements retry loop for empty LLM content."""
         max_retries_val = self._config_service.get_setting("llm.max_retries")
@@ -141,15 +139,8 @@ class PlanningService(IPlanningUseCase):
         plan_content = ""
         turn_cost = 0.0
 
-        # Construct overrides dict for kwargs
-        overrides = {}
-        if api_key:
-            overrides["api_key"] = api_key
-
         for attempt in range(max_retries):
-            response = self._llm_client.get_completion(
-                messages=messages, model=model, **overrides
-            )
+            response = self._llm_client.get_completion(messages=messages, model=model)
             plan_content = self._extract_plan_content(response)
             attempt_cost = self._llm_client.get_completion_cost(
                 response, model_override=model

{teddy_cli-0.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/src/teddy_executor/core/services/session_service.py

@@ -137,8 +137,6 @@ class SessionService(ISessionManager):
         }
         if options.model:
             meta_data["model"] = options.model
-        if options.api_key:
-            meta_data["api_key"] = options.api_key
         return meta_data
 
     def _resolve_agent_prompt(self, agent_name: str) -> tuple[str, str]:
@@ -486,7 +484,7 @@ class SessionService(ISessionManager):
         }
 
         # Carry over LLM overrides and actual_model for display continuity
-        for key in ["model", "actual_model", "provider", "api_key"]:
+        for key in ["model", "actual_model", "provider"]:
             if key in current_meta:
                 meta[key] = current_meta[key]
 

{teddy_cli-0.1.17.dev1396 → teddy_cli-0.1.17.dev1397}/src/teddy_executor/resources/config/config.yaml

@@ -46,6 +46,9 @@ llm:
     X-OpenRouter-Title: "TeDDy"
     X-OpenRouter-Categories: "cli-agent"
 
+# llm.model must start with the provider prefix, e.g. "openai/qwen3-coder-30b".
+# A bare model name fails preflight, because litellm cannot infer the provider.
+
 # Local models (Ollama, LM Studio):
 #   model: "ollama/qwen3-coder:30b"
 #   model: "lm_studio/qwen3-coder-30b"