niceeval 0.15.1-canary.76 → 0.16.1

package/dist/record/family/execution-traces/schema.d.ts

@@ -1,6 +1,33 @@
 import { Schema } from "effect";
 import type { TraceJson } from "../../../adapter-execution-trace.js";
 export declare const ExecutionTraceJsonSchema: Schema.Codec<TraceJson>;
+/** Persisted image blocks carry the descriptor fixed at acceptance. */
+export declare const ExecutionDisplayBlockRecordSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"text">;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"message">;
+    readonly role: Schema.Literals<readonly ["user", "assistant", "system", "other"]>;
+    readonly speaker: Schema.optional<Schema.String>;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"fields">;
+    readonly fields: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>;
+    }>>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"code">;
+    readonly language: Schema.optional<Schema.String>;
+    readonly text: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"image">;
+    readonly artifactId: Schema.String;
+    readonly alt: Schema.String;
+    readonly mediaType: Schema.Literals<readonly ["image/png", "image/jpeg", "image/webp", "image/gif"]>;
+    readonly byteLength: Schema.Number;
+    readonly sha256: Schema.String;
+}>]>;
 export declare const ExecutionTraceInputSchema: Schema.Struct<{
     readonly traceId: Schema.String;
     readonly schema: Schema.Struct<{
@@ -60,6 +87,29 @@ export declare const ExecutionTraceInputSchema: Schema.Struct<{
             readonly scopeId: Schema.String;
             readonly state: Schema.Literals<readonly ["included", "excluded", "unknown"]>;
         }>>>;
+        readonly display: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"message">;
+            readonly role: Schema.Literals<readonly ["user", "assistant", "system", "other"]>;
+            readonly speaker: Schema.optional<Schema.String>;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"fields">;
+            readonly fields: Schema.$Array<Schema.Struct<{
+                readonly label: Schema.String;
+                readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"code">;
+            readonly language: Schema.optional<Schema.String>;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"image">;
+            readonly artifactId: Schema.String;
+            readonly alt: Schema.String;
+        }>]>>>;
     }>>;
 }>;
 export declare const ExecutionTraceHeaderRecordSchema: Schema.Struct<{
@@ -133,6 +183,32 @@ export declare const ExecutionTraceEventRecordSchema: Schema.Struct<{
         readonly scopeId: Schema.String;
         readonly state: Schema.Literals<readonly ["included", "excluded", "unknown"]>;
     }>>;
+    readonly display: Schema.optional<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"message">;
+        readonly role: Schema.Literals<readonly ["user", "assistant", "system", "other"]>;
+        readonly speaker: Schema.optional<Schema.String>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"fields">;
+        readonly fields: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"code">;
+        readonly language: Schema.optional<Schema.String>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"image">;
+        readonly artifactId: Schema.String;
+        readonly alt: Schema.String;
+        readonly mediaType: Schema.Literals<readonly ["image/png", "image/jpeg", "image/webp", "image/gif"]>;
+        readonly byteLength: Schema.Number;
+        readonly sha256: Schema.String;
+    }>]>>>;
 }>;
 export declare const ExecutionTraceRecordSchema: Schema.Union<readonly [Schema.Struct<{
     readonly kind: Schema.Literal<"trace-header">;
@@ -204,10 +280,37 @@ export declare const ExecutionTraceRecordSchema: Schema.Union<readonly [Schema.S
         readonly scopeId: Schema.String;
         readonly state: Schema.Literals<readonly ["included", "excluded", "unknown"]>;
     }>>;
+    readonly display: Schema.optional<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"text">;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"message">;
+        readonly role: Schema.Literals<readonly ["user", "assistant", "system", "other"]>;
+        readonly speaker: Schema.optional<Schema.String>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"fields">;
+        readonly fields: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.Null]>;
+        }>>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"code">;
+        readonly language: Schema.optional<Schema.String>;
+        readonly text: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"image">;
+        readonly artifactId: Schema.String;
+        readonly alt: Schema.String;
+        readonly mediaType: Schema.Literals<readonly ["image/png", "image/jpeg", "image/webp", "image/gif"]>;
+        readonly byteLength: Schema.Number;
+        readonly sha256: Schema.String;
+    }>]>>>;
 }>]>;
 export type ExecutionTraceHeaderRecord = Schema.Schema.Type<typeof ExecutionTraceHeaderRecordSchema>;
 export type ExecutionTraceEventRecord = Schema.Schema.Type<typeof ExecutionTraceEventRecordSchema>;
 export type ExecutionTraceRecord = Schema.Schema.Type<typeof ExecutionTraceRecordSchema>;
