feat: add Inspect AI integration package (learning-commons-inspect-scorers)

Adds integrations/inspect-python with InspectModelAdapter (wraps Inspect's
get_model() to satisfy LLMGeneratorProtocol) and gla_scorer() — an Inspect
scorer for grade-level appropriateness, wired to the GLA evaluator via the
injected-provider protocol from the SDK.

- inspect-ai>=0.3.214 (Score.unscored() lower bound)
- registered for independent release via release-please

Split out from the combined integrations PR so the Inspect path — which has a
real consumer (edu-panda-skill-harness) — can be validated and merged on its own.

Author: adnanrhussain

.release-please-manifest.json

@@ -1,5 +1,6 @@
 {
   "evals/prompts": "1.5.0",
   "sdks/python": "0.2.0",
-  "sdks/typescript": "0.7.0"
+  "sdks/typescript": "0.7.0",
+  "integrations/inspect-python": "0.1.0"
 }

integrations/inspect-python/.gitignore

@@ -0,0 +1,6 @@
+*.egg-info/
+dist/
+build/
+__pycache__/
+.pytest_cache/
+.mypy_cache/

integrations/inspect-python/CHANGELOG.md

@@ -0,0 +1 @@
+# Changelog

integrations/inspect-python/README.md

@@ -0,0 +1,73 @@
+# learning-commons-inspect-scorers
+
+[Inspect AI](https://inspect.aisi.org.uk/) scorer wrappers for the [Learning Commons evaluators](https://github.com/learning-commons-org/evaluators) SDK.
+
+## Installation
+
+```bash
+pip install learning-commons-inspect-scorers
+```
+
+> **Note:** Requires `learning-commons-evaluators>=0.2.0`. During local development
+> install the SDK from the repo root first:
+> ```bash
+> pip install -e sdks/python
+> pip install -e integrations/inspect-python
+> ```
+
+## Usage
+
+### Grade Level Appropriateness scorer
+
+Evaluates whether model output (or generated artifact files) is written at the
+appropriate reading level for a target K-12 grade band.
+
+```python
+from inspect_ai import Task, task
+from inspect_ai.dataset import csv_dataset, FieldSpec
+from inspect_ai.solver import generate
+from learning_commons_inspect_scorers import gla_scorer
+
+@task
+def my_eval():
+    return Task(
+        dataset=csv_dataset("samples.csv"),  # requires target_grade column
+        solver=[generate()],
+        scorer=gla_scorer(),
+    )
+```
+
+The dataset CSV must include a `target_grade` metadata column with one of:
+`K-1`, `2-3`, `4-5`, `6-8`, `9-10`, `11-CCR`.
+
+### Scoring artifact files (edu-panda-skill-harness)
+
+```python
+scorer=gla_scorer(text_source="artifacts")
+```
+
+### Re-scoring an existing log from the CLI
+
+Once installed, scorers are registered via Inspect's entry point system:
+
+```bash
+inspect score logs/my-eval.eval --scorer learning_commons_inspect_scorers/gla_scorer
+```
+
+## Configuration
+
+| Parameter | Default | Description |
+|---|---|---|
+| `grader_model` | `"anthropic/claude-opus-4-8"` | Inspect model string for the grading LLM. Uses Inspect's model system — no separate API key configuration needed. |
+| `text_source` | `"completion"` | `"completion"` scores `state.output.completion`; `"artifacts"` joins `state.metadata["artifacts"]` file contents. |
+| `target_grade_key` | `"target_grade"` | Metadata key holding the expected grade band. |
+| `allow_adjacent` | `True` | If `True`, the one grade band above or below the target also passes. |
+
+## Development
+
+```bash
+# From repo root
+pip install -e sdks/python
+pip install -e "integrations/inspect-python[dev]"
+pytest integrations/inspect-python/tests/
+```

integrations/inspect-python/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "learning-commons-inspect-scorers"
+version = "0.1.0"
+description = "Inspect AI scorer wrappers for Learning Commons evaluators"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Learning Commons" }]
+keywords = ["education", "evaluators", "inspect", "evals", "scoring"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Education",
+]
+dependencies = [
+    "learning-commons-evaluators>=0.2.0",
+    # Score.unscored() — used in every skip/error path of gla_scorer — was added in inspect-ai 0.3.214.
+    "inspect-ai>=0.3.214",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "ruff>=0.9.0",
+    "mypy>=1.14.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/learning-commons-org/evaluators"
+Repository = "https://github.com/learning-commons-org/evaluators/tree/main/integrations/inspect-python"
+Documentation = "https://docs.learningcommons.org/evaluators"
+"Bug Tracker" = "https://github.com/learning-commons-org/evaluators/issues"
+
+# Registers scorers with Inspect's component discovery via setuptools entry points.
+# Once installed, scorers are accessible as e.g. `learning_commons_inspect_scorers/gla_scorer`
+# from the CLI: inspect score log.eval --scorer learning_commons_inspect_scorers/gla_scorer
+[project.entry-points.inspect_ai]
+learning_commons_inspect_scorers = "learning_commons_inspect_scorers._registry"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+learning_commons_inspect_scorers = ["py.typed"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "I", "UP", "B", "SIM"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.10"
+mypy_path = ["src", "tests"]
+explicit_package_bases = true
+plugins = ["pydantic.mypy"]
+warn_unused_configs = true
+show_error_codes = true

integrations/inspect-python/src/learning_commons_inspect_scorers/__init__.py

@@ -0,0 +1,6 @@
+"""Learning Commons Inspect scorers — Inspect AI wrappers for LC evaluators."""
+
+from learning_commons_inspect_scorers.adapter import InspectModelAdapter
+from learning_commons_inspect_scorers.gla import gla_scorer
+
+__all__ = ["InspectModelAdapter", "gla_scorer"]

integrations/inspect-python/src/learning_commons_inspect_scorers/_registry.py

@@ -0,0 +1,10 @@
+"""Entry point registry — imported by Inspect via the inspect_ai setuptools entry point.
+
+Importing this module registers all scorers with Inspect's component system,
+making them accessible by name (e.g. learning_commons_inspect_scorers/gla_scorer)
+from both the Python API and the CLI.
+"""
+
+from learning_commons_inspect_scorers.gla import (
+    gla_scorer,  # noqa: F401 — import triggers @scorer registry side-effect
+)

integrations/inspect-python/src/learning_commons_inspect_scorers/adapter.py

@@ -0,0 +1,71 @@
+"""Inspect AI model adapter implementing LLMGeneratorProtocol.
+
+This is a separate package (``learning-commons-inspect-scorers``) rather than
+part of ``learning-commons-evaluators`` because it introduces ``inspect-ai`` as
+a hard dependency — a heavy framework that not all SDK users need.
+
+**Versioning contract**: this package requires ``learning-commons-evaluators>=0.2.0``
+where ``LLMGeneratorProtocol`` was introduced. If a new method is added to the
+protocol, bump the lower bound here and update this adapter.
+
+**Building a new integration** (e.g. ``integrations/langsmith-python``):
+implement ``LLMGeneratorProtocol`` — a single async ``generate()`` method that
+calls your framework's model and returns ``LLMResponse`` — then inject it into
+any evaluator via ``GradeLevelAppropriatenessEvaluator(config=..., llm_provider=adapter)``.
+"""
+
+from __future__ import annotations
+
+from inspect_ai.model import (
+    ChatMessageSystem,
+    ChatMessageUser,
+    get_model,
+)
+from inspect_ai.model import (
+    GenerateConfig as InspectGenConfig,
+)
+from learning_commons_evaluators.schemas.llm_provider import GenerateConfig, LLMResponse
+
+
+class InspectModelAdapter:
+    """Wraps Inspect's get_model() to satisfy LLMGeneratorProtocol.
+
+    Pass a model string in the same form accepted by Inspect's ``--model`` flag,
+    for example ``"anthropic/claude-opus-4-8"`` or ``"openai/gpt-4o"``.
+
+    Example::
+
+        adapter = InspectModelAdapter("anthropic/claude-opus-4-8")
+        evaluator = GradeLevelAppropriatenessEvaluator(
+            config=create_config_no_telemetry(),
+            llm_provider=adapter,
+        )
+    """
+
+    def __init__(self, model_name: str) -> None:
+        self._model_name = model_name
+
+    async def generate(
+        self,
+        *,
+        system: str,
+        human: str,
+        config: GenerateConfig | None = None,
+    ) -> LLMResponse:
+        # get_model() is memoized by Inspect — repeated calls with the same string
+        # return the cached Model object without reconstruction.
+        inspect_model = get_model(self._model_name)
+        inspect_config = InspectGenConfig(
+            temperature=config.temperature if config is not None else None,
+            max_tokens=config.max_tokens if config is not None else None,
+        )
+        output = await inspect_model.generate(
+            [ChatMessageSystem(content=system), ChatMessageUser(content=human)],
+            config=inspect_config,
+        )
+        return LLMResponse(
+            content=output.completion,
+            model=self._model_name,
+            input_tokens=getattr(output.usage, "input_tokens", None),
+            output_tokens=getattr(output.usage, "output_tokens", None),
+        )