@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.3

package/dist/evals/budget.js

@@ -1,5 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable, Module } from "@nestjs/common";
 import { sql } from "kysely";
 import { audit } from "../identity/audit.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
 /**
  * 评测运行的 token 预算（C7）：`eval_runs.tokens_used` 在 PG 里原子累加，达到 `token_cap` 的同一条语句把
  * 状态置为 `capped`；worker 每次请求前查 {@link runActive}，不活跃就不再发新请求。在途请求可以越过上限，
@@ -83,13 +96,44 @@ export async function skipPendingJudges(db, runId, caseId) {
     await q.execute();
 }
 /**
- * 重算 `cases_done` = 结果全部结束、且没有等评委的结果的用例数（幂等：任务重做不会重复计数），达到 `cases_total` 且运行仍在执行 →
- * `completed`。先锁运行行再数（READ COMMITTED 下新语句看得到其他任务已提交的结果），并发完成的任务不会互相覆盖。
- * worker 每做完一个用例、取消、入队失败时都调用。在事务里调用时锁随事务释放。
+ * 运行仍在执行（queued / running），且所属组织与评测集的 agent 都没有删除：取消、达到上限、已结束、运行行已删除、
+ * 组织或 agent 已删除都为 false（删除组织 / agent 时会显式取消运行，这里再兜一次底，挡住删除与请求之间的竞争）。
  */
