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

package/dist/evals/run-replay.js

@@ -1,11 +1,24 @@
+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 { randomUUID } from "node:crypto";
 import { ModelError, } from "@capybara-hq/plugin-sdk";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { normalizeStoredDefinition } from "../agents/definition.js";
+import { EventLog } from "../conversations/event-log.js";
 import { ApiError } from "../errors.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";
 import { estimateTokens } from "../runtime/context/tokens.js";
 import { RunError } from "../runtime/model-call.js";
-import { finishRun } from "../runtime/run-finish.js";
 import { recordedSkillForks } from "../runtime/subagents/skill-fork.js";
 import { skillsCatalogIdemKey } from "../skills/catalog.js";
 import { ACTIVE_EVAL_STATUSES, addUsage, consumeTokens, TOO_MANY_ERRORS, usageTokens, } from "./budget.js";
@@ -17,6 +30,111 @@ export class ReplayClaimLost extends Error {
         this.name = "ReplayClaimLost";
     }
 }
+/**
+ * The seed of a full-run replay (C6): the `kind = 'eval'` conversation with the events before the
+ * original run at their original seqs, the run row and its `run_started` (and the original
+ * `skills_catalog`), in one transaction of its own.
+ */
+let EvalReplaySeeder = class EvalReplaySeeder {
+    db;
+    eventLog;
+    txHost;
+    constructor(db, eventLog, txHost) {
+        this.db = db;
+        this.eventLog = eventLog;
+        this.txHost = txHost;
+    }
+    /**
+     * Writes the seed; `onSeeded` runs inside the same transaction (false = the claim is lost: the
+     * seed rolls back and {@link ReplayClaimLost} is thrown).
+     */
+    async seed(p, onSeeded) {
+        const { conversationId, runId, evalRunId } = p;
+        // 运行行加共享锁并复核仍在执行：与取消 / 删除评测集（UPDATE 持行锁）互斥，删除之后不会再长出评测对话
+        const live = await this.db
+            .selectFrom("eval_runs")
+            .select("id")
+            .where("id", "=", evalRunId)
+            .where("status", "in", [...ACTIVE_EVAL_STATUSES])
+            .forShare()
+            .executeTakeFirst();
+        if (!live)
+            throw new ReplayClaimLost();
+        await this.db
+            .insertInto("conversations")
+            .values({
+            id: conversationId,
+            org_id: p.orgId,
+            agent_id: p.agentId,
+            account_id: p.accountId,
+            last_seq: p.runStartedSeq - 1,
+            consumed_seq: p.consumed,
+            kind: "eval",
+            eval_run_id: evalRunId,
+        })
+            .execute();
+        for (let i = 0; i < p.seeds.length; i += SEED_BATCH) {
+            await this.db
+                .insertInto("conversation_events")
+                .values(p.seeds.slice(i, i + SEED_BATCH).map((e) => ({
+                conversation_id: conversationId,
+                seq: e.seq,
+                type: e.type,
+                run_id: e.runId,
+                idem_key: null,
+                payload: JSON.stringify(e.payload),
+                created_at: new Date(e.createdAt),
+            })))
+                .execute();
+        }
+        await this.db
+            .insertInto("runs")
+            .values({
+            id: runId,
+            conversation_id: conversationId,
+            status: "running",
+            agent_version: p.agentVersion,
+            trigger_account_id: p.accountId,
+            trigger_seq: p.trigger,
+            started_at: new Date(),
+        })
+            .execute();
+        await this.eventLog.appendIn(conversationId, [
+            {
+                type: "run_started",
+                runId,
+                idemKey: `run_started:${runId}`,
+                payload: {
+                    agentVersion: p.agentVersion,
+                    model: p.model,
+                    triggerAccountId: p.accountId,
+                },
+            },
+            ...(p.catalog
+                ? [
+                    {
+                        type: "skills_catalog",
+                        runId,
+                        idemKey: skillsCatalogIdemKey(runId),
+                        payload: p.catalog.payload,
+                    },
+                ]
+                : []),
+        ]);
+        if (onSeeded && !(await onSeeded(conversationId)))
+            throw new ReplayClaimLost();
+    }
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalReplaySeeder.prototype, "seed", null);
+EvalReplaySeeder = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(EventLog)),
+    __param(2, Inject(TransactionHost))
+], EvalReplaySeeder);
+export { EvalReplaySeeder };
 /** 运行不再执行或失去认领时的原因；还能继续为 null。 */
 async function stopReason(db, evalRunId, stillClaimed) {
     const r = await db
@@ -183,81 +301,21 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         };
     const conversationId = randomUUID();
     const runId = randomUUID();