+export type ExecutionDisplayBlockRecord = Schema.Schema.Type<typeof ExecutionDisplayBlockRecordSchema>;
 export declare const ExecutionTraceRecordLimits: Readonly<{
     maximumTraces: 32;
     maximumEvents: 100000;
@@ -225,4 +328,15 @@ export declare const ExecutionTraceRecordLimits: Readonly<{
     maximumDetailBytes: number;
     maximumOutlineEvents: 32;
     maximumOutlineBytes: number;
+    maximumDisplayBlocksPerEvent: 4;
+    maximumDisplayBytesPerEvent: number;
+    maximumDisplayFields: 16;
+    maximumDisplayLabelBytes: 128;
+    maximumDisplayAltBytes: 512;
+    maximumDisplayPreviewBytes: 1024;
+    maximumOutlineEventBytes: number;
+    maximumDisplayInlineImageBytes: number;
 }>;
+export declare const ExecutionDisplayImageMediaTypes: ReadonlySet<string>;
+/** True when a display string contains a control or bidirectional formatting character other than tab and newline. */
+export declare function displayTextHasForbiddenCharacter(value: string): boolean;

package/dist/record/family/execution-traces/schema.js

@@ -1,16 +1,22 @@
 import { createRequire as __niceevalCreateRequire } from "node:module";
 const __niceevalRequire = __niceevalCreateRequire(import.meta.url);
 const __niceevalCanonical = __niceevalRequire("./schema.cjs");
-const __niceevalExport0 = __niceevalCanonical["ExecutionTraceEventRecordSchema"];
-export { __niceevalExport0 as ExecutionTraceEventRecordSchema };
-const __niceevalExport1 = __niceevalCanonical["ExecutionTraceHeaderRecordSchema"];
-export { __niceevalExport1 as ExecutionTraceHeaderRecordSchema };
-const __niceevalExport2 = __niceevalCanonical["ExecutionTraceInputSchema"];
-export { __niceevalExport2 as ExecutionTraceInputSchema };
-const __niceevalExport3 = __niceevalCanonical["ExecutionTraceJsonSchema"];
-export { __niceevalExport3 as ExecutionTraceJsonSchema };
-const __niceevalExport4 = __niceevalCanonical["ExecutionTraceRecordLimits"];
-export { __niceevalExport4 as ExecutionTraceRecordLimits };
-const __niceevalExport5 = __niceevalCanonical["ExecutionTraceRecordSchema"];
-export { __niceevalExport5 as ExecutionTraceRecordSchema };
+const __niceevalExport0 = __niceevalCanonical["ExecutionDisplayBlockRecordSchema"];
+export { __niceevalExport0 as ExecutionDisplayBlockRecordSchema };
+const __niceevalExport1 = __niceevalCanonical["ExecutionDisplayImageMediaTypes"];
+export { __niceevalExport1 as ExecutionDisplayImageMediaTypes };
+const __niceevalExport2 = __niceevalCanonical["ExecutionTraceEventRecordSchema"];
+export { __niceevalExport2 as ExecutionTraceEventRecordSchema };
+const __niceevalExport3 = __niceevalCanonical["ExecutionTraceHeaderRecordSchema"];
+export { __niceevalExport3 as ExecutionTraceHeaderRecordSchema };
+const __niceevalExport4 = __niceevalCanonical["ExecutionTraceInputSchema"];
+export { __niceevalExport4 as ExecutionTraceInputSchema };
+const __niceevalExport5 = __niceevalCanonical["ExecutionTraceJsonSchema"];
+export { __niceevalExport5 as ExecutionTraceJsonSchema };
+const __niceevalExport6 = __niceevalCanonical["ExecutionTraceRecordLimits"];
+export { __niceevalExport6 as ExecutionTraceRecordLimits };
+const __niceevalExport7 = __niceevalCanonical["ExecutionTraceRecordSchema"];
+export { __niceevalExport7 as ExecutionTraceRecordSchema };
+const __niceevalExport8 = __niceevalCanonical["displayTextHasForbiddenCharacter"];
+export { __niceevalExport8 as displayTextHasForbiddenCharacter };
 //# sourceMappingURL=schema.js.map

package/dist/record/family/judge-usage/definition.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.judgeUsageRecordAttachment = void 0;
+const index_ts_1 = require("../../attachment/index.cjs");
+const schema_ts_1 = require("./schema.cjs");
+exports.judgeUsageRecordAttachment = (0, index_ts_1.defineRecordAttachment)({
+    owner: index_ts_1.RecordOwner.attempt,
+    family: "niceeval.judge-usage",
+    schema: schema_ts_1.JudgeUsageAttachmentSchema,
+    validate: schema_ts_1.validateJudgeUsageAttachment,
+});
+//# sourceMappingURL=definition.cjs.map

package/dist/record/family/judge-usage/definition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","sourceRoot":"","sources":["definition.ts"],"names":[],"mappings":";;;AAAA,wDAAgF;AAChF,2CAAuF;AAC1E,QAAA,0BAA0B,GAAG,IAAA,iCAAsB,EAAC;IAC7D,KAAK,EAAE,sBAAW,CAAC,OAAO;IAC1B,MAAM,EAAE,sBAAsB;IAC9B,MAAM,EAAE,sCAA0B;IAClC,QAAQ,EAAE,wCAA4B;CACzC,CAAC,CAAC","sourcesContent":["import { defineRecordAttachment, RecordOwner } from \"../../attachment/index.ts\";\nimport { JudgeUsageAttachmentSchema, validateJudgeUsageAttachment } from \"./schema.ts\";\nexport const judgeUsageRecordAttachment = defineRecordAttachment({\n    owner: RecordOwner.attempt,\n    family: \"niceeval.judge-usage\",\n    schema: JudgeUsageAttachmentSchema,\n    validate: validateJudgeUsageAttachment,\n});\n"]}

