@toloka-platform/sdk 0.1.0-preview.3

package/docs/nodes.md

@@ -0,0 +1,87 @@
+# Nodes
+
+Which node to reach for, what belongs inside a human-work node, and how to price one.
+
+## Choose a node
+
+| The task is | Use | Constructor |
+|---|---|---|
+| the pipeline's input and output contract | the root | `root` |
+| deterministic from its inputs | code | `code` |
+| work only a person can do | human work | `generation` |
+| the same item judged by several people independently | human work with overlap | `quorum` |
+| a decision about where an item goes next | routing | `match` |
+
+### root
+
+The root defines which dataset columns the pipeline reads and which it writes back. `started` lists the fields the pipeline consumes; `completed` lists the fields it produces. Every pipeline has exactly one root. The dataset name belongs in `definePipeline({ dataset: '...' })`, not in the root settings.
+
+### code
+
+Reach for `code` whenever the answer is computable: parsing, filtering, arithmetic, string work, reshaping a payload, calling an HTTP API, or calling an LLM programmatically. An LLM call is still `code` — the node runs a program, and what that program talks to is its business.
+
+The sandbox has no ambient environment. Credentials come from `envVars`, which name project secrets set with `toloka secret set`.
+
+### generation
+
+Reach for `generation` when the work needs a person: annotating images, video, or audio; writing or rewriting text; rating or comparing; validating a model's output; or collecting original content such as a recording or a photo the expert produces.
+
+One `generation` node is one task type, and it owns the entire expert journey for that task. See below.
+
+### quorum
+
+Reach for `quorum` when you want the same item labeled by N independent experts and the disagreement to remain visible — typically classification, rating, or short labels where consensus is the deliverable. `overlap` is how many experts see each item.
+
+### match
+
+Reach for `match` to branch. Conditions are predicates over input fields, evaluated in declaration order. Use it for conditional flow, not for fan-out.
+
+## What lives inside a human-work node
+
+This is the part that surprises people who have built DAGs elsewhere: **the review cycle is not a node.**
+
+A `generation` or `quorum` node owns, as settings on the node itself:
+
+| Concern | Setting |
+|---|---|
+| what the expert sees and submits | `entities`, `ui` |
+| what "good" means | `qualityCriteria` |
+| who judges quality, and how | `qualityAssurance` |
+| what the expert must learn first | `onboarding` (the Training course) |
+| an optional gate before real work | `exam` |
+| who may take the task, and for how much | `audienceAndPricing` |
+| written guidance | `instruction` |
+
+Redo, review, appeal, and payment retry are internal to the node. If you catch yourself drawing an edge backwards to model "send it back for another look", stop: the behavior you want is a setting on the node you are coming from. The graph stays acyclic by construction.
+
+Post-human work in the graph is either deterministic processing (`code`) or routing (`match`).
+
+Two defaults worth knowing before you author one:
+
+- **Quality assurance is on.** A human-work node has quality criteria judged automatically. It is not something you add later as a review step.
+- **Training is on.** A new human-work node expects a course, and the platform requires at least three steps with at least one quiz block. The constructor drops a one-step placeholder, which will not deploy. Build a real course.
+
+## Pricing and time
+
+`audienceAndPricing` carries `pricePerTask` (USD) and `timeForTask` (seconds). `timeForTask` is a real duration, not a display hint. The shipped example uses `pricePerTask: 0.2` with `timeForTask: 60`.
+
+## Quorum data shape
+
+Every output field on a `quorum` node is a **top-level array**, with one element per labeler — nominally `overlap` of them, one submitted by each expert.
+
+This propagates. A downstream `code` node reading a quorum output receives the array, not a scalar, and its Python must aggregate: take a majority, a mean, or the disagreement itself. Writing that node as though it reads one label is the most common mistake with quorum, and the symptom is a type error deep in the run rather than at author time.
+
+## Match routing
+
+A `match` node declares conditions; the graph connects their outcomes:
+
+| Port | Routes |
+|---|---|
+| `matched(0)`, `matched(1)`, ... | items satisfying the i-th condition, in declaration order |
+| `default` | everything that matched nothing |
+
+Wire `default` to wherever unmatched items should go. An item that matches no condition has no other path through the graph.
+
+## See also
+
+[Authoring](./authoring.md) · [CLI reference](./cli.md) · [Limitations](./limitations.md)