-    await db.transaction().execute(async (t) => {
-        // 运行行加共享锁并复核仍在执行：与取消 / 删除评测集（UPDATE 持行锁）互斥，删除之后不会再长出评测对话
-        const live = await t
-            .selectFrom("eval_runs")
-            .select("id")
-            .where("id", "=", evalRunId)
-            .where("status", "in", [...ACTIVE_EVAL_STATUSES])
-            .forShare()
-            .executeTakeFirst();
-        if (!live)
-            throw new ReplayClaimLost();
-        await t
-            .insertInto("conversations")
-            .values({
-            id: conversationId,
-            org_id: s.orgId,
-            agent_id: s.agentId,
-            account_id: accountId,
-            last_seq: R - 1,
-            consumed_seq: consumed,
-            kind: "eval",
-            eval_run_id: evalRunId,
-        })
-            .execute();
-        for (let i = 0; i < seeds.length; i += SEED_BATCH) {
-            await t
-                .insertInto("conversation_events")
-                .values(seeds.slice(i, i + SEED_BATCH).map((e) => ({
-                conversation_id: conversationId,
-                seq: e.seq,
-                type: e.type,
-                run_id: e.runId,
-                idem_key: null,
-                payload: JSON.stringify(e.payload),
-                created_at: new Date(e.createdAt),
-            })))
-                .execute();
-        }
-        await t
-            .insertInto("runs")
-            .values({
-            id: runId,
-            conversation_id: conversationId,
-            status: "running",
-            agent_version: candidate.agentVersion,
-            trigger_account_id: accountId,
-            trigger_seq: trigger,
-            started_at: new Date(),
-        })
-            .execute();
-        await eventLog.append(conversationId, [
-            {
-                type: "run_started",
-                runId,
-                idemKey: `run_started:${runId}`,
-                payload: {
-                    agentVersion: candidate.agentVersion,
-                    model: agent.model,
-                    triggerAccountId: accountId,
-                },
-            },
-            ...(catalog
-                ? [
-                    {
-                        type: "skills_catalog",
-                        runId,
-                        idemKey: skillsCatalogIdemKey(runId),
-                        payload: catalog.payload,
-                    },
-                ]
-                : []),
-        ], t);
-        if (d.onSeeded && !(await d.onSeeded(t, conversationId)))
-            throw new ReplayClaimLost();
-    });
+    await d.seeder.seed({
+        evalRunId,
+        orgId: s.orgId,
+        agentId: s.agentId,
+        accountId,
+        conversationId,
+        runId,
+        runStartedSeq: R,
+        consumed,
+        seeds,
+        trigger,
+        agentVersion: candidate.agentVersion,
+        model: agent.model,
+        catalog,
+    }, d.onSeeded);
     await d.hooks?.afterRunSeeded?.(evalRunId, conversationId);
     // 停止：取消 / 越限 / 熔断 / 失去认领 / 截止时间 → 中止 loop（进行中的请求立即停下，loop 以 aborted 返回）
     const stopper = new AbortController();
@@ -412,7 +470,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         }
         return out;
     };
