applied-cli 0.6.7__tar.gz → 0.6.9__tar.gz

{applied_cli-0.6.7 → applied_cli-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.6.7
+Version: 0.6.9
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT

{applied_cli-0.6.7 → applied_cli-0.6.9}/applied_cli/cli.py

@@ -1540,15 +1540,26 @@ def send_message_cmd(
 @app.command()
 def benchmarks(
     agent_id: str = typer.Option(None, "--agent-id", help="Filter by agent ID"),
+    with_results: bool = typer.Option(
+        False,
+        "--with-results",
+        help="Include each benchmark's pass/fail/unrated tally and pass rate "
+        "(one scenario fetch per benchmark) — a go/no-go portfolio view",
+    ),
     shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
     format: str = typer.Option(
         "csv", "--format", "-f", help="Output format: csv or json"
     ),
 ) -> None:
-    """List benchmarks."""
+    """List benchmarks (optionally with per-benchmark pass rates via --with-results)."""
     client = get_client(shop_id=shop_id)
     result = asyncio.run(
-        tools.benchmark_list(client, agent_id=agent_id, output_format=format)
+        tools.benchmark_list(
+            client,
+            agent_id=agent_id,
+            output_format=format,
+            with_results=with_results,
+        )
     )
     typer.echo(result)
 
@@ -1774,6 +1785,46 @@ def scenario_create(
     typer.echo(result)
 
 
+@app.command("scenario-create-bulk")
+def scenario_create_bulk(
+    conversation_ids: str = typer.Option(
+        ..., "--conversation-ids", help="Comma-separated source conversation IDs"
+    ),
+    benchmark_id: str = typer.Option(
+        None, "--benchmark-id", help="Attach the scenarios to an existing benchmark"
+    ),
+    benchmark_name: str = typer.Option(
+        None, "--benchmark-name", help="Create or reuse a benchmark by name"
+    ),
+    agent_id: str = typer.Option(
+        None, "--agent-id", help="Required when --benchmark-name is used"
+    ),
+    name_prefix: str = typer.Option(
+        None,
+        "--name-prefix",
+        help="Name scenarios '<prefix> N' instead of deriving from conversation titles",
+    ),
+    shop_id: str = typer.Option(None, "--shop-id", help="Override shop ID"),
+    format: str = typer.Option(
+        "text", "--format", "-f", help="Output format: text or json"
+    ),
+) -> None:
+    """Create scenarios from several conversations at once (build a suite fast)."""
+    client = get_client(shop_id=shop_id)
+    result = asyncio.run(
+        tools.scenario_create_bulk(
+            client,
+            conversation_ids=_parse_csv_option(conversation_ids),
+            benchmark_id=benchmark_id,
+            benchmark_name=benchmark_name,
+            agent_id=agent_id,
+            name_prefix=name_prefix,
+            output_format=format,
+        )
+    )
+    typer.echo(result)
+
+
 @app.command("scenario-update")
 def scenario_update_cmd(
     id: str = typer.Argument(..., help="Scenario ID"),

{applied_cli-0.6.7 → applied_cli-0.6.9}/applied_cli/tools.py

@@ -5306,6 +5306,7 @@ async def benchmark_list(
     client: AppliedClient,
     agent_id: str | None = None,
     output_format: str = "csv",
+    with_results: bool = False,
 ) -> str:
     """
     List conversation benchmarks.
@@ -5314,26 +5315,45 @@ async def benchmark_list(
         client: Authenticated AppliedClient
         agent_id: Optional - filter by agent UUID
         output_format: 'csv' or 'json'
+        with_results: Also compute each benchmark's pass/fail/unrated tally and
+            pass rate (one extra scenario fetch per benchmark) — a go/no-go
+            portfolio view across all benchmarks
 
     Returns:
-        List of benchmarks with id, name, agent, scenario count
+        List of benchmarks with id, name, agent, scenario count (and pass-rate
+        columns when with_results is set)
     """
     benchmarks = await client.list_benchmarks(agent_id=agent_id)
-    mapped = [
-        {
+    mapped = []
+    for b in benchmarks:
+        row = {
             "id": b.get("id"),
             "name": b.get("name"),
             "agent_name": b.get("agent", {}).get("name", ""),
             "scenario_count": b.get("scenario_count", 0),
             "description": str(b.get("description", ""))[:80],
         }
-        for b in benchmarks
-    ]
+        if with_results:
+            scenarios = await client.list_scenarios(
+                benchmark_id=b.get("id"), fetch_all=True
+            )
+            tally = _pass_status_tally(scenarios)
+            pass_rate = tally["pass_rate"]
+            row["passed"] = tally["passed"]
+            row["failed"] = tally["failed"]
+            row["unrated"] = tally["unrated"]
+            row["pass_rate"] = (
+                f"{pass_rate * 100:.1f}%" if pass_rate is not None else "n/a"
+            )
+        mapped.append(row)
+
+    columns = ["id", "name", "agent_name", "scenario_count"]
+    if with_results:
+        columns += ["passed", "failed", "unrated", "pass_rate"]
+    columns.append("description")
 
     if output_format == "csv":
-        return to_csv(
-            mapped, ["id", "name", "agent_name", "scenario_count", "description"]
-        )
+        return to_csv(mapped, columns)
     return to_json(mapped)
 
 
@@ -5710,6 +5730,40 @@ async def benchmark_clone(
     return "\n".join(lines)
 
 
+def _pass_status_tally(scenarios: list[dict]) -> dict[str, Any]:
+    """Tally scenarios by pass_status and compute the pass rate among rated.
+
+    Scenario pass_status from the API is the *effective* value (the latest run's
+    pass_status when present, else the scenario's own), so this reflects the most
+    recent run per scenario.
+    """
+    tally = {"pass": 0, "fail": 0, "unrated": 0}
+    failing: list[dict[str, Any]] = []
+    unrated: list[dict[str, Any]] = []
+    for scenario in scenarios:
+        status = str(scenario.get("pass_status") or "unrated").lower()
+        if status not in tally:
+            status = "unrated"
+        tally[status] += 1
+        entry = {"id": scenario.get("id"), "name": scenario.get("name")}
+        if status == "fail":
+            failing.append(entry)
+        elif status == "unrated":
+            unrated.append(entry)
+
+    rated = tally["pass"] + tally["fail"]
+    return {
+        "total": len(scenarios),
+        "passed": tally["pass"],
+        "failed": tally["fail"],
+        "unrated": tally["unrated"],
+        "rated": rated,
+        "pass_rate": round(tally["pass"] / rated, 4) if rated else None,
+        "failing_scenarios": failing,
+        "unrated_scenarios": unrated,
+    }
+
+
 async def benchmark_results(
     client: AppliedClient,
     benchmark_id: str,
@@ -5739,30 +5793,18 @@ async def benchmark_results(
     except AppliedAPIError as e:
         return _format_error(e)
 
-    tally = {"pass": 0, "fail": 0, "unrated": 0}
-    failing: list[dict[str, Any]] = []
-    unrated: list[dict[str, Any]] = []
-    for scenario in scenarios:
-        status = str(scenario.get("pass_status") or "unrated").lower()
-        if status not in tally:
-            status = "unrated"
-        tally[status] += 1
-        entry = {"id": scenario.get("id"), "name": scenario.get("name")}
-        if status == "fail":
-            failing.append(entry)
-        elif status == "unrated":
-            unrated.append(entry)
-
-    rated = tally["pass"] + tally["fail"]
-    pass_rate = round(tally["pass"] / rated, 4) if rated else None
+    t = _pass_status_tally(scenarios)
+    failing = t["failing_scenarios"]
+    unrated = t["unrated_scenarios"]
+    pass_rate = t["pass_rate"]
     summary = {
         "benchmark_id": benchmark_id,
         "benchmark_name": benchmark.get("name"),
-        "total_scenarios": len(scenarios),
-        "passed": tally["pass"],
-        "failed": tally["fail"],
-        "unrated": tally["unrated"],
-        "rated": rated,
+        "total_scenarios": t["total"],
+        "passed": t["passed"],
+        "failed": t["failed"],
+        "unrated": t["unrated"],
+        "rated": t["rated"],
         "pass_rate": pass_rate,
         "failing_scenarios": failing,
         "unrated_scenarios": unrated,
@@ -5772,16 +5814,16 @@ async def benchmark_results(
         return to_json(summary)
 
     pass_rate_str = (
-        f"{pass_rate * 100:.1f}% ({tally['pass']}/{rated} rated)"
+        f"{pass_rate * 100:.1f}% ({t['passed']}/{t['rated']} rated)"
         if pass_rate is not None
         else "n/a (no rated scenarios yet)"
     )
     lines = [
         f"# Benchmark Results: {benchmark.get('name')} ({benchmark_id})",
         f"total_scenarios: {summary['total_scenarios']}",
-        f"passed: {tally['pass']}",
-        f"failed: {tally['fail']}",
-        f"unrated: {tally['unrated']}",
+        f"passed: {t['passed']}",
+        f"failed: {t['failed']}",
+        f"unrated: {t['unrated']}",
         f"pass_rate: {pass_rate_str}",
     ]
     if failing:
@@ -5942,6 +5984,97 @@ async def scenario_create(
     return result
 
 
+async def scenario_create_bulk(
+    client: AppliedClient,
+    conversation_ids: list[str],
+    *,
+    benchmark_id: str | None = None,
+    benchmark_name: str | None = None,
+    agent_id: str | None = None,
+    name_prefix: str | None = None,
+    output_format: str = "text",
+) -> str:
+    """
+    Create scenarios from several conversations at once and attach them to a
+    benchmark — the fast way to build a regression suite from real conversations.
+
+    Each scenario's name is derived from its source conversation's title; pass
+    name_prefix to instead name them "<prefix> 1", "<prefix> 2", … (skips the
+    per-conversation title lookup). Names are de-duplicated server-side.
+
+    Args:
+        client: Authenticated AppliedClient
+        conversation_ids: Source conversation UUIDs (one scenario each)
+        benchmark_id: Attach the scenarios to this existing benchmark
+        benchmark_name: Create or reuse a benchmark by name (requires agent_id)
+        agent_id: Required when benchmark_name is used
+        name_prefix: Name scenarios "<prefix> N" instead of using conversation titles
+        output_format: 'text' (default) or 'json'
+
+    Returns:
+        Summary of created scenarios and any per-conversation errors.
+    """
+    if not conversation_ids:
+        return _format_argument_error("Pass at least one conversation id.")
+
+    created: list[dict[str, Any]] = []
+    errors: list[dict[str, Any]] = []
+    for index, conversation_id in enumerate(conversation_ids):
+        if name_prefix:
+            name = f"{name_prefix} {index + 1}"
+        else:
+            try:
+                conversation = await client.get_conversation(conversation_id)
+                name = conversation.get("title") or f"Scenario {str(conversation_id)[:8]}"
+            except AppliedAPIError:
+                name = f"Scenario {str(conversation_id)[:8]}"
+
+        try:
+            scenario = await client.create_scenario(
+                input_conversation_id=conversation_id,
+                name=name,
+                benchmark_id=benchmark_id,
+                benchmark_name=benchmark_name,
+                agent_id=agent_id,
+            )
+            created.append(
+                {
+                    "id": scenario.get("id"),
+                    "name": scenario.get("name"),
+                    "conversation_id": conversation_id,
+                }
+            )
+        except AppliedAPIError as e:
+            errors.append({"conversation_id": conversation_id, "error": str(e)})
+
+    summary = {
+        "requested": len(conversation_ids),
+        "created": len(created),
+        "failed": len(errors),
+        "scenarios": created,
+        "errors": errors,
+    }
+
+    if output_format == "json":
+        return to_json(summary)
+
+    lines = [
+        "# Bulk Scenario Create",
+        f"requested: {summary['requested']}",
+        f"created: {summary['created']}",
+        f"failed: {summary['failed']}",
+    ]
+    if created:
+        lines.append("\n# Created")
+        lines.extend(f"  - {s['name']} ({s['id']})" for s in created[:50])
+        if len(created) > 50:
+            lines.append(f"  ... and {len(created) - 50} more")
+    if errors:
+        lines.append(f"\n# Errors ({len(errors)})")
+        lines.extend(f"  - {e['conversation_id']}: {e['error']}" for e in errors[:20])
+    return "\n".join(lines)
+
+
 async def scenario_update(
     client: AppliedClient,
     scenario_id: str,

{applied_cli-0.6.7 → applied_cli-0.6.9}/applied_cli/v2/domains.py

@@ -112,6 +112,7 @@ DOMAIN_TOOL_RENAMES: dict[str, dict[str, str]] = {
         "scenario_list": "scenarios_list",
         "scenario_get": "scenarios_get",
         "scenario_create": "scenarios_create",
+        "scenario_create_bulk": "scenarios_create_bulk",
         "scenario_update": "scenarios_update",
         "scenario_delete": "scenarios_delete",
         "scenario_run_list": "scenarios_runs_list",

{applied_cli-0.6.7 → applied_cli-0.6.9}/applied_cli/v2/scenarios.py

@@ -43,6 +43,7 @@ class ScenariosBulkCancelInput(StrictInput):
 class BenchmarksListInput(StrictInput):
     agent_id: str | None = None
     limit: int = 50
+    with_results: bool = False
 
 
 class BenchmarksGetInput(StrictInput):
@@ -97,6 +98,14 @@ class ScenariosCreateInput(StrictInput):
     agent_id: str | None = None
 
 
+class ScenariosCreateBulkInput(StrictInput):
+    conversation_ids: list[str]
+    benchmark_id: str | None = None
+    benchmark_name: str | None = None
+    agent_id: str | None = None
+    name_prefix: str | None = None
+
+
 class ScenariosUpdateInput(StrictInput):
     scenario_id: str
     name: str | None = None
@@ -395,10 +404,26 @@ async def benchmarks_list_handler(
             agent_id=params.agent_id,
             limit=params.limit,
         )
+        payload = []
+        for benchmark in benchmarks:
+            row = _project_benchmark_payload(benchmark)
+            if params.with_results:
+                from applied_cli.tools import _pass_status_tally
+
+                scenarios = await client.list_scenarios(
+                    benchmark_id=benchmark.get("id"), fetch_all=True
+                )
+                tally = _pass_status_tally(scenarios)
+                row["results"] = {
+                    "passed": tally["passed"],
+                    "failed": tally["failed"],
+                    "unrated": tally["unrated"],
+                    "pass_rate": tally["pass_rate"],
+                }
+            payload.append(row)
     except AppliedAPIError as exc:
         return _api_error_result(exc)
 
-    payload = [_project_benchmark_payload(benchmark) for benchmark in benchmarks]
     return ToolResult(
         data=payload,
         summary=_count_summary(len(payload), "benchmark"),
@@ -634,6 +659,46 @@ async def scenarios_create_handler(
     )
 
 
+async def scenarios_create_bulk_handler(
+    client: AppliedClient,
+    params: ScenariosCreateBulkInput,
+) -> ToolResult[Any]:
+    from applied_cli import tools as legacy_tools
+
+    raw = await legacy_tools.scenario_create_bulk(
+        client,
+        conversation_ids=params.conversation_ids,
+        benchmark_id=params.benchmark_id,
+        benchmark_name=params.benchmark_name,
+        agent_id=params.agent_id,
+        name_prefix=params.name_prefix,
+        output_format="json",
+    )
+    try:
+        data = json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        return ToolResult(data={"message": raw}, summary=str(raw))
+
+    next_actions = []
+    if data.get("created"):
+        next_actions.append(
+            "Use scenarios_bulk_run with the benchmark_id to run the new scenarios."
+        )
+    return ToolResult(
+        data=data,
+        summary=(
+            f"Created {data.get('created', 0)}/{data.get('requested', 0)} "
+            f"scenarios ({data.get('failed', 0)} failed)."
+        ),
+        warnings=(
+            [f"{data['failed']} conversation(s) failed to convert."]
+            if data.get("failed")
+            else []
+        ),
+        next_actions=next_actions,
+    )
+
+
 async def scenarios_get_handler(
     client: AppliedClient,
     params: ScenariosGetInput,
@@ -991,7 +1056,11 @@ def scenario_specs() -> list[ToolSpec]:
         ToolSpec(
             name="benchmarks_list",
             namespace="benchmarks",
-            description="List conversation benchmarks as structured rows.",
+            description=(
+                "List conversation benchmarks as structured rows. Set "
+                "with_results=true for each benchmark's pass/fail/unrated tally "
+                "and pass rate (a go/no-go portfolio view)."
+            ),
             input_model=BenchmarksListInput,
             output_model=None,
             handler=benchmarks_list_handler,
@@ -1095,6 +1164,21 @@ def scenario_specs() -> list[ToolSpec]:
             read_write_mode="write",
             tags=["scenario_create", "native"],
         ),
+        ToolSpec(
+            name="scenarios_create_bulk",
+            namespace="scenarios",
+            description=(
+                "Create scenarios from several conversations at once and attach "
+                "them to a benchmark — build a regression suite from real "
+                "conversations. Names derive from each conversation's title "
+                "unless name_prefix is given."
+            ),
+            input_model=ScenariosCreateBulkInput,
+            output_model=None,
+            handler=scenarios_create_bulk_handler,
+            read_write_mode="write",
+            tags=["scenario_create_bulk", "native"],
+        ),
         ToolSpec(
             name="scenarios_update",
             namespace="scenarios",

{applied_cli-0.6.7 → applied_cli-0.6.9}/applied_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: applied-cli
-Version: 0.6.7
+Version: 0.6.9
 Summary: CLI and shared client library for Applied Labs AI support agents
 Author: Applied Labs
 License-Expression: MIT

{applied_cli-0.6.7 → applied_cli-0.6.9}/applied_cli.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ tests/test_audit_tools.py
 tests/test_auth_context.py
 tests/test_benchmark_clone.py
 tests/test_benchmark_delete_guardrail.py
+tests/test_benchmark_list_with_results.py
 tests/test_benchmark_results.py
 tests/test_benchmark_scenario_tools.py
 tests/test_cli.py
@@ -53,6 +54,7 @@ tests/test_recovery.py
 tests/test_scenario_bulk_cancel.py
 tests/test_scenario_bulk_run_contact.py
 tests/test_scenario_bulk_run_wait.py
+tests/test_scenario_create_bulk.py
 tests/test_toolkit_contract.py
 tests/test_v2_agents.py
 tests/test_v2_articles.py

{applied_cli-0.6.7 → applied_cli-0.6.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "applied-cli"
-version = "0.6.7"
+version = "0.6.9"
 description = "CLI and shared client library for Applied Labs AI support agents"
 readme = "README.md"
 requires-python = ">=3.11"

applied_cli-0.6.9/tests/test_benchmark_list_with_results.py

@@ -0,0 +1,104 @@
+import json
+
+import pytest
+
+from applied_cli import tools
+
+BENCHMARKS = [
+    {"id": "b1", "name": "Cancel", "agent": {"name": "August"}, "scenario_count": 3},
+    {"id": "b2", "name": "Refund", "agent": {"name": "August"}, "scenario_count": 1},
+]
+
+SCENARIOS_BY_BENCHMARK = {
+    "b1": [
+        {"id": "s1", "name": "a", "pass_status": "pass"},
+        {"id": "s2", "name": "b", "pass_status": "fail"},
+        {"id": "s3", "name": "c", "pass_status": "unrated"},
+    ],
+    "b2": [{"id": "s4", "name": "d", "pass_status": "pass"}],
+}
+
+
+class FakeListClient:
+    def __init__(self):
+        self.list_scenarios_calls = 0
+
+    async def list_benchmarks(self, agent_id=None, limit=50):
+        return list(BENCHMARKS)
+
+    async def list_scenarios(self, benchmark_id=None, fetch_all=True, **kwargs):
+        self.list_scenarios_calls += 1
+        return list(SCENARIOS_BY_BENCHMARK.get(benchmark_id, []))
+
+
+@pytest.mark.asyncio
+async def test_list_without_results_does_not_fetch_scenarios():
+    client = FakeListClient()
+    out = await tools.benchmark_list(client, output_format="json")
+    rows = json.loads(out)
+    assert client.list_scenarios_calls == 0
+    assert "pass_rate" not in rows[0]
+
+
+@pytest.mark.asyncio
+async def test_list_with_results_adds_pass_rate_per_benchmark():
+    client = FakeListClient()
+    out = await tools.benchmark_list(
+        client, output_format="json", with_results=True
+    )
+    rows = {r["id"]: r for r in json.loads(out)}
+    # One scenario fetch per benchmark.
+    assert client.list_scenarios_calls == 2
+    # b1: 1 pass / 2 rated = 50%
+    assert rows["b1"]["passed"] == 1
+    assert rows["b1"]["failed"] == 1
+    assert rows["b1"]["unrated"] == 1
+    assert rows["b1"]["pass_rate"] == "50.0%"
+    # b2: 1 pass / 1 rated = 100%
+    assert rows["b2"]["pass_rate"] == "100.0%"
+
+
+@pytest.mark.asyncio
+async def test_list_with_results_csv_has_columns():
+    client = FakeListClient()
+    out = await tools.benchmark_list(client, output_format="csv", with_results=True)
+    header = out.splitlines()[0]
+    for col in ("passed", "failed", "unrated", "pass_rate"):
+        assert col in header
+
+
+def test_pass_status_tally_pure():
+    tally = tools._pass_status_tally(
+        [
+            {"id": "1", "pass_status": "pass"},
+            {"id": "2", "pass_status": "PASS"},  # case-insensitive
+            {"id": "3", "pass_status": "fail"},
+            {"id": "4"},  # missing -> unrated
+        ]
+    )
+    assert tally["passed"] == 2
+    assert tally["failed"] == 1
+    assert tally["unrated"] == 1
+    assert tally["rated"] == 3
+    assert tally["pass_rate"] == round(2 / 3, 4)
+
+
+def test_pass_status_tally_no_rated():
+    tally = tools._pass_status_tally([{"id": "1", "pass_status": "unrated"}])
+    assert tally["pass_rate"] is None
+
+
+@pytest.mark.asyncio
+async def test_v2_benchmarks_list_with_results():
+    from applied_cli.v2.scenarios import (
+        BenchmarksListInput,
+        benchmarks_list_handler,
+    )
+
+    client = FakeListClient()
+    result = await benchmarks_list_handler(
+        client, BenchmarksListInput(with_results=True)
+    )
+    by_id = {r["id"]: r for r in result.data}
+    assert by_id["b1"]["results"]["passed"] == 1
+    assert by_id["b2"]["results"]["pass_rate"] == 1.0

applied_cli-0.6.9/tests/test_scenario_create_bulk.py

@@ -0,0 +1,112 @@
+import json
+
+import pytest
+
+from applied_cli import tools
+from applied_cli.client import AppliedAPIError
+
+
+class FakeBulkCreateClient:
+    def __init__(self, titles=None, fail_ids=None):
+        self._titles = titles or {}
+        self._fail_ids = set(fail_ids or [])
+        self.get_conversation_calls = []
+        self.created = []
+
+    async def get_conversation(self, conversation_id, *, shop_id=None):
+        self.get_conversation_calls.append(conversation_id)
+        return {"id": conversation_id, "title": self._titles.get(conversation_id)}
+
+    async def create_scenario(
+        self,
+        input_conversation_id,
+        name,
+        benchmark_id=None,
+        benchmark_name=None,
+        agent_id=None,
+    ):
+        if input_conversation_id in self._fail_ids:
+            raise AppliedAPIError("boom", status_code=400)
+        rec = {
+            "id": f"scn-{len(self.created) + 1}",
+            "name": name,
+            "input_conversation_id": input_conversation_id,
+            "benchmark_id": benchmark_id,
+        }
+        self.created.append(rec)
+        return rec
+
+
+@pytest.mark.asyncio
+async def test_bulk_create_names_from_conversation_titles():
+    client = FakeBulkCreateClient(
+        titles={"c1": "Cancel order BP123", "c2": "Refund request"}
+    )
+    out = await tools.scenario_create_bulk(
+        client, ["c1", "c2"], benchmark_id="b1", output_format="json"
+    )
+    data = json.loads(out)
+    assert data["created"] == 2
+    assert [s["name"] for s in client.created] == ["Cancel order BP123", "Refund request"]
+    assert all(s["benchmark_id"] == "b1" for s in client.created)
+    assert client.get_conversation_calls == ["c1", "c2"]
+
+
+@pytest.mark.asyncio
+async def test_name_prefix_skips_title_lookup():
+    client = FakeBulkCreateClient()
+    await tools.scenario_create_bulk(
+        client, ["c1", "c2", "c3"], name_prefix="DG Cancel", output_format="json"
+    )
+    assert [s["name"] for s in client.created] == [
+        "DG Cancel 1",
+        "DG Cancel 2",
+        "DG Cancel 3",
+    ]
+    # No per-conversation fetches when a prefix is supplied.
+    assert client.get_conversation_calls == []
+
+
+@pytest.mark.asyncio
+async def test_missing_title_falls_back_to_short_id():
+    client = FakeBulkCreateClient(titles={"abcdef12-0000": None})
+    await tools.scenario_create_bulk(
+        client, ["abcdef12-0000"], output_format="json"
+    )
+    assert client.created[0]["name"] == "Scenario abcdef12"
+
+
+@pytest.mark.asyncio
+async def test_partial_failures_are_reported_not_fatal():
+    client = FakeBulkCreateClient(
+        titles={"c1": "A", "c2": "B", "c3": "C"}, fail_ids=["c2"]
+    )
+    out = await tools.scenario_create_bulk(
+        client, ["c1", "c2", "c3"], output_format="json"
+    )
+    data = json.loads(out)
+    assert data["created"] == 2
+    assert data["failed"] == 1
+    assert data["errors"][0]["conversation_id"] == "c2"
+
+
+@pytest.mark.asyncio
+async def test_empty_list_is_an_argument_error():
+    client = FakeBulkCreateClient()
+    out = await tools.scenario_create_bulk(client, [], output_format="text")
+    assert "at least one conversation id" in out.lower()
+
+
+@pytest.mark.asyncio
+async def test_v2_scenarios_create_bulk_handler():
+    from applied_cli.v2.scenarios import (
+        ScenariosCreateBulkInput,
+        scenarios_create_bulk_handler,
+    )
+
+    client = FakeBulkCreateClient(titles={"c1": "A"})
+    result = await scenarios_create_bulk_handler(
+        client, ScenariosCreateBulkInput(conversation_ids=["c1"], benchmark_id="b1")
+    )
+    assert result.data["created"] == 1
+    assert "scenarios" in " ".join(result.next_actions).lower()