package/docs/troubleshooting.md

@@ -0,0 +1,110 @@
+# Troubleshooting
+
+The failures you will actually hit, what causes each, and the next step that works.
+
+Every entry here has been reproduced against a live platform. Where the right fix is on the platform side rather than yours, this page says so instead of suggesting a workaround that does not exist.
+
+## plan reports a change immediately after apply
+
+Run `plan` once more. If it still reports the same change, the source and the platform genuinely disagree and the diff names the node and setting.
+
+`plan` compares only the settings your source declares. A setting the platform materialized but your source never wrote is owned by the platform and is not drift. The consequence worth knowing: deleting a setting from source does not report the live value as a difference. To change a materialized setting, declare it explicitly with the value you want.
+
+## Dataset field schema conflict
+
+```
+Dataset field schemas conflict with source: cat-images.annotations
+```
+
+Dataset columns are immutable. The column exists with a different JSON Schema than your source declares, and neither `plan` nor `apply` will rewrite it. There is no operation on the platform that alters or removes a dataset field.
+
+Two ways forward:
+
+- Declare a new column name with the schema you want, and migrate readers to it.
+- Bind the pipeline to a new dataset.
+
+Neither is a workaround; they are the only two shapes the platform supports. See [datasets](./datasets.md).
+
+## Missing project secrets
+
+```
+Required secrets are missing: OPENAI_API_KEY
+```
+
+`apply` refuses before writing anything. Set every name it lists, then plan again:
+
+```sh
+toloka secret set OPENAI_API_KEY --from-env OPENAI_API_KEY
+```
+
+Values are read from stdin or a named environment variable so they do not reach shell history or process listings. Node settings reference secret names; they never carry values.
+
+## Refusing to delete pipelines or datasets
+
+```
+Refusing to delete pipelines absent from source: pipelines/cat-labeling
+```
+
+A resource exists on the platform but not in your source tree. `apply` reports it and stops rather than deleting live work — deleting a pipeline is not a side effect of an edit. Either restore the source, or remove the resource deliberately through the platform UI.
+
+## 409 stale version
+
+Another writer changed the graph after your source was read. Do not retry blindly: `plan` again to re-read live state, review the new diff, carry any intentional remote change into source, then `apply`.
+
+## Second upload of the same filename fails
+
+Uploading a file whose basename already exists in that dataset fails with a bodyless `500`. `toloka dataset upload` sends the file's basename, so running the same documented command twice reproduces it:
+
+```sh
+toloka dataset upload cat-images ./data/rows.jsonl   # first time: fine
+toloka dataset upload cat-images ./data/rows.jsonl   # second time: 500
+```
+
+Until the platform returns a proper conflict, use a distinct filename per upload — for example `rows-2026-08-13.jsonl`. This is a platform defect, tracked; the SDK cannot detect it in advance.
+
+## Another upload is already in progress
+
+```
+409 Another upload is already in progress
+```
+
+A previous upload to that dataset failed after the upload row was created, and a pending upload counts as in progress. There is no public operation to cancel it, so the dataset's upload path stays blocked. Load the rows into a new dataset, and report the dataset id so the pending upload can be cleared platform-side.
+
+## toloka dataset fields prints nothing for a dataset that has rows
+
+Column inference runs on the file-upload path only. Rows added through the items endpoint are stored without inference, so a dataset can visibly hold rows and still report zero inferred fields. Declare the columns in source instead of relying on inference.
+
+## Starting a run returns 500
+
+`toloka pipeline run` can fail with a bodyless `500` transiently. Before retrying, check whether a run was created anyway:
+
+```sh
+toloka pipeline runs <name>
+```
+
+If it lists no new run, retry. The same call has succeeded minutes later with no configuration change.
+
+## Exit code 2 from toloka pipeline run
+
+The timeout closed while the run was still in progress. That is not a failure of the run and not a failure of your pipeline. A queue with no one working it stays in progress indefinitely, so report what you observed — item counts and current states — rather than waiting unbounded:
+
+```sh
+toloka pipeline status <name>
+toloka pipeline results <runId> --failed
+```
+
+## apply succeeded but the pipeline will not deploy
+
+`toloka validate` reports platform spec errors and the latest matching check jobs without writing the graph. `apply` writes the graph. Neither certifies that the pipeline is ready to launch. Deployment gates that live outside that report — an enabled Training course with no content, or a labeler UI that has not been validated — surface in the platform UI, not in the CLI.
+
+## Missing credentials
+
+```
+Missing API key. Run toloka login once to store credentials for this machine.
+```
+
+Run `toloka login`, or set `POTATO_API_KEY` in an environment where interactive login is not possible. `toloka whoami` reports which platform and which key source is in effect, and exits non-zero when the platform is unreachable.
+
+## Authentication fails with a key you just generated
+
+Keys are scoped to the platform that issued them. A key from one platform's console will not authenticate against a different platform. `whoami` prints the base URL it is using; confirm it matches the console where the key was generated.