-    const runtime = d.config().runtime;
+    const runtime = d.config.get().runtime;
     const deadline = Date.now() + runtime.maxRunSeconds * 1000;
     let deadlineHit = false;
     const timer = setTimeout(() => {
@@ -447,13 +505,15 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
     }
     catch (e) {
         const err = e instanceof RunError ? e : new RunError("run.internal", "The run failed unexpectedly");
-        await finishRun(db, eventLog, {
+        await d.runFinish
+            .finish({
             conversationId,
             runId,
             status: "failed",
             consumed: null,
             event: { type: "run_failed", payload: { error: { code: err.code, message: err.message } } },
-        }).catch((x) => d.log.warn("cannot finish eval replay run", { runId, err: x }));
+        })
+            .catch((x) => d.log.warn("cannot finish eval replay run", { runId, err: x }));
         await Promise.allSettled([...charges]);
         throw crash ?? e;
     }
@@ -472,7 +532,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
     if (outcome.kind === "aborted" && stopped === undefined && signal.aborted)
         stopped = "shutdown";
     const finalConsumed = Math.max(0, ...fed.values(), trigger);
-    await finishRun(db, eventLog, {
+    await d.runFinish.finish({
         conversationId,
         runId,
         status: outcome.kind === "aborted" ? "aborted" : "completed",

package/dist/evals/runs.controller.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
-import type { EvalEstimate, EvalResultLight, EvalResultView, EvalRunsService, EvalRunView, EvalTokenCaps } from "./runs.service.js";
+import { type EvalEstimate, type EvalResultLight, type EvalResultView, EvalRunsService, type EvalRunView, type EvalTokenCaps } from "./runs.service.js";
 /** `tokenCap` 只校验类型，范围由服务判定（`eval.token_cap_invalid`）。 */
 declare const EstimateBody: z.ZodObject<{
     mode: z.ZodEnum<{

package/dist/evals/runs.controller.js

@@ -7,13 +7,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Body, Controller, Get, HttpCode, Inject, Param, Post, Put, Query } from "@nestjs/common";
+import { Controller, Get, HttpCode, Inject, Param, Post, Put } from "@nestjs/common";
 import { z } from "zod";
 import { ModelRef } from "../agents/definition.js";
-import { EVAL_RUNS } from "../http/tokens.js";
-import { ZodPipe } from "../http/zod.pipe.js";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
+import { createZodDto } from "../infra/validation/create-zod-dto.js";
+import { ZBody, ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { EvalRunsService, } from "./runs.service.js";
 const Candidate = z
     .object({
     agentVersion: z.number().int().min(1).optional(),
@@ -63,6 +64,14 @@ function candidateOf(c) {
         ...(c.instructions !== undefined && { instructions: c.instructions }),
     };
 }
+class EstimateBodyDto extends createZodDto(EstimateBody, "EvalRunEstimateBody") {
+}
+class StartBodyDto extends createZodDto(StartBody, "EvalRunStartBody") {
+}
+class ResultsQueryDto extends createZodDto(ResultsQuery, "EvalRunResultsQuery") {
+}
+class LabelBodyDto extends createZodDto(LabelBody, "EvalRunLabelBody") {
+}
 /**
  * 评测运行（`/api/v1/orgs/:orgId/eval-sets/:setId/runs`、`/api/v1/orgs/:orgId/eval-runs/:runId[/results[/:resultId]]`）与
  * 结果的人工标注（`/api/v1/orgs/:orgId/eval-results/:resultId/label`）：
@@ -136,7 +145,7 @@ __decorate([
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("setId")),
-    __param(3, Body(new ZodPipe(EstimateBody)))
+    __param(3, ZBody(EstimateBodyDto))
 ], EvalRunsController.prototype, "estimate", null);
 __decorate([
     Post("eval-sets/:setId/runs"),
@@ -144,7 +153,7 @@ __decorate([
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("setId")),
-    __param(3, Body(new ZodPipe(StartBody)))
+    __param(3, ZBody(StartBodyDto))
 ], EvalRunsController.prototype, "start", null);
 __decorate([
     Get("eval-sets/:setId/runs"),
@@ -166,7 +175,7 @@ __decorate([
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("runId")),
-    __param(3, Query(new ZodPipe(ResultsQuery)))
+    __param(3, ZQuery(ResultsQueryDto))
 ], EvalRunsController.prototype, "results", null);
 __decorate([
     Get("eval-runs/:runId/results/:resultId"),
@@ -190,10 +199,10 @@ __decorate([
     __param(0, CurrentPrincipal()),
     __param(1, CurrentOrg()),
     __param(2, Param("resultId")),
-    __param(3, Body(new ZodPipe(LabelBody)))
+    __param(3, ZBody(LabelBodyDto))
 ], EvalRunsController.prototype, "label", null);
 EvalRunsController = __decorate([
     Controller("api/v1/orgs/:orgId"),
-    __param(0, Inject(EVAL_RUNS))
+    __param(0, Inject(EvalRunsService))
 ], EvalRunsController);
 export { EvalRunsController };

package/dist/evals/runs.service.d.ts

@@ -1,26 +1,21 @@
-import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { Redis } from "ioredis";
 import { type AgentDefinition } from "../agents/definition.js";
-import type { KernelConfig } from "../config/schema.js";
 import { type Selection } from "../conversations/selection.js";
-import type { EvalResultStatus, EvalRunStatus, JudgeStatus, KernelDb } from "../db/kernel-schema.js";
-import type { SettingsService } from "../identity/settings.js";
-import { type PricesService } from "../models/prices.js";
-import type { ModelPurposesService } from "../models/purposes.js";
-import { type ProviderRegistry } from "../runtime/providers.js";
+import type { EvalResultStatus, EvalRunStatus, JudgeStatus, KernelSchemaDb } from "../db/kernel-schema.js";
+import { SettingsService } from "../identity/settings.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { LockService } from "../infra/lock/lock.service.js";
+import { PricesService } from "../models/prices.js";
+import { ModelPurposesService } from "../models/purposes.js";
+import { OrgLock } from "../orgs/org-lock.js";
+import { ProviderRegistry } from "../runtime/providers.js";
+import { EvalBudget } from "./budget.js";
+import { EvalJobs } from "./jobs.js";
 import type { CaseSnapshot } from "./snapshot.js";
 import { type EvalCandidate } from "./step-replay.js";
+export { EVAL_QUEUE_NAME, type EvalJobData, evalJobId } from "./jobs.js";
 export type { EvalCandidate, EvalResultStatus, EvalRunStatus };
-/** 评测队列的 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;
-}
 /** 运行前的估算（D5：运行前显示预计请求数）。 */
 export interface EvalEstimate {
     cases: number;
@@ -126,54 +121,31 @@ export interface EvalResultView {
     labeledBy: string | null;
     labeledAt: string | null;
 }
-/** 评测队列（生产方）：懒建连接；`close()` 关闭。 */
-export declare class EvalQueue {
-    private readonly redisUrl;
-    private readonly log;
-    private queue;
-    private conn;
-    private closed;
-    constructor(redisUrl: string, log: Pick<Logger, "error">);
-    private get;
-    enqueue(jobs: EvalJobData[]): Promise<void>;
-    close(): Promise<void>;
-}
 /**
  * 用例的原版本与定义：快照里的；快照缺（较早的快照）时查 `agent_versions`。The definition is the
  * one the run used: with the person's model / effort switch in effect at its `run_started`
  * applied (UI refresh B, `selectionAt`), which is also returned as `selection`.
  */
-export declare function caseBase(db: KernelDb, s: CaseSnapshot): Promise<{
+export declare function caseBase(db: KernelSchemaDb, s: CaseSnapshot): Promise<{
     definition: AgentDefinition;
     agentVersion: number;
     selection: Selection;
 } | null>;
 /** 候选 agent 版本的定义（没给版本 → undefined）。 */
-export declare function versionDefinition(db: KernelDb, agentId: string, version: number | undefined): Promise<AgentDefinition | undefined>;
+export declare function versionDefinition(db: KernelSchemaDb, agentId: string, version: number | undefined): Promise<AgentDefinition | undefined>;
 /**
  * 轻量列表的 `asOf`：本次读取时数据库的当前时间往前留的余量（毫秒）。下一次轮询以它为 `updatedSince`：
  * 写结果的事务在读取之前开始、之后才提交时，`updated_at` 早于读取时间，留出余量才不会漏掉；重复的行由调用方按 id 合并。
  */
 export declare const RESULTS_ASOF_OVERLAP_MS = 15000;
-export interface EvalRunsDeps {
-    db: KernelDb;
-    /** 查看结果审计的去重（`SET NX EX`）；不给时每次查看都写审计。 */
-    redis?: Pick<Redis, "set">;
-    config: () => KernelConfig;
-    registry: Pick<ProviderRegistry, "resolve">;
-    prices: Pick<PricesService, "table">;
-    settings: Pick<SettingsService, "get">;
-    queue: Pick<EvalQueue, "enqueue">;
-    /** 模型用途映射：开评委时 `eval` 用途必须已映射（否则 `model.unconfigured`）；估算按它给评委定价。 */
-    purposes: Pick<ModelPurposesService, "resolve">;
-}
 /**
  * 评测运行（D5、C7）：估算、启动（校验候选、预建结果、每个用例入队一个任务）、查看、结果分页、取消。
  * 执行在 `evals/worker.ts`。写操作在事务里锁组织行并复核角色（`evals.manage`）。
  */
 export declare class EvalRunsService {
+    readonly txHost: TransactionHost;
     private readonly d;
-    constructor(d: EvalRunsDeps);
+    constructor(kdb: KernelDb, orgLock: OrgLock, locks: LockService, config: KernelConfigService, registry: ProviderRegistry, prices: PricesService, settings: SettingsService, queue: EvalJobs, budget: EvalBudget, purposes: ModelPurposesService, txHost: TransactionHost);
     private liveSet;
     /**
      * 解析模型；不存在 / 不可用 → `eval.candidate_invalid`（供应商列表暂时失败照常抛出）。
@@ -223,6 +195,10 @@ export declare class EvalRunsService {
         judge: boolean;
         tokenCap?: number;
     }, actorTokenId?: string): Promise<EvalRunView>;
+    /** The run row and its pending results, in a transaction of their own (enqueued after the commit). */
+    private startIn;
+    /** The enqueue failed: the run is `failed`, its pending results `skipped`. */
+    private failStartIn;
     /** 各运行的汇总（只算已结束的）。 */
     private summaries;
     private static toView;
@@ -272,4 +248,6 @@ export declare class EvalRunsService {
         label: "pass" | "fail" | null;
         note?: string;
     }, actorTokenId?: string): Promise<EvalResultView>;
+    private cancelIn;
+    private labelIn;
 }