fix(cli): unify crewai run flow input resolution and prompt from the state schema (#6466)

* fix(cli): unify `crewai run` flow input resolution; prompt from state schema

`crewai run` resolved the configured [tool.crewai] flow, but `--inputs` was
hard-gated behind `--definition` and routed through a separate branch — the two
ways of pointing at the same flow didn't share resolution, and required inputs
were never detected, prompted, or validated (a missing field only blew up at
runtime).

Now inputs and definition come from one place:

- Remove the "--inputs requires --definition" gate (cli.py, run_crew.py,
  run_declarative_flow.py). `--inputs` alone resolves the configured flow,
  exactly like a bare `crewai run`; `--definition` is purely an override. The
  project-env re-exec forwards `--inputs` instead of rejecting it.
- Read the flow's state schema from the runtime Flow instance
  (`type(flow.state).model_json_schema()`), which is reliable for both inline
  `json_schema` and ref-imported `pydantic` state (the static definition's
  json_schema is None for the common ref case).
- Plain `crewai run` detects required state fields (minus those satisfied by
  state defaults) and prompts for them interactively, showing each field's
  description; skipped in non-interactive / CREWAI_DMN mode.
- Validate against the schema before kickoff: pointed
  "Missing required input 'x' — <description>" errors, and warn on unknown keys
  with a did-you-mean suggestion (catches typos like `prospect_emai`).

`--inputs` on a non-flow project now errors clearly ("only supported for
declarative flows") instead of the old confusing gate.

Tests: schema-driven prompt/validate/override paths, unknown-key warning,
defaults-satisfy-required, type validation, and re-exec input forwarding.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RBYGqJHC2TMC6fonFziuuh

* fix(cli): forward reserved `id` input to flow kickoff; ruff format

- Cursor: the schema filter treated an `id` key in --inputs as unknown and
  dropped it, regressing kickoff's persistence-restore support (inputs["id"]).
  Let `id` pass through untouched (test: reserved_id_input_is_forwarded).
- Apply ruff format to run_declarative_flow.py (fixes the lint-run
  `ruff format --check` step).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RBYGqJHC2TMC6fonFziuuh

* fix(cli): don't block persistence-restore resume on schema validation

Cursor (High): `crewai run --inputs '{"id":"…"}'` is a persistence resume —
kickoff hydrates full state from storage, so schema-required fields may come
from the restored state rather than --inputs. The new required-field
prompt/validation was erroring/prompting before kickoff, breaking resume. When
`id` is present in --inputs, forward the inputs unchanged and skip the
prompt/validation. Test: test_id_only_input_skips_required_validation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RBYGqJHC2TMC6fonFziuuh

* fix(cli): load project .env in the declarative-flow runner

The declarative-flow path never loaded .env — flow projects (type = "flow")
missed API keys/config that crew projects pick up. The JSON-crew path loads
Path.cwd()/.env with override=True (run_crew._run_json_crew); mirror that at
the top of run_declarative_flow() so flow projects behave the same regardless
of where crewai is installed. Test: run_declarative_flow_loads_project_env.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RBYGqJHC2TMC6fonFziuuh

* feat(cli): unify runtime-input prompting across declarative flows and crews

Declarative (JSON) crews now resolve inputs the same way declarative flows
do, via a shared crewai_cli.input_prompt module (prompt_for_inputs,
parse_inputs_json, closest_name, is_interactive):

- accept --inputs (previously rejected for crews), forwarded to the crew
  subprocess via CREWAI_JSON_CREW_INPUTS and validated before spinning up uv
- layer --inputs over the crew's declared `inputs` defaults
- prompt for missing {placeholder}s with the same UX as flows, and error
  cleanly with a pointed per-name message when non-interactive
- warn on unknown keys with a "did you mean" suggestion

Unlike flows — whose state schema is authoritative, so unknown keys are
dropped — the crew placeholder scan is heuristic (agent/task text fields
only), so unrecognized keys are warned about but kept, to avoid discarding a
value a field the scan doesn't cover may rely on.

--inputs remains rejected for classic (Python/YAML) crews, which take their
inputs from main.py. run_declarative_flow's private input helpers move to the
shared module with no behavior change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RBYGqJHC2TMC6fonFziuuh

* test(crewai): update mirrored CLI test after run_crew input refactor

lib/crewai/tests/cli/test_run_crew.py imports crewai_cli internals and is
collected by the lib/crewai test job (Run Tests). It still imported
_prompt_for_missing_inputs, which was replaced by _resolve_crew_inputs, so
the module failed to import — erroring pytest at collection and cancelling
the rest of the matrix via fail-fast.

Point it at _resolve_crew_inputs and patch the prompt in the shared
crewai_cli.input_prompt module where prompting now lives.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RBYGqJHC2TMC6fonFziuuh

* fix(cli): filter unknown --inputs keys even on flow persistence restore

Review follow-up: the `id` (persistence-restore) branch of
_resolve_flow_inputs returned the raw payload, so typo keys passed alongside
`id` skipped the unknown-key warning/drop and reached kickoff — which can
fail strict (extra="forbid") flow state models. The restore path now still
warns on and drops unknown keys (keeping `id` and known state fields); it
only skips the required-field prompt and pre-kickoff validation, which
persistence hydrates. Regression test: test_id_restore_still_drops_unknown_keys.

Also drop the duplicate module import in test_input_prompt.py (both `import`
and `from ... import` of crewai_cli.input_prompt) flagged by the code-quality
bot; monkeypatching now uses the string target form.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RBYGqJHC2TMC6fonFziuuh

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

lib/cli/tests/test_run_declarative_flow.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+import os
 from pathlib import Path
 
 import pytest
 
+import crewai_cli.input_prompt as input_prompt_module
 import crewai_cli.run_declarative_flow as run_declarative_flow_module
 
 
@@ -146,3 +148,255 @@ def test_run_declarative_flow_in_process_inside_uv(
     )
 
     assert capsys.readouterr().out == "AI\n"
+
+
+def test_run_declarative_flow_in_project_env_forwards_inputs(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    subprocess_calls = []
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.delenv("UV_RUN_RECURSION_DEPTH", raising=False)
+    (tmp_path / "pyproject.toml").write_text("[project]\nname = 'demo'\n")
+    monkeypatch.setattr(
+        run_declarative_flow_module,
+        "build_env_with_all_tool_credentials",
+        lambda: {},
+    )
+    monkeypatch.setattr(
+        run_declarative_flow_module.subprocess,
+        "run",
+        lambda command, **kwargs: subprocess_calls.append(command),
+    )
+
+    run_declarative_flow_module.run_declarative_flow_in_project_env(
+        "flow.yaml", '{"topic":"AI"}'
+    )
+
+    # --inputs is forwarded to the in-env run instead of being rejected.
+    assert subprocess_calls == [
+        ["uv", "run", "crewai", "run", "--inputs", '{"topic":"AI"}']
+    ]
+
+
+# ── Schema-driven inputs: prompt, validate, override ────────────────
+
+REQUIRED_FLOW_YAML = """\
+schema: crewai.flow/v1
+name: RequiredInputFlow
+config:
+  suppress_flow_events: true
+state:
+  type: json_schema
+  json_schema:
+    type: object
+    properties:
+      prospect_email:
+        type: string
+        description: Email address of the prospect to research
+    required: [prospect_email]
+methods:
+  begin:
+    start: true
+    do:
+      call: expression
+      expr: state.prospect_email
+"""
+
+DEFAULTS_FLOW_YAML = """\
+schema: crewai.flow/v1
+name: DefaultsFlow
+config:
+  suppress_flow_events: true
+state:
+  type: json_schema
+  json_schema:
+    type: object
+    properties:
+      topic: {type: string}
+      audience: {type: string}
+    required: [topic, audience]
+  default:
+    topic: AI
+methods:
+  begin:
+    start: true
+    do:
+      call: expression
+      expr: state.audience
+"""
+
+TYPED_FLOW_YAML = """\
+schema: crewai.flow/v1
+name: TypedFlow
+config:
+  suppress_flow_events: true
+state:
+  type: json_schema
+  json_schema:
+    type: object
+    properties:
+      count: {type: integer}
+    required: [count]
+methods:
+  begin:
+    start: true
+    do:
+      call: expression
+      expr: state.count
+"""
+
+
+def _write(tmp_path: Path, contents: str) -> Path:
+    path = tmp_path / "flow.yaml"
+    path.write_text(contents, encoding="utf-8")
+    return path
+
+
+def test_inputs_flag_satisfies_required_field(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    path = _write(tmp_path, REQUIRED_FLOW_YAML)
+
+    run_declarative_flow_module.run_declarative_flow(
+        str(path), '{"prospect_email":"a@b.com"}'
+    )
+
+    assert capsys.readouterr().out == "a@b.com\n"
+
+
+def test_missing_required_reports_pointed_error(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(run_declarative_flow_module, "_is_interactive", lambda: False)
+    path = _write(tmp_path, REQUIRED_FLOW_YAML)
+
+    with pytest.raises(SystemExit):
+        run_declarative_flow_module.run_declarative_flow(str(path))
+
+    assert (
+        "Missing required input 'prospect_email' — "
+        "Email address of the prospect to research" in capsys.readouterr().err
+    )
+
+
+def test_prompts_for_missing_required_when_interactive(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    path = _write(tmp_path, REQUIRED_FLOW_YAML)
+    monkeypatch.setattr(run_declarative_flow_module, "_is_interactive", lambda: True)
+    prompted: list[str] = []
+
+    def fake_prompt(text: str, **kwargs: object) -> str:
+        prompted.append(text)
+        return "typed@example.com"
+
+    monkeypatch.setattr(input_prompt_module.click, "prompt", fake_prompt)
+
+    run_declarative_flow_module.run_declarative_flow(str(path))
+
+    assert capsys.readouterr().out == "typed@example.com\n"
+    assert any("prospect_email" in text for text in prompted)
+
+
+def test_defaults_satisfy_required_and_are_not_prompted(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(run_declarative_flow_module, "_is_interactive", lambda: False)
+    path = _write(tmp_path, DEFAULTS_FLOW_YAML)
+
+    with pytest.raises(SystemExit):
+        run_declarative_flow_module.run_declarative_flow(str(path))
+
+    err = capsys.readouterr().err
+    # topic has a state default -> satisfied; only audience is missing.
+    assert "Missing required input 'audience'" in err
+    assert "'topic'" not in err
+
+
+def test_warns_on_unknown_input_with_suggestion(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    path = _write(tmp_path, REQUIRED_FLOW_YAML)
+
+    run_declarative_flow_module.run_declarative_flow(
+        str(path), '{"prospect_email":"a@b.com","prospect_emai":"typo"}'
+    )
+
+    captured = capsys.readouterr()
+    assert captured.out == "a@b.com\n"
+    assert "Ignoring unknown input 'prospect_emai'" in captured.err
+    assert "Did you mean 'prospect_email'?" in captured.err
+
+
+def test_validates_input_types_before_kickoff(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    path = _write(tmp_path, TYPED_FLOW_YAML)
+
+    with pytest.raises(SystemExit):
+        run_declarative_flow_module.run_declarative_flow(str(path), '{"count":"nope"}')
+
+    assert "Invalid input 'count'" in capsys.readouterr().err
+
+
+def test_reserved_id_input_is_forwarded_not_dropped(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    # `id` is a reserved kickoff key (persistence restore); it must pass through
+    # instead of being flagged as an unknown key and dropped.
+    path = _write(tmp_path, REQUIRED_FLOW_YAML)
+
+    run_declarative_flow_module.run_declarative_flow(
+        str(path), '{"id":"run-123","prospect_email":"a@b.com"}'
+    )
+
+    captured = capsys.readouterr()
+    assert captured.out == "a@b.com\n"
+    assert "Ignoring unknown input 'id'" not in captured.err
+
+
+def test_run_declarative_flow_loads_project_env(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    # Flow projects must pick up the project's .env, like crew projects do,
+    # overriding any pre-existing value.
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("DECL_FLOW_ENV_PROBE", "old")
+    (tmp_path / ".env").write_text("DECL_FLOW_ENV_PROBE=from_dotenv\n", encoding="utf-8")
+    path = _write(tmp_path, REQUIRED_FLOW_YAML)
+
+    run_declarative_flow_module.run_declarative_flow(
+        str(path), '{"prospect_email":"a@b.com"}'
+    )
+
+    assert os.environ["DECL_FLOW_ENV_PROBE"] == "from_dotenv"
+
+
+def test_id_only_input_skips_required_validation(tmp_path: Path) -> None:
+    # Resume via `crewai run --inputs '{"id":"..."}'` must not be blocked by the
+    # required-field check: kickoff hydrates required state from persistence.
+    path = _write(tmp_path, REQUIRED_FLOW_YAML)
+    flow = run_declarative_flow_module.load_declarative_flow(str(path))
+
+    resolved = run_declarative_flow_module._resolve_flow_inputs(flow, {"id": "run-123"})
+
+    assert resolved == {"id": "run-123"}
+
+
+def test_id_restore_still_drops_unknown_keys(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    # A persistence restore (`id` present) still filters typo keys so they don't
+    # reach kickoff and trip strict (extra="forbid") state models — it only
+    # skips the required-field prompt/validation, not the unknown-key warning.
+    path = _write(tmp_path, REQUIRED_FLOW_YAML)
+    flow = run_declarative_flow_module.load_declarative_flow(str(path))
+
+    resolved = run_declarative_flow_module._resolve_flow_inputs(
+        flow, {"id": "run-123", "prospect_emai": "typo"}
+    )
+
+    captured = capsys.readouterr()
+    assert resolved == {"id": "run-123"}  # id kept, typo dropped
+    assert "Ignoring unknown input 'prospect_emai'" in captured.err
+    assert "Ignoring unknown input 'id'" not in captured.err