niceeval 0.17.1 → 0.19.0

package/docs-site/zh/tutorials/sandbox-agent.mdx

@@ -106,7 +106,7 @@ export default defineExperiment({
 | `codex` | `CODEX_API_KEY` |
 | `bub` | `BUB_API_KEY`、`BUB_API_BASE` |
 
-这些是各 Agent 官方的变量名。CI 里只保存一组共享凭据时，在 Experiment 里用 `apiKey`、`baseUrl` 或 `apiBase` 显式传入。这不会改变 Adapter 默认读取的变量名。
+这些是各 Agent 官方的变量名。CI 里只保存一组共享凭据时，在 Experiment 里用 `apiKey`、`baseUrl` 显式传入。这不会改变 Adapter 默认读取的变量名。
 
 ## 一个 Attempt 依次做什么
 

package/docs-site/zh/tutorials/sandbox-reuse.mdx

@@ -79,7 +79,7 @@ export default defineExperiment({
 });
 ```
 
-NiceEval 在 Experiment `setup` 和创建 Sandbox 之前取得这个 key 的租约，等 Sandbox 清理、Provider 收尾和 Experiment `teardown` 全部完成后才释放。另一个终端里用同一个 key 的运行会排队等待，不会提前创建 Sandbox。拿到租约后，它照自己的计划继续跑，不读取或沿用对方的结果。
+NiceEval 在 Experiment `before` 和创建 Sandbox 之前取得这个 key 的租约，等 Sandbox 清理、Provider 收尾和 Experiment `after` 全部完成后才释放。另一个终端里用同一个 key 的运行会排队等待，不会提前创建 Sandbox。拿到租约后，它照自己的计划继续跑，不读取或沿用对方的结果。
 
 key 也是结果配置的一部分。换一个 key 就是换一份状态，旧结果不会混进来。租约只保护外部 checkpoint，和结果文件无关；不用 `sharedState` 的运行照样可以并发写入结果。不同机器或不同 working copy 之间仍需要外部分布式锁。
 
@@ -89,12 +89,12 @@ key 也是结果配置的一部分。换一个 key 就是换一份状态，旧
 |---|---|
 | Sandbox 创建 / 停止 | 每个 Sandbox 一次 |
 | Sandbox `.before()` / `.after()` 准备步骤与已登记的清理 | 每个真正要跑的 Attempt 一次 |
-| Agent 级 `setup` / `teardown` | 每个 Attempt 一次 |
-| 评估用例的 `setup` / `teardown`、`test(t)` | 每个 Attempt 一次 |
+| Agent 级 `before` / `after` | 每个 Attempt 一次 |
+| 评估用例的 `before` / `after`、`test(t)` | 每个 Attempt 一次 |
 
 <SandboxLanes />
 
-每个 Attempt 结束后，NiceEval 对 `workdir` 执行 `git reset --hard` 和 `git clean`，恢复到起始状态，再开始下一个。这一步只管 `workdir`，`/opt`、`$HOME`、`/tmp`、全局安装、包缓存和后台进程都不会消失。它们要么由评估用例的 `teardown` 自己清理，要么是你有意留给下一道题用的状态。
+每个 Attempt 结束后，NiceEval 对 `workdir` 执行 `git reset --hard` 和 `git clean`，恢复到起始状态，再开始下一个。这一步只管 `workdir`，`/opt`、`$HOME`、`/tmp`、全局安装、包缓存和后台进程都不会消失。它们要么由评估用例的 `after` 自己清理，要么是你有意留给下一道题用的状态。
 
 大型的持久构建产物或缓存不能放任增长。给它定一个容量上限和提前告警的阈值：正常的大小和命中情况用 `facts` 记录，接近风险阈值时用 `diagnostic` 告警，同时准备好清理、轮换或换掉这台 Sandbox 的办法。
 
@@ -102,8 +102,8 @@ key 也是结果配置的一部分。换一个 key 就是换一份状态，旧
 
 - **所有实验都要的重依赖**（Agent CLI、语言运行时）：烘进 Provider 的 image / template / snapshot，或写成最低频的 `.before()` 准备步骤。
 - **整批评估共用的准备**（装工具链、clone 公共仓库、预热构建缓存）：写成低频的 `.before()` 准备步骤。在 Docker 上，没变的准备步骤下次运行可以直接沿用。这些步骤仍然每个 Attempt 都要经过一次，你不能要求它在整台 Sandbox 上只跑一次。
-- **只有这道题要的素材**（它自己的仓库、数据、依赖）：放进评估用例自己的 `setup` 或 `test(t)`。每道题重置后都会再跑一遍，所以必须是重复执行也正确的代码。
-- **起了后台进程、占了端口**：由评估用例的 `teardown` 自己清理，重置 `workdir` 不会杀进程。
+- **只有这道题要的素材**（它自己的仓库、数据、依赖）：放进评估用例自己的 `before` 或 `test(t)`。每道题重置后都会再跑一遍，所以必须是重复执行也正确的代码。
+- **起了后台进程、占了端口**：由评估用例的 `after` 自己清理，重置 `workdir` 不会杀进程。
 
 每道题各自 clone 仓库时，整个 Experiment 用同一个固定名字的临时目录，例如 `.niceeval-task-clone`，并把它加进 `diff.ignore`。clone 前只运行 `rm -rf .niceeval-task-clone`，清掉上一道题的残留。绝不要删除 `workdir` 根目录的 `.git`：题间重置依赖它，而且它会一直留着。
 
@@ -131,7 +131,7 @@ npm install          # 按 package.json/lockfile 装齐，本身就可以重复
 
 两件事仍归你：
 
-- **`postSetup` 脚本必须可以重复执行**。它每个 Attempt 都会在留下来的 `$HOME` 上再跑一遍。往全局配置登记 hook 的脚本，跑多少遍都要得到同一份配置。开复用前，先拿两三道题在一条 Sandbox 泳道上跑一轮，从第二道题开始才能看出问题。
+- **`before` 脚本必须可以重复执行**。它每个 Attempt 都会在留下来的 `$HOME` 上再跑一遍。往全局配置登记 hook 的脚本，跑多少遍都要得到同一份配置。开复用前，先拿两三道题在一条 Sandbox 泳道上跑一轮，从第二道题开始才能看出问题。
 - **插件数据放在哪**。插件安装目录每个 Attempt 都会被重装覆盖。要留到下一道题的数据，只能写在安装目录之外。留下的数据会不会影响下一道题，是你的实验设计要回答的问题。
 
 重新安装不省钱：插件安装每个 Attempt 都要付一次。复用省下的是 Sandbox 创建；没变的 `.before()` 准备步骤在 Docker 上还能沿用。marketplace 拉取太慢时，用 `sparse` 只拉插件路径，或者把插件烘进 template，并从 `plugins` 里去掉声明。代价是安装清单里不再记录插件和它解析到的版本。

package/docs-site/zh/tutorials/upgrade-0-18.mdx

@@ -0,0 +1,64 @@
+---
+title: "升级到 0.18"
+description: "共享模型用途、原生数值材料与公开入口调整"
+---
+
+0.18 保留 0.17 的 `t.usage.cacheRead.rate()` 与按用途查询方式，并增加可复用的用途类型声明。
+在评估项目中升级依赖：
+
+```sh
+pnpm add niceeval@^0.18.0
+```
+
+## 共享模型用途
+
+用 `defineModelRoles` 提取声明，实验的 `models` 与 Adapter 绑定评估的 `requires.models` 引用它。
+给 `defineAdapter` 同样添加 `requires.models` 后，`ctx.models` 与 `ctx.recordUsage` 的用途键也会被收窄。
+完整示例见[按用途检查缓存读取率](/zh/tutorials/control-run-cost#让模型用途名称参与类型检查)。
+
+0.18 继续接受省略 `requires` 的 0.17 写法，按调用时校验名称。
+根入口的 `defineEval`、`defineScoreEval` 属于 Agent 路径；共享声明只扩展 Adapter 绑定工厂。
+用途要求不会绑定具体实验或固定模型值。
+
+## 调整重复的导入入口
+
+| 原来的入口 | 0.18 写法 |
+| --- | --- |
+| 根入口的 `defineJudge`、`defineScoreMatch`、`defineMaterialMatch`、`defineContextMatch` | 从 `niceeval/expect` 导入 |
+| 根入口的 `factuality`、`faithfulness`、`instructionFollowing`、`pairwisePreference` | 从 `niceeval/expect` 导入 |
+| 根入口的 `readScoreMatchAudit` | 从 `niceeval/inspection` 导入 |
+| `niceeval/sandbox` 的 `resolveDockerProfileAlias` | 使用同入口的 `resolveDockerProfile` |
+| 根入口的 `requireEnv`、`getEnv`、`stripComments` | 取消公开导出，由项目自行提供需要的工具 |
+
+例如，自定义评分判据改为：
+
+```ts
+import { defineScoreEval } from "niceeval";
+import { defineScoreMatch } from "niceeval/expect";
+```
+
+判据的执行语义不变，原有根类型导出与错误类保留。
+环境工具原先将空字符串当作缺失；改用 `process.env` 时请明确保留还是改变这一行为。
+文本 matcher 的 `stripComments` 选项仍可使用，不受同名通用函数移除影响。
+
+## 替换项目数值工具
+
+```ts
+import { atMost, isTrue, measured, quantile } from "niceeval/expect";
+
+// value 为 null 时保留原因，不会把缺失转换成 0。
+t.check(measured(durationMs, { unavailable: "record-incomplete" }), atMost(3000)).gate();
+
+// 默认 linear；也可显式选择 nearest-rank。
+t.check(quantile(intervalsMs, 0.5), atMost(1200)).gate();
+t.check(quantile(intervalsMs, 0.9, { method: "nearest-rank" }), atMost(3000)).gate();
+
+// fraction 直接作为评分材料；无样本继续显示不可判定。
+t.score(measured(successRate, { unavailable: "no-samples" }), { weight: 1 });
+t.check(completed, isTrue()).gate();
+```
+
+`quantile` 返回值的 `statistics` 包含 `sampleCount`、`probability` 与 `method`。
+空集合返回 `no-samples`，非有限样本返回 `non-finite-sample`；非法概率或算法参数直接报错。
+`measured` 对非有限数值返回 `non-finite-number`。
+`fraction` 必须位于 `[0, 1]`，`t.score` 不会替作者截断越界值。

package/docs-site/zh/tutorials/upgrade-0-19.mdx

@@ -0,0 +1,121 @@
+---
+title: "升级到 0.19"
+description: "替换模型用途名称，迁移撤销的作者配置。"
+---
+
+模型用途统一称为 **role**，请一起替换以下名称：
+
+| 旧名 | 0.19 |
+| --- | --- |
+| `defineModelSlots` | `defineModelRoles` |
+| `ModelSlotSelection` | `ModelRoleSelection` |
+| `recordUsage({ modelSlot })` | `recordUsage({ modelRole })` |
+| `cacheRead.modelSlots` | `cacheRead.roles` |
+| 分组字段 `modelSlot` | 分组字段 `modelRole` |
+| `slot-has-no-calls` | `role-has-no-calls` |
+
+`models`、`requires.models`、`ctx.models` 和 `t.usage.cacheRead.rate(role?)` 的行为不变。消费 `show --json`、Query 与 View 数据的代码也要同步替换字段。旧 API 名称不保留转发别名。
+
+## 替换撤销字段
+
+| 撤销项 | 替代方式 |
+| --- | --- |
+| `Config.workspace` | 从项目目录运行 |
+| `Eval.reporters` | `Config.reporters` |
+| `Experiment.classifyFailure` | 内建分类、`ExperimentFatalError` 或 `EvalFatalError` |
+| `run show <run-id>` | `show --run <run-id>` |
+
+撤销字段在定义加载时立即报错，显式写成 `undefined` 也会被拒绝。Codex 与 Claude Code 原生插件仍属于 Adapter 配置。Config reporters、Eval 的 `diff` 与 `metadata`、构建与准备并发控制，以及 Agent/Adapter 实现继续保留。
+
+已有结果保持可读。持久化用量和 config identity 编码不变，不使用撤销字段的实验可以继续 carry 已有结果。
+
+## Experiment 使用 adapter
+
+将 `defineExperiment({ agent: target })` 改为 `defineExperiment({ adapter: target })`。
+`defineAgent` 与 `defineSandboxAgent` 的返回值可直接用作 `adapter`，无需包装。
+定义中仍出现 `agent` 时会报错，显式写成 `undefined` 也会被拒绝。
+
+单模型的 `model` / `reasoningEffort` 简写保留，归一为 `default` role；多用途配置继续使用 `models`。
+两种写法不能混用。仅将 `agent` 改成 `adapter` 不改变配置身份，已有结果可以继续 carry。
+
+## t.note
+
+用 `t.note(label, value)` 保存只供审阅的数据，不增加 Assertion，也不影响 Verdict、score 或 coverage。
+值可以是 JSON 或带单位的 Quantity；`null` 显示为 unavailable。
+
+```ts
+import { ms } from "niceeval/expect";
+
+t.note("出手频率", result.activity);
+t.note("首个决策延迟", ms(result.firstDecisionMs));
+```
+
+同一 Attempt 的 label 必须唯一，最多 64 项，每项 JSON 不超过 64 KiB；违规时抛出 `TypeError`。
+`show @<locator>` 与 View 在 Assertions 后显示 Notes，JSON 与 Query 的 Attempt 结果新增 `notes`。
+`show --exp <experiment-id>` 按 label 和单位聚合数值 Note，列出 count、min、median、p90、max。
+历史结果没有 Note 时返回空列表。
+
+## 数值单位
+
+在把数值交给 NiceEval 的边界，使用 `niceeval/expect` 的 `ms`、`seconds`、`tokens`、`usd`、`ratio`、`count` 或 `bytes` 包装。构造函数返回冻结的 `Quantity`，通过 `.value` 和 `.unit` 读取；先做数值运算，再包装单位。非有限输入抛出 `RangeError`，`ratio` 还会拒绝 `[0, 1]` 以外的数值。
+
+```ts
+import { atLeast, atMost, measured, ms, ratio } from "niceeval/expect";
+
+const latency = measured(ms(512), { unavailable: "没有延迟观测" });
+t.check(latency, atMost(ms(600)));
+t.check(t.usage.cacheRead.rate(), atLeast(ratio(0.6)));
+```
+
+`measured` 和 `quantile` 保留单位。`atLeast`、`atMost`、`greaterThan`、`lessThan` 与包含两端的 `between` 要求材料和阈值使用相同单位；跨单位或未包装的阈值不能通过类型检查。绕过类型时，不兼容比较形成 unavailable。`cacheRead.rate()` 现在要求 `ratio(...)` 阈值。无单位材料继续使用普通 number 阈值，旧 Record 未提供单位时仍视为无单位。Show 与 View 按 `512 ms`、`61.2%`、`$0.031` 等形式显示。
+
+## Planned attempt
+
+Run 的计划执行位置现在称为 Planned attempt；已发布的执行事实仍称为 Attempt。
+`query` 使用 `niceeval.query/v2`，`/inspection` decoder 不再接受 v1。
+将 `slotId`、`expectedSlots` 和 `originSlotId` 分别替换为 `plannedAttemptId`、`plannedAttempts` 和 `originPlannedAttemptId`。
+Run 和当前结果的 `slots` 集合改为 `plannedAttempts`。Show 完整度统计显示 Planned / Recorded / Missing attempts。
+已有 Record 无需重写；持久字段在查询投影边界转换。
+
+Adapter 的 `createSessionSlot` / `SessionSlot` 改为 `createSessionKey` / `SessionKey`；
+并发等待文案改为 `waiting for capacity`。
+
+## 命名收敛
+
+旧名字不再提供别名；定义和 CLI 解析会提示替代名字。
+
+| 0.18 | 0.19 |
+| --- | --- |
+| `maxSetupPrefixConcurrency`、`--max-setup-prefix-concurrency` | `maxBeforeCacheConcurrency`、`--max-before-cache-concurrency` |
+| `sandboxCache.setup`、`SandboxSetupCache`、`--sandbox-setup-cache` | `sandboxCache.before`、`SandboxBeforeCache`、`--sandbox-before-cache` |
+| summary `setupPrefixes`、debug `setupPrefixPlan` | `beforeCaches`、`beforeCachePlan` |
+| `bubAgent({ apiBase })` | `bubAgent({ baseUrl })` |
+| `t.o11y`、`O11ySummary` | `t.observability`、`ObservabilitySummary` |
+| `turn.message` | `turn.reply` |
+| `Experiment.judgeRuntime`、`Config.judgeRuntime` | `Experiment.judge`、`Config.judgeProvider` |
+| `niceeval session list/show` | `niceeval invocation list/show` |
+| `niceeval sandbox --record` | `niceeval sandbox --record-root` |
+
+准备缓存现在称为 before cache，身份类型称为 `BeforeCacheKey`。timing 和 diagnostic 的生命周期名称使用 `*.before`、`*.after`。缓存目录、缓存键与 Record 编码保持原样，读取时映射名称，已有缓存与结果无需重写。
+
+Docker profile 解码和定义只保留 `decodeDockerExecutionProfile`、`defineDockerExecutionProfile`。
+索引和查找只保留 `indexDockerProfiles`、`resolveDockerProfile`。
+版本常量只保留 `DOCKER_EXECUTION_PROFILE_SCHEMA_VERSION`。删除这些实现的其它别名。
+
+`/sandbox` 不再导出身份计算、Compose 编译、内部构建调度、capture normalization 与 profile 策略常量。
+`/loaders` 不再导出 `captureLoadedFiles`。
+`/inspection` 不再导出 `canonicalInspectionJson`、`canonicalJsonValue`、`closeInspectionJson`。
+这些内部能力没有替代作者 API。
+
+## Plugin
+
+`definePlugin({ name, identity, ... })` 直接返回实例；`definePlugin((options) => ({ name, identity, ... }))` 返回单参数工厂。
+用 `plugins: [condition]` 和数组展开组合。用 `key` 区分同名实例，把行为版本写进 `identity`。
+生命周期字段改成 `experiment`、`group`、`attempt`、`sandbox`，各自接受 `{ before, after }`；`agent` 提供内建 Agent 扩展。
+详见 [Plugin](/zh/tutorials/plugins)。
+
+## 生命周期 before / after
+
+Experiment、`defineAgent` 与 `defineSandboxAgent` 使用 `before` / `after`。内建 Agent factory 也使用这两个字段。
+CLI 的手动收尾改用 `exp <selector> --after`；`experimentHost.after()`、`hasBefore`、`hasAfter` 与 `after-required` 使用同一命名。
+安装报告使用 `AgentInstallationManifest`、`reportInstallation` 与 `agentInstallation`；附件文件名保持不变。

package/docs-site/zh/tutorials/upgrade-0-20.mdx

@@ -0,0 +1,12 @@
+---
+title: "升级到 0.20"
+description: "更新配置与固定版本协议。"
+---
+
+## Bub 与 OpenCode 固定协议
+
+`bubAgent({ version })` 只接受 `"0.5.1"`。删除旧版本设置，或改用该固定版本；自定义 `otelPlugin` 需要支持对应 tape 协议。
+Bub 的旧顶层 `type` 事件和 OpenCode 的字段 fallback 不再解析为行为证据。OpenCode 的协议基线为 `1.18.5`。
+
+未知事件汇总为每条 Attempt 的一条 `agent-event-unrecognized` warning。运行 `niceeval show @locator` 查看类型与次数，并核对实际 CLI 版本。
+已落盘的标准事件不需要迁移。

package/docs-site/zh/tutorials/verify-judge.mdx

@@ -17,7 +17,7 @@ import { defineConfig } from "niceeval";
 import { OpenAIProvider } from "niceeval/judge";
 
 export default defineConfig({
-  judgeRuntime: OpenAIProvider({
+  judgeProvider: OpenAIProvider({
     model: "judge-model",
     baseUrl: "https://gateway.example.com/v1",
     apiKeyEnv: "JUDGE_GATEWAY_KEY",
@@ -68,7 +68,8 @@ export default defineEval({
 
 ```ts
 import { readFile } from "node:fs/promises";
-import { defineEval, defineJudge } from "niceeval";
+import { defineEval } from "niceeval";
+import { defineJudge } from "niceeval/expect";
 import { judgeImage } from "niceeval/judge";
 
 const actionQuality = defineJudge({
@@ -119,7 +120,7 @@ pnpm exec niceeval show @<attempt-locator>
 
 | 看到的结果 | 原因 | 先查什么 |
 |---|---|---|
-| `unavailable`，原因 `judge-provider-unresolved` | 没有配置 Provider，没有发请求 | `niceeval.config.ts` 的 `judgeRuntime` |
+| `unavailable`，原因 `judge-provider-unresolved` | 没有配置 Provider，没有发请求 | `niceeval.config.ts` 的 `judgeProvider` |
 | `unavailable`，原因 `judge-key-unresolved` | 读不到 key，没有发请求 | `apiKeyEnv` 写的变量名是否已设置 |
 | `unavailable` | 请求发不出去或超时 | 网络、`baseUrl`、`timeoutMs` |
 | `errored` | 端点返回 HTTP 400、协议不兼容，或返回内容不符合要求的格式 | `baseUrl` 是否指向兼容网关、`model` 名是否正确 |

package/docs-site/zh/tutorials/viewing-results.mdx

@@ -154,7 +154,7 @@ pnpm exec niceeval view --run <run-id>
 ```sh
 pnpm --silent exec niceeval query run --request - <<'JSON'
 {
-  "protocol": "niceeval.query/v1",
+  "protocol": "niceeval.query/v2",
   "operation": { "kind": "attempt.get", "locator": "@1K1P0VJAPVJ12" }
 }
 JSON
@@ -165,7 +165,7 @@ JSON
 ```sh
 pnpm --silent exec niceeval query run --request - <<'JSON'
 {
-  "protocol": "niceeval.query/v1",
+  "protocol": "niceeval.query/v2",
   "operation": {
     "kind": "attempt.assertion.detail",
     "locator": "@1K1P0VJAPVJ12",

package/docs-site/zh/tutorials/write-experiment.mdx

@@ -211,7 +211,7 @@ export default defineExperiment({
 });
 ```
 
-Adapter 从 `ctx.models` 读取这份配置交给应用，每次请求模型时在 `ctx.recordUsage` 里写上对应的 `modelSlot`。这样用量和费用能按用途分开统计；没被调用的角色不会产生费用。
+Adapter 从 `ctx.models` 读取这份配置交给应用，每次请求模型时在 `ctx.recordUsage` 里写上对应的 `modelRole`。这样用量和费用能按用途分开统计；没被调用的角色不会产生费用。
 
 `models` 不能和 `model`、`reasoningEffort` 同时写。Agent 类的 Adapter 只用单个 `model`。
 

package/docs-site/zh/tutorials/write-send.mdx

@@ -89,25 +89,25 @@ if (!res.requestId) {
 
 怎么续接取决于应用接口：
 
-- **客户端每轮发完整历史**（服务端不记状态，Chat Completions 形是典型）：用 `createSessionSlot<TMsg[]>()` 声明一份 Adapter 私有的会话状态，再用 `ctx.session.get(...)` / `ctx.session.set(...)` 存取历史消息。
+- **客户端每轮发完整历史**（服务端不记状态，Chat Completions 形是典型）：用 `createSessionKey<TMsg[]>()` 声明一份 Adapter 私有的会话状态，再用 `ctx.session.get(...)` / `ctx.session.set(...)` 存取历史消息。
 - **服务端记历史**（接口收一个会话 id，例如 Responses 形的 `previous_response_id`、各 SDK 的原生 session / thread）：用 `ctx.session.id` 读取，用 `ctx.session.capture(id)` 写回。
 
 本教程的接口是前一种：
 
 ```ts
 // agents/chat-app.ts
-import { completeEvidenceCoverage, createSessionSlot, defineAgent } from "niceeval/adapter";
+import { completeEvidenceCoverage, createSessionKey, defineAgent } from "niceeval/adapter";
 
 const BASE_URL = "http://localhost:8080";
 
 interface Msg { role: "user" | "assistant"; content: string | null }
-const historySlot = createSessionSlot<Msg[]>("chat-app/history");
+const historyKey = createSessionKey<Msg[]>("chat-app/history");
 
 export default defineAgent({
   name: "chat-app",
   evidenceCoverage: completeEvidenceCoverage,
   async send(input, ctx) {
-    const history = ctx.session.get(historySlot) ?? []; // ← 新会话线上还没有历史
+    const history = ctx.session.get(historyKey) ?? []; // ← 新会话线上还没有历史
     const messages = [...history, { role: "user" as const, content: input.text }];
 
     const res = await fetch(`${BASE_URL}/v1/chat/completions`, {
@@ -116,7 +116,7 @@ export default defineAgent({
     }).then((r) => r.json());
 
     const reply = res.choices[0].message;
-    ctx.session.set(historySlot, [...messages, reply]); // ← 写回。同一条线的下一轮 get() 自动带上
+    ctx.session.set(historyKey, [...messages, reply]); // ← 写回。同一条线的下一轮 get() 自动带上
 
     return {
       status: "completed",
@@ -126,7 +126,7 @@ export default defineAgent({
 });
 ```
 
-这里不需要“第一轮”分支。新会话线上 `ctx.session.get(historySlot)` 返回 `undefined`，`?? []` 把它变成空历史，第一轮自然就是空历史加一条新消息。也不需要在 `defineAgent` 上声明额外能力：用了 `ctx.session`，多轮就能续上；不用，每轮各是一场新对话。
+这里不需要“第一轮”分支。新会话线上 `ctx.session.get(historyKey)` 返回 `undefined`，`?? []` 把它变成空历史，第一轮自然就是空历史加一条新消息。也不需要在 `defineAgent` 上声明额外能力：用了 `ctx.session`，多轮就能续上；不用，每轮各是一场新对话。
 
 应用接口收会话 id 时，历史留在服务端，Adapter 只记住 id。`send` 里只改两处：
 
@@ -240,7 +240,7 @@ type StreamEvent =
 
 | 你返回的事件 | 能写的断言 |
 |---|---|
-| `message` | `t.reply`、`t.check(turn.message, includes(...))` / `pattern(...)`、Judge 的对话材料 |
+| `message` | `t.reply`、`t.check(turn.reply, includes(...))` / `pattern(...)`、Judge 的对话材料 |
 | tool `operation.started` / `operation.finished`（靠 `operationId` 配对） | `turn.calledTool()` / `turn.toolOrder()` / `turn.maxToolCalls()` / `turn.noFailedActions()`… |
 | `input.requested`（配合 status `"waiting"`） | `t.check(turn.status, equals("waiting"))`、`t.requireInputRequest()`、`t.respond()`（第五步） |
 | `thinking` / `compaction` / `error` | 报告与诊断；也可把原始 `events` 交给普通 `check(events, match)` |
@@ -256,20 +256,20 @@ Chat Completions 响应**不保证列出全过程**。应用可能在服务端
 - **等待的那一轮**：返回 `status: "waiting"`，并为每个待回答的问题返回一条带稳定 `id` 的 `input.requested` 事件。`t.check(turn.status, equals("waiting"))` 和 `t.requireInputRequest()` 读的就是它，回答也靠这个 `id` 对上问题。
 - **回答的那一轮**：评估用例里的 `t.respond(...)` 到 Adapter 这边是**又一次普通的 `send`**，还在同一条会话线上，拿到同一份状态。回答随 `input.responses` 到达，每条带 `requestId`，以及 `optionId` 或 `text`（形态见[不同回答的入参](/zh/explanation/adapter#不同回答的入参)）。Adapter 先把回答交给应用，再接着取结果。被拒绝的工具调用，`operation.finished` 的 `status` 写 `"rejected"`，不写 `"failed"`。拒绝是人的决定，不是工具故障，`noFailedActions()` 不会把它算成失败。
 
-等待时还没读完的东西，例如一条读到一半的 SSE 流，也存在 `ctx.session` 上。Adapter 用 `createSessionSlot<Pending>()` 声明一份私有状态，等待时 `ctx.session.set(...)` 存进去，回答轮开头 `ctx.session.take(...)` 取回。取出后它就被清掉，只能取一次。
+等待时还没读完的东西，例如一条读到一半的 SSE 流，也存在 `ctx.session` 上。Adapter 用 `createSessionKey<Pending>()` 声明一份私有状态，等待时 `ctx.session.set(...)` 存进去，回答轮开头 `ctx.session.take(...)` 取回。取出后它就被清掉，只能取一次。
 
 HITL 几乎总发生在流式接口上，应用停在流的中间。所以这一步的示例换成一个用 SSE 透传原生事件的应用，它同时用上前面几步的全部内容（完整可跑版本见 [tier1 示例](https://github.com/CorrectRoadH/niceeval/tree/main/examples/zh/tier1)）：
 
 ```ts
 // agents/my-app.ts
-import { completeEvidenceCoverage, createSessionSlot, defineAgent, sseJsonFrames, createPiAgentEventStream, driveFrameStream } from "niceeval/adapter";
+import { completeEvidenceCoverage, createSessionKey, defineAgent, sseJsonFrames, createPiAgentEventStream, driveFrameStream } from "niceeval/adapter";
 import type { AgentContext, PiAgentStream, SseFrameCursor } from "niceeval/adapter";
 import type { Turn, TurnInput } from "niceeval";
 
 const BASE_URL = "http://localhost:5299";               // 应用自己的端口，eval 不代管进程
 
 interface Pending { cursor: SseFrameCursor<Frame>; stream: PiAgentStream; callId: string }
-const pendingSlot = createSessionSlot<Pending>("my-app/pending");
+const pendingKey = createSessionKey<Pending>("my-app/pending");
 
 function readStream(cursor: SseFrameCursor<Frame>, ctx: AgentContext, stream: PiAgentStream): Promise<Turn> {
   return driveFrameStream(cursor, stream, ctx, (frame) => {
@@ -278,7 +278,7 @@ function readStream(cursor: SseFrameCursor<Frame>, ctx: AgentContext, stream: Pi
       return;
     }
     if (frame.type === "approval_request") {            // ← 本步：应用停下等审批，存下现场
-      ctx.session.set(pendingSlot, { cursor, stream, callId: frame.toolCallId });
+      ctx.session.set(pendingKey, { cursor, stream, callId: frame.toolCallId });
       return { pause: { id: frame.toolCallId, action: frame.toolName,
                         options: [{ id: "approve" }, { id: "deny" }] } };
       // driveFrameStream 收到 pause：补一条 input.requested、status 置 "waiting"、停止读流
@@ -291,7 +291,7 @@ export default defineAgent({
   name: "my-app",
   evidenceCoverage: completeEvidenceCoverage,
   async send(input: TurnInput, ctx: AgentContext): Promise<Turn> {
-    const held = ctx.session.take(pendingSlot);
+    const held = ctx.session.take(pendingKey);
     if (held) {                                         // ← t.respond("approve")：普通 send，先交裁决
       const approved = input.responses?.[0]?.optionId === "approve";  // 多请求并停时按 requestId 对位
       if (!approved) held.stream.markRejected(held.callId);
@@ -314,7 +314,7 @@ export default defineAgent({
 });
 ```
 
-不需要 HITL 的接口，删掉和等待相关的三处（`Pending`、`pendingSlot`、开头的 `take` 分支），其余不变。等待、回答、继续执行的完整流程见 [HITL](/zh/explanation/hitl)。
+不需要 HITL 的接口，删掉和等待相关的三处（`Pending`、`pendingKey`、开头的 `take` 分支），其余不变。等待、回答、继续执行的完整流程见 [HITL](/zh/explanation/hitl)。
 
 **这一步支持**：`t.check(turn.status, equals("waiting"))`、`t.requireInputRequest()`、`t.respond()` / `t.respondAll()`。被拒绝的调用可以用 `calledTool(toolMatch(..., { status: "rejected" }))` 精确断言。`t.requireInputRequest()` 找不到请求时，先查等待的那一轮是否同时返回了 `status: "waiting"` 和 `input.requested` 事件。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niceeval",
-  "version": "0.17.1",
+  "version": "0.19.0",
   "description": "Agent-native eval tool — eval agents, services, functions, and coding-agent fixtures",
   "type": "module",
   "license": "MIT",

package/dist/agents/effect-runtime.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect-runtime.js","sourceRoot":"","sources":["effect-runtime.ts"],"names":[],"mappings":";;AAaA,kDAEC;AACD,gEAGC;AAED,oDAUC;AACD,0CAEC;AACD,4CAKC;AACD,kDAKC;AA9CD,mCAAgC;AAWhC,MAAM,QAAQ,GAAG,IAAI,OAAO,EAA6B,CAAC;AAC1D,wFAAwF;AACxF,SAAgB,mBAAmB,CAAyC,MAA+D,EAAE,MAAkD;IAC3L,OAAO,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,eAAM,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;AACxF,CAAC;AACD,SAAgB,0BAA0B,CAA0B,KAAgB,EAAE,OAA2B;IAC7G,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC7B,OAAO,KAAK,CAAC;AACjB,CAAC;AACD,wGAAwG;AACxG,SAAgB,oBAAoB,CAAQ,QAAsC;IAC9E,OAAO,eAAM,CAAC,OAAO,CAAC,GAAG,EAAE;QACvB,MAAM,MAAM,GAAY,QAAQ,EAAE,CAAC;QACnC,IAAI,eAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;YACvB,OAAO,MAA8C,CAAC;QAC1D,OAAO,eAAM,CAAC,UAAU,CAAC;YACrB,GAAG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,MAAe,CAAC;YAC3C,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK;SAC1B,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC;AACD,SAAgB,eAAe,CAAC,KAAY,EAAE,KAAgB,EAAE,OAAyB;IACrF,OAAO,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AACrD,CAAC;AACD,SAAgB,gBAAgB,CAAC,KAAY,EAAE,OAAgB,EAAE,OAAgD;IAC7G,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACpC,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS;QAC3B,CAAC,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC,OAAO,EAAE,OAAmC,CAAC;QACvE,CAAC,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC,OAAO,CAAC,CAAC;AAC1C,CAAC;AACD,SAAgB,mBAAmB,CAAC,KAAY,EAAE,OAAgB,EAAE,OAAqB;IACrF,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACpC,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS;QAC3B,CAAC,CAAC,OAAO,EAAE,eAAe,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC;QAC9C,CAAC,CAAC,OAAO,EAAE,cAAc,EAAE,CAAC,OAAO,CAAC,CAAC;AAC7C,CAAC","sourcesContent":["import { Effect } from \"effect\";\nimport type { Agent, AgentContext, AgentSendContext, SandboxAgentSetupContext, SandboxAgentSendContext, Turn, TurnInput, } from \"./types.ts\";\nimport type { Sandbox } from \"../sandbox/types.ts\";\nexport type AgentSendEffect = (input: TurnInput, context: AgentSendContext) => Effect.Effect<Turn, unknown, never>;\nexport interface AgentEffectRuntime {\n    readonly send: AgentSendEffect;\n    readonly sandboxSetup?: (sandbox: Sandbox, context: SandboxAgentSetupContext) => Effect.Effect<void, unknown, never>;\n    readonly directSetup?: (context: AgentContext) => Effect.Effect<void, unknown, never>;\n    readonly sandboxTeardown?: (sandbox: Sandbox, context: AgentContext) => Effect.Effect<void, unknown, never>;\n    readonly directTeardown?: (context: AgentContext) => Effect.Effect<void, unknown, never>;\n}\nconst runtimes = new WeakMap<Agent, AgentEffectRuntime>();\n/** Promise facade for built-in adapters; Runner uses the registered Effect directly. */\nexport function effectAgentCallback<Args extends readonly unknown[], Value>(effect: (...args: Args) => Effect.Effect<Value, unknown, never>, signal: (...args: Args) => AbortSignal | undefined): (...args: Args) => Promise<Value> {\n    return (...args) => Effect.runPromise(effect(...args), { signal: signal(...args) });\n}\nexport function registerAgentEffectRuntime<AgentType extends Agent>(agent: AgentType, runtime: AgentEffectRuntime): AgentType {\n    runtimes.set(agent, runtime);\n    return agent;\n}\n/** Adapts the public Promise callback once; legacy Effect values remain an untyped runtime fallback. */\nexport function authorCallbackEffect<Value>(callback: () => Promise<Value> | Value): Effect.Effect<Value, unknown, never> {\n    return Effect.suspend(() => {\n        const result: unknown = callback();\n        if (Effect.isEffect(result))\n            return result as Effect.Effect<Value, unknown, never>;\n        return Effect.tryPromise({\n            try: () => Promise.resolve(result as Value),\n            catch: (cause) => cause,\n        });\n    });\n}\nexport function agentSendEffect(agent: Agent, input: TurnInput, context: AgentSendContext): Effect.Effect<Turn, unknown, never> | undefined {\n    return runtimes.get(agent)?.send(input, context);\n}\nexport function agentSetupEffect(agent: Agent, sandbox: Sandbox, context: SandboxAgentSetupContext | AgentContext): Effect.Effect<void, unknown, never> | undefined {\n    const runtime = runtimes.get(agent);\n    return agent.kind === \"sandbox\"\n        ? runtime?.sandboxSetup?.(sandbox, context as SandboxAgentSetupContext)\n        : runtime?.directSetup?.(context);\n}\nexport function agentTeardownEffect(agent: Agent, sandbox: Sandbox, context: AgentContext): Effect.Effect<void, unknown, never> | undefined {\n    const runtime = runtimes.get(agent);\n    return agent.kind === \"sandbox\"\n        ? runtime?.sandboxTeardown?.(sandbox, context)\n        : runtime?.directTeardown?.(context);\n}\nexport type InternalSandboxAgentDefinition = {\n    readonly send: (input: TurnInput, context: SandboxAgentSendContext) => Effect.Effect<Turn, unknown, never>;\n    readonly setup?: (sandbox: Sandbox, context: SandboxAgentSetupContext) => Effect.Effect<void, unknown, never>;\n    readonly teardown?: (sandbox: Sandbox, context: AgentContext) => Effect.Effect<void, unknown, never>;\n};\nexport type InternalDirectAgentDefinition = {\n    readonly send: (input: TurnInput, context: AgentSendContext) => Effect.Effect<Turn, unknown, never>;\n    readonly setup?: (context: AgentContext) => Effect.Effect<void, unknown, never>;\n    readonly teardown?: (context: AgentContext) => Effect.Effect<void, unknown, never>;\n};\n"]}

package/dist/agents/effect-runtime.d.cts

@@ -1,29 +0,0 @@
-import { Effect } from "effect";
-import type { Agent, AgentContext, AgentSendContext, SandboxAgentSetupContext, SandboxAgentSendContext, Turn, TurnInput } from "./types.cjs";
-import type { Sandbox } from "../sandbox/types.cjs";
-export type AgentSendEffect = (input: TurnInput, context: AgentSendContext) => Effect.Effect<Turn, unknown, never>;
-export interface AgentEffectRuntime {
-    readonly send: AgentSendEffect;
-    readonly sandboxSetup?: (sandbox: Sandbox, context: SandboxAgentSetupContext) => Effect.Effect<void, unknown, never>;
-    readonly directSetup?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly sandboxTeardown?: (sandbox: Sandbox, context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly directTeardown?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-}
-/** Promise facade for built-in adapters; Runner uses the registered Effect directly. */
-export declare function effectAgentCallback<Args extends readonly unknown[], Value>(effect: (...args: Args) => Effect.Effect<Value, unknown, never>, signal: (...args: Args) => AbortSignal | undefined): (...args: Args) => Promise<Value>;
-export declare function registerAgentEffectRuntime<AgentType extends Agent>(agent: AgentType, runtime: AgentEffectRuntime): AgentType;
-/** Adapts the public Promise callback once; legacy Effect values remain an untyped runtime fallback. */
-export declare function authorCallbackEffect<Value>(callback: () => Promise<Value> | Value): Effect.Effect<Value, unknown, never>;
-export declare function agentSendEffect(agent: Agent, input: TurnInput, context: AgentSendContext): Effect.Effect<Turn, unknown, never> | undefined;
-export declare function agentSetupEffect(agent: Agent, sandbox: Sandbox, context: SandboxAgentSetupContext | AgentContext): Effect.Effect<void, unknown, never> | undefined;
-export declare function agentTeardownEffect(agent: Agent, sandbox: Sandbox, context: AgentContext): Effect.Effect<void, unknown, never> | undefined;
-export type InternalSandboxAgentDefinition = {
-    readonly send: (input: TurnInput, context: SandboxAgentSendContext) => Effect.Effect<Turn, unknown, never>;
-    readonly setup?: (sandbox: Sandbox, context: SandboxAgentSetupContext) => Effect.Effect<void, unknown, never>;
-    readonly teardown?: (sandbox: Sandbox, context: AgentContext) => Effect.Effect<void, unknown, never>;
-};
-export type InternalDirectAgentDefinition = {
-    readonly send: (input: TurnInput, context: AgentSendContext) => Effect.Effect<Turn, unknown, never>;
-    readonly setup?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly teardown?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-};

package/dist/agents/effect-runtime.d.mts

@@ -1,29 +0,0 @@
-import { Effect } from "effect";
-import type { Agent, AgentContext, AgentSendContext, SandboxAgentSetupContext, SandboxAgentSendContext, Turn, TurnInput } from "./types.mjs";
-import type { Sandbox } from "../sandbox/types.mjs";
-export type AgentSendEffect = (input: TurnInput, context: AgentSendContext) => Effect.Effect<Turn, unknown, never>;
-export interface AgentEffectRuntime {
-    readonly send: AgentSendEffect;
-    readonly sandboxSetup?: (sandbox: Sandbox, context: SandboxAgentSetupContext) => Effect.Effect<void, unknown, never>;
-    readonly directSetup?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly sandboxTeardown?: (sandbox: Sandbox, context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly directTeardown?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-}
-/** Promise facade for built-in adapters; Runner uses the registered Effect directly. */
-export declare function effectAgentCallback<Args extends readonly unknown[], Value>(effect: (...args: Args) => Effect.Effect<Value, unknown, never>, signal: (...args: Args) => AbortSignal | undefined): (...args: Args) => Promise<Value>;
-export declare function registerAgentEffectRuntime<AgentType extends Agent>(agent: AgentType, runtime: AgentEffectRuntime): AgentType;
-/** Adapts the public Promise callback once; legacy Effect values remain an untyped runtime fallback. */
-export declare function authorCallbackEffect<Value>(callback: () => Promise<Value> | Value): Effect.Effect<Value, unknown, never>;
-export declare function agentSendEffect(agent: Agent, input: TurnInput, context: AgentSendContext): Effect.Effect<Turn, unknown, never> | undefined;
-export declare function agentSetupEffect(agent: Agent, sandbox: Sandbox, context: SandboxAgentSetupContext | AgentContext): Effect.Effect<void, unknown, never> | undefined;
-export declare function agentTeardownEffect(agent: Agent, sandbox: Sandbox, context: AgentContext): Effect.Effect<void, unknown, never> | undefined;
-export type InternalSandboxAgentDefinition = {
-    readonly send: (input: TurnInput, context: SandboxAgentSendContext) => Effect.Effect<Turn, unknown, never>;
-    readonly setup?: (sandbox: Sandbox, context: SandboxAgentSetupContext) => Effect.Effect<void, unknown, never>;
-    readonly teardown?: (sandbox: Sandbox, context: AgentContext) => Effect.Effect<void, unknown, never>;
-};
-export type InternalDirectAgentDefinition = {
-    readonly send: (input: TurnInput, context: AgentSendContext) => Effect.Effect<Turn, unknown, never>;
-    readonly setup?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly teardown?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-};

package/dist/agents/effect-runtime.d.ts

@@ -1,29 +0,0 @@
-import { Effect } from "effect";
-import type { Agent, AgentContext, AgentSendContext, SandboxAgentSetupContext, SandboxAgentSendContext, Turn, TurnInput } from "./types.js";
-import type { Sandbox } from "../sandbox/types.js";
-export type AgentSendEffect = (input: TurnInput, context: AgentSendContext) => Effect.Effect<Turn, unknown, never>;
-export interface AgentEffectRuntime {
-    readonly send: AgentSendEffect;
-    readonly sandboxSetup?: (sandbox: Sandbox, context: SandboxAgentSetupContext) => Effect.Effect<void, unknown, never>;
-    readonly directSetup?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly sandboxTeardown?: (sandbox: Sandbox, context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly directTeardown?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-}
-/** Promise facade for built-in adapters; Runner uses the registered Effect directly. */
-export declare function effectAgentCallback<Args extends readonly unknown[], Value>(effect: (...args: Args) => Effect.Effect<Value, unknown, never>, signal: (...args: Args) => AbortSignal | undefined): (...args: Args) => Promise<Value>;
-export declare function registerAgentEffectRuntime<AgentType extends Agent>(agent: AgentType, runtime: AgentEffectRuntime): AgentType;
-/** Adapts the public Promise callback once; legacy Effect values remain an untyped runtime fallback. */
-export declare function authorCallbackEffect<Value>(callback: () => Promise<Value> | Value): Effect.Effect<Value, unknown, never>;
-export declare function agentSendEffect(agent: Agent, input: TurnInput, context: AgentSendContext): Effect.Effect<Turn, unknown, never> | undefined;
-export declare function agentSetupEffect(agent: Agent, sandbox: Sandbox, context: SandboxAgentSetupContext | AgentContext): Effect.Effect<void, unknown, never> | undefined;
-export declare function agentTeardownEffect(agent: Agent, sandbox: Sandbox, context: AgentContext): Effect.Effect<void, unknown, never> | undefined;
-export type InternalSandboxAgentDefinition = {
-    readonly send: (input: TurnInput, context: SandboxAgentSendContext) => Effect.Effect<Turn, unknown, never>;
-    readonly setup?: (sandbox: Sandbox, context: SandboxAgentSetupContext) => Effect.Effect<void, unknown, never>;
-    readonly teardown?: (sandbox: Sandbox, context: AgentContext) => Effect.Effect<void, unknown, never>;
-};
-export type InternalDirectAgentDefinition = {
-    readonly send: (input: TurnInput, context: AgentSendContext) => Effect.Effect<Turn, unknown, never>;
-    readonly setup?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-    readonly teardown?: (context: AgentContext) => Effect.Effect<void, unknown, never>;
-};

package/dist/agents/effect-runtime.js

@@ -1,16 +0,0 @@
-import { createRequire as __niceevalCreateRequire } from "node:module";
-const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
-const __niceevalCanonical = __niceevalRequire("./effect-runtime.cjs");
-const __niceevalExport0 = __niceevalCanonical["agentSendEffect"];
-export { __niceevalExport0 as agentSendEffect };
-const __niceevalExport1 = __niceevalCanonical["agentSetupEffect"];
-export { __niceevalExport1 as agentSetupEffect };
-const __niceevalExport2 = __niceevalCanonical["agentTeardownEffect"];
-export { __niceevalExport2 as agentTeardownEffect };
-const __niceevalExport3 = __niceevalCanonical["authorCallbackEffect"];
-export { __niceevalExport3 as authorCallbackEffect };
-const __niceevalExport4 = __niceevalCanonical["effectAgentCallback"];
-export { __niceevalExport4 as effectAgentCallback };
-const __niceevalExport5 = __niceevalCanonical["registerAgentEffectRuntime"];
-export { __niceevalExport5 as registerAgentEffectRuntime };
-//# sourceMappingURL=effect-runtime.js.map

package/dist/agents/effect-runtime.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect-runtime.js","sources":[],"names":[],"mappings":""}

package/dist/agents/session-slot.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-slot.js","sourceRoot":"","sources":["session-slot.ts"],"names":[],"mappings":";;AAUA,8CAEC;AAHD,0CAA0C;AAC1C,SAAgB,iBAAiB,CAAI,IAAY;IAC7C,OAAO,EAAE,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,EAAoB,CAAC;AACnD,CAAC","sourcesContent":["declare const sessionSlotValue: unique symbol;\n/**\n * Adapter 私有的会话状态槽。运行时只用 `key` 的 symbol 身份寻址；\n * 非导出品牌让 `T` 在编译期保持不变，不同值类型的 slot 不能互换。\n */\nexport interface SessionSlot<T> {\n    readonly key: symbol;\n    readonly [sessionSlotValue]: (value: T) => T;\n}\n/** 创建一个按 symbol 身份隔离的 Adapter 私有会话状态槽。 */\nexport function createSessionSlot<T>(name: string): SessionSlot<T> {\n    return { key: Symbol(name) } as SessionSlot<T>;\n}\n"]}

package/dist/agents/session-slot.d.cts

@@ -1,12 +0,0 @@
-declare const sessionSlotValue: unique symbol;
-/**
- * Adapter 私有的会话状态槽。运行时只用 `key` 的 symbol 身份寻址；
- * 非导出品牌让 `T` 在编译期保持不变，不同值类型的 slot 不能互换。
- */
-export interface SessionSlot<T> {
-    readonly key: symbol;
-    readonly [sessionSlotValue]: (value: T) => T;
-}
-/** 创建一个按 symbol 身份隔离的 Adapter 私有会话状态槽。 */
-export declare function createSessionSlot<T>(name: string): SessionSlot<T>;
-export {};

package/dist/agents/session-slot.d.mts

@@ -1,12 +0,0 @@
-declare const sessionSlotValue: unique symbol;
-/**
- * Adapter 私有的会话状态槽。运行时只用 `key` 的 symbol 身份寻址；
- * 非导出品牌让 `T` 在编译期保持不变，不同值类型的 slot 不能互换。
- */
-export interface SessionSlot<T> {
-    readonly key: symbol;
-    readonly [sessionSlotValue]: (value: T) => T;
-}
-/** 创建一个按 symbol 身份隔离的 Adapter 私有会话状态槽。 */
-export declare function createSessionSlot<T>(name: string): SessionSlot<T>;
-export {};

package/dist/agents/session-slot.d.ts

@@ -1,12 +0,0 @@
-declare const sessionSlotValue: unique symbol;
-/**
- * Adapter 私有的会话状态槽。运行时只用 `key` 的 symbol 身份寻址；
- * 非导出品牌让 `T` 在编译期保持不变，不同值类型的 slot 不能互换。
- */
-export interface SessionSlot<T> {
-    readonly key: symbol;
-    readonly [sessionSlotValue]: (value: T) => T;
-}
-/** 创建一个按 symbol 身份隔离的 Adapter 私有会话状态槽。 */
-export declare function createSessionSlot<T>(name: string): SessionSlot<T>;
-export {};

package/dist/agents/session-slot.js

@@ -1,6 +0,0 @@
-import { createRequire as __niceevalCreateRequire } from "node:module";
-const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
-const __niceevalCanonical = __niceevalRequire("./session-slot.cjs");
-const __niceevalExport0 = __niceevalCanonical["createSessionSlot"];
-export { __niceevalExport0 as createSessionSlot };
-//# sourceMappingURL=session-slot.js.map

package/dist/agents/session-slot.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"session-slot.js","sources":[],"names":[],"mappings":""}