package/dist/record/family/judge-usage/definition.d.cts

@@ -0,0 +1,91 @@
+export declare const judgeUsageRecordAttachment: import("../../attachment/protocol.cjs").RecordAttachmentDefinition<"attempt", "niceeval.judge-usage", import("effect/Schema").Struct<{
+    readonly collection: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly state: import("effect/Schema").Literal<"complete">;
+        readonly limitations: import("effect/Schema").Tuple<readonly []>;
+    }>, import("effect/Schema").Struct<{
+        readonly state: import("effect/Schema").Literal<"partial">;
+        readonly limitations: import("effect/Schema").NonEmptyArray<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly code: import("effect/Schema").Literals<readonly ["capture-failed", "capture-interrupted"]>;
+            readonly stage: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly code: import("effect/Schema").Literals<readonly ["collection-cap-reached", "unsupported-input"]>;
+            readonly omittedAtLeast: import("effect/Schema").Number;
+        }>]>>;
+    }>]>;
+    readonly calls: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly callId: import("effect/Schema").String;
+        readonly entryIndex: import("effect/Schema").Number;
+        readonly entryId: import("effect/Schema").Codec<import("../../../index.cjs").AssertionEntryId, string, never, never>;
+        readonly logicalOrdinal: import("effect/Schema").Number;
+        readonly transmissionOrdinal: import("effect/Schema").Number;
+        readonly operation: import("effect/Schema").Literals<readonly ["score", "classify", "extract", "batchClassify"]>;
+        readonly requestModel: import("effect/Schema").String;
+        readonly transportProvider: import("effect/Schema").Literals<readonly ["openai", "vercel", "openrouter", "typesafe"]>;
+        readonly provider: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly model: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled", "unknown"]>;
+        readonly httpStatus: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly inputTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly inputTotalTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly outputTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cacheReadTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cacheWriteTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cost: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>;
+            readonly currency: import("effect/Schema").Codec<import("../source-receipt/model.cjs").CurrencyCode, string, never, never>;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"reported">;
+                readonly id: import("effect/Schema").String;
+            }>;
+        }>>;
+        readonly receipt: import("effect/Schema").Struct<{
+            readonly state: import("effect/Schema").Literals<readonly ["available", "unavailable"]>;
+            readonly reason: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["response-unavailable", "cancelled", "response-too-large", "invalid-json", "usage-not-reported", "invalid-usage", "response-model-too-large"]>>;
+            readonly responseDigest: import("effect/Schema").NullOr<import("effect/Schema").String>;
+            readonly fields: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly path: import("effect/Schema").Literals<readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"]>;
+                readonly value: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Number, import("effect/Schema").Null]>;
+            }>>;
+        }>;
+    }>>;
+    readonly priceReceipts: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"judge-call-price-estimate">;
+        readonly callId: import("effect/Schema").String;
+        readonly state: import("effect/Schema").Literals<readonly ["complete", "partial"]>;
+        readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>;
+        readonly currency: import("effect/Schema").Literal<"USD">;
+        readonly source: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"estimated">;
+            readonly id: import("effect/Schema").String;
+        }>;
+        readonly pricing: import("effect/Schema").Struct<{
+            readonly basis: import("effect/Schema").Literal<"catalog-reference">;
+            readonly currency: import("effect/Schema").Literal<"USD">;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"configured-profile">;
+                readonly id: import("effect/Schema").String;
+                readonly asOf: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+                readonly profileDigest: import("effect/Schema").String;
+            }>;
+            readonly requestModel: import("effect/Schema").String;
+            readonly selector: import("effect/Schema").String;
+            readonly match: import("effect/Schema").Literals<readonly ["exact", "provider-wildcard"]>;
+            readonly ratesPerMTok: import("effect/Schema").Struct<{
+                readonly input: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+                readonly output: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+                readonly cacheRead: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+                readonly cacheWrite: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+            }>;
+        }>;
+        readonly charges: import("effect/Schema").NonEmptyArray<import("effect/Schema").Struct<{
+            readonly bucket: import("effect/Schema").Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly tokens: import("effect/Schema").Number;
+            readonly ratePerMTok: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+            readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>;
+        }>>;
+        readonly missing: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly bucket: import("effect/Schema").Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly reason: import("effect/Schema").Literals<readonly ["tokens-unknown", "rate-unknown"]>;
+        }>>;
+    }>>;
+}>>;

