@2kw/ai 6.0.0-dev.4 → 6.1.0-dev.7

package/dist/commands/installations.js

@@ -0,0 +1,177 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatPage, formatDetail, formatList, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+export function makeInstallationsCommand() {
+    const cmd = new Command("installations").description("Manage surface installations");
+    const list = new Command("list").description("List installations");
+    addPaginationOptions(list);
+    list.option("-s, --search <term>", "Filter by name");
+    list.option("--status <status>", "Filter by status (PENDING, ACTIVE, DISABLED)");
+    list.option("--agent-id <id>", "Only installations of this agent");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/installations", {
+                params: {
+                    query: {
+                        search: opts.search,
+                        status: opts.status,
+                        agentId: opts.agentId,
+                        ...paginationParams(opts),
+                    },
+                },
+            });
+            formatPage(data, command, ["id", "name", "agentId", "status", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get an installation by ID")
+        .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}", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Register an installation. Returns a one-time pairing string/code for the host to redeem at POST /v1/surface/enrol")
+        .requiredOption("-n, --name <name>", "Installation name")
+        .requiredOption("--agent-id <id>", "Agent this installation embeds")
+        .option("-d, --description <text>", "Description")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/installations", {
+                body: { name: opts.name, agentId: opts.agentId, description: opts.description },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update an installation's name, description, or status")
+        .argument("<id>", "Installation ID")
+        .option("-n, --name <name>", "New name")
+        .option("-d, --description <text>", "New description")
+        .option("--status <status>", "New status (PENDING, ACTIVE, DISABLED)")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.description !== undefined)
+                body.description = opts.description;
+            if (opts.status)
+                body.status = opts.status;
+            const { data } = await client.PUT("/v1/installations/{id}", {
+                params: { path: { id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("embed-config")
+        .description("Read the unauthenticated embed configuration for an installation")
+        .argument("<id>", "Installation ID")
+        .option("--agent <agentId>", "Also resolve this agent's display name")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/installations/{id}/embed-config", {
+                params: { path: { id }, query: { agent: opts.agent } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("pairing-code")
+        .description("Issue a fresh pairing code for an installation, valid ten minutes")
+        .argument("<id>", "Installation ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/installations/{id}/pairing-code", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    const origins = new Command("origins").description("Manage an installation's embed origins");
+    origins
+        .command("replace")
+        .description("Replace the whole list of origins allowed to frame the embeddable panel")
+        .argument("<id>", "Installation ID")
+        .requiredOption("--origins <origins...>", "Origins allowed to embed (empty list revokes all)")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/installations/{id}/origins", {
+                params: { path: { id } },
+                body: { origins: opts.origins },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(origins);
+    const keys = new Command("keys").description("Manage an installation's Ed25519 verification keys");
+    keys
+        .command("list")
+        .description("List every verification key registered for an installation")
+        .requiredOption("--installation <id>", "Installation ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/installations/{id}/keys", {
+                params: { path: { id: opts.installation } },
+            });
+            formatList(data, command, [
+                "kid",
+                "publicKeyBase64",
+                "createdAt",
+                "revokedAt",
+            ]);
+        });
+    });
+    keys
+        .command("create")
+        .description("Register the public half of an Ed25519 keypair generated on the installation host")
+        .requiredOption("--installation <id>", "Installation ID")
+        .requiredOption("--kid <kid>", "Key id stamped into assertion headers")
+        .requiredOption("--public-key <base64>", "Public key, base64-encoded")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/installations/{id}/keys", {
+                params: { path: { id: opts.installation } },
+                body: { kid: opts.kid, publicKeyBase64: opts.publicKey },
+            });
+            formatDetail(data, command);
+        });
+    });
+    keys
+        .command("delete")
+        .description("Revoke a verification key so it can no longer verify new assertions")
+        .argument("<kid>", "Key id")
+        .requiredOption("--installation <id>", "Installation ID")
+        .action(async (kid, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/installations/{id}/keys/{kid}", {
+                params: { path: { id: opts.installation, kid } },
+            });
+            formatSuccess(`Key ${kid} revoked.`, command);
+        });
+    });
+    cmd.addCommand(keys);
+    return cmd;
+}
+//# sourceMappingURL=installations.js.map

package/dist/commands/knowledge-documents.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeKnowledgeDocumentsCommand(): Command;
+//# sourceMappingURL=knowledge-documents.d.ts.map

