@toloka-platform/sdk 0.2.0-preview.2 → 0.2.0-preview.4

package/src/cli/trainings.ts

@@ -3,10 +3,21 @@ import { readFile, stat } from "node:fs/promises";
 
 import { randomUUID } from "node:crypto";
 
-import { assert } from "es-toolkit";
-
-import type { PotatoClient, Training, TrainingCostEstimate, TrainingRun } from "../client";
+import type {
+  PotatoClient,
+  Training,
+  TrainingCostEstimate,
+  TrainingRun,
+  TrainingRunMetricHistory,
+  TrainingRunMetrics,
+} from "../client";
 import type { BaseModelId, TrainingConfigurationInput } from "../../openapi/gen/models";
+import { assertCli, RETRY_OR_REPORT_HINT, TolokaCliError } from "./cli-error";
+import type { CliErrorHint } from "./cli-error";
+
+const ESTIMATE_FILE_HINT: CliErrorHint = {
+  description: "Regenerate it with toloka training cost <training> --json > <file>.",
+};
 
 type TrainingMethod = TrainingConfigurationInput["method"];
 type TrainingSource = TrainingConfigurationInput["source"];
@@ -23,9 +34,12 @@ export type TrainingDraftOptions = {
   validationDatasetId?: string;
   trainingFilter?: string;
   validationFilter?: string;
-  regime?: "low" | "medium" | "high";
+  loraRank?: SftConfigurationInput["loraRank"];
+  gistTokens?: GistingConfigurationInput["gistTokens"];
   epochs?: number;
-  evalSteps?: number;
+  learningRate?: number;
+  batchSize?: SftConfigurationInput["batchSize"];
+  maxSequenceLength?: number;
   promptFilePath?: string;
   fetch?: typeof globalThis.fetch;
 };
@@ -33,6 +47,7 @@ export type TrainingDraftOptions = {
 type TrainingApi = Pick<PotatoClient, "trainings">;
 type TrainingDraftApi = Pick<PotatoClient, "trainings" | "files" | "datasets">;
 type TrainingCostApi = Pick<PotatoClient, "trainings" | "waitFor">;
+type TrainingRunApi = Pick<PotatoClient, "trainings" | "waitFor">;
 const GISTING_PROMPT_MAX_BYTES = 256 * 1024;
 type TrainingIo = { readonly stdout: (text: string) => void };
 type TableRow = readonly string[];
@@ -64,6 +79,13 @@ const formatTraining = (training: Training): string =>
       "Method",
       training.configuration.method === "sft" ? "Supervised fine-tuning (SFT)" : "Prompt gisting",
     ],
+    training.configuration.method === "sft"
+      ? ["LoRA rank", String(training.configuration.loraRank)]
+      : ["Gist tokens", String(training.configuration.gistTokens)],
+    ["Epochs", String(training.configuration.epochs)],
+    ["Learning rate", String(training.configuration.learningRate)],
+    ["Batch size", String(training.configuration.batchSize)],
+    ["Max sequence length", String(training.configuration.maxSequenceLength)],
     ["Output Model", training.modelId ?? "-"],
     ["Archived at", training.archivedAt ?? "-"],
     ["Created at", training.createdAt],
