@toloka-platform/sdk 0.12.2 → 0.13.0

package/openapi/gen/models/index.ts

@@ -25,6 +25,35 @@ export * from './attachPipelineDatasetBodyItemFilterSlice';
 export * from './baseModel';
 export * from './baseModelId';
 export * from './baseModelIdProperty';
+export * from './batchInferenceMode';
+export * from './batchInferenceModeOneOf';
+export * from './batchInferenceModel';
+export * from './batchInferenceModelOneOf';
+export * from './batchInferenceModelOneOfBaseModelId';
+export * from './batchInferenceModelOneOfThree';
+export * from './batchInferenceRun';
+export * from './batchInferenceRunBlockedReason';
+export * from './batchInferenceRunChargedAmount';
+export * from './batchInferenceRunError';
+export * from './batchInferenceRunErrorAnyOf';
+export * from './batchInferenceRunErrorAnyOfCode';
+export * from './batchInferenceRunId';
+export * from './batchInferenceRunMessage';
+export * from './batchInferenceRunOutput';
+export * from './batchInferenceRunOutputType';
+export * from './batchInferenceRunProgress';
+export * from './batchInferenceRunProgressAnyOf';
+export * from './batchInferenceRunProgressAnyOfPhase';
+export * from './batchInferenceRunProgressAnyOfRequests';
+export * from './batchInferenceRunQuote';
+export * from './batchInferenceRunQuoteAnyOf';
+export * from './batchInferenceRunQuoteAnyOfConfirmBefore';
+export * from './batchInferenceRunResult';
+export * from './batchInferenceRunResultAnyOf';
+export * from './batchInferenceRunResultAnyOfErrorCounts';
+export * from './batchInferenceRunResultAnyOfErrorSamplesItem';
+export * from './batchInferenceRunSampling';
+export * from './batchInferenceRunStatus';
 export * from './checkJob';
 export * from './checkJobError';
 export * from './checkJobResult';
@@ -78,6 +107,25 @@ export * from './codeNodeSettingsFieldProxies';
 export * from './codeNodeSettingsFieldProxiesInputItem';
 export * from './codeNodeSettingsFieldProxiesOutputItem';
 export * from './copyPipelineBody';
+export * from './createBatchInferenceRunBody';
+export * from './createBatchInferenceRunBodyItemFilter';
+export * from './createBatchInferenceRunBodyItemFilterExcludePartsItem';
+export * from './createBatchInferenceRunBodyItemFilterFieldSourcesItem';
+export * from './createBatchInferenceRunBodyItemFilterFieldSourcesItemSourcesItem';
+export * from './createBatchInferenceRunBodyItemFilterFieldSourcesItemSourcesItemOneOf';
+export * from './createBatchInferenceRunBodyItemFilterFieldSourcesItemSourcesItemOneOfTwo';
+export * from './createBatchInferenceRunBodyItemFilterFieldValuesItem';
+export * from './createBatchInferenceRunBodyItemFilterFieldValuesItemOperator';
+export * from './createBatchInferenceRunBodyItemFilterFieldValuesItemSourcesItem';
+export * from './createBatchInferenceRunBodyItemFilterFieldValuesItemSourcesItemOneOf';
+export * from './createBatchInferenceRunBodyItemFilterFieldValuesItemSourcesItemOneOfTwo';
+export * from './createBatchInferenceRunBodyItemFilterFieldValuesItemValue';
+export * from './createBatchInferenceRunBodyItemFilterParts';
+export * from './createBatchInferenceRunBodyItemFilterSlice';
+export * from './createBatchInferenceRunBodyOutput';
+export * from './createBatchInferenceRunBodyOutputOneOf';
+export * from './createBatchInferenceRunBodyOutputOneOfTwo';
+export * from './createBatchInferenceRunBodySampling';
 export * from './createDatasetBody';
 export * from './createDatasetBodyProfile';
 export * from './createDatasetExportBody';
@@ -168,6 +216,9 @@ export * from './datasetFieldSplitAnyOfRecipeAnyOfBalanceByFieldId';
 export * from './datasetFieldSplitAnyOfRecipeAnyOfSharesItem';
 export * from './datasetFieldSplitAnyOfStatus';
 export * from './datasetFieldSplitFillOperation';
