agentcheck-ai 0.1.0__tar.gz

agentcheck_ai-0.1.0/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,49 @@
+name: Bug report
+description: Something AgentCheck did that it should not have, or did not do that it should
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Please do not paste API keys, provider payloads, or customer data.
+        Artifacts under `.agentcheck/` can contain prompts, model output and
+        absolute paths — read before pasting.
+
+        For a security vulnerability, do not open an issue. See SECURITY.md.
+  - type: textarea
+    id: what
+    attributes:
+      label: What happened
+      description: What you expected, and what you got instead.
+    validations:
+      required: true
+  - type: dropdown
+    id: framework
+    attributes:
+      label: Framework adapter
+      options: ["OpenAI Agents SDK", "PydanticAI", "Neither / not applicable"]
+    validations:
+      required: true
+  - type: input
+    id: versions
+    attributes:
+      label: Versions
+      description: AgentCheck version, framework SDK version, Python version.
+      placeholder: "agentcheck 0.1.0, openai-agents 0.20.0, Python 3.12"
+    validations:
+      required: true
+  - type: dropdown
+    id: verdict
+    attributes:
+      label: Verdict involved
+      description: INFRA_ERROR usually means the harness failed, not your agent.
+      options: ["PASS", "FAIL", "INCONCLUSIVE", "INFRA_ERROR", "No verdict / command failed"]
+    validations:
+      required: true
+  - type: textarea
+    id: repro
+    attributes:
+      label: Reproduction
+      description: The command you ran and, if possible, a minimal target.
+    validations:
+      required: true

agentcheck_ai-0.1.0/.github/workflows/agentcheck-example.yml

@@ -0,0 +1,101 @@
+# Example AgentCheck regression gate.
+#
+# Copy this workflow into a repository that has an AgentCheck target, then:
+#   1. Set AGENTCHECK_TARGET to that directory (often ".").
+#   2. Commit a trusted baseline produced by an explicit command, not by a
+#      failing CI run:
+#         agentcheck test "$AGENTCHECK_TARGET" --no-store
+#         agentcheck baseline create "$AGENTCHECK_TARGET" --latest --out agentcheck-baseline.json
+#   3. Enable pull_request/push triggers if you want this on every change.
+#
+# This workflow does not call a hosted AgentCheck service, does not use the
+# GitHub API, and does not supply provider credentials. It fails only on new
+# or changed authoritative FAIL identities, not on historical failures and
+# not on INCONCLUSIVE.
+#
+# This repository is not itself an AgentCheck target at its root. The default
+# below points at the bundled deterministic example. There is no committed
+# example baseline here; workflow_dispatch will exit 2 until you create one
+# locally or in a consuming project.
+
+# Runner note: this workflow is deliberately GitHub-hosted, unlike ci.yml.
+# It is a template meant to be copied into a project that uses AgentCheck, so
+# pointing it at a self-hosted label would hand every reader a workflow that
+# runs on exactly one machine. It is workflow_dispatch only, so it costs
+# nothing until someone triggers it. See docs/ci-trust-model.md.
+
+name: AgentCheck
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PIP_DISABLE_PIP_VERSION_CHECK: "1"
+  PYTHONDONTWRITEBYTECODE: "1"
+  AGENTCHECK_TARGET: examples/evaluation/account_agent
+  AGENTCHECK_BASELINE: agentcheck-baseline.json
+
+jobs:
+  regression-gate:
+    name: Compare against a trusted baseline
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.12"
+          cache: pip
+          cache-dependency-path: pyproject.toml
+
+      - name: Install AgentCheck
+        run: |
+          python -m pip install --upgrade "pip==26.1.2" "setuptools==83.0.0"
+          python -m pip install ".[openai-agents]"
+
+      - name: Run deterministic AgentCheck tests
+        run: |
+          set +e
+          agentcheck test "$AGENTCHECK_TARGET" --no-store --run-id "ci-${{ github.run_id }}"
+          status=$?
+          set -e
+          # Historical FAILs (1) and INCONCLUSIVE (3) are not release blockers.
+          # The baseline check decides whether any FAIL is new. Infrastructure (2)
+          # still fails the job.
+          if [ "$status" -eq 2 ] || [ "$status" -eq 130 ]; then
+            exit "$status"
+          fi
+          if [ "$status" -gt 3 ]; then
+            exit "$status"
+          fi
+
+      - name: Require a committed baseline
+        run: |
+          baseline="$AGENTCHECK_TARGET/$AGENTCHECK_BASELINE"
+          if [ ! -f "$baseline" ]; then
+            echo "No trusted baseline at $baseline"
+            echo "Create one explicitly with:"
+            echo "  agentcheck baseline create \"$AGENTCHECK_TARGET\" --latest --out $AGENTCHECK_BASELINE"
+            echo "A failing test run is never an implicit baseline."
+            exit 2
+          fi
+
+      - name: Fail on new authoritative regressions
+        run: |
+          agentcheck baseline check "$AGENTCHECK_TARGET" \
+            --baseline "$AGENTCHECK_BASELINE" \
+            --run-id "ci-${{ github.run_id }}" \
+            --json