@@ -107,27 +129,32 @@ type ReadyEstimateFile = {
 };
 
 const parseReadyEstimateFile = (value: unknown): ReadyEstimateFile => {
-  assert(
+  assertCli(
     typeof value === "object" && value !== null && !Array.isArray(value),
     "The estimate file must contain a JSON object.",
+    { hint: ESTIMATE_FILE_HINT },
   );
-  assert(
+  assertCli(
     "status" in value && value.status === "ready",
     "The estimate file is not a ready Training Cost Estimate.",
+    { hint: ESTIMATE_FILE_HINT },
   );
-  assert(
+  assertCli(
     "trainingId" in value && typeof value.trainingId === "string",
     "The estimate file has no Training ID.",
+    { hint: ESTIMATE_FILE_HINT },
   );
-  assert(
+  assertCli(
     "inputSetId" in value && typeof value.inputSetId === "string",
     "The estimate file has no Input Set ID.",
+    { hint: ESTIMATE_FILE_HINT },
   );
-  assert(
+  assertCli(
     "fingerprint" in value &&
       typeof value.fingerprint === "string" &&
       /^[0-9a-f]{64}$/.test(value.fingerprint),
     "The estimate file has no valid fingerprint.",
+    { hint: ESTIMATE_FILE_HINT },
   );
 
   return {
@@ -163,9 +190,10 @@ const resolveTraining = async (
 ): Promise<Training> => {
   if (nameOrId.startsWith("trg.")) {
     const training = await client.trainings.get({ trainingId: nameOrId });
-    assert(
+    assertCli(
       training.projectId === projectId,
       `Training ${nameOrId} was not found in project ${projectId}.`,
+      { hint: { description: "Run toloka training list; a Training belongs to one project." } },
     );
     return training;
   }
@@ -174,7 +202,9 @@ const resolveTraining = async (
   for await (const training of client.trainings.listAll({ projectId, limit: 100 })) {
     if (training.name === nameOrId) matches.push(training);
   }
-  assert(matches.length === 1, `Training ${nameOrId} was not found or is ambiguous.`);
+  assertCli(matches.length === 1, `Training ${nameOrId} was not found or is ambiguous.`, {
+    hint: { description: "Run toloka training list and pass the training id (trg.…)." },
+  });
   return matches[0]!;
 };
 
@@ -191,12 +221,18 @@ const resolveSelection = async (
   datasetId: string,
   filter: string | undefined,
 ): Promise<TrainingSelection> => {
-  assert(datasetId, "A Dataset is required when specifying a filter.");
+  assertCli(datasetId, "A Dataset is required when specifying a filter.", {
+    hint: {
+      description:
+        "Pass --dataset together with --train-filter, and --validation-dataset together with --validation-filter.",
+    },
+  });
   if (filter === undefined) return { datasetId };
   const separator = filter.indexOf("=");
-  assert(
+  assertCli(
     separator > 0 && separator < filter.length - 1,
     "Dataset filters must use FIELD=VALUE syntax.",
+    { hint: { description: "Write the filter as field=value, for example split=train." } },
   );
   const fieldName = filter.slice(0, separator);
   const rawValue = filter.slice(separator + 1);
@@ -205,9 +241,10 @@ const resolveSelection = async (
     if (field.name === fieldName) matches.push(field);
   }
   const [field] = matches;
-  assert(
+  assertCli(
     field && matches.length === 1,
     `Dataset field ${fieldName} was not found or is ambiguous.`,
+    { hint: { description: "Run toloka dataset fields <dataset> to see the field names." } },
   );
   return {
     datasetId,
@@ -232,14 +269,17 @@ const sourceFromOptions = (
   options: Pick<TrainingDraftOptions, "baseModelId" | "modelVersionId">,
   fallback?: TrainingSource,
 ): TrainingSource => {
-  assert(
+  assertCli(
     !(options.baseModelId && options.modelVersionId),
     "Choose exactly one of --base-model and --model-version.",
+    { hint: { disabled: true } },
   );
   if (options.baseModelId) return { type: "base_model", baseModelId: options.baseModelId };
   if (options.modelVersionId)
     return { type: "model_version", modelVersionId: options.modelVersionId };
-  assert(fallback, "Choose exactly one of --base-model and --model-version.");
+  assertCli(fallback, "Choose exactly one of --base-model and --model-version.", {
+    hint: { disabled: true },
+  });
   return fallback;
 };
 
@@ -250,20 +290,29 @@ const uploadPromptFile = async (
   fetchImplementation: typeof globalThis.fetch,
 ): Promise<string> => {
   const metadata = await stat(filePath);
-  assert(metadata.isFile(), "--prompt-file must point to a file.");
-  assert(metadata.size > 0, "The gisting prompt file is empty.");
-  assert(
+  assertCli(metadata.isFile(), "--prompt-file must point to a file.", {
+    hint: { description: "Pass the absolute path of the prompt text file." },
+  });
+  assertCli(metadata.size > 0, "The gisting prompt file is empty.", {
+    hint: { description: "Put the full prompt text into the file before creating the Training." },
+  });
+  assertCli(
     metadata.size <= GISTING_PROMPT_MAX_BYTES,
     "The gisting prompt file exceeds the 256 KiB limit.",
+    { hint: { description: "Shorten the prompt to under 256 KiB." } },
   );
   const payload = await readFile(filePath);
   let prompt: string;
   try {
     prompt = new TextDecoder("utf-8", { fatal: true }).decode(payload);
   } catch {
-    throw new Error("The gisting prompt file must contain valid UTF-8 text.");
+    throw new TolokaCliError("The gisting prompt file must contain valid UTF-8 text.", {
+      hint: { description: "Save the prompt file as UTF-8 text." },
+    });
   }
-  assert(prompt.trim().length > 0, "The gisting prompt file is empty.");
+  assertCli(prompt.trim().length > 0, "The gisting prompt file is empty.", {
+    hint: { description: "Put the full prompt text into the file before creating the Training." },
+  });
   const started = await client.files.startUpload({
     projectId,
     filename: basename(filePath),
@@ -275,7 +324,9 @@ const uploadPromptFile = async (
       headers: { "x-ms-blob-type": "BlockBlob", "Content-Type": "text/plain; charset=utf-8" },
       body: payload,
     });
-    assert(response.ok, `Failed to upload gisting prompt: HTTP ${response.status}.`);
+    assertCli(response.ok, `Failed to upload gisting prompt: HTTP ${response.status}.`, {
+      hint: RETRY_OR_REPORT_HINT,
+    });
     return (await client.files.finalizeUpload({ projectId, fileId: started.file.id })).id;
   } catch (error) {
     await client.files.delete({ projectId, fileId: started.file.id }).catch(() => undefined);
@@ -293,7 +344,9 @@ const resolveSelections = async ({
   options: TrainingDraftOptions;
 }): Promise<ResolvedSelections> => {
   const trainingDatasetId = options.datasetId ?? current?.training.datasetId;
-  assert(trainingDatasetId, "--dataset is required.");
+  assertCli(trainingDatasetId, "--dataset is required.", {
+    hint: { description: "Pass --dataset <dataset-id>; toloka dataset list shows the ids." },
+  });
   const training =
     options.datasetId === undefined && options.trainingFilter === undefined && current
       ? current.training
@@ -309,6 +362,14 @@ const resolveSelections = async ({
   return { training, validation };
 };
 
+const sharedHyperparameters = (options: TrainingDraftOptions) => ({
+  ...(options.learningRate === undefined ? {} : { learningRate: options.learningRate }),
+  ...(options.batchSize === undefined ? {} : { batchSize: options.batchSize }),
+  ...(options.maxSequenceLength === undefined
+    ? {}
+    : { maxSequenceLength: options.maxSequenceLength }),
+});
+
 const buildSftConfiguration = ({
   source,
   selections,
@@ -320,15 +381,28 @@ const buildSftConfiguration = ({
   current: SftConfigurationInput | undefined;
   options: TrainingDraftOptions;
 }): SftConfigurationInput => {
-  assert(options.promptFilePath === undefined, "Gisting options cannot be used with SFT.");
+  assertCli(options.promptFilePath === undefined, "--prompt-file applies to gisting only.", {
+    hint: {
+      description: "Pass --method gisting to use --prompt-file, or omit --prompt-file for SFT.",
+    },
+  });
+  assertCli(
+    options.gistTokens === undefined,
+    "--gist-tokens applies to gisting; SFT takes --lora-rank.",
+    {
+      hint: {
+        description: "Use --lora-rank for SFT, or pass --method gisting to use --gist-tokens.",
+      },
+    },
+  );
   return {
     ...current,
     method: "sft",
     source,
     ...selections,
-    ...(options.regime === undefined ? {} : { regime: options.regime }),
+    ...(options.loraRank === undefined ? {} : { loraRank: options.loraRank }),
     ...(options.epochs === undefined ? {} : { epochs: options.epochs }),
-    ...(options.evalSteps === undefined ? {} : { evalSteps: options.evalSteps }),
+    ...sharedHyperparameters(options),
   };
 };
 
@@ -347,7 +421,15 @@ const buildGistingConfiguration = async ({
   current: GistingConfigurationInput | undefined;
   options: TrainingDraftOptions;
 }): Promise<GistingConfigurationInput> => {
-  assert(options.evalSteps === undefined, "SFT options cannot be used with gisting.");
+  assertCli(
+    options.loraRank === undefined,
+    "--lora-rank applies to SFT; gisting takes --gist-tokens.",
+    {
+      hint: {
+        description: "Use --gist-tokens for gisting, or omit --method gisting to create SFT.",
+      },
+    },
+  );
   const promptFileId = options.promptFilePath
     ? await uploadPromptFile(
         client,
@@ -356,15 +438,18 @@ const buildGistingConfiguration = async ({
         options.fetch ?? globalThis.fetch,
       )
     : current?.promptFileId;
-  assert(promptFileId, "--prompt-file is required for gisting.");
+  assertCli(promptFileId, "--prompt-file is required for gisting.", {
+    hint: { description: "Pass --prompt-file <absolute-path> with the prompt text." },
+  });
   return {
     ...current,
     method: "gisting",
     source,
     ...selections,
     promptFileId,
-    ...(options.regime === undefined ? {} : { regime: options.regime }),
+    ...(options.gistTokens === undefined ? {} : { gistTokens: options.gistTokens }),
     ...(options.epochs === undefined ? {} : { epochs: options.epochs }),
+    ...sharedHyperparameters(options),
   };
 };
 
@@ -445,8 +530,14 @@ export const createTraining = async (
   },
   io: TrainingIo,
 ): Promise<void> => {
-  assert(input.datasetId, "--dataset is required.");
-  assert(!input.validationFilter || input.validationDatasetId, "--validation-filter requires --validation-dataset.");
+  assertCli(input.datasetId, "--dataset is required.", {
+    hint: { description: "Pass --dataset <dataset-id>; toloka dataset list shows the ids." },
+  });
+  assertCli(
+    !input.validationFilter || input.validationDatasetId,
+    "--validation-filter requires --validation-dataset.",
+    { hint: { disabled: true } },
+  );
 
   const configuration = await buildTrainingConfiguration({
     client,
@@ -458,12 +549,7 @@ export const createTraining = async (
     name: input.name,
     configuration,
   });
-  writeOutput(
-    io,
-    input.json,
-    training,
-    `Created training ${training.id}`,
-  );
+  writeOutput(io, input.json, training, `Created training ${training.id}`);
 };
 
 export const updateTraining = async (
@@ -485,19 +571,13 @@ export const updateTraining = async (
       options: input,
     }),
   });
-  writeOutput(
-    io,
-    input.json,
-    updated,
-    `Updated training ${updated.id}`,
-  );
+  writeOutput(io, input.json, updated, `Updated training ${updated.id}`);
 };
 
-export const estimateTrainingCost = async (
+const prepareTrainingCostEstimate = async (
   client: TrainingCostApi,
-  input: { projectId: string; nameOrId: string; idempotencyKey?: string; json: boolean },
-  io: TrainingIo,
-): Promise<void> => {
+  input: { nameOrId: string; projectId: string; idempotencyKey?: string },
+): Promise<{ training: Training; estimate: TrainingCostEstimate }> => {
   const training = await resolveTraining(client, input.projectId, input.nameOrId);
   const inputSet = await client.trainings.prepareCostEstimateInputs({
     trainingId: training.id,
@@ -511,33 +591,65 @@ export const estimateTrainingCost = async (
     exportIds.map((exportId) => client.waitFor({ type: "datasetExport", exportId })),
   );
 
-  const estimate = await client.trainings.estimateCost({
-    trainingId: training.id,
-    inputSetId: inputSet.id,
+  return {
+    training,
+    estimate: await client.trainings.estimateCost({
+      trainingId: training.id,
+      inputSetId: inputSet.id,
+    }),
+  };
+};
+
+export const estimateTrainingCost = async (
+  client: TrainingCostApi,
+  input: { projectId: string; nameOrId: string; idempotencyKey?: string; json: boolean },
+  io: TrainingIo,
+): Promise<void> => {
+  const { estimate } = await prepareTrainingCostEstimate(client, input);
+  assertCli(estimate.status === "ready", formatCostEstimate(estimate), {
+    hint: { description: "Fix the blocked issues above, then run toloka training cost again." },
   });
   writeOutput(io, input.json, estimate, formatCostEstimate(estimate));
 };
 
 export const createTrainingRun = async (
-  client: TrainingApi,
+  client: TrainingRunApi,
   input: {
     projectId: string;
     nameOrId: string;
-    estimateFile: string;
-    versionName: string;
+    estimateFile?: string;
+    versionName?: string;
     idempotencyKey?: string;
     json: boolean;
   },
   io: TrainingIo,
 ): Promise<void> => {
   const training = await resolveTraining(client, input.projectId, input.nameOrId);
-  const estimate = parseReadyEstimateFile(JSON.parse(await readFile(input.estimateFile, "utf8")));
-  assert(estimate.trainingId === training.id, "The estimate file belongs to another Training.");
+  const estimate = input.estimateFile
+    ? parseReadyEstimateFile(JSON.parse(await readFile(input.estimateFile, "utf8")))
+    : await (async () => {
+        const prepared = await prepareTrainingCostEstimate(client, {
+          projectId: input.projectId,
+          nameOrId: input.nameOrId,
+        });
+        assertCli(prepared.estimate.status === "ready", formatCostEstimate(prepared.estimate), {
+          hint: {
+            description: "Fix the blocked issues above, then run toloka training cost again.",
+          },
+        });
+        return parseReadyEstimateFile(prepared.estimate);
+      })();
+  assertCli(estimate.trainingId === training.id, "The estimate file belongs to another Training.", {
+    hint: {
+      description:
+        "Run toloka training cost <training> --json > <file> for this Training, get its maximumCharge approved, then re-run with that file.",
+    },
+  });
   const run = await client.trainings.createRun({
     trainingId: training.id,
     inputSetId: estimate.inputSetId,
     estimateFingerprint: estimate.fingerprint,
-    versionName: input.versionName,
+    versionName: input.versionName ?? training.name,
     idempotencyKey: input.idempotencyKey ?? randomUUID(),
   });
   writeOutput(io, input.json, run, formatTrainingRun(run));
@@ -625,3 +737,76 @@ export const readTrainingRunLogs = async (
     });
   }
 };
+
+const formatMetricValue = (point: {
+  value: number | null;
+  nonFinite: "nan" | "positive_infinity" | "negative_infinity" | null;
+}): string => {
+  if (point.nonFinite === "nan") return "NaN";
+  if (point.nonFinite === "positive_infinity") return "Infinity";
+  if (point.nonFinite === "negative_infinity") return "-Infinity";
+  return point.value === null ? "-" : String(point.value);
+};
+
+const METRICS_UNAVAILABLE: Record<"not_configured" | "unresolved", string> = {
+  not_configured:
+    "This Training Run has no metrics: it started before metrics were available, or the server records none.",
+  unresolved:
+    "Metrics are temporarily unreachable. The Training Run itself is unaffected; try again later.",
+};
+
+const formatTrainingRunMetrics = (metrics: TrainingRunMetrics): string => {
+  if (!metrics.available) {
+    return metrics.unavailableReason === null
+      ? "No metrics are available for this Training Run."
+      : METRICS_UNAVAILABLE[metrics.unavailableReason];
+  }
+  if (metrics.metrics.length === 0) return "No metrics have been reported yet.";
+
+  const rows = metrics.metrics.map((entry) => [
+    entry.key,
+    entry.metric ?? "-",
+    formatMetricValue(entry.latest),
+    String(entry.latest.step),
+  ]);
+  const table = formatTable([["Metric", "Meaning", "Latest", "Step"], ...rows]);
+  return metrics.truncated ? `${table}\n\nMore metrics exist than the server returns.` : table;
+};
+
+const formatTrainingRunMetricHistory = (history: TrainingRunMetricHistory): string => {
+  const header = formatTable([
+    ["Metric", history.key],
+    ["Meaning", history.metric ?? "-"],
+    ["Points", String(history.points.length)],
+  ]);
+  const points = formatTable([
+    ["Step", "Value"],
+    ...history.points.map((point) => [String(point.step), formatMetricValue(point)]),
+  ]);
+  const note = history.truncated
+    ? "\n\nNot every recorded point is shown: the series is thinned to fit --resolution, and a very long run keeps only its most recent points."
+    : "";
+  return `${header}\n\n${points}${note}`;
+};
+
+export const readTrainingRunMetrics = async (
+  client: TrainingApi,
+  input: { trainingRunId: string; json: boolean },
+  io: TrainingIo,
+): Promise<void> => {
+  const metrics = await client.trainings.getRunMetrics({ trainingRunId: input.trainingRunId });
+  writeOutput(io, input.json, metrics, formatTrainingRunMetrics(metrics));
+};
+
+export const readTrainingRunMetricHistory = async (
+  client: TrainingApi,
+  input: { trainingRunId: string; metricKey: string; resolution?: number; json: boolean },
+  io: TrainingIo,
+): Promise<void> => {
+  const history = await client.trainings.getRunMetricHistory({
+    trainingRunId: input.trainingRunId,
+    metricKey: input.metricKey,
+    resolution: input.resolution,
+  });
+  writeOutput(io, input.json, history, formatTrainingRunMetricHistory(history));
+};

package/src/cli/version.ts

@@ -2,8 +2,8 @@ import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve, sep } from "node:path";
 
-import { assert } from "es-toolkit";
-import { SDK_VERSION } from "./init";
+import { SDK_VERSION } from "./sdk-version";
+import { assertCli, REPORT_HINT } from "./cli-error";
 
 export type CliInstallChannel = "global-registry" | "linked" | "project-local";
 
@@ -36,7 +36,7 @@ const classifyInstallChannel = (
 };
 
 export const cliVersionInfo = (entryPath = process.argv[1], options: VersionInfoOptions = {}) => {
-  assert(entryPath, "CLI entry path is unavailable");
+  assertCli(entryPath, "CLI entry path is unavailable", { hint: REPORT_HINT });
   const globalBinDirectory =
     options.globalBinDirectory ??
     resolve(process.env.BUN_INSTALL ?? join(homedir(), ".bun"), "bin");

package/src/client.ts

@@ -25,6 +25,7 @@ import type {
   ImportPipelineBody,
   InferredField as GeneratedInferredField,
   GetTrainingRunLogsParams,
+  GetTrainingRunMetricHistoryParams,
   ListDatasetFieldsParams,
   ListModelVersionsParams,
   ListDatasetItemsParams,
@@ -45,6 +46,8 @@ import type {
   TrainingCostEstimate as GeneratedTrainingCostEstimate,
   TrainingCostEstimateInputSet as GeneratedTrainingCostEstimateInputSet,
   TrainingRun as GeneratedTrainingRun,
+  TrainingRunMetricHistory as GeneratedTrainingRunMetricHistory,
+  TrainingRunMetrics as GeneratedTrainingRunMetrics,
   TrainingRunLogs as GeneratedTrainingRunLogs,
   ReplaceTrainingConfigurationBody,
   UpdateTrainingMetadataBody,
@@ -164,6 +167,8 @@ export type TrainingCostEstimateInputSet = BrandedResource<
 export type TrainingCostEstimate = BrandResourceUnion<GeneratedTrainingCostEstimate>;
 export type TrainingRun = BrandedResource<GeneratedTrainingRun, TrainingRunId>;
 export type TrainingRunLogs = GeneratedTrainingRunLogs;
+export type TrainingRunMetrics = GeneratedTrainingRunMetrics;
+export type TrainingRunMetricHistory = GeneratedTrainingRunMetricHistory;
 export type BaseModel = GeneratedBaseModel;
 export type BaseModelId = GeneratedBaseModelId;
 export type Pipeline = BrandedResource<GeneratedPipeline, PipelineId>;
@@ -223,12 +228,6 @@ export type WaitForTarget =
 const createClientImplementation = (config: ClientConfig) => {
   const requestOptions = createRequestOptions(config.baseUrl, config.apiKey, config.fetch);
 
-  const emptyJsonRequestOptions = (): RequestInit => {
-    const headers = new Headers(requestOptions.headers);
-    headers.set("Content-Type", "application/json");
-    return { ...requestOptions, headers, body: "{}" };
-  };
-
   function waitFor(
     target: DatasetUploadWaitTarget,
     options?: WaitForOptions,
@@ -482,6 +481,14 @@ const createClientImplementation = (config: ClientConfig) => {
       ...params
     }: { trainingRunId: TrainingRunId } & GetTrainingRunLogsParams) =>
       wire.getTrainingRunLogs(trainingRunId, params, requestOptions),
+    getRunMetrics: ({ trainingRunId }: { trainingRunId: TrainingRunId }) =>
+      wire.getTrainingRunMetrics(trainingRunId, requestOptions),
+    getRunMetricHistory: ({
+      trainingRunId,
+      metricKey,
+      ...params
+    }: { trainingRunId: TrainingRunId; metricKey: string } & GetTrainingRunMetricHistoryParams) =>
+      wire.getTrainingRunMetricHistory(trainingRunId, metricKey, params, requestOptions),
   };
 
   const datasets = {
@@ -551,9 +558,9 @@ const createClientImplementation = (config: ClientConfig) => {
     startUpload: ({ datasetId, ...body }: { datasetId: DatasetId } & CreateDatasetUploadBody) =>
       wire.createDatasetUpload(datasetId, body, requestOptions),
     finalizeUpload: ({ uploadId }: { uploadId: UploadId }) =>
-      wire.finalizeDatasetUpload(uploadId, emptyJsonRequestOptions()),
+      wire.finalizeDatasetUpload(uploadId, requestOptions),
     cancelUpload: ({ uploadId }: { uploadId: UploadId }) =>
-      wire.cancelDatasetUpload(uploadId, emptyJsonRequestOptions()),
+      wire.cancelDatasetUpload(uploadId, requestOptions),
     getUpload: ({ uploadId }: { uploadId: UploadId }) =>
       wire.getDatasetUpload(uploadId, requestOptions),
     startExport: ({ datasetId, ...body }: { datasetId: DatasetId } & CreateDatasetExportBody) =>
@@ -564,7 +571,7 @@ const createClientImplementation = (config: ClientConfig) => {
 
   const runs = {
     start: ({ pipelineId }: { pipelineId: PipelineId }) =>
-      wire.createPipelineRun(pipelineId, emptyJsonRequestOptions()),
+      wire.createPipelineRun(pipelineId, requestOptions),
     get: ({ runId }: { runId: RunId }) => wire.getPipelineRun(runId, requestOptions),
     cancel: ({ runId }: { runId: RunId }) => wire.cancelPipelineRun(runId, requestOptions),
     listPage: ({ pipelineId, ...params }: { pipelineId: PipelineId } & ListPipelineRunsParams) =>
@@ -624,6 +631,10 @@ const createClientImplementation = (config: ClientConfig) => {
       wire.getPipelineCheck(checkRunId, requestOptions),
   };
 
+  const deliveryOrders = {
+    list: async () => (await wire.listDeliveryOrders(requestOptions)).deliveryOrders,
+  };
+
   return {
     me: () => wire.getCurrentUser(requestOptions),
     projects,
@@ -636,6 +647,7 @@ const createClientImplementation = (config: ClientConfig) => {
     secrets,
     files,
     checks,
+    deliveryOrders,
     waitFor,
   };
 };