package/dist/record/family/judge-usage/definition.d.mts

@@ -0,0 +1,91 @@
+export declare const judgeUsageRecordAttachment: import("../../attachment/protocol.mjs").RecordAttachmentDefinition<"attempt", "niceeval.judge-usage", import("effect/Schema").Struct<{
+    readonly collection: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly state: import("effect/Schema").Literal<"complete">;
+        readonly limitations: import("effect/Schema").Tuple<readonly []>;
+    }>, import("effect/Schema").Struct<{
+        readonly state: import("effect/Schema").Literal<"partial">;
+        readonly limitations: import("effect/Schema").NonEmptyArray<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly code: import("effect/Schema").Literals<readonly ["capture-failed", "capture-interrupted"]>;
+            readonly stage: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly code: import("effect/Schema").Literals<readonly ["collection-cap-reached", "unsupported-input"]>;
+            readonly omittedAtLeast: import("effect/Schema").Number;
+        }>]>>;
+    }>]>;
+    readonly calls: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly callId: import("effect/Schema").String;
+        readonly entryIndex: import("effect/Schema").Number;
+        readonly entryId: import("effect/Schema").Codec<import("../../../index.mjs").AssertionEntryId, string, never, never>;
+        readonly logicalOrdinal: import("effect/Schema").Number;
+        readonly transmissionOrdinal: import("effect/Schema").Number;
+        readonly operation: import("effect/Schema").Literals<readonly ["score", "classify", "extract", "batchClassify"]>;
+        readonly requestModel: import("effect/Schema").String;
+        readonly transportProvider: import("effect/Schema").Literals<readonly ["openai", "vercel", "openrouter", "typesafe"]>;
+        readonly provider: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly model: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled", "unknown"]>;
+        readonly httpStatus: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly inputTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly inputTotalTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly outputTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cacheReadTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cacheWriteTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cost: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.mjs").CanonicalDecimal, string, never, never>;
+            readonly currency: import("effect/Schema").Codec<import("../source-receipt/model.mjs").CurrencyCode, string, never, never>;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"reported">;
+                readonly id: import("effect/Schema").String;
+            }>;
+        }>>;
+        readonly receipt: import("effect/Schema").Struct<{
+            readonly state: import("effect/Schema").Literals<readonly ["available", "unavailable"]>;
+            readonly reason: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["response-unavailable", "cancelled", "response-too-large", "invalid-json", "usage-not-reported", "invalid-usage", "response-model-too-large"]>>;
+            readonly responseDigest: import("effect/Schema").NullOr<import("effect/Schema").String>;
+            readonly fields: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly path: import("effect/Schema").Literals<readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"]>;
+                readonly value: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Number, import("effect/Schema").Null]>;
+            }>>;
+        }>;
+    }>>;
+    readonly priceReceipts: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"judge-call-price-estimate">;
+        readonly callId: import("effect/Schema").String;
+        readonly state: import("effect/Schema").Literals<readonly ["complete", "partial"]>;
+        readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.mjs").CanonicalDecimal, string, never, never>;
+        readonly currency: import("effect/Schema").Literal<"USD">;
+        readonly source: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"estimated">;
+            readonly id: import("effect/Schema").String;
+        }>;
+        readonly pricing: import("effect/Schema").Struct<{
+            readonly basis: import("effect/Schema").Literal<"catalog-reference">;
+            readonly currency: import("effect/Schema").Literal<"USD">;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"configured-profile">;
+                readonly id: import("effect/Schema").String;
+                readonly asOf: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+                readonly profileDigest: import("effect/Schema").String;
+            }>;
+            readonly requestModel: import("effect/Schema").String;
+            readonly selector: import("effect/Schema").String;
+            readonly match: import("effect/Schema").Literals<readonly ["exact", "provider-wildcard"]>;
+            readonly ratesPerMTok: import("effect/Schema").Struct<{
+                readonly input: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.mjs").CanonicalDecimal, string, never, never>>;
+                readonly output: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.mjs").CanonicalDecimal, string, never, never>>;
+                readonly cacheRead: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.mjs").CanonicalDecimal, string, never, never>>;
+                readonly cacheWrite: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.mjs").CanonicalDecimal, string, never, never>>;
+            }>;
+        }>;
+        readonly charges: import("effect/Schema").NonEmptyArray<import("effect/Schema").Struct<{
+            readonly bucket: import("effect/Schema").Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly tokens: import("effect/Schema").Number;
+            readonly ratePerMTok: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.mjs").CanonicalDecimal, string, never, never>>;
+            readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.mjs").CanonicalDecimal, string, never, never>;
+        }>>;
+        readonly missing: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly bucket: import("effect/Schema").Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly reason: import("effect/Schema").Literals<readonly ["tokens-unknown", "rate-unknown"]>;
+        }>>;
+    }>>;
+}>>;