+export * from './datasetFieldWriteOperation';
+export * from './datasetFieldWriteOperationProgress';
+export * from './datasetFieldWriteOperationProgressAnyOf';
 export * from './datasetId';
 export * from './datasetItem';
 export * from './datasetItemCurrentSubmissionId';
@@ -356,6 +407,8 @@ export * from './jsonSchemaTypeAnyOfItem';
 export * from './listAudienceSpecializations200';
 export * from './listAudienceSpecializationsParams';
 export * from './listBaseModels200';
+export * from './listBatchInferenceRuns200';
+export * from './listBatchInferenceRunsParams';
 export * from './listDatasetFields200';
 export * from './listDatasetFieldsParams';
 export * from './listDatasetItems200';

package/openapi/gen/models/listBatchInferenceRuns200.ts

@@ -0,0 +1,7 @@
+import type { BatchInferenceRun } from './batchInferenceRun';
+import type { Pagination } from './pagination';
+
+export type ListBatchInferenceRuns200 = {
+  batchInferenceRuns: BatchInferenceRun[];
+  pagination: Pagination;
+};

package/openapi/gen/models/listBatchInferenceRunsParams.ts

@@ -0,0 +1,5 @@
+
+export type ListBatchInferenceRunsParams = {
+limit?: number;
+offset?: number;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toloka-platform/sdk",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "private": false,
   "description": "Build, inspect, and operate Toloka pipeline projects as TypeScript source. The public API may change between minor versions before 1.0.",
   "license": "Apache-2.0",
@@ -77,6 +77,6 @@
     "bun": ">=1.4.0"
   },
   "tolokaBuild": {
-    "commit": "72b9ea77f616c7f9c3c564c550eac42f703929b2"
+    "commit": "63680479b4e4905b946650ebec6070af910e2340"
   }
 }

package/skills/catalog.json

@@ -11,8 +11,8 @@
         "testing",
         "checks"
       ],
-      "version": "0.12.2",
-      "digest": "7e6b79b9b85fbfc86cf98f33ebd30fdb4617707d22f7c24440bee2fedecb5f71",
+      "version": "0.13.0",
+      "digest": "1595dd10deec49f9f940445f26fe0dc0ed1383ffccb33e42d1ad05d282e71a5c",
       "files": [
         "SKILL.md",
         "references/human-work.md",
@@ -33,7 +33,7 @@
         "bug",
         "report"
       ],
-      "version": "0.12.2",
+      "version": "0.13.0",
       "digest": "70f0bd2c80b32f87896aeb27c363b8a2d37f40e22424f57fe1aad142e125ad67",
       "files": [
         "SKILL.md",
@@ -50,7 +50,7 @@
         "getting-started",
         "agent"
       ],
-      "version": "0.12.2",
+      "version": "0.13.0",
       "digest": "2278adeb46a792356579395fcf73c42322cb23bcd0c61e20856ccabdad6762d1",
       "files": [
         "SKILL.md"
@@ -67,7 +67,7 @@
         "sft",
         "models"
       ],
-      "version": "0.12.2",
+      "version": "0.13.0",
       "digest": "3ce10dee5d3c283d8b5fdea15134a58fc738c7af2c1bb19eb5a0bf70ea0bca13",
       "files": [
         "SKILL.md"
@@ -84,7 +84,7 @@
         "prompt",
         "models"
       ],
