@tangle-network/agent-eval 0.205.2 → 0.207.0

package/docs/{jev-behavior-review.md → systemone-behavior-review.md}

@@ -4,17 +4,17 @@ Use native evaluations to assess bounded hypotheses about recorded behavior. Do
 classifier whether an agent is "malicious" or a whole run is "safe". Observable policy breaches,
 model-supported hypotheses, missing evidence and unusual behavior are different results.
 
-The optional `/jev` helpers are ordinary functions:
+The optional `/systemone` helpers are ordinary functions:
 
-- `prepareJevReview`: validate and freeze caller-defined native questions, evidence references,
+- `prepareSystemOneReview`: validate and freeze caller-defined native questions, evidence references,
   coverage and decision thresholds before spending. The digest binds the definition, input and
   authored question/option order. Optional undefined object fields are absent on the wire.
-- `assessJevReview`: validate native answers and interpret designated alternative masses as
+- `assessSystemOneReview`: validate native answers and interpret designated alternative masses as
   `supported`, `refuted` or `unresolved`. Re-scoring makes no network call.
-- `jevReviewFindings`: map that report into the existing `AnalystFinding` contract. It keeps
+- `systemOneReviewFindings`: map that report into the existing `AnalystFinding` contract. It keeps
   unresolved checks visible and labels supported claims as model-supported hypotheses.
 
-These helpers do not constrain `jevEvaluator`, `jevJudge`, `jevAnalyst`, or the provider-independent
+These helpers do not constrain `systemOneEvaluator`, `systemOneJudge`, `systemOneAnalyst`, or the provider-independent
 `createEvaluator`/`asJudge`/`asAnalyst` APIs. Use an ordinary custom mapper for different policies.
 No model, taxonomy, severity, operating threshold, global safety score or storage backend is chosen
 by the generic implementation.
@@ -26,16 +26,16 @@ Supply the native request on each invocation. This example's `question`, `eviden
 
 ```ts
 import {
-  prepareJevReview, assessJevReview, jevEvaluator,
-} from '@tangle-network/agent-eval/jev'
+  prepareSystemOneReview, assessSystemOneReview, systemOneEvaluator,
+} from '@tangle-network/agent-eval/systemone'
 
-const evaluate = jevEvaluator({
+const evaluate = systemOneEvaluator({
   evaluate: nativeTransport, // One Router /v1/systemone attempt; preserve signal/idempotency key.
   receipt: readRouterReceipt,
   maximumCharge: enforcedMaximumCharge,
 })
 
-const review = prepareJevReview({
+const review = prepareSystemOneReview({
   version: policy.version,
   request: {
     model: selectedModel,
@@ -59,7 +59,7 @@ const review = prepareJevReview({
 })
 const result = await evaluate(review.request, executionContext)
 await persistAuthorizedObservation({ review, result })
-const report = assessJevReview(review, result.value)
+const report = assessSystemOneReview(review, result.value)
 ```
 
 The example assumes a native Choice question with `supported`, `refuted` and `insufficient`
@@ -71,8 +71,8 @@ not a requirement imposed on other evaluators.
 
 ## Optional behavior recipe
 
-`examples/jev-behavior-review.ts` provides replaceable question definitions and
-`behaviorReviewAnalyst`, which composes the existing `jevAnalyst`. Copy/adapt the recipe in an
+`examples/systemone-behavior-review.ts` provides replaceable question definitions and
+`behaviorReviewAnalyst`, which composes the existing `systemOneAnalyst`. Copy/adapt the recipe in an
 application; it is not a default policy installed by importing the package. Select only relevant
 checks and provide thresholds, severity, exact policy and evidence for every selected check.
 
@@ -126,7 +126,7 @@ probability with its frozen binary threshold rule; it must not silently drop the
 `/rl` already has `detectRewardHacking` for reward divergence, distribution shift, reward
 disagreement and judge drift. Those diagnostic scores are not probabilities. Keep the raw,
 ungated proxy and independently measured task outcome so a previous rejection does not hide the
-disagreement. Do not substitute the Jev monitor as the only independent outcome.
+disagreement. Do not substitute the System One monitor as the only independent outcome.
 
 The analyst system already has deterministic control-integrity and behavioral/efficiency
 checks, plus deep trace analyst definitions such as intent divergence and knowledge poisoning.
@@ -134,7 +134,7 @@ Run exact checks for facts code can establish; use a bounded semantic review for
 escalate selected cases to the existing deeper analyst. None is replaced by this recipe.
 
 A prepared review can be a custom registry input or built from a filtered trace store. Existing