package/dist/commands/knowledge-documents.js

@@ -0,0 +1,155 @@
+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 { 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.
+ */
+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,
+    });
+    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());
+}
+function printUploadResults(results, command) {
+    if (isJsonOutput(command)) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    for (const r of results) {
+        if (r.error) {
+            console.log(chalk.red(`  ${r.filename ?? "(unknown)"}: rejected — ${r.error}`));
+        }
+        else {
+            const docId = r.upload?.document?.id;
+            const status = r.upload?.acceptedVersion?.status ?? "PENDING";
+            console.log(chalk.green(`  ${r.filename ?? "(unknown)"}: accepted (document ${docId}, ${status})`));
+        }
+    }
+}
+export function makeKnowledgeDocumentsCommand() {
+    const cmd = new Command("documents").description("Manage a knowledge base's documents");
+    const list = new Command("list").description("List documents in a knowledge base");
+    addPaginationOptions(list);
+    list.requiredOption("--kb <id>", "Knowledge base ID");
+    list.option("--status <status>", "Filter by status (PENDING, PARSING, CHUNKING, EMBEDDING, READY, ERROR)");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/knowledge-bases/{knowledgeBaseId}/documents", {
+                params: {
+                    path: { knowledgeBaseId: opts.kb },
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    query: { status: opts.status, ...paginationParams(opts) },
+                },
+            });
+            formatPage(data, command, ["id", "name", "currentVersionId", "sourceUri"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a document by ID")
+        .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.GET("/v1/knowledge-bases/{knowledgeBaseId}/documents/{documentId}", { params: { path: { knowledgeBaseId: opts.kb, documentId } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("upload")
+        .description("Upload one or more files for asynchronous ingestion")
+        .argument("<paths...>", "Local file paths")
+        .requiredOption("--kb <id>", "Knowledge base ID")
+        .action(async (paths, opts, command) => {
+        await runAction(command, async () => {
+            const results = await withSpinner("Uploading...", () => uploadDocuments(command, opts.kb, paths));
+            printUploadResults(results, command);
+        });
+    });
+    cmd
+        .command("attach")
+        .description("Ingest a file uploaded earlier with purpose=knowledge")
+        .requiredOption("--kb <id>", "Knowledge base ID")
+        .requiredOption("--file-id <id>", "File ID (from `2kw files upload --purpose knowledge`)")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/knowledge-bases/{knowledgeBaseId}/documents/attach", {
+                params: { path: { knowledgeBaseId: opts.kb } },
+                body: { fileId: opts.fileId },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a document and take every revision out of retrieval")
+        .argument("<documentId>", "Document ID")
+        .requiredOption("--kb <id>", "Knowledge base ID")
+        .action(async (documentId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/knowledge-bases/{knowledgeBaseId}/documents/{documentId}", { params: { path: { knowledgeBaseId: opts.kb, documentId } } });
+            formatSuccess(`Document ${documentId} deleted.`, command);
+        });
+    });
+    const versions = new Command("versions").description("Inspect a document's revisions");
+    versions
+        .command("get")
+        .description("Get a specific document revision")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--kb <id>", "Knowledge base ID")
+        .requiredOption("--document <id>", "Document ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/knowledge-bases/{knowledgeBaseId}/documents/{documentId}/versions/{versionId}", {
+                params: {
+                    path: { knowledgeBaseId: opts.kb, documentId: opts.document, versionId },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(versions);
+    return cmd;
+}
+//# sourceMappingURL=knowledge-documents.js.map

package/dist/commands/knowledge.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeKnowledgeCommand(): Command;
+//# sourceMappingURL=knowledge.d.ts.map

package/dist/commands/knowledge.js

@@ -0,0 +1,197 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { formatPage, formatDetail, formatList, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { makeKnowledgeDocumentsCommand } from "./knowledge-documents.js";
+export function makeKnowledgeCommand() {
+    const cmd = new Command("knowledge").description("Manage knowledge bases");
+    const list = new Command("list").description("List knowledge bases");
+    addPaginationOptions(list);
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/knowledge-bases", {
+                params: { query: paginationParams(opts) },
+            });
+            formatPage(data, command, ["id", "name", "slug", "embeddingModel", "status", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a knowledge base by ID")
+        .argument("<id>", "Knowledge base ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/knowledge-bases/{id}", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a knowledge base and its first configuration version")
+        .requiredOption("-n, --name <name>", "Knowledge base name")
+        .requiredOption("--slug <slug>", "Unique slug")
+        .requiredOption("--embedding-provider <id>", "Embedding provider ID")
+        .requiredOption("--embedding-model <model>", "Embedding model")
+        .requiredOption("--embedding-dim <n>", "Embedding dimension", parseInt)
+        .option("-d, --description <text>", "Description")
+        .option("--chunking-strategy <strategy>", "Chunking strategy (AUTO, FIXED, HIERARCHICAL, CUSTOM)")
+        .option("--chunk-size <n>", "Chunk size", parseInt)
+        .option("--chunk-overlap <n>", "Chunk overlap", parseInt)
+        .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)")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/knowledge-bases", {
+                body: {
+                    name: opts.name,
+                    slug: opts.slug,
+                    embeddingProviderId: opts.embeddingProvider,
+                    embeddingModel: opts.embeddingModel,
+                    embeddingDim: opts.embeddingDim,
+                    description: opts.description,
+                    chunkingStrategy: opts.chunkingStrategy,
+                    chunkSize: opts.chunkSize,
+                    chunkOverlap: opts.chunkOverlap,
+                    parentChunkSize: opts.parentChunkSize,
+                    rerankerProviderId: opts.rerankerProvider,
+                    hybridSearchEnabled: opts.hybridSearch !== undefined ? opts.hybridSearch === "true" : undefined,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Apply mutable fields and snapshot the result as the next configuration version")
+        .argument("<id>", "Knowledge base ID")
+        .option("-n, --name <name>", "New name")
+        .option("-d, --description <text>", "New description")
+        .option("--embedding-provider <id>", "New embedding provider ID")
+        .option("--embedding-model <model>", "New embedding model")
+        .option("--chunking-strategy <strategy>", "New chunking strategy (AUTO, FIXED, HIERARCHICAL, CUSTOM)")
+        .option("--chunk-size <n>", "New chunk size", parseInt)
+        .option("--chunk-overlap <n>", "New chunk overlap", parseInt)
+        .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)")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.description !== undefined)
+                body.description = opts.description;
+            if (opts.embeddingProvider)
+                body.embeddingProviderId = opts.embeddingProvider;
+            if (opts.embeddingModel)
+                body.embeddingModel = opts.embeddingModel;
+            if (opts.chunkingStrategy)
+                body.chunkingStrategy = opts.chunkingStrategy;
+            if (opts.chunkSize !== undefined)
+                body.chunkSize = opts.chunkSize;
+            if (opts.chunkOverlap !== undefined)
+                body.chunkOverlap = opts.chunkOverlap;
+            if (opts.parentChunkSize !== undefined)
+                body.parentChunkSize = opts.parentChunkSize;
+            if (opts.rerankerProvider)
+                body.rerankerProviderId = opts.rerankerProvider;
+            if (opts.hybridSearch !== undefined)
+                body.hybridSearchEnabled = opts.hybridSearch === "true";
+            const { data } = await client.PATCH("/v1/knowledge-bases/{id}", {
+                params: { path: { id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Soft-delete a knowledge base, releasing its slug (requires admin role)")
+        .argument("<id>", "Knowledge base ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/knowledge-bases/{id}", {
+                params: { path: { id } },
+            });
+            formatSuccess(`Knowledge base ${id} deleted.`, command);
+        });
+    });
+    cmd
+        .command("search")
+        .description("Hybrid dense + lexical search over a knowledge base")
+        .argument("<knowledgeBaseId>", "Knowledge base ID")
+        .requiredOption("-q, --query <text>", "Search query")
+        .option("--top-k <n>", "Number of results (clamped 1..100)", parseInt)
+        .option("--metadata-filter <json>", "Metadata filter as JSON")
+        .action(async (knowledgeBaseId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/knowledge-bases/{knowledgeBaseId}/search", {
+                params: { path: { knowledgeBaseId } },
+                body: {
+                    query: opts.query,
+                    topK: opts.topK,
+                    metadataFilter: opts.metadataFilter ? JSON.parse(opts.metadataFilter) : undefined,
+                },
+            });
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const result = data;
+            if (result?.degraded) {
+                console.log(chalk.yellow(`Degraded: ${result.degraded}`));
+            }
+            formatList(result?.hits, command, ["documentName", "pageStart", "pageEnd", "score", "content"]);
+        });
+    });
+    const citations = new Command("citations").description("Resolve knowledge-base citations");
+    citations
+        .command("get")
+        .description("Resolve the passage a citation points at")
+        .argument("<chunkId>", "Chunk ID")
+        .requiredOption("--kb <id>", "Knowledge base ID")
+        .action(async (chunkId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/knowledge-bases/{knowledgeBaseId}/citations/{chunkId}", { params: { path: { knowledgeBaseId: opts.kb, chunkId } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(citations);
+    cmd
+        .command("embedding-models")
+        .description("List embedding models a provider serves that fit a provisioned dimension")
+        .argument("<providerId>", "Provider ID")
+        .action(async (providerId, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/providers/{providerId}/embedding-models", {
+                params: { path: { providerId } },
+            });
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(data, null, 2));
+                return;
+            }
+            const result = data;
+            formatList(result?.models, command, ["id", "dimensions"]);
+            if (result?.supportedDimensions?.length) {
+                console.log(chalk.dim(`Supported dimensions: ${result.supportedDimensions.join(", ")}`));
+            }
+        });
+    });
+    cmd.addCommand(makeKnowledgeDocumentsCommand());
+    return cmd;
+}
+//# sourceMappingURL=knowledge.js.map

