@2kw/ai-mcp-server 6.0.0 → 6.1.0-dev.10

package/dist/tools/datasets.js

@@ -103,6 +103,118 @@ export function register(server, client) {
             };
         }
     });
+    // ── update_dataset ─────────────────────────────────────────────
+    server.tool("2kw_update_dataset", "Update an existing dataset's details.", {
+        datasetId: z.string().describe("The dataset ID"),
+        name: z.string().optional().describe("New name"),
+        description: z.string().optional().describe("New description"),
+        type: z.string().optional().describe("New type"),
+        inputSchema: z.unknown().optional().describe("New input JSON Schema definition"),
+        expectedOutputSchema: z.unknown().optional().describe("New expected output JSON Schema definition"),
+        metadata: z.unknown().optional().describe("Arbitrary metadata (JSON object)"),
+    }, async ({ datasetId, name, description, type, inputSchema, expectedOutputSchema, metadata }) => {
+        try {
+            const body = {};
+            if (name !== undefined)
+                body.name = name;
+            if (description !== undefined)
+                body.description = description;
+            if (type !== undefined)
+                body.type = type;
+            if (inputSchema !== undefined)
+                body.inputSchema = inputSchema;
+            if (expectedOutputSchema !== undefined)
+                body.expectedOutputSchema = expectedOutputSchema;
+            if (metadata !== undefined)
+                body.metadata = metadata;
+            const { data } = await client.PUT("/v1/datasets/{id}", {
+                params: { path: { id: datasetId } },
+                body: body,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── delete_dataset ─────────────────────────────────────────────
+    server.tool("2kw_delete_dataset", "Delete a dataset and all its versions and items. Requires admin role.", {
+        datasetId: z.string().describe("The dataset ID"),
+    }, async ({ datasetId }) => {
+        try {
+            await client.DELETE("/v1/datasets/{id}", {
+                params: { path: { id: datasetId } },
+            });
+            return {
+                content: [{ type: "text", text: `Dataset ${datasetId} deleted.` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_dataset_versions ────────────────────────────────────────
+    server.tool("2kw_get_dataset_versions", "List all versions of a dataset with pagination.", {
+        datasetId: z.string().describe("The dataset ID"),
+        page: z.number().optional().default(0).describe("Page number (0-based)"),
+        size: z.number().optional().default(20).describe("Page size"),
+    }, async ({ datasetId, page, size }) => {
+        try {
+            const { data } = await client.GET("/v1/datasets/{id}/versions", {
+                params: {
+                    path: { id: datasetId },
+                    query: { pageable: { page, size } },
+                },
+            });
+            const result = data;
+            const lines = (result.content ?? []).map((v) => `- Version ${v.versionNumber} (id: ${v.id}, items: ${v.itemCount ?? 0})${v.changeDescription ? ` — ${v.changeDescription}` : ""}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Versions (${result.totalElements} total, page ${(result.number ?? 0) + 1}/${result.totalPages}):\n${lines.join("\n") || "(none)"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_dataset_version ─────────────────────────────────────────
+    server.tool("2kw_get_dataset_version", "Get a specific dataset version by ID.", {
+        datasetId: z.string().describe("The dataset ID"),
+        versionId: z.string().describe("The dataset version ID"),
+    }, async ({ datasetId, versionId }) => {
+        try {
+            const { data } = await client.GET("/v1/datasets/{id}/versions/{versionId}", {
+                params: {
+                    // OpenAPI spec omits `id` in declared path params though `{id}` is in the URL template.
+                    path: { id: datasetId, versionId },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── create_dataset_version ─────────────────────────────────────
     server.tool("2kw_create_dataset_version", "Create a new version of a dataset.", {
         datasetId: z.string().describe("The dataset ID"),
@@ -160,6 +272,40 @@ export function register(server, client) {
             };
         }
     });
+    // ── add_dataset_items ──────────────────────────────────────────
+    server.tool("2kw_add_dataset_items", "Add multiple items to a dataset in a single request. Uses the latest version unless versionId is specified.", {
+        datasetId: z.string().describe("The dataset ID"),
+        versionId: z.string().optional().describe("The dataset version ID (defaults to latest)"),
+        items: z
+            .array(z.object({
+            input: z.unknown().describe("Item input data (JSON object)"),
+            expectedOutput: z.unknown().optional().describe("Expected output (JSON object)"),
+            tags: z.array(z.string()).optional().describe("Tags for the item"),
+            metadata: z.unknown().optional().describe("Arbitrary metadata (JSON object)"),
+        }))
+            .min(1)
+            .describe("Items to add"),
+    }, async ({ datasetId, versionId, items }) => {
+        try {
+            const resolvedVersionId = versionId ?? (await resolveLatestVersionId(client, datasetId));
+            const { data } = await client.POST("/v1/datasets/{id}/versions/{versionId}/items/bulk", {
+                params: {
+                    // OpenAPI spec omits `id` in declared path params though `{id}` is in the URL template.
+                    path: { id: datasetId, versionId: resolvedVersionId },
+                },
+                body: items,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── get_dataset_items ──────────────────────────────────────────
     server.tool("2kw_get_dataset_items", "List items in a dataset with pagination. Uses the latest version unless versionId is specified.", {
         datasetId: z.string().describe("The dataset ID"),
@@ -196,5 +342,63 @@ export function register(server, client) {
             };
         }
     });
+    // ── delete_dataset_item ─────────────────────────────────────────
+    server.tool("2kw_delete_dataset_item", "Soft-delete a dataset item by marking it as deleted. The item is retained for historical " +
+        "traceability (e.g. past run results) but excluded from default listings. Uses the latest " +
+        "version unless versionId is specified.", {
+        datasetId: z.string().describe("The dataset ID"),
+        itemId: z.string().describe("The dataset item ID"),
+        versionId: z.string().optional().describe("The dataset version ID (defaults to latest)"),
+    }, async ({ datasetId, itemId, versionId }) => {
+        try {
+            const resolvedVersionId = versionId ?? (await resolveLatestVersionId(client, datasetId));
+            await client.DELETE("/v1/datasets/{id}/versions/{versionId}/items/{itemId}", {
+                params: {
+                    // OpenAPI spec omits `id` in declared path params though `{id}` is in the URL template.
+                    path: { id: datasetId, versionId: resolvedVersionId, itemId },
+                },
+            });
+            return {
+                content: [{ type: "text", text: `Item ${itemId} deleted.` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── update_dataset_item_expected_output ──────────────────────────
+    server.tool("2kw_update_dataset_item_expected_output", "Update only the expectedOutput of a dataset item. Other fields (input, tags, metadata) are " +
+        "immutable after creation. Uses the latest version unless versionId is specified.", {
+        datasetId: z.string().describe("The dataset ID"),
+        itemId: z.string().describe("The dataset item ID"),
+        versionId: z.string().optional().describe("The dataset version ID (defaults to latest)"),
+        expectedOutput: z.unknown().optional().describe("New expected output (JSON object); omit to clear it"),
+    }, async ({ datasetId, itemId, versionId, expectedOutput }) => {
+        try {
+            const resolvedVersionId = versionId ?? (await resolveLatestVersionId(client, datasetId));
+            const body = {};
+            if (expectedOutput !== undefined)
+                body.expectedOutput = expectedOutput;
+            const { data } = await client.PATCH("/v1/datasets/{id}/versions/{versionId}/items/{itemId}/expected-output", {
+                params: {
+                    // OpenAPI spec omits `id` in declared path params though `{id}` is in the URL template.
+                    path: { id: datasetId, versionId: resolvedVersionId, itemId },
+                },
+                body: body,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
 }
 //# sourceMappingURL=datasets.js.map

package/dist/tools/experiments.js

@@ -98,6 +98,61 @@ export function register(server, client) {
             };
         }
     });
+    // ── update_experiment ───────────────────────────────────────────
+    server.tool("2kw_update_experiment", "Update an existing experiment's details.", {
+        experimentId: z.string().describe("The experiment ID"),
+        name: z.string().optional().describe("New name"),
+        description: z.string().optional().describe("New description"),
+        type: z.string().optional().describe("New type"),
+        datasetVersionId: z.string().optional().describe("Dataset version ID to evaluate against"),
+        metadata: z.unknown().optional().describe("Arbitrary metadata (JSON object)"),
+    }, async ({ experimentId, name, description, type, datasetVersionId, metadata }) => {
+        try {
+            const body = {};
+            if (name !== undefined)
+                body.name = name;
+            if (description !== undefined)
+                body.description = description;
+            if (type !== undefined)
+                body.type = type;
+            if (datasetVersionId !== undefined)
+                body.datasetVersionId = datasetVersionId;
+            if (metadata !== undefined)
+                body.metadata = metadata;
+            const { data } = await client.PUT("/v1/experiments/{id}", {
+                params: { path: { id: experimentId } },
+                body: body,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── delete_experiment ───────────────────────────────────────────
+    server.tool("2kw_delete_experiment", "Delete an experiment and all associated data. Requires admin role.", {
+        experimentId: z.string().describe("The experiment ID"),
+    }, async ({ experimentId }) => {
+        try {
+            await client.DELETE("/v1/experiments/{id}", {
+                params: { path: { id: experimentId } },
+            });
+            return {
+                content: [{ type: "text", text: `Experiment ${experimentId} deleted.` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── add_variant ─────────────────────────────────────────────────
     server.tool("2kw_add_variant", "Add a variant to an experiment with a task type and configuration.", {
         experimentId: z.string().describe("The experiment ID"),
@@ -128,6 +183,89 @@ export function register(server, client) {
             };
         }
     });
+    // ── get_variants ────────────────────────────────────────────────
+    server.tool("2kw_get_variants", "List all variants for an experiment.", {
+        experimentId: z.string().describe("The experiment ID"),
+    }, async ({ experimentId }) => {
+        try {
+            const { data } = await client.GET("/v1/experiments/{id}/variants", {
+                params: { path: { id: experimentId } },
+            });
+            const variants = data ?? [];
+            const lines = variants.map((v) => `- ${v.name} (id: ${v.id}, taskType: ${v.taskType})${v.description ? ` — ${v.description}` : ""}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Variants (${variants.length} total):\n${lines.join("\n") || "(none)"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── update_variant ──────────────────────────────────────────────
+    server.tool("2kw_update_variant", "Update an existing variant's details.", {
+        experimentId: z.string().describe("The experiment ID"),
+        variantId: z.string().describe("The variant ID"),
+        name: z.string().optional().describe("New variant name"),
+        taskType: z.string().optional().describe("New task type"),
+        configuration: z.unknown().optional().describe("New variant configuration (JSON object)"),
+        description: z.string().optional().describe("New variant description"),
+        sortOrder: z.number().optional().describe("New sort order for display"),
+    }, async ({ experimentId, variantId, name, taskType, configuration, description, sortOrder }) => {
+        try {
+            const body = {};
+            if (name !== undefined)
+                body.name = name;
+            if (taskType !== undefined)
+                body.taskType = taskType;
+            if (configuration !== undefined)
+                body.configuration = configuration;
+            if (description !== undefined)
+                body.description = description;
+            if (sortOrder !== undefined)
+                body.sortOrder = sortOrder;
+            const { data } = await client.PUT("/v1/experiments/{id}/variants/{variantId}", {
+                params: { path: { id: experimentId, variantId } },
+                body: body,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── delete_variant ──────────────────────────────────────────────
+    server.tool("2kw_delete_variant", "Delete a variant from an experiment. Requires admin role.", {
+        experimentId: z.string().describe("The experiment ID"),
+        variantId: z.string().describe("The variant ID"),
+    }, async ({ experimentId, variantId }) => {
+        try {
+            await client.DELETE("/v1/experiments/{id}/variants/{variantId}", {
+                params: { path: { id: experimentId, variantId } },
+            });
+            return {
+                content: [{ type: "text", text: `Variant ${variantId} deleted.` }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── run_experiment ──────────────────────────────────────────────
     server.tool("2kw_run_experiment", "Start an experiment run. Returns immediately with the run ID — use 2kw_get_experiment_runs to poll for completion.", {
         experimentId: z.string().describe("The experiment ID"),
@@ -189,6 +327,66 @@ export function register(server, client) {
             };
         }
     });
+    // ── get_run ─────────────────────────────────────────────────────
+    server.tool("2kw_get_run", "Get a single experiment run by ID, including status, progress, and baseline flag.", {
+        experimentId: z.string().describe("The experiment ID"),
+        runId: z.string().describe("The run ID"),
+    }, async ({ experimentId, runId }) => {
+        try {
+            const { data } = await client.GET("/v1/experiments/{id}/runs/{runId}", {
+                params: { path: { id: experimentId, runId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── set_baseline ────────────────────────────────────────────────
+    server.tool("2kw_set_baseline", "Mark a run as the baseline for its variant. Any prior baseline on the same variant is cleared.", {
+        experimentId: z.string().describe("The experiment ID"),
+        runId: z.string().describe("The run ID"),
+    }, async ({ experimentId, runId }) => {
+        try {
+            const { data } = await client.PUT("/v1/experiments/{id}/runs/{runId}/baseline", {
+                params: { path: { id: experimentId, runId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── clear_baseline ──────────────────────────────────────────────
+    server.tool("2kw_clear_baseline", "Unmark a run as the baseline for its variant.", {
+        experimentId: z.string().describe("The experiment ID"),
+        runId: z.string().describe("The run ID"),
+    }, async ({ experimentId, runId }) => {
+        try {
+            const { data } = await client.DELETE("/v1/experiments/{id}/runs/{runId}/baseline", {
+                params: { path: { id: experimentId, runId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── get_run_results ─────────────────────────────────────────────
     server.tool("2kw_get_run_results", "Get detailed results for an experiment run, including output, token usage, cost, and errors per dataset item.", {
         experimentId: z.string().describe("The experiment ID"),
@@ -227,5 +425,54 @@ export function register(server, client) {
             };
         }
     });
+    // ── get_run_regression ───────────────────────────────────────────
+    server.tool("2kw_get_run_regression", "Compare an experiment run against a baseline run on the same variant, reporting regressed, improved, and ground-truth-changed items. If baselineRunId is omitted, the baseline is resolved as (1) the run flagged baseline on the same variant, or (2) the most recent prior COMPLETED run on the same variant.", {
+        experimentId: z.string().describe("The experiment ID"),
+        runId: z.string().describe("The run ID"),
+        baselineRunId: z.string().optional().describe("Explicit baseline run ID to compare against"),
+        threshold: z.number().optional().describe("Score delta threshold for classifying a regression"),
+    }, async ({ experimentId, runId, baselineRunId, threshold }) => {
+        try {
+            const { data } = await client.GET("/v1/experiments/{id}/runs/{runId}/regression", {
+                params: {
+                    path: { id: experimentId, runId },
+                    query: { baselineRunId, threshold },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_experiment_comparison ────────────────────────────────────
+    server.tool("2kw_get_experiment_comparison", "Get the paged comparison matrix for an experiment: dataset items joined with the latest completed run per variant, plus per-variant aggregates over all results.", {
+        experimentId: z.string().describe("The experiment ID"),
+        page: z.number().optional().default(0).describe("Page number (0-based)"),
+        size: z.number().optional().default(20).describe("Page size"),
+    }, async ({ experimentId, page, size }) => {
+        try {
+            const { data } = await client.GET("/v1/experiments/{id}/comparison", {
+                params: {
+                    path: { id: experimentId },
+                    query: { pageable: { page, size } },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
 }
 //# sourceMappingURL=experiments.js.map

package/dist/tools/extraction.js

@@ -166,6 +166,27 @@ export function register(server, client) {
             };
         }
     });
+    // ── delete_extraction ────────────────────────────────────────────────────
+    server.tool("2kw_delete_extraction", "Delete an extraction and all associated results. Requires admin role. Usage records are preserved.", {
+        extractionId: z.string().describe("The extraction ID"),
+    }, async ({ extractionId }) => {
+        try {
+            await client.DELETE("/v1/extractions/{id}", {
+                params: { path: { id: extractionId } },
+            });
+            return {
+                content: [
+                    { type: "text", text: `Extraction ${extractionId} deleted.` },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── estimate_tokens ─────────────────────────────────────────────────────
     server.tool("2kw_estimate_tokens", "Estimate token usage for an extraction without executing it. Useful for cost estimation.", {
         schemaId: z.string().describe("The schema ID"),

package/dist/tools/files.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ApiClient } from "../client.js";
+export declare function register(server: McpServer, client: ApiClient): void;
+//# sourceMappingURL=files.d.ts.map

package/dist/tools/files.js

@@ -0,0 +1,143 @@
+import { z } from "zod";
+import { readFile, writeFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { BackboneApiError, formatErrorForMcp } from "../errors.js";
+import { getMimeType } from "../mime.js";
+const FilePurpose = z.enum(["agent_input", "knowledge"]);
+export function register(server, client) {
+    // ── list_files ────────────────────────────────────────────────────────────
+    server.tool("2kw_list_files", "List the organization's files as a page, newest first by default, optionally narrowed by purpose.", {
+        purpose: FilePurpose.optional().describe("Narrow the list to one purpose"),
+        page: z.number().optional().default(0).describe("Page number (0-based)"),
+        size: z.number().optional().default(20).describe("Page size"),
+    }, async ({ purpose, page, size }) => {
+        try {
+            const { data } = await client.GET("/v1/files", {
+                params: { query: { purpose, pageable: { page, size } } },
+            });
+            const result = data;
+            const lines = (result.content ?? []).map((f) => `- ${f.filename} (id: ${f.id}, purpose: ${f.purpose}, bytes: ${f.bytes})`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Files (${result.totalElements} total, page ${(result.number ?? 0) + 1}/${result.totalPages}):\n${lines.join("\n") || "(none)"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── upload_file ───────────────────────────────────────────────────────────
+    server.tool("2kw_upload_file", "Upload a local file and get back its file id. purpose=agent_input files expire after the configured TTL unless referenced by a turn; purpose=knowledge is for organization members only and can be ingested into a knowledge base with 2kw_attach_knowledge_document_file. Size and per-end-user quotas apply.", {
+        filePath: z.string().describe("Local path to the file to upload"),
+        purpose: FilePurpose.describe("Why the file exists — determines its lifecycle"),
+    }, async ({ filePath, purpose }) => {
+        try {
+            const fileBuffer = await readFile(filePath);
+            const filename = basename(filePath);
+            const mimeType = getMimeType(filename);
+            const formData = new FormData();
+            formData.append("file", new Blob([fileBuffer], { type: mimeType }), filename);
+            const { data } = await client.POST("/v1/files", {
+                params: { query: { purpose } },
+                // Provide placeholder body for type checking; actual payload comes from bodySerializer
+                body: { file: "" },
+                bodySerializer: () => formData,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── get_file ──────────────────────────────────────────────────────────────
+    server.tool("2kw_get_file", "Fetch a file's metadata by id.", { fileId: z.string().describe("The file ID") }, async ({ fileId }) => {
+        try {
+            const { data } = await client.GET("/v1/files/{fileId}", {
+                params: { path: { fileId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── delete_file ───────────────────────────────────────────────────────────
+    server.tool("2kw_delete_file", "Soft-delete an agent_input file. Knowledge files are not deletable through this API; their lifecycle belongs to the knowledge base's document.", { fileId: z.string().describe("The file ID to delete") }, async ({ fileId }) => {
+        try {
+            const { data } = await client.DELETE("/v1/files/{fileId}", {
+                params: { path: { fileId } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── download_file ─────────────────────────────────────────────────────────
+    server.tool("2kw_download_file", "Download a file's bytes and save them to a local path.", {
+        fileId: z.string().describe("The file ID"),
+        savePath: z.string().describe("Local path to write the downloaded bytes to"),
+    }, async ({ fileId, savePath }) => {
+        try {
+            const { baseUrl, apiKey } = client._config;
+            const res = await fetch(`${baseUrl}/v1/files/${encodeURIComponent(fileId)}/content`, {
+                headers: { Authorization: `Bearer ${apiKey}` },
+            });
+            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);
+            }
+            const buffer = Buffer.from(await res.arrayBuffer());
+            await writeFile(savePath, buffer);
+            const contentType = res.headers.get("content-type") ?? "application/octet-stream";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Downloaded ${buffer.length} bytes (${contentType}) to ${savePath}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=files.js.map