schemarouter 0.2.0a1__tar.gz → 0.3.0__tar.gz

schemarouter-0.3.0/.github/workflows/ci.yml

@@ -0,0 +1,190 @@
+name: CI
+
+on:
+  workflow_call:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: pytest -q -m "not mcp_integration"
+      - run: python examples/quickstart.py
+
+  windows-smoke:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.14"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: pytest -q -m "not mcp_integration"
+      - run: python examples/quickstart.py
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev,mcp,langchain,llamaindex,jev,otel]"
+      - run: pyright
+
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev,mcp,langchain,llamaindex,jev,otel]"
+      - run: pytest -q --cov=schemarouter --cov-branch --cov-report=term-missing --cov-report=xml:coverage.xml
+      - uses: actions/upload-artifact@v7
+        with:
+          name: coverage-report
+          path: coverage.xml
+          if-no-files-found: error
+          retention-days: 14
+
+  minimum-dependencies:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.10"
+      - run: python -m pip install --upgrade pip
+      - run: pip install "pytest>=8.2" "pytest-asyncio>=0.23"
+      - run: pip install "httpx==0.27.0" "jsonschema==4.23.0" "pydantic==2.8.0" "pyyaml==6.0.0"
+      - run: pip install -e . --no-deps
+      - run: pytest -q -m "not mcp_integration"
+      - run: python examples/quickstart.py
+
+  package:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install build twine
+      - run: python -m build
+      - run: twine check dist/*
+      - name: Verify license is packaged
+        run: |
+          python - <<'PY'
+          import glob
+          import zipfile
+
+          wheel = glob.glob("dist/*.whl")[0]
+          names = zipfile.ZipFile(wheel).namelist()
+          assert any(name.endswith("/licenses/LICENSE") for name in names), names
+          PY
+      - run: python -m venv /tmp/schemarouter-wheel
+      - run: /tmp/schemarouter-wheel/bin/python -m pip install --upgrade pip
+      - run: /tmp/schemarouter-wheel/bin/pip install dist/*.whl
+      - run: /tmp/schemarouter-wheel/bin/python -c "from importlib.metadata import version; import schemarouter; assert schemarouter.__version__ == version('schemarouter')"
+      - run: /tmp/schemarouter-wheel/bin/python examples/quickstart.py
+      - run: /tmp/schemarouter-wheel/bin/python scripts/benchmark_decision_routing.py
+      - run: python -m venv /tmp/schemarouter-sdist
+      - run: /tmp/schemarouter-sdist/bin/python -m pip install --upgrade pip
+      - run: /tmp/schemarouter-sdist/bin/pip install dist/*.tar.gz
+      - run: /tmp/schemarouter-sdist/bin/python -c "from importlib.metadata import version; import schemarouter; assert schemarouter.__version__ == version('schemarouter')"
+      - run: /tmp/schemarouter-sdist/bin/python examples/quickstart.py
+
+  langchain-integration:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev,langchain]"
+      - run: pytest -q tests/test_langchain_integration.py
+      - run: python examples/langchain_quickstart.py
+
+  llamaindex-integration:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev,llamaindex]"
+      - run: pytest -q tests/test_llamaindex_integration.py
+      - run: python examples/llamaindex_quickstart.py
+
+  jev-integration:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev,jev]"
+      - run: pytest -q tests/test_jev_integration.py
+
+  otel-integration:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev,otel]"
+      - run: pytest -q tests/test_opentelemetry_integration.py
+
+  mcp-integration:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev,mcp]"
+      - run: pytest -q tests/test_mcp_integration.py
+
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[docs]"
+      - run: mkdocs build --strict
+        env:
+          NO_MKDOCS_2_WARNING: "1"

schemarouter-0.3.0/.github/workflows/python-preview.yml

@@ -0,0 +1,30 @@
+name: Python Preview
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: python-preview-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  python-preview:
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.15.0-rc.2"
+          allow-prereleases: true
+      - run: python -m pip install --upgrade pip
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: pytest -q -m "not mcp_integration"
+      - run: python examples/quickstart.py

schemarouter-0.3.0/.github/workflows/release.yml

@@ -0,0 +1,353 @@
+name: Release
+
+on:
+  workflow_run:
+    workflows: ["CI"]
+    types: [completed]
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release-${{ github.repository }}
+  cancel-in-progress: false
+
+jobs:
+  prepare:
+    if: >-
+      (github.event_name == 'workflow_run' &&
+       github.event.workflow_run.conclusion == 'success' &&
+       github.event.workflow_run.head_branch == 'main') ||
+      (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v'))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    outputs:
+      should_release: ${{ steps.state.outputs.should_release }}
+      version: ${{ steps.metadata.outputs.version }}
+      tag: ${{ steps.metadata.outputs.tag }}
+      release_sha: ${{ steps.metadata.outputs.release_sha }}
+      release_notes: ${{ steps.metadata.outputs.release_notes }}
+      prerelease: ${{ steps.metadata.outputs.prerelease }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ github.event_name == 'workflow_run' && github.event.workflow_run.head_sha || github.ref_name }}
+          fetch-depth: 0
+
+      - name: Verify successful CI still refers to current main
+        if: github.event_name == 'workflow_run'
+        env:
+          TESTED_SHA: ${{ github.event.workflow_run.head_sha }}
+        run: |
+          git fetch origin main --tags
+          current_main="$(git rev-parse origin/main)"
+          if [[ "$current_main" != "$TESTED_SHA" ]]; then
+            echo "CI passed for stale main SHA $TESTED_SHA; current main is $current_main."
+            echo "SKIP_RELEASE=true" >> "$GITHUB_ENV"
+          fi
+
+      - name: Resolve release metadata and target SHA
+        id: metadata
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          TESTED_SHA: ${{ github.event.workflow_run.head_sha }}
+          PUSHED_TAG: ${{ github.ref_name }}
+        run: |
+          python - <<'PY'
+          import os
+          import re
+          import subprocess
+          import tomllib
+          from pathlib import Path
+
+          output_path = Path(os.environ["GITHUB_OUTPUT"])
+
+          def emit(**values: object) -> None:
+              with output_path.open("a", encoding="utf-8") as output:
+                  for key, value in values.items():
+                      print(f"{key}={value}", file=output)
+
+          if os.environ.get("SKIP_RELEASE") == "true":
+              emit(releasable="false")
+              raise SystemExit(0)
+
+          def read_version_at(ref: str | None = None) -> str:
+              if ref is None:
+                  content = Path("pyproject.toml").read_bytes()
+              else:
+                  content = subprocess.check_output(
+                      ["git", "show", f"{ref}:pyproject.toml"]
+                  )
+              return tomllib.loads(content.decode("utf-8"))["project"]["version"]
+
+          version = read_version_at()
+          if ".dev" in version:
+              emit(releasable="false")
+              raise SystemExit(0)
+
+          if not re.fullmatch(r"\d+\.\d+\.\d+(?:(?:a|b|rc)\d+)?", version):
+              raise SystemExit(
+                  f"unsupported automatic release version format: {version!r}"
+              )
+
+          release_notes = Path("docs") / "releases" / f"{version}.md"
+          if not release_notes.is_file():
+              raise SystemExit(f"missing release notes: {release_notes}")
+
+          changelog = Path("CHANGELOG.md").read_text(encoding="utf-8")
+          if f"## {version} -" not in changelog:
+              raise SystemExit(
+                  f"CHANGELOG.md is missing a dated {version} release heading"
+              )
+
+          tag = f"v{version}"
+          event_name = os.environ["EVENT_NAME"]
+
+          if event_name == "push":
+              pushed_tag = os.environ["PUSHED_TAG"]
+              if pushed_tag != tag:
+                  raise SystemExit(
+                      f"tag {pushed_tag!r} does not match package version {tag!r}"
+                  )
+              subprocess.check_call(["git", "fetch", "origin", "tag", tag, "--force"])
+              release_sha = subprocess.check_output(
+                  ["git", "rev-list", "-n", "1", tag],
+                  text=True,
+              ).strip()
+          else:
+              tested_sha = os.environ["TESTED_SHA"]
+              remote = subprocess.run(
+                  [
+                      "git",
+                      "ls-remote",
+                      "--exit-code",
+                      "--tags",
+                      "origin",
+                      f"refs/tags/{tag}",
+                  ],
+                  stdout=subprocess.DEVNULL,
+                  stderr=subprocess.DEVNULL,
+                  check=False,
+              )
+              if remote.returncode == 0:
+                  subprocess.check_call(
+                      ["git", "fetch", "origin", "tag", tag, "--force"]
+                  )
+                  release_sha = subprocess.check_output(
+                      ["git", "rev-list", "-n", "1", tag],
+                      text=True,
+                  ).strip()
+                  if release_sha != tested_sha:
+                      ancestor = subprocess.run(
+                          [
+                              "git",
+                              "merge-base",
+                              "--is-ancestor",
+                              release_sha,
+                              tested_sha,
+                          ],
+                          check=False,
+                      )
+                      if ancestor.returncode != 0:
+                          raise SystemExit(
+                              f"existing {tag} points to {release_sha}, which is not "
+                              f"an ancestor of green main {tested_sha}"
+                          )
+                      tagged_version = read_version_at(release_sha)
+                      if tagged_version != version:
+                          raise SystemExit(
+                              f"existing {tag} contains package version "
+                              f"{tagged_version!r}, expected {version!r}"
+                          )
+              else:
+                  release_sha = tested_sha
+
+          prerelease = bool(re.search(r"(?:a|b|rc)\d+(?:$|[.+-])", version))
+          emit(
+              releasable="true",
+              version=version,
+              tag=tag,
+              release_sha=release_sha,
+              release_notes=release_notes.as_posix(),
+              prerelease="true" if prerelease else "false",
+          )
+          PY
+
+      - name: Create annotated tag when missing
+        if: >-
+          github.event_name == 'workflow_run' &&
+          steps.metadata.outputs.releasable == 'true'
+        env:
+          RELEASE_SHA: ${{ steps.metadata.outputs.release_sha }}
+          RELEASE_TAG: ${{ steps.metadata.outputs.tag }}
+          RELEASE_VERSION: ${{ steps.metadata.outputs.version }}
+        run: |
+          if git ls-remote --exit-code --tags origin "refs/tags/$RELEASE_TAG" >/dev/null 2>&1; then
+            echo "$RELEASE_TAG already exists."
+            exit 0
+          fi
+
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git tag -a "$RELEASE_TAG" "$RELEASE_SHA" -m "SchemaRouter $RELEASE_VERSION"
+          git push origin "refs/tags/$RELEASE_TAG"
+
+      - name: Check whether GitHub release already exists
+        id: state
+        if: steps.metadata.outputs.releasable == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ steps.metadata.outputs.tag }}
+        run: |
+          if gh release view "$RELEASE_TAG" >/dev/null 2>&1; then
+            echo "should_release=false" >> "$GITHUB_OUTPUT"
+            echo "$RELEASE_TAG is already published on GitHub."
+          else
+            echo "should_release=true" >> "$GITHUB_OUTPUT"
+          fi
+
+  build:
+    needs: prepare
+    if: needs.prepare.outputs.should_release == 'true'
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ needs.prepare.outputs.version }}
+      release_notes: ${{ needs.prepare.outputs.release_notes }}
+      prerelease: ${{ needs.prepare.outputs.prerelease }}
+      tag: ${{ needs.prepare.outputs.tag }}
+      release_sha: ${{ needs.prepare.outputs.release_sha }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ needs.prepare.outputs.release_sha }}
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - name: Verify release checkout metadata
+        env:
+          RELEASE_VERSION: ${{ needs.prepare.outputs.version }}
+        run: |
+          python - <<'PY'
+          import os
+          import tomllib
+          from pathlib import Path
+
+          version = tomllib.loads(Path("pyproject.toml").read_text())["project"]["version"]
+          expected = os.environ["RELEASE_VERSION"]
+          if version != expected:
+              raise SystemExit(
+                  f"release checkout version {version!r} does not match {expected!r}"
+              )
+          PY
+      - run: python -m pip install --upgrade pip
+      - run: pip install build twine
+      - run: python -m build
+      - run: twine check dist/*
+      - name: Verify release artifacts
+        env:
+          RELEASE_VERSION: ${{ needs.prepare.outputs.version }}
+        run: |
+          python - <<'PY'
+          import glob
+          import os
+          import subprocess
+          import sys
+          import tempfile
+          import venv
+          import zipfile
+          from pathlib import Path
+
+          wheel = glob.glob("dist/*.whl")[0]
+          sdist = glob.glob("dist/*.tar.gz")[0]
+
+          wheel_names = zipfile.ZipFile(wheel).namelist()
+          assert any(name.endswith("/licenses/LICENSE") for name in wheel_names), wheel_names
+
+          import tarfile
+
+          with tarfile.open(sdist, "r:gz") as archive:
+              sdist_names = archive.getnames()
+          assert any(name.endswith("/LICENSE") for name in sdist_names), sdist_names
+
+          for artifact in (wheel, sdist):
+              with tempfile.TemporaryDirectory() as root:
+                  env = Path(root) / "venv"
+                  venv.EnvBuilder(with_pip=True).create(env)
+                  python = env / (
+                      "Scripts/python.exe" if sys.platform == "win32" else "bin/python"
+                  )
+                  subprocess.check_call([str(python), "-m", "pip", "install", artifact])
+                  subprocess.check_call(
+                      [
+                          str(python),
+                          "-c",
+                          (
+                              "from importlib.metadata import version; "
+                              "import schemarouter; "
+                              f"assert schemarouter.__version__ == "
+                              f"{os.environ['RELEASE_VERSION']!r}; "
+                              f"assert version('schemarouter') == "
+                              f"{os.environ['RELEASE_VERSION']!r}"
+                          ),
+                      ]
+                  )
+                  subprocess.check_call([str(python), "examples/quickstart.py"])
+          PY
+      - uses: actions/upload-artifact@v7
+        with:
+          name: python-dist
+          path: dist/
+          if-no-files-found: error
+          retention-days: 7
+
+  github-release:
+    needs: [prepare, build]
+    if: needs.prepare.outputs.should_release == 'true'
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          ref: ${{ needs.prepare.outputs.release_sha }}
+      - uses: actions/download-artifact@v8
+        with:
+          name: python-dist
+          path: dist
+      - name: Create GitHub release
+        env:
+          GH_TOKEN: ${{ github.token }}
+          RELEASE_TAG: ${{ needs.prepare.outputs.tag }}
+          RELEASE_VERSION: ${{ needs.prepare.outputs.version }}
+          RELEASE_NOTES: ${{ needs.prepare.outputs.release_notes }}
+          IS_PRERELEASE: ${{ needs.prepare.outputs.prerelease }}
+        run: |
+          prerelease_args=()
+          if [[ "$IS_PRERELEASE" == "true" ]]; then
+            prerelease_args+=(--prerelease)
+          fi
+
+          gh release create "$RELEASE_TAG" dist/*             --title "SchemaRouter $RELEASE_VERSION"             --notes-file "$RELEASE_NOTES"             "${prerelease_args[@]}"             --verify-tag
+
+  pypi:
+    needs: [prepare, build]
+    if: needs.prepare.outputs.should_release == 'true'
+    permissions:
+      id-token: write
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/schemarouter/
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: python-dist
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/
+          skip-existing: true

schemarouter-0.3.0/CHANGELOG.md

@@ -0,0 +1,119 @@
+# Changelog
+
+All notable changes to SchemaRouter are documented here.
+
+The project is pre-1.0 and follows the compatibility rules in
+[`docs/versioning.md`](docs/versioning.md).
+
+## Unreleased
+
+## 0.3.0 - 2026-09-22
+
+### Changed
+
+- promoted the 0.3 line to the first non-prerelease release after the 0.3.0a1 validation cycle;
+- standard PyPI installation no longer requires `--pre`;
+- package maturity metadata now identifies the project as beta while retaining the documented
+  pre-1.0 compatibility policy;
+- GitHub Pages deployment and protected-main required-check enforcement are now active repository
+  controls.
+
+### Compatibility
+
+- no intentional public API changes were introduced relative to 0.3.0a1;
+- the 0.x line remains pre-1.0, so later minor releases may still include deliberate, documented
+  compatibility changes.
+
+## 0.3.0a1 - 2026-09-22
+
+### Added
+
+- provider-neutral bounded `DecisionBackend` contracts with deterministic fallback;
+- optional `JevDecisionBackend` backed by TypeSafe System One through `schemarouter[jev]`;
+- optional LlamaIndex `FunctionTool` integration;
+- runnable LangChain and LlamaIndex integration examples enforced in CI;
+- provider-neutral decision-routing benchmark harness covering accuracy, abstention, latency,
+  token usage, and optional cost estimation;
+- explicit ecosystem compatibility matrix and integration maintenance policy;
+- Korean project overview in `README.ko.md`;
+- Python 3.13 and 3.14 core CI coverage;
+- a non-blocking Python 3.15 release-candidate preview;
+- a Windows + Python 3.14 smoke surface;
+- a Pyright static-type gate for the typed package surface;
+- full-suite branch-coverage reporting with an 82% blocking floor;
+- declared lower-bound runtime dependency testing;
+- clean wheel and sdist installation smoke tests;
+- a checked-in 144-case multilingual/adversarial decision-routing corpus with JSON/CSV output,
+  category metrics, invalid-plan rate, abstention/fallback tracking, and p50/p95 latency;
+- machine-readable OpenAPI compatibility reports for partial/unsupported constructs;
+- authenticated MCP trusted-header and custom client-factory transport boundaries;
+- trusted sync/async per-call approval callbacks;
+- per-run execution budgets for logical calls, attempts, remote attempts, elapsed time, per-tool
+  quotas, and application-defined cost units;
+- optional privacy-preserving OpenTelemetry run/tool span export;
+- explicit allowlisted third-party adapter plugins through `schemarouter.adapters` entry points.
+
+### Changed
+
+- release preparation now uses explicit PEP 440 release versions while normal post-release
+  development returns to a `.dev0` version;
+- release automation now derives version, release title, release-note path, prerelease state, and
+  artifact verification from `pyproject.toml` instead of hard-coded release literals;
+- release publication now consumes a successful current-`main` CI result, verifies or creates the
+  annotated version tag, and clean-installs both wheel and sdist artifacts before publication;
+- superseded pull-request CI runs are cancelled automatically to avoid stale validation consuming
+  runner capacity;
+- releasable `main` commits are automatically published by the top-level Release workflow only
+  after green CI, current-head verification, release-note/changelog validation, and duplicate-tag
+  checks; existing unpublished tags may be resumed only from a compatible ancestor SHA.
+
+### Security
+
+- OpenAPI runtime responses are now streamed through a bounded reader with a 16 MiB default limit,
+  enforcing the bound both from declared `Content-Length` and actual bytes received;
+- Jev option IDs are validated before confidence-based abstention, so unknown IDs always fail
+  closed;
+- Jev credentials remain SDK client configuration and are never placed in model state;
+- `DecisionOption.metadata` is not forwarded to Jev;
+- provider failures can deterministically fall back without weakening execution policy;
+- MCP credentials are rejected in URLs and remain outside tool/planner metadata;
+- MCP protocol-controlled headers cannot be overridden through trusted runtime headers;
+- adapter entry points are metadata-only during discovery and are never auto-imported;
+- OpenTelemetry export omits payload values, RunConfig metadata, tags, and exception messages;
+- approval callback failures and execution budget exhaustion fail closed.
+
+## 0.2.0a1 - 2026-09-20
+
+### Added
+
+- pluggable structured-source `AdapterRegistry` with explicit and priority-based auto discovery;
+- OPTIMADE v1 discovery through base and entry-type info endpoints;
+- OPTIMADE field-aware execution that maps planned fields to `response_fields`;
+- call-aware invoker support for protocol adapters that need the full `ToolCall`;
+- typed tool, endpoint, parameter, response-field, plan, and result contracts;
+- namespaced versioned registry;
+- schema-aware planning with recall-preserving field projection;
+- provider-neutral model-assisted query analysis;
+- OpenAPI 3.x URL ingestion and guarded HTTP execution;
+- MCP tool discovery and execution;
+- evidence-grounded proposals for human-readable API documentation;
+- runtime JSON Schema validation for arguments and raw outputs;
+- schema and invoker-binding drift detection;
+- fail-closed execution policy for mutations, destructive calls, and unclassified remote tools;
+- Runnable-style `invoke`, `batch`, `stream`, and typed event APIs;
+- run configuration, concurrency control, and safe retry policy;
+- typed Python callable registration with `@schema_tool`;
+- optional LangChain `StructuredTool` integration;
+- framework maturity, architecture, release, and versioning documentation;
+- MIT licensing and package metadata;
+- MkDocs Material documentation site with guides, recipes, and generated API reference;
+- SchemaRouter brace-and-routing-hub brand system with light/dark marks, lockups, favicon, and
+  social preview source artwork.
+
+### Security
+
+- separated schema-fetch credentials from runtime API credentials;
+- restricted schema redirects and runtime API origins;
+- blocked model/tool control of sensitive runtime headers;
+- redacted event payloads by default;
+- prevented automatic retries for non-read-only calls.