humanish 0.117.0 → 0.119.0

package/dist/analysis/evidence.js

@@ -8,15 +8,8 @@ import { ACTION_CAPTURE_VERSION, } from "./types.js";
 import { digestAnalysisInput, hashAnalysisValue, validateAnalysisInputMetadata, } from "./validation.js";
 import { boundedText, fairShares, hasUnmappedCaptures, participantAssignment, participantSource, sourceEntries, sourceOrder, impressionEventIds, } from "./evidence-sources.js";
 import { readBoundedFile, readBoundedFileResult } from "../run/evidence-files.js";
-export const EVIDENCE_LIMITS = Object.freeze({
-    participants: 16,
-    evidence: 800,
-    captures: 40,
-    textBytes: 160 * 1024,
-    imageBytes: 8 * 1024 * 1024,
-    totalImageBytes: 20 * 1024 * 1024,
-    sourceBytes: 16 * 1024 * 1024,
-});
+import { analysisCohortCount, analysisCohorts, EVIDENCE_LIMITS } from "./analysis-limits.js";
+export { EVIDENCE_LIMITS };
 // A second guard for direct callers. The analysis service already requires every stream to be in
 // TERMINAL_SIMULATION_STATUSES; this refuses only statuses that mean still running, so a dry-run
 // bundle's contract_proof_only streams stay capturable. The source is not shape-guarded here, so
@@ -39,7 +32,7 @@ function parseSource(prepared, bytes) {
         value.schema !== "humanish.run-bundle.v1" ||
         value.runId !== runIdOf(prepared) ||
         !Array.isArray(value.streams) ||
-        value.streams.length > 128 ||
+        value.streams.length > EVIDENCE_LIMITS.participants ||
         !Array.isArray(value.events) ||
         value.events.length > 100000 ||
         (value.commsReceiving !== undefined && !isCommsReceivingEvidence(value.commsReceiving)))
