@toloka-platform/sdk 0.11.4 → 0.12.1

package/dist/cli/toloka.js.jsc.sha256

@@ -1 +1 @@
-a7b5f9f339e9293bf388a7a57c15cfa4297942cdb7243e8b53d116661ddf5f0d  toloka.js.jsc
+53fe90017e8148a870d73fa33a0f56c6c82f88bf3eb77b8e9fb20838d06a20ca  toloka.js.jsc

package/dist/cli/toloka.js.sha256

@@ -1 +1 @@
-3c36c2751f8365c8ed466bd389723fa1d836d2ec5e61850450e4a725648ec0f8  toloka.js
+c8be9f7f4e8971c442387fef3a07e1653f45fe83af5dd034d48cdba6364c305a  toloka.js

package/docs/cli.md

@@ -384,8 +384,8 @@ Create a reusable Training draft, price it, and run it.
 ```sh
 toloka training list [--json]
 toloka training get <name-or-id> [--json]
-toloka training create <name> [--method sft|gisting] (--base-model <id> | --model-version <id>) --dataset <id> [--train-filter field=value] [--validation-dataset <id> [--validation-filter field=value]] [--prompt-file <path>] [--lora-rank 8|16|32 | --gist-tokens 8|32|64|1/4|1/8|1/16|1/32] [--epochs 1..5] [--learning-rate <rate>] [--batch-size 8|16|32|64] [--max-sequence-length <tokens>] [--json]
-toloka training update <name-or-id> [--base-model <id> | --model-version <id>] [--dataset <id>] [--train-filter field=value] [--validation-dataset <id> [--validation-filter field=value]] [--prompt-file <path>] [--lora-rank 8|16|32 | --gist-tokens 8|32|64|1/4|1/8|1/16|1/32] [--epochs 1..5] [--learning-rate <rate>] [--batch-size 8|16|32|64] [--max-sequence-length <tokens>] [--json]
+toloka training create <name> [--method sft|gisting] (--base-model <id> | --model-version <id>) (--dataset <name-or-id> | --slice <id>) [--split-column <name-or-id>] [--parts <names>] [--prompt-file <path>] [--lora-rank 8|16|32 | --gist-tokens 8|32|64|1/4|1/8|1/16|1/32] [--epochs 1..5] [--learning-rate <rate>] [--batch-size 8|16|32|64] [--max-sequence-length <tokens>] [--json]
+toloka training update <name-or-id> [--base-model <id> | --model-version <id>] [--dataset <name-or-id> | --slice <id>] [--split-column <name-or-id>] [--parts <names>] [--prompt-file <path>] [--lora-rank 8|16|32 | --gist-tokens 8|32|64|1/4|1/8|1/16|1/32] [--epochs 1..5] [--learning-rate <rate>] [--batch-size 8|16|32|64] [--max-sequence-length <tokens>] [--json]
 toloka training cost <name-or-id> [--idempotency-key <key>] [--json]
 toloka training run <name-or-id> [--estimate-file <path>] [--version-name <name>] [--idempotency-key <key>] [--json]
 toloka training runs <name-or-id> [--json]
@@ -398,6 +398,8 @@ toloka training metrics <training-run-id> [--key <metric>] [--resolution <n>] [-
 
 Hyperparameters are optional flags on `training create` and `training update`: `--epochs 1..5` (default 3), `--learning-rate` (SFT 0.00001–0.001, default 0.00015; gisting 0.001–0.3, default 0.03), `--batch-size 8|16|32|64` (default 8; sequences per optimizer step across all GPUs) and `--max-sequence-length 64..16384` (default 12288 for SFT, 3072 for gisting) apply to both methods; `--lora-rank 8|16|32` (default 16) is SFT-only and `--gist-tokens` (default `1/8`) is gisting-only — passing one to the other method fails before any request. `--gist-tokens` takes an absolute count `8|32|64` or a fraction of the prompt being compressed (`1/4`, `1/8`, `1/16`, `1/32`), which the run resolves to `ceil(prompt tokens / N)` clamped to 8..256. `--regime` and `--eval-steps` no longer exist. `training update` has no `--method` flag: the method stays as created, and every flag you omit keeps its current value. `training cost` is blocked when the longest example exceeds `--max-sequence-length` or when the training selection leaves fewer rows than `--batch-size` after the 10% holdout. `training get` prints the resolved recipe, so omitted flags are visible as their defaults.
 
+A Training learns on a ready dataset slice that freezes a split column, and `training create` needs `--dataset` or `--slice`. `--dataset <name-or-id>` fills the empty cells of the dataset's split column (a new `split` column, 80/10/10, when it has none), freezes a slice named after the Training, and trains on it; it waits up to 10 minutes for each step and prints one line per step before `Created training`. A split column adopted from an ordinary column has no shares, so `--dataset` does not fill it; give it shares first with `toloka dataset split <dataset> --column <name> --parts <name>=<roles>:<percent>,...`. `--slice <id>` takes a slice frozen with `toloka dataset slice create`. With several split columns, `--split-column` picks the one to train with. The Training learns on the column's train parts, or the ones `--parts` names, and validates on its validate parts, including a part that both validates and tests; without validation rows, the run holds out 10% of the training rows. Rows without a part are never trained on. `training update` keeps the slice, split column and train parts. A new `--dataset` or `--slice` resets the split column and train parts unless you pass them too; `--dataset` splits again and freezes a new slice named after the Training. `training get` prints the slice, split column and train parts. `training cost` leaves out rows that any split column now puts in a test part, a validate + test part of the Training's own column apart, and, when there are any, prints how many as `Left out as test`. The test parts of the Training's own column are outside the train parts to begin with, so they are not counted there. A Training saved before split slices were required is refused by `training cost` until `training update` gives it one.
+
 ## dataset
 
 Catalog and row commands for datasets in the selected project. Name or id is accepted; duplicate names must be addressed by id.
@@ -406,19 +408,38 @@ Catalog and row commands for datasets in the selected project. Name or id is acc
 toloka dataset list
 toloka dataset create <name>
 toloka dataset fields <name>
-toloka dataset load <name> --out <file> [--limit <n>] [--timeout <ms>]
+toloka dataset fields add <name> (<field>… | --all) [--no-wait] [--timeout <ms>] [--json]
+toloka dataset columns <name> [--json]
+toloka dataset load <name> --out <file> [--fields <fields>] [--limit <n>] [--timeout <ms>]
 toloka dataset upload <name> <file>
+toloka dataset split <name> [--column <name>] [--ratios 80/10/10 [--validate-on-test] | --parts <name[=roles][:percent],…>] [--balance-by <field>] [--seed <n>] [--filter field=value… | --slice <slice-id>] [--no-wait] [--timeout <ms>] [--json]
+toloka dataset slice create <name> [--name <name>] [--filter field=value]… [--freeze <columns>] [--no-wait] [--timeout <ms>] [--json]
+toloka dataset slice create <name> --from <slice-id> [--name <name>] [--freeze <columns>] [--no-wait] [--timeout <ms>] [--json]
+toloka dataset slice list <name>
+toloka dataset slice show <slice-id> [--json]
 ```
 
 `dataset list` prints live `name` and id. It does not page items.
 
