probe: plain stock CI at 1b61d7ca (fork-only, do not merge)

.github/scripts/check-provider-startup.py

@@ -0,0 +1,115 @@
+"""Start installed providers without inference and verify the selected OpenAI major."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import os
+from importlib.metadata import version
+
+from pydantic import BaseModel
+from wheelchecks import Framework
+
+logger = logging.getLogger(__name__)
+MODEL_ID = "gpt-4o-mini"
+API_KEY = "test"
+
+
+async def start_pydantic_ai() -> None:
+    import httpx2  # noqa: PLC0415 -- only modern consumers install HTTPX2
+    from pydantic_ai.models import infer_model  # noqa: PLC0415 -- optional consumer dependency
+
+    from band.adapters.pydantic_ai import (  # noqa: PLC0415 -- only the Pydantic AI consumer installs this adapter
+        PydanticAIAdapter,
+        PydanticAIAdapterConfig,
+    )
+
+    for alias in ("openai", "openai-chat"):
+        adapter = PydanticAIAdapter(
+            PydanticAIAdapterConfig(model=f"{alias}:{MODEL_ID}")
+        )
+        await adapter.on_started("Wheel consumer", "Provider startup check")
+        assert adapter._agent is not None
+        async with adapter._agent:
+            model = infer_model(f"{alias}:{MODEL_ID}")
+            assert isinstance(model.provider.client._client, httpx2.AsyncClient)
+
+
+async def start_crewai() -> None:
+    from crewai import LLM  # noqa: PLC0415 -- only the CrewAI consumer installs this provider
+
+    LLM(model=f"openai/{MODEL_ID}", api_key=API_KEY)
+
+
+async def start_strands() -> None:
+    from strands.models.openai_responses import OpenAIResponsesModel  # noqa: PLC0415 -- only the Strands consumer installs this provider
+
+    OpenAIResponsesModel(model_id=MODEL_ID, client_args={"api_key": API_KEY})
+
+
+async def start_nooa() -> None:
+    from nooa.unifiedllm.registry import get_llm_client  # noqa: PLC0415 -- only the NOOA consumer installs this provider
+
+    get_llm_client(f"openai/{MODEL_ID}", api_key=API_KEY)
+
+
+async def start_langgraph() -> None:
+    from langchain_openai import ChatOpenAI  # noqa: PLC0415 -- only LangGraph consumers install this provider
+
+    model = ChatOpenAI(model=MODEL_ID, api_key=API_KEY)
+    await model.root_async_client.close()
+    model.root_client.close()
+
+
+async def start_parlant() -> None:
+    import httpx2  # noqa: PLC0415 -- only modern consumers install HTTPX2
+    from parlant.adapters.nlp.openai_service import OpenAIService  # noqa: PLC0415 -- only the Parlant consumer installs this provider
+    from parlant.core.loggers import StdoutLogger  # noqa: PLC0415 -- optional consumer dependency
+    from parlant.core.meter import LocalMeter  # noqa: PLC0415 -- optional consumer dependency
+    from parlant.core.tracer import LocalTracer  # noqa: PLC0415 -- optional consumer dependency
+
+    tracer = LocalTracer()
+    provider_logger = StdoutLogger(tracer)
+    service = OpenAIService(provider_logger, tracer, LocalMeter(provider_logger))
+    generator = await service.get_schematic_generator(BaseModel)
+    assert isinstance(generator._client._client, httpx2.AsyncClient)
+    await generator._client.close()
+
+
+async def start_provider(framework: Framework) -> None:
+    match framework:
+        case Framework.PYDANTIC_AI:
+            await start_pydantic_ai()
+        case Framework.CREWAI:
+            await start_crewai()
+        case Framework.STRANDS:
+            await start_strands()
+        case Framework.NOOA:
+            await start_nooa()
+        case Framework.LANGGRAPH:
+            await start_langgraph()
+        case Framework.PARLANT:
+            await start_parlant()
+    logger.info("%s provider starts", framework)
+
+
+async def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--framework", type=Framework, choices=Framework, action="append", required=True
+    )
+    parser.add_argument("--openai-major", type=int, required=True)
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    selected_version = version("openai")
+    assert int(selected_version.split(".")[0]) == args.openai_major, selected_version
+    # Upstream string-based providers read this; no real credentials or inference are needed.
+    os.environ["OPENAI_API_KEY"] = API_KEY
+    for framework in args.framework:
+        await start_provider(framework)
+    logger.info("OpenAI %s: provider startup checks passed", selected_version)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

.github/scripts/check-wheel-extras.py

@@ -0,0 +1,100 @@
+"""Verify clean wheel installs, provider startup, and incompatible-extra rejection.
+
+Run outside the repository resolver: each case gets a fresh virtual environment
+and installs the built wheel through its published Requires-Dist metadata.
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from wheelchecks import CONSUMERS, Consumer, Framework
+
+logger = logging.getLogger(__name__)
+PROVIDER_PROBE = Path(__file__).with_name("check-provider-startup.py")
+
+
+def run(command: list[str], cwd: Path) -> subprocess.CompletedProcess[str]:
+    result = subprocess.run(
+        command, cwd=cwd, text=True, capture_output=True, check=False
+    )
+    logger.info("$ %s\n%s%s", " ".join(command), result.stdout, result.stderr)
+    return result
+
+
+def require_success(command: list[str], cwd: Path) -> None:
+    result = run(command, cwd)
+    if result.returncode != 0:
+        raise RuntimeError(f"Wheel consumer check failed: {command}")
+
+
+def install_consumer(wheel: Path, consumer: Consumer, python: Path, cwd: Path) -> None:
+    requirements = [f"{wheel}[{consumer.extras}]"]
+    if consumer.openai_major == 3:
+        requirements.append("openai>=3.26,<4")
+    require_success(
+        ["uv", "pip", "install", "--python", str(python), *requirements], cwd
+    )
+    require_success(["uv", "pip", "check", "--python", str(python)], cwd)
+
+
+def check_providers(consumer: Consumer, python: Path, cwd: Path) -> None:
+    framework_flags = [
+        value
+        for framework in consumer.frameworks
+        for value in ("--framework", str(framework))
+    ]
+    require_success(
+        [
+            str(python),
+            str(PROVIDER_PROBE),
+            "--openai-major",
+            str(consumer.openai_major),
+            *framework_flags,
+        ],
+        cwd,
+    )
+
+
+def check_incompatible_extras(
+    wheel: Path, consumer: Consumer, python: Path, cwd: Path
+) -> None:
+    extras = f"{Framework.PYDANTIC_AI},{consumer.extras}"
+    result = run(
+        ["uv", "pip", "install", "--python", str(python), f"{wheel}[{extras}]"], cwd
+    )
+    if result.returncode == 0 or "No solution found" not in result.stderr:
+        raise RuntimeError("Incompatible extras did not fail dependency resolution")
+    logger.info("Incompatible extras rejected: %s", extras)
+
+
+def check_consumer(wheel: Path, consumer: Consumer) -> None:
+    with tempfile.TemporaryDirectory(prefix="band-wheel-") as directory:
+        cwd = Path(directory)
+        environment = cwd / "venv"
+        require_success(["uv", "venv", "--python", "3.12", str(environment)], cwd)
+        python = environment / (
+            "Scripts/python.exe" if sys.platform == "win32" else "bin/python"
+        )
+        install_consumer(wheel, consumer, python, cwd)
+        check_providers(consumer, python, cwd)
+        if consumer.rejects_pydantic_ai:
+            check_incompatible_extras(wheel, consumer, python, cwd)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("wheel", type=Path)
+    parser.add_argument("--case", choices=CONSUMERS, required=True)
+    args = parser.parse_args()
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    check_consumer(args.wheel.resolve(), CONSUMERS[args.case])
+
+
+if __name__ == "__main__":
+    main()

