aeval-framework 0.1.0__py3-none-any.whl

agent_eval/metrics/pytest_plugin.py

@@ -0,0 +1,308 @@
+"""pytest integration — metric fixtures + suite gate (framework layer).
+
+模块级只依赖 pytest + agent_eval 自身 (AChat 装配 eval_integration 在
+runner 装配路径内延迟导入 — 纯框架使用场景不触碰 app 代码, AST import
+检查仅约束 app.*)。
+
+注册方式 (dev 期 import 注册, entry-point 打包延后至独立 repo — design D3):
+根 conftest.py 中 ``pytest_plugins = ["agent_eval.metrics.pytest_plugin"]``
+
+Fixtures:
+    eval_metrics      — P0 指标注册表 (name → SyncMetric)
+    answer_relevancy / faithfulness / context_recall / context_precision — 单指标
+    eval_runner       — EvalRunner (默认经 eval_integration 装配, 未配置时
+                        skip 并提示; 可用 set_eval_runner_factory 覆盖装配)
+
+每个指标 fixture 值为 SyncMetric 同步包装: 同步测试直接调用
+``measure(...)`` (内部 asyncio.run, 零事件循环管理); 异步测试取
+``.async_metric`` 直接 await measure (不与 pytest-asyncio 抢 loop)。
+指标默认未注入 llm_fn — 缺配置时报错信息可读 (LLMNotConfiguredError),
+测试可经 ``fixture.async_metric.llm_fn = stub`` 注入。
+
+Suite 门禁:
+    pytest --eval-suite=suite.yaml --eval-threshold=0.7
+
+常规测试循环结束后执行 suite 评测, terminal summary 打印 pass@k 与阈值
+判定; pass@1 低于阈值时置 session.testsfailed (退出码非 0)。
+评测 runner 装配与 eval_runner fixture 同源 (set_eval_runner_factory 可覆盖)。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from collections.abc import Callable
+from typing import Any
+
+import pytest
+
+from agent_eval.core.types import RunResult
+from agent_eval.metrics import (
+    AnswerRelevancyMetric,
+    ContextPrecisionMetric,
+    ContextRecallMetric,
+    FaithfulnessMetric,
+    build_default_metrics_registry,
+)
+from agent_eval.metrics.base import Metric, MetricResult
+
+# ─── 同步包装 ────────────────────────────────────────────────────────────────
+
+
+class SyncMetric:
+    """Metric 同步包装 — measure 内部 asyncio.run, 供纯同步 pytest 测试调用。
+
+    用法边界: 仅限无 running event loop 的同步测试 (notebook 等已有 loop
+    的环境不适用); 异步测试取 .async_metric 直接 await measure。
+    """
+
+    def __init__(self, metric: Metric):
+        self._metric = metric
+
+    @property
+    def async_metric(self) -> Metric:
+        """原始异步 Metric (异步测试直接 await 其 measure)"""
+        return self._metric
+
+    @property
+    def name(self) -> str:
+        return self._metric.name
+
+    @property
+    def threshold(self) -> float:
+        return self._metric.threshold
+
+    def measure(
+        self,
+        input: str,
+        actual_output: str,
+        expected_output: str | None = None,
+        context: list[str] | None = None,
+        retrieval_context: list[str] | None = None,
+    ) -> MetricResult:
+        """同步 measure (内部 asyncio.run 桥接异步 Metric.measure)。"""
+        return asyncio.run(
+            self._metric.measure(
+                input=input,
+                actual_output=actual_output,
+                expected_output=expected_output,
+                context=context,
+                retrieval_context=retrieval_context,
+            )
+        )
+
+
+def _sync(metric: Metric) -> SyncMetric:
+    return SyncMetric(metric)
+
+
+# ─── Fixtures ────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture
+def eval_metrics() -> dict[str, SyncMetric]:
+    """P0 指标注册表 (name → SyncMetric; 原始异步对象经 .async_metric)。"""
+    return {name: _sync(m) for name, m in build_default_metrics_registry().items()}
+
+
+@pytest.fixture
+def answer_relevancy() -> SyncMetric:
+    """AnswerRelevancyMetric 同步包装 (llm_fn 未注入 — 按需注入 stub/凭证)。"""
+    return _sync(AnswerRelevancyMetric())
+
+
+@pytest.fixture
+def faithfulness() -> SyncMetric:
+    """FaithfulnessMetric 同步包装。"""
+    return _sync(FaithfulnessMetric())
+
+
+@pytest.fixture
+def context_recall() -> SyncMetric:
+    """ContextRecallMetric 同步包装。"""
+    return _sync(ContextRecallMetric())
+
+
+@pytest.fixture
+def context_precision() -> SyncMetric:
+    """ContextPrecisionMetric 同步包装。"""
+    return _sync(ContextPrecisionMetric())
+
+
+# ─── Runner 装配 (eval_runner fixture 与 suite 门禁共用) ─────────────────────
+
+
+class EvalRunnerUnavailableError(Exception):
+    """Aeval runner 无法装配 (eval_integration 不可用或配置缺失)。"""
+
+
+# 同步返回 runner, 或返回 awaitable (async 工厂)
+EvalRunnerFactory = Callable[[], Any]
+
+_eval_runner_factory: EvalRunnerFactory | None = None
+
+
+def set_eval_runner_factory(factory: EvalRunnerFactory | None) -> None:
+    """注入 runner 装配工厂 (测试/宿主覆盖装配点, 如 MockRunner 演示)。"""
+    global _eval_runner_factory
+    _eval_runner_factory = factory
+
+
+async def build_eval_runner():
+    """装配 EvalRunner: 注入工厂优先; 默认经 eval_integration (AChat 接入层)。
+
+    Raises:
+        EvalRunnerUnavailableError: 装配点不可用 (错误信息可读;
+            eval_runner fixture 据此 skip, suite 门禁据此判门禁失败)
+    """
+    if _eval_runner_factory is not None:
+        result = _eval_runner_factory()
+        if inspect.isawaitable(result):
+            result = await result
+        return result
+
+    # 延迟导入: 框架独立使用场景不依赖 AChat 接入层
+    try:
+        from eval_integration.config import create_aeval_runner
+    except Exception as e:
+        raise EvalRunnerUnavailableError(
+            "eval_integration unavailable — cannot assemble an Aeval runner "
+            "(standalone usage: register one via set_eval_runner_factory): "
+            f"{e}"
+        ) from e
+    try:
+        return await create_aeval_runner()
+    except Exception as e:
+        raise EvalRunnerUnavailableError(
+            "Aeval runner assembly failed (check EVAL_AGENT_ID / EVAL_API_BASE / "
+            f"token settings): {e}"
+        ) from e
+
+
+@pytest.fixture
+def eval_runner():
+    """EvalRunner 实例 (默认经 eval_integration 装配; 未配置时 skip 并提示)。"""
+    try:
+        return asyncio.run(build_eval_runner())
+    except EvalRunnerUnavailableError as e:
+        pytest.skip(f"eval_runner unavailable — skipping: {e}")
+
+
+# ─── Suite 门禁 (--eval-suite / --eval-threshold) ────────────────────────────
+
+
+class SuiteGatePlugin:
+    """--eval-suite 门禁: 测试循环结束后跑 suite, 打印 pass@k 并按阈值置失败。
+
+    阈值判定在 pytest_runtestloop wrapper 的 finally 中递增
+    session.testsfailed — 早于 _main 的退出码计算 (terminal summary 阶段
+    已无法影响退出码); 打印则放在 pytest_terminal_summary。
+    """
+
+    def __init__(self, suite_path: str, threshold: float):
+        self.suite_path = suite_path
+        self.threshold = threshold
+        self.suite_name: str | None = None
+        self.result: RunResult | None = None
+        self.error: str | None = None
+        self.failed = False
+
+    @pytest.hookimpl(wrapper=True)
+    def pytest_runtestloop(self, session):
+        try:
+            return (yield)
+        finally:
+            self._apply_gate(session)
+
+    def _apply_gate(self, session) -> None:
+        if session.config.option.collectonly:
+            return
+        try:
+            self.result = asyncio.run(self._run_suite())
+        except Exception as e:
+            self.error = str(e)
+        # 阈值判定: 分数低于阈值或评测本身出错都判门禁失败 (CI 语义 —
+        # 装配失败静默放行比失败更危险)
+        if self.error is not None or self._pass_at_1() < self.threshold:
+            self.failed = True
+            session.testsfailed += 1
+
+    async def _run_suite(self):
+        from agent_eval.core.suite import load_suite
+
+        suite = load_suite(self.suite_path)
+        self.suite_name = suite.name
+        runner = await build_eval_runner()
+        return await runner.run_suite(suite)
+
+    def _pass_at_1(self) -> float:
+        if self.result is None or self.result.summary is None:
+            return 0.0
+        return float(self.result.summary.pass_at_k.get(1, 0.0))
+
+    def pytest_terminal_summary(self, terminalreporter, exitstatus) -> None:
+        terminalreporter.write_sep("=", "AEVAL EVALUATION GATE")
+        suite_label = f"{self.suite_name} ({self.suite_path})" if self.suite_name else self.suite_path
+        terminalreporter.write_line(
+            f"Suite: {suite_label} (threshold: {self.threshold:.4f})"
+        )
+
+        if self.error is not None:
+            terminalreporter.write_line(f"GATE ERROR: {self.error}")
+            return
+
+        result = self.result
+        if result is None:
+            terminalreporter.write_line("GATE ERROR: evaluation produced no result")
+            return
+
+        summary = result.summary
+        terminalreporter.write_line(
+            f"Run {result.run_id} status={result.status} "
+            f"tasks={summary.total_tasks if summary else 0} "
+            f"trials={summary.total_trials if summary else 0}"
+        )
+        pass_at_k = summary.pass_at_k if summary else {}
+        terminalreporter.write_line(
+            "Pass@k: "
+            + ", ".join(f"@{k}={v:.4f}" for k, v in sorted(pass_at_k.items()))
+        )
+        pass1 = self._pass_at_1()
+        if self.failed:
+            terminalreporter.write_line(
+                f"GATE FAILED: pass@1 {pass1:.4f} < threshold {self.threshold:.4f}"
+            )
+        else:
+            terminalreporter.write_line(
+                f"GATE PASSED: pass@1 {pass1:.4f} >= threshold {self.threshold:.4f}"
+            )
+
+
+_gate_plugin: SuiteGatePlugin | None = None
+
+
+def pytest_addoption(parser) -> None:
+    group = parser.getgroup("aeval", "Aeval evaluation framework")
+    group.addoption(
+        "--eval-suite",
+        action="store",
+        default=None,
+        help="Aeval 评测 Suite YAML 路径 (常规测试跑完后执行 suite 门禁)",
+    )
+    group.addoption(
+        "--eval-threshold",
+        action="store",
+        type=float,
+        default=0.7,
+        help="门禁通过阈值 (pass@1, 默认 0.7)",
+    )
+
+
+def pytest_configure(config) -> None:
+    global _gate_plugin
+    suite_path = config.getoption("eval_suite")
+    if suite_path:
+        _gate_plugin = SuiteGatePlugin(
+            suite_path, float(config.getoption("eval_threshold"))
+        )
+        config.pluginmanager.register(_gate_plugin)

agent_eval/metrics/report.py

@@ -0,0 +1,149 @@
+"""Metric report rendering — RunResult / BatchEvaluationResult → Markdown or JSON text.
+
+纯渲染函数 (无 I/O、无模板依赖): 批量报告含逐条分数与汇总统计; run 报告含
+pass@k / pass^k / 任务分解。可直接写入 stdout 或文件, 供 CI 脚本与 Phase 2
+CLI 消费 (交互视图由 Dashboard 覆盖, 不做 HTML/图表)。
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Literal
+
+from agent_eval.core.types import RunResult
+from agent_eval.metrics.batch_evaluation import BatchEvaluationResult
+
+ReportFormat = Literal["markdown", "json"]
+
+
+def render_batch_report(
+    result: BatchEvaluationResult,
+    fmt: ReportFormat = "markdown",
+) -> str:
+    """渲染批量评测结果 (markdown: 分数表 + 汇总段; json: 纯 dump)。"""
+    if fmt == "json":
+        return json.dumps(result.model_dump(), ensure_ascii=False, indent=2)
+    if fmt != "markdown":
+        raise ValueError(f"Unsupported report format: {fmt!r} (use 'markdown' or 'json')")
+    return _render_batch_markdown(result)
+
+
+def render_run_report(run: RunResult, fmt: ReportFormat = "markdown") -> str:
+    """渲染 run 结果 (markdown: 汇总 + 任务分解; json: 纯 dump)。"""
+    if fmt == "json":
+        return json.dumps(run.model_dump(), ensure_ascii=False, indent=2)
+    if fmt != "markdown":
+        raise ValueError(f"Unsupported report format: {fmt!r} (use 'markdown' or 'json')")
+    return _render_run_markdown(run)
+
+
+# ─── Markdown 渲染 ───────────────────────────────────────────────────────────
+
+
+def _score(value: float) -> str:
+    return f"{value:.4f}"
+
+
+def _pct(value: float) -> str:
+    return f"{value:.1%}"
+
+
+def _render_batch_markdown(result: BatchEvaluationResult) -> str:
+    lines: list[str] = ["# Aeval 批量评测报告", "", "## 概览", ""]
+
+    total = result.pass_count + result.fail_count
+    lines.append(f"- 用例数: {total}")
+    lines.append(f"- 通过 / 失败: {result.pass_count} / {result.fail_count}")
+    lines.append(f"- pass_rate: {_pct(result.pass_rate)}")
+    lines.append("")
+
+    lines += ["## 指标汇总", ""]
+    if result.summary:
+        lines.append("| 指标 | 平均分 | 最小 | 最大 | 通过 | 失败 | pass_rate | 阈值 |")
+        lines.append("|------|--------|------|------|------|------|-----------|------|")
+        for name, s in result.summary.items():
+            lines.append(
+                f"| {name} | {_score(s.avg)} | {_score(s.min)} | {_score(s.max)} "
+                f"| {s.pass_count} | {s.fail_count} | {_pct(s.pass_rate)} | {_score(s.threshold)} |"
+            )
+    else:
+        lines.append("（无指标数据）")
+    lines.append("")
+
+    lines += ["## 逐用例结果", ""]
+    if result.results:
+        lines.append("| # | 输入 | 各指标分数 | 结果 |")
+        lines.append("|---|------|------------|------|")
+        for case in result.results:
+            parts = []
+            for name, s in case.scores.items():
+                mark = "PASS" if s.success else "FAIL"
+                cell = f"{name}={_score(s.score)} ({mark})"
+                if s.error:
+                    cell += f" [error: {s.error}]"
+                parts.append(cell)
+            verdict = "PASS" if case.overall_pass else "FAIL"
+            lines.append(f"| {case.index} | {case.input} | {' / '.join(parts)} | {verdict} |")
+    else:
+        lines.append("（无用例）")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _render_run_markdown(run: RunResult) -> str:
+    lines: list[str] = ["# Aeval 评测 Run 报告", "", "## 概览", ""]
+
+    lines.append(f"- Run ID: {run.run_id}")
+    lines.append(f"- Suite: {run.suite_name}")
+    lines.append(f"- 状态: {run.status}")
+    if run.duration_ms is not None:
+        lines.append(f"- 耗时: {run.duration_ms:.0f} ms")
+    lines.append("")
+
+    summary = run.summary
+    lines += ["## 汇总", ""]
+    if summary is None:
+        lines.append("（无汇总 — run 未完成或汇总未计算）")
+        lines.append("")
+        return "\n".join(lines)
+
+    lines.append(f"- 总任务 / 总 trial: {summary.total_tasks} / {summary.total_trials}")
+    lines.append(
+        "- Pass@k: "
+        + ", ".join(
+            f"@{k}={_pct(v)}" for k, v in sorted(summary.pass_at_k.items())
+        )
+    )
+    lines.append(
+        "- Pass^k: "
+        + ", ".join(
+            f"@{k}={_pct(v)}" for k, v in sorted(summary.pass_power_k.items())
+        )
+    )
+    lines.append(f"- 平均分: {_score(summary.avg_score)}")
+    lines.append("")
+
+    lines += ["## 任务分解", ""]
+    if summary.task_summaries:
+        lines.append("| 任务 | 描述 | Trials | Pass@1 | Pass^1 | 平均分 | 失败 Trials |")
+        lines.append("|------|------|--------|--------|--------|--------|-------------|")
+        for ts in summary.task_summaries:
+            pass1 = _pct(ts.pass_at_k.get(1, 0.0))
+            pow1 = _pct(ts.pass_power_k.get(1, 0.0))
+            failures = ", ".join(str(i) for i in ts.failures) if ts.failures else "—"
+            lines.append(
+                f"| {ts.task_id} | {ts.task_description} | {ts.total_trials} "
+                f"| {pass1} | {pow1} | {_score(ts.avg_score)} | {failures} |"
+            )
+    else:
+        lines.append("（无任务汇总）")
+
+    saturation = summary.saturation
+    if saturation:
+        lines.append("")
+        lines.append(
+            f"饱和度: is_saturated={saturation.get('is_saturated', False)}, "
+            f"ratio={saturation.get('saturation_ratio', 0.0)}"
+        )
+    lines.append("")
+    return "\n".join(lines)