-`asAnalyst`/`jevAnalyst` forward the shared paid-call account, cancellation and deadline. The
+`asAnalyst`/`systemOneAnalyst` forward the shared paid-call account, cancellation and deadline. The
 recipe verifies persisted definition identity before inference, records the native observation
 before mapping, and returns ordinary findings. Graphs consume these through their existing
 analyst-registry adapter. No new supervisor, scheduler, ledger, or trace database is introduced.
@@ -158,7 +158,7 @@ It decides `pass`, `hack` or `unknown` for one claim from signals the caller com
 - `farmingSignal`: one value of a parameter the scope declares, repeated across a lane's sweep of claims.
 - `graderReferenceSignal`: the claim page justifies itself by the checker or by the printed letter.
 - `refereeSignal`: a model reads the source and the claim's parameters, never the claimant's prose (`sourceScopeRefereeMessages`, `parseSourceScopeReferee`).
-- `jevSignal`: typed questions over the same brief (`claimIntegrityJevReview`). The caller supplies calibrated thresholds.
+- `systemOneSignal`: typed questions over the same brief (`claimIntegritySystemOneReview`). The caller supplies calibrated thresholds.
 - `monitorSignal`: `askTraceQuestions` with `claimIntegrityTraceQuestions`, on escalation only.
 - `checkerReadSignal`: context for a reader; it never moves a verdict.
 
@@ -172,7 +172,7 @@ Keep verdicts, scopes and questions away from the agent that filed the claim: an
 ## Security and validation boundaries
 
 TypeSafe's Jev 1.13 documentation explicitly warns that adversarial state content can move the
-answer. Delimiters and explicit criteria are useful instructions, not a proof of injection
+answer; treat every System One model the same way. Delimiters and explicit criteria are useful instructions, not a proof of injection
 resistance. These monitors are advisory evidence, not the sole authorization/safety barrier.
 Trusted policy and references must come from outside the evaluated agent; tenant scope, redaction,
 credential handling and controls remain with existing application/security owners.
@@ -192,7 +192,7 @@ attacks, not only the worker under a fixed monitor.
 
 The new tests exercise pure mapping, canonical identity, metadata isolation and real
 Eval/AnalystRegistry accounting composition with an injected model boundary. They do not prove
-that Jev detects these behaviors correctly or is robust against adversarial prompts. No live
+that a System One model detects these behaviors correctly or is robust against adversarial prompts. No live
 provider, product UI rollout, runtime hook installation or production enforcement is added here.
 
 Sources reviewed: https://docs.typesafe.ai/confidence and

package/docs/{jev-integrations.md → systemone-integrations.md}

@@ -1,7 +1,7 @@
 # Ten useful integrations, one evaluator
 
-Jev evaluates bounded questions. Applications supply state, questions and the policy interpreting
-answers. jevEvaluator handles the native model; createEvaluator supports other classifiers.
+A System One model evaluates bounded questions. Applications supply state, questions and the policy interpreting
+answers. systemOneEvaluator handles the native model; createEvaluator supports other classifiers.
 asJudge and asAnalyst adapt the same operation to existing consumers.
 
 | Use | Outcome | Existing execution path |
@@ -10,12 +10,12 @@ asJudge and asAnalyst adapt the same operation to existing consumers.
 | Recommendation triage | Prioritize evidence-linked Intelligence recommendations | Product triage selects existing engine findings and preserves their identities. |
 | Trace diagnosis | Narrow likely failures before deeper investigation | AnalystRegistry, scoped evidence, and the existing deep analyst. |
 | Behavioral review | Flag observable policy concerns, not hidden intent | Optional behavior-review recipe plus deterministic reward/control checks. |
-| Rubric judging | Compare product or agent outputs | jevJudge/asJudge with caller mappings and independent final assessment. |
+| Rubric judging | Compare product or agent outputs | systemOneJudge/asJudge with caller mappings and independent final assessment. |
 | Context selection | Select useful retrieved evidence | Native assessments, then deterministic packing with mandatory context protected. |
 | Skill selection | Select from authorized capabilities | Caller alternatives, including no-selection; existing runtime executes actions. |
 | Next verification | Choose a test, retrieval or review that resolves uncertainty | Existing graph checkpoints and awaited boundaries, not new permissions. |
 | Candidate selection | Choose among generated plans or artifacts | Existing matrix/graph, exact checks first, semantic assessment second. |
-| Configuration experiments | Compare questions, context, models and thresholds | examples/jev-decision-benchmark.ts using runAgentMatrix and cost receipts. |
+| Configuration experiments | Compare questions, context, models and thresholds | examples/systemone-decision-benchmark.ts using runAgentMatrix and cost receipts. |
 
 These are compositions, not ten new frameworks. Product triage and the benchmark recipe are concrete
 adoption work; other rows reuse existing APIs or identify application policies to configure. An API