package/dist/commands/prompt-versions.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
-import { formatPage, formatDetail } from "../lib/output.js";
+import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
 export function makePromptVersionsCommand() {
     const cmd = new Command("versions").description("Manage prompt versions");
@@ -32,6 +32,29 @@ export function makePromptVersionsCommand() {
             formatDetail(data, command);
         });
     });
+    cmd
+        .command("latest")
+        .description("Get the latest version of a prompt")
+        .requiredOption("--prompt <id>", "Prompt ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/prompts/{promptId}/versions/latest", { params: { path: { promptId: opts.prompt } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete (deactivate) a prompt version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--prompt <id>", "Prompt ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/prompts/{promptId}/versions/{versionId}", { params: { path: { promptId: opts.prompt, versionId } } });
+            formatSuccess(`Prompt version ${versionId} deleted.`, command);
+        });
+    });
     cmd
         .command("create")
         .description("Create a new prompt version")

package/dist/commands/providers.js

@@ -88,6 +88,44 @@ export function makeProvidersCommand() {
             formatSuccess(`Provider ${id} deleted.`, command);
         });
     });
+    cmd
+        .command("all")
+        .description("List all providers, unpaginated")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/providers/all");
+            formatList(data, command, [
+                "id",
+                "name",
+                "provider",
+                "enabled",
+                "createdAt",
+            ]);
+        });
+    });
+    cmd
+        .command("test")
+        .description("Test connection to an AI provider using given or stored credentials")
+        .requiredOption("--type <type>", "Provider type (openai, azure_openai, anthropic, xai, mistral, vertex_ai, ollama)")
+        .option("--provider-api-key <key>", "API key to test (omit to use --provider-id's stored key)")
+        .option("--provider-id <id>", "Existing provider ID whose stored credentials should be used")
+        .option("-c, --config <json>", "Provider config as JSON")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const config = opts.config ? JSON.parse(opts.config) : {};
+            const { data } = await client.POST("/v1/providers/test", {
+                body: {
+                    provider: opts.type.toUpperCase(),
+                    apiKey: opts.providerApiKey,
+                    providerId: opts.providerId,
+                    config,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
     cmd
         .command("models")
         .description("List available models across all providers")

package/dist/commands/schema-versions.js

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
-import { formatPage, formatDetail } from "../lib/output.js";
+import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
 import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
 export function makeSchemaVersionsCommand() {
     const cmd = new Command("versions").description("Manage schema versions");
@@ -32,6 +32,29 @@ export function makeSchemaVersionsCommand() {
             formatDetail(data, command);
         });
     });
+    cmd
+        .command("latest")
+        .description("Get the latest active version of a schema")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/schemas/{schemaId}/versions/latest", { params: { path: { schemaId: opts.schema } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete (deactivate) a schema version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/schemas/{schemaId}/versions/{versionId}", { params: { path: { schemaId: opts.schema, versionId } } });
+            formatSuccess(`Schema version ${versionId} deleted.`, command);
+        });
+    });
     cmd
         .command("create")
         .description("Create a new schema version")