agent_eval/metrics/synthetic_data.py

@@ -0,0 +1,203 @@
+"""Synthetic data generation — documents → Goldens → dataset items (D6).
+
+Golden = a synthetic eval case (input / expected_output / source context).
+Long text is chunked by character length (no tokenizer dependency). Goldens
+convert to dataset items with llm_generated provenance and default
+answer_relevancy + faithfulness metric graders (threshold 0.7).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from agent_eval.dataset.models import EvalDatasetItem, SourceType, now_ms
+from agent_eval.dataset.sources.llm_generator import LLMFn, _extract_json_array
+from agent_eval.dataset.sources.manual import DatasetImportError
+from agent_eval.metrics.llm_judge import require_llm_fn
+
+# 分块大小 (字符; 按长度估算, 不做 tokenizer 依赖) 与重叠
+_CHUNK_SIZE_CHARS = 2000
+_CHUNK_OVERLAP_CHARS = 200
+
+_SYNTH_SYSTEM_PROMPT = "You are an evaluation dataset designer. You output only valid JSON."
+
+_SYNTH_PROMPT = """根据以下文档, 生成 {count} 个高质量评测问题。
+
+文档内容:
+{context}
+
+对每个问题, 提供:
+- "input": 用户问题 (应能从文档中回答)
+- "expected_output": 标准答案 (基于文档)
+
+要求:
+- 问题类型多样 (事实性/推理性/比较性)
+- 答案必须能从文档中直接推导
+- 避免模糊或主观的问题
+
+以 JSON 数组格式返回，不要输出数组以外的任何内容。"""
+
+
+@dataclass
+class Golden:
+    """评测黄金标准 — 单个合成测试用例"""
+
+    input: str  # 问题
+    expected_output: str  # 期望回答
+    context: list[str] = field(default_factory=list)  # 来源文档
+    source: str = ""  # 来源引用
+
+
+class SyntheticDataGenerator:
+    """合成数据生成器 — 从文档自动生成评测用例"""
+
+    def __init__(self, llm_fn: LLMFn | None = None):
+        self.llm_fn = llm_fn
+
+    async def generate_from_docs(
+        self,
+        documents: list[str],
+        count_per_doc: int = 3,
+        llm_fn: LLMFn | None = None,
+    ) -> list[Golden]:
+        """从文档列表生成评测用例 (每文档 count_per_doc 个)"""
+        fn = require_llm_fn(llm_fn or self.llm_fn)
+        goldens: list[Golden] = []
+        for idx, doc in enumerate(documents):
+            if not str(doc).strip():
+                continue
+            raw = await fn(
+                _SYNTH_SYSTEM_PROMPT,
+                _SYNTH_PROMPT.format(context=doc, count=count_per_doc),
+            )
+            parsed = _extract_json_array(raw)
+            if parsed is None:
+                raise DatasetImportError(
+                    f"Synthetic generation: document #{idx} judge response is not "
+                    f"a parsable JSON array (got: {raw[:120]!r}...)"
+                )
+            for entry in parsed:
+                if not isinstance(entry, dict):
+                    continue
+                question = str(entry.get("input", "")).strip()
+                answer = str(entry.get("expected_output", "")).strip()
+                if not question or not answer:
+                    continue
+                goldens.append(Golden(
+                    input=question,
+                    expected_output=answer,
+                    context=[str(doc)],
+                    source=f"doc[{idx}]",
+                ))
+        return goldens
+
+    async def generate_from_text(
+        self,
+        text: str,
+        count: int = 5,
+        llm_fn: LLMFn | None = None,
+    ) -> list[Golden]:
+        """从单段长文本生成评测用例 (先分块再逐块生成)"""
+        fn = llm_fn or self.llm_fn
+        chunks = self.chunk_text(text)
+        if not chunks:
+            return []
+        per_chunk = max(1, count // len(chunks))
+        remainder = count - per_chunk * len(chunks)
+
+        goldens: list[Golden] = []
+        for i, chunk in enumerate(chunks):
+            take = per_chunk + (1 if i < remainder else 0)
+            if take <= 0:
+                continue
+            goldens.extend(await self.generate_from_docs([chunk], take, llm_fn=fn))
+        return goldens
+
+    @staticmethod
+    def chunk_text(
+        text: str,
+        max_chars: int = _CHUNK_SIZE_CHARS,
+        overlap: int = _CHUNK_OVERLAP_CHARS,
+    ) -> list[str]:
+        """按字符长度分块 (段落边界优先, 带重叠)"""
+        text = (text or "").strip()
+        if not text:
+            return []
+        if len(text) <= max_chars:
+            return [text]
+
+        paragraphs = text.split("\n\n")
+        chunks: list[str] = []
+        current = ""
+        for para in paragraphs:
+            if current and len(current) + len(para) + 2 > max_chars:
+                chunks.append(current)
+                # 保留尾部重叠, 维持跨块上下文
+                current = current[-overlap:] + "\n\n" + para if overlap else para
+            else:
+                current = f"{current}\n\n{para}" if current else para
+            # 单段超长: 硬切
+            while len(current) > max_chars:
+                chunks.append(current[:max_chars])
+                current = current[max_chars - overlap:] if overlap else ""
+        if current.strip():
+            chunks.append(current)
+        return chunks
+
+    def to_dataset_items(
+        self,
+        goldens: list[Golden],
+        threshold: float = 0.7,
+    ) -> list[EvalDatasetItem]:
+        """
+        Golden → 数据集条目 (D6)。
+
+        默认 graders: answer_relevancy + faithfulness 指标 (threshold 0.7),
+        source_type=llm_generated, source_ref=来源文档引用。
+        """
+        from agent_eval.dataset.models import make_grader_config
+
+        # answer_relevancy 对所有条目相同; faithfulness 需要按条目注入
+        # Golden context (grader config.context) 才能在流水线中评估忠实度
+        relevancy_grader = make_grader_config(
+            "metric",
+            name="answer_relevancy",
+            metric_name="answer_relevancy",
+            threshold=threshold,
+        )
+        items = []
+        for i, g in enumerate(goldens):
+            faithfulness_grader = make_grader_config(
+                "metric",
+                name="faithfulness",
+                metric_name="faithfulness",
+                threshold=threshold,
+                context=g.context,
+            )
+            items.append(EvalDatasetItem(
+                id=f"synthetic_{i:04d}",
+                prompt=g.input,
+                description=f"Synthetic: {g.input[:60]}",
+                graders=[relevancy_grader, faithfulness_grader],
+                env={},
+                metadata={
+                    "capabilities": ["rag"],
+                    "context": g.context,
+                    "expected_output": g.expected_output,
+                },
+                source_type=SourceType.LLM_GENERATED,
+                source_ref=g.source,
+                created_at=now_ms(),
+            ))
+        return items
+
+    async def generate_dataset_items(
+        self,
+        documents: list[str],
+        count_per_doc: int = 3,
+        threshold: float = 0.7,
+        llm_fn: LLMFn | None = None,
+    ) -> list[EvalDatasetItem]:
+        """文档 → Golden → 数据集条目 (便捷链路)"""
+        goldens = await self.generate_from_docs(documents, count_per_doc, llm_fn)
+        return self.to_dataset_items(goldens, threshold=threshold)

agent_eval/storage/__init__.py

@@ -0,0 +1,17 @@
+"""
+Storage implementations for the Aeval evaluation framework.
+
+Provides SQLite (default) and in-memory storage.
+PostgreSQL can be added for production use.
+
+Usage:
+    from agent_eval.storage import SqliteStorage, MemoryStorage
+
+    storage = SqliteStorage(db_path="./aeval.db")
+    await storage.save_run(run_result)
+"""
+
+from agent_eval.storage.memory import MemoryStorage
+from agent_eval.storage.sqlite import SqliteStorage
+
+__all__ = ["MemoryStorage", "SqliteStorage"]