agentcheck_ai-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,341 @@
+# Normal AgentCheck CI.
+#
+# ============================================================================
+# READ BEFORE MAKING THIS REPOSITORY PUBLIC
+# ============================================================================
+# Every job below runs on `agentcheck-local`, a self-hosted runner that is a
+# maintainer's own workstation. That is acceptable *only* while this repository
+# is private and every branch in it is written by the owner.
+#
+# The moment this repository becomes public, anyone can open a pull request
+# containing arbitrary code. Running that on this runner is remote code
+# execution on a personal machine with its filesystem, its network, and its
+# credentials.
+#
+# The `if:` guard on each job is what stands in the way: it admits pushes and
+# same-repository pull requests only, so a fork's pull request is skipped
+# rather than executed. Going public therefore does not silently expose the
+# runner -- but it does leave external contributors with no CI at all, which is
+# not a workable open-source project.
+#
+# So before publication, the tests and checks jobs must move back to
+# GitHub-hosted or isolated ephemeral runners. `docs/ci-trust-model.md` records
+# the full argument and the exact change. scripts/check_workflow_safety.py
+# proves the guard holds in the meantime, and it runs as part of this workflow.
+# ============================================================================
+#
+# No job here needs a secret, and none makes a provider call.
+
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  PIP_DISABLE_PIP_VERSION_CHECK: "1"
+  PYTHONDONTWRITEBYTECODE: "1"
+  # The interpreter that runs the whole suite. Every other supported version
+  # runs the cross-version suite from tests/compat_manifest.py.
+  PRIMARY_PYTHON: "3.12"
+
+jobs:
+  tests:
+    name: Tests (Python ${{ matrix.python-version }})
+    # Carried by every job independently: a job-level `if` is not inherited, so
+    # a single unguarded job would be enough to run a fork's code on this
+    # machine.
+    #
+    # An allowlist, not `event_name != 'pull_request'`. A deny-list admits any
+    # trigger added to `on:` later -- a workflow_dispatch from a fork's branch,
+    # a future pull_request_target -- without anyone noticing. Naming the two
+    # trusted contexts means a new trigger has to be added here deliberately
+    # before it can reach this runner.
+    if: >-
+      github.event_name == 'push'
+      || (github.event_name == 'pull_request'
+          && github.event.pull_request.head.repo.full_name == github.repository)
+    runs-on: [self-hosted, Linux, X64]
+    # The suite measured 20:00 at -n 2 on this machine. 40 leaves real margin
+    # for a workstation's own background load without letting a hung job hold
+    # the single runner all afternoon.
+    timeout-minutes: 40
+    strategy:
+      fail-fast: false
+      matrix:
+        # One runner means these queue serially, so every entry is wall-clock a
+        # pull request waits. On a pull request all three supported versions run;
+        # after merge only the primary does, because the merge-race this second
+        # run exists to catch would show up on any interpreter. See the Test step.
+        python-version: ${{ github.event_name == 'push' && fromJSON('["3.12"]') || fromJSON('["3.10", "3.11", "3.12"]') }}
+
+    env:
+      # A self-hosted runner inherits the service environment of a machine that
+      # holds real credentials, so every variable this package reads is pinned
+      # to an inert value. AgentCheck's environment surface is small: a grep for
+      # os.environ/os.getenv across the package and tests finds only the name
+      # below, plus OPENAI_API_KEY.
+      #
+      # Deliberately absent: OPENAI_API_KEY. agentcheck/inspect/extractor.py
+      # branches on whether that name is *present*, and `FOO: ""` makes it
+      # present. Pinning it here would change what those tests observe. The
+      # runner environment is verified credential-free by a step below instead.
+      AGENTCHECK_ALLOWED_TEST: ""
+
+    steps:
+      - name: Checkout
+        # The default clean: true runs git clean -ffdx, which clears the
+        # editable-install egg-info, __pycache__, and anything else a previous
+        # job left in this persistent workspace.
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        # Not actions/setup-python. The interpreters it downloads record the
+        # absolute path of their own libpython as
+        # /opt/hostedtoolcache/Python/<version>/x64/lib, which exists only on a
+        # GitHub-hosted VM. This runner keeps its tool cache elsewhere, so the
+        # loader substitutes the host's libpython and the job ends up running a
+        # standard library and a core from different releases. uv's
+        # interpreters resolve libpython relative to the executable, so they
+        # stay correct wherever they are unpacked.
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        with:
+          version: "0.9.18"
+          # This runner keeps uv's cache on local disk between jobs, so a
+          # GitHub cache round-trip would be pure overhead.
+          enable-cache: false
+
+      - name: Verify no provider credential reached this job
+        # The suite asserts on how AgentCheck behaves when a provider
+        # credential is absent, and extractor.py takes a different branch when
+        # OPENAI_API_KEY is present. A key exported into the runner service
+        # would not fail loudly -- it would quietly change what several tests
+        # observe. Names only; no value is read or printed.
+        run: |
+          for name in OPENAI_API_KEY ANTHROPIC_API_KEY GOOGLE_API_KEY; do
+            if printenv "$name" >/dev/null 2>&1; then
+              echo "$name is present in this job's environment; the suite expects it absent" >&2
+              exit 1
+            fi
+          done
+          echo "PASS: no provider credential is visible to this job"
+
+      - name: Create an isolated virtual environment
+        # only-managed rather than whatever Python the host publishes: the job
+        # should test the version the matrix names, not a host build that
+        # merely shares its minor number. RUNNER_TEMP is recreated per job.
+        run: |
+          uv venv --python "${{ matrix.python-version }}" \
+            --python-preference only-managed "$RUNNER_TEMP/venv"
+          echo "$RUNNER_TEMP/venv/bin" >> "$GITHUB_PATH"
+
+      - name: Verify interpreter integrity
+        # Seconds, before anything expensive. A mismatched interpreter does not
+        # fail honestly: it segfaults the worker subprocesses and arrives as a
+        # wall of behavioural failures with no diagnostics -- exactly the
+        # infrastructure-as-product-failure confusion AgentCheck exists to
+        # prevent.
+        run: python scripts/check_interpreter_integrity.py "${{ matrix.python-version }}"
+
+      - name: Install
+        run: uv pip install --python "$RUNNER_TEMP/venv/bin/python" -e ".[dev]"
+
+      - name: Compile Python sources
+        run: python -m compileall -q agentcheck scripts examples tests
+
+      - name: Test
+        # -n 2, measured rather than guessed, and not a knob to turn up.
+        #
+        # Every scenario runs in its own child process under a 10s wall-clock
+        # budget. That budget is a product default and the suite's ability to
+        # notice a starved scenario depends on it, so it is never raised to buy
+        # CI headroom. pytest-xdist workers each spawn their own scenario
+        # children, so the worker count decides whether those children get
+        # their budget. On this 14-core machine -n 2 has a green history; -n 3
+        # and -n 4 were benchmarked and starved scenarios, turning real
+        # verdicts into worker_timeout.
+        #
+        # The primary interpreter runs everything. The others run the
+        # cross-version suite, whose contents and rationale live in
+        # tests/compat_manifest.py and are enforced by
+        # tests/agentcheck/test_compat_manifest.py -- the list is read from the
+        # manifest here rather than duplicated, so the two cannot drift.
+        #
+        # The package has no sys.version_info branching, so what differs between
+        # interpreters is where it meets one: recursive TypeAliasType models,
+        # subprocess workers, import machinery, SDK internals and the CLI entry
+        # point. Those all run on every version. Pure logic over already-built
+        # objects runs once.
+        run: |
+          if [ "${{ matrix.python-version }}" = "$PRIMARY_PYTHON" ]; then
+            python -m pytest -p no:cacheprovider tests -q -n 2
+          else
+            mapfile -t compat < <(python tests/compat_manifest.py)
+            echo "cross-version suite: ${#compat[@]} files"
+            python -m pytest -p no:cacheprovider "${compat[@]}" -q -n 2
+          fi
+
+  checks:
+    # One job, not five. There is a single self-hosted runner, so every extra
+    # job is another slot in a serial queue: as separate jobs these checks cost
+    # a few minutes of work but five job setups and five checkouts, all waiting
+    # behind each other. Merged into one job they stay individually named
+    # steps, so each result is still visible, and `!cancelled()` keeps a
+    # failure in one check from hiding the outcome of the rest.
+    name: Quality, packaging, extras, and runner trust
+    if: >-
+      github.event_name == 'push'
+      || (github.event_name == 'pull_request'
+          && github.event.pull_request.head.repo.full_name == github.repository)
+    runs-on: [self-hosted, Linux, X64]
+    timeout-minutes: 30
+
+    env:
+      AGENTCHECK_ALLOWED_TEST: ""
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        with:
+          version: "0.9.18"
+          enable-cache: false
+
+      - name: Verify no provider credential reached this job
+        run: |
+          for name in OPENAI_API_KEY ANTHROPIC_API_KEY GOOGLE_API_KEY; do
+            if printenv "$name" >/dev/null 2>&1; then
+              echo "$name is present in this job's environment" >&2
+              exit 1
+            fi
+          done
+          echo "PASS: no provider credential is visible to this job"
+
+      - name: Create isolated virtual environments
+        run: |
+          uv venv --python 3.12 --python-preference only-managed "$RUNNER_TEMP/venv"
+          uv venv --python 3.12 --python-preference only-managed "$RUNNER_TEMP/base-venv"
+          uv venv --python 3.12 --python-preference only-managed "$RUNNER_TEMP/openai-venv"
+          uv venv --python 3.12 --python-preference only-managed "$RUNNER_TEMP/pydantic-venv"
+          uv venv --python 3.12 --python-preference only-managed "$RUNNER_TEMP/wheel-venv"
+          echo "$RUNNER_TEMP/venv/bin" >> "$GITHUB_PATH"
+
+      - name: Verify interpreter integrity
+        run: python scripts/check_interpreter_integrity.py "3.12"
+
+      - name: Install
+        run: uv pip install --python "$RUNNER_TEMP/venv/bin/python" -e ".[dev]"
+
+      - name: Verify no untrusted context can reach this runner
+        # Every job here runs on a personal machine, and a job-level `if` is not
+        # inherited, so the guards are the only thing between a fork's branch
+        # and this host. They are checked by evaluating them against synthetic
+        # push, same-repo, fork, pull_request_target, workflow_run,
+        # workflow_dispatch, and issue_comment contexts rather than by matching
+        # their text, because the mistakes worth catching are logical ones.
+        if: ${{ !cancelled() }}
+        run: python scripts/check_workflow_safety.py
+
+      - name: Ruff
+        if: ${{ !cancelled() }}
+        run: python -m ruff check agentcheck tests scripts
+
+      - name: Mypy
+        if: ${{ !cancelled() }}
+        run: python -m mypy agentcheck
+
+      - name: Secret scan
+        if: ${{ !cancelled() }}
+        run: python scripts/check_no_secrets.py
+
+      - name: Base install has no framework
+        # A base install must import and run with neither framework present.
+        if: ${{ !cancelled() }}
+        run: |
+          uv pip install --python "$RUNNER_TEMP/base-venv/bin/python" .
+          "$RUNNER_TEMP/base-venv/bin/python" - <<'PY'
+          import importlib.util, subprocess
+          for framework in ("agents", "pydantic_ai"):
+              assert importlib.util.find_spec(framework) is None, (
+                  f"{framework} must not be a base dependency"
+              )
+          import agentcheck
+          print("base import ok:", agentcheck.__version__)
+          PY
+          "$RUNNER_TEMP/base-venv/bin/agentcheck" --help > /dev/null
+
+      - name: A missing extra is actionable, not a traceback
+        if: ${{ !cancelled() }}
+        run: |
+          "$RUNNER_TEMP/base-venv/bin/python" - <<'PY'
+          from agentcheck.adapters import AdapterDependencyError
+          from agentcheck.adapters.openai_agents import _require_sdk as need_openai
+          from agentcheck.adapters.pydantic_ai import _require_sdk as need_pydantic
+
+          for require in (need_openai, need_pydantic):
+              try:
+                  require()
+              except AdapterDependencyError as exc:
+                  assert "pip install" in str(exc), exc
+                  print("ok:", exc)
+              else:
+                  raise AssertionError(f"{require} should have refused")
+          PY
+
+      - name: Extra openai-agents in isolation
+        # Installed alone, so a leak from the other extra shows up here rather
+        # than being masked by a combined environment.
+        if: ${{ !cancelled() }}
+        run: |
+          uv pip install --python "$RUNNER_TEMP/openai-venv/bin/python" ".[openai-agents]" pytest
+          "$RUNNER_TEMP/openai-venv/bin/python" -c "
+          import importlib.util
+          assert importlib.util.find_spec('agents') is not None
+          assert importlib.util.find_spec('pydantic_ai') is None, 'pydantic-ai leaked'
+          "
+          "$RUNNER_TEMP/openai-venv/bin/python" -m pytest tests/agentcheck/test_openai_adapter.py -q
+
+      - name: Extra pydantic-ai in isolation
+        if: ${{ !cancelled() }}
+        run: |
+          uv pip install --python "$RUNNER_TEMP/pydantic-venv/bin/python" ".[pydantic-ai]" pytest
+          "$RUNNER_TEMP/pydantic-venv/bin/python" -c "
+          import importlib.util
+          assert importlib.util.find_spec('pydantic_ai') is not None
+          assert importlib.util.find_spec('agents') is None, 'openai-agents leaked'
+          "
+          "$RUNNER_TEMP/pydantic-venv/bin/python" -m pytest tests/agentcheck/test_pydantic_ai_adapter.py -q
+
+      - name: Build wheel and sdist
+        if: ${{ !cancelled() }}
+        run: python -m build --outdir "$RUNNER_TEMP/dist"
+
+      - name: Audit artifact contents
+        if: ${{ !cancelled() }}
+        run: |
+          rm -rf dist && cp -r "$RUNNER_TEMP/dist" dist
+          python scripts/check_distribution.py
+
+      - name: Wheel install smoke test
+        if: ${{ !cancelled() }}
+        run: |
+          uv pip install --python "$RUNNER_TEMP/wheel-venv/bin/python" "$RUNNER_TEMP"/dist/*.whl
+          cd "$RUNNER_TEMP"
+          "$RUNNER_TEMP/wheel-venv/bin/python" -c "import agentcheck; print(agentcheck.__version__)"
+          "$RUNNER_TEMP/wheel-venv/bin/agentcheck" --help > /dev/null
+          echo "wheel install smoke passed"

agentcheck_ai-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,133 @@
+# PyPI Trusted Publishing. This workflow intentionally has no manual trigger:
+# publishing starts only when a non-prerelease GitHub Release is published.
+#
+# Before the first release, create the `pypi` GitHub Environment with a required
+# reviewer (where the repository plan supports it), then register this exact
+# workflow and environment as the pending publisher for `agentcheck-ai` on PyPI.
+
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pypi-${{ github.event.release.tag_name }}
+  cancel-in-progress: false
+
+jobs:
+  build:
+    name: Build and validate distributions
+    if: ${{ github.event.release.prerelease == false }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    permissions:
+      contents: read
+
+    steps:
+      - name: Checkout the published release tag
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        with:
+          python-version: "3.12"
+
+      - name: Verify release source and version
+        env:
+          DEFAULT_BRANCH: ${{ github.event.repository.default_branch }}
+          RELEASE_SHA: ${{ github.sha }}
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+        run: |
+          python - <<'PY'
+          import os
+          import pathlib
+          import tomllib
+
+          metadata = tomllib.loads(pathlib.Path("pyproject.toml").read_text(encoding="utf-8"))
+          version = metadata["project"]["version"]
+          expected_tag = f"v{version}"
+          release_tag = os.environ["RELEASE_TAG"]
+          if release_tag != expected_tag:
+              raise SystemExit(
+                  f"release tag {release_tag!r} does not match package version {version!r}; "
+                  f"expected {expected_tag!r}"
+              )
+          print(f"release tag matches agentcheck-ai {version}")
+          PY
+
+          if [ "$(git rev-parse HEAD)" != "$RELEASE_SHA" ]; then
+            echo "checked-out source does not match the published release tag" >&2
+            exit 1
+          fi
+
+          if ! git merge-base --is-ancestor HEAD "refs/remotes/origin/$DEFAULT_BRANCH"; then
+            echo "published release tag is not reachable from $DEFAULT_BRANCH" >&2
+            exit 1
+          fi
+
+      - name: Install build validation tools
+        run: python -m pip install "build==1.5.0" "twine==7.0.0"
+
+      - name: Build wheel and source distribution
+        run: python -m build
+
+      - name: Validate distributions
+        run: |
+          python -m twine check --strict dist/*
+          python scripts/check_distribution.py
+          python - <<'PY'
+          import pathlib
+          import tomllib
+
+          metadata = tomllib.loads(pathlib.Path("pyproject.toml").read_text(encoding="utf-8"))
+          version = metadata["project"]["version"]
+          expected = {
+              f"agentcheck_ai-{version}-py3-none-any.whl",
+              f"agentcheck_ai-{version}.tar.gz",
+          }
+          actual = {path.name for path in pathlib.Path("dist").iterdir() if path.is_file()}
+          if actual != expected:
+              raise SystemExit(
+                  f"release artifact set mismatch: expected {sorted(expected)!r}, "
+                  f"found {sorted(actual)!r}"
+              )
+          print(f"validated release artifacts: {sorted(actual)!r}")
+          PY
+
+      - name: Upload validated distributions
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: python-package-distributions
+          path: dist/
+          if-no-files-found: error
+          retention-days: 1
+
+  publish:
+    name: Publish distributions to PyPI
+    if: ${{ github.event.release.prerelease == false }}
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    environment:
+      name: pypi
+      url: https://pypi.org/p/agentcheck-ai
+    permissions:
+      id-token: write
+
+    steps:
+      - name: Download validated distributions
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Publish distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2