package/examples/face-image-collection/README.md

@@ -0,0 +1,42 @@
+# Face image collection
+
+The TypeScript files in this directory are authoritative project source. The pipeline names its `face-images` dataset, and its `field()` declarations define the columns the pipeline requires. Dataset items and secret values never live in source.
+
+After adding `@toloka-platform/sdk` to the project, initialize the source root so its agents discover the bundled pipeline-authoring guidance:
+
+```sh
+toloka init
+```
+
+Then configure the API and import an existing project:
+
+```sh
+export POTATO_API_KEY=api-key
+export POTATO_BASE_URL=https://potato.example.com
+toloka import pp.0190abcd-abcd-7abc-8abc-abcdefabcdef
+# Imported project pp.0190abcd-abcd-7abc-8abc-abcdefabcdef with 1 pipeline and 1 dataset into ...
+```
+
+Edit a node under `pipelines/face-image-collection/nodes/`, then inspect and apply the project-wide reconciliation:
+
+```sh
+toloka plan
+# ~ Node changed in pipelines/face-image-collection: annotate_faces (...)
+
+toloka apply
+# Applied 1 write to project pp.0190abcd-abcd-7abc-8abc-abcdefabcdef.
+```
+
+`apply` creates the named dataset and missing required columns before it binds the pipeline. It never reconciles dataset items. Upload items explicitly as JSONL:
+
+```sh
+toloka dataset upload face-images ./face-images.jsonl
+# Uploaded 2 rows to dataset face-images.
+```
+
+Set a required secret from a named environment variable or stdin. The value is never accepted as an argument, printed, or written to source:
+
+```sh
+toloka secret set openai-api-key --from-env OPENAI_API_KEY
+# Set secret openai-api-key.
+```

package/examples/face-image-collection/fields.ts

@@ -0,0 +1,26 @@
+import { field } from "@toloka-platform/sdk";
+
+const faceAnnotationsSchema: Parameters<typeof field>[1] = {
+  type: "array",
+  items: {
+    type: "object",
+    properties: {
+      boundingBox: {
+        type: "object",
+        properties: {
+          x: { type: "number" },
+          y: { type: "number" },
+          width: { type: "number" },
+          height: { type: "number" },
+        },
+        required: ["x", "y", "width", "height"],
+      },
+      label: { type: "string", const: "face" },
+    },
+    required: ["boundingBox", "label"],
+  },
+};
+
+export const imageUrl = field("image_url", { type: "string", format: "uri" });
+export const draftFaces = field("draft_faces", faceAnnotationsSchema);
+export const faces = field("faces", faceAnnotationsSchema);

package/examples/face-image-collection/nodes/annotate-faces/node.ts