package/dist/record/family/judge-usage/definition.d.ts

@@ -0,0 +1,91 @@
+export declare const judgeUsageRecordAttachment: import("../../attachment/protocol.js").RecordAttachmentDefinition<"attempt", "niceeval.judge-usage", import("effect/Schema").Struct<{
+    readonly collection: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly state: import("effect/Schema").Literal<"complete">;
+        readonly limitations: import("effect/Schema").Tuple<readonly []>;
+    }>, import("effect/Schema").Struct<{
+        readonly state: import("effect/Schema").Literal<"partial">;
+        readonly limitations: import("effect/Schema").NonEmptyArray<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly code: import("effect/Schema").Literals<readonly ["capture-failed", "capture-interrupted"]>;
+            readonly stage: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly code: import("effect/Schema").Literals<readonly ["collection-cap-reached", "unsupported-input"]>;
+            readonly omittedAtLeast: import("effect/Schema").Number;
+        }>]>>;
+    }>]>;
+    readonly calls: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly callId: import("effect/Schema").String;
+        readonly entryIndex: import("effect/Schema").Number;
+        readonly entryId: import("effect/Schema").Codec<import("../../../index.js").AssertionEntryId, string, never, never>;
+        readonly logicalOrdinal: import("effect/Schema").Number;
+        readonly transmissionOrdinal: import("effect/Schema").Number;
+        readonly operation: import("effect/Schema").Literals<readonly ["score", "classify", "extract", "batchClassify"]>;
+        readonly requestModel: import("effect/Schema").String;
+        readonly transportProvider: import("effect/Schema").Literals<readonly ["openai", "vercel", "openrouter", "typesafe"]>;
+        readonly provider: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly model: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled", "unknown"]>;
+        readonly httpStatus: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly inputTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly inputTotalTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly outputTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cacheReadTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cacheWriteTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cost: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+            readonly currency: import("effect/Schema").Codec<import("../source-receipt/model.js").CurrencyCode, string, never, never>;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"reported">;
+                readonly id: import("effect/Schema").String;
+            }>;
+        }>>;
+        readonly receipt: import("effect/Schema").Struct<{
+            readonly state: import("effect/Schema").Literals<readonly ["available", "unavailable"]>;
+            readonly reason: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["response-unavailable", "cancelled", "response-too-large", "invalid-json", "usage-not-reported", "invalid-usage", "response-model-too-large"]>>;
+            readonly responseDigest: import("effect/Schema").NullOr<import("effect/Schema").String>;
+            readonly fields: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly path: import("effect/Schema").Literals<readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"]>;
+                readonly value: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Number, import("effect/Schema").Null]>;
+            }>>;
+        }>;
+    }>>;
+    readonly priceReceipts: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"judge-call-price-estimate">;
+        readonly callId: import("effect/Schema").String;
+        readonly state: import("effect/Schema").Literals<readonly ["complete", "partial"]>;
+        readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+        readonly currency: import("effect/Schema").Literal<"USD">;
+        readonly source: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"estimated">;
+            readonly id: import("effect/Schema").String;
+        }>;
+        readonly pricing: import("effect/Schema").Struct<{
+            readonly basis: import("effect/Schema").Literal<"catalog-reference">;
+            readonly currency: import("effect/Schema").Literal<"USD">;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"configured-profile">;
+                readonly id: import("effect/Schema").String;
+                readonly asOf: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+                readonly profileDigest: import("effect/Schema").String;
+            }>;
+            readonly requestModel: import("effect/Schema").String;
+            readonly selector: import("effect/Schema").String;
+            readonly match: import("effect/Schema").Literals<readonly ["exact", "provider-wildcard"]>;
+            readonly ratesPerMTok: import("effect/Schema").Struct<{
+                readonly input: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly output: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly cacheRead: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+                readonly cacheWrite: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            }>;
+        }>;
+        readonly charges: import("effect/Schema").NonEmptyArray<import("effect/Schema").Struct<{
+            readonly bucket: import("effect/Schema").Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly tokens: import("effect/Schema").Number;
+            readonly ratePerMTok: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>>;
+            readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.js").CanonicalDecimal, string, never, never>;
+        }>>;
+        readonly missing: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly bucket: import("effect/Schema").Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly reason: import("effect/Schema").Literals<readonly ["tokens-unknown", "rate-unknown"]>;
+        }>>;
+    }>>;
+}>>;

