dataiku-sdk 3.2.0 → 3.4.0

package/dist/src/resources/groups.d.ts

@@ -0,0 +1,47 @@
+import { BaseResource } from "./base.js";
+/**
+ * A DSS group as returned by the admin Security endpoints. The documented
+ * attributes below are stable; DSS may return undocumented extra attributes
+ * (per the API docs they must not be modified on update), so they are preserved
+ * under `Record<string, unknown>` and are never stripped by this SDK.
+ */
+export interface DssGroup extends Record<string, unknown> {
+    name?: string;
+    description?: string;
+    /** Whether this group gives administrative rights on DSS. */
+    admin?: boolean;
+    sourceType?: string;
+}
+/**
+ * Body of `POST /admin/groups` (create) and the editable subset of the PUT
+ * body. DSS requires `name` on create; `admin` and `description` are optional.
+ */
+export interface GroupCreateRequest extends Record<string, unknown> {
+    name: string;
+    description?: string;
+    admin?: boolean;
+}
+export declare class GroupsResource extends BaseResource {
+    /** Retrieves the list of DSS groups (Admin required). */
+    list(): Promise<DssGroup[]>;
+    /**
+     * Retrieves a Group object describing a DSS user group, used for access
+     * control on connections and projects (Admin required).
+     */
+    get(groupName: string): Promise<DssGroup>;
+    /**
+     * Creates a group (Admin required). DSS answers with
+     * `{msg: "Created group <name>"}`; the raw server record is returned as-is.
+     */
+    create(body: GroupCreateRequest): Promise<Record<string, unknown>>;
+    /**
+     * Updates a group (Admin required). Per the docs the body MUST have been
+     * obtained from a prior GET at the same URL; undocumented attributes should
+     * be passed through unmodified. DSS answers with `{msg: "Edited group ..."}`.
+     */
+    update(groupName: string, body: DssGroup): Promise<Record<string, unknown>>;
+    /** Deletes a DSS users group (Admin required). */
+    delete(groupName: string): Promise<{
+        deleted: string;
+    }>;
+}

package/dist/src/resources/groups.js

@@ -0,0 +1,56 @@
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, requireArrayResponse, requireNonEmpty, } from "./base.js";
+function validateGroupBody(body, method) {
+    if (body === null || body === undefined || typeof body !== "object" || Array.isArray(body)) {
+        throw new ClientValidationError(`${method}: body must be a Group object.`);
+    }
+    const record = body;
+    if (record.admin !== undefined && typeof record.admin !== "boolean") {
+        throw new ClientValidationError(`${method}: admin must be a boolean.`);
+    }
+    return record;
+}
+export class GroupsResource extends BaseResource {
+    /** Retrieves the list of DSS groups (Admin required). */
+    async list() {
+        const raw = await this.client.get("/public/api/admin/groups");
+        return requireArrayResponse(raw, "groups.list");
+    }
+    /**
+     * Retrieves a Group object describing a DSS user group, used for access
+     * control on connections and projects (Admin required).
+     */
+    async get(groupName) {
+        const enc = requireNonEmpty(groupName, "groupName").trim();
+        return this.client.get(`/public/api/admin/groups/${encodeURIComponent(enc)}`);
+    }
+    /**
+     * Creates a group (Admin required). DSS answers with
+     * `{msg: "Created group <name>"}`; the raw server record is returned as-is.
+     */
+    async create(body) {
+        if (body === null || body === undefined || typeof body !== "object" || Array.isArray(body)
+            || typeof body.name !== "string"
+            || body.name.trim().length === 0) {
+            throw new ClientValidationError("groups.create: body.name is required.");
+        }
+        validateGroupBody(body, "groups.create");
+        return this.client.post("/public/api/admin/groups", body);
+    }
+    /**
+     * Updates a group (Admin required). Per the docs the body MUST have been
+     * obtained from a prior GET at the same URL; undocumented attributes should
+     * be passed through unmodified. DSS answers with `{msg: "Edited group ..."}`.
+     */
+    async update(groupName, body) {
+        const enc = requireNonEmpty(groupName, "groupName").trim();
+        const validated = validateGroupBody(body, "groups.update");
+        return this.client.put(`/public/api/admin/groups/${encodeURIComponent(enc)}`, validated);
+    }
+    /** Deletes a DSS users group (Admin required). */
+    async delete(groupName) {
+        const enc = requireNonEmpty(groupName, "groupName").trim();
+        await this.client.del(`/public/api/admin/groups/${encodeURIComponent(enc)}`);
+        return { deleted: enc, };
+    }
+}

