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

package/README.md

@@ -1,6 +1,6 @@
 # 2kw.ai MCP Server
 
-An [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server for [2kw.ai](https://2kw.ai) — the EU-hosted AI integration platform. It gives AI coding assistants like Claude Code, Cursor, and Windsurf direct access to an [OpenAI-compatible LLM gateway](https://2kw.ai/gateway), [schema-driven document extraction](https://2kw.ai/extraction), audio transcription, and [cost observability](https://2kw.ai/observability) — 86 tools, straight from your editor.
+An [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server for [2kw.ai](https://2kw.ai) — the EU-hosted AI integration platform. It gives AI coding assistants like Claude Code, Cursor, and Windsurf direct access to an [OpenAI-compatible LLM gateway](https://2kw.ai/gateway), [schema-driven document extraction](https://2kw.ai/extraction), audio transcription, and [cost observability](https://2kw.ai/observability) — 88 tools, straight from your editor.
 
 Typical prompts once installed: *"extract the line items from this invoice PDF"*, *"create a schema for purchase orders and test it against these samples"*, *"transcribe this call recording"*, *"what did our extraction traffic cost this week?"*.
 
@@ -51,7 +51,7 @@ Get an API key from your [2kw.ai dashboard](https://2kw.ai) — paid plans start
 |----------|---------------------------|
 | **Document conversion** | Convert PDF, DOCX, XLSX, images, and 20+ formats to Markdown/text/HTML/JSON |
 | **Data extraction** | Run schema-driven extractions (sync/async), estimate tokens, re-run, inspect results |
-| **AI Gateway** | Chat completions through the OpenAI-compatible gateway, list available models |
+| **AI Gateway** | Chat completions and Responses (agent or direct model) through the OpenAI-compatible gateway, embeddings, list available models |
 | **Transcription** | Transcribe audio (FLAC, MP3, MP4, OGG, WAV, WebM) to text, JSON, SRT, VTT |
 | **Schemas** | CRUD, versioning, labels, validation, and testing against sample documents |
 | **Prompts** | Versioned prompt management, labels, compilation, testing |

package/dist/tools/ai-gateway.js

@@ -81,6 +81,110 @@ export function register(server, client) {
             };
         }
     });
+    // ── create_response ─────────────────────────────────────────────────────
+    server.tool("2kw_create_response", "Send a request through Backbone's OpenAI-compatible OpenResponses endpoint (POST /v1/responses). Model format: 'provider/model' for a direct gateway call via `model`, or use `agent` to invoke a stored agent by id or name (optionally 'ref@label', e.g. 'support-bot@latest'). Always non-streaming.", {
+        input: z.string().min(1).describe("The input text (sent as a single user message)"),
+        agent: z
+            .string()
+            .optional()
+            .describe("Stored agent id or name to invoke, optionally 'ref@label'. Mutually exclusive with `model`."),
+        model: z
+            .string()
+            .optional()
+            .describe("Model identifier in 'provider/model' format. Mutually exclusive with `agent`."),
+        conversation: z.string().optional().describe("Conversation ID this response belongs to"),
+    }, async ({ input, agent, model, conversation }) => {
+        try {
+            if (agent && model) {
+                throw new Error("Use either `agent` or `model`, not both.");
+            }
+            if (!agent && !model) {
+                throw new Error("Either `agent` or `model` is required.");
+            }
+            const resolvedModel = agent ? `agent/${agent}` : model;
+            const body = {
+                model: resolvedModel,
+                // The wire `input` field also accepts a bare string (shorthand for
+                // a single user message; see ResponseItemInputDeserializer), which
+                // the generated type does not model.
+                input,
+                stream: false,
+                ...(conversation !== undefined && { conversation }),
+            };
+            const { data } = await client.POST("/v1/responses", {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                body: body,
+            });
+            const result = data;
+            const parts = [];
+            const output = result.output;
+            for (const item of output ?? []) {
+                if (item.type !== "message")
+                    continue;
+                for (const part of item.content ?? []) {
+                    if (part.type === "output_text" && part.text) {
+                        parts.push({ type: "text", text: part.text });
+                    }
+                }
+            }
+            const status = result.status;
+            if (status && status !== "completed") {
+                parts.push({ type: "text", text: `\n[status: ${status}]` });
+            }
+            const usage = result.usage;
+            if (usage) {
+                parts.push({
+                    type: "text",
+                    text: `\n[Usage: ${usage.input_tokens} input + ${usage.output_tokens} output = ${usage.total_tokens} total tokens]`,
+                });
+            }
+            if (parts.length === 0) {
+                parts.push({ type: "text", text: JSON.stringify(result, null, 2) });
+            }
+            return { content: parts };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── create_embeddings ───────────────────────────────────────────────────
+    server.tool("2kw_create_embeddings", "Create embeddings for input text through Backbone's OpenAI-compatible embeddings endpoint (POST /v1/embeddings).", {
+        input: z.string().min(1).describe("The text to embed"),
+        model: z.string().describe("Model identifier in 'provider/model' format"),
+    }, async ({ input, model }) => {
+        try {
+            const { data } = await client.POST("/v1/embeddings", {
+                // POST /v1/embeddings has no request body in the generated spec
+                // (backend: "Not yet implemented"); cast, same as the untyped
+                // convert.ts source-conversion calls in the CLI.
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                body: { model, input },
+            });
+            const result = data;
+            const items = result.data ?? [];
+            const lines = items.map((item, i) => `[${item.index ?? i}] ${item.embedding?.length ?? 0} dimensions`);
+            if (result.usage) {
+                lines.push(`\n[Usage: ${result.usage.prompt_tokens} prompt / ${result.usage.total_tokens} total tokens]`);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Embeddings (model: ${result.model}):\n${lines.join("\n") || "(none)"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── list_models ─────────────────────────────────────────────────────────
     server.tool("2kw_list_models", "List available AI models and providers accessible through the Backbone AI gateway.", {}, async () => {
         try {

package/dist/tools/billing.js

@@ -43,6 +43,27 @@ export function register(server, client) {
             };
         }
     });
+    server.tool("2kw_billing_has_available", "Check whether the org has enough available capacity for a metered resource (extraction credits, conversion credits, gateway tokens) before consuming it.", {
+        type: z
+            .enum(["EXTRACTION_CREDITS", "CONVERSION_CREDITS", "GATEWAY_TOKENS"])
+            .describe("Resource type to check"),
+        required: z.number().optional().describe("Amount required (server defaults to 1)"),
+    }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/billing/has-available", {
+                params: { query: { type: params.type, required: params.required } },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     server.tool("2kw_billing_check", "Check whether the org can create another resource of the given type before attempting it. Returns a single boolean answer.", {
         resource: z
             .enum(["schema", "prompt", "team-member"])

package/dist/tools/conversion.js

@@ -234,6 +234,87 @@ export function register(server, client) {
             };
         }
     });
+    // ── convert_file ────────────────────────────────────────────────────────
+    server.tool("2kw_convert_file", "Convert one or more local files (PDF, DOCX, XLSX, images, etc.) synchronously via direct multipart upload. Simpler single-purpose alternative to 2kw_convert_document for local-file-only conversions.", {
+        paths: z.array(z.string()).min(1).describe("Local file paths to upload and convert"),
+        pipeline: z
+            .string()
+            .optional()
+            .describe("Processing pipeline: 'fast' (default), 'ocr', or 'vlm'"),
+        outputFormats: z
+            .array(z.string())
+            .optional()
+            .describe("Output formats, e.g. ['md', 'text', 'html', 'json']. Only relevant for ocr/vlm pipelines."),
+    }, async ({ paths, pipeline, outputFormats }) => {
+        try {
+            const formData = new FormData();
+            for (const p of paths) {
+                const buffer = await readFile(p);
+                const filename = basename(p);
+                formData.append("files", new Blob([buffer], { type: getMimeType(filename) }), filename);
+            }
+            if (outputFormats?.length) {
+                formData.append("options", new Blob([JSON.stringify({ outputFormats: outputFormats.map(mapOutputFormat) })], { type: "application/json" }));
+            }
+            const { data } = await client.POST("/v1/convert/file", {
+                params: { query: { pipeline } },
+                // Provide placeholder body for type checking; actual payload comes from bodySerializer
+                body: { files: paths },
+                bodySerializer: () => formData,
+            });
+            return { content: formatConvertResponse(data) };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    // ── convert_file_async ───────────────────────────────────────────────────
+    server.tool("2kw_convert_file_async", "Start an asynchronous conversion of one or more local files via direct multipart upload. Returns a task ID — poll with 2kw_get_task_status / 2kw_get_task_result.", {
+        paths: z.array(z.string()).min(1).describe("Local file paths to upload and convert"),
+        pipeline: z
+            .string()
+            .optional()
+            .describe("Processing pipeline: 'fast' (default), 'ocr', or 'vlm'"),
+        outputFormats: z
+            .array(z.string())
+            .optional()
+            .describe("Output formats, e.g. ['md', 'text', 'html', 'json']. Only relevant for ocr/vlm pipelines."),
+    }, async ({ paths, pipeline, outputFormats }) => {
+        try {
+            const formData = new FormData();
+            for (const p of paths) {
+                const buffer = await readFile(p);
+                const filename = basename(p);
+                formData.append("files", new Blob([buffer], { type: getMimeType(filename) }), filename);
+            }
+            if (outputFormats?.length) {
+                formData.append("options", new Blob([JSON.stringify({ outputFormats: outputFormats.map(mapOutputFormat) })], { type: "application/json" }));
+            }
+            const { data } = await client.POST("/v1/convert/file/async", {
+                params: { query: { pipeline } },
+                body: { files: paths },
+                bodySerializer: () => formData,
+            });
+            const taskId = data?.taskId;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Conversion submitted (task: ${taskId}). Poll with 2kw_get_task_status / 2kw_get_task_result.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── get_task_status ─────────────────────────────────────────────────────
     server.tool("2kw_get_task_status", "Check the status of an async conversion task. Supports long polling with the wait parameter.", {
         taskId: z.string().describe("The async task ID returned by convert_document"),

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/prompts.js

@@ -243,6 +243,43 @@ export function register(server, client) {
             };
         }
     });
+    server.tool("2kw_get_latest_prompt_version", "Get the latest version of a prompt.", { promptId: z.string() }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/prompts/{promptId}/versions/latest", { params: { path: { promptId: params.promptId } } });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_delete_prompt_version", "Delete (deactivate) a specific prompt version.", { promptId: z.string(), versionId: z.string() }, async (params) => {
+        try {
+            await client.DELETE("/v1/prompts/{promptId}/versions/{versionId}", {
+                params: {
+                    path: { promptId: params.promptId, versionId: params.versionId },
+                },
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Prompt version ${params.versionId} deleted.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     server.tool("2kw_create_prompt_version", "Create a new prompt version. The latest version is the implicit active one unless you activate a specific one.", {
         promptId: z.string(),
         content: z.string().describe("Prompt template content"),

package/dist/tools/providers.js

@@ -130,6 +130,49 @@ export function register(server, client) {
             };
         }
     });
+    server.tool("2kw_list_all_providers", "List every AI provider configured for the org, unpaginated. Useful when you need the full set at once (e.g. to check for a duplicate type before creating a new one).", {}, async () => {
+        try {
+            const { data } = await client.GET("/v1/providers/all");
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_test_provider", "Test connectivity/credentials for an AI provider before (or without) saving it. Pass a fresh apiKey to test ad-hoc credentials, or providerId to re-test an existing provider's stored key.", {
+        provider: ProviderType.describe("Provider vendor type"),
+        apiKey: z.string().optional().describe("Credential to test (omit to use providerId's stored key)"),
+        providerId: z.string().optional().describe("Existing provider ID whose stored credentials should be used"),
+        config: z
+            .record(z.string(), z.unknown())
+            .optional()
+            .describe("Provider-specific config (e.g. endpoint, region)"),
+    }, async (params) => {
+        try {
+            const { data } = await client.POST("/v1/providers/test", {
+                body: {
+                    provider: params.provider,
+                    apiKey: params.apiKey,
+                    providerId: params.providerId,
+                    config: params.config ?? {},
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     server.tool("2kw_list_provider_models", "List every model exposed by every configured provider. Useful to discover which provider/model ids are valid for extractions, chat, and experiments.", {}, async () => {
         try {
             const { data } = await client.GET("/v1/providers/models");

package/dist/tools/schema-versions.js

@@ -103,6 +103,31 @@ export function register(server, client) {
             };
         }
     });
+    // ── delete_schema_version ───────────────────────────────────────────────
+    server.tool("2kw_delete_schema_version", "Delete (deactivate) a schema version. Requires admin role.", {
+        schemaId: z.string().describe("The schema ID"),
+        versionId: z.string().describe("The version ID to delete"),
+    }, async ({ schemaId, versionId }) => {
+        try {
+            await client.DELETE("/v1/schemas/{schemaId}/versions/{versionId}", {
+                params: { path: { schemaId, versionId } },
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Schema version ${versionId} deleted.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── activate_schema_version ─────────────────────────────────────────────
     server.tool("2kw_activate_schema_version", "Re-activate a historical schema version by creating a copy as the newest active version.", {
         schemaId: z.string().describe("The schema ID"),

package/dist/tools/schemas.js

@@ -111,6 +111,32 @@ export function register(server, client) {
             };
         }
     });
+    // ── resolve_schema ──────────────────────────────────────────────────────
+    server.tool("2kw_resolve_schema", "Resolve a schema's active or labeled content — returns the version that would be used at runtime.", {
+        schemaId: z.string().describe("The schema ID"),
+        label: z
+            .string()
+            .optional()
+            .describe("Label (e.g. 'production') — otherwise returns the active version"),
+    }, async ({ schemaId, label }) => {
+        try {
+            const { data } = await client.GET("/v1/schemas/{schemaId}/resolve", {
+                params: {
+                    path: { schemaId },
+                    query: { label },
+                },
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
     // ── delete_schema ───────────────────────────────────────────────────────
     server.tool("2kw_delete_schema", "Delete a schema and all its versions. This action is irreversible.", {
         schemaId: z.string().describe("The schema ID to delete"),

package/dist/tools/tracing.js

@@ -120,5 +120,68 @@ export function register(server, client) {
             };
         }
     });
+    // ── sessions ────────────────────────────────────────────────────────────
+    server.tool("2kw_list_trace_sessions", "List sessions (spans grouped by an exporter-stamped session id) in the org, with turn/error counts, duration, tokens and cost. Optional free-text search across session id and name, and a start-time range.", {
+        search: z.string().optional().describe("Free-text search across session id and name"),
+        from: z.string().optional().describe("Start of time range (ISO-8601)"),
+        to: z.string().optional().describe("End of time range (ISO-8601)"),
+        page: z.number().int().min(0).optional().describe("Page index (0-based)"),
+        size: z.number().int().min(1).max(100).optional().describe("Page size"),
+    }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/traces/sessions", {
+                params: {
+                    query: {
+                        search: params.search,
+                        from: params.from,
+                        to: params.to,
+                        page: params.page ?? 0,
+                        size: params.size ?? 20,
+                    },
+                },
+            });
+            const result = data;
+            const lines = (result.content ?? []).map((s) => {
+                const services = Array.isArray(s.sourceServices)
+                    ? s.sourceServices.join(", ")
+                    : "";
+                return `- ${s.sessionId} ${s.name ?? "(unnamed)"} · ${s.durationMs}ms · ${s.turnCount} turns · ${s.errorCount} errors · ${services}`;
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Sessions (${result.totalElements ?? 0} total, page ${(result.number ?? 0) + 1}/${result.totalPages ?? 1}):\n${lines.join("\n") || "(none)"}`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("2kw_get_trace_session", "Get every span recorded under a session, flat and sorted by start time — reconstruct the conversation chronologically. The id is the external session id stamped by the exporter.", {
+        sessionId: z.string().describe("Session id"),
+    }, async (params) => {
+        try {
+            const { data } = await client.GET("/v1/traces/sessions/{sessionId}", {
+                params: { path: { sessionId: params.sessionId } },
+            });
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(data, null, 2) },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: formatErrorForMcp(error) }],
+                isError: true,
+            };
+        }
+    });
 }
 //# sourceMappingURL=tracing.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@2kw/ai-mcp-server",
-  "version": "6.0.0-dev.4",
-  "description": "MCP server for 2kw.ai — EU-hosted AI platform: OpenAI-compatible LLM gateway, schema-driven document extraction, transcription, and cost observability. 86 tools for Claude Code, Cursor, and Windsurf.",
+  "version": "6.1.0-dev.7",
+  "description": "MCP server for 2kw.ai — EU-hosted AI platform: OpenAI-compatible LLM gateway, schema-driven document extraction, transcription, and cost observability. 88 tools for Claude Code, Cursor, and Windsurf.",
   "mcpName": "ai.2kw/mcp-server",
   "keywords": [
     "mcp",
@@ -40,6 +40,7 @@
     "check:spec": "tsx --env-file=.env openapi/scripts/check-drift.ts",
     "check:generated": "tsx openapi/scripts/check-generated.ts",
     "fix:generated": "tsx openapi/scripts/check-generated.ts --write",
+    "check:coverage": "tsx ../cli/openapi/scripts/check-coverage.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {