@toloka-platform/sdk 0.1.0-preview.5 → 0.1.0-preview.6

package/src/cli/models.ts

@@ -0,0 +1,188 @@
+import { assert } from "es-toolkit";
+
+import type { BaseModel, BaseModelId, Model, ModelVersion, PotatoClient } from "../client";
+
+type ModelApi = Pick<PotatoClient, "baseModels" | "models">;
+type ModelIo = { readonly stdout: (text: string) => void };
+type TableRow = readonly string[];
+
+const BASE_MODEL_IDS = [
+  "qwen3-4b",
+  "qwen3-8b",
+  "qwen3-32b",
+  "qwen3-235b",
+] satisfies readonly BaseModelId[];
+
+const formatTable = (rows: readonly TableRow[]): string => {
+  const widths = rows.reduce<number[]>(
+    (current, row) => row.map((cell, index) => Math.max(current[index] ?? 0, cell.length)),
+    [],
+  );
+  return rows
+    .map((row) =>
+      row
+        .map((cell, index) => cell.padEnd(widths[index] ?? cell.length))
+        .join("  ")
+        .trimEnd(),
+    )
+    .join("\n");
+};
+
+const writeOutput = (io: ModelIo, json: boolean, value: unknown, formatted: string): void => {
+  io.stdout(json ? JSON.stringify(value, null, 2) : formatted);
+};
+
+const formatBaseModel = (model: BaseModel): string =>
+  formatTable([
+    ["ID", model.id],
+    ["Name", model.displayName],
+    ["Provider", model.provider],
+    ["Upstream model", model.upstreamModel],
+    ["Upstream revision", model.upstreamRevision],
+  ]);
+
+const formatModel = (model: Model): string =>
+  formatTable([
+    ["ID", model.id],
+    ["Project", model.projectId],
+    ["Name", model.name],
+    ["Base model", model.baseModelId],
+    ["Description", model.description ?? "-"],
+    ["Archived at", model.archivedAt ?? "-"],
+    ["Created at", model.createdAt],
+    ["Updated at", model.updatedAt],
+  ]);
+
+export const parseBaseModelId = (value: string): BaseModelId => {
+  const modelId = BASE_MODEL_IDS.find((candidate) => candidate === value);
+  assert(modelId, `Unknown base model ${value}.`);
+  return modelId;
+};
+
+const resolveModel = async (
+  client: ModelApi,
+  projectId: string,
+  nameOrId: string,
+): Promise<Model> => {
+  if (nameOrId.startsWith("mdl.")) return client.models.get({ projectId, modelId: nameOrId });
+  const matches: Model[] = [];
+  for await (const model of client.models.listAll({ projectId, limit: 100 })) {
+    if (model.name === nameOrId) matches.push(model);
+  }
+  assert(matches.length === 1, `Model ${nameOrId} was not found or is ambiguous.`);
+  return matches[0]!;
+};
+
+export const listBaseModels = async (
+  client: ModelApi,
+  input: { json: boolean },
+  io: ModelIo,
+): Promise<void> => {
+  const models = await client.baseModels.list();
+  writeOutput(
+    io,
+    input.json,
+    models,
+    models.length === 0
+      ? "No base models found."
+      : formatTable([
+          ["ID", "NAME", "PROVIDER", "UPSTREAM MODEL"],
+          ...models.map((model) => [
+            model.id,
+            model.displayName,
+            model.provider,
+            model.upstreamModel,
+          ]),
+        ]),
+  );
+};
+
+export const getBaseModel = async (
+  client: ModelApi,
+  input: { id: BaseModelId; json: boolean },
+  io: ModelIo,
+): Promise<void> => {
+  const model = await client.baseModels.get({ id: input.id });
+  writeOutput(io, input.json, model, formatBaseModel(model));
+};
+
+export const listModels = async (
+  client: ModelApi,
+  input: { projectId: string; json: boolean },
+  io: ModelIo,
+): Promise<void> => {
+  const page = await client.models.listPage({ projectId: input.projectId, limit: 100, offset: 0 });
+  writeOutput(
+    io,
+    input.json,
+    page.models,
+    page.models.length === 0
+      ? "No models found."
+      : formatTable([
+          ["ID", "NAME", "BASE MODEL"],
+          ...page.models.map((model) => [model.id, model.name, model.baseModelId]),
+        ]),
+  );
+};
+
+export const getModel = async (
+  client: ModelApi,
+  input: { projectId: string; nameOrId: string; json: boolean },
+  io: ModelIo,
+): Promise<void> => {
+  const model = await resolveModel(client, input.projectId, input.nameOrId);
+  writeOutput(io, input.json, model, formatModel(model));
+};
+
+export const listModelVersions = async (
+  client: ModelApi,
+  input: { projectId: string; nameOrId: string; json: boolean },
+  io: ModelIo,
+): Promise<void> => {
+  const model = await resolveModel(client, input.projectId, input.nameOrId);
+  const versions: ModelVersion[] = [];
+  for await (const version of client.models.listAllVersions({
+    projectId: input.projectId,
+    modelId: model.id,
+    limit: 100,
+  })) {
+    versions.push(version);
+  }
+  writeOutput(
+    io,
+    input.json,
+    versions,
+    versions.length === 0
+      ? "No Model Versions found."
+      : formatTable([
+          ["VERSION", "ID", "CREATED AT"],
+          ...versions.map((version) => [version.version, version.id, version.createdAt]),
+        ]),
+  );
+};
+
+export const createModel = async (
+  client: ModelApi,
+  input: {
+    projectId: string;
+    name: string;
+    description?: string;
+    baseModelId: BaseModelId;
+    json: boolean;
+  },
+  io: ModelIo,
+): Promise<void> => {
+  const { json, ...body } = input;
+  const model = await client.models.create(body);
+  writeOutput(io, json, model, formatModel(model));
+};
+
+export const archiveModel = async (
+  client: ModelApi,
+  input: { projectId: string; nameOrId: string; json: boolean },
+  io: ModelIo,
+): Promise<void> => {
+  const model = await resolveModel(client, input.projectId, input.nameOrId);
+  const archived = await client.models.archive({ projectId: input.projectId, modelId: model.id });
+  writeOutput(io, input.json, archived, `Archived Model ${archived.id}.`);
+};

package/src/cli/program.ts

@@ -33,6 +33,16 @@ import {
   projectStatus,
   validateProject,
 } from "./project";
+import {
+  archiveModel,
+  createModel,
+  getBaseModel,
+  getModel,
+  listBaseModels,
+  listModels,
+  listModelVersions,
+  parseBaseModelId,
+} from "./models";
 import {
   MISSING_PROJECT_ID_MESSAGE,
   addProject,
@@ -533,6 +543,94 @@ export function createProgram(context: ProgramContext): CreatedProgram {
       }
     });
 
+  const baseModel = program
+    .command("base-model")
+    .description("inspect the global base model catalog");
+  baseModel
+    .command("list")
+    .option("--json", "print JSON", false)
+    .description("list base models")
+    .action(async (options: { json: boolean }) => {
+      const { client } = await resolveContext(globals(), context);
+      await listBaseModels(client, { json: options.json }, context.io);
+    });
+  baseModel
+    .command("get")
+    .argument("<id>", "base model ID")
+    .option("--json", "print JSON", false)
+    .description("show one base model")
+    .action(async (id: string, options: { json: boolean }) => {
+      const { client } = await resolveContext(globals(), context);
+      await getBaseModel(client, { id: parseBaseModelId(id), json: options.json }, context.io);
+    });
+
+  const model = program
+    .command("model")
+    .description("manage project Models and immutable versions");
+  model
+    .command("list")
+    .option("--json", "print JSON", false)
+    .description("list Models owned by the selected project")
+    .action(async (options: { json: boolean }) => {
+      const { client, projectId } = await resolveContext(globals(), context);
+      assert(projectId, MISSING_PROJECT_ID_MESSAGE);
+      await listModels(client, { projectId, json: options.json }, context.io);
+    });
+  model
+    .command("get")
+    .argument("<name-or-id>", "project Model name or ID")
+    .option("--json", "print JSON", false)
+    .description("show one project Model")
+    .action(async (nameOrId: string, options: { json: boolean }) => {
+      const { client, projectId } = await resolveContext(globals(), context);
+      assert(projectId, MISSING_PROJECT_ID_MESSAGE);
+      await getModel(client, { projectId, nameOrId, json: options.json }, context.io);
+    });
+  model
+    .command("versions")
+    .argument("<name-or-id>", "project Model name or ID")
+    .option("--json", "print JSON", false)
+    .description("list immutable versions of a model")
+    .action(async (nameOrId: string, options: { json: boolean }) => {
+      const { client, projectId } = await resolveContext(globals(), context);
+      assert(projectId, MISSING_PROJECT_ID_MESSAGE);
+      await listModelVersions(client, { projectId, nameOrId, json: options.json }, context.io);
+    });
+  model
+    .command("create")
+    .argument("<name>", "new Model name")
+    .requiredOption("--base <id>", "base model ID")
+    .option("--description <text>", "Model description")
+    .option("--json", "print JSON", false)
+    .description("create project Model metadata without a Model Version")
+    .action(
+      async (name: string, options: { base: string; description?: string; json: boolean }) => {
+        const { client, projectId } = await resolveContext(globals(), context);
+        assert(projectId, MISSING_PROJECT_ID_MESSAGE);
+        await createModel(
+          client,
+          {
+            projectId,
+            name,
+            description: options.description,
+            baseModelId: parseBaseModelId(options.base),
+            json: options.json,
+          },
+          context.io,
+        );
+      },
+    );
+  model
+    .command("archive")
+    .option("--json", "print JSON", false)
+    .argument("<name-or-id>", "project Model name or ID")
+    .description("archive a project Model")
+    .action(async (nameOrId: string, options: { json: boolean }) => {
+      const { client, projectId } = await resolveContext(globals(), context);
+      assert(projectId, MISSING_PROJECT_ID_MESSAGE);
+      await archiveModel(client, { projectId, nameOrId, json: options.json }, context.io);
+    });
+
   const dataset = program
     .command("dataset")
     .description("inspect and move dataset catalog and rows");
@@ -580,7 +678,7 @@ export function createProgram(context: ProgramContext): CreatedProgram {
   dataset
     .command("upload")
     .argument("<name>", "dataset name or id")
-    .argument("<file>", "JSONL file, one JSON object per line")
+    .argument("<file>", "JSON array, JSONL, or CSV file")
     .description("append rows to a dataset")
     .action(async (name: string, file: string) => {
       const { sourceRoot, client, projectId } = await resolveContext(globals(), context);

package/src/client.ts

@@ -8,6 +8,7 @@ import type {
   CopyPipelineBody,
   CreateDatasetBody,
   CreateDatasetExportBody,
+  CreateProjectModelBody,
   CreateDatasetFieldBodyAnyOf,
   CreateDatasetUploadBody,
   CreatePipelineCheckBody,
@@ -21,13 +22,17 @@ import type {
   ImportPipelineBody,
   InferredField as GeneratedInferredField,
   ListDatasetFieldsParams,
+  ListModelVersionsParams,
   ListDatasetItemsParams,
   ListPipelineRunItemsParams,
   ListPipelineRunsParams,
   ListProjectDatasetsParams,
   ListProjectPipelinesParams,
+  ListProjectModelsParams,
   ListProjectsParams,
   Pipeline as GeneratedPipeline,
+  Model as GeneratedModel,
+  ModelVersion as GeneratedModelVersion,
   PatchPipelineNodeBody,
   PipelineGraphSnapshot,
   Project as GeneratedProject,
@@ -38,6 +43,8 @@ import type {
   RunJob as GeneratedRunJob,
   RunSummary as GeneratedRunSummary,
   SetProjectSecretBody,
+  BaseModel as GeneratedBaseModel,
+  BaseModelId as GeneratedBaseModelId,
   UpdatePipelineBody,
   UpdateProjectBody,
   UploadJob as GeneratedUploadJob,
@@ -57,6 +64,8 @@ export type DatasetFieldId = Branded<string, "DatasetFieldId">;
 export type DatasetId = Branded<string, "DatasetId">;
 export type DatasetItemId = Branded<string, "DatasetItemId">;
 export type ExportId = Branded<string, "ExportId">;
+export type ModelId = Branded<string, "ModelId">;
+export type ModelVersionId = Branded<string, "ModelVersionId">;
 export type PipelineId = Branded<string, "PipelineId">;
 export type ProjectFileId = Branded<string, "ProjectFileId">;
 export type ProjectId = Branded<string, "ProjectId">;
@@ -76,6 +85,8 @@ type ResourceIdsByProperty = {
   exportId: ExportId;
   fieldId: DatasetFieldId;
   fileId: ProjectFileId;
+  modelId: ModelId;
+  modelVersionId: ModelVersionId;
   goldenDatasetId: DatasetId;
   itemId: RunItemId;
   pipelineId: PipelineId;
@@ -121,6 +132,10 @@ export type DatasetField = BrandedResource<GeneratedDatasetField, DatasetFieldId
 export type DatasetItem = BrandedResource<GeneratedDatasetItem, DatasetItemId>;
 export type ExportJob = BrandedResource<GeneratedExportJob, ExportId>;
 export type InferredField = GeneratedInferredField;
+export type Model = BrandedResource<GeneratedModel, ModelId>;
+export type ModelVersion = BrandedResource<GeneratedModelVersion, ModelVersionId>;
+export type BaseModel = GeneratedBaseModel;
+export type BaseModelId = GeneratedBaseModelId;
 export type Pipeline = BrandedResource<GeneratedPipeline, PipelineId>;
 export type Project = BrandedResource<GeneratedProject, ProjectId>;
 export type ProjectFile = BrandedResource<GeneratedProjectFile, ProjectFileId>;
@@ -178,6 +193,12 @@ 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,
@@ -296,6 +317,56 @@ const createClientImplementation = (config: ClientConfig) => {
       wire.copyPipeline(pipelineId, body, requestOptions),
   };
 
+  const baseModels = {
+    list: async () => (await wire.listBaseModels(requestOptions)).baseModels,
+    get: ({ id }: { id: BaseModelId }) => wire.getBaseModel(id, requestOptions),
+  };
+
+  const models = {
+    listPage: ({ projectId, ...params }: { projectId: ProjectId } & ListProjectModelsParams) =>
+      wire.listProjectModels(projectId, params, requestOptions),
+    listAll: ({ projectId, ...params }: { projectId: ProjectId } & ListProjectModelsParams) =>
+      listAllPages(async (pageOptions) => {
+        const page = await wire.listProjectModels(
+          projectId,
+          { ...params, ...pageOptions },
+          requestOptions,
+        );
+        return { items: page.models, pagination: page.pagination };
+      }, params),
+    get: ({ projectId, modelId }: { projectId: ProjectId; modelId: ModelId }) =>
+      wire.getProjectModel(projectId, modelId, requestOptions),
+    listVersionsPage: ({
+      projectId,
+      modelId,
+      ...params
+    }: { projectId: ProjectId; modelId: ModelId } & ListModelVersionsParams) =>
+      wire.listModelVersions(projectId, modelId, params, requestOptions),
+    listAllVersions: ({
+      projectId,
+      modelId,
+      ...params
+    }: { projectId: ProjectId; modelId: ModelId } & ListModelVersionsParams) =>
+      listAllPages(async (pageOptions) => {
+        const page = await wire.listModelVersions(
+          projectId,
+          modelId,
+          { ...params, ...pageOptions },
+          requestOptions,
+        );
+        return { items: page.versions, pagination: page.pagination };
+      }, params),
+    create: ({ projectId, ...body }: { projectId: ProjectId } & CreateProjectModelBody) =>
+      wire.createProjectModel(projectId, body, requestOptions),
+    getVersion: ({ modelVersionId }: { modelVersionId: ModelVersionId }) =>
+      wire.getModelVersion(modelVersionId, requestOptions),
+    archive: ({ projectId, modelId }: { projectId: ProjectId; modelId: ModelId }) => {
+      const headers = new Headers(requestOptions.headers);
+      headers.set("Content-Type", "application/json");
+      return wire.archiveProjectModel(projectId, modelId, { ...requestOptions, headers });
+    },
+  };
+
   const datasets = {
     create: ({ projectId, ...body }: { projectId: ProjectId } & CreateDatasetBody) =>
       wire.createDataset(projectId, body, requestOptions),
@@ -363,7 +434,9 @@ const createClientImplementation = (config: ClientConfig) => {
     startUpload: ({ datasetId, ...body }: { datasetId: DatasetId } & CreateDatasetUploadBody) =>
       wire.createDatasetUpload(datasetId, body, requestOptions),
     finalizeUpload: ({ uploadId }: { uploadId: UploadId }) =>
-      wire.finalizeDatasetUpload(uploadId, requestOptions),
+      wire.finalizeDatasetUpload(uploadId, emptyJsonRequestOptions()),
+    cancelUpload: ({ uploadId }: { uploadId: UploadId }) =>
+      wire.cancelDatasetUpload(uploadId, emptyJsonRequestOptions()),
     getUpload: ({ uploadId }: { uploadId: UploadId }) =>
       wire.getDatasetUpload(uploadId, requestOptions),
     startExport: ({ datasetId, ...body }: { datasetId: DatasetId } & CreateDatasetExportBody) =>
@@ -373,15 +446,8 @@ const createClientImplementation = (config: ClientConfig) => {
   };
 
   const runs = {
-    start: ({ pipelineId }: { pipelineId: PipelineId }) => {
-      const headers = new Headers(requestOptions.headers);
-      headers.set("Content-Type", "application/json");
-      return wire.createPipelineRun(pipelineId, {
-        ...requestOptions,
-        headers,
-        body: "{}",
-      });
-    },
+    start: ({ pipelineId }: { pipelineId: PipelineId }) =>
+      wire.createPipelineRun(pipelineId, emptyJsonRequestOptions()),
     get: ({ runId }: { runId: RunId }) => wire.getPipelineRun(runId, requestOptions),
     cancel: ({ runId }: { runId: RunId }) => wire.cancelPipelineRun(runId, requestOptions),
     listPage: ({ pipelineId, ...params }: { pipelineId: PipelineId } & ListPipelineRunsParams) =>
@@ -446,6 +512,8 @@ const createClientImplementation = (config: ClientConfig) => {
     projects,
     pipelines,
     datasets,
+    baseModels,
+    models,
     runs,
     secrets,
     files,
@@ -462,31 +530,37 @@ type PublicOutput<T> = T extends GeneratedCheckJob
       ? ExportJob
       : T extends GeneratedUploadJob
         ? UploadJob
-        : T extends GeneratedProject
-          ? Project
-          : T extends GeneratedPipeline
-            ? Pipeline
-            : T extends GeneratedDataset
-              ? Dataset
-              : T extends GeneratedDatasetField
-                ? DatasetField
-                : T extends GeneratedDatasetItem
-                  ? DatasetItem
-                  : T extends GeneratedProjectFile
-                    ? ProjectFile
-                    : T extends GeneratedRunItem
-                      ? RunItem
-                      : T extends GeneratedRunSummary
-                        ? RunSummary
-                        : T extends Promise<infer Value>
-                          ? Promise<PublicOutput<Value>>
-                          : T extends AsyncGenerator<infer Value, infer Return, infer Next>
-                            ? AsyncGenerator<PublicOutput<Value>, PublicOutput<Return>, Next>
-                            : T extends readonly unknown[]
-                              ? { [K in keyof T]: PublicOutput<T[K]> }
-                              : T extends object
-                                ? { [K in keyof T]: PublicOutput<T[K]> }
-                                : T;
+        : T extends GeneratedModel
+          ? Model
+          : T extends GeneratedModelVersion
+            ? ModelVersion
+            : T extends GeneratedProject
+              ? Project
+              : T extends GeneratedPipeline
+                ? Pipeline
+                : T extends GeneratedDataset
+                  ? Dataset
+                  : T extends GeneratedDatasetField
+                    ? DatasetField
+                    : T extends GeneratedDatasetItem
+                      ? DatasetItem
+                      : T extends GeneratedProjectFile
+                        ? ProjectFile
+                        : T extends GeneratedRunItem
+                          ? RunItem
+                          : T extends GeneratedRunSummary
+                            ? RunSummary
+                            : T extends Blob
+                              ? Blob
+                              : T extends Promise<infer Value>
+                                ? Promise<PublicOutput<Value>>
+                                : T extends AsyncGenerator<infer Value, infer Return, infer Next>
+                                  ? AsyncGenerator<PublicOutput<Value>, PublicOutput<Return>, Next>
+                                  : T extends readonly unknown[]
+                                    ? { [K in keyof T]: PublicOutput<T[K]> }
+                                    : T extends object
+                                      ? { [K in keyof T]: PublicOutput<T[K]> }
+                                      : T;
 
 type PublicClientMember<T> = T extends (...args: infer Args) => infer Result
   ? (...args: { [K in keyof Args]: PublicInput<Args[K]> }) => PublicOutput<Result>

package/src/errors.ts

@@ -1,28 +1,43 @@
-export type PotatoApiErrorCode = 'http' | 'wait_timeout';
+export type PotatoApiErrorCode = "http" | "wait_timeout";
 
 export class PotatoApiError extends Error {
   readonly code: PotatoApiErrorCode;
   readonly status: number | undefined;
   readonly body: unknown;
+  readonly requestId: string | undefined;
 
-  private constructor(message: string, code: PotatoApiErrorCode, status: number | undefined, body: unknown) {
+  private constructor(
+    message: string,
+    code: PotatoApiErrorCode,
+    status: number | undefined,
+    body: unknown,
+    requestId?: string,
+  ) {
     super(message);
-    this.name = 'PotatoApiError';
+    this.name = "PotatoApiError";
     this.code = code;
     this.status = status;
     this.body = body;
+    this.requestId = requestId;
   }
 
-  static fromResponse(status: number, body: unknown) {
-    return new PotatoApiError(`Potato API request failed with status ${status}`, 'http', status, body);
+  static fromResponse(status: number, body: unknown, requestId?: string) {
+    const requestSuffix = requestId === undefined ? "" : ` (request id: ${requestId})`;
+    return new PotatoApiError(
+      `Potato API request failed with status ${status}${requestSuffix}`,
+      "http",
+      status,
+      body,
+      requestId,
+    );
   }
 
   static waitTimeout(timeoutMs: number) {
     return new PotatoApiError(
       `Potato API job did not reach a terminal status within ${timeoutMs} ms`,
-      'wait_timeout',
+      "wait_timeout",
       undefined,
-      { timeoutMs }
+      { timeoutMs },
     );
   }
 }
@@ -33,17 +48,17 @@ export type PipelineGraphValidationIssue = {
 };
 
 export class PipelineGraphValidationError extends Error {
-  readonly code = 'invalid_pipeline_graph';
+  readonly code = "invalid_pipeline_graph";
   readonly issues: readonly PipelineGraphValidationIssue[];
 
   private constructor(message: string, issues: readonly PipelineGraphValidationIssue[]) {
     super(message);
-    this.name = 'PipelineGraphValidationError';
+    this.name = "PipelineGraphValidationError";
     this.issues = issues;
   }
 
   static fromIssues(issues: readonly PipelineGraphValidationIssue[]) {
-    const details = issues.map(({ path, reason }) => `- ${path}: ${reason}`).join('\n');
+    const details = issues.map(({ path, reason }) => `- ${path}: ${reason}`).join("\n");
     return new PipelineGraphValidationError(`Pipeline graph validation failed\n${details}`, issues);
   }
 }

package/src/transport.ts

@@ -1,7 +1,7 @@
-import { assert } from 'es-toolkit';
-import { PotatoApiError } from './errors';
+import { assert } from "es-toolkit";
+import { PotatoApiError } from "./errors";
 
-const BASE_URL_HEADER = 'x-potato-sdk-base-url';
+const BASE_URL_HEADER = "x-potato-sdk-base-url";
 
 type TransportRequestInit = RequestInit & {
   readonly fetch?: typeof globalThis.fetch;
@@ -10,18 +10,18 @@ type TransportRequestInit = RequestInit & {
 export const createRequestOptions = (
   baseUrl: string,
   apiKey: string,
-  fetch?: typeof globalThis.fetch
+  fetch?: typeof globalThis.fetch,
 ): TransportRequestInit => {
-  assert(baseUrl.length > 0, 'The SDK base URL cannot be empty');
-  assert(apiKey.length > 0, 'The SDK API key cannot be empty');
+  assert(baseUrl.length > 0, "The SDK base URL cannot be empty");
+  assert(apiKey.length > 0, "The SDK API key cannot be empty");
 
   return {
     headers: {
-      Accept: 'application/json',
+      Accept: "application/json",
       Authorization: `ApiKey ${apiKey}`,
-      [BASE_URL_HEADER]: new URL(baseUrl).toString()
+      [BASE_URL_HEADER]: new URL(baseUrl).toString(),
     },
-    fetch
+    fetch,
   };
 };
 
@@ -30,7 +30,7 @@ export async function potatoFetch(url: string, options: TransportRequestInit): P
   const { fetch: fetchImplementation = globalThis.fetch, ...requestOptions } = options;
   const headers = new Headers(requestOptions.headers);
   const baseUrl = headers.get(BASE_URL_HEADER);
-  assert(baseUrl, 'The SDK base URL is missing');
+  assert(baseUrl, "The SDK base URL is missing");
   headers.delete(BASE_URL_HEADER);
 
   const response = await fetchImplementation(new URL(url, baseUrl), { ...requestOptions, headers });
@@ -41,13 +41,16 @@ export async function potatoFetch(url: string, options: TransportRequestInit): P
 
     if (text.length === 0) {
       body = undefined;
-    } else if (response.headers.get('content-type')?.includes('application/json')) {
+    } else if (response.headers.get("content-type")?.includes("application/json")) {
       body = JSON.parse(text);
     }
 
-    throw PotatoApiError.fromResponse(response.status, body);
+    throw PotatoApiError.fromResponse(
+      response.status,
+      body,
+      response.headers.get("x-request-id") ?? undefined,
+    );
   }
 
   return text.length === 0 ? undefined : JSON.parse(text);
 }
-