-`dataset create` makes an empty dataset in the selected project; the first `dataset upload` infers its columns from the rows.
+`dataset create` makes an empty dataset in the selected project. The first `dataset upload` stores each row whole in the `uploaded` field and infers the fields of the rows; `dataset fields add` adds them as dataset fields.
 
 `dataset fields` prints inferred `field()` TypeScript, or `Dataset <name> has no inferred fields yet.`
 
-`dataset load` starts a platform export, waits for it (default 60s; pass `--timeout`), downloads the JSON array, and writes JSONL to `--out`. `--limit` slices after download; it still waits for the full export. On timeout the message names the export id. Failed downloads and invalid payloads leave `--out` untouched.
+`dataset fields add` adds a dataset field for each named top-level field of the uploaded rows, with the type inferred from them, so `--filter`, `--balance-by` and `dataset split --column` can use its values; `--all` takes every top-level field that is not a dataset field yet. A dataset field name takes lowercase letters, numbers and underscores, starts with a letter, ends with a letter or number and has at most 128 characters: a named field that breaks the rule is refused, and `--all` skips such fields and prints which. The values are copied from the uploaded rows in the background, and from every later upload. The command waits up to 60 seconds for the copy (`--timeout <ms>` sets the wait) and prints the fields with their types; `--no-wait` returns at once. A slice or a split that reads a field refuses to start while the field is still being copied, and `dataset slice create` and `dataset split` wait for it first unless `--no-wait` is passed; `training create --dataset` always waits.
+
+`dataset columns` prints each visible column with its id and, for a split column, its status and its parts with shares and roles, for example `ready · train 80% (train), validate 10% (validate), test 10% (test)`. `--json` prints every field with its `split` and `operations`, the background operations writing into it: `copy` while values are copied in from the field `sourceFieldId` names, and `split_fill` while a split column fills.
+
+`dataset load` starts a platform export, waits for it (default 60s; pass `--timeout`), downloads the JSON array, and writes JSONL to `--out`: one object per row with `index` and every visible field, or only the fields `--fields` names, for example `--fields uploaded,split`. `uploaded` holds each uploaded row whole, as one value. `--limit` slices after download; it still waits for the full export. On timeout the message names the export id. Failed downloads and invalid payloads leave `--out` untouched. A dataset without fields has no rows yet, and the command exits with 1.
+
+`dataset upload` accepts `.json` arrays, `.jsonl` files with one object per line, and `.csv` files with a header row. The CLI infers the format from the extension and uploads the original bytes without conversion. If the blob transfer or finalization fails, the CLI cancels the started upload before returning the error, so another upload can start immediately and may reuse the same filename. Field schemas are immutable after the first successful upload: you can add columns, never alter or remove one. When the dataset has no fields besides `uploaded` yet, the CLI prints the `dataset fields add` command that adds the uploaded fields as dataset fields; when it has fields copied from the uploaded rows, it waits until the new rows' values are copied too. See [datasets](./datasets.md).
+
+`dataset split` fills a split column: every row that has no value in it gets a part, sampled by share, and rows that already have a part keep it, so a test row stays a test row as the dataset grows. `--column` names the column (default `split`). A new name creates it; the name of a split column fills its empty cells with the shares, balancing column and seed of its last fill; the name of an ordinary column whose values name the parts makes it a split column without placing anything, and naming it again changes nothing; since nothing is placed, `--seed`, `--balance-by`, `--filter` and `--slice` are refused there unless `--parts` gives shares. A name that is a field of the uploaded rows but not a dataset field is refused with the `dataset fields add` command that adds it, so a Hugging Face `split` field becomes a split column with `toloka dataset fields add <name> split` and then `toloka dataset split <name> --column split`. `--ratios` takes whole percentages for `train`, `validate` and `test` that add up to 100 (default `80/10/10` for a new column); a 0% part is left out. `--parts` takes `name[=roles][:percent]` entries with roles `train`, `validate`, `test`, `validate+test` or `none`, for example `train:70,dev=validate:10,holdout=test:20`; a part named after a role takes it without `=roles`. To make an ordinary column a split column, `--parts` without percentages names the parts its values hold; without `--parts`, roles follow the values `train`, `validation`, `validate`, `val`, `dev` and `test`, and every value must be one of them. A part keeps its roles across fills, and the column keeps the shares of its last fill. On a split column that has shares, `--parts` without percentages is refused; omit `--parts` to repeat the last shares. `--validate-on-test` makes the test part the validation set too, the usual split when data is scarce; it needs a validate ratio of 0, for example `--ratios 80/0/20 --validate-on-test`, and the test score is then not fully held out. `--balance-by` shares out the rows of every label value on their own, so each part gets about the same mix of labels, though a label with only a few rows can still miss a part; a column with more than 1,000 distinct values fails the fill. `--seed` fixes the row order: rows are ranked by a hash of the seed and each row's position in the dataset, so the same seed puts the same rows, uploaded in the same order, in the same parts in any dataset. It is generated when omitted and kept by the column. Shares carry over: rows that already have a part count toward it, so the column keeps its proportions as rows are added. `--filter field=value` (repeatable) places only the rows that match when the fill starts, and `--slice` only the rows of a slice, waiting while it is still freezing. Rows uploaded during a fill wait for the next one. The command waits up to 60 seconds for the rows to be placed (`--timeout <ms>` sets the wait), prints the column's parts and the rows each holds, and exits with the error when the fill fails; when the wait runs out the fill keeps running. `--no-wait` returns at once, and `dataset columns` shows the progress. A fill is refused while the same column is still filling, or while a field it reads, such as the `--balance-by` field, is still being copied from the uploaded rows or filled by another split; without `--no-wait` the command first waits until no field is being copied and no split column is filling.
+
+A dataset can have several split columns. A row that any of them puts in a test part never reaches training, nor validation unless it sits in a validate + test part of the Training's own split column, so a column such as `--column holdout --parts holdout=test:10,rest=none:90` holds rows out of every Training. Name the column to train with through `training create --split-column`.
+
+`dataset slice create` freezes rows at a cutoff: the rows that match every `--filter field=value` (the top-level field equals the value; repeat the flag for more fields), or every row. The slice's id (`dsl.…`) always selects the same rows, and its frozen columns always read as they were just before the cutoff. `--name` tells slices apart (default `Slice 1`, `Slice 2` and so on). Rows uploaded later are never in it, and it is refused while an upload to the dataset is still running, a split column is still filling, or a field it freezes is still being copied from the uploaded rows; without `--no-wait` the command first waits until no field is being copied and no split column is filling. A dataset without rows has nothing to freeze, so the command refuses it. `--freeze` names the columns to freeze (default: every column); split columns are always frozen, so a slice records the parts as they were. The other columns read their latest values, and so do extra filters on a slice, such as field values or excluded parts. `--from <slice-id>` takes a ready slice again: its filters and, unless `--freeze` says otherwise, its frozen columns at a new cutoff, so rows added since join, rows that no longer match drop out, and frozen columns take their current values. `--from` refuses `--filter`. The command waits up to 60 seconds for the rows to be frozen (`--timeout <ms>` sets the wait; the slice keeps freezing when it runs out) and exits with the error when the slice fails, for example when no row matches; `--no-wait` returns at once, and `dataset slice show` reports the name, status, row count, filters and frozen columns. A slice that matches no row fails.
 
