niceeval 0.13.2 → 0.13.3-canary.37

package/dist/runner/attempt-resources.d.ts

@@ -0,0 +1,13 @@
+import type { AttemptResourceRegistry } from "../types.js";
+export declare class ManagedAttemptResources implements AttemptResourceRegistry {
+    private readonly entries;
+    private closing;
+    private releaseReceipt?;
+    acquire<T>(acquire: () => Promise<T>, lifecycle: {
+        shutdown: (resource: T, signal: AbortSignal) => Promise<void>;
+        release: (resource: T, signal: AbortSignal) => Promise<void>;
+    }): Promise<T>;
+    shutdownAll(signal: AbortSignal): Promise<void>;
+    releaseAll(signal: AbortSignal): Promise<void>;
+    private releaseEntries;
+}

package/dist/runner/attempt-resources.js

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

package/dist/runner/attempt-resources.js.map

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

package/dist/runner/attempt.cjs

@@ -15,6 +15,8 @@ const registry_ts_1 = require("../sandbox/registry.cjs");
 const paths_ts_1 = require("../sandbox/paths.cjs");
 const request_executor_ts_1 = require("../sandbox/request-executor.cjs");
 const cleanup_timeout_ts_1 = require("./cleanup-timeout.cjs");
+const attempt_resources_ts_1 = require("./attempt-resources.cjs");
+const attempt_resources_ts_2 = require("../context/attempt-resources.cjs");
 const timeout_ts_1 = require("./timeout.cjs");
 const deadline_ts_1 = require("../sandbox/deadline.cjs");
 const failure_class_ts_1 = require("../shared/failure-class.cjs");
@@ -83,6 +85,15 @@ function runAttemptEffect(a, opts, sandboxSem, { buildLocators, runTiming, paren
     // an internal capability until the Record producer seals its own Attachments.
     const sourceRegistry = (0, source_loc_ts_1.createSourceRegistry)(process.cwd());
     const sourceCapture = (0, source_producer_ts_1.createRunnerAttemptSourceCapture)(sourceRegistry);
+    const attemptResources = new attempt_resources_ts_1.ManagedAttemptResources();
+    let attemptResourceReleaseFailureReported = false;
+    const reportAttemptResourceReleaseFailure = (error) => {
+        if (attemptResourceReleaseFailureReported)
+            return;
+        attemptResourceReleaseFailureReported = true;
+        declareFailure("agent.teardown", error);
+        diagnostics.push(teardownDiagnostic("agent.teardown", error));
+    };
     const base = {
         id: evalDef.id,
         description: evalDef.description,
@@ -767,6 +778,13 @@ function runAttemptEffect(a, opts, sandboxSem, { buildLocators, runTiming, paren
                     .catch(() => { });
             }));
         }
+        // Cross-send adapter processes belong to the Attempt Scope, not to the
+        // Promise-shaped body. On timeout the bridge is intentionally sealed
+        // before that Promise's finally continuation can submit more work, so a
+        // scope finalizer must remain the unconditional release owner.
+        yield* effect_1.Effect.addFinalizer(() => (0, cleanup_timeout_ts_1.cleanupCallback)((cleanupSignal) => attemptResources.releaseAll(cleanupSignal)).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.sync(() => {
+            reportAttemptResourceReleaseFailure(error);
+        }))));
         // The legacy setup/diff body remains Promise-shaped, while OTLP waits,
         // author execution, and sealing run in this Attempt's Effect scope. No
         // nested runtime is introduced.
@@ -797,6 +815,8 @@ function runAttemptEffect(a, opts, sandboxSem, { buildLocators, runTiming, paren
             declareFailure,
             isDeadlineTimedOut: () => timedOut,
             layerCleanups,
+            attemptResources,
+            reportAttemptResourceReleaseFailure,
             registerEvidence: (getEvents, getUsage, getRetryAttempts) => {
                 liveEvents = getEvents;
                 liveUsage = getUsage;
@@ -1210,8 +1230,9 @@ async function runAttemptBody(a, config, t0, base, res, parentSignal) {
     const sandbox = usesSandbox
         ? withCommandTiming(rawSandbox, recorder, getPhase, commands, sensitiveValues, res.deadlineAt, observabilityRuntime, signal)
         : rawSandbox;
+    const { attemptResources, reportAttemptResourceReleaseFailure } = res;
     // Direct Agent 只拿基础 ctx；Sandbox Agent 才拿带真实 Sandbox 的扩展 ctx。
-    const attemptCtx = {
+    const attemptCtx = (0, attempt_resources_ts_2.bindAttemptResources)({
         signal,
         evalId: evalDef.id,
         attempt: { id: evalDef.id, index: attempt },
@@ -1229,8 +1250,8 @@ async function runAttemptBody(a, config, t0, base, res, parentSignal) {
         diagnostic: feedback.diagnostic,
         // log 是 progress({ message }) 的别名,不是第二条通道(见 AgentContext.log 注释)。
         log,
-    };
-    const sandboxAttemptCtx = { ...attemptCtx, sandbox };
+    }, attemptResources);
+    const sandboxAttemptCtx = (0, attempt_resources_ts_2.bindAttemptResources)({ ...attemptCtx, sandbox }, attemptResources);
     const commandTarget = (0, operations_ts_1.createSandboxCommandTarget)(sandbox);
     /** agent.setup 时点已走到(未声明 setup 也置位)——agent.teardown 的触发条件(成对触发规则)。 */
     let agentSetupReached = false;
@@ -1428,6 +1449,7 @@ async function runAttemptBody(a, config, t0, base, res, parentSignal) {
             // 走的生命周期链是同一个函数,两条链的决议序各自单源在 send-failures.ts / failure-class.ts。
             experimentClassifier: run.classifyFailure,
             sourceRegistry,
+            resources: attemptResources,
             nextSourceOrder: sourceCapture.nextSourceOrder,
             // Pass / Score share the same Assert-first entry runtime. Their
             // independent folds are both derived only after this Attempt seals.
@@ -1847,6 +1869,18 @@ async function runAttemptBody(a, config, t0, base, res, parentSignal) {
             })
                 .catch(() => { });
         }
+        try {
+            await assertFirst.requestEffect((0, cleanup_timeout_ts_1.cleanupCallback)((cleanupSignal) => attemptResources.releaseAll(cleanupSignal)));
+        }
+        catch (error) {
+            // An interrupted body can resume its Promise finally only after the
+            // Effect bridge has closed. The Scope finalizer above still performs the
+            // release; this named closure is therefore lifecycle control, not a
+            // second teardown failure.
+            if (!(error instanceof api_ts_1.AssertionAuthoringClosedError && error.reason === "attempt-interrupted")) {
+                reportAttemptResourceReleaseFailure(error);
+            }
+        }
         for (const lifecycle of evalPluginLifecycles.slice(0, activatedEvalPlugins).reverse()) {
             if (lifecycle.teardown === undefined)
                 continue;