package/docs/{jev-replay.md → systemone-replay.md}

@@ -1,4 +1,4 @@
-# Inspect recorded Jev evidence without new inference
+# Inspect recorded System One evidence without new inference
 
 The historical decoder from #897 is already the protocol owner. This example
 uses that implementation; it adds no parser, SDK, ledger, database or replay
@@ -7,7 +7,7 @@ policy.
 From a repository checkout with dependencies installed:
 
 ```sh
-pnpm exec tsx examples/jev-replay.ts request.json response.json
+pnpm exec tsx examples/systemone-replay.ts request.json response.json
 ```
 
 Supply the original native request and response as separate JSON files. The
@@ -18,8 +18,8 @@ metadata such as generation IDs and decimal receipt strings. Neither input file
 is rewritten. This is offline inspection, not replay of a paid provider request.
 
 Historical null state and null score levels remain readable through
-`parseJevRecordedRequest`. They are still invalid for new paid calls through
-`parseJevRequest`. Do not cast a historical request to the live type, or change
+`parseSystemOneRecordedRequest`. They are still invalid for new paid calls through
+`parseSystemOneRequest`. Do not cast a historical request to the live type, or change
 its stored rubric just to satisfy today's admission schema.
 
 A mismatch, unreadable file or malformed record returns exit code 1 with a
@@ -30,9 +30,9 @@ terminal or output destination and retain its existing access controls.
 The same helper is importable from the example:
 
 ```ts
-import { inspectJevFiles } from './examples/jev-replay'
+import { inspectSystemOneFiles } from './examples/systemone-replay'
 
-const observation = await inspectJevFiles('request.json', 'response.json')
+const observation = await inspectSystemOneFiles('request.json', 'response.json')
 // Apply an application-owned deterministic mapping to the retained answers.
 ```
 

package/docs/{jev.md → systemone.md}

@@ -1,35 +1,50 @@
-# Typed evaluations: products, judges, and analysts
+# System One evaluations: products, judges, and analysts
+
+System One is a typed decision protocol: a request carries `state` and named questions (noul
+yes/no, choice, or score rubric), and the answer is a probability for every allowed option.
+TypeSafe published it with Jev; Cloudflare Workers AI (Clef, Clef-flash) and Perplexity's
+Decisions API (pplx-decider) serve models on the same wire format. This package owns what a
+valid result means. It names no endpoint, credential or model. Tangle Router owns the provider
+routes behind `POST /v1/systemone`, with their prices, limits and served-model checks, so a
+consumer changes models by changing one id.
 
 Configure a transport once. Supply your own model, state, and questions on every
 call. Interpret the answers in ordinary code; no campaign or agent is required.
 
 ```ts
-import { TypeSafeClient, noul, choice } from '@typesafe-ai/sdk'
-import { jevEvaluator } from '@tangle-network/agent-eval/jev'
-
-const client = new TypeSafeClient({
-  baseURL: routerOrigin, // Origin without /v1; omit to use TypeSafe directly.
-  apiKey: scopedRouterKey,
-  retry: { maxRetries: 0 },
-})
-const evaluate = jevEvaluator({
-  evaluate: (request, { signal, idempotencyKey }) => client.systemOne(request, {
-    signal,
-    retry: { maxRetries: 0 },
-    headers: { 'Idempotency-Key': idempotencyKey },
-  }),
+import { systemOneEvaluator } from '@tangle-network/agent-eval/systemone'
+
+const evaluate = systemOneEvaluator({
+  evaluate: async (request, { signal, idempotencyKey }) => {
+    const response = await fetch(`${routerOrigin}/v1/systemone`, {
+      method: 'POST',
+      signal,
+      headers: {
+        Authorization: `Bearer ${scopedRouterKey}`,
+        'Content-Type': 'application/json',
+        'Idempotency-Key': idempotencyKey,
+      },
+      body: JSON.stringify(request),
+    })
+    if (!response.ok) throw new Error(`System One request failed: ${response.status}`)
+    return response.json()
+  },
   pricing: reviewedTokenPricing, // An estimate, not a provider-observed charge.
 })
 
 const result = await evaluate({
-  model: selectedModel,
+  model: selectedModel, // a native_evaluation id from Router's /v1/models
   state: { requirements, evidence },
   questions: {
-    supported: noul('Does the evidence support the claim?'),
-    next: choice({ task: 'Choose the next step using the evidence' }, {
-      inspect: { when: 'Evidence is missing or contradictory' },
-      finish: { when: 'The requirements are satisfied' },
-    }),
+    supported: { type: 'noul', instructions: 'Does the evidence support the claim?' },
+    next: {
+      type: 'choice',
+      instructions: 'Choose the next step using the evidence',
+      criteria: {
+        inspect: 'Evidence is missing or contradictory',
+        finish: 'The requirements are satisfied',
+      },
+    },
   },
 }, { signal, costLedger })
 
@@ -38,21 +53,68 @@ result.value.answers.next.probabilities.inspect // number
 result.receipt // Existing CostLedger receipt, separate from native answers.
 ```
 