-`dataset upload` accepts `.json` arrays, `.jsonl` files with one object per line, and `.csv` files with a header row. The CLI infers the format from the extension and uploads the original bytes without conversion. If the blob transfer or finalization fails, the CLI cancels the started upload before returning the error, so another upload can start immediately and may reuse the same filename. Field schemas are immutable after the first successful upload: you can add columns, never alter or remove one. See [datasets](./datasets.md).
+`dataset slice list` prints the dataset's slices, newest first, with their names and the slice each one was taken from. Every slice stays readable by id.
 
 ## report
 

package/docs/datasets.md

@@ -59,7 +59,7 @@ Plan: 4 changes
 
 ## Immutability
 
-**A dataset field can be added. It can never be altered or removed after creation.**
+**A dataset field can be added. It can never be altered or removed after creation.** One exception: `dataset split` turning an ordinary column into a split column replaces its JSON Schema with an enum of the part names, which every value the column holds already matches.
 
 The platform API exposes exactly two field operations:
 
@@ -93,11 +93,14 @@ There is no flag to force an in-place change. The schema you declare on first ap
 toloka dataset list
 toloka dataset fields face-images
 toloka dataset load face-images --out data/face_images.jsonl
-toloka dataset load face-images --limit 100 --out data/face_images.sample.jsonl
+toloka dataset load face-images --fields image_url,faces --limit 100 --out data/face_images.sample.jsonl
 toloka dataset upload face-images data/face_images.jsonl