-      "version": "0.12.2",
+      "version": "0.13.0",
       "digest": "be8bce8d9cf7241ccb60d2b2a9b7cc07d7755a76e8ff8ec1b0847c49efbb3469",
       "files": [
         "SKILL.md"

package/skills/toloka-build/references/workflow-and-cli.md

@@ -35,7 +35,7 @@ Run `toloka --help` and `toloka <command> --help` for the exact commands and opt
 - source reconciliation: `init`, `import`, `check`, `validate`, `plan`, `apply`, `status`, `secret set`;
 - catalogs: `audience specialization list`, `generation-model list`, `ui components`;
 - data and runs: `dataset` (`list`, `create`, `fields`, `fields add`, `columns`, `load`, `upload`, `split`, `slice`), `pipeline` (`list`, `run`, `status`, `runs`, `cost`, `results`, `cancel`);
-- models and training: `base-model`, `model` (including `model version download`), `training`;
+- models and training: `base-model`, `model` (including `model version download`), `training`, `batch-inference` (`run`, `list`, `status`, `confirm`, `resume`, `cancel`);
 - skills and reports: `skill` (`list`, `search`, `install`), `report`.
 
 `toloka audience specialization list` prints the global specialization catalog: `ID`, `NAME`, and `EXPERTS` columns (`--json` for the array). Run it before setting `audience.specializations` on a node, pick entries by name, and copy `ID` into `qualificationId` and `NAME` into `value`; never invent a `qualificationId`. `EXPERTS` counts ID-verified experts currently eligible for tasks; a `0` means the id is valid but nobody currently qualifies, so prefer another specialization or widen the audience.
@@ -58,6 +58,10 @@ Hyperparameters are optional flags on `training create` and `training update`; t
 
 Use `training cost` to validate inputs and show the maximum charge before `training run`. A blocked estimate exits 1 and lists the issues on stderr instead of printing the estimate; fix them and recalculate. `training run` accepts that ready estimate JSON through `--estimate-file`; without it, the command calculates a fresh ready estimate itself before creating the run. `--version-name` defaults to the Training name; pass it when a Model Version with that name already exists. Use `training status`, `training logs`, `training metrics`, `training resume`, and `training cancel` with the returned Training Run ID. `training metrics` lists each metric's latest value while the run is still training; `--key` prints one metric's point history instead. `training cancel` before training starts is free; on a run that is already training it stops the GPU job, and the run is charged only for the GPU seconds used until then and produces no Model Version.
 
+## Answer dataset rows with a model
+
+`toloka batch-inference run --dataset <id> (--base-model <id> | --model-version <id>) (--output-field <name> | --output-dataset <name>) --max-output-tokens <n>` sends each selected row's `messages` to a qwen3-4b or qwen3-8b Base Model, or a Model Version trained from one, and writes one answer per row into a text column or a new dataset. An existing `--output-field` column must allow strings; one whose schema allows none is refused with "does not accept text", so pick or create a text column. `--filter field=value`, `--slice <id>` and `--parts <names>` (with `--split-column` when the dataset has several) narrow the rows; a slice answers the prompts it froze. `run` waits for the quote and prints the rows and the maximum charge: show them to the user and confirm only with their approval, through `--yes` on `run` or `toloka batch-inference confirm <run-id>` within 24 hours. Follow a run with `status --wait`. A `blocked` run names its reason: after `funds` or `payment`, `resume` continues it once the user adds funds; `billing_review` waits for support to reconcile the charge, and `resume` does not apply to it. `cancel` stops a run and charges the GPU time used, and `list` shows the project's runs. A scoped token needs `inference:deploy` (the `deploy` preset) to run, confirm, resume or cancel. `toloka batch-inference <command> --help` lists every flag.
+
 ## Check locally and validate against the platform
 
 Run the complete local gate first, then validate every bound pipeline remotely:

package/src/cli/analytics.ts

@@ -108,6 +108,14 @@ const COMMAND_GROUPS: Readonly<Record<string, CommandGroup>> = {
     metrics: true,
     logs: true,
   },
+  "batch-inference": {
+    run: true,
+    list: true,
+    status: true,
+    confirm: true,
+    resume: true,
+    cancel: true,
+  },
   "base-model": { list: true, get: true },
   "generation-model": { list: true },
   model: {

package/src/cli/batch-inference.ts

@@ -0,0 +1,267 @@
+import { randomUUID } from "node:crypto";
+
+import type { BatchInferenceRun, PotatoClient } from "../client";
+import type { BaseModelId, CreateBatchInferenceRunBody } from "../../openapi/gen/models";
+import { assertCli } from "./cli-error";
+import { resolveFieldValueFilters } from "./filters";
+import { resolveModelVersion } from "./models";
+import { resolveSplitParts } from "./splits";
+import { formatTable, type TableIo as BatchInferenceIo, writeOutput } from "./table";
+
+type BatchInferenceApi = Pick<PotatoClient, "batchInference">;
+type BatchInferenceStartApi = Pick<
+  PotatoClient,
+  "batchInference" | "datasets" | "models" | "baseModels"
+>;
+
+const QUOTE_WAIT_MS = 10 * 60 * 1_000;
+const SETTLED_STATUSES: ReadonlySet<BatchInferenceRun["status"]> = new Set([
+  "awaiting_confirmation",
+  "blocked",
+  "completed",
+  "failed",
+  "canceled",
+]);
+
+const sleep = (ms: number) =>
+  new Promise<void>((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+export const formatBatchInferenceRun = (run: BatchInferenceRun): string =>
+  formatTable([
+    ["ID", run.id],
+    ["Status", run.status],
+    ["Dataset", run.datasetId],
+    ["Model", run.model.type === "base_model" ? run.model.baseModelId : run.model.modelVersionId],
+    [
+      "Output",
+      run.output.type === "field"
+        ? `field ${run.output.fieldId} on dataset ${run.output.datasetId}`
+        : `new dataset ${run.output.datasetId}`,
+    ],
+    ...(run.quote
+      ? [
+          ["Rows", String(run.quote.requests)],
+          ["Skipped rows", String(run.quote.skippedRows)],
+          ["Maximum charge", `$${run.quote.maximumCharge}`],
+          ...(run.quote.confirmBefore ? [["Confirm before", run.quote.confirmBefore]] : []),
+        ]
+      : []),
+    ...(run.progress?.requests
+      ? [["Progress", `${run.progress.requests.done}/${run.progress.requests.total} rows`]]
+      : []),
+    ...(run.chargedAmount ? [["Charged", `$${run.chargedAmount}`]] : []),
+    ...(run.result
+      ? [
+          ["Written", String(run.result.written)],
+          ["Failed", String(run.result.failed)],
+          ["Cut at max tokens", String(run.result.truncated)],
+          ["Tokens", `${run.result.inputTokens} in, ${run.result.outputTokens} out`],
+        ]
+      : []),
+    ...(run.message ? [["Message", run.message]] : []),
+  ]);
+
+const waitUntil = async (
+  client: BatchInferenceApi,
+  batchInferenceRunId: string,
+  isReady: (run: BatchInferenceRun) => boolean,
+  pollIntervalMs: number,
+  timeoutMs: number,
+): Promise<BatchInferenceRun> => {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const run = await client.batchInference.getRun({ batchInferenceRunId });
+    if (isReady(run)) return run;
+    assertCli(Date.now() < deadline, `Batch Inference Run ${run.id} is still ${run.status}.`, {
+      hint: { description: `Check it later with toloka batch-inference status ${run.id}.` },
+    });
+    await sleep(pollIntervalMs);
+  }
+};
+
+export type StartBatchInferenceRunInput = {
+  projectId: string;
+  datasetId: string;
+  filter?: string;
+  slice?: string;
+  parts?: string[];
+  splitColumn?: string;
+  baseModel?: BaseModelId;
+  modelVersion?: string;
+  outputField?: string;
+  outputDataset?: string;
+  maxOutputTokens: number;
+  temperature?: number;
+  topP?: number;
+  stop: string[];
+  seed?: number;
+  samplesPerRow?: number;
+  idempotencyKey?: string;
+  yes: boolean;
+  json: boolean;
+  pollIntervalMs?: number;
+};
+
+const resolveItemFilter = async (
+  client: BatchInferenceStartApi,
+  input: StartBatchInferenceRunInput,
+): Promise<CreateBatchInferenceRunBody["itemFilter"]> => {
+  assertCli(
+    input.splitColumn === undefined || input.parts !== undefined,
+    "--split-column needs --parts.",
+    { hint: { description: "Pass --parts test to answer the rows of the test part." } },
+  );
+  const itemFilter = {
+    ...(input.filter !== undefined &&
+      (await resolveFieldValueFilters(
+        client,
+        { datasetId: input.datasetId, name: input.datasetId, nameIsUnique: false },
+        [input.filter],
+      ))),
+    ...(input.slice !== undefined && { slice: { sliceId: input.slice } }),
+    ...(input.parts !== undefined && {
+      parts: await resolveSplitParts(client, input.datasetId, {
+        splitColumn: input.splitColumn,
+        parts: input.parts,
+      }),
+    }),
+  };
+  return Object.keys(itemFilter).length > 0 ? itemFilter : undefined;
+};
+
+export const startBatchInferenceRun = async (
+  client: BatchInferenceStartApi,
+  input: StartBatchInferenceRunInput,
+  io: BatchInferenceIo,
+): Promise<void> => {
+  assertCli(
+    (input.baseModel === undefined) !== (input.modelVersion === undefined),
+    "Pass exactly one of --base-model or --model-version.",
+    {
+      hint: {
+        description: "Run toloka base-model list or toloka model versions <model> to pick one.",
+      },
+    },
+  );
+  assertCli(
+    (input.outputField === undefined) !== (input.outputDataset === undefined),
+    "Pass exactly one of --output-field or --output-dataset.",
+    {
+      hint: {
+        description:
+          "--output-field writes a column on the dataset; --output-dataset creates a new dataset with the prompts and answers.",
+      },
+    },
+  );
+  const itemFilter = await resolveItemFilter(client, input);
+  const model: CreateBatchInferenceRunBody["model"] = input.baseModel
+    ? { type: "base_model", baseModelId: input.baseModel }
+    : {
+        type: "model_version",
+        modelVersionId: (await resolveModelVersion(client, input.projectId, input.modelVersion!))
+          .id,
+      };
+  const created = await client.batchInference.createRun({
+    projectId: input.projectId,
+    idempotencyKey: input.idempotencyKey ?? randomUUID(),
+    datasetId: input.datasetId,
+    ...(itemFilter && { itemFilter }),
+    model,
+    sampling: {
+      maxOutputTokens: input.maxOutputTokens,
+      ...(input.temperature !== undefined && { temperature: input.temperature }),
+      ...(input.topP !== undefined && { topP: input.topP }),
+      ...(input.stop.length > 0 && { stop: input.stop }),
+      ...(input.seed !== undefined && { seed: input.seed }),
+      ...(input.samplesPerRow !== undefined && { samplesPerRow: input.samplesPerRow }),
+    },
+    output:
+      input.outputField === undefined
+        ? { type: "dataset", name: input.outputDataset! }
+        : { type: "field", fieldName: input.outputField },
+  });
+  const quoted = await waitUntil(
+    client,
+    created.id,
+    (run) => run.status !== "preparing",
+    input.pollIntervalMs ?? 1_000,
+    QUOTE_WAIT_MS,
+  );
+  assertCli(quoted.status === "awaiting_confirmation", formatBatchInferenceRun(quoted), {
+    hint: { description: "Fix the selection or the model, then start a new run." },
+  });
+  if (!input.yes) {
+    writeOutput(
+      io,
+      input.json,
+      quoted,
+      `${formatBatchInferenceRun(quoted)}\n\nConfirm the maximum charge with: toloka batch-inference confirm ${quoted.id}`,
+    );
+    return;
+  }
+  const confirmed = await client.batchInference.confirmRun({ batchInferenceRunId: quoted.id });
+  writeOutput(io, input.json, confirmed, formatBatchInferenceRun(confirmed));
+};
+
+export const listBatchInferenceRuns = async (
+  client: BatchInferenceApi,
+  input: { projectId: string; json: boolean },
+  io: BatchInferenceIo,
+): Promise<void> => {
+  const page = await client.batchInference.listRunsPage({
+    projectId: input.projectId,
+    limit: 100,
+    offset: 0,
+  });
+  writeOutput(
+    io,
+    input.json,
+    page.batchInferenceRuns,
+    page.batchInferenceRuns.length === 0
+      ? "No Batch Inference Runs found."
+      : formatTable([
+          ["ID", "STATUS", "DATASET", "MAXIMUM CHARGE", "CHARGED"],
+          ...page.batchInferenceRuns.map((run) => [
+            run.id,
+            run.status,
+            run.datasetId,
+            run.quote ? `$${run.quote.maximumCharge}` : "-",
+            run.chargedAmount ? `$${run.chargedAmount}` : "-",
+          ]),
+        ]),
+  );
+};
+
+export const getBatchInferenceRun = async (
+  client: BatchInferenceApi,
+  input: { batchInferenceRunId: string; wait: boolean; json: boolean; pollIntervalMs?: number },
+  io: BatchInferenceIo,
+): Promise<void> => {
+  const run = input.wait
+    ? await waitUntil(
+        client,
+        input.batchInferenceRunId,
+        (candidate) => SETTLED_STATUSES.has(candidate.status),
+        input.pollIntervalMs ?? 5_000,
+        Number.POSITIVE_INFINITY,
+      )
+    : await client.batchInference.getRun({ batchInferenceRunId: input.batchInferenceRunId });
+  writeOutput(io, input.json, run, formatBatchInferenceRun(run));
+};
+
+export const changeBatchInferenceRun = async (
+  client: BatchInferenceApi,
+  input: { batchInferenceRunId: string; action: "confirm" | "cancel" | "resume"; json: boolean },
+  io: BatchInferenceIo,
+): Promise<void> => {
+  const request = { batchInferenceRunId: input.batchInferenceRunId };
+  const run =
+    input.action === "confirm"
+      ? await client.batchInference.confirmRun(request)
+      : input.action === "cancel"
+        ? await client.batchInference.cancelRun(request)
+        : await client.batchInference.resumeRun(request);
+  writeOutput(io, input.json, run, formatBatchInferenceRun(run));
+};

package/src/cli/commands/batch-inference.ts

@@ -0,0 +1,116 @@
+import type { Command } from "commander";
+
+import {
+  changeBatchInferenceRun,
+  getBatchInferenceRun,
+  listBatchInferenceRuns,
+  startBatchInferenceRun,
+  type StartBatchInferenceRunInput,
+} from "../batch-inference";
+import {
+  collectValues,
+  nonNegativeInteger,
+  partNames,
+  positiveInteger,
+  resolveContext,
+  samplingTemperature,
+  samplingTopP,
+  type CommandHost,
+} from "../context";
+import { parseBaseModelId } from "../models";
+import { assertProjectSelected } from "../project-context";
+
+type RunOptions = Omit<StartBatchInferenceRunInput, "projectId" | "datasetId"> & {
+  dataset: string;
+};
+
+export const registerBatchInferenceCommands = (program: Command, host: CommandHost): void => {
+  const { context, globals } = host;
+  const batchInference = program
+    .command("batch-inference")
+    .description("answer dataset rows with a base model or Model Version");
+  batchInference
+    .command("run")
+    .requiredOption("--dataset <id>", "Dataset whose chat messages are the prompts")
+    .option("--filter <field=value>", "only rows whose field equals the value")
+    .option("--slice <id>", "only rows of this ready Dataset Slice, with the prompts it froze")
+    .option(
+      "--parts <names>",
+      "only rows in these split parts, comma-separated, for example test",
+      partNames,
+    )
+    .option(
+      "--split-column <name-or-id>",
+      "split column that --parts names, when the dataset has more than one",
+    )
+    .option("--base-model <id>", "catalog Base Model that answers", parseBaseModelId)
+    .option("--model-version <id>", "Model Version that answers: mdv.<id> or Model@name")
+    .option("--output-field <name>", "text column on the dataset that receives the answers")
+    .option("--output-dataset <name>", "new dataset that receives the prompts and answers")
+    .requiredOption(
+      "--max-output-tokens <count>",
+      "token limit per answer, at most 8192",
+      positiveInteger,
+    )
+    .option(
+      "--temperature <value>",
+      "sampling temperature from 0 to 2 (default 0)",
+      samplingTemperature,
+    )
+    .option("--top-p <value>", "nucleus sampling threshold above 0 and at most 1", samplingTopP)
+    .option("--stop <text>", "stop sequence; repeat for up to four", collectValues, [])
+    .option("--seed <number>", "sampling seed", nonNegativeInteger)
+    .option(
+      "--samples-per-row <count>",
+      "answers per row, at most 16; above 1 needs --output-dataset and a temperature above 0",
+      positiveInteger,
+    )
+    .option("--idempotency-key <key>", "reuse the run of an earlier identical request")
+    .option("--yes", "confirm the quoted maximum charge and start right away", false)
+    .option("--json", "print JSON", false)
+    .description("quote a Batch Inference Run, then confirm it to start")
+    .action(async (options: RunOptions) => {
+      const { client, projectId } = await resolveContext(globals(), context);
+      assertProjectSelected(projectId);
+      const { dataset, ...rest } = options;
+      await startBatchInferenceRun(client, { ...rest, projectId, datasetId: dataset }, context.io);
+    });
+  batchInference
+    .command("list")
+    .option("--json", "print JSON", false)
+    .description("list the selected project's Batch Inference Runs")
+    .action(async (options: { json: boolean }) => {
+      const { client, projectId } = await resolveContext(globals(), context);
+      assertProjectSelected(projectId);
+      await listBatchInferenceRuns(client, { projectId, json: options.json }, context.io);
+    });
+  batchInference
+    .command("status")
+    .argument("<batch-inference-run-id>", "Batch Inference Run ID")
+    .option("--wait", "wait until the run finishes or needs you", false)
+    .option("--json", "print JSON", false)
+    .description("show one Batch Inference Run")
+    .action(async (batchInferenceRunId: string, options: { wait: boolean; json: boolean }) => {
+      const { client } = await resolveContext(globals(), context);
+      await getBatchInferenceRun(client, { batchInferenceRunId, ...options }, context.io);
+    });
+  for (const [action, description] of [
+    ["confirm", "accept the quoted maximum charge and start the run"],
+    ["resume", "resume a run blocked on funds or payment"],
+    ["cancel", "cancel a run; answers already generated are kept and the GPU time used is charged"],
+  ] as const) {
+    batchInference
+      .command(action)
+      .argument("<batch-inference-run-id>", "Batch Inference Run ID")
+      .option("--json", "print JSON", false)
+      .description(description)
+      .action(async (batchInferenceRunId: string, options: { json: boolean }) => {
+        const { client } = await resolveContext(globals(), context);
+        await changeBatchInferenceRun(
+          client,
+          { batchInferenceRunId, action, json: options.json },
+          context.io,
+        );
+      });
+  }
+};

package/src/cli/context.ts

@@ -97,6 +97,20 @@ export const nonNegativeInteger = (raw: string): number => {
   return value;
 };
 
+export const samplingTemperature = (raw: string): number => {
+  const value = Number(raw);
+  if (raw.trim() === "" || !Number.isFinite(value) || value < 0 || value > 2)
+    throw new InvalidArgumentError("Expected a temperature from 0 to 2.");
+  return value;
+};
+
+export const samplingTopP = (raw: string): number => {
+  const value = Number(raw);
+  if (raw.trim() === "" || !Number.isFinite(value) || value <= 0 || value > 1)
+    throw new InvalidArgumentError("Expected a top-p above 0 and at most 1.");
+  return value;
+};
+
 export const trainingMethod = (raw: string): "sft" | "gisting" => {
   if (raw !== "sft" && raw !== "gisting") {
     throw new InvalidArgumentError('Expected training method "sft" or "gisting".');

package/src/cli/models.ts

@@ -69,7 +69,7 @@ const resolveModel = async (
   return matches[0]!;
 };
 
-const resolveModelVersion = async (
+export const resolveModelVersion = async (
   client: ModelApi,
   projectId: string | undefined,
   nameOrId: string,

package/src/cli/program.ts

@@ -23,6 +23,7 @@ import { registerSourceCommands } from "./commands/source";
 import { registerStatusCommand } from "./commands/status";
 import { registerTrainingCommands } from "./commands/training";
 import { registerUiCommands } from "./commands/ui";
+import { registerBatchInferenceCommands } from "./commands/batch-inference";
 import { registerVersionCommand } from "./commands/version";
 import type { TolokaEnvironment } from "./config";
 import {
@@ -102,6 +103,7 @@ export function createProgram(context: ProgramContext): CreatedProgram {
   registerSecretCommands(program, host);
   registerModelCommands(program, host);
   registerTrainingCommands(program, host);
+  registerBatchInferenceCommands(program, host);
   registerDatasetCommands(program, host);
   registerPipelineCommands(program, host);
   registerStatusCommand(program, host);