package/dist/src/resources/jobs.d.ts

@@ -1,6 +1,13 @@
 import type { BuildMode, JobSummary, JobWaitResult } from "../schemas.js";
 import { BaseResource } from "./base.js";
-export type JobBuildTargetType = "DATASET" | "MANAGED_FOLDER";
+/**
+ * Buildable target kinds. DATASET and MANAGED_FOLDER are user-selectable;
+ * MODEL_EVALUATION_STORE appears as a recipe output role and is a valid job
+ * target per the official client (recipe.run object_type_map maps
+ * COMPUTABLE_MODEL_EVALUATION_STORE to MODEL_EVALUATION_STORE before
+ * JobDefinition.with_output).
+ */
+export type JobBuildTargetType = "DATASET" | "MANAGED_FOLDER" | "MODEL_EVALUATION_STORE";
 export type JobLogFilter = "stdout" | "stderr" | "user" | "errors";
 export interface JobLogProgress {
     lastProgressLine?: string;
@@ -46,17 +53,6 @@ export interface JobBuildAndWaitOptions extends JobBuildOptions {
     logId?: string;
     summary?: boolean;
 }
-interface ComputeNextPollDelayMsOptions {
-    pollCount: number;
-    baseIntervalMs: number;
-    adaptiveEnabled: boolean;
-}
-/**
- * Compute the next poll delay.
- * When adaptive polling is enabled, the interval doubles every 3 polls,
- * capped at MAX_POLL_INTERVAL_MS (or baseIntervalMs if it's larger).
- */
-export declare function computeNextPollDelayMs({ pollCount, baseIntervalMs, adaptiveEnabled, }: ComputeNextPollDelayMsOptions): number;
 export declare function parseJobLogProgress(log: string, elapsedMs?: number): JobLogProgress | undefined;
 export declare class JobsResource extends BaseResource {
     /** List jobs in a project. */
@@ -146,4 +142,3 @@ export declare class JobsResource extends BaseResource {
     /** Request a job abort. */
     abort(jobId: string, projectKey?: string): Promise<void>;
 }
-export {};

package/dist/src/resources/jobs.js

@@ -1,8 +1,8 @@
 import { DataikuError, } from "../errors.js";
 import { JobSummaryArraySchema, } from "../schemas.js";
+import { computeNextPollDelayMs, isRequestDeadlineError, } from "../utils/polling.js";
 import { BaseResource, } from "./base.js";
 const DEFAULT_POLL_INTERVAL_MS = 2_000;
-const MAX_POLL_INTERVAL_MS = 10_000;
 const DEFAULT_TIMEOUT_MS = 120_000;
 const DEFAULT_MAX_LOG_LINES = 500;
 /**
@@ -26,19 +26,6 @@ function isTerminalState(state) {
 function isSuccessfulTerminalState(state) {
     return (state ?? "").toUpperCase() === "DONE";
 }
-/**
- * Compute the next poll delay.
- * When adaptive polling is enabled, the interval doubles every 3 polls,
- * capped at MAX_POLL_INTERVAL_MS (or baseIntervalMs if it's larger).
- */
-export function computeNextPollDelayMs({ pollCount, baseIntervalMs, adaptiveEnabled, }) {
-    if (!adaptiveEnabled) {
-        return baseIntervalMs;
-    }
-    const step = Math.max(0, Math.floor((pollCount - 1) / 3));
-    const interval = baseIntervalMs * 2 ** step;
-    return Math.min(interval, Math.max(baseIntervalMs, MAX_POLL_INTERVAL_MS));
-}
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -48,7 +35,10 @@ function jobBuildOutput(target, defaultProjectKey, defaultPartition, defaultTarg
     const projectKey = target.projectKey ?? defaultProjectKey;
     const partition = target.partition ?? defaultPartition;
     const output = { projectKey, id: target.id, type: targetType, };
-    if (targetType === "DATASET") {
+    if (targetType === "DATASET" || targetType === "MODEL_EVALUATION_STORE") {
+        // MES targets follow the plain {projectKey, id, type} shape (official
+        // JobDefinition.with_output sends the name/id plus object type, with no
+        // managed-folder indirection).
         if (partition !== undefined)
             output.partition = partition;
     }
@@ -294,12 +284,73 @@ export class JobsResource extends BaseResource {
         const jobEnc = encodeURIComponent(jobId);
         const baseIntervalMs = Math.max(1, opts?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
         const adaptivePolling = opts?.pollIntervalMs === undefined;
+        // Pre-existing contract: the effective budget is never below one poll
+        // interval, so a single observation always fits inside it.
         const timeout = Math.max(baseIntervalMs, opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS);
         const startedAt = Date.now();
         let pollCount = 0;
+        let lastJ;
         while (true) {
+            const elapsedBeforeMs = Date.now() - startedAt;
+            // The first observation always happens, even when the budget is
+            // already spent. A later poll is never started after the deadline:
+            // the loop reports the structured timeout from the last observed
+            // state instead of issuing a request the budget cannot cover.
+            if (lastJ !== undefined && elapsedBeforeMs >= timeout) {
+                const bs = lastJ.baseStatus ?? {};
+                const def = bs.def ?? {};
+                const gs = lastJ.globalState ?? {};
+                return {
+                    success: false,
+                    jobId,
+                    state: bs.state ?? "unknown",
+                    type: def.type ?? "unknown",
+                    elapsedMs: elapsedBeforeMs,
+                    pollCount,
+                    timedOut: true,
+                    progress: {
+                        done: gs.done ?? 0,
+                        failed: gs.failed ?? 0,
+                        running: gs.running ?? 0,
+                        total: gs.total ?? null,
+                    },
+                };
+            }
             pollCount += 1;
-            const j = await this.client.get(`/public/api/projects/${projectEnc}/jobs/${jobEnc}/`);
+            // Requests issued while budget remains are bounded by the remaining
+            // time; a spent budget still issues exactly one transport attempt
+            // (no retries, client requestTimeoutMs cap) so the first observation
+            // reaches the server instead of failing before any attempt.
+            const remainingMs = timeout - elapsedBeforeMs;
+            let j;
+            try {
+                j = await this.client.get(`/public/api/projects/${projectEnc}/jobs/${jobEnc}/`, remainingMs > 0
+                    ? { timeoutMs: remainingMs, }
+                    : { noRetry: true, });
+            }
+            catch (error) {
+                // The poll budget ran out mid-request: report the documented
+                // structured timeout instead of letting the transport deadline
+                // error escape the loop.
+                if (!isRequestDeadlineError(error, startedAt + timeout))
+                    throw error;
+                return {
+                    success: false,
+                    jobId,
+                    state: "unknown",
+                    type: "unknown",
+                    elapsedMs: Date.now() - startedAt,
+                    pollCount,
+                    timedOut: true,
+                    progress: {
+                        done: 0,
+                        failed: 0,
+                        running: 0,
+                        total: null,
+                    },
+                };
+            }
+            lastJ = j;
             const bs = j.baseStatus ?? {};
             const def = bs.def ?? {};
             const gs = j.globalState ?? {};
@@ -362,24 +413,10 @@ export class JobsResource extends BaseResource {
                     ...(removed !== undefined ? { removed, } : {}),
                 };
             }
-            // Timeout — return failure result, don't throw
-            if (elapsedMs >= timeout) {
-                return {
-                    success: false,
-                    jobId,
-                    state,
-                    type: def.type ?? "unknown",
-                    elapsedMs,
-                    pollCount,
-                    timedOut: true,
-                    progress: {
-                        done: gs.done ?? 0,
-                        failed: gs.failed ?? 0,
-                        running: gs.running ?? 0,
-                        total: gs.total ?? null,
-                    },
-                };
-            }
+            // Timeout — the guard at the top of the loop returns the failure
+            // result from this observation without issuing another request.
+            if (elapsedMs >= timeout)
+                continue;
             const nextDelayMs = computeNextPollDelayMs({
                 pollCount,
                 baseIntervalMs,

package/dist/src/resources/knowledge-banks.d.ts

@@ -0,0 +1,58 @@
+import { BaseResource } from "./base.js";
+/** Search algorithm for knowledge-bank search, per the DSS 15 REST schema. */
+export type KnowledgeBankSearchType = "SIMILARITY" | "SIMILARITY_THRESHOLD" | "MMR" | "HYBRID" | (string & {});
+/**
+ * Optional search parameters, documented in the DSS 15 REST reference for
+ * `POST /projects/{projectKey}/knowledge-banks/{knowledgeBankId}/search`.
+ * Which knobs apply depends on the backing vector store.
+ */
+export interface KnowledgeBankSearchParams {
+    /** Maximum number of documents to return (default 10). */
+    maxDocuments?: number;
+    /** Search algorithm. Defaults to SIMILARITY. */
+    searchType?: KnowledgeBankSearchType;
+    /** Similarity threshold; only applied for SIMILARITY_THRESHOLD. */
+    similarityThreshold?: number;
+    /** Documents considered before selection; only applied for MMR. */
+    mmrK?: number;
+    /** 0..1 balance of diversity (0) vs relevancy (1); only applied for MMR. */
+    mmrDiversity?: number;
+    /** Proprietary rerankers; only valid for Azure AI and ElasticSearch stores. */
+    useAdvancedReranking?: boolean;
+    /** Weight of lower-ranked documents; only valid for ElasticSearch stores. */
+    rrfRankConstant?: number;
+    /** Documents considered per search type; only valid for ElasticSearch stores. */
+    rrfRankWindowSize?: number;
+    [key: string]: unknown;
+}
+/** Request body for knowledge-bank search. */
+export interface KnowledgeBankSearchBody {
+    query: string;
+    params?: KnowledgeBankSearchParams;
+}
+/** One retrieved knowledge-bank document. Metadata is server-defined. */
+export interface KnowledgeBankDocument extends Record<string, unknown> {
+    /** Document text content. */
+    text?: string;
+    /** Arbitrary server-defined metadata map. */
+    metadata?: Record<string, unknown>;
+    /** Relevance score in [0, 1] as returned by the backend. */
+    score?: number;
+}
+/** Response envelope of the knowledge-bank search endpoint. */
+export interface KnowledgeBankSearchResult extends Record<string, unknown> {
+    documents?: KnowledgeBankDocument[];
+}
+export declare class KnowledgeBanksResource extends BaseResource {
+    /**
+     * Search a knowledge bank for documents matching a query string.
+     * Requires READ_CONF.
+     */
+    search(knowledgeBankId: string, body: KnowledgeBankSearchBody, projectKey?: string): Promise<KnowledgeBankSearchResult>;
+    /**
+     * Clear all data from a knowledge bank. DESTRUCTIVE: the stored knowledge
+     * bank content is removed and cannot be recovered from this call. Requires
+     * WRITE_CONF.
+     */
+    clear(knowledgeBankId: string, projectKey?: string): Promise<void>;
+}

package/dist/src/resources/knowledge-banks.js

@@ -0,0 +1,61 @@
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, requireNonEmpty, } from "./base.js";
+export class KnowledgeBanksResource extends BaseResource {
+    /**
+     * Search a knowledge bank for documents matching a query string.
+     * Requires READ_CONF.
+     */
+    async search(knowledgeBankId, body, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(knowledgeBankId, "knowledgeBankId"));
+        const payload = validateKnowledgeBankSearchBody(body);
+        return this.client.post(`/public/api/projects/${this.enc(projectKey)}/knowledge-banks/${id}/search`, payload);
+    }
+    /**
+     * Clear all data from a knowledge bank. DESTRUCTIVE: the stored knowledge
+     * bank content is removed and cannot be recovered from this call. Requires
+     * WRITE_CONF.
+     */
+    async clear(knowledgeBankId, projectKey) {
+        const id = encodeURIComponent(requireNonEmpty(knowledgeBankId, "knowledgeBankId"));
+        await this.client.post(`/public/api/projects/${this.enc(projectKey)}/knowledge-banks/${id}/clear`, {});
+    }
+}
+/**
+ * Validate a knowledge-bank search body on the client boundary: `query` must
+ * be a non-empty string and `params`, when present, an object. Documented
+ * params are checked for type; unknown fields pass through untouched.
+ */
+function validateKnowledgeBankSearchBody(body) {
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        throw new ClientValidationError("knowledgeBanks.search body must be an object with a query string.");
+    }
+    const query = requireNonEmpty(body.query, "query");
+    const payload = { query, };
+    const params = body.params;
+    if (params !== undefined) {
+        if (params === null || typeof params !== "object" || Array.isArray(params)) {
+            throw new ClientValidationError("knowledgeBanks.search params must be an object.");
+        }
+        const searchParams = { ...params, };
+        validateSearchParamNumber(searchParams, "maxDocuments");
+        validateSearchParamNumber(searchParams, "similarityThreshold");
+        validateSearchParamNumber(searchParams, "mmrK");
+        validateSearchParamNumber(searchParams, "mmrDiversity");
+        validateSearchParamNumber(searchParams, "rrfRankConstant");
+        validateSearchParamNumber(searchParams, "rrfRankWindowSize");
+        const reranking = searchParams["useAdvancedReranking"];
+        if (reranking !== undefined && typeof reranking !== "boolean") {
+            throw new ClientValidationError("knowledgeBanks.search params.useAdvancedReranking must be a boolean.");
+        }
+        payload["params"] = searchParams;
+    }
+    return payload;
+}
+function validateSearchParamNumber(params, name) {
+    const value = params[name];
+    if (value === undefined)
+        return;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new ClientValidationError(`knowledgeBanks.search params.${name} must be a finite number.`);
+    }
+}

package/dist/src/resources/llms.d.ts

@@ -0,0 +1,92 @@
+import { BaseResource } from "./base.js";
+/**
+ * Usage purpose of an LLM as documented in the DSS 15 REST reference
+ * (`GET /projects/{projectKey}/llms/{?purpose}`). The list is open: DSS
+ * versions may add purposes, so unknown server-provided values stay usable.
+ */
+export type LlmPurpose = "GENERIC_COMPLETION" | "TEXT_EMBEDDING_EXTRACTION" | "IMAGE_GENERATION" | (string & {});
+/** One entry of the LLM list endpoint. The rest of the object is server-defined. */
+export interface LlmDescriptor extends Record<string, unknown> {
+    /** Fully-qualified LLM id, e.g. `openai:openai1:gpt-4`. Contains colons. */
+    id?: string;
+    /** Backend type, e.g. `OPENAI`, `BEDROCK`, `HUGGINGFACE_TRANSFORMER_LOCAL`. */
+    type?: string;
+    /** DSS connection backing the LLM, e.g. `openai1`. */
+    connection?: string;
+    /** Model name as configured on the connection. */
+    model?: string;
+    /** True when the LLM supports prompt-based interactions. */
+    promptDriven?: boolean;
+}
+/** Per-query settings block documented for the completions endpoint. */
+export interface LlmCompletionSettings {
+    temperature?: number;
+    maxOutputTokens?: number;
+    topP?: number;
+    [key: string]: unknown;
+}
+/**
+ * One completions query. The documented shape is a chat `messages` array; the
+ * full documented request field set (roles, contents) is server-defined, so
+ * the object is left open rather than fake-strictly modeled.
+ */
+export interface LlmCompletionQuery extends Record<string, unknown> {
+    messages?: Array<Record<string, unknown>>;
+}
+/** One embeddings query. `text` is the documented input field. */
+export interface LlmEmbeddingQuery extends Record<string, unknown> {
+    text?: string;
+}
+/** One completion result. Fields are the documented stable set plus extras. */
+export interface LlmCompletionResponse extends Record<string, unknown> {
+    ok?: boolean;
+    text?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    /** Cost estimate in cost units, per DSS LLM Mesh accounting. */
+    estimatedCost?: number;
+}
+/** One embedding result. Fields are the documented stable set plus extras. */
+export interface LlmEmbeddingResponse extends Record<string, unknown> {
+    ok?: boolean;
+    /** Embedding vector as returned by the backend. */
+    embedding?: number[];
+    promptTokens?: number;
+    estimatedCost?: number;
+}
+/** Response envelope of the completions endpoint. */
+export interface LlmCompletionsResult extends Record<string, unknown> {
+    responses?: LlmCompletionResponse[];
+}
+/** Response envelope of the embeddings endpoint. */
+export interface LlmEmbeddingsResult extends Record<string, unknown> {
+    responses?: LlmEmbeddingResponse[];
+}
+export declare class LlmsResource extends BaseResource {
+    /**
+     * List the LLMs available in a project, including Retrieval-Augmented
+     * Generation ones. Requires READ_CONF.
+     */
+    list(options?: {
+        purpose?: LlmPurpose;
+        projectKey?: string;
+    }): Promise<LlmDescriptor[]>;
+    /**
+     * Perform completions on an LLM. This call is cost-bearing: it invokes an
+     * external LLM provider and may incur charges.
+     */
+    completions(body: {
+        llmId: string;
+        queries: LlmCompletionQuery[];
+        settings?: LlmCompletionSettings;
+    }, projectKey?: string): Promise<LlmCompletionsResult>;
+    /**
+     * Perform embeddings on an LLM. This call is cost-bearing: it invokes an
+     * external LLM provider and may incur charges.
+     */
+    embeddings(body: {
+        llmId: string;
+        queries: LlmEmbeddingQuery[];
+    }, projectKey?: string): Promise<LlmEmbeddingsResult>;
+}

package/dist/src/resources/llms.js

@@ -0,0 +1,62 @@
+import { ClientValidationError, } from "../errors.js";
+import { BaseResource, requireNonEmpty, } from "./base.js";
+export class LlmsResource extends BaseResource {
+    /**
+     * List the LLMs available in a project, including Retrieval-Augmented
+     * Generation ones. Requires READ_CONF.
+     */
+    async list(options = {}) {
+        const params = new URLSearchParams();
+        if (options.purpose !== undefined) {
+            params.set("purpose", requireNonEmpty(options.purpose, "purpose"));
+        }
+        const query = params.size > 0 ? `?${params.toString()}` : "";
+        return this.client.get(`/public/api/projects/${this.enc(options.projectKey)}/llms/${query}`);
+    }
+    /**
+     * Perform completions on an LLM. This call is cost-bearing: it invokes an
+     * external LLM provider and may incur charges.
+     */
+    async completions(body, projectKey) {
+        const payload = validateLlmInferenceBody(body, "completions");
+        return this.client.post(`/public/api/projects/${this.enc(projectKey)}/llms/completions`, payload);
+    }
+    /**
+     * Perform embeddings on an LLM. This call is cost-bearing: it invokes an
+     * external LLM provider and may incur charges.
+     */
+    async embeddings(body, projectKey) {
+        const payload = validateLlmInferenceBody(body, "embeddings");
+        return this.client.post(`/public/api/projects/${this.enc(projectKey)}/llms/embeddings`, payload);
+    }
+}
+/**
+ * Validate a completions/embeddings request body on the client boundary:
+ * `llmId` must be a non-empty string and `queries` a non-empty array of
+ * objects. Unknown documented fields pass through untouched.
+ */
+function validateLlmInferenceBody(body, action) {
+    if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        throw new ClientValidationError(`llms.${action} body must be an object with llmId and queries.`);
+    }
+    const llmId = requireNonEmpty(body.llmId, "llmId");
+    if (!Array.isArray(body.queries) || body.queries.length === 0) {
+        throw new ClientValidationError(`llms.${action} queries must be a non-empty array of query objects.`, "validation_failed", 'Pass at least one query, e.g. queries: [{ messages: [...] }] for completions or [{ text: "..." }] for embeddings.');
+    }
+    for (const [index, query,] of body.queries.entries()) {
+        if (query === null || typeof query !== "object" || Array.isArray(query)) {
+            throw new ClientValidationError(`llms.${action} queries[${index}] must be an object.`);
+        }
+    }
+    const payload = {
+        llmId,
+        queries: body.queries,
+    };
+    if (body.settings !== undefined) {
+        if (body.settings === null || typeof body.settings !== "object" || Array.isArray(body.settings)) {
+            throw new ClientValidationError("llms.completions settings must be an object.");
+        }
+        payload["settings"] = body.settings;
+    }
+    return payload;
+}