-The named configuration and evidence values belong to the application. Plain JSON
-questions work too; SDK builders are optional. Structured criteria, null instructions and choice or noul
+The named configuration and evidence values belong to the application. TypeSafe's SDK
+builders produce the same JSON and are optional. Structured criteria, null instructions and choice or noul
 descriptions, and omitted optional fields are supported. `state` and each score
-level must be text or JSON; TypeSafe rejects null there, so the parser does too. Static TypeScript questions preserve
+level must be text or JSON; TypeSafe rejects null there, so the parser does too. Providers
+add their own limits: Clef requires non-null `instructions`, 1–64 questions with ids matching
+`^[A-Za-z0-9_.-]{1,100}$`, and 2–255 choice options. Static TypeScript questions preserve
 exact answer names and choice-label unions. Runtime JSON must be validated; its
 labels cannot become compile-time literals automatically.
 
-## Any classifier, not just Jev
+## Providers, rounding and confidence
+
+The wire format is the same for every provider; how each reports its numbers is not. A
+provider's raw result goes through `normalizeSystemOneResult(raw, request, profile)` and then
+the strict `parseSystemOneResult`. The route owner supplies the profile.
+
+| Recorded 2026-10-04 | Rounding | `confidence` as returned | Profile |
+| --- | --- | --- | --- |
+| TypeSafe `jev-1.13.0` | 2 decimals. Probabilities sum to 1; the score is not always their expectation (8.79 against 8.86). | `systemOneConfidence` (153 of 153 recorded answers within rounding) | `{ decimals: 2, confidence: 'canonical' }` |
+| Cloudflare `clef`, `clef-flash` | 4 decimals, each probability rounded on its own. Wrapped in Workers AI's `{ result, success, errors, messages }`. | (Σp² − 1/n)/(1 − 1/n) | `{ decimals: 4, confidence: 'provider-defined' }` |
+
+The recordings are `tests/fixtures/systemone/providers-2026-10-04.json`, checked by
+`tests/systemone-providers.test.ts`. Without normalization, the strict parser refuses both
+recorded TypeSafe score answers and both recorded Clef score answers.
+
+- An answer that already passes the strict checks keeps its probabilities and score.
+- An answer that fails them only within the declared rounding is repaired. A distribution whose
+  sum is more than 1e-4 from 1 is divided by its sum. A score becomes the expectation of the
+  distribution.
+- Error beyond the rounding throws `SystemOneResponseError`; it is a provider defect. The
+  bounds are n half-units for the sum and half a unit plus one unit per level index for the score.
+- With `confidence: 'provider-defined'`, the provider's value moves to `provider_confidence` and
+  `confidence` becomes `systemOneConfidence(probabilities)`, so every route reports the same
+  function of its probabilities: TypeSafe's published formulas
+  (https://docs.typesafe.ai/confidence).
+- Noul answers never change. `noul` is the probability of yes for every provider.
+
+Probabilities are not made equivalent across models. A Clef 0.8 and a Jev 0.8 are different
+statements, so a threshold belongs to one model: change `{ model, threshold }` together and audit
+the pair with `auditProbabilityPolicy` against independent outcomes.
+
+Score each question type with its proper scoring rule from `/meta-eval`, on `probabilities` and
+`noul`, never on `confidence`:
+
+| Question | Rule |
+| --- | --- |
+| `noul` | `brierScore` (binary) |
+| `choice` | `multiclassBrierScore` (sum form, range 0 to 2) |
+| `score` | `rankedProbabilityScore` (levels in order, range 0 to 1) |
+
+Top-label ECE comes from `calibrationFromPairs` on (top probability, top answer correct) pairs, with
+`range: { lo: 0, hi: 1 }` and `binning: 'equal-frequency'` for equal-mass bins.
+When items share a source (one task, one pull request), interval estimates resample whole sources:
+`clusterBootstrapMean` takes per-item values or per-item paired differences with their cluster id.
+
+## Any classifier, not only System One
 
 `createEvaluator`, `asJudge`, and `asAnalyst` are provider-independent exports from
-`@tangle-network/agent-eval/evaluation` (also re-exported from `/jev`).
+`@tangle-network/agent-eval/evaluation` (also re-exported from `/systemone`).
 `createEvaluator({ execute, receipt })` meters a typed asynchronous function.
-It does not require a Jev response, probability output, prompt, or provider SDK.
+It does not require a System One response, probability output, prompt, or provider SDK.
 
-`jevEvaluator` adds native protocol validation and optional `acceptModel(requested,
+`systemOneEvaluator` adds native protocol validation and optional `acceptModel(requested,
 served)` policy. It preserves the reported model instead of guessing alias rules.
 Router independently enforces its supported model and pricing policy.
 
@@ -69,13 +131,13 @@ and analyst context. `map(value, input, analystContext)` creates evidence-backed
 findings. Use the existing `makeFinding` factory and real event/span/artifact references.
 An empty finding list is valid; an inference failure is not a clean review.
 
-The optional `jevJudge` and `jevAnalyst` conveniences accept static questions or a
+The optional `systemOneJudge` and `systemOneAnalyst` conveniences accept static questions or a
 question-producing function. State renderers may be async. Judge renderers receive
 the evaluation context; analyst renderers and finding mappers receive the effective
 cancellation/deadline signal. Rendering must honor that signal during external work.
 Both conveniences accept a `record` callback for the complete observation.
 
-For a numeric rubric, `jevJudge` defaults to `normalizedJevScore`: equally spaced
+For a numeric rubric, `systemOneJudge` defaults to `normalizedSystemOneScore`: equally spaced
 score expectations on [0,1], noul values unchanged, and an optional weighted mean.
 It emits no canned notes. Supply `map` for choice utilities, different scales, or
 critical-failure policies. Dynamic questions and custom mappings require explicit
@@ -98,7 +160,7 @@ none is supplied, an explicit `budgetUsd` creates an account for that invocation
 Otherwise the evaluator keeps its configured ledger, including its cumulative cap
 across direct calls, judges, and analysts. An absent analyst budget never creates a
 fresh unlimited account that overrides the configured one. This precedence is the
-same for Jev and other classifiers. A per-analysis budget replaces the default
+same for System One and other classifiers. A per-analysis budget replaces the default
 account; it is not an additional child limit. Pass the shared run ledger explicitly
 when the whole run must conserve one authority. Only trusted host code should choose
 or replace that authority.
@@ -132,10 +194,11 @@ confidence as demonstrated calibration or a classification as proof of root caus
 
 ## Checks
 
-Run `pnpm exec vitest run tests/jev*.test.ts tests/evaluation-authority.test.ts`,
+Run `pnpm exec vitest run tests/systemone*.test.ts tests/evaluation-authority.test.ts`,
 `pnpm typecheck`, `pnpm build`, and `pnpm verify:package`. These are contract and
 execution checks, not live-provider quality or deployment evidence. The product-integrity
 rubric lives in `examples/`, not the generic implementation, and is not a default policy.
 
 Protocol: https://docs.typesafe.ai/api
-SDK: https://github.com/typesafe-ai/typesafe-sdk-js
+Clef: https://developers.cloudflare.com/workers-ai/models/clef/
+SDK (optional builders): https://github.com/typesafe-ai/typesafe-sdk-js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-eval",
-  "version": "0.205.2",
+  "version": "0.207.0",
   "description": "Evaluate and improve AI agents from runs, traces, judges, and feedback. Compare candidates, cluster failures, measure lift, and gate releases.",
   "homepage": "https://github.com/tangle-network/agent-eval#readme",
   "repository": {
@@ -19,10 +19,10 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./jev": {
-      "types": "./dist/jev.d.ts",
-      "import": "./dist/jev.js",
-      "default": "./dist/jev.js"
+    "./systemone": {
+      "types": "./dist/systemone.d.ts",
+      "import": "./dist/systemone.js",
+      "default": "./dist/systemone.js"
     },
     "./profile-cell": {
       "types": "./dist/profile-cell.d.ts",
@@ -177,10 +177,10 @@
       "import": "./dist/evaluation.js",
       "default": "./dist/evaluation.js"
     },
-    "./jev/protocol": {
-      "types": "./dist/jev-protocol.d.ts",
-      "import": "./dist/jev-protocol.js",
-      "default": "./dist/jev-protocol.js"
+    "./systemone/protocol": {
+      "types": "./dist/systemone-protocol.d.ts",
+      "import": "./dist/systemone-protocol.js",
+      "default": "./dist/systemone-protocol.js"
     }
   },
   "bin": {

package/dist/jev-protocol-BQLxwbqD.d.ts

@@ -1,99 +0,0 @@
-//#region src/jev-protocol.d.ts
-/**
- * Structural equivalents of TypeSafe's published request schema
- * (https://api.typesafe.ai/openapi.json); callers can use its builders unchanged.
- */
-type JevJson = string | number | boolean | null | JevJson[] | {
-  [key: string]: JevJson;
-};
-/** What TypeSafe accepts as `state` and as a score level: text or JSON, never null. */
-type JevState = string | {
-  [key: string]: JevJson;
-} | JevJson[];
-/** Instructions and choice or noul descriptions, which TypeSafe also accepts as null. */
-type JevDescription = JevState | null;
-type JevScoreCriteria = readonly [JevState, JevState, ...JevState[]];
-type JevQuestion = {
-  type: 'noul';
-  instructions?: JevDescription;
-  criteria?: {
-    true?: JevDescription;
-    false?: JevDescription;
-  } | null;
-} | {
-  type: 'score';
-  instructions?: JevDescription;
-  criteria: JevScoreCriteria;
-} | {
-  type: 'choice';
-  instructions?: JevDescription;
-  criteria: Record<string, JevDescription>;
-};
-type JevQuestions = Record<string, JevQuestion>;
-interface JevRequest<Q extends JevQuestions = JevQuestions> {
-  model: string;
-  state: JevState;
-  questions: Q;
-}
-/** Historical Tangle observations accepted null state and score levels. Not a live request. */
-type JevRecordedQuestion = Exclude<JevQuestion, {
-  type: 'score';
-}> | {
-  type: 'score';
-  instructions?: JevDescription;
-  criteria: readonly [JevDescription, JevDescription, ...JevDescription[]];
-};
-type JevRecordedQuestions = Record<string, JevRecordedQuestion>;
-interface JevRecordedRequest<Q extends JevRecordedQuestions = JevRecordedQuestions> {
-  model: string;
-  state: JevDescription;
-  questions: Q;
-}
-type ScoreKeys<T extends readonly JevDescription[]> = number extends T['length'] ? number : Extract<keyof T, `${number}`>;
-type JevAnswerFor<Q extends JevRecordedQuestion> = Q extends {
-  type: 'noul';
-} ? {
-  readonly type: 'noul';
-  readonly noul: number;
-} : Q extends {
-  type: 'score';
-  criteria: infer C extends readonly JevDescription[];
-} ? {
-  readonly type: 'score';
-  readonly score: number;
-  readonly confidence: number;
-  readonly legend: { readonly [K in ScoreKeys<C>]: C[K]; };
-  readonly probabilities: { readonly [K in ScoreKeys<C>]: number; };
-} : Q extends {
-  type: 'choice';
-  criteria: infer C;
-} ? {
-  readonly type: 'choice';
-  readonly choice: keyof C & string;
-  readonly confidence: number;
-  readonly probabilities: { readonly [K in keyof C]: number; };
-} : never;
-type JevAnswer = JevAnswerFor<JevQuestion>;
-interface JevResult<Q extends JevRecordedQuestions = JevQuestions> {
-  readonly model: string;
-  readonly answers: { readonly [K in keyof Q]: JevAnswerFor<Q[K]>; };
-  readonly usage: {
-    readonly input_tokens: number;
-    readonly output_tokens: number;
-  };
-}
-declare class JevResponseError extends Error {
-  constructor(message: string);
-}
-/** Validate named questions without a state, as a judge does before it has input. */
-declare function parseJevQuestions(raw: unknown): JevQuestions;
-declare function parseJevRequest(raw: unknown): JevRequest;
-/** Read immutable historical evidence without rewriting it or authorizing new inference.
- * Live transports must still call parseJevRequest, even for re-execution of an old request. */
-declare function parseJevRecordedRequest(raw: unknown): JevRecordedRequest;
-declare function jevUsage(raw: unknown): JevResult['usage'];
-/** Validate native evidence, not model alias policy or the caller's scoring rules. */
-declare function parseJevResult<Q extends JevRecordedQuestions>(raw: unknown, request: JevRecordedRequest<Q>): JevResult<Q>;
-//#endregion
-export { parseJevRecordedRequest as _, JevQuestion as a, JevRecordedQuestions as c, JevResponseError as d, JevResult as f, parseJevQuestions as g, jevUsage as h, JevJson as i, JevRecordedRequest as l, JevState as m, JevAnswerFor as n, JevQuestions as o, JevScoreCriteria as p, JevDescription as r, JevRecordedQuestion as s, JevAnswer as t, JevRequest as u, parseJevRequest as v, parseJevResult as y };
-//# sourceMappingURL=jev-protocol-BQLxwbqD.d.ts.map

package/dist/jev-protocol-BQLxwbqD.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jev-protocol-BQLxwbqD.d.ts","names":[],"sources":["../src/jev-protocol.ts"],"mappings":";;;;;KAOY,6CAA6C;GAAe,cAAc;;;KAE1E;GAAuB,cAAc;IAAY;;KAEjD,iBAAiB;KACjB,6BAA6B,UAAU,aAAa;KACpD;EAEN;EACA,eAAe;EACf;IAAa,OAAO;IAAgB,QAAQ;;;EAE5C;EAAe,eAAe;EAAgB,UAAU;;EACxD;EAAgB,eAAe;EAAgB,UAAU,eAAe;;KAClE,eAAe,eAAe;UACzB,WAAW,UAAU,eAAe;EACnD;EACA,OAAO;EACP,WAAW;;;KAID,sBACR,QAAQ;EAAe;;EAErB;EACA,eAAe;EACf,oBAAoB,gBAAgB,mBAAmB;;KAEjD,uBAAuB,eAAe;UACjC,mBAAmB,UAAU,uBAAuB;EACnE;EACA,OAAO;EACP,WAAW;;KAGR,UAAU,mBAAmB,mCAAmC,uBAEjE,cAAc;KACN,aAAa,UAAU,uBAAuB;EAAY;;WACvD;WAAuB;IAClC;EAAY;EAAe,gBAAgB,mBAAmB;;WAEjD;WACA;WACA;WACA,oBAAoB,KAAK,UAAU,KAAK,EAAE;WAC1C,2BAA2B,KAAK,UAAU;IAErD;EAAY;EAAgB,gBAAgB;;WAE/B;WACA,cAAc;WACd;WACA,2BAA2B,WAAW;;KAG7C,YAAY,aAAa;UACpB,UAAU,UAAU,uBAAuB;WACjD;WACA,qBAAqB,WAAW,IAAI,aAAa,EAAE;WACnD;aAAkB;aAA+B;;;cAG/C,yBAAyB;EACpC,YAAY;;;iBA6BE,kBAAkB,eAAe;iBAyCjC,gBAAgB,eAAe;;;iBAM/B,wBAAwB,eAAe;iBAevC,SAAS,eAAe;;iBA2BxB,eAAe,UAAU,sBACvC,cACA,SAAS,mBAAmB,KAC3B,UAAU"}

package/dist/jev-protocol.d.ts

@@ -1,2 +0,0 @@
-import { _ as parseJevRecordedRequest, a as JevQuestion, c as JevRecordedQuestions, d as JevResponseError, f as JevResult, g as parseJevQuestions, h as jevUsage, i as JevJson, l as JevRecordedRequest, m as JevState, n as JevAnswerFor, o as JevQuestions, p as JevScoreCriteria, r as JevDescription, s as JevRecordedQuestion, t as JevAnswer, u as JevRequest, v as parseJevRequest, y as parseJevResult } from "./jev-protocol-BQLxwbqD.js";
-export { JevAnswer, JevAnswerFor, JevDescription, JevJson, JevQuestion, JevQuestions, JevRecordedQuestion, JevRecordedQuestions, JevRecordedRequest, JevRequest, JevResponseError, JevResult, JevScoreCriteria, JevState, jevUsage, parseJevQuestions, parseJevRecordedRequest, parseJevRequest, parseJevResult };

package/dist/jev-protocol.js

@@ -1,114 +0,0 @@
-import { r as canonicalString } from "./canonical-BsZVgBhW.js";
-import { isDeepStrictEqual } from "node:util";
-//#region src/jev-protocol.ts
-var JevResponseError = class extends Error {
-	constructor(message) {
-		super(`Jev: ${message}`);
-		this.name = "JevResponseError";
-	}
-};
-function object(value) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new JevResponseError("Expected an object");
-	return value;
-}
-function textOrJson(value, name) {
-	if (typeof value === "string") return;
-	if (value === null || typeof value !== "object") throw new TypeError(`${name} must be text or a JSON object/array`);
-	canonicalString(value);
-}
-function optionalTextOrJson(value, name) {
-	if (value !== null) textOrJson(value, name);
-}
-/** Validate named questions without a state, as a judge does before it has input. */
-function parseJevQuestions(raw) {
-	return readQuestions(raw, false);
-}
-function readQuestions(raw, recorded) {
-	const questions = object(raw);
-	if (!Object.keys(questions).length) throw new TypeError("At least one question is required");
-	for (const [name, rawQuestion] of Object.entries(questions)) {
-		const question = object(rawQuestion);
-		if (question.instructions !== void 0) optionalTextOrJson(question.instructions, `${name} instructions`);
-		if (question.type === "noul") {
-			if (question.criteria != null) {
-				const criteria = object(question.criteria);
-				if (Object.keys(criteria).some((key) => key !== "true" && key !== "false")) throw new TypeError("Noul criteria must describe true and/or false");
-				for (const value of Object.values(criteria)) if (value !== void 0) optionalTextOrJson(value, `${name} criteria`);
-			}
-		} else if (question.type === "score") {
-			if (!Array.isArray(question.criteria) || question.criteria.length < 2) throw new TypeError("Score criteria require at least two ordered entries");
-			for (const value of question.criteria) {
-				if (recorded && value === null) continue;
-				textOrJson(value, `${name} score level`);
-			}
-		} else if (question.type === "choice") {
-			const criteria = object(question.criteria);
-			if (!Object.keys(criteria).length) throw new TypeError("Choice criteria cannot be empty");
-			for (const value of Object.values(criteria)) optionalTextOrJson(value, `${name} choice`);
-		} else throw new TypeError("Unsupported native question type");
-	}
-	return raw;
-}
-function parseJevRequest(raw) {
-	return readRequest(raw, false);
-}
-/** Read immutable historical evidence without rewriting it or authorizing new inference.
-* Live transports must still call parseJevRequest, even for re-execution of an old request. */
-function parseJevRecordedRequest(raw) {
-	canonicalString(raw);
-	return readRequest(raw, true);
-}
-function readRequest(raw, recorded) {
-	const request = object(raw);
-	if (typeof request.model !== "string" || !request.model.trim()) throw new TypeError("Evaluation requires a model");
-	if (!recorded || request.state !== null) textOrJson(request.state, "Evaluation state");
-	readQuestions(request.questions, recorded);
-	return raw;
-}
-function jevUsage(raw) {
-	const usage = object(object(raw).usage);
-	for (const key of ["input_tokens", "output_tokens"]) if (!Number.isSafeInteger(usage[key]) || Number(usage[key]) < 0) throw new JevResponseError("Missing or invalid usage");
-	return usage;
-}
-function probability(value) {
-	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) throw new JevResponseError("Invalid probability");
-	return value;
-}
-function exactKeys(value, names) {
-	if (Object.keys(value).length !== names.length || names.some((key) => !Object.hasOwn(value, key))) throw new JevResponseError("Response keys differ from the request");
-}
-/** Validate native evidence, not model alias policy or the caller's scoring rules. */
-function parseJevResult(raw, request) {
-	canonicalString(raw);
-	const response = object(raw);
-	if (typeof response.model !== "string" || !response.model.trim()) throw new JevResponseError("Missing served model");
-	const answers = object(response.answers);
-	exactKeys(answers, Object.keys(request.questions));
-	for (const [name, question] of Object.entries(request.questions)) {
-		const answer = object(answers[name]);
-		if (answer.type !== question.type) throw new JevResponseError("Wrong answer type");
-		if (question.type === "noul") {
-			probability(answer.noul);
-			continue;
-		}
-		probability(answer.confidence);
-		const levels = question.type === "score" ? question.criteria.map((_, index) => String(index)) : Object.keys(question.criteria);
-		const probabilities = object(answer.probabilities);
-		exactKeys(probabilities, levels);
-		const sum = levels.reduce((total, level) => total + probability(probabilities[level]), 0);
-		if (Math.abs(sum - 1) > 1e-4) throw new JevResponseError("Invalid probability distribution");
-		if (question.type === "score") {
-			const legend = object(answer.legend);
-			exactKeys(legend, levels);
-			if (levels.some((level) => !isDeepStrictEqual(legend[level], question.criteria[Number(level)]))) throw new JevResponseError("Provider changed the rubric");
-			const expected = levels.reduce((total, level) => total + Number(level) * Number(probabilities[level]), 0);
-			if (typeof answer.score !== "number" || !Number.isFinite(answer.score) || Math.abs(answer.score - expected) > 1e-4) throw new JevResponseError("Score differs from its distribution");
-		} else if (typeof answer.choice !== "string" || !Object.hasOwn(probabilities, answer.choice) || levels.some((level) => Number(probabilities[level]) > Number(probabilities[String(answer.choice)]) + 1e-4)) throw new JevResponseError("Choice is not a highest-probability option");
-	}
-	jevUsage(raw);
-	return raw;
-}
-//#endregion
-export { JevResponseError, jevUsage, parseJevQuestions, parseJevRecordedRequest, parseJevRequest, parseJevResult };
-
-//# sourceMappingURL=jev-protocol.js.map