crewai-cli 1.15.2a2.dev20260707__tar.gz → 1.15.2.dev20260710__tar.gz

{crewai_cli-1.15.2a2.dev20260707 → crewai_cli-1.15.2.dev20260710}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crewai-cli
-Version: 1.15.2a2.dev20260707
+Version: 1.15.2.dev20260710
 Summary: CLI for CrewAI — scaffold, run, deploy and manage AI agent crews.
 Project-URL: Homepage, https://crewai.com
 Project-URL: Documentation, https://docs.crewai.com
@@ -10,7 +10,7 @@ Requires-Python: <3.14,>=3.10
 Requires-Dist: appdirs~=1.4.4
 Requires-Dist: certifi
 Requires-Dist: click<9,>=8.1.7
-Requires-Dist: crewai-core==1.15.2a2.dev20260707
+Requires-Dist: crewai-core==1.15.2.dev20260710
 Requires-Dist: cryptography>=42.0
 Requires-Dist: httpx~=0.28.1
 Requires-Dist: packaging>=23.0

{crewai_cli-1.15.2a2.dev20260707 → crewai_cli-1.15.2.dev20260710}/pyproject.toml

@@ -8,7 +8,7 @@ authors = [
 ]
 requires-python = ">=3.10, <3.14"
 dependencies = [
-    "crewai-core==1.15.2a2.dev20260707",
+    "crewai-core==1.15.2.dev20260710",
     "click>=8.1.7,<9",
     "pydantic>=2.11.9,<2.13",
     "pydantic-settings~=2.10.1",

crewai_cli-1.15.2.dev20260710/src/crewai_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.15.2.dev20260710"

{crewai_cli-1.15.2a2.dev20260707 → crewai_cli-1.15.2.dev20260710}/src/crewai_cli/cli.py

@@ -526,8 +526,8 @@ def run(
     inputs: str | None,
 ) -> None:
     """Run the Crew or Flow."""
-    if inputs is not None and definition is None:
-        raise click.UsageError("--inputs requires --definition")
+    # --inputs no longer requires --definition: with no override it resolves the
+    # configured [tool.crewai] flow, same as a bare `crewai run`.
     if trained_agents_file is not None and definition is not None:
         raise click.UsageError("--filename can only be used when running crews")
 

crewai_cli-1.15.2.dev20260710/src/crewai_cli/input_prompt.py

@@ -0,0 +1,84 @@
+"""Shared interactive prompting for runtime inputs (flows and crews).
+
+``crewai run`` asks the user for values that were not provided up front — for a
+declarative flow (derived from its state schema) and for a declarative (JSON)
+crew (derived from the ``{placeholder}`` references in its agents and tasks).
+Both paths go through this module so the experience is identical: the same
+header, the same per-field prompt styling, and prompt chrome on stderr so
+stdout carries only the run's result.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+import difflib
+import json
+import sys
+from typing import Any
+
+import click
+
+from crewai_cli.utils import enable_prompt_line_editing, is_dmn_mode_enabled
+
+
+def parse_inputs_json(inputs: str | None) -> dict[str, Any] | None:
+    """Parse a ``--inputs`` JSON object, exiting with a pointed error if invalid."""
+    if inputs is None:
+        return None
+
+    try:
+        parsed = json.loads(inputs)
+    except json.JSONDecodeError as exc:
+        click.echo(f"Invalid --inputs JSON: {exc}", err=True)
+        raise SystemExit(1) from exc
+
+    if not isinstance(parsed, dict):
+        click.echo("Invalid --inputs JSON: expected an object.", err=True)
+        raise SystemExit(1)
+
+    return parsed
+
+
+def closest_name(key: str, candidates: Iterable[str]) -> str | None:
+    """Nearest candidate name to a likely typo, if one is close enough."""
+    matches = difflib.get_close_matches(key, list(candidates), n=1, cutoff=0.7)
+    return matches[0] if matches else None
+
+
+def is_interactive() -> bool:
+    """Prompt only in an interactive terminal, never in non-interactive mode."""
+    return not is_dmn_mode_enabled() and sys.stdin.isatty()
+
+
+def prompt_for_inputs(
+    names: list[str],
+    *,
+    title: str,
+    subtitle: str,
+    describe: Callable[[str], str | None] | None = None,
+    coerce: Callable[[str, str], Any] | None = None,
+) -> dict[str, Any]:
+    """Prompt for each name and return ``{name: value}``.
+
+    ``describe(name)`` returns an optional hint shown dim above the prompt (used
+    by flows to surface a field's schema description). ``coerce(name, raw)``
+    converts the typed string to the stored value (used by flows to coerce to
+    the field's JSON-schema type); by default the raw string is kept as-is.
+
+    Prompt chrome is written to stderr so stdout carries only the run result.
+    """
+    enable_prompt_line_editing()
+    click.echo(err=True)
+    click.secho(f"  {title}", fg="cyan", bold=True, err=True)
+    click.secho(f"  {subtitle}", dim=True, err=True)
+
+    collected: dict[str, Any] = {}
+    for name in names:
+        if describe is not None and (hint := describe(name)):
+            click.secho(f"  {hint}", dim=True, err=True)
+        raw = click.prompt(
+            click.style(f"  {name}", fg="cyan"),
+            prompt_suffix=click.style(" > ", fg="bright_white"),
+        )
+        collected[name] = coerce(name, raw) if coerce is not None else raw
+    return collected

{crewai_cli-1.15.2a2.dev20260707 → crewai_cli-1.15.2.dev20260710}/src/crewai_cli/model_catalog.py

@@ -24,6 +24,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 import contextlib
+import hashlib
 import json
 import os
 from pathlib import Path
@@ -45,8 +46,11 @@ MAX_MODELS = 8
 #: Timeout (seconds) for any network call made while resolving models.
 _TIMEOUT = 6.0
 
-#: How long a resolved (dynamic) catalog stays fresh before we refetch.
-_CATALOG_TTL = 6 * 3600
+#: How long a resolved (dynamic) catalog stays fresh before we refetch. Kept
+#: short: it only spares the picker repeated fetches within a wizard session,
+#: and a stale list (new/removed models, account changes) is worse than a ~1s
+#: refetch. Local providers (Ollama) are not cached at all — see _is_cacheable.
+_CATALOG_TTL = 300
 
 #: How long a fallback result is cached after a failed/empty fetch. Short, so a
 #: newly-added API key takes effect soon, but long enough to spare the picker a
@@ -171,9 +175,8 @@ def get_provider_models(
 
     # Nothing fresher than the curated list. Cache it briefly (negative cache)
     # so a failed vendor/LiteLLM fetch isn't retried on every subsequent call.
-    # Skip Ollama: it's a local, fast-failing server, so re-probing is cheap and
-    # avoids serving suggestions after the server comes up within the TTL.
-    if fallback and provider_key != "ollama":
+    # (_write_catalog_cache skips non-cacheable providers like Ollama.)
+    if fallback:
         _write_catalog_cache(provider_key, fallback, source="fallback")
     return fallback
 
@@ -601,25 +604,36 @@ def _litellm_cache_file() -> Path:
     return _cache_dir() / "provider_cache.json"
 
 
+def _is_cacheable(provider_key: str) -> bool:
+    """Whether a provider's resolved catalog may be cached.
+
+    Ollama is a local server (``/api/tags`` is fast), and its installed models
+    change out-of-band, so it is never cached — the picker re-probes every call
+    and always reflects what is currently installed.
+    """
+    return provider_key != "ollama"
+
+
 def _cache_key(provider_key: str) -> str:
     """Cache key for a provider's resolved model list.
 
-    Includes the inputs that change what a fetch would return, so a cached
-    entry is only reused when those inputs still match:
-
-    - Ollama lists models from a base URL that can change between runs.
-    - Whether the vendor's API key is present flips between a live fetch and
-      the negatively-cached fallback — so a key added after a no-key call is
-      not shadowed by the cached fallback.
+    Keyed by the exact API key (via a short, non-reversible digest — never the
+    key itself), so switching to a different key for the same provider misses
+    the previous account's cached entry and refetches. Absent key -> ``#nokey``,
+    which also keeps a negatively-cached no-key fallback from shadowing a run
+    after a key is added.
     """
-    if provider_key == "ollama":
-        return f"ollama@{_ollama_base()}"
-    suffix = "key" if _provider_api_key(provider_key) else "nokey"
-    return f"{provider_key}#{suffix}"
+    api_key = _provider_api_key(provider_key)
+    if not api_key:
+        return f"{provider_key}#nokey"
+    digest = hashlib.sha256(api_key.encode("utf-8")).hexdigest()[:12]
+    return f"{provider_key}#{digest}"
 
 
 def _read_catalog_cache(provider_key: str) -> list[tuple[str, str]] | None:
     """Return a fresh cached catalog for ``provider_key``, or ``None``."""
+    if not _is_cacheable(provider_key):
+        return None
     payload = _read_json(_catalog_cache_file())
     if not isinstance(payload, dict):
         return None
@@ -642,6 +656,8 @@ def _read_catalog_cache(provider_key: str) -> list[tuple[str, str]] | None:
 def _write_catalog_cache(
     provider_key: str, models: list[tuple[str, str]], *, source: str
 ) -> None:
+    if not _is_cacheable(provider_key):
+        return
     cache_file = _catalog_cache_file()
     payload = _read_json(cache_file)
     if not isinstance(payload, dict):

{crewai_cli-1.15.2a2.dev20260707 → crewai_cli-1.15.2.dev20260710}/src/crewai_cli/run_crew.py

@@ -12,9 +12,14 @@ import click
 from crewai_core.constants import CREWAI_TRAINED_AGENTS_FILE_ENV
 from packaging import version
 
+from crewai_cli.input_prompt import (
+    closest_name,
+    is_interactive,
+    parse_inputs_json,
+    prompt_for_inputs,
+)
 from crewai_cli.utils import (
     build_env_with_all_tool_credentials,
-    enable_prompt_line_editing,
     is_dmn_mode_enabled,
 )
 from crewai_cli.version import get_crewai_tools_dependency, get_crewai_version
@@ -31,6 +36,7 @@ _INPUT_PLACEHOLDER_RE = re.compile(r"(?<!{){([A-Za-z_][A-Za-z0-9_\-]*)}(?!})")
 _CREWAI_CLI_RUNNER_PACKAGE_DIR_ENV = "CREWAI_CLI_RUNNER_PACKAGE_DIR"
 _CREWAI_RUNNER_SOURCE_DIR_ENV = "CREWAI_RUNNER_SOURCE_DIR"
 _CREWAI_JSON_CREW_DEFINITION_ENV = "CREWAI_JSON_CREW_DEFINITION"
+_CREWAI_JSON_CREW_INPUTS_ENV = "CREWAI_JSON_CREW_INPUTS"
 _FULL_CREWAI_INSTALL_MESSAGE = f"""\
 CrewAI CLI is installed without the `crewai` package required to run crews.
 
@@ -79,6 +85,8 @@ kwargs = {
 }
 if crew_definition := os.getenv("CREWAI_JSON_CREW_DEFINITION"):
     kwargs["crew_path"] = crew_definition
+if crew_inputs := os.getenv("CREWAI_JSON_CREW_INPUTS"):
+    kwargs["inputs"] = crew_inputs
 
 try:
     module._run_json_crew(**kwargs)
@@ -138,8 +146,8 @@ def _extract_input_placeholders(text: str | None) -> set[str]:
     return set(_INPUT_PLACEHOLDER_RE.findall(text))
 
 
-def _missing_input_names(crew: Any, inputs: dict[str, Any]) -> list[str]:
-    """Return input placeholders used by a crew but not provided as defaults."""
+def _referenced_input_names(crew: Any) -> set[str]:
+    """All ``{placeholder}`` names referenced by a crew's agents and tasks."""
     placeholders: set[str] = set()
 
     for agent in getattr(crew, "agents", []) or []:
@@ -160,32 +168,70 @@ def _missing_input_names(crew: Any, inputs: dict[str, Any]) -> list[str]:
             _extract_input_placeholders(getattr(task, "output_file", None))
         )
 
-    return sorted(name for name in placeholders if name not in inputs)
+    return placeholders
+
+
+def _missing_input_names(crew: Any, inputs: dict[str, Any]) -> list[str]:
+    """Return input placeholders referenced by a crew but not provided as inputs."""
+    return sorted(name for name in _referenced_input_names(crew) if name not in inputs)
 
 
-def _prompt_for_missing_inputs(
-    crew: Any, default_inputs: dict[str, Any]
+def _resolve_crew_inputs(
+    crew: Any,
+    default_inputs: dict[str, Any],
+    provided: dict[str, Any] | None,
+    *,
+    interactive: bool,
 ) -> dict[str, Any]:
-    """Ask for runtime values for placeholders that lack default inputs."""
+    """Resolve kickoff inputs for a declarative crew.
+
+    Mirrors the declarative-flow experience (``_resolve_flow_inputs``): layers
+    ``--inputs`` over the crew's declared ``inputs`` defaults, warns on provided
+    keys that aren't referenced as ``{placeholder}``s, prompts for any
+    still-missing placeholders when interactive, and exits with a pointed
+    message when one is still missing.
+
+    Unlike flows — whose state schema is an authoritative contract, so unknown
+    keys are dropped — the crew placeholder scan is heuristic (it only covers
+    agent/task text fields). An unrecognized key is therefore warned about but
+    *kept*, never dropped: dropping could silently discard a value that a field
+    the scan doesn't cover actually relies on.
+    """
+    referenced = _referenced_input_names(crew)
     inputs = dict(default_inputs or {})
-    missing = _missing_input_names(crew, inputs)
-    if not missing:
-        return inputs
 
-    enable_prompt_line_editing()
+    for key, value in (provided or {}).items():
+        if key not in referenced:
+            suggestion = closest_name(key, referenced)
+            hint = f" Did you mean '{suggestion}'?" if suggestion else ""
+            click.secho(
+                f"  Input '{key}' isn't referenced by any {{placeholder}} "
+                f"in the crew.{hint}",
+                fg="yellow",
+                err=True,
+            )
+        inputs[key] = value
 
-    click.echo()
-    click.secho("  Runtime inputs", fg="cyan", bold=True)
-    click.secho(
-        "  Values for {placeholder} references in your agents and tasks.",
-        dim=True,
-    )
+    missing = _missing_input_names(crew, inputs)
+    if missing and interactive:
+        inputs.update(
+            prompt_for_inputs(
+                missing,
+                title="Crew inputs",
+                subtitle="This crew needs the following to run.",
+            )
+        )
+        missing = _missing_input_names(crew, inputs)
 
-    for name in missing:
-        inputs[name] = click.prompt(
-            click.style(f"  {name}", fg="cyan"),
-            prompt_suffix=click.style(" > ", fg="bright_white"),
+    if missing:
+        for name in missing:
+            click.secho(f"  Missing required input '{name}'", fg="red", err=True)
+        click.secho(
+            "  Provide them via --inputs or the `inputs` object in crew.json(c).",
+            dim=True,
+            err=True,
         )
+        raise SystemExit(1)
 
     return inputs
 
@@ -243,29 +289,14 @@ def _prepare_json_crew_for_tui(crew: Any) -> None:
             agent.llm.stream = True
 
 
-def _runtime_inputs_without_prompt(
-    crew: Any, default_inputs: dict[str, Any]
-) -> dict[str, Any]:
-    """Return runtime inputs in non-interactive mode or exit on missing values."""
-    inputs = dict(default_inputs or {})
-    missing = _missing_input_names(crew, inputs)
-    if missing:
-        missing_list = ", ".join(missing)
-        click.echo(
-            "Missing runtime inputs for CREWAI_DMN mode: "
-            f"{missing_list}. Add them to the `inputs` object in crew.json(c).",
-            err=True,
-        )
-        raise SystemExit(1)
-    return inputs
-
-
-def _run_json_crew_without_tui(crew_path: Path) -> Any:
+def _run_json_crew_without_tui(crew_path: Path, provided: dict[str, Any] | None) -> Any:
     """Run a JSON-defined crew with plain terminal output."""
     with _json_loading_status("Preparing crew..."):
         crew, default_inputs = _load_json_crew(crew_path)
 
-    runtime_inputs = _runtime_inputs_without_prompt(crew, default_inputs)
+    runtime_inputs = _resolve_crew_inputs(
+        crew, default_inputs, provided, interactive=False
+    )
     result = crew.kickoff(inputs=runtime_inputs)
     if result is not None:
         click.echo(str(result))
@@ -275,6 +306,7 @@ def _run_json_crew_without_tui(crew_path: Path) -> Any:
 def _run_json_crew(
     trained_agents_file: str | None = None,
     crew_path: str | Path | None = None,
+    inputs: str | None = None,
 ) -> Any:
     """Load and run a JSON-defined crew."""
     from dotenv import load_dotenv
@@ -296,13 +328,17 @@ def _run_json_crew(
         )
     crew_path = Path(crew_path)
 
+    provided = parse_inputs_json(inputs)
+
     if is_dmn_mode_enabled():
-        return _run_json_crew_without_tui(crew_path)
+        return _run_json_crew_without_tui(crew_path, provided)
 
     crew_run_app_cls, crew, default_inputs, task_names, agent_names = (
         _load_json_crew_for_tui(crew_path)
     )
-    runtime_inputs = _prompt_for_missing_inputs(crew, default_inputs)
+    runtime_inputs = _resolve_crew_inputs(
+        crew, default_inputs, provided, interactive=is_interactive()
+    )
 
     app = crew_run_app_cls(
         crew_name=crew.name or "Crew",
@@ -411,12 +447,18 @@ def _json_crew_run_command(project_root: Path | None = None) -> list[str]:
 def _run_json_crew_in_project_env(
     trained_agents_file: str | None = None,
     crew_path: str | Path | None = None,
+    inputs: str | None = None,
 ) -> Any:
     """Run JSON crews from the project's uv-managed environment."""
+    # Validate --inputs up front so bad JSON fails before we spin up the uv env.
+    if inputs is not None:
+        parse_inputs_json(inputs)
+
     if not (Path.cwd() / "pyproject.toml").is_file():
         return _run_json_crew(
             trained_agents_file=trained_agents_file,
             crew_path=crew_path,
+            inputs=inputs,
         )
 
     _install_json_crew_dependencies_if_needed()
@@ -430,6 +472,8 @@ def _run_json_crew_in_project_env(
         env[CREWAI_TRAINED_AGENTS_FILE_ENV] = trained_agents_file
     if crew_path is not None:
         env[_CREWAI_JSON_CREW_DEFINITION_ENV] = str(crew_path)
+    if inputs is not None:
+        env[_CREWAI_JSON_CREW_INPUTS_ENV] = inputs
 
     try:
         subprocess.run(  # noqa: S603
@@ -569,11 +613,11 @@ def run_crew(
             ``CREWAI_TRAINED_AGENTS_FILE`` so agents load suggestions from this
             file instead of the default ``trained_agents_data.pkl``.
         definition: Optional path to a declarative Flow definition.
-        inputs: Optional JSON object passed to a declarative Flow.
+        inputs: Optional JSON object of runtime inputs for a declarative flow
+            or declarative (JSON) crew. Layered over the definition's own
+            defaults; missing required values are prompted for interactively.
     """
-    if inputs is not None and definition is None:
-        raise click.UsageError("--inputs requires --definition")
-
+    # --definition is a pure override: run that flow directly.
     if definition is not None:
         _run_explicit_declarative_flow(
             definition=definition,
@@ -584,9 +628,13 @@ def run_crew(
 
     pyproject_data = read_toml()
     if json_crew_definition := configured_project_json_crew(pyproject_data):
+        # Declarative (JSON) crews resolve inputs the same way flows do: --inputs
+        # layers over the crew's declared defaults, missing {placeholder}s are
+        # prompted for, and unknown keys are flagged. Forward the raw JSON.
         _run_json_crew_in_project_env(
             trained_agents_file=trained_agents_file,
             crew_path=json_crew_definition,
+            inputs=inputs,
         )
         return
 
@@ -594,18 +642,29 @@ def run_crew(
     project_type = get_crewai_project_type(pyproject_data)
 
     if project_type == "flow":
+        # No --definition: resolve the configured [tool.crewai] flow — the same
+        # resolution as a bare `crewai run` — and pass --inputs straight through.
         _run_flow_project(
             pyproject_data=pyproject_data,
             trained_agents_file=trained_agents_file,
+            inputs=inputs,
         )
         return
 
+    _reject_inputs_for_non_flow(inputs)
     _run_classic_crew_project(
         pyproject_data=pyproject_data,
         trained_agents_file=trained_agents_file,
     )
 
 
+def _reject_inputs_for_non_flow(inputs: str | None) -> None:
+    if inputs is not None:
+        raise click.UsageError(
+            "--inputs is only supported for declarative flows and crews"
+        )
+
+
 def _run_explicit_declarative_flow(
     definition: str, inputs: str | None, trained_agents_file: str | None
 ) -> None:
@@ -618,7 +677,9 @@ def _run_explicit_declarative_flow(
 
 
 def _run_flow_project(
-    pyproject_data: dict[str, Any], trained_agents_file: str | None
+    pyproject_data: dict[str, Any],
+    trained_agents_file: str | None,
+    inputs: str | None = None,
 ) -> None:
     if trained_agents_file is not None:
         raise click.UsageError("--filename can only be used when running crews")
@@ -629,9 +690,16 @@ def _run_flow_project(
     )
 
     if definition := configured_project_declarative_flow(pyproject_data):
-        run_declarative_flow_in_project_env(definition=definition)
+        run_declarative_flow_in_project_env(definition=definition, inputs=inputs)
         return
 
+    # No configured declarative flow definition to resolve inputs against.
+    if inputs is not None:
+        raise click.UsageError(
+            "--inputs requires a declarative flow definition "
+            "([tool.crewai].definition) or --definition"
+        )
+
     from crewai_cli.kickoff_flow import (
         _load_conversational_flow_from_kickoff_script,
         _run_conversational_flow_tui,