package/dist/record/family/judge-usage/definition.js

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

package/dist/record/family/judge-usage/definition.js.map

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

package/dist/record/family/judge-usage/persistence.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.judgeUsageRecordAttachmentPersistence = void 0;
+const index_ts_1 = require("../../attachment/index.cjs");
+const definition_ts_1 = require("./definition.cjs");
+exports.judgeUsageRecordAttachmentPersistence = (0, index_ts_1.defineRecordAttachmentPersistence)({
+    attachment: definition_ts_1.judgeUsageRecordAttachment,
+    revision: 1,
+});
+//# sourceMappingURL=persistence.cjs.map

package/dist/record/family/judge-usage/persistence.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence.js","sourceRoot":"","sources":["persistence.ts"],"names":[],"mappings":";;;AAAA,wDAA8E;AAC9E,mDAA6D;AAChD,QAAA,qCAAqC,GAAG,IAAA,4CAAiC,EAAC;IACnF,UAAU,EAAE,0CAA0B;IACtC,QAAQ,EAAE,CAAC;CACd,CAAC,CAAC","sourcesContent":["import { defineRecordAttachmentPersistence } from \"../../attachment/index.ts\";\nimport { judgeUsageRecordAttachment } from \"./definition.ts\";\nexport const judgeUsageRecordAttachmentPersistence = defineRecordAttachmentPersistence({\n    attachment: judgeUsageRecordAttachment,\n    revision: 1,\n});\n"]}

