@2kw/ai 6.3.0-dev.14 → 6.3.0-dev.144

package/dist/commands/conversations.js

@@ -98,6 +98,22 @@ export function makeConversationsCommand() {
             formatSuccess(`Conversation ${conversationId} deleted.`, command);
         });
     });
+    cmd
+        .command("cancel")
+        .description("Ask a running turn of a conversation to stop")
+        .argument("<conversationId>", "Conversation ID")
+        .requiredOption("--turn <turnId>", "The turn id the client sent as the Backbone-Turn-Id header")
+        .action(async (conversationId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.POST("/v1/conversations/{conversationId}/cancel", {
+                params: { path: { conversationId } },
+                body: { turn_id: opts.turn },
+            });
+            // Accepted, not performed: the turn's own response says whether it stopped.
+            formatSuccess(`Stop requested for turn ${opts.turn} of conversation ${conversationId}.`, command);
+        });
+    });
     const items = new Command("items").description("List a conversation's items");
     items
         .command("list")

package/dist/commands/datasets.js

@@ -3,6 +3,7 @@ import { getClient, runAction } from "../lib/client.js";
 import { resolveLatestVersionId } from "../lib/datasets.js";
 import { formatPage, formatDetail, formatList, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { assertNameNotBlank, overlay } from "../lib/overlay.js";
 import { makeDatasetVersionsCommand } from "./dataset-versions.js";
 export function makeDatasetsCommand() {
     const cmd = new Command("datasets").description("Manage datasets");
@@ -77,24 +78,25 @@ export function makeDatasetsCommand() {
         .option("--metadata <json>", "Metadata (JSON)")
         .action(async (id, opts, command) => {
         await runAction(command, async () => {
+            assertNameNotBlank(opts.name);
+            const changes = {
+                name: opts.name,
+                description: opts.description,
+                type: opts.type,
+                inputSchema: opts.inputSchema ? JSON.parse(opts.inputSchema) : undefined,
+                expectedOutputSchema: opts.expectedOutputSchema ? JSON.parse(opts.expectedOutputSchema) : undefined,
+                metadata: opts.metadata ? JSON.parse(opts.metadata) : undefined,
+            };
             const client = getClient(command);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const body = {};
-            if (opts.name)
-                body.name = opts.name;
-            if (opts.description !== undefined)
-                body.description = opts.description;
-            if (opts.type !== undefined)
-                body.type = opts.type;
-            if (opts.inputSchema)
-                body.inputSchema = JSON.parse(opts.inputSchema);
-            if (opts.expectedOutputSchema)
-                body.expectedOutputSchema = JSON.parse(opts.expectedOutputSchema);
-            if (opts.metadata)
-                body.metadata = JSON.parse(opts.metadata);
+            // PUT /v1/datasets/{id} replaces the whole dataset, so an omitted field would be stored as null.
+            const { data: current } = await client.GET("/v1/datasets/{id}", {
+                params: { path: { id } },
+            });
+            if (!current)
+                throw new Error(`Dataset ${id} could not be read.`);
             const { data } = await client.PUT("/v1/datasets/{id}", {
                 params: { path: { id } },
-                body: body,
+                body: overlay(current, changes),
             });
             formatDetail(data, command);
         });

package/dist/commands/experiments.js

@@ -5,6 +5,7 @@ import Table from "cli-table3";
 import { getClient, runAction } from "../lib/client.js";
 import { formatPage, formatDetail, formatList, formatSuccess, withSpinner } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { assertNameNotBlank, overlay } from "../lib/overlay.js";
 import { isJsonOutput } from "../lib/config.js";
 const TERMINAL_STATUSES = new Set(["COMPLETED", "FAILED"]);
 /** Summarize a single cell of the comparison matrix (a variant's result for one item). */
@@ -92,21 +93,24 @@ export function makeExperimentsCommand() {
         .option("--metadata <json>", "Metadata (JSON)")
         .action(async (id, opts, command) => {
         await runAction(command, async () => {
+            assertNameNotBlank(opts.name);
+            const changes = {
+                name: opts.name,
+                description: opts.description,
+                type: opts.type,
+                datasetVersionId: opts.datasetVersion,
+                metadata: opts.metadata ? JSON.parse(opts.metadata) : undefined,
+            };
             const client = getClient(command);
-            const body = {};
-            if (opts.name)
-                body.name = opts.name;
-            if (opts.description !== undefined)
-                body.description = opts.description;
-            if (opts.type !== undefined)
-                body.type = opts.type;
-            if (opts.datasetVersion !== undefined)
-                body.datasetVersionId = opts.datasetVersion;
-            if (opts.metadata)
-                body.metadata = JSON.parse(opts.metadata);
+            // PUT /v1/experiments/{id} replaces the whole experiment, so an omitted field would be stored as null.
+            const { data: current } = await client.GET("/v1/experiments/{id}", {
+                params: { path: { id } },
+            });
+            if (!current)
+                throw new Error(`Experiment ${id} could not be read.`);
             const { data } = await client.PUT("/v1/experiments/{id}", {
                 params: { path: { id } },
-                body: body,
+                body: overlay(current, changes),
             });
             formatDetail(data, command);
         });
@@ -131,7 +135,7 @@ export function makeExperimentsCommand() {
         .description("Add a variant to an experiment")
         .requiredOption("--experiment <id>", "Experiment ID")
         .requiredOption("-n, --name <name>", "Variant name")
-        .requiredOption("--task-type <type>", "Task type")
+        .requiredOption("--task-type <type>", "Task type: extraction or agent")
         .requiredOption("--config <json>", "Variant configuration (JSON)")
         .option("-d, --description <text>", "Variant description")
         .option("--sort-order <n>", "Sort order", parseInt)
@@ -179,27 +183,33 @@ export function makeExperimentsCommand() {
         .argument("<variantId>", "Variant ID")
         .requiredOption("--experiment <id>", "Experiment ID")
         .option("-n, --name <name>", "Variant name")
-        .option("--task-type <type>", "Task type")
+        .option("--task-type <type>", "Task type; must equal the variant's current one (it cannot change)")
         .option("--config <json>", "Variant configuration (JSON)")
         .option("-d, --description <text>", "Variant description")
         .option("--sort-order <n>", "Sort order", parseInt)
         .action(async (variantId, opts, command) => {
         await runAction(command, async () => {
+            assertNameNotBlank(opts.name);
+            const changes = {
+                name: opts.name,
+                taskType: opts.taskType,
+                configuration: opts.config ? JSON.parse(opts.config) : undefined,
+                description: opts.description,
+                sortOrder: opts.sortOrder,
+            };
             const client = getClient(command);
-            const body = {};
-            if (opts.name !== undefined)
-                body.name = opts.name;
-            if (opts.taskType !== undefined)
-                body.taskType = opts.taskType;
-            if (opts.config)
-                body.configuration = JSON.parse(opts.config);
-            if (opts.description !== undefined)
-                body.description = opts.description;
-            if (opts.sortOrder !== undefined)
-                body.sortOrder = opts.sortOrder;
+            // The variant PUT writes name, description and configuration as sent, so an omitted one would
+            // be cleared. There is no single-variant GET: read it from the list. The read's version goes
+            // back with the body, so a change made since is refused with 409.
+            const { data: variants } = await client.GET("/v1/experiments/{id}/variants", {
+                params: { path: { id: opts.experiment } },
+            });
+            const current = variants?.find((v) => v.id === variantId);
+            if (!current)
+                throw new Error(`Variant ${variantId} is not a variant of experiment ${opts.experiment}.`);
             const { data } = await client.PUT("/v1/experiments/{id}/variants/{variantId}", {
                 params: { path: { id: opts.experiment, variantId } },
-                body: body,
+                body: overlay(current, changes),
             });
             formatDetail(data, command);
         });

package/dist/commands/files.js

@@ -8,40 +8,22 @@ import { formatPage, formatDetail, formatSuccess, withSpinner } from "../lib/out
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
 import { fileToBlob } from "../lib/multipart.js";
 /**
- * Upload a single file with purpose=agent_input|knowledge. Bypasses the typed
- * client the same way convert.ts and transcribe.ts do: the generated types
- * describe the multipart body as an opaque `file: string`, which is not
- * something FormData can produce a match for.
+ * Upload a single file with purpose=agent_input|knowledge. The generated type
+ * describes the "file" part as a binary string, which FormData cannot match,
+ * so the placeholder body satisfies the type and bodySerializer sends the
+ * real part.
  */
 async function uploadFile(command, filePath, purpose) {
-    const config = resolveConfig(command);
-    const authHeader = await resolveAuthHeader(config);
     const { blob, filename } = fileToBlob(filePath);
     const formData = new FormData();
     formData.append("file", blob, filename);
-    const baseUrl = config.baseUrl.replace(/\/+$/, "");
-    const url = `${baseUrl}/v1/files?purpose=${encodeURIComponent(purpose)}`;
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { Authorization: authHeader },
-        body: formData,
+    const client = getClient(command);
+    const { data } = await client.POST("/v1/files", {
+        params: { query: { purpose } },
+        body: { file: "" },
+        bodySerializer: () => formData,
     });
-    if (!res.ok) {
-        let body;
-        try {
-            body = await res.json();
-        }
-        catch {
-            body = {
-                error: res.statusText,
-                message: `HTTP ${res.status}: ${res.statusText}`,
-                status: res.status,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        throw new BackboneApiError(body);
-    }
-    return (await res.json());
+    return data;
 }
 /** Stream a file's bytes from /v1/files/{fileId}/content via a raw fetch. */
 async function downloadFile(command, fileId) {

package/dist/commands/installations.js

@@ -1,7 +1,22 @@
 import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
+import { CliUsageError } from "../lib/errors.js";
 import { formatPage, formatDetail, formatList, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+const MIN_MONTHLY_PERCENT = 0;
+const MAX_MONTHLY_PERCENT = 1000;
+/**
+ * Validated inside the action rather than as commander's argument parser, so the refusal
+ * travels through `runAction` and exits 2 like every other usage error (see `parsePort` in
+ * connectors.ts).
+ */
+function parseMonthlyPercent(value) {
+    const percent = /^\d+$/.test(value) ? Number(value) : NaN;
+    if (!Number.isInteger(percent) || percent < MIN_MONTHLY_PERCENT || percent > MAX_MONTHLY_PERCENT) {
+        throw new CliUsageError(`percent must be a whole number between ${MIN_MONTHLY_PERCENT} and ${MAX_MONTHLY_PERCENT}, not '${value}'`);
+    }
+    return percent;
+}
 export function makeInstallationsCommand() {
     const cmd = new Command("installations").description("Manage surface installations");
     const list = new Command("list").description("List installations");
@@ -73,7 +88,7 @@ export function makeInstallationsCommand() {
                 body.status = opts.status;
             const { data } = await client.PUT("/v1/installations/{id}", {
                 params: { path: { id } },
-                body: body,
+                body,
             });
             formatDetail(data, command);
         });
@@ -172,6 +187,36 @@ export function makeInstallationsCommand() {
         });
     });
     cmd.addCommand(keys);
+    const budget = new Command("budget").description("Manage an installation's monthly budget: a share of the organisation's pool");
+    budget
+        .command("get")
+        .description("Read an installation's current budget: percent, period, and usage")
+        .argument("<id>", "Installation ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/installations/{id}/budget", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    budget
+        .command("set")
+        .description("Set or change an installation's monthly budget share, 0-1000 percent")
+        .argument("<id>", "Installation ID")
+        .argument("<percent>", "Monthly percent of the organisation's pool, 0-1000")
+        .action(async (id, percent, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/installations/{id}/budget", {
+                params: { path: { id } },
+                body: { monthlyPercent: parseMonthlyPercent(percent) },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(budget);
     return cmd;
 }
 //# sourceMappingURL=installations.js.map

package/dist/commands/knowledge-documents.js

@@ -1,49 +1,29 @@
 import { Command } from "commander";
 import chalk from "chalk";
-import { getClient, resolveAuthHeader, runAction } from "../lib/client.js";
-import { resolveConfig, isJsonOutput } from "../lib/config.js";
-import { BackboneApiError } from "../lib/errors.js";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
 import { formatPage, formatDetail, formatSuccess, withSpinner } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
 import { fileToBlob } from "../lib/multipart.js";
 /**
- * Upload one or more local files to a knowledge base. Bypasses the typed
- * client the same way convert.ts's multipartConvert does: springdoc mis-shapes
- * this endpoint's `files` parameter as a query array of binary strings, but the
- * controller (`KnowledgeDocumentController.upload`) actually reads it off a
- * multipart/form-data body with repeated "files" parts.
+ * Upload one or more local files to a knowledge base as repeated "files"
+ * parts of a multipart/form-data body. The generated type describes each part
+ * as a binary string, which FormData cannot match, so the placeholder body
+ * satisfies the type and bodySerializer sends the real parts.
  */
 async function uploadDocuments(command, knowledgeBaseId, paths) {
-    const config = resolveConfig(command);
-    const authHeader = await resolveAuthHeader(config);
     const formData = new FormData();
     for (const p of paths) {
         const { blob, filename } = fileToBlob(p);
         formData.append("files", blob, filename);
     }
-    const baseUrl = config.baseUrl.replace(/\/+$/, "");
-    const url = `${baseUrl}/v1/knowledge-bases/${encodeURIComponent(knowledgeBaseId)}/documents`;
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { Authorization: authHeader },
-        body: formData,
+    const client = getClient(command);
+    const { data } = await client.POST("/v1/knowledge-bases/{knowledgeBaseId}/documents", {
+        params: { path: { knowledgeBaseId } },
+        body: { files: [] },
+        bodySerializer: () => formData,
     });
-    if (!res.ok) {
-        let body;
-        try {
-            body = await res.json();
-        }
-        catch {
-            body = {
-                error: res.statusText,
-                message: `HTTP ${res.status}: ${res.statusText}`,
-                status: res.status,
-                timestamp: new Date().toISOString(),
-            };
-        }
-        throw new BackboneApiError(body);
-    }
-    return (await res.json());
+    return data ?? [];
 }
 function printUploadResults(results, command) {
     if (isJsonOutput(command)) {
@@ -119,6 +99,18 @@ export function makeKnowledgeDocumentsCommand() {
             formatDetail(data, command);
         });
     });
+    cmd
+        .command("retry")
+        .description("Re-ingest a document whose newest revision failed, from its stored file")
+        .argument("<documentId>", "Document ID")
+        .requiredOption("--kb <id>", "Knowledge base ID")
+        .action(async (documentId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/knowledge-bases/{knowledgeBaseId}/documents/{documentId}/retry", { params: { path: { knowledgeBaseId: opts.kb, documentId } } });
+            formatDetail(data, command);
+        });
+    });
     cmd
         .command("delete")
         .description("Delete a document and take every revision out of retrieval")

package/dist/commands/knowledge.js

@@ -47,6 +47,7 @@ export function makeKnowledgeCommand() {
         .option("--parent-chunk-size <n>", "Parent chunk size (hierarchical chunking)", parseInt)
         .option("--reranker-provider <id>", "Reranker provider ID")
         .option("--hybrid-search <bool>", "Enable hybrid search (true/false)")
+        .option("--text-search-language <name>", "Text-search language for the lexical leg (default simple)")
         .action(async (opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
@@ -64,6 +65,7 @@ export function makeKnowledgeCommand() {
                     parentChunkSize: opts.parentChunkSize,
                     rerankerProviderId: opts.rerankerProvider,
                     hybridSearchEnabled: opts.hybridSearch !== undefined ? opts.hybridSearch === "true" : undefined,
+                    textSearchLanguage: opts.textSearchLanguage,
                 },
             });
             formatDetail(data, command);
@@ -83,6 +85,7 @@ export function makeKnowledgeCommand() {
         .option("--parent-chunk-size <n>", "New parent chunk size", parseInt)
         .option("--reranker-provider <id>", "New reranker provider ID")
         .option("--hybrid-search <bool>", "Enable hybrid search (true/false)")
+        .option("--text-search-language <name>", "Change the text-search language (reindexes in the background); omit to leave it untouched")
         .action(async (id, opts, command) => {
         await runAction(command, async () => {
             const client = getClient(command);
@@ -107,6 +110,8 @@ export function makeKnowledgeCommand() {
                 body.rerankerProviderId = opts.rerankerProvider;
             if (opts.hybridSearch !== undefined)
                 body.hybridSearchEnabled = opts.hybridSearch === "true";
+            if (opts.textSearchLanguage)
+                body.textSearchLanguage = opts.textSearchLanguage;
             const { data } = await client.PATCH("/v1/knowledge-bases/{id}", {
                 params: { path: { id } },
                 body: body,

package/dist/commands/memory.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+/** The If-Match value for a version a GET returned: the quoted ETag the API expects. */
+export declare function ifMatchHeader(version: string): string;
+/**
+ * Agent memory (agent memory spec §7.1, §7.4). `ls`, `cat`, `put`, `rm` and `forget` act on
+ * the caller's own memory; `members` and `erase` are for ADMIN and OWNER and never show
+ * paths or content. Content is lossless: `cat` prints it raw, `put` sends the file as is.
+ */
+export declare function makeMemoryCommand(): Command;
+//# sourceMappingURL=memory.d.ts.map

package/dist/commands/memory.js

@@ -0,0 +1,132 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { CliUsageError } from "../lib/errors.js";
+import { formatDetail, formatList, formatSuccess } from "../lib/output.js";
+/** The If-Match value for a version a GET returned: the quoted ETag the API expects. */
+export function ifMatchHeader(version) {
+    if (!/^\d{1,18}$/.test(version)) {
+        throw new CliUsageError(`--if-match takes the file's version, a whole number: ${version}`);
+    }
+    return `"${version}"`;
+}
+function requireYes(opts, what) {
+    if (!opts.yes) {
+        throw new CliUsageError(`${what} cannot be undone. Pass --yes to confirm.`);
+    }
+}
+/**
+ * Agent memory (agent memory spec §7.1, §7.4). `ls`, `cat`, `put`, `rm` and `forget` act on
+ * the caller's own memory; `members` and `erase` are for ADMIN and OWNER and never show
+ * paths or content. Content is lossless: `cat` prints it raw, `put` sends the file as is.
+ */
+export function makeMemoryCommand() {
+    const cmd = new Command("memory").description("Your agent memory files; member totals and erasure for admins");
+    cmd
+        .command("ls")
+        .description("List your memory files")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/memories/me/files");
+            formatList(data, command, [
+                "path",
+                "sizeBytes",
+                "version",
+                "updatedAt",
+                "lastWrittenByAgentId",
+            ]);
+        });
+    });
+    cmd
+        .command("cat <path>")
+        .description("Print one of your memory files, raw (--json for the file object)")
+        .action(async (path, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/memories/me/file", {
+                params: { query: { path } },
+            });
+            if (isJsonOutput(command)) {
+                formatDetail(data, command);
+            }
+            else {
+                process.stdout.write(data.content);
+            }
+        });
+    });
+    cmd
+        .command("put <path>")
+        .description("Create or replace one of your memory files from a local UTF-8 file")
+        .requiredOption("--file <file>", "Local file whose content is stored")
+        .option("--if-match <version>", "Only replace the file if it still has this version")
+        .action(async (path, opts, command) => {
+        await runAction(command, async () => {
+            // An empty --if-match (e.g. an unset shell variable) must be refused, never dropped
+            // into an unconditional overwrite.
+            const headers = opts.ifMatch !== undefined ? { "If-Match": ifMatchHeader(opts.ifMatch) } : undefined;
+            const content = readFileSync(opts.file, "utf8");
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/memories/me/file", {
+                params: { query: { path } },
+                body: { content },
+                headers,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("rm <path>")
+        .description("Delete one of your memory files, or a directory with everything below it")
+        .action(async (path, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/memories/me/file", { params: { query: { path } } });
+            formatSuccess(`Deleted ${path}`, command);
+        });
+    });
+    cmd
+        .command("forget")
+        .description("Delete your whole memory (cannot be undone)")
+        .option("--yes", "Confirm")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            requireYes(opts, "Forgetting your whole memory");
+            const client = getClient(command);
+            await client.DELETE("/v1/memories/me");
+            formatSuccess("Forgot your whole memory", command);
+        });
+    });
+    cmd
+        .command("members")
+        .description("Memory totals per member, without paths or content (ADMIN+)")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/memories/users");
+            formatList(data, command, [
+                "userId",
+                "fileCount",
+                "totalBytes",
+                "lastUpdatedAt",
+            ]);
+        });
+    });
+    cmd
+        .command("erase <userId>")
+        .description("Erase a member's whole memory (ADMIN+, cannot be undone)")
+        .option("--yes", "Confirm")
+        .action(async (userId, opts, command) => {
+        await runAction(command, async () => {
+            requireYes(opts, "Erasing a member's memory");
+            const client = getClient(command);
+            await client.DELETE("/v1/memories/users/{userId}", {
+                params: { path: { userId } },
+            });
+            formatSuccess(`Erased the memory of ${userId}`, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=memory.js.map

package/dist/commands/prompts.js

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
 import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { assertNameNotBlank, overlay } from "../lib/overlay.js";
 import { makePromptVersionsCommand } from "./prompt-versions.js";
 import { makePromptLabelsCommand } from "./prompt-labels.js";
 export function makePromptsCommand() {
@@ -59,17 +60,17 @@ export function makePromptsCommand() {
         .option("--type <type>", "New type")
         .action(async (id, opts, command) => {
         await runAction(command, async () => {
+            assertNameNotBlank(opts.name);
             const client = getClient(command);
-            const body = {};
-            if (opts.name)
-                body.name = opts.name;
-            if (opts.description !== undefined)
-                body.description = opts.description;
-            if (opts.type !== undefined)
-                body.type = opts.type;
+            // PUT /v1/prompts/{id} replaces the whole prompt, so an omitted field would be stored as null.
+            const { data: current } = await client.GET("/v1/prompts/{id}", {
+                params: { path: { id } },
+            });
+            if (!current)
+                throw new Error(`Prompt ${id} could not be read.`);
             const { data } = await client.PUT("/v1/prompts/{id}", {
                 params: { path: { id } },
-                body: body,
+                body: overlay(current, { name: opts.name, description: opts.description, type: opts.type }),
             });
             formatDetail(data, command);
         });

package/dist/commands/schemas.js

@@ -58,15 +58,24 @@ export function makeSchemasCommand() {
         .option("-d, --description <text>", "New description")
         .action(async (id, opts, command) => {
         await runAction(command, async () => {
+            let name = opts.name;
+            let description = opts.description;
+            if (name !== undefined && !name.trim())
+                throw new Error("--name must not be empty.");
             const client = getClient(command);
-            const body = {};
-            if (opts.name)
-                body.name = opts.name;
-            if (opts.description !== undefined)
-                body.description = opts.description;
+            // PUT /v1/schemas/{id} replaces the whole schema, so an omitted field would be stored as null.
+            if (name === undefined || description === undefined) {
+                const { data: current } = await client.GET("/v1/schemas/{id}", {
+                    params: { path: { id } },
+                });
+                if (!current)
+                    throw new Error(`Schema ${id} could not be read.`);
+                name ??= current.name;
+                description ??= current.description;
+            }
             const { data } = await client.PUT("/v1/schemas/{id}", {
                 params: { path: { id } },
-                body: body,
+                body: { name, description },
             });
             formatDetail(data, command);
         });