.github/scripts/wheelchecks.py

@@ -0,0 +1,46 @@
+"""Declared wheel-consumer combinations and their expected OpenAI compatibility."""
+
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class Framework(StrEnum):
+    PYDANTIC_AI = "pydantic-ai"
+    CREWAI = "crewai"
+    STRANDS = "strands"
+    NOOA = "nooa"
+    LANGGRAPH = "langgraph"
+    PARLANT = "parlant"
+
+
+@dataclass(frozen=True)
+class Consumer:
+    frameworks: tuple[Framework, ...]
+    openai_major: int
+    rejects_pydantic_ai: bool = False
+
+    @property
+    def extras(self) -> str:
+        return ",".join(self.frameworks)
+
+
+CONSUMERS: dict[str, Consumer] = {
+    consumer.extras.replace(",", "-"): consumer
+    for consumer in (
+        Consumer((Framework.PYDANTIC_AI,), 3),
+        Consumer((Framework.CREWAI,), 2, rejects_pydantic_ai=True),
+        Consumer((Framework.STRANDS,), 2, rejects_pydantic_ai=True),
+        Consumer((Framework.NOOA,), 2, rejects_pydantic_ai=True),
+        Consumer((Framework.LANGGRAPH, Framework.STRANDS), 2, rejects_pydantic_ai=True),
+        Consumer((Framework.LANGGRAPH,), 3),
+        Consumer((Framework.PARLANT,), 3),
+    )
+}
+
+
+if __name__ == "__main__":
+    sys.stdout.write(json.dumps({"case": list(CONSUMERS)}) + "\n")