+toloka dataset fields add face-images --all
 ```
 
-`load` starts a platform export, waits (default 60s), downloads a JSON array, and writes JSONL to `--out`. `--limit` slices after that download. `--timeout` raises the wait. Failed downloads leave `--out` untouched.
+`load` starts a platform export, waits (default 60s), downloads a JSON array, and writes JSONL to `--out`: one object per row with every visible field, or only the fields `--fields` names. `uploaded` holds each uploaded row whole, as one value. `--limit` slices after that download. `--timeout` raises the wait. Failed downloads leave `--out` untouched.
+
+A dataset that no pipeline declares keeps each uploaded row whole in its `uploaded` field, so the rows' own fields are not dataset fields yet: `--filter`, `--balance-by` and `dataset split --column` need dataset fields. `toloka dataset fields add <dataset> <field>…` adds top-level fields of the uploaded rows as dataset fields, `--all` every one, and copies their values from the uploaded rows and from every later upload. A dataset field name takes lowercase letters, numbers and underscores, starts with a letter, ends with a letter or number and has at most 128 characters; `--all` skips fields whose names break the rule and says which. A slice or a split waits while a field it reads is still being copied.
 
 ## Load rows
 
@@ -146,6 +149,54 @@ export const faces = field(
 
 Inference runs once, after the first upload attaches rows to the dataset. When no upload has completed, the command prints "Dataset X has no inferred fields yet." Upload a representative file first.
 
+## Split a dataset and freeze a slice
+
+A split column puts each row in a part such as train, validate or test. A slice freezes a set of rows, and it always freezes the split columns.
+
+```sh
+toloka dataset split banking77 --ratios 80/10/10 --balance-by intent
+toloka dataset slice create banking77 --name "intent eval" --freeze text,intent
+```
+
+`dataset split` fills a split column, `split` unless `--column` names another: every row without a part gets one, sampled by share. Each part has roles. Trainings learn on `train` parts and validate on `validate` parts; `test` parts are held out: no training learns on a row that any split column puts in a test part, and none validates on one unless it sits in a validate + test part of the training's own split column. A part with no roles is for anything else. A part can both validate and test, the usual split when data is scarce (`--ratios 80/0/20 --validate-on-test`); its test score is then not fully held out. A train part has no other role. `--ratios` covers `train`, `validate` and `test`; `--parts train:70,calibration=none:10,validate:10,test:10` names other parts. `toloka dataset columns banking77` shows the split columns with their parts and roles.
+
+A split only fills empty cells. After an upload, run it again: the new rows join the parts so that the column keeps its shares, balanced by the same column with the same seed, and every row that already had a part keeps it, so no test row moves into training. Rows without a part are never trained on. To adopt a column that already names each row's part, such as a top-level Hugging Face `split` column, pass its name: `toloka dataset split banking77 --column split`. When `split` is a field of the uploaded rows rather than a dataset field, add it first with `toloka dataset fields add banking77 split`; `dataset split` refuses a field of the uploaded rows that is not a dataset field, instead of sampling a new column under that name. The seed ranks rows by their position in the dataset, so the same file uploaded to two datasets splits the same way with the same seed. Roles follow the values `train`, `validation`, `validate`, `val`, `dev` and `test`; `--parts train,dev=validate,test` maps other names.
+
+A slice takes the rows that match its filters (`--filter intent=card_arrival`, repeated for more fields), or every row, at a cutoff. Its id (`dsl.…`) always selects the same rows, and it reads its frozen columns as they were just before the cutoff, so those values never change either. By default every column is frozen; `--freeze text,intent` picks the columns instead, split columns are always added, and the others read their latest values. Rows uploaded later are never in a slice, and a slice cannot be taken while an upload to the dataset is still running, a split column is still filling, or a column it freezes is still being copied from the uploaded rows. Reading through a slice, the rows and its frozen columns, split parts included, are as of the slice cutoff; extra filters you add, such as field values or excluded parts, match the latest values. `--from <slice-id>` takes a slice again at a new cutoff: rows added since join and rows that no longer match drop out.
+
+A Training learns on a slice that freezes a split column: pass `--slice <id>` (`sliceId` in the API), or `--dataset <name>` to split the dataset and freeze a slice named after the Training in one step. It learns on the train parts and validates on the validate parts of that column; `--split-column` (`splitFieldId`) picks the column when the slice freezes several, and `--parts` (`trainParts`) picks among the train parts.
+
+From the SDK:
+
+```ts
+const column = await client.datasets.split({
+  datasetId,
+  parts: [
+    { name: "train", roles: ["train"], share: 0.7 },
+    { name: "calibration", roles: [], share: 0.1 },
+    { name: "validate", roles: ["validate"], share: 0.1 },
+    { name: "test", roles: ["test"], share: 0.1 },
+  ],
+  balanceBy: "intent",
+});
+const filled = await client.waitFor({ type: "datasetSplit", datasetId, column: column.name });
+const slice = await client.datasets.createSlice({ datasetId, name: "intent eval", frozenColumns: ["text", "intent"] });
+const ready = await client.waitFor({ type: "datasetSlice", sliceId: slice.id });
+```
+
+`split` returns the column, a dataset field whose `split` has the parts, the recipe and a `status` of `filling`, `ready` or `failed`. `waitFor({ type: "datasetSplit", datasetId, column })` resolves once the column stops filling, with `split.lastFill` counting the rows it placed, the rows that already had a part, and the rows per part. Pass `slice: sliceId` or an `itemFilter` to place only those rows. To adopt a column, pass its name and parts without shares: `{ datasetId, column: "split", parts: [{ name: "train", roles: ["train"] }, { name: "validation", roles: ["validate"] }, { name: "test", roles: ["test"] }] }`, or omit `parts` to infer the roles from the values. An adoption places no rows, so it refuses `seed`, `balanceBy`, `slice` and `itemFilter`. To take a slice again, pass `{ datasetId, fromSlice: sliceId }` to `createSlice`.
+
+To add fields of the uploaded rows as dataset fields from code, and wait until their values are copied:
+
+```ts
+const created = await client.datasets.createFieldsFromUploadedRows({ datasetId, names: ["intent", "split"] });
+const fields = await client.waitFor({ type: "datasetFields", datasetId, names: ["intent", "split"] });
+```
+
+`createFieldsFromUploadedRows` adds a dataset field for each named top-level field of the uploaded rows, with the schema inferred from them, and returns the new fields, each with a `copy` operation in `operations` while the values are copied in the background. `waitFor({ type: "datasetFields", datasetId, names })` polls the dataset's fields until none of the named fields, or none at all when `names` is omitted, has a blocking operation (`copy` or `split_fill`), and resolves with every field. Like the other waits, it gives up after 60 seconds unless `timeoutMs` says otherwise and throws a `PotatoApiError` with code `wait_timeout`; the copy keeps running. `split` and `createSlice` are refused with a conflict (HTTP 409) while a field they read is still being copied.
+
+Pipeline runs accept `slice: { sliceId }`, `parts: { fieldId, names: ["test"] }` and `excludeParts: [{ fieldId, names }]` in their row filter. `parts` reads the column as it was at the slice's cutoff when the same filter selects a slice that freezes it. A run that selects through a slice reads the slice's frozen columns as they were at the cutoff and every other column as usual.
+
 ## What plan refuses
 
 `plan` is read-only and reports everything `apply` will not do. Two dataset-related refusals are safety properties, not obstacles:

package/openapi/gen/api.ts

@@ -11,6 +11,8 @@ import type {
   CreateDatasetExportBody,
   CreateDatasetField200,
   CreateDatasetFieldBody,
+  CreateDatasetFieldsFromUploadedRowsBody,
+  CreateDatasetSliceBody,
   CreateDatasetUpload200,
   CreateDatasetUploadBody,
   CreatePipelineCheckBody,
@@ -21,9 +23,12 @@ import type {
   CreateProjectTrainingBody,
   CreateScopedTokenBody,
   CreateTrainingRunBody,
+  CreatedDatasetFields,
   CurrentUser,
   Dataset,
+  DatasetField,
   DatasetId,
+  DatasetSlice,
   EstimatePipelineCostBody,
   EstimateTrainingCostBody,
   ExportId,
@@ -40,6 +45,8 @@ import type {
   ListDatasetFieldsParams,
   ListDatasetItems200,
   ListDatasetItemsParams,
+  ListDatasetSlices200,
+  ListDatasetSlicesParams,
   ListDeliveryOrders200,
   ListGenerationModels200,
   ListModelVersions200,
@@ -96,6 +103,7 @@ import type {
   SampleResult,
   ScopedToken,
   SetProjectSecretBody,
+  SplitDatasetBody,
   Training,
   TrainingCostEstimate,
   TrainingCostEstimateInputSet,
@@ -1511,6 +1519,103 @@ export const getDatasetSample = async (sampleId: string, options?: RequestInit):
 
 
 
+export const getCreateDatasetSliceUrl = (datasetId: DatasetId,) => {
+
+
+  
+
+  return `/api/v2-beta/datasets/${datasetId}/slices`
+}
+
+export const createDatasetSlice = async (datasetId: DatasetId,
+    createDatasetSliceBody: CreateDatasetSliceBody, options?: RequestInit): Promise<DatasetSlice> => {
+  
+  return potatoFetch<DatasetSlice>(getCreateDatasetSliceUrl(datasetId),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createDatasetSliceBody,)
+  }
+);}
+
+
+
+export const getListDatasetSlicesUrl = (datasetId: DatasetId,
+    params?: ListDatasetSlicesParams,) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? 'null' : value.toString())
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/api/v2-beta/datasets/${datasetId}/slices?${stringifiedParams}` : `/api/v2-beta/datasets/${datasetId}/slices`
+}
+
+export const listDatasetSlices = async (datasetId: DatasetId,
+    params?: ListDatasetSlicesParams, options?: RequestInit): Promise<ListDatasetSlices200> => {
+  
+  return potatoFetch<ListDatasetSlices200>(getListDatasetSlicesUrl(datasetId,params),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetDatasetSliceUrl = (sliceId: string,) => {
+
+
+  
+
+  return `/api/v2-beta/slices/${sliceId}`
+}
+
+export const getDatasetSlice = async (sliceId: string, options?: RequestInit): Promise<DatasetSlice> => {
+  
+  return potatoFetch<DatasetSlice>(getGetDatasetSliceUrl(sliceId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getSplitDatasetUrl = (datasetId: DatasetId,) => {
+
+
+  
+
+  return `/api/v2-beta/datasets/${datasetId}/split`
+}
+
+export const splitDataset = async (datasetId: DatasetId,
+    splitDatasetBody: SplitDatasetBody, options?: RequestInit): Promise<DatasetField> => {
+  
+  return potatoFetch<DatasetField>(getSplitDatasetUrl(datasetId),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      splitDatasetBody,)
+  }
+);}
+
+
+
 export const getCreateDatasetExportUrl = (datasetId: DatasetId,) => {
 
 
@@ -1555,6 +1660,29 @@ export const getDatasetExport = async (exportId: ExportId, options?: RequestInit
 
 
 
+export const getCreateDatasetFieldsFromUploadedRowsUrl = (datasetId: DatasetId,) => {
+
+
+  
+
+  return `/api/v2-beta/datasets/${datasetId}/fields/from-uploaded`
+}
+
+export const createDatasetFieldsFromUploadedRows = async (datasetId: DatasetId,
+    createDatasetFieldsFromUploadedRowsBody: CreateDatasetFieldsFromUploadedRowsBody, options?: RequestInit): Promise<CreatedDatasetFields> => {
+  
+  return potatoFetch<CreatedDatasetFields>(getCreateDatasetFieldsFromUploadedRowsUrl(datasetId),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createDatasetFieldsFromUploadedRowsBody,)
+  }
+);}
+
+
+
 export const getGetPipelineGraphSnapshotUrl = (pipelineId: PipelineId,) => {
 
 

package/openapi/gen/models/attachPipelineDatasetBodyItemFilter.ts

@@ -1,9 +1,15 @@
 import type { AttachPipelineDatasetBodyItemFilterFieldValuesItem } from './attachPipelineDatasetBodyItemFilterFieldValuesItem';
 import type { AttachPipelineDatasetBodyItemFilterFieldSourcesItem } from './attachPipelineDatasetBodyItemFilterFieldSourcesItem';
+import type { AttachPipelineDatasetBodyItemFilterSlice } from './attachPipelineDatasetBodyItemFilterSlice';
+import type { AttachPipelineDatasetBodyItemFilterParts } from './attachPipelineDatasetBodyItemFilterParts';
+import type { AttachPipelineDatasetBodyItemFilterExcludePartsItem } from './attachPipelineDatasetBodyItemFilterExcludePartsItem';
 
 export type AttachPipelineDatasetBodyItemFilter = {
   fieldValues?: AttachPipelineDatasetBodyItemFilterFieldValuesItem[];
   fieldSources?: AttachPipelineDatasetBodyItemFilterFieldSourcesItem[];
   missingRevisionFields?: string[];
+  slice?: AttachPipelineDatasetBodyItemFilterSlice;
+  parts?: AttachPipelineDatasetBodyItemFilterParts;
+  excludeParts?: AttachPipelineDatasetBodyItemFilterExcludePartsItem[];
   createdBefore?: string;
 };

package/openapi/gen/models/attachPipelineDatasetBodyItemFilterExcludePartsItem.ts

@@ -0,0 +1,5 @@
+
+export type AttachPipelineDatasetBodyItemFilterExcludePartsItem = {
+  fieldId: string;
+  names: string[];
+};

package/openapi/gen/models/attachPipelineDatasetBodyItemFilterParts.ts

@@ -0,0 +1,5 @@
+
+export type AttachPipelineDatasetBodyItemFilterParts = {
+  fieldId: string;
+  names: string[];
+};

package/openapi/gen/models/attachPipelineDatasetBodyItemFilterSlice.ts

@@ -0,0 +1,4 @@
+
+export type AttachPipelineDatasetBodyItemFilterSlice = {
+  sliceId: string;
+};

package/openapi/gen/models/createDatasetFieldsFromUploadedRowsBody.ts

@@ -0,0 +1,4 @@
+
+export type CreateDatasetFieldsFromUploadedRowsBody = {
+  names: string[];
+};

package/openapi/gen/models/createDatasetSliceBody.ts

@@ -0,0 +1,4 @@
+import type { CreateDatasetSliceBodyAnyOf } from './createDatasetSliceBodyAnyOf';
+import type { CreateDatasetSliceBodyAnyOfOnethree } from './createDatasetSliceBodyAnyOfOnethree';
+
+export type CreateDatasetSliceBody = CreateDatasetSliceBodyAnyOf | CreateDatasetSliceBodyAnyOfOnethree;

package/openapi/gen/models/createDatasetSliceBodyAnyOf.ts

@@ -0,0 +1,7 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilter } from './createDatasetSliceBodyAnyOfItemFilter';
+
+export type CreateDatasetSliceBodyAnyOf = {
+  name?: string;
+  itemFilter?: CreateDatasetSliceBodyAnyOfItemFilter;
+  frozenColumns?: string[];
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilter.ts

@@ -0,0 +1,8 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItem } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItem';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItem } from './createDatasetSliceBodyAnyOfItemFilterFieldSourcesItem';
+
+export type CreateDatasetSliceBodyAnyOfItemFilter = {
+  fieldValues?: CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItem[];
+  fieldSources?: CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItem[];
+  missingRevisionFields?: string[];
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldSourcesItem.ts

@@ -0,0 +1,6 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItem } from './createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItem';
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItem = {
+  fieldId: string;
+  sources: CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItem[];
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItem.ts

@@ -0,0 +1,4 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf } from './createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo } from './createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo';
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItem = CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf | CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo;

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf.ts

@@ -0,0 +1,5 @@
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf = {
+  type: 'user';
+  userId: string;
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo.ts

@@ -0,0 +1,5 @@
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo = {
+  type: 'system';
+  source: string;
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItem.ts

@@ -0,0 +1,12 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem';
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItem = {
+  jsonPath: string;
+  operator: CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator;
+  value: CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue;
+  fieldId: string;
+  latestOnly?: boolean;
+  sources?: CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem[];
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator.ts

@@ -0,0 +1,2 @@
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator = 'text_eq' | 'text_neq';

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem.ts

@@ -0,0 +1,4 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo';
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem = CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf | CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo;

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf.ts

@@ -0,0 +1,5 @@
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf = {
+  type: 'user';
+  userId: string;
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo.ts

@@ -0,0 +1,5 @@
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo = {
+  type: 'system';
+  source: string;
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue.ts

@@ -0,0 +1,2 @@
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue = string | number | boolean | null;

package/openapi/gen/models/createDatasetSliceBodyAnyOfOnethree.ts

@@ -0,0 +1,6 @@
+
+export type CreateDatasetSliceBodyAnyOfOnethree = {
+  name?: string;
+  fromSlice: string;
+  frozenColumns?: string[];
+};

package/openapi/gen/models/datasetField.ts

@@ -1,6 +1,8 @@
 import type { DatasetFieldId } from './datasetFieldId';
 import type { DatasetFieldDescription } from './datasetFieldDescription';
 import type { DatasetFieldJsonSchema } from './datasetFieldJsonSchema';
+import type { DatasetFieldSplit } from './datasetFieldSplit';
+import type { DatasetFieldOperation } from './datasetFieldOperation';
 
 export interface DatasetField {
   id: DatasetFieldId;
@@ -8,5 +10,7 @@ export interface DatasetField {
   description: DatasetFieldDescription;
   jsonSchema: DatasetFieldJsonSchema;
   internal: boolean;
+  split: DatasetFieldSplit;
+  operations: DatasetFieldOperation[];
   createdAt: string;
 }

package/openapi/gen/models/datasetFieldCopyOperation.ts

@@ -0,0 +1,7 @@
+import type { DatasetFieldId } from './datasetFieldId';
+
+export interface DatasetFieldCopyOperation {
+  type: 'copy';
+  sourceFieldId: DatasetFieldId;
+  blocking: boolean;
+}

package/openapi/gen/models/datasetFieldOperation.ts

@@ -0,0 +1,4 @@
+import type { DatasetFieldCopyOperation } from './datasetFieldCopyOperation';
+import type { DatasetFieldSplitFillOperation } from './datasetFieldSplitFillOperation';
+
+export type DatasetFieldOperation = DatasetFieldCopyOperation | DatasetFieldSplitFillOperation;

package/openapi/gen/models/datasetFieldSplit.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOf } from './datasetFieldSplitAnyOf';
+
+export type DatasetFieldSplit = DatasetFieldSplitAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOf.ts

@@ -0,0 +1,15 @@
+import type { DatasetFieldSplitAnyOfPartsItem } from './datasetFieldSplitAnyOfPartsItem';
+import type { DatasetFieldSplitAnyOfRecipe } from './datasetFieldSplitAnyOfRecipe';
+import type { DatasetFieldSplitAnyOfStatus } from './datasetFieldSplitAnyOfStatus';
+import type { DatasetFieldSplitAnyOfProgress } from './datasetFieldSplitAnyOfProgress';
+import type { DatasetFieldSplitAnyOfLastFill } from './datasetFieldSplitAnyOfLastFill';
+import type { DatasetFieldSplitAnyOfError } from './datasetFieldSplitAnyOfError';
+
+export type DatasetFieldSplitAnyOf = {
+  parts: DatasetFieldSplitAnyOfPartsItem[];
+  recipe: DatasetFieldSplitAnyOfRecipe;
+  status: DatasetFieldSplitAnyOfStatus;
+  progress: DatasetFieldSplitAnyOfProgress;
+  lastFill: DatasetFieldSplitAnyOfLastFill;
+  error: DatasetFieldSplitAnyOfError;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfError.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOfErrorAnyOf } from './datasetFieldSplitAnyOfErrorAnyOf';
+
+export type DatasetFieldSplitAnyOfError = DatasetFieldSplitAnyOfErrorAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOfErrorAnyOf.ts

@@ -0,0 +1,6 @@
+import type { DatasetFieldSplitAnyOfErrorAnyOfCode } from './datasetFieldSplitAnyOfErrorAnyOfCode';
+
+export type DatasetFieldSplitAnyOfErrorAnyOf = {
+  code: DatasetFieldSplitAnyOfErrorAnyOfCode;
+  message: string;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfErrorAnyOfCode.ts

@@ -0,0 +1,2 @@
+
+export type DatasetFieldSplitAnyOfErrorAnyOfCode = 'too_many_labels' | 'slice_failed';

package/openapi/gen/models/datasetFieldSplitAnyOfLastFill.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOfLastFillAnyOf } from './datasetFieldSplitAnyOfLastFillAnyOf';
+
+export type DatasetFieldSplitAnyOfLastFill = DatasetFieldSplitAnyOfLastFillAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOfLastFillAnyOf.ts

@@ -0,0 +1,7 @@
+import type { DatasetFieldSplitAnyOfLastFillAnyOfParts } from './datasetFieldSplitAnyOfLastFillAnyOfParts';
+
+export type DatasetFieldSplitAnyOfLastFillAnyOf = {
+  placed: number;
+  kept: number;
+  parts: DatasetFieldSplitAnyOfLastFillAnyOfParts;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfLastFillAnyOfParts.ts

@@ -0,0 +1,2 @@
+
+export type DatasetFieldSplitAnyOfLastFillAnyOfParts = {[key: string]: number};

package/openapi/gen/models/datasetFieldSplitAnyOfPartsItem.ts

@@ -0,0 +1,6 @@
+import type { DatasetFieldSplitAnyOfPartsItemRolesItem } from './datasetFieldSplitAnyOfPartsItemRolesItem';
+
+export type DatasetFieldSplitAnyOfPartsItem = {
+  name: string;
+  roles: DatasetFieldSplitAnyOfPartsItemRolesItem[];
+};

package/openapi/gen/models/datasetFieldSplitAnyOfPartsItemRolesItem.ts

@@ -0,0 +1,2 @@
+
+export type DatasetFieldSplitAnyOfPartsItemRolesItem = 'train' | 'validate' | 'test';

package/openapi/gen/models/datasetFieldSplitAnyOfProgress.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOfProgressAnyOf } from './datasetFieldSplitAnyOfProgressAnyOf';
+
+export type DatasetFieldSplitAnyOfProgress = DatasetFieldSplitAnyOfProgressAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOfProgressAnyOf.ts

@@ -0,0 +1,5 @@
+
+export type DatasetFieldSplitAnyOfProgressAnyOf = {
+  placed: number;
+  total: number;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfRecipe.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOfRecipeAnyOf } from './datasetFieldSplitAnyOfRecipeAnyOf';
+
+export type DatasetFieldSplitAnyOfRecipe = DatasetFieldSplitAnyOfRecipeAnyOf | null;