@@ -0,0 +1,142 @@
+import { generation } from "@toloka-platform/sdk";
+
+import { draftFaces, imageUrl } from "../../fields";
+
+export const annotateFaces = generation("annotate_faces", {
+  about: {
+    description: "Draw a bounding box around every visible human face in the image.",
+    projectType: "general",
+  },
+  publicName: "Face image collection",
+  audienceAndPricing: {
+    audienceType: "human",
+    verifiedExperts: true,
+    audience: {
+      languages: { type: "and", values: [{ value: "English" }] },
+      specializations: { type: "and", values: [] },
+      countries: { type: "or", values: [] },
+    },
+    pricePerTask: 0.2,
+    timeForTask: 60,
+    perExpertCapEnabled: false,
+    perExpertCapValue: 1,
+  },
+  entities: {
+    input: [
+      {
+        field: imageUrl,
+        entityType: "IMAGE",
+        description: "Public URL of an image that may contain human faces.",
+      },
+    ],
+    output: [
+      {
+        field: draftFaces,
+        entityType: "ANNOTATION",
+        jsonPath: "$.draft_faces[*]",
+        description: "One tight bounding box for each visible human face.",
+        relations: [{ field: imageUrl, rel_type: "references" }],
+        dynamic: true,
+        maxEntities: 50,
+      },
+    ],
+  },
+  qualityCriteria: [
+    {
+      id: "123e4567-e89b-42d3-a456-426614174000",
+      qualityElement: "Completeness",
+      thresholds: {
+        pass: "Every visible human face has exactly one tight bounding box.",
+        fail: "A visible face is missing, duplicated, or bounded too loosely.",
+      },
+      targetEntity: draftFaces,
+    },
+  ],
+  instruction:
+    "Draw one tight rectangular bounding box around every visible human face. Do not annotate faces shown only in photographs, posters, or reflections.",
+  ui: {
+    code: "<Field.ImageAnnotation path={'draft_faces'} image={actions.get('image_url', '')} tools={['rectangle']} labels={[{ label: 'Face', value: 'face' }]} />",
+    data: '{"image_url":"https://example.com/face.jpg"}',
+    preprocess: "return {}",
+    postprocess: "return {};",
+    constants: "{}",
+  },
+  qualityAssurance: {
+    qaMode: "llm_only",
+    llmQaModelId: "gpt-5.4",
+  },
+  onboarding: {
+    enabled: true,
+    steps: [
+      {
+        id: "step-1",
+        blocks: [
+          {
+            id: "intro",
+            type: "text",
+            title: "Annotate every visible face",
+            content: [
+              {
+                type: "markdown",
+                value:
+                  "Draw a tight box around each visible human face and leave non-human faces unmarked.",
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: "step-2",
+        blocks: [
+          {
+            id: "guidance",
+            type: "text",
+            title: "Use tight boxes",
+            content: [
+              {
+                type: "markdown",
+                value: "Keep every box close to the visible face without cropping it.",
+              },
+            ],
+          },
+        ],
+      },
+      {
+        id: "step-3",
+        blocks: [
+          {
+            id: "quiz",
+            type: "quiz",
+            title: "Face annotation check",
+            questions: [
+              {
+                id: "question-1",
+                type: "single-choice",
+                question: "Which faces should be annotated?",
+                options: [
+                  { value: "all", label: "Every visible human face" },
+                  { value: "largest", label: "Only the largest face" },
+                ],
+                correctAnswer: "all",
+              },
+            ],
+          },
+        ],
+      },
+    ],
+    info: {
+      estimatedTime: "5 minutes",
+      role: "Face annotator",
+      goal: "Identify every visible human face",
+      successCriteria: "Every face has one tight bounding box",
+    },
+  },
+  exam: {
+    enabled: false,
+    gradedEntities: [],
+    tasksPerExpert: 1,
+    passThreshold: 1,
+  },
+  reuseAudienceWithNodeId: null,
+  smartSearch: null,
+});

package/examples/face-image-collection/nodes/collection/node.ts

@@ -0,0 +1,5 @@
+import { root } from "@toloka-platform/sdk";
+
+import { faces, imageUrl } from "../../fields";
+
+export const collection = root({ started: [imageUrl], completed: [faces] });

package/examples/face-image-collection/nodes/order-faces/node.ts

@@ -0,0 +1,26 @@
+import { code } from "@toloka-platform/sdk";
+
+import { draftFaces, faces } from "../../fields";
+
+export const orderFaces = code("order_faces", {
+  about: {
+    name: "order_faces",
+    description:
+      "Order face annotations from top left to bottom right for deterministic downstream data.",
+  },
+  envVars: [],
+  fieldProxies: {
+    input: [{ field: draftFaces, optional: false }],
+    output: [{ field: faces, optional: false }],
+  },
+  code: {
+    code: `from main_types import Inputs, Outputs
+
+async def main(inputs: Inputs) -> Outputs:
+    ordered_faces = sorted(
+        inputs["draft_faces"],
+        key=lambda face: (face["boundingBox"]["y"], face["boundingBox"]["x"]),
+    )
+    return {"faces": ordered_faces}`,
+  },
+});

package/examples/face-image-collection/pipeline.ts

@@ -0,0 +1,19 @@
+import { connect, definePipeline } from "@toloka-platform/sdk";
+
+import { draftFaces, faces, imageUrl } from "./fields";
+import { annotateFaces } from "./nodes/annotate-faces/node";
+import { collection } from "./nodes/collection/node";
+import { orderFaces } from "./nodes/order-faces/node";
+
+export const pipeline = definePipeline({
+  dataset: "face-images",
+  fields: [imageUrl, draftFaces, faces],
+  nodes: [collection, annotateFaces, orderFaces],
+  connections: [
+    connect(collection.started, annotateFaces.input),
+    connect(annotateFaces.output, orderFaces.input),
+    connect(orderFaces.output, collection.completed),
+  ],
+});
+
+export default pipeline;

package/examples/video-pair-rating/README.md

@@ -0,0 +1,57 @@
+# Video pair rating
+
+A side-by-side comparison pipeline: two generated videos per prompt, rated independently by a quorum of raters across several quality metrics, resolved by deterministic cascade logic, with a human adjudication branch for the metrics that stay disputed.
+
+This is the largest example in the package. It exists because the small examples do not exercise the shapes that make real pipelines hard: a quorum whose outputs are arrays, deterministic resolution that has to un-swap presentation order, predicate routing whose `default` branch skips work, and a second adjudication loop for one specific metric.
+
+## Shape
+
+```
+root.started
+  └─> shuffle_ab                    code    randomize left/right presentation, record the swap
+      └─> rate_pair                 quorum  N raters score every metric on the shuffled pair
+          └─> cascade               code    un-swap, then apply the deterministic resolution cascade
+              └─> route_adjudication            match   did any metric stay disputed?
+                  ├─ matched(0) ─> adjudicate           generation  a senior rater breaks the tie
+                  │                 └─> merge_adjudication  code
+                  └─ default ────> merge_adjudication    code
+                      └─> route_overall                 match   is overall preference still open?
+                          ├─ matched(0) ─> overall_preference_pick  quorum  a separate vote
+                          │                 └─> op_quorum_resolve   code
+                          │                     └─> route_op_adjudication  match
+                          │                         ├─ matched(0) ─> adjudicate_op  generation
+                          │                         │                 └─> merge_op_adjudication  code
+                          │                         └─ default ────> merge_op_adjudication
+                          │                             └─> finalize_overall  code
+                          └─ default ────────────────────> finalize_overall  code
+                              └─> adjudication_match  code
+                                  └─> assemble        code
+                                      └─> root.completed
+```
+
+Sixteen nodes: one root, eight `code`, three `match`, two `generation`, two `quorum`.
+
+## What to read first
+
+| file | why |
+|---|---|
+| `pipeline.ts` | the whole topology on one screen — every edge is explicit |
+| `nodes/cascade/node.ts` | the deterministic core that resolves every metric from rater arrays |
+| `nodes/rate_pair/node.ts` | a quorum node with real quality criteria and a Training course |
+| `nodes/route_overall/node.ts` | predicate routing, and what the `default` branch is for |
+
+## Conventions this example demonstrates
+
+**One directory per node.** Each node owns its file. A price change, a prompt change, or a Python fix touches exactly one directory, which is what makes review and agent edits cheap.
+
+**Topology is stated, never inferred.** `pipeline.ts` holds a literal `connections` array. You can read the graph without opening a single node file, and a reviewer can diff a topology change without reading Python.
+
+**Quorum outputs are arrays.** Every output field on `rate_pair` carries one element per rater. `cascade` consumes those arrays; it never receives a single value. This is the most common surprise when moving from `generation` to `quorum`.
+
+**Presentation order is data.** `shuffle_ab` records which video went left, and `cascade` un-swaps before resolving. Randomizing without recording the swap silently corrupts every downstream comparison.
+
+**Adjudication is a branch, not a loop.** The graph stays acyclic. Redo, appeal, and payment retry live inside the human-work nodes; only the tie-breaking hand-off is a graph edge.
+
+## Provenance
+
+The topology, the resolution cascade, and the per-node layout are adapted from a design spike by @hexode. Media URLs, sample payloads, prompts, and prose here are synthetic: no customer data, project identifiers, or asset URLs from the original are carried over.

package/examples/video-pair-rating/fields.ts

@@ -0,0 +1,155 @@
+import { field, type JsonSchema } from "@toloka-platform/sdk";
+
+const METRIC_PICK = ["video_1", "video_2", "tie"];
+const METRIC_PICK_OR_NONE = ["video_1", "video_2", "tie", "none"];
+const PAIR_PICK = ["video_a", "video_b", "tie"];
+const PAIR_PICK_OR_NONE = ["video_a", "video_b", "tie", "none"];
+
+const votes = (values: readonly string[]): JsonSchema => ({
+  type: "array",
+  items: { type: "string", enum: [...values] },
+});
+
+const nullableVotes = (values: readonly string[]): JsonSchema => ({
+  type: ["array", "null"],
+  items: { type: "string", enum: [...values] },
+});
+
+export const prompt = field("prompt", { type: "string" });
+export const videoA = field("video_a", { type: "string" });
+export const videoB = field("video_b", { type: "string" });
+export const deliveryRecord = field("delivery_record", { type: "object" });
+export const recordId = field("record_id", { type: "string" });
+
+export const leftVideo = field("left_video", { type: "string" });
+export const rightVideo = field("right_video", { type: "string" });
+export const swap = field("swap", { type: "boolean" });
+
+export const imageTextAlignment = field("image_text_alignment", votes(METRIC_PICK));
+export const motionTextAlignment = field("motion_text_alignment", votes(METRIC_PICK));
+export const motionQuality = field("motion_quality", votes(METRIC_PICK));
+export const subjectBackgroundConsistency = field(
+  "subject_background_consistency",
+  votes(METRIC_PICK),
+);
+export const videoRealism = field("video_realism", votes(METRIC_PICK));
+export const imageQuality = field("image_quality", votes(METRIC_PICK_OR_NONE));
+
+export const perMetricResolved = field("per_metric_resolved", { type: "object" });
+export const needsAdjudication = field("needs_adjudication", { type: "string" });
+export const disagreedTask = field("disagreed_task", { type: "string" });
+export const disagreedMetrics = field("disagreed_metrics", {
+  type: "array",
+  items: { type: "string" },
+});
+
+export const adjudicatedMetrics = field("adjudicated_metrics", { type: "object" });
+export const finalMetrics = field("final_metrics", { type: "object" });
+export const annotatorIdAdjudicator = field("annotator_id_adjudicator", {
+  type: ["string", "null"],
+});
+export const resolutionMethod = field("resolution_method", { type: "string" });
+
+export const overallManualVotes = field("overall_manual_votes", votes(PAIR_PICK));
+export const overallPreference = field("overall_preference", { type: "string" });
+export const overallPreferenceSource = field("overall_preference_source", { type: "string" });
+export const opValueOrNull = field("op_value_or_null", { type: ["string", "null"] });
+export const opSource = field("op_source", { type: "string" });
+export const opManualValue = field("op_manual_value", { type: ["string", "null"] });
+export const needsOverallManual = field("needs_overall_manual", { type: "string" });
+
+export const opNeedsAdjudication = field("op_needs_adjudication", {
+  type: "string",
+  enum: ["true", "false"],
+});
+export const disagreedOpTask = field("disagreed_op_task", { type: "object" });
+export const opAdjudicatedValue = field("op_adjudicated_value", {
+  type: "string",
+  enum: [...PAIR_PICK],
+});
+export const opAdjudicatorId = field("op_adjudicator_id", { type: ["string", "null"] });
+export const finalOpValue = field("final_op_value", { type: "string", enum: [...PAIR_PICK] });
+export const finalOpResolutionMethod = field("final_op_resolution_method", {
+  type: "string",
+  enum: ["agreement", "adjudication"],
+});
+export const finalOpAdjudicatorId = field("final_op_adjudicator_id", { type: ["string", "null"] });
+
+export const raterDurationSeconds = field("rater_duration_seconds", {
+  type: "array",
+  items: { type: "number" },
+});
+export const raterBothPlayed = field("rater_both_played", {
+  type: "array",
+  items: { type: "boolean" },
+});
+export const raterItaVotes = field("rater_ita_votes", votes(PAIR_PICK));
+export const raterMtaVotes = field("rater_mta_votes", votes(PAIR_PICK));
+export const raterIqVotes = field("rater_iq_votes", votes(PAIR_PICK_OR_NONE));
+export const raterMqVotes = field("rater_mq_votes", votes(PAIR_PICK_OR_NONE));
+export const raterSbcVotes = field("rater_sbc_votes", votes(PAIR_PICK_OR_NONE));
+export const raterVrVotes = field("rater_vr_votes", votes(PAIR_PICK_OR_NONE));
+export const raterOpVotes = field("rater_op_votes", nullableVotes(PAIR_PICK));
+export const raterItaMatchesAdjudication = field("rater_ita_matches_adjudication", {
+  type: ["array", "null"],
+  items: { type: "boolean" },
+});
+export const raterIqMatchesAdjudication = field("rater_iq_matches_adjudication", {
+  type: ["array", "null"],
+  items: { type: "boolean" },
+});
+export const raterOpMatchesAdjudication = field("rater_op_matches_adjudication", {
+  type: ["array", "null"],
+  items: { type: "boolean" },
+});
+
+export const allFields = [
+  prompt,
+  videoA,
+  videoB,
+  deliveryRecord,
+  recordId,
+  leftVideo,
+  rightVideo,
+  swap,
+  imageTextAlignment,
+  motionTextAlignment,
+  motionQuality,
+  subjectBackgroundConsistency,
+  videoRealism,
+  imageQuality,
+  perMetricResolved,
+  needsAdjudication,
+  disagreedTask,
+  disagreedMetrics,
+  adjudicatedMetrics,
+  finalMetrics,
+  annotatorIdAdjudicator,
+  resolutionMethod,
+  overallManualVotes,
+  overallPreference,
+  overallPreferenceSource,
+  opValueOrNull,
+  opSource,
+  opManualValue,
+  needsOverallManual,
+  opNeedsAdjudication,
+  disagreedOpTask,
+  opAdjudicatedValue,
+  opAdjudicatorId,
+  finalOpValue,
+  finalOpResolutionMethod,
+  finalOpAdjudicatorId,
+  raterDurationSeconds,
+  raterBothPlayed,
+  raterItaVotes,
+  raterMtaVotes,
+  raterIqVotes,
+  raterMqVotes,
+  raterSbcVotes,
+  raterVrVotes,
+  raterOpVotes,
+  raterItaMatchesAdjudication,
+  raterIqMatchesAdjudication,
+  raterOpMatchesAdjudication,
+];