.github/workflows/ci.yml

@@ -102,10 +102,10 @@ jobs:
       # Linux-only: doc snippets are OS-independent, and this step relies on
       # git ls-files globbing that we don't need to re-run per platform.
       if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
-      # examples/ READMEs have illustrative fragments not yet snippet-testable
+      # NOOA snippets run in test-strands-nooa; examples/ READMEs are illustrative.
       run: |
         # shellcheck disable=SC2046  # word-splitting the ls-files output is the point
-        uv run --all-packages pytest --markdown-docs $(git ls-files '*.md' ':!:examples/*') --no-cov
+        uv run --all-packages pytest --markdown-docs $(git ls-files '*.md' ':!:examples/*' ':!:docs/adapters/nooa.md') --no-cov
 
 
   test-crewai:
@@ -177,6 +177,79 @@ jobs:
           src/band/integrations/crewai/
 
 
+  test-strands-nooa:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: ['3.11', '3.12', '3.13']
+      fail-fast: false
+
+    # Use bash on every OS so the multiline pytest and pyrefly commands stay
+    # identical across Linux and Windows.
+    defaults:
+      run:
+        shell: bash
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+
+    - name: Configure git to use HTTPS for GitHub
+      uses: ./.github/actions/git-https-auth
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+      with:
+        enable-cache: true
+        cache-dependency-glob: "**/pyproject.toml"
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install Strands and NOOA dependencies
+      run: uv sync --all-packages --locked --extra dev-strands-nooa
+
+    - name: Collect baseline E2E in the Strands and NOOA environment
+      env:
+        BAND_ALLOW_MISSING_FRAMEWORKS: "1"
+        BAND_TEST_EXTRA: "dev-strands-nooa"
+      run: uv run --all-packages pytest tests/e2e/baseline/ --collect-only -q --no-cov
+
+    - name: Run Strands and NOOA tests
+      env:
+        # dev-strands-nooa lacks modern framework packages;
+        # tolerate missing framework configs instead of failing fast.
+        BAND_ALLOW_MISSING_FRAMEWORKS: "1"
+        BAND_TEST_EXTRA: "dev-strands-nooa"
+      run: |
+        uv run --all-packages pytest \
+          tests/adapters/test_strands_adapter.py \
+          tests/adapters/nooa/ \
+          tests/converters/test_strands.py \
+          tests/framework_conformance/ -k 'strands or nooa or legacy or probe_registry'
+
+    - name: Verify selected Strands and NOOA coverage
+      env:
+        BAND_ALLOW_MISSING_FRAMEWORKS: "1"
+        BAND_TEST_EXTRA: "dev-strands-nooa"
+      run: uv run --all-packages pytest tests/framework_conformance/test_strands_nooa_job_coverage.py
+
+    - name: Run NOOA markdown examples
+      if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.12'
+      run: uv run --all-packages pytest --markdown-docs docs/adapters/nooa.md --no-cov
+
+    - name: Pyrefly check (Strands and NOOA sources)
+      run: |
+        uv run --all-packages pyrefly check \
+          src/band/adapters/strands.py \
+          src/band/converters/strands.py \
+          src/band/adapters/nooa/ \
+          src/band/converters/nooa.py
+
+
   test-parlant:
     runs-on: ${{ matrix.os }}
     strategy:
@@ -369,3 +442,39 @@ jobs:
 
     - name: Verify band-mcp CLI entry point
       run: /tmp/band-mcp-install/bin/band-mcp --version
+
+
+  wheel-extra-cases:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.cases.outputs.matrix }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+    - name: Set up Python
+      uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7
+      with:
+        python-version: '3.12'
+    - name: Resolve wheel consumer cases
+      id: cases
+      run: echo "matrix=$(python3 .github/scripts/wheelchecks.py)" >> "$GITHUB_OUTPUT"
+
+  wheel-extras:
+    needs: wheel-extra-cases
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJSON(needs.wheel-extra-cases.outputs.matrix) }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+    - name: Install uv
+      uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
+    - name: Set up Python
+      uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7
+      with:
+        python-version: '3.12'
+    - name: Build wheel
+      run: uv build --wheel
+    - name: Check published extras and provider startup
+      run: python3 .github/scripts/check-wheel-extras.py dist/band_sdk-*.whl --case ${{ matrix.case }}