package/dist/record/family/judge-usage/persistence.d.cts

@@ -0,0 +1,91 @@
+export declare const judgeUsageRecordAttachmentPersistence: import("../../attachment/protocol.cjs").RecordAttachmentPersistence<import("../../attachment/protocol.cjs").RecordAttachmentDefinition<"attempt", "niceeval.judge-usage", import("effect/Schema").Struct<{
+    readonly collection: import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+        readonly state: import("effect/Schema").Literal<"complete">;
+        readonly limitations: import("effect/Schema").Tuple<readonly []>;
+    }>, import("effect/Schema").Struct<{
+        readonly state: import("effect/Schema").Literal<"partial">;
+        readonly limitations: import("effect/Schema").NonEmptyArray<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+            readonly code: import("effect/Schema").Literals<readonly ["capture-failed", "capture-interrupted"]>;
+            readonly stage: import("effect/Schema").String;
+        }>, import("effect/Schema").Struct<{
+            readonly code: import("effect/Schema").Literals<readonly ["collection-cap-reached", "unsupported-input"]>;
+            readonly omittedAtLeast: import("effect/Schema").Number;
+        }>]>>;
+    }>]>;
+    readonly calls: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly callId: import("effect/Schema").String;
+        readonly entryIndex: import("effect/Schema").Number;
+        readonly entryId: import("effect/Schema").Codec<import("../../../index.cjs").AssertionEntryId, string, never, never>;
+        readonly logicalOrdinal: import("effect/Schema").Number;
+        readonly transmissionOrdinal: import("effect/Schema").Number;
+        readonly operation: import("effect/Schema").Literals<readonly ["score", "classify", "extract", "batchClassify"]>;
+        readonly requestModel: import("effect/Schema").String;
+        readonly transportProvider: import("effect/Schema").Literals<readonly ["openai", "vercel", "openrouter", "typesafe"]>;
+        readonly provider: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly model: import("effect/Schema").NullOr<import("effect/Schema").String>;
+        readonly status: import("effect/Schema").Literals<readonly ["succeeded", "failed", "cancelled", "unknown"]>;
+        readonly httpStatus: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly inputTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly inputTotalTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly outputTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cacheReadTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cacheWriteTokens: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+        readonly cost: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>;
+            readonly currency: import("effect/Schema").Codec<import("../source-receipt/model.cjs").CurrencyCode, string, never, never>;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"reported">;
+                readonly id: import("effect/Schema").String;
+            }>;
+        }>>;
+        readonly receipt: import("effect/Schema").Struct<{
+            readonly state: import("effect/Schema").Literals<readonly ["available", "unavailable"]>;
+            readonly reason: import("effect/Schema").NullOr<import("effect/Schema").Literals<readonly ["response-unavailable", "cancelled", "response-too-large", "invalid-json", "usage-not-reported", "invalid-usage", "response-model-too-large"]>>;
+            readonly responseDigest: import("effect/Schema").NullOr<import("effect/Schema").String>;
+            readonly fields: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+                readonly path: import("effect/Schema").Literals<readonly ["model", "provider", "usage.completion_tokens", "usage.cost", "usage.input_tokens", "usage.output_tokens", "usage.prompt_tokens", "usage.prompt_tokens_details.cache_write_tokens", "usage.prompt_tokens_details.cached_tokens", "usage.total_tokens"]>;
+                readonly value: import("effect/Schema").Union<readonly [import("effect/Schema").String, import("effect/Schema").Number, import("effect/Schema").Null]>;
+            }>>;
+        }>;
+    }>>;
+    readonly priceReceipts: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly kind: import("effect/Schema").Literal<"judge-call-price-estimate">;
+        readonly callId: import("effect/Schema").String;
+        readonly state: import("effect/Schema").Literals<readonly ["complete", "partial"]>;
+        readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>;
+        readonly currency: import("effect/Schema").Literal<"USD">;
+        readonly source: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"estimated">;
+            readonly id: import("effect/Schema").String;
+        }>;
+        readonly pricing: import("effect/Schema").Struct<{
+            readonly basis: import("effect/Schema").Literal<"catalog-reference">;
+            readonly currency: import("effect/Schema").Literal<"USD">;
+            readonly source: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").Literal<"configured-profile">;
+                readonly id: import("effect/Schema").String;
+                readonly asOf: import("effect/Schema").NullOr<import("effect/Schema").Number>;
+                readonly profileDigest: import("effect/Schema").String;
+            }>;
+            readonly requestModel: import("effect/Schema").String;
+            readonly selector: import("effect/Schema").String;
+            readonly match: import("effect/Schema").Literals<readonly ["exact", "provider-wildcard"]>;
+            readonly ratesPerMTok: import("effect/Schema").Struct<{
+                readonly input: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+                readonly output: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+                readonly cacheRead: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+                readonly cacheWrite: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+            }>;
+        }>;
+        readonly charges: import("effect/Schema").NonEmptyArray<import("effect/Schema").Struct<{
+            readonly bucket: import("effect/Schema").Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly tokens: import("effect/Schema").Number;
+            readonly ratePerMTok: import("effect/Schema").NullOr<import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>>;
+            readonly amount: import("effect/Schema").Codec<import("../source-receipt/model.cjs").CanonicalDecimal, string, never, never>;
+        }>>;
+        readonly missing: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly bucket: import("effect/Schema").Literals<readonly ["input", "output", "cache-read", "cache-write"]>;
+            readonly reason: import("effect/Schema").Literals<readonly ["tokens-unknown", "rate-unknown"]>;
+        }>>;
+    }>>;
+}>>, 1>;