@@ -108,7 +101,7 @@ export async function captureEvidence(prepared, bundleBytes, requested = {}) {
     const evidence = [];
     const images = [];
     const omissions = new Set();
-    let textBytes = 0;
+    const contextBytes = new Map();
     const participants = selected.map((stream) => {
         const participant = participantSource(stream, captureVersion);
         const assignment = participantAssignment(stream, captureVersion);
@@ -118,30 +111,38 @@ export async function captureEvidence(prepared, bundleBytes, requested = {}) {
             participant.assignment !== assignment ||
             participant.recordedReason !== (stream.actor?.reason ?? null))
             omissions.add("Participant context exceeded the text limit.");
-        textBytes += Buffer.byteLength(JSON.stringify(participant));
+        contextBytes.set(stream, Buffer.byteLength(JSON.stringify(participant)));
         return participant;
     });
-    if (textBytes > limits.textBytes)
-        throw new Error("ANALYSIS_PARTICIPANT_CONTEXT_TOO_LARGE");
-    // Tie-breaking uses stable participant IDs, not the order of streams in a bundle.
-    // The emitted packet still preserves participant and source event order.
-    const packings = selected
-        .map((stream) => ({
-        stream,
-        entries: sourceEntries(bundle, stream, captureVersion),
-        captures: new Map(),
-        admitted: new Set(),
-        captureCursor: 0,
-        attempts: 0,
-        readBytes: 0,
-        imageBytes: 0,
-        reservationBlocked: false,
-    }))
-        .sort((a, b) => (a.stream.id < b.stream.id ? -1 : a.stream.id > b.stream.id ? 1 : 0));
-    const sel = planCaptureSelection(packings, limits);
-    await selectCaptures(prepared, packings, sel, omissions);
-    recordCaptureOmissions(packings, sel, omissions);
-    const textByEntry = boundEvidenceText(packings, limits.textBytes - textBytes, omissions);
+    // Each cohort is one request's packet, selected under the full limits on its own.
+    const packings = [];
+    const textByEntry = new Map();
+    for (const cohort of analysisCohorts(selected)) {
+        const textBytes = cohort.reduce((total, stream) => total + contextBytes.get(stream), 0);
+        if (textBytes > limits.textBytes)
+            throw new Error("ANALYSIS_PARTICIPANT_CONTEXT_TOO_LARGE");
+        // Tie-breaking uses stable participant IDs, not the order of streams in a bundle.
+        // The emitted packet still preserves participant and source event order.
+        const cohortPackings = cohort
+            .map((stream) => ({
+            stream,
+            entries: sourceEntries(bundle, stream, captureVersion),
+            captures: new Map(),
+            admitted: new Set(),
+            captureCursor: 0,
+            attempts: 0,
+            readBytes: 0,
+            imageBytes: 0,
+            reservationBlocked: false,
+        }))
+            .sort((a, b) => (a.stream.id < b.stream.id ? -1 : a.stream.id > b.stream.id ? 1 : 0));
+        const sel = planCaptureSelection(cohortPackings, limits);
+        await selectCaptures(prepared, cohortPackings, sel, omissions);
+        recordCaptureOmissions(cohortPackings, sel, omissions);
+        for (const [entry, text] of boundEvidenceText(cohortPackings, limits.textBytes - textBytes, omissions))
+            textByEntry.set(entry, text);
+        packings.push(...cohortPackings);
+    }
     packEvidence(selected, packings, textByEntry, evidence, images);
     const omittedStreamIds = bundle.streams.slice(limits.participants).map((stream) => stream.id);
     const coverage = {
@@ -425,6 +426,8 @@ export async function validateAnalysisEvidence(prepared, artifact, bundleBytes)
     }
     const sourceKeys = new Set();
     const checkedCaptures = new Map();
+    // Each cohort's packet holds at most totalImageBytes.
+    const imageByteLimit = analysisCohortCount(included.size) * EVIDENCE_LIMITS.totalImageBytes;
     let checkedImageBytes = 0;
     for (const entry of artifact.evidence) {
         const matches = sourceByStream
@@ -462,7 +465,7 @@ export async function validateAnalysisEvidence(prepared, artifact, bundleBytes)
                 if (!bytes || screenshotEvidenceError(source.capturePath, bytes) !== null)
                     throw new Error("ANALYSIS_CAPTURE_UNAVAILABLE");
                 checkedImageBytes += bytes.length;
-                if (checkedImageBytes > EVIDENCE_LIMITS.totalImageBytes)
+                if (checkedImageBytes > imageByteLimit)
                     throw new Error("ANALYSIS_IMAGE_LIMIT_EXCEEDED");
                 hash = sha256(bytes);
                 checkedCaptures.set(source.capturePath, hash);

package/dist/analysis/execute.d.ts

@@ -23,6 +23,9 @@ export interface AnalysisAdmission {
     admittedCostUsd: number | null;
     maxCostUsd: number | null;
     ratesAsOf: string | null;
+    /** The provider requests the costs cover: one per cohort, and the merge request for more than
+     *  one cohort. Null when the input or configuration was refused. */
+    requests: number | null;
 }
 export interface AnalysisProgress {
     phase: "admitted" | "requesting" | "validating" | "finished";
@@ -43,14 +46,28 @@ export interface AnalysisProgress {
  */
 export declare function estimateAnalysisAdmission(input: AnalysisInput, config: AnalysisConfig): AnalysisAdmission;
 /**
- * The expected cost of an analysis for this many participants before any evidence exists: from a
- * packet with no evidence to one at the evidence limits with every capture at the image-token
- * ceiling. Undefined for Codex and for a model without rates.
+ * The expected cost of the analysis admission would start, before any evidence exists: from a
+ * packet with no evidence to the largest packet admission admits. When admission refuses even a
+ * packet with no evidence, `refusedFromUsd` is that packet's expected cost.
  */
-export declare function analysisCostRange(config: AnalysisConfig, participants: number): {
-    low: number;
-    high: number;
-} | undefined;
+export type AnalysisCostRange = {
+    expectedCostUsd: {
+        low: number;
+        high: number;
+    };
+} | {
+    refusedFromUsd: number;
+};
+/**
+ * The expected cost of the analysis admission would start for this many participants, before any
+ * evidence exists. Packets grow from no evidence toward the evidence limits with every capture at
+ * the image-token ceiling, and the range ends at the largest one admission admits, so it never
+ * passes the cap. There is one packet per cohort, each a share of its own limits, and the merge
+ * request when there is more than one cohort. With `preferLargerOutput` each request gets the
+ * output allowance dispatch would give it (preferLargerAnalysisOutput). Undefined for Codex and
+ * for a model without rates.
+ */
+export declare function analysisCostRange(config: AnalysisConfig, participants: number, preferLargerOutput?: boolean): AnalysisCostRange | undefined;
 /** Only for an omitted output limit. Preserve the established allowance when
  * more reasoning/report space would refuse a study its declared budget admits.
  * This is one pre-dispatch choice, never a fallback request or a budget increase. */