-export async function recountCases(db, runId) {
-    const run = async (trx) => {
-        const row = await trx
+export async function runActive(db, runId) {
+    const r = await db
+        .selectFrom("eval_runs as r")
+        .innerJoin("eval_sets as s", "s.id", "r.set_id")
+        .innerJoin("agents as a", "a.id", "s.agent_id")
+        .innerJoin("orgs as o", "o.id", "r.org_id")
+        .select("r.id")
+        .where("r.id", "=", runId)
+        .where("r.status", "in", [...ACTIVE_EVAL_STATUSES])
+        .where("a.deleted_at", "is", null)
+        .where("o.deleted_at", "is", null)
+        .executeTakeFirst();
+    return r !== undefined;
+}
+/**
+ * The eval run bookkeeping that needs a transaction: the progress recount (it locks the run row)
+ * and the cancellation of an org's or agent's runs when it is deleted. One provider, shared by the
+ * evals, the agents and the orgs.
+ */
+let EvalBudget = class EvalBudget {
+    db;
+    txHost;
+    constructor(db, txHost) {
+        this.db = db;
+        this.txHost = txHost;
+    }
+    /**
+     * 重算 `cases_done` = 结果全部结束、且没有等评委的结果的用例数（幂等：任务重做不会重复计数），达到 `cases_total` 且运行仍在执行 →
+     * `completed`。先锁运行行再数（READ COMMITTED 下新语句看得到其他任务已提交的结果），并发完成的任务不会互相覆盖。
+     * worker 每做完一个用例、取消、入队失败时都调用。Joins the caller's transaction (the lock is released with it),
+     * else runs in its own.
+     */
+    async recountCases(runId) {
+        const db = this.db.db;
+        const row = await db
             .selectFrom("eval_runs")
             .select(["cases_total", "status"])
             .where("id", "=", runId)
@@ -102,10 +146,10 @@ export async function recountCases(db, runId) {
         SELECT case_id FROM capybara.eval_results WHERE run_id = ${runId}
         GROUP BY case_id
         HAVING bool_and(status IN ('done', 'error', 'skipped') AND judge_status <> 'pending')
-      ) finished`.execute(trx);
+      ) finished`.execute(db);
         const done = Number(r.rows[0]?.n ?? 0);
         const complete = done >= row.cases_total && ACTIVE_EVAL_STATUSES.includes(row.status);
-        await trx
+        await db
             .updateTable("eval_runs")
             .set({
             cases_done: done,
@@ -113,66 +157,74 @@ export async function recountCases(db, runId) {
         })
             .where("id", "=", runId)
             .execute();
-    };
-    if (db.isTransaction)
-        await run(db);
-    else
-        await db.transaction().execute((trx) => run(trx));
-}
-/**
- * 运行仍在执行（queued / running），且所属组织与评测集的 agent 都没有删除：取消、达到上限、已结束、运行行已删除、
- * 组织或 agent 已删除都为 false（删除组织 / agent 时会显式取消运行，这里再兜一次底，挡住删除与请求之间的竞争）。
- */
-export async function runActive(db, runId) {
-    const r = await db
-        .selectFrom("eval_runs as r")
-        .innerJoin("eval_sets as s", "s.id", "r.set_id")
-        .innerJoin("agents as a", "a.id", "s.agent_id")
-        .innerJoin("orgs as o", "o.id", "r.org_id")
-        .select("r.id")
-        .where("r.id", "=", runId)
-        .where("r.status", "in", [...ACTIVE_EVAL_STATUSES])
-        .where("a.deleted_at", "is", null)
-        .where("o.deleted_at", "is", null)
-        .executeTakeFirst();
-    return r !== undefined;
-}
-/**
- * 删除组织或 agent 时（调用方的事务内）取消其在执行的评测运行：运行置 `cancelled`，未开始的结果 `skipped`、
- * 等评委的记 `skipped`，重算进度，每个运行写审计 `eval.run_cancelled`（detail 带原因）。在途请求做完后写不进新的请求
- * （worker 每次请求前查 {@link runActive}）。运行创建者离开组织不取消（Ruling S1-b：管理员的评测运行是组织的工作）。
- */
-export async function cancelEvalRuns(trx, scope, actor, reason) {
-    let q = trx
-        .updateTable("eval_runs")
-        .set({ status: "cancelled", finished_at: sql `now()` })
-        .where("org_id", "=", scope.orgId)
-        .where("status", "in", [...ACTIVE_EVAL_STATUSES]);
-    if (scope.agentId !== undefined) {
-        const agentId = scope.agentId;
-        q = q.where("set_id", "in", (eb) => eb.selectFrom("eval_sets").select("id").where("agent_id", "=", agentId));
     }
-    const runs = await q.returning("id").execute();
-    for (const r of runs) {
-        await trx
+    /**
+     * 删除组织或 agent 时（调用方的事务内）取消其在执行的评测运行：运行置 `cancelled`，未开始的结果 `skipped`、
+     * 等评委的记 `skipped`，重算进度，每个运行写审计 `eval.run_cancelled`（detail 带原因）。在途请求做完后写不进新的请求
+     * （worker 每次请求前查 {@link runActive}）。运行创建者离开组织不取消（Ruling S1-b：管理员的评测运行是组织的工作）。
+     */
+    async cancelRuns(scope, actor, reason) {
+        const db = this.db.db;
+        let q = db
+            .updateTable("eval_runs")
+            .set({ status: "cancelled", finished_at: sql `now()` })
+            .where("org_id", "=", scope.orgId)
+            .where("status", "in", [...ACTIVE_EVAL_STATUSES]);
+        if (scope.agentId !== undefined) {
+            const agentId = scope.agentId;
+            q = q.where("set_id", "in", (eb) => eb.selectFrom("eval_sets").select("id").where("agent_id", "=", agentId));
+        }
+        const runs = await q.returning("id").execute();
+        for (const r of runs) {
+            await this.skipRun(r.id);
+            await audit(db, {
+                actorAccountId: actor.accountId,
+                ...(actor.tokenId !== undefined && { actorTokenId: actor.tokenId }),
+                orgId: scope.orgId,
+                action: "eval.run_cancelled",
+                target: r.id,
+                detail: { reason },
+            });
+        }
+        return runs.map((r) => r.id);
+    }
+    /**
+     * A run that stopped (cancelled, its set deleted): its results not started yet are `skipped`,
+     * the pending judges too, and the progress is recounted, in the caller's transaction.
+     */
+    async skipRun(runId) {
+        await this.db
             .updateTable("eval_results")
             .set({ status: "skipped", updated_at: sql `now()` })
-            .where("run_id", "=", r.id)
+            .where("run_id", "=", runId)
             .where("status", "=", "pending")
             .execute();
-        await skipPendingJudges(trx, r.id);
-        await recountCases(trx, r.id);
-        await audit(trx, {
-            actorAccountId: actor.accountId,
-            ...(actor.tokenId !== undefined && { actorTokenId: actor.tokenId }),
-            orgId: scope.orgId,
-            action: "eval.run_cancelled",
-            target: r.id,
-            detail: { reason },
-        });
+        await skipPendingJudges(this.db.db, runId);
+        await this.recountCases(runId);
     }
-    return runs.map((r) => r.id);
-}
+};
+__decorate([
+    Transactional()
+], EvalBudget.prototype, "recountCases", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], EvalBudget.prototype, "cancelRuns", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], EvalBudget.prototype, "skipRun", null);
+EvalBudget = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(TransactionHost))
+], EvalBudget);
+export { EvalBudget };
+/** {@link EvalBudget} on its own: the agents and the orgs import it without the evals. */
+let EvalBudgetModule = class EvalBudgetModule {
+};
+EvalBudgetModule = __decorate([
+    Module({ providers: [EvalBudget], exports: [EvalBudget] })
+], EvalBudgetModule);
+export { EvalBudgetModule };
 export const addUsage = (a, b) => ({
     inputTokens: a.inputTokens + b.inputTokens,
     outputTokens: a.outputTokens + b.outputTokens,

package/dist/evals/evals.module.d.ts

@@ -0,0 +1,31 @@
+import { WorkerHost } from "@nestjs/bullmq";
+import { type DynamicModule } from "@nestjs/common";
+import type { Job, Worker } from "bullmq";
+import type { KernelConfig } from "../config/schema.js";
+import { type EvalJobData } from "./jobs.js";
+import { EvalWorker } from "./worker.js";
+/**
+ * Evals: the trajectory viewer, eval sets and cases, eval runs (the producer of
+ * `cap-kernel-evals`) and the run bookkeeping ({@link EvalBudgetModule}, re-exported).
+ */
+export declare class EvalsModule {
+}
+/** The consumer of `cap-kernel-evals` (one case per job): {@link EvalWorker}. */
+export declare class EvalsProcessor extends WorkerHost<Worker<EvalJobData>> {
+    private readonly evals;
+    constructor(evals: EvalWorker);
+    process(job: Job<EvalJobData>, token?: string): Promise<void>;
+    failed(job: Job<EvalJobData> | undefined, err: Error): void;
+    error(err: Error): void;
+}
+/**
+ * The eval worker (step and full-run replays, the judge) over the runtime's loop and model
+ * registry, and the consumer of `cap-kernel-evals`, its options from the startup config
+ * (concurrency `evals.workerConcurrency`, the run queues' job lock and stalled detection). Imported
+ * only by the worker role (`WorkerModule`), so other roles get no processor and no BullMQ worker.
+ * The worker never starts by itself: the worker role (`WorkerRole`) starts it after the extensions
+ * loaded, and drains it on stop.
+ */
+export declare class EvalWorkersModule {
+    static forRoot(config: KernelConfig): DynamicModule;
+}

package/dist/evals/evals.module.js

@@ -0,0 +1,114 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var EvalWorkersModule_1;
+import { hostname } from "node:os";
+import { OnWorkerEvent, WorkerHost } from "@nestjs/bullmq";
+import { Inject, Injectable, Module } from "@nestjs/common";
+import { EventLogModule } from "../conversations/event-log.js";
+import { IdentityModule } from "../identity/identity.module.js";
+import { configuredProcessor } from "../infra/queue/configured-processor.js";
+import { QueueModule } from "../infra/queue/queue.module.js";
+import { runJob } from "../infra/queue/run-job.js";
+import { ModelsModule } from "../models/models.module.js";
+import { OrgLockModule } from "../orgs/org-lock.js";
+import { ProvidersModule } from "../runtime/providers.js";
+import { RuntimeModule } from "../runtime/runtime.module.js";
+import { EvalBudgetModule } from "./budget.js";
+import { EVAL_QUEUE_NAME, EvalJobs } from "./jobs.js";
+import { EvalReplaySeeder } from "./run-replay.js";
+import { EvalRunsService } from "./runs.service.js";
+import { EvalSetsService } from "./sets.service.js";
+import { TrajectoryService } from "./trajectory.service.js";
+import { EVAL_MAX_STALLED_COUNT, EvalWorker } from "./worker.js";
+/**
+ * Evals: the trajectory viewer, eval sets and cases, eval runs (the producer of
+ * `cap-kernel-evals`) and the run bookkeeping ({@link EvalBudgetModule}, re-exported).
+ */
+let EvalsModule = class EvalsModule {
+};
+EvalsModule = __decorate([
+    Module({
+        imports: [
+            EventLogModule,
+            ModelsModule,
+            IdentityModule,
+            OrgLockModule,
+            ProvidersModule,
+            EvalBudgetModule,
+            QueueModule.registerQueue(EVAL_QUEUE_NAME),
+        ],
+        providers: [TrajectoryService, EvalSetsService, EvalRunsService, EvalJobs],
+        exports: [TrajectoryService, EvalSetsService, EvalRunsService, EvalJobs, EvalBudgetModule],
+    })
+], EvalsModule);
+export { EvalsModule };
+/** The consumer of `cap-kernel-evals` (one case per job): {@link EvalWorker}. */
+let EvalsProcessor = class EvalsProcessor extends WorkerHost {
+    evals;
+    constructor(evals) {
+        super();
+        this.evals = evals;
+    }
+    process(job, token) {
+        return runJob(EVAL_QUEUE_NAME, job, () => this.evals.process(job, token));
+    }
+    failed(job, err) {
+        this.evals.onFailed(job, err);
+    }
+    error(err) {
+        this.evals.onError(err);
+    }
+};
+__decorate([
+    OnWorkerEvent("failed")
+], EvalsProcessor.prototype, "failed", null);
+__decorate([
+    OnWorkerEvent("error")
+], EvalsProcessor.prototype, "error", null);
+EvalsProcessor = __decorate([
+    Injectable(),
+    __param(0, Inject(EvalWorker))
+], EvalsProcessor);
+export { EvalsProcessor };
+/**
+ * The eval worker (step and full-run replays, the judge) over the runtime's loop and model
+ * registry, and the consumer of `cap-kernel-evals`, its options from the startup config
+ * (concurrency `evals.workerConcurrency`, the run queues' job lock and stalled detection). Imported
+ * only by the worker role (`WorkerModule`), so other roles get no processor and no BullMQ worker.
+ * The worker never starts by itself: the worker role (`WorkerRole`) starts it after the extensions
+ * loaded, and drains it on stop.
+ */
+let EvalWorkersModule = EvalWorkersModule_1 = class EvalWorkersModule {
+    static forRoot(config) {
+        const { jobLockMs, stalledIntervalMs } = config.runtime;
+        return {
+            module: EvalWorkersModule_1,
+            imports: [EvalsModule, RuntimeModule, EventLogModule, ModelsModule],
+            providers: [
+                EvalReplaySeeder,
+                EvalWorker,
+                configuredProcessor(EvalsProcessor, EVAL_QUEUE_NAME, {
+                    // the worker name is recorded on the job (BullMQ processedBy): which replica ran it
+                    name: `${hostname()}-${process.pid}`,
+                    concurrency: config.evals.workerConcurrency,
+                    lockDuration: jobLockMs,
+                    stalledInterval: stalledIntervalMs,
+                    maxStalledCount: EVAL_MAX_STALLED_COUNT,
+                }),
+            ],
+            exports: [EvalWorker, EvalsProcessor],
+        };
+    }
+};
+EvalWorkersModule = EvalWorkersModule_1 = __decorate([
+    Module({})
+    // biome-ignore lint/complexity/noStaticOnlyClass: a Nest dynamic module
+], EvalWorkersModule);
+export { EvalWorkersModule };

package/dist/evals/jobs.d.ts

@@ -0,0 +1,20 @@
+import type { Queue } from "bullmq";
+/** 评测队列的 BullMQ 队列名（不含 `:`，C7）。 */
+export declare const EVAL_QUEUE_NAME = "cap-kernel-evals";
+/** 每个用例一个任务（C7；不含 `:`）。 */
+export declare const evalJobId: (runId: string, caseId: string) => string;
+/** 评测任务的数据。 */
+export interface EvalJobData {
+    runId: string;
+    caseId: string;
+    orgId: string;
+}
+/**
+ * The producer of `cap-kernel-evals` (one job per case, {@link evalJobId}); the eval worker
+ * consumes it on the worker role. A leaf module: the runs service and the worker import it.
+ */
+export declare class EvalJobs {
+    private readonly queue;
+    constructor(queue: Pick<Queue, "addBulk">);
+    enqueue(jobs: EvalJobData[]): Promise<void>;
+}

package/dist/evals/jobs.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { getQueueToken } from "@nestjs/bullmq";
+import { Inject, Injectable } from "@nestjs/common";
+/** 评测队列的 BullMQ 队列名（不含 `:`，C7）。 */
+export const EVAL_QUEUE_NAME = "cap-kernel-evals";
+/** 每个用例一个任务（C7；不含 `:`）。 */
+export const evalJobId = (runId, caseId) => `eval-${runId}-${caseId}`;
+/**
+ * The producer of `cap-kernel-evals` (one job per case, {@link evalJobId}); the eval worker
+ * consumes it on the worker role. A leaf module: the runs service and the worker import it.
+ */
+let EvalJobs = class EvalJobs {
+    queue;
+    constructor(queue) {
+        this.queue = queue;
+    }
+    async enqueue(jobs) {
+        await this.queue.addBulk(jobs.map((data) => ({
+            name: "case",
+            data,
+            opts: {
+                jobId: evalJobId(data.runId, data.caseId),
+                // 处理函数外的暂时故障（PG / Redis）：指数退避重试，不让整个用例一次失败。
+                // 结果按认领号写入，重做不会重复写结果
+                attempts: 3,
+                backoff: { type: "exponential", delay: 1000 },
+                removeOnComplete: true,
+                removeOnFail: 1000,
+            },
+        })));
+    }
+};
+EvalJobs = __decorate([
+    Injectable(),
+    __param(0, Inject(getQueueToken(EVAL_QUEUE_NAME)))
+], EvalJobs);
+export { EvalJobs };

package/dist/evals/recorded-tools.d.ts

@@ -1,4 +1,5 @@
 import type { EventLog } from "../conversations/event-log.js";
+import { type LegacyScope } from "../tools/legacy-keys.js";
 import { type ToolPipeline, type ToolStepContext } from "../tools/pipeline.js";
 import type { CaseSnapshot } from "./snapshot.js";
 /**
@@ -15,12 +16,34 @@ export interface RecordedCall {
     inputKey: string;
     content: string;
     isError: boolean;
-    /** 原结果里的 `tool_search` 已加载工具（照抄：之后请求的已加载集合由日志还原）。 */
+    /** 原结果里的 `ToolSearch` 已加载工具（照抄：之后请求的已加载集合由日志还原）。 */
     loadedTools?: string[];
     contentTypes?: string[];
     /** 原 `tool_call_started` 的定义指纹（没有开始事件的调用为空串）。 */
     specHash: string;
+    /** The recorded call used release-candidate names; `toolKey` and `inputKey` are already the current ones. */
+    legacy?: true;
 }
+/**
+ * The connectors and extensions an rc `<x>__<tool>` key can name, from positive evidence in the
+ * snapshot only (a head with no evidence, or evidence of both kinds, stays unmapped, so its
+ * recorded calls are unmatched, which is a safe miss):
+ * - a connector: the tool definition the key was recorded with (`toolSpecs`, found by the specHash of
+ *   its `tool_call_started` or its `model_call` tools / catalog entry) has `connectorData`;
+ * - an extension: that definition exists without `connectorData` and its name is the key's tool
+ *   part, or an agent definition names exactly that tool as a `{ kind: "plugin", plugin: x, name }` ref.
+ */
+export declare function legacyScopeOf(s: CaseSnapshot): LegacyScope;
+/**
+ * A recorded call in the current names: an rc builtin or `<x>__<tool>` key becomes its current
+ * key with the input's parameters renamed. Only the recorded side is ever normalized; a call
+ * already in current names (or one that cannot be mapped) is returned as is.
+ */
+export declare function currentCall(name: string, input: unknown, scope: LegacyScope): {
+    name: string;
+    input: unknown;
+    legacy: boolean;
+};
 /** 规范化 JSON：对象键递归按码点排序，数组保持顺序；`undefined` 按 JSON 规则省略。 */
 export declare function canonicalJson(v: unknown): string;
 /** The matching key of a call: the canonical JSON of its input without the ignored fields. */
@@ -43,7 +66,10 @@ export declare class RecordedToolPipeline implements Pick<ToolPipeline, "runStep
     private readonly d;
     private readonly used;
     private misses;
+    private legacyHits;
     constructor(d: RecordedToolPipelineDeps);
+    /** Calls so far matched with a recording made under release-candidate tool names. */
+    legacyMatches(): number;
     /** 至今没有匹配到记录的调用数。 */
     unmatched(): number;
     runStep(ctx: ToolStepContext): Promise<{

package/dist/evals/recorded-tools.js

@@ -1,4 +1,6 @@
 import { assistantIdemKey } from "../runtime/model-call.js";
+import { MATCH_IGNORED_FIELDS } from "../tools/builtin-names.js";
+import { isLegacyPrefixedKey, legacyToolInput, legacyToolKey, } from "../tools/legacy-keys.js";
 import { RUN_STOPPED_TEXT } from "../tools/pipeline.js";
 /**
  * 整轮回放的工具管线（C6 / Review Focus 3）：只回放原运行记录的工具结果，**从不执行任何工具**——
@@ -7,6 +9,77 @@ import { RUN_STOPPED_TEXT } from "../tools/pipeline.js";
  */
 /** 没有匹配记录时模型看到的工具结果（模型可见，英文）。 */
 export const REPLAY_NO_RECORDING = "[replay] No recorded result matches this tool call (same tool and arguments); the tool was not executed during replay.";
+/**
+ * The connectors and extensions an rc `<x>__<tool>` key can name, from positive evidence in the
+ * snapshot only (a head with no evidence, or evidence of both kinds, stays unmapped, so its
+ * recorded calls are unmatched, which is a safe miss):
+ * - a connector: the tool definition the key was recorded with (`toolSpecs`, found by the specHash of
+ *   its `tool_call_started` or its `model_call` tools / catalog entry) has `connectorData`;
+ * - an extension: that definition exists without `connectorData` and its name is the key's tool
+ *   part, or an agent definition names exactly that tool as a `{ kind: "plugin", plugin: x, name }` ref.
+ */
+export function legacyScopeOf(s) {
+    const hashes = new Map();
+    const note = (key, hash) => {
+        if (!isLegacyPrefixedKey(key))
+            return;
+        const set = hashes.get(key) ?? new Set();
+        if (hash !== undefined && hash !== "")
+            set.add(hash);
+        hashes.set(key, set);
+    };
+    for (const e of s.events) {
+        if (e.type === "tool_call_started") {
+            const p = e.payload;
+            note(p.toolKey, p.specHash);
+        }
+        else if (e.type === "model_call") {
+            const r = e.payload.request;
+            for (const t of [...(r?.tools ?? []), ...(r?.catalog ?? [])])
+                note(t.key, t.specHash);
+        }
+    }
+    const extensionNames = new Set();
+    const connectorSlugs = new Set();
+    const planted = new Set();
+    for (const def of Object.values(s.definitions)) {
+        for (const t of def.tools)
+            if (t.kind === "plugin")
+                planted.add(`${t.plugin}__${t.name}`);
+    }
+    for (const [key, set] of hashes) {
+        const i = key.indexOf("__");
+        const head = key.slice(0, i);
+        const tool = key.slice(i + 2);
+        for (const h of set) {
+            const spec = s.toolSpecs[h];
+            if (spec === undefined)
+                continue;
+            if (spec.connectorData !== undefined) {
+                connectorSlugs.add(head);
+            }
+            else if (spec.name === tool) {
+                extensionNames.add(head);
+            }
+        }
+    }
+    for (const key of planted) {
+        if (hashes.has(key))
+            extensionNames.add(key.slice(0, key.indexOf("__")));
+    }
+    return { connectorSlugs, extensionNames };
+}
+/**
+ * A recorded call in the current names: an rc builtin or `<x>__<tool>` key becomes its current
+ * key with the input's parameters renamed. Only the recorded side is ever normalized; a call
+ * already in current names (or one that cannot be mapped) is returned as is.
+ */
+export function currentCall(name, input, scope) {
+    const key = legacyToolKey(name, scope);
+    if (key === null)
+        return { name, input, legacy: false };
+    return { name: key, input: legacyToolInput(name, input), legacy: true };
+}
 /** 规范化 JSON：对象键递归按码点排序，数组保持顺序；`undefined` 按 JSON 规则省略。 */
 export function canonicalJson(v) {
     const norm = (x) => {
@@ -23,14 +96,6 @@ export function canonicalJson(v) {
     };
     return JSON.stringify(norm(v) ?? null);
 }
-/**
- * Input fields left out when matching, per tool: display-only arguments the model writes that do not
- * change what the tool does. `sandbox_bash`'s `description` became required in UI refresh B, so a
- * recording without it and a replayed call with one (or a different wording) still match.
- */
-const MATCH_IGNORED_FIELDS = {
-    sandbox_bash: ["description"],
-};
 /** The matching key of a call: the canonical JSON of its input without the ignored fields. */
 export function matchKey(toolKey, input) {
     const ignored = MATCH_IGNORED_FIELDS[toolKey];
@@ -64,6 +129,7 @@ export function recordedCalls(s) {
                 started.set(p.callId, p.specHash);
         }
     }
+    const scope = legacyScopeOf(s);
     const out = [];
     for (const e of own) {
         if (e.type !== "assistant_message")
@@ -76,9 +142,11 @@ export function recordedCalls(s) {
             const r = results.get(call.id);
             if (!r)
                 continue;
+            const cur = currentCall(call.name, call.input, scope);
             out.push({
-                toolKey: call.name,
-                inputKey: matchKey(call.name, call.input),
+                toolKey: cur.name,
+                inputKey: matchKey(cur.name, cur.input),
+                ...(cur.legacy && { legacy: true }),
                 content: r.content,
                 isError: r.isError,
                 ...(r.loadedTools !== undefined && { loadedTools: r.loadedTools }),
@@ -98,9 +166,14 @@ export class RecordedToolPipeline {
     d;
     used = new Set();
     misses = 0;
+    legacyHits = 0;
     constructor(d) {
         this.d = d;
     }
+    /** Calls so far matched with a recording made under release-candidate tool names. */
+    legacyMatches() {
+        return this.legacyHits;
+    }
     /** 至今没有匹配到记录的调用数。 */
     unmatched() {
         return this.misses;
@@ -162,6 +235,8 @@ export class RecordedToolPipeline {
         if (i < 0)
             return undefined;
         this.used.add(i);
+        if (this.d.recordings[i]?.legacy === true)
+            this.legacyHits++;
         